1 /* 2 * QEMU e1000 emulation 3 * 4 * Software developer's manual: 5 * http://download.intel.com/design/network/manuals/8254x_GBe_SDM.pdf 6 * 7 * Nir Peleg, Tutis Systems Ltd. for Qumranet Inc. 8 * Copyright (c) 2008 Qumranet 9 * Based on work done by: 10 * Copyright (c) 2007 Dan Aloni 11 * Copyright (c) 2004 Antony T Curtis 12 * 13 * This library is free software; you can redistribute it and/or 14 * modify it under the terms of the GNU Lesser General Public 15 * License as published by the Free Software Foundation; either 16 * version 2 of the License, or (at your option) any later version. 17 * 18 * This library is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 21 * Lesser General Public License for more details. 22 * 23 * You should have received a copy of the GNU Lesser General Public 24 * License along with this library; if not, see <http://www.gnu.org/licenses/>. 25 */ 26 27 28 #include "qemu/osdep.h" 29 #include "hw/hw.h" 30 #include "hw/pci/pci.h" 31 #include "net/net.h" 32 #include "net/checksum.h" 33 #include "hw/loader.h" 34 #include "sysemu/sysemu.h" 35 #include "sysemu/dma.h" 36 #include "qemu/iov.h" 37 #include "qemu/range.h" 38 39 #include "e1000_regs.h" 40 41 static const uint8_t bcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; 42 43 #define E1000_DEBUG 44 45 #ifdef E1000_DEBUG 46 enum { 47 DEBUG_GENERAL, DEBUG_IO, DEBUG_MMIO, DEBUG_INTERRUPT, 48 DEBUG_RX, DEBUG_TX, DEBUG_MDIC, DEBUG_EEPROM, 49 DEBUG_UNKNOWN, DEBUG_TXSUM, DEBUG_TXERR, DEBUG_RXERR, 50 DEBUG_RXFILTER, DEBUG_PHY, DEBUG_NOTYET, 51 }; 52 #define DBGBIT(x) (1<<DEBUG_##x) 53 static int debugflags = DBGBIT(TXERR) | DBGBIT(GENERAL); 54 55 #define DBGOUT(what, fmt, ...) do { \ 56 if (debugflags & DBGBIT(what)) \ 57 fprintf(stderr, "e1000: " fmt, ## __VA_ARGS__); \ 58 } while (0) 59 #else 60 #define DBGOUT(what, fmt, ...) do {} while (0) 61 #endif 62 63 #define IOPORT_SIZE 0x40 64 #define PNPMMIO_SIZE 0x20000 65 #define MIN_BUF_SIZE 60 /* Min. octets in an ethernet frame sans FCS */ 66 67 /* this is the size past which hardware will drop packets when setting LPE=0 */ 68 #define MAXIMUM_ETHERNET_VLAN_SIZE 1522 69 /* this is the size past which hardware will drop packets when setting LPE=1 */ 70 #define MAXIMUM_ETHERNET_LPE_SIZE 16384 71 72 #define MAXIMUM_ETHERNET_HDR_LEN (14+4) 73 74 /* 75 * HW models: 76 * E1000_DEV_ID_82540EM works with Windows, Linux, and OS X <= 10.8 77 * E1000_DEV_ID_82544GC_COPPER appears to work; not well tested 78 * E1000_DEV_ID_82545EM_COPPER works with Linux and OS X >= 10.6 79 * Others never tested 80 */ 81 82 typedef struct E1000State_st { 83 /*< private >*/ 84 PCIDevice parent_obj; 85 /*< public >*/ 86 87 NICState *nic; 88 NICConf conf; 89 MemoryRegion mmio; 90 MemoryRegion io; 91 92 uint32_t mac_reg[0x8000]; 93 uint16_t phy_reg[0x20]; 94 uint16_t eeprom_data[64]; 95 96 uint32_t rxbuf_size; 97 uint32_t rxbuf_min_shift; 98 struct e1000_tx { 99 unsigned char header[256]; 100 unsigned char vlan_header[4]; 101 /* Fields vlan and data must not be reordered or separated. */ 102 unsigned char vlan[4]; 103 unsigned char data[0x10000]; 104 uint16_t size; 105 unsigned char sum_needed; 106 unsigned char vlan_needed; 107 uint8_t ipcss; 108 uint8_t ipcso; 109 uint16_t ipcse; 110 uint8_t tucss; 111 uint8_t tucso; 112 uint16_t tucse; 113 uint8_t hdr_len; 114 uint16_t mss; 115 uint32_t paylen; 116 uint16_t tso_frames; 117 char tse; 118 int8_t ip; 119 int8_t tcp; 120 char cptse; // current packet tse bit 121 } tx; 122 123 struct { 124 uint32_t val_in; /* shifted in from guest driver */ 125 uint16_t bitnum_in; 126 uint16_t bitnum_out; 127 uint16_t reading; 128 uint32_t old_eecd; 129 } eecd_state; 130 131 QEMUTimer *autoneg_timer; 132 133 QEMUTimer *mit_timer; /* Mitigation timer. */ 134 bool mit_timer_on; /* Mitigation timer is running. */ 135 bool mit_irq_level; /* Tracks interrupt pin level. */ 136 uint32_t mit_ide; /* Tracks E1000_TXD_CMD_IDE bit. */ 137 138 /* Compatibility flags for migration to/from qemu 1.3.0 and older */ 139 #define E1000_FLAG_AUTONEG_BIT 0 140 #define E1000_FLAG_MIT_BIT 1 141 #define E1000_FLAG_MAC_BIT 2 142 #define E1000_FLAG_AUTONEG (1 << E1000_FLAG_AUTONEG_BIT) 143 #define E1000_FLAG_MIT (1 << E1000_FLAG_MIT_BIT) 144 #define E1000_FLAG_MAC (1 << E1000_FLAG_MAC_BIT) 145 uint32_t compat_flags; 146 } E1000State; 147 148 #define chkflag(x) (s->compat_flags & E1000_FLAG_##x) 149 150 typedef struct E1000BaseClass { 151 PCIDeviceClass parent_class; 152 uint16_t phy_id2; 153 } E1000BaseClass; 154 155 #define TYPE_E1000_BASE "e1000-base" 156 157 #define E1000(obj) \ 158 OBJECT_CHECK(E1000State, (obj), TYPE_E1000_BASE) 159 160 #define E1000_DEVICE_CLASS(klass) \ 161 OBJECT_CLASS_CHECK(E1000BaseClass, (klass), TYPE_E1000_BASE) 162 #define E1000_DEVICE_GET_CLASS(obj) \ 163 OBJECT_GET_CLASS(E1000BaseClass, (obj), TYPE_E1000_BASE) 164 165 #define defreg(x) x = (E1000_##x>>2) 166 enum { 167 defreg(CTRL), defreg(EECD), defreg(EERD), defreg(GPRC), 168 defreg(GPTC), defreg(ICR), defreg(ICS), defreg(IMC), 169 defreg(IMS), defreg(LEDCTL), defreg(MANC), defreg(MDIC), 170 defreg(MPC), defreg(PBA), defreg(RCTL), defreg(RDBAH), 171 defreg(RDBAL), defreg(RDH), defreg(RDLEN), defreg(RDT), 172 defreg(STATUS), defreg(SWSM), defreg(TCTL), defreg(TDBAH), 173 defreg(TDBAL), defreg(TDH), defreg(TDLEN), defreg(TDT), 174 defreg(TORH), defreg(TORL), defreg(TOTH), defreg(TOTL), 175 defreg(TPR), defreg(TPT), defreg(TXDCTL), defreg(WUFC), 176 defreg(RA), defreg(MTA), defreg(CRCERRS), defreg(VFTA), 177 defreg(VET), defreg(RDTR), defreg(RADV), defreg(TADV), 178 defreg(ITR), defreg(FCRUC), defreg(TDFH), defreg(TDFT), 179 defreg(TDFHS), defreg(TDFTS), defreg(TDFPC), defreg(RDFH), 180 defreg(RDFT), defreg(RDFHS), defreg(RDFTS), defreg(RDFPC), 181 defreg(IPAV), defreg(WUC), defreg(WUS), defreg(AIT), 182 defreg(IP6AT), defreg(IP4AT), defreg(FFLT), defreg(FFMT), 183 defreg(FFVT), defreg(WUPM), defreg(PBM), defreg(SCC), 184 defreg(ECOL), defreg(MCC), defreg(LATECOL), defreg(COLC), 185 defreg(DC), defreg(TNCRS), defreg(SEC), defreg(CEXTERR), 186 defreg(RLEC), defreg(XONRXC), defreg(XONTXC), defreg(XOFFRXC), 187 defreg(XOFFTXC), defreg(RFC), defreg(RJC), defreg(RNBC), 188 defreg(TSCTFC), defreg(MGTPRC), defreg(MGTPDC), defreg(MGTPTC), 189 defreg(RUC), defreg(ROC), defreg(GORCL), defreg(GORCH), 190 defreg(GOTCL), defreg(GOTCH), defreg(BPRC), defreg(MPRC), 191 defreg(TSCTC), defreg(PRC64), defreg(PRC127), defreg(PRC255), 192 defreg(PRC511), defreg(PRC1023), defreg(PRC1522), defreg(PTC64), 193 defreg(PTC127), defreg(PTC255), defreg(PTC511), defreg(PTC1023), 194 defreg(PTC1522), defreg(MPTC), defreg(BPTC) 195 }; 196 197 static void 198 e1000_link_down(E1000State *s) 199 { 200 s->mac_reg[STATUS] &= ~E1000_STATUS_LU; 201 s->phy_reg[PHY_STATUS] &= ~MII_SR_LINK_STATUS; 202 s->phy_reg[PHY_STATUS] &= ~MII_SR_AUTONEG_COMPLETE; 203 s->phy_reg[PHY_LP_ABILITY] &= ~MII_LPAR_LPACK; 204 } 205 206 static void 207 e1000_link_up(E1000State *s) 208 { 209 s->mac_reg[STATUS] |= E1000_STATUS_LU; 210 s->phy_reg[PHY_STATUS] |= MII_SR_LINK_STATUS; 211 212 /* E1000_STATUS_LU is tested by e1000_can_receive() */ 213 qemu_flush_queued_packets(qemu_get_queue(s->nic)); 214 } 215 216 static bool 217 have_autoneg(E1000State *s) 218 { 219 return chkflag(AUTONEG) && (s->phy_reg[PHY_CTRL] & MII_CR_AUTO_NEG_EN); 220 } 221 222 static void 223 set_phy_ctrl(E1000State *s, int index, uint16_t val) 224 { 225 /* bits 0-5 reserved; MII_CR_[RESTART_AUTO_NEG,RESET] are self clearing */ 226 s->phy_reg[PHY_CTRL] = val & ~(0x3f | 227 MII_CR_RESET | 228 MII_CR_RESTART_AUTO_NEG); 229 230 /* 231 * QEMU 1.3 does not support link auto-negotiation emulation, so if we 232 * migrate during auto negotiation, after migration the link will be 233 * down. 234 */ 235 if (have_autoneg(s) && (val & MII_CR_RESTART_AUTO_NEG)) { 236 e1000_link_down(s); 237 DBGOUT(PHY, "Start link auto negotiation\n"); 238 timer_mod(s->autoneg_timer, 239 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 500); 240 } 241 } 242 243 static void (*phyreg_writeops[])(E1000State *, int, uint16_t) = { 244 [PHY_CTRL] = set_phy_ctrl, 245 }; 246 247 enum { NPHYWRITEOPS = ARRAY_SIZE(phyreg_writeops) }; 248 249 enum { PHY_R = 1, PHY_W = 2, PHY_RW = PHY_R | PHY_W }; 250 static const char phy_regcap[0x20] = { 251 [PHY_STATUS] = PHY_R, [M88E1000_EXT_PHY_SPEC_CTRL] = PHY_RW, 252 [PHY_ID1] = PHY_R, [M88E1000_PHY_SPEC_CTRL] = PHY_RW, 253 [PHY_CTRL] = PHY_RW, [PHY_1000T_CTRL] = PHY_RW, 254 [PHY_LP_ABILITY] = PHY_R, [PHY_1000T_STATUS] = PHY_R, 255 [PHY_AUTONEG_ADV] = PHY_RW, [M88E1000_RX_ERR_CNTR] = PHY_R, 256 [PHY_ID2] = PHY_R, [M88E1000_PHY_SPEC_STATUS] = PHY_R, 257 [PHY_AUTONEG_EXP] = PHY_R, 258 }; 259 260 /* PHY_ID2 documented in 8254x_GBe_SDM.pdf, pp. 250 */ 261 static const uint16_t phy_reg_init[] = { 262 [PHY_CTRL] = MII_CR_SPEED_SELECT_MSB | 263 MII_CR_FULL_DUPLEX | 264 MII_CR_AUTO_NEG_EN, 265 266 [PHY_STATUS] = MII_SR_EXTENDED_CAPS | 267 MII_SR_LINK_STATUS | /* link initially up */ 268 MII_SR_AUTONEG_CAPS | 269 /* MII_SR_AUTONEG_COMPLETE: initially NOT completed */ 270 MII_SR_PREAMBLE_SUPPRESS | 271 MII_SR_EXTENDED_STATUS | 272 MII_SR_10T_HD_CAPS | 273 MII_SR_10T_FD_CAPS | 274 MII_SR_100X_HD_CAPS | 275 MII_SR_100X_FD_CAPS, 276 277 [PHY_ID1] = 0x141, 278 /* [PHY_ID2] configured per DevId, from e1000_reset() */ 279 [PHY_AUTONEG_ADV] = 0xde1, 280 [PHY_LP_ABILITY] = 0x1e0, 281 [PHY_1000T_CTRL] = 0x0e00, 282 [PHY_1000T_STATUS] = 0x3c00, 283 [M88E1000_PHY_SPEC_CTRL] = 0x360, 284 [M88E1000_PHY_SPEC_STATUS] = 0xac00, 285 [M88E1000_EXT_PHY_SPEC_CTRL] = 0x0d60, 286 }; 287 288 static const uint32_t mac_reg_init[] = { 289 [PBA] = 0x00100030, 290 [LEDCTL] = 0x602, 291 [CTRL] = E1000_CTRL_SWDPIN2 | E1000_CTRL_SWDPIN0 | 292 E1000_CTRL_SPD_1000 | E1000_CTRL_SLU, 293 [STATUS] = 0x80000000 | E1000_STATUS_GIO_MASTER_ENABLE | 294 E1000_STATUS_ASDV | E1000_STATUS_MTXCKOK | 295 E1000_STATUS_SPEED_1000 | E1000_STATUS_FD | 296 E1000_STATUS_LU, 297 [MANC] = E1000_MANC_EN_MNG2HOST | E1000_MANC_RCV_TCO_EN | 298 E1000_MANC_ARP_EN | E1000_MANC_0298_EN | 299 E1000_MANC_RMCP_EN, 300 }; 301 302 /* Helper function, *curr == 0 means the value is not set */ 303 static inline void 304 mit_update_delay(uint32_t *curr, uint32_t value) 305 { 306 if (value && (*curr == 0 || value < *curr)) { 307 *curr = value; 308 } 309 } 310 311 static void 312 set_interrupt_cause(E1000State *s, int index, uint32_t val) 313 { 314 PCIDevice *d = PCI_DEVICE(s); 315 uint32_t pending_ints; 316 uint32_t mit_delay; 317 318 s->mac_reg[ICR] = val; 319 320 /* 321 * Make sure ICR and ICS registers have the same value. 322 * The spec says that the ICS register is write-only. However in practice, 323 * on real hardware ICS is readable, and for reads it has the same value as 324 * ICR (except that ICS does not have the clear on read behaviour of ICR). 325 * 326 * The VxWorks PRO/1000 driver uses this behaviour. 327 */ 328 s->mac_reg[ICS] = val; 329 330 pending_ints = (s->mac_reg[IMS] & s->mac_reg[ICR]); 331 if (!s->mit_irq_level && pending_ints) { 332 /* 333 * Here we detect a potential raising edge. We postpone raising the 334 * interrupt line if we are inside the mitigation delay window 335 * (s->mit_timer_on == 1). 336 * We provide a partial implementation of interrupt mitigation, 337 * emulating only RADV, TADV and ITR (lower 16 bits, 1024ns units for 338 * RADV and TADV, 256ns units for ITR). RDTR is only used to enable 339 * RADV; relative timers based on TIDV and RDTR are not implemented. 340 */ 341 if (s->mit_timer_on) { 342 return; 343 } 344 if (chkflag(MIT)) { 345 /* Compute the next mitigation delay according to pending 346 * interrupts and the current values of RADV (provided 347 * RDTR!=0), TADV and ITR. 348 * Then rearm the timer. 349 */ 350 mit_delay = 0; 351 if (s->mit_ide && 352 (pending_ints & (E1000_ICR_TXQE | E1000_ICR_TXDW))) { 353 mit_update_delay(&mit_delay, s->mac_reg[TADV] * 4); 354 } 355 if (s->mac_reg[RDTR] && (pending_ints & E1000_ICS_RXT0)) { 356 mit_update_delay(&mit_delay, s->mac_reg[RADV] * 4); 357 } 358 mit_update_delay(&mit_delay, s->mac_reg[ITR]); 359 360 /* 361 * According to e1000 SPEC, the Ethernet controller guarantees 362 * a maximum observable interrupt rate of 7813 interrupts/sec. 363 * Thus if mit_delay < 500 then the delay should be set to the 364 * minimum delay possible which is 500. 365 */ 366 mit_delay = (mit_delay < 500) ? 500 : mit_delay; 367 368 if (mit_delay) { 369 s->mit_timer_on = 1; 370 timer_mod(s->mit_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + 371 mit_delay * 256); 372 } 373 s->mit_ide = 0; 374 } 375 } 376 377 s->mit_irq_level = (pending_ints != 0); 378 pci_set_irq(d, s->mit_irq_level); 379 } 380 381 static void 382 e1000_mit_timer(void *opaque) 383 { 384 E1000State *s = opaque; 385 386 s->mit_timer_on = 0; 387 /* Call set_interrupt_cause to update the irq level (if necessary). */ 388 set_interrupt_cause(s, 0, s->mac_reg[ICR]); 389 } 390 391 static void 392 set_ics(E1000State *s, int index, uint32_t val) 393 { 394 DBGOUT(INTERRUPT, "set_ics %x, ICR %x, IMR %x\n", val, s->mac_reg[ICR], 395 s->mac_reg[IMS]); 396 set_interrupt_cause(s, 0, val | s->mac_reg[ICR]); 397 } 398 399 static void 400 e1000_autoneg_timer(void *opaque) 401 { 402 E1000State *s = opaque; 403 if (!qemu_get_queue(s->nic)->link_down) { 404 e1000_link_up(s); 405 s->phy_reg[PHY_LP_ABILITY] |= MII_LPAR_LPACK; 406 s->phy_reg[PHY_STATUS] |= MII_SR_AUTONEG_COMPLETE; 407 DBGOUT(PHY, "Auto negotiation is completed\n"); 408 set_ics(s, 0, E1000_ICS_LSC); /* signal link status change to guest */ 409 } 410 } 411 412 static int 413 rxbufsize(uint32_t v) 414 { 415 v &= E1000_RCTL_BSEX | E1000_RCTL_SZ_16384 | E1000_RCTL_SZ_8192 | 416 E1000_RCTL_SZ_4096 | E1000_RCTL_SZ_2048 | E1000_RCTL_SZ_1024 | 417 E1000_RCTL_SZ_512 | E1000_RCTL_SZ_256; 418 switch (v) { 419 case E1000_RCTL_BSEX | E1000_RCTL_SZ_16384: 420 return 16384; 421 case E1000_RCTL_BSEX | E1000_RCTL_SZ_8192: 422 return 8192; 423 case E1000_RCTL_BSEX | E1000_RCTL_SZ_4096: 424 return 4096; 425 case E1000_RCTL_SZ_1024: 426 return 1024; 427 case E1000_RCTL_SZ_512: 428 return 512; 429 case E1000_RCTL_SZ_256: 430 return 256; 431 } 432 return 2048; 433 } 434 435 static void e1000_reset(void *opaque) 436 { 437 E1000State *d = opaque; 438 E1000BaseClass *edc = E1000_DEVICE_GET_CLASS(d); 439 uint8_t *macaddr = d->conf.macaddr.a; 440 int i; 441 442 timer_del(d->autoneg_timer); 443 timer_del(d->mit_timer); 444 d->mit_timer_on = 0; 445 d->mit_irq_level = 0; 446 d->mit_ide = 0; 447 memset(d->phy_reg, 0, sizeof d->phy_reg); 448 memmove(d->phy_reg, phy_reg_init, sizeof phy_reg_init); 449 d->phy_reg[PHY_ID2] = edc->phy_id2; 450 memset(d->mac_reg, 0, sizeof d->mac_reg); 451 memmove(d->mac_reg, mac_reg_init, sizeof mac_reg_init); 452 d->rxbuf_min_shift = 1; 453 memset(&d->tx, 0, sizeof d->tx); 454 455 if (qemu_get_queue(d->nic)->link_down) { 456 e1000_link_down(d); 457 } 458 459 /* Some guests expect pre-initialized RAH/RAL (AddrValid flag + MACaddr) */ 460 d->mac_reg[RA] = 0; 461 d->mac_reg[RA + 1] = E1000_RAH_AV; 462 for (i = 0; i < 4; i++) { 463 d->mac_reg[RA] |= macaddr[i] << (8 * i); 464 d->mac_reg[RA + 1] |= (i < 2) ? macaddr[i + 4] << (8 * i) : 0; 465 } 466 qemu_format_nic_info_str(qemu_get_queue(d->nic), macaddr); 467 } 468 469 static void 470 set_ctrl(E1000State *s, int index, uint32_t val) 471 { 472 /* RST is self clearing */ 473 s->mac_reg[CTRL] = val & ~E1000_CTRL_RST; 474 } 475 476 static void 477 set_rx_control(E1000State *s, int index, uint32_t val) 478 { 479 s->mac_reg[RCTL] = val; 480 s->rxbuf_size = rxbufsize(val); 481 s->rxbuf_min_shift = ((val / E1000_RCTL_RDMTS_QUAT) & 3) + 1; 482 DBGOUT(RX, "RCTL: %d, mac_reg[RCTL] = 0x%x\n", s->mac_reg[RDT], 483 s->mac_reg[RCTL]); 484 qemu_flush_queued_packets(qemu_get_queue(s->nic)); 485 } 486 487 static void 488 set_mdic(E1000State *s, int index, uint32_t val) 489 { 490 uint32_t data = val & E1000_MDIC_DATA_MASK; 491 uint32_t addr = ((val & E1000_MDIC_REG_MASK) >> E1000_MDIC_REG_SHIFT); 492 493 if ((val & E1000_MDIC_PHY_MASK) >> E1000_MDIC_PHY_SHIFT != 1) // phy # 494 val = s->mac_reg[MDIC] | E1000_MDIC_ERROR; 495 else if (val & E1000_MDIC_OP_READ) { 496 DBGOUT(MDIC, "MDIC read reg 0x%x\n", addr); 497 if (!(phy_regcap[addr] & PHY_R)) { 498 DBGOUT(MDIC, "MDIC read reg %x unhandled\n", addr); 499 val |= E1000_MDIC_ERROR; 500 } else 501 val = (val ^ data) | s->phy_reg[addr]; 502 } else if (val & E1000_MDIC_OP_WRITE) { 503 DBGOUT(MDIC, "MDIC write reg 0x%x, value 0x%x\n", addr, data); 504 if (!(phy_regcap[addr] & PHY_W)) { 505 DBGOUT(MDIC, "MDIC write reg %x unhandled\n", addr); 506 val |= E1000_MDIC_ERROR; 507 } else { 508 if (addr < NPHYWRITEOPS && phyreg_writeops[addr]) { 509 phyreg_writeops[addr](s, index, data); 510 } else { 511 s->phy_reg[addr] = data; 512 } 513 } 514 } 515 s->mac_reg[MDIC] = val | E1000_MDIC_READY; 516 517 if (val & E1000_MDIC_INT_EN) { 518 set_ics(s, 0, E1000_ICR_MDAC); 519 } 520 } 521 522 static uint32_t 523 get_eecd(E1000State *s, int index) 524 { 525 uint32_t ret = E1000_EECD_PRES|E1000_EECD_GNT | s->eecd_state.old_eecd; 526 527 DBGOUT(EEPROM, "reading eeprom bit %d (reading %d)\n", 528 s->eecd_state.bitnum_out, s->eecd_state.reading); 529 if (!s->eecd_state.reading || 530 ((s->eeprom_data[(s->eecd_state.bitnum_out >> 4) & 0x3f] >> 531 ((s->eecd_state.bitnum_out & 0xf) ^ 0xf))) & 1) 532 ret |= E1000_EECD_DO; 533 return ret; 534 } 535 536 static void 537 set_eecd(E1000State *s, int index, uint32_t val) 538 { 539 uint32_t oldval = s->eecd_state.old_eecd; 540 541 s->eecd_state.old_eecd = val & (E1000_EECD_SK | E1000_EECD_CS | 542 E1000_EECD_DI|E1000_EECD_FWE_MASK|E1000_EECD_REQ); 543 if (!(E1000_EECD_CS & val)) { /* CS inactive; nothing to do */ 544 return; 545 } 546 if (E1000_EECD_CS & (val ^ oldval)) { /* CS rise edge; reset state */ 547 s->eecd_state.val_in = 0; 548 s->eecd_state.bitnum_in = 0; 549 s->eecd_state.bitnum_out = 0; 550 s->eecd_state.reading = 0; 551 } 552 if (!(E1000_EECD_SK & (val ^ oldval))) { /* no clock edge */ 553 return; 554 } 555 if (!(E1000_EECD_SK & val)) { /* falling edge */ 556 s->eecd_state.bitnum_out++; 557 return; 558 } 559 s->eecd_state.val_in <<= 1; 560 if (val & E1000_EECD_DI) 561 s->eecd_state.val_in |= 1; 562 if (++s->eecd_state.bitnum_in == 9 && !s->eecd_state.reading) { 563 s->eecd_state.bitnum_out = ((s->eecd_state.val_in & 0x3f)<<4)-1; 564 s->eecd_state.reading = (((s->eecd_state.val_in >> 6) & 7) == 565 EEPROM_READ_OPCODE_MICROWIRE); 566 } 567 DBGOUT(EEPROM, "eeprom bitnum in %d out %d, reading %d\n", 568 s->eecd_state.bitnum_in, s->eecd_state.bitnum_out, 569 s->eecd_state.reading); 570 } 571 572 static uint32_t 573 flash_eerd_read(E1000State *s, int x) 574 { 575 unsigned int index, r = s->mac_reg[EERD] & ~E1000_EEPROM_RW_REG_START; 576 577 if ((s->mac_reg[EERD] & E1000_EEPROM_RW_REG_START) == 0) 578 return (s->mac_reg[EERD]); 579 580 if ((index = r >> E1000_EEPROM_RW_ADDR_SHIFT) > EEPROM_CHECKSUM_REG) 581 return (E1000_EEPROM_RW_REG_DONE | r); 582 583 return ((s->eeprom_data[index] << E1000_EEPROM_RW_REG_DATA) | 584 E1000_EEPROM_RW_REG_DONE | r); 585 } 586 587 static void 588 putsum(uint8_t *data, uint32_t n, uint32_t sloc, uint32_t css, uint32_t cse) 589 { 590 uint32_t sum; 591 592 if (cse && cse < n) 593 n = cse + 1; 594 if (sloc < n-1) { 595 sum = net_checksum_add(n-css, data+css); 596 stw_be_p(data + sloc, net_checksum_finish(sum)); 597 } 598 } 599 600 static inline void 601 inc_reg_if_not_full(E1000State *s, int index) 602 { 603 if (s->mac_reg[index] != 0xffffffff) { 604 s->mac_reg[index]++; 605 } 606 } 607 608 static inline void 609 inc_tx_bcast_or_mcast_count(E1000State *s, const unsigned char *arr) 610 { 611 if (!memcmp(arr, bcast, sizeof bcast)) { 612 inc_reg_if_not_full(s, BPTC); 613 } else if (arr[0] & 1) { 614 inc_reg_if_not_full(s, MPTC); 615 } 616 } 617 618 static void 619 grow_8reg_if_not_full(E1000State *s, int index, int size) 620 { 621 uint64_t sum = s->mac_reg[index] | (uint64_t)s->mac_reg[index+1] << 32; 622 623 if (sum + size < sum) { 624 sum = ~0ULL; 625 } else { 626 sum += size; 627 } 628 s->mac_reg[index] = sum; 629 s->mac_reg[index+1] = sum >> 32; 630 } 631 632 static void 633 increase_size_stats(E1000State *s, const int *size_regs, int size) 634 { 635 if (size > 1023) { 636 inc_reg_if_not_full(s, size_regs[5]); 637 } else if (size > 511) { 638 inc_reg_if_not_full(s, size_regs[4]); 639 } else if (size > 255) { 640 inc_reg_if_not_full(s, size_regs[3]); 641 } else if (size > 127) { 642 inc_reg_if_not_full(s, size_regs[2]); 643 } else if (size > 64) { 644 inc_reg_if_not_full(s, size_regs[1]); 645 } else if (size == 64) { 646 inc_reg_if_not_full(s, size_regs[0]); 647 } 648 } 649 650 static inline int 651 vlan_enabled(E1000State *s) 652 { 653 return ((s->mac_reg[CTRL] & E1000_CTRL_VME) != 0); 654 } 655 656 static inline int 657 vlan_rx_filter_enabled(E1000State *s) 658 { 659 return ((s->mac_reg[RCTL] & E1000_RCTL_VFE) != 0); 660 } 661 662 static inline int 663 is_vlan_packet(E1000State *s, const uint8_t *buf) 664 { 665 return (be16_to_cpup((uint16_t *)(buf + 12)) == 666 le16_to_cpu(s->mac_reg[VET])); 667 } 668 669 static inline int 670 is_vlan_txd(uint32_t txd_lower) 671 { 672 return ((txd_lower & E1000_TXD_CMD_VLE) != 0); 673 } 674 675 /* FCS aka Ethernet CRC-32. We don't get it from backends and can't 676 * fill it in, just pad descriptor length by 4 bytes unless guest 677 * told us to strip it off the packet. */ 678 static inline int 679 fcs_len(E1000State *s) 680 { 681 return (s->mac_reg[RCTL] & E1000_RCTL_SECRC) ? 0 : 4; 682 } 683 684 static void 685 e1000_send_packet(E1000State *s, const uint8_t *buf, int size) 686 { 687 static const int PTCregs[6] = { PTC64, PTC127, PTC255, PTC511, 688 PTC1023, PTC1522 }; 689 690 NetClientState *nc = qemu_get_queue(s->nic); 691 if (s->phy_reg[PHY_CTRL] & MII_CR_LOOPBACK) { 692 nc->info->receive(nc, buf, size); 693 } else { 694 qemu_send_packet(nc, buf, size); 695 } 696 inc_tx_bcast_or_mcast_count(s, buf); 697 increase_size_stats(s, PTCregs, size); 698 } 699 700 static void 701 xmit_seg(E1000State *s) 702 { 703 uint16_t len, *sp; 704 unsigned int frames = s->tx.tso_frames, css, sofar; 705 struct e1000_tx *tp = &s->tx; 706 707 if (tp->tse && tp->cptse) { 708 css = tp->ipcss; 709 DBGOUT(TXSUM, "frames %d size %d ipcss %d\n", 710 frames, tp->size, css); 711 if (tp->ip) { /* IPv4 */ 712 stw_be_p(tp->data+css+2, tp->size - css); 713 stw_be_p(tp->data+css+4, 714 be16_to_cpup((uint16_t *)(tp->data+css+4))+frames); 715 } else { /* IPv6 */ 716 stw_be_p(tp->data+css+4, tp->size - css); 717 } 718 css = tp->tucss; 719 len = tp->size - css; 720 DBGOUT(TXSUM, "tcp %d tucss %d len %d\n", tp->tcp, css, len); 721 if (tp->tcp) { 722 sofar = frames * tp->mss; 723 stl_be_p(tp->data+css+4, ldl_be_p(tp->data+css+4)+sofar); /* seq */ 724 if (tp->paylen - sofar > tp->mss) { 725 tp->data[css + 13] &= ~9; /* PSH, FIN */ 726 } else if (frames) { 727 inc_reg_if_not_full(s, TSCTC); 728 } 729 } else /* UDP */ 730 stw_be_p(tp->data+css+4, len); 731 if (tp->sum_needed & E1000_TXD_POPTS_TXSM) { 732 unsigned int phsum; 733 // add pseudo-header length before checksum calculation 734 sp = (uint16_t *)(tp->data + tp->tucso); 735 phsum = be16_to_cpup(sp) + len; 736 phsum = (phsum >> 16) + (phsum & 0xffff); 737 stw_be_p(sp, phsum); 738 } 739 tp->tso_frames++; 740 } 741 742 if (tp->sum_needed & E1000_TXD_POPTS_TXSM) 743 putsum(tp->data, tp->size, tp->tucso, tp->tucss, tp->tucse); 744 if (tp->sum_needed & E1000_TXD_POPTS_IXSM) 745 putsum(tp->data, tp->size, tp->ipcso, tp->ipcss, tp->ipcse); 746 if (tp->vlan_needed) { 747 memmove(tp->vlan, tp->data, 4); 748 memmove(tp->data, tp->data + 4, 8); 749 memcpy(tp->data + 8, tp->vlan_header, 4); 750 e1000_send_packet(s, tp->vlan, tp->size + 4); 751 } else { 752 e1000_send_packet(s, tp->data, tp->size); 753 } 754 755 inc_reg_if_not_full(s, TPT); 756 grow_8reg_if_not_full(s, TOTL, s->tx.size); 757 s->mac_reg[GPTC] = s->mac_reg[TPT]; 758 s->mac_reg[GOTCL] = s->mac_reg[TOTL]; 759 s->mac_reg[GOTCH] = s->mac_reg[TOTH]; 760 } 761 762 static void 763 process_tx_desc(E1000State *s, struct e1000_tx_desc *dp) 764 { 765 PCIDevice *d = PCI_DEVICE(s); 766 uint32_t txd_lower = le32_to_cpu(dp->lower.data); 767 uint32_t dtype = txd_lower & (E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D); 768 unsigned int split_size = txd_lower & 0xffff, bytes, sz, op; 769 unsigned int msh = 0xfffff; 770 uint64_t addr; 771 struct e1000_context_desc *xp = (struct e1000_context_desc *)dp; 772 struct e1000_tx *tp = &s->tx; 773 774 s->mit_ide |= (txd_lower & E1000_TXD_CMD_IDE); 775 if (dtype == E1000_TXD_CMD_DEXT) { /* context descriptor */ 776 op = le32_to_cpu(xp->cmd_and_length); 777 tp->ipcss = xp->lower_setup.ip_fields.ipcss; 778 tp->ipcso = xp->lower_setup.ip_fields.ipcso; 779 tp->ipcse = le16_to_cpu(xp->lower_setup.ip_fields.ipcse); 780 tp->tucss = xp->upper_setup.tcp_fields.tucss; 781 tp->tucso = xp->upper_setup.tcp_fields.tucso; 782 tp->tucse = le16_to_cpu(xp->upper_setup.tcp_fields.tucse); 783 tp->paylen = op & 0xfffff; 784 tp->hdr_len = xp->tcp_seg_setup.fields.hdr_len; 785 tp->mss = le16_to_cpu(xp->tcp_seg_setup.fields.mss); 786 tp->ip = (op & E1000_TXD_CMD_IP) ? 1 : 0; 787 tp->tcp = (op & E1000_TXD_CMD_TCP) ? 1 : 0; 788 tp->tse = (op & E1000_TXD_CMD_TSE) ? 1 : 0; 789 tp->tso_frames = 0; 790 if (tp->tucso == 0) { /* this is probably wrong */ 791 DBGOUT(TXSUM, "TCP/UDP: cso 0!\n"); 792 tp->tucso = tp->tucss + (tp->tcp ? 16 : 6); 793 } 794 return; 795 } else if (dtype == (E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D)) { 796 // data descriptor 797 if (tp->size == 0) { 798 tp->sum_needed = le32_to_cpu(dp->upper.data) >> 8; 799 } 800 tp->cptse = ( txd_lower & E1000_TXD_CMD_TSE ) ? 1 : 0; 801 } else { 802 // legacy descriptor 803 tp->cptse = 0; 804 } 805 806 if (vlan_enabled(s) && is_vlan_txd(txd_lower) && 807 (tp->cptse || txd_lower & E1000_TXD_CMD_EOP)) { 808 tp->vlan_needed = 1; 809 stw_be_p(tp->vlan_header, 810 le16_to_cpu(s->mac_reg[VET])); 811 stw_be_p(tp->vlan_header + 2, 812 le16_to_cpu(dp->upper.fields.special)); 813 } 814 815 addr = le64_to_cpu(dp->buffer_addr); 816 if (tp->tse && tp->cptse) { 817 msh = tp->hdr_len + tp->mss; 818 do { 819 bytes = split_size; 820 if (tp->size + bytes > msh) 821 bytes = msh - tp->size; 822 823 bytes = MIN(sizeof(tp->data) - tp->size, bytes); 824 pci_dma_read(d, addr, tp->data + tp->size, bytes); 825 sz = tp->size + bytes; 826 if (sz >= tp->hdr_len && tp->size < tp->hdr_len) { 827 memmove(tp->header, tp->data, tp->hdr_len); 828 } 829 tp->size = sz; 830 addr += bytes; 831 if (sz == msh) { 832 xmit_seg(s); 833 memmove(tp->data, tp->header, tp->hdr_len); 834 tp->size = tp->hdr_len; 835 } 836 split_size -= bytes; 837 } while (bytes && split_size); 838 } else if (!tp->tse && tp->cptse) { 839 // context descriptor TSE is not set, while data descriptor TSE is set 840 DBGOUT(TXERR, "TCP segmentation error\n"); 841 } else { 842 split_size = MIN(sizeof(tp->data) - tp->size, split_size); 843 pci_dma_read(d, addr, tp->data + tp->size, split_size); 844 tp->size += split_size; 845 } 846 847 if (!(txd_lower & E1000_TXD_CMD_EOP)) 848 return; 849 if (!(tp->tse && tp->cptse && tp->size < tp->hdr_len)) { 850 xmit_seg(s); 851 } 852 tp->tso_frames = 0; 853 tp->sum_needed = 0; 854 tp->vlan_needed = 0; 855 tp->size = 0; 856 tp->cptse = 0; 857 } 858 859 static uint32_t 860 txdesc_writeback(E1000State *s, dma_addr_t base, struct e1000_tx_desc *dp) 861 { 862 PCIDevice *d = PCI_DEVICE(s); 863 uint32_t txd_upper, txd_lower = le32_to_cpu(dp->lower.data); 864 865 if (!(txd_lower & (E1000_TXD_CMD_RS|E1000_TXD_CMD_RPS))) 866 return 0; 867 txd_upper = (le32_to_cpu(dp->upper.data) | E1000_TXD_STAT_DD) & 868 ~(E1000_TXD_STAT_EC | E1000_TXD_STAT_LC | E1000_TXD_STAT_TU); 869 dp->upper.data = cpu_to_le32(txd_upper); 870 pci_dma_write(d, base + ((char *)&dp->upper - (char *)dp), 871 &dp->upper, sizeof(dp->upper)); 872 return E1000_ICR_TXDW; 873 } 874 875 static uint64_t tx_desc_base(E1000State *s) 876 { 877 uint64_t bah = s->mac_reg[TDBAH]; 878 uint64_t bal = s->mac_reg[TDBAL] & ~0xf; 879 880 return (bah << 32) + bal; 881 } 882 883 static void 884 start_xmit(E1000State *s) 885 { 886 PCIDevice *d = PCI_DEVICE(s); 887 dma_addr_t base; 888 struct e1000_tx_desc desc; 889 uint32_t tdh_start = s->mac_reg[TDH], cause = E1000_ICS_TXQE; 890 891 if (!(s->mac_reg[TCTL] & E1000_TCTL_EN)) { 892 DBGOUT(TX, "tx disabled\n"); 893 return; 894 } 895 896 while (s->mac_reg[TDH] != s->mac_reg[TDT]) { 897 base = tx_desc_base(s) + 898 sizeof(struct e1000_tx_desc) * s->mac_reg[TDH]; 899 pci_dma_read(d, base, &desc, sizeof(desc)); 900 901 DBGOUT(TX, "index %d: %p : %x %x\n", s->mac_reg[TDH], 902 (void *)(intptr_t)desc.buffer_addr, desc.lower.data, 903 desc.upper.data); 904 905 process_tx_desc(s, &desc); 906 cause |= txdesc_writeback(s, base, &desc); 907 908 if (++s->mac_reg[TDH] * sizeof(desc) >= s->mac_reg[TDLEN]) 909 s->mac_reg[TDH] = 0; 910 /* 911 * the following could happen only if guest sw assigns 912 * bogus values to TDT/TDLEN. 913 * there's nothing too intelligent we could do about this. 914 */ 915 if (s->mac_reg[TDH] == tdh_start || 916 tdh_start >= s->mac_reg[TDLEN] / sizeof(desc)) { 917 DBGOUT(TXERR, "TDH wraparound @%x, TDT %x, TDLEN %x\n", 918 tdh_start, s->mac_reg[TDT], s->mac_reg[TDLEN]); 919 break; 920 } 921 } 922 set_ics(s, 0, cause); 923 } 924 925 static int 926 receive_filter(E1000State *s, const uint8_t *buf, int size) 927 { 928 static const int mta_shift[] = {4, 3, 2, 0}; 929 uint32_t f, rctl = s->mac_reg[RCTL], ra[2], *rp; 930 int isbcast = !memcmp(buf, bcast, sizeof bcast), ismcast = (buf[0] & 1); 931 932 if (is_vlan_packet(s, buf) && vlan_rx_filter_enabled(s)) { 933 uint16_t vid = be16_to_cpup((uint16_t *)(buf + 14)); 934 uint32_t vfta = le32_to_cpup((uint32_t *)(s->mac_reg + VFTA) + 935 ((vid >> 5) & 0x7f)); 936 if ((vfta & (1 << (vid & 0x1f))) == 0) 937 return 0; 938 } 939 940 if (!isbcast && !ismcast && (rctl & E1000_RCTL_UPE)) { /* promiscuous ucast */ 941 return 1; 942 } 943 944 if (ismcast && (rctl & E1000_RCTL_MPE)) { /* promiscuous mcast */ 945 inc_reg_if_not_full(s, MPRC); 946 return 1; 947 } 948 949 if (isbcast && (rctl & E1000_RCTL_BAM)) { /* broadcast enabled */ 950 inc_reg_if_not_full(s, BPRC); 951 return 1; 952 } 953 954 for (rp = s->mac_reg + RA; rp < s->mac_reg + RA + 32; rp += 2) { 955 if (!(rp[1] & E1000_RAH_AV)) 956 continue; 957 ra[0] = cpu_to_le32(rp[0]); 958 ra[1] = cpu_to_le32(rp[1]); 959 if (!memcmp(buf, (uint8_t *)ra, 6)) { 960 DBGOUT(RXFILTER, 961 "unicast match[%d]: %02x:%02x:%02x:%02x:%02x:%02x\n", 962 (int)(rp - s->mac_reg - RA)/2, 963 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]); 964 return 1; 965 } 966 } 967 DBGOUT(RXFILTER, "unicast mismatch: %02x:%02x:%02x:%02x:%02x:%02x\n", 968 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]); 969 970 f = mta_shift[(rctl >> E1000_RCTL_MO_SHIFT) & 3]; 971 f = (((buf[5] << 8) | buf[4]) >> f) & 0xfff; 972 if (s->mac_reg[MTA + (f >> 5)] & (1 << (f & 0x1f))) { 973 inc_reg_if_not_full(s, MPRC); 974 return 1; 975 } 976 DBGOUT(RXFILTER, 977 "dropping, inexact filter mismatch: %02x:%02x:%02x:%02x:%02x:%02x MO %d MTA[%d] %x\n", 978 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], 979 (rctl >> E1000_RCTL_MO_SHIFT) & 3, f >> 5, 980 s->mac_reg[MTA + (f >> 5)]); 981 982 return 0; 983 } 984 985 static void 986 e1000_set_link_status(NetClientState *nc) 987 { 988 E1000State *s = qemu_get_nic_opaque(nc); 989 uint32_t old_status = s->mac_reg[STATUS]; 990 991 if (nc->link_down) { 992 e1000_link_down(s); 993 } else { 994 if (have_autoneg(s) && 995 !(s->phy_reg[PHY_STATUS] & MII_SR_AUTONEG_COMPLETE)) { 996 /* emulate auto-negotiation if supported */ 997 timer_mod(s->autoneg_timer, 998 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 500); 999 } else { 1000 e1000_link_up(s); 1001 } 1002 } 1003 1004 if (s->mac_reg[STATUS] != old_status) 1005 set_ics(s, 0, E1000_ICR_LSC); 1006 } 1007 1008 static bool e1000_has_rxbufs(E1000State *s, size_t total_size) 1009 { 1010 int bufs; 1011 /* Fast-path short packets */ 1012 if (total_size <= s->rxbuf_size) { 1013 return s->mac_reg[RDH] != s->mac_reg[RDT]; 1014 } 1015 if (s->mac_reg[RDH] < s->mac_reg[RDT]) { 1016 bufs = s->mac_reg[RDT] - s->mac_reg[RDH]; 1017 } else if (s->mac_reg[RDH] > s->mac_reg[RDT]) { 1018 bufs = s->mac_reg[RDLEN] / sizeof(struct e1000_rx_desc) + 1019 s->mac_reg[RDT] - s->mac_reg[RDH]; 1020 } else { 1021 return false; 1022 } 1023 return total_size <= bufs * s->rxbuf_size; 1024 } 1025 1026 static int 1027 e1000_can_receive(NetClientState *nc) 1028 { 1029 E1000State *s = qemu_get_nic_opaque(nc); 1030 1031 return (s->mac_reg[STATUS] & E1000_STATUS_LU) && 1032 (s->mac_reg[RCTL] & E1000_RCTL_EN) && 1033 (s->parent_obj.config[PCI_COMMAND] & PCI_COMMAND_MASTER) && 1034 e1000_has_rxbufs(s, 1); 1035 } 1036 1037 static uint64_t rx_desc_base(E1000State *s) 1038 { 1039 uint64_t bah = s->mac_reg[RDBAH]; 1040 uint64_t bal = s->mac_reg[RDBAL] & ~0xf; 1041 1042 return (bah << 32) + bal; 1043 } 1044 1045 static ssize_t 1046 e1000_receive_iov(NetClientState *nc, const struct iovec *iov, int iovcnt) 1047 { 1048 E1000State *s = qemu_get_nic_opaque(nc); 1049 PCIDevice *d = PCI_DEVICE(s); 1050 struct e1000_rx_desc desc; 1051 dma_addr_t base; 1052 unsigned int n, rdt; 1053 uint32_t rdh_start; 1054 uint16_t vlan_special = 0; 1055 uint8_t vlan_status = 0; 1056 uint8_t min_buf[MIN_BUF_SIZE]; 1057 struct iovec min_iov; 1058 uint8_t *filter_buf = iov->iov_base; 1059 size_t size = iov_size(iov, iovcnt); 1060 size_t iov_ofs = 0; 1061 size_t desc_offset; 1062 size_t desc_size; 1063 size_t total_size; 1064 static const int PRCregs[6] = { PRC64, PRC127, PRC255, PRC511, 1065 PRC1023, PRC1522 }; 1066 1067 if (!(s->mac_reg[STATUS] & E1000_STATUS_LU)) { 1068 return -1; 1069 } 1070 1071 if (!(s->mac_reg[RCTL] & E1000_RCTL_EN)) { 1072 return -1; 1073 } 1074 1075 /* Pad to minimum Ethernet frame length */ 1076 if (size < sizeof(min_buf)) { 1077 iov_to_buf(iov, iovcnt, 0, min_buf, size); 1078 memset(&min_buf[size], 0, sizeof(min_buf) - size); 1079 inc_reg_if_not_full(s, RUC); 1080 min_iov.iov_base = filter_buf = min_buf; 1081 min_iov.iov_len = size = sizeof(min_buf); 1082 iovcnt = 1; 1083 iov = &min_iov; 1084 } else if (iov->iov_len < MAXIMUM_ETHERNET_HDR_LEN) { 1085 /* This is very unlikely, but may happen. */ 1086 iov_to_buf(iov, iovcnt, 0, min_buf, MAXIMUM_ETHERNET_HDR_LEN); 1087 filter_buf = min_buf; 1088 } 1089 1090 /* Discard oversized packets if !LPE and !SBP. */ 1091 if ((size > MAXIMUM_ETHERNET_LPE_SIZE || 1092 (size > MAXIMUM_ETHERNET_VLAN_SIZE 1093 && !(s->mac_reg[RCTL] & E1000_RCTL_LPE))) 1094 && !(s->mac_reg[RCTL] & E1000_RCTL_SBP)) { 1095 inc_reg_if_not_full(s, ROC); 1096 return size; 1097 } 1098 1099 if (!receive_filter(s, filter_buf, size)) { 1100 return size; 1101 } 1102 1103 if (vlan_enabled(s) && is_vlan_packet(s, filter_buf)) { 1104 vlan_special = cpu_to_le16(be16_to_cpup((uint16_t *)(filter_buf 1105 + 14))); 1106 iov_ofs = 4; 1107 if (filter_buf == iov->iov_base) { 1108 memmove(filter_buf + 4, filter_buf, 12); 1109 } else { 1110 iov_from_buf(iov, iovcnt, 4, filter_buf, 12); 1111 while (iov->iov_len <= iov_ofs) { 1112 iov_ofs -= iov->iov_len; 1113 iov++; 1114 } 1115 } 1116 vlan_status = E1000_RXD_STAT_VP; 1117 size -= 4; 1118 } 1119 1120 rdh_start = s->mac_reg[RDH]; 1121 desc_offset = 0; 1122 total_size = size + fcs_len(s); 1123 if (!e1000_has_rxbufs(s, total_size)) { 1124 set_ics(s, 0, E1000_ICS_RXO); 1125 return -1; 1126 } 1127 do { 1128 desc_size = total_size - desc_offset; 1129 if (desc_size > s->rxbuf_size) { 1130 desc_size = s->rxbuf_size; 1131 } 1132 base = rx_desc_base(s) + sizeof(desc) * s->mac_reg[RDH]; 1133 pci_dma_read(d, base, &desc, sizeof(desc)); 1134 desc.special = vlan_special; 1135 desc.status |= (vlan_status | E1000_RXD_STAT_DD); 1136 if (desc.buffer_addr) { 1137 if (desc_offset < size) { 1138 size_t iov_copy; 1139 hwaddr ba = le64_to_cpu(desc.buffer_addr); 1140 size_t copy_size = size - desc_offset; 1141 if (copy_size > s->rxbuf_size) { 1142 copy_size = s->rxbuf_size; 1143 } 1144 do { 1145 iov_copy = MIN(copy_size, iov->iov_len - iov_ofs); 1146 pci_dma_write(d, ba, iov->iov_base + iov_ofs, iov_copy); 1147 copy_size -= iov_copy; 1148 ba += iov_copy; 1149 iov_ofs += iov_copy; 1150 if (iov_ofs == iov->iov_len) { 1151 iov++; 1152 iov_ofs = 0; 1153 } 1154 } while (copy_size); 1155 } 1156 desc_offset += desc_size; 1157 desc.length = cpu_to_le16(desc_size); 1158 if (desc_offset >= total_size) { 1159 desc.status |= E1000_RXD_STAT_EOP | E1000_RXD_STAT_IXSM; 1160 } else { 1161 /* Guest zeroing out status is not a hardware requirement. 1162 Clear EOP in case guest didn't do it. */ 1163 desc.status &= ~E1000_RXD_STAT_EOP; 1164 } 1165 } else { // as per intel docs; skip descriptors with null buf addr 1166 DBGOUT(RX, "Null RX descriptor!!\n"); 1167 } 1168 pci_dma_write(d, base, &desc, sizeof(desc)); 1169 1170 if (++s->mac_reg[RDH] * sizeof(desc) >= s->mac_reg[RDLEN]) 1171 s->mac_reg[RDH] = 0; 1172 /* see comment in start_xmit; same here */ 1173 if (s->mac_reg[RDH] == rdh_start || 1174 rdh_start >= s->mac_reg[RDLEN] / sizeof(desc)) { 1175 DBGOUT(RXERR, "RDH wraparound @%x, RDT %x, RDLEN %x\n", 1176 rdh_start, s->mac_reg[RDT], s->mac_reg[RDLEN]); 1177 set_ics(s, 0, E1000_ICS_RXO); 1178 return -1; 1179 } 1180 } while (desc_offset < total_size); 1181 1182 increase_size_stats(s, PRCregs, total_size); 1183 inc_reg_if_not_full(s, TPR); 1184 s->mac_reg[GPRC] = s->mac_reg[TPR]; 1185 /* TOR - Total Octets Received: 1186 * This register includes bytes received in a packet from the <Destination 1187 * Address> field through the <CRC> field, inclusively. 1188 * Always include FCS length (4) in size. 1189 */ 1190 grow_8reg_if_not_full(s, TORL, size+4); 1191 s->mac_reg[GORCL] = s->mac_reg[TORL]; 1192 s->mac_reg[GORCH] = s->mac_reg[TORH]; 1193 1194 n = E1000_ICS_RXT0; 1195 if ((rdt = s->mac_reg[RDT]) < s->mac_reg[RDH]) 1196 rdt += s->mac_reg[RDLEN] / sizeof(desc); 1197 if (((rdt - s->mac_reg[RDH]) * sizeof(desc)) <= s->mac_reg[RDLEN] >> 1198 s->rxbuf_min_shift) 1199 n |= E1000_ICS_RXDMT0; 1200 1201 set_ics(s, 0, n); 1202 1203 return size; 1204 } 1205 1206 static ssize_t 1207 e1000_receive(NetClientState *nc, const uint8_t *buf, size_t size) 1208 { 1209 const struct iovec iov = { 1210 .iov_base = (uint8_t *)buf, 1211 .iov_len = size 1212 }; 1213 1214 return e1000_receive_iov(nc, &iov, 1); 1215 } 1216 1217 static uint32_t 1218 mac_readreg(E1000State *s, int index) 1219 { 1220 return s->mac_reg[index]; 1221 } 1222 1223 static uint32_t 1224 mac_low4_read(E1000State *s, int index) 1225 { 1226 return s->mac_reg[index] & 0xf; 1227 } 1228 1229 static uint32_t 1230 mac_low11_read(E1000State *s, int index) 1231 { 1232 return s->mac_reg[index] & 0x7ff; 1233 } 1234 1235 static uint32_t 1236 mac_low13_read(E1000State *s, int index) 1237 { 1238 return s->mac_reg[index] & 0x1fff; 1239 } 1240 1241 static uint32_t 1242 mac_low16_read(E1000State *s, int index) 1243 { 1244 return s->mac_reg[index] & 0xffff; 1245 } 1246 1247 static uint32_t 1248 mac_icr_read(E1000State *s, int index) 1249 { 1250 uint32_t ret = s->mac_reg[ICR]; 1251 1252 DBGOUT(INTERRUPT, "ICR read: %x\n", ret); 1253 set_interrupt_cause(s, 0, 0); 1254 return ret; 1255 } 1256 1257 static uint32_t 1258 mac_read_clr4(E1000State *s, int index) 1259 { 1260 uint32_t ret = s->mac_reg[index]; 1261 1262 s->mac_reg[index] = 0; 1263 return ret; 1264 } 1265 1266 static uint32_t 1267 mac_read_clr8(E1000State *s, int index) 1268 { 1269 uint32_t ret = s->mac_reg[index]; 1270 1271 s->mac_reg[index] = 0; 1272 s->mac_reg[index-1] = 0; 1273 return ret; 1274 } 1275 1276 static void 1277 mac_writereg(E1000State *s, int index, uint32_t val) 1278 { 1279 uint32_t macaddr[2]; 1280 1281 s->mac_reg[index] = val; 1282 1283 if (index == RA + 1) { 1284 macaddr[0] = cpu_to_le32(s->mac_reg[RA]); 1285 macaddr[1] = cpu_to_le32(s->mac_reg[RA + 1]); 1286 qemu_format_nic_info_str(qemu_get_queue(s->nic), (uint8_t *)macaddr); 1287 } 1288 } 1289 1290 static void 1291 set_rdt(E1000State *s, int index, uint32_t val) 1292 { 1293 s->mac_reg[index] = val & 0xffff; 1294 if (e1000_has_rxbufs(s, 1)) { 1295 qemu_flush_queued_packets(qemu_get_queue(s->nic)); 1296 } 1297 } 1298 1299 static void 1300 set_16bit(E1000State *s, int index, uint32_t val) 1301 { 1302 s->mac_reg[index] = val & 0xffff; 1303 } 1304 1305 static void 1306 set_dlen(E1000State *s, int index, uint32_t val) 1307 { 1308 s->mac_reg[index] = val & 0xfff80; 1309 } 1310 1311 static void 1312 set_tctl(E1000State *s, int index, uint32_t val) 1313 { 1314 s->mac_reg[index] = val; 1315 s->mac_reg[TDT] &= 0xffff; 1316 start_xmit(s); 1317 } 1318 1319 static void 1320 set_icr(E1000State *s, int index, uint32_t val) 1321 { 1322 DBGOUT(INTERRUPT, "set_icr %x\n", val); 1323 set_interrupt_cause(s, 0, s->mac_reg[ICR] & ~val); 1324 } 1325 1326 static void 1327 set_imc(E1000State *s, int index, uint32_t val) 1328 { 1329 s->mac_reg[IMS] &= ~val; 1330 set_ics(s, 0, 0); 1331 } 1332 1333 static void 1334 set_ims(E1000State *s, int index, uint32_t val) 1335 { 1336 s->mac_reg[IMS] |= val; 1337 set_ics(s, 0, 0); 1338 } 1339 1340 #define getreg(x) [x] = mac_readreg 1341 static uint32_t (*macreg_readops[])(E1000State *, int) = { 1342 getreg(PBA), getreg(RCTL), getreg(TDH), getreg(TXDCTL), 1343 getreg(WUFC), getreg(TDT), getreg(CTRL), getreg(LEDCTL), 1344 getreg(MANC), getreg(MDIC), getreg(SWSM), getreg(STATUS), 1345 getreg(TORL), getreg(TOTL), getreg(IMS), getreg(TCTL), 1346 getreg(RDH), getreg(RDT), getreg(VET), getreg(ICS), 1347 getreg(TDBAL), getreg(TDBAH), getreg(RDBAH), getreg(RDBAL), 1348 getreg(TDLEN), getreg(RDLEN), getreg(RDTR), getreg(RADV), 1349 getreg(TADV), getreg(ITR), getreg(FCRUC), getreg(IPAV), 1350 getreg(WUC), getreg(WUS), getreg(SCC), getreg(ECOL), 1351 getreg(MCC), getreg(LATECOL), getreg(COLC), getreg(DC), 1352 getreg(TNCRS), getreg(SEC), getreg(CEXTERR), getreg(RLEC), 1353 getreg(XONRXC), getreg(XONTXC), getreg(XOFFRXC), getreg(XOFFTXC), 1354 getreg(RFC), getreg(RJC), getreg(RNBC), getreg(TSCTFC), 1355 getreg(MGTPRC), getreg(MGTPDC), getreg(MGTPTC), getreg(GORCL), 1356 getreg(GOTCL), 1357 1358 [TOTH] = mac_read_clr8, [TORH] = mac_read_clr8, 1359 [GOTCH] = mac_read_clr8, [GORCH] = mac_read_clr8, 1360 [PRC64] = mac_read_clr4, [PRC127] = mac_read_clr4, 1361 [PRC255] = mac_read_clr4, [PRC511] = mac_read_clr4, 1362 [PRC1023] = mac_read_clr4, [PRC1522] = mac_read_clr4, 1363 [PTC64] = mac_read_clr4, [PTC127] = mac_read_clr4, 1364 [PTC255] = mac_read_clr4, [PTC511] = mac_read_clr4, 1365 [PTC1023] = mac_read_clr4, [PTC1522] = mac_read_clr4, 1366 [GPRC] = mac_read_clr4, [GPTC] = mac_read_clr4, 1367 [TPT] = mac_read_clr4, [TPR] = mac_read_clr4, 1368 [RUC] = mac_read_clr4, [ROC] = mac_read_clr4, 1369 [BPRC] = mac_read_clr4, [MPRC] = mac_read_clr4, 1370 [TSCTC] = mac_read_clr4, [BPTC] = mac_read_clr4, 1371 [MPTC] = mac_read_clr4, 1372 [ICR] = mac_icr_read, [EECD] = get_eecd, 1373 [EERD] = flash_eerd_read, 1374 [RDFH] = mac_low13_read, [RDFT] = mac_low13_read, 1375 [RDFHS] = mac_low13_read, [RDFTS] = mac_low13_read, 1376 [RDFPC] = mac_low13_read, 1377 [TDFH] = mac_low11_read, [TDFT] = mac_low11_read, 1378 [TDFHS] = mac_low13_read, [TDFTS] = mac_low13_read, 1379 [TDFPC] = mac_low13_read, 1380 [AIT] = mac_low16_read, 1381 1382 [CRCERRS ... MPC] = &mac_readreg, 1383 [IP6AT ... IP6AT+3] = &mac_readreg, [IP4AT ... IP4AT+6] = &mac_readreg, 1384 [FFLT ... FFLT+6] = &mac_low11_read, 1385 [RA ... RA+31] = &mac_readreg, 1386 [WUPM ... WUPM+31] = &mac_readreg, 1387 [MTA ... MTA+127] = &mac_readreg, 1388 [VFTA ... VFTA+127] = &mac_readreg, 1389 [FFMT ... FFMT+254] = &mac_low4_read, 1390 [FFVT ... FFVT+254] = &mac_readreg, 1391 [PBM ... PBM+16383] = &mac_readreg, 1392 }; 1393 enum { NREADOPS = ARRAY_SIZE(macreg_readops) }; 1394 1395 #define putreg(x) [x] = mac_writereg 1396 static void (*macreg_writeops[])(E1000State *, int, uint32_t) = { 1397 putreg(PBA), putreg(EERD), putreg(SWSM), putreg(WUFC), 1398 putreg(TDBAL), putreg(TDBAH), putreg(TXDCTL), putreg(RDBAH), 1399 putreg(RDBAL), putreg(LEDCTL), putreg(VET), putreg(FCRUC), 1400 putreg(TDFH), putreg(TDFT), putreg(TDFHS), putreg(TDFTS), 1401 putreg(TDFPC), putreg(RDFH), putreg(RDFT), putreg(RDFHS), 1402 putreg(RDFTS), putreg(RDFPC), putreg(IPAV), putreg(WUC), 1403 putreg(WUS), putreg(AIT), 1404 1405 [TDLEN] = set_dlen, [RDLEN] = set_dlen, [TCTL] = set_tctl, 1406 [TDT] = set_tctl, [MDIC] = set_mdic, [ICS] = set_ics, 1407 [TDH] = set_16bit, [RDH] = set_16bit, [RDT] = set_rdt, 1408 [IMC] = set_imc, [IMS] = set_ims, [ICR] = set_icr, 1409 [EECD] = set_eecd, [RCTL] = set_rx_control, [CTRL] = set_ctrl, 1410 [RDTR] = set_16bit, [RADV] = set_16bit, [TADV] = set_16bit, 1411 [ITR] = set_16bit, 1412 1413 [IP6AT ... IP6AT+3] = &mac_writereg, [IP4AT ... IP4AT+6] = &mac_writereg, 1414 [FFLT ... FFLT+6] = &mac_writereg, 1415 [RA ... RA+31] = &mac_writereg, 1416 [WUPM ... WUPM+31] = &mac_writereg, 1417 [MTA ... MTA+127] = &mac_writereg, 1418 [VFTA ... VFTA+127] = &mac_writereg, 1419 [FFMT ... FFMT+254] = &mac_writereg, [FFVT ... FFVT+254] = &mac_writereg, 1420 [PBM ... PBM+16383] = &mac_writereg, 1421 }; 1422 1423 enum { NWRITEOPS = ARRAY_SIZE(macreg_writeops) }; 1424 1425 enum { MAC_ACCESS_PARTIAL = 1, MAC_ACCESS_FLAG_NEEDED = 2 }; 1426 1427 #define markflag(x) ((E1000_FLAG_##x << 2) | MAC_ACCESS_FLAG_NEEDED) 1428 /* In the array below the meaning of the bits is: [f|f|f|f|f|f|n|p] 1429 * f - flag bits (up to 6 possible flags) 1430 * n - flag needed 1431 * p - partially implenented */ 1432 static const uint8_t mac_reg_access[0x8000] = { 1433 [RDTR] = markflag(MIT), [TADV] = markflag(MIT), 1434 [RADV] = markflag(MIT), [ITR] = markflag(MIT), 1435 1436 [IPAV] = markflag(MAC), [WUC] = markflag(MAC), 1437 [IP6AT] = markflag(MAC), [IP4AT] = markflag(MAC), 1438 [FFVT] = markflag(MAC), [WUPM] = markflag(MAC), 1439 [ECOL] = markflag(MAC), [MCC] = markflag(MAC), 1440 [DC] = markflag(MAC), [TNCRS] = markflag(MAC), 1441 [RLEC] = markflag(MAC), [XONRXC] = markflag(MAC), 1442 [XOFFTXC] = markflag(MAC), [RFC] = markflag(MAC), 1443 [TSCTFC] = markflag(MAC), [MGTPRC] = markflag(MAC), 1444 [WUS] = markflag(MAC), [AIT] = markflag(MAC), 1445 [FFLT] = markflag(MAC), [FFMT] = markflag(MAC), 1446 [SCC] = markflag(MAC), [FCRUC] = markflag(MAC), 1447 [LATECOL] = markflag(MAC), [COLC] = markflag(MAC), 1448 [SEC] = markflag(MAC), [CEXTERR] = markflag(MAC), 1449 [XONTXC] = markflag(MAC), [XOFFRXC] = markflag(MAC), 1450 [RJC] = markflag(MAC), [RNBC] = markflag(MAC), 1451 [MGTPDC] = markflag(MAC), [MGTPTC] = markflag(MAC), 1452 [RUC] = markflag(MAC), [ROC] = markflag(MAC), 1453 [GORCL] = markflag(MAC), [GORCH] = markflag(MAC), 1454 [GOTCL] = markflag(MAC), [GOTCH] = markflag(MAC), 1455 [BPRC] = markflag(MAC), [MPRC] = markflag(MAC), 1456 [TSCTC] = markflag(MAC), [PRC64] = markflag(MAC), 1457 [PRC127] = markflag(MAC), [PRC255] = markflag(MAC), 1458 [PRC511] = markflag(MAC), [PRC1023] = markflag(MAC), 1459 [PRC1522] = markflag(MAC), [PTC64] = markflag(MAC), 1460 [PTC127] = markflag(MAC), [PTC255] = markflag(MAC), 1461 [PTC511] = markflag(MAC), [PTC1023] = markflag(MAC), 1462 [PTC1522] = markflag(MAC), [MPTC] = markflag(MAC), 1463 [BPTC] = markflag(MAC), 1464 1465 [TDFH] = markflag(MAC) | MAC_ACCESS_PARTIAL, 1466 [TDFT] = markflag(MAC) | MAC_ACCESS_PARTIAL, 1467 [TDFHS] = markflag(MAC) | MAC_ACCESS_PARTIAL, 1468 [TDFTS] = markflag(MAC) | MAC_ACCESS_PARTIAL, 1469 [TDFPC] = markflag(MAC) | MAC_ACCESS_PARTIAL, 1470 [RDFH] = markflag(MAC) | MAC_ACCESS_PARTIAL, 1471 [RDFT] = markflag(MAC) | MAC_ACCESS_PARTIAL, 1472 [RDFHS] = markflag(MAC) | MAC_ACCESS_PARTIAL, 1473 [RDFTS] = markflag(MAC) | MAC_ACCESS_PARTIAL, 1474 [RDFPC] = markflag(MAC) | MAC_ACCESS_PARTIAL, 1475 [PBM] = markflag(MAC) | MAC_ACCESS_PARTIAL, 1476 }; 1477 1478 static void 1479 e1000_mmio_write(void *opaque, hwaddr addr, uint64_t val, 1480 unsigned size) 1481 { 1482 E1000State *s = opaque; 1483 unsigned int index = (addr & 0x1ffff) >> 2; 1484 1485 if (index < NWRITEOPS && macreg_writeops[index]) { 1486 if (!(mac_reg_access[index] & MAC_ACCESS_FLAG_NEEDED) 1487 || (s->compat_flags & (mac_reg_access[index] >> 2))) { 1488 if (mac_reg_access[index] & MAC_ACCESS_PARTIAL) { 1489 DBGOUT(GENERAL, "Writing to register at offset: 0x%08x. " 1490 "It is not fully implemented.\n", index<<2); 1491 } 1492 macreg_writeops[index](s, index, val); 1493 } else { /* "flag needed" bit is set, but the flag is not active */ 1494 DBGOUT(MMIO, "MMIO write attempt to disabled reg. addr=0x%08x\n", 1495 index<<2); 1496 } 1497 } else if (index < NREADOPS && macreg_readops[index]) { 1498 DBGOUT(MMIO, "e1000_mmio_writel RO %x: 0x%04"PRIx64"\n", 1499 index<<2, val); 1500 } else { 1501 DBGOUT(UNKNOWN, "MMIO unknown write addr=0x%08x,val=0x%08"PRIx64"\n", 1502 index<<2, val); 1503 } 1504 } 1505 1506 static uint64_t 1507 e1000_mmio_read(void *opaque, hwaddr addr, unsigned size) 1508 { 1509 E1000State *s = opaque; 1510 unsigned int index = (addr & 0x1ffff) >> 2; 1511 1512 if (index < NREADOPS && macreg_readops[index]) { 1513 if (!(mac_reg_access[index] & MAC_ACCESS_FLAG_NEEDED) 1514 || (s->compat_flags & (mac_reg_access[index] >> 2))) { 1515 if (mac_reg_access[index] & MAC_ACCESS_PARTIAL) { 1516 DBGOUT(GENERAL, "Reading register at offset: 0x%08x. " 1517 "It is not fully implemented.\n", index<<2); 1518 } 1519 return macreg_readops[index](s, index); 1520 } else { /* "flag needed" bit is set, but the flag is not active */ 1521 DBGOUT(MMIO, "MMIO read attempt of disabled reg. addr=0x%08x\n", 1522 index<<2); 1523 } 1524 } else { 1525 DBGOUT(UNKNOWN, "MMIO unknown read addr=0x%08x\n", index<<2); 1526 } 1527 return 0; 1528 } 1529 1530 static const MemoryRegionOps e1000_mmio_ops = { 1531 .read = e1000_mmio_read, 1532 .write = e1000_mmio_write, 1533 .endianness = DEVICE_LITTLE_ENDIAN, 1534 .impl = { 1535 .min_access_size = 4, 1536 .max_access_size = 4, 1537 }, 1538 }; 1539 1540 static uint64_t e1000_io_read(void *opaque, hwaddr addr, 1541 unsigned size) 1542 { 1543 E1000State *s = opaque; 1544 1545 (void)s; 1546 return 0; 1547 } 1548 1549 static void e1000_io_write(void *opaque, hwaddr addr, 1550 uint64_t val, unsigned size) 1551 { 1552 E1000State *s = opaque; 1553 1554 (void)s; 1555 } 1556 1557 static const MemoryRegionOps e1000_io_ops = { 1558 .read = e1000_io_read, 1559 .write = e1000_io_write, 1560 .endianness = DEVICE_LITTLE_ENDIAN, 1561 }; 1562 1563 static bool is_version_1(void *opaque, int version_id) 1564 { 1565 return version_id == 1; 1566 } 1567 1568 static void e1000_pre_save(void *opaque) 1569 { 1570 E1000State *s = opaque; 1571 NetClientState *nc = qemu_get_queue(s->nic); 1572 1573 /* If the mitigation timer is active, emulate a timeout now. */ 1574 if (s->mit_timer_on) { 1575 e1000_mit_timer(s); 1576 } 1577 1578 /* 1579 * If link is down and auto-negotiation is supported and ongoing, 1580 * complete auto-negotiation immediately. This allows us to look 1581 * at MII_SR_AUTONEG_COMPLETE to infer link status on load. 1582 */ 1583 if (nc->link_down && have_autoneg(s)) { 1584 s->phy_reg[PHY_STATUS] |= MII_SR_AUTONEG_COMPLETE; 1585 } 1586 } 1587 1588 static int e1000_post_load(void *opaque, int version_id) 1589 { 1590 E1000State *s = opaque; 1591 NetClientState *nc = qemu_get_queue(s->nic); 1592 1593 if (!chkflag(MIT)) { 1594 s->mac_reg[ITR] = s->mac_reg[RDTR] = s->mac_reg[RADV] = 1595 s->mac_reg[TADV] = 0; 1596 s->mit_irq_level = false; 1597 } 1598 s->mit_ide = 0; 1599 s->mit_timer_on = false; 1600 1601 /* nc.link_down can't be migrated, so infer link_down according 1602 * to link status bit in mac_reg[STATUS]. 1603 * Alternatively, restart link negotiation if it was in progress. */ 1604 nc->link_down = (s->mac_reg[STATUS] & E1000_STATUS_LU) == 0; 1605 1606 if (have_autoneg(s) && 1607 !(s->phy_reg[PHY_STATUS] & MII_SR_AUTONEG_COMPLETE)) { 1608 nc->link_down = false; 1609 timer_mod(s->autoneg_timer, 1610 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 500); 1611 } 1612 1613 return 0; 1614 } 1615 1616 static bool e1000_mit_state_needed(void *opaque) 1617 { 1618 E1000State *s = opaque; 1619 1620 return chkflag(MIT); 1621 } 1622 1623 static bool e1000_full_mac_needed(void *opaque) 1624 { 1625 E1000State *s = opaque; 1626 1627 return chkflag(MAC); 1628 } 1629 1630 static const VMStateDescription vmstate_e1000_mit_state = { 1631 .name = "e1000/mit_state", 1632 .version_id = 1, 1633 .minimum_version_id = 1, 1634 .needed = e1000_mit_state_needed, 1635 .fields = (VMStateField[]) { 1636 VMSTATE_UINT32(mac_reg[RDTR], E1000State), 1637 VMSTATE_UINT32(mac_reg[RADV], E1000State), 1638 VMSTATE_UINT32(mac_reg[TADV], E1000State), 1639 VMSTATE_UINT32(mac_reg[ITR], E1000State), 1640 VMSTATE_BOOL(mit_irq_level, E1000State), 1641 VMSTATE_END_OF_LIST() 1642 } 1643 }; 1644 1645 static const VMStateDescription vmstate_e1000_full_mac_state = { 1646 .name = "e1000/full_mac_state", 1647 .version_id = 1, 1648 .minimum_version_id = 1, 1649 .needed = e1000_full_mac_needed, 1650 .fields = (VMStateField[]) { 1651 VMSTATE_UINT32_ARRAY(mac_reg, E1000State, 0x8000), 1652 VMSTATE_END_OF_LIST() 1653 } 1654 }; 1655 1656 static const VMStateDescription vmstate_e1000 = { 1657 .name = "e1000", 1658 .version_id = 2, 1659 .minimum_version_id = 1, 1660 .pre_save = e1000_pre_save, 1661 .post_load = e1000_post_load, 1662 .fields = (VMStateField[]) { 1663 VMSTATE_PCI_DEVICE(parent_obj, E1000State), 1664 VMSTATE_UNUSED_TEST(is_version_1, 4), /* was instance id */ 1665 VMSTATE_UNUSED(4), /* Was mmio_base. */ 1666 VMSTATE_UINT32(rxbuf_size, E1000State), 1667 VMSTATE_UINT32(rxbuf_min_shift, E1000State), 1668 VMSTATE_UINT32(eecd_state.val_in, E1000State), 1669 VMSTATE_UINT16(eecd_state.bitnum_in, E1000State), 1670 VMSTATE_UINT16(eecd_state.bitnum_out, E1000State), 1671 VMSTATE_UINT16(eecd_state.reading, E1000State), 1672 VMSTATE_UINT32(eecd_state.old_eecd, E1000State), 1673 VMSTATE_UINT8(tx.ipcss, E1000State), 1674 VMSTATE_UINT8(tx.ipcso, E1000State), 1675 VMSTATE_UINT16(tx.ipcse, E1000State), 1676 VMSTATE_UINT8(tx.tucss, E1000State), 1677 VMSTATE_UINT8(tx.tucso, E1000State), 1678 VMSTATE_UINT16(tx.tucse, E1000State), 1679 VMSTATE_UINT32(tx.paylen, E1000State), 1680 VMSTATE_UINT8(tx.hdr_len, E1000State), 1681 VMSTATE_UINT16(tx.mss, E1000State), 1682 VMSTATE_UINT16(tx.size, E1000State), 1683 VMSTATE_UINT16(tx.tso_frames, E1000State), 1684 VMSTATE_UINT8(tx.sum_needed, E1000State), 1685 VMSTATE_INT8(tx.ip, E1000State), 1686 VMSTATE_INT8(tx.tcp, E1000State), 1687 VMSTATE_BUFFER(tx.header, E1000State), 1688 VMSTATE_BUFFER(tx.data, E1000State), 1689 VMSTATE_UINT16_ARRAY(eeprom_data, E1000State, 64), 1690 VMSTATE_UINT16_ARRAY(phy_reg, E1000State, 0x20), 1691 VMSTATE_UINT32(mac_reg[CTRL], E1000State), 1692 VMSTATE_UINT32(mac_reg[EECD], E1000State), 1693 VMSTATE_UINT32(mac_reg[EERD], E1000State), 1694 VMSTATE_UINT32(mac_reg[GPRC], E1000State), 1695 VMSTATE_UINT32(mac_reg[GPTC], E1000State), 1696 VMSTATE_UINT32(mac_reg[ICR], E1000State), 1697 VMSTATE_UINT32(mac_reg[ICS], E1000State), 1698 VMSTATE_UINT32(mac_reg[IMC], E1000State), 1699 VMSTATE_UINT32(mac_reg[IMS], E1000State), 1700 VMSTATE_UINT32(mac_reg[LEDCTL], E1000State), 1701 VMSTATE_UINT32(mac_reg[MANC], E1000State), 1702 VMSTATE_UINT32(mac_reg[MDIC], E1000State), 1703 VMSTATE_UINT32(mac_reg[MPC], E1000State), 1704 VMSTATE_UINT32(mac_reg[PBA], E1000State), 1705 VMSTATE_UINT32(mac_reg[RCTL], E1000State), 1706 VMSTATE_UINT32(mac_reg[RDBAH], E1000State), 1707 VMSTATE_UINT32(mac_reg[RDBAL], E1000State), 1708 VMSTATE_UINT32(mac_reg[RDH], E1000State), 1709 VMSTATE_UINT32(mac_reg[RDLEN], E1000State), 1710 VMSTATE_UINT32(mac_reg[RDT], E1000State), 1711 VMSTATE_UINT32(mac_reg[STATUS], E1000State), 1712 VMSTATE_UINT32(mac_reg[SWSM], E1000State), 1713 VMSTATE_UINT32(mac_reg[TCTL], E1000State), 1714 VMSTATE_UINT32(mac_reg[TDBAH], E1000State), 1715 VMSTATE_UINT32(mac_reg[TDBAL], E1000State), 1716 VMSTATE_UINT32(mac_reg[TDH], E1000State), 1717 VMSTATE_UINT32(mac_reg[TDLEN], E1000State), 1718 VMSTATE_UINT32(mac_reg[TDT], E1000State), 1719 VMSTATE_UINT32(mac_reg[TORH], E1000State), 1720 VMSTATE_UINT32(mac_reg[TORL], E1000State), 1721 VMSTATE_UINT32(mac_reg[TOTH], E1000State), 1722 VMSTATE_UINT32(mac_reg[TOTL], E1000State), 1723 VMSTATE_UINT32(mac_reg[TPR], E1000State), 1724 VMSTATE_UINT32(mac_reg[TPT], E1000State), 1725 VMSTATE_UINT32(mac_reg[TXDCTL], E1000State), 1726 VMSTATE_UINT32(mac_reg[WUFC], E1000State), 1727 VMSTATE_UINT32(mac_reg[VET], E1000State), 1728 VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, RA, 32), 1729 VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, MTA, 128), 1730 VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, VFTA, 128), 1731 VMSTATE_END_OF_LIST() 1732 }, 1733 .subsections = (const VMStateDescription*[]) { 1734 &vmstate_e1000_mit_state, 1735 &vmstate_e1000_full_mac_state, 1736 NULL 1737 } 1738 }; 1739 1740 /* 1741 * EEPROM contents documented in Tables 5-2 and 5-3, pp. 98-102. 1742 * Note: A valid DevId will be inserted during pci_e1000_init(). 1743 */ 1744 static const uint16_t e1000_eeprom_template[64] = { 1745 0x0000, 0x0000, 0x0000, 0x0000, 0xffff, 0x0000, 0x0000, 0x0000, 1746 0x3000, 0x1000, 0x6403, 0 /*DevId*/, 0x8086, 0 /*DevId*/, 0x8086, 0x3040, 1747 0x0008, 0x2000, 0x7e14, 0x0048, 0x1000, 0x00d8, 0x0000, 0x2700, 1748 0x6cc9, 0x3150, 0x0722, 0x040b, 0x0984, 0x0000, 0xc000, 0x0706, 1749 0x1008, 0x0000, 0x0f04, 0x7fff, 0x4d01, 0xffff, 0xffff, 0xffff, 1750 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 1751 0x0100, 0x4000, 0x121c, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 1752 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0000, 1753 }; 1754 1755 /* PCI interface */ 1756 1757 static void 1758 e1000_mmio_setup(E1000State *d) 1759 { 1760 int i; 1761 const uint32_t excluded_regs[] = { 1762 E1000_MDIC, E1000_ICR, E1000_ICS, E1000_IMS, 1763 E1000_IMC, E1000_TCTL, E1000_TDT, PNPMMIO_SIZE 1764 }; 1765 1766 memory_region_init_io(&d->mmio, OBJECT(d), &e1000_mmio_ops, d, 1767 "e1000-mmio", PNPMMIO_SIZE); 1768 memory_region_add_coalescing(&d->mmio, 0, excluded_regs[0]); 1769 for (i = 0; excluded_regs[i] != PNPMMIO_SIZE; i++) 1770 memory_region_add_coalescing(&d->mmio, excluded_regs[i] + 4, 1771 excluded_regs[i+1] - excluded_regs[i] - 4); 1772 memory_region_init_io(&d->io, OBJECT(d), &e1000_io_ops, d, "e1000-io", IOPORT_SIZE); 1773 } 1774 1775 static void 1776 pci_e1000_uninit(PCIDevice *dev) 1777 { 1778 E1000State *d = E1000(dev); 1779 1780 timer_del(d->autoneg_timer); 1781 timer_free(d->autoneg_timer); 1782 timer_del(d->mit_timer); 1783 timer_free(d->mit_timer); 1784 qemu_del_nic(d->nic); 1785 } 1786 1787 static NetClientInfo net_e1000_info = { 1788 .type = NET_CLIENT_OPTIONS_KIND_NIC, 1789 .size = sizeof(NICState), 1790 .can_receive = e1000_can_receive, 1791 .receive = e1000_receive, 1792 .receive_iov = e1000_receive_iov, 1793 .link_status_changed = e1000_set_link_status, 1794 }; 1795 1796 static void e1000_write_config(PCIDevice *pci_dev, uint32_t address, 1797 uint32_t val, int len) 1798 { 1799 E1000State *s = E1000(pci_dev); 1800 1801 pci_default_write_config(pci_dev, address, val, len); 1802 1803 if (range_covers_byte(address, len, PCI_COMMAND) && 1804 (pci_dev->config[PCI_COMMAND] & PCI_COMMAND_MASTER)) { 1805 qemu_flush_queued_packets(qemu_get_queue(s->nic)); 1806 } 1807 } 1808 1809 1810 static void pci_e1000_realize(PCIDevice *pci_dev, Error **errp) 1811 { 1812 DeviceState *dev = DEVICE(pci_dev); 1813 E1000State *d = E1000(pci_dev); 1814 PCIDeviceClass *pdc = PCI_DEVICE_GET_CLASS(pci_dev); 1815 uint8_t *pci_conf; 1816 uint16_t checksum = 0; 1817 int i; 1818 uint8_t *macaddr; 1819 1820 pci_dev->config_write = e1000_write_config; 1821 1822 pci_conf = pci_dev->config; 1823 1824 /* TODO: RST# value should be 0, PCI spec 6.2.4 */ 1825 pci_conf[PCI_CACHE_LINE_SIZE] = 0x10; 1826 1827 pci_conf[PCI_INTERRUPT_PIN] = 1; /* interrupt pin A */ 1828 1829 e1000_mmio_setup(d); 1830 1831 pci_register_bar(pci_dev, 0, PCI_BASE_ADDRESS_SPACE_MEMORY, &d->mmio); 1832 1833 pci_register_bar(pci_dev, 1, PCI_BASE_ADDRESS_SPACE_IO, &d->io); 1834 1835 memmove(d->eeprom_data, e1000_eeprom_template, 1836 sizeof e1000_eeprom_template); 1837 qemu_macaddr_default_if_unset(&d->conf.macaddr); 1838 macaddr = d->conf.macaddr.a; 1839 for (i = 0; i < 3; i++) 1840 d->eeprom_data[i] = (macaddr[2*i+1]<<8) | macaddr[2*i]; 1841 d->eeprom_data[11] = d->eeprom_data[13] = pdc->device_id; 1842 for (i = 0; i < EEPROM_CHECKSUM_REG; i++) 1843 checksum += d->eeprom_data[i]; 1844 checksum = (uint16_t) EEPROM_SUM - checksum; 1845 d->eeprom_data[EEPROM_CHECKSUM_REG] = checksum; 1846 1847 d->nic = qemu_new_nic(&net_e1000_info, &d->conf, 1848 object_get_typename(OBJECT(d)), dev->id, d); 1849 1850 qemu_format_nic_info_str(qemu_get_queue(d->nic), macaddr); 1851 1852 d->autoneg_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, e1000_autoneg_timer, d); 1853 d->mit_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, e1000_mit_timer, d); 1854 } 1855 1856 static void qdev_e1000_reset(DeviceState *dev) 1857 { 1858 E1000State *d = E1000(dev); 1859 e1000_reset(d); 1860 } 1861 1862 static Property e1000_properties[] = { 1863 DEFINE_NIC_PROPERTIES(E1000State, conf), 1864 DEFINE_PROP_BIT("autonegotiation", E1000State, 1865 compat_flags, E1000_FLAG_AUTONEG_BIT, true), 1866 DEFINE_PROP_BIT("mitigation", E1000State, 1867 compat_flags, E1000_FLAG_MIT_BIT, true), 1868 DEFINE_PROP_BIT("extra_mac_registers", E1000State, 1869 compat_flags, E1000_FLAG_MAC_BIT, true), 1870 DEFINE_PROP_END_OF_LIST(), 1871 }; 1872 1873 typedef struct E1000Info { 1874 const char *name; 1875 uint16_t device_id; 1876 uint8_t revision; 1877 uint16_t phy_id2; 1878 } E1000Info; 1879 1880 static void e1000_class_init(ObjectClass *klass, void *data) 1881 { 1882 DeviceClass *dc = DEVICE_CLASS(klass); 1883 PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); 1884 E1000BaseClass *e = E1000_DEVICE_CLASS(klass); 1885 const E1000Info *info = data; 1886 1887 k->realize = pci_e1000_realize; 1888 k->exit = pci_e1000_uninit; 1889 k->romfile = "efi-e1000.rom"; 1890 k->vendor_id = PCI_VENDOR_ID_INTEL; 1891 k->device_id = info->device_id; 1892 k->revision = info->revision; 1893 e->phy_id2 = info->phy_id2; 1894 k->class_id = PCI_CLASS_NETWORK_ETHERNET; 1895 set_bit(DEVICE_CATEGORY_NETWORK, dc->categories); 1896 dc->desc = "Intel Gigabit Ethernet"; 1897 dc->reset = qdev_e1000_reset; 1898 dc->vmsd = &vmstate_e1000; 1899 dc->props = e1000_properties; 1900 } 1901 1902 static void e1000_instance_init(Object *obj) 1903 { 1904 E1000State *n = E1000(obj); 1905 device_add_bootindex_property(obj, &n->conf.bootindex, 1906 "bootindex", "/ethernet-phy@0", 1907 DEVICE(n), NULL); 1908 } 1909 1910 static const TypeInfo e1000_base_info = { 1911 .name = TYPE_E1000_BASE, 1912 .parent = TYPE_PCI_DEVICE, 1913 .instance_size = sizeof(E1000State), 1914 .instance_init = e1000_instance_init, 1915 .class_size = sizeof(E1000BaseClass), 1916 .abstract = true, 1917 }; 1918 1919 static const E1000Info e1000_devices[] = { 1920 { 1921 .name = "e1000", 1922 .device_id = E1000_DEV_ID_82540EM, 1923 .revision = 0x03, 1924 .phy_id2 = E1000_PHY_ID2_8254xx_DEFAULT, 1925 }, 1926 { 1927 .name = "e1000-82544gc", 1928 .device_id = E1000_DEV_ID_82544GC_COPPER, 1929 .revision = 0x03, 1930 .phy_id2 = E1000_PHY_ID2_82544x, 1931 }, 1932 { 1933 .name = "e1000-82545em", 1934 .device_id = E1000_DEV_ID_82545EM_COPPER, 1935 .revision = 0x03, 1936 .phy_id2 = E1000_PHY_ID2_8254xx_DEFAULT, 1937 }, 1938 }; 1939 1940 static void e1000_register_types(void) 1941 { 1942 int i; 1943 1944 type_register_static(&e1000_base_info); 1945 for (i = 0; i < ARRAY_SIZE(e1000_devices); i++) { 1946 const E1000Info *info = &e1000_devices[i]; 1947 TypeInfo type_info = {}; 1948 1949 type_info.name = info->name; 1950 type_info.parent = TYPE_E1000_BASE; 1951 type_info.class_data = (void *)info; 1952 type_info.class_init = e1000_class_init; 1953 type_info.instance_init = e1000_instance_init; 1954 1955 type_register(&type_info); 1956 } 1957 } 1958 1959 type_init(e1000_register_types) 1960