?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
monitor/qmp: Update comment for commit 4eaca8de268
[qemu/armbru.git] / hw / net / e1000.c
blob8ae4e08f1e90c89cc77cf168772686e3524ae9ea
1 /*
2 * QEMU e1000 emulation
3 *
4 * Software developer's manual:
5 * http://download.intel.com/design/network/manuals/8254x_GBe_SDM.pdf
6 *
7 * Nir Peleg, Tutis Systems Ltd. for Qumranet Inc.
8 * Copyright (c) 2008 Qumranet
9 * Based on work done by:
10 * Copyright (c) 2007 Dan Aloni
11 * Copyright (c) 2004 Antony T Curtis
12 *
13 * This library is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2 of the License, or (at your option) any later version.
17 *
18 * This library is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * Lesser General Public License for more details.
22 *
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
25 */
26
27
28 #include "qemu/osdep.h"
29 #include "hw/pci/pci.h"
30 #include "hw/qdev-properties.h"
31 #include "migration/vmstate.h"
32 #include "net/net.h"
33 #include "net/checksum.h"
34 #include "sysemu/sysemu.h"
35 #include "sysemu/dma.h"
36 #include "qemu/iov.h"
37 #include "qemu/module.h"
38 #include "qemu/range.h"
39
40 #include "e1000x_common.h"
41 #include "trace.h"
42
43 static const uint8_t bcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
44
45 /* #define E1000_DEBUG */
46
47 #ifdef E1000_DEBUG
48 enum {
49 DEBUG_GENERAL, DEBUG_IO, DEBUG_MMIO, DEBUG_INTERRUPT,
50 DEBUG_RX, DEBUG_TX, DEBUG_MDIC, DEBUG_EEPROM,
51 DEBUG_UNKNOWN, DEBUG_TXSUM, DEBUG_TXERR, DEBUG_RXERR,
52 DEBUG_RXFILTER, DEBUG_PHY, DEBUG_NOTYET,
53 };
54 #define DBGBIT(x) (1<<DEBUG_##x)
55 static int debugflags = DBGBIT(TXERR) | DBGBIT(GENERAL);
56
57 #define DBGOUT(what, fmt, ...) do { \
58 if (debugflags & DBGBIT(what)) \
59 fprintf(stderr, "e1000: " fmt, ## __VA_ARGS__); \
60 } while (0)
61 #else
62 #define DBGOUT(what, fmt, ...) do {} while (0)
63 #endif
64
65 #define IOPORT_SIZE 0x40
66 #define PNPMMIO_SIZE 0x20000
67 #define MIN_BUF_SIZE 60 /* Min. octets in an ethernet frame sans FCS */
68
69 #define MAXIMUM_ETHERNET_HDR_LEN (14+4)
70
71 /*
72 * HW models:
73 * E1000_DEV_ID_82540EM works with Windows, Linux, and OS X <= 10.8
74 * E1000_DEV_ID_82544GC_COPPER appears to work; not well tested
75 * E1000_DEV_ID_82545EM_COPPER works with Linux and OS X >= 10.6
76 * Others never tested
77 */
78
79 typedef struct E1000State_st {
80 /*< private >*/
81 PCIDevice parent_obj;
82 /*< public >*/
83
84 NICState *nic;
85 NICConf conf;
86 MemoryRegion mmio;
87 MemoryRegion io;
88
89 uint32_t mac_reg[0x8000];
90 uint16_t phy_reg[0x20];
91 uint16_t eeprom_data[64];
92
93 uint32_t rxbuf_size;
94 uint32_t rxbuf_min_shift;
95 struct e1000_tx {
96 unsigned char header[256];
97 unsigned char vlan_header[4];
98 /* Fields vlan and data must not be reordered or separated. */
99 unsigned char vlan[4];
100 unsigned char data[0x10000];
101 uint16_t size;
102 unsigned char vlan_needed;
103 unsigned char sum_needed;
104 bool cptse;
105 e1000x_txd_props props;
106 e1000x_txd_props tso_props;
107 uint16_t tso_frames;
108 } tx;
109
110 struct {
111 uint32_t val_in; /* shifted in from guest driver */
112 uint16_t bitnum_in;
113 uint16_t bitnum_out;
114 uint16_t reading;
115 uint32_t old_eecd;
116 } eecd_state;
117
118 QEMUTimer *autoneg_timer;
119
120 QEMUTimer *mit_timer; /* Mitigation timer. */
121 bool mit_timer_on; /* Mitigation timer is running. */
122 bool mit_irq_level; /* Tracks interrupt pin level. */
123 uint32_t mit_ide; /* Tracks E1000_TXD_CMD_IDE bit. */
124
125 QEMUTimer *flush_queue_timer;
126
127 /* Compatibility flags for migration to/from qemu 1.3.0 and older */
128 #define E1000_FLAG_AUTONEG_BIT 0
129 #define E1000_FLAG_MIT_BIT 1
130 #define E1000_FLAG_MAC_BIT 2
131 #define E1000_FLAG_TSO_BIT 3
132 #define E1000_FLAG_AUTONEG (1 << E1000_FLAG_AUTONEG_BIT)
133 #define E1000_FLAG_MIT (1 << E1000_FLAG_MIT_BIT)
134 #define E1000_FLAG_MAC (1 << E1000_FLAG_MAC_BIT)
135 #define E1000_FLAG_TSO (1 << E1000_FLAG_TSO_BIT)
136 uint32_t compat_flags;
137 bool received_tx_tso;
138 bool use_tso_for_migration;
139 e1000x_txd_props mig_props;
140 } E1000State;
141
142 #define chkflag(x) (s->compat_flags & E1000_FLAG_##x)
143
144 typedef struct E1000BaseClass {
145 PCIDeviceClass parent_class;
146 uint16_t phy_id2;
147 } E1000BaseClass;
148
149 #define TYPE_E1000_BASE "e1000-base"
150
151 #define E1000(obj) \
152 OBJECT_CHECK(E1000State, (obj), TYPE_E1000_BASE)
153
154 #define E1000_DEVICE_CLASS(klass) \
155 OBJECT_CLASS_CHECK(E1000BaseClass, (klass), TYPE_E1000_BASE)
156 #define E1000_DEVICE_GET_CLASS(obj) \
157 OBJECT_GET_CLASS(E1000BaseClass, (obj), TYPE_E1000_BASE)
158
159 static void
160 e1000_link_up(E1000State *s)
161 {
162 e1000x_update_regs_on_link_up(s->mac_reg, s->phy_reg);
163
164 /* E1000_STATUS_LU is tested by e1000_can_receive() */
165 qemu_flush_queued_packets(qemu_get_queue(s->nic));
166 }
167
168 static void
169 e1000_autoneg_done(E1000State *s)
170 {
171 e1000x_update_regs_on_autoneg_done(s->mac_reg, s->phy_reg);
172
173 /* E1000_STATUS_LU is tested by e1000_can_receive() */
174 qemu_flush_queued_packets(qemu_get_queue(s->nic));
175 }
176
177 static bool
178 have_autoneg(E1000State *s)
179 {
180 return chkflag(AUTONEG) && (s->phy_reg[PHY_CTRL] & MII_CR_AUTO_NEG_EN);
181 }
182
183 static void
184 set_phy_ctrl(E1000State *s, int index, uint16_t val)
185 {
186 /* bits 0-5 reserved; MII_CR_[RESTART_AUTO_NEG,RESET] are self clearing */
187 s->phy_reg[PHY_CTRL] = val & ~(0x3f |
188 MII_CR_RESET |
189 MII_CR_RESTART_AUTO_NEG);
190
191 /*
192 * QEMU 1.3 does not support link auto-negotiation emulation, so if we
193 * migrate during auto negotiation, after migration the link will be
194 * down.
195 */
196 if (have_autoneg(s) && (val & MII_CR_RESTART_AUTO_NEG)) {
197 e1000x_restart_autoneg(s->mac_reg, s->phy_reg, s->autoneg_timer);
198 }
199 }
200
201 static void (*phyreg_writeops[])(E1000State *, int, uint16_t) = {
202 [PHY_CTRL] = set_phy_ctrl,
203 };
204
205 enum { NPHYWRITEOPS = ARRAY_SIZE(phyreg_writeops) };
206
207 enum { PHY_R = 1, PHY_W = 2, PHY_RW = PHY_R | PHY_W };
208 static const char phy_regcap[0x20] = {
209 [PHY_STATUS] = PHY_R, [M88E1000_EXT_PHY_SPEC_CTRL] = PHY_RW,
210 [PHY_ID1] = PHY_R, [M88E1000_PHY_SPEC_CTRL] = PHY_RW,
211 [PHY_CTRL] = PHY_RW, [PHY_1000T_CTRL] = PHY_RW,
212 [PHY_LP_ABILITY] = PHY_R, [PHY_1000T_STATUS] = PHY_R,
213 [PHY_AUTONEG_ADV] = PHY_RW, [M88E1000_RX_ERR_CNTR] = PHY_R,
214 [PHY_ID2] = PHY_R, [M88E1000_PHY_SPEC_STATUS] = PHY_R,
215 [PHY_AUTONEG_EXP] = PHY_R,
216 };
217
218 /* PHY_ID2 documented in 8254x_GBe_SDM.pdf, pp. 250 */
219 static const uint16_t phy_reg_init[] = {
220 [PHY_CTRL] = MII_CR_SPEED_SELECT_MSB |
221 MII_CR_FULL_DUPLEX |
222 MII_CR_AUTO_NEG_EN,
223
224 [PHY_STATUS] = MII_SR_EXTENDED_CAPS |
225 MII_SR_LINK_STATUS | /* link initially up */
226 MII_SR_AUTONEG_CAPS |
227 /* MII_SR_AUTONEG_COMPLETE: initially NOT completed */
228 MII_SR_PREAMBLE_SUPPRESS |
229 MII_SR_EXTENDED_STATUS |
230 MII_SR_10T_HD_CAPS |
231 MII_SR_10T_FD_CAPS |
232 MII_SR_100X_HD_CAPS |
233 MII_SR_100X_FD_CAPS,
234
235 [PHY_ID1] = 0x141,
236 /* [PHY_ID2] configured per DevId, from e1000_reset() */
237 [PHY_AUTONEG_ADV] = 0xde1,
238 [PHY_LP_ABILITY] = 0x1e0,
239 [PHY_1000T_CTRL] = 0x0e00,
240 [PHY_1000T_STATUS] = 0x3c00,
241 [M88E1000_PHY_SPEC_CTRL] = 0x360,
242 [M88E1000_PHY_SPEC_STATUS] = 0xac00,
243 [M88E1000_EXT_PHY_SPEC_CTRL] = 0x0d60,
244 };
245
246 static const uint32_t mac_reg_init[] = {
247 [PBA] = 0x00100030,
248 [LEDCTL] = 0x602,
249 [CTRL] = E1000_CTRL_SWDPIN2 | E1000_CTRL_SWDPIN0 |
250 E1000_CTRL_SPD_1000 | E1000_CTRL_SLU,
251 [STATUS] = 0x80000000 | E1000_STATUS_GIO_MASTER_ENABLE |
252 E1000_STATUS_ASDV | E1000_STATUS_MTXCKOK |
253 E1000_STATUS_SPEED_1000 | E1000_STATUS_FD |
254 E1000_STATUS_LU,
255 [MANC] = E1000_MANC_EN_MNG2HOST | E1000_MANC_RCV_TCO_EN |
256 E1000_MANC_ARP_EN | E1000_MANC_0298_EN |
257 E1000_MANC_RMCP_EN,
258 };
259
260 /* Helper function, *curr == 0 means the value is not set */
261 static inline void
262 mit_update_delay(uint32_t *curr, uint32_t value)
263 {
264 if (value && (*curr == 0 || value < *curr)) {
265 *curr = value;
266 }
267 }
268
269 static void
270 set_interrupt_cause(E1000State *s, int index, uint32_t val)
271 {
272 PCIDevice *d = PCI_DEVICE(s);
273 uint32_t pending_ints;
274 uint32_t mit_delay;
275
276 s->mac_reg[ICR] = val;
277
278 /*
279 * Make sure ICR and ICS registers have the same value.
280 * The spec says that the ICS register is write-only. However in practice,
281 * on real hardware ICS is readable, and for reads it has the same value as
282 * ICR (except that ICS does not have the clear on read behaviour of ICR).
283 *
284 * The VxWorks PRO/1000 driver uses this behaviour.
285 */
286 s->mac_reg[ICS] = val;
287
288 pending_ints = (s->mac_reg[IMS] & s->mac_reg[ICR]);
289 if (!s->mit_irq_level && pending_ints) {
290 /*
291 * Here we detect a potential raising edge. We postpone raising the
292 * interrupt line if we are inside the mitigation delay window
293 * (s->mit_timer_on == 1).
294 * We provide a partial implementation of interrupt mitigation,
295 * emulating only RADV, TADV and ITR (lower 16 bits, 1024ns units for
296 * RADV and TADV, 256ns units for ITR). RDTR is only used to enable
297 * RADV; relative timers based on TIDV and RDTR are not implemented.
298 */
299 if (s->mit_timer_on) {
300 return;
301 }
302 if (chkflag(MIT)) {
303 /* Compute the next mitigation delay according to pending
304 * interrupts and the current values of RADV (provided
305 * RDTR!=0), TADV and ITR.
306 * Then rearm the timer.
307 */
308 mit_delay = 0;
309 if (s->mit_ide &&
310 (pending_ints & (E1000_ICR_TXQE | E1000_ICR_TXDW))) {
311 mit_update_delay(&mit_delay, s->mac_reg[TADV] * 4);
312 }
313 if (s->mac_reg[RDTR] && (pending_ints & E1000_ICS_RXT0)) {
314 mit_update_delay(&mit_delay, s->mac_reg[RADV] * 4);
315 }
316 mit_update_delay(&mit_delay, s->mac_reg[ITR]);
317
318 /*
319 * According to e1000 SPEC, the Ethernet controller guarantees
320 * a maximum observable interrupt rate of 7813 interrupts/sec.
321 * Thus if mit_delay < 500 then the delay should be set to the
322 * minimum delay possible which is 500.
323 */
324 mit_delay = (mit_delay < 500) ? 500 : mit_delay;
325
326 s->mit_timer_on = 1;
327 timer_mod(s->mit_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
328 mit_delay * 256);
329 s->mit_ide = 0;
330 }
331 }
332
333 s->mit_irq_level = (pending_ints != 0);
334 pci_set_irq(d, s->mit_irq_level);
335 }
336
337 static void
338 e1000_mit_timer(void *opaque)
339 {
340 E1000State *s = opaque;
341
342 s->mit_timer_on = 0;
343 /* Call set_interrupt_cause to update the irq level (if necessary). */
344 set_interrupt_cause(s, 0, s->mac_reg[ICR]);
345 }
346
347 static void
348 set_ics(E1000State *s, int index, uint32_t val)
349 {
350 DBGOUT(INTERRUPT, "set_ics %x, ICR %x, IMR %x\n", val, s->mac_reg[ICR],
351 s->mac_reg[IMS]);
352 set_interrupt_cause(s, 0, val | s->mac_reg[ICR]);
353 }
354
355 static void
356 e1000_autoneg_timer(void *opaque)
357 {
358 E1000State *s = opaque;
359 if (!qemu_get_queue(s->nic)->link_down) {
360 e1000_autoneg_done(s);
361 set_ics(s, 0, E1000_ICS_LSC); /* signal link status change to guest */
362 }
363 }
364
365 static void e1000_reset(void *opaque)
366 {
367 E1000State *d = opaque;
368 E1000BaseClass *edc = E1000_DEVICE_GET_CLASS(d);
369 uint8_t *macaddr = d->conf.macaddr.a;
370
371 timer_del(d->autoneg_timer);
372 timer_del(d->mit_timer);
373 timer_del(d->flush_queue_timer);
374 d->mit_timer_on = 0;
375 d->mit_irq_level = 0;
376 d->mit_ide = 0;
377 memset(d->phy_reg, 0, sizeof d->phy_reg);
378 memmove(d->phy_reg, phy_reg_init, sizeof phy_reg_init);
379 d->phy_reg[PHY_ID2] = edc->phy_id2;
380 memset(d->mac_reg, 0, sizeof d->mac_reg);
381 memmove(d->mac_reg, mac_reg_init, sizeof mac_reg_init);
382 d->rxbuf_min_shift = 1;
383 memset(&d->tx, 0, sizeof d->tx);
384
385 if (qemu_get_queue(d->nic)->link_down) {
386 e1000x_update_regs_on_link_down(d->mac_reg, d->phy_reg);
387 }
388
389 e1000x_reset_mac_addr(d->nic, d->mac_reg, macaddr);
390 }
391
392 static void
393 set_ctrl(E1000State *s, int index, uint32_t val)
394 {
395 /* RST is self clearing */
396 s->mac_reg[CTRL] = val & ~E1000_CTRL_RST;
397 }
398
399 static void
400 e1000_flush_queue_timer(void *opaque)
401 {
402 E1000State *s = opaque;
403
404 qemu_flush_queued_packets(qemu_get_queue(s->nic));
405 }
406
407 static void
408 set_rx_control(E1000State *s, int index, uint32_t val)
409 {
410 s->mac_reg[RCTL] = val;
411 s->rxbuf_size = e1000x_rxbufsize(val);
412 s->rxbuf_min_shift = ((val / E1000_RCTL_RDMTS_QUAT) & 3) + 1;
413 DBGOUT(RX, "RCTL: %d, mac_reg[RCTL] = 0x%x\n", s->mac_reg[RDT],
414 s->mac_reg[RCTL]);
415 timer_mod(s->flush_queue_timer,
416 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 1000);
417 }
418
419 static void
420 set_mdic(E1000State *s, int index, uint32_t val)
421 {
422 uint32_t data = val & E1000_MDIC_DATA_MASK;
423 uint32_t addr = ((val & E1000_MDIC_REG_MASK) >> E1000_MDIC_REG_SHIFT);
424
425 if ((val & E1000_MDIC_PHY_MASK) >> E1000_MDIC_PHY_SHIFT != 1) // phy #
426 val = s->mac_reg[MDIC] | E1000_MDIC_ERROR;
427 else if (val & E1000_MDIC_OP_READ) {
428 DBGOUT(MDIC, "MDIC read reg 0x%x\n", addr);
429 if (!(phy_regcap[addr] & PHY_R)) {
430 DBGOUT(MDIC, "MDIC read reg %x unhandled\n", addr);
431 val |= E1000_MDIC_ERROR;
432 } else
433 val = (val ^ data) | s->phy_reg[addr];
434 } else if (val & E1000_MDIC_OP_WRITE) {
435 DBGOUT(MDIC, "MDIC write reg 0x%x, value 0x%x\n", addr, data);
436 if (!(phy_regcap[addr] & PHY_W)) {
437 DBGOUT(MDIC, "MDIC write reg %x unhandled\n", addr);
438 val |= E1000_MDIC_ERROR;
439 } else {
440 if (addr < NPHYWRITEOPS && phyreg_writeops[addr]) {
441 phyreg_writeops[addr](s, index, data);
442 } else {
443 s->phy_reg[addr] = data;
444 }
445 }
446 }
447 s->mac_reg[MDIC] = val | E1000_MDIC_READY;
448
449 if (val & E1000_MDIC_INT_EN) {
450 set_ics(s, 0, E1000_ICR_MDAC);
451 }
452 }
453
454 static uint32_t
455 get_eecd(E1000State *s, int index)
456 {
457 uint32_t ret = E1000_EECD_PRES|E1000_EECD_GNT | s->eecd_state.old_eecd;
458
459 DBGOUT(EEPROM, "reading eeprom bit %d (reading %d)\n",
460 s->eecd_state.bitnum_out, s->eecd_state.reading);
461 if (!s->eecd_state.reading ||
462 ((s->eeprom_data[(s->eecd_state.bitnum_out >> 4) & 0x3f] >>
463 ((s->eecd_state.bitnum_out & 0xf) ^ 0xf))) & 1)
464 ret |= E1000_EECD_DO;
465 return ret;
466 }
467
468 static void
469 set_eecd(E1000State *s, int index, uint32_t val)
470 {
471 uint32_t oldval = s->eecd_state.old_eecd;
472
473 s->eecd_state.old_eecd = val & (E1000_EECD_SK | E1000_EECD_CS |
474 E1000_EECD_DI|E1000_EECD_FWE_MASK|E1000_EECD_REQ);
475 if (!(E1000_EECD_CS & val)) { /* CS inactive; nothing to do */
476 return;
477 }
478 if (E1000_EECD_CS & (val ^ oldval)) { /* CS rise edge; reset state */
479 s->eecd_state.val_in = 0;
480 s->eecd_state.bitnum_in = 0;
481 s->eecd_state.bitnum_out = 0;
482 s->eecd_state.reading = 0;
483 }
484 if (!(E1000_EECD_SK & (val ^ oldval))) { /* no clock edge */
485 return;
486 }
487 if (!(E1000_EECD_SK & val)) { /* falling edge */
488 s->eecd_state.bitnum_out++;
489 return;
490 }
491 s->eecd_state.val_in <<= 1;
492 if (val & E1000_EECD_DI)
493 s->eecd_state.val_in |= 1;
494 if (++s->eecd_state.bitnum_in == 9 && !s->eecd_state.reading) {
495 s->eecd_state.bitnum_out = ((s->eecd_state.val_in & 0x3f)<<4)-1;
496 s->eecd_state.reading = (((s->eecd_state.val_in >> 6) & 7) ==
497 EEPROM_READ_OPCODE_MICROWIRE);
498 }
499 DBGOUT(EEPROM, "eeprom bitnum in %d out %d, reading %d\n",
500 s->eecd_state.bitnum_in, s->eecd_state.bitnum_out,
501 s->eecd_state.reading);
502 }
503
504 static uint32_t
505 flash_eerd_read(E1000State *s, int x)
506 {
507 unsigned int index, r = s->mac_reg[EERD] & ~E1000_EEPROM_RW_REG_START;
508
509 if ((s->mac_reg[EERD] & E1000_EEPROM_RW_REG_START) == 0)
510 return (s->mac_reg[EERD]);
511
512 if ((index = r >> E1000_EEPROM_RW_ADDR_SHIFT) > EEPROM_CHECKSUM_REG)
513 return (E1000_EEPROM_RW_REG_DONE | r);
514
515 return ((s->eeprom_data[index] << E1000_EEPROM_RW_REG_DATA) |
516 E1000_EEPROM_RW_REG_DONE | r);
517 }
518
519 static void
520 putsum(uint8_t *data, uint32_t n, uint32_t sloc, uint32_t css, uint32_t cse)
521 {
522 uint32_t sum;
523
524 if (cse && cse < n)
525 n = cse + 1;
526 if (sloc < n-1) {
527 sum = net_checksum_add(n-css, data+css);
528 stw_be_p(data + sloc, net_checksum_finish_nozero(sum));
529 }
530 }
531
532 static inline void
533 inc_tx_bcast_or_mcast_count(E1000State *s, const unsigned char *arr)
534 {
535 if (!memcmp(arr, bcast, sizeof bcast)) {
536 e1000x_inc_reg_if_not_full(s->mac_reg, BPTC);
537 } else if (arr[0] & 1) {
538 e1000x_inc_reg_if_not_full(s->mac_reg, MPTC);
539 }
540 }
541
542 static void
543 e1000_send_packet(E1000State *s, const uint8_t *buf, int size)
544 {
545 static const int PTCregs[6] = { PTC64, PTC127, PTC255, PTC511,
546 PTC1023, PTC1522 };
547
548 NetClientState *nc = qemu_get_queue(s->nic);
549 if (s->phy_reg[PHY_CTRL] & MII_CR_LOOPBACK) {
550 nc->info->receive(nc, buf, size);
551 } else {
552 qemu_send_packet(nc, buf, size);
553 }
554 inc_tx_bcast_or_mcast_count(s, buf);
555 e1000x_increase_size_stats(s->mac_reg, PTCregs, size);
556 }
557
558 static void
559 xmit_seg(E1000State *s)
560 {
561 uint16_t len;
562 unsigned int frames = s->tx.tso_frames, css, sofar;
563 struct e1000_tx *tp = &s->tx;
564 struct e1000x_txd_props *props = tp->cptse ? &tp->tso_props : &tp->props;
565
566 if (tp->cptse) {
567 css = props->ipcss;
568 DBGOUT(TXSUM, "frames %d size %d ipcss %d\n",
569 frames, tp->size, css);
570 if (props->ip) { /* IPv4 */
571 stw_be_p(tp->data+css+2, tp->size - css);
572 stw_be_p(tp->data+css+4,
573 lduw_be_p(tp->data + css + 4) + frames);
574 } else { /* IPv6 */
575 stw_be_p(tp->data+css+4, tp->size - css);
576 }
577 css = props->tucss;
578 len = tp->size - css;
579 DBGOUT(TXSUM, "tcp %d tucss %d len %d\n", props->tcp, css, len);
580 if (props->tcp) {
581 sofar = frames * props->mss;
582 stl_be_p(tp->data+css+4, ldl_be_p(tp->data+css+4)+sofar); /* seq */
583 if (props->paylen - sofar > props->mss) {
584 tp->data[css + 13] &= ~9; /* PSH, FIN */
585 } else if (frames) {
586 e1000x_inc_reg_if_not_full(s->mac_reg, TSCTC);
587 }
588 } else { /* UDP */
589 stw_be_p(tp->data+css+4, len);
590 }
591 if (tp->sum_needed & E1000_TXD_POPTS_TXSM) {
592 unsigned int phsum;
593 // add pseudo-header length before checksum calculation
594 void *sp = tp->data + props->tucso;
595
596 phsum = lduw_be_p(sp) + len;
597 phsum = (phsum >> 16) + (phsum & 0xffff);
598 stw_be_p(sp, phsum);
599 }
600 tp->tso_frames++;
601 }
602
603 if (tp->sum_needed & E1000_TXD_POPTS_TXSM) {
604 putsum(tp->data, tp->size, props->tucso, props->tucss, props->tucse);
605 }
606 if (tp->sum_needed & E1000_TXD_POPTS_IXSM) {
607 putsum(tp->data, tp->size, props->ipcso, props->ipcss, props->ipcse);
608 }
609 if (tp->vlan_needed) {
610 memmove(tp->vlan, tp->data, 4);
611 memmove(tp->data, tp->data + 4, 8);
612 memcpy(tp->data + 8, tp->vlan_header, 4);
613 e1000_send_packet(s, tp->vlan, tp->size + 4);
614 } else {
615 e1000_send_packet(s, tp->data, tp->size);
616 }
617
618 e1000x_inc_reg_if_not_full(s->mac_reg, TPT);
619 e1000x_grow_8reg_if_not_full(s->mac_reg, TOTL, s->tx.size);
620 s->mac_reg[GPTC] = s->mac_reg[TPT];
621 s->mac_reg[GOTCL] = s->mac_reg[TOTL];
622 s->mac_reg[GOTCH] = s->mac_reg[TOTH];
623 }
624
625 static void
626 process_tx_desc(E1000State *s, struct e1000_tx_desc *dp)
627 {
628 PCIDevice *d = PCI_DEVICE(s);
629 uint32_t txd_lower = le32_to_cpu(dp->lower.data);
630 uint32_t dtype = txd_lower & (E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D);
631 unsigned int split_size = txd_lower & 0xffff, bytes, sz;
632 unsigned int msh = 0xfffff;
633 uint64_t addr;
634 struct e1000_context_desc *xp = (struct e1000_context_desc *)dp;
635 struct e1000_tx *tp = &s->tx;
636
637 s->mit_ide |= (txd_lower & E1000_TXD_CMD_IDE);
638 if (dtype == E1000_TXD_CMD_DEXT) { /* context descriptor */
639 if (le32_to_cpu(xp->cmd_and_length) & E1000_TXD_CMD_TSE) {
640 e1000x_read_tx_ctx_descr(xp, &tp->tso_props);
641 s->use_tso_for_migration = 1;
642 tp->tso_frames = 0;
643 } else {
644 e1000x_read_tx_ctx_descr(xp, &tp->props);
645 s->use_tso_for_migration = 0;
646 }
647 return;
648 } else if (dtype == (E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D)) {
649 // data descriptor
650 if (tp->size == 0) {
651 tp->sum_needed = le32_to_cpu(dp->upper.data) >> 8;
652 }
653 tp->cptse = (txd_lower & E1000_TXD_CMD_TSE) ? 1 : 0;
654 } else {
655 // legacy descriptor
656 tp->cptse = 0;
657 }
658
659 if (e1000x_vlan_enabled(s->mac_reg) &&
660 e1000x_is_vlan_txd(txd_lower) &&
661 (tp->cptse || txd_lower & E1000_TXD_CMD_EOP)) {
662 tp->vlan_needed = 1;
663 stw_be_p(tp->vlan_header,
664 le16_to_cpu(s->mac_reg[VET]));
665 stw_be_p(tp->vlan_header + 2,
666 le16_to_cpu(dp->upper.fields.special));
667 }
668
669 addr = le64_to_cpu(dp->buffer_addr);
670 if (tp->cptse) {
671 msh = tp->tso_props.hdr_len + tp->tso_props.mss;
672 do {
673 bytes = split_size;
674 if (tp->size + bytes > msh)
675 bytes = msh - tp->size;
676
677 bytes = MIN(sizeof(tp->data) - tp->size, bytes);
678 pci_dma_read(d, addr, tp->data + tp->size, bytes);
679 sz = tp->size + bytes;
680 if (sz >= tp->tso_props.hdr_len
681 && tp->size < tp->tso_props.hdr_len) {
682 memmove(tp->header, tp->data, tp->tso_props.hdr_len);
683 }
684 tp->size = sz;
685 addr += bytes;
686 if (sz == msh) {
687 xmit_seg(s);
688 memmove(tp->data, tp->header, tp->tso_props.hdr_len);
689 tp->size = tp->tso_props.hdr_len;
690 }
691 split_size -= bytes;
692 } while (bytes && split_size);
693 } else {
694 split_size = MIN(sizeof(tp->data) - tp->size, split_size);
695 pci_dma_read(d, addr, tp->data + tp->size, split_size);
696 tp->size += split_size;
697 }
698
699 if (!(txd_lower & E1000_TXD_CMD_EOP))
700 return;
701 if (!(tp->cptse && tp->size < tp->tso_props.hdr_len)) {
702 xmit_seg(s);
703 }
704 tp->tso_frames = 0;
705 tp->sum_needed = 0;
706 tp->vlan_needed = 0;
707 tp->size = 0;
708 tp->cptse = 0;
709 }
710
711 static uint32_t
712 txdesc_writeback(E1000State *s, dma_addr_t base, struct e1000_tx_desc *dp)
713 {
714 PCIDevice *d = PCI_DEVICE(s);
715 uint32_t txd_upper, txd_lower = le32_to_cpu(dp->lower.data);
716
717 if (!(txd_lower & (E1000_TXD_CMD_RS|E1000_TXD_CMD_RPS)))
718 return 0;
719 txd_upper = (le32_to_cpu(dp->upper.data) | E1000_TXD_STAT_DD) &
720 ~(E1000_TXD_STAT_EC | E1000_TXD_STAT_LC | E1000_TXD_STAT_TU);
721 dp->upper.data = cpu_to_le32(txd_upper);
722 pci_dma_write(d, base + ((char *)&dp->upper - (char *)dp),
723 &dp->upper, sizeof(dp->upper));
724 return E1000_ICR_TXDW;
725 }
726
727 static uint64_t tx_desc_base(E1000State *s)
728 {
729 uint64_t bah = s->mac_reg[TDBAH];
730 uint64_t bal = s->mac_reg[TDBAL] & ~0xf;
731
732 return (bah << 32) + bal;
733 }
734
735 static void
736 start_xmit(E1000State *s)
737 {
738 PCIDevice *d = PCI_DEVICE(s);
739 dma_addr_t base;
740 struct e1000_tx_desc desc;
741 uint32_t tdh_start = s->mac_reg[TDH], cause = E1000_ICS_TXQE;
742
743 if (!(s->mac_reg[TCTL] & E1000_TCTL_EN)) {
744 DBGOUT(TX, "tx disabled\n");
745 return;
746 }
747
748 while (s->mac_reg[TDH] != s->mac_reg[TDT]) {
749 base = tx_desc_base(s) +
750 sizeof(struct e1000_tx_desc) * s->mac_reg[TDH];
751 pci_dma_read(d, base, &desc, sizeof(desc));
752
753 DBGOUT(TX, "index %d: %p : %x %x\n", s->mac_reg[TDH],
754 (void *)(intptr_t)desc.buffer_addr, desc.lower.data,
755 desc.upper.data);
756
757 process_tx_desc(s, &desc);
758 cause |= txdesc_writeback(s, base, &desc);
759
760 if (++s->mac_reg[TDH] * sizeof(desc) >= s->mac_reg[TDLEN])
761 s->mac_reg[TDH] = 0;
762 /*
763 * the following could happen only if guest sw assigns
764 * bogus values to TDT/TDLEN.
765 * there's nothing too intelligent we could do about this.
766 */
767 if (s->mac_reg[TDH] == tdh_start ||
768 tdh_start >= s->mac_reg[TDLEN] / sizeof(desc)) {
769 DBGOUT(TXERR, "TDH wraparound @%x, TDT %x, TDLEN %x\n",
770 tdh_start, s->mac_reg[TDT], s->mac_reg[TDLEN]);
771 break;
772 }
773 }
774 set_ics(s, 0, cause);
775 }
776
777 static int
778 receive_filter(E1000State *s, const uint8_t *buf, int size)
779 {
780 uint32_t rctl = s->mac_reg[RCTL];
781 int isbcast = !memcmp(buf, bcast, sizeof bcast), ismcast = (buf[0] & 1);
782
783 if (e1000x_is_vlan_packet(buf, le16_to_cpu(s->mac_reg[VET])) &&
784 e1000x_vlan_rx_filter_enabled(s->mac_reg)) {
785 uint16_t vid = lduw_be_p(buf + 14);
786 uint32_t vfta = ldl_le_p((uint32_t*)(s->mac_reg + VFTA) +
787 ((vid >> 5) & 0x7f));
788 if ((vfta & (1 << (vid & 0x1f))) == 0)
789 return 0;
790 }
791
792 if (!isbcast && !ismcast && (rctl & E1000_RCTL_UPE)) { /* promiscuous ucast */
793 return 1;
794 }
795
796 if (ismcast && (rctl & E1000_RCTL_MPE)) { /* promiscuous mcast */
797 e1000x_inc_reg_if_not_full(s->mac_reg, MPRC);
798 return 1;
799 }
800
801 if (isbcast && (rctl & E1000_RCTL_BAM)) { /* broadcast enabled */
802 e1000x_inc_reg_if_not_full(s->mac_reg, BPRC);
803 return 1;
804 }
805
806 return e1000x_rx_group_filter(s->mac_reg, buf);
807 }
808
809 static void
810 e1000_set_link_status(NetClientState *nc)
811 {
812 E1000State *s = qemu_get_nic_opaque(nc);
813 uint32_t old_status = s->mac_reg[STATUS];
814
815 if (nc->link_down) {
816 e1000x_update_regs_on_link_down(s->mac_reg, s->phy_reg);
817 } else {
818 if (have_autoneg(s) &&
819 !(s->phy_reg[PHY_STATUS] & MII_SR_AUTONEG_COMPLETE)) {
820 e1000x_restart_autoneg(s->mac_reg, s->phy_reg, s->autoneg_timer);
821 } else {
822 e1000_link_up(s);
823 }
824 }
825
826 if (s->mac_reg[STATUS] != old_status)
827 set_ics(s, 0, E1000_ICR_LSC);
828 }
829
830 static bool e1000_has_rxbufs(E1000State *s, size_t total_size)
831 {
832 int bufs;
833 /* Fast-path short packets */
834 if (total_size <= s->rxbuf_size) {
835 return s->mac_reg[RDH] != s->mac_reg[RDT];
836 }
837 if (s->mac_reg[RDH] < s->mac_reg[RDT]) {
838 bufs = s->mac_reg[RDT] - s->mac_reg[RDH];
839 } else if (s->mac_reg[RDH] > s->mac_reg[RDT]) {
840 bufs = s->mac_reg[RDLEN] / sizeof(struct e1000_rx_desc) +
841 s->mac_reg[RDT] - s->mac_reg[RDH];
842 } else {
843 return false;
844 }
845 return total_size <= bufs * s->rxbuf_size;
846 }
847
848 static int
849 e1000_can_receive(NetClientState *nc)
850 {
851 E1000State *s = qemu_get_nic_opaque(nc);
852
853 return e1000x_rx_ready(&s->parent_obj, s->mac_reg) &&
854 e1000_has_rxbufs(s, 1) && !timer_pending(s->flush_queue_timer);
855 }
856
857 static uint64_t rx_desc_base(E1000State *s)
858 {
859 uint64_t bah = s->mac_reg[RDBAH];
860 uint64_t bal = s->mac_reg[RDBAL] & ~0xf;
861
862 return (bah << 32) + bal;
863 }
864
865 static void
866 e1000_receiver_overrun(E1000State *s, size_t size)
867 {
868 trace_e1000_receiver_overrun(size, s->mac_reg[RDH], s->mac_reg[RDT]);
869 e1000x_inc_reg_if_not_full(s->mac_reg, RNBC);
870 e1000x_inc_reg_if_not_full(s->mac_reg, MPC);
871 set_ics(s, 0, E1000_ICS_RXO);
872 }
873
874 static ssize_t
875 e1000_receive_iov(NetClientState *nc, const struct iovec *iov, int iovcnt)
876 {
877 E1000State *s = qemu_get_nic_opaque(nc);
878 PCIDevice *d = PCI_DEVICE(s);
879 struct e1000_rx_desc desc;
880 dma_addr_t base;
881 unsigned int n, rdt;
882 uint32_t rdh_start;
883 uint16_t vlan_special = 0;
884 uint8_t vlan_status = 0;
885 uint8_t min_buf[MIN_BUF_SIZE];
886 struct iovec min_iov;
887 uint8_t *filter_buf = iov->iov_base;
888 size_t size = iov_size(iov, iovcnt);
889 size_t iov_ofs = 0;
890 size_t desc_offset;
891 size_t desc_size;
892 size_t total_size;
893
894 if (!e1000x_hw_rx_enabled(s->mac_reg)) {
895 return -1;
896 }
897
898 if (timer_pending(s->flush_queue_timer)) {
899 return 0;
900 }
901
902 /* Pad to minimum Ethernet frame length */
903 if (size < sizeof(min_buf)) {
904 iov_to_buf(iov, iovcnt, 0, min_buf, size);
905 memset(&min_buf[size], 0, sizeof(min_buf) - size);
906 min_iov.iov_base = filter_buf = min_buf;
907 min_iov.iov_len = size = sizeof(min_buf);
908 iovcnt = 1;
909 iov = &min_iov;
910 } else if (iov->iov_len < MAXIMUM_ETHERNET_HDR_LEN) {
911 /* This is very unlikely, but may happen. */
912 iov_to_buf(iov, iovcnt, 0, min_buf, MAXIMUM_ETHERNET_HDR_LEN);
913 filter_buf = min_buf;
914 }
915
916 /* Discard oversized packets if !LPE and !SBP. */
917 if (e1000x_is_oversized(s->mac_reg, size)) {
918 return size;
919 }
920
921 if (!receive_filter(s, filter_buf, size)) {
922 return size;
923 }
924
925 if (e1000x_vlan_enabled(s->mac_reg) &&
926 e1000x_is_vlan_packet(filter_buf, le16_to_cpu(s->mac_reg[VET]))) {
927 vlan_special = cpu_to_le16(lduw_be_p(filter_buf + 14));
928 iov_ofs = 4;
929 if (filter_buf == iov->iov_base) {
930 memmove(filter_buf + 4, filter_buf, 12);
931 } else {
932 iov_from_buf(iov, iovcnt, 4, filter_buf, 12);
933 while (iov->iov_len <= iov_ofs) {
934 iov_ofs -= iov->iov_len;
935 iov++;
936 }
937 }
938 vlan_status = E1000_RXD_STAT_VP;
939 size -= 4;
940 }
941
942 rdh_start = s->mac_reg[RDH];
943 desc_offset = 0;
944 total_size = size + e1000x_fcs_len(s->mac_reg);
945 if (!e1000_has_rxbufs(s, total_size)) {
946 e1000_receiver_overrun(s, total_size);
947 return -1;
948 }
949 do {
950 desc_size = total_size - desc_offset;
951 if (desc_size > s->rxbuf_size) {
952 desc_size = s->rxbuf_size;
953 }
954 base = rx_desc_base(s) + sizeof(desc) * s->mac_reg[RDH];
955 pci_dma_read(d, base, &desc, sizeof(desc));
956 desc.special = vlan_special;
957 desc.status |= (vlan_status | E1000_RXD_STAT_DD);
958 if (desc.buffer_addr) {
959 if (desc_offset < size) {
960 size_t iov_copy;
961 hwaddr ba = le64_to_cpu(desc.buffer_addr);
962 size_t copy_size = size - desc_offset;
963 if (copy_size > s->rxbuf_size) {
964 copy_size = s->rxbuf_size;
965 }
966 do {
967 iov_copy = MIN(copy_size, iov->iov_len - iov_ofs);
968 pci_dma_write(d, ba, iov->iov_base + iov_ofs, iov_copy);
969 copy_size -= iov_copy;
970 ba += iov_copy;
971 iov_ofs += iov_copy;
972 if (iov_ofs == iov->iov_len) {
973 iov++;
974 iov_ofs = 0;
975 }
976 } while (copy_size);
977 }
978 desc_offset += desc_size;
979 desc.length = cpu_to_le16(desc_size);
980 if (desc_offset >= total_size) {
981 desc.status |= E1000_RXD_STAT_EOP | E1000_RXD_STAT_IXSM;
982 } else {
983 /* Guest zeroing out status is not a hardware requirement.
984 Clear EOP in case guest didn't do it. */
985 desc.status &= ~E1000_RXD_STAT_EOP;
986 }
987 } else { // as per intel docs; skip descriptors with null buf addr
988 DBGOUT(RX, "Null RX descriptor!!\n");
989 }
990 pci_dma_write(d, base, &desc, sizeof(desc));
991
992 if (++s->mac_reg[RDH] * sizeof(desc) >= s->mac_reg[RDLEN])
993 s->mac_reg[RDH] = 0;
994 /* see comment in start_xmit; same here */
995 if (s->mac_reg[RDH] == rdh_start ||
996 rdh_start >= s->mac_reg[RDLEN] / sizeof(desc)) {
997 DBGOUT(RXERR, "RDH wraparound @%x, RDT %x, RDLEN %x\n",
998 rdh_start, s->mac_reg[RDT], s->mac_reg[RDLEN]);
999 e1000_receiver_overrun(s, total_size);
1000 return -1;
1001 }
1002 } while (desc_offset < total_size);
1003
1004 e1000x_update_rx_total_stats(s->mac_reg, size, total_size);
1005
1006 n = E1000_ICS_RXT0;
1007 if ((rdt = s->mac_reg[RDT]) < s->mac_reg[RDH])
1008 rdt += s->mac_reg[RDLEN] / sizeof(desc);
1009 if (((rdt - s->mac_reg[RDH]) * sizeof(desc)) <= s->mac_reg[RDLEN] >>
1010 s->rxbuf_min_shift)
1011 n |= E1000_ICS_RXDMT0;
1012
1013 set_ics(s, 0, n);
1014
1015 return size;
1016 }
1017
1018 static ssize_t
1019 e1000_receive(NetClientState *nc, const uint8_t *buf, size_t size)
1020 {
1021 const struct iovec iov = {
1022 .iov_base = (uint8_t *)buf,
1023 .iov_len = size
1024 };
1025
1026 return e1000_receive_iov(nc, &iov, 1);
1027 }
1028
1029 static uint32_t
1030 mac_readreg(E1000State *s, int index)
1031 {
1032 return s->mac_reg[index];
1033 }
1034
1035 static uint32_t
1036 mac_low4_read(E1000State *s, int index)
1037 {
1038 return s->mac_reg[index] & 0xf;
1039 }
1040
1041 static uint32_t
1042 mac_low11_read(E1000State *s, int index)
1043 {
1044 return s->mac_reg[index] & 0x7ff;
1045 }
1046
1047 static uint32_t
1048 mac_low13_read(E1000State *s, int index)
1049 {
1050 return s->mac_reg[index] & 0x1fff;
1051 }
1052
1053 static uint32_t
1054 mac_low16_read(E1000State *s, int index)
1055 {
1056 return s->mac_reg[index] & 0xffff;
1057 }
1058
1059 static uint32_t
1060 mac_icr_read(E1000State *s, int index)
1061 {
1062 uint32_t ret = s->mac_reg[ICR];
1063
1064 DBGOUT(INTERRUPT, "ICR read: %x\n", ret);
1065 set_interrupt_cause(s, 0, 0);
1066 return ret;
1067 }
1068
1069 static uint32_t
1070 mac_read_clr4(E1000State *s, int index)
1071 {
1072 uint32_t ret = s->mac_reg[index];
1073
1074 s->mac_reg[index] = 0;
1075 return ret;
1076 }
1077
1078 static uint32_t
1079 mac_read_clr8(E1000State *s, int index)
1080 {
1081 uint32_t ret = s->mac_reg[index];
1082
1083 s->mac_reg[index] = 0;
1084 s->mac_reg[index-1] = 0;
1085 return ret;
1086 }
1087
1088 static void
1089 mac_writereg(E1000State *s, int index, uint32_t val)
1090 {
1091 uint32_t macaddr[2];
1092
1093 s->mac_reg[index] = val;
1094
1095 if (index == RA + 1) {
1096 macaddr[0] = cpu_to_le32(s->mac_reg[RA]);
1097 macaddr[1] = cpu_to_le32(s->mac_reg[RA + 1]);
1098 qemu_format_nic_info_str(qemu_get_queue(s->nic), (uint8_t *)macaddr);
1099 }
1100 }
1101
1102 static void
1103 set_rdt(E1000State *s, int index, uint32_t val)
1104 {
1105 s->mac_reg[index] = val & 0xffff;
1106 if (e1000_has_rxbufs(s, 1)) {
1107 qemu_flush_queued_packets(qemu_get_queue(s->nic));
1108 }
1109 }
1110
1111 static void
1112 set_16bit(E1000State *s, int index, uint32_t val)
1113 {
1114 s->mac_reg[index] = val & 0xffff;
1115 }
1116
1117 static void
1118 set_dlen(E1000State *s, int index, uint32_t val)
1119 {
1120 s->mac_reg[index] = val & 0xfff80;
1121 }
1122
1123 static void
1124 set_tctl(E1000State *s, int index, uint32_t val)
1125 {
1126 s->mac_reg[index] = val;
1127 s->mac_reg[TDT] &= 0xffff;
1128 start_xmit(s);
1129 }
1130
1131 static void
1132 set_icr(E1000State *s, int index, uint32_t val)
1133 {
1134 DBGOUT(INTERRUPT, "set_icr %x\n", val);
1135 set_interrupt_cause(s, 0, s->mac_reg[ICR] & ~val);
1136 }
1137
1138 static void
1139 set_imc(E1000State *s, int index, uint32_t val)
1140 {
1141 s->mac_reg[IMS] &= ~val;
1142 set_ics(s, 0, 0);
1143 }
1144
1145 static void
1146 set_ims(E1000State *s, int index, uint32_t val)
1147 {
1148 s->mac_reg[IMS] |= val;
1149 set_ics(s, 0, 0);
1150 }
1151
1152 #define getreg(x) [x] = mac_readreg
1153 static uint32_t (*macreg_readops[])(E1000State *, int) = {
1154 getreg(PBA), getreg(RCTL), getreg(TDH), getreg(TXDCTL),
1155 getreg(WUFC), getreg(TDT), getreg(CTRL), getreg(LEDCTL),
1156 getreg(MANC), getreg(MDIC), getreg(SWSM), getreg(STATUS),
1157 getreg(TORL), getreg(TOTL), getreg(IMS), getreg(TCTL),
1158 getreg(RDH), getreg(RDT), getreg(VET), getreg(ICS),
1159 getreg(TDBAL), getreg(TDBAH), getreg(RDBAH), getreg(RDBAL),
1160 getreg(TDLEN), getreg(RDLEN), getreg(RDTR), getreg(RADV),
1161 getreg(TADV), getreg(ITR), getreg(FCRUC), getreg(IPAV),
1162 getreg(WUC), getreg(WUS), getreg(SCC), getreg(ECOL),
1163 getreg(MCC), getreg(LATECOL), getreg(COLC), getreg(DC),
1164 getreg(TNCRS), getreg(SEQEC), getreg(CEXTERR), getreg(RLEC),
1165 getreg(XONRXC), getreg(XONTXC), getreg(XOFFRXC), getreg(XOFFTXC),
1166 getreg(RFC), getreg(RJC), getreg(RNBC), getreg(TSCTFC),
1167 getreg(MGTPRC), getreg(MGTPDC), getreg(MGTPTC), getreg(GORCL),
1168 getreg(GOTCL),
1169
1170 [TOTH] = mac_read_clr8, [TORH] = mac_read_clr8,
1171 [GOTCH] = mac_read_clr8, [GORCH] = mac_read_clr8,
1172 [PRC64] = mac_read_clr4, [PRC127] = mac_read_clr4,
1173 [PRC255] = mac_read_clr4, [PRC511] = mac_read_clr4,
1174 [PRC1023] = mac_read_clr4, [PRC1522] = mac_read_clr4,
1175 [PTC64] = mac_read_clr4, [PTC127] = mac_read_clr4,
1176 [PTC255] = mac_read_clr4, [PTC511] = mac_read_clr4,
1177 [PTC1023] = mac_read_clr4, [PTC1522] = mac_read_clr4,
1178 [GPRC] = mac_read_clr4, [GPTC] = mac_read_clr4,
1179 [TPT] = mac_read_clr4, [TPR] = mac_read_clr4,
1180 [RUC] = mac_read_clr4, [ROC] = mac_read_clr4,
1181 [BPRC] = mac_read_clr4, [MPRC] = mac_read_clr4,
1182 [TSCTC] = mac_read_clr4, [BPTC] = mac_read_clr4,
1183 [MPTC] = mac_read_clr4,
1184 [ICR] = mac_icr_read, [EECD] = get_eecd,
1185 [EERD] = flash_eerd_read,
1186 [RDFH] = mac_low13_read, [RDFT] = mac_low13_read,
1187 [RDFHS] = mac_low13_read, [RDFTS] = mac_low13_read,
1188 [RDFPC] = mac_low13_read,
1189 [TDFH] = mac_low11_read, [TDFT] = mac_low11_read,
1190 [TDFHS] = mac_low13_read, [TDFTS] = mac_low13_read,
1191 [TDFPC] = mac_low13_read,
1192 [AIT] = mac_low16_read,
1193
1194 [CRCERRS ... MPC] = &mac_readreg,
1195 [IP6AT ... IP6AT+3] = &mac_readreg, [IP4AT ... IP4AT+6] = &mac_readreg,
1196 [FFLT ... FFLT+6] = &mac_low11_read,
1197 [RA ... RA+31] = &mac_readreg,
1198 [WUPM ... WUPM+31] = &mac_readreg,
1199 [MTA ... MTA+127] = &mac_readreg,
1200 [VFTA ... VFTA+127] = &mac_readreg,
1201 [FFMT ... FFMT+254] = &mac_low4_read,
1202 [FFVT ... FFVT+254] = &mac_readreg,
1203 [PBM ... PBM+16383] = &mac_readreg,
1204 };
1205 enum { NREADOPS = ARRAY_SIZE(macreg_readops) };
1206
1207 #define putreg(x) [x] = mac_writereg
1208 static void (*macreg_writeops[])(E1000State *, int, uint32_t) = {
1209 putreg(PBA), putreg(EERD), putreg(SWSM), putreg(WUFC),
1210 putreg(TDBAL), putreg(TDBAH), putreg(TXDCTL), putreg(RDBAH),
1211 putreg(RDBAL), putreg(LEDCTL), putreg(VET), putreg(FCRUC),
1212 putreg(TDFH), putreg(TDFT), putreg(TDFHS), putreg(TDFTS),
1213 putreg(TDFPC), putreg(RDFH), putreg(RDFT), putreg(RDFHS),
1214 putreg(RDFTS), putreg(RDFPC), putreg(IPAV), putreg(WUC),
1215 putreg(WUS), putreg(AIT),
1216
1217 [TDLEN] = set_dlen, [RDLEN] = set_dlen, [TCTL] = set_tctl,
1218 [TDT] = set_tctl, [MDIC] = set_mdic, [ICS] = set_ics,
1219 [TDH] = set_16bit, [RDH] = set_16bit, [RDT] = set_rdt,
1220 [IMC] = set_imc, [IMS] = set_ims, [ICR] = set_icr,
1221 [EECD] = set_eecd, [RCTL] = set_rx_control, [CTRL] = set_ctrl,
1222 [RDTR] = set_16bit, [RADV] = set_16bit, [TADV] = set_16bit,
1223 [ITR] = set_16bit,
1224
1225 [IP6AT ... IP6AT+3] = &mac_writereg, [IP4AT ... IP4AT+6] = &mac_writereg,
1226 [FFLT ... FFLT+6] = &mac_writereg,
1227 [RA ... RA+31] = &mac_writereg,
1228 [WUPM ... WUPM+31] = &mac_writereg,
1229 [MTA ... MTA+127] = &mac_writereg,
1230 [VFTA ... VFTA+127] = &mac_writereg,
1231 [FFMT ... FFMT+254] = &mac_writereg, [FFVT ... FFVT+254] = &mac_writereg,
1232 [PBM ... PBM+16383] = &mac_writereg,
1233 };
1234
1235 enum { NWRITEOPS = ARRAY_SIZE(macreg_writeops) };
1236
1237 enum { MAC_ACCESS_PARTIAL = 1, MAC_ACCESS_FLAG_NEEDED = 2 };
1238
1239 #define markflag(x) ((E1000_FLAG_##x << 2) | MAC_ACCESS_FLAG_NEEDED)
1240 /* In the array below the meaning of the bits is: [f|f|f|f|f|f|n|p]
1241 * f - flag bits (up to 6 possible flags)
1242 * n - flag needed
1243 * p - partially implenented */
1244 static const uint8_t mac_reg_access[0x8000] = {
1245 [RDTR] = markflag(MIT), [TADV] = markflag(MIT),
1246 [RADV] = markflag(MIT), [ITR] = markflag(MIT),
1247
1248 [IPAV] = markflag(MAC), [WUC] = markflag(MAC),
1249 [IP6AT] = markflag(MAC), [IP4AT] = markflag(MAC),
1250 [FFVT] = markflag(MAC), [WUPM] = markflag(MAC),
1251 [ECOL] = markflag(MAC), [MCC] = markflag(MAC),
1252 [DC] = markflag(MAC), [TNCRS] = markflag(MAC),
1253 [RLEC] = markflag(MAC), [XONRXC] = markflag(MAC),
1254 [XOFFTXC] = markflag(MAC), [RFC] = markflag(MAC),
1255 [TSCTFC] = markflag(MAC), [MGTPRC] = markflag(MAC),
1256 [WUS] = markflag(MAC), [AIT] = markflag(MAC),
1257 [FFLT] = markflag(MAC), [FFMT] = markflag(MAC),
1258 [SCC] = markflag(MAC), [FCRUC] = markflag(MAC),
1259 [LATECOL] = markflag(MAC), [COLC] = markflag(MAC),
1260 [SEQEC] = markflag(MAC), [CEXTERR] = markflag(MAC),
1261 [XONTXC] = markflag(MAC), [XOFFRXC] = markflag(MAC),
1262 [RJC] = markflag(MAC), [RNBC] = markflag(MAC),
1263 [MGTPDC] = markflag(MAC), [MGTPTC] = markflag(MAC),
1264 [RUC] = markflag(MAC), [ROC] = markflag(MAC),
1265 [GORCL] = markflag(MAC), [GORCH] = markflag(MAC),
1266 [GOTCL] = markflag(MAC), [GOTCH] = markflag(MAC),
1267 [BPRC] = markflag(MAC), [MPRC] = markflag(MAC),
1268 [TSCTC] = markflag(MAC), [PRC64] = markflag(MAC),
1269 [PRC127] = markflag(MAC), [PRC255] = markflag(MAC),
1270 [PRC511] = markflag(MAC), [PRC1023] = markflag(MAC),
1271 [PRC1522] = markflag(MAC), [PTC64] = markflag(MAC),
1272 [PTC127] = markflag(MAC), [PTC255] = markflag(MAC),
1273 [PTC511] = markflag(MAC), [PTC1023] = markflag(MAC),
1274 [PTC1522] = markflag(MAC), [MPTC] = markflag(MAC),
1275 [BPTC] = markflag(MAC),
1276
1277 [TDFH] = markflag(MAC) | MAC_ACCESS_PARTIAL,
1278 [TDFT] = markflag(MAC) | MAC_ACCESS_PARTIAL,
1279 [TDFHS] = markflag(MAC) | MAC_ACCESS_PARTIAL,
1280 [TDFTS] = markflag(MAC) | MAC_ACCESS_PARTIAL,
1281 [TDFPC] = markflag(MAC) | MAC_ACCESS_PARTIAL,
1282 [RDFH] = markflag(MAC) | MAC_ACCESS_PARTIAL,
1283 [RDFT] = markflag(MAC) | MAC_ACCESS_PARTIAL,
1284 [RDFHS] = markflag(MAC) | MAC_ACCESS_PARTIAL,
1285 [RDFTS] = markflag(MAC) | MAC_ACCESS_PARTIAL,
1286 [RDFPC] = markflag(MAC) | MAC_ACCESS_PARTIAL,
1287 [PBM] = markflag(MAC) | MAC_ACCESS_PARTIAL,
1288 };
1289
1290 static void
1291 e1000_mmio_write(void *opaque, hwaddr addr, uint64_t val,
1292 unsigned size)
1293 {
1294 E1000State *s = opaque;
1295 unsigned int index = (addr & 0x1ffff) >> 2;
1296
1297 if (index < NWRITEOPS && macreg_writeops[index]) {
1298 if (!(mac_reg_access[index] & MAC_ACCESS_FLAG_NEEDED)
1299 || (s->compat_flags & (mac_reg_access[index] >> 2))) {
1300 if (mac_reg_access[index] & MAC_ACCESS_PARTIAL) {
1301 DBGOUT(GENERAL, "Writing to register at offset: 0x%08x. "
1302 "It is not fully implemented.\n", index<<2);
1303 }
1304 macreg_writeops[index](s, index, val);
1305 } else { /* "flag needed" bit is set, but the flag is not active */
1306 DBGOUT(MMIO, "MMIO write attempt to disabled reg. addr=0x%08x\n",
1307 index<<2);
1308 }
1309 } else if (index < NREADOPS && macreg_readops[index]) {
1310 DBGOUT(MMIO, "e1000_mmio_writel RO %x: 0x%04"PRIx64"\n",
1311 index<<2, val);
1312 } else {
1313 DBGOUT(UNKNOWN, "MMIO unknown write addr=0x%08x,val=0x%08"PRIx64"\n",
1314 index<<2, val);
1315 }
1316 }
1317
1318 static uint64_t
1319 e1000_mmio_read(void *opaque, hwaddr addr, unsigned size)
1320 {
1321 E1000State *s = opaque;
1322 unsigned int index = (addr & 0x1ffff) >> 2;
1323
1324 if (index < NREADOPS && macreg_readops[index]) {
1325 if (!(mac_reg_access[index] & MAC_ACCESS_FLAG_NEEDED)
1326 || (s->compat_flags & (mac_reg_access[index] >> 2))) {
1327 if (mac_reg_access[index] & MAC_ACCESS_PARTIAL) {
1328 DBGOUT(GENERAL, "Reading register at offset: 0x%08x. "
1329 "It is not fully implemented.\n", index<<2);
1330 }
1331 return macreg_readops[index](s, index);
1332 } else { /* "flag needed" bit is set, but the flag is not active */
1333 DBGOUT(MMIO, "MMIO read attempt of disabled reg. addr=0x%08x\n",
1334 index<<2);
1335 }
1336 } else {
1337 DBGOUT(UNKNOWN, "MMIO unknown read addr=0x%08x\n", index<<2);
1338 }
1339 return 0;
1340 }
1341
1342 static const MemoryRegionOps e1000_mmio_ops = {
1343 .read = e1000_mmio_read,
1344 .write = e1000_mmio_write,
1345 .endianness = DEVICE_LITTLE_ENDIAN,
1346 .impl = {
1347 .min_access_size = 4,
1348 .max_access_size = 4,
1349 },
1350 };
1351
1352 static uint64_t e1000_io_read(void *opaque, hwaddr addr,
1353 unsigned size)
1354 {
1355 E1000State *s = opaque;
1356
1357 (void)s;
1358 return 0;
1359 }
1360
1361 static void e1000_io_write(void *opaque, hwaddr addr,
1362 uint64_t val, unsigned size)
1363 {
1364 E1000State *s = opaque;
1365
1366 (void)s;
1367 }
1368
1369 static const MemoryRegionOps e1000_io_ops = {
1370 .read = e1000_io_read,
1371 .write = e1000_io_write,
1372 .endianness = DEVICE_LITTLE_ENDIAN,
1373 };
1374
1375 static bool is_version_1(void *opaque, int version_id)
1376 {
1377 return version_id == 1;
1378 }
1379
1380 static int e1000_pre_save(void *opaque)
1381 {
1382 E1000State *s = opaque;
1383 NetClientState *nc = qemu_get_queue(s->nic);
1384
1385 /*
1386 * If link is down and auto-negotiation is supported and ongoing,
1387 * complete auto-negotiation immediately. This allows us to look
1388 * at MII_SR_AUTONEG_COMPLETE to infer link status on load.
1389 */
1390 if (nc->link_down && have_autoneg(s)) {
1391 s->phy_reg[PHY_STATUS] |= MII_SR_AUTONEG_COMPLETE;
1392 }
1393
1394 /* Decide which set of props to migrate in the main structure */
1395 if (chkflag(TSO) || !s->use_tso_for_migration) {
1396 /* Either we're migrating with the extra subsection, in which
1397 * case the mig_props is always 'props' OR
1398 * we've not got the subsection, but 'props' was the last
1399 * updated.
1400 */
1401 s->mig_props = s->tx.props;
1402 } else {
1403 /* We're not using the subsection, and 'tso_props' was
1404 * the last updated.
1405 */
1406 s->mig_props = s->tx.tso_props;
1407 }
1408 return 0;
1409 }
1410
1411 static int e1000_post_load(void *opaque, int version_id)
1412 {
1413 E1000State *s = opaque;
1414 NetClientState *nc = qemu_get_queue(s->nic);
1415
1416 if (!chkflag(MIT)) {
1417 s->mac_reg[ITR] = s->mac_reg[RDTR] = s->mac_reg[RADV] =
1418 s->mac_reg[TADV] = 0;
1419 s->mit_irq_level = false;
1420 }
1421 s->mit_ide = 0;
1422 s->mit_timer_on = true;
1423 timer_mod(s->mit_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + 1);
1424
1425 /* nc.link_down can't be migrated, so infer link_down according
1426 * to link status bit in mac_reg[STATUS].
1427 * Alternatively, restart link negotiation if it was in progress. */
1428 nc->link_down = (s->mac_reg[STATUS] & E1000_STATUS_LU) == 0;
1429
1430 if (have_autoneg(s) &&
1431 !(s->phy_reg[PHY_STATUS] & MII_SR_AUTONEG_COMPLETE)) {
1432 nc->link_down = false;
1433 timer_mod(s->autoneg_timer,
1434 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 500);
1435 }
1436
1437 s->tx.props = s->mig_props;
1438 if (!s->received_tx_tso) {
1439 /* We received only one set of offload data (tx.props)
1440 * and haven't got tx.tso_props. The best we can do
1441 * is dupe the data.
1442 */
1443 s->tx.tso_props = s->mig_props;
1444 }
1445 return 0;
1446 }
1447
1448 static int e1000_tx_tso_post_load(void *opaque, int version_id)
1449 {
1450 E1000State *s = opaque;
1451 s->received_tx_tso = true;
1452 return 0;
1453 }
1454
1455 static bool e1000_mit_state_needed(void *opaque)
1456 {
1457 E1000State *s = opaque;
1458
1459 return chkflag(MIT);
1460 }
1461
1462 static bool e1000_full_mac_needed(void *opaque)
1463 {
1464 E1000State *s = opaque;
1465
1466 return chkflag(MAC);
1467 }
1468
1469 static bool e1000_tso_state_needed(void *opaque)
1470 {
1471 E1000State *s = opaque;
1472
1473 return chkflag(TSO);
1474 }
1475
1476 static const VMStateDescription vmstate_e1000_mit_state = {
1477 .name = "e1000/mit_state",
1478 .version_id = 1,
1479 .minimum_version_id = 1,
1480 .needed = e1000_mit_state_needed,
1481 .fields = (VMStateField[]) {
1482 VMSTATE_UINT32(mac_reg[RDTR], E1000State),
1483 VMSTATE_UINT32(mac_reg[RADV], E1000State),
1484 VMSTATE_UINT32(mac_reg[TADV], E1000State),
1485 VMSTATE_UINT32(mac_reg[ITR], E1000State),
1486 VMSTATE_BOOL(mit_irq_level, E1000State),
1487 VMSTATE_END_OF_LIST()
1488 }
1489 };
1490
1491 static const VMStateDescription vmstate_e1000_full_mac_state = {
1492 .name = "e1000/full_mac_state",
1493 .version_id = 1,
1494 .minimum_version_id = 1,
1495 .needed = e1000_full_mac_needed,
1496 .fields = (VMStateField[]) {
1497 VMSTATE_UINT32_ARRAY(mac_reg, E1000State, 0x8000),
1498 VMSTATE_END_OF_LIST()
1499 }
1500 };
1501
1502 static const VMStateDescription vmstate_e1000_tx_tso_state = {
1503 .name = "e1000/tx_tso_state",
1504 .version_id = 1,
1505 .minimum_version_id = 1,
1506 .needed = e1000_tso_state_needed,
1507 .post_load = e1000_tx_tso_post_load,
1508 .fields = (VMStateField[]) {
1509 VMSTATE_UINT8(tx.tso_props.ipcss, E1000State),
1510 VMSTATE_UINT8(tx.tso_props.ipcso, E1000State),
1511 VMSTATE_UINT16(tx.tso_props.ipcse, E1000State),
1512 VMSTATE_UINT8(tx.tso_props.tucss, E1000State),
1513 VMSTATE_UINT8(tx.tso_props.tucso, E1000State),
1514 VMSTATE_UINT16(tx.tso_props.tucse, E1000State),
1515 VMSTATE_UINT32(tx.tso_props.paylen, E1000State),
1516 VMSTATE_UINT8(tx.tso_props.hdr_len, E1000State),
1517 VMSTATE_UINT16(tx.tso_props.mss, E1000State),
1518 VMSTATE_INT8(tx.tso_props.ip, E1000State),
1519 VMSTATE_INT8(tx.tso_props.tcp, E1000State),
1520 VMSTATE_END_OF_LIST()
1521 }
1522 };
1523
1524 static const VMStateDescription vmstate_e1000 = {
1525 .name = "e1000",
1526 .version_id = 2,
1527 .minimum_version_id = 1,
1528 .pre_save = e1000_pre_save,
1529 .post_load = e1000_post_load,
1530 .fields = (VMStateField[]) {
1531 VMSTATE_PCI_DEVICE(parent_obj, E1000State),
1532 VMSTATE_UNUSED_TEST(is_version_1, 4), /* was instance id */
1533 VMSTATE_UNUSED(4), /* Was mmio_base. */
1534 VMSTATE_UINT32(rxbuf_size, E1000State),
1535 VMSTATE_UINT32(rxbuf_min_shift, E1000State),
1536 VMSTATE_UINT32(eecd_state.val_in, E1000State),
1537 VMSTATE_UINT16(eecd_state.bitnum_in, E1000State),
1538 VMSTATE_UINT16(eecd_state.bitnum_out, E1000State),
1539 VMSTATE_UINT16(eecd_state.reading, E1000State),
1540 VMSTATE_UINT32(eecd_state.old_eecd, E1000State),
1541 VMSTATE_UINT8(mig_props.ipcss, E1000State),
1542 VMSTATE_UINT8(mig_props.ipcso, E1000State),
1543 VMSTATE_UINT16(mig_props.ipcse, E1000State),
1544 VMSTATE_UINT8(mig_props.tucss, E1000State),
1545 VMSTATE_UINT8(mig_props.tucso, E1000State),
1546 VMSTATE_UINT16(mig_props.tucse, E1000State),
1547 VMSTATE_UINT32(mig_props.paylen, E1000State),
1548 VMSTATE_UINT8(mig_props.hdr_len, E1000State),
1549 VMSTATE_UINT16(mig_props.mss, E1000State),
1550 VMSTATE_UINT16(tx.size, E1000State),
1551 VMSTATE_UINT16(tx.tso_frames, E1000State),
1552 VMSTATE_UINT8(tx.sum_needed, E1000State),
1553 VMSTATE_INT8(mig_props.ip, E1000State),
1554 VMSTATE_INT8(mig_props.tcp, E1000State),
1555 VMSTATE_BUFFER(tx.header, E1000State),
1556 VMSTATE_BUFFER(tx.data, E1000State),
1557 VMSTATE_UINT16_ARRAY(eeprom_data, E1000State, 64),
1558 VMSTATE_UINT16_ARRAY(phy_reg, E1000State, 0x20),
1559 VMSTATE_UINT32(mac_reg[CTRL], E1000State),
1560 VMSTATE_UINT32(mac_reg[EECD], E1000State),
1561 VMSTATE_UINT32(mac_reg[EERD], E1000State),
1562 VMSTATE_UINT32(mac_reg[GPRC], E1000State),
1563 VMSTATE_UINT32(mac_reg[GPTC], E1000State),
1564 VMSTATE_UINT32(mac_reg[ICR], E1000State),
1565 VMSTATE_UINT32(mac_reg[ICS], E1000State),
1566 VMSTATE_UINT32(mac_reg[IMC], E1000State),
1567 VMSTATE_UINT32(mac_reg[IMS], E1000State),
1568 VMSTATE_UINT32(mac_reg[LEDCTL], E1000State),
1569 VMSTATE_UINT32(mac_reg[MANC], E1000State),
1570 VMSTATE_UINT32(mac_reg[MDIC], E1000State),
1571 VMSTATE_UINT32(mac_reg[MPC], E1000State),
1572 VMSTATE_UINT32(mac_reg[PBA], E1000State),
1573 VMSTATE_UINT32(mac_reg[RCTL], E1000State),
1574 VMSTATE_UINT32(mac_reg[RDBAH], E1000State),
1575 VMSTATE_UINT32(mac_reg[RDBAL], E1000State),
1576 VMSTATE_UINT32(mac_reg[RDH], E1000State),
1577 VMSTATE_UINT32(mac_reg[RDLEN], E1000State),
1578 VMSTATE_UINT32(mac_reg[RDT], E1000State),
1579 VMSTATE_UINT32(mac_reg[STATUS], E1000State),
1580 VMSTATE_UINT32(mac_reg[SWSM], E1000State),
1581 VMSTATE_UINT32(mac_reg[TCTL], E1000State),
1582 VMSTATE_UINT32(mac_reg[TDBAH], E1000State),
1583 VMSTATE_UINT32(mac_reg[TDBAL], E1000State),
1584 VMSTATE_UINT32(mac_reg[TDH], E1000State),
1585 VMSTATE_UINT32(mac_reg[TDLEN], E1000State),
1586 VMSTATE_UINT32(mac_reg[TDT], E1000State),
1587 VMSTATE_UINT32(mac_reg[TORH], E1000State),
1588 VMSTATE_UINT32(mac_reg[TORL], E1000State),
1589 VMSTATE_UINT32(mac_reg[TOTH], E1000State),
1590 VMSTATE_UINT32(mac_reg[TOTL], E1000State),
1591 VMSTATE_UINT32(mac_reg[TPR], E1000State),
1592 VMSTATE_UINT32(mac_reg[TPT], E1000State),
1593 VMSTATE_UINT32(mac_reg[TXDCTL], E1000State),
1594 VMSTATE_UINT32(mac_reg[WUFC], E1000State),
1595 VMSTATE_UINT32(mac_reg[VET], E1000State),
1596 VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, RA, 32),
1597 VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, MTA, 128),
1598 VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, VFTA, 128),
1599 VMSTATE_END_OF_LIST()
1600 },
1601 .subsections = (const VMStateDescription*[]) {
1602 &vmstate_e1000_mit_state,
1603 &vmstate_e1000_full_mac_state,
1604 &vmstate_e1000_tx_tso_state,
1605 NULL
1606 }
1607 };
1608
1609 /*
1610 * EEPROM contents documented in Tables 5-2 and 5-3, pp. 98-102.
1611 * Note: A valid DevId will be inserted during pci_e1000_init().
1612 */
1613 static const uint16_t e1000_eeprom_template[64] = {
1614 0x0000, 0x0000, 0x0000, 0x0000, 0xffff, 0x0000, 0x0000, 0x0000,
1615 0x3000, 0x1000, 0x6403, 0 /*DevId*/, 0x8086, 0 /*DevId*/, 0x8086, 0x3040,
1616 0x0008, 0x2000, 0x7e14, 0x0048, 0x1000, 0x00d8, 0x0000, 0x2700,
1617 0x6cc9, 0x3150, 0x0722, 0x040b, 0x0984, 0x0000, 0xc000, 0x0706,
1618 0x1008, 0x0000, 0x0f04, 0x7fff, 0x4d01, 0xffff, 0xffff, 0xffff,
1619 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
1620 0x0100, 0x4000, 0x121c, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
1621 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0000,
1622 };
1623
1624 /* PCI interface */
1625
1626 static void
1627 e1000_mmio_setup(E1000State *d)
1628 {
1629 int i;
1630 const uint32_t excluded_regs[] = {
1631 E1000_MDIC, E1000_ICR, E1000_ICS, E1000_IMS,
1632 E1000_IMC, E1000_TCTL, E1000_TDT, PNPMMIO_SIZE
1633 };
1634
1635 memory_region_init_io(&d->mmio, OBJECT(d), &e1000_mmio_ops, d,
1636 "e1000-mmio", PNPMMIO_SIZE);
1637 memory_region_add_coalescing(&d->mmio, 0, excluded_regs[0]);
1638 for (i = 0; excluded_regs[i] != PNPMMIO_SIZE; i++)
1639 memory_region_add_coalescing(&d->mmio, excluded_regs[i] + 4,
1640 excluded_regs[i+1] - excluded_regs[i] - 4);
1641 memory_region_init_io(&d->io, OBJECT(d), &e1000_io_ops, d, "e1000-io", IOPORT_SIZE);
1642 }
1643
1644 static void
1645 pci_e1000_uninit(PCIDevice *dev)
1646 {
1647 E1000State *d = E1000(dev);
1648
1649 timer_del(d->autoneg_timer);
1650 timer_free(d->autoneg_timer);
1651 timer_del(d->mit_timer);
1652 timer_free(d->mit_timer);
1653 timer_del(d->flush_queue_timer);
1654 timer_free(d->flush_queue_timer);
1655 qemu_del_nic(d->nic);
1656 }
1657
1658 static NetClientInfo net_e1000_info = {
1659 .type = NET_CLIENT_DRIVER_NIC,
1660 .size = sizeof(NICState),
1661 .can_receive = e1000_can_receive,
1662 .receive = e1000_receive,
1663 .receive_iov = e1000_receive_iov,
1664 .link_status_changed = e1000_set_link_status,
1665 };
1666
1667 static void e1000_write_config(PCIDevice *pci_dev, uint32_t address,
1668 uint32_t val, int len)
1669 {
1670 E1000State *s = E1000(pci_dev);
1671
1672 pci_default_write_config(pci_dev, address, val, len);
1673
1674 if (range_covers_byte(address, len, PCI_COMMAND) &&
1675 (pci_dev->config[PCI_COMMAND] & PCI_COMMAND_MASTER)) {
1676 qemu_flush_queued_packets(qemu_get_queue(s->nic));
1677 }
1678 }
1679
1680 static void pci_e1000_realize(PCIDevice *pci_dev, Error **errp)
1681 {
1682 DeviceState *dev = DEVICE(pci_dev);
1683 E1000State *d = E1000(pci_dev);
1684 uint8_t *pci_conf;
1685 uint8_t *macaddr;
1686
1687 pci_dev->config_write = e1000_write_config;
1688
1689 pci_conf = pci_dev->config;
1690
1691 /* TODO: RST# value should be 0, PCI spec 6.2.4 */
1692 pci_conf[PCI_CACHE_LINE_SIZE] = 0x10;
1693
1694 pci_conf[PCI_INTERRUPT_PIN] = 1; /* interrupt pin A */
1695
1696 e1000_mmio_setup(d);
1697
1698 pci_register_bar(pci_dev, 0, PCI_BASE_ADDRESS_SPACE_MEMORY, &d->mmio);
1699
1700 pci_register_bar(pci_dev, 1, PCI_BASE_ADDRESS_SPACE_IO, &d->io);
1701
1702 qemu_macaddr_default_if_unset(&d->conf.macaddr);
1703 macaddr = d->conf.macaddr.a;
1704
1705 e1000x_core_prepare_eeprom(d->eeprom_data,
1706 e1000_eeprom_template,
1707 sizeof(e1000_eeprom_template),
1708 PCI_DEVICE_GET_CLASS(pci_dev)->device_id,
1709 macaddr);
1710
1711 d->nic = qemu_new_nic(&net_e1000_info, &d->conf,
1712 object_get_typename(OBJECT(d)), dev->id, d);
1713
1714 qemu_format_nic_info_str(qemu_get_queue(d->nic), macaddr);
1715
1716 d->autoneg_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, e1000_autoneg_timer, d);
1717 d->mit_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, e1000_mit_timer, d);
1718 d->flush_queue_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL,
1719 e1000_flush_queue_timer, d);
1720 }
1721
1722 static void qdev_e1000_reset(DeviceState *dev)
1723 {
1724 E1000State *d = E1000(dev);
1725 e1000_reset(d);
1726 }
1727
1728 static Property e1000_properties[] = {
1729 DEFINE_NIC_PROPERTIES(E1000State, conf),
1730 DEFINE_PROP_BIT("autonegotiation", E1000State,
1731 compat_flags, E1000_FLAG_AUTONEG_BIT, true),
1732 DEFINE_PROP_BIT("mitigation", E1000State,
1733 compat_flags, E1000_FLAG_MIT_BIT, true),
1734 DEFINE_PROP_BIT("extra_mac_registers", E1000State,
1735 compat_flags, E1000_FLAG_MAC_BIT, true),
1736 DEFINE_PROP_BIT("migrate_tso_props", E1000State,
1737 compat_flags, E1000_FLAG_TSO_BIT, true),
1738 DEFINE_PROP_END_OF_LIST(),
1739 };
1740
1741 typedef struct E1000Info {
1742 const char *name;
1743 uint16_t device_id;
1744 uint8_t revision;
1745 uint16_t phy_id2;
1746 } E1000Info;
1747
1748 static void e1000_class_init(ObjectClass *klass, void *data)
1749 {
1750 DeviceClass *dc = DEVICE_CLASS(klass);
1751 PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
1752 E1000BaseClass *e = E1000_DEVICE_CLASS(klass);
1753 const E1000Info *info = data;
1754
1755 k->realize = pci_e1000_realize;
1756 k->exit = pci_e1000_uninit;
1757 k->romfile = "efi-e1000.rom";
1758 k->vendor_id = PCI_VENDOR_ID_INTEL;
1759 k->device_id = info->device_id;
1760 k->revision = info->revision;
1761 e->phy_id2 = info->phy_id2;
1762 k->class_id = PCI_CLASS_NETWORK_ETHERNET;
1763 set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
1764 dc->desc = "Intel Gigabit Ethernet";
1765 dc->reset = qdev_e1000_reset;
1766 dc->vmsd = &vmstate_e1000;
1767 dc->props = e1000_properties;
1768 }
1769
1770 static void e1000_instance_init(Object *obj)
1771 {
1772 E1000State *n = E1000(obj);
1773 device_add_bootindex_property(obj, &n->conf.bootindex,
1774 "bootindex", "/ethernet-phy@0",
1775 DEVICE(n), NULL);
1776 }
1777
1778 static const TypeInfo e1000_base_info = {
1779 .name = TYPE_E1000_BASE,
1780 .parent = TYPE_PCI_DEVICE,
1781 .instance_size = sizeof(E1000State),
1782 .instance_init = e1000_instance_init,
1783 .class_size = sizeof(E1000BaseClass),
1784 .abstract = true,
1785 .interfaces = (InterfaceInfo[]) {
1786 { INTERFACE_CONVENTIONAL_PCI_DEVICE },
1787 { },
1788 },
1789 };
1790
1791 static const E1000Info e1000_devices[] = {
1792 {
1793 .name = "e1000",
1794 .device_id = E1000_DEV_ID_82540EM,
1795 .revision = 0x03,
1796 .phy_id2 = E1000_PHY_ID2_8254xx_DEFAULT,
1797 },
1798 {
1799 .name = "e1000-82544gc",
1800 .device_id = E1000_DEV_ID_82544GC_COPPER,
1801 .revision = 0x03,
1802 .phy_id2 = E1000_PHY_ID2_82544x,
1803 },
1804 {
1805 .name = "e1000-82545em",
1806 .device_id = E1000_DEV_ID_82545EM_COPPER,
1807 .revision = 0x03,
1808 .phy_id2 = E1000_PHY_ID2_8254xx_DEFAULT,
1809 },
1810 };
1811
1812 static void e1000_register_types(void)
1813 {
1814 int i;
1815
1816 type_register_static(&e1000_base_info);
1817 for (i = 0; i < ARRAY_SIZE(e1000_devices); i++) {
1818 const E1000Info *info = &e1000_devices[i];
1819 TypeInfo type_info = {};
1820
1821 type_info.name = info->name;
1822 type_info.parent = TYPE_E1000_BASE;
1823 type_info.class_data = (void *)info;
1824 type_info.class_init = e1000_class_init;
1825 type_info.instance_init = e1000_instance_init;
1826
1827 type_register(&type_info);
1828 }
1829 }
1830
1831 type_init(e1000_register_types)
armbru's QEMU hackery