vcs.maemo.org Git - qemu/blob - hw/pcnet.c

   1 /*
   2  * QEMU AMD PC-Net II (Am79C970A) emulation
   3  *
   4  * Copyright (c) 2004 Antony T Curtis
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 /* This software was written to be compatible with the specification:
  26  * AMD Am79C970A PCnet-PCI II Ethernet Controller Data-Sheet
  27  * AMD Publication# 19436  Rev:E  Amendment/0  Issue Date: June 2000
  28  */
  29
  30 #include "vl.h"
  31
  32 //#define PCNET_DEBUG
  33 //#define PCNET_DEBUG_IO
  34 //#define PCNET_DEBUG_BCR
  35 //#define PCNET_DEBUG_CSR
  36 //#define PCNET_DEBUG_RMD
  37 //#define PCNET_DEBUG_TMD
  38 //#define PCNET_DEBUG_MATCH
  39
  40
  41 #define PCNET_IOPORT_SIZE       0x20
  42 #define PCNET_PNPMMIO_SIZE      0x20
  43
  44
  45 typedef struct PCNetState_st PCNetState;
  46
  47 struct PCNetState_st {
  48     PCIDevice dev;
  49     VLANClientState *vc;
  50     NICInfo *nd;
  51     QEMUTimer *poll_timer;
  52     int mmio_io_addr, rap, isr, lnkst;
  53     target_phys_addr_t rdra, tdra;
  54     uint8_t prom[16];
  55     uint16_t csr[128];
  56     uint16_t bcr[32];
  57     uint64_t timer;
  58     int xmit_pos, recv_pos;
  59     uint8_t buffer[4096];
  60     int tx_busy;
  61 };
  62
  63 /* XXX: using bitfields for target memory structures is almost surely
  64    not portable, so it should be suppressed ASAP */
  65 #ifdef __GNUC__
  66 #define PACKED_FIELD(A) A __attribute__ ((packed))
  67 #else
  68 #error FixMe
  69 #endif
  70
  71 struct qemu_ether_header {
  72     uint8_t ether_dhost[6];
  73     uint8_t ether_shost[6];
  74     uint16_t ether_type;
  75 };
  76
  77 /* BUS CONFIGURATION REGISTERS */
  78 #define BCR_MSRDA    0
  79 #define BCR_MSWRA    1
  80 #define BCR_MC       2
  81 #define BCR_LNKST    4
  82 #define BCR_LED1     5
  83 #define BCR_LED2     6
  84 #define BCR_LED3     7
  85 #define BCR_FDC      9
  86 #define BCR_BSBC     18
  87 #define BCR_EECAS    19
  88 #define BCR_SWS      20
  89 #define BCR_PLAT     22
  90
  91 #define BCR_DWIO(S)      !!((S)->bcr[BCR_BSBC] & 0x0080)
  92 #define BCR_SSIZE32(S)   !!((S)->bcr[BCR_SWS ] & 0x0100)
  93 #define BCR_SWSTYLE(S)     ((S)->bcr[BCR_SWS ] & 0x00FF)
  94
  95 #define CSR_INIT(S)      !!(((S)->csr[0])&0x0001)
  96 #define CSR_STRT(S)      !!(((S)->csr[0])&0x0002)
  97 #define CSR_STOP(S)      !!(((S)->csr[0])&0x0004)
  98 #define CSR_TDMD(S)      !!(((S)->csr[0])&0x0008)
  99 #define CSR_TXON(S)      !!(((S)->csr[0])&0x0010)
 100 #define CSR_RXON(S)      !!(((S)->csr[0])&0x0020)
 101 #define CSR_INEA(S)      !!(((S)->csr[0])&0x0040)
 102 #define CSR_LAPPEN(S)    !!(((S)->csr[3])&0x0020)
 103 #define CSR_DXSUFLO(S)   !!(((S)->csr[3])&0x0040)
 104 #define CSR_ASTRP_RCV(S) !!(((S)->csr[4])&0x0800)
 105 #define CSR_DPOLL(S)     !!(((S)->csr[4])&0x1000)
 106 #define CSR_SPND(S)      !!(((S)->csr[5])&0x0001)
 107 #define CSR_LTINTEN(S)   !!(((S)->csr[5])&0x4000)
 108 #define CSR_TOKINTD(S)   !!(((S)->csr[5])&0x8000)
 109 #define CSR_DRX(S)       !!(((S)->csr[15])&0x0001)
 110 #define CSR_DTX(S)       !!(((S)->csr[15])&0x0002)
 111 #define CSR_LOOP(S)      !!(((S)->csr[15])&0x0004)
 112 #define CSR_DRCVPA(S)    !!(((S)->csr[15])&0x2000)
 113 #define CSR_DRCVBC(S)    !!(((S)->csr[15])&0x4000)
 114 #define CSR_PROM(S)      !!(((S)->csr[15])&0x8000)
 115
 116 #define CSR_CRBC(S)      ((S)->csr[40])
 117 #define CSR_CRST(S)      ((S)->csr[41])
 118 #define CSR_CXBC(S)      ((S)->csr[42])
 119 #define CSR_CXST(S)      ((S)->csr[43])
 120 #define CSR_NRBC(S)      ((S)->csr[44])
 121 #define CSR_NRST(S)      ((S)->csr[45])
 122 #define CSR_POLL(S)      ((S)->csr[46])
 123 #define CSR_PINT(S)      ((S)->csr[47])
 124 #define CSR_RCVRC(S)     ((S)->csr[72])
 125 #define CSR_XMTRC(S)     ((S)->csr[74])
 126 #define CSR_RCVRL(S)     ((S)->csr[76])
 127 #define CSR_XMTRL(S)     ((S)->csr[78])
 128 #define CSR_MISSC(S)     ((S)->csr[112])
 129
 130 #define CSR_IADR(S)      ((S)->csr[ 1] | ((S)->csr[ 2] << 16))
 131 #define CSR_CRBA(S)      ((S)->csr[18] | ((S)->csr[19] << 16))
 132 #define CSR_CXBA(S)      ((S)->csr[20] | ((S)->csr[21] << 16))
 133 #define CSR_NRBA(S)      ((S)->csr[22] | ((S)->csr[23] << 16))
 134 #define CSR_BADR(S)      ((S)->csr[24] | ((S)->csr[25] << 16))
 135 #define CSR_NRDA(S)      ((S)->csr[26] | ((S)->csr[27] << 16))
 136 #define CSR_CRDA(S)      ((S)->csr[28] | ((S)->csr[29] << 16))
 137 #define CSR_BADX(S)      ((S)->csr[30] | ((S)->csr[31] << 16))
 138 #define CSR_NXDA(S)      ((S)->csr[32] | ((S)->csr[33] << 16))
 139 #define CSR_CXDA(S)      ((S)->csr[34] | ((S)->csr[35] << 16))
 140 #define CSR_NNRD(S)      ((S)->csr[36] | ((S)->csr[37] << 16))
 141 #define CSR_NNXD(S)      ((S)->csr[38] | ((S)->csr[39] << 16))
 142 #define CSR_PXDA(S)      ((S)->csr[60] | ((S)->csr[61] << 16))
 143 #define CSR_NXBA(S)      ((S)->csr[64] | ((S)->csr[65] << 16))
 144
 145 #define PHYSADDR(S,A) \
 146   (BCR_SSIZE32(S) ? (A) : (A) | ((0xff00 & (uint32_t)(s)->csr[2])<<16))
 147
 148 struct pcnet_initblk16 {
 149     uint16_t mode;
 150     uint16_t padr1;
 151     uint16_t padr2;
 152     uint16_t padr3;
 153     uint16_t ladrf1;
 154     uint16_t ladrf2;
 155     uint16_t ladrf3;
 156     uint16_t ladrf4;
 157     unsigned PACKED_FIELD(rdra:24);
 158     unsigned PACKED_FIELD(res1:5);
 159     unsigned PACKED_FIELD(rlen:3);
 160     unsigned PACKED_FIELD(tdra:24);
 161     unsigned PACKED_FIELD(res2:5);
 162     unsigned PACKED_FIELD(tlen:3);
 163 };
 164
 165 struct pcnet_initblk32 {
 166     uint16_t mode;
 167     unsigned PACKED_FIELD(res1:4);
 168     unsigned PACKED_FIELD(rlen:4);
 169     unsigned PACKED_FIELD(res2:4);
 170     unsigned PACKED_FIELD(tlen:4);
 171     uint16_t padr1;
 172     uint16_t padr2;
 173     uint16_t padr3;
 174     uint16_t _res;
 175     uint16_t ladrf1;
 176     uint16_t ladrf2;
 177     uint16_t ladrf3;
 178     uint16_t ladrf4;
 179     uint32_t rdra;
 180     uint32_t tdra;
 181 };
 182
 183 struct pcnet_TMD {
 184     struct {
 185         unsigned tbadr:32;
 186     } tmd0;
 187     struct {
 188         unsigned PACKED_FIELD(bcnt:12), PACKED_FIELD(ones:4), PACKED_FIELD(res:7), PACKED_FIELD(bpe:1);
 189         unsigned PACKED_FIELD(enp:1), PACKED_FIELD(stp:1), PACKED_FIELD(def:1), PACKED_FIELD(one:1);
 190         unsigned PACKED_FIELD(ltint:1), PACKED_FIELD(nofcs:1), PACKED_FIELD(err:1), PACKED_FIELD(own:1);
 191     } tmd1;
 192     struct {
 193         unsigned PACKED_FIELD(trc:4), PACKED_FIELD(res:12);
 194         unsigned PACKED_FIELD(tdr:10), PACKED_FIELD(rtry:1), PACKED_FIELD(lcar:1);
 195         unsigned PACKED_FIELD(lcol:1), PACKED_FIELD(exdef:1), PACKED_FIELD(uflo:1), PACKED_FIELD(buff:1);
 196     } tmd2;
 197     struct {
 198         unsigned res:32;
 199     } tmd3;
 200 };
 201
 202 struct pcnet_RMD {
 203     struct {
 204         unsigned rbadr:32;
 205     } rmd0;
 206     struct {
 207         unsigned PACKED_FIELD(bcnt:12), PACKED_FIELD(ones:4), PACKED_FIELD(res:4);
 208         unsigned PACKED_FIELD(bam:1), PACKED_FIELD(lafm:1), PACKED_FIELD(pam:1), PACKED_FIELD(bpe:1);
 209         unsigned PACKED_FIELD(enp:1), PACKED_FIELD(stp:1), PACKED_FIELD(buff:1), PACKED_FIELD(crc:1);
 210         unsigned PACKED_FIELD(oflo:1), PACKED_FIELD(fram:1), PACKED_FIELD(err:1), PACKED_FIELD(own:1);
 211     } rmd1;
 212     struct {
 213         unsigned PACKED_FIELD(mcnt:12), PACKED_FIELD(zeros:4);
 214         unsigned PACKED_FIELD(rpc:8), PACKED_FIELD(rcc:8);
 215     } rmd2;
 216     struct {
 217         unsigned res:32;
 218     } rmd3;
 219 };
 220
 221
 222 #define PRINT_TMD(T) printf(    \
 223         "TMD0 : TBADR=0x%08x\n" \
 224         "TMD1 : OWN=%d, ERR=%d, FCS=%d, LTI=%d, "       \
 225         "ONE=%d, DEF=%d, STP=%d, ENP=%d,\n"             \
 226         "       BPE=%d, BCNT=%d\n"                      \
 227         "TMD2 : BUF=%d, UFL=%d, EXD=%d, LCO=%d, "       \
 228         "LCA=%d, RTR=%d,\n"                             \
 229         "       TDR=%d, TRC=%d\n",                      \
 230         (T)->tmd0.tbadr,                                \
 231         (T)->tmd1.own, (T)->tmd1.err, (T)->tmd1.nofcs,  \
 232         (T)->tmd1.ltint, (T)->tmd1.one, (T)->tmd1.def,  \
 233         (T)->tmd1.stp, (T)->tmd1.enp, (T)->tmd1.bpe,    \
 234         4096-(T)->tmd1.bcnt,                            \
 235         (T)->tmd2.buff, (T)->tmd2.uflo, (T)->tmd2.exdef,\
 236         (T)->tmd2.lcol, (T)->tmd2.lcar, (T)->tmd2.rtry, \
 237         (T)->tmd2.tdr, (T)->tmd2.trc)
 238
 239 #define PRINT_RMD(R) printf(    \
 240         "RMD0 : RBADR=0x%08x\n" \
 241         "RMD1 : OWN=%d, ERR=%d, FRAM=%d, OFLO=%d, "     \
 242         "CRC=%d, BUFF=%d, STP=%d, ENP=%d,\n       "     \
 243         "BPE=%d, PAM=%d, LAFM=%d, BAM=%d, ONES=%d, BCNT=%d\n"    \
 244         "RMD2 : RCC=%d, RPC=%d, MCNT=%d, ZEROS=%d\n",   \
 245         (R)->rmd0.rbadr,                                \
 246         (R)->rmd1.own, (R)->rmd1.err, (R)->rmd1.fram,   \
 247         (R)->rmd1.oflo, (R)->rmd1.crc, (R)->rmd1.buff,  \
 248         (R)->rmd1.stp, (R)->rmd1.enp, (R)->rmd1.bpe,    \
 249         (R)->rmd1.pam, (R)->rmd1.lafm, (R)->rmd1.bam,   \
 250         (R)->rmd1.ones, 4096-(R)->rmd1.bcnt,            \
 251         (R)->rmd2.rcc, (R)->rmd2.rpc, (R)->rmd2.mcnt,   \
 252         (R)->rmd2.zeros)
 253
 254 static inline void pcnet_tmd_load(PCNetState *s, struct pcnet_TMD *tmd, target_phys_addr_t addr)
 255 {
 256     if (!BCR_SWSTYLE(s)) {
 257         uint16_t xda[4];
 258         cpu_physical_memory_read(addr,
 259                 (void *)&xda[0], sizeof(xda));
 260         ((uint32_t *)tmd)[0] = (xda[0]&0xffff) |
 261                 ((xda[1]&0x00ff) << 16);
 262         ((uint32_t *)tmd)[1] = (xda[2]&0xffff)|
 263                 ((xda[1] & 0xff00) << 16);
 264         ((uint32_t *)tmd)[2] =
 265                 (xda[3] & 0xffff) << 16;
 266         ((uint32_t *)tmd)[3] = 0;
 267     }
 268     else
 269     if (BCR_SWSTYLE(s) != 3)
 270         cpu_physical_memory_read(addr, (void *)tmd, 16);
 271     else {
 272         uint32_t xda[4];
 273         cpu_physical_memory_read(addr,
 274                 (void *)&xda[0], sizeof(xda));
 275         ((uint32_t *)tmd)[0] = xda[2];
 276         ((uint32_t *)tmd)[1] = xda[1];
 277         ((uint32_t *)tmd)[2] = xda[0];
 278         ((uint32_t *)tmd)[3] = xda[3];
 279     }
 280 }
 281
 282 static inline void pcnet_tmd_store(PCNetState *s, struct pcnet_TMD *tmd, target_phys_addr_t addr)
 283 {
 284     if (!BCR_SWSTYLE(s)) {
 285         uint16_t xda[4];
 286         xda[0] = ((uint32_t *)tmd)[0] & 0xffff;
 287         xda[1] = ((((uint32_t *)tmd)[0]>>16)&0x00ff) |
 288             ((((uint32_t *)tmd)[1]>>16)&0xff00);
 289         xda[2] = ((uint32_t *)tmd)[1] & 0xffff;
 290         xda[3] = ((uint32_t *)tmd)[2] >> 16;
 291         cpu_physical_memory_write(addr,
 292                 (void *)&xda[0], sizeof(xda));
 293     }
 294     else {
 295         if (BCR_SWSTYLE(s) != 3)
 296             cpu_physical_memory_write(addr, (void *)tmd, 16);
 297         else {
 298             uint32_t xda[4];
 299             xda[0] = ((uint32_t *)tmd)[2];
 300             xda[1] = ((uint32_t *)tmd)[1];
 301             xda[2] = ((uint32_t *)tmd)[0];
 302             xda[3] = ((uint32_t *)tmd)[3];
 303             cpu_physical_memory_write(addr,
 304                     (void *)&xda[0], sizeof(xda));
 305         }
 306     }
 307 }
 308
 309 static inline void pcnet_rmd_load(PCNetState *s, struct pcnet_RMD *rmd, target_phys_addr_t addr)
 310 {
 311     if (!BCR_SWSTYLE(s)) {
 312         uint16_t rda[4];
 313         cpu_physical_memory_read(addr,
 314                 (void *)&rda[0], sizeof(rda));
 315         ((uint32_t *)rmd)[0] = (rda[0]&0xffff)|
 316                 ((rda[1] & 0x00ff) << 16);
 317         ((uint32_t *)rmd)[1] = (rda[2]&0xffff)|
 318                 ((rda[1] & 0xff00) << 16);
 319         ((uint32_t *)rmd)[2] = rda[3] & 0xffff;
 320         ((uint32_t *)rmd)[3] = 0;
 321     }
 322     else
 323     if (BCR_SWSTYLE(s) != 3)
 324         cpu_physical_memory_read(addr, (void *)rmd, 16);
 325     else {
 326         uint32_t rda[4];
 327         cpu_physical_memory_read(addr,
 328                 (void *)&rda[0], sizeof(rda));
 329         ((uint32_t *)rmd)[0] = rda[2];
 330         ((uint32_t *)rmd)[1] = rda[1];
 331         ((uint32_t *)rmd)[2] = rda[0];
 332         ((uint32_t *)rmd)[3] = rda[3];
 333     }
 334 }
 335
 336 static inline void pcnet_rmd_store(PCNetState *s, struct pcnet_RMD *rmd, target_phys_addr_t addr)
 337 {
 338     if (!BCR_SWSTYLE(s)) {
 339         uint16_t rda[4];                        \
 340         rda[0] = ((uint32_t *)rmd)[0] & 0xffff; \
 341         rda[1] = ((((uint32_t *)rmd)[0]>>16)&0xff)|\
 342             ((((uint32_t *)rmd)[1]>>16)&0xff00);\
 343         rda[2] = ((uint32_t *)rmd)[1] & 0xffff; \
 344         rda[3] = ((uint32_t *)rmd)[2] & 0xffff; \
 345         cpu_physical_memory_write(addr,         \
 346                 (void *)&rda[0], sizeof(rda));  \
 347     }
 348     else {
 349         if (BCR_SWSTYLE(s) != 3)
 350             cpu_physical_memory_write(addr, (void *)rmd, 16);
 351         else {
 352             uint32_t rda[4];
 353             rda[0] = ((uint32_t *)rmd)[2];
 354             rda[1] = ((uint32_t *)rmd)[1];
 355             rda[2] = ((uint32_t *)rmd)[0];
 356             rda[3] = ((uint32_t *)rmd)[3];
 357             cpu_physical_memory_write(addr,
 358                     (void *)&rda[0], sizeof(rda));
 359         }
 360     }
 361 }
 362
 363
 364 #define TMDLOAD(TMD,ADDR) pcnet_tmd_load(s,TMD,ADDR)
 365
 366 #define TMDSTORE(TMD,ADDR) pcnet_tmd_store(s,TMD,ADDR)
 367
 368 #define RMDLOAD(RMD,ADDR) pcnet_rmd_load(s,RMD,ADDR)
 369
 370 #define RMDSTORE(RMD,ADDR) pcnet_rmd_store(s,RMD,ADDR)
 371
 372 #if 1
 373
 374 #define CHECK_RMD(ADDR,RES) do {                \
 375     struct pcnet_RMD rmd;                       \
 376     RMDLOAD(&rmd,(ADDR));                       \
 377     (RES) |= (rmd.rmd1.ones != 15)              \
 378           || (rmd.rmd2.zeros != 0);             \
 379 } while (0)
 380
 381 #define CHECK_TMD(ADDR,RES) do {                \
 382     struct pcnet_TMD tmd;                       \
 383     TMDLOAD(&tmd,(ADDR));                       \
 384     (RES) |= (tmd.tmd1.ones != 15);             \
 385 } while (0)
 386
 387 #else
 388
 389 #define CHECK_RMD(ADDR,RES) do {                \
 390     switch (BCR_SWSTYLE(s)) {                   \
 391     case 0x00:                                  \
 392         do {                                    \
 393             uint16_t rda[4];                    \
 394             cpu_physical_memory_read((ADDR),    \
 395                 (void *)&rda[0], sizeof(rda));  \
 396             (RES) |= (rda[2] & 0xf000)!=0xf000; \
 397             (RES) |= (rda[3] & 0xf000)!=0x0000; \
 398         } while (0);                            \
 399         break;                                  \
 400     case 0x01:                                  \
 401     case 0x02:                                  \
 402         do {                                    \
 403             uint32_t rda[4];                    \
 404             cpu_physical_memory_read((ADDR),    \
 405                 (void *)&rda[0], sizeof(rda)); \
 406             (RES) |= (rda[1] & 0x0000f000L)!=0x0000f000L; \
 407             (RES) |= (rda[2] & 0x0000f000L)!=0x00000000L; \
 408         } while (0);                            \
 409         break;                                  \
 410     case 0x03:                                  \
 411         do {                                    \
 412             uint32_t rda[4];                    \
 413             cpu_physical_memory_read((ADDR),    \
 414                 (void *)&rda[0], sizeof(rda)); \
 415             (RES) |= (rda[0] & 0x0000f000L)!=0x00000000L; \
 416             (RES) |= (rda[1] & 0x0000f000L)!=0x0000f000L; \
 417         } while (0);                            \
 418         break;                                  \
 419     }                                           \
 420 } while (0)
 421
 422 #define CHECK_TMD(ADDR,RES) do {                \
 423     switch (BCR_SWSTYLE(s)) {                   \
 424     case 0x00:                                  \
 425         do {                                    \
 426             uint16_t xda[4];                    \
 427             cpu_physical_memory_read((ADDR),    \
 428                 (void *)&xda[0], sizeof(xda));  \
 429             (RES) |= (xda[2] & 0xf000)!=0xf000;\
 430         } while (0);                            \
 431         break;                                  \
 432     case 0x01:                                  \
 433     case 0x02:                                  \
 434     case 0x03:                                  \
 435         do {                                    \
 436             uint32_t xda[4];                    \
 437             cpu_physical_memory_read((ADDR),    \
 438                 (void *)&xda[0], sizeof(xda));  \
 439             (RES) |= (xda[1] & 0x0000f000L)!=0x0000f000L; \
 440         } while (0);                            \
 441         break;                                  \
 442     }                                           \
 443 } while (0)
 444
 445 #endif
 446
 447 #define PRINT_PKTHDR(BUF) do {                  \
 448     struct qemu_ether_header *hdr = (void *)(BUF);   \
 449     printf("packet dhost=%02x:%02x:%02x:%02x:%02x:%02x, "       \
 450            "shost=%02x:%02x:%02x:%02x:%02x:%02x, "              \
 451            "type=0x%04x (bcast=%d)\n",                          \
 452            hdr->ether_dhost[0],hdr->ether_dhost[1],hdr->ether_dhost[2], \
 453            hdr->ether_dhost[3],hdr->ether_dhost[4],hdr->ether_dhost[5], \
 454            hdr->ether_shost[0],hdr->ether_shost[1],hdr->ether_shost[2], \
 455            hdr->ether_shost[3],hdr->ether_shost[4],hdr->ether_shost[5], \
 456            be16_to_cpu(hdr->ether_type),                                \
 457            !!ETHER_IS_MULTICAST(hdr->ether_dhost));                     \
 458 } while (0)
 459
 460 #define MULTICAST_FILTER_LEN 8
 461
 462 static inline uint32_t lnc_mchash(const uint8_t *ether_addr)
 463 {
 464 #define LNC_POLYNOMIAL          0xEDB88320UL
 465     uint32_t crc = 0xFFFFFFFF;
 466     int idx, bit;
 467     uint8_t data;
 468
 469     for (idx = 0; idx < 6; idx++) {
 470         for (data = *ether_addr++, bit = 0; bit < MULTICAST_FILTER_LEN; bit++) {
 471             crc = (crc >> 1) ^ (((crc ^ data) & 1) ? LNC_POLYNOMIAL : 0);
 472             data >>= 1;
 473         }
 474     }
 475     return crc;
 476 #undef LNC_POLYNOMIAL
 477 }
 478
 479 #define CRC(crc, ch)     (crc = (crc >> 8) ^ crctab[(crc ^ (ch)) & 0xff])
 480
 481 /* generated using the AUTODIN II polynomial
 482  *      x^32 + x^26 + x^23 + x^22 + x^16 +
 483  *      x^12 + x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x^1 + 1
 484  */
 485 static const uint32_t crctab[256] = {
 486         0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
 487         0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
 488         0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
 489         0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
 490         0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
 491         0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
 492         0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
 493         0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
 494         0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
 495         0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
 496         0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
 497         0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
 498         0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
 499         0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
 500         0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
 501         0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
 502         0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
 503         0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
 504         0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
 505         0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
 506         0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
 507         0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
 508         0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
 509         0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
 510         0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
 511         0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
 512         0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
 513         0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
 514         0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
 515         0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
 516         0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
 517         0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
 518         0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
 519         0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
 520         0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
 521         0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
 522         0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
 523         0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
 524         0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
 525         0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
 526         0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
 527         0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
 528         0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
 529         0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
 530         0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
 531         0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
 532         0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
 533         0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
 534         0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
 535         0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
 536         0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
 537         0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
 538         0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
 539         0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
 540         0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
 541         0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
 542         0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
 543         0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
 544         0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
 545         0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
 546         0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
 547         0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
 548         0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
 549         0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
 550 };
 551
 552 static inline int padr_match(PCNetState *s, const uint8_t *buf, int size)
 553 {
 554     struct qemu_ether_header *hdr = (void *)buf;
 555     uint8_t padr[6] = {
 556         s->csr[12] & 0xff, s->csr[12] >> 8,
 557         s->csr[13] & 0xff, s->csr[13] >> 8,
 558         s->csr[14] & 0xff, s->csr[14] >> 8
 559     };
 560     int result = (!CSR_DRCVPA(s)) && !memcmp(hdr->ether_dhost, padr, 6);
 561 #ifdef PCNET_DEBUG_MATCH
 562     printf("packet dhost=%02x:%02x:%02x:%02x:%02x:%02x, "
 563            "padr=%02x:%02x:%02x:%02x:%02x:%02x\n",
 564            hdr->ether_dhost[0],hdr->ether_dhost[1],hdr->ether_dhost[2],
 565            hdr->ether_dhost[3],hdr->ether_dhost[4],hdr->ether_dhost[5],
 566            padr[0],padr[1],padr[2],padr[3],padr[4],padr[5]);
 567     printf("padr_match result=%d\n", result);
 568 #endif
 569     return result;
 570 }
 571
 572 static inline int padr_bcast(PCNetState *s, const uint8_t *buf, int size)
 573 {
 574     static uint8_t BCAST[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 575     struct qemu_ether_header *hdr = (void *)buf;
 576     int result = !CSR_DRCVBC(s) && !memcmp(hdr->ether_dhost, BCAST, 6);
 577 #ifdef PCNET_DEBUG_MATCH
 578     printf("padr_bcast result=%d\n", result);
 579 #endif
 580     return result;
 581 }
 582
 583 static inline int ladr_match(PCNetState *s, const uint8_t *buf, int size)
 584 {
 585     struct qemu_ether_header *hdr = (void *)buf;
 586     if ((*(hdr->ether_dhost)&0x01) &&
 587         ((uint64_t *)&s->csr[8])[0] != 0LL) {
 588         uint8_t ladr[8] = {
 589             s->csr[8] & 0xff, s->csr[8] >> 8,
 590             s->csr[9] & 0xff, s->csr[9] >> 8,
 591             s->csr[10] & 0xff, s->csr[10] >> 8,
 592             s->csr[11] & 0xff, s->csr[11] >> 8
 593         };
 594         int index = lnc_mchash(hdr->ether_dhost) >> 26;
 595         return !!(ladr[index >> 3] & (1 << (index & 7)));
 596     }
 597     return 0;
 598 }
 599
 600 static inline target_phys_addr_t pcnet_rdra_addr(PCNetState *s, int idx)
 601 {
 602     while (idx < 1) idx += CSR_RCVRL(s);
 603     return s->rdra + ((CSR_RCVRL(s) - idx) * (BCR_SWSTYLE(s) ? 16 : 8));
 604 }
 605
 606 static inline int64_t pcnet_get_next_poll_time(PCNetState *s, int64_t current_time)
 607 {
 608     int64_t next_time = current_time +
 609         muldiv64(65536 - (CSR_SPND(s) ? 0 : CSR_POLL(s)),
 610                  ticks_per_sec, 33000000L);
 611     if (next_time <= current_time)
 612         next_time = current_time + 1;
 613     return next_time;
 614 }
 615
 616 static void pcnet_poll(PCNetState *s);
 617 static void pcnet_poll_timer(void *opaque);
 618
 619 static uint32_t pcnet_csr_readw(PCNetState *s, uint32_t rap);
 620 static void pcnet_csr_writew(PCNetState *s, uint32_t rap, uint32_t new_value);
 621 static void pcnet_bcr_writew(PCNetState *s, uint32_t rap, uint32_t val);
 622 static uint32_t pcnet_bcr_readw(PCNetState *s, uint32_t rap);
 623
 624 static void pcnet_s_reset(PCNetState *s)
 625 {
 626 #ifdef PCNET_DEBUG
 627     printf("pcnet_s_reset\n");
 628 #endif
 629
 630     s->lnkst = 0x40;
 631     s->rdra = 0;
 632     s->tdra = 0;
 633     s->rap = 0;
 634
 635     s->bcr[BCR_BSBC] &= ~0x0080;
 636
 637     s->csr[0]   = 0x0004;
 638     s->csr[3]   = 0x0000;
 639     s->csr[4]   = 0x0115;
 640     s->csr[5]   = 0x0000;
 641     s->csr[6]   = 0x0000;
 642     s->csr[8]   = 0;
 643     s->csr[9]   = 0;
 644     s->csr[10]  = 0;
 645     s->csr[11]  = 0;
 646     s->csr[12]  = le16_to_cpu(((uint16_t *)&s->prom[0])[0]);
 647     s->csr[13]  = le16_to_cpu(((uint16_t *)&s->prom[0])[1]);
 648     s->csr[14]  = le16_to_cpu(((uint16_t *)&s->prom[0])[2]);
 649     s->csr[15] &= 0x21c4;
 650     s->csr[72]  = 1;
 651     s->csr[74]  = 1;
 652     s->csr[76]  = 1;
 653     s->csr[78]  = 1;
 654     s->csr[80]  = 0x1410;
 655     s->csr[88]  = 0x1003;
 656     s->csr[89]  = 0x0262;
 657     s->csr[94]  = 0x0000;
 658     s->csr[100] = 0x0200;
 659     s->csr[103] = 0x0105;
 660     s->csr[103] = 0x0105;
 661     s->csr[112] = 0x0000;
 662     s->csr[114] = 0x0000;
 663     s->csr[122] = 0x0000;
 664     s->csr[124] = 0x0000;
 665
 666     s->tx_busy = 0;
 667 }
 668
 669 static void pcnet_update_irq(PCNetState *s)
 670 {
 671     int isr = 0;
 672     s->csr[0] &= ~0x0080;
 673
 674 #if 1
 675     if (((s->csr[0] & ~s->csr[3]) & 0x5f00) ||
 676         (((s->csr[4]>>1) & ~s->csr[4]) & 0x0115) ||
 677         (((s->csr[5]>>1) & s->csr[5]) & 0x0048))
 678 #else
 679     if ((!(s->csr[3] & 0x4000) && !!(s->csr[0] & 0x4000)) /* BABL */ ||
 680         (!(s->csr[3] & 0x1000) && !!(s->csr[0] & 0x1000)) /* MISS */ ||
 681         (!(s->csr[3] & 0x0100) && !!(s->csr[0] & 0x0100)) /* IDON */ ||
 682         (!(s->csr[3] & 0x0200) && !!(s->csr[0] & 0x0200)) /* TINT */ ||
 683         (!(s->csr[3] & 0x0400) && !!(s->csr[0] & 0x0400)) /* RINT */ ||
 684         (!(s->csr[3] & 0x0800) && !!(s->csr[0] & 0x0800)) /* MERR */ ||
 685         (!(s->csr[4] & 0x0001) && !!(s->csr[4] & 0x0002)) /* JAB */ ||
 686         (!(s->csr[4] & 0x0004) && !!(s->csr[4] & 0x0008)) /* TXSTRT */ ||
 687         (!(s->csr[4] & 0x0010) && !!(s->csr[4] & 0x0020)) /* RCVO */ ||
 688         (!(s->csr[4] & 0x0100) && !!(s->csr[4] & 0x0200)) /* MFCO */ ||
 689         (!!(s->csr[5] & 0x0040) && !!(s->csr[5] & 0x0080)) /* EXDINT */ ||
 690         (!!(s->csr[5] & 0x0008) && !!(s->csr[5] & 0x0010)) /* MPINT */)
 691 #endif
 692     {
 693
 694         isr = CSR_INEA(s);
 695         s->csr[0] |= 0x0080;
 696     }
 697
 698     if (!!(s->csr[4] & 0x0080) && CSR_INEA(s)) { /* UINT */
 699         s->csr[4] &= ~0x0080;
 700         s->csr[4] |= 0x0040;
 701         s->csr[0] |= 0x0080;
 702         isr = 1;
 703 #ifdef PCNET_DEBUG
 704         printf("pcnet user int\n");
 705 #endif
 706     }
 707
 708 #if 1
 709     if (((s->csr[5]>>1) & s->csr[5]) & 0x0500)
 710 #else
 711     if ((!!(s->csr[5] & 0x0400) && !!(s->csr[5] & 0x0800)) /* SINT */ ||
 712         (!!(s->csr[5] & 0x0100) && !!(s->csr[5] & 0x0200)) /* SLPINT */ )
 713 #endif
 714     {
 715         isr = 1;
 716         s->csr[0] |= 0x0080;
 717     }
 718
 719     if (isr != s->isr) {
 720 #ifdef PCNET_DEBUG
 721         printf("pcnet: INTA=%d\n", isr);
 722 #endif
 723     }
 724         pci_set_irq(&s->dev, 0, isr);
 725         s->isr = isr;
 726 }
 727
 728 static void pcnet_init(PCNetState *s)
 729 {
 730 #ifdef PCNET_DEBUG
 731     printf("pcnet_init init_addr=0x%08x\n", PHYSADDR(s,CSR_IADR(s)));
 732 #endif
 733
 734 #define PCNET_INIT() do { \
 735         cpu_physical_memory_read(PHYSADDR(s,CSR_IADR(s)),       \
 736                 (uint8_t *)&initblk, sizeof(initblk));          \
 737         s->csr[15] = le16_to_cpu(initblk.mode);                 \
 738         CSR_RCVRL(s) = (initblk.rlen < 9) ? (1 << initblk.rlen) : 512;  \
 739         CSR_XMTRL(s) = (initblk.tlen < 9) ? (1 << initblk.tlen) : 512;  \
 740         s->csr[ 6] = (initblk.tlen << 12) | (initblk.rlen << 8);        \
 741         s->csr[ 8] = le16_to_cpu(initblk.ladrf1);                       \
 742         s->csr[ 9] = le16_to_cpu(initblk.ladrf2);                       \
 743         s->csr[10] = le16_to_cpu(initblk.ladrf3);                       \
 744         s->csr[11] = le16_to_cpu(initblk.ladrf4);                       \
 745         s->csr[12] = le16_to_cpu(initblk.padr1);                        \
 746         s->csr[13] = le16_to_cpu(initblk.padr2);                        \
 747         s->csr[14] = le16_to_cpu(initblk.padr3);                        \
 748         s->rdra = PHYSADDR(s,initblk.rdra);                             \
 749         s->tdra = PHYSADDR(s,initblk.tdra);                             \
 750 } while (0)
 751
 752     if (BCR_SSIZE32(s)) {
 753         struct pcnet_initblk32 initblk;
 754         PCNET_INIT();
 755 #ifdef PCNET_DEBUG
 756         printf("initblk.rlen=0x%02x, initblk.tlen=0x%02x\n",
 757                 initblk.rlen, initblk.tlen);
 758 #endif
 759     } else {
 760         struct pcnet_initblk16 initblk;
 761         PCNET_INIT();
 762 #ifdef PCNET_DEBUG
 763         printf("initblk.rlen=0x%02x, initblk.tlen=0x%02x\n",
 764                 initblk.rlen, initblk.tlen);
 765 #endif
 766     }
 767
 768 #undef PCNET_INIT
 769
 770     CSR_RCVRC(s) = CSR_RCVRL(s);
 771     CSR_XMTRC(s) = CSR_XMTRL(s);
 772
 773 #ifdef PCNET_DEBUG
 774     printf("pcnet ss32=%d rdra=0x%08x[%d] tdra=0x%08x[%d]\n",
 775         BCR_SSIZE32(s),
 776         s->rdra, CSR_RCVRL(s), s->tdra, CSR_XMTRL(s));
 777 #endif
 778
 779     s->csr[0] |= 0x0101;
 780     s->csr[0] &= ~0x0004;       /* clear STOP bit */
 781 }
 782
 783 static void pcnet_start(PCNetState *s)
 784 {
 785 #ifdef PCNET_DEBUG
 786     printf("pcnet_start\n");
 787 #endif
 788
 789     if (!CSR_DTX(s))
 790         s->csr[0] |= 0x0010;    /* set TXON */
 791
 792     if (!CSR_DRX(s))
 793         s->csr[0] |= 0x0020;    /* set RXON */
 794
 795     s->csr[0] &= ~0x0004;       /* clear STOP bit */
 796     s->csr[0] |= 0x0002;
 797 }
 798
 799 static void pcnet_stop(PCNetState *s)
 800 {
 801 #ifdef PCNET_DEBUG
 802     printf("pcnet_stop\n");
 803 #endif
 804     s->csr[0] &= ~0x7feb;
 805     s->csr[0] |= 0x0014;
 806     s->csr[4] &= ~0x02c2;
 807     s->csr[5] &= ~0x0011;
 808     pcnet_poll_timer(s);
 809 }
 810
 811 static void pcnet_rdte_poll(PCNetState *s)
 812 {
 813     s->csr[28] = s->csr[29] = 0;
 814     if (s->rdra) {
 815         int bad = 0;
 816 #if 1
 817         target_phys_addr_t crda = pcnet_rdra_addr(s, CSR_RCVRC(s));
 818         target_phys_addr_t nrda = pcnet_rdra_addr(s, -1 + CSR_RCVRC(s));
 819         target_phys_addr_t nnrd = pcnet_rdra_addr(s, -2 + CSR_RCVRC(s));
 820 #else
 821         target_phys_addr_t crda = s->rdra +
 822             (CSR_RCVRL(s) - CSR_RCVRC(s)) *
 823             (BCR_SWSTYLE(s) ? 16 : 8 );
 824         int nrdc = CSR_RCVRC(s)<=1 ? CSR_RCVRL(s) : CSR_RCVRC(s)-1;
 825         target_phys_addr_t nrda = s->rdra +
 826             (CSR_RCVRL(s) - nrdc) *
 827             (BCR_SWSTYLE(s) ? 16 : 8 );
 828         int nnrc = nrdc<=1 ? CSR_RCVRL(s) : nrdc-1;
 829         target_phys_addr_t nnrd = s->rdra +
 830             (CSR_RCVRL(s) - nnrc) *
 831             (BCR_SWSTYLE(s) ? 16 : 8 );
 832 #endif
 833
 834         CHECK_RMD(PHYSADDR(s,crda), bad);
 835         if (!bad) {
 836             CHECK_RMD(PHYSADDR(s,nrda), bad);
 837             if (bad || (nrda == crda)) nrda = 0;
 838             CHECK_RMD(PHYSADDR(s,nnrd), bad);
 839             if (bad || (nnrd == crda)) nnrd = 0;
 840
 841             s->csr[28] = crda & 0xffff;
 842             s->csr[29] = crda >> 16;
 843             s->csr[26] = nrda & 0xffff;
 844             s->csr[27] = nrda >> 16;
 845             s->csr[36] = nnrd & 0xffff;
 846             s->csr[37] = nnrd >> 16;
 847 #ifdef PCNET_DEBUG
 848             if (bad) {
 849                 printf("pcnet: BAD RMD RECORDS AFTER 0x%08x\n",
 850                        PHYSADDR(s,crda));
 851             }
 852         } else {
 853             printf("pcnet: BAD RMD RDA=0x%08x\n", PHYSADDR(s,crda));
 854 #endif
 855         }
 856     }
 857
 858     if (CSR_CRDA(s)) {
 859         struct pcnet_RMD rmd;
 860         RMDLOAD(&rmd, PHYSADDR(s,CSR_CRDA(s)));
 861         CSR_CRBC(s) = rmd.rmd1.bcnt;
 862         CSR_CRST(s) = ((uint32_t *)&rmd)[1] >> 16;
 863 #ifdef PCNET_DEBUG_RMD_X
 864         printf("CRDA=0x%08x CRST=0x%04x RCVRC=%d RMD1=0x%08x RMD2=0x%08x\n",
 865                 PHYSADDR(s,CSR_CRDA(s)), CSR_CRST(s), CSR_RCVRC(s),
 866                 ((uint32_t *)&rmd)[1], ((uint32_t *)&rmd)[2]);
 867         PRINT_RMD(&rmd);
 868 #endif
 869     } else {
 870         CSR_CRBC(s) = CSR_CRST(s) = 0;
 871     }
 872
 873     if (CSR_NRDA(s)) {
 874         struct pcnet_RMD rmd;
 875         RMDLOAD(&rmd, PHYSADDR(s,CSR_NRDA(s)));
 876         CSR_NRBC(s) = rmd.rmd1.bcnt;
 877         CSR_NRST(s) = ((uint32_t *)&rmd)[1] >> 16;
 878     } else {
 879         CSR_NRBC(s) = CSR_NRST(s) = 0;
 880     }
 881
 882 }
 883
 884 static int pcnet_tdte_poll(PCNetState *s)
 885 {
 886     s->csr[34] = s->csr[35] = 0;
 887     if (s->tdra) {
 888         target_phys_addr_t cxda = s->tdra +
 889             (CSR_XMTRL(s) - CSR_XMTRC(s)) *
 890             (BCR_SWSTYLE(s) ? 16 : 8 );
 891         int bad = 0;
 892         CHECK_TMD(PHYSADDR(s, cxda),bad);
 893         if (!bad) {
 894             if (CSR_CXDA(s) != cxda) {
 895                 s->csr[60] = s->csr[34];
 896                 s->csr[61] = s->csr[35];
 897                 s->csr[62] = CSR_CXBC(s);
 898                 s->csr[63] = CSR_CXST(s);
 899             }
 900             s->csr[34] = cxda & 0xffff;
 901             s->csr[35] = cxda >> 16;
 902 #ifdef PCNET_DEBUG
 903         } else {
 904             printf("pcnet: BAD TMD XDA=0x%08x\n", PHYSADDR(s,cxda));
 905 #endif
 906         }
 907     }
 908
 909     if (CSR_CXDA(s)) {
 910         struct pcnet_TMD tmd;
 911
 912         TMDLOAD(&tmd, PHYSADDR(s,CSR_CXDA(s)));
 913
 914         CSR_CXBC(s) = tmd.tmd1.bcnt;
 915         CSR_CXST(s) = ((uint32_t *)&tmd)[1] >> 16;
 916     } else {
 917         CSR_CXBC(s) = CSR_CXST(s) = 0;
 918     }
 919
 920     return !!(CSR_CXST(s) & 0x8000);
 921 }
 922
 923 static int pcnet_can_receive(void *opaque)
 924 {
 925     PCNetState *s = opaque;
 926     if (CSR_STOP(s) || CSR_SPND(s))
 927         return 0;
 928
 929     if (s->recv_pos > 0)
 930         return 0;
 931
 932     return sizeof(s->buffer)-16;
 933 }
 934
 935 #define MIN_BUF_SIZE 60
 936
 937 static void pcnet_receive(void *opaque, const uint8_t *buf, int size)
 938 {
 939     PCNetState *s = opaque;
 940     int is_padr = 0, is_bcast = 0, is_ladr = 0;
 941     uint8_t buf1[60];
 942
 943     if (CSR_DRX(s) || CSR_STOP(s) || CSR_SPND(s) || !size)
 944         return;
 945
 946 #ifdef PCNET_DEBUG
 947     printf("pcnet_receive size=%d\n", size);
 948 #endif
 949
 950     /* if too small buffer, then expand it */
 951     if (size < MIN_BUF_SIZE) {
 952         memcpy(buf1, buf, size);
 953         memset(buf1 + size, 0, MIN_BUF_SIZE - size);
 954         buf = buf1;
 955         size = MIN_BUF_SIZE;
 956     }
 957
 958     if (CSR_PROM(s)
 959         || (is_padr=padr_match(s, buf, size))
 960         || (is_bcast=padr_bcast(s, buf, size))
 961         || (is_ladr=ladr_match(s, buf, size))) {
 962
 963         pcnet_rdte_poll(s);
 964
 965         if (!(CSR_CRST(s) & 0x8000) && s->rdra) {
 966             struct pcnet_RMD rmd;
 967             int rcvrc = CSR_RCVRC(s)-1,i;
 968             target_phys_addr_t nrda;
 969             for (i = CSR_RCVRL(s)-1; i > 0; i--, rcvrc--) {
 970                 if (rcvrc <= 1)
 971                     rcvrc = CSR_RCVRL(s);
 972                 nrda = s->rdra +
 973                     (CSR_RCVRL(s) - rcvrc) *
 974                     (BCR_SWSTYLE(s) ? 16 : 8 );
 975                 RMDLOAD(&rmd, PHYSADDR(s,nrda));
 976                 if (rmd.rmd1.own) {
 977 #ifdef PCNET_DEBUG_RMD
 978                     printf("pcnet - scan buffer: RCVRC=%d PREV_RCVRC=%d\n",
 979                                 rcvrc, CSR_RCVRC(s));
 980 #endif
 981                     CSR_RCVRC(s) = rcvrc;
 982                     pcnet_rdte_poll(s);
 983                     break;
 984                 }
 985             }
 986         }
 987
 988         if (!(CSR_CRST(s) & 0x8000)) {
 989 #ifdef PCNET_DEBUG_RMD
 990             printf("pcnet - no buffer: RCVRC=%d\n", CSR_RCVRC(s));
 991 #endif
 992             s->csr[0] |= 0x1000; /* Set MISS flag */
 993             CSR_MISSC(s)++;
 994         } else {
 995             uint8_t *src = &s->buffer[8];
 996             target_phys_addr_t crda = CSR_CRDA(s);
 997             struct pcnet_RMD rmd;
 998             int pktcount = 0;
 999
1000             memcpy(src, buf, size);
1001
1002 #if 1
1003             /* no need to compute the CRC */
1004             src[size] = 0;
1005             src[size + 1] = 0;
1006             src[size + 2] = 0;
1007             src[size + 3] = 0;
1008             size += 4;
1009 #else
1010             /* XXX: avoid CRC generation */
1011             if (!CSR_ASTRP_RCV(s)) {
1012                 uint32_t fcs = ~0;
1013                 uint8_t *p = src;
1014
1015                 while (size < 46) {
1016                     src[size++] = 0;
1017                 }
1018
1019                 while (p != &src[size]) {
1020                     CRC(fcs, *p++);
1021                 }
1022                 ((uint32_t *)&src[size])[0] = htonl(fcs);
1023                 size += 4; /* FCS at end of packet */
1024             } else size += 4;
1025 #endif
1026
1027 #ifdef PCNET_DEBUG_MATCH
1028             PRINT_PKTHDR(buf);
1029 #endif
1030
1031             RMDLOAD(&rmd, PHYSADDR(s,crda));
1032             /*if (!CSR_LAPPEN(s))*/
1033                 rmd.rmd1.stp = 1;
1034
1035 #define PCNET_RECV_STORE() do {                                 \
1036     int count = MIN(4096 - rmd.rmd1.bcnt,size);                 \
1037     target_phys_addr_t rbadr = PHYSADDR(s, rmd.rmd0.rbadr);     \
1038     cpu_physical_memory_write(rbadr, src, count);               \
1039     src += count; size -= count;                                \
1040     rmd.rmd2.mcnt = count; rmd.rmd1.own = 0;                    \
1041     RMDSTORE(&rmd, PHYSADDR(s,crda));                           \
1042     pktcount++;                                                 \
1043 } while (0)
1044
1045             PCNET_RECV_STORE();
1046             if ((size > 0) && CSR_NRDA(s)) {
1047                 target_phys_addr_t nrda = CSR_NRDA(s);
1048                 RMDLOAD(&rmd, PHYSADDR(s,nrda));
1049                 if (rmd.rmd1.own) {
1050                     crda = nrda;
1051                     PCNET_RECV_STORE();
1052                     if ((size > 0) && (nrda=CSR_NNRD(s))) {
1053                         RMDLOAD(&rmd, PHYSADDR(s,nrda));
1054                         if (rmd.rmd1.own) {
1055                             crda = nrda;
1056                             PCNET_RECV_STORE();
1057                         }
1058                     }
1059                 }
1060             }
1061
1062 #undef PCNET_RECV_STORE
1063
1064             RMDLOAD(&rmd, PHYSADDR(s,crda));
1065             if (size == 0) {
1066                 rmd.rmd1.enp = 1;
1067                 rmd.rmd1.pam = !CSR_PROM(s) && is_padr;
1068                 rmd.rmd1.lafm = !CSR_PROM(s) && is_ladr;
1069                 rmd.rmd1.bam = !CSR_PROM(s) && is_bcast;
1070             } else {
1071                 rmd.rmd1.oflo = 1;
1072                 rmd.rmd1.buff = 1;
1073                 rmd.rmd1.err = 1;
1074             }
1075             RMDSTORE(&rmd, PHYSADDR(s,crda));
1076             s->csr[0] |= 0x0400;
1077
1078 #ifdef PCNET_DEBUG
1079             printf("RCVRC=%d CRDA=0x%08x BLKS=%d\n",
1080                 CSR_RCVRC(s), PHYSADDR(s,CSR_CRDA(s)), pktcount);
1081 #endif
1082 #ifdef PCNET_DEBUG_RMD
1083             PRINT_RMD(&rmd);
1084 #endif
1085
1086             while (pktcount--) {
1087                 if (CSR_RCVRC(s) <= 1)
1088                     CSR_RCVRC(s) = CSR_RCVRL(s);
1089                 else
1090                     CSR_RCVRC(s)--;
1091             }
1092
1093             pcnet_rdte_poll(s);
1094
1095         }
1096     }
1097
1098     pcnet_poll(s);
1099     pcnet_update_irq(s);
1100 }
1101
1102 static void pcnet_transmit(PCNetState *s)
1103 {
1104     target_phys_addr_t xmit_cxda = 0;
1105     int count = CSR_XMTRL(s)-1;
1106     s->xmit_pos = -1;
1107
1108     if (!CSR_TXON(s)) {
1109         s->csr[0] &= ~0x0008;
1110         return;
1111     }
1112
1113     s->tx_busy = 1;
1114
1115     txagain:
1116     if (pcnet_tdte_poll(s)) {
1117         struct pcnet_TMD tmd;
1118
1119         TMDLOAD(&tmd, PHYSADDR(s,CSR_CXDA(s)));
1120
1121 #ifdef PCNET_DEBUG_TMD
1122         printf("  TMDLOAD 0x%08x\n", PHYSADDR(s,CSR_CXDA(s)));
1123         PRINT_TMD(&tmd);
1124 #endif
1125         if (tmd.tmd1.stp) {
1126             s->xmit_pos = 0;
1127             if (!tmd.tmd1.enp) {
1128                 cpu_physical_memory_read(PHYSADDR(s, tmd.tmd0.tbadr),
1129                         s->buffer, 4096 - tmd.tmd1.bcnt);
1130                 s->xmit_pos += 4096 - tmd.tmd1.bcnt;
1131             }
1132             xmit_cxda = PHYSADDR(s,CSR_CXDA(s));
1133         }
1134         if (tmd.tmd1.enp && (s->xmit_pos >= 0)) {
1135             cpu_physical_memory_read(PHYSADDR(s, tmd.tmd0.tbadr),
1136                     s->buffer + s->xmit_pos, 4096 - tmd.tmd1.bcnt);
1137             s->xmit_pos += 4096 - tmd.tmd1.bcnt;
1138 #ifdef PCNET_DEBUG
1139             printf("pcnet_transmit size=%d\n", s->xmit_pos);
1140 #endif
1141             if (CSR_LOOP(s))
1142                 pcnet_receive(s, s->buffer, s->xmit_pos);
1143             else
1144                 qemu_send_packet(s->vc, s->buffer, s->xmit_pos);
1145
1146             s->csr[0] &= ~0x0008;   /* clear TDMD */
1147             s->csr[4] |= 0x0004;    /* set TXSTRT */
1148             s->xmit_pos = -1;
1149         }
1150
1151         tmd.tmd1.own = 0;
1152         TMDSTORE(&tmd, PHYSADDR(s,CSR_CXDA(s)));
1153         if (!CSR_TOKINTD(s) || (CSR_LTINTEN(s) && tmd.tmd1.ltint))
1154             s->csr[0] |= 0x0200;    /* set TINT */
1155
1156         if (CSR_XMTRC(s)<=1)
1157             CSR_XMTRC(s) = CSR_XMTRL(s);
1158         else
1159             CSR_XMTRC(s)--;
1160         if (count--)
1161             goto txagain;
1162
1163     } else
1164     if (s->xmit_pos >= 0) {
1165         struct pcnet_TMD tmd;
1166         TMDLOAD(&tmd, PHYSADDR(s,xmit_cxda));
1167         tmd.tmd2.buff = tmd.tmd2.uflo = tmd.tmd1.err = 1;
1168         tmd.tmd1.own = 0;
1169         TMDSTORE(&tmd, PHYSADDR(s,xmit_cxda));
1170         s->csr[0] |= 0x0200;    /* set TINT */
1171         if (!CSR_DXSUFLO(s)) {
1172             s->csr[0] &= ~0x0010;
1173         } else
1174         if (count--)
1175           goto txagain;
1176     }
1177
1178     s->tx_busy = 0;
1179 }
1180
1181 static void pcnet_poll(PCNetState *s)
1182 {
1183     if (CSR_RXON(s)) {
1184         pcnet_rdte_poll(s);
1185     }
1186
1187     if (CSR_TDMD(s) ||
1188         (CSR_TXON(s) && !CSR_DPOLL(s) && pcnet_tdte_poll(s)))
1189     {
1190         /* prevent recursion */
1191         if (s->tx_busy)
1192             return;
1193
1194         pcnet_transmit(s);
1195     }
1196 }
1197
1198 static void pcnet_poll_timer(void *opaque)
1199 {
1200     PCNetState *s = opaque;
1201
1202     qemu_del_timer(s->poll_timer);
1203
1204     if (CSR_TDMD(s)) {
1205         pcnet_transmit(s);
1206     }
1207
1208     pcnet_update_irq(s);
1209
1210     if (!CSR_STOP(s) && !CSR_SPND(s) && !CSR_DPOLL(s)) {
1211         uint64_t now = qemu_get_clock(vm_clock) * 33;
1212         if (!s->timer || !now)
1213             s->timer = now;
1214         else {
1215             uint64_t t = now - s->timer + CSR_POLL(s);
1216             if (t > 0xffffLL) {
1217                 pcnet_poll(s);
1218                 CSR_POLL(s) = CSR_PINT(s);
1219             } else
1220                 CSR_POLL(s) = t;
1221         }
1222         qemu_mod_timer(s->poll_timer,
1223             pcnet_get_next_poll_time(s,qemu_get_clock(vm_clock)));
1224     }
1225 }
1226
1227
1228 static void pcnet_csr_writew(PCNetState *s, uint32_t rap, uint32_t new_value)
1229 {
1230     uint16_t val = new_value;
1231 #ifdef PCNET_DEBUG_CSR
1232     printf("pcnet_csr_writew rap=%d val=0x%04x\n", rap, val);
1233 #endif
1234     switch (rap) {
1235     case 0:
1236         s->csr[0] &= ~(val & 0x7f00); /* Clear any interrupt flags */
1237
1238         s->csr[0] = (s->csr[0] & ~0x0040) | (val & 0x0048);
1239
1240         val = (val & 0x007f) | (s->csr[0] & 0x7f00);
1241
1242         /* IFF STOP, STRT and INIT are set, clear STRT and INIT */
1243         if ((val&7) == 7)
1244           val &= ~3;
1245
1246         if (!CSR_STOP(s) && (val & 4))
1247             pcnet_stop(s);
1248
1249         if (!CSR_INIT(s) && (val & 1))
1250             pcnet_init(s);
1251
1252         if (!CSR_STRT(s) && (val & 2))
1253             pcnet_start(s);
1254
1255         if (CSR_TDMD(s))
1256             pcnet_transmit(s);
1257
1258         return;
1259     case 1:
1260     case 2:
1261     case 8:
1262     case 9:
1263     case 10:
1264     case 11:
1265     case 12:
1266     case 13:
1267     case 14:
1268     case 15:
1269     case 18: /* CRBAL */
1270     case 19: /* CRBAU */
1271     case 20: /* CXBAL */
1272     case 21: /* CXBAU */
1273     case 22: /* NRBAU */
1274     case 23: /* NRBAU */
1275     case 24:
1276     case 25:
1277     case 26:
1278     case 27:
1279     case 28:
1280     case 29:
1281     case 30:
1282     case 31:
1283     case 32:
1284     case 33:
1285     case 34:
1286     case 35:
1287     case 36:
1288     case 37:
1289     case 38:
1290     case 39:
1291     case 40: /* CRBC */
1292     case 41:
1293     case 42: /* CXBC */
1294     case 43:
1295     case 44:
1296     case 45:
1297     case 46: /* POLL */
1298     case 47: /* POLLINT */
1299     case 72:
1300     case 74:
1301     case 76: /* RCVRL */
1302     case 78: /* XMTRL */
1303     case 112:
1304        if (CSR_STOP(s) || CSR_SPND(s))
1305            break;
1306        return;
1307     case 3:
1308         break;
1309     case 4:
1310         s->csr[4] &= ~(val & 0x026a);
1311         val &= ~0x026a; val |= s->csr[4] & 0x026a;
1312         break;
1313     case 5:
1314         s->csr[5] &= ~(val & 0x0a90);
1315         val &= ~0x0a90; val |= s->csr[5] & 0x0a90;
1316         break;
1317     case 16:
1318         pcnet_csr_writew(s,1,val);
1319         return;
1320     case 17:
1321         pcnet_csr_writew(s,2,val);
1322         return;
1323     case 58:
1324         pcnet_bcr_writew(s,BCR_SWS,val);
1325         break;
1326     default:
1327         return;
1328     }
1329     s->csr[rap] = val;
1330 }
1331
1332 static uint32_t pcnet_csr_readw(PCNetState *s, uint32_t rap)
1333 {
1334     uint32_t val;
1335     switch (rap) {
1336     case 0:
1337         pcnet_update_irq(s);
1338         val = s->csr[0];
1339         val |= (val & 0x7800) ? 0x8000 : 0;
1340         break;
1341     case 16:
1342         return pcnet_csr_readw(s,1);
1343     case 17:
1344         return pcnet_csr_readw(s,2);
1345     case 58:
1346         return pcnet_bcr_readw(s,BCR_SWS);
1347     case 88:
1348         val = s->csr[89];
1349         val <<= 16;
1350         val |= s->csr[88];
1351         break;
1352     default:
1353         val = s->csr[rap];
1354     }
1355 #ifdef PCNET_DEBUG_CSR
1356     printf("pcnet_csr_readw rap=%d val=0x%04x\n", rap, val);
1357 #endif
1358     return val;
1359 }
1360
1361 static void pcnet_bcr_writew(PCNetState *s, uint32_t rap, uint32_t val)
1362 {
1363     rap &= 127;
1364 #ifdef PCNET_DEBUG_BCR
1365     printf("pcnet_bcr_writew rap=%d val=0x%04x\n", rap, val);
1366 #endif
1367     switch (rap) {
1368     case BCR_SWS:
1369         if (!(CSR_STOP(s) || CSR_SPND(s)))
1370             return;
1371         val &= ~0x0300;
1372         switch (val & 0x00ff) {
1373         case 0:
1374             val |= 0x0200;
1375             break;
1376         case 1:
1377             val |= 0x0100;
1378             break;
1379         case 2:
1380         case 3:
1381             val |= 0x0300;
1382             break;
1383         default:
1384             printf("Bad SWSTYLE=0x%02x\n", val & 0xff);
1385             val = 0x0200;
1386             break;
1387         }
1388 #ifdef PCNET_DEBUG
1389        printf("BCR_SWS=0x%04x\n", val);
1390 #endif
1391     case BCR_LNKST:
1392     case BCR_LED1:
1393     case BCR_LED2:
1394     case BCR_LED3:
1395     case BCR_MC:
1396     case BCR_FDC:
1397     case BCR_BSBC:
1398     case BCR_EECAS:
1399     case BCR_PLAT:
1400         s->bcr[rap] = val;
1401         break;
1402     default:
1403         break;
1404     }
1405 }
1406
1407 static uint32_t pcnet_bcr_readw(PCNetState *s, uint32_t rap)
1408 {
1409     uint32_t val;
1410     rap &= 127;
1411     switch (rap) {
1412     case BCR_LNKST:
1413     case BCR_LED1:
1414     case BCR_LED2:
1415     case BCR_LED3:
1416         val = s->bcr[rap] & ~0x8000;
1417         val |= (val & 0x017f & s->lnkst) ? 0x8000 : 0;
1418         break;
1419     default:
1420         val = rap < 32 ? s->bcr[rap] : 0;
1421         break;
1422     }
1423 #ifdef PCNET_DEBUG_BCR
1424     printf("pcnet_bcr_readw rap=%d val=0x%04x\n", rap, val);
1425 #endif
1426     return val;
1427 }
1428
1429 static void pcnet_h_reset(PCNetState *s)
1430 {
1431     int i;
1432     uint16_t checksum;
1433
1434     /* Initialize the PROM */
1435
1436     memcpy(s->prom, s->nd->macaddr, 6);
1437     s->prom[12] = s->prom[13] = 0x00;
1438     s->prom[14] = s->prom[15] = 0x57;
1439
1440     for (i = 0,checksum = 0; i < 16; i++)
1441         checksum += s->prom[i];
1442     *(uint16_t *)&s->prom[12] = cpu_to_le16(checksum);
1443
1444
1445     s->bcr[BCR_MSRDA] = 0x0005;
1446     s->bcr[BCR_MSWRA] = 0x0005;
1447     s->bcr[BCR_MC   ] = 0x0002;
1448     s->bcr[BCR_LNKST] = 0x00c0;
1449     s->bcr[BCR_LED1 ] = 0x0084;
1450     s->bcr[BCR_LED2 ] = 0x0088;
1451     s->bcr[BCR_LED3 ] = 0x0090;
1452     s->bcr[BCR_FDC  ] = 0x0000;
1453     s->bcr[BCR_BSBC ] = 0x9001;
1454     s->bcr[BCR_EECAS] = 0x0002;
1455     s->bcr[BCR_SWS  ] = 0x0200;
1456     s->bcr[BCR_PLAT ] = 0xff06;
1457
1458     pcnet_s_reset(s);
1459 }
1460
1461 static void pcnet_aprom_writeb(void *opaque, uint32_t addr, uint32_t val)
1462 {
1463     PCNetState *s = opaque;
1464 #ifdef PCNET_DEBUG
1465     printf("pcnet_aprom_writeb addr=0x%08x val=0x%02x\n", addr, val);
1466 #endif
1467     /* Check APROMWE bit to enable write access */
1468     if (pcnet_bcr_readw(s,2) & 0x80)
1469         s->prom[addr & 15] = val;
1470 }
1471
1472 static uint32_t pcnet_aprom_readb(void *opaque, uint32_t addr)
1473 {
1474     PCNetState *s = opaque;
1475     uint32_t val = s->prom[addr &= 15];
1476 #ifdef PCNET_DEBUG
1477     printf("pcnet_aprom_readb addr=0x%08x val=0x%02x\n", addr, val);
1478 #endif
1479     return val;
1480 }
1481
1482 static void pcnet_ioport_writew(void *opaque, uint32_t addr, uint32_t val)
1483 {
1484     PCNetState *s = opaque;
1485     pcnet_poll_timer(s);
1486 #ifdef PCNET_DEBUG_IO
1487     printf("pcnet_ioport_writew addr=0x%08x val=0x%04x\n", addr, val);
1488 #endif
1489     if (!BCR_DWIO(s)) {
1490         switch (addr & 0x0f) {
1491         case 0x00: /* RDP */
1492             pcnet_csr_writew(s, s->rap, val);
1493             break;
1494         case 0x02:
1495             s->rap = val & 0x7f;
1496             break;
1497         case 0x06:
1498             pcnet_bcr_writew(s, s->rap, val);
1499             break;
1500         }
1501     }
1502     pcnet_update_irq(s);
1503 }
1504
1505 static uint32_t pcnet_ioport_readw(void *opaque, uint32_t addr)
1506 {
1507     PCNetState *s = opaque;
1508     uint32_t val = -1;
1509     pcnet_poll_timer(s);
1510     if (!BCR_DWIO(s)) {
1511         switch (addr & 0x0f) {
1512         case 0x00: /* RDP */
1513             val = pcnet_csr_readw(s, s->rap);
1514             break;
1515         case 0x02:
1516             val = s->rap;
1517             break;
1518         case 0x04:
1519             pcnet_s_reset(s);
1520             val = 0;
1521             break;
1522         case 0x06:
1523             val = pcnet_bcr_readw(s, s->rap);
1524             break;
1525         }
1526     }
1527     pcnet_update_irq(s);
1528 #ifdef PCNET_DEBUG_IO
1529     printf("pcnet_ioport_readw addr=0x%08x val=0x%04x\n", addr, val & 0xffff);
1530 #endif
1531     return val;
1532 }
1533
1534 static void pcnet_ioport_writel(void *opaque, uint32_t addr, uint32_t val)
1535 {
1536     PCNetState *s = opaque;
1537     pcnet_poll_timer(s);
1538 #ifdef PCNET_DEBUG_IO
1539     printf("pcnet_ioport_writel addr=0x%08x val=0x%08x\n", addr, val);
1540 #endif
1541     if (BCR_DWIO(s)) {
1542         switch (addr & 0x0f) {
1543         case 0x00: /* RDP */
1544             pcnet_csr_writew(s, s->rap, val & 0xffff);
1545             break;
1546         case 0x04:
1547             s->rap = val & 0x7f;
1548             break;
1549         case 0x0c:
1550             pcnet_bcr_writew(s, s->rap, val & 0xffff);
1551             break;
1552         }
1553     } else
1554     if ((addr & 0x0f) == 0) {
1555         /* switch device to dword i/o mode */
1556         pcnet_bcr_writew(s, BCR_BSBC, pcnet_bcr_readw(s, BCR_BSBC) | 0x0080);
1557 #ifdef PCNET_DEBUG_IO
1558         printf("device switched into dword i/o mode\n");
1559 #endif
1560     }
1561     pcnet_update_irq(s);
1562 }
1563
1564 static uint32_t pcnet_ioport_readl(void *opaque, uint32_t addr)
1565 {
1566     PCNetState *s = opaque;
1567     uint32_t val = -1;
1568     pcnet_poll_timer(s);
1569     if (BCR_DWIO(s)) {
1570         switch (addr & 0x0f) {
1571         case 0x00: /* RDP */
1572             val = pcnet_csr_readw(s, s->rap);
1573             break;
1574         case 0x04:
1575             val = s->rap;
1576             break;
1577         case 0x08:
1578             pcnet_s_reset(s);
1579             val = 0;
1580             break;
1581         case 0x0c:
1582             val = pcnet_bcr_readw(s, s->rap);
1583             break;
1584         }
1585     }
1586     pcnet_update_irq(s);
1587 #ifdef PCNET_DEBUG_IO
1588     printf("pcnet_ioport_readl addr=0x%08x val=0x%08x\n", addr, val);
1589 #endif
1590     return val;
1591 }
1592
1593 static void pcnet_ioport_map(PCIDevice *pci_dev, int region_num,
1594                              uint32_t addr, uint32_t size, int type)
1595 {
1596     PCNetState *d = (PCNetState *)pci_dev;
1597
1598 #ifdef PCNET_DEBUG_IO
1599     printf("pcnet_ioport_map addr=0x%04x size=0x%04x\n", addr, size);
1600 #endif
1601
1602     register_ioport_write(addr, 16, 1, pcnet_aprom_writeb, d);
1603     register_ioport_read(addr, 16, 1, pcnet_aprom_readb, d);
1604
1605     register_ioport_write(addr + 0x10, 0x10, 2, pcnet_ioport_writew, d);
1606     register_ioport_read(addr + 0x10, 0x10, 2, pcnet_ioport_readw, d);
1607     register_ioport_write(addr + 0x10, 0x10, 4, pcnet_ioport_writel, d);
1608     register_ioport_read(addr + 0x10, 0x10, 4, pcnet_ioport_readl, d);
1609 }
1610
1611 static void pcnet_mmio_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
1612 {
1613     PCNetState *d = opaque;
1614 #ifdef PCNET_DEBUG_IO
1615     printf("pcnet_mmio_writeb addr=0x%08x val=0x%02x\n", addr, val);
1616 #endif
1617     if (!(addr & 0x10))
1618         pcnet_aprom_writeb(d, addr & 0x0f, val);
1619 }
1620
1621 static uint32_t pcnet_mmio_readb(void *opaque, target_phys_addr_t addr)
1622 {
1623     PCNetState *d = opaque;
1624     uint32_t val = -1;
1625     if (!(addr & 0x10))
1626         val = pcnet_aprom_readb(d, addr & 0x0f);
1627 #ifdef PCNET_DEBUG_IO
1628     printf("pcnet_mmio_readb addr=0x%08x val=0x%02x\n", addr, val & 0xff);
1629 #endif
1630     return val;
1631 }
1632
1633 static void pcnet_mmio_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
1634 {
1635     PCNetState *d = opaque;
1636 #ifdef PCNET_DEBUG_IO
1637     printf("pcnet_mmio_writew addr=0x%08x val=0x%04x\n", addr, val);
1638 #endif
1639     if (addr & 0x10)
1640         pcnet_ioport_writew(d, addr & 0x0f, val);
1641     else {
1642         addr &= 0x0f;
1643         pcnet_aprom_writeb(d, addr, val & 0xff);
1644         pcnet_aprom_writeb(d, addr+1, (val & 0xff00) >> 8);
1645     }
1646 }
1647
1648 static uint32_t pcnet_mmio_readw(void *opaque, target_phys_addr_t addr)
1649 {
1650     PCNetState *d = opaque;
1651     uint32_t val = -1;
1652     if (addr & 0x10)
1653         val = pcnet_ioport_readw(d, addr & 0x0f);
1654     else {
1655         addr &= 0x0f;
1656         val = pcnet_aprom_readb(d, addr+1);
1657         val <<= 8;
1658         val |= pcnet_aprom_readb(d, addr);
1659     }
1660 #ifdef PCNET_DEBUG_IO
1661     printf("pcnet_mmio_readw addr=0x%08x val = 0x%04x\n", addr, val & 0xffff);
1662 #endif
1663     return val;
1664 }
1665
1666 static void pcnet_mmio_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
1667 {
1668     PCNetState *d = opaque;
1669 #ifdef PCNET_DEBUG_IO
1670     printf("pcnet_mmio_writel addr=0x%08x val=0x%08x\n", addr, val);
1671 #endif
1672     if (addr & 0x10)
1673         pcnet_ioport_writel(d, addr & 0x0f, val);
1674     else {
1675         addr &= 0x0f;
1676         pcnet_aprom_writeb(d, addr, val & 0xff);
1677         pcnet_aprom_writeb(d, addr+1, (val & 0xff00) >> 8);
1678         pcnet_aprom_writeb(d, addr+2, (val & 0xff0000) >> 16);
1679         pcnet_aprom_writeb(d, addr+3, (val & 0xff000000) >> 24);
1680     }
1681 }
1682
1683 static uint32_t pcnet_mmio_readl(void *opaque, target_phys_addr_t addr)
1684 {
1685     PCNetState *d = opaque;
1686     uint32_t val;
1687     if (addr & 0x10)
1688         val = pcnet_ioport_readl(d, addr & 0x0f);
1689     else {
1690         addr &= 0x0f;
1691         val = pcnet_aprom_readb(d, addr+3);
1692         val <<= 8;
1693         val |= pcnet_aprom_readb(d, addr+2);
1694         val <<= 8;
1695         val |= pcnet_aprom_readb(d, addr+1);
1696         val <<= 8;
1697         val |= pcnet_aprom_readb(d, addr);
1698     }
1699 #ifdef PCNET_DEBUG_IO
1700     printf("pcnet_mmio_readl addr=0x%08x val=0x%08x\n", addr, val);
1701 #endif
1702     return val;
1703 }
1704
1705
1706 static CPUWriteMemoryFunc *pcnet_mmio_write[] = {
1707     (CPUWriteMemoryFunc *)&pcnet_mmio_writeb,
1708     (CPUWriteMemoryFunc *)&pcnet_mmio_writew,
1709     (CPUWriteMemoryFunc *)&pcnet_mmio_writel
1710 };
1711
1712 static CPUReadMemoryFunc *pcnet_mmio_read[] = {
1713     (CPUReadMemoryFunc *)&pcnet_mmio_readb,
1714     (CPUReadMemoryFunc *)&pcnet_mmio_readw,
1715     (CPUReadMemoryFunc *)&pcnet_mmio_readl
1716 };
1717
1718 static void pcnet_mmio_map(PCIDevice *pci_dev, int region_num,
1719                             uint32_t addr, uint32_t size, int type)
1720 {
1721     PCNetState *d = (PCNetState *)pci_dev;
1722
1723 #ifdef PCNET_DEBUG_IO
1724     printf("pcnet_ioport_map addr=0x%08x 0x%08x\n", addr, size);
1725 #endif
1726
1727     cpu_register_physical_memory(addr, PCNET_PNPMMIO_SIZE, d->mmio_io_addr);
1728 }
1729
1730 void pci_pcnet_init(PCIBus *bus, NICInfo *nd)
1731 {
1732     PCNetState *d;
1733     uint8_t *pci_conf;
1734
1735 #if 0
1736     printf("sizeof(RMD)=%d, sizeof(TMD)=%d\n",
1737         sizeof(struct pcnet_RMD), sizeof(struct pcnet_TMD));
1738 #endif
1739
1740     d = (PCNetState *)pci_register_device(bus, "PCNet", sizeof(PCNetState),
1741                                           -1, NULL, NULL);
1742
1743     pci_conf = d->dev.config;
1744
1745     *(uint16_t *)&pci_conf[0x00] = cpu_to_le16(0x1022);
1746     *(uint16_t *)&pci_conf[0x02] = cpu_to_le16(0x2000);
1747     *(uint16_t *)&pci_conf[0x04] = cpu_to_le16(0x0007);
1748     *(uint16_t *)&pci_conf[0x06] = cpu_to_le16(0x0280);
1749     pci_conf[0x08] = 0x10;
1750     pci_conf[0x09] = 0x00;
1751     pci_conf[0x0a] = 0x00; // ethernet network controller
1752     pci_conf[0x0b] = 0x02;
1753     pci_conf[0x0e] = 0x00; // header_type
1754
1755     *(uint32_t *)&pci_conf[0x10] = cpu_to_le32(0x00000001);
1756     *(uint32_t *)&pci_conf[0x14] = cpu_to_le32(0x00000000);
1757
1758     pci_conf[0x3d] = 1; // interrupt pin 0
1759     pci_conf[0x3e] = 0x06;
1760     pci_conf[0x3f] = 0xff;
1761
1762     /* Handler for memory-mapped I/O */
1763     d->mmio_io_addr =
1764       cpu_register_io_memory(0, pcnet_mmio_read, pcnet_mmio_write, d);
1765
1766     pci_register_io_region((PCIDevice *)d, 0, PCNET_IOPORT_SIZE,
1767                            PCI_ADDRESS_SPACE_IO, pcnet_ioport_map);
1768
1769     pci_register_io_region((PCIDevice *)d, 1, PCNET_PNPMMIO_SIZE,
1770                            PCI_ADDRESS_SPACE_MEM, pcnet_mmio_map);
1771
1772     d->poll_timer = qemu_new_timer(vm_clock, pcnet_poll_timer, d);
1773
1774     d->nd = nd;
1775
1776     d->vc = qemu_new_vlan_client(nd->vlan, pcnet_receive,
1777                                  pcnet_can_receive, d);
1778
1779     snprintf(d->vc->info_str, sizeof(d->vc->info_str),
1780              "pcnet macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
1781              d->nd->macaddr[0],
1782              d->nd->macaddr[1],
1783              d->nd->macaddr[2],
1784              d->nd->macaddr[3],
1785              d->nd->macaddr[4],
1786              d->nd->macaddr[5]);
1787
1788     pcnet_h_reset(d);
1789 }