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