hw/eepro100.c

   1 /*
   2  * QEMU i8255x (PRO100) emulation
   3  *
   4  * Copyright (C) 2006-2011 Stefan Weil
   5  *
   6  * Portions of the code are copies from grub / etherboot eepro100.c
   7  * and linux e100.c.
   8  *
   9  * This program is free software: you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation, either version 2 of the License, or
  12  * (at your option) version 3 or any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  *
  22  * Tested features (i82559):
  23  *      PXE boot (i386 guest, i386 / mips / mipsel / ppc host) ok
  24  *      Linux networking (i386) ok
  25  *
  26  * Untested:
  27  *      Windows networking
  28  *
  29  * References:
  30  *
  31  * Intel 8255x 10/100 Mbps Ethernet Controller Family
  32  * Open Source Software Developer Manual
  33  *
  34  * TODO:
  35  *      * PHY emulation should be separated from nic emulation.
  36  *        Most nic emulations could share the same phy code.
  37  *      * i82550 is untested. It is programmed like the i82559.
  38  *      * i82562 is untested. It is programmed like the i82559.
  39  *      * Power management (i82558 and later) is not implemented.
  40  *      * Wake-on-LAN is not implemented.
  41  */
  42
  43 #include <stddef.h>             /* offsetof */
  44 #include "hw.h"
  45 #include "pci.h"
  46 #include "net.h"
  47 #include "eeprom93xx.h"
  48 #include "sysemu.h"
  49 #include "dma.h"
  50
  51 /* QEMU sends frames smaller than 60 bytes to ethernet nics.
  52  * Such frames are rejected by real nics and their emulations.
  53  * To avoid this behaviour, other nic emulations pad received
  54  * frames. The following definition enables this padding for
  55  * eepro100, too. We keep the define around in case it might
  56  * become useful the future if the core networking is ever
  57  * changed to pad short packets itself. */
  58 #define CONFIG_PAD_RECEIVED_FRAMES
  59
  60 #define KiB 1024
  61
  62 /* Debug EEPRO100 card. */
  63 #if 0
  64 # define DEBUG_EEPRO100
  65 #endif
  66
  67 #ifdef DEBUG_EEPRO100
  68 #define logout(fmt, ...) fprintf(stderr, "EE100\t%-24s" fmt, __func__, ## __VA_ARGS__)
  69 #else
  70 #define logout(fmt, ...) ((void)0)
  71 #endif
  72
  73 /* Set flags to 0 to disable debug output. */
  74 #define INT     1       /* interrupt related actions */
  75 #define MDI     1       /* mdi related actions */
  76 #define OTHER   1
  77 #define RXTX    1
  78 #define EEPROM  1       /* eeprom related actions */
  79
  80 #define TRACE(flag, command) ((flag) ? (command) : (void)0)
  81
  82 #define missing(text) fprintf(stderr, "eepro100: feature is missing in this emulation: " text "\n")
  83
  84 #define MAX_ETH_FRAME_SIZE 1514
  85
  86 /* This driver supports several different devices which are declared here. */
  87 #define i82550          0x82550
  88 #define i82551          0x82551
  89 #define i82557A         0x82557a
  90 #define i82557B         0x82557b
  91 #define i82557C         0x82557c
  92 #define i82558A         0x82558a
  93 #define i82558B         0x82558b
  94 #define i82559A         0x82559a
  95 #define i82559B         0x82559b
  96 #define i82559C         0x82559c
  97 #define i82559ER        0x82559e
  98 #define i82562          0x82562
  99 #define i82801          0x82801
 100
 101 /* Use 64 word EEPROM. TODO: could be a runtime option. */
 102 #define EEPROM_SIZE     64
 103
 104 #define PCI_MEM_SIZE            (4 * KiB)
 105 #define PCI_IO_SIZE             64
 106 #define PCI_FLASH_SIZE          (128 * KiB)
 107
 108 #define BIT(n) (1 << (n))
 109 #define BITS(n, m) (((0xffffffffU << (31 - n)) >> (31 - n + m)) << m)
 110
 111 /* The SCB accepts the following controls for the Tx and Rx units: */
 112 #define  CU_NOP         0x0000  /* No operation. */
 113 #define  CU_START       0x0010  /* CU start. */
 114 #define  CU_RESUME      0x0020  /* CU resume. */
 115 #define  CU_STATSADDR   0x0040  /* Load dump counters address. */
 116 #define  CU_SHOWSTATS   0x0050  /* Dump statistical counters. */
 117 #define  CU_CMD_BASE    0x0060  /* Load CU base address. */
 118 #define  CU_DUMPSTATS   0x0070  /* Dump and reset statistical counters. */
 119 #define  CU_SRESUME     0x00a0  /* CU static resume. */
 120
 121 #define  RU_NOP         0x0000
 122 #define  RX_START       0x0001
 123 #define  RX_RESUME      0x0002
 124 #define  RU_ABORT       0x0004
 125 #define  RX_ADDR_LOAD   0x0006
 126 #define  RX_RESUMENR    0x0007
 127 #define INT_MASK        0x0100
 128 #define DRVR_INT        0x0200  /* Driver generated interrupt. */
 129
 130 typedef struct {
 131     const char *name;
 132     const char *desc;
 133     uint16_t device_id;
 134     uint8_t revision;
 135     uint16_t subsystem_vendor_id;
 136     uint16_t subsystem_id;
 137
 138     uint32_t device;
 139     uint8_t stats_size;
 140     bool has_extended_tcb_support;
 141     bool power_management;
 142 } E100PCIDeviceInfo;
 143
 144 /* Offsets to the various registers.
 145    All accesses need not be longword aligned. */
 146 typedef enum {
 147     SCBStatus = 0,              /* Status Word. */
 148     SCBAck = 1,
 149     SCBCmd = 2,                 /* Rx/Command Unit command and status. */
 150     SCBIntmask = 3,
 151     SCBPointer = 4,             /* General purpose pointer. */
 152     SCBPort = 8,                /* Misc. commands and operands.  */
 153     SCBflash = 12,              /* Flash memory control. */
 154     SCBeeprom = 14,             /* EEPROM control. */
 155     SCBCtrlMDI = 16,            /* MDI interface control. */
 156     SCBEarlyRx = 20,            /* Early receive byte count. */
 157     SCBFlow = 24,               /* Flow Control. */
 158     SCBpmdr = 27,               /* Power Management Driver. */
 159     SCBgctrl = 28,              /* General Control. */
 160     SCBgstat = 29,              /* General Status. */
 161 } E100RegisterOffset;
 162
 163 /* A speedo3 transmit buffer descriptor with two buffers... */
 164 typedef struct {
 165     uint16_t status;
 166     uint16_t command;
 167     uint32_t link;              /* void * */
 168     uint32_t tbd_array_addr;    /* transmit buffer descriptor array address. */
 169     uint16_t tcb_bytes;         /* transmit command block byte count (in lower 14 bits */
 170     uint8_t tx_threshold;       /* transmit threshold */
 171     uint8_t tbd_count;          /* TBD number */
 172 #if 0
 173     /* This constitutes two "TBD" entries: hdr and data */
 174     uint32_t tx_buf_addr0;  /* void *, header of frame to be transmitted.  */
 175     int32_t  tx_buf_size0;  /* Length of Tx hdr. */
 176     uint32_t tx_buf_addr1;  /* void *, data to be transmitted.  */
 177     int32_t  tx_buf_size1;  /* Length of Tx data. */
 178 #endif
 179 } eepro100_tx_t;
 180
 181 /* Receive frame descriptor. */
 182 typedef struct {
 183     int16_t status;
 184     uint16_t command;
 185     uint32_t link;              /* struct RxFD * */
 186     uint32_t rx_buf_addr;       /* void * */
 187     uint16_t count;
 188     uint16_t size;
 189     /* Ethernet frame data follows. */
 190 } eepro100_rx_t;
 191
 192 typedef enum {
 193     COMMAND_EL = BIT(15),
 194     COMMAND_S = BIT(14),
 195     COMMAND_I = BIT(13),
 196     COMMAND_NC = BIT(4),
 197     COMMAND_SF = BIT(3),
 198     COMMAND_CMD = BITS(2, 0),
 199 } scb_command_bit;
 200
 201 typedef enum {
 202     STATUS_C = BIT(15),
 203     STATUS_OK = BIT(13),
 204 } scb_status_bit;
 205
 206 typedef struct {
 207     uint32_t tx_good_frames, tx_max_collisions, tx_late_collisions,
 208              tx_underruns, tx_lost_crs, tx_deferred, tx_single_collisions,
 209              tx_multiple_collisions, tx_total_collisions;
 210     uint32_t rx_good_frames, rx_crc_errors, rx_alignment_errors,
 211              rx_resource_errors, rx_overrun_errors, rx_cdt_errors,
 212              rx_short_frame_errors;
 213     uint32_t fc_xmt_pause, fc_rcv_pause, fc_rcv_unsupported;
 214     uint16_t xmt_tco_frames, rcv_tco_frames;
 215     /* TODO: i82559 has six reserved statistics but a total of 24 dwords. */
 216     uint32_t reserved[4];
 217 } eepro100_stats_t;
 218
 219 typedef enum {
 220     cu_idle = 0,
 221     cu_suspended = 1,
 222     cu_active = 2,
 223     cu_lpq_active = 2,
 224     cu_hqp_active = 3
 225 } cu_state_t;
 226
 227 typedef enum {
 228     ru_idle = 0,
 229     ru_suspended = 1,
 230     ru_no_resources = 2,
 231     ru_ready = 4
 232 } ru_state_t;
 233
 234 typedef struct {
 235     PCIDevice dev;
 236     /* Hash register (multicast mask array, multiple individual addresses). */
 237     uint8_t mult[8];
 238     MemoryRegion mmio_bar;
 239     MemoryRegion io_bar;
 240     MemoryRegion flash_bar;
 241     NICState *nic;
 242     NICConf conf;
 243     uint8_t scb_stat;           /* SCB stat/ack byte */
 244     uint8_t int_stat;           /* PCI interrupt status */
 245     /* region must not be saved by nic_save. */
 246     uint16_t mdimem[32];
 247     eeprom_t *eeprom;
 248     uint32_t device;            /* device variant */
 249     /* (cu_base + cu_offset) address the next command block in the command block list. */
 250     uint32_t cu_base;           /* CU base address */
 251     uint32_t cu_offset;         /* CU address offset */
 252     /* (ru_base + ru_offset) address the RFD in the Receive Frame Area. */
 253     uint32_t ru_base;           /* RU base address */
 254     uint32_t ru_offset;         /* RU address offset */
 255     uint32_t statsaddr;         /* pointer to eepro100_stats_t */
 256
 257     /* Temporary status information (no need to save these values),
 258      * used while processing CU commands. */
 259     eepro100_tx_t tx;           /* transmit buffer descriptor */
 260     uint32_t cb_address;        /* = cu_base + cu_offset */
 261
 262     /* Statistical counters. Also used for wake-up packet (i82559). */
 263     eepro100_stats_t statistics;
 264
 265     /* Data in mem is always in the byte order of the controller (le).
 266      * It must be dword aligned to allow direct access to 32 bit values. */
 267     uint8_t mem[PCI_MEM_SIZE] __attribute__((aligned(8)));
 268
 269     /* Configuration bytes. */
 270     uint8_t configuration[22];
 271
 272     /* vmstate for each particular nic */
 273     VMStateDescription *vmstate;
 274
 275     /* Quasi static device properties (no need to save them). */
 276     uint16_t stats_size;
 277     bool has_extended_tcb_support;
 278 } EEPRO100State;
 279
 280 /* Word indices in EEPROM. */
 281 typedef enum {
 282     EEPROM_CNFG_MDIX  = 0x03,
 283     EEPROM_ID         = 0x05,
 284     EEPROM_PHY_ID     = 0x06,
 285     EEPROM_VENDOR_ID  = 0x0c,
 286     EEPROM_CONFIG_ASF = 0x0d,
 287     EEPROM_DEVICE_ID  = 0x23,
 288     EEPROM_SMBUS_ADDR = 0x90,
 289 } EEPROMOffset;
 290
 291 /* Bit values for EEPROM ID word. */
 292 typedef enum {
 293     EEPROM_ID_MDM = BIT(0),     /* Modem */
 294     EEPROM_ID_STB = BIT(1),     /* Standby Enable */
 295     EEPROM_ID_WMR = BIT(2),     /* ??? */
 296     EEPROM_ID_WOL = BIT(5),     /* Wake on LAN */
 297     EEPROM_ID_DPD = BIT(6),     /* Deep Power Down */
 298     EEPROM_ID_ALT = BIT(7),     /* */
 299     /* BITS(10, 8) device revision */
 300     EEPROM_ID_BD = BIT(11),     /* boot disable */
 301     EEPROM_ID_ID = BIT(13),     /* id bit */
 302     /* BITS(15, 14) signature */
 303     EEPROM_ID_VALID = BIT(14),  /* signature for valid eeprom */
 304 } eeprom_id_bit;
 305
 306 /* Default values for MDI (PHY) registers */
 307 static const uint16_t eepro100_mdi_default[] = {
 308     /* MDI Registers 0 - 6, 7 */
 309     0x3000, 0x780d, 0x02a8, 0x0154, 0x05e1, 0x0000, 0x0000, 0x0000,
 310     /* MDI Registers 8 - 15 */
 311     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 312     /* MDI Registers 16 - 31 */
 313     0x0003, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 314     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 315 };
 316
 317 /* Readonly mask for MDI (PHY) registers */
 318 static const uint16_t eepro100_mdi_mask[] = {
 319     0x0000, 0xffff, 0xffff, 0xffff, 0xc01f, 0xffff, 0xffff, 0x0000,
 320     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 321     0x0fff, 0x0000, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 322     0xffff, 0xffff, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 323 };
 324
 325 static E100PCIDeviceInfo *eepro100_get_class(EEPRO100State *s);
 326
 327 /* Read a 16 bit control/status (CSR) register. */
 328 static uint16_t e100_read_reg2(EEPRO100State *s, E100RegisterOffset addr)
 329 {
 330     assert(!((uintptr_t)&s->mem[addr] & 1));
 331     return le16_to_cpup((uint16_t *)&s->mem[addr]);
 332 }
 333
 334 /* Read a 32 bit control/status (CSR) register. */
 335 static uint32_t e100_read_reg4(EEPRO100State *s, E100RegisterOffset addr)
 336 {
 337     assert(!((uintptr_t)&s->mem[addr] & 3));
 338     return le32_to_cpup((uint32_t *)&s->mem[addr]);
 339 }
 340
 341 /* Write a 16 bit control/status (CSR) register. */
 342 static void e100_write_reg2(EEPRO100State *s, E100RegisterOffset addr,
 343                             uint16_t val)
 344 {
 345     assert(!((uintptr_t)&s->mem[addr] & 1));
 346     cpu_to_le16w((uint16_t *)&s->mem[addr], val);
 347 }
 348
 349 /* Read a 32 bit control/status (CSR) register. */
 350 static void e100_write_reg4(EEPRO100State *s, E100RegisterOffset addr,
 351                             uint32_t val)
 352 {
 353     assert(!((uintptr_t)&s->mem[addr] & 3));
 354     cpu_to_le32w((uint32_t *)&s->mem[addr], val);
 355 }
 356
 357 #if defined(DEBUG_EEPRO100)
 358 static const char *nic_dump(const uint8_t * buf, unsigned size)
 359 {
 360     static char dump[3 * 16 + 1];
 361     char *p = &dump[0];
 362     if (size > 16) {
 363         size = 16;
 364     }
 365     while (size-- > 0) {
 366         p += sprintf(p, " %02x", *buf++);
 367     }
 368     return dump;
 369 }
 370 #endif                          /* DEBUG_EEPRO100 */
 371
 372 enum scb_stat_ack {
 373     stat_ack_not_ours = 0x00,
 374     stat_ack_sw_gen = 0x04,
 375     stat_ack_rnr = 0x10,
 376     stat_ack_cu_idle = 0x20,
 377     stat_ack_frame_rx = 0x40,
 378     stat_ack_cu_cmd_done = 0x80,
 379     stat_ack_not_present = 0xFF,
 380     stat_ack_rx = (stat_ack_sw_gen | stat_ack_rnr | stat_ack_frame_rx),
 381     stat_ack_tx = (stat_ack_cu_idle | stat_ack_cu_cmd_done),
 382 };
 383
 384 static void disable_interrupt(EEPRO100State * s)
 385 {
 386     if (s->int_stat) {
 387         TRACE(INT, logout("interrupt disabled\n"));
 388         qemu_irq_lower(s->dev.irq[0]);
 389         s->int_stat = 0;
 390     }
 391 }
 392
 393 static void enable_interrupt(EEPRO100State * s)
 394 {
 395     if (!s->int_stat) {
 396         TRACE(INT, logout("interrupt enabled\n"));
 397         qemu_irq_raise(s->dev.irq[0]);
 398         s->int_stat = 1;
 399     }
 400 }
 401
 402 static void eepro100_acknowledge(EEPRO100State * s)
 403 {
 404     s->scb_stat &= ~s->mem[SCBAck];
 405     s->mem[SCBAck] = s->scb_stat;
 406     if (s->scb_stat == 0) {
 407         disable_interrupt(s);
 408     }
 409 }
 410
 411 static void eepro100_interrupt(EEPRO100State * s, uint8_t status)
 412 {
 413     uint8_t mask = ~s->mem[SCBIntmask];
 414     s->mem[SCBAck] |= status;
 415     status = s->scb_stat = s->mem[SCBAck];
 416     status &= (mask | 0x0f);
 417 #if 0
 418     status &= (~s->mem[SCBIntmask] | 0x0xf);
 419 #endif
 420     if (status && (mask & 0x01)) {
 421         /* SCB mask and SCB Bit M do not disable interrupt. */
 422         enable_interrupt(s);
 423     } else if (s->int_stat) {
 424         disable_interrupt(s);
 425     }
 426 }
 427
 428 static void eepro100_cx_interrupt(EEPRO100State * s)
 429 {
 430     /* CU completed action command. */
 431     /* Transmit not ok (82557 only, not in emulation). */
 432     eepro100_interrupt(s, 0x80);
 433 }
 434
 435 static void eepro100_cna_interrupt(EEPRO100State * s)
 436 {
 437     /* CU left the active state. */
 438     eepro100_interrupt(s, 0x20);
 439 }
 440
 441 static void eepro100_fr_interrupt(EEPRO100State * s)
 442 {
 443     /* RU received a complete frame. */
 444     eepro100_interrupt(s, 0x40);
 445 }
 446
 447 static void eepro100_rnr_interrupt(EEPRO100State * s)
 448 {
 449     /* RU is not ready. */
 450     eepro100_interrupt(s, 0x10);
 451 }
 452
 453 static void eepro100_mdi_interrupt(EEPRO100State * s)
 454 {
 455     /* MDI completed read or write cycle. */
 456     eepro100_interrupt(s, 0x08);
 457 }
 458
 459 static void eepro100_swi_interrupt(EEPRO100State * s)
 460 {
 461     /* Software has requested an interrupt. */
 462     eepro100_interrupt(s, 0x04);
 463 }
 464
 465 #if 0
 466 static void eepro100_fcp_interrupt(EEPRO100State * s)
 467 {
 468     /* Flow control pause interrupt (82558 and later). */
 469     eepro100_interrupt(s, 0x01);
 470 }
 471 #endif
 472
 473 static void e100_pci_reset(EEPRO100State * s)
 474 {
 475     E100PCIDeviceInfo *info = eepro100_get_class(s);
 476     uint32_t device = s->device;
 477     uint8_t *pci_conf = s->dev.config;
 478
 479     TRACE(OTHER, logout("%p\n", s));
 480
 481     /* PCI Status */
 482     pci_set_word(pci_conf + PCI_STATUS, PCI_STATUS_DEVSEL_MEDIUM |
 483                                         PCI_STATUS_FAST_BACK);
 484     /* PCI Latency Timer */
 485     pci_set_byte(pci_conf + PCI_LATENCY_TIMER, 0x20);   /* latency timer = 32 clocks */
 486     /* Capability Pointer is set by PCI framework. */
 487     /* Interrupt Line */
 488     /* Interrupt Pin */
 489     pci_set_byte(pci_conf + PCI_INTERRUPT_PIN, 1);      /* interrupt pin A */
 490     /* Minimum Grant */
 491     pci_set_byte(pci_conf + PCI_MIN_GNT, 0x08);
 492     /* Maximum Latency */
 493     pci_set_byte(pci_conf + PCI_MAX_LAT, 0x18);
 494
 495     s->stats_size = info->stats_size;
 496     s->has_extended_tcb_support = info->has_extended_tcb_support;
 497
 498     switch (device) {
 499     case i82550:
 500     case i82551:
 501     case i82557A:
 502     case i82557B:
 503     case i82557C:
 504     case i82558A:
 505     case i82558B:
 506     case i82559A:
 507     case i82559B:
 508     case i82559ER:
 509     case i82562:
 510     case i82801:
 511     case i82559C:
 512         break;
 513     default:
 514         logout("Device %X is undefined!\n", device);
 515     }
 516
 517     /* Standard TxCB. */
 518     s->configuration[6] |= BIT(4);
 519
 520     /* Standard statistical counters. */
 521     s->configuration[6] |= BIT(5);
 522
 523     if (s->stats_size == 80) {
 524         /* TODO: check TCO Statistical Counters bit. Documentation not clear. */
 525         if (s->configuration[6] & BIT(2)) {
 526             /* TCO statistical counters. */
 527             assert(s->configuration[6] & BIT(5));
 528         } else {
 529             if (s->configuration[6] & BIT(5)) {
 530                 /* No extended statistical counters, i82557 compatible. */
 531                 s->stats_size = 64;
 532             } else {
 533                 /* i82558 compatible. */
 534                 s->stats_size = 76;
 535             }
 536         }
 537     } else {
 538         if (s->configuration[6] & BIT(5)) {
 539             /* No extended statistical counters. */
 540             s->stats_size = 64;
 541         }
 542     }
 543     assert(s->stats_size > 0 && s->stats_size <= sizeof(s->statistics));
 544
 545     if (info->power_management) {
 546         /* Power Management Capabilities */
 547         int cfg_offset = 0xdc;
 548         int r = pci_add_capability(&s->dev, PCI_CAP_ID_PM,
 549                                    cfg_offset, PCI_PM_SIZEOF);
 550         assert(r >= 0);
 551         pci_set_word(pci_conf + cfg_offset + PCI_PM_PMC, 0x7e21);
 552 #if 0 /* TODO: replace dummy code for power management emulation. */
 553         /* TODO: Power Management Control / Status. */
 554         pci_set_word(pci_conf + cfg_offset + PCI_PM_CTRL, 0x0000);
 555         /* TODO: Ethernet Power Consumption Registers (i82559 and later). */
 556         pci_set_byte(pci_conf + cfg_offset + PCI_PM_PPB_EXTENSIONS, 0x0000);
 557 #endif
 558     }
 559
 560 #if EEPROM_SIZE > 0
 561     if (device == i82557C || device == i82558B || device == i82559C) {
 562         /*
 563         TODO: get vendor id from EEPROM for i82557C or later.
 564         TODO: get device id from EEPROM for i82557C or later.
 565         TODO: status bit 4 can be disabled by EEPROM for i82558, i82559.
 566         TODO: header type is determined by EEPROM for i82559.
 567         TODO: get subsystem id from EEPROM for i82557C or later.
 568         TODO: get subsystem vendor id from EEPROM for i82557C or later.
 569         TODO: exp. rom baddr depends on a bit in EEPROM for i82558 or later.
 570         TODO: capability pointer depends on EEPROM for i82558.
 571         */
 572         logout("Get device id and revision from EEPROM!!!\n");
 573     }
 574 #endif /* EEPROM_SIZE > 0 */
 575 }
 576
 577 static void nic_selective_reset(EEPRO100State * s)
 578 {
 579     size_t i;
 580     uint16_t *eeprom_contents = eeprom93xx_data(s->eeprom);
 581 #if 0
 582     eeprom93xx_reset(s->eeprom);
 583 #endif
 584     memcpy(eeprom_contents, s->conf.macaddr.a, 6);
 585     eeprom_contents[EEPROM_ID] = EEPROM_ID_VALID;
 586     if (s->device == i82557B || s->device == i82557C)
 587         eeprom_contents[5] = 0x0100;
 588     eeprom_contents[EEPROM_PHY_ID] = 1;
 589     uint16_t sum = 0;
 590     for (i = 0; i < EEPROM_SIZE - 1; i++) {
 591         sum += eeprom_contents[i];
 592     }
 593     eeprom_contents[EEPROM_SIZE - 1] = 0xbaba - sum;
 594     TRACE(EEPROM, logout("checksum=0x%04x\n", eeprom_contents[EEPROM_SIZE - 1]));
 595
 596     memset(s->mem, 0, sizeof(s->mem));
 597     e100_write_reg4(s, SCBCtrlMDI, BIT(21));
 598
 599     assert(sizeof(s->mdimem) == sizeof(eepro100_mdi_default));
 600     memcpy(&s->mdimem[0], &eepro100_mdi_default[0], sizeof(s->mdimem));
 601 }
 602
 603 static void nic_reset(void *opaque)
 604 {
 605     EEPRO100State *s = opaque;
 606     TRACE(OTHER, logout("%p\n", s));
 607     /* TODO: Clearing of hash register for selective reset, too? */
 608     memset(&s->mult[0], 0, sizeof(s->mult));
 609     nic_selective_reset(s);
 610 }
 611
 612 #if defined(DEBUG_EEPRO100)
 613 static const char * const e100_reg[PCI_IO_SIZE / 4] = {
 614     "Command/Status",
 615     "General Pointer",
 616     "Port",
 617     "EEPROM/Flash Control",
 618     "MDI Control",
 619     "Receive DMA Byte Count",
 620     "Flow Control",
 621     "General Status/Control"
 622 };
 623
 624 static char *regname(uint32_t addr)
 625 {
 626     static char buf[32];
 627     if (addr < PCI_IO_SIZE) {
 628         const char *r = e100_reg[addr / 4];
 629         if (r != 0) {
 630             snprintf(buf, sizeof(buf), "%s+%u", r, addr % 4);
 631         } else {
 632             snprintf(buf, sizeof(buf), "0x%02x", addr);
 633         }
 634     } else {
 635         snprintf(buf, sizeof(buf), "??? 0x%08x", addr);
 636     }
 637     return buf;
 638 }
 639 #endif                          /* DEBUG_EEPRO100 */
 640
 641 /*****************************************************************************
 642  *
 643  * Command emulation.
 644  *
 645  ****************************************************************************/
 646
 647 #if 0
 648 static uint16_t eepro100_read_command(EEPRO100State * s)
 649 {
 650     uint16_t val = 0xffff;
 651     TRACE(OTHER, logout("val=0x%04x\n", val));
 652     return val;
 653 }
 654 #endif
 655
 656 /* Commands that can be put in a command list entry. */
 657 enum commands {
 658     CmdNOp = 0,
 659     CmdIASetup = 1,
 660     CmdConfigure = 2,
 661     CmdMulticastList = 3,
 662     CmdTx = 4,
 663     CmdTDR = 5,                 /* load microcode */
 664     CmdDump = 6,
 665     CmdDiagnose = 7,
 666
 667     /* And some extra flags: */
 668     CmdSuspend = 0x4000,        /* Suspend after completion. */
 669     CmdIntr = 0x2000,           /* Interrupt after completion. */
 670     CmdTxFlex = 0x0008,         /* Use "Flexible mode" for CmdTx command. */
 671 };
 672
 673 static cu_state_t get_cu_state(EEPRO100State * s)
 674 {
 675     return ((s->mem[SCBStatus] & BITS(7, 6)) >> 6);
 676 }
 677
 678 static void set_cu_state(EEPRO100State * s, cu_state_t state)
 679 {
 680     s->mem[SCBStatus] = (s->mem[SCBStatus] & ~BITS(7, 6)) + (state << 6);
 681 }
 682
 683 static ru_state_t get_ru_state(EEPRO100State * s)
 684 {
 685     return ((s->mem[SCBStatus] & BITS(5, 2)) >> 2);
 686 }
 687
 688 static void set_ru_state(EEPRO100State * s, ru_state_t state)
 689 {
 690     s->mem[SCBStatus] = (s->mem[SCBStatus] & ~BITS(5, 2)) + (state << 2);
 691 }
 692
 693 static void dump_statistics(EEPRO100State * s)
 694 {
 695     /* Dump statistical data. Most data is never changed by the emulation
 696      * and always 0, so we first just copy the whole block and then those
 697      * values which really matter.
 698      * Number of data should check configuration!!!
 699      */
 700     pci_dma_write(&s->dev, s->statsaddr, &s->statistics, s->stats_size);
 701     stl_le_pci_dma(&s->dev, s->statsaddr + 0,
 702                    s->statistics.tx_good_frames);
 703     stl_le_pci_dma(&s->dev, s->statsaddr + 36,
 704                    s->statistics.rx_good_frames);
 705     stl_le_pci_dma(&s->dev, s->statsaddr + 48,
 706                    s->statistics.rx_resource_errors);
 707     stl_le_pci_dma(&s->dev, s->statsaddr + 60,
 708                    s->statistics.rx_short_frame_errors);
 709 #if 0
 710     stw_le_pci_dma(&s->dev, s->statsaddr + 76, s->statistics.xmt_tco_frames);
 711     stw_le_pci_dma(&s->dev, s->statsaddr + 78, s->statistics.rcv_tco_frames);
 712     missing("CU dump statistical counters");
 713 #endif
 714 }
 715
 716 static void read_cb(EEPRO100State *s)
 717 {
 718     pci_dma_read(&s->dev, s->cb_address, &s->tx, sizeof(s->tx));
 719     s->tx.status = le16_to_cpu(s->tx.status);
 720     s->tx.command = le16_to_cpu(s->tx.command);
 721     s->tx.link = le32_to_cpu(s->tx.link);
 722     s->tx.tbd_array_addr = le32_to_cpu(s->tx.tbd_array_addr);
 723     s->tx.tcb_bytes = le16_to_cpu(s->tx.tcb_bytes);
 724 }
 725
 726 static void tx_command(EEPRO100State *s)
 727 {
 728     uint32_t tbd_array = le32_to_cpu(s->tx.tbd_array_addr);
 729     uint16_t tcb_bytes = (le16_to_cpu(s->tx.tcb_bytes) & 0x3fff);
 730     /* Sends larger than MAX_ETH_FRAME_SIZE are allowed, up to 2600 bytes. */
 731     uint8_t buf[2600];
 732     uint16_t size = 0;
 733     uint32_t tbd_address = s->cb_address + 0x10;
 734     TRACE(RXTX, logout
 735         ("transmit, TBD array address 0x%08x, TCB byte count 0x%04x, TBD count %u\n",
 736          tbd_array, tcb_bytes, s->tx.tbd_count));
 737
 738     if (tcb_bytes > 2600) {
 739         logout("TCB byte count too large, using 2600\n");
 740         tcb_bytes = 2600;
 741     }
 742     if (!((tcb_bytes > 0) || (tbd_array != 0xffffffff))) {
 743         logout
 744             ("illegal values of TBD array address and TCB byte count!\n");
 745     }
 746     assert(tcb_bytes <= sizeof(buf));
 747     while (size < tcb_bytes) {
 748         uint32_t tx_buffer_address = ldl_le_pci_dma(&s->dev, tbd_address);
 749         uint16_t tx_buffer_size = lduw_le_pci_dma(&s->dev, tbd_address + 4);
 750 #if 0
 751         uint16_t tx_buffer_el = lduw_le_pci_dma(&s->dev, tbd_address + 6);
 752 #endif
 753         tbd_address += 8;
 754         TRACE(RXTX, logout
 755             ("TBD (simplified mode): buffer address 0x%08x, size 0x%04x\n",
 756              tx_buffer_address, tx_buffer_size));
 757         tx_buffer_size = MIN(tx_buffer_size, sizeof(buf) - size);
 758         pci_dma_read(&s->dev, tx_buffer_address, &buf[size], tx_buffer_size);
 759         size += tx_buffer_size;
 760     }
 761     if (tbd_array == 0xffffffff) {
 762         /* Simplified mode. Was already handled by code above. */
 763     } else {
 764         /* Flexible mode. */
 765         uint8_t tbd_count = 0;
 766         if (s->has_extended_tcb_support && !(s->configuration[6] & BIT(4))) {
 767             /* Extended Flexible TCB. */
 768             for (; tbd_count < 2; tbd_count++) {
 769                 uint32_t tx_buffer_address = ldl_le_pci_dma(&s->dev,
 770                                                             tbd_address);
 771                 uint16_t tx_buffer_size = lduw_le_pci_dma(&s->dev,
 772                                                           tbd_address + 4);
 773                 uint16_t tx_buffer_el = lduw_le_pci_dma(&s->dev,
 774                                                         tbd_address + 6);
 775                 tbd_address += 8;
 776                 TRACE(RXTX, logout
 777                     ("TBD (extended flexible mode): buffer address 0x%08x, size 0x%04x\n",
 778                      tx_buffer_address, tx_buffer_size));
 779                 tx_buffer_size = MIN(tx_buffer_size, sizeof(buf) - size);
 780                 pci_dma_read(&s->dev, tx_buffer_address,
 781                              &buf[size], tx_buffer_size);
 782                 size += tx_buffer_size;
 783                 if (tx_buffer_el & 1) {
 784                     break;
 785                 }
 786             }
 787         }
 788         tbd_address = tbd_array;
 789         for (; tbd_count < s->tx.tbd_count; tbd_count++) {
 790             uint32_t tx_buffer_address = ldl_le_pci_dma(&s->dev, tbd_address);
 791             uint16_t tx_buffer_size = lduw_le_pci_dma(&s->dev, tbd_address + 4);
 792             uint16_t tx_buffer_el = lduw_le_pci_dma(&s->dev, tbd_address + 6);
 793             tbd_address += 8;
 794             TRACE(RXTX, logout
 795                 ("TBD (flexible mode): buffer address 0x%08x, size 0x%04x\n",
 796                  tx_buffer_address, tx_buffer_size));
 797             tx_buffer_size = MIN(tx_buffer_size, sizeof(buf) - size);
 798             pci_dma_read(&s->dev, tx_buffer_address,
 799                          &buf[size], tx_buffer_size);
 800             size += tx_buffer_size;
 801             if (tx_buffer_el & 1) {
 802                 break;
 803             }
 804         }
 805     }
 806     TRACE(RXTX, logout("%p sending frame, len=%d,%s\n", s, size, nic_dump(buf, size)));
 807     qemu_send_packet(&s->nic->nc, buf, size);
 808     s->statistics.tx_good_frames++;
 809     /* Transmit with bad status would raise an CX/TNO interrupt.
 810      * (82557 only). Emulation never has bad status. */
 811 #if 0
 812     eepro100_cx_interrupt(s);
 813 #endif
 814 }
 815
 816 static void set_multicast_list(EEPRO100State *s)
 817 {
 818     uint16_t multicast_count = s->tx.tbd_array_addr & BITS(13, 0);
 819     uint16_t i;
 820     memset(&s->mult[0], 0, sizeof(s->mult));
 821     TRACE(OTHER, logout("multicast list, multicast count = %u\n", multicast_count));
 822     for (i = 0; i < multicast_count; i += 6) {
 823         uint8_t multicast_addr[6];
 824         pci_dma_read(&s->dev, s->cb_address + 10 + i, multicast_addr, 6);
 825         TRACE(OTHER, logout("multicast entry %s\n", nic_dump(multicast_addr, 6)));
 826         unsigned mcast_idx = compute_mcast_idx(multicast_addr);
 827         assert(mcast_idx < 64);
 828         s->mult[mcast_idx >> 3] |= (1 << (mcast_idx & 7));
 829     }
 830 }
 831
 832 static void action_command(EEPRO100State *s)
 833 {
 834     for (;;) {
 835         bool bit_el;
 836         bool bit_s;
 837         bool bit_i;
 838         bool bit_nc;
 839         uint16_t ok_status = STATUS_OK;
 840         s->cb_address = s->cu_base + s->cu_offset;
 841         read_cb(s);
 842         bit_el = ((s->tx.command & COMMAND_EL) != 0);
 843         bit_s = ((s->tx.command & COMMAND_S) != 0);
 844         bit_i = ((s->tx.command & COMMAND_I) != 0);
 845         bit_nc = ((s->tx.command & COMMAND_NC) != 0);
 846 #if 0
 847         bool bit_sf = ((s->tx.command & COMMAND_SF) != 0);
 848 #endif
 849         s->cu_offset = s->tx.link;
 850         TRACE(OTHER,
 851               logout("val=(cu start), status=0x%04x, command=0x%04x, link=0x%08x\n",
 852                      s->tx.status, s->tx.command, s->tx.link));
 853         switch (s->tx.command & COMMAND_CMD) {
 854         case CmdNOp:
 855             /* Do nothing. */
 856             break;
 857         case CmdIASetup:
 858             pci_dma_read(&s->dev, s->cb_address + 8, &s->conf.macaddr.a[0], 6);
 859             TRACE(OTHER, logout("macaddr: %s\n", nic_dump(&s->conf.macaddr.a[0], 6)));
 860             break;
 861         case CmdConfigure:
 862             pci_dma_read(&s->dev, s->cb_address + 8,
 863                          &s->configuration[0], sizeof(s->configuration));
 864             TRACE(OTHER, logout("configuration: %s\n",
 865                                 nic_dump(&s->configuration[0], 16)));
 866             TRACE(OTHER, logout("configuration: %s\n",
 867                                 nic_dump(&s->configuration[16],
 868                                 ARRAY_SIZE(s->configuration) - 16)));
 869             if (s->configuration[20] & BIT(6)) {
 870                 TRACE(OTHER, logout("Multiple IA bit\n"));
 871             }
 872             break;
 873         case CmdMulticastList:
 874             set_multicast_list(s);
 875             break;
 876         case CmdTx:
 877             if (bit_nc) {
 878                 missing("CmdTx: NC = 0");
 879                 ok_status = 0;
 880                 break;
 881             }
 882             tx_command(s);
 883             break;
 884         case CmdTDR:
 885             TRACE(OTHER, logout("load microcode\n"));
 886             /* Starting with offset 8, the command contains
 887              * 64 dwords microcode which we just ignore here. */
 888             break;
 889         case CmdDiagnose:
 890             TRACE(OTHER, logout("diagnose\n"));
 891             /* Make sure error flag is not set. */
 892             s->tx.status = 0;
 893             break;
 894         default:
 895             missing("undefined command");
 896             ok_status = 0;
 897             break;
 898         }
 899         /* Write new status. */
 900         stw_le_pci_dma(&s->dev, s->cb_address,
 901                        s->tx.status | ok_status | STATUS_C);
 902         if (bit_i) {
 903             /* CU completed action. */
 904             eepro100_cx_interrupt(s);
 905         }
 906         if (bit_el) {
 907             /* CU becomes idle. Terminate command loop. */
 908             set_cu_state(s, cu_idle);
 909             eepro100_cna_interrupt(s);
 910             break;
 911         } else if (bit_s) {
 912             /* CU becomes suspended. Terminate command loop. */
 913             set_cu_state(s, cu_suspended);
 914             eepro100_cna_interrupt(s);
 915             break;
 916         } else {
 917             /* More entries in list. */
 918             TRACE(OTHER, logout("CU list with at least one more entry\n"));
 919         }
 920     }
 921     TRACE(OTHER, logout("CU list empty\n"));
 922     /* List is empty. Now CU is idle or suspended. */
 923 }
 924
 925 static void eepro100_cu_command(EEPRO100State * s, uint8_t val)
 926 {
 927     cu_state_t cu_state;
 928     switch (val) {
 929     case CU_NOP:
 930         /* No operation. */
 931         break;
 932     case CU_START:
 933         cu_state = get_cu_state(s);
 934         if (cu_state != cu_idle && cu_state != cu_suspended) {
 935             /* Intel documentation says that CU must be idle or suspended
 936              * for the CU start command. */
 937             logout("unexpected CU state is %u\n", cu_state);
 938         }
 939         set_cu_state(s, cu_active);
 940         s->cu_offset = e100_read_reg4(s, SCBPointer);
 941         action_command(s);
 942         break;
 943     case CU_RESUME:
 944         if (get_cu_state(s) != cu_suspended) {
 945             logout("bad CU resume from CU state %u\n", get_cu_state(s));
 946             /* Workaround for bad Linux eepro100 driver which resumes
 947              * from idle state. */
 948 #if 0
 949             missing("cu resume");
 950 #endif
 951             set_cu_state(s, cu_suspended);
 952         }
 953         if (get_cu_state(s) == cu_suspended) {
 954             TRACE(OTHER, logout("CU resuming\n"));
 955             set_cu_state(s, cu_active);
 956             action_command(s);
 957         }
 958         break;
 959     case CU_STATSADDR:
 960         /* Load dump counters address. */
 961         s->statsaddr = e100_read_reg4(s, SCBPointer);
 962         TRACE(OTHER, logout("val=0x%02x (dump counters address)\n", val));
 963         if (s->statsaddr & 3) {
 964             /* Memory must be Dword aligned. */
 965             logout("unaligned dump counters address\n");
 966             /* Handling of misaligned addresses is undefined.
 967              * Here we align the address by ignoring the lower bits. */
 968             /* TODO: Test unaligned dump counter address on real hardware. */
 969             s->statsaddr &= ~3;
 970         }
 971         break;
 972     case CU_SHOWSTATS:
 973         /* Dump statistical counters. */
 974         TRACE(OTHER, logout("val=0x%02x (dump stats)\n", val));
 975         dump_statistics(s);
 976         stl_le_pci_dma(&s->dev, s->statsaddr + s->stats_size, 0xa005);
 977         break;
 978     case CU_CMD_BASE:
 979         /* Load CU base. */
 980         TRACE(OTHER, logout("val=0x%02x (CU base address)\n", val));
 981         s->cu_base = e100_read_reg4(s, SCBPointer);
 982         break;
 983     case CU_DUMPSTATS:
 984         /* Dump and reset statistical counters. */
 985         TRACE(OTHER, logout("val=0x%02x (dump stats and reset)\n", val));
 986         dump_statistics(s);
 987         stl_le_pci_dma(&s->dev, s->statsaddr + s->stats_size, 0xa007);
 988         memset(&s->statistics, 0, sizeof(s->statistics));
 989         break;
 990     case CU_SRESUME:
 991         /* CU static resume. */
 992         missing("CU static resume");
 993         break;
 994     default:
 995         missing("Undefined CU command");
 996     }
 997 }
 998
 999 static void eepro100_ru_command(EEPRO100State * s, uint8_t val)
1000 {
1001     switch (val) {
1002     case RU_NOP:
1003         /* No operation. */
1004         break;
1005     case RX_START:
1006         /* RU start. */
1007         if (get_ru_state(s) != ru_idle) {
1008             logout("RU state is %u, should be %u\n", get_ru_state(s), ru_idle);
1009 #if 0
1010             assert(!"wrong RU state");
1011 #endif
1012         }
1013         set_ru_state(s, ru_ready);
1014         s->ru_offset = e100_read_reg4(s, SCBPointer);
1015         TRACE(OTHER, logout("val=0x%02x (rx start)\n", val));
1016         break;
1017     case RX_RESUME:
1018         /* Restart RU. */
1019         if (get_ru_state(s) != ru_suspended) {
1020             logout("RU state is %u, should be %u\n", get_ru_state(s),
1021                    ru_suspended);
1022 #if 0
1023             assert(!"wrong RU state");
1024 #endif
1025         }
1026         set_ru_state(s, ru_ready);
1027         break;
1028     case RU_ABORT:
1029         /* RU abort. */
1030         if (get_ru_state(s) == ru_ready) {
1031             eepro100_rnr_interrupt(s);
1032         }
1033         set_ru_state(s, ru_idle);
1034         break;
1035     case RX_ADDR_LOAD:
1036         /* Load RU base. */
1037         TRACE(OTHER, logout("val=0x%02x (RU base address)\n", val));
1038         s->ru_base = e100_read_reg4(s, SCBPointer);
1039         break;
1040     default:
1041         logout("val=0x%02x (undefined RU command)\n", val);
1042         missing("Undefined SU command");
1043     }
1044 }
1045
1046 static void eepro100_write_command(EEPRO100State * s, uint8_t val)
1047 {
1048     eepro100_ru_command(s, val & 0x0f);
1049     eepro100_cu_command(s, val & 0xf0);
1050     if ((val) == 0) {
1051         TRACE(OTHER, logout("val=0x%02x\n", val));
1052     }
1053     /* Clear command byte after command was accepted. */
1054     s->mem[SCBCmd] = 0;
1055 }
1056
1057 /*****************************************************************************
1058  *
1059  * EEPROM emulation.
1060  *
1061  ****************************************************************************/
1062
1063 #define EEPROM_CS       0x02
1064 #define EEPROM_SK       0x01
1065 #define EEPROM_DI       0x04
1066 #define EEPROM_DO       0x08
1067
1068 static uint16_t eepro100_read_eeprom(EEPRO100State * s)
1069 {
1070     uint16_t val = e100_read_reg2(s, SCBeeprom);
1071     if (eeprom93xx_read(s->eeprom)) {
1072         val |= EEPROM_DO;
1073     } else {
1074         val &= ~EEPROM_DO;
1075     }
1076     TRACE(EEPROM, logout("val=0x%04x\n", val));
1077     return val;
1078 }
1079
1080 static void eepro100_write_eeprom(eeprom_t * eeprom, uint8_t val)
1081 {
1082     TRACE(EEPROM, logout("val=0x%02x\n", val));
1083
1084     /* mask unwritable bits */
1085 #if 0
1086     val = SET_MASKED(val, 0x31, eeprom->value);
1087 #endif
1088
1089     int eecs = ((val & EEPROM_CS) != 0);
1090     int eesk = ((val & EEPROM_SK) != 0);
1091     int eedi = ((val & EEPROM_DI) != 0);
1092     eeprom93xx_write(eeprom, eecs, eesk, eedi);
1093 }
1094
1095 /*****************************************************************************
1096  *
1097  * MDI emulation.
1098  *
1099  ****************************************************************************/
1100
1101 #if defined(DEBUG_EEPRO100)
1102 static const char * const mdi_op_name[] = {
1103     "opcode 0",
1104     "write",
1105     "read",
1106     "opcode 3"
1107 };
1108
1109 static const char * const mdi_reg_name[] = {
1110     "Control",
1111     "Status",
1112     "PHY Identification (Word 1)",
1113     "PHY Identification (Word 2)",
1114     "Auto-Negotiation Advertisement",
1115     "Auto-Negotiation Link Partner Ability",
1116     "Auto-Negotiation Expansion"
1117 };
1118
1119 static const char *reg2name(uint8_t reg)
1120 {
1121     static char buffer[10];
1122     const char *p = buffer;
1123     if (reg < ARRAY_SIZE(mdi_reg_name)) {
1124         p = mdi_reg_name[reg];
1125     } else {
1126         snprintf(buffer, sizeof(buffer), "reg=0x%02x", reg);
1127     }
1128     return p;
1129 }
1130 #endif                          /* DEBUG_EEPRO100 */
1131
1132 static uint32_t eepro100_read_mdi(EEPRO100State * s)
1133 {
1134     uint32_t val = e100_read_reg4(s, SCBCtrlMDI);
1135
1136 #ifdef DEBUG_EEPRO100
1137     uint8_t raiseint = (val & BIT(29)) >> 29;
1138     uint8_t opcode = (val & BITS(27, 26)) >> 26;
1139     uint8_t phy = (val & BITS(25, 21)) >> 21;
1140     uint8_t reg = (val & BITS(20, 16)) >> 16;
1141     uint16_t data = (val & BITS(15, 0));
1142 #endif
1143     /* Emulation takes no time to finish MDI transaction. */
1144     val |= BIT(28);
1145     TRACE(MDI, logout("val=0x%08x (int=%u, %s, phy=%u, %s, data=0x%04x\n",
1146                       val, raiseint, mdi_op_name[opcode], phy,
1147                       reg2name(reg), data));
1148     return val;
1149 }
1150
1151 static void eepro100_write_mdi(EEPRO100State *s)
1152 {
1153     uint32_t val = e100_read_reg4(s, SCBCtrlMDI);
1154     uint8_t raiseint = (val & BIT(29)) >> 29;
1155     uint8_t opcode = (val & BITS(27, 26)) >> 26;
1156     uint8_t phy = (val & BITS(25, 21)) >> 21;
1157     uint8_t reg = (val & BITS(20, 16)) >> 16;
1158     uint16_t data = (val & BITS(15, 0));
1159     TRACE(MDI, logout("val=0x%08x (int=%u, %s, phy=%u, %s, data=0x%04x\n",
1160           val, raiseint, mdi_op_name[opcode], phy, reg2name(reg), data));
1161     if (phy != 1) {
1162         /* Unsupported PHY address. */
1163 #if 0
1164         logout("phy must be 1 but is %u\n", phy);
1165 #endif
1166         data = 0;
1167     } else if (opcode != 1 && opcode != 2) {
1168         /* Unsupported opcode. */
1169         logout("opcode must be 1 or 2 but is %u\n", opcode);
1170         data = 0;
1171     } else if (reg > 6) {
1172         /* Unsupported register. */
1173         logout("register must be 0...6 but is %u\n", reg);
1174         data = 0;
1175     } else {
1176         TRACE(MDI, logout("val=0x%08x (int=%u, %s, phy=%u, %s, data=0x%04x\n",
1177                           val, raiseint, mdi_op_name[opcode], phy,
1178                           reg2name(reg), data));
1179         if (opcode == 1) {
1180             /* MDI write */
1181             switch (reg) {
1182             case 0:            /* Control Register */
1183                 if (data & 0x8000) {
1184                     /* Reset status and control registers to default. */
1185                     s->mdimem[0] = eepro100_mdi_default[0];
1186                     s->mdimem[1] = eepro100_mdi_default[1];
1187                     data = s->mdimem[reg];
1188                 } else {
1189                     /* Restart Auto Configuration = Normal Operation */
1190                     data &= ~0x0200;
1191                 }
1192                 break;
1193             case 1:            /* Status Register */
1194                 missing("not writable");
1195                 data = s->mdimem[reg];
1196                 break;
1197             case 2:            /* PHY Identification Register (Word 1) */
1198             case 3:            /* PHY Identification Register (Word 2) */
1199                 missing("not implemented");
1200                 break;
1201             case 4:            /* Auto-Negotiation Advertisement Register */
1202             case 5:            /* Auto-Negotiation Link Partner Ability Register */
1203                 break;
1204             case 6:            /* Auto-Negotiation Expansion Register */
1205             default:
1206                 missing("not implemented");
1207             }
1208             s->mdimem[reg] = data;
1209         } else if (opcode == 2) {
1210             /* MDI read */
1211             switch (reg) {
1212             case 0:            /* Control Register */
1213                 if (data & 0x8000) {
1214                     /* Reset status and control registers to default. */
1215                     s->mdimem[0] = eepro100_mdi_default[0];
1216                     s->mdimem[1] = eepro100_mdi_default[1];
1217                 }
1218                 break;
1219             case 1:            /* Status Register */
1220                 s->mdimem[reg] |= 0x0020;
1221                 break;
1222             case 2:            /* PHY Identification Register (Word 1) */
1223             case 3:            /* PHY Identification Register (Word 2) */
1224             case 4:            /* Auto-Negotiation Advertisement Register */
1225                 break;
1226             case 5:            /* Auto-Negotiation Link Partner Ability Register */
1227                 s->mdimem[reg] = 0x41fe;
1228                 break;
1229             case 6:            /* Auto-Negotiation Expansion Register */
1230                 s->mdimem[reg] = 0x0001;
1231                 break;
1232             }
1233             data = s->mdimem[reg];
1234         }
1235         /* Emulation takes no time to finish MDI transaction.
1236          * Set MDI bit in SCB status register. */
1237         s->mem[SCBAck] |= 0x08;
1238         val |= BIT(28);
1239         if (raiseint) {
1240             eepro100_mdi_interrupt(s);
1241         }
1242     }
1243     val = (val & 0xffff0000) + data;
1244     e100_write_reg4(s, SCBCtrlMDI, val);
1245 }
1246
1247 /*****************************************************************************
1248  *
1249  * Port emulation.
1250  *
1251  ****************************************************************************/
1252
1253 #define PORT_SOFTWARE_RESET     0
1254 #define PORT_SELFTEST           1
1255 #define PORT_SELECTIVE_RESET    2
1256 #define PORT_DUMP               3
1257 #define PORT_SELECTION_MASK     3
1258
1259 typedef struct {
1260     uint32_t st_sign;           /* Self Test Signature */
1261     uint32_t st_result;         /* Self Test Results */
1262 } eepro100_selftest_t;
1263
1264 static uint32_t eepro100_read_port(EEPRO100State * s)
1265 {
1266     return 0;
1267 }
1268
1269 static void eepro100_write_port(EEPRO100State *s)
1270 {
1271     uint32_t val = e100_read_reg4(s, SCBPort);
1272     uint32_t address = (val & ~PORT_SELECTION_MASK);
1273     uint8_t selection = (val & PORT_SELECTION_MASK);
1274     switch (selection) {
1275     case PORT_SOFTWARE_RESET:
1276         nic_reset(s);
1277         break;
1278     case PORT_SELFTEST:
1279         TRACE(OTHER, logout("selftest address=0x%08x\n", address));
1280         eepro100_selftest_t data;
1281         pci_dma_read(&s->dev, address, (uint8_t *) &data, sizeof(data));
1282         data.st_sign = 0xffffffff;
1283         data.st_result = 0;
1284         pci_dma_write(&s->dev, address, (uint8_t *) &data, sizeof(data));
1285         break;
1286     case PORT_SELECTIVE_RESET:
1287         TRACE(OTHER, logout("selective reset, selftest address=0x%08x\n", address));
1288         nic_selective_reset(s);
1289         break;
1290     default:
1291         logout("val=0x%08x\n", val);
1292         missing("unknown port selection");
1293     }
1294 }
1295
1296 /*****************************************************************************
1297  *
1298  * General hardware emulation.
1299  *
1300  ****************************************************************************/
1301
1302 static uint8_t eepro100_read1(EEPRO100State * s, uint32_t addr)
1303 {
1304     uint8_t val = 0;
1305     if (addr <= sizeof(s->mem) - sizeof(val)) {
1306         val = s->mem[addr];
1307     }
1308
1309     switch (addr) {
1310     case SCBStatus:
1311     case SCBAck:
1312         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1313         break;
1314     case SCBCmd:
1315         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1316 #if 0
1317         val = eepro100_read_command(s);
1318 #endif
1319         break;
1320     case SCBIntmask:
1321         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1322         break;
1323     case SCBPort + 3:
1324         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1325         break;
1326     case SCBeeprom:
1327         val = eepro100_read_eeprom(s);
1328         break;
1329     case SCBCtrlMDI:
1330     case SCBCtrlMDI + 1:
1331     case SCBCtrlMDI + 2:
1332     case SCBCtrlMDI + 3:
1333         val = (uint8_t)(eepro100_read_mdi(s) >> (8 * (addr & 3)));
1334         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1335         break;
1336     case SCBpmdr:       /* Power Management Driver Register */
1337         val = 0;
1338         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1339         break;
1340     case SCBgctrl:      /* General Control Register */
1341         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1342         break;
1343     case SCBgstat:      /* General Status Register */
1344         /* 100 Mbps full duplex, valid link */
1345         val = 0x07;
1346         TRACE(OTHER, logout("addr=General Status val=%02x\n", val));
1347         break;
1348     default:
1349         logout("addr=%s val=0x%02x\n", regname(addr), val);
1350         missing("unknown byte read");
1351     }
1352     return val;
1353 }
1354
1355 static uint16_t eepro100_read2(EEPRO100State * s, uint32_t addr)
1356 {
1357     uint16_t val = 0;
1358     if (addr <= sizeof(s->mem) - sizeof(val)) {
1359         val = e100_read_reg2(s, addr);
1360     }
1361
1362     switch (addr) {
1363     case SCBStatus:
1364     case SCBCmd:
1365         TRACE(OTHER, logout("addr=%s val=0x%04x\n", regname(addr), val));
1366         break;
1367     case SCBeeprom:
1368         val = eepro100_read_eeprom(s);
1369         TRACE(OTHER, logout("addr=%s val=0x%04x\n", regname(addr), val));
1370         break;
1371     case SCBCtrlMDI:
1372     case SCBCtrlMDI + 2:
1373         val = (uint16_t)(eepro100_read_mdi(s) >> (8 * (addr & 3)));
1374         TRACE(OTHER, logout("addr=%s val=0x%04x\n", regname(addr), val));
1375         break;
1376     default:
1377         logout("addr=%s val=0x%04x\n", regname(addr), val);
1378         missing("unknown word read");
1379     }
1380     return val;
1381 }
1382
1383 static uint32_t eepro100_read4(EEPRO100State * s, uint32_t addr)
1384 {
1385     uint32_t val = 0;
1386     if (addr <= sizeof(s->mem) - sizeof(val)) {
1387         val = e100_read_reg4(s, addr);
1388     }
1389
1390     switch (addr) {
1391     case SCBStatus:
1392         TRACE(OTHER, logout("addr=%s val=0x%08x\n", regname(addr), val));
1393         break;
1394     case SCBPointer:
1395         TRACE(OTHER, logout("addr=%s val=0x%08x\n", regname(addr), val));
1396         break;
1397     case SCBPort:
1398         val = eepro100_read_port(s);
1399         TRACE(OTHER, logout("addr=%s val=0x%08x\n", regname(addr), val));
1400         break;
1401     case SCBflash:
1402         val = eepro100_read_eeprom(s);
1403         TRACE(OTHER, logout("addr=%s val=0x%08x\n", regname(addr), val));
1404         break;
1405     case SCBCtrlMDI:
1406         val = eepro100_read_mdi(s);
1407         break;
1408     default:
1409         logout("addr=%s val=0x%08x\n", regname(addr), val);
1410         missing("unknown longword read");
1411     }
1412     return val;
1413 }
1414
1415 static void eepro100_write1(EEPRO100State * s, uint32_t addr, uint8_t val)
1416 {
1417     /* SCBStatus is readonly. */
1418     if (addr > SCBStatus && addr <= sizeof(s->mem) - sizeof(val)) {
1419         s->mem[addr] = val;
1420     }
1421
1422     switch (addr) {
1423     case SCBStatus:
1424         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1425         break;
1426     case SCBAck:
1427         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1428         eepro100_acknowledge(s);
1429         break;
1430     case SCBCmd:
1431         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1432         eepro100_write_command(s, val);
1433         break;
1434     case SCBIntmask:
1435         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1436         if (val & BIT(1)) {
1437             eepro100_swi_interrupt(s);
1438         }
1439         eepro100_interrupt(s, 0);
1440         break;
1441     case SCBPointer:
1442     case SCBPointer + 1:
1443     case SCBPointer + 2:
1444     case SCBPointer + 3:
1445         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1446         break;
1447     case SCBPort:
1448     case SCBPort + 1:
1449     case SCBPort + 2:
1450         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1451         break;
1452     case SCBPort + 3:
1453         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1454         eepro100_write_port(s);
1455         break;
1456     case SCBFlow:       /* does not exist on 82557 */
1457     case SCBFlow + 1:
1458     case SCBFlow + 2:
1459     case SCBpmdr:       /* does not exist on 82557 */
1460         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1461         break;
1462     case SCBeeprom:
1463         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1464         eepro100_write_eeprom(s->eeprom, val);
1465         break;
1466     case SCBCtrlMDI:
1467     case SCBCtrlMDI + 1:
1468     case SCBCtrlMDI + 2:
1469         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1470         break;
1471     case SCBCtrlMDI + 3:
1472         TRACE(OTHER, logout("addr=%s val=0x%02x\n", regname(addr), val));
1473         eepro100_write_mdi(s);
1474         break;
1475     default:
1476         logout("addr=%s val=0x%02x\n", regname(addr), val);
1477         missing("unknown byte write");
1478     }
1479 }
1480
1481 static void eepro100_write2(EEPRO100State * s, uint32_t addr, uint16_t val)
1482 {
1483     /* SCBStatus is readonly. */
1484     if (addr > SCBStatus && addr <= sizeof(s->mem) - sizeof(val)) {
1485         e100_write_reg2(s, addr, val);
1486     }
1487
1488     switch (addr) {
1489     case SCBStatus:
1490         TRACE(OTHER, logout("addr=%s val=0x%04x\n", regname(addr), val));
1491         s->mem[SCBAck] = (val >> 8);
1492         eepro100_acknowledge(s);
1493         break;
1494     case SCBCmd:
1495         TRACE(OTHER, logout("addr=%s val=0x%04x\n", regname(addr), val));
1496         eepro100_write_command(s, val);
1497         eepro100_write1(s, SCBIntmask, val >> 8);
1498         break;
1499     case SCBPointer:
1500     case SCBPointer + 2:
1501         TRACE(OTHER, logout("addr=%s val=0x%04x\n", regname(addr), val));
1502         break;
1503     case SCBPort:
1504         TRACE(OTHER, logout("addr=%s val=0x%04x\n", regname(addr), val));
1505         break;
1506     case SCBPort + 2:
1507         TRACE(OTHER, logout("addr=%s val=0x%04x\n", regname(addr), val));
1508         eepro100_write_port(s);
1509         break;
1510     case SCBeeprom:
1511         TRACE(OTHER, logout("addr=%s val=0x%04x\n", regname(addr), val));
1512         eepro100_write_eeprom(s->eeprom, val);
1513         break;
1514     case SCBCtrlMDI:
1515         TRACE(OTHER, logout("addr=%s val=0x%04x\n", regname(addr), val));
1516         break;
1517     case SCBCtrlMDI + 2:
1518         TRACE(OTHER, logout("addr=%s val=0x%04x\n", regname(addr), val));
1519         eepro100_write_mdi(s);
1520         break;
1521     default:
1522         logout("addr=%s val=0x%04x\n", regname(addr), val);
1523         missing("unknown word write");
1524     }
1525 }
1526
1527 static void eepro100_write4(EEPRO100State * s, uint32_t addr, uint32_t val)
1528 {
1529     if (addr <= sizeof(s->mem) - sizeof(val)) {
1530         e100_write_reg4(s, addr, val);
1531     }
1532
1533     switch (addr) {
1534     case SCBPointer:
1535         TRACE(OTHER, logout("addr=%s val=0x%08x\n", regname(addr), val));
1536         break;
1537     case SCBPort:
1538         TRACE(OTHER, logout("addr=%s val=0x%08x\n", regname(addr), val));
1539         eepro100_write_port(s);
1540         break;
1541     case SCBflash:
1542         TRACE(OTHER, logout("addr=%s val=0x%08x\n", regname(addr), val));
1543         val = val >> 16;
1544         eepro100_write_eeprom(s->eeprom, val);
1545         break;
1546     case SCBCtrlMDI:
1547         TRACE(OTHER, logout("addr=%s val=0x%08x\n", regname(addr), val));
1548         eepro100_write_mdi(s);
1549         break;
1550     default:
1551         logout("addr=%s val=0x%08x\n", regname(addr), val);
1552         missing("unknown longword write");
1553     }
1554 }
1555
1556 static uint64_t eepro100_read(void *opaque, target_phys_addr_t addr,
1557                               unsigned size)
1558 {
1559     EEPRO100State *s = opaque;
1560
1561     switch (size) {
1562     case 1: return eepro100_read1(s, addr);
1563     case 2: return eepro100_read2(s, addr);
1564     case 4: return eepro100_read4(s, addr);
1565     default: abort();
1566     }
1567 }
1568
1569 static void eepro100_write(void *opaque, target_phys_addr_t addr,
1570                            uint64_t data, unsigned size)
1571 {
1572     EEPRO100State *s = opaque;
1573
1574     switch (size) {
1575     case 1: return eepro100_write1(s, addr, data);
1576     case 2: return eepro100_write2(s, addr, data);
1577     case 4: return eepro100_write4(s, addr, data);
1578     default: abort();
1579     }
1580 }
1581
1582 static const MemoryRegionOps eepro100_ops = {
1583     .read = eepro100_read,
1584     .write = eepro100_write,
1585     .endianness = DEVICE_LITTLE_ENDIAN,
1586 };
1587
1588 static int nic_can_receive(VLANClientState *nc)
1589 {
1590     EEPRO100State *s = DO_UPCAST(NICState, nc, nc)->opaque;
1591     TRACE(RXTX, logout("%p\n", s));
1592     return get_ru_state(s) == ru_ready;
1593 #if 0
1594     return !eepro100_buffer_full(s);
1595 #endif
1596 }
1597
1598 static ssize_t nic_receive(VLANClientState *nc, const uint8_t * buf, size_t size)
1599 {
1600     /* TODO:
1601      * - Magic packets should set bit 30 in power management driver register.
1602      * - Interesting packets should set bit 29 in power management driver register.
1603      */
1604     EEPRO100State *s = DO_UPCAST(NICState, nc, nc)->opaque;
1605     uint16_t rfd_status = 0xa000;
1606 #if defined(CONFIG_PAD_RECEIVED_FRAMES)
1607     uint8_t min_buf[60];
1608 #endif
1609     static const uint8_t broadcast_macaddr[6] =
1610         { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1611
1612 #if defined(CONFIG_PAD_RECEIVED_FRAMES)
1613     /* Pad to minimum Ethernet frame length */
1614     if (size < sizeof(min_buf)) {
1615         memcpy(min_buf, buf, size);
1616         memset(&min_buf[size], 0, sizeof(min_buf) - size);
1617         buf = min_buf;
1618         size = sizeof(min_buf);
1619     }
1620 #endif
1621
1622     if (s->configuration[8] & 0x80) {
1623         /* CSMA is disabled. */
1624         logout("%p received while CSMA is disabled\n", s);
1625         return -1;
1626 #if !defined(CONFIG_PAD_RECEIVED_FRAMES)
1627     } else if (size < 64 && (s->configuration[7] & BIT(0))) {
1628         /* Short frame and configuration byte 7/0 (discard short receive) set:
1629          * Short frame is discarded */
1630         logout("%p received short frame (%zu byte)\n", s, size);
1631         s->statistics.rx_short_frame_errors++;
1632         return -1;
1633 #endif
1634     } else if ((size > MAX_ETH_FRAME_SIZE + 4) && !(s->configuration[18] & BIT(3))) {
1635         /* Long frame and configuration byte 18/3 (long receive ok) not set:
1636          * Long frames are discarded. */
1637         logout("%p received long frame (%zu byte), ignored\n", s, size);
1638         return -1;
1639     } else if (memcmp(buf, s->conf.macaddr.a, 6) == 0) {       /* !!! */
1640         /* Frame matches individual address. */
1641         /* TODO: check configuration byte 15/4 (ignore U/L). */
1642         TRACE(RXTX, logout("%p received frame for me, len=%zu\n", s, size));
1643     } else if (memcmp(buf, broadcast_macaddr, 6) == 0) {
1644         /* Broadcast frame. */
1645         TRACE(RXTX, logout("%p received broadcast, len=%zu\n", s, size));
1646         rfd_status |= 0x0002;
1647     } else if (buf[0] & 0x01) {
1648         /* Multicast frame. */
1649         TRACE(RXTX, logout("%p received multicast, len=%zu,%s\n", s, size, nic_dump(buf, size)));
1650         if (s->configuration[21] & BIT(3)) {
1651           /* Multicast all bit is set, receive all multicast frames. */
1652         } else {
1653           unsigned mcast_idx = compute_mcast_idx(buf);
1654           assert(mcast_idx < 64);
1655           if (s->mult[mcast_idx >> 3] & (1 << (mcast_idx & 7))) {
1656             /* Multicast frame is allowed in hash table. */
1657           } else if (s->configuration[15] & BIT(0)) {
1658               /* Promiscuous: receive all. */
1659               rfd_status |= 0x0004;
1660           } else {
1661               TRACE(RXTX, logout("%p multicast ignored\n", s));
1662               return -1;
1663           }
1664         }
1665         /* TODO: Next not for promiscuous mode? */
1666         rfd_status |= 0x0002;
1667     } else if (s->configuration[15] & BIT(0)) {
1668         /* Promiscuous: receive all. */
1669         TRACE(RXTX, logout("%p received frame in promiscuous mode, len=%zu\n", s, size));
1670         rfd_status |= 0x0004;
1671     } else if (s->configuration[20] & BIT(6)) {
1672         /* Multiple IA bit set. */
1673         unsigned mcast_idx = compute_mcast_idx(buf);
1674         assert(mcast_idx < 64);
1675         if (s->mult[mcast_idx >> 3] & (1 << (mcast_idx & 7))) {
1676             TRACE(RXTX, logout("%p accepted, multiple IA bit set\n", s));
1677         } else {
1678             TRACE(RXTX, logout("%p frame ignored, multiple IA bit set\n", s));
1679             return -1;
1680         }
1681     } else {
1682         TRACE(RXTX, logout("%p received frame, ignored, len=%zu,%s\n", s, size,
1683               nic_dump(buf, size)));
1684         return size;
1685     }
1686
1687     if (get_ru_state(s) != ru_ready) {
1688         /* No resources available. */
1689         logout("no resources, state=%u\n", get_ru_state(s));
1690         /* TODO: RNR interrupt only at first failed frame? */
1691         eepro100_rnr_interrupt(s);
1692         s->statistics.rx_resource_errors++;
1693 #if 0
1694         assert(!"no resources");
1695 #endif
1696         return -1;
1697     }
1698     /* !!! */
1699     eepro100_rx_t rx;
1700     pci_dma_read(&s->dev, s->ru_base + s->ru_offset,
1701                  &rx, sizeof(eepro100_rx_t));
1702     uint16_t rfd_command = le16_to_cpu(rx.command);
1703     uint16_t rfd_size = le16_to_cpu(rx.size);
1704
1705     if (size > rfd_size) {
1706         logout("Receive buffer (%" PRId16 " bytes) too small for data "
1707             "(%zu bytes); data truncated\n", rfd_size, size);
1708         size = rfd_size;
1709     }
1710 #if !defined(CONFIG_PAD_RECEIVED_FRAMES)
1711     if (size < 64) {
1712         rfd_status |= 0x0080;
1713     }
1714 #endif
1715     TRACE(OTHER, logout("command 0x%04x, link 0x%08x, addr 0x%08x, size %u\n",
1716           rfd_command, rx.link, rx.rx_buf_addr, rfd_size));
1717     stw_le_pci_dma(&s->dev, s->ru_base + s->ru_offset +
1718                 offsetof(eepro100_rx_t, status), rfd_status);
1719     stw_le_pci_dma(&s->dev, s->ru_base + s->ru_offset +
1720                 offsetof(eepro100_rx_t, count), size);
1721     /* Early receive interrupt not supported. */
1722 #if 0
1723     eepro100_er_interrupt(s);
1724 #endif
1725     /* Receive CRC Transfer not supported. */
1726     if (s->configuration[18] & BIT(2)) {
1727         missing("Receive CRC Transfer");
1728         return -1;
1729     }
1730     /* TODO: check stripping enable bit. */
1731 #if 0
1732     assert(!(s->configuration[17] & BIT(0)));
1733 #endif
1734     pci_dma_write(&s->dev, s->ru_base + s->ru_offset +
1735                   sizeof(eepro100_rx_t), buf, size);
1736     s->statistics.rx_good_frames++;
1737     eepro100_fr_interrupt(s);
1738     s->ru_offset = le32_to_cpu(rx.link);
1739     if (rfd_command & COMMAND_EL) {
1740         /* EL bit is set, so this was the last frame. */
1741         logout("receive: Running out of frames\n");
1742         set_ru_state(s, ru_suspended);
1743     }
1744     if (rfd_command & COMMAND_S) {
1745         /* S bit is set. */
1746         set_ru_state(s, ru_suspended);
1747     }
1748     return size;
1749 }
1750
1751 static const VMStateDescription vmstate_eepro100 = {
1752     .version_id = 3,
1753     .minimum_version_id = 2,
1754     .minimum_version_id_old = 2,
1755     .fields      = (VMStateField []) {
1756         VMSTATE_PCI_DEVICE(dev, EEPRO100State),
1757         VMSTATE_UNUSED(32),
1758         VMSTATE_BUFFER(mult, EEPRO100State),
1759         VMSTATE_BUFFER(mem, EEPRO100State),
1760         /* Save all members of struct between scb_stat and mem. */
1761         VMSTATE_UINT8(scb_stat, EEPRO100State),
1762         VMSTATE_UINT8(int_stat, EEPRO100State),
1763         VMSTATE_UNUSED(3*4),
1764         VMSTATE_MACADDR(conf.macaddr, EEPRO100State),
1765         VMSTATE_UNUSED(19*4),
1766         VMSTATE_UINT16_ARRAY(mdimem, EEPRO100State, 32),
1767         /* The eeprom should be saved and restored by its own routines. */
1768         VMSTATE_UINT32(device, EEPRO100State),
1769         /* TODO check device. */
1770         VMSTATE_UINT32(cu_base, EEPRO100State),
1771         VMSTATE_UINT32(cu_offset, EEPRO100State),
1772         VMSTATE_UINT32(ru_base, EEPRO100State),
1773         VMSTATE_UINT32(ru_offset, EEPRO100State),
1774         VMSTATE_UINT32(statsaddr, EEPRO100State),
1775         /* Save eepro100_stats_t statistics. */
1776         VMSTATE_UINT32(statistics.tx_good_frames, EEPRO100State),
1777         VMSTATE_UINT32(statistics.tx_max_collisions, EEPRO100State),
1778         VMSTATE_UINT32(statistics.tx_late_collisions, EEPRO100State),
1779         VMSTATE_UINT32(statistics.tx_underruns, EEPRO100State),
1780         VMSTATE_UINT32(statistics.tx_lost_crs, EEPRO100State),
1781         VMSTATE_UINT32(statistics.tx_deferred, EEPRO100State),
1782         VMSTATE_UINT32(statistics.tx_single_collisions, EEPRO100State),
1783         VMSTATE_UINT32(statistics.tx_multiple_collisions, EEPRO100State),
1784         VMSTATE_UINT32(statistics.tx_total_collisions, EEPRO100State),
1785         VMSTATE_UINT32(statistics.rx_good_frames, EEPRO100State),
1786         VMSTATE_UINT32(statistics.rx_crc_errors, EEPRO100State),
1787         VMSTATE_UINT32(statistics.rx_alignment_errors, EEPRO100State),
1788         VMSTATE_UINT32(statistics.rx_resource_errors, EEPRO100State),
1789         VMSTATE_UINT32(statistics.rx_overrun_errors, EEPRO100State),
1790         VMSTATE_UINT32(statistics.rx_cdt_errors, EEPRO100State),
1791         VMSTATE_UINT32(statistics.rx_short_frame_errors, EEPRO100State),
1792         VMSTATE_UINT32(statistics.fc_xmt_pause, EEPRO100State),
1793         VMSTATE_UINT32(statistics.fc_rcv_pause, EEPRO100State),
1794         VMSTATE_UINT32(statistics.fc_rcv_unsupported, EEPRO100State),
1795         VMSTATE_UINT16(statistics.xmt_tco_frames, EEPRO100State),
1796         VMSTATE_UINT16(statistics.rcv_tco_frames, EEPRO100State),
1797         /* Configuration bytes. */
1798         VMSTATE_BUFFER(configuration, EEPRO100State),
1799         VMSTATE_END_OF_LIST()
1800     }
1801 };
1802
1803 static void nic_cleanup(VLANClientState *nc)
1804 {
1805     EEPRO100State *s = DO_UPCAST(NICState, nc, nc)->opaque;
1806
1807     s->nic = NULL;
1808 }
1809
1810 static int pci_nic_uninit(PCIDevice *pci_dev)
1811 {
1812     EEPRO100State *s = DO_UPCAST(EEPRO100State, dev, pci_dev);
1813
1814     memory_region_destroy(&s->mmio_bar);
1815     memory_region_destroy(&s->io_bar);
1816     memory_region_destroy(&s->flash_bar);
1817     vmstate_unregister(&pci_dev->qdev, s->vmstate, s);
1818     eeprom93xx_free(&pci_dev->qdev, s->eeprom);
1819     qemu_del_vlan_client(&s->nic->nc);
1820     return 0;
1821 }
1822
1823 static NetClientInfo net_eepro100_info = {
1824     .type = NET_CLIENT_TYPE_NIC,
1825     .size = sizeof(NICState),
1826     .can_receive = nic_can_receive,
1827     .receive = nic_receive,
1828     .cleanup = nic_cleanup,
1829 };
1830
1831 static int e100_nic_init(PCIDevice *pci_dev)
1832 {
1833     EEPRO100State *s = DO_UPCAST(EEPRO100State, dev, pci_dev);
1834     E100PCIDeviceInfo *info = eepro100_get_class(s);
1835
1836     TRACE(OTHER, logout("\n"));
1837
1838     s->device = info->device;
1839
1840     e100_pci_reset(s);
1841
1842     /* Add 64 * 2 EEPROM. i82557 and i82558 support a 64 word EEPROM,
1843      * i82559 and later support 64 or 256 word EEPROM. */
1844     s->eeprom = eeprom93xx_new(&pci_dev->qdev, EEPROM_SIZE);
1845
1846     /* Handler for memory-mapped I/O */
1847     memory_region_init_io(&s->mmio_bar, &eepro100_ops, s, "eepro100-mmio",
1848                           PCI_MEM_SIZE);
1849     pci_register_bar(&s->dev, 0, PCI_BASE_ADDRESS_MEM_PREFETCH, &s->mmio_bar);
1850     memory_region_init_io(&s->io_bar, &eepro100_ops, s, "eepro100-io",
1851                           PCI_IO_SIZE);
1852     pci_register_bar(&s->dev, 1, PCI_BASE_ADDRESS_SPACE_IO, &s->io_bar);
1853     /* FIXME: flash aliases to mmio?! */
1854     memory_region_init_io(&s->flash_bar, &eepro100_ops, s, "eepro100-flash",
1855                           PCI_FLASH_SIZE);
1856     pci_register_bar(&s->dev, 2, 0, &s->flash_bar);
1857
1858     qemu_macaddr_default_if_unset(&s->conf.macaddr);
1859     logout("macaddr: %s\n", nic_dump(&s->conf.macaddr.a[0], 6));
1860
1861     nic_reset(s);
1862
1863     s->nic = qemu_new_nic(&net_eepro100_info, &s->conf,
1864                           object_get_typename(OBJECT(pci_dev)), pci_dev->qdev.id, s);
1865
1866     qemu_format_nic_info_str(&s->nic->nc, s->conf.macaddr.a);
1867     TRACE(OTHER, logout("%s\n", s->nic->nc.info_str));
1868
1869     qemu_register_reset(nic_reset, s);
1870
1871     s->vmstate = g_malloc(sizeof(vmstate_eepro100));
1872     memcpy(s->vmstate, &vmstate_eepro100, sizeof(vmstate_eepro100));
1873     s->vmstate->name = s->nic->nc.model;
1874     vmstate_register(&pci_dev->qdev, -1, s->vmstate, s);
1875
1876     add_boot_device_path(s->conf.bootindex, &pci_dev->qdev, "/ethernet-phy@0");
1877
1878     return 0;
1879 }
1880
1881 static E100PCIDeviceInfo e100_devices[] = {
1882     {
1883         .name = "i82550",
1884         .desc = "Intel i82550 Ethernet",
1885         .device = i82550,
1886         /* TODO: check device id. */
1887         .device_id = PCI_DEVICE_ID_INTEL_82551IT,
1888         /* Revision ID: 0x0c, 0x0d, 0x0e. */
1889         .revision = 0x0e,
1890         /* TODO: check size of statistical counters. */
1891         .stats_size = 80,
1892         /* TODO: check extended tcb support. */
1893         .has_extended_tcb_support = true,
1894         .power_management = true,
1895     },{
1896         .name = "i82551",
1897         .desc = "Intel i82551 Ethernet",
1898         .device = i82551,
1899         .device_id = PCI_DEVICE_ID_INTEL_82551IT,
1900         /* Revision ID: 0x0f, 0x10. */
1901         .revision = 0x0f,
1902         /* TODO: check size of statistical counters. */
1903         .stats_size = 80,
1904         .has_extended_tcb_support = true,
1905         .power_management = true,
1906     },{
1907         .name = "i82557a",
1908         .desc = "Intel i82557A Ethernet",
1909         .device = i82557A,
1910         .device_id = PCI_DEVICE_ID_INTEL_82557,
1911         .revision = 0x01,
1912         .power_management = false,
1913     },{
1914         .name = "i82557b",
1915         .desc = "Intel i82557B Ethernet",
1916         .device = i82557B,
1917         .device_id = PCI_DEVICE_ID_INTEL_82557,
1918         .revision = 0x02,
1919         .power_management = false,
1920     },{
1921         .name = "i82557c",
1922         .desc = "Intel i82557C Ethernet",
1923         .device = i82557C,
1924         .device_id = PCI_DEVICE_ID_INTEL_82557,
1925         .revision = 0x03,
1926         .power_management = false,
1927     },{
1928         .name = "i82558a",
1929         .desc = "Intel i82558A Ethernet",
1930         .device = i82558A,
1931         .device_id = PCI_DEVICE_ID_INTEL_82557,
1932         .revision = 0x04,
1933         .stats_size = 76,
1934         .has_extended_tcb_support = true,
1935         .power_management = true,
1936     },{
1937         .name = "i82558b",
1938         .desc = "Intel i82558B Ethernet",
1939         .device = i82558B,
1940         .device_id = PCI_DEVICE_ID_INTEL_82557,
1941         .revision = 0x05,
1942         .stats_size = 76,
1943         .has_extended_tcb_support = true,
1944         .power_management = true,
1945     },{
1946         .name = "i82559a",
1947         .desc = "Intel i82559A Ethernet",
1948         .device = i82559A,
1949         .device_id = PCI_DEVICE_ID_INTEL_82557,
1950         .revision = 0x06,
1951         .stats_size = 80,
1952         .has_extended_tcb_support = true,
1953         .power_management = true,
1954     },{
1955         .name = "i82559b",
1956         .desc = "Intel i82559B Ethernet",
1957         .device = i82559B,
1958         .device_id = PCI_DEVICE_ID_INTEL_82557,
1959         .revision = 0x07,
1960         .stats_size = 80,
1961         .has_extended_tcb_support = true,
1962         .power_management = true,
1963     },{
1964         .name = "i82559c",
1965         .desc = "Intel i82559C Ethernet",
1966         .device = i82559C,
1967         .device_id = PCI_DEVICE_ID_INTEL_82557,
1968 #if 0
1969         .revision = 0x08,
1970 #endif
1971         /* TODO: Windows wants revision id 0x0c. */
1972         .revision = 0x0c,
1973 #if EEPROM_SIZE > 0
1974         .subsystem_vendor_id = PCI_VENDOR_ID_INTEL,
1975         .subsystem_id = 0x0040,
1976 #endif
1977         .stats_size = 80,
1978         .has_extended_tcb_support = true,
1979         .power_management = true,
1980     },{
1981         .name = "i82559er",
1982         .desc = "Intel i82559ER Ethernet",
1983         .device = i82559ER,
1984         .device_id = PCI_DEVICE_ID_INTEL_82551IT,
1985         .revision = 0x09,
1986         .stats_size = 80,
1987         .has_extended_tcb_support = true,
1988         .power_management = true,
1989     },{
1990         .name = "i82562",
1991         .desc = "Intel i82562 Ethernet",
1992         .device = i82562,
1993         /* TODO: check device id. */
1994         .device_id = PCI_DEVICE_ID_INTEL_82551IT,
1995         /* TODO: wrong revision id. */
1996         .revision = 0x0e,
1997         .stats_size = 80,
1998         .has_extended_tcb_support = true,
1999         .power_management = true,
2000     },{
2001         /* Toshiba Tecra 8200. */
2002         .name = "i82801",
2003         .desc = "Intel i82801 Ethernet",
2004         .device = i82801,
2005         .device_id = 0x2449,
2006         .revision = 0x03,
2007         .stats_size = 80,
2008         .has_extended_tcb_support = true,
2009         .power_management = true,
2010     }
2011 };
2012
2013 static E100PCIDeviceInfo *eepro100_get_class_by_name(const char *typename)
2014 {
2015     E100PCIDeviceInfo *info = NULL;
2016     int i;
2017
2018     /* This is admittedly awkward but also temporary.  QOM allows for
2019      * parameterized typing and for subclassing both of which would suitable
2020      * handle what's going on here.  But class_data is already being used as
2021      * a stop-gap hack to allow incremental qdev conversion so we cannot use it
2022      * right now.  Once we merge the final QOM series, we can come back here and
2023      * do this in a much more elegant fashion.
2024      */
2025     for (i = 0; i < ARRAY_SIZE(e100_devices); i++) {
2026         if (strcmp(e100_devices[i].name, typename) == 0) {
2027             info = &e100_devices[i];
2028             break;
2029         }
2030     }
2031     assert(info != NULL);
2032
2033     return info;
2034 }
2035
2036 static E100PCIDeviceInfo *eepro100_get_class(EEPRO100State *s)
2037 {
2038     return eepro100_get_class_by_name(object_get_typename(OBJECT(s)));
2039 }
2040
2041 static Property e100_properties[] = {
2042     DEFINE_NIC_PROPERTIES(EEPRO100State, conf),
2043     DEFINE_PROP_END_OF_LIST(),
2044 };
2045
2046 static void eepro100_class_init(ObjectClass *klass, void *data)
2047 {
2048     DeviceClass *dc = DEVICE_CLASS(klass);
2049     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
2050     E100PCIDeviceInfo *info;
2051
2052     info = eepro100_get_class_by_name(object_class_get_name(klass));
2053
2054     dc->props = e100_properties;
2055     dc->desc = info->desc;
2056     k->vendor_id = PCI_VENDOR_ID_INTEL;
2057     k->class_id = PCI_CLASS_NETWORK_ETHERNET;
2058     k->romfile = "pxe-eepro100.rom";
2059     k->init = e100_nic_init;
2060     k->exit = pci_nic_uninit;
2061     k->device_id = info->device_id;
2062     k->revision = info->revision;
2063     k->subsystem_vendor_id = info->subsystem_vendor_id;
2064     k->subsystem_id = info->subsystem_id;
2065 }
2066
2067 static void eepro100_register_types(void)
2068 {
2069     size_t i;
2070     for (i = 0; i < ARRAY_SIZE(e100_devices); i++) {
2071         TypeInfo type_info = {};
2072         E100PCIDeviceInfo *info = &e100_devices[i];
2073
2074         type_info.name = info->name;
2075         type_info.parent = TYPE_PCI_DEVICE;
2076         type_info.class_init = eepro100_class_init;
2077         type_info.instance_size = sizeof(EEPRO100State);
2078
2079         type_register(&type_info);
2080     }
2081 }
2082
2083 type_init(eepro100_register_types)