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