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