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