]> git.proxmox.com Git - qemu.git/blob - hw/e1000.c
projects / qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
misc: move include files to include/qemu/
[qemu.git] / hw / e1000.c
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 "hw.h"
29 #include "pci/pci.h"
30 #include "net/net.h"
31 #include "net/checksum.h"
32 #include "loader.h"
33 #include "sysemu.h"
34 #include "dma.h"
35
36 #include "e1000_hw.h"
37
38 #define E1000_DEBUG
39
40 #ifdef E1000_DEBUG
41 enum {
42 DEBUG_GENERAL, DEBUG_IO, DEBUG_MMIO, DEBUG_INTERRUPT,
43 DEBUG_RX, DEBUG_TX, DEBUG_MDIC, DEBUG_EEPROM,
44 DEBUG_UNKNOWN, DEBUG_TXSUM, DEBUG_TXERR, DEBUG_RXERR,
45 DEBUG_RXFILTER, DEBUG_PHY, DEBUG_NOTYET,
46 };
47 #define DBGBIT(x) (1<<DEBUG_##x)
48 static int debugflags = DBGBIT(TXERR) | DBGBIT(GENERAL);
49
50 #define DBGOUT(what, fmt, ...) do { \
51 if (debugflags & DBGBIT(what)) \
52 fprintf(stderr, "e1000: " fmt, ## __VA_ARGS__); \
53 } while (0)
54 #else
55 #define DBGOUT(what, fmt, ...) do {} while (0)
56 #endif
57
58 #define IOPORT_SIZE 0x40
59 #define PNPMMIO_SIZE 0x20000
60 #define MIN_BUF_SIZE 60 /* Min. octets in an ethernet frame sans FCS */
61
62 /* this is the size past which hardware will drop packets when setting LPE=0 */
63 #define MAXIMUM_ETHERNET_VLAN_SIZE 1522
64
65 /*
66 * HW models:
67 * E1000_DEV_ID_82540EM works with Windows and Linux
68 * E1000_DEV_ID_82573L OK with windoze and Linux 2.6.22,
69 * appears to perform better than 82540EM, but breaks with Linux 2.6.18
70 * E1000_DEV_ID_82544GC_COPPER appears to work; not well tested
71 * Others never tested
72 */
73 enum { E1000_DEVID = E1000_DEV_ID_82540EM };
74
75 /*
76 * May need to specify additional MAC-to-PHY entries --
77 * Intel's Windows driver refuses to initialize unless they match
78 */
79 enum {
80 PHY_ID2_INIT = E1000_DEVID == E1000_DEV_ID_82573L ? 0xcc2 :
81 E1000_DEVID == E1000_DEV_ID_82544GC_COPPER ? 0xc30 :
82 /* default to E1000_DEV_ID_82540EM */ 0xc20
83 };
84
85 typedef struct E1000State_st {
86 PCIDevice dev;
87 NICState *nic;
88 NICConf conf;
89 MemoryRegion mmio;
90 MemoryRegion io;
91
92 uint32_t mac_reg[0x8000];
93 uint16_t phy_reg[0x20];
94 uint16_t eeprom_data[64];
95
96 uint32_t rxbuf_size;
97 uint32_t rxbuf_min_shift;
98 struct e1000_tx {
99 unsigned char header[256];
100 unsigned char vlan_header[4];
101 /* Fields vlan and data must not be reordered or separated. */
102 unsigned char vlan[4];
103 unsigned char data[0x10000];
104 uint16_t size;
105 unsigned char sum_needed;
106 unsigned char vlan_needed;
107 uint8_t ipcss;
108 uint8_t ipcso;
109 uint16_t ipcse;
110 uint8_t tucss;
111 uint8_t tucso;
112 uint16_t tucse;
113 uint8_t hdr_len;
114 uint16_t mss;
115 uint32_t paylen;
116 uint16_t tso_frames;
117 char tse;
118 int8_t ip;
119 int8_t tcp;
120 char cptse; // current packet tse bit
121 } tx;
122
123 struct {
124 uint32_t val_in; // shifted in from guest driver
125 uint16_t bitnum_in;
126 uint16_t bitnum_out;
127 uint16_t reading;
128 uint32_t old_eecd;
129 } eecd_state;
130
131 QEMUTimer *autoneg_timer;
132 } E1000State;
133
134 #define defreg(x) x = (E1000_##x>>2)
135 enum {
136 defreg(CTRL), defreg(EECD), defreg(EERD), defreg(GPRC),
137 defreg(GPTC), defreg(ICR), defreg(ICS), defreg(IMC),
138 defreg(IMS), defreg(LEDCTL), defreg(MANC), defreg(MDIC),
139 defreg(MPC), defreg(PBA), defreg(RCTL), defreg(RDBAH),
140 defreg(RDBAL), defreg(RDH), defreg(RDLEN), defreg(RDT),
141 defreg(STATUS), defreg(SWSM), defreg(TCTL), defreg(TDBAH),
142 defreg(TDBAL), defreg(TDH), defreg(TDLEN), defreg(TDT),
143 defreg(TORH), defreg(TORL), defreg(TOTH), defreg(TOTL),
144 defreg(TPR), defreg(TPT), defreg(TXDCTL), defreg(WUFC),
145 defreg(RA), defreg(MTA), defreg(CRCERRS),defreg(VFTA),
146 defreg(VET),
147 };
148
149 static void
150 e1000_link_down(E1000State *s)
151 {
152 s->mac_reg[STATUS] &= ~E1000_STATUS_LU;
153 s->phy_reg[PHY_STATUS] &= ~MII_SR_LINK_STATUS;
154 }
155
156 static void
157 e1000_link_up(E1000State *s)
158 {
159 s->mac_reg[STATUS] |= E1000_STATUS_LU;
160 s->phy_reg[PHY_STATUS] |= MII_SR_LINK_STATUS;
161 }
162
163 static void
164 set_phy_ctrl(E1000State *s, int index, uint16_t val)
165 {
166 if ((val & MII_CR_AUTO_NEG_EN) && (val & MII_CR_RESTART_AUTO_NEG)) {
167 s->nic->nc.link_down = true;
168 e1000_link_down(s);
169 s->phy_reg[PHY_STATUS] &= ~MII_SR_AUTONEG_COMPLETE;
170 DBGOUT(PHY, "Start link auto negotiation\n");
171 qemu_mod_timer(s->autoneg_timer, qemu_get_clock_ms(vm_clock) + 500);
172 }
173 }
174
175 static void
176 e1000_autoneg_timer(void *opaque)
177 {
178 E1000State *s = opaque;
179 s->nic->nc.link_down = false;
180 e1000_link_up(s);
181 s->phy_reg[PHY_STATUS] |= MII_SR_AUTONEG_COMPLETE;
182 DBGOUT(PHY, "Auto negotiation is completed\n");
183 }
184
185 static void (*phyreg_writeops[])(E1000State *, int, uint16_t) = {
186 [PHY_CTRL] = set_phy_ctrl,
187 };
188
189 enum { NPHYWRITEOPS = ARRAY_SIZE(phyreg_writeops) };
190
191 enum { PHY_R = 1, PHY_W = 2, PHY_RW = PHY_R | PHY_W };
192 static const char phy_regcap[0x20] = {
193 [PHY_STATUS] = PHY_R, [M88E1000_EXT_PHY_SPEC_CTRL] = PHY_RW,
194 [PHY_ID1] = PHY_R, [M88E1000_PHY_SPEC_CTRL] = PHY_RW,
195 [PHY_CTRL] = PHY_RW, [PHY_1000T_CTRL] = PHY_RW,
196 [PHY_LP_ABILITY] = PHY_R, [PHY_1000T_STATUS] = PHY_R,
197 [PHY_AUTONEG_ADV] = PHY_RW, [M88E1000_RX_ERR_CNTR] = PHY_R,
198 [PHY_ID2] = PHY_R, [M88E1000_PHY_SPEC_STATUS] = PHY_R
199 };
200
201 static const uint16_t phy_reg_init[] = {
202 [PHY_CTRL] = 0x1140,
203 [PHY_STATUS] = 0x794d, /* link initially up with not completed autoneg */
204 [PHY_ID1] = 0x141, [PHY_ID2] = PHY_ID2_INIT,
205 [PHY_1000T_CTRL] = 0x0e00, [M88E1000_PHY_SPEC_CTRL] = 0x360,
206 [M88E1000_EXT_PHY_SPEC_CTRL] = 0x0d60, [PHY_AUTONEG_ADV] = 0xde1,
207 [PHY_LP_ABILITY] = 0x1e0, [PHY_1000T_STATUS] = 0x3c00,
208 [M88E1000_PHY_SPEC_STATUS] = 0xac00,
209 };
210
211 static const uint32_t mac_reg_init[] = {
212 [PBA] = 0x00100030,
213 [LEDCTL] = 0x602,
214 [CTRL] = E1000_CTRL_SWDPIN2 | E1000_CTRL_SWDPIN0 |
215 E1000_CTRL_SPD_1000 | E1000_CTRL_SLU,
216 [STATUS] = 0x80000000 | E1000_STATUS_GIO_MASTER_ENABLE |
217 E1000_STATUS_ASDV | E1000_STATUS_MTXCKOK |
218 E1000_STATUS_SPEED_1000 | E1000_STATUS_FD |
219 E1000_STATUS_LU,
220 [MANC] = E1000_MANC_EN_MNG2HOST | E1000_MANC_RCV_TCO_EN |
221 E1000_MANC_ARP_EN | E1000_MANC_0298_EN |
222 E1000_MANC_RMCP_EN,
223 };
224
225 static void
226 set_interrupt_cause(E1000State *s, int index, uint32_t val)
227 {
228 if (val && (E1000_DEVID >= E1000_DEV_ID_82547EI_MOBILE)) {
229 /* Only for 8257x */
230 val |= E1000_ICR_INT_ASSERTED;
231 }
232 s->mac_reg[ICR] = val;
233 s->mac_reg[ICS] = val;
234 qemu_set_irq(s->dev.irq[0], (s->mac_reg[IMS] & s->mac_reg[ICR]) != 0);
235 }
236
237 static void
238 set_ics(E1000State *s, int index, uint32_t val)
239 {
240 DBGOUT(INTERRUPT, "set_ics %x, ICR %x, IMR %x\n", val, s->mac_reg[ICR],
241 s->mac_reg[IMS]);
242 set_interrupt_cause(s, 0, val | s->mac_reg[ICR]);
243 }
244
245 static int
246 rxbufsize(uint32_t v)
247 {
248 v &= E1000_RCTL_BSEX | E1000_RCTL_SZ_16384 | E1000_RCTL_SZ_8192 |
249 E1000_RCTL_SZ_4096 | E1000_RCTL_SZ_2048 | E1000_RCTL_SZ_1024 |
250 E1000_RCTL_SZ_512 | E1000_RCTL_SZ_256;
251 switch (v) {
252 case E1000_RCTL_BSEX | E1000_RCTL_SZ_16384:
253 return 16384;
254 case E1000_RCTL_BSEX | E1000_RCTL_SZ_8192:
255 return 8192;
256 case E1000_RCTL_BSEX | E1000_RCTL_SZ_4096:
257 return 4096;
258 case E1000_RCTL_SZ_1024:
259 return 1024;
260 case E1000_RCTL_SZ_512:
261 return 512;
262 case E1000_RCTL_SZ_256:
263 return 256;
264 }
265 return 2048;
266 }
267
268 static void e1000_reset(void *opaque)
269 {
270 E1000State *d = opaque;
271 uint8_t *macaddr = d->conf.macaddr.a;
272 int i;
273
274 qemu_del_timer(d->autoneg_timer);
275 memset(d->phy_reg, 0, sizeof d->phy_reg);
276 memmove(d->phy_reg, phy_reg_init, sizeof phy_reg_init);
277 memset(d->mac_reg, 0, sizeof d->mac_reg);
278 memmove(d->mac_reg, mac_reg_init, sizeof mac_reg_init);
279 d->rxbuf_min_shift = 1;
280 memset(&d->tx, 0, sizeof d->tx);
281
282 if (d->nic->nc.link_down) {
283 e1000_link_down(d);
284 }
285
286 /* Some guests expect pre-initialized RAH/RAL (AddrValid flag + MACaddr) */
287 d->mac_reg[RA] = 0;
288 d->mac_reg[RA + 1] = E1000_RAH_AV;
289 for (i = 0; i < 4; i++) {
290 d->mac_reg[RA] |= macaddr[i] << (8 * i);
291 d->mac_reg[RA + 1] |= (i < 2) ? macaddr[i + 4] << (8 * i) : 0;
292 }
293 }
294
295 static void
296 set_ctrl(E1000State *s, int index, uint32_t val)
297 {
298 /* RST is self clearing */
299 s->mac_reg[CTRL] = val & ~E1000_CTRL_RST;
300 }
301
302 static void
303 set_rx_control(E1000State *s, int index, uint32_t val)
304 {
305 s->mac_reg[RCTL] = val;
306 s->rxbuf_size = rxbufsize(val);
307 s->rxbuf_min_shift = ((val / E1000_RCTL_RDMTS_QUAT) & 3) + 1;
308 DBGOUT(RX, "RCTL: %d, mac_reg[RCTL] = 0x%x\n", s->mac_reg[RDT],
309 s->mac_reg[RCTL]);
310 qemu_flush_queued_packets(&s->nic->nc);
311 }
312
313 static void
314 set_mdic(E1000State *s, int index, uint32_t val)
315 {
316 uint32_t data = val & E1000_MDIC_DATA_MASK;
317 uint32_t addr = ((val & E1000_MDIC_REG_MASK) >> E1000_MDIC_REG_SHIFT);
318
319 if ((val & E1000_MDIC_PHY_MASK) >> E1000_MDIC_PHY_SHIFT != 1) // phy #
320 val = s->mac_reg[MDIC] | E1000_MDIC_ERROR;
321 else if (val & E1000_MDIC_OP_READ) {
322 DBGOUT(MDIC, "MDIC read reg 0x%x\n", addr);
323 if (!(phy_regcap[addr] & PHY_R)) {
324 DBGOUT(MDIC, "MDIC read reg %x unhandled\n", addr);
325 val |= E1000_MDIC_ERROR;
326 } else
327 val = (val ^ data) | s->phy_reg[addr];
328 } else if (val & E1000_MDIC_OP_WRITE) {
329 DBGOUT(MDIC, "MDIC write reg 0x%x, value 0x%x\n", addr, data);
330 if (!(phy_regcap[addr] & PHY_W)) {
331 DBGOUT(MDIC, "MDIC write reg %x unhandled\n", addr);
332 val |= E1000_MDIC_ERROR;
333 } else {
334 if (addr < NPHYWRITEOPS && phyreg_writeops[addr]) {
335 phyreg_writeops[addr](s, index, data);
336 }
337 s->phy_reg[addr] = data;
338 }
339 }
340 s->mac_reg[MDIC] = val | E1000_MDIC_READY;
341
342 if (val & E1000_MDIC_INT_EN) {
343 set_ics(s, 0, E1000_ICR_MDAC);
344 }
345 }
346
347 static uint32_t
348 get_eecd(E1000State *s, int index)
349 {
350 uint32_t ret = E1000_EECD_PRES|E1000_EECD_GNT | s->eecd_state.old_eecd;
351
352 DBGOUT(EEPROM, "reading eeprom bit %d (reading %d)\n",
353 s->eecd_state.bitnum_out, s->eecd_state.reading);
354 if (!s->eecd_state.reading ||
355 ((s->eeprom_data[(s->eecd_state.bitnum_out >> 4) & 0x3f] >>
356 ((s->eecd_state.bitnum_out & 0xf) ^ 0xf))) & 1)
357 ret |= E1000_EECD_DO;
358 return ret;
359 }
360
361 static void
362 set_eecd(E1000State *s, int index, uint32_t val)
363 {
364 uint32_t oldval = s->eecd_state.old_eecd;
365
366 s->eecd_state.old_eecd = val & (E1000_EECD_SK | E1000_EECD_CS |
367 E1000_EECD_DI|E1000_EECD_FWE_MASK|E1000_EECD_REQ);
368 if (!(E1000_EECD_CS & val)) // CS inactive; nothing to do
369 return;
370 if (E1000_EECD_CS & (val ^ oldval)) { // CS rise edge; reset state
371 s->eecd_state.val_in = 0;
372 s->eecd_state.bitnum_in = 0;
373 s->eecd_state.bitnum_out = 0;
374 s->eecd_state.reading = 0;
375 }
376 if (!(E1000_EECD_SK & (val ^ oldval))) // no clock edge
377 return;
378 if (!(E1000_EECD_SK & val)) { // falling edge
379 s->eecd_state.bitnum_out++;
380 return;
381 }
382 s->eecd_state.val_in <<= 1;
383 if (val & E1000_EECD_DI)
384 s->eecd_state.val_in |= 1;
385 if (++s->eecd_state.bitnum_in == 9 && !s->eecd_state.reading) {
386 s->eecd_state.bitnum_out = ((s->eecd_state.val_in & 0x3f)<<4)-1;
387 s->eecd_state.reading = (((s->eecd_state.val_in >> 6) & 7) ==
388 EEPROM_READ_OPCODE_MICROWIRE);
389 }
390 DBGOUT(EEPROM, "eeprom bitnum in %d out %d, reading %d\n",
391 s->eecd_state.bitnum_in, s->eecd_state.bitnum_out,
392 s->eecd_state.reading);
393 }
394
395 static uint32_t
396 flash_eerd_read(E1000State *s, int x)
397 {
398 unsigned int index, r = s->mac_reg[EERD] & ~E1000_EEPROM_RW_REG_START;
399
400 if ((s->mac_reg[EERD] & E1000_EEPROM_RW_REG_START) == 0)
401 return (s->mac_reg[EERD]);
402
403 if ((index = r >> E1000_EEPROM_RW_ADDR_SHIFT) > EEPROM_CHECKSUM_REG)
404 return (E1000_EEPROM_RW_REG_DONE | r);
405
406 return ((s->eeprom_data[index] << E1000_EEPROM_RW_REG_DATA) |
407 E1000_EEPROM_RW_REG_DONE | r);
408 }
409
410 static void
411 putsum(uint8_t *data, uint32_t n, uint32_t sloc, uint32_t css, uint32_t cse)
412 {
413 uint32_t sum;
414
415 if (cse && cse < n)
416 n = cse + 1;
417 if (sloc < n-1) {
418 sum = net_checksum_add(n-css, data+css);
419 cpu_to_be16wu((uint16_t *)(data + sloc),
420 net_checksum_finish(sum));
421 }
422 }
423
424 static inline int
425 vlan_enabled(E1000State *s)
426 {
427 return ((s->mac_reg[CTRL] & E1000_CTRL_VME) != 0);
428 }
429
430 static inline int
431 vlan_rx_filter_enabled(E1000State *s)
432 {
433 return ((s->mac_reg[RCTL] & E1000_RCTL_VFE) != 0);
434 }
435
436 static inline int
437 is_vlan_packet(E1000State *s, const uint8_t *buf)
438 {
439 return (be16_to_cpup((uint16_t *)(buf + 12)) ==
440 le16_to_cpup((uint16_t *)(s->mac_reg + VET)));
441 }
442
443 static inline int
444 is_vlan_txd(uint32_t txd_lower)
445 {
446 return ((txd_lower & E1000_TXD_CMD_VLE) != 0);
447 }
448
449 /* FCS aka Ethernet CRC-32. We don't get it from backends and can't
450 * fill it in, just pad descriptor length by 4 bytes unless guest
451 * told us to strip it off the packet. */
452 static inline int
453 fcs_len(E1000State *s)
454 {
455 return (s->mac_reg[RCTL] & E1000_RCTL_SECRC) ? 0 : 4;
456 }
457
458 static void
459 e1000_send_packet(E1000State *s, const uint8_t *buf, int size)
460 {
461 if (s->phy_reg[PHY_CTRL] & MII_CR_LOOPBACK) {
462 s->nic->nc.info->receive(&s->nic->nc, buf, size);
463 } else {
464 qemu_send_packet(&s->nic->nc, buf, size);
465 }
466 }
467
468 static void
469 xmit_seg(E1000State *s)
470 {
471 uint16_t len, *sp;
472 unsigned int frames = s->tx.tso_frames, css, sofar, n;
473 struct e1000_tx *tp = &s->tx;
474
475 if (tp->tse && tp->cptse) {
476 css = tp->ipcss;
477 DBGOUT(TXSUM, "frames %d size %d ipcss %d\n",
478 frames, tp->size, css);
479 if (tp->ip) { // IPv4
480 cpu_to_be16wu((uint16_t *)(tp->data+css+2),
481 tp->size - css);
482 cpu_to_be16wu((uint16_t *)(tp->data+css+4),
483 be16_to_cpup((uint16_t *)(tp->data+css+4))+frames);
484 } else // IPv6
485 cpu_to_be16wu((uint16_t *)(tp->data+css+4),
486 tp->size - css);
487 css = tp->tucss;
488 len = tp->size - css;
489 DBGOUT(TXSUM, "tcp %d tucss %d len %d\n", tp->tcp, css, len);
490 if (tp->tcp) {
491 sofar = frames * tp->mss;
492 cpu_to_be32wu((uint32_t *)(tp->data+css+4), // seq
493 be32_to_cpupu((uint32_t *)(tp->data+css+4))+sofar);
494 if (tp->paylen - sofar > tp->mss)
495 tp->data[css + 13] &= ~9; // PSH, FIN
496 } else // UDP
497 cpu_to_be16wu((uint16_t *)(tp->data+css+4), len);
498 if (tp->sum_needed & E1000_TXD_POPTS_TXSM) {
499 unsigned int phsum;
500 // add pseudo-header length before checksum calculation
501 sp = (uint16_t *)(tp->data + tp->tucso);
502 phsum = be16_to_cpup(sp) + len;
503 phsum = (phsum >> 16) + (phsum & 0xffff);
504 cpu_to_be16wu(sp, phsum);
505 }
506 tp->tso_frames++;
507 }
508
509 if (tp->sum_needed & E1000_TXD_POPTS_TXSM)
510 putsum(tp->data, tp->size, tp->tucso, tp->tucss, tp->tucse);
511 if (tp->sum_needed & E1000_TXD_POPTS_IXSM)
512 putsum(tp->data, tp->size, tp->ipcso, tp->ipcss, tp->ipcse);
513 if (tp->vlan_needed) {
514 memmove(tp->vlan, tp->data, 4);
515 memmove(tp->data, tp->data + 4, 8);
516 memcpy(tp->data + 8, tp->vlan_header, 4);
517 e1000_send_packet(s, tp->vlan, tp->size + 4);
518 } else
519 e1000_send_packet(s, tp->data, tp->size);
520 s->mac_reg[TPT]++;
521 s->mac_reg[GPTC]++;
522 n = s->mac_reg[TOTL];
523 if ((s->mac_reg[TOTL] += s->tx.size) < n)
524 s->mac_reg[TOTH]++;
525 }
526
527 static void
528 process_tx_desc(E1000State *s, struct e1000_tx_desc *dp)
529 {
530 uint32_t txd_lower = le32_to_cpu(dp->lower.data);
531 uint32_t dtype = txd_lower & (E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D);
532 unsigned int split_size = txd_lower & 0xffff, bytes, sz, op;
533 unsigned int msh = 0xfffff, hdr = 0;
534 uint64_t addr;
535 struct e1000_context_desc *xp = (struct e1000_context_desc *)dp;
536 struct e1000_tx *tp = &s->tx;
537
538 if (dtype == E1000_TXD_CMD_DEXT) { // context descriptor
539 op = le32_to_cpu(xp->cmd_and_length);
540 tp->ipcss = xp->lower_setup.ip_fields.ipcss;
541 tp->ipcso = xp->lower_setup.ip_fields.ipcso;
542 tp->ipcse = le16_to_cpu(xp->lower_setup.ip_fields.ipcse);
543 tp->tucss = xp->upper_setup.tcp_fields.tucss;
544 tp->tucso = xp->upper_setup.tcp_fields.tucso;
545 tp->tucse = le16_to_cpu(xp->upper_setup.tcp_fields.tucse);
546 tp->paylen = op & 0xfffff;
547 tp->hdr_len = xp->tcp_seg_setup.fields.hdr_len;
548 tp->mss = le16_to_cpu(xp->tcp_seg_setup.fields.mss);
549 tp->ip = (op & E1000_TXD_CMD_IP) ? 1 : 0;
550 tp->tcp = (op & E1000_TXD_CMD_TCP) ? 1 : 0;
551 tp->tse = (op & E1000_TXD_CMD_TSE) ? 1 : 0;
552 tp->tso_frames = 0;
553 if (tp->tucso == 0) { // this is probably wrong
554 DBGOUT(TXSUM, "TCP/UDP: cso 0!\n");
555 tp->tucso = tp->tucss + (tp->tcp ? 16 : 6);
556 }
557 return;
558 } else if (dtype == (E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D)) {
559 // data descriptor
560 if (tp->size == 0) {
561 tp->sum_needed = le32_to_cpu(dp->upper.data) >> 8;
562 }
563 tp->cptse = ( txd_lower & E1000_TXD_CMD_TSE ) ? 1 : 0;
564 } else {
565 // legacy descriptor
566 tp->cptse = 0;
567 }
568
569 if (vlan_enabled(s) && is_vlan_txd(txd_lower) &&
570 (tp->cptse || txd_lower & E1000_TXD_CMD_EOP)) {
571 tp->vlan_needed = 1;
572 cpu_to_be16wu((uint16_t *)(tp->vlan_header),
573 le16_to_cpup((uint16_t *)(s->mac_reg + VET)));
574 cpu_to_be16wu((uint16_t *)(tp->vlan_header + 2),
575 le16_to_cpu(dp->upper.fields.special));
576 }
577
578 addr = le64_to_cpu(dp->buffer_addr);
579 if (tp->tse && tp->cptse) {
580 hdr = tp->hdr_len;
581 msh = hdr + tp->mss;
582 do {
583 bytes = split_size;
584 if (tp->size + bytes > msh)
585 bytes = msh - tp->size;
586
587 bytes = MIN(sizeof(tp->data) - tp->size, bytes);
588 pci_dma_read(&s->dev, addr, tp->data + tp->size, bytes);
589 if ((sz = tp->size + bytes) >= hdr && tp->size < hdr)
590 memmove(tp->header, tp->data, hdr);
591 tp->size = sz;
592 addr += bytes;
593 if (sz == msh) {
594 xmit_seg(s);
595 memmove(tp->data, tp->header, hdr);
596 tp->size = hdr;
597 }
598 } while (split_size -= bytes);
599 } else if (!tp->tse && tp->cptse) {
600 // context descriptor TSE is not set, while data descriptor TSE is set
601 DBGOUT(TXERR, "TCP segmentation error\n");
602 } else {
603 split_size = MIN(sizeof(tp->data) - tp->size, split_size);
604 pci_dma_read(&s->dev, addr, tp->data + tp->size, split_size);
605 tp->size += split_size;
606 }
607
608 if (!(txd_lower & E1000_TXD_CMD_EOP))
609 return;
610 if (!(tp->tse && tp->cptse && tp->size < hdr))
611 xmit_seg(s);
612 tp->tso_frames = 0;
613 tp->sum_needed = 0;
614 tp->vlan_needed = 0;
615 tp->size = 0;
616 tp->cptse = 0;
617 }
618
619 static uint32_t
620 txdesc_writeback(E1000State *s, dma_addr_t base, struct e1000_tx_desc *dp)
621 {
622 uint32_t txd_upper, txd_lower = le32_to_cpu(dp->lower.data);
623
624 if (!(txd_lower & (E1000_TXD_CMD_RS|E1000_TXD_CMD_RPS)))
625 return 0;
626 txd_upper = (le32_to_cpu(dp->upper.data) | E1000_TXD_STAT_DD) &
627 ~(E1000_TXD_STAT_EC | E1000_TXD_STAT_LC | E1000_TXD_STAT_TU);
628 dp->upper.data = cpu_to_le32(txd_upper);
629 pci_dma_write(&s->dev, base + ((char *)&dp->upper - (char *)dp),
630 &dp->upper, sizeof(dp->upper));
631 return E1000_ICR_TXDW;
632 }
633
634 static uint64_t tx_desc_base(E1000State *s)
635 {
636 uint64_t bah = s->mac_reg[TDBAH];
637 uint64_t bal = s->mac_reg[TDBAL] & ~0xf;
638
639 return (bah << 32) + bal;
640 }
641
642 static void
643 start_xmit(E1000State *s)
644 {
645 dma_addr_t base;
646 struct e1000_tx_desc desc;
647 uint32_t tdh_start = s->mac_reg[TDH], cause = E1000_ICS_TXQE;
648
649 if (!(s->mac_reg[TCTL] & E1000_TCTL_EN)) {
650 DBGOUT(TX, "tx disabled\n");
651 return;
652 }
653
654 while (s->mac_reg[TDH] != s->mac_reg[TDT]) {
655 base = tx_desc_base(s) +
656 sizeof(struct e1000_tx_desc) * s->mac_reg[TDH];
657 pci_dma_read(&s->dev, base, &desc, sizeof(desc));
658
659 DBGOUT(TX, "index %d: %p : %x %x\n", s->mac_reg[TDH],
660 (void *)(intptr_t)desc.buffer_addr, desc.lower.data,
661 desc.upper.data);
662
663 process_tx_desc(s, &desc);
664 cause |= txdesc_writeback(s, base, &desc);
665
666 if (++s->mac_reg[TDH] * sizeof(desc) >= s->mac_reg[TDLEN])
667 s->mac_reg[TDH] = 0;
668 /*
669 * the following could happen only if guest sw assigns
670 * bogus values to TDT/TDLEN.
671 * there's nothing too intelligent we could do about this.
672 */
673 if (s->mac_reg[TDH] == tdh_start) {
674 DBGOUT(TXERR, "TDH wraparound @%x, TDT %x, TDLEN %x\n",
675 tdh_start, s->mac_reg[TDT], s->mac_reg[TDLEN]);
676 break;
677 }
678 }
679 set_ics(s, 0, cause);
680 }
681
682 static int
683 receive_filter(E1000State *s, const uint8_t *buf, int size)
684 {
685 static const uint8_t bcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
686 static const int mta_shift[] = {4, 3, 2, 0};
687 uint32_t f, rctl = s->mac_reg[RCTL], ra[2], *rp;
688
689 if (is_vlan_packet(s, buf) && vlan_rx_filter_enabled(s)) {
690 uint16_t vid = be16_to_cpup((uint16_t *)(buf + 14));
691 uint32_t vfta = le32_to_cpup((uint32_t *)(s->mac_reg + VFTA) +
692 ((vid >> 5) & 0x7f));
693 if ((vfta & (1 << (vid & 0x1f))) == 0)
694 return 0;
695 }
696
697 if (rctl & E1000_RCTL_UPE) // promiscuous
698 return 1;
699
700 if ((buf[0] & 1) && (rctl & E1000_RCTL_MPE)) // promiscuous mcast
701 return 1;
702
703 if ((rctl & E1000_RCTL_BAM) && !memcmp(buf, bcast, sizeof bcast))
704 return 1;
705
706 for (rp = s->mac_reg + RA; rp < s->mac_reg + RA + 32; rp += 2) {
707 if (!(rp[1] & E1000_RAH_AV))
708 continue;
709 ra[0] = cpu_to_le32(rp[0]);
710 ra[1] = cpu_to_le32(rp[1]);
711 if (!memcmp(buf, (uint8_t *)ra, 6)) {
712 DBGOUT(RXFILTER,
713 "unicast match[%d]: %02x:%02x:%02x:%02x:%02x:%02x\n",
714 (int)(rp - s->mac_reg - RA)/2,
715 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
716 return 1;
717 }
718 }
719 DBGOUT(RXFILTER, "unicast mismatch: %02x:%02x:%02x:%02x:%02x:%02x\n",
720 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
721
722 f = mta_shift[(rctl >> E1000_RCTL_MO_SHIFT) & 3];
723 f = (((buf[5] << 8) | buf[4]) >> f) & 0xfff;
724 if (s->mac_reg[MTA + (f >> 5)] & (1 << (f & 0x1f)))
725 return 1;
726 DBGOUT(RXFILTER,
727 "dropping, inexact filter mismatch: %02x:%02x:%02x:%02x:%02x:%02x MO %d MTA[%d] %x\n",
728 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5],
729 (rctl >> E1000_RCTL_MO_SHIFT) & 3, f >> 5,
730 s->mac_reg[MTA + (f >> 5)]);
731
732 return 0;
733 }
734
735 static void
736 e1000_set_link_status(NetClientState *nc)
737 {
738 E1000State *s = DO_UPCAST(NICState, nc, nc)->opaque;
739 uint32_t old_status = s->mac_reg[STATUS];
740
741 if (nc->link_down) {
742 e1000_link_down(s);
743 } else {
744 e1000_link_up(s);
745 }
746
747 if (s->mac_reg[STATUS] != old_status)
748 set_ics(s, 0, E1000_ICR_LSC);
749 }
750
751 static bool e1000_has_rxbufs(E1000State *s, size_t total_size)
752 {
753 int bufs;
754 /* Fast-path short packets */
755 if (total_size <= s->rxbuf_size) {
756 return s->mac_reg[RDH] != s->mac_reg[RDT];
757 }
758 if (s->mac_reg[RDH] < s->mac_reg[RDT]) {
759 bufs = s->mac_reg[RDT] - s->mac_reg[RDH];
760 } else if (s->mac_reg[RDH] > s->mac_reg[RDT]) {
761 bufs = s->mac_reg[RDLEN] / sizeof(struct e1000_rx_desc) +
762 s->mac_reg[RDT] - s->mac_reg[RDH];
763 } else {
764 return false;
765 }
766 return total_size <= bufs * s->rxbuf_size;
767 }
768
769 static int
770 e1000_can_receive(NetClientState *nc)
771 {
772 E1000State *s = DO_UPCAST(NICState, nc, nc)->opaque;
773
774 return (s->mac_reg[RCTL] & E1000_RCTL_EN) && e1000_has_rxbufs(s, 1);
775 }
776
777 static uint64_t rx_desc_base(E1000State *s)
778 {
779 uint64_t bah = s->mac_reg[RDBAH];
780 uint64_t bal = s->mac_reg[RDBAL] & ~0xf;
781
782 return (bah << 32) + bal;
783 }
784
785 static ssize_t
786 e1000_receive(NetClientState *nc, const uint8_t *buf, size_t size)
787 {
788 E1000State *s = DO_UPCAST(NICState, nc, nc)->opaque;
789 struct e1000_rx_desc desc;
790 dma_addr_t base;
791 unsigned int n, rdt;
792 uint32_t rdh_start;
793 uint16_t vlan_special = 0;
794 uint8_t vlan_status = 0, vlan_offset = 0;
795 uint8_t min_buf[MIN_BUF_SIZE];
796 size_t desc_offset;
797 size_t desc_size;
798 size_t total_size;
799
800 if (!(s->mac_reg[RCTL] & E1000_RCTL_EN))
801 return -1;
802
803 /* Pad to minimum Ethernet frame length */
804 if (size < sizeof(min_buf)) {
805 memcpy(min_buf, buf, size);
806 memset(&min_buf[size], 0, sizeof(min_buf) - size);
807 buf = min_buf;
808 size = sizeof(min_buf);
809 }
810
811 /* Discard oversized packets if !LPE and !SBP. */
812 if (size > MAXIMUM_ETHERNET_VLAN_SIZE
813 && !(s->mac_reg[RCTL] & E1000_RCTL_LPE)
814 && !(s->mac_reg[RCTL] & E1000_RCTL_SBP)) {
815 return size;
816 }
817
818 if (!receive_filter(s, buf, size))
819 return size;
820
821 if (vlan_enabled(s) && is_vlan_packet(s, buf)) {
822 vlan_special = cpu_to_le16(be16_to_cpup((uint16_t *)(buf + 14)));
823 memmove((uint8_t *)buf + 4, buf, 12);
824 vlan_status = E1000_RXD_STAT_VP;
825 vlan_offset = 4;
826 size -= 4;
827 }
828
829 rdh_start = s->mac_reg[RDH];
830 desc_offset = 0;
831 total_size = size + fcs_len(s);
832 if (!e1000_has_rxbufs(s, total_size)) {
833 set_ics(s, 0, E1000_ICS_RXO);
834 return -1;
835 }
836 do {
837 desc_size = total_size - desc_offset;
838 if (desc_size > s->rxbuf_size) {
839 desc_size = s->rxbuf_size;
840 }
841 base = rx_desc_base(s) + sizeof(desc) * s->mac_reg[RDH];
842 pci_dma_read(&s->dev, base, &desc, sizeof(desc));
843 desc.special = vlan_special;
844 desc.status |= (vlan_status | E1000_RXD_STAT_DD);
845 if (desc.buffer_addr) {
846 if (desc_offset < size) {
847 size_t copy_size = size - desc_offset;
848 if (copy_size > s->rxbuf_size) {
849 copy_size = s->rxbuf_size;
850 }
851 pci_dma_write(&s->dev, le64_to_cpu(desc.buffer_addr),
852 buf + desc_offset + vlan_offset, copy_size);
853 }
854 desc_offset += desc_size;
855 desc.length = cpu_to_le16(desc_size);
856 if (desc_offset >= total_size) {
857 desc.status |= E1000_RXD_STAT_EOP | E1000_RXD_STAT_IXSM;
858 } else {
859 /* Guest zeroing out status is not a hardware requirement.
860 Clear EOP in case guest didn't do it. */
861 desc.status &= ~E1000_RXD_STAT_EOP;
862 }
863 } else { // as per intel docs; skip descriptors with null buf addr
864 DBGOUT(RX, "Null RX descriptor!!\n");
865 }
866 pci_dma_write(&s->dev, base, &desc, sizeof(desc));
867
868 if (++s->mac_reg[RDH] * sizeof(desc) >= s->mac_reg[RDLEN])
869 s->mac_reg[RDH] = 0;
870 /* see comment in start_xmit; same here */
871 if (s->mac_reg[RDH] == rdh_start) {
872 DBGOUT(RXERR, "RDH wraparound @%x, RDT %x, RDLEN %x\n",
873 rdh_start, s->mac_reg[RDT], s->mac_reg[RDLEN]);
874 set_ics(s, 0, E1000_ICS_RXO);
875 return -1;
876 }
877 } while (desc_offset < total_size);
878
879 s->mac_reg[GPRC]++;
880 s->mac_reg[TPR]++;
881 /* TOR - Total Octets Received:
882 * This register includes bytes received in a packet from the <Destination
883 * Address> field through the <CRC> field, inclusively.
884 */
885 n = s->mac_reg[TORL] + size + /* Always include FCS length. */ 4;
886 if (n < s->mac_reg[TORL])
887 s->mac_reg[TORH]++;
888 s->mac_reg[TORL] = n;
889
890 n = E1000_ICS_RXT0;
891 if ((rdt = s->mac_reg[RDT]) < s->mac_reg[RDH])
892 rdt += s->mac_reg[RDLEN] / sizeof(desc);
893 if (((rdt - s->mac_reg[RDH]) * sizeof(desc)) <= s->mac_reg[RDLEN] >>
894 s->rxbuf_min_shift)
895 n |= E1000_ICS_RXDMT0;
896
897 set_ics(s, 0, n);
898
899 return size;
900 }
901
902 static uint32_t
903 mac_readreg(E1000State *s, int index)
904 {
905 return s->mac_reg[index];
906 }
907
908 static uint32_t
909 mac_icr_read(E1000State *s, int index)
910 {
911 uint32_t ret = s->mac_reg[ICR];
912
913 DBGOUT(INTERRUPT, "ICR read: %x\n", ret);
914 set_interrupt_cause(s, 0, 0);
915 return ret;
916 }
917
918 static uint32_t
919 mac_read_clr4(E1000State *s, int index)
920 {
921 uint32_t ret = s->mac_reg[index];
922
923 s->mac_reg[index] = 0;
924 return ret;
925 }
926
927 static uint32_t
928 mac_read_clr8(E1000State *s, int index)
929 {
930 uint32_t ret = s->mac_reg[index];
931
932 s->mac_reg[index] = 0;
933 s->mac_reg[index-1] = 0;
934 return ret;
935 }
936
937 static void
938 mac_writereg(E1000State *s, int index, uint32_t val)
939 {
940 s->mac_reg[index] = val;
941 }
942
943 static void
944 set_rdt(E1000State *s, int index, uint32_t val)
945 {
946 s->mac_reg[index] = val & 0xffff;
947 if (e1000_has_rxbufs(s, 1)) {
948 qemu_flush_queued_packets(&s->nic->nc);
949 }
950 }
951
952 static void
953 set_16bit(E1000State *s, int index, uint32_t val)
954 {
955 s->mac_reg[index] = val & 0xffff;
956 }
957
958 static void
959 set_dlen(E1000State *s, int index, uint32_t val)
960 {
961 s->mac_reg[index] = val & 0xfff80;
962 }
963
964 static void
965 set_tctl(E1000State *s, int index, uint32_t val)
966 {
967 s->mac_reg[index] = val;
968 s->mac_reg[TDT] &= 0xffff;
969 start_xmit(s);
970 }
971
972 static void
973 set_icr(E1000State *s, int index, uint32_t val)
974 {
975 DBGOUT(INTERRUPT, "set_icr %x\n", val);
976 set_interrupt_cause(s, 0, s->mac_reg[ICR] & ~val);
977 }
978
979 static void
980 set_imc(E1000State *s, int index, uint32_t val)
981 {
982 s->mac_reg[IMS] &= ~val;
983 set_ics(s, 0, 0);
984 }
985
986 static void
987 set_ims(E1000State *s, int index, uint32_t val)
988 {
989 s->mac_reg[IMS] |= val;
990 set_ics(s, 0, 0);
991 }
992
993 #define getreg(x) [x] = mac_readreg
994 static uint32_t (*macreg_readops[])(E1000State *, int) = {
995 getreg(PBA), getreg(RCTL), getreg(TDH), getreg(TXDCTL),
996 getreg(WUFC), getreg(TDT), getreg(CTRL), getreg(LEDCTL),
997 getreg(MANC), getreg(MDIC), getreg(SWSM), getreg(STATUS),
998 getreg(TORL), getreg(TOTL), getreg(IMS), getreg(TCTL),
999 getreg(RDH), getreg(RDT), getreg(VET), getreg(ICS),
1000 getreg(TDBAL), getreg(TDBAH), getreg(RDBAH), getreg(RDBAL),
1001 getreg(TDLEN), getreg(RDLEN),
1002
1003 [TOTH] = mac_read_clr8, [TORH] = mac_read_clr8, [GPRC] = mac_read_clr4,
1004 [GPTC] = mac_read_clr4, [TPR] = mac_read_clr4, [TPT] = mac_read_clr4,
1005 [ICR] = mac_icr_read, [EECD] = get_eecd, [EERD] = flash_eerd_read,
1006 [CRCERRS ... MPC] = &mac_readreg,
1007 [RA ... RA+31] = &mac_readreg,
1008 [MTA ... MTA+127] = &mac_readreg,
1009 [VFTA ... VFTA+127] = &mac_readreg,
1010 };
1011 enum { NREADOPS = ARRAY_SIZE(macreg_readops) };
1012
1013 #define putreg(x) [x] = mac_writereg
1014 static void (*macreg_writeops[])(E1000State *, int, uint32_t) = {
1015 putreg(PBA), putreg(EERD), putreg(SWSM), putreg(WUFC),
1016 putreg(TDBAL), putreg(TDBAH), putreg(TXDCTL), putreg(RDBAH),
1017 putreg(RDBAL), putreg(LEDCTL), putreg(VET),
1018 [TDLEN] = set_dlen, [RDLEN] = set_dlen, [TCTL] = set_tctl,
1019 [TDT] = set_tctl, [MDIC] = set_mdic, [ICS] = set_ics,
1020 [TDH] = set_16bit, [RDH] = set_16bit, [RDT] = set_rdt,
1021 [IMC] = set_imc, [IMS] = set_ims, [ICR] = set_icr,
1022 [EECD] = set_eecd, [RCTL] = set_rx_control, [CTRL] = set_ctrl,
1023 [RA ... RA+31] = &mac_writereg,
1024 [MTA ... MTA+127] = &mac_writereg,
1025 [VFTA ... VFTA+127] = &mac_writereg,
1026 };
1027
1028 enum { NWRITEOPS = ARRAY_SIZE(macreg_writeops) };
1029
1030 static void
1031 e1000_mmio_write(void *opaque, hwaddr addr, uint64_t val,
1032 unsigned size)
1033 {
1034 E1000State *s = opaque;
1035 unsigned int index = (addr & 0x1ffff) >> 2;
1036
1037 if (index < NWRITEOPS && macreg_writeops[index]) {
1038 macreg_writeops[index](s, index, val);
1039 } else if (index < NREADOPS && macreg_readops[index]) {
1040 DBGOUT(MMIO, "e1000_mmio_writel RO %x: 0x%04"PRIx64"\n", index<<2, val);
1041 } else {
1042 DBGOUT(UNKNOWN, "MMIO unknown write addr=0x%08x,val=0x%08"PRIx64"\n",
1043 index<<2, val);
1044 }
1045 }
1046
1047 static uint64_t
1048 e1000_mmio_read(void *opaque, hwaddr addr, unsigned size)
1049 {
1050 E1000State *s = opaque;
1051 unsigned int index = (addr & 0x1ffff) >> 2;
1052
1053 if (index < NREADOPS && macreg_readops[index])
1054 {
1055 return macreg_readops[index](s, index);
1056 }
1057 DBGOUT(UNKNOWN, "MMIO unknown read addr=0x%08x\n", index<<2);
1058 return 0;
1059 }
1060
1061 static const MemoryRegionOps e1000_mmio_ops = {
1062 .read = e1000_mmio_read,
1063 .write = e1000_mmio_write,
1064 .endianness = DEVICE_LITTLE_ENDIAN,
1065 .impl = {
1066 .min_access_size = 4,
1067 .max_access_size = 4,
1068 },
1069 };
1070
1071 static uint64_t e1000_io_read(void *opaque, hwaddr addr,
1072 unsigned size)
1073 {
1074 E1000State *s = opaque;
1075
1076 (void)s;
1077 return 0;
1078 }
1079
1080 static void e1000_io_write(void *opaque, hwaddr addr,
1081 uint64_t val, unsigned size)
1082 {
1083 E1000State *s = opaque;
1084
1085 (void)s;
1086 }
1087
1088 static const MemoryRegionOps e1000_io_ops = {
1089 .read = e1000_io_read,
1090 .write = e1000_io_write,
1091 .endianness = DEVICE_LITTLE_ENDIAN,
1092 };
1093
1094 static bool is_version_1(void *opaque, int version_id)
1095 {
1096 return version_id == 1;
1097 }
1098
1099 static int e1000_post_load(void *opaque, int version_id)
1100 {
1101 E1000State *s = opaque;
1102
1103 /* nc.link_down can't be migrated, so infer link_down according
1104 * to link status bit in mac_reg[STATUS] */
1105 s->nic->nc.link_down = (s->mac_reg[STATUS] & E1000_STATUS_LU) == 0;
1106
1107 return 0;
1108 }
1109
1110 static const VMStateDescription vmstate_e1000 = {
1111 .name = "e1000",
1112 .version_id = 2,
1113 .minimum_version_id = 1,
1114 .minimum_version_id_old = 1,
1115 .post_load = e1000_post_load,
1116 .fields = (VMStateField []) {
1117 VMSTATE_PCI_DEVICE(dev, E1000State),
1118 VMSTATE_UNUSED_TEST(is_version_1, 4), /* was instance id */
1119 VMSTATE_UNUSED(4), /* Was mmio_base. */
1120 VMSTATE_UINT32(rxbuf_size, E1000State),
1121 VMSTATE_UINT32(rxbuf_min_shift, E1000State),
1122 VMSTATE_UINT32(eecd_state.val_in, E1000State),
1123 VMSTATE_UINT16(eecd_state.bitnum_in, E1000State),
1124 VMSTATE_UINT16(eecd_state.bitnum_out, E1000State),
1125 VMSTATE_UINT16(eecd_state.reading, E1000State),
1126 VMSTATE_UINT32(eecd_state.old_eecd, E1000State),
1127 VMSTATE_UINT8(tx.ipcss, E1000State),
1128 VMSTATE_UINT8(tx.ipcso, E1000State),
1129 VMSTATE_UINT16(tx.ipcse, E1000State),
1130 VMSTATE_UINT8(tx.tucss, E1000State),
1131 VMSTATE_UINT8(tx.tucso, E1000State),
1132 VMSTATE_UINT16(tx.tucse, E1000State),
1133 VMSTATE_UINT32(tx.paylen, E1000State),
1134 VMSTATE_UINT8(tx.hdr_len, E1000State),
1135 VMSTATE_UINT16(tx.mss, E1000State),
1136 VMSTATE_UINT16(tx.size, E1000State),
1137 VMSTATE_UINT16(tx.tso_frames, E1000State),
1138 VMSTATE_UINT8(tx.sum_needed, E1000State),
1139 VMSTATE_INT8(tx.ip, E1000State),
1140 VMSTATE_INT8(tx.tcp, E1000State),
1141 VMSTATE_BUFFER(tx.header, E1000State),
1142 VMSTATE_BUFFER(tx.data, E1000State),
1143 VMSTATE_UINT16_ARRAY(eeprom_data, E1000State, 64),
1144 VMSTATE_UINT16_ARRAY(phy_reg, E1000State, 0x20),
1145 VMSTATE_UINT32(mac_reg[CTRL], E1000State),
1146 VMSTATE_UINT32(mac_reg[EECD], E1000State),
1147 VMSTATE_UINT32(mac_reg[EERD], E1000State),
1148 VMSTATE_UINT32(mac_reg[GPRC], E1000State),
1149 VMSTATE_UINT32(mac_reg[GPTC], E1000State),
1150 VMSTATE_UINT32(mac_reg[ICR], E1000State),
1151 VMSTATE_UINT32(mac_reg[ICS], E1000State),
1152 VMSTATE_UINT32(mac_reg[IMC], E1000State),
1153 VMSTATE_UINT32(mac_reg[IMS], E1000State),
1154 VMSTATE_UINT32(mac_reg[LEDCTL], E1000State),
1155 VMSTATE_UINT32(mac_reg[MANC], E1000State),
1156 VMSTATE_UINT32(mac_reg[MDIC], E1000State),
1157 VMSTATE_UINT32(mac_reg[MPC], E1000State),
1158 VMSTATE_UINT32(mac_reg[PBA], E1000State),
1159 VMSTATE_UINT32(mac_reg[RCTL], E1000State),
1160 VMSTATE_UINT32(mac_reg[RDBAH], E1000State),
1161 VMSTATE_UINT32(mac_reg[RDBAL], E1000State),
1162 VMSTATE_UINT32(mac_reg[RDH], E1000State),
1163 VMSTATE_UINT32(mac_reg[RDLEN], E1000State),
1164 VMSTATE_UINT32(mac_reg[RDT], E1000State),
1165 VMSTATE_UINT32(mac_reg[STATUS], E1000State),
1166 VMSTATE_UINT32(mac_reg[SWSM], E1000State),
1167 VMSTATE_UINT32(mac_reg[TCTL], E1000State),
1168 VMSTATE_UINT32(mac_reg[TDBAH], E1000State),
1169 VMSTATE_UINT32(mac_reg[TDBAL], E1000State),
1170 VMSTATE_UINT32(mac_reg[TDH], E1000State),
1171 VMSTATE_UINT32(mac_reg[TDLEN], E1000State),
1172 VMSTATE_UINT32(mac_reg[TDT], E1000State),
1173 VMSTATE_UINT32(mac_reg[TORH], E1000State),
1174 VMSTATE_UINT32(mac_reg[TORL], E1000State),
1175 VMSTATE_UINT32(mac_reg[TOTH], E1000State),
1176 VMSTATE_UINT32(mac_reg[TOTL], E1000State),
1177 VMSTATE_UINT32(mac_reg[TPR], E1000State),
1178 VMSTATE_UINT32(mac_reg[TPT], E1000State),
1179 VMSTATE_UINT32(mac_reg[TXDCTL], E1000State),
1180 VMSTATE_UINT32(mac_reg[WUFC], E1000State),
1181 VMSTATE_UINT32(mac_reg[VET], E1000State),
1182 VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, RA, 32),
1183 VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, MTA, 128),
1184 VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, VFTA, 128),
1185 VMSTATE_END_OF_LIST()
1186 }
1187 };
1188
1189 static const uint16_t e1000_eeprom_template[64] = {
1190 0x0000, 0x0000, 0x0000, 0x0000, 0xffff, 0x0000, 0x0000, 0x0000,
1191 0x3000, 0x1000, 0x6403, E1000_DEVID, 0x8086, E1000_DEVID, 0x8086, 0x3040,
1192 0x0008, 0x2000, 0x7e14, 0x0048, 0x1000, 0x00d8, 0x0000, 0x2700,
1193 0x6cc9, 0x3150, 0x0722, 0x040b, 0x0984, 0x0000, 0xc000, 0x0706,
1194 0x1008, 0x0000, 0x0f04, 0x7fff, 0x4d01, 0xffff, 0xffff, 0xffff,
1195 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
1196 0x0100, 0x4000, 0x121c, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
1197 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0000,
1198 };
1199
1200 /* PCI interface */
1201
1202 static void
1203 e1000_mmio_setup(E1000State *d)
1204 {
1205 int i;
1206 const uint32_t excluded_regs[] = {
1207 E1000_MDIC, E1000_ICR, E1000_ICS, E1000_IMS,
1208 E1000_IMC, E1000_TCTL, E1000_TDT, PNPMMIO_SIZE
1209 };
1210
1211 memory_region_init_io(&d->mmio, &e1000_mmio_ops, d, "e1000-mmio",
1212 PNPMMIO_SIZE);
1213 memory_region_add_coalescing(&d->mmio, 0, excluded_regs[0]);
1214 for (i = 0; excluded_regs[i] != PNPMMIO_SIZE; i++)
1215 memory_region_add_coalescing(&d->mmio, excluded_regs[i] + 4,
1216 excluded_regs[i+1] - excluded_regs[i] - 4);
1217 memory_region_init_io(&d->io, &e1000_io_ops, d, "e1000-io", IOPORT_SIZE);
1218 }
1219
1220 static void
1221 e1000_cleanup(NetClientState *nc)
1222 {
1223 E1000State *s = DO_UPCAST(NICState, nc, nc)->opaque;
1224
1225 s->nic = NULL;
1226 }
1227
1228 static void
1229 pci_e1000_uninit(PCIDevice *dev)
1230 {
1231 E1000State *d = DO_UPCAST(E1000State, dev, dev);
1232
1233 qemu_del_timer(d->autoneg_timer);
1234 qemu_free_timer(d->autoneg_timer);
1235 memory_region_destroy(&d->mmio);
1236 memory_region_destroy(&d->io);
1237 qemu_del_net_client(&d->nic->nc);
1238 }
1239
1240 static NetClientInfo net_e1000_info = {
1241 .type = NET_CLIENT_OPTIONS_KIND_NIC,
1242 .size = sizeof(NICState),
1243 .can_receive = e1000_can_receive,
1244 .receive = e1000_receive,
1245 .cleanup = e1000_cleanup,
1246 .link_status_changed = e1000_set_link_status,
1247 };
1248
1249 static int pci_e1000_init(PCIDevice *pci_dev)
1250 {
1251 E1000State *d = DO_UPCAST(E1000State, dev, pci_dev);
1252 uint8_t *pci_conf;
1253 uint16_t checksum = 0;
1254 int i;
1255 uint8_t *macaddr;
1256
1257 pci_conf = d->dev.config;
1258
1259 /* TODO: RST# value should be 0, PCI spec 6.2.4 */
1260 pci_conf[PCI_CACHE_LINE_SIZE] = 0x10;
1261
1262 pci_conf[PCI_INTERRUPT_PIN] = 1; /* interrupt pin A */
1263
1264 e1000_mmio_setup(d);
1265
1266 pci_register_bar(&d->dev, 0, PCI_BASE_ADDRESS_SPACE_MEMORY, &d->mmio);
1267
1268 pci_register_bar(&d->dev, 1, PCI_BASE_ADDRESS_SPACE_IO, &d->io);
1269
1270 memmove(d->eeprom_data, e1000_eeprom_template,
1271 sizeof e1000_eeprom_template);
1272 qemu_macaddr_default_if_unset(&d->conf.macaddr);
1273 macaddr = d->conf.macaddr.a;
1274 for (i = 0; i < 3; i++)
1275 d->eeprom_data[i] = (macaddr[2*i+1]<<8) | macaddr[2*i];
1276 for (i = 0; i < EEPROM_CHECKSUM_REG; i++)
1277 checksum += d->eeprom_data[i];
1278 checksum = (uint16_t) EEPROM_SUM - checksum;
1279 d->eeprom_data[EEPROM_CHECKSUM_REG] = checksum;
1280
1281 d->nic = qemu_new_nic(&net_e1000_info, &d->conf,
1282 object_get_typename(OBJECT(d)), d->dev.qdev.id, d);
1283
1284 qemu_format_nic_info_str(&d->nic->nc, macaddr);
1285
1286 add_boot_device_path(d->conf.bootindex, &pci_dev->qdev, "/ethernet-phy@0");
1287
1288 d->autoneg_timer = qemu_new_timer_ms(vm_clock, e1000_autoneg_timer, d);
1289
1290 return 0;
1291 }
1292
1293 static void qdev_e1000_reset(DeviceState *dev)
1294 {
1295 E1000State *d = DO_UPCAST(E1000State, dev.qdev, dev);
1296 e1000_reset(d);
1297 }
1298
1299 static Property e1000_properties[] = {
1300 DEFINE_NIC_PROPERTIES(E1000State, conf),
1301 DEFINE_PROP_END_OF_LIST(),
1302 };
1303
1304 static void e1000_class_init(ObjectClass *klass, void *data)
1305 {
1306 DeviceClass *dc = DEVICE_CLASS(klass);
1307 PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
1308
1309 k->init = pci_e1000_init;
1310 k->exit = pci_e1000_uninit;
1311 k->romfile = "pxe-e1000.rom";
1312 k->vendor_id = PCI_VENDOR_ID_INTEL;
1313 k->device_id = E1000_DEVID;
1314 k->revision = 0x03;
1315 k->class_id = PCI_CLASS_NETWORK_ETHERNET;
1316 dc->desc = "Intel Gigabit Ethernet";
1317 dc->reset = qdev_e1000_reset;
1318 dc->vmsd = &vmstate_e1000;
1319 dc->props = e1000_properties;
1320 }
1321
1322 static TypeInfo e1000_info = {
1323 .name = "e1000",
1324 .parent = TYPE_PCI_DEVICE,
1325 .instance_size = sizeof(E1000State),
1326 .class_init = e1000_class_init,
1327 };
1328
1329 static void e1000_register_types(void)
1330 {
1331 type_register_static(&e1000_info);
1332 }
1333
1334 type_init(e1000_register_types)
Qemu copy for testing