motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-06 01:03:55 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fix unportable bitfields use which broke pcnet for big endian hosts.

Browse source 
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@2469 c046a42c-6fe2-441c-8c8c-71466251a162
This commit is contained in:
ths 2007-03-06 18:56:13 +00:00
parent 94fc95cdb2
commit 6d2980f515
1 changed files with 336 additions and 266 deletions
Download patch file Download diff file Expand all files Collapse all files

602
hw/pcnet.c
View file

@ -77,14 +77,6 @@ struct PCNetState_st {
void *dma_opaque; void *dma_opaque;
}; };
/* XXX: using bitfields for target memory structures is almost surely
not portable, so it should be suppressed ASAP */
#ifdef __GNUC__
#define PACKED_FIELD(A) A __attribute__ ((packed))
#else
#error FixMe
#endif
struct qemu_ether_header { struct qemu_ether_header {
uint8_t ether_dhost[6]; uint8_t ether_dhost[6];
uint8_t ether_shost[6]; uint8_t ether_shost[6];
@ -183,223 +175,291 @@ struct pcnet_initblk32 {
}; };
struct pcnet_TMD { struct pcnet_TMD {
struct { uint32_t tbadr;
unsigned tbadr:32; int16_t length;
} tmd0; int16_t status;
struct { uint32_t misc;
unsigned PACKED_FIELD(bcnt:12), PACKED_FIELD(ones:4), PACKED_FIELD(res:7), PACKED_FIELD(bpe:1); uint32_t res;
unsigned PACKED_FIELD(enp:1), PACKED_FIELD(stp:1), PACKED_FIELD(def:1), PACKED_FIELD(one:1);
unsigned PACKED_FIELD(ltint:1), PACKED_FIELD(nofcs:1), PACKED_FIELD(err:1), PACKED_FIELD(own:1);
} tmd1;
struct {
unsigned PACKED_FIELD(trc:4), PACKED_FIELD(res:12);
unsigned PACKED_FIELD(tdr:10), PACKED_FIELD(rtry:1), PACKED_FIELD(lcar:1);
unsigned PACKED_FIELD(lcol:1), PACKED_FIELD(exdef:1), PACKED_FIELD(uflo:1), PACKED_FIELD(buff:1);
} tmd2;
struct {
unsigned res:32;
} tmd3;
}; };
#define TMDL_BCNT_MASK 0x0fff
#define TMDL_BCNT_SH 0
#define TMDL_ONES_MASK 0xf000
#define TMDL_ONES_SH 12
#define TMDS_BPE_MASK 0x0080
#define TMDS_BPE_SH 7
#define TMDS_ENP_MASK 0x0100
#define TMDS_ENP_SH 8
#define TMDS_STP_MASK 0x0200
#define TMDS_STP_SH 9
#define TMDS_DEF_MASK 0x0400
#define TMDS_DEF_SH 10
#define TMDS_ONE_MASK 0x0800
#define TMDS_ONE_SH 11
#define TMDS_LTINT_MASK 0x1000
#define TMDS_LTINT_SH 12
#define TMDS_NOFCS_MASK 0x2000
#define TMDS_NOFCS_SH 13
#define TMDS_ERR_MASK 0x4000
#define TMDS_ERR_SH 14
#define TMDS_OWN_MASK 0x8000
#define TMDS_OWN_SH 15
#define TMDM_TRC_MASK 0x0000000f
#define TMDM_TRC_SH 0
#define TMDM_TDR_MASK 0x03ff0000
#define TMDM_TDR_SH 16
#define TMDM_RTRY_MASK 0x04000000
#define TMDM_RTRY_SH 26
#define TMDM_LCAR_MASK 0x08000000
#define TMDM_LCAR_SH 27
#define TMDM_LCOL_MASK 0x10000000
#define TMDM_LCOL_SH 28
#define TMDM_EXDEF_MASK 0x20000000
#define TMDM_EXDEF_SH 29
#define TMDM_UFLO_MASK 0x40000000
#define TMDM_UFLO_SH 30
#define TMDM_BUFF_MASK 0x80000000
#define TMDM_BUFF_SH 31
struct pcnet_RMD { struct pcnet_RMD {
struct { uint32_t rbadr;
unsigned rbadr:32; int16_t buf_length;
} rmd0; int16_t status;
struct { uint32_t msg_length;
unsigned PACKED_FIELD(bcnt:12), PACKED_FIELD(ones:4), PACKED_FIELD(res:4); uint32_t res;
unsigned PACKED_FIELD(bam:1), PACKED_FIELD(lafm:1), PACKED_FIELD(pam:1), PACKED_FIELD(bpe:1);
unsigned PACKED_FIELD(enp:1), PACKED_FIELD(stp:1), PACKED_FIELD(buff:1), PACKED_FIELD(crc:1);
unsigned PACKED_FIELD(oflo:1), PACKED_FIELD(fram:1), PACKED_FIELD(err:1), PACKED_FIELD(own:1);
} rmd1;
struct {
unsigned PACKED_FIELD(mcnt:12), PACKED_FIELD(zeros:4);
unsigned PACKED_FIELD(rpc:8), PACKED_FIELD(rcc:8);
} rmd2;
struct {
unsigned res:32;
} rmd3;
}; };
#define RMDL_BCNT_MASK 0x0fff
#define RMDL_BCNT_SH 0
#define RMDL_ONES_MASK 0xf000
#define RMDL_ONES_SH 12
#define PRINT_TMD(T) printf( \ #define RMDS_BAM_MASK 0x0010
"TMD0 : TBADR=0x%08x\n" \ #define RMDS_BAM_SH 4
#define RMDS_LFAM_MASK 0x0020
#define RMDS_LFAM_SH 5
#define RMDS_PAM_MASK 0x0040
#define RMDS_PAM_SH 6
#define RMDS_BPE_MASK 0x0080
#define RMDS_BPE_SH 7
#define RMDS_ENP_MASK 0x0100
#define RMDS_ENP_SH 8
#define RMDS_STP_MASK 0x0200
#define RMDS_STP_SH 9
#define RMDS_BUFF_MASK 0x0400
#define RMDS_BUFF_SH 10
#define RMDS_CRC_MASK 0x0800
#define RMDS_CRC_SH 11
#define RMDS_OFLO_MASK 0x1000
#define RMDS_OFLO_SH 12
#define RMDS_FRAM_MASK 0x2000
#define RMDS_FRAM_SH 13
#define RMDS_ERR_MASK 0x4000
#define RMDS_ERR_SH 14
#define RMDS_OWN_MASK 0x8000
#define RMDS_OWN_SH 15
#define RMDM_MCNT_MASK 0x00000fff
#define RMDM_MCNT_SH 0
#define RMDM_ZEROS_MASK 0x0000f000
#define RMDM_ZEROS_SH 12
#define RMDM_RPC_MASK 0x00ff0000
#define RMDM_RPC_SH 16
#define RMDM_RCC_MASK 0xff000000
#define RMDM_RCC_SH 24
#define SET_FIELD(regp, name, field, value) \
(*(regp) = (*(regp) & ~(name ## _ ## field ## _MASK)) \
| ((value) << name ## _ ## field ## _SH))
#define GET_FIELD(reg, name, field) \
(((reg) & name ## _ ## field ## _MASK) >> name ## _ ## field ## _SH)
#define PRINT_TMD(T) printf( \
"TMD0 : TBADR=0x%08x\n" \
"TMD1 : OWN=%d, ERR=%d, FCS=%d, LTI=%d, " \ "TMD1 : OWN=%d, ERR=%d, FCS=%d, LTI=%d, " \
"ONE=%d, DEF=%d, STP=%d, ENP=%d,\n" \ "ONE=%d, DEF=%d, STP=%d, ENP=%d,\n" \
" BPE=%d, BCNT=%d\n" \ " BPE=%d, BCNT=%d\n" \
"TMD2 : BUF=%d, UFL=%d, EXD=%d, LCO=%d, " \ "TMD2 : BUF=%d, UFL=%d, EXD=%d, LCO=%d, " \
"LCA=%d, RTR=%d,\n" \ "LCA=%d, RTR=%d,\n" \
" TDR=%d, TRC=%d\n", \ " TDR=%d, TRC=%d\n", \
(T)->tmd0.tbadr, \ (T)->tbadr, \
(T)->tmd1.own, (T)->tmd1.err, (T)->tmd1.nofcs, \ GET_FIELD((T)->status, TMDS, OWN), \
(T)->tmd1.ltint, (T)->tmd1.one, (T)->tmd1.def, \ GET_FIELD((T)->status, TMDS, ERR), \
(T)->tmd1.stp, (T)->tmd1.enp, (T)->tmd1.bpe, \ GET_FIELD((T)->status, TMDS, NOFCS), \
4096-(T)->tmd1.bcnt, \ GET_FIELD((T)->status, TMDS, LTINT), \
(T)->tmd2.buff, (T)->tmd2.uflo, (T)->tmd2.exdef,\ GET_FIELD((T)->status, TMDS, ONE), \
(T)->tmd2.lcol, (T)->tmd2.lcar, (T)->tmd2.rtry, \ GET_FIELD((T)->status, TMDS, DEF), \
(T)->tmd2.tdr, (T)->tmd2.trc) GET_FIELD((T)->status, TMDS, STP), \
GET_FIELD((T)->status, TMDS, ENP), \
GET_FIELD((T)->status, TMDS, BPE), \
4096-GET_FIELD((T)->length, TMDL, BCNT), \
GET_FIELD((T)->misc, TMDM, BUFF), \
GET_FIELD((T)->misc, TMDM, UFLO), \
GET_FIELD((T)->misc, TMDM, EXDEF), \
GET_FIELD((T)->misc, TMDM, LCOL), \
GET_FIELD((T)->misc, TMDM, LCAR), \
GET_FIELD((T)->misc, TMDM, RTRY), \
GET_FIELD((T)->misc, TMDM, TDR), \
GET_FIELD((T)->misc, TMDM, TRC))
#define PRINT_RMD(R) printf( \ #define PRINT_RMD(R) printf( \
"RMD0 : RBADR=0x%08x\n" \ "RMD0 : RBADR=0x%08x\n" \
"RMD1 : OWN=%d, ERR=%d, FRAM=%d, OFLO=%d, " \ "RMD1 : OWN=%d, ERR=%d, FRAM=%d, OFLO=%d, " \
"CRC=%d, BUFF=%d, STP=%d, ENP=%d,\n " \ "CRC=%d, BUFF=%d, STP=%d, ENP=%d,\n " \
"BPE=%d, PAM=%d, LAFM=%d, BAM=%d, ONES=%d, BCNT=%d\n" \ "BPE=%d, PAM=%d, LAFM=%d, BAM=%d, ONES=%d, BCNT=%d\n" \
"RMD2 : RCC=%d, RPC=%d, MCNT=%d, ZEROS=%d\n", \ "RMD2 : RCC=%d, RPC=%d, MCNT=%d, ZEROS=%d\n", \
(R)->rmd0.rbadr, \ (R)->rbadr, \
(R)->rmd1.own, (R)->rmd1.err, (R)->rmd1.fram, \ GET_FIELD((R)->status, RMDS, OWN), \
(R)->rmd1.oflo, (R)->rmd1.crc, (R)->rmd1.buff, \ GET_FIELD((R)->status, RMDS, ERR), \
(R)->rmd1.stp, (R)->rmd1.enp, (R)->rmd1.bpe, \ GET_FIELD((R)->status, RMDS, FRAM), \
(R)->rmd1.pam, (R)->rmd1.lafm, (R)->rmd1.bam, \ GET_FIELD((R)->status, RMDS, OFLO), \
(R)->rmd1.ones, 4096-(R)->rmd1.bcnt, \ GET_FIELD((R)->status, RMDS, CRC), \
(R)->rmd2.rcc, (R)->rmd2.rpc, (R)->rmd2.mcnt, \ GET_FIELD((R)->status, RMDS, BUFF), \
(R)->rmd2.zeros) GET_FIELD((R)->status, RMDS, STP), \
GET_FIELD((R)->status, RMDS, ENP), \
GET_FIELD((R)->status, RMDS, BPE), \
GET_FIELD((R)->status, RMDS, PAM), \
GET_FIELD((R)->status, RMDS, LFAM), \
GET_FIELD((R)->status, RMDS, BAM), \
GET_FIELD((R)->buf_length, RMDL, ONES), \
4096-GET_FIELD((R)->buf_length, RMDL, BCNT), \
GET_FIELD((R)->msg_length, RMDM, RCC), \
GET_FIELD((R)->msg_length, RMDM, RPC), \
GET_FIELD((R)->msg_length, RMDM, MCNT), \
GET_FIELD((R)->msg_length, RMDM, ZEROS))
static inline void pcnet_tmd_load(PCNetState *s, struct pcnet_TMD *tmd1, static inline void pcnet_tmd_load(PCNetState *s, struct pcnet_TMD *tmd,
target_phys_addr_t addr) target_phys_addr_t addr)
{ {
uint32_t *tmd = (uint32_t *)tmd1; if (!BCR_SSIZE32(s)) {
struct {
if (!BCR_SWSTYLE(s)) { uint32_t tbadr;
uint16_t xda[4]; int16_t length;
s->phys_mem_read(s->dma_opaque, addr, int16_t status;
(void *)&xda[0], sizeof(xda), 0); } xda;
le16_to_cpus(&xda[0]); s->phys_mem_read(s->dma_opaque, addr, (void *)&xda, sizeof(xda), 0);
le16_to_cpus(&xda[1]); tmd->tbadr = le32_to_cpu(xda.tbadr) & 0xffffff;
le16_to_cpus(&xda[2]); tmd->length = le16_to_cpu(xda.length);
le16_to_cpus(&xda[3]); tmd->status = (le32_to_cpu(xda.tbadr) >> 16) & 0xff00;
tmd[0] = (xda[0]&0xffff) | tmd->misc = le16_to_cpu(xda.status) << 16;
((xda[1]&0x00ff) << 16); tmd->res = 0;
tmd[1] = (xda[2]&0xffff)|
((xda[1] & 0xff00) << 16);
tmd[2] =
(xda[3] & 0xffff) << 16;
tmd[3] = 0;
} else { } else {
uint32_t xda[4]; s->phys_mem_read(s->dma_opaque, addr, (void *)tmd, sizeof(*tmd), 0);
s->phys_mem_read(s->dma_opaque, addr, le32_to_cpus(&tmd->tbadr);
(void *)&xda[0], sizeof(xda), 0); le16_to_cpus(&tmd->length);
le32_to_cpus(&xda[0]); le16_to_cpus(&tmd->status);
le32_to_cpus(&xda[1]); le32_to_cpus(&tmd->misc);
le32_to_cpus(&xda[2]); le32_to_cpus(&tmd->res);
le32_to_cpus(&xda[3]); if (BCR_SWSTYLE(s) == 3) {
if (BCR_SWSTYLE(s) != 3) { uint32_t tmp = tmd->tbadr;
memcpy(tmd, xda, sizeof(xda)); tmd->tbadr = tmd->misc;
} else { tmd->misc = tmp;
tmd[0] = xda[2];
tmd[1] = xda[1];
tmd[2] = xda[0];
tmd[3] = xda[3];
} }
} }
} }
static inline void pcnet_tmd_store(PCNetState *s, const struct pcnet_TMD *tmd1, static inline void pcnet_tmd_store(PCNetState *s, const struct pcnet_TMD *tmd,
target_phys_addr_t addr) target_phys_addr_t addr)
{ {
const uint32_t *tmd = (const uint32_t *)tmd1; if (!BCR_SSIZE32(s)) {
if (!BCR_SWSTYLE(s)) { struct {
uint16_t xda[4]; uint32_t tbadr;
xda[0] = tmd[0] & 0xffff; int16_t length;
xda[1] = ((tmd[0]>>16)&0x00ff) | int16_t status;
((tmd[1]>>16)&0xff00); } xda;
xda[2] = tmd[1] & 0xffff; xda.tbadr = cpu_to_le32((tmd->tbadr & 0xffffff) |
xda[3] = tmd[2] >> 16; ((tmd->status & 0xff00) << 16));
cpu_to_le16s(&xda[0]); xda.length = cpu_to_le16(tmd->length);
cpu_to_le16s(&xda[1]); xda.status = cpu_to_le16(tmd->misc >> 16);
cpu_to_le16s(&xda[2]); s->phys_mem_write(s->dma_opaque, addr, (void *)&xda, sizeof(xda), 0);
cpu_to_le16s(&xda[3]);
s->phys_mem_write(s->dma_opaque, addr,
(void *)&xda[0], sizeof(xda), 0);
} else { } else {
uint32_t xda[4]; struct {
if (BCR_SWSTYLE(s) != 3) { uint32_t tbadr;
memcpy(xda, tmd, sizeof(xda)); int16_t length;
} else { int16_t status;
xda[0] = tmd[2]; uint32_t misc;
xda[1] = tmd[1]; uint32_t res;
xda[2] = tmd[0]; } xda;
xda[3] = tmd[3]; xda.tbadr = cpu_to_le32(tmd->tbadr);
xda.length = cpu_to_le16(tmd->length);
xda.status = cpu_to_le16(tmd->status);
xda.misc = cpu_to_le32(tmd->misc);
xda.res = cpu_to_le32(tmd->res);
if (BCR_SWSTYLE(s) == 3) {
uint32_t tmp = xda.tbadr;
xda.tbadr = xda.misc;
xda.misc = tmp;
} }
cpu_to_le32s(&xda[0]); s->phys_mem_write(s->dma_opaque, addr, (void *)&xda, sizeof(xda), 0);
cpu_to_le32s(&xda[1]);
cpu_to_le32s(&xda[2]);
cpu_to_le32s(&xda[3]);
s->phys_mem_write(s->dma_opaque, addr,
(void *)&xda[0], sizeof(xda), 0);
} }
} }
static inline void pcnet_rmd_load(PCNetState *s, struct pcnet_RMD *rmd1, static inline void pcnet_rmd_load(PCNetState *s, struct pcnet_RMD *rmd,
target_phys_addr_t addr) target_phys_addr_t addr)
{ {
uint32_t *rmd = (uint32_t *)rmd1; if (!BCR_SSIZE32(s)) {
struct {
if (!BCR_SWSTYLE(s)) { uint32_t rbadr;
uint16_t rda[4]; int16_t buf_length;
s->phys_mem_read(s->dma_opaque, addr, int16_t msg_length;
(void *)&rda[0], sizeof(rda), 0); } rda;
le16_to_cpus(&rda[0]); s->phys_mem_read(s->dma_opaque, addr, (void *)&rda, sizeof(rda), 0);
le16_to_cpus(&rda[1]); rmd->rbadr = le32_to_cpu(rda.rbadr) & 0xffffff;
le16_to_cpus(&rda[2]); rmd->buf_length = le16_to_cpu(rda.buf_length);
le16_to_cpus(&rda[3]); rmd->status = (le32_to_cpu(rda.rbadr) >> 16) & 0xff00;
rmd[0] = (rda[0]&0xffff)| rmd->msg_length = le16_to_cpu(rda.msg_length);
((rda[1] & 0x00ff) << 16); rmd->res = 0;
rmd[1] = (rda[2]&0xffff)|
((rda[1] & 0xff00) << 16);
rmd[2] = rda[3] & 0xffff;
rmd[3] = 0;
} else { } else {
uint32_t rda[4]; s->phys_mem_read(s->dma_opaque, addr, (void *)rmd, sizeof(*rmd), 0);
s->phys_mem_read(s->dma_opaque, addr, le32_to_cpus(&rmd->rbadr);
(void *)&rda[0], sizeof(rda), 0); le16_to_cpus(&rmd->buf_length);
le32_to_cpus(&rda[0]); le16_to_cpus(&rmd->status);
le32_to_cpus(&rda[1]); le32_to_cpus(&rmd->msg_length);
le32_to_cpus(&rda[2]); le32_to_cpus(&rmd->res);
le32_to_cpus(&rda[3]); if (BCR_SWSTYLE(s) == 3) {
if (BCR_SWSTYLE(s) != 3) { uint32_t tmp = rmd->rbadr;
memcpy(rmd, rda, sizeof(rda)); rmd->rbadr = rmd->msg_length;
} else { rmd->msg_length = tmp;
rmd[0] = rda[2];
rmd[1] = rda[1];
rmd[2] = rda[0];
rmd[3] = rda[3];
} }
} }
} }
static inline void pcnet_rmd_store(PCNetState *s, struct pcnet_RMD *rmd1, static inline void pcnet_rmd_store(PCNetState *s, struct pcnet_RMD *rmd,
target_phys_addr_t addr) target_phys_addr_t addr)
{ {
const uint32_t *rmd = (const uint32_t *)rmd1; if (!BCR_SSIZE32(s)) {
struct {
if (!BCR_SWSTYLE(s)) { uint32_t rbadr;
uint16_t rda[4]; int16_t buf_length;
rda[0] = rmd[0] & 0xffff; int16_t msg_length;
rda[1] = ((rmd[0]>>16)&0xff)| } rda;
((rmd[1]>>16)&0xff00); rda.rbadr = cpu_to_le32((rmd->rbadr & 0xffffff) |
rda[2] = rmd[1] & 0xffff; ((rmd->status & 0xff00) << 16));
rda[3] = rmd[2] & 0xffff; rda.buf_length = cpu_to_le16(rmd->buf_length);
cpu_to_le16s(&rda[0]); rda.msg_length = cpu_to_le16(rmd->msg_length);
cpu_to_le16s(&rda[1]); s->phys_mem_write(s->dma_opaque, addr, (void *)&rda, sizeof(rda), 0);
cpu_to_le16s(&rda[2]);
cpu_to_le16s(&rda[3]);
s->phys_mem_write(s->dma_opaque, addr,
(void *)&rda[0], sizeof(rda), 0);
} else { } else {
uint32_t rda[4]; struct {
if (BCR_SWSTYLE(s) != 3) { uint32_t rbadr;
memcpy(rda, rmd, sizeof(rda)); int16_t buf_length;
} else { int16_t status;
rda[0] = rmd[2]; uint32_t msg_length;
rda[1] = rmd[1]; uint32_t res;
rda[2] = rmd[0]; } rda;
rda[3] = rmd[3]; rda.rbadr = cpu_to_le32(rmd->rbadr);
rda.buf_length = cpu_to_le16(rmd->buf_length);
rda.status = cpu_to_le16(rmd->status);
rda.msg_length = cpu_to_le32(rmd->msg_length);
rda.res = cpu_to_le32(rmd->res);
if (BCR_SWSTYLE(s) == 3) {
uint32_t tmp = rda.rbadr;
rda.rbadr = rda.msg_length;
rda.msg_length = tmp;
} }
cpu_to_le32s(&rda[0]); s->phys_mem_write(s->dma_opaque, addr, (void *)&rda, sizeof(rda), 0);
cpu_to_le32s(&rda[1]);
cpu_to_le32s(&rda[2]);
cpu_to_le32s(&rda[3]);
s->phys_mem_write(s->dma_opaque, addr,
(void *)&rda[0], sizeof(rda), 0);
} }
} }
@ -417,14 +477,14 @@ static inline void pcnet_rmd_store(PCNetState *s, struct pcnet_RMD *rmd1,
#define CHECK_RMD(ADDR,RES) do { \ #define CHECK_RMD(ADDR,RES) do { \
struct pcnet_RMD rmd; \ struct pcnet_RMD rmd; \
RMDLOAD(&rmd,(ADDR)); \ RMDLOAD(&rmd,(ADDR)); \
(RES) |= (rmd.rmd1.ones != 15) \ (RES) |= (GET_FIELD(rmd.buf_length, RMDL, ONES) != 15) \
|| (rmd.rmd2.zeros != 0); \ || (GET_FIELD(rmd.msg_length, RMDM, ZEROS) != 0); \
} while (0) } while (0)
#define CHECK_TMD(ADDR,RES) do { \ #define CHECK_TMD(ADDR,RES) do { \
struct pcnet_TMD tmd; \ struct pcnet_TMD tmd; \
TMDLOAD(&tmd,(ADDR)); \ TMDLOAD(&tmd,(ADDR)); \
(RES) |= (tmd.tmd1.ones != 15); \ (RES) |= (GET_FIELD(tmd.length, TMDL, ONES) != 15); \
} while (0) } while (0)
#else #else
@ -434,8 +494,8 @@ static inline void pcnet_rmd_store(PCNetState *s, struct pcnet_RMD *rmd1,
case 0x00: \ case 0x00: \
do { \ do { \
uint16_t rda[4]; \ uint16_t rda[4]; \
s->phys_mem_read(s->dma_opaque, (ADDR), \ s->phys_mem_read(s->dma_opaque, (ADDR), \
(void *)&rda[0], sizeof(rda), 0); \ (void *)&rda[0], sizeof(rda), 0); \
(RES) |= (rda[2] & 0xf000)!=0xf000; \ (RES) |= (rda[2] & 0xf000)!=0xf000; \
(RES) |= (rda[3] & 0xf000)!=0x0000; \ (RES) |= (rda[3] & 0xf000)!=0x0000; \
} while (0); \ } while (0); \
@ -444,7 +504,7 @@ static inline void pcnet_rmd_store(PCNetState *s, struct pcnet_RMD *rmd1,
case 0x02: \ case 0x02: \
do { \ do { \
uint32_t rda[4]; \ uint32_t rda[4]; \
s->phys_mem_read(s->dma_opaque, (ADDR), \ s->phys_mem_read(s->dma_opaque, (ADDR), \
(void *)&rda[0], sizeof(rda), 0); \ (void *)&rda[0], sizeof(rda), 0); \
(RES) |= (rda[1] & 0x0000f000L)!=0x0000f000L; \ (RES) |= (rda[1] & 0x0000f000L)!=0x0000f000L; \
(RES) |= (rda[2] & 0x0000f000L)!=0x00000000L; \ (RES) |= (rda[2] & 0x0000f000L)!=0x00000000L; \
@ -453,7 +513,7 @@ static inline void pcnet_rmd_store(PCNetState *s, struct pcnet_RMD *rmd1,
case 0x03: \ case 0x03: \
do { \ do { \
uint32_t rda[4]; \ uint32_t rda[4]; \
s->phys_mem_read(s->dma_opaque, (ADDR), \ s->phys_mem_read(s->dma_opaque, (ADDR), \
(void *)&rda[0], sizeof(rda), 0); \ (void *)&rda[0], sizeof(rda), 0); \
(RES) |= (rda[0] & 0x0000f000L)!=0x00000000L; \ (RES) |= (rda[0] & 0x0000f000L)!=0x00000000L; \
(RES) |= (rda[1] & 0x0000f000L)!=0x0000f000L; \ (RES) |= (rda[1] & 0x0000f000L)!=0x0000f000L; \
@ -467,9 +527,9 @@ static inline void pcnet_rmd_store(PCNetState *s, struct pcnet_RMD *rmd1,
case 0x00: \ case 0x00: \
do { \ do { \
uint16_t xda[4]; \ uint16_t xda[4]; \
s->phys_mem_read(s->dma_opaque, (ADDR), \ s->phys_mem_read(s->dma_opaque, (ADDR), \
(void *)&xda[0], sizeof(xda), 0); \ (void *)&xda[0], sizeof(xda), 0); \
(RES) |= (xda[2] & 0xf000)!=0xf000;\ (RES) |= (xda[2] & 0xf000)!=0xf000; \
} while (0); \ } while (0); \
break; \ break; \
case 0x01: \ case 0x01: \
@ -477,8 +537,8 @@ static inline void pcnet_rmd_store(PCNetState *s, struct pcnet_RMD *rmd1,
case 0x03: \ case 0x03: \
do { \ do { \
uint32_t xda[4]; \ uint32_t xda[4]; \
s->phys_mem_read(s->dma_opaque, (ADDR), \ s->phys_mem_read(s->dma_opaque, (ADDR), \
(void *)&xda[0], sizeof(xda), 0); \ (void *)&xda[0], sizeof(xda), 0); \
(RES) |= (xda[1] & 0x0000f000L)!=0x0000f000L; \ (RES) |= (xda[1] & 0x0000f000L)!=0x0000f000L; \
} while (0); \ } while (0); \
break; \ break; \
@ -488,15 +548,15 @@ static inline void pcnet_rmd_store(PCNetState *s, struct pcnet_RMD *rmd1,
#endif #endif
#define PRINT_PKTHDR(BUF) do { \ #define PRINT_PKTHDR(BUF) do { \
struct qemu_ether_header *hdr = (void *)(BUF); \ struct qemu_ether_header *hdr = (void *)(BUF); \
printf("packet dhost=%02x:%02x:%02x:%02x:%02x:%02x, " \ printf("packet dhost=%02x:%02x:%02x:%02x:%02x:%02x, " \
"shost=%02x:%02x:%02x:%02x:%02x:%02x, " \ "shost=%02x:%02x:%02x:%02x:%02x:%02x, " \
"type=0x%04x\n", \ "type=0x%04x\n", \
hdr->ether_dhost[0],hdr->ether_dhost[1],hdr->ether_dhost[2], \ hdr->ether_dhost[0],hdr->ether_dhost[1],hdr->ether_dhost[2], \
hdr->ether_dhost[3],hdr->ether_dhost[4],hdr->ether_dhost[5], \ hdr->ether_dhost[3],hdr->ether_dhost[4],hdr->ether_dhost[5], \
hdr->ether_shost[0],hdr->ether_shost[1],hdr->ether_shost[2], \ hdr->ether_shost[0],hdr->ether_shost[1],hdr->ether_shost[2], \
hdr->ether_shost[3],hdr->ether_shost[4],hdr->ether_shost[5], \ hdr->ether_shost[3],hdr->ether_shost[4],hdr->ether_shost[5], \
be16_to_cpu(hdr->ether_type)); \ be16_to_cpu(hdr->ether_type)); \
} while (0) } while (0)
#define MULTICAST_FILTER_LEN 8 #define MULTICAST_FILTER_LEN 8
@ -770,7 +830,7 @@ static void pcnet_update_irq(PCNetState *s)
static void pcnet_init(PCNetState *s) static void pcnet_init(PCNetState *s)
{ {
int rlen, tlen; int rlen, tlen;
uint16_t *padr, *ladrf, mode; uint16_t padr[3], ladrf[4], mode;
uint32_t rdra, tdra; uint32_t rdra, tdra;
#ifdef PCNET_DEBUG #ifdef PCNET_DEBUG
@ -781,22 +841,30 @@ static void pcnet_init(PCNetState *s)
struct pcnet_initblk32 initblk; struct pcnet_initblk32 initblk;
s->phys_mem_read(s->dma_opaque, PHYSADDR(s,CSR_IADR(s)), s->phys_mem_read(s->dma_opaque, PHYSADDR(s,CSR_IADR(s)),
(uint8_t *)&initblk, sizeof(initblk), 0); (uint8_t *)&initblk, sizeof(initblk), 0);
mode = initblk.mode; mode = le16_to_cpu(initblk.mode);
rlen = initblk.rlen >> 4; rlen = initblk.rlen >> 4;
tlen = initblk.tlen >> 4; tlen = initblk.tlen >> 4;
ladrf = initblk.ladrf; ladrf[0] = le16_to_cpu(initblk.ladrf[0]);
padr = initblk.padr; ladrf[1] = le16_to_cpu(initblk.ladrf[1]);
ladrf[2] = le16_to_cpu(initblk.ladrf[2]);
ladrf[3] = le16_to_cpu(initblk.ladrf[3]);
padr[0] = le16_to_cpu(initblk.padr[0]);
padr[1] = le16_to_cpu(initblk.padr[1]);
padr[2] = le16_to_cpu(initblk.padr[2]);
rdra = le32_to_cpu(initblk.rdra); rdra = le32_to_cpu(initblk.rdra);
tdra = le32_to_cpu(initblk.tdra); tdra = le32_to_cpu(initblk.tdra);
s->rdra = PHYSADDR(s,initblk.rdra);
s->tdra = PHYSADDR(s,initblk.tdra);
} else { } else {
struct pcnet_initblk16 initblk; struct pcnet_initblk16 initblk;
s->phys_mem_read(s->dma_opaque, PHYSADDR(s,CSR_IADR(s)), s->phys_mem_read(s->dma_opaque, PHYSADDR(s,CSR_IADR(s)),
(uint8_t *)&initblk, sizeof(initblk), 0); (uint8_t *)&initblk, sizeof(initblk), 0);
mode = initblk.mode; mode = le16_to_cpu(initblk.mode);
ladrf = initblk.ladrf; ladrf[0] = le16_to_cpu(initblk.ladrf[0]);
padr = initblk.padr; ladrf[1] = le16_to_cpu(initblk.ladrf[1]);
ladrf[2] = le16_to_cpu(initblk.ladrf[2]);
ladrf[3] = le16_to_cpu(initblk.ladrf[3]);
padr[0] = le16_to_cpu(initblk.padr[0]);
padr[1] = le16_to_cpu(initblk.padr[1]);
padr[2] = le16_to_cpu(initblk.padr[2]);
rdra = le32_to_cpu(initblk.rdra); rdra = le32_to_cpu(initblk.rdra);
tdra = le32_to_cpu(initblk.tdra); tdra = le32_to_cpu(initblk.tdra);
rlen = rdra >> 29; rlen = rdra >> 29;
@ -804,22 +872,22 @@ static void pcnet_init(PCNetState *s)
rdra &= 0x00ffffff; rdra &= 0x00ffffff;
tdra &= 0x00ffffff; tdra &= 0x00ffffff;
} }
#if defined(PCNET_DEBUG) #if defined(PCNET_DEBUG)
printf("rlen=%d tlen=%d\n", printf("rlen=%d tlen=%d\n", rlen, tlen);
rlen, tlen);
#endif #endif
CSR_RCVRL(s) = (rlen < 9) ? (1 << rlen) : 512; CSR_RCVRL(s) = (rlen < 9) ? (1 << rlen) : 512;
CSR_XMTRL(s) = (tlen < 9) ? (1 << tlen) : 512; CSR_XMTRL(s) = (tlen < 9) ? (1 << tlen) : 512;
s->csr[ 6] = (tlen << 12) | (rlen << 8); s->csr[ 6] = (tlen << 12) | (rlen << 8);
s->csr[15] = le16_to_cpu(mode); s->csr[15] = mode;
s->csr[ 8] = le16_to_cpu(ladrf[0]); s->csr[ 8] = ladrf[0];
s->csr[ 9] = le16_to_cpu(ladrf[1]); s->csr[ 9] = ladrf[1];
s->csr[10] = le16_to_cpu(ladrf[2]); s->csr[10] = ladrf[2];
s->csr[11] = le16_to_cpu(ladrf[3]); s->csr[11] = ladrf[3];
s->csr[12] = le16_to_cpu(padr[0]); s->csr[12] = padr[0];
s->csr[13] = le16_to_cpu(padr[1]); s->csr[13] = padr[1];
s->csr[14] = le16_to_cpu(padr[2]); s->csr[14] = padr[2];
s->rdra = PHYSADDR(s, rdra); s->rdra = PHYSADDR(s, rdra);
s->tdra = PHYSADDR(s, tdra); s->tdra = PHYSADDR(s, tdra);
@ -914,12 +982,12 @@ static void pcnet_rdte_poll(PCNetState *s)
if (CSR_CRDA(s)) { if (CSR_CRDA(s)) {
struct pcnet_RMD rmd; struct pcnet_RMD rmd;
RMDLOAD(&rmd, PHYSADDR(s,CSR_CRDA(s))); RMDLOAD(&rmd, PHYSADDR(s,CSR_CRDA(s)));
CSR_CRBC(s) = rmd.rmd1.bcnt; CSR_CRBC(s) = GET_FIELD(rmd.buf_length, RMDL, BCNT);
CSR_CRST(s) = ((uint32_t *)&rmd)[1] >> 16; CSR_CRST(s) = rmd.status;
#ifdef PCNET_DEBUG_RMD_X #ifdef PCNET_DEBUG_RMD_X
printf("CRDA=0x%08x CRST=0x%04x RCVRC=%d RMD1=0x%08x RMD2=0x%08x\n", printf("CRDA=0x%08x CRST=0x%04x RCVRC=%d RMDL=0x%04x RMDS=0x%04x RMDM=0x%08x\n",
PHYSADDR(s,CSR_CRDA(s)), CSR_CRST(s), CSR_RCVRC(s), PHYSADDR(s,CSR_CRDA(s)), CSR_CRST(s), CSR_RCVRC(s),
((uint32_t *)&rmd)[1], ((uint32_t *)&rmd)[2]); rmd.buf_length, rmd.status, rmd.msg_length);
PRINT_RMD(&rmd); PRINT_RMD(&rmd);
#endif #endif
} else { } else {
@ -929,8 +997,8 @@ static void pcnet_rdte_poll(PCNetState *s)
if (CSR_NRDA(s)) { if (CSR_NRDA(s)) {
struct pcnet_RMD rmd; struct pcnet_RMD rmd;
RMDLOAD(&rmd, PHYSADDR(s,CSR_NRDA(s))); RMDLOAD(&rmd, PHYSADDR(s,CSR_NRDA(s)));
CSR_NRBC(s) = rmd.rmd1.bcnt; CSR_NRBC(s) = GET_FIELD(rmd.buf_length, RMDL, BCNT);
CSR_NRST(s) = ((uint32_t *)&rmd)[1] >> 16; CSR_NRST(s) = rmd.status;
} else { } else {
CSR_NRBC(s) = CSR_NRST(s) = 0; CSR_NRBC(s) = CSR_NRST(s) = 0;
} }
@ -943,7 +1011,7 @@ static int pcnet_tdte_poll(PCNetState *s)
if (s->tdra) { if (s->tdra) {
target_phys_addr_t cxda = s->tdra + target_phys_addr_t cxda = s->tdra +
(CSR_XMTRL(s) - CSR_XMTRC(s)) * (CSR_XMTRL(s) - CSR_XMTRC(s)) *
(BCR_SWSTYLE(s) ? 16 : 8 ); (BCR_SWSTYLE(s) ? 16 : 8);
int bad = 0; int bad = 0;
CHECK_TMD(PHYSADDR(s, cxda),bad); CHECK_TMD(PHYSADDR(s, cxda),bad);
if (!bad) { if (!bad) {
@ -955,8 +1023,7 @@ static int pcnet_tdte_poll(PCNetState *s)
} }
s->csr[34] = cxda & 0xffff; s->csr[34] = cxda & 0xffff;
s->csr[35] = cxda >> 16; s->csr[35] = cxda >> 16;
#ifdef PCNET_DEBUG #ifdef PCNET_DEBUG_X
} else {
printf("pcnet: BAD TMD XDA=0x%08x\n", PHYSADDR(s,cxda)); printf("pcnet: BAD TMD XDA=0x%08x\n", PHYSADDR(s,cxda));
#endif #endif
} }
@ -967,8 +1034,8 @@ static int pcnet_tdte_poll(PCNetState *s)
TMDLOAD(&tmd, PHYSADDR(s,CSR_CXDA(s))); TMDLOAD(&tmd, PHYSADDR(s,CSR_CXDA(s)));
CSR_CXBC(s) = tmd.tmd1.bcnt; CSR_CXBC(s) = GET_FIELD(tmd.length, TMDL, BCNT);
CSR_CXST(s) = ((uint32_t *)&tmd)[1] >> 16; CSR_CXST(s) = tmd.status;
} else { } else {
CSR_CXBC(s) = CSR_CXST(s) = 0; CSR_CXBC(s) = CSR_CXST(s) = 0;
} }
@ -1029,7 +1096,7 @@ static void pcnet_receive(void *opaque, const uint8_t *buf, int size)
(CSR_RCVRL(s) - rcvrc) * (CSR_RCVRL(s) - rcvrc) *
(BCR_SWSTYLE(s) ? 16 : 8 ); (BCR_SWSTYLE(s) ? 16 : 8 );
RMDLOAD(&rmd, PHYSADDR(s,nrda)); RMDLOAD(&rmd, PHYSADDR(s,nrda));
if (rmd.rmd1.own) { if (GET_FIELD(rmd.status, RMDS, OWN)) {
#ifdef PCNET_DEBUG_RMD #ifdef PCNET_DEBUG_RMD
printf("pcnet - scan buffer: RCVRC=%d PREV_RCVRC=%d\n", printf("pcnet - scan buffer: RCVRC=%d PREV_RCVRC=%d\n",
rcvrc, CSR_RCVRC(s)); rcvrc, CSR_RCVRC(s));
@ -1086,14 +1153,15 @@ static void pcnet_receive(void *opaque, const uint8_t *buf, int size)
RMDLOAD(&rmd, PHYSADDR(s,crda)); RMDLOAD(&rmd, PHYSADDR(s,crda));
/*if (!CSR_LAPPEN(s))*/ /*if (!CSR_LAPPEN(s))*/
rmd.rmd1.stp = 1; SET_FIELD(&rmd.status, RMDS, STP, 1);
#define PCNET_RECV_STORE() do { \ #define PCNET_RECV_STORE() do { \
int count = MIN(4096 - rmd.rmd1.bcnt,size); \ int count = MIN(4096 - GET_FIELD(rmd.buf_length, RMDL, BCNT),size); \
target_phys_addr_t rbadr = PHYSADDR(s, rmd.rmd0.rbadr); \ target_phys_addr_t rbadr = PHYSADDR(s, rmd.rbadr); \
s->phys_mem_write(s->dma_opaque, rbadr, src, count, CSR_BSWP(s)); \ s->phys_mem_write(s->dma_opaque, rbadr, src, count, CSR_BSWP(s)); \
src += count; size -= count; \ src += count; size -= count; \
rmd.rmd2.mcnt = count; rmd.rmd1.own = 0; \ SET_FIELD(&rmd.msg_length, RMDM, MCNT, count); \
SET_FIELD(&rmd.status, RMDS, OWN, 0); \
RMDSTORE(&rmd, PHYSADDR(s,crda)); \ RMDSTORE(&rmd, PHYSADDR(s,crda)); \
pktcount++; \ pktcount++; \
} while (0) } while (0)
@ -1102,12 +1170,12 @@ static void pcnet_receive(void *opaque, const uint8_t *buf, int size)
if ((size > 0) && CSR_NRDA(s)) { if ((size > 0) && CSR_NRDA(s)) {
target_phys_addr_t nrda = CSR_NRDA(s); target_phys_addr_t nrda = CSR_NRDA(s);
RMDLOAD(&rmd, PHYSADDR(s,nrda)); RMDLOAD(&rmd, PHYSADDR(s,nrda));
if (rmd.rmd1.own) { if (GET_FIELD(rmd.status, RMDS, OWN)) {
crda = nrda; crda = nrda;
PCNET_RECV_STORE(); PCNET_RECV_STORE();
if ((size > 0) && (nrda=CSR_NNRD(s))) { if ((size > 0) && (nrda=CSR_NNRD(s))) {
RMDLOAD(&rmd, PHYSADDR(s,nrda)); RMDLOAD(&rmd, PHYSADDR(s,nrda));
if (rmd.rmd1.own) { if (GET_FIELD(rmd.status, RMDS, OWN)) {
crda = nrda; crda = nrda;
PCNET_RECV_STORE(); PCNET_RECV_STORE();
} }
@ -1119,14 +1187,14 @@ static void pcnet_receive(void *opaque, const uint8_t *buf, int size)
RMDLOAD(&rmd, PHYSADDR(s,crda)); RMDLOAD(&rmd, PHYSADDR(s,crda));
if (size == 0) { if (size == 0) {
rmd.rmd1.enp = 1; SET_FIELD(&rmd.status, RMDS, ENP, 1);
rmd.rmd1.pam = !CSR_PROM(s) && is_padr; SET_FIELD(&rmd.status, RMDS, PAM, !CSR_PROM(s) && is_padr);
rmd.rmd1.lafm = !CSR_PROM(s) && is_ladr; SET_FIELD(&rmd.status, RMDS, LFAM, !CSR_PROM(s) && is_ladr);
rmd.rmd1.bam = !CSR_PROM(s) && is_bcast; SET_FIELD(&rmd.status, RMDS, BAM, !CSR_PROM(s) && is_bcast);
} else { } else {
rmd.rmd1.oflo = 1; SET_FIELD(&rmd.status, RMDS, OFLO, 1);
rmd.rmd1.buff = 1; SET_FIELD(&rmd.status, RMDS, BUFF, 1);
rmd.rmd1.err = 1; SET_FIELD(&rmd.status, RMDS, ERR, 1);
} }
RMDSTORE(&rmd, PHYSADDR(s,crda)); RMDSTORE(&rmd, PHYSADDR(s,crda));
s->csr[0] |= 0x0400; s->csr[0] |= 0x0400;
@ -1172,30 +1240,30 @@ static void pcnet_transmit(PCNetState *s)
if (pcnet_tdte_poll(s)) { if (pcnet_tdte_poll(s)) {
struct pcnet_TMD tmd; struct pcnet_TMD tmd;
TMDLOAD(&tmd, PHYSADDR(s,CSR_CXDA(s))); TMDLOAD(&tmd, PHYSADDR(s,CSR_CXDA(s)));
#ifdef PCNET_DEBUG_TMD #ifdef PCNET_DEBUG_TMD
printf(" TMDLOAD 0x%08x\n", PHYSADDR(s,CSR_CXDA(s))); printf(" TMDLOAD 0x%08x\n", PHYSADDR(s,CSR_CXDA(s)));
PRINT_TMD(&tmd); PRINT_TMD(&tmd);
#endif #endif
if (tmd.tmd1.stp) { if (GET_FIELD(tmd.status, TMDS, STP)) {
s->xmit_pos = 0; s->xmit_pos = 0;
if (!tmd.tmd1.enp) { if (!GET_FIELD(tmd.status, TMDS, ENP)) {
s->phys_mem_read(s->dma_opaque, PHYSADDR(s, tmd.tmd0.tbadr), int bcnt = 4096 - GET_FIELD(tmd.length, TMDL, BCNT);
s->buffer, 4096 - tmd.tmd1.bcnt, s->phys_mem_read(s->dma_opaque, PHYSADDR(s, tmd.tbadr),
CSR_BSWP(s)); s->buffer, bcnt, CSR_BSWP(s));
s->xmit_pos += 4096 - tmd.tmd1.bcnt; s->xmit_pos += bcnt;
} }
xmit_cxda = PHYSADDR(s,CSR_CXDA(s)); xmit_cxda = PHYSADDR(s,CSR_CXDA(s));
} }
if (tmd.tmd1.enp && (s->xmit_pos >= 0)) { if (GET_FIELD(tmd.status, TMDS, ENP) && (s->xmit_pos >= 0)) {
s->phys_mem_read(s->dma_opaque, PHYSADDR(s, tmd.tmd0.tbadr), int bcnt = 4096 - GET_FIELD(tmd.length, TMDL, BCNT);
s->buffer + s->xmit_pos, 4096 - tmd.tmd1.bcnt, s->phys_mem_read(s->dma_opaque, PHYSADDR(s, tmd.tbadr),
CSR_BSWP(s)); s->buffer + s->xmit_pos, bcnt, CSR_BSWP(s));
s->xmit_pos += 4096 - tmd.tmd1.bcnt; s->xmit_pos += bcnt;
#ifdef PCNET_DEBUG #ifdef PCNET_DEBUG
printf("pcnet_transmit size=%d\n", s->xmit_pos); printf("pcnet_transmit size=%d\n", s->xmit_pos);
#endif #endif
if (CSR_LOOP(s)) if (CSR_LOOP(s))
pcnet_receive(s, s->buffer, s->xmit_pos); pcnet_receive(s, s->buffer, s->xmit_pos);
else else
@ -1206,9 +1274,9 @@ static void pcnet_transmit(PCNetState *s)
s->xmit_pos = -1; s->xmit_pos = -1;
} }
tmd.tmd1.own = 0; SET_FIELD(&tmd.status, TMDS, OWN, 0);
TMDSTORE(&tmd, PHYSADDR(s,CSR_CXDA(s))); TMDSTORE(&tmd, PHYSADDR(s,CSR_CXDA(s)));
if (!CSR_TOKINTD(s) || (CSR_LTINTEN(s) && tmd.tmd1.ltint)) if (!CSR_TOKINTD(s) || (CSR_LTINTEN(s) && GET_FIELD(tmd.status, TMDS, LTINT)))
s->csr[0] |= 0x0200; /* set TINT */ s->csr[0] |= 0x0200; /* set TINT */
if (CSR_XMTRC(s)<=1) if (CSR_XMTRC(s)<=1)
@ -1221,9 +1289,11 @@ static void pcnet_transmit(PCNetState *s)
} else } else
if (s->xmit_pos >= 0) { if (s->xmit_pos >= 0) {
struct pcnet_TMD tmd; struct pcnet_TMD tmd;
TMDLOAD(&tmd, PHYSADDR(s,xmit_cxda)); TMDLOAD(&tmd, PHYSADDR(s,xmit_cxda));
tmd.tmd2.buff = tmd.tmd2.uflo = tmd.tmd1.err = 1; SET_FIELD(&tmd.misc, TMDM, BUFF, 1);
tmd.tmd1.own = 0; SET_FIELD(&tmd.misc, TMDM, UFLO, 1);
SET_FIELD(&tmd.status, TMDS, ERR, 1);
SET_FIELD(&tmd.status, TMDS, OWN, 0);
TMDSTORE(&tmd, PHYSADDR(s,xmit_cxda)); TMDSTORE(&tmd, PHYSADDR(s,xmit_cxda));
s->csr[0] |= 0x0200; /* set TINT */ s->csr[0] |= 0x0200; /* set TINT */
if (!CSR_DXSUFLO(s)) { if (!CSR_DXSUFLO(s)) {