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