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