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