2 * QEMU i8255x (PRO100) emulation
4 * Copyright (C) 2006-2010 Stefan Weil
6 * Portions of the code are copies from grub / etherboot eepro100.c
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.
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.
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/>.
22 * Tested features (i82559):
24 * Linux networking (i386) ok
32 * Intel 8255x 10/100 Mbps Ethernet Controller Family
33 * Open Source Software Developer Manual
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.
44 #include <stdbool.h> /* bool */
45 #include <stddef.h> /* offsetof */
49 #include "eeprom93xx.h"
53 /* Debug EEPRO100 card. */
55 # define DEBUG_EEPRO100
59 #define logout(fmt, ...) fprintf(stderr, "EE100\t%-24s" fmt, __func__, ## __VA_ARGS__)
61 #define logout(fmt, ...) ((void)0)
64 /* Set flags to 0 to disable debug output. */
65 #define INT 1 /* interrupt related actions */
66 #define MDI 1 /* mdi related actions */
69 #define EEPROM 1 /* eeprom related actions */
71 #define TRACE(flag, command) ((flag) ? (command) : (void)0)
73 #define missing(text) fprintf(stderr, "eepro100: feature is missing in this emulation: " text "\n")
75 #define MAX_ETH_FRAME_SIZE 1514
77 /* This driver supports several different devices which are declared here. */
78 #define i82550 0x82550
79 #define i82551 0x82551
80 #define i82557A 0x82557a
81 #define i82557B 0x82557b
82 #define i82557C 0x82557c
83 #define i82558A 0x82558a
84 #define i82558B 0x82558b
85 #define i82559A 0x82559a
86 #define i82559B 0x82559b
87 #define i82559C 0x82559c
88 #define i82559ER 0x82559e
89 #define i82562 0x82562
90 #define i82801 0x82801
92 /* Use 64 word EEPROM. TODO: could be a runtime option. */
93 #define EEPROM_SIZE 64
95 #define PCI_MEM_SIZE (4 * KiB)
96 #define PCI_IO_SIZE 64
97 #define PCI_FLASH_SIZE (128 * KiB)
99 #define BIT(n) (1 << (n))
100 #define BITS(n, m) (((0xffffffffU << (31 - n)) >> (31 - n + m)) << m)
102 /* The SCB accepts the following controls for the Tx and Rx units: */
103 #define CU_NOP 0x0000 /* No operation. */
104 #define CU_START 0x0010 /* CU start. */
105 #define CU_RESUME 0x0020 /* CU resume. */
106 #define CU_STATSADDR 0x0040 /* Load dump counters address. */
107 #define CU_SHOWSTATS 0x0050 /* Dump statistical counters. */
108 #define CU_CMD_BASE 0x0060 /* Load CU base address. */
109 #define CU_DUMPSTATS 0x0070 /* Dump and reset statistical counters. */
110 #define CU_SRESUME 0x00a0 /* CU static resume. */
112 #define RU_NOP 0x0000
113 #define RX_START 0x0001
114 #define RX_RESUME 0x0002
115 #define RU_ABORT 0x0004
116 #define RX_ADDR_LOAD 0x0006
117 #define RX_RESUMENR 0x0007
118 #define INT_MASK 0x0100
119 #define DRVR_INT 0x0200 /* Driver generated interrupt. */
127 bool has_extended_tcb_support
;
128 bool power_management
;
131 /* Offsets to the various registers.
132 All accesses need not be longword aligned. */
133 enum speedo_offsets
{
134 SCBStatus
= 0, /* Status Word. */
136 SCBCmd
= 2, /* Rx/Command Unit command and status. */
138 SCBPointer
= 4, /* General purpose pointer. */
139 SCBPort
= 8, /* Misc. commands and operands. */
140 SCBflash
= 12, /* Flash memory control. */
141 SCBeeprom
= 14, /* EEPROM control. */
142 SCBCtrlMDI
= 16, /* MDI interface control. */
143 SCBEarlyRx
= 20, /* Early receive byte count. */
144 SCBFlow
= 24, /* Flow Control. */
145 SCBpmdr
= 27, /* Power Management Driver. */
146 SCBgctrl
= 28, /* General Control. */
147 SCBgstat
= 29, /* General Status. */
150 /* A speedo3 transmit buffer descriptor with two buffers... */
154 uint32_t link
; /* void * */
155 uint32_t tbd_array_addr
; /* transmit buffer descriptor array address. */
156 uint16_t tcb_bytes
; /* transmit command block byte count (in lower 14 bits */
157 uint8_t tx_threshold
; /* transmit threshold */
158 uint8_t tbd_count
; /* TBD number */
160 /* This constitutes two "TBD" entries: hdr and data */
161 uint32_t tx_buf_addr0
; /* void *, header of frame to be transmitted. */
162 int32_t tx_buf_size0
; /* Length of Tx hdr. */
163 uint32_t tx_buf_addr1
; /* void *, data to be transmitted. */
164 int32_t tx_buf_size1
; /* Length of Tx data. */
168 /* Receive frame descriptor. */
172 uint32_t link
; /* struct RxFD * */
173 uint32_t rx_buf_addr
; /* void * */
176 char packet
[MAX_ETH_FRAME_SIZE
+ 4];
180 COMMAND_EL
= BIT(15),
185 COMMAND_CMD
= BITS(2, 0),
194 uint32_t tx_good_frames
, tx_max_collisions
, tx_late_collisions
,
195 tx_underruns
, tx_lost_crs
, tx_deferred
, tx_single_collisions
,
196 tx_multiple_collisions
, tx_total_collisions
;
197 uint32_t rx_good_frames
, rx_crc_errors
, rx_alignment_errors
,
198 rx_resource_errors
, rx_overrun_errors
, rx_cdt_errors
,
199 rx_short_frame_errors
;
200 uint32_t fc_xmt_pause
, fc_rcv_pause
, fc_rcv_unsupported
;
201 uint16_t xmt_tco_frames
, rcv_tco_frames
;
202 /* TODO: i82559 has six reserved statistics but a total of 24 dwords. */
203 uint32_t reserved
[4];
223 uint8_t mult
[8]; /* multicast mask array */
227 uint8_t scb_stat
; /* SCB stat/ack byte */
228 uint8_t int_stat
; /* PCI interrupt status */
229 /* region must not be saved by nic_save. */
230 uint32_t region
[3]; /* PCI region addresses */
233 uint32_t device
; /* device variant */
235 /* (cu_base + cu_offset) address the next command block in the command block list. */
236 uint32_t cu_base
; /* CU base address */
237 uint32_t cu_offset
; /* CU address offset */
238 /* (ru_base + ru_offset) address the RFD in the Receive Frame Area. */
239 uint32_t ru_base
; /* RU base address */
240 uint32_t ru_offset
; /* RU address offset */
241 uint32_t statsaddr
; /* pointer to eepro100_stats_t */
243 /* Temporary status information (no need to save these values),
244 * used while processing CU commands. */
245 eepro100_tx_t tx
; /* transmit buffer descriptor */
246 uint32_t cb_address
; /* = cu_base + cu_offset */
248 /* Statistical counters. Also used for wake-up packet (i82559). */
249 eepro100_stats_t statistics
;
251 /* Configuration bytes. */
252 uint8_t configuration
[22];
254 /* Data in mem is always in the byte order of the controller (le). */
255 uint8_t mem
[PCI_MEM_SIZE
];
256 /* vmstate for each particular nic */
257 VMStateDescription
*vmstate
;
259 /* Quasi static device properties (no need to save them). */
261 bool has_extended_tcb_support
;
264 /* Word indices in EEPROM. */
266 EEPROM_CNFG_MDIX
= 0x03,
268 EEPROM_PHY_ID
= 0x06,
269 EEPROM_VENDOR_ID
= 0x0c,
270 EEPROM_CONFIG_ASF
= 0x0d,
271 EEPROM_DEVICE_ID
= 0x23,
272 EEPROM_SMBUS_ADDR
= 0x90,
275 /* Bit values for EEPROM ID word. */
277 EEPROM_ID_MDM
= BIT(0), /* Modem */
278 EEPROM_ID_STB
= BIT(1), /* Standby Enable */
279 EEPROM_ID_WMR
= BIT(2), /* ??? */
280 EEPROM_ID_WOL
= BIT(5), /* Wake on LAN */
281 EEPROM_ID_DPD
= BIT(6), /* Deep Power Down */
282 EEPROM_ID_ALT
= BIT(7), /* */
283 /* BITS(10, 8) device revision */
284 EEPROM_ID_BD
= BIT(11), /* boot disable */
285 EEPROM_ID_ID
= BIT(13), /* id bit */
286 /* BITS(15, 14) signature */
287 EEPROM_ID_VALID
= BIT(14), /* signature for valid eeprom */
290 /* Default values for MDI (PHY) registers */
291 static const uint16_t eepro100_mdi_default
[] = {
292 /* MDI Registers 0 - 6, 7 */
293 0x3000, 0x780d, 0x02a8, 0x0154, 0x05e1, 0x0000, 0x0000, 0x0000,
294 /* MDI Registers 8 - 15 */
295 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
296 /* MDI Registers 16 - 31 */
297 0x0003, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
298 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
301 /* Readonly mask for MDI (PHY) registers */
302 static const uint16_t eepro100_mdi_mask
[] = {
303 0x0000, 0xffff, 0xffff, 0xffff, 0xc01f, 0xffff, 0xffff, 0x0000,
304 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
305 0x0fff, 0x0000, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
306 0xffff, 0xffff, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
310 static void stl_le_phys(target_phys_addr_t addr
, uint32_t val
)
312 val
= cpu_to_le32(val
);
313 cpu_physical_memory_write(addr
, (const uint8_t *)&val
, sizeof(val
));
316 #define POLYNOMIAL 0x04c11db6
320 static unsigned compute_mcast_idx(const uint8_t * ep
)
327 for (i
= 0; i
< 6; i
++) {
329 for (j
= 0; j
< 8; j
++) {
330 carry
= ((crc
& 0x80000000L
) ? 1 : 0) ^ (b
& 0x01);
334 crc
= ((crc
^ POLYNOMIAL
) | carry
);
338 return (crc
& BITS(7, 2)) >> 2;
341 #if defined(DEBUG_EEPRO100)
342 static const char *nic_dump(const uint8_t * buf
, unsigned size
)
344 static char dump
[3 * 16 + 1];
350 p
+= sprintf(p
, " %02x", *buf
++);
354 #endif /* DEBUG_EEPRO100 */
357 stat_ack_not_ours
= 0x00,
358 stat_ack_sw_gen
= 0x04,
360 stat_ack_cu_idle
= 0x20,
361 stat_ack_frame_rx
= 0x40,
362 stat_ack_cu_cmd_done
= 0x80,
363 stat_ack_not_present
= 0xFF,
364 stat_ack_rx
= (stat_ack_sw_gen
| stat_ack_rnr
| stat_ack_frame_rx
),
365 stat_ack_tx
= (stat_ack_cu_idle
| stat_ack_cu_cmd_done
),
368 static void disable_interrupt(EEPRO100State
* s
)
371 TRACE(INT
, logout("interrupt disabled\n"));
372 qemu_irq_lower(s
->dev
.irq
[0]);
377 static void enable_interrupt(EEPRO100State
* s
)
380 TRACE(INT
, logout("interrupt enabled\n"));
381 qemu_irq_raise(s
->dev
.irq
[0]);
386 static void eepro100_acknowledge(EEPRO100State
* s
)
388 s
->scb_stat
&= ~s
->mem
[SCBAck
];
389 s
->mem
[SCBAck
] = s
->scb_stat
;
390 if (s
->scb_stat
== 0) {
391 disable_interrupt(s
);
395 static void eepro100_interrupt(EEPRO100State
* s
, uint8_t status
)
397 uint8_t mask
= ~s
->mem
[SCBIntmask
];
398 s
->mem
[SCBAck
] |= status
;
399 status
= s
->scb_stat
= s
->mem
[SCBAck
];
400 status
&= (mask
| 0x0f);
402 status
&= (~s
->mem
[SCBIntmask
] | 0x0xf
);
404 if (status
&& (mask
& 0x01)) {
405 /* SCB mask and SCB Bit M do not disable interrupt. */
407 } else if (s
->int_stat
) {
408 disable_interrupt(s
);
412 static void eepro100_cx_interrupt(EEPRO100State
* s
)
414 /* CU completed action command. */
415 /* Transmit not ok (82557 only, not in emulation). */
416 eepro100_interrupt(s
, 0x80);
419 static void eepro100_cna_interrupt(EEPRO100State
* s
)
421 /* CU left the active state. */
422 eepro100_interrupt(s
, 0x20);
425 static void eepro100_fr_interrupt(EEPRO100State
* s
)
427 /* RU received a complete frame. */
428 eepro100_interrupt(s
, 0x40);
431 static void eepro100_rnr_interrupt(EEPRO100State
* s
)
433 /* RU is not ready. */
434 eepro100_interrupt(s
, 0x10);
437 static void eepro100_mdi_interrupt(EEPRO100State
* s
)
439 /* MDI completed read or write cycle. */
440 eepro100_interrupt(s
, 0x08);
443 static void eepro100_swi_interrupt(EEPRO100State
* s
)
445 /* Software has requested an interrupt. */
446 eepro100_interrupt(s
, 0x04);
450 static void eepro100_fcp_interrupt(EEPRO100State
* s
)
452 /* Flow control pause interrupt (82558 and later). */
453 eepro100_interrupt(s
, 0x01);
457 static void e100_pci_reset(EEPRO100State
* s
, E100PCIDeviceInfo
*e100_device
)
459 uint32_t device
= s
->device
;
460 uint8_t *pci_conf
= s
->dev
.config
;
462 TRACE(OTHER
, logout("%p\n", s
));
465 pci_config_set_vendor_id(pci_conf
, PCI_VENDOR_ID_INTEL
);
467 pci_config_set_device_id(pci_conf
, e100_device
->device_id
);
469 pci_set_word(pci_conf
+ PCI_STATUS
, PCI_STATUS_DEVSEL_MEDIUM
|
470 PCI_STATUS_FAST_BACK
);
471 /* PCI Revision ID */
472 pci_config_set_revision(pci_conf
, e100_device
->revision
);
473 pci_config_set_class(pci_conf
, PCI_CLASS_NETWORK_ETHERNET
);
474 /* PCI Latency Timer */
475 pci_set_byte(pci_conf
+ PCI_LATENCY_TIMER
, 0x20); /* latency timer = 32 clocks */
476 /* Capability Pointer is set by PCI framework. */
478 pci_set_byte(pci_conf
+ PCI_MIN_GNT
, 0x08);
479 /* Maximum Latency */
480 pci_set_byte(pci_conf
+ PCI_MAX_LAT
, 0x18);
482 s
->stats_size
= e100_device
->stats_size
;
483 s
->has_extended_tcb_support
= e100_device
->has_extended_tcb_support
;
501 pci_set_word(pci_conf
+ PCI_SUBSYSTEM_VENDOR_ID
, PCI_VENDOR_ID_INTEL
);
502 pci_set_word(pci_conf
+ PCI_SUBSYSTEM_ID
, 0x0040);
506 logout("Device %X is undefined!\n", device
);
510 s
->configuration
[6] |= BIT(4);
512 /* Standard statistical counters. */
513 s
->configuration
[6] |= BIT(5);
515 if (s
->stats_size
== 80) {
516 /* TODO: check TCO Statistical Counters bit. Documentation not clear. */
517 if (s
->configuration
[6] & BIT(2)) {
518 /* TCO statistical counters. */
519 assert(s
->configuration
[6] & BIT(5));
521 if (s
->configuration
[6] & BIT(5)) {
522 /* No extended statistical counters, i82557 compatible. */
525 /* i82558 compatible. */
530 if (s
->configuration
[6] & BIT(5)) {
531 /* No extended statistical counters. */
535 assert(s
->stats_size
> 0 && s
->stats_size
<= sizeof(s
->statistics
));
537 if (e100_device
->power_management
) {
538 /* Power Management Capabilities */
540 pci_reserve_capability(&s
->dev
, PCI_CONFIG_HEADER_SIZE
,
541 0xdc - PCI_CONFIG_HEADER_SIZE
);
542 cfg_offset
= pci_add_capability(&s
->dev
, PCI_CAP_ID_PM
, PCI_PM_SIZEOF
);
543 assert(cfg_offset
== 0xdc);
544 if (cfg_offset
> 0) {
545 /* Power Management Capabilities */
546 pci_set_word(pci_conf
+ cfg_offset
+ PCI_PM_PMC
, 0x7e21);
547 #if 0 /* TODO: replace dummy code for power management emulation. */
548 /* TODO: Power Management Control / Status. */
549 pci_set_word(pci_conf
+ cfg_offset
+ PCI_PM_CTRL
, 0x0000);
550 /* TODO: Ethernet Power Consumption Registers (i82559 and later). */
551 pci_set_byte(pci_conf
+ cfg_offset
+ PCI_PM_PPB_EXTENSIONS
, 0x0000);
557 if (device
== i82557C
|| device
== i82558B
|| device
== i82559C
) {
559 TODO: get vendor id from EEPROM for i82557C or later.
560 TODO: get device id from EEPROM for i82557C or later.
561 TODO: status bit 4 can be disabled by EEPROM for i82558, i82559.
562 TODO: header type is determined by EEPROM for i82559.
563 TODO: get subsystem id from EEPROM for i82557C or later.
564 TODO: get subsystem vendor id from EEPROM for i82557C or later.
565 TODO: exp. rom baddr depends on a bit in EEPROM for i82558 or later.
566 TODO: capability pointer depends on EEPROM for i82558.
568 logout("Get device id and revision from EEPROM!!!\n");
570 #endif /* EEPROM_SIZE > 0 */
573 static void nic_selective_reset(EEPRO100State
* s
)
576 uint16_t *eeprom_contents
= eeprom93xx_data(s
->eeprom
);
578 eeprom93xx_reset(s
->eeprom
);
580 memcpy(eeprom_contents
, s
->conf
.macaddr
.a
, 6);
581 eeprom_contents
[EEPROM_ID
] = EEPROM_ID_VALID
;
582 if (s
->device
== i82557B
|| s
->device
== i82557C
)
583 eeprom_contents
[5] = 0x0100;
584 eeprom_contents
[EEPROM_PHY_ID
] = 1;
586 for (i
= 0; i
< EEPROM_SIZE
- 1; i
++) {
587 sum
+= eeprom_contents
[i
];
589 eeprom_contents
[EEPROM_SIZE
- 1] = 0xbaba - sum
;
590 TRACE(EEPROM
, logout("checksum=0x%04x\n", eeprom_contents
[EEPROM_SIZE
- 1]));
592 memset(s
->mem
, 0, sizeof(s
->mem
));
593 uint32_t val
= BIT(21);
594 memcpy(&s
->mem
[SCBCtrlMDI
], &val
, sizeof(val
));
596 assert(sizeof(s
->mdimem
) == sizeof(eepro100_mdi_default
));
597 memcpy(&s
->mdimem
[0], &eepro100_mdi_default
[0], sizeof(s
->mdimem
));
600 static void nic_reset(void *opaque
)
602 EEPRO100State
*s
= opaque
;
603 TRACE(OTHER
, logout("%p\n", s
));
604 /* TODO: Clearing of multicast table for selective reset, too? */
605 memset(&s
->mult
[0], 0, sizeof(s
->mult
));
606 nic_selective_reset(s
);
609 #if defined(DEBUG_EEPRO100)
610 static const char * const e100_reg
[PCI_IO_SIZE
/ 4] = {
614 "EEPROM/Flash Control",
616 "Receive DMA Byte Count",
618 "General Status/Control"
621 static char *regname(uint32_t addr
)
624 if (addr
< PCI_IO_SIZE
) {
625 const char *r
= e100_reg
[addr
/ 4];
627 snprintf(buf
, sizeof(buf
), "%s+%u", r
, addr
% 4);
629 snprintf(buf
, sizeof(buf
), "0x%02x", addr
);
632 snprintf(buf
, sizeof(buf
), "??? 0x%08x", addr
);
636 #endif /* DEBUG_EEPRO100 */
638 /*****************************************************************************
642 ****************************************************************************/
645 static uint16_t eepro100_read_command(EEPRO100State
* s
)
647 uint16_t val
= 0xffff;
648 TRACE(OTHER
, logout("val=0x%04x\n", val
));
653 /* Commands that can be put in a command list entry. */
658 CmdMulticastList
= 3,
660 CmdTDR
= 5, /* load microcode */
664 /* And some extra flags: */
665 CmdSuspend
= 0x4000, /* Suspend after completion. */
666 CmdIntr
= 0x2000, /* Interrupt after completion. */
667 CmdTxFlex
= 0x0008, /* Use "Flexible mode" for CmdTx command. */
670 static cu_state_t
get_cu_state(EEPRO100State
* s
)
672 return ((s
->mem
[SCBStatus
] & BITS(7, 6)) >> 6);
675 static void set_cu_state(EEPRO100State
* s
, cu_state_t state
)
677 s
->mem
[SCBStatus
] = (s
->mem
[SCBStatus
] & ~BITS(7, 6)) + (state
<< 6);
680 static ru_state_t
get_ru_state(EEPRO100State
* s
)
682 return ((s
->mem
[SCBStatus
] & BITS(5, 2)) >> 2);
685 static void set_ru_state(EEPRO100State
* s
, ru_state_t state
)
687 s
->mem
[SCBStatus
] = (s
->mem
[SCBStatus
] & ~BITS(5, 2)) + (state
<< 2);
690 static void dump_statistics(EEPRO100State
* s
)
692 /* Dump statistical data. Most data is never changed by the emulation
693 * and always 0, so we first just copy the whole block and then those
694 * values which really matter.
695 * Number of data should check configuration!!!
697 cpu_physical_memory_write(s
->statsaddr
,
698 (uint8_t *) & s
->statistics
, s
->stats_size
);
699 stl_le_phys(s
->statsaddr
+ 0, s
->statistics
.tx_good_frames
);
700 stl_le_phys(s
->statsaddr
+ 36, s
->statistics
.rx_good_frames
);
701 stl_le_phys(s
->statsaddr
+ 48, s
->statistics
.rx_resource_errors
);
702 stl_le_phys(s
->statsaddr
+ 60, s
->statistics
.rx_short_frame_errors
);
704 stw_le_phys(s
->statsaddr
+ 76, s
->statistics
.xmt_tco_frames
);
705 stw_le_phys(s
->statsaddr
+ 78, s
->statistics
.rcv_tco_frames
);
706 missing("CU dump statistical counters");
710 static void read_cb(EEPRO100State
*s
)
712 cpu_physical_memory_read(s
->cb_address
, (uint8_t *) &s
->tx
, sizeof(s
->tx
));
713 s
->tx
.status
= le16_to_cpu(s
->tx
.status
);
714 s
->tx
.command
= le16_to_cpu(s
->tx
.command
);
715 s
->tx
.link
= le32_to_cpu(s
->tx
.link
);
716 s
->tx
.tbd_array_addr
= le32_to_cpu(s
->tx
.tbd_array_addr
);
717 s
->tx
.tcb_bytes
= le16_to_cpu(s
->tx
.tcb_bytes
);
720 static void tx_command(EEPRO100State
*s
)
722 uint32_t tbd_array
= le32_to_cpu(s
->tx
.tbd_array_addr
);
723 uint16_t tcb_bytes
= (le16_to_cpu(s
->tx
.tcb_bytes
) & 0x3fff);
724 /* Sends larger than MAX_ETH_FRAME_SIZE are allowed, up to 2600 bytes. */
727 uint32_t tbd_address
= s
->cb_address
+ 0x10;
729 ("transmit, TBD array address 0x%08x, TCB byte count 0x%04x, TBD count %u\n",
730 tbd_array
, tcb_bytes
, s
->tx
.tbd_count
));
732 if (tcb_bytes
> 2600) {
733 logout("TCB byte count too large, using 2600\n");
736 if (!((tcb_bytes
> 0) || (tbd_array
!= 0xffffffff))) {
738 ("illegal values of TBD array address and TCB byte count!\n");
740 assert(tcb_bytes
<= sizeof(buf
));
741 while (size
< tcb_bytes
) {
742 uint32_t tx_buffer_address
= ldl_phys(tbd_address
);
743 uint16_t tx_buffer_size
= lduw_phys(tbd_address
+ 4);
745 uint16_t tx_buffer_el
= lduw_phys(tbd_address
+ 6);
749 ("TBD (simplified mode): buffer address 0x%08x, size 0x%04x\n",
750 tx_buffer_address
, tx_buffer_size
));
751 tx_buffer_size
= MIN(tx_buffer_size
, sizeof(buf
) - size
);
752 cpu_physical_memory_read(tx_buffer_address
, &buf
[size
],
754 size
+= tx_buffer_size
;
756 if (tbd_array
== 0xffffffff) {
757 /* Simplified mode. Was already handled by code above. */
760 uint8_t tbd_count
= 0;
761 if (s
->has_extended_tcb_support
&& !(s
->configuration
[6] & BIT(4))) {
762 /* Extended Flexible TCB. */
763 for (; tbd_count
< 2; tbd_count
++) {
764 uint32_t tx_buffer_address
= ldl_phys(tbd_address
);
765 uint16_t tx_buffer_size
= lduw_phys(tbd_address
+ 4);
766 uint16_t tx_buffer_el
= lduw_phys(tbd_address
+ 6);
769 ("TBD (extended flexible mode): buffer address 0x%08x, size 0x%04x\n",
770 tx_buffer_address
, tx_buffer_size
));
771 tx_buffer_size
= MIN(tx_buffer_size
, sizeof(buf
) - size
);
772 cpu_physical_memory_read(tx_buffer_address
, &buf
[size
],
774 size
+= tx_buffer_size
;
775 if (tx_buffer_el
& 1) {
780 tbd_address
= tbd_array
;
781 for (; tbd_count
< s
->tx
.tbd_count
; tbd_count
++) {
782 uint32_t tx_buffer_address
= ldl_phys(tbd_address
);
783 uint16_t tx_buffer_size
= lduw_phys(tbd_address
+ 4);
784 uint16_t tx_buffer_el
= lduw_phys(tbd_address
+ 6);
787 ("TBD (flexible mode): buffer address 0x%08x, size 0x%04x\n",
788 tx_buffer_address
, tx_buffer_size
));
789 tx_buffer_size
= MIN(tx_buffer_size
, sizeof(buf
) - size
);
790 cpu_physical_memory_read(tx_buffer_address
, &buf
[size
],
792 size
+= tx_buffer_size
;
793 if (tx_buffer_el
& 1) {
798 TRACE(RXTX
, logout("%p sending frame, len=%d,%s\n", s
, size
, nic_dump(buf
, size
)));
799 qemu_send_packet(&s
->nic
->nc
, buf
, size
);
800 s
->statistics
.tx_good_frames
++;
801 /* Transmit with bad status would raise an CX/TNO interrupt.
802 * (82557 only). Emulation never has bad status. */
804 eepro100_cx_interrupt(s
);
808 static void set_multicast_list(EEPRO100State
*s
)
810 uint16_t multicast_count
= s
->tx
.tbd_array_addr
& BITS(13, 0);
812 memset(&s
->mult
[0], 0, sizeof(s
->mult
));
813 TRACE(OTHER
, logout("multicast list, multicast count = %u\n", multicast_count
));
814 for (i
= 0; i
< multicast_count
; i
+= 6) {
815 uint8_t multicast_addr
[6];
816 cpu_physical_memory_read(s
->cb_address
+ 10 + i
, multicast_addr
, 6);
817 TRACE(OTHER
, logout("multicast entry %s\n", nic_dump(multicast_addr
, 6)));
818 unsigned mcast_idx
= compute_mcast_idx(multicast_addr
);
819 assert(mcast_idx
< 64);
820 s
->mult
[mcast_idx
>> 3] |= (1 << (mcast_idx
& 7));
824 static void action_command(EEPRO100State
*s
)
831 uint16_t ok_status
= STATUS_OK
;
832 s
->cb_address
= s
->cu_base
+ s
->cu_offset
;
834 bit_el
= ((s
->tx
.command
& COMMAND_EL
) != 0);
835 bit_s
= ((s
->tx
.command
& COMMAND_S
) != 0);
836 bit_i
= ((s
->tx
.command
& COMMAND_I
) != 0);
837 bit_nc
= ((s
->tx
.command
& COMMAND_NC
) != 0);
839 bool bit_sf
= ((s
->tx
.command
& COMMAND_SF
) != 0);
841 s
->cu_offset
= s
->tx
.link
;
843 logout("val=(cu start), status=0x%04x, command=0x%04x, link=0x%08x\n",
844 s
->tx
.status
, s
->tx
.command
, s
->tx
.link
));
845 switch (s
->tx
.command
& COMMAND_CMD
) {
850 cpu_physical_memory_read(s
->cb_address
+ 8, &s
->conf
.macaddr
.a
[0], 6);
851 TRACE(OTHER
, logout("macaddr: %s\n", nic_dump(&s
->conf
.macaddr
.a
[0], 6)));
854 cpu_physical_memory_read(s
->cb_address
+ 8, &s
->configuration
[0],
855 sizeof(s
->configuration
));
856 TRACE(OTHER
, logout("configuration: %s\n", nic_dump(&s
->configuration
[0], 16)));
858 case CmdMulticastList
:
859 set_multicast_list(s
);
863 missing("CmdTx: NC = 0");
870 TRACE(OTHER
, logout("load microcode\n"));
871 /* Starting with offset 8, the command contains
872 * 64 dwords microcode which we just ignore here. */
875 TRACE(OTHER
, logout("diagnose\n"));
876 /* Make sure error flag is not set. */
880 missing("undefined command");
884 /* Write new status. */
885 stw_phys(s
->cb_address
, s
->tx
.status
| ok_status
| STATUS_C
);
887 /* CU completed action. */
888 eepro100_cx_interrupt(s
);
891 /* CU becomes idle. Terminate command loop. */
892 set_cu_state(s
, cu_idle
);
893 eepro100_cna_interrupt(s
);
896 /* CU becomes suspended. Terminate command loop. */
897 set_cu_state(s
, cu_suspended
);
898 eepro100_cna_interrupt(s
);
901 /* More entries in list. */
902 TRACE(OTHER
, logout("CU list with at least one more entry\n"));
905 TRACE(OTHER
, logout("CU list empty\n"));
906 /* List is empty. Now CU is idle or suspended. */
909 static void eepro100_cu_command(EEPRO100State
* s
, uint8_t val
)
917 cu_state
= get_cu_state(s
);
918 if (cu_state
!= cu_idle
&& cu_state
!= cu_suspended
) {
919 /* Intel documentation says that CU must be idle or suspended
920 * for the CU start command. */
921 logout("unexpected CU state is %u\n", cu_state
);
923 set_cu_state(s
, cu_active
);
924 s
->cu_offset
= s
->pointer
;
928 if (get_cu_state(s
) != cu_suspended
) {
929 logout("bad CU resume from CU state %u\n", get_cu_state(s
));
930 /* Workaround for bad Linux eepro100 driver which resumes
931 * from idle state. */
933 missing("cu resume");
935 set_cu_state(s
, cu_suspended
);
937 if (get_cu_state(s
) == cu_suspended
) {
938 TRACE(OTHER
, logout("CU resuming\n"));
939 set_cu_state(s
, cu_active
);
944 /* Load dump counters address. */
945 s
->statsaddr
= s
->pointer
;
946 TRACE(OTHER
, logout("val=0x%02x (status address)\n", val
));
949 /* Dump statistical counters. */
950 TRACE(OTHER
, logout("val=0x%02x (dump stats)\n", val
));
952 stl_le_phys(s
->statsaddr
+ s
->stats_size
, 0xa005);
956 TRACE(OTHER
, logout("val=0x%02x (CU base address)\n", val
));
957 s
->cu_base
= s
->pointer
;
960 /* Dump and reset statistical counters. */
961 TRACE(OTHER
, logout("val=0x%02x (dump stats and reset)\n", val
));
963 stl_le_phys(s
->statsaddr
+ s
->stats_size
, 0xa007);
964 memset(&s
->statistics
, 0, sizeof(s
->statistics
));
967 /* CU static resume. */
968 missing("CU static resume");
971 missing("Undefined CU command");
975 static void eepro100_ru_command(EEPRO100State
* s
, uint8_t val
)
983 if (get_ru_state(s
) != ru_idle
) {
984 logout("RU state is %u, should be %u\n", get_ru_state(s
), ru_idle
);
986 assert(!"wrong RU state");
989 set_ru_state(s
, ru_ready
);
990 s
->ru_offset
= s
->pointer
;
991 TRACE(OTHER
, logout("val=0x%02x (rx start)\n", val
));
995 if (get_ru_state(s
) != ru_suspended
) {
996 logout("RU state is %u, should be %u\n", get_ru_state(s
),
999 assert(!"wrong RU state");
1002 set_ru_state(s
, ru_ready
);
1006 if (get_ru_state(s
) == ru_ready
) {
1007 eepro100_rnr_interrupt(s
);
1009 set_ru_state(s
, ru_idle
);
1013 TRACE(OTHER
, logout("val=0x%02x (RU base address)\n", val
));
1014 s
->ru_base
= s
->pointer
;
1017 logout("val=0x%02x (undefined RU command)\n", val
);
1018 missing("Undefined SU command");
1022 static void eepro100_write_command(EEPRO100State
* s
, uint8_t val
)
1024 eepro100_ru_command(s
, val
& 0x0f);
1025 eepro100_cu_command(s
, val
& 0xf0);
1027 TRACE(OTHER
, logout("val=0x%02x\n", val
));
1029 /* Clear command byte after command was accepted. */
1033 /*****************************************************************************
1037 ****************************************************************************/
1039 #define EEPROM_CS 0x02
1040 #define EEPROM_SK 0x01
1041 #define EEPROM_DI 0x04
1042 #define EEPROM_DO 0x08
1044 static uint16_t eepro100_read_eeprom(EEPRO100State
* s
)
1047 memcpy(&val
, &s
->mem
[SCBeeprom
], sizeof(val
));
1048 if (eeprom93xx_read(s
->eeprom
)) {
1053 TRACE(EEPROM
, logout("val=0x%04x\n", val
));
1057 static void eepro100_write_eeprom(eeprom_t
* eeprom
, uint8_t val
)
1059 TRACE(EEPROM
, logout("val=0x%02x\n", val
));
1061 /* mask unwriteable bits */
1063 val
= SET_MASKED(val
, 0x31, eeprom
->value
);
1066 int eecs
= ((val
& EEPROM_CS
) != 0);
1067 int eesk
= ((val
& EEPROM_SK
) != 0);
1068 int eedi
= ((val
& EEPROM_DI
) != 0);
1069 eeprom93xx_write(eeprom
, eecs
, eesk
, eedi
);
1072 static void eepro100_write_pointer(EEPRO100State
* s
, uint32_t val
)
1074 s
->pointer
= le32_to_cpu(val
);
1075 TRACE(OTHER
, logout("val=0x%08x\n", val
));
1078 /*****************************************************************************
1082 ****************************************************************************/
1084 #if defined(DEBUG_EEPRO100)
1085 static const char * const mdi_op_name
[] = {
1092 static const char * const mdi_reg_name
[] = {
1095 "PHY Identification (Word 1)",
1096 "PHY Identification (Word 2)",
1097 "Auto-Negotiation Advertisement",
1098 "Auto-Negotiation Link Partner Ability",
1099 "Auto-Negotiation Expansion"
1102 static const char *reg2name(uint8_t reg
)
1104 static char buffer
[10];
1105 const char *p
= buffer
;
1106 if (reg
< ARRAY_SIZE(mdi_reg_name
)) {
1107 p
= mdi_reg_name
[reg
];
1109 snprintf(buffer
, sizeof(buffer
), "reg=0x%02x", reg
);
1113 #endif /* DEBUG_EEPRO100 */
1115 static uint32_t eepro100_read_mdi(EEPRO100State
* s
)
1118 memcpy(&val
, &s
->mem
[0x10], sizeof(val
));
1120 #ifdef DEBUG_EEPRO100
1121 uint8_t raiseint
= (val
& BIT(29)) >> 29;
1122 uint8_t opcode
= (val
& BITS(27, 26)) >> 26;
1123 uint8_t phy
= (val
& BITS(25, 21)) >> 21;
1124 uint8_t reg
= (val
& BITS(20, 16)) >> 16;
1125 uint16_t data
= (val
& BITS(15, 0));
1127 /* Emulation takes no time to finish MDI transaction. */
1129 TRACE(MDI
, logout("val=0x%08x (int=%u, %s, phy=%u, %s, data=0x%04x\n",
1130 val
, raiseint
, mdi_op_name
[opcode
], phy
,
1131 reg2name(reg
), data
));
1135 static void eepro100_write_mdi(EEPRO100State
* s
, uint32_t val
)
1137 uint8_t raiseint
= (val
& BIT(29)) >> 29;
1138 uint8_t opcode
= (val
& BITS(27, 26)) >> 26;
1139 uint8_t phy
= (val
& BITS(25, 21)) >> 21;
1140 uint8_t reg
= (val
& BITS(20, 16)) >> 16;
1141 uint16_t data
= (val
& BITS(15, 0));
1142 TRACE(MDI
, logout("val=0x%08x (int=%u, %s, phy=%u, %s, data=0x%04x\n",
1143 val
, raiseint
, mdi_op_name
[opcode
], phy
, reg2name(reg
), data
));
1145 /* Unsupported PHY address. */
1147 logout("phy must be 1 but is %u\n", phy
);
1150 } else if (opcode
!= 1 && opcode
!= 2) {
1151 /* Unsupported opcode. */
1152 logout("opcode must be 1 or 2 but is %u\n", opcode
);
1154 } else if (reg
> 6) {
1155 /* Unsupported register. */
1156 logout("register must be 0...6 but is %u\n", reg
);
1159 TRACE(MDI
, logout("val=0x%08x (int=%u, %s, phy=%u, %s, data=0x%04x\n",
1160 val
, raiseint
, mdi_op_name
[opcode
], phy
,
1161 reg2name(reg
), data
));
1165 case 0: /* Control Register */
1166 if (data
& 0x8000) {
1167 /* Reset status and control registers to default. */
1168 s
->mdimem
[0] = eepro100_mdi_default
[0];
1169 s
->mdimem
[1] = eepro100_mdi_default
[1];
1170 data
= s
->mdimem
[reg
];
1172 /* Restart Auto Configuration = Normal Operation */
1176 case 1: /* Status Register */
1177 missing("not writable");
1178 data
= s
->mdimem
[reg
];
1180 case 2: /* PHY Identification Register (Word 1) */
1181 case 3: /* PHY Identification Register (Word 2) */
1182 missing("not implemented");
1184 case 4: /* Auto-Negotiation Advertisement Register */
1185 case 5: /* Auto-Negotiation Link Partner Ability Register */
1187 case 6: /* Auto-Negotiation Expansion Register */
1189 missing("not implemented");
1191 s
->mdimem
[reg
] = data
;
1192 } else if (opcode
== 2) {
1195 case 0: /* Control Register */
1196 if (data
& 0x8000) {
1197 /* Reset status and control registers to default. */
1198 s
->mdimem
[0] = eepro100_mdi_default
[0];
1199 s
->mdimem
[1] = eepro100_mdi_default
[1];
1202 case 1: /* Status Register */
1203 s
->mdimem
[reg
] |= 0x0020;
1205 case 2: /* PHY Identification Register (Word 1) */
1206 case 3: /* PHY Identification Register (Word 2) */
1207 case 4: /* Auto-Negotiation Advertisement Register */
1209 case 5: /* Auto-Negotiation Link Partner Ability Register */
1210 s
->mdimem
[reg
] = 0x41fe;
1212 case 6: /* Auto-Negotiation Expansion Register */
1213 s
->mdimem
[reg
] = 0x0001;
1216 data
= s
->mdimem
[reg
];
1218 /* Emulation takes no time to finish MDI transaction.
1219 * Set MDI bit in SCB status register. */
1220 s
->mem
[SCBAck
] |= 0x08;
1223 eepro100_mdi_interrupt(s
);
1226 val
= (val
& 0xffff0000) + data
;
1227 memcpy(&s
->mem
[0x10], &val
, sizeof(val
));
1230 /*****************************************************************************
1234 ****************************************************************************/
1236 #define PORT_SOFTWARE_RESET 0
1237 #define PORT_SELFTEST 1
1238 #define PORT_SELECTIVE_RESET 2
1240 #define PORT_SELECTION_MASK 3
1243 uint32_t st_sign
; /* Self Test Signature */
1244 uint32_t st_result
; /* Self Test Results */
1245 } eepro100_selftest_t
;
1247 static uint32_t eepro100_read_port(EEPRO100State
* s
)
1252 static void eepro100_write_port(EEPRO100State
* s
, uint32_t val
)
1254 val
= le32_to_cpu(val
);
1255 uint32_t address
= (val
& ~PORT_SELECTION_MASK
);
1256 uint8_t selection
= (val
& PORT_SELECTION_MASK
);
1257 switch (selection
) {
1258 case PORT_SOFTWARE_RESET
:
1262 TRACE(OTHER
, logout("selftest address=0x%08x\n", address
));
1263 eepro100_selftest_t data
;
1264 cpu_physical_memory_read(address
, (uint8_t *) & data
, sizeof(data
));
1265 data
.st_sign
= 0xffffffff;
1267 cpu_physical_memory_write(address
, (uint8_t *) & data
, sizeof(data
));
1269 case PORT_SELECTIVE_RESET
:
1270 TRACE(OTHER
, logout("selective reset, selftest address=0x%08x\n", address
));
1271 nic_selective_reset(s
);
1274 logout("val=0x%08x\n", val
);
1275 missing("unknown port selection");
1279 /*****************************************************************************
1281 * General hardware emulation.
1283 ****************************************************************************/
1285 static uint8_t eepro100_read1(EEPRO100State
* s
, uint32_t addr
)
1288 if (addr
<= sizeof(s
->mem
) - sizeof(val
)) {
1289 memcpy(&val
, &s
->mem
[addr
], sizeof(val
));
1295 TRACE(OTHER
, logout("addr=%s val=0x%02x\n", regname(addr
), val
));
1298 TRACE(OTHER
, logout("addr=%s val=0x%02x\n", regname(addr
), val
));
1300 val
= eepro100_read_command(s
);
1304 TRACE(OTHER
, logout("addr=%s val=0x%02x\n", regname(addr
), val
));
1307 TRACE(OTHER
, logout("addr=%s val=0x%02x\n", regname(addr
), val
));
1310 val
= eepro100_read_eeprom(s
);
1312 case SCBpmdr
: /* Power Management Driver Register */
1314 TRACE(OTHER
, logout("addr=%s val=0x%02x\n", regname(addr
), val
));
1316 case SCBgstat
: /* General Status Register */
1317 /* 100 Mbps full duplex, valid link */
1319 TRACE(OTHER
, logout("addr=General Status val=%02x\n", val
));
1322 logout("addr=%s val=0x%02x\n", regname(addr
), val
);
1323 missing("unknown byte read");
1328 static uint16_t eepro100_read2(EEPRO100State
* s
, uint32_t addr
)
1331 if (addr
<= sizeof(s
->mem
) - sizeof(val
)) {
1332 memcpy(&val
, &s
->mem
[addr
], sizeof(val
));
1338 TRACE(OTHER
, logout("addr=%s val=0x%04x\n", regname(addr
), val
));
1341 val
= eepro100_read_eeprom(s
);
1342 TRACE(OTHER
, logout("addr=%s val=0x%04x\n", regname(addr
), val
));
1345 logout("addr=%s val=0x%04x\n", regname(addr
), val
);
1346 missing("unknown word read");
1351 static uint32_t eepro100_read4(EEPRO100State
* s
, uint32_t addr
)
1354 if (addr
<= sizeof(s
->mem
) - sizeof(val
)) {
1355 memcpy(&val
, &s
->mem
[addr
], sizeof(val
));
1360 TRACE(OTHER
, logout("addr=%s val=0x%08x\n", regname(addr
), val
));
1364 val
= eepro100_read_pointer(s
);
1366 TRACE(OTHER
, logout("addr=%s val=0x%08x\n", regname(addr
), val
));
1369 val
= eepro100_read_port(s
);
1370 TRACE(OTHER
, logout("addr=%s val=0x%08x\n", regname(addr
), val
));
1373 val
= eepro100_read_mdi(s
);
1376 logout("addr=%s val=0x%08x\n", regname(addr
), val
);
1377 missing("unknown longword read");
1382 static void eepro100_write1(EEPRO100State
* s
, uint32_t addr
, uint8_t val
)
1384 /* SCBStatus is readonly. */
1385 if (addr
> SCBStatus
&& addr
<= sizeof(s
->mem
) - sizeof(val
)) {
1386 memcpy(&s
->mem
[addr
], &val
, sizeof(val
));
1389 TRACE(OTHER
, logout("addr=%s val=0x%02x\n", regname(addr
), val
));
1395 eepro100_acknowledge(s
);
1398 eepro100_write_command(s
, val
);
1402 eepro100_swi_interrupt(s
);
1404 eepro100_interrupt(s
, 0);
1407 case SCBFlow
: /* does not exist on 82557 */
1410 case SCBpmdr
: /* does not exist on 82557 */
1411 TRACE(OTHER
, logout("addr=%s val=0x%02x\n", regname(addr
), val
));
1414 eepro100_write_eeprom(s
->eeprom
, val
);
1417 logout("addr=%s val=0x%02x\n", regname(addr
), val
);
1418 missing("unknown byte write");
1422 static void eepro100_write2(EEPRO100State
* s
, uint32_t addr
, uint16_t val
)
1424 /* SCBStatus is readonly. */
1425 if (addr
> SCBStatus
&& addr
<= sizeof(s
->mem
) - sizeof(val
)) {
1426 memcpy(&s
->mem
[addr
], &val
, sizeof(val
));
1429 TRACE(OTHER
, logout("addr=%s val=0x%04x\n", regname(addr
), val
));
1433 s
->mem
[SCBAck
] = (val
>> 8);
1434 eepro100_acknowledge(s
);
1437 eepro100_write_command(s
, val
);
1438 eepro100_write1(s
, SCBIntmask
, val
>> 8);
1441 eepro100_write_eeprom(s
->eeprom
, val
);
1444 logout("addr=%s val=0x%04x\n", regname(addr
), val
);
1445 missing("unknown word write");
1449 static void eepro100_write4(EEPRO100State
* s
, uint32_t addr
, uint32_t val
)
1451 if (addr
<= sizeof(s
->mem
) - sizeof(val
)) {
1452 memcpy(&s
->mem
[addr
], &val
, sizeof(val
));
1457 eepro100_write_pointer(s
, val
);
1460 TRACE(OTHER
, logout("addr=%s val=0x%08x\n", regname(addr
), val
));
1461 eepro100_write_port(s
, val
);
1464 eepro100_write_mdi(s
, val
);
1467 logout("addr=%s val=0x%08x\n", regname(addr
), val
);
1468 missing("unknown longword write");
1472 /*****************************************************************************
1476 ****************************************************************************/
1478 static uint32_t ioport_read1(void *opaque
, uint32_t addr
)
1480 EEPRO100State
*s
= opaque
;
1482 logout("addr=%s\n", regname(addr
));
1484 return eepro100_read1(s
, addr
- s
->region
[1]);
1487 static uint32_t ioport_read2(void *opaque
, uint32_t addr
)
1489 EEPRO100State
*s
= opaque
;
1490 return eepro100_read2(s
, addr
- s
->region
[1]);
1493 static uint32_t ioport_read4(void *opaque
, uint32_t addr
)
1495 EEPRO100State
*s
= opaque
;
1496 return eepro100_read4(s
, addr
- s
->region
[1]);
1499 static void ioport_write1(void *opaque
, uint32_t addr
, uint32_t val
)
1501 EEPRO100State
*s
= opaque
;
1503 logout("addr=%s val=0x%02x\n", regname(addr
), val
);
1505 eepro100_write1(s
, addr
- s
->region
[1], val
);
1508 static void ioport_write2(void *opaque
, uint32_t addr
, uint32_t val
)
1510 EEPRO100State
*s
= opaque
;
1511 eepro100_write2(s
, addr
- s
->region
[1], val
);
1514 static void ioport_write4(void *opaque
, uint32_t addr
, uint32_t val
)
1516 EEPRO100State
*s
= opaque
;
1517 eepro100_write4(s
, addr
- s
->region
[1], val
);
1520 /***********************************************************/
1521 /* PCI EEPRO100 definitions */
1523 static void pci_map(PCIDevice
* pci_dev
, int region_num
,
1524 pcibus_t addr
, pcibus_t size
, int type
)
1526 EEPRO100State
*s
= DO_UPCAST(EEPRO100State
, dev
, pci_dev
);
1528 TRACE(OTHER
, logout("region %d, addr=0x%08"FMT_PCIBUS
", "
1529 "size=0x%08"FMT_PCIBUS
", type=%d\n",
1530 region_num
, addr
, size
, type
));
1532 assert(region_num
== 1);
1533 register_ioport_write(addr
, size
, 1, ioport_write1
, s
);
1534 register_ioport_read(addr
, size
, 1, ioport_read1
, s
);
1535 register_ioport_write(addr
, size
, 2, ioport_write2
, s
);
1536 register_ioport_read(addr
, size
, 2, ioport_read2
, s
);
1537 register_ioport_write(addr
, size
, 4, ioport_write4
, s
);
1538 register_ioport_read(addr
, size
, 4, ioport_read4
, s
);
1540 s
->region
[region_num
] = addr
;
1543 /*****************************************************************************
1545 * Memory mapped I/O.
1547 ****************************************************************************/
1549 static void pci_mmio_writeb(void *opaque
, target_phys_addr_t addr
, uint32_t val
)
1551 EEPRO100State
*s
= opaque
;
1553 logout("addr=%s val=0x%02x\n", regname(addr
), val
);
1555 eepro100_write1(s
, addr
, val
);
1558 static void pci_mmio_writew(void *opaque
, target_phys_addr_t addr
, uint32_t val
)
1560 EEPRO100State
*s
= opaque
;
1562 logout("addr=%s val=0x%02x\n", regname(addr
), val
);
1564 eepro100_write2(s
, addr
, val
);
1567 static void pci_mmio_writel(void *opaque
, target_phys_addr_t addr
, uint32_t val
)
1569 EEPRO100State
*s
= opaque
;
1571 logout("addr=%s val=0x%02x\n", regname(addr
), val
);
1573 eepro100_write4(s
, addr
, val
);
1576 static uint32_t pci_mmio_readb(void *opaque
, target_phys_addr_t addr
)
1578 EEPRO100State
*s
= opaque
;
1580 logout("addr=%s\n", regname(addr
));
1582 return eepro100_read1(s
, addr
);
1585 static uint32_t pci_mmio_readw(void *opaque
, target_phys_addr_t addr
)
1587 EEPRO100State
*s
= opaque
;
1589 logout("addr=%s\n", regname(addr
));
1591 return eepro100_read2(s
, addr
);
1594 static uint32_t pci_mmio_readl(void *opaque
, target_phys_addr_t addr
)
1596 EEPRO100State
*s
= opaque
;
1598 logout("addr=%s\n", regname(addr
));
1600 return eepro100_read4(s
, addr
);
1603 static CPUWriteMemoryFunc
* const pci_mmio_write
[] = {
1609 static CPUReadMemoryFunc
* const pci_mmio_read
[] = {
1615 static void pci_mmio_map(PCIDevice
* pci_dev
, int region_num
,
1616 pcibus_t addr
, pcibus_t size
, int type
)
1618 EEPRO100State
*s
= DO_UPCAST(EEPRO100State
, dev
, pci_dev
);
1620 TRACE(OTHER
, logout("region %d, addr=0x%08"FMT_PCIBUS
", "
1621 "size=0x%08"FMT_PCIBUS
", type=%d\n",
1622 region_num
, addr
, size
, type
));
1624 assert(region_num
== 0 || region_num
== 2);
1626 /* Map control / status registers and flash. */
1627 cpu_register_physical_memory(addr
, size
, s
->mmio_index
);
1628 s
->region
[region_num
] = addr
;
1631 static int nic_can_receive(VLANClientState
*nc
)
1633 EEPRO100State
*s
= DO_UPCAST(NICState
, nc
, nc
)->opaque
;
1634 TRACE(RXTX
, logout("%p\n", s
));
1635 return get_ru_state(s
) == ru_ready
;
1637 return !eepro100_buffer_full(s
);
1641 static ssize_t
nic_receive(VLANClientState
*nc
, const uint8_t * buf
, size_t size
)
1644 * - Magic packets should set bit 30 in power management driver register.
1645 * - Interesting packets should set bit 29 in power management driver register.
1647 EEPRO100State
*s
= DO_UPCAST(NICState
, nc
, nc
)->opaque
;
1648 uint16_t rfd_status
= 0xa000;
1649 static const uint8_t broadcast_macaddr
[6] =
1650 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1652 /* TODO: check multiple IA bit. */
1653 if (s
->configuration
[20] & BIT(6)) {
1654 missing("Multiple IA bit");
1658 if (s
->configuration
[8] & 0x80) {
1659 /* CSMA is disabled. */
1660 logout("%p received while CSMA is disabled\n", s
);
1662 } else if (size
< 64 && (s
->configuration
[7] & BIT(0))) {
1663 /* Short frame and configuration byte 7/0 (discard short receive) set:
1664 * Short frame is discarded */
1665 logout("%p received short frame (%zu byte)\n", s
, size
);
1666 s
->statistics
.rx_short_frame_errors
++;
1670 } else if ((size
> MAX_ETH_FRAME_SIZE
+ 4) && !(s
->configuration
[18] & BIT(3))) {
1671 /* Long frame and configuration byte 18/3 (long receive ok) not set:
1672 * Long frames are discarded. */
1673 logout("%p received long frame (%zu byte), ignored\n", s
, size
);
1675 } else if (memcmp(buf
, s
->conf
.macaddr
.a
, 6) == 0) { /* !!! */
1676 /* Frame matches individual address. */
1677 /* TODO: check configuration byte 15/4 (ignore U/L). */
1678 TRACE(RXTX
, logout("%p received frame for me, len=%zu\n", s
, size
));
1679 } else if (memcmp(buf
, broadcast_macaddr
, 6) == 0) {
1680 /* Broadcast frame. */
1681 TRACE(RXTX
, logout("%p received broadcast, len=%zu\n", s
, size
));
1682 rfd_status
|= 0x0002;
1683 } else if (buf
[0] & 0x01) {
1684 /* Multicast frame. */
1685 TRACE(RXTX
, logout("%p received multicast, len=%zu,%s\n", s
, size
, nic_dump(buf
, size
)));
1686 if (s
->configuration
[21] & BIT(3)) {
1687 /* Multicast all bit is set, receive all multicast frames. */
1689 unsigned mcast_idx
= compute_mcast_idx(buf
);
1690 assert(mcast_idx
< 64);
1691 if (s
->mult
[mcast_idx
>> 3] & (1 << (mcast_idx
& 7))) {
1692 /* Multicast frame is allowed in hash table. */
1693 } else if (s
->configuration
[15] & BIT(0)) {
1694 /* Promiscuous: receive all. */
1695 rfd_status
|= 0x0004;
1697 TRACE(RXTX
, logout("%p multicast ignored\n", s
));
1701 /* TODO: Next not for promiscuous mode? */
1702 rfd_status
|= 0x0002;
1703 } else if (s
->configuration
[15] & BIT(0)) {
1704 /* Promiscuous: receive all. */
1705 TRACE(RXTX
, logout("%p received frame in promiscuous mode, len=%zu\n", s
, size
));
1706 rfd_status
|= 0x0004;
1708 TRACE(RXTX
, logout("%p received frame, ignored, len=%zu,%s\n", s
, size
,
1709 nic_dump(buf
, size
)));
1713 if (get_ru_state(s
) != ru_ready
) {
1714 /* No resources available. */
1715 logout("no resources, state=%u\n", get_ru_state(s
));
1716 /* TODO: RNR interrupt only at first failed frame? */
1717 eepro100_rnr_interrupt(s
);
1718 s
->statistics
.rx_resource_errors
++;
1720 assert(!"no resources");
1726 cpu_physical_memory_read(s
->ru_base
+ s
->ru_offset
, (uint8_t *) & rx
,
1727 offsetof(eepro100_rx_t
, packet
));
1728 uint16_t rfd_command
= le16_to_cpu(rx
.command
);
1729 uint16_t rfd_size
= le16_to_cpu(rx
.size
);
1731 if (size
> rfd_size
) {
1732 logout("Receive buffer (%" PRId16
" bytes) too small for data "
1733 "(%zu bytes); data truncated\n", rfd_size
, size
);
1737 rfd_status
|= 0x0080;
1739 TRACE(OTHER
, logout("command 0x%04x, link 0x%08x, addr 0x%08x, size %u\n",
1740 rfd_command
, rx
.link
, rx
.rx_buf_addr
, rfd_size
));
1741 stw_phys(s
->ru_base
+ s
->ru_offset
+ offsetof(eepro100_rx_t
, status
),
1743 stw_phys(s
->ru_base
+ s
->ru_offset
+ offsetof(eepro100_rx_t
, count
), size
);
1744 /* Early receive interrupt not supported. */
1746 eepro100_er_interrupt(s
);
1748 /* Receive CRC Transfer not supported. */
1749 if (s
->configuration
[18] & BIT(2)) {
1750 missing("Receive CRC Transfer");
1753 /* TODO: check stripping enable bit. */
1755 assert(!(s
->configuration
[17] & BIT(0)));
1757 cpu_physical_memory_write(s
->ru_base
+ s
->ru_offset
+
1758 offsetof(eepro100_rx_t
, packet
), buf
, size
);
1759 s
->statistics
.rx_good_frames
++;
1760 eepro100_fr_interrupt(s
);
1761 s
->ru_offset
= le32_to_cpu(rx
.link
);
1762 if (rfd_command
& COMMAND_EL
) {
1763 /* EL bit is set, so this was the last frame. */
1764 logout("receive: Running out of frames\n");
1765 set_ru_state(s
, ru_suspended
);
1767 if (rfd_command
& COMMAND_S
) {
1769 set_ru_state(s
, ru_suspended
);
1774 static const VMStateDescription vmstate_eepro100
= {
1776 .minimum_version_id
= 2,
1777 .minimum_version_id_old
= 2,
1778 .fields
= (VMStateField
[]) {
1779 VMSTATE_PCI_DEVICE(dev
, EEPRO100State
),
1781 VMSTATE_BUFFER(mult
, EEPRO100State
),
1782 VMSTATE_BUFFER(mem
, EEPRO100State
),
1783 /* Save all members of struct between scb_stat and mem. */
1784 VMSTATE_UINT8(scb_stat
, EEPRO100State
),
1785 VMSTATE_UINT8(int_stat
, EEPRO100State
),
1786 VMSTATE_UNUSED(3*4),
1787 VMSTATE_MACADDR(conf
.macaddr
, EEPRO100State
),
1788 VMSTATE_UNUSED(19*4),
1789 VMSTATE_UINT16_ARRAY(mdimem
, EEPRO100State
, 32),
1790 /* The eeprom should be saved and restored by its own routines. */
1791 VMSTATE_UINT32(device
, EEPRO100State
),
1792 /* TODO check device. */
1793 VMSTATE_UINT32(pointer
, EEPRO100State
),
1794 VMSTATE_UINT32(cu_base
, EEPRO100State
),
1795 VMSTATE_UINT32(cu_offset
, EEPRO100State
),
1796 VMSTATE_UINT32(ru_base
, EEPRO100State
),
1797 VMSTATE_UINT32(ru_offset
, EEPRO100State
),
1798 VMSTATE_UINT32(statsaddr
, EEPRO100State
),
1799 /* Save eepro100_stats_t statistics. */
1800 VMSTATE_UINT32(statistics
.tx_good_frames
, EEPRO100State
),
1801 VMSTATE_UINT32(statistics
.tx_max_collisions
, EEPRO100State
),
1802 VMSTATE_UINT32(statistics
.tx_late_collisions
, EEPRO100State
),
1803 VMSTATE_UINT32(statistics
.tx_underruns
, EEPRO100State
),
1804 VMSTATE_UINT32(statistics
.tx_lost_crs
, EEPRO100State
),
1805 VMSTATE_UINT32(statistics
.tx_deferred
, EEPRO100State
),
1806 VMSTATE_UINT32(statistics
.tx_single_collisions
, EEPRO100State
),
1807 VMSTATE_UINT32(statistics
.tx_multiple_collisions
, EEPRO100State
),
1808 VMSTATE_UINT32(statistics
.tx_total_collisions
, EEPRO100State
),
1809 VMSTATE_UINT32(statistics
.rx_good_frames
, EEPRO100State
),
1810 VMSTATE_UINT32(statistics
.rx_crc_errors
, EEPRO100State
),
1811 VMSTATE_UINT32(statistics
.rx_alignment_errors
, EEPRO100State
),
1812 VMSTATE_UINT32(statistics
.rx_resource_errors
, EEPRO100State
),
1813 VMSTATE_UINT32(statistics
.rx_overrun_errors
, EEPRO100State
),
1814 VMSTATE_UINT32(statistics
.rx_cdt_errors
, EEPRO100State
),
1815 VMSTATE_UINT32(statistics
.rx_short_frame_errors
, EEPRO100State
),
1816 VMSTATE_UINT32(statistics
.fc_xmt_pause
, EEPRO100State
),
1817 VMSTATE_UINT32(statistics
.fc_rcv_pause
, EEPRO100State
),
1818 VMSTATE_UINT32(statistics
.fc_rcv_unsupported
, EEPRO100State
),
1819 VMSTATE_UINT16(statistics
.xmt_tco_frames
, EEPRO100State
),
1820 VMSTATE_UINT16(statistics
.rcv_tco_frames
, EEPRO100State
),
1821 /* Configuration bytes. */
1822 VMSTATE_BUFFER(configuration
, EEPRO100State
),
1823 VMSTATE_END_OF_LIST()
1827 static void nic_cleanup(VLANClientState
*nc
)
1829 EEPRO100State
*s
= DO_UPCAST(NICState
, nc
, nc
)->opaque
;
1834 static int pci_nic_uninit(PCIDevice
*pci_dev
)
1836 EEPRO100State
*s
= DO_UPCAST(EEPRO100State
, dev
, pci_dev
);
1838 cpu_unregister_io_memory(s
->mmio_index
);
1839 vmstate_unregister(s
->vmstate
, s
);
1840 eeprom93xx_free(s
->eeprom
);
1841 qemu_del_vlan_client(&s
->nic
->nc
);
1845 static NetClientInfo net_eepro100_info
= {
1846 .type
= NET_CLIENT_TYPE_NIC
,
1847 .size
= sizeof(NICState
),
1848 .can_receive
= nic_can_receive
,
1849 .receive
= nic_receive
,
1850 .cleanup
= nic_cleanup
,
1853 static int e100_nic_init(PCIDevice
*pci_dev
)
1855 EEPRO100State
*s
= DO_UPCAST(EEPRO100State
, dev
, pci_dev
);
1856 E100PCIDeviceInfo
*e100_device
= DO_UPCAST(E100PCIDeviceInfo
, pci
.qdev
,
1857 pci_dev
->qdev
.info
);
1859 TRACE(OTHER
, logout("\n"));
1861 s
->device
= e100_device
->device
;
1863 e100_pci_reset(s
, e100_device
);
1865 /* Add 64 * 2 EEPROM. i82557 and i82558 support a 64 word EEPROM,
1866 * i82559 and later support 64 or 256 word EEPROM. */
1867 s
->eeprom
= eeprom93xx_new(EEPROM_SIZE
);
1869 /* Handler for memory-mapped I/O */
1871 cpu_register_io_memory(pci_mmio_read
, pci_mmio_write
, s
);
1873 pci_register_bar(&s
->dev
, 0, PCI_MEM_SIZE
,
1874 PCI_BASE_ADDRESS_SPACE_MEMORY
|
1875 PCI_BASE_ADDRESS_MEM_PREFETCH
, pci_mmio_map
);
1876 pci_register_bar(&s
->dev
, 1, PCI_IO_SIZE
, PCI_BASE_ADDRESS_SPACE_IO
,
1878 pci_register_bar(&s
->dev
, 2, PCI_FLASH_SIZE
, PCI_BASE_ADDRESS_SPACE_MEMORY
,
1881 qemu_macaddr_default_if_unset(&s
->conf
.macaddr
);
1882 logout("macaddr: %s\n", nic_dump(&s
->conf
.macaddr
.a
[0], 6));
1883 assert(s
->region
[1] == 0);
1887 s
->nic
= qemu_new_nic(&net_eepro100_info
, &s
->conf
,
1888 pci_dev
->qdev
.info
->name
, pci_dev
->qdev
.id
, s
);
1890 qemu_format_nic_info_str(&s
->nic
->nc
, s
->conf
.macaddr
.a
);
1891 TRACE(OTHER
, logout("%s\n", s
->nic
->nc
.info_str
));
1893 qemu_register_reset(nic_reset
, s
);
1895 s
->vmstate
= qemu_malloc(sizeof(vmstate_eepro100
));
1896 memcpy(s
->vmstate
, &vmstate_eepro100
, sizeof(vmstate_eepro100
));
1897 s
->vmstate
->name
= s
->nic
->nc
.model
;
1898 vmstate_register(-1, s
->vmstate
, s
);
1903 static E100PCIDeviceInfo e100_devices
[] = {
1905 .pci
.qdev
.name
= "i82550",
1906 .pci
.qdev
.desc
= "Intel i82550 Ethernet",
1908 /* TODO: check device id. */
1909 .device_id
= PCI_DEVICE_ID_INTEL_82551IT
,
1910 /* Revision ID: 0x0c, 0x0d, 0x0e. */
1912 /* TODO: check size of statistical counters. */
1914 /* TODO: check extended tcb support. */
1915 .has_extended_tcb_support
= true,
1916 .power_management
= true,
1918 .pci
.qdev
.name
= "i82551",
1919 .pci
.qdev
.desc
= "Intel i82551 Ethernet",
1921 .device_id
= PCI_DEVICE_ID_INTEL_82551IT
,
1922 /* Revision ID: 0x0f, 0x10. */
1924 /* TODO: check size of statistical counters. */
1926 .has_extended_tcb_support
= true,
1927 .power_management
= true,
1929 .pci
.qdev
.name
= "i82557a",
1930 .pci
.qdev
.desc
= "Intel i82557A Ethernet",
1932 .device_id
= PCI_DEVICE_ID_INTEL_82557
,
1934 .power_management
= false,
1936 .pci
.qdev
.name
= "i82557b",
1937 .pci
.qdev
.desc
= "Intel i82557B Ethernet",
1939 .device_id
= PCI_DEVICE_ID_INTEL_82557
,
1941 .power_management
= false,
1943 .pci
.qdev
.name
= "i82557c",
1944 .pci
.qdev
.desc
= "Intel i82557C Ethernet",
1946 .device_id
= PCI_DEVICE_ID_INTEL_82557
,
1948 .power_management
= false,
1950 .pci
.qdev
.name
= "i82558a",
1951 .pci
.qdev
.desc
= "Intel i82558A Ethernet",
1953 .device_id
= PCI_DEVICE_ID_INTEL_82557
,
1956 .has_extended_tcb_support
= true,
1957 .power_management
= true,
1959 .pci
.qdev
.name
= "i82558b",
1960 .pci
.qdev
.desc
= "Intel i82558B Ethernet",
1962 .device_id
= PCI_DEVICE_ID_INTEL_82557
,
1965 .has_extended_tcb_support
= true,
1966 .power_management
= true,
1968 .pci
.qdev
.name
= "i82559a",
1969 .pci
.qdev
.desc
= "Intel i82559A Ethernet",
1971 .device_id
= PCI_DEVICE_ID_INTEL_82557
,
1974 .has_extended_tcb_support
= true,
1975 .power_management
= true,
1977 .pci
.qdev
.name
= "i82559b",
1978 .pci
.qdev
.desc
= "Intel i82559B Ethernet",
1980 .device_id
= PCI_DEVICE_ID_INTEL_82557
,
1983 .has_extended_tcb_support
= true,
1984 .power_management
= true,
1986 .pci
.qdev
.name
= "i82559c",
1987 .pci
.qdev
.desc
= "Intel i82559C Ethernet",
1989 .device_id
= PCI_DEVICE_ID_INTEL_82557
,
1993 /* TODO: Windows wants revision id 0x0c. */
1996 .has_extended_tcb_support
= true,
1997 .power_management
= true,
1999 .pci
.qdev
.name
= "i82559er",
2000 .pci
.qdev
.desc
= "Intel i82559ER Ethernet",
2002 .device_id
= PCI_DEVICE_ID_INTEL_82551IT
,
2005 .has_extended_tcb_support
= true,
2006 .power_management
= true,
2008 .pci
.qdev
.name
= "i82562",
2009 .pci
.qdev
.desc
= "Intel i82562 Ethernet",
2011 /* TODO: check device id. */
2012 .device_id
= PCI_DEVICE_ID_INTEL_82551IT
,
2013 /* TODO: wrong revision id. */
2016 .has_extended_tcb_support
= true,
2017 .power_management
= true,
2019 /* Toshiba Tecra 8200. */
2020 .pci
.qdev
.name
= "i82801",
2021 .pci
.qdev
.desc
= "Intel i82801 Ethernet",
2023 .device_id
= 0x2449,
2026 .has_extended_tcb_support
= true,
2027 .power_management
= true,
2031 static Property e100_properties
[] = {
2032 DEFINE_NIC_PROPERTIES(EEPRO100State
, conf
),
2033 DEFINE_PROP_END_OF_LIST(),
2036 static void eepro100_register_devices(void)
2039 for (i
= 0; i
< ARRAY_SIZE(e100_devices
); i
++) {
2040 PCIDeviceInfo
*pci_dev
= &e100_devices
[i
].pci
;
2041 switch (e100_devices
[i
].device_id
) {
2042 case PCI_DEVICE_ID_INTEL_82551IT
:
2043 pci_dev
->romfile
= "gpxe-eepro100-80861209.rom";
2045 case PCI_DEVICE_ID_INTEL_82557
:
2046 pci_dev
->romfile
= "gpxe-eepro100-80861229.rom";
2049 pci_dev
->romfile
= "gpxe-eepro100-80862449.rom";
2052 pci_dev
->init
= e100_nic_init
;
2053 pci_dev
->exit
= pci_nic_uninit
;
2054 pci_dev
->qdev
.props
= e100_properties
;
2055 pci_dev
->qdev
.size
= sizeof(EEPRO100State
);
2056 pci_qdev_register(pci_dev
);
2060 device_init(eepro100_register_devices
)