2009-04-15 18:57:54 +04:00
|
|
|
/*
|
|
|
|
* QEMU NS SONIC DP8393x netcard
|
|
|
|
*
|
|
|
|
* Copyright (c) 2008-2009 Herve Poussineau
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation; either version 2 of
|
|
|
|
* the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
2009-07-17 00:47:01 +04:00
|
|
|
* with this program; if not, see <http://www.gnu.org/licenses/>.
|
2009-04-15 18:57:54 +04:00
|
|
|
*/
|
|
|
|
|
2016-01-26 21:17:11 +03:00
|
|
|
#include "qemu/osdep.h"
|
2019-08-12 08:23:42 +03:00
|
|
|
#include "hw/irq.h"
|
2019-08-12 08:23:51 +03:00
|
|
|
#include "hw/qdev-properties.h"
|
2015-06-03 23:45:45 +03:00
|
|
|
#include "hw/sysbus.h"
|
2019-08-12 08:23:45 +03:00
|
|
|
#include "migration/vmstate.h"
|
2012-10-24 10:43:34 +04:00
|
|
|
#include "net/net.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 11:01:28 +03:00
|
|
|
#include "qapi/error.h"
|
2019-05-23 17:35:07 +03:00
|
|
|
#include "qemu/module.h"
|
2015-06-03 23:45:45 +03:00
|
|
|
#include "qemu/timer.h"
|
2015-06-03 23:45:42 +03:00
|
|
|
#include <zlib.h>
|
2009-04-15 18:57:54 +04:00
|
|
|
|
|
|
|
//#define DEBUG_SONIC
|
|
|
|
|
2015-06-03 23:45:46 +03:00
|
|
|
#define SONIC_PROM_SIZE 0x1000
|
2009-04-15 18:57:54 +04:00
|
|
|
|
|
|
|
#ifdef DEBUG_SONIC
|
2009-05-13 21:53:17 +04:00
|
|
|
#define DPRINTF(fmt, ...) \
|
|
|
|
do { printf("sonic: " fmt , ## __VA_ARGS__); } while (0)
|
2009-04-15 18:57:54 +04:00
|
|
|
static const char* reg_names[] = {
|
|
|
|
"CR", "DCR", "RCR", "TCR", "IMR", "ISR", "UTDA", "CTDA",
|
|
|
|
"TPS", "TFC", "TSA0", "TSA1", "TFS", "URDA", "CRDA", "CRBA0",
|
|
|
|
"CRBA1", "RBWC0", "RBWC1", "EOBC", "URRA", "RSA", "REA", "RRP",
|
|
|
|
"RWP", "TRBA0", "TRBA1", "0x1b", "0x1c", "0x1d", "0x1e", "LLFA",
|
|
|
|
"TTDA", "CEP", "CAP2", "CAP1", "CAP0", "CE", "CDP", "CDC",
|
|
|
|
"SR", "WT0", "WT1", "RSC", "CRCT", "FAET", "MPT", "MDT",
|
|
|
|
"0x30", "0x31", "0x32", "0x33", "0x34", "0x35", "0x36", "0x37",
|
|
|
|
"0x38", "0x39", "0x3a", "0x3b", "0x3c", "0x3d", "0x3e", "DCR2" };
|
|
|
|
#else
|
2009-05-13 21:53:17 +04:00
|
|
|
#define DPRINTF(fmt, ...) do {} while (0)
|
2009-04-15 18:57:54 +04:00
|
|
|
#endif
|
|
|
|
|
2009-05-13 21:53:17 +04:00
|
|
|
#define SONIC_ERROR(fmt, ...) \
|
|
|
|
do { printf("sonic ERROR: %s: " fmt, __func__ , ## __VA_ARGS__); } while (0)
|
2009-04-15 18:57:54 +04:00
|
|
|
|
|
|
|
#define SONIC_CR 0x00
|
|
|
|
#define SONIC_DCR 0x01
|
|
|
|
#define SONIC_RCR 0x02
|
|
|
|
#define SONIC_TCR 0x03
|
|
|
|
#define SONIC_IMR 0x04
|
|
|
|
#define SONIC_ISR 0x05
|
|
|
|
#define SONIC_UTDA 0x06
|
|
|
|
#define SONIC_CTDA 0x07
|
|
|
|
#define SONIC_TPS 0x08
|
|
|
|
#define SONIC_TFC 0x09
|
|
|
|
#define SONIC_TSA0 0x0a
|
|
|
|
#define SONIC_TSA1 0x0b
|
|
|
|
#define SONIC_TFS 0x0c
|
|
|
|
#define SONIC_URDA 0x0d
|
|
|
|
#define SONIC_CRDA 0x0e
|
|
|
|
#define SONIC_CRBA0 0x0f
|
|
|
|
#define SONIC_CRBA1 0x10
|
|
|
|
#define SONIC_RBWC0 0x11
|
|
|
|
#define SONIC_RBWC1 0x12
|
|
|
|
#define SONIC_EOBC 0x13
|
|
|
|
#define SONIC_URRA 0x14
|
|
|
|
#define SONIC_RSA 0x15
|
|
|
|
#define SONIC_REA 0x16
|
|
|
|
#define SONIC_RRP 0x17
|
|
|
|
#define SONIC_RWP 0x18
|
|
|
|
#define SONIC_TRBA0 0x19
|
|
|
|
#define SONIC_TRBA1 0x1a
|
|
|
|
#define SONIC_LLFA 0x1f
|
|
|
|
#define SONIC_TTDA 0x20
|
|
|
|
#define SONIC_CEP 0x21
|
|
|
|
#define SONIC_CAP2 0x22
|
|
|
|
#define SONIC_CAP1 0x23
|
|
|
|
#define SONIC_CAP0 0x24
|
|
|
|
#define SONIC_CE 0x25
|
|
|
|
#define SONIC_CDP 0x26
|
|
|
|
#define SONIC_CDC 0x27
|
|
|
|
#define SONIC_SR 0x28
|
|
|
|
#define SONIC_WT0 0x29
|
|
|
|
#define SONIC_WT1 0x2a
|
|
|
|
#define SONIC_RSC 0x2b
|
|
|
|
#define SONIC_CRCT 0x2c
|
|
|
|
#define SONIC_FAET 0x2d
|
|
|
|
#define SONIC_MPT 0x2e
|
|
|
|
#define SONIC_MDT 0x2f
|
|
|
|
#define SONIC_DCR2 0x3f
|
|
|
|
|
|
|
|
#define SONIC_CR_HTX 0x0001
|
|
|
|
#define SONIC_CR_TXP 0x0002
|
|
|
|
#define SONIC_CR_RXDIS 0x0004
|
|
|
|
#define SONIC_CR_RXEN 0x0008
|
|
|
|
#define SONIC_CR_STP 0x0010
|
|
|
|
#define SONIC_CR_ST 0x0020
|
|
|
|
#define SONIC_CR_RST 0x0080
|
|
|
|
#define SONIC_CR_RRRA 0x0100
|
|
|
|
#define SONIC_CR_LCAM 0x0200
|
|
|
|
#define SONIC_CR_MASK 0x03bf
|
|
|
|
|
|
|
|
#define SONIC_DCR_DW 0x0020
|
|
|
|
#define SONIC_DCR_LBR 0x2000
|
|
|
|
#define SONIC_DCR_EXBUS 0x8000
|
|
|
|
|
|
|
|
#define SONIC_RCR_PRX 0x0001
|
|
|
|
#define SONIC_RCR_LBK 0x0002
|
|
|
|
#define SONIC_RCR_FAER 0x0004
|
|
|
|
#define SONIC_RCR_CRCR 0x0008
|
|
|
|
#define SONIC_RCR_CRS 0x0020
|
|
|
|
#define SONIC_RCR_LPKT 0x0040
|
|
|
|
#define SONIC_RCR_BC 0x0080
|
|
|
|
#define SONIC_RCR_MC 0x0100
|
|
|
|
#define SONIC_RCR_LB0 0x0200
|
|
|
|
#define SONIC_RCR_LB1 0x0400
|
|
|
|
#define SONIC_RCR_AMC 0x0800
|
|
|
|
#define SONIC_RCR_PRO 0x1000
|
|
|
|
#define SONIC_RCR_BRD 0x2000
|
|
|
|
#define SONIC_RCR_RNT 0x4000
|
|
|
|
|
|
|
|
#define SONIC_TCR_PTX 0x0001
|
|
|
|
#define SONIC_TCR_BCM 0x0002
|
|
|
|
#define SONIC_TCR_FU 0x0004
|
|
|
|
#define SONIC_TCR_EXC 0x0040
|
|
|
|
#define SONIC_TCR_CRSL 0x0080
|
|
|
|
#define SONIC_TCR_NCRS 0x0100
|
|
|
|
#define SONIC_TCR_EXD 0x0400
|
|
|
|
#define SONIC_TCR_CRCI 0x2000
|
|
|
|
#define SONIC_TCR_PINT 0x8000
|
|
|
|
|
|
|
|
#define SONIC_ISR_RBE 0x0020
|
|
|
|
#define SONIC_ISR_RDE 0x0040
|
|
|
|
#define SONIC_ISR_TC 0x0080
|
|
|
|
#define SONIC_ISR_TXDN 0x0200
|
|
|
|
#define SONIC_ISR_PKTRX 0x0400
|
|
|
|
#define SONIC_ISR_PINT 0x0800
|
|
|
|
#define SONIC_ISR_LCD 0x1000
|
|
|
|
|
2015-06-03 23:45:45 +03:00
|
|
|
#define TYPE_DP8393X "dp8393x"
|
|
|
|
#define DP8393X(obj) OBJECT_CHECK(dp8393xState, (obj), TYPE_DP8393X)
|
|
|
|
|
2009-04-15 18:57:54 +04:00
|
|
|
typedef struct dp8393xState {
|
2015-06-03 23:45:45 +03:00
|
|
|
SysBusDevice parent_obj;
|
|
|
|
|
2009-04-15 18:57:54 +04:00
|
|
|
/* Hardware */
|
2015-06-03 23:45:45 +03:00
|
|
|
uint8_t it_shift;
|
2009-04-15 18:57:54 +04:00
|
|
|
qemu_irq irq;
|
|
|
|
#ifdef DEBUG_SONIC
|
|
|
|
int irq_level;
|
|
|
|
#endif
|
|
|
|
QEMUTimer *watchdog;
|
|
|
|
int64_t wt_last_update;
|
2009-11-25 21:49:17 +03:00
|
|
|
NICConf conf;
|
|
|
|
NICState *nic;
|
2011-11-09 20:22:37 +04:00
|
|
|
MemoryRegion mmio;
|
2015-06-03 23:45:46 +03:00
|
|
|
MemoryRegion prom;
|
2009-04-15 18:57:54 +04:00
|
|
|
|
|
|
|
/* Registers */
|
|
|
|
uint8_t cam[16][6];
|
|
|
|
uint16_t regs[0x40];
|
|
|
|
|
|
|
|
/* Temporaries */
|
|
|
|
uint8_t tx_buffer[0x10000];
|
|
|
|
int loopback_packet;
|
|
|
|
|
|
|
|
/* Memory access */
|
2015-06-03 23:45:45 +03:00
|
|
|
void *dma_mr;
|
2015-06-03 23:45:37 +03:00
|
|
|
AddressSpace as;
|
2009-04-15 18:57:54 +04:00
|
|
|
} dp8393xState;
|
|
|
|
|
2017-01-09 21:43:57 +03:00
|
|
|
/* Accessor functions for values which are formed by
|
|
|
|
* concatenating two 16 bit device registers. By putting these
|
|
|
|
* in their own functions with a uint32_t return type we avoid the
|
|
|
|
* pitfall of implicit sign extension where ((x << 16) | y) is a
|
|
|
|
* signed 32 bit integer that might get sign-extended to a 64 bit integer.
|
|
|
|
*/
|
|
|
|
static uint32_t dp8393x_cdp(dp8393xState *s)
|
|
|
|
{
|
|
|
|
return (s->regs[SONIC_URRA] << 16) | s->regs[SONIC_CDP];
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t dp8393x_crba(dp8393xState *s)
|
|
|
|
{
|
|
|
|
return (s->regs[SONIC_CRBA1] << 16) | s->regs[SONIC_CRBA0];
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t dp8393x_crda(dp8393xState *s)
|
|
|
|
{
|
|
|
|
return (s->regs[SONIC_URDA] << 16) | s->regs[SONIC_CRDA];
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t dp8393x_rbwc(dp8393xState *s)
|
|
|
|
{
|
|
|
|
return (s->regs[SONIC_RBWC1] << 16) | s->regs[SONIC_RBWC0];
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t dp8393x_rrp(dp8393xState *s)
|
|
|
|
{
|
|
|
|
return (s->regs[SONIC_URRA] << 16) | s->regs[SONIC_RRP];
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t dp8393x_tsa(dp8393xState *s)
|
|
|
|
{
|
|
|
|
return (s->regs[SONIC_TSA1] << 16) | s->regs[SONIC_TSA0];
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t dp8393x_ttda(dp8393xState *s)
|
|
|
|
{
|
|
|
|
return (s->regs[SONIC_UTDA] << 16) | s->regs[SONIC_TTDA];
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t dp8393x_wt(dp8393xState *s)
|
|
|
|
{
|
|
|
|
return s->regs[SONIC_WT1] << 16 | s->regs[SONIC_WT0];
|
|
|
|
}
|
|
|
|
|
2009-04-15 18:57:54 +04:00
|
|
|
static void dp8393x_update_irq(dp8393xState *s)
|
|
|
|
{
|
|
|
|
int level = (s->regs[SONIC_IMR] & s->regs[SONIC_ISR]) ? 1 : 0;
|
|
|
|
|
|
|
|
#ifdef DEBUG_SONIC
|
|
|
|
if (level != s->irq_level) {
|
|
|
|
s->irq_level = level;
|
|
|
|
if (level) {
|
|
|
|
DPRINTF("raise irq, isr is 0x%04x\n", s->regs[SONIC_ISR]);
|
|
|
|
} else {
|
|
|
|
DPRINTF("lower irq\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
qemu_set_irq(s->irq, level);
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
static void dp8393x_do_load_cam(dp8393xState *s)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
|
|
|
uint16_t data[8];
|
|
|
|
int width, size;
|
|
|
|
uint16_t index = 0;
|
|
|
|
|
|
|
|
width = (s->regs[SONIC_DCR] & SONIC_DCR_DW) ? 2 : 1;
|
|
|
|
size = sizeof(uint16_t) * 4 * width;
|
|
|
|
|
|
|
|
while (s->regs[SONIC_CDC] & 0x1f) {
|
|
|
|
/* Fill current entry */
|
2017-01-09 21:43:57 +03:00
|
|
|
address_space_rw(&s->as, dp8393x_cdp(s),
|
2015-06-03 23:45:37 +03:00
|
|
|
MEMTXATTRS_UNSPECIFIED, (uint8_t *)data, size, 0);
|
2009-04-15 18:57:54 +04:00
|
|
|
s->cam[index][0] = data[1 * width] & 0xff;
|
|
|
|
s->cam[index][1] = data[1 * width] >> 8;
|
|
|
|
s->cam[index][2] = data[2 * width] & 0xff;
|
|
|
|
s->cam[index][3] = data[2 * width] >> 8;
|
|
|
|
s->cam[index][4] = data[3 * width] & 0xff;
|
|
|
|
s->cam[index][5] = data[3 * width] >> 8;
|
|
|
|
DPRINTF("load cam[%d] with %02x%02x%02x%02x%02x%02x\n", index,
|
|
|
|
s->cam[index][0], s->cam[index][1], s->cam[index][2],
|
|
|
|
s->cam[index][3], s->cam[index][4], s->cam[index][5]);
|
|
|
|
/* Move to next entry */
|
|
|
|
s->regs[SONIC_CDC]--;
|
|
|
|
s->regs[SONIC_CDP] += size;
|
|
|
|
index++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Read CAM enable */
|
2017-01-09 21:43:57 +03:00
|
|
|
address_space_rw(&s->as, dp8393x_cdp(s),
|
2015-06-03 23:45:37 +03:00
|
|
|
MEMTXATTRS_UNSPECIFIED, (uint8_t *)data, size, 0);
|
2009-04-15 18:57:54 +04:00
|
|
|
s->regs[SONIC_CE] = data[0 * width];
|
|
|
|
DPRINTF("load cam done. cam enable mask 0x%04x\n", s->regs[SONIC_CE]);
|
|
|
|
|
|
|
|
/* Done */
|
|
|
|
s->regs[SONIC_CR] &= ~SONIC_CR_LCAM;
|
|
|
|
s->regs[SONIC_ISR] |= SONIC_ISR_LCD;
|
|
|
|
dp8393x_update_irq(s);
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
static void dp8393x_do_read_rra(dp8393xState *s)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
|
|
|
uint16_t data[8];
|
|
|
|
int width, size;
|
|
|
|
|
|
|
|
/* Read memory */
|
|
|
|
width = (s->regs[SONIC_DCR] & SONIC_DCR_DW) ? 2 : 1;
|
|
|
|
size = sizeof(uint16_t) * 4 * width;
|
2017-01-09 21:43:57 +03:00
|
|
|
address_space_rw(&s->as, dp8393x_rrp(s),
|
2015-06-03 23:45:37 +03:00
|
|
|
MEMTXATTRS_UNSPECIFIED, (uint8_t *)data, size, 0);
|
2009-04-15 18:57:54 +04:00
|
|
|
|
|
|
|
/* Update SONIC registers */
|
|
|
|
s->regs[SONIC_CRBA0] = data[0 * width];
|
|
|
|
s->regs[SONIC_CRBA1] = data[1 * width];
|
|
|
|
s->regs[SONIC_RBWC0] = data[2 * width];
|
|
|
|
s->regs[SONIC_RBWC1] = data[3 * width];
|
|
|
|
DPRINTF("CRBA0/1: 0x%04x/0x%04x, RBWC0/1: 0x%04x/0x%04x\n",
|
|
|
|
s->regs[SONIC_CRBA0], s->regs[SONIC_CRBA1],
|
|
|
|
s->regs[SONIC_RBWC0], s->regs[SONIC_RBWC1]);
|
|
|
|
|
|
|
|
/* Go to next entry */
|
|
|
|
s->regs[SONIC_RRP] += size;
|
|
|
|
|
|
|
|
/* Handle wrap */
|
|
|
|
if (s->regs[SONIC_RRP] == s->regs[SONIC_REA]) {
|
|
|
|
s->regs[SONIC_RRP] = s->regs[SONIC_RSA];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check resource exhaustion */
|
|
|
|
if (s->regs[SONIC_RRP] == s->regs[SONIC_RWP])
|
|
|
|
{
|
|
|
|
s->regs[SONIC_ISR] |= SONIC_ISR_RBE;
|
|
|
|
dp8393x_update_irq(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Done */
|
|
|
|
s->regs[SONIC_CR] &= ~SONIC_CR_RRRA;
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
static void dp8393x_do_software_reset(dp8393xState *s)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
2013-08-21 19:03:08 +04:00
|
|
|
timer_del(s->watchdog);
|
2009-04-15 18:57:54 +04:00
|
|
|
|
|
|
|
s->regs[SONIC_CR] &= ~(SONIC_CR_LCAM | SONIC_CR_RRRA | SONIC_CR_TXP | SONIC_CR_HTX);
|
|
|
|
s->regs[SONIC_CR] |= SONIC_CR_RST | SONIC_CR_RXDIS;
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
static void dp8393x_set_next_tick(dp8393xState *s)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
|
|
|
uint32_t ticks;
|
|
|
|
int64_t delay;
|
|
|
|
|
|
|
|
if (s->regs[SONIC_CR] & SONIC_CR_STP) {
|
2013-08-21 19:03:08 +04:00
|
|
|
timer_del(s->watchdog);
|
2009-04-15 18:57:54 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-01-09 21:43:57 +03:00
|
|
|
ticks = dp8393x_wt(s);
|
2013-08-21 19:03:08 +04:00
|
|
|
s->wt_last_update = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
|
2016-03-21 19:02:30 +03:00
|
|
|
delay = NANOSECONDS_PER_SECOND * ticks / 5000000;
|
2013-08-21 19:03:08 +04:00
|
|
|
timer_mod(s->watchdog, s->wt_last_update + delay);
|
2009-04-15 18:57:54 +04:00
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
static void dp8393x_update_wt_regs(dp8393xState *s)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
|
|
|
int64_t elapsed;
|
|
|
|
uint32_t val;
|
|
|
|
|
|
|
|
if (s->regs[SONIC_CR] & SONIC_CR_STP) {
|
2013-08-21 19:03:08 +04:00
|
|
|
timer_del(s->watchdog);
|
2009-04-15 18:57:54 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-08-21 19:03:08 +04:00
|
|
|
elapsed = s->wt_last_update - qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
|
2017-01-09 21:43:57 +03:00
|
|
|
val = dp8393x_wt(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
val -= elapsed / 5000000;
|
|
|
|
s->regs[SONIC_WT1] = (val >> 16) & 0xffff;
|
|
|
|
s->regs[SONIC_WT0] = (val >> 0) & 0xffff;
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_set_next_tick(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
static void dp8393x_do_start_timer(dp8393xState *s)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
|
|
|
s->regs[SONIC_CR] &= ~SONIC_CR_STP;
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_set_next_tick(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
static void dp8393x_do_stop_timer(dp8393xState *s)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
|
|
|
s->regs[SONIC_CR] &= ~SONIC_CR_ST;
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_update_wt_regs(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
}
|
|
|
|
|
2015-07-15 13:19:12 +03:00
|
|
|
static int dp8393x_can_receive(NetClientState *nc);
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
static void dp8393x_do_receiver_enable(dp8393xState *s)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
|
|
|
s->regs[SONIC_CR] &= ~SONIC_CR_RXDIS;
|
2015-07-15 13:19:12 +03:00
|
|
|
if (dp8393x_can_receive(s->nic->ncs)) {
|
|
|
|
qemu_flush_queued_packets(qemu_get_queue(s->nic));
|
|
|
|
}
|
2009-04-15 18:57:54 +04:00
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
static void dp8393x_do_receiver_disable(dp8393xState *s)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
|
|
|
s->regs[SONIC_CR] &= ~SONIC_CR_RXEN;
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
static void dp8393x_do_transmit_packets(dp8393xState *s)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
2013-01-30 15:12:22 +04:00
|
|
|
NetClientState *nc = qemu_get_queue(s->nic);
|
2009-04-15 18:57:54 +04:00
|
|
|
uint16_t data[12];
|
|
|
|
int width, size;
|
|
|
|
int tx_len, len;
|
|
|
|
uint16_t i;
|
|
|
|
|
|
|
|
width = (s->regs[SONIC_DCR] & SONIC_DCR_DW) ? 2 : 1;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
/* Read memory */
|
|
|
|
size = sizeof(uint16_t) * 6 * width;
|
|
|
|
s->regs[SONIC_TTDA] = s->regs[SONIC_CTDA];
|
2017-01-09 21:43:57 +03:00
|
|
|
DPRINTF("Transmit packet at %08x\n", dp8393x_ttda(s));
|
2015-06-03 23:45:37 +03:00
|
|
|
address_space_rw(&s->as,
|
2017-01-09 21:43:57 +03:00
|
|
|
dp8393x_ttda(s) + sizeof(uint16_t) * width,
|
2015-06-03 23:45:37 +03:00
|
|
|
MEMTXATTRS_UNSPECIFIED, (uint8_t *)data, size, 0);
|
2009-04-15 18:57:54 +04:00
|
|
|
tx_len = 0;
|
|
|
|
|
|
|
|
/* Update registers */
|
|
|
|
s->regs[SONIC_TCR] = data[0 * width] & 0xf000;
|
|
|
|
s->regs[SONIC_TPS] = data[1 * width];
|
|
|
|
s->regs[SONIC_TFC] = data[2 * width];
|
|
|
|
s->regs[SONIC_TSA0] = data[3 * width];
|
|
|
|
s->regs[SONIC_TSA1] = data[4 * width];
|
|
|
|
s->regs[SONIC_TFS] = data[5 * width];
|
|
|
|
|
|
|
|
/* Handle programmable interrupt */
|
|
|
|
if (s->regs[SONIC_TCR] & SONIC_TCR_PINT) {
|
|
|
|
s->regs[SONIC_ISR] |= SONIC_ISR_PINT;
|
|
|
|
} else {
|
|
|
|
s->regs[SONIC_ISR] &= ~SONIC_ISR_PINT;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < s->regs[SONIC_TFC]; ) {
|
|
|
|
/* Append fragment */
|
|
|
|
len = s->regs[SONIC_TFS];
|
|
|
|
if (tx_len + len > sizeof(s->tx_buffer)) {
|
|
|
|
len = sizeof(s->tx_buffer) - tx_len;
|
|
|
|
}
|
2017-01-09 21:43:57 +03:00
|
|
|
address_space_rw(&s->as, dp8393x_tsa(s),
|
2015-06-03 23:45:37 +03:00
|
|
|
MEMTXATTRS_UNSPECIFIED, &s->tx_buffer[tx_len], len, 0);
|
2009-04-15 18:57:54 +04:00
|
|
|
tx_len += len;
|
|
|
|
|
|
|
|
i++;
|
|
|
|
if (i != s->regs[SONIC_TFC]) {
|
|
|
|
/* Read next fragment details */
|
|
|
|
size = sizeof(uint16_t) * 3 * width;
|
2015-06-03 23:45:37 +03:00
|
|
|
address_space_rw(&s->as,
|
2017-01-09 21:43:57 +03:00
|
|
|
dp8393x_ttda(s) + sizeof(uint16_t) * (4 + 3 * i) * width,
|
2015-06-03 23:45:37 +03:00
|
|
|
MEMTXATTRS_UNSPECIFIED, (uint8_t *)data, size, 0);
|
2009-04-15 18:57:54 +04:00
|
|
|
s->regs[SONIC_TSA0] = data[0 * width];
|
|
|
|
s->regs[SONIC_TSA1] = data[1 * width];
|
|
|
|
s->regs[SONIC_TFS] = data[2 * width];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle Ethernet checksum */
|
|
|
|
if (!(s->regs[SONIC_TCR] & SONIC_TCR_CRCI)) {
|
|
|
|
/* Don't append FCS there, to look like slirp packets
|
|
|
|
* which don't have one */
|
|
|
|
} else {
|
|
|
|
/* Remove existing FCS */
|
|
|
|
tx_len -= 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->regs[SONIC_RCR] & (SONIC_RCR_LB1 | SONIC_RCR_LB0)) {
|
|
|
|
/* Loopback */
|
|
|
|
s->regs[SONIC_TCR] |= SONIC_TCR_CRSL;
|
2013-01-30 15:12:22 +04:00
|
|
|
if (nc->info->can_receive(nc)) {
|
2009-04-15 18:57:54 +04:00
|
|
|
s->loopback_packet = 1;
|
2013-01-30 15:12:22 +04:00
|
|
|
nc->info->receive(nc, s->tx_buffer, tx_len);
|
2009-04-15 18:57:54 +04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Transmit packet */
|
2013-01-30 15:12:22 +04:00
|
|
|
qemu_send_packet(nc, s->tx_buffer, tx_len);
|
2009-04-15 18:57:54 +04:00
|
|
|
}
|
|
|
|
s->regs[SONIC_TCR] |= SONIC_TCR_PTX;
|
|
|
|
|
|
|
|
/* Write status */
|
|
|
|
data[0 * width] = s->regs[SONIC_TCR] & 0x0fff; /* status */
|
|
|
|
size = sizeof(uint16_t) * width;
|
2015-06-03 23:45:37 +03:00
|
|
|
address_space_rw(&s->as,
|
2017-01-09 21:43:57 +03:00
|
|
|
dp8393x_ttda(s),
|
2015-06-03 23:45:37 +03:00
|
|
|
MEMTXATTRS_UNSPECIFIED, (uint8_t *)data, size, 1);
|
2009-04-15 18:57:54 +04:00
|
|
|
|
|
|
|
if (!(s->regs[SONIC_CR] & SONIC_CR_HTX)) {
|
|
|
|
/* Read footer of packet */
|
|
|
|
size = sizeof(uint16_t) * width;
|
2015-06-03 23:45:37 +03:00
|
|
|
address_space_rw(&s->as,
|
2017-01-09 21:43:57 +03:00
|
|
|
dp8393x_ttda(s) +
|
|
|
|
sizeof(uint16_t) *
|
|
|
|
(4 + 3 * s->regs[SONIC_TFC]) * width,
|
2015-06-03 23:45:37 +03:00
|
|
|
MEMTXATTRS_UNSPECIFIED, (uint8_t *)data, size, 0);
|
2009-04-15 18:57:54 +04:00
|
|
|
s->regs[SONIC_CTDA] = data[0 * width] & ~0x1;
|
|
|
|
if (data[0 * width] & 0x1) {
|
|
|
|
/* EOL detected */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Done */
|
|
|
|
s->regs[SONIC_CR] &= ~SONIC_CR_TXP;
|
|
|
|
s->regs[SONIC_ISR] |= SONIC_ISR_TXDN;
|
|
|
|
dp8393x_update_irq(s);
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
static void dp8393x_do_halt_transmission(dp8393xState *s)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
|
|
|
/* Nothing to do */
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
static void dp8393x_do_command(dp8393xState *s, uint16_t command)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
|
|
|
if ((s->regs[SONIC_CR] & SONIC_CR_RST) && !(command & SONIC_CR_RST)) {
|
|
|
|
s->regs[SONIC_CR] &= ~SONIC_CR_RST;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->regs[SONIC_CR] |= (command & SONIC_CR_MASK);
|
|
|
|
|
|
|
|
if (command & SONIC_CR_HTX)
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_do_halt_transmission(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
if (command & SONIC_CR_TXP)
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_do_transmit_packets(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
if (command & SONIC_CR_RXDIS)
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_do_receiver_disable(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
if (command & SONIC_CR_RXEN)
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_do_receiver_enable(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
if (command & SONIC_CR_STP)
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_do_stop_timer(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
if (command & SONIC_CR_ST)
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_do_start_timer(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
if (command & SONIC_CR_RST)
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_do_software_reset(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
if (command & SONIC_CR_RRRA)
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_do_read_rra(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
if (command & SONIC_CR_LCAM)
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_do_load_cam(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:43 +03:00
|
|
|
static uint64_t dp8393x_read(void *opaque, hwaddr addr, unsigned int size)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
2015-06-03 23:45:43 +03:00
|
|
|
dp8393xState *s = opaque;
|
|
|
|
int reg = addr >> s->it_shift;
|
2009-04-15 18:57:54 +04:00
|
|
|
uint16_t val = 0;
|
|
|
|
|
|
|
|
switch (reg) {
|
|
|
|
/* Update data before reading it */
|
|
|
|
case SONIC_WT0:
|
|
|
|
case SONIC_WT1:
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_update_wt_regs(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
val = s->regs[reg];
|
|
|
|
break;
|
|
|
|
/* Accept read to some registers only when in reset mode */
|
|
|
|
case SONIC_CAP2:
|
|
|
|
case SONIC_CAP1:
|
|
|
|
case SONIC_CAP0:
|
|
|
|
if (s->regs[SONIC_CR] & SONIC_CR_RST) {
|
|
|
|
val = s->cam[s->regs[SONIC_CEP] & 0xf][2* (SONIC_CAP0 - reg) + 1] << 8;
|
|
|
|
val |= s->cam[s->regs[SONIC_CEP] & 0xf][2* (SONIC_CAP0 - reg)];
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
/* All other registers have no special contrainst */
|
|
|
|
default:
|
|
|
|
val = s->regs[reg];
|
|
|
|
}
|
|
|
|
|
|
|
|
DPRINTF("read 0x%04x from reg %s\n", val, reg_names[reg]);
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:43 +03:00
|
|
|
static void dp8393x_write(void *opaque, hwaddr addr, uint64_t data,
|
|
|
|
unsigned int size)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
2015-06-03 23:45:43 +03:00
|
|
|
dp8393xState *s = opaque;
|
|
|
|
int reg = addr >> s->it_shift;
|
|
|
|
|
|
|
|
DPRINTF("write 0x%04x to reg %s\n", (uint16_t)data, reg_names[reg]);
|
2009-04-15 18:57:54 +04:00
|
|
|
|
|
|
|
switch (reg) {
|
|
|
|
/* Command register */
|
|
|
|
case SONIC_CR:
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_do_command(s, data);
|
2009-04-15 18:57:54 +04:00
|
|
|
break;
|
|
|
|
/* Prevent write to read-only registers */
|
|
|
|
case SONIC_CAP2:
|
|
|
|
case SONIC_CAP1:
|
|
|
|
case SONIC_CAP0:
|
|
|
|
case SONIC_SR:
|
|
|
|
case SONIC_MDT:
|
|
|
|
DPRINTF("writing to reg %d invalid\n", reg);
|
|
|
|
break;
|
|
|
|
/* Accept write to some registers only when in reset mode */
|
|
|
|
case SONIC_DCR:
|
|
|
|
if (s->regs[SONIC_CR] & SONIC_CR_RST) {
|
2015-06-03 23:45:43 +03:00
|
|
|
s->regs[reg] = data & 0xbfff;
|
2009-04-15 18:57:54 +04:00
|
|
|
} else {
|
|
|
|
DPRINTF("writing to DCR invalid\n");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SONIC_DCR2:
|
|
|
|
if (s->regs[SONIC_CR] & SONIC_CR_RST) {
|
2015-06-03 23:45:43 +03:00
|
|
|
s->regs[reg] = data & 0xf017;
|
2009-04-15 18:57:54 +04:00
|
|
|
} else {
|
|
|
|
DPRINTF("writing to DCR2 invalid\n");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
/* 12 lower bytes are Read Only */
|
|
|
|
case SONIC_TCR:
|
2015-06-03 23:45:43 +03:00
|
|
|
s->regs[reg] = data & 0xf000;
|
2009-04-15 18:57:54 +04:00
|
|
|
break;
|
|
|
|
/* 9 lower bytes are Read Only */
|
|
|
|
case SONIC_RCR:
|
2015-06-03 23:45:43 +03:00
|
|
|
s->regs[reg] = data & 0xffe0;
|
2009-04-15 18:57:54 +04:00
|
|
|
break;
|
|
|
|
/* Ignore most significant bit */
|
|
|
|
case SONIC_IMR:
|
2015-06-03 23:45:43 +03:00
|
|
|
s->regs[reg] = data & 0x7fff;
|
2009-04-15 18:57:54 +04:00
|
|
|
dp8393x_update_irq(s);
|
|
|
|
break;
|
|
|
|
/* Clear bits by writing 1 to them */
|
|
|
|
case SONIC_ISR:
|
2015-06-03 23:45:43 +03:00
|
|
|
data &= s->regs[reg];
|
|
|
|
s->regs[reg] &= ~data;
|
|
|
|
if (data & SONIC_ISR_RBE) {
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_do_read_rra(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
}
|
|
|
|
dp8393x_update_irq(s);
|
2015-07-15 13:19:12 +03:00
|
|
|
if (dp8393x_can_receive(s->nic->ncs)) {
|
|
|
|
qemu_flush_queued_packets(qemu_get_queue(s->nic));
|
|
|
|
}
|
2009-04-15 18:57:54 +04:00
|
|
|
break;
|
|
|
|
/* Ignore least significant bit */
|
|
|
|
case SONIC_RSA:
|
|
|
|
case SONIC_REA:
|
|
|
|
case SONIC_RRP:
|
|
|
|
case SONIC_RWP:
|
2015-06-03 23:45:43 +03:00
|
|
|
s->regs[reg] = data & 0xfffe;
|
2009-04-15 18:57:54 +04:00
|
|
|
break;
|
|
|
|
/* Invert written value for some registers */
|
|
|
|
case SONIC_CRCT:
|
|
|
|
case SONIC_FAET:
|
|
|
|
case SONIC_MPT:
|
2015-06-03 23:45:43 +03:00
|
|
|
s->regs[reg] = data ^ 0xffff;
|
2009-04-15 18:57:54 +04:00
|
|
|
break;
|
|
|
|
/* All other registers have no special contrainst */
|
|
|
|
default:
|
2015-06-03 23:45:43 +03:00
|
|
|
s->regs[reg] = data;
|
2009-04-15 18:57:54 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (reg == SONIC_WT0 || reg == SONIC_WT1) {
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_set_next_tick(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:43 +03:00
|
|
|
static const MemoryRegionOps dp8393x_ops = {
|
|
|
|
.read = dp8393x_read,
|
|
|
|
.write = dp8393x_write,
|
|
|
|
.impl.min_access_size = 2,
|
|
|
|
.impl.max_access_size = 2,
|
|
|
|
.endianness = DEVICE_NATIVE_ENDIAN,
|
|
|
|
};
|
|
|
|
|
2009-04-15 18:57:54 +04:00
|
|
|
static void dp8393x_watchdog(void *opaque)
|
|
|
|
{
|
|
|
|
dp8393xState *s = opaque;
|
|
|
|
|
|
|
|
if (s->regs[SONIC_CR] & SONIC_CR_STP) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->regs[SONIC_WT1] = 0xffff;
|
|
|
|
s->regs[SONIC_WT0] = 0xffff;
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_set_next_tick(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
|
|
|
|
/* Signal underflow */
|
|
|
|
s->regs[SONIC_ISR] |= SONIC_ISR_TC;
|
|
|
|
dp8393x_update_irq(s);
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
static int dp8393x_can_receive(NetClientState *nc)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
2013-01-30 15:12:23 +04:00
|
|
|
dp8393xState *s = qemu_get_nic_opaque(nc);
|
2009-04-15 18:57:54 +04:00
|
|
|
|
|
|
|
if (!(s->regs[SONIC_CR] & SONIC_CR_RXEN))
|
|
|
|
return 0;
|
|
|
|
if (s->regs[SONIC_ISR] & SONIC_ISR_RBE)
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
static int dp8393x_receive_filter(dp8393xState *s, const uint8_t * buf,
|
|
|
|
int size)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
|
|
|
static const uint8_t bcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Check promiscuous mode */
|
|
|
|
if ((s->regs[SONIC_RCR] & SONIC_RCR_PRO) && (buf[0] & 1) == 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check multicast packets */
|
|
|
|
if ((s->regs[SONIC_RCR] & SONIC_RCR_AMC) && (buf[0] & 1) == 1) {
|
|
|
|
return SONIC_RCR_MC;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check broadcast */
|
|
|
|
if ((s->regs[SONIC_RCR] & SONIC_RCR_BRD) && !memcmp(buf, bcast, sizeof(bcast))) {
|
|
|
|
return SONIC_RCR_BC;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check CAM */
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
if (s->regs[SONIC_CE] & (1 << i)) {
|
|
|
|
/* Entry enabled */
|
|
|
|
if (!memcmp(buf, s->cam[i], sizeof(s->cam[i]))) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
static ssize_t dp8393x_receive(NetClientState *nc, const uint8_t * buf,
|
|
|
|
size_t size)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
2013-01-30 15:12:23 +04:00
|
|
|
dp8393xState *s = qemu_get_nic_opaque(nc);
|
2009-04-15 18:57:54 +04:00
|
|
|
uint16_t data[10];
|
|
|
|
int packet_type;
|
|
|
|
uint32_t available, address;
|
|
|
|
int width, rx_len = size;
|
|
|
|
uint32_t checksum;
|
|
|
|
|
|
|
|
width = (s->regs[SONIC_DCR] & SONIC_DCR_DW) ? 2 : 1;
|
|
|
|
|
|
|
|
s->regs[SONIC_RCR] &= ~(SONIC_RCR_PRX | SONIC_RCR_LBK | SONIC_RCR_FAER |
|
|
|
|
SONIC_RCR_CRCR | SONIC_RCR_LPKT | SONIC_RCR_BC | SONIC_RCR_MC);
|
|
|
|
|
2015-06-03 23:45:44 +03:00
|
|
|
packet_type = dp8393x_receive_filter(s, buf, size);
|
2009-04-15 18:57:54 +04:00
|
|
|
if (packet_type < 0) {
|
|
|
|
DPRINTF("packet not for netcard\n");
|
2009-05-18 16:40:55 +04:00
|
|
|
return -1;
|
2009-04-15 18:57:54 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX: Check byte ordering */
|
|
|
|
|
|
|
|
/* Check for EOL */
|
|
|
|
if (s->regs[SONIC_LLFA] & 0x1) {
|
|
|
|
/* Are we still in resource exhaustion? */
|
|
|
|
size = sizeof(uint16_t) * 1 * width;
|
2017-01-09 21:43:57 +03:00
|
|
|
address = dp8393x_crda(s) + sizeof(uint16_t) * 5 * width;
|
2015-06-03 23:45:37 +03:00
|
|
|
address_space_rw(&s->as, address, MEMTXATTRS_UNSPECIFIED,
|
|
|
|
(uint8_t *)data, size, 0);
|
2009-04-15 18:57:54 +04:00
|
|
|
if (data[0 * width] & 0x1) {
|
|
|
|
/* Still EOL ; stop reception */
|
2009-05-18 16:40:55 +04:00
|
|
|
return -1;
|
2009-04-15 18:57:54 +04:00
|
|
|
} else {
|
|
|
|
s->regs[SONIC_CRDA] = s->regs[SONIC_LLFA];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Save current position */
|
|
|
|
s->regs[SONIC_TRBA1] = s->regs[SONIC_CRBA1];
|
|
|
|
s->regs[SONIC_TRBA0] = s->regs[SONIC_CRBA0];
|
|
|
|
|
|
|
|
/* Calculate the ethernet checksum */
|
|
|
|
checksum = cpu_to_le32(crc32(0, buf, rx_len));
|
|
|
|
|
|
|
|
/* Put packet into RBA */
|
2017-01-09 21:43:57 +03:00
|
|
|
DPRINTF("Receive packet at %08x\n", dp8393x_crba(s));
|
|
|
|
address = dp8393x_crba(s);
|
2015-06-03 23:45:37 +03:00
|
|
|
address_space_rw(&s->as, address,
|
|
|
|
MEMTXATTRS_UNSPECIFIED, (uint8_t *)buf, rx_len, 1);
|
2009-04-15 18:57:54 +04:00
|
|
|
address += rx_len;
|
2015-06-03 23:45:37 +03:00
|
|
|
address_space_rw(&s->as, address,
|
|
|
|
MEMTXATTRS_UNSPECIFIED, (uint8_t *)&checksum, 4, 1);
|
2009-04-15 18:57:54 +04:00
|
|
|
rx_len += 4;
|
|
|
|
s->regs[SONIC_CRBA1] = address >> 16;
|
|
|
|
s->regs[SONIC_CRBA0] = address & 0xffff;
|
2017-01-09 21:43:57 +03:00
|
|
|
available = dp8393x_rbwc(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
available -= rx_len / 2;
|
|
|
|
s->regs[SONIC_RBWC1] = available >> 16;
|
|
|
|
s->regs[SONIC_RBWC0] = available & 0xffff;
|
|
|
|
|
|
|
|
/* Update status */
|
2017-01-09 21:43:57 +03:00
|
|
|
if (dp8393x_rbwc(s) < s->regs[SONIC_EOBC]) {
|
2009-04-15 18:57:54 +04:00
|
|
|
s->regs[SONIC_RCR] |= SONIC_RCR_LPKT;
|
|
|
|
}
|
|
|
|
s->regs[SONIC_RCR] |= packet_type;
|
|
|
|
s->regs[SONIC_RCR] |= SONIC_RCR_PRX;
|
|
|
|
if (s->loopback_packet) {
|
|
|
|
s->regs[SONIC_RCR] |= SONIC_RCR_LBK;
|
|
|
|
s->loopback_packet = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Write status to memory */
|
2017-01-09 21:43:57 +03:00
|
|
|
DPRINTF("Write status at %08x\n", dp8393x_crda(s));
|
2009-04-15 18:57:54 +04:00
|
|
|
data[0 * width] = s->regs[SONIC_RCR]; /* status */
|
|
|
|
data[1 * width] = rx_len; /* byte count */
|
|
|
|
data[2 * width] = s->regs[SONIC_TRBA0]; /* pkt_ptr0 */
|
|
|
|
data[3 * width] = s->regs[SONIC_TRBA1]; /* pkt_ptr1 */
|
|
|
|
data[4 * width] = s->regs[SONIC_RSC]; /* seq_no */
|
|
|
|
size = sizeof(uint16_t) * 5 * width;
|
2017-01-09 21:43:57 +03:00
|
|
|
address_space_rw(&s->as, dp8393x_crda(s),
|
2015-06-03 23:45:37 +03:00
|
|
|
MEMTXATTRS_UNSPECIFIED, (uint8_t *)data, size, 1);
|
2009-04-15 18:57:54 +04:00
|
|
|
|
|
|
|
/* Move to next descriptor */
|
|
|
|
size = sizeof(uint16_t) * width;
|
2017-01-09 21:43:57 +03:00
|
|
|
address_space_rw(&s->as, dp8393x_crda(s) + sizeof(uint16_t) * 5 * width,
|
2015-06-03 23:45:37 +03:00
|
|
|
MEMTXATTRS_UNSPECIFIED, (uint8_t *)data, size, 0);
|
2009-04-15 18:57:54 +04:00
|
|
|
s->regs[SONIC_LLFA] = data[0 * width];
|
|
|
|
if (s->regs[SONIC_LLFA] & 0x1) {
|
|
|
|
/* EOL detected */
|
|
|
|
s->regs[SONIC_ISR] |= SONIC_ISR_RDE;
|
|
|
|
} else {
|
|
|
|
data[0 * width] = 0; /* in_use */
|
2017-01-09 21:43:57 +03:00
|
|
|
address_space_rw(&s->as, dp8393x_crda(s) + sizeof(uint16_t) * 6 * width,
|
2015-06-03 23:45:48 +03:00
|
|
|
MEMTXATTRS_UNSPECIFIED, (uint8_t *)data, sizeof(uint16_t), 1);
|
2009-04-15 18:57:54 +04:00
|
|
|
s->regs[SONIC_CRDA] = s->regs[SONIC_LLFA];
|
|
|
|
s->regs[SONIC_ISR] |= SONIC_ISR_PKTRX;
|
|
|
|
s->regs[SONIC_RSC] = (s->regs[SONIC_RSC] & 0xff00) | (((s->regs[SONIC_RSC] & 0x00ff) + 1) & 0x00ff);
|
|
|
|
|
|
|
|
if (s->regs[SONIC_RCR] & SONIC_RCR_LPKT) {
|
|
|
|
/* Read next RRA */
|
2015-06-03 23:45:44 +03:00
|
|
|
dp8393x_do_read_rra(s);
|
2009-04-15 18:57:54 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Done */
|
|
|
|
dp8393x_update_irq(s);
|
2009-05-18 16:40:55 +04:00
|
|
|
|
|
|
|
return size;
|
2009-04-15 18:57:54 +04:00
|
|
|
}
|
|
|
|
|
2015-06-03 23:45:45 +03:00
|
|
|
static void dp8393x_reset(DeviceState *dev)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
2015-06-03 23:45:45 +03:00
|
|
|
dp8393xState *s = DP8393X(dev);
|
2013-08-21 19:03:08 +04:00
|
|
|
timer_del(s->watchdog);
|
2009-04-15 18:57:54 +04:00
|
|
|
|
2015-06-03 23:45:49 +03:00
|
|
|
memset(s->regs, 0, sizeof(s->regs));
|
2009-04-15 18:57:54 +04:00
|
|
|
s->regs[SONIC_CR] = SONIC_CR_RST | SONIC_CR_STP | SONIC_CR_RXDIS;
|
|
|
|
s->regs[SONIC_DCR] &= ~(SONIC_DCR_EXBUS | SONIC_DCR_LBR);
|
|
|
|
s->regs[SONIC_RCR] &= ~(SONIC_RCR_LB0 | SONIC_RCR_LB1 | SONIC_RCR_BRD | SONIC_RCR_RNT);
|
|
|
|
s->regs[SONIC_TCR] |= SONIC_TCR_NCRS | SONIC_TCR_PTX;
|
|
|
|
s->regs[SONIC_TCR] &= ~SONIC_TCR_BCM;
|
|
|
|
s->regs[SONIC_IMR] = 0;
|
|
|
|
s->regs[SONIC_ISR] = 0;
|
|
|
|
s->regs[SONIC_DCR2] = 0;
|
|
|
|
s->regs[SONIC_EOBC] = 0x02F8;
|
|
|
|
s->regs[SONIC_RSC] = 0;
|
|
|
|
s->regs[SONIC_CE] = 0;
|
|
|
|
s->regs[SONIC_RSC] = 0;
|
|
|
|
|
|
|
|
/* Network cable is connected */
|
|
|
|
s->regs[SONIC_RCR] |= SONIC_RCR_CRS;
|
|
|
|
|
|
|
|
dp8393x_update_irq(s);
|
|
|
|
}
|
|
|
|
|
2009-11-25 21:49:17 +03:00
|
|
|
static NetClientInfo net_dp83932_info = {
|
qapi: Change Netdev into a flat union
This is a mostly-mechanical conversion that creates a new flat
union 'Netdev' QAPI type that covers all the branches of the
former 'NetClientOptions' simple union, where the branches are
now listed in a new 'NetClientDriver' enum rather than generated
from the simple union. The existence of a flat union has no
change to the command line syntax accepted for new code, and
will make it possible for a future patch to switch the QMP
command to parse a boxed union for no change to valid QMP; but
it does have some ripple effect on the C code when dealing with
the new types.
While making the conversion, note that the 'NetLegacy' type
remains unchanged: it applies only to legacy command line options,
and will not be ported to QMP, so it should remain a wrapper
around a simple union; to avoid confusion, the type named
'NetClientOptions' is now gone, and we introduce 'NetLegacyOptions'
in its place. Then, in the C code, we convert from NetLegacy to
Netdev as soon as possible, so that the bulk of the net stack
only has to deal with one QAPI type, not two. Note that since
the old legacy code always rejected 'hubport', we can just omit
that branch from the new 'NetLegacyOptions' simple union.
Based on an idea originally by Zoltán Kővágó <DirtY.iCE.hu@gmail.com>:
Message-Id: <01a527fbf1a5de880091f98cf011616a78adeeee.1441627176.git.DirtY.iCE.hu@gmail.com>
although the sed script in that patch no longer applies due to
other changes in the tree since then, and I also did some manual
cleanups (such as fixing whitespace to keep checkpatch happy).
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1468468228-27827-13-git-send-email-eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
[Fixup from Eric squashed in]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-07-14 06:50:23 +03:00
|
|
|
.type = NET_CLIENT_DRIVER_NIC,
|
2009-11-25 21:49:17 +03:00
|
|
|
.size = sizeof(NICState),
|
2015-06-03 23:45:44 +03:00
|
|
|
.can_receive = dp8393x_can_receive,
|
|
|
|
.receive = dp8393x_receive,
|
2009-11-25 21:49:17 +03:00
|
|
|
};
|
|
|
|
|
2015-06-03 23:45:45 +03:00
|
|
|
static void dp8393x_instance_init(Object *obj)
|
2009-04-15 18:57:54 +04:00
|
|
|
{
|
2015-06-03 23:45:45 +03:00
|
|
|
SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
|
|
|
|
dp8393xState *s = DP8393X(obj);
|
2009-04-15 18:57:54 +04:00
|
|
|
|
2015-06-03 23:45:45 +03:00
|
|
|
sysbus_init_mmio(sbd, &s->mmio);
|
2015-06-03 23:45:46 +03:00
|
|
|
sysbus_init_mmio(sbd, &s->prom);
|
2015-06-03 23:45:45 +03:00
|
|
|
sysbus_init_irq(sbd, &s->irq);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dp8393x_realize(DeviceState *dev, Error **errp)
|
|
|
|
{
|
|
|
|
dp8393xState *s = DP8393X(dev);
|
2015-06-03 23:45:46 +03:00
|
|
|
int i, checksum;
|
|
|
|
uint8_t *prom;
|
2015-07-26 23:32:55 +03:00
|
|
|
Error *local_err = NULL;
|
2009-04-15 18:57:54 +04:00
|
|
|
|
2015-06-03 23:45:45 +03:00
|
|
|
address_space_init(&s->as, s->dma_mr, "dp8393x");
|
|
|
|
memory_region_init_io(&s->mmio, OBJECT(dev), &dp8393x_ops, s,
|
|
|
|
"dp8393x-regs", 0x40 << s->it_shift);
|
|
|
|
|
|
|
|
s->nic = qemu_new_nic(&net_dp83932_info, &s->conf,
|
|
|
|
object_get_typename(OBJECT(dev)), dev->id, s);
|
|
|
|
qemu_format_nic_info_str(qemu_get_queue(s->nic), s->conf.macaddr.a);
|
2009-04-15 18:57:54 +04:00
|
|
|
|
2013-08-21 19:03:08 +04:00
|
|
|
s->watchdog = timer_new_ns(QEMU_CLOCK_VIRTUAL, dp8393x_watchdog, s);
|
2009-04-15 18:57:54 +04:00
|
|
|
s->regs[SONIC_SR] = 0x0004; /* only revision recognized by Linux */
|
2015-06-03 23:45:46 +03:00
|
|
|
|
2018-07-09 16:51:35 +03:00
|
|
|
memory_region_init_ram(&s->prom, OBJECT(dev),
|
2015-07-26 23:32:55 +03:00
|
|
|
"dp8393x-prom", SONIC_PROM_SIZE, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
memory_region_set_readonly(&s->prom, true);
|
2015-06-03 23:45:46 +03:00
|
|
|
prom = memory_region_get_ram_ptr(&s->prom);
|
|
|
|
checksum = 0;
|
|
|
|
for (i = 0; i < 6; i++) {
|
|
|
|
prom[i] = s->conf.macaddr.a[i];
|
|
|
|
checksum += prom[i];
|
|
|
|
if (checksum > 0xff) {
|
|
|
|
checksum = (checksum + 1) & 0xff;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
prom[7] = 0xff - checksum;
|
2015-06-03 23:45:45 +03:00
|
|
|
}
|
2009-04-15 18:57:54 +04:00
|
|
|
|
2015-06-03 23:45:47 +03:00
|
|
|
static const VMStateDescription vmstate_dp8393x = {
|
|
|
|
.name = "dp8393x",
|
|
|
|
.version_id = 0,
|
|
|
|
.minimum_version_id = 0,
|
|
|
|
.fields = (VMStateField []) {
|
|
|
|
VMSTATE_BUFFER_UNSAFE(cam, dp8393xState, 0, 16 * 6),
|
|
|
|
VMSTATE_UINT16_ARRAY(regs, dp8393xState, 0x40),
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-06-03 23:45:45 +03:00
|
|
|
static Property dp8393x_properties[] = {
|
|
|
|
DEFINE_NIC_PROPERTIES(dp8393xState, conf),
|
|
|
|
DEFINE_PROP_PTR("dma_mr", dp8393xState, dma_mr),
|
|
|
|
DEFINE_PROP_UINT8("it_shift", dp8393xState, it_shift, 0),
|
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
2009-11-25 21:49:17 +03:00
|
|
|
|
2015-06-03 23:45:45 +03:00
|
|
|
static void dp8393x_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
2009-04-15 18:57:54 +04:00
|
|
|
|
2015-06-03 23:45:45 +03:00
|
|
|
set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
|
|
|
|
dc->realize = dp8393x_realize;
|
|
|
|
dc->reset = dp8393x_reset;
|
2015-06-03 23:45:47 +03:00
|
|
|
dc->vmsd = &vmstate_dp8393x;
|
2015-06-03 23:45:45 +03:00
|
|
|
dc->props = dp8393x_properties;
|
2015-07-24 21:42:21 +03:00
|
|
|
/* Reason: dma_mr property can't be set */
|
2017-05-03 23:35:44 +03:00
|
|
|
dc->user_creatable = false;
|
2015-06-03 23:45:45 +03:00
|
|
|
}
|
2009-04-15 18:57:54 +04:00
|
|
|
|
2015-06-03 23:45:45 +03:00
|
|
|
static const TypeInfo dp8393x_info = {
|
|
|
|
.name = TYPE_DP8393X,
|
|
|
|
.parent = TYPE_SYS_BUS_DEVICE,
|
|
|
|
.instance_size = sizeof(dp8393xState),
|
|
|
|
.instance_init = dp8393x_instance_init,
|
|
|
|
.class_init = dp8393x_class_init,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void dp8393x_register_types(void)
|
|
|
|
{
|
|
|
|
type_register_static(&dp8393x_info);
|
2009-04-15 18:57:54 +04:00
|
|
|
}
|
2015-06-03 23:45:45 +03:00
|
|
|
|
|
|
|
type_init(dp8393x_register_types)
|