1 /* 2 * Core code for QEMU igb emulation 3 * 4 * Datasheet: 5 * https://www.intel.com/content/dam/www/public/us/en/documents/datasheets/82576eg-gbe-datasheet.pdf 6 * 7 * Copyright (c) 2020-2023 Red Hat, Inc. 8 * Copyright (c) 2015 Ravello Systems LTD (http://ravellosystems.com) 9 * Developed by Daynix Computing LTD (http://www.daynix.com) 10 * 11 * Authors: 12 * Akihiko Odaki <akihiko.odaki@daynix.com> 13 * Gal Hammmer <gal.hammer@sap.com> 14 * Marcel Apfelbaum <marcel.apfelbaum@gmail.com> 15 * Dmitry Fleytman <dmitry@daynix.com> 16 * Leonid Bloch <leonid@daynix.com> 17 * Yan Vugenfirer <yan@daynix.com> 18 * 19 * Based on work done by: 20 * Nir Peleg, Tutis Systems Ltd. for Qumranet Inc. 21 * Copyright (c) 2008 Qumranet 22 * Based on work done by: 23 * Copyright (c) 2007 Dan Aloni 24 * Copyright (c) 2004 Antony T Curtis 25 * 26 * This library is free software; you can redistribute it and/or 27 * modify it under the terms of the GNU Lesser General Public 28 * License as published by the Free Software Foundation; either 29 * version 2.1 of the License, or (at your option) any later version. 30 * 31 * This library is distributed in the hope that it will be useful, 32 * but WITHOUT ANY WARRANTY; without even the implied warranty of 33 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 34 * Lesser General Public License for more details. 35 * 36 * You should have received a copy of the GNU Lesser General Public 37 * License along with this library; if not, see <http://www.gnu.org/licenses/>. 38 */ 39 40 #include "qemu/osdep.h" 41 #include "qemu/log.h" 42 #include "net/net.h" 43 #include "net/tap.h" 44 #include "hw/net/mii.h" 45 #include "hw/pci/msi.h" 46 #include "hw/pci/msix.h" 47 #include "sysemu/runstate.h" 48 49 #include "net_tx_pkt.h" 50 #include "net_rx_pkt.h" 51 52 #include "igb_common.h" 53 #include "e1000x_common.h" 54 #include "igb_core.h" 55 56 #include "trace.h" 57 58 #define E1000E_MAX_TX_FRAGS (64) 59 60 union e1000_rx_desc_union { 61 struct e1000_rx_desc legacy; 62 union e1000_adv_rx_desc adv; 63 }; 64 65 typedef struct IGBTxPktVmdqCallbackContext { 66 IGBCore *core; 67 NetClientState *nc; 68 } IGBTxPktVmdqCallbackContext; 69 70 static ssize_t 71 igb_receive_internal(IGBCore *core, const struct iovec *iov, int iovcnt, 72 bool has_vnet, bool *external_tx); 73 74 static inline void 75 igb_set_interrupt_cause(IGBCore *core, uint32_t val); 76 77 static void igb_update_interrupt_state(IGBCore *core); 78 static void igb_reset(IGBCore *core, bool sw); 79 80 static inline void 81 igb_raise_legacy_irq(IGBCore *core) 82 { 83 trace_e1000e_irq_legacy_notify(true); 84 e1000x_inc_reg_if_not_full(core->mac, IAC); 85 pci_set_irq(core->owner, 1); 86 } 87 88 static inline void 89 igb_lower_legacy_irq(IGBCore *core) 90 { 91 trace_e1000e_irq_legacy_notify(false); 92 pci_set_irq(core->owner, 0); 93 } 94 95 static void igb_msix_notify(IGBCore *core, unsigned int vector) 96 { 97 PCIDevice *dev = core->owner; 98 uint16_t vfn; 99 100 vfn = 8 - (vector + 2) / IGBVF_MSIX_VEC_NUM; 101 if (vfn < pcie_sriov_num_vfs(core->owner)) { 102 dev = pcie_sriov_get_vf_at_index(core->owner, vfn); 103 assert(dev); 104 vector = (vector + 2) % IGBVF_MSIX_VEC_NUM; 105 } else if (vector >= IGB_MSIX_VEC_NUM) { 106 qemu_log_mask(LOG_GUEST_ERROR, 107 "igb: Tried to use vector unavailable for PF"); 108 return; 109 } 110 111 msix_notify(dev, vector); 112 } 113 114 static inline void 115 igb_intrmgr_rearm_timer(IGBIntrDelayTimer *timer) 116 { 117 int64_t delay_ns = (int64_t) timer->core->mac[timer->delay_reg] * 118 timer->delay_resolution_ns; 119 120 trace_e1000e_irq_rearm_timer(timer->delay_reg << 2, delay_ns); 121 122 timer_mod(timer->timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + delay_ns); 123 124 timer->running = true; 125 } 126 127 static void 128 igb_intmgr_timer_resume(IGBIntrDelayTimer *timer) 129 { 130 if (timer->running) { 131 igb_intrmgr_rearm_timer(timer); 132 } 133 } 134 135 static void 136 igb_intmgr_timer_pause(IGBIntrDelayTimer *timer) 137 { 138 if (timer->running) { 139 timer_del(timer->timer); 140 } 141 } 142 143 static void 144 igb_intrmgr_on_msix_throttling_timer(void *opaque) 145 { 146 IGBIntrDelayTimer *timer = opaque; 147 int idx = timer - &timer->core->eitr[0]; 148 149 timer->running = false; 150 151 trace_e1000e_irq_msix_notify_postponed_vec(idx); 152 igb_msix_notify(timer->core, idx); 153 } 154 155 static void 156 igb_intrmgr_initialize_all_timers(IGBCore *core, bool create) 157 { 158 int i; 159 160 for (i = 0; i < IGB_INTR_NUM; i++) { 161 core->eitr[i].core = core; 162 core->eitr[i].delay_reg = EITR0 + i; 163 core->eitr[i].delay_resolution_ns = E1000_INTR_DELAY_NS_RES; 164 } 165 166 if (!create) { 167 return; 168 } 169 170 for (i = 0; i < IGB_INTR_NUM; i++) { 171 core->eitr[i].timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, 172 igb_intrmgr_on_msix_throttling_timer, 173 &core->eitr[i]); 174 } 175 } 176 177 static void 178 igb_intrmgr_resume(IGBCore *core) 179 { 180 int i; 181 182 for (i = 0; i < IGB_INTR_NUM; i++) { 183 igb_intmgr_timer_resume(&core->eitr[i]); 184 } 185 } 186 187 static void 188 igb_intrmgr_pause(IGBCore *core) 189 { 190 int i; 191 192 for (i = 0; i < IGB_INTR_NUM; i++) { 193 igb_intmgr_timer_pause(&core->eitr[i]); 194 } 195 } 196 197 static void 198 igb_intrmgr_reset(IGBCore *core) 199 { 200 int i; 201 202 for (i = 0; i < IGB_INTR_NUM; i++) { 203 if (core->eitr[i].running) { 204 timer_del(core->eitr[i].timer); 205 igb_intrmgr_on_msix_throttling_timer(&core->eitr[i]); 206 } 207 } 208 } 209 210 static void 211 igb_intrmgr_pci_unint(IGBCore *core) 212 { 213 int i; 214 215 for (i = 0; i < IGB_INTR_NUM; i++) { 216 timer_free(core->eitr[i].timer); 217 } 218 } 219 220 static void 221 igb_intrmgr_pci_realize(IGBCore *core) 222 { 223 igb_intrmgr_initialize_all_timers(core, true); 224 } 225 226 static inline bool 227 igb_rx_csum_enabled(IGBCore *core) 228 { 229 return (core->mac[RXCSUM] & E1000_RXCSUM_PCSD) ? false : true; 230 } 231 232 static inline bool 233 igb_rx_use_legacy_descriptor(IGBCore *core) 234 { 235 /* 236 * TODO: If SRRCTL[n],DESCTYPE = 000b, the 82576 uses the legacy Rx 237 * descriptor. 238 */ 239 return false; 240 } 241 242 static inline bool 243 igb_rss_enabled(IGBCore *core) 244 { 245 return (core->mac[MRQC] & 3) == E1000_MRQC_ENABLE_RSS_MQ && 246 !igb_rx_csum_enabled(core) && 247 !igb_rx_use_legacy_descriptor(core); 248 } 249 250 typedef struct E1000E_RSSInfo_st { 251 bool enabled; 252 uint32_t hash; 253 uint32_t queue; 254 uint32_t type; 255 } E1000E_RSSInfo; 256 257 static uint32_t 258 igb_rss_get_hash_type(IGBCore *core, struct NetRxPkt *pkt) 259 { 260 bool hasip4, hasip6; 261 EthL4HdrProto l4hdr_proto; 262 263 assert(igb_rss_enabled(core)); 264 265 net_rx_pkt_get_protocols(pkt, &hasip4, &hasip6, &l4hdr_proto); 266 267 if (hasip4) { 268 trace_e1000e_rx_rss_ip4(l4hdr_proto, core->mac[MRQC], 269 E1000_MRQC_EN_TCPIPV4(core->mac[MRQC]), 270 E1000_MRQC_EN_IPV4(core->mac[MRQC])); 271 272 if (l4hdr_proto == ETH_L4_HDR_PROTO_TCP && 273 E1000_MRQC_EN_TCPIPV4(core->mac[MRQC])) { 274 return E1000_MRQ_RSS_TYPE_IPV4TCP; 275 } 276 277 if (E1000_MRQC_EN_IPV4(core->mac[MRQC])) { 278 return E1000_MRQ_RSS_TYPE_IPV4; 279 } 280 } else if (hasip6) { 281 eth_ip6_hdr_info *ip6info = net_rx_pkt_get_ip6_info(pkt); 282 283 bool ex_dis = core->mac[RFCTL] & E1000_RFCTL_IPV6_EX_DIS; 284 bool new_ex_dis = core->mac[RFCTL] & E1000_RFCTL_NEW_IPV6_EXT_DIS; 285 286 /* 287 * Following two traces must not be combined because resulting 288 * event will have 11 arguments totally and some trace backends 289 * (at least "ust") have limitation of maximum 10 arguments per 290 * event. Events with more arguments fail to compile for 291 * backends like these. 292 */ 293 trace_e1000e_rx_rss_ip6_rfctl(core->mac[RFCTL]); 294 trace_e1000e_rx_rss_ip6(ex_dis, new_ex_dis, l4hdr_proto, 295 ip6info->has_ext_hdrs, 296 ip6info->rss_ex_dst_valid, 297 ip6info->rss_ex_src_valid, 298 core->mac[MRQC], 299 E1000_MRQC_EN_TCPIPV6(core->mac[MRQC]), 300 E1000_MRQC_EN_IPV6EX(core->mac[MRQC]), 301 E1000_MRQC_EN_IPV6(core->mac[MRQC])); 302 303 if ((!ex_dis || !ip6info->has_ext_hdrs) && 304 (!new_ex_dis || !(ip6info->rss_ex_dst_valid || 305 ip6info->rss_ex_src_valid))) { 306 307 if (l4hdr_proto == ETH_L4_HDR_PROTO_TCP && 308 E1000_MRQC_EN_TCPIPV6(core->mac[MRQC])) { 309 return E1000_MRQ_RSS_TYPE_IPV6TCP; 310 } 311 312 if (E1000_MRQC_EN_IPV6EX(core->mac[MRQC])) { 313 return E1000_MRQ_RSS_TYPE_IPV6EX; 314 } 315 316 } 317 318 if (E1000_MRQC_EN_IPV6(core->mac[MRQC])) { 319 return E1000_MRQ_RSS_TYPE_IPV6; 320 } 321 322 } 323 324 return E1000_MRQ_RSS_TYPE_NONE; 325 } 326 327 static uint32_t 328 igb_rss_calc_hash(IGBCore *core, struct NetRxPkt *pkt, E1000E_RSSInfo *info) 329 { 330 NetRxPktRssType type; 331 332 assert(igb_rss_enabled(core)); 333 334 switch (info->type) { 335 case E1000_MRQ_RSS_TYPE_IPV4: 336 type = NetPktRssIpV4; 337 break; 338 case E1000_MRQ_RSS_TYPE_IPV4TCP: 339 type = NetPktRssIpV4Tcp; 340 break; 341 case E1000_MRQ_RSS_TYPE_IPV6TCP: 342 type = NetPktRssIpV6TcpEx; 343 break; 344 case E1000_MRQ_RSS_TYPE_IPV6: 345 type = NetPktRssIpV6; 346 break; 347 case E1000_MRQ_RSS_TYPE_IPV6EX: 348 type = NetPktRssIpV6Ex; 349 break; 350 default: 351 assert(false); 352 return 0; 353 } 354 355 return net_rx_pkt_calc_rss_hash(pkt, type, (uint8_t *) &core->mac[RSSRK]); 356 } 357 358 static void 359 igb_rss_parse_packet(IGBCore *core, struct NetRxPkt *pkt, bool tx, 360 E1000E_RSSInfo *info) 361 { 362 trace_e1000e_rx_rss_started(); 363 364 if (tx || !igb_rss_enabled(core)) { 365 info->enabled = false; 366 info->hash = 0; 367 info->queue = 0; 368 info->type = 0; 369 trace_e1000e_rx_rss_disabled(); 370 return; 371 } 372 373 info->enabled = true; 374 375 info->type = igb_rss_get_hash_type(core, pkt); 376 377 trace_e1000e_rx_rss_type(info->type); 378 379 if (info->type == E1000_MRQ_RSS_TYPE_NONE) { 380 info->hash = 0; 381 info->queue = 0; 382 return; 383 } 384 385 info->hash = igb_rss_calc_hash(core, pkt, info); 386 info->queue = E1000_RSS_QUEUE(&core->mac[RETA], info->hash); 387 } 388 389 static bool 390 igb_setup_tx_offloads(IGBCore *core, struct igb_tx *tx) 391 { 392 if (tx->first_cmd_type_len & E1000_ADVTXD_DCMD_TSE) { 393 uint32_t idx = (tx->first_olinfo_status >> 4) & 1; 394 uint32_t mss = tx->ctx[idx].mss_l4len_idx >> 16; 395 if (!net_tx_pkt_build_vheader(tx->tx_pkt, true, true, mss)) { 396 return false; 397 } 398 399 net_tx_pkt_update_ip_checksums(tx->tx_pkt); 400 e1000x_inc_reg_if_not_full(core->mac, TSCTC); 401 return true; 402 } 403 404 if (tx->first_olinfo_status & E1000_ADVTXD_POTS_TXSM) { 405 if (!net_tx_pkt_build_vheader(tx->tx_pkt, false, true, 0)) { 406 return false; 407 } 408 } 409 410 if (tx->first_olinfo_status & E1000_ADVTXD_POTS_IXSM) { 411 net_tx_pkt_update_ip_hdr_checksum(tx->tx_pkt); 412 } 413 414 return true; 415 } 416 417 static void igb_tx_pkt_mac_callback(void *core, 418 const struct iovec *iov, 419 int iovcnt, 420 const struct iovec *virt_iov, 421 int virt_iovcnt) 422 { 423 igb_receive_internal(core, virt_iov, virt_iovcnt, true, NULL); 424 } 425 426 static void igb_tx_pkt_vmdq_callback(void *opaque, 427 const struct iovec *iov, 428 int iovcnt, 429 const struct iovec *virt_iov, 430 int virt_iovcnt) 431 { 432 IGBTxPktVmdqCallbackContext *context = opaque; 433 bool external_tx; 434 435 igb_receive_internal(context->core, virt_iov, virt_iovcnt, true, 436 &external_tx); 437 438 if (external_tx) { 439 if (context->core->has_vnet) { 440 qemu_sendv_packet(context->nc, virt_iov, virt_iovcnt); 441 } else { 442 qemu_sendv_packet(context->nc, iov, iovcnt); 443 } 444 } 445 } 446 447 /* TX Packets Switching (7.10.3.6) */ 448 static bool igb_tx_pkt_switch(IGBCore *core, struct igb_tx *tx, 449 NetClientState *nc) 450 { 451 IGBTxPktVmdqCallbackContext context; 452 453 /* TX switching is only used to serve VM to VM traffic. */ 454 if (!(core->mac[MRQC] & 1)) { 455 goto send_out; 456 } 457 458 /* TX switching requires DTXSWC.Loopback_en bit enabled. */ 459 if (!(core->mac[DTXSWC] & E1000_DTXSWC_VMDQ_LOOPBACK_EN)) { 460 goto send_out; 461 } 462 463 context.core = core; 464 context.nc = nc; 465 466 return net_tx_pkt_send_custom(tx->tx_pkt, false, 467 igb_tx_pkt_vmdq_callback, &context); 468 469 send_out: 470 return net_tx_pkt_send(tx->tx_pkt, nc); 471 } 472 473 static bool 474 igb_tx_pkt_send(IGBCore *core, struct igb_tx *tx, int queue_index) 475 { 476 int target_queue = MIN(core->max_queue_num, queue_index); 477 NetClientState *queue = qemu_get_subqueue(core->owner_nic, target_queue); 478 479 if (!igb_setup_tx_offloads(core, tx)) { 480 return false; 481 } 482 483 net_tx_pkt_dump(tx->tx_pkt); 484 485 if ((core->phy[MII_BMCR] & MII_BMCR_LOOPBACK) || 486 ((core->mac[RCTL] & E1000_RCTL_LBM_MAC) == E1000_RCTL_LBM_MAC)) { 487 return net_tx_pkt_send_custom(tx->tx_pkt, false, 488 igb_tx_pkt_mac_callback, core); 489 } else { 490 return igb_tx_pkt_switch(core, tx, queue); 491 } 492 } 493 494 static void 495 igb_on_tx_done_update_stats(IGBCore *core, struct NetTxPkt *tx_pkt) 496 { 497 static const int PTCregs[6] = { PTC64, PTC127, PTC255, PTC511, 498 PTC1023, PTC1522 }; 499 500 size_t tot_len = net_tx_pkt_get_total_len(tx_pkt) + 4; 501 502 e1000x_increase_size_stats(core->mac, PTCregs, tot_len); 503 e1000x_inc_reg_if_not_full(core->mac, TPT); 504 e1000x_grow_8reg_if_not_full(core->mac, TOTL, tot_len); 505 506 switch (net_tx_pkt_get_packet_type(tx_pkt)) { 507 case ETH_PKT_BCAST: 508 e1000x_inc_reg_if_not_full(core->mac, BPTC); 509 break; 510 case ETH_PKT_MCAST: 511 e1000x_inc_reg_if_not_full(core->mac, MPTC); 512 break; 513 case ETH_PKT_UCAST: 514 break; 515 default: 516 g_assert_not_reached(); 517 } 518 519 core->mac[GPTC] = core->mac[TPT]; 520 core->mac[GOTCL] = core->mac[TOTL]; 521 core->mac[GOTCH] = core->mac[TOTH]; 522 } 523 524 static void 525 igb_process_tx_desc(IGBCore *core, 526 PCIDevice *dev, 527 struct igb_tx *tx, 528 union e1000_adv_tx_desc *tx_desc, 529 int queue_index) 530 { 531 struct e1000_adv_tx_context_desc *tx_ctx_desc; 532 uint32_t cmd_type_len; 533 uint32_t idx; 534 uint64_t buffer_addr; 535 uint16_t length; 536 537 cmd_type_len = le32_to_cpu(tx_desc->read.cmd_type_len); 538 539 if (cmd_type_len & E1000_ADVTXD_DCMD_DEXT) { 540 if ((cmd_type_len & E1000_ADVTXD_DTYP_DATA) == 541 E1000_ADVTXD_DTYP_DATA) { 542 /* advanced transmit data descriptor */ 543 if (tx->first) { 544 tx->first_cmd_type_len = cmd_type_len; 545 tx->first_olinfo_status = le32_to_cpu(tx_desc->read.olinfo_status); 546 tx->first = false; 547 } 548 } else if ((cmd_type_len & E1000_ADVTXD_DTYP_CTXT) == 549 E1000_ADVTXD_DTYP_CTXT) { 550 /* advanced transmit context descriptor */ 551 tx_ctx_desc = (struct e1000_adv_tx_context_desc *)tx_desc; 552 idx = (le32_to_cpu(tx_ctx_desc->mss_l4len_idx) >> 4) & 1; 553 tx->ctx[idx].vlan_macip_lens = le32_to_cpu(tx_ctx_desc->vlan_macip_lens); 554 tx->ctx[idx].seqnum_seed = le32_to_cpu(tx_ctx_desc->seqnum_seed); 555 tx->ctx[idx].type_tucmd_mlhl = le32_to_cpu(tx_ctx_desc->type_tucmd_mlhl); 556 tx->ctx[idx].mss_l4len_idx = le32_to_cpu(tx_ctx_desc->mss_l4len_idx); 557 return; 558 } else { 559 /* unknown descriptor type */ 560 return; 561 } 562 } else { 563 /* legacy descriptor */ 564 565 /* TODO: Implement a support for legacy descriptors (7.2.2.1). */ 566 } 567 568 buffer_addr = le64_to_cpu(tx_desc->read.buffer_addr); 569 length = cmd_type_len & 0xFFFF; 570 571 if (!tx->skip_cp) { 572 if (!net_tx_pkt_add_raw_fragment(tx->tx_pkt, buffer_addr, length)) { 573 tx->skip_cp = true; 574 } 575 } 576 577 if (cmd_type_len & E1000_TXD_CMD_EOP) { 578 if (!tx->skip_cp && net_tx_pkt_parse(tx->tx_pkt)) { 579 if (cmd_type_len & E1000_TXD_CMD_VLE) { 580 idx = (tx->first_olinfo_status >> 4) & 1; 581 uint16_t vlan = tx->ctx[idx].vlan_macip_lens >> 16; 582 uint16_t vet = core->mac[VET] & 0xffff; 583 net_tx_pkt_setup_vlan_header_ex(tx->tx_pkt, vlan, vet); 584 } 585 if (igb_tx_pkt_send(core, tx, queue_index)) { 586 igb_on_tx_done_update_stats(core, tx->tx_pkt); 587 } 588 } 589 590 tx->first = true; 591 tx->skip_cp = false; 592 net_tx_pkt_reset(tx->tx_pkt, dev); 593 } 594 } 595 596 static uint32_t igb_tx_wb_eic(IGBCore *core, int queue_idx) 597 { 598 uint32_t n, ent = 0; 599 600 n = igb_ivar_entry_tx(queue_idx); 601 ent = (core->mac[IVAR0 + n / 4] >> (8 * (n % 4))) & 0xff; 602 603 return (ent & E1000_IVAR_VALID) ? BIT(ent & 0x1f) : 0; 604 } 605 606 static uint32_t igb_rx_wb_eic(IGBCore *core, int queue_idx) 607 { 608 uint32_t n, ent = 0; 609 610 n = igb_ivar_entry_rx(queue_idx); 611 ent = (core->mac[IVAR0 + n / 4] >> (8 * (n % 4))) & 0xff; 612 613 return (ent & E1000_IVAR_VALID) ? BIT(ent & 0x1f) : 0; 614 } 615 616 typedef struct E1000E_RingInfo_st { 617 int dbah; 618 int dbal; 619 int dlen; 620 int dh; 621 int dt; 622 int idx; 623 } E1000E_RingInfo; 624 625 static inline bool 626 igb_ring_empty(IGBCore *core, const E1000E_RingInfo *r) 627 { 628 return core->mac[r->dh] == core->mac[r->dt] || 629 core->mac[r->dt] >= core->mac[r->dlen] / E1000_RING_DESC_LEN; 630 } 631 632 static inline uint64_t 633 igb_ring_base(IGBCore *core, const E1000E_RingInfo *r) 634 { 635 uint64_t bah = core->mac[r->dbah]; 636 uint64_t bal = core->mac[r->dbal]; 637 638 return (bah << 32) + bal; 639 } 640 641 static inline uint64_t 642 igb_ring_head_descr(IGBCore *core, const E1000E_RingInfo *r) 643 { 644 return igb_ring_base(core, r) + E1000_RING_DESC_LEN * core->mac[r->dh]; 645 } 646 647 static inline void 648 igb_ring_advance(IGBCore *core, const E1000E_RingInfo *r, uint32_t count) 649 { 650 core->mac[r->dh] += count; 651 652 if (core->mac[r->dh] * E1000_RING_DESC_LEN >= core->mac[r->dlen]) { 653 core->mac[r->dh] = 0; 654 } 655 } 656 657 static inline uint32_t 658 igb_ring_free_descr_num(IGBCore *core, const E1000E_RingInfo *r) 659 { 660 trace_e1000e_ring_free_space(r->idx, core->mac[r->dlen], 661 core->mac[r->dh], core->mac[r->dt]); 662 663 if (core->mac[r->dh] <= core->mac[r->dt]) { 664 return core->mac[r->dt] - core->mac[r->dh]; 665 } 666 667 if (core->mac[r->dh] > core->mac[r->dt]) { 668 return core->mac[r->dlen] / E1000_RING_DESC_LEN + 669 core->mac[r->dt] - core->mac[r->dh]; 670 } 671 672 g_assert_not_reached(); 673 return 0; 674 } 675 676 static inline bool 677 igb_ring_enabled(IGBCore *core, const E1000E_RingInfo *r) 678 { 679 return core->mac[r->dlen] > 0; 680 } 681 682 typedef struct IGB_TxRing_st { 683 const E1000E_RingInfo *i; 684 struct igb_tx *tx; 685 } IGB_TxRing; 686 687 static inline int 688 igb_mq_queue_idx(int base_reg_idx, int reg_idx) 689 { 690 return (reg_idx - base_reg_idx) / 16; 691 } 692 693 static inline void 694 igb_tx_ring_init(IGBCore *core, IGB_TxRing *txr, int idx) 695 { 696 static const E1000E_RingInfo i[IGB_NUM_QUEUES] = { 697 { TDBAH0, TDBAL0, TDLEN0, TDH0, TDT0, 0 }, 698 { TDBAH1, TDBAL1, TDLEN1, TDH1, TDT1, 1 }, 699 { TDBAH2, TDBAL2, TDLEN2, TDH2, TDT2, 2 }, 700 { TDBAH3, TDBAL3, TDLEN3, TDH3, TDT3, 3 }, 701 { TDBAH4, TDBAL4, TDLEN4, TDH4, TDT4, 4 }, 702 { TDBAH5, TDBAL5, TDLEN5, TDH5, TDT5, 5 }, 703 { TDBAH6, TDBAL6, TDLEN6, TDH6, TDT6, 6 }, 704 { TDBAH7, TDBAL7, TDLEN7, TDH7, TDT7, 7 }, 705 { TDBAH8, TDBAL8, TDLEN8, TDH8, TDT8, 8 }, 706 { TDBAH9, TDBAL9, TDLEN9, TDH9, TDT9, 9 }, 707 { TDBAH10, TDBAL10, TDLEN10, TDH10, TDT10, 10 }, 708 { TDBAH11, TDBAL11, TDLEN11, TDH11, TDT11, 11 }, 709 { TDBAH12, TDBAL12, TDLEN12, TDH12, TDT12, 12 }, 710 { TDBAH13, TDBAL13, TDLEN13, TDH13, TDT13, 13 }, 711 { TDBAH14, TDBAL14, TDLEN14, TDH14, TDT14, 14 }, 712 { TDBAH15, TDBAL15, TDLEN15, TDH15, TDT15, 15 } 713 }; 714 715 assert(idx < ARRAY_SIZE(i)); 716 717 txr->i = &i[idx]; 718 txr->tx = &core->tx[idx]; 719 } 720 721 typedef struct E1000E_RxRing_st { 722 const E1000E_RingInfo *i; 723 } E1000E_RxRing; 724 725 static inline void 726 igb_rx_ring_init(IGBCore *core, E1000E_RxRing *rxr, int idx) 727 { 728 static const E1000E_RingInfo i[IGB_NUM_QUEUES] = { 729 { RDBAH0, RDBAL0, RDLEN0, RDH0, RDT0, 0 }, 730 { RDBAH1, RDBAL1, RDLEN1, RDH1, RDT1, 1 }, 731 { RDBAH2, RDBAL2, RDLEN2, RDH2, RDT2, 2 }, 732 { RDBAH3, RDBAL3, RDLEN3, RDH3, RDT3, 3 }, 733 { RDBAH4, RDBAL4, RDLEN4, RDH4, RDT4, 4 }, 734 { RDBAH5, RDBAL5, RDLEN5, RDH5, RDT5, 5 }, 735 { RDBAH6, RDBAL6, RDLEN6, RDH6, RDT6, 6 }, 736 { RDBAH7, RDBAL7, RDLEN7, RDH7, RDT7, 7 }, 737 { RDBAH8, RDBAL8, RDLEN8, RDH8, RDT8, 8 }, 738 { RDBAH9, RDBAL9, RDLEN9, RDH9, RDT9, 9 }, 739 { RDBAH10, RDBAL10, RDLEN10, RDH10, RDT10, 10 }, 740 { RDBAH11, RDBAL11, RDLEN11, RDH11, RDT11, 11 }, 741 { RDBAH12, RDBAL12, RDLEN12, RDH12, RDT12, 12 }, 742 { RDBAH13, RDBAL13, RDLEN13, RDH13, RDT13, 13 }, 743 { RDBAH14, RDBAL14, RDLEN14, RDH14, RDT14, 14 }, 744 { RDBAH15, RDBAL15, RDLEN15, RDH15, RDT15, 15 } 745 }; 746 747 assert(idx < ARRAY_SIZE(i)); 748 749 rxr->i = &i[idx]; 750 } 751 752 static uint32_t 753 igb_txdesc_writeback(IGBCore *core, dma_addr_t base, 754 union e1000_adv_tx_desc *tx_desc, 755 const E1000E_RingInfo *txi) 756 { 757 PCIDevice *d; 758 uint32_t cmd_type_len = le32_to_cpu(tx_desc->read.cmd_type_len); 759 uint64_t tdwba; 760 761 tdwba = core->mac[E1000_TDWBAL(txi->idx) >> 2]; 762 tdwba |= (uint64_t)core->mac[E1000_TDWBAH(txi->idx) >> 2] << 32; 763 764 if (!(cmd_type_len & E1000_TXD_CMD_RS)) { 765 return 0; 766 } 767 768 d = pcie_sriov_get_vf_at_index(core->owner, txi->idx % 8); 769 if (!d) { 770 d = core->owner; 771 } 772 773 if (tdwba & 1) { 774 uint32_t buffer = cpu_to_le32(core->mac[txi->dh]); 775 pci_dma_write(d, tdwba & ~3, &buffer, sizeof(buffer)); 776 } else { 777 uint32_t status = le32_to_cpu(tx_desc->wb.status) | E1000_TXD_STAT_DD; 778 779 tx_desc->wb.status = cpu_to_le32(status); 780 pci_dma_write(d, base + offsetof(union e1000_adv_tx_desc, wb), 781 &tx_desc->wb, sizeof(tx_desc->wb)); 782 } 783 784 return igb_tx_wb_eic(core, txi->idx); 785 } 786 787 static inline bool 788 igb_tx_enabled(IGBCore *core, const E1000E_RingInfo *txi) 789 { 790 bool vmdq = core->mac[MRQC] & 1; 791 uint16_t qn = txi->idx; 792 uint16_t pool = qn % IGB_NUM_VM_POOLS; 793 794 return (core->mac[TCTL] & E1000_TCTL_EN) && 795 (!vmdq || core->mac[VFTE] & BIT(pool)) && 796 (core->mac[TXDCTL0 + (qn * 16)] & E1000_TXDCTL_QUEUE_ENABLE); 797 } 798 799 static void 800 igb_start_xmit(IGBCore *core, const IGB_TxRing *txr) 801 { 802 PCIDevice *d; 803 dma_addr_t base; 804 union e1000_adv_tx_desc desc; 805 const E1000E_RingInfo *txi = txr->i; 806 uint32_t eic = 0; 807 808 if (!igb_tx_enabled(core, txi)) { 809 trace_e1000e_tx_disabled(); 810 return; 811 } 812 813 d = pcie_sriov_get_vf_at_index(core->owner, txi->idx % 8); 814 if (!d) { 815 d = core->owner; 816 } 817 818 net_tx_pkt_reset(txr->tx->tx_pkt, d); 819 820 while (!igb_ring_empty(core, txi)) { 821 base = igb_ring_head_descr(core, txi); 822 823 pci_dma_read(d, base, &desc, sizeof(desc)); 824 825 trace_e1000e_tx_descr((void *)(intptr_t)desc.read.buffer_addr, 826 desc.read.cmd_type_len, desc.wb.status); 827 828 igb_process_tx_desc(core, d, txr->tx, &desc, txi->idx); 829 igb_ring_advance(core, txi, 1); 830 eic |= igb_txdesc_writeback(core, base, &desc, txi); 831 } 832 833 if (eic) { 834 core->mac[EICR] |= eic; 835 igb_set_interrupt_cause(core, E1000_ICR_TXDW); 836 } 837 } 838 839 static uint32_t 840 igb_rxbufsize(IGBCore *core, const E1000E_RingInfo *r) 841 { 842 uint32_t srrctl = core->mac[E1000_SRRCTL(r->idx) >> 2]; 843 uint32_t bsizepkt = srrctl & E1000_SRRCTL_BSIZEPKT_MASK; 844 if (bsizepkt) { 845 return bsizepkt << E1000_SRRCTL_BSIZEPKT_SHIFT; 846 } 847 848 return e1000x_rxbufsize(core->mac[RCTL]); 849 } 850 851 static bool 852 igb_has_rxbufs(IGBCore *core, const E1000E_RingInfo *r, size_t total_size) 853 { 854 uint32_t bufs = igb_ring_free_descr_num(core, r); 855 uint32_t bufsize = igb_rxbufsize(core, r); 856 857 trace_e1000e_rx_has_buffers(r->idx, bufs, total_size, bufsize); 858 859 return total_size <= bufs / (core->rx_desc_len / E1000_MIN_RX_DESC_LEN) * 860 bufsize; 861 } 862 863 void 864 igb_start_recv(IGBCore *core) 865 { 866 int i; 867 868 trace_e1000e_rx_start_recv(); 869 870 for (i = 0; i <= core->max_queue_num; i++) { 871 qemu_flush_queued_packets(qemu_get_subqueue(core->owner_nic, i)); 872 } 873 } 874 875 bool 876 igb_can_receive(IGBCore *core) 877 { 878 int i; 879 880 if (!e1000x_rx_ready(core->owner, core->mac)) { 881 return false; 882 } 883 884 for (i = 0; i < IGB_NUM_QUEUES; i++) { 885 E1000E_RxRing rxr; 886 if (!(core->mac[RXDCTL0 + (i * 16)] & E1000_RXDCTL_QUEUE_ENABLE)) { 887 continue; 888 } 889 890 igb_rx_ring_init(core, &rxr, i); 891 if (igb_ring_enabled(core, rxr.i) && igb_has_rxbufs(core, rxr.i, 1)) { 892 trace_e1000e_rx_can_recv(); 893 return true; 894 } 895 } 896 897 trace_e1000e_rx_can_recv_rings_full(); 898 return false; 899 } 900 901 ssize_t 902 igb_receive(IGBCore *core, const uint8_t *buf, size_t size) 903 { 904 const struct iovec iov = { 905 .iov_base = (uint8_t *)buf, 906 .iov_len = size 907 }; 908 909 return igb_receive_iov(core, &iov, 1); 910 } 911 912 static inline bool 913 igb_rx_l3_cso_enabled(IGBCore *core) 914 { 915 return !!(core->mac[RXCSUM] & E1000_RXCSUM_IPOFLD); 916 } 917 918 static inline bool 919 igb_rx_l4_cso_enabled(IGBCore *core) 920 { 921 return !!(core->mac[RXCSUM] & E1000_RXCSUM_TUOFLD); 922 } 923 924 static uint16_t igb_receive_assign(IGBCore *core, const struct eth_header *ehdr, 925 E1000E_RSSInfo *rss_info, bool *external_tx) 926 { 927 static const int ta_shift[] = { 4, 3, 2, 0 }; 928 uint32_t f, ra[2], *macp, rctl = core->mac[RCTL]; 929 uint16_t queues = 0; 930 uint16_t vid = lduw_be_p(&PKT_GET_VLAN_HDR(ehdr)->h_tci) & VLAN_VID_MASK; 931 bool accepted = false; 932 int i; 933 934 memset(rss_info, 0, sizeof(E1000E_RSSInfo)); 935 936 if (external_tx) { 937 *external_tx = true; 938 } 939 940 if (e1000x_is_vlan_packet(ehdr, core->mac[VET] & 0xffff) && 941 e1000x_vlan_rx_filter_enabled(core->mac)) { 942 uint32_t vfta = 943 ldl_le_p((uint32_t *)(core->mac + VFTA) + 944 ((vid >> E1000_VFTA_ENTRY_SHIFT) & E1000_VFTA_ENTRY_MASK)); 945 if ((vfta & (1 << (vid & E1000_VFTA_ENTRY_BIT_SHIFT_MASK))) == 0) { 946 trace_e1000e_rx_flt_vlan_mismatch(vid); 947 return queues; 948 } else { 949 trace_e1000e_rx_flt_vlan_match(vid); 950 } 951 } 952 953 if (core->mac[MRQC] & 1) { 954 if (is_broadcast_ether_addr(ehdr->h_dest)) { 955 for (i = 0; i < IGB_NUM_VM_POOLS; i++) { 956 if (core->mac[VMOLR0 + i] & E1000_VMOLR_BAM) { 957 queues |= BIT(i); 958 } 959 } 960 } else { 961 for (macp = core->mac + RA; macp < core->mac + RA + 32; macp += 2) { 962 if (!(macp[1] & E1000_RAH_AV)) { 963 continue; 964 } 965 ra[0] = cpu_to_le32(macp[0]); 966 ra[1] = cpu_to_le32(macp[1]); 967 if (!memcmp(ehdr->h_dest, (uint8_t *)ra, ETH_ALEN)) { 968 queues |= (macp[1] & E1000_RAH_POOL_MASK) / E1000_RAH_POOL_1; 969 } 970 } 971 972 for (macp = core->mac + RA2; macp < core->mac + RA2 + 16; macp += 2) { 973 if (!(macp[1] & E1000_RAH_AV)) { 974 continue; 975 } 976 ra[0] = cpu_to_le32(macp[0]); 977 ra[1] = cpu_to_le32(macp[1]); 978 if (!memcmp(ehdr->h_dest, (uint8_t *)ra, ETH_ALEN)) { 979 queues |= (macp[1] & E1000_RAH_POOL_MASK) / E1000_RAH_POOL_1; 980 } 981 } 982 983 if (!queues) { 984 macp = core->mac + (is_multicast_ether_addr(ehdr->h_dest) ? MTA : UTA); 985 986 f = ta_shift[(rctl >> E1000_RCTL_MO_SHIFT) & 3]; 987 f = (((ehdr->h_dest[5] << 8) | ehdr->h_dest[4]) >> f) & 0xfff; 988 if (macp[f >> 5] & (1 << (f & 0x1f))) { 989 for (i = 0; i < IGB_NUM_VM_POOLS; i++) { 990 if (core->mac[VMOLR0 + i] & E1000_VMOLR_ROMPE) { 991 queues |= BIT(i); 992 } 993 } 994 } 995 } else if (is_unicast_ether_addr(ehdr->h_dest) && external_tx) { 996 *external_tx = false; 997 } 998 } 999 1000 if (e1000x_vlan_rx_filter_enabled(core->mac)) { 1001 uint16_t mask = 0; 1002 1003 if (e1000x_is_vlan_packet(ehdr, core->mac[VET] & 0xffff)) { 1004 for (i = 0; i < E1000_VLVF_ARRAY_SIZE; i++) { 1005 if ((core->mac[VLVF0 + i] & E1000_VLVF_VLANID_MASK) == vid && 1006 (core->mac[VLVF0 + i] & E1000_VLVF_VLANID_ENABLE)) { 1007 uint32_t poolsel = core->mac[VLVF0 + i] & E1000_VLVF_POOLSEL_MASK; 1008 mask |= poolsel >> E1000_VLVF_POOLSEL_SHIFT; 1009 } 1010 } 1011 } else { 1012 for (i = 0; i < IGB_NUM_VM_POOLS; i++) { 1013 if (core->mac[VMOLR0 + i] & E1000_VMOLR_AUPE) { 1014 mask |= BIT(i); 1015 } 1016 } 1017 } 1018 1019 queues &= mask; 1020 } 1021 1022 if (is_unicast_ether_addr(ehdr->h_dest) && !queues && !external_tx && 1023 !(core->mac[VT_CTL] & E1000_VT_CTL_DISABLE_DEF_POOL)) { 1024 uint32_t def_pl = core->mac[VT_CTL] & E1000_VT_CTL_DEFAULT_POOL_MASK; 1025 queues = BIT(def_pl >> E1000_VT_CTL_DEFAULT_POOL_SHIFT); 1026 } 1027 1028 queues &= core->mac[VFRE]; 1029 igb_rss_parse_packet(core, core->rx_pkt, external_tx != NULL, rss_info); 1030 if (rss_info->queue & 1) { 1031 queues <<= 8; 1032 } 1033 } else { 1034 switch (net_rx_pkt_get_packet_type(core->rx_pkt)) { 1035 case ETH_PKT_UCAST: 1036 if (rctl & E1000_RCTL_UPE) { 1037 accepted = true; /* promiscuous ucast */ 1038 } 1039 break; 1040 1041 case ETH_PKT_BCAST: 1042 if (rctl & E1000_RCTL_BAM) { 1043 accepted = true; /* broadcast enabled */ 1044 } 1045 break; 1046 1047 case ETH_PKT_MCAST: 1048 if (rctl & E1000_RCTL_MPE) { 1049 accepted = true; /* promiscuous mcast */ 1050 } 1051 break; 1052 1053 default: 1054 g_assert_not_reached(); 1055 } 1056 1057 if (!accepted) { 1058 accepted = e1000x_rx_group_filter(core->mac, ehdr->h_dest); 1059 } 1060 1061 if (!accepted) { 1062 for (macp = core->mac + RA2; macp < core->mac + RA2 + 16; macp += 2) { 1063 if (!(macp[1] & E1000_RAH_AV)) { 1064 continue; 1065 } 1066 ra[0] = cpu_to_le32(macp[0]); 1067 ra[1] = cpu_to_le32(macp[1]); 1068 if (!memcmp(ehdr->h_dest, (uint8_t *)ra, ETH_ALEN)) { 1069 trace_e1000x_rx_flt_ucast_match((int)(macp - core->mac - RA2) / 2, 1070 MAC_ARG(ehdr->h_dest)); 1071 1072 accepted = true; 1073 break; 1074 } 1075 } 1076 } 1077 1078 if (accepted) { 1079 igb_rss_parse_packet(core, core->rx_pkt, false, rss_info); 1080 queues = BIT(rss_info->queue); 1081 } 1082 } 1083 1084 return queues; 1085 } 1086 1087 static inline void 1088 igb_read_lgcy_rx_descr(IGBCore *core, struct e1000_rx_desc *desc, 1089 hwaddr *buff_addr) 1090 { 1091 *buff_addr = le64_to_cpu(desc->buffer_addr); 1092 } 1093 1094 static inline void 1095 igb_read_adv_rx_descr(IGBCore *core, union e1000_adv_rx_desc *desc, 1096 hwaddr *buff_addr) 1097 { 1098 *buff_addr = le64_to_cpu(desc->read.pkt_addr); 1099 } 1100 1101 static inline void 1102 igb_read_rx_descr(IGBCore *core, union e1000_rx_desc_union *desc, 1103 hwaddr *buff_addr) 1104 { 1105 if (igb_rx_use_legacy_descriptor(core)) { 1106 igb_read_lgcy_rx_descr(core, &desc->legacy, buff_addr); 1107 } else { 1108 igb_read_adv_rx_descr(core, &desc->adv, buff_addr); 1109 } 1110 } 1111 1112 static void 1113 igb_verify_csum_in_sw(IGBCore *core, 1114 struct NetRxPkt *pkt, 1115 uint32_t *status_flags, 1116 EthL4HdrProto l4hdr_proto) 1117 { 1118 bool csum_valid; 1119 uint32_t csum_error; 1120 1121 if (igb_rx_l3_cso_enabled(core)) { 1122 if (!net_rx_pkt_validate_l3_csum(pkt, &csum_valid)) { 1123 trace_e1000e_rx_metadata_l3_csum_validation_failed(); 1124 } else { 1125 csum_error = csum_valid ? 0 : E1000_RXDEXT_STATERR_IPE; 1126 *status_flags |= E1000_RXD_STAT_IPCS | csum_error; 1127 } 1128 } else { 1129 trace_e1000e_rx_metadata_l3_cso_disabled(); 1130 } 1131 1132 if (!igb_rx_l4_cso_enabled(core)) { 1133 trace_e1000e_rx_metadata_l4_cso_disabled(); 1134 return; 1135 } 1136 1137 if (!net_rx_pkt_validate_l4_csum(pkt, &csum_valid)) { 1138 trace_e1000e_rx_metadata_l4_csum_validation_failed(); 1139 return; 1140 } 1141 1142 csum_error = csum_valid ? 0 : E1000_RXDEXT_STATERR_TCPE; 1143 *status_flags |= E1000_RXD_STAT_TCPCS | csum_error; 1144 1145 if (l4hdr_proto == ETH_L4_HDR_PROTO_UDP) { 1146 *status_flags |= E1000_RXD_STAT_UDPCS; 1147 } 1148 } 1149 1150 static void 1151 igb_build_rx_metadata(IGBCore *core, 1152 struct NetRxPkt *pkt, 1153 bool is_eop, 1154 const E1000E_RSSInfo *rss_info, 1155 uint16_t *pkt_info, uint16_t *hdr_info, 1156 uint32_t *rss, 1157 uint32_t *status_flags, 1158 uint16_t *ip_id, 1159 uint16_t *vlan_tag) 1160 { 1161 struct virtio_net_hdr *vhdr; 1162 bool hasip4, hasip6; 1163 EthL4HdrProto l4hdr_proto; 1164 uint32_t pkt_type; 1165 1166 *status_flags = E1000_RXD_STAT_DD; 1167 1168 /* No additional metadata needed for non-EOP descriptors */ 1169 /* TODO: EOP apply only to status so don't skip whole function. */ 1170 if (!is_eop) { 1171 goto func_exit; 1172 } 1173 1174 *status_flags |= E1000_RXD_STAT_EOP; 1175 1176 net_rx_pkt_get_protocols(pkt, &hasip4, &hasip6, &l4hdr_proto); 1177 trace_e1000e_rx_metadata_protocols(hasip4, hasip6, l4hdr_proto); 1178 1179 /* VLAN state */ 1180 if (net_rx_pkt_is_vlan_stripped(pkt)) { 1181 *status_flags |= E1000_RXD_STAT_VP; 1182 *vlan_tag = cpu_to_le16(net_rx_pkt_get_vlan_tag(pkt)); 1183 trace_e1000e_rx_metadata_vlan(*vlan_tag); 1184 } 1185 1186 /* Packet parsing results */ 1187 if ((core->mac[RXCSUM] & E1000_RXCSUM_PCSD) != 0) { 1188 if (rss_info->enabled) { 1189 *rss = cpu_to_le32(rss_info->hash); 1190 trace_igb_rx_metadata_rss(*rss); 1191 } 1192 } else if (hasip4) { 1193 *status_flags |= E1000_RXD_STAT_IPIDV; 1194 *ip_id = cpu_to_le16(net_rx_pkt_get_ip_id(pkt)); 1195 trace_e1000e_rx_metadata_ip_id(*ip_id); 1196 } 1197 1198 if (l4hdr_proto == ETH_L4_HDR_PROTO_TCP && net_rx_pkt_is_tcp_ack(pkt)) { 1199 *status_flags |= E1000_RXD_STAT_ACK; 1200 trace_e1000e_rx_metadata_ack(); 1201 } 1202 1203 if (hasip6 && (core->mac[RFCTL] & E1000_RFCTL_IPV6_DIS)) { 1204 trace_e1000e_rx_metadata_ipv6_filtering_disabled(); 1205 pkt_type = E1000_RXD_PKT_MAC; 1206 } else if (l4hdr_proto == ETH_L4_HDR_PROTO_TCP || 1207 l4hdr_proto == ETH_L4_HDR_PROTO_UDP) { 1208 pkt_type = hasip4 ? E1000_RXD_PKT_IP4_XDP : E1000_RXD_PKT_IP6_XDP; 1209 } else if (hasip4 || hasip6) { 1210 pkt_type = hasip4 ? E1000_RXD_PKT_IP4 : E1000_RXD_PKT_IP6; 1211 } else { 1212 pkt_type = E1000_RXD_PKT_MAC; 1213 } 1214 1215 trace_e1000e_rx_metadata_pkt_type(pkt_type); 1216 1217 if (pkt_info) { 1218 if (rss_info->enabled) { 1219 *pkt_info = rss_info->type; 1220 } 1221 1222 *pkt_info |= (pkt_type << 4); 1223 } else { 1224 *status_flags |= E1000_RXD_PKT_TYPE(pkt_type); 1225 } 1226 1227 if (hdr_info) { 1228 *hdr_info = 0; 1229 } 1230 1231 /* RX CSO information */ 1232 if (hasip6 && (core->mac[RFCTL] & E1000_RFCTL_IPV6_XSUM_DIS)) { 1233 trace_e1000e_rx_metadata_ipv6_sum_disabled(); 1234 goto func_exit; 1235 } 1236 1237 vhdr = net_rx_pkt_get_vhdr(pkt); 1238 1239 if (!(vhdr->flags & VIRTIO_NET_HDR_F_DATA_VALID) && 1240 !(vhdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM)) { 1241 trace_e1000e_rx_metadata_virthdr_no_csum_info(); 1242 igb_verify_csum_in_sw(core, pkt, status_flags, l4hdr_proto); 1243 goto func_exit; 1244 } 1245 1246 if (igb_rx_l3_cso_enabled(core)) { 1247 *status_flags |= hasip4 ? E1000_RXD_STAT_IPCS : 0; 1248 } else { 1249 trace_e1000e_rx_metadata_l3_cso_disabled(); 1250 } 1251 1252 if (igb_rx_l4_cso_enabled(core)) { 1253 switch (l4hdr_proto) { 1254 case ETH_L4_HDR_PROTO_TCP: 1255 *status_flags |= E1000_RXD_STAT_TCPCS; 1256 break; 1257 1258 case ETH_L4_HDR_PROTO_UDP: 1259 *status_flags |= E1000_RXD_STAT_TCPCS | E1000_RXD_STAT_UDPCS; 1260 break; 1261 1262 default: 1263 goto func_exit; 1264 } 1265 } else { 1266 trace_e1000e_rx_metadata_l4_cso_disabled(); 1267 } 1268 1269 trace_e1000e_rx_metadata_status_flags(*status_flags); 1270 1271 func_exit: 1272 *status_flags = cpu_to_le32(*status_flags); 1273 } 1274 1275 static inline void 1276 igb_write_lgcy_rx_descr(IGBCore *core, struct e1000_rx_desc *desc, 1277 struct NetRxPkt *pkt, 1278 const E1000E_RSSInfo *rss_info, 1279 uint16_t length) 1280 { 1281 uint32_t status_flags, rss; 1282 uint16_t ip_id; 1283 1284 assert(!rss_info->enabled); 1285 desc->length = cpu_to_le16(length); 1286 desc->csum = 0; 1287 1288 igb_build_rx_metadata(core, pkt, pkt != NULL, 1289 rss_info, 1290 NULL, NULL, &rss, 1291 &status_flags, &ip_id, 1292 &desc->special); 1293 desc->errors = (uint8_t) (le32_to_cpu(status_flags) >> 24); 1294 desc->status = (uint8_t) le32_to_cpu(status_flags); 1295 } 1296 1297 static inline void 1298 igb_write_adv_rx_descr(IGBCore *core, union e1000_adv_rx_desc *desc, 1299 struct NetRxPkt *pkt, 1300 const E1000E_RSSInfo *rss_info, 1301 uint16_t length) 1302 { 1303 memset(&desc->wb, 0, sizeof(desc->wb)); 1304 1305 desc->wb.upper.length = cpu_to_le16(length); 1306 1307 igb_build_rx_metadata(core, pkt, pkt != NULL, 1308 rss_info, 1309 &desc->wb.lower.lo_dword.pkt_info, 1310 &desc->wb.lower.lo_dword.hdr_info, 1311 &desc->wb.lower.hi_dword.rss, 1312 &desc->wb.upper.status_error, 1313 &desc->wb.lower.hi_dword.csum_ip.ip_id, 1314 &desc->wb.upper.vlan); 1315 } 1316 1317 static inline void 1318 igb_write_rx_descr(IGBCore *core, union e1000_rx_desc_union *desc, 1319 struct NetRxPkt *pkt, const E1000E_RSSInfo *rss_info, uint16_t length) 1320 { 1321 if (igb_rx_use_legacy_descriptor(core)) { 1322 igb_write_lgcy_rx_descr(core, &desc->legacy, pkt, rss_info, length); 1323 } else { 1324 igb_write_adv_rx_descr(core, &desc->adv, pkt, rss_info, length); 1325 } 1326 } 1327 1328 static inline void 1329 igb_pci_dma_write_rx_desc(IGBCore *core, PCIDevice *dev, dma_addr_t addr, 1330 union e1000_rx_desc_union *desc, dma_addr_t len) 1331 { 1332 if (igb_rx_use_legacy_descriptor(core)) { 1333 struct e1000_rx_desc *d = &desc->legacy; 1334 size_t offset = offsetof(struct e1000_rx_desc, status); 1335 uint8_t status = d->status; 1336 1337 d->status &= ~E1000_RXD_STAT_DD; 1338 pci_dma_write(dev, addr, desc, len); 1339 1340 if (status & E1000_RXD_STAT_DD) { 1341 d->status = status; 1342 pci_dma_write(dev, addr + offset, &status, sizeof(status)); 1343 } 1344 } else { 1345 union e1000_adv_rx_desc *d = &desc->adv; 1346 size_t offset = 1347 offsetof(union e1000_adv_rx_desc, wb.upper.status_error); 1348 uint32_t status = d->wb.upper.status_error; 1349 1350 d->wb.upper.status_error &= ~E1000_RXD_STAT_DD; 1351 pci_dma_write(dev, addr, desc, len); 1352 1353 if (status & E1000_RXD_STAT_DD) { 1354 d->wb.upper.status_error = status; 1355 pci_dma_write(dev, addr + offset, &status, sizeof(status)); 1356 } 1357 } 1358 } 1359 1360 static void 1361 igb_write_to_rx_buffers(IGBCore *core, 1362 PCIDevice *d, 1363 hwaddr ba, 1364 uint16_t *written, 1365 const char *data, 1366 dma_addr_t data_len) 1367 { 1368 trace_igb_rx_desc_buff_write(ba, *written, data, data_len); 1369 pci_dma_write(d, ba + *written, data, data_len); 1370 *written += data_len; 1371 } 1372 1373 static void 1374 igb_update_rx_stats(IGBCore *core, size_t data_size, size_t data_fcs_size) 1375 { 1376 e1000x_update_rx_total_stats(core->mac, data_size, data_fcs_size); 1377 1378 switch (net_rx_pkt_get_packet_type(core->rx_pkt)) { 1379 case ETH_PKT_BCAST: 1380 e1000x_inc_reg_if_not_full(core->mac, BPRC); 1381 break; 1382 1383 case ETH_PKT_MCAST: 1384 e1000x_inc_reg_if_not_full(core->mac, MPRC); 1385 break; 1386 1387 default: 1388 break; 1389 } 1390 } 1391 1392 static inline bool 1393 igb_rx_descr_threshold_hit(IGBCore *core, const E1000E_RingInfo *rxi) 1394 { 1395 return igb_ring_free_descr_num(core, rxi) == 1396 ((core->mac[E1000_SRRCTL(rxi->idx) >> 2] >> 20) & 31) * 16; 1397 } 1398 1399 static void 1400 igb_write_packet_to_guest(IGBCore *core, struct NetRxPkt *pkt, 1401 const E1000E_RxRing *rxr, 1402 const E1000E_RSSInfo *rss_info) 1403 { 1404 PCIDevice *d; 1405 dma_addr_t base; 1406 union e1000_rx_desc_union desc; 1407 size_t desc_size; 1408 size_t desc_offset = 0; 1409 size_t iov_ofs = 0; 1410 1411 struct iovec *iov = net_rx_pkt_get_iovec(pkt); 1412 size_t size = net_rx_pkt_get_total_len(pkt); 1413 size_t total_size = size + e1000x_fcs_len(core->mac); 1414 const E1000E_RingInfo *rxi = rxr->i; 1415 size_t bufsize = igb_rxbufsize(core, rxi); 1416 1417 d = pcie_sriov_get_vf_at_index(core->owner, rxi->idx % 8); 1418 if (!d) { 1419 d = core->owner; 1420 } 1421 1422 do { 1423 hwaddr ba; 1424 uint16_t written = 0; 1425 bool is_last = false; 1426 1427 desc_size = total_size - desc_offset; 1428 1429 if (desc_size > bufsize) { 1430 desc_size = bufsize; 1431 } 1432 1433 if (igb_ring_empty(core, rxi)) { 1434 return; 1435 } 1436 1437 base = igb_ring_head_descr(core, rxi); 1438 1439 pci_dma_read(d, base, &desc, core->rx_desc_len); 1440 1441 trace_e1000e_rx_descr(rxi->idx, base, core->rx_desc_len); 1442 1443 igb_read_rx_descr(core, &desc, &ba); 1444 1445 if (ba) { 1446 if (desc_offset < size) { 1447 static const uint32_t fcs_pad; 1448 size_t iov_copy; 1449 size_t copy_size = size - desc_offset; 1450 if (copy_size > bufsize) { 1451 copy_size = bufsize; 1452 } 1453 1454 /* Copy packet payload */ 1455 while (copy_size) { 1456 iov_copy = MIN(copy_size, iov->iov_len - iov_ofs); 1457 1458 igb_write_to_rx_buffers(core, d, ba, &written, 1459 iov->iov_base + iov_ofs, iov_copy); 1460 1461 copy_size -= iov_copy; 1462 iov_ofs += iov_copy; 1463 if (iov_ofs == iov->iov_len) { 1464 iov++; 1465 iov_ofs = 0; 1466 } 1467 } 1468 1469 if (desc_offset + desc_size >= total_size) { 1470 /* Simulate FCS checksum presence in the last descriptor */ 1471 igb_write_to_rx_buffers(core, d, ba, &written, 1472 (const char *) &fcs_pad, e1000x_fcs_len(core->mac)); 1473 } 1474 } 1475 } else { /* as per intel docs; skip descriptors with null buf addr */ 1476 trace_e1000e_rx_null_descriptor(); 1477 } 1478 desc_offset += desc_size; 1479 if (desc_offset >= total_size) { 1480 is_last = true; 1481 } 1482 1483 igb_write_rx_descr(core, &desc, is_last ? core->rx_pkt : NULL, 1484 rss_info, written); 1485 igb_pci_dma_write_rx_desc(core, d, base, &desc, core->rx_desc_len); 1486 1487 igb_ring_advance(core, rxi, core->rx_desc_len / E1000_MIN_RX_DESC_LEN); 1488 1489 } while (desc_offset < total_size); 1490 1491 igb_update_rx_stats(core, size, total_size); 1492 } 1493 1494 static inline void 1495 igb_rx_fix_l4_csum(IGBCore *core, struct NetRxPkt *pkt) 1496 { 1497 struct virtio_net_hdr *vhdr = net_rx_pkt_get_vhdr(pkt); 1498 1499 if (vhdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) { 1500 net_rx_pkt_fix_l4_csum(pkt); 1501 } 1502 } 1503 1504 ssize_t 1505 igb_receive_iov(IGBCore *core, const struct iovec *iov, int iovcnt) 1506 { 1507 return igb_receive_internal(core, iov, iovcnt, core->has_vnet, NULL); 1508 } 1509 1510 static ssize_t 1511 igb_receive_internal(IGBCore *core, const struct iovec *iov, int iovcnt, 1512 bool has_vnet, bool *external_tx) 1513 { 1514 static const int maximum_ethernet_hdr_len = (ETH_HLEN + 4); 1515 1516 uint16_t queues = 0; 1517 uint32_t n = 0; 1518 uint8_t min_buf[ETH_ZLEN]; 1519 struct iovec min_iov; 1520 struct eth_header *ehdr; 1521 uint8_t *filter_buf; 1522 size_t size, orig_size; 1523 size_t iov_ofs = 0; 1524 E1000E_RxRing rxr; 1525 E1000E_RSSInfo rss_info; 1526 size_t total_size; 1527 int i; 1528 1529 trace_e1000e_rx_receive_iov(iovcnt); 1530 1531 if (external_tx) { 1532 *external_tx = true; 1533 } 1534 1535 if (!e1000x_hw_rx_enabled(core->mac)) { 1536 return -1; 1537 } 1538 1539 /* Pull virtio header in */ 1540 if (has_vnet) { 1541 net_rx_pkt_set_vhdr_iovec(core->rx_pkt, iov, iovcnt); 1542 iov_ofs = sizeof(struct virtio_net_hdr); 1543 } else { 1544 net_rx_pkt_unset_vhdr(core->rx_pkt); 1545 } 1546 1547 filter_buf = iov->iov_base + iov_ofs; 1548 orig_size = iov_size(iov, iovcnt); 1549 size = orig_size - iov_ofs; 1550 1551 /* Pad to minimum Ethernet frame length */ 1552 if (size < sizeof(min_buf)) { 1553 iov_to_buf(iov, iovcnt, iov_ofs, min_buf, size); 1554 memset(&min_buf[size], 0, sizeof(min_buf) - size); 1555 e1000x_inc_reg_if_not_full(core->mac, RUC); 1556 min_iov.iov_base = filter_buf = min_buf; 1557 min_iov.iov_len = size = sizeof(min_buf); 1558 iovcnt = 1; 1559 iov = &min_iov; 1560 iov_ofs = 0; 1561 } else if (iov->iov_len < maximum_ethernet_hdr_len) { 1562 /* This is very unlikely, but may happen. */ 1563 iov_to_buf(iov, iovcnt, iov_ofs, min_buf, maximum_ethernet_hdr_len); 1564 filter_buf = min_buf; 1565 } 1566 1567 /* Discard oversized packets if !LPE and !SBP. */ 1568 if (e1000x_is_oversized(core->mac, size)) { 1569 return orig_size; 1570 } 1571 1572 ehdr = PKT_GET_ETH_HDR(filter_buf); 1573 net_rx_pkt_set_packet_type(core->rx_pkt, get_eth_packet_type(ehdr)); 1574 1575 net_rx_pkt_attach_iovec_ex(core->rx_pkt, iov, iovcnt, iov_ofs, 1576 e1000x_vlan_enabled(core->mac), 1577 core->mac[VET] & 0xffff); 1578 1579 queues = igb_receive_assign(core, ehdr, &rss_info, external_tx); 1580 if (!queues) { 1581 trace_e1000e_rx_flt_dropped(); 1582 return orig_size; 1583 } 1584 1585 total_size = net_rx_pkt_get_total_len(core->rx_pkt) + 1586 e1000x_fcs_len(core->mac); 1587 1588 for (i = 0; i < IGB_NUM_QUEUES; i++) { 1589 if (!(queues & BIT(i)) || 1590 !(core->mac[RXDCTL0 + (i * 16)] & E1000_RXDCTL_QUEUE_ENABLE)) { 1591 continue; 1592 } 1593 1594 igb_rx_ring_init(core, &rxr, i); 1595 1596 if (!igb_has_rxbufs(core, rxr.i, total_size)) { 1597 n |= E1000_ICS_RXO; 1598 trace_e1000e_rx_not_written_to_guest(rxr.i->idx); 1599 continue; 1600 } 1601 1602 n |= E1000_ICR_RXDW; 1603 1604 igb_rx_fix_l4_csum(core, core->rx_pkt); 1605 igb_write_packet_to_guest(core, core->rx_pkt, &rxr, &rss_info); 1606 1607 /* Check if receive descriptor minimum threshold hit */ 1608 if (igb_rx_descr_threshold_hit(core, rxr.i)) { 1609 n |= E1000_ICS_RXDMT0; 1610 } 1611 1612 core->mac[EICR] |= igb_rx_wb_eic(core, rxr.i->idx); 1613 1614 trace_e1000e_rx_written_to_guest(rxr.i->idx); 1615 } 1616 1617 trace_e1000e_rx_interrupt_set(n); 1618 igb_set_interrupt_cause(core, n); 1619 1620 return orig_size; 1621 } 1622 1623 static inline bool 1624 igb_have_autoneg(IGBCore *core) 1625 { 1626 return core->phy[MII_BMCR] & MII_BMCR_AUTOEN; 1627 } 1628 1629 static void igb_update_flowctl_status(IGBCore *core) 1630 { 1631 if (igb_have_autoneg(core) && core->phy[MII_BMSR] & MII_BMSR_AN_COMP) { 1632 trace_e1000e_link_autoneg_flowctl(true); 1633 core->mac[CTRL] |= E1000_CTRL_TFCE | E1000_CTRL_RFCE; 1634 } else { 1635 trace_e1000e_link_autoneg_flowctl(false); 1636 } 1637 } 1638 1639 static inline void 1640 igb_link_down(IGBCore *core) 1641 { 1642 e1000x_update_regs_on_link_down(core->mac, core->phy); 1643 igb_update_flowctl_status(core); 1644 } 1645 1646 static inline void 1647 igb_set_phy_ctrl(IGBCore *core, uint16_t val) 1648 { 1649 /* bits 0-5 reserved; MII_BMCR_[ANRESTART,RESET] are self clearing */ 1650 core->phy[MII_BMCR] = val & ~(0x3f | MII_BMCR_RESET | MII_BMCR_ANRESTART); 1651 1652 if ((val & MII_BMCR_ANRESTART) && igb_have_autoneg(core)) { 1653 e1000x_restart_autoneg(core->mac, core->phy, core->autoneg_timer); 1654 } 1655 } 1656 1657 void igb_core_set_link_status(IGBCore *core) 1658 { 1659 NetClientState *nc = qemu_get_queue(core->owner_nic); 1660 uint32_t old_status = core->mac[STATUS]; 1661 1662 trace_e1000e_link_status_changed(nc->link_down ? false : true); 1663 1664 if (nc->link_down) { 1665 e1000x_update_regs_on_link_down(core->mac, core->phy); 1666 } else { 1667 if (igb_have_autoneg(core) && 1668 !(core->phy[MII_BMSR] & MII_BMSR_AN_COMP)) { 1669 e1000x_restart_autoneg(core->mac, core->phy, 1670 core->autoneg_timer); 1671 } else { 1672 e1000x_update_regs_on_link_up(core->mac, core->phy); 1673 igb_start_recv(core); 1674 } 1675 } 1676 1677 if (core->mac[STATUS] != old_status) { 1678 igb_set_interrupt_cause(core, E1000_ICR_LSC); 1679 } 1680 } 1681 1682 static void 1683 igb_set_ctrl(IGBCore *core, int index, uint32_t val) 1684 { 1685 trace_e1000e_core_ctrl_write(index, val); 1686 1687 /* RST is self clearing */ 1688 core->mac[CTRL] = val & ~E1000_CTRL_RST; 1689 core->mac[CTRL_DUP] = core->mac[CTRL]; 1690 1691 trace_e1000e_link_set_params( 1692 !!(val & E1000_CTRL_ASDE), 1693 (val & E1000_CTRL_SPD_SEL) >> E1000_CTRL_SPD_SHIFT, 1694 !!(val & E1000_CTRL_FRCSPD), 1695 !!(val & E1000_CTRL_FRCDPX), 1696 !!(val & E1000_CTRL_RFCE), 1697 !!(val & E1000_CTRL_TFCE)); 1698 1699 if (val & E1000_CTRL_RST) { 1700 trace_e1000e_core_ctrl_sw_reset(); 1701 igb_reset(core, true); 1702 } 1703 1704 if (val & E1000_CTRL_PHY_RST) { 1705 trace_e1000e_core_ctrl_phy_reset(); 1706 core->mac[STATUS] |= E1000_STATUS_PHYRA; 1707 } 1708 } 1709 1710 static void 1711 igb_set_rfctl(IGBCore *core, int index, uint32_t val) 1712 { 1713 trace_e1000e_rx_set_rfctl(val); 1714 1715 if (!(val & E1000_RFCTL_ISCSI_DIS)) { 1716 trace_e1000e_wrn_iscsi_filtering_not_supported(); 1717 } 1718 1719 if (!(val & E1000_RFCTL_NFSW_DIS)) { 1720 trace_e1000e_wrn_nfsw_filtering_not_supported(); 1721 } 1722 1723 if (!(val & E1000_RFCTL_NFSR_DIS)) { 1724 trace_e1000e_wrn_nfsr_filtering_not_supported(); 1725 } 1726 1727 core->mac[RFCTL] = val; 1728 } 1729 1730 static void 1731 igb_calc_rxdesclen(IGBCore *core) 1732 { 1733 if (igb_rx_use_legacy_descriptor(core)) { 1734 core->rx_desc_len = sizeof(struct e1000_rx_desc); 1735 } else { 1736 core->rx_desc_len = sizeof(union e1000_adv_rx_desc); 1737 } 1738 trace_e1000e_rx_desc_len(core->rx_desc_len); 1739 } 1740 1741 static void 1742 igb_set_rx_control(IGBCore *core, int index, uint32_t val) 1743 { 1744 core->mac[RCTL] = val; 1745 trace_e1000e_rx_set_rctl(core->mac[RCTL]); 1746 1747 if (val & E1000_RCTL_DTYP_MASK) { 1748 qemu_log_mask(LOG_GUEST_ERROR, 1749 "igb: RCTL.DTYP must be zero for compatibility"); 1750 } 1751 1752 if (val & E1000_RCTL_EN) { 1753 igb_calc_rxdesclen(core); 1754 igb_start_recv(core); 1755 } 1756 } 1757 1758 static inline void 1759 igb_clear_ims_bits(IGBCore *core, uint32_t bits) 1760 { 1761 trace_e1000e_irq_clear_ims(bits, core->mac[IMS], core->mac[IMS] & ~bits); 1762 core->mac[IMS] &= ~bits; 1763 } 1764 1765 static inline bool 1766 igb_postpone_interrupt(IGBIntrDelayTimer *timer) 1767 { 1768 if (timer->running) { 1769 trace_e1000e_irq_postponed_by_xitr(timer->delay_reg << 2); 1770 1771 return true; 1772 } 1773 1774 if (timer->core->mac[timer->delay_reg] != 0) { 1775 igb_intrmgr_rearm_timer(timer); 1776 } 1777 1778 return false; 1779 } 1780 1781 static inline bool 1782 igb_eitr_should_postpone(IGBCore *core, int idx) 1783 { 1784 return igb_postpone_interrupt(&core->eitr[idx]); 1785 } 1786 1787 static void igb_send_msix(IGBCore *core) 1788 { 1789 uint32_t causes = core->mac[EICR] & core->mac[EIMS]; 1790 uint32_t effective_eiac; 1791 int vector; 1792 1793 for (vector = 0; vector < IGB_INTR_NUM; ++vector) { 1794 if ((causes & BIT(vector)) && !igb_eitr_should_postpone(core, vector)) { 1795 1796 trace_e1000e_irq_msix_notify_vec(vector); 1797 igb_msix_notify(core, vector); 1798 1799 trace_e1000e_irq_icr_clear_eiac(core->mac[EICR], core->mac[EIAC]); 1800 effective_eiac = core->mac[EIAC] & BIT(vector); 1801 core->mac[EICR] &= ~effective_eiac; 1802 } 1803 } 1804 } 1805 1806 static inline void 1807 igb_fix_icr_asserted(IGBCore *core) 1808 { 1809 core->mac[ICR] &= ~E1000_ICR_ASSERTED; 1810 if (core->mac[ICR]) { 1811 core->mac[ICR] |= E1000_ICR_ASSERTED; 1812 } 1813 1814 trace_e1000e_irq_fix_icr_asserted(core->mac[ICR]); 1815 } 1816 1817 static void 1818 igb_update_interrupt_state(IGBCore *core) 1819 { 1820 uint32_t icr; 1821 uint32_t causes; 1822 uint32_t int_alloc; 1823 1824 icr = core->mac[ICR] & core->mac[IMS]; 1825 1826 if (msix_enabled(core->owner)) { 1827 if (icr) { 1828 causes = 0; 1829 if (icr & E1000_ICR_DRSTA) { 1830 int_alloc = core->mac[IVAR_MISC] & 0xff; 1831 if (int_alloc & E1000_IVAR_VALID) { 1832 causes |= BIT(int_alloc & 0x1f); 1833 } 1834 } 1835 /* Check if other bits (excluding the TCP Timer) are enabled. */ 1836 if (icr & ~E1000_ICR_DRSTA) { 1837 int_alloc = (core->mac[IVAR_MISC] >> 8) & 0xff; 1838 if (int_alloc & E1000_IVAR_VALID) { 1839 causes |= BIT(int_alloc & 0x1f); 1840 } 1841 trace_e1000e_irq_add_msi_other(core->mac[EICR]); 1842 } 1843 core->mac[EICR] |= causes; 1844 } 1845 1846 if ((core->mac[EICR] & core->mac[EIMS])) { 1847 igb_send_msix(core); 1848 } 1849 } else { 1850 igb_fix_icr_asserted(core); 1851 1852 if (icr) { 1853 core->mac[EICR] |= (icr & E1000_ICR_DRSTA) | E1000_EICR_OTHER; 1854 } else { 1855 core->mac[EICR] &= ~E1000_EICR_OTHER; 1856 } 1857 1858 trace_e1000e_irq_pending_interrupts(core->mac[ICR] & core->mac[IMS], 1859 core->mac[ICR], core->mac[IMS]); 1860 1861 if (msi_enabled(core->owner)) { 1862 if (icr) { 1863 msi_notify(core->owner, 0); 1864 } 1865 } else { 1866 if (icr) { 1867 igb_raise_legacy_irq(core); 1868 } else { 1869 igb_lower_legacy_irq(core); 1870 } 1871 } 1872 } 1873 } 1874 1875 static void 1876 igb_set_interrupt_cause(IGBCore *core, uint32_t val) 1877 { 1878 trace_e1000e_irq_set_cause_entry(val, core->mac[ICR]); 1879 1880 core->mac[ICR] |= val; 1881 1882 trace_e1000e_irq_set_cause_exit(val, core->mac[ICR]); 1883 1884 igb_update_interrupt_state(core); 1885 } 1886 1887 static void igb_set_eics(IGBCore *core, int index, uint32_t val) 1888 { 1889 bool msix = !!(core->mac[GPIE] & E1000_GPIE_MSIX_MODE); 1890 1891 trace_igb_irq_write_eics(val, msix); 1892 1893 core->mac[EICS] |= 1894 val & (msix ? E1000_EICR_MSIX_MASK : E1000_EICR_LEGACY_MASK); 1895 1896 /* 1897 * TODO: Move to igb_update_interrupt_state if EICS is modified in other 1898 * places. 1899 */ 1900 core->mac[EICR] = core->mac[EICS]; 1901 1902 igb_update_interrupt_state(core); 1903 } 1904 1905 static void igb_set_eims(IGBCore *core, int index, uint32_t val) 1906 { 1907 bool msix = !!(core->mac[GPIE] & E1000_GPIE_MSIX_MODE); 1908 1909 trace_igb_irq_write_eims(val, msix); 1910 1911 core->mac[EIMS] |= 1912 val & (msix ? E1000_EICR_MSIX_MASK : E1000_EICR_LEGACY_MASK); 1913 1914 igb_update_interrupt_state(core); 1915 } 1916 1917 static void mailbox_interrupt_to_vf(IGBCore *core, uint16_t vfn) 1918 { 1919 uint32_t ent = core->mac[VTIVAR_MISC + vfn]; 1920 1921 if ((ent & E1000_IVAR_VALID)) { 1922 core->mac[EICR] |= (ent & 0x3) << (22 - vfn * IGBVF_MSIX_VEC_NUM); 1923 igb_update_interrupt_state(core); 1924 } 1925 } 1926 1927 static void mailbox_interrupt_to_pf(IGBCore *core) 1928 { 1929 igb_set_interrupt_cause(core, E1000_ICR_VMMB); 1930 } 1931 1932 static void igb_set_pfmailbox(IGBCore *core, int index, uint32_t val) 1933 { 1934 uint16_t vfn = index - P2VMAILBOX0; 1935 1936 trace_igb_set_pfmailbox(vfn, val); 1937 1938 if (val & E1000_P2VMAILBOX_STS) { 1939 core->mac[V2PMAILBOX0 + vfn] |= E1000_V2PMAILBOX_PFSTS; 1940 mailbox_interrupt_to_vf(core, vfn); 1941 } 1942 1943 if (val & E1000_P2VMAILBOX_ACK) { 1944 core->mac[V2PMAILBOX0 + vfn] |= E1000_V2PMAILBOX_PFACK; 1945 mailbox_interrupt_to_vf(core, vfn); 1946 } 1947 1948 /* Buffer Taken by PF (can be set only if the VFU is cleared). */ 1949 if (val & E1000_P2VMAILBOX_PFU) { 1950 if (!(core->mac[index] & E1000_P2VMAILBOX_VFU)) { 1951 core->mac[index] |= E1000_P2VMAILBOX_PFU; 1952 core->mac[V2PMAILBOX0 + vfn] |= E1000_V2PMAILBOX_PFU; 1953 } 1954 } else { 1955 core->mac[index] &= ~E1000_P2VMAILBOX_PFU; 1956 core->mac[V2PMAILBOX0 + vfn] &= ~E1000_V2PMAILBOX_PFU; 1957 } 1958 1959 if (val & E1000_P2VMAILBOX_RVFU) { 1960 core->mac[V2PMAILBOX0 + vfn] &= ~E1000_V2PMAILBOX_VFU; 1961 core->mac[MBVFICR] &= ~((E1000_MBVFICR_VFACK_VF1 << vfn) | 1962 (E1000_MBVFICR_VFREQ_VF1 << vfn)); 1963 } 1964 } 1965 1966 static void igb_set_vfmailbox(IGBCore *core, int index, uint32_t val) 1967 { 1968 uint16_t vfn = index - V2PMAILBOX0; 1969 1970 trace_igb_set_vfmailbox(vfn, val); 1971 1972 if (val & E1000_V2PMAILBOX_REQ) { 1973 core->mac[MBVFICR] |= E1000_MBVFICR_VFREQ_VF1 << vfn; 1974 mailbox_interrupt_to_pf(core); 1975 } 1976 1977 if (val & E1000_V2PMAILBOX_ACK) { 1978 core->mac[MBVFICR] |= E1000_MBVFICR_VFACK_VF1 << vfn; 1979 mailbox_interrupt_to_pf(core); 1980 } 1981 1982 /* Buffer Taken by VF (can be set only if the PFU is cleared). */ 1983 if (val & E1000_V2PMAILBOX_VFU) { 1984 if (!(core->mac[index] & E1000_V2PMAILBOX_PFU)) { 1985 core->mac[index] |= E1000_V2PMAILBOX_VFU; 1986 core->mac[P2VMAILBOX0 + vfn] |= E1000_P2VMAILBOX_VFU; 1987 } 1988 } else { 1989 core->mac[index] &= ~E1000_V2PMAILBOX_VFU; 1990 core->mac[P2VMAILBOX0 + vfn] &= ~E1000_P2VMAILBOX_VFU; 1991 } 1992 } 1993 1994 static void igb_vf_reset(IGBCore *core, uint16_t vfn) 1995 { 1996 uint16_t qn0 = vfn; 1997 uint16_t qn1 = vfn + IGB_NUM_VM_POOLS; 1998 1999 /* disable Rx and Tx for the VF*/ 2000 core->mac[RXDCTL0 + (qn0 * 16)] &= ~E1000_RXDCTL_QUEUE_ENABLE; 2001 core->mac[RXDCTL0 + (qn1 * 16)] &= ~E1000_RXDCTL_QUEUE_ENABLE; 2002 core->mac[TXDCTL0 + (qn0 * 16)] &= ~E1000_TXDCTL_QUEUE_ENABLE; 2003 core->mac[TXDCTL0 + (qn1 * 16)] &= ~E1000_TXDCTL_QUEUE_ENABLE; 2004 core->mac[VFRE] &= ~BIT(vfn); 2005 core->mac[VFTE] &= ~BIT(vfn); 2006 /* indicate VF reset to PF */ 2007 core->mac[VFLRE] |= BIT(vfn); 2008 /* VFLRE and mailbox use the same interrupt cause */ 2009 mailbox_interrupt_to_pf(core); 2010 } 2011 2012 static void igb_w1c(IGBCore *core, int index, uint32_t val) 2013 { 2014 core->mac[index] &= ~val; 2015 } 2016 2017 static void igb_set_eimc(IGBCore *core, int index, uint32_t val) 2018 { 2019 bool msix = !!(core->mac[GPIE] & E1000_GPIE_MSIX_MODE); 2020 2021 /* Interrupts are disabled via a write to EIMC and reflected in EIMS. */ 2022 core->mac[EIMS] &= 2023 ~(val & (msix ? E1000_EICR_MSIX_MASK : E1000_EICR_LEGACY_MASK)); 2024 2025 trace_igb_irq_write_eimc(val, core->mac[EIMS], msix); 2026 igb_update_interrupt_state(core); 2027 } 2028 2029 static void igb_set_eiac(IGBCore *core, int index, uint32_t val) 2030 { 2031 bool msix = !!(core->mac[GPIE] & E1000_GPIE_MSIX_MODE); 2032 2033 if (msix) { 2034 trace_igb_irq_write_eiac(val); 2035 2036 /* 2037 * TODO: When using IOV, the bits that correspond to MSI-X vectors 2038 * that are assigned to a VF are read-only. 2039 */ 2040 core->mac[EIAC] |= (val & E1000_EICR_MSIX_MASK); 2041 } 2042 } 2043 2044 static void igb_set_eiam(IGBCore *core, int index, uint32_t val) 2045 { 2046 bool msix = !!(core->mac[GPIE] & E1000_GPIE_MSIX_MODE); 2047 2048 /* 2049 * TODO: When using IOV, the bits that correspond to MSI-X vectors that 2050 * are assigned to a VF are read-only. 2051 */ 2052 core->mac[EIAM] |= 2053 ~(val & (msix ? E1000_EICR_MSIX_MASK : E1000_EICR_LEGACY_MASK)); 2054 2055 trace_igb_irq_write_eiam(val, msix); 2056 } 2057 2058 static void igb_set_eicr(IGBCore *core, int index, uint32_t val) 2059 { 2060 bool msix = !!(core->mac[GPIE] & E1000_GPIE_MSIX_MODE); 2061 2062 /* 2063 * TODO: In IOV mode, only bit zero of this vector is available for the PF 2064 * function. 2065 */ 2066 core->mac[EICR] &= 2067 ~(val & (msix ? E1000_EICR_MSIX_MASK : E1000_EICR_LEGACY_MASK)); 2068 2069 trace_igb_irq_write_eicr(val, msix); 2070 igb_update_interrupt_state(core); 2071 } 2072 2073 static void igb_set_vtctrl(IGBCore *core, int index, uint32_t val) 2074 { 2075 uint16_t vfn; 2076 2077 if (val & E1000_CTRL_RST) { 2078 vfn = (index - PVTCTRL0) / 0x40; 2079 igb_vf_reset(core, vfn); 2080 } 2081 } 2082 2083 static void igb_set_vteics(IGBCore *core, int index, uint32_t val) 2084 { 2085 uint16_t vfn = (index - PVTEICS0) / 0x40; 2086 2087 core->mac[index] = val; 2088 igb_set_eics(core, EICS, (val & 0x7) << (22 - vfn * IGBVF_MSIX_VEC_NUM)); 2089 } 2090 2091 static void igb_set_vteims(IGBCore *core, int index, uint32_t val) 2092 { 2093 uint16_t vfn = (index - PVTEIMS0) / 0x40; 2094 2095 core->mac[index] = val; 2096 igb_set_eims(core, EIMS, (val & 0x7) << (22 - vfn * IGBVF_MSIX_VEC_NUM)); 2097 } 2098 2099 static void igb_set_vteimc(IGBCore *core, int index, uint32_t val) 2100 { 2101 uint16_t vfn = (index - PVTEIMC0) / 0x40; 2102 2103 core->mac[index] = val; 2104 igb_set_eimc(core, EIMC, (val & 0x7) << (22 - vfn * IGBVF_MSIX_VEC_NUM)); 2105 } 2106 2107 static void igb_set_vteiac(IGBCore *core, int index, uint32_t val) 2108 { 2109 uint16_t vfn = (index - PVTEIAC0) / 0x40; 2110 2111 core->mac[index] = val; 2112 igb_set_eiac(core, EIAC, (val & 0x7) << (22 - vfn * IGBVF_MSIX_VEC_NUM)); 2113 } 2114 2115 static void igb_set_vteiam(IGBCore *core, int index, uint32_t val) 2116 { 2117 uint16_t vfn = (index - PVTEIAM0) / 0x40; 2118 2119 core->mac[index] = val; 2120 igb_set_eiam(core, EIAM, (val & 0x7) << (22 - vfn * IGBVF_MSIX_VEC_NUM)); 2121 } 2122 2123 static void igb_set_vteicr(IGBCore *core, int index, uint32_t val) 2124 { 2125 uint16_t vfn = (index - PVTEICR0) / 0x40; 2126 2127 core->mac[index] = val; 2128 igb_set_eicr(core, EICR, (val & 0x7) << (22 - vfn * IGBVF_MSIX_VEC_NUM)); 2129 } 2130 2131 static void igb_set_vtivar(IGBCore *core, int index, uint32_t val) 2132 { 2133 uint16_t vfn = (index - VTIVAR); 2134 uint16_t qn = vfn; 2135 uint8_t ent; 2136 int n; 2137 2138 core->mac[index] = val; 2139 2140 /* Get assigned vector associated with queue Rx#0. */ 2141 if ((val & E1000_IVAR_VALID)) { 2142 n = igb_ivar_entry_rx(qn); 2143 ent = E1000_IVAR_VALID | (24 - vfn * IGBVF_MSIX_VEC_NUM - (2 - (val & 0x7))); 2144 core->mac[IVAR0 + n / 4] |= ent << 8 * (n % 4); 2145 } 2146 2147 /* Get assigned vector associated with queue Tx#0 */ 2148 ent = val >> 8; 2149 if ((ent & E1000_IVAR_VALID)) { 2150 n = igb_ivar_entry_tx(qn); 2151 ent = E1000_IVAR_VALID | (24 - vfn * IGBVF_MSIX_VEC_NUM - (2 - (ent & 0x7))); 2152 core->mac[IVAR0 + n / 4] |= ent << 8 * (n % 4); 2153 } 2154 2155 /* 2156 * Ignoring assigned vectors associated with queues Rx#1 and Tx#1 for now. 2157 */ 2158 } 2159 2160 static inline void 2161 igb_autoneg_timer(void *opaque) 2162 { 2163 IGBCore *core = opaque; 2164 if (!qemu_get_queue(core->owner_nic)->link_down) { 2165 e1000x_update_regs_on_autoneg_done(core->mac, core->phy); 2166 igb_start_recv(core); 2167 2168 igb_update_flowctl_status(core); 2169 /* signal link status change to the guest */ 2170 igb_set_interrupt_cause(core, E1000_ICR_LSC); 2171 } 2172 } 2173 2174 static inline uint16_t 2175 igb_get_reg_index_with_offset(const uint16_t *mac_reg_access, hwaddr addr) 2176 { 2177 uint16_t index = (addr & 0x1ffff) >> 2; 2178 return index + (mac_reg_access[index] & 0xfffe); 2179 } 2180 2181 static const char igb_phy_regcap[MAX_PHY_REG_ADDRESS + 1] = { 2182 [MII_BMCR] = PHY_RW, 2183 [MII_BMSR] = PHY_R, 2184 [MII_PHYID1] = PHY_R, 2185 [MII_PHYID2] = PHY_R, 2186 [MII_ANAR] = PHY_RW, 2187 [MII_ANLPAR] = PHY_R, 2188 [MII_ANER] = PHY_R, 2189 [MII_ANNP] = PHY_RW, 2190 [MII_ANLPRNP] = PHY_R, 2191 [MII_CTRL1000] = PHY_RW, 2192 [MII_STAT1000] = PHY_R, 2193 [MII_EXTSTAT] = PHY_R, 2194 2195 [IGP01E1000_PHY_PORT_CONFIG] = PHY_RW, 2196 [IGP01E1000_PHY_PORT_STATUS] = PHY_R, 2197 [IGP01E1000_PHY_PORT_CTRL] = PHY_RW, 2198 [IGP01E1000_PHY_LINK_HEALTH] = PHY_R, 2199 [IGP02E1000_PHY_POWER_MGMT] = PHY_RW, 2200 [IGP01E1000_PHY_PAGE_SELECT] = PHY_W 2201 }; 2202 2203 static void 2204 igb_phy_reg_write(IGBCore *core, uint32_t addr, uint16_t data) 2205 { 2206 assert(addr <= MAX_PHY_REG_ADDRESS); 2207 2208 if (addr == MII_BMCR) { 2209 igb_set_phy_ctrl(core, data); 2210 } else { 2211 core->phy[addr] = data; 2212 } 2213 } 2214 2215 static void 2216 igb_set_mdic(IGBCore *core, int index, uint32_t val) 2217 { 2218 uint32_t data = val & E1000_MDIC_DATA_MASK; 2219 uint32_t addr = ((val & E1000_MDIC_REG_MASK) >> E1000_MDIC_REG_SHIFT); 2220 2221 if ((val & E1000_MDIC_PHY_MASK) >> E1000_MDIC_PHY_SHIFT != 1) { /* phy # */ 2222 val = core->mac[MDIC] | E1000_MDIC_ERROR; 2223 } else if (val & E1000_MDIC_OP_READ) { 2224 if (!(igb_phy_regcap[addr] & PHY_R)) { 2225 trace_igb_core_mdic_read_unhandled(addr); 2226 val |= E1000_MDIC_ERROR; 2227 } else { 2228 val = (val ^ data) | core->phy[addr]; 2229 trace_igb_core_mdic_read(addr, val); 2230 } 2231 } else if (val & E1000_MDIC_OP_WRITE) { 2232 if (!(igb_phy_regcap[addr] & PHY_W)) { 2233 trace_igb_core_mdic_write_unhandled(addr); 2234 val |= E1000_MDIC_ERROR; 2235 } else { 2236 trace_igb_core_mdic_write(addr, data); 2237 igb_phy_reg_write(core, addr, data); 2238 } 2239 } 2240 core->mac[MDIC] = val | E1000_MDIC_READY; 2241 2242 if (val & E1000_MDIC_INT_EN) { 2243 igb_set_interrupt_cause(core, E1000_ICR_MDAC); 2244 } 2245 } 2246 2247 static void 2248 igb_set_rdt(IGBCore *core, int index, uint32_t val) 2249 { 2250 core->mac[index] = val & 0xffff; 2251 trace_e1000e_rx_set_rdt(igb_mq_queue_idx(RDT0, index), val); 2252 igb_start_recv(core); 2253 } 2254 2255 static void 2256 igb_set_status(IGBCore *core, int index, uint32_t val) 2257 { 2258 if ((val & E1000_STATUS_PHYRA) == 0) { 2259 core->mac[index] &= ~E1000_STATUS_PHYRA; 2260 } 2261 } 2262 2263 static void 2264 igb_set_ctrlext(IGBCore *core, int index, uint32_t val) 2265 { 2266 trace_igb_link_set_ext_params(!!(val & E1000_CTRL_EXT_ASDCHK), 2267 !!(val & E1000_CTRL_EXT_SPD_BYPS), 2268 !!(val & E1000_CTRL_EXT_PFRSTD)); 2269 2270 /* Zero self-clearing bits */ 2271 val &= ~(E1000_CTRL_EXT_ASDCHK | E1000_CTRL_EXT_EE_RST); 2272 core->mac[CTRL_EXT] = val; 2273 2274 if (core->mac[CTRL_EXT] & E1000_CTRL_EXT_PFRSTD) { 2275 for (int vfn = 0; vfn < IGB_MAX_VF_FUNCTIONS; vfn++) { 2276 core->mac[V2PMAILBOX0 + vfn] &= ~E1000_V2PMAILBOX_RSTI; 2277 core->mac[V2PMAILBOX0 + vfn] |= E1000_V2PMAILBOX_RSTD; 2278 } 2279 } 2280 } 2281 2282 static void 2283 igb_set_pbaclr(IGBCore *core, int index, uint32_t val) 2284 { 2285 int i; 2286 2287 core->mac[PBACLR] = val & E1000_PBACLR_VALID_MASK; 2288 2289 if (!msix_enabled(core->owner)) { 2290 return; 2291 } 2292 2293 for (i = 0; i < IGB_INTR_NUM; i++) { 2294 if (core->mac[PBACLR] & BIT(i)) { 2295 msix_clr_pending(core->owner, i); 2296 } 2297 } 2298 } 2299 2300 static void 2301 igb_set_fcrth(IGBCore *core, int index, uint32_t val) 2302 { 2303 core->mac[FCRTH] = val & 0xFFF8; 2304 } 2305 2306 static void 2307 igb_set_fcrtl(IGBCore *core, int index, uint32_t val) 2308 { 2309 core->mac[FCRTL] = val & 0x8000FFF8; 2310 } 2311 2312 #define IGB_LOW_BITS_SET_FUNC(num) \ 2313 static void \ 2314 igb_set_##num##bit(IGBCore *core, int index, uint32_t val) \ 2315 { \ 2316 core->mac[index] = val & (BIT(num) - 1); \ 2317 } 2318 2319 IGB_LOW_BITS_SET_FUNC(4) 2320 IGB_LOW_BITS_SET_FUNC(13) 2321 IGB_LOW_BITS_SET_FUNC(16) 2322 2323 static void 2324 igb_set_dlen(IGBCore *core, int index, uint32_t val) 2325 { 2326 core->mac[index] = val & 0xffff0; 2327 } 2328 2329 static void 2330 igb_set_dbal(IGBCore *core, int index, uint32_t val) 2331 { 2332 core->mac[index] = val & E1000_XDBAL_MASK; 2333 } 2334 2335 static void 2336 igb_set_tdt(IGBCore *core, int index, uint32_t val) 2337 { 2338 IGB_TxRing txr; 2339 int qn = igb_mq_queue_idx(TDT0, index); 2340 2341 core->mac[index] = val & 0xffff; 2342 2343 igb_tx_ring_init(core, &txr, qn); 2344 igb_start_xmit(core, &txr); 2345 } 2346 2347 static void 2348 igb_set_ics(IGBCore *core, int index, uint32_t val) 2349 { 2350 trace_e1000e_irq_write_ics(val); 2351 igb_set_interrupt_cause(core, val); 2352 } 2353 2354 static void 2355 igb_set_imc(IGBCore *core, int index, uint32_t val) 2356 { 2357 trace_e1000e_irq_ims_clear_set_imc(val); 2358 igb_clear_ims_bits(core, val); 2359 igb_update_interrupt_state(core); 2360 } 2361 2362 static void 2363 igb_set_ims(IGBCore *core, int index, uint32_t val) 2364 { 2365 uint32_t valid_val = val & 0x77D4FBFD; 2366 2367 trace_e1000e_irq_set_ims(val, core->mac[IMS], core->mac[IMS] | valid_val); 2368 core->mac[IMS] |= valid_val; 2369 igb_update_interrupt_state(core); 2370 } 2371 2372 static void igb_commit_icr(IGBCore *core) 2373 { 2374 /* 2375 * If GPIE.NSICR = 0, then the copy of IAM to IMS will occur only if at 2376 * least one bit is set in the IMS and there is a true interrupt as 2377 * reflected in ICR.INTA. 2378 */ 2379 if ((core->mac[GPIE] & E1000_GPIE_NSICR) || 2380 (core->mac[IMS] && (core->mac[ICR] & E1000_ICR_INT_ASSERTED))) { 2381 igb_set_ims(core, IMS, core->mac[IAM]); 2382 } else { 2383 igb_update_interrupt_state(core); 2384 } 2385 } 2386 2387 static void igb_set_icr(IGBCore *core, int index, uint32_t val) 2388 { 2389 uint32_t icr = core->mac[ICR] & ~val; 2390 2391 trace_igb_irq_icr_write(val, core->mac[ICR], icr); 2392 core->mac[ICR] = icr; 2393 igb_commit_icr(core); 2394 } 2395 2396 static uint32_t 2397 igb_mac_readreg(IGBCore *core, int index) 2398 { 2399 return core->mac[index]; 2400 } 2401 2402 static uint32_t 2403 igb_mac_ics_read(IGBCore *core, int index) 2404 { 2405 trace_e1000e_irq_read_ics(core->mac[ICS]); 2406 return core->mac[ICS]; 2407 } 2408 2409 static uint32_t 2410 igb_mac_ims_read(IGBCore *core, int index) 2411 { 2412 trace_e1000e_irq_read_ims(core->mac[IMS]); 2413 return core->mac[IMS]; 2414 } 2415 2416 static uint32_t 2417 igb_mac_swsm_read(IGBCore *core, int index) 2418 { 2419 uint32_t val = core->mac[SWSM]; 2420 core->mac[SWSM] = val | E1000_SWSM_SMBI; 2421 return val; 2422 } 2423 2424 static uint32_t 2425 igb_mac_eitr_read(IGBCore *core, int index) 2426 { 2427 return core->eitr_guest_value[index - EITR0]; 2428 } 2429 2430 static uint32_t igb_mac_vfmailbox_read(IGBCore *core, int index) 2431 { 2432 uint32_t val = core->mac[index]; 2433 2434 core->mac[index] &= ~(E1000_V2PMAILBOX_PFSTS | E1000_V2PMAILBOX_PFACK | 2435 E1000_V2PMAILBOX_RSTD); 2436 2437 return val; 2438 } 2439 2440 static uint32_t 2441 igb_mac_icr_read(IGBCore *core, int index) 2442 { 2443 uint32_t ret = core->mac[ICR]; 2444 trace_e1000e_irq_icr_read_entry(ret); 2445 2446 if (core->mac[GPIE] & E1000_GPIE_NSICR) { 2447 trace_igb_irq_icr_clear_gpie_nsicr(); 2448 core->mac[ICR] = 0; 2449 } else if (core->mac[IMS] == 0) { 2450 trace_e1000e_irq_icr_clear_zero_ims(); 2451 core->mac[ICR] = 0; 2452 } else if (!msix_enabled(core->owner)) { 2453 trace_e1000e_irq_icr_clear_nonmsix_icr_read(); 2454 core->mac[ICR] = 0; 2455 } 2456 2457 trace_e1000e_irq_icr_read_exit(core->mac[ICR]); 2458 igb_commit_icr(core); 2459 return ret; 2460 } 2461 2462 static uint32_t 2463 igb_mac_read_clr4(IGBCore *core, int index) 2464 { 2465 uint32_t ret = core->mac[index]; 2466 2467 core->mac[index] = 0; 2468 return ret; 2469 } 2470 2471 static uint32_t 2472 igb_mac_read_clr8(IGBCore *core, int index) 2473 { 2474 uint32_t ret = core->mac[index]; 2475 2476 core->mac[index] = 0; 2477 core->mac[index - 1] = 0; 2478 return ret; 2479 } 2480 2481 static uint32_t 2482 igb_get_ctrl(IGBCore *core, int index) 2483 { 2484 uint32_t val = core->mac[CTRL]; 2485 2486 trace_e1000e_link_read_params( 2487 !!(val & E1000_CTRL_ASDE), 2488 (val & E1000_CTRL_SPD_SEL) >> E1000_CTRL_SPD_SHIFT, 2489 !!(val & E1000_CTRL_FRCSPD), 2490 !!(val & E1000_CTRL_FRCDPX), 2491 !!(val & E1000_CTRL_RFCE), 2492 !!(val & E1000_CTRL_TFCE)); 2493 2494 return val; 2495 } 2496 2497 static uint32_t igb_get_status(IGBCore *core, int index) 2498 { 2499 uint32_t res = core->mac[STATUS]; 2500 uint16_t num_vfs = pcie_sriov_num_vfs(core->owner); 2501 2502 if (core->mac[CTRL] & E1000_CTRL_FRCDPX) { 2503 res |= (core->mac[CTRL] & E1000_CTRL_FD) ? E1000_STATUS_FD : 0; 2504 } else { 2505 res |= E1000_STATUS_FD; 2506 } 2507 2508 if ((core->mac[CTRL] & E1000_CTRL_FRCSPD) || 2509 (core->mac[CTRL_EXT] & E1000_CTRL_EXT_SPD_BYPS)) { 2510 switch (core->mac[CTRL] & E1000_CTRL_SPD_SEL) { 2511 case E1000_CTRL_SPD_10: 2512 res |= E1000_STATUS_SPEED_10; 2513 break; 2514 case E1000_CTRL_SPD_100: 2515 res |= E1000_STATUS_SPEED_100; 2516 break; 2517 case E1000_CTRL_SPD_1000: 2518 default: 2519 res |= E1000_STATUS_SPEED_1000; 2520 break; 2521 } 2522 } else { 2523 res |= E1000_STATUS_SPEED_1000; 2524 } 2525 2526 if (num_vfs) { 2527 res |= num_vfs << E1000_STATUS_NUM_VFS_SHIFT; 2528 res |= E1000_STATUS_IOV_MODE; 2529 } 2530 2531 /* 2532 * Windows driver 12.18.9.23 resets if E1000_STATUS_GIO_MASTER_ENABLE is 2533 * left set after E1000_CTRL_LRST is set. 2534 */ 2535 if (!(core->mac[CTRL] & E1000_CTRL_GIO_MASTER_DISABLE) && 2536 !(core->mac[CTRL] & E1000_CTRL_LRST)) { 2537 res |= E1000_STATUS_GIO_MASTER_ENABLE; 2538 } 2539 2540 return res; 2541 } 2542 2543 static void 2544 igb_mac_writereg(IGBCore *core, int index, uint32_t val) 2545 { 2546 core->mac[index] = val; 2547 } 2548 2549 static void 2550 igb_mac_setmacaddr(IGBCore *core, int index, uint32_t val) 2551 { 2552 uint32_t macaddr[2]; 2553 2554 core->mac[index] = val; 2555 2556 macaddr[0] = cpu_to_le32(core->mac[RA]); 2557 macaddr[1] = cpu_to_le32(core->mac[RA + 1]); 2558 qemu_format_nic_info_str(qemu_get_queue(core->owner_nic), 2559 (uint8_t *) macaddr); 2560 2561 trace_e1000e_mac_set_sw(MAC_ARG(macaddr)); 2562 } 2563 2564 static void 2565 igb_set_eecd(IGBCore *core, int index, uint32_t val) 2566 { 2567 static const uint32_t ro_bits = E1000_EECD_PRES | 2568 E1000_EECD_AUTO_RD | 2569 E1000_EECD_SIZE_EX_MASK; 2570 2571 core->mac[EECD] = (core->mac[EECD] & ro_bits) | (val & ~ro_bits); 2572 } 2573 2574 static void 2575 igb_set_eerd(IGBCore *core, int index, uint32_t val) 2576 { 2577 uint32_t addr = (val >> E1000_EERW_ADDR_SHIFT) & E1000_EERW_ADDR_MASK; 2578 uint32_t flags = 0; 2579 uint32_t data = 0; 2580 2581 if ((addr < IGB_EEPROM_SIZE) && (val & E1000_EERW_START)) { 2582 data = core->eeprom[addr]; 2583 flags = E1000_EERW_DONE; 2584 } 2585 2586 core->mac[EERD] = flags | 2587 (addr << E1000_EERW_ADDR_SHIFT) | 2588 (data << E1000_EERW_DATA_SHIFT); 2589 } 2590 2591 static void 2592 igb_set_eitr(IGBCore *core, int index, uint32_t val) 2593 { 2594 uint32_t eitr_num = index - EITR0; 2595 2596 trace_igb_irq_eitr_set(eitr_num, val); 2597 2598 core->eitr_guest_value[eitr_num] = val & ~E1000_EITR_CNT_IGNR; 2599 core->mac[index] = val & 0x7FFE; 2600 } 2601 2602 static void 2603 igb_update_rx_offloads(IGBCore *core) 2604 { 2605 int cso_state = igb_rx_l4_cso_enabled(core); 2606 2607 trace_e1000e_rx_set_cso(cso_state); 2608 2609 if (core->has_vnet) { 2610 qemu_set_offload(qemu_get_queue(core->owner_nic)->peer, 2611 cso_state, 0, 0, 0, 0); 2612 } 2613 } 2614 2615 static void 2616 igb_set_rxcsum(IGBCore *core, int index, uint32_t val) 2617 { 2618 core->mac[RXCSUM] = val; 2619 igb_update_rx_offloads(core); 2620 } 2621 2622 static void 2623 igb_set_gcr(IGBCore *core, int index, uint32_t val) 2624 { 2625 uint32_t ro_bits = core->mac[GCR] & E1000_GCR_RO_BITS; 2626 core->mac[GCR] = (val & ~E1000_GCR_RO_BITS) | ro_bits; 2627 } 2628 2629 static uint32_t igb_get_systiml(IGBCore *core, int index) 2630 { 2631 e1000x_timestamp(core->mac, core->timadj, SYSTIML, SYSTIMH); 2632 return core->mac[SYSTIML]; 2633 } 2634 2635 static uint32_t igb_get_rxsatrh(IGBCore *core, int index) 2636 { 2637 core->mac[TSYNCRXCTL] &= ~E1000_TSYNCRXCTL_VALID; 2638 return core->mac[RXSATRH]; 2639 } 2640 2641 static uint32_t igb_get_txstmph(IGBCore *core, int index) 2642 { 2643 core->mac[TSYNCTXCTL] &= ~E1000_TSYNCTXCTL_VALID; 2644 return core->mac[TXSTMPH]; 2645 } 2646 2647 static void igb_set_timinca(IGBCore *core, int index, uint32_t val) 2648 { 2649 e1000x_set_timinca(core->mac, &core->timadj, val); 2650 } 2651 2652 static void igb_set_timadjh(IGBCore *core, int index, uint32_t val) 2653 { 2654 core->mac[TIMADJH] = val; 2655 core->timadj += core->mac[TIMADJL] | ((int64_t)core->mac[TIMADJH] << 32); 2656 } 2657 2658 #define igb_getreg(x) [x] = igb_mac_readreg 2659 typedef uint32_t (*readops)(IGBCore *, int); 2660 static const readops igb_macreg_readops[] = { 2661 igb_getreg(WUFC), 2662 igb_getreg(MANC), 2663 igb_getreg(TOTL), 2664 igb_getreg(RDT0), 2665 igb_getreg(RDT1), 2666 igb_getreg(RDT2), 2667 igb_getreg(RDT3), 2668 igb_getreg(RDT4), 2669 igb_getreg(RDT5), 2670 igb_getreg(RDT6), 2671 igb_getreg(RDT7), 2672 igb_getreg(RDT8), 2673 igb_getreg(RDT9), 2674 igb_getreg(RDT10), 2675 igb_getreg(RDT11), 2676 igb_getreg(RDT12), 2677 igb_getreg(RDT13), 2678 igb_getreg(RDT14), 2679 igb_getreg(RDT15), 2680 igb_getreg(RDBAH0), 2681 igb_getreg(RDBAH1), 2682 igb_getreg(RDBAH2), 2683 igb_getreg(RDBAH3), 2684 igb_getreg(RDBAH4), 2685 igb_getreg(RDBAH5), 2686 igb_getreg(RDBAH6), 2687 igb_getreg(RDBAH7), 2688 igb_getreg(RDBAH8), 2689 igb_getreg(RDBAH9), 2690 igb_getreg(RDBAH10), 2691 igb_getreg(RDBAH11), 2692 igb_getreg(RDBAH12), 2693 igb_getreg(RDBAH13), 2694 igb_getreg(RDBAH14), 2695 igb_getreg(RDBAH15), 2696 igb_getreg(TDBAL0), 2697 igb_getreg(TDBAL1), 2698 igb_getreg(TDBAL2), 2699 igb_getreg(TDBAL3), 2700 igb_getreg(TDBAL4), 2701 igb_getreg(TDBAL5), 2702 igb_getreg(TDBAL6), 2703 igb_getreg(TDBAL7), 2704 igb_getreg(TDBAL8), 2705 igb_getreg(TDBAL9), 2706 igb_getreg(TDBAL10), 2707 igb_getreg(TDBAL11), 2708 igb_getreg(TDBAL12), 2709 igb_getreg(TDBAL13), 2710 igb_getreg(TDBAL14), 2711 igb_getreg(TDBAL15), 2712 igb_getreg(RDLEN0), 2713 igb_getreg(RDLEN1), 2714 igb_getreg(RDLEN2), 2715 igb_getreg(RDLEN3), 2716 igb_getreg(RDLEN4), 2717 igb_getreg(RDLEN5), 2718 igb_getreg(RDLEN6), 2719 igb_getreg(RDLEN7), 2720 igb_getreg(RDLEN8), 2721 igb_getreg(RDLEN9), 2722 igb_getreg(RDLEN10), 2723 igb_getreg(RDLEN11), 2724 igb_getreg(RDLEN12), 2725 igb_getreg(RDLEN13), 2726 igb_getreg(RDLEN14), 2727 igb_getreg(RDLEN15), 2728 igb_getreg(SRRCTL0), 2729 igb_getreg(SRRCTL1), 2730 igb_getreg(SRRCTL2), 2731 igb_getreg(SRRCTL3), 2732 igb_getreg(SRRCTL4), 2733 igb_getreg(SRRCTL5), 2734 igb_getreg(SRRCTL6), 2735 igb_getreg(SRRCTL7), 2736 igb_getreg(SRRCTL8), 2737 igb_getreg(SRRCTL9), 2738 igb_getreg(SRRCTL10), 2739 igb_getreg(SRRCTL11), 2740 igb_getreg(SRRCTL12), 2741 igb_getreg(SRRCTL13), 2742 igb_getreg(SRRCTL14), 2743 igb_getreg(SRRCTL15), 2744 igb_getreg(LATECOL), 2745 igb_getreg(XONTXC), 2746 igb_getreg(TDFH), 2747 igb_getreg(TDFT), 2748 igb_getreg(TDFHS), 2749 igb_getreg(TDFTS), 2750 igb_getreg(TDFPC), 2751 igb_getreg(WUS), 2752 igb_getreg(RDFH), 2753 igb_getreg(RDFT), 2754 igb_getreg(RDFHS), 2755 igb_getreg(RDFTS), 2756 igb_getreg(RDFPC), 2757 igb_getreg(GORCL), 2758 igb_getreg(MGTPRC), 2759 igb_getreg(EERD), 2760 igb_getreg(EIAC), 2761 igb_getreg(MANC2H), 2762 igb_getreg(RXCSUM), 2763 igb_getreg(GSCL_3), 2764 igb_getreg(GSCN_2), 2765 igb_getreg(FCAH), 2766 igb_getreg(FCRTH), 2767 igb_getreg(FLOP), 2768 igb_getreg(RXSTMPH), 2769 igb_getreg(TXSTMPL), 2770 igb_getreg(TIMADJL), 2771 igb_getreg(RDH0), 2772 igb_getreg(RDH1), 2773 igb_getreg(RDH2), 2774 igb_getreg(RDH3), 2775 igb_getreg(RDH4), 2776 igb_getreg(RDH5), 2777 igb_getreg(RDH6), 2778 igb_getreg(RDH7), 2779 igb_getreg(RDH8), 2780 igb_getreg(RDH9), 2781 igb_getreg(RDH10), 2782 igb_getreg(RDH11), 2783 igb_getreg(RDH12), 2784 igb_getreg(RDH13), 2785 igb_getreg(RDH14), 2786 igb_getreg(RDH15), 2787 igb_getreg(TDT0), 2788 igb_getreg(TDT1), 2789 igb_getreg(TDT2), 2790 igb_getreg(TDT3), 2791 igb_getreg(TDT4), 2792 igb_getreg(TDT5), 2793 igb_getreg(TDT6), 2794 igb_getreg(TDT7), 2795 igb_getreg(TDT8), 2796 igb_getreg(TDT9), 2797 igb_getreg(TDT10), 2798 igb_getreg(TDT11), 2799 igb_getreg(TDT12), 2800 igb_getreg(TDT13), 2801 igb_getreg(TDT14), 2802 igb_getreg(TDT15), 2803 igb_getreg(TNCRS), 2804 igb_getreg(RJC), 2805 igb_getreg(IAM), 2806 igb_getreg(GSCL_2), 2807 igb_getreg(TIPG), 2808 igb_getreg(FLMNGCTL), 2809 igb_getreg(FLMNGCNT), 2810 igb_getreg(TSYNCTXCTL), 2811 igb_getreg(EEMNGDATA), 2812 igb_getreg(CTRL_EXT), 2813 igb_getreg(SYSTIMH), 2814 igb_getreg(EEMNGCTL), 2815 igb_getreg(FLMNGDATA), 2816 igb_getreg(TSYNCRXCTL), 2817 igb_getreg(LEDCTL), 2818 igb_getreg(TCTL), 2819 igb_getreg(TCTL_EXT), 2820 igb_getreg(DTXCTL), 2821 igb_getreg(RXPBS), 2822 igb_getreg(TDH0), 2823 igb_getreg(TDH1), 2824 igb_getreg(TDH2), 2825 igb_getreg(TDH3), 2826 igb_getreg(TDH4), 2827 igb_getreg(TDH5), 2828 igb_getreg(TDH6), 2829 igb_getreg(TDH7), 2830 igb_getreg(TDH8), 2831 igb_getreg(TDH9), 2832 igb_getreg(TDH10), 2833 igb_getreg(TDH11), 2834 igb_getreg(TDH12), 2835 igb_getreg(TDH13), 2836 igb_getreg(TDH14), 2837 igb_getreg(TDH15), 2838 igb_getreg(ECOL), 2839 igb_getreg(DC), 2840 igb_getreg(RLEC), 2841 igb_getreg(XOFFTXC), 2842 igb_getreg(RFC), 2843 igb_getreg(RNBC), 2844 igb_getreg(MGTPTC), 2845 igb_getreg(TIMINCA), 2846 igb_getreg(FACTPS), 2847 igb_getreg(GSCL_1), 2848 igb_getreg(GSCN_0), 2849 igb_getreg(PBACLR), 2850 igb_getreg(FCTTV), 2851 igb_getreg(RXSATRL), 2852 igb_getreg(TORL), 2853 igb_getreg(TDLEN0), 2854 igb_getreg(TDLEN1), 2855 igb_getreg(TDLEN2), 2856 igb_getreg(TDLEN3), 2857 igb_getreg(TDLEN4), 2858 igb_getreg(TDLEN5), 2859 igb_getreg(TDLEN6), 2860 igb_getreg(TDLEN7), 2861 igb_getreg(TDLEN8), 2862 igb_getreg(TDLEN9), 2863 igb_getreg(TDLEN10), 2864 igb_getreg(TDLEN11), 2865 igb_getreg(TDLEN12), 2866 igb_getreg(TDLEN13), 2867 igb_getreg(TDLEN14), 2868 igb_getreg(TDLEN15), 2869 igb_getreg(MCC), 2870 igb_getreg(WUC), 2871 igb_getreg(EECD), 2872 igb_getreg(FCRTV), 2873 igb_getreg(TXDCTL0), 2874 igb_getreg(TXDCTL1), 2875 igb_getreg(TXDCTL2), 2876 igb_getreg(TXDCTL3), 2877 igb_getreg(TXDCTL4), 2878 igb_getreg(TXDCTL5), 2879 igb_getreg(TXDCTL6), 2880 igb_getreg(TXDCTL7), 2881 igb_getreg(TXDCTL8), 2882 igb_getreg(TXDCTL9), 2883 igb_getreg(TXDCTL10), 2884 igb_getreg(TXDCTL11), 2885 igb_getreg(TXDCTL12), 2886 igb_getreg(TXDCTL13), 2887 igb_getreg(TXDCTL14), 2888 igb_getreg(TXDCTL15), 2889 igb_getreg(TXCTL0), 2890 igb_getreg(TXCTL1), 2891 igb_getreg(TXCTL2), 2892 igb_getreg(TXCTL3), 2893 igb_getreg(TXCTL4), 2894 igb_getreg(TXCTL5), 2895 igb_getreg(TXCTL6), 2896 igb_getreg(TXCTL7), 2897 igb_getreg(TXCTL8), 2898 igb_getreg(TXCTL9), 2899 igb_getreg(TXCTL10), 2900 igb_getreg(TXCTL11), 2901 igb_getreg(TXCTL12), 2902 igb_getreg(TXCTL13), 2903 igb_getreg(TXCTL14), 2904 igb_getreg(TXCTL15), 2905 igb_getreg(TDWBAL0), 2906 igb_getreg(TDWBAL1), 2907 igb_getreg(TDWBAL2), 2908 igb_getreg(TDWBAL3), 2909 igb_getreg(TDWBAL4), 2910 igb_getreg(TDWBAL5), 2911 igb_getreg(TDWBAL6), 2912 igb_getreg(TDWBAL7), 2913 igb_getreg(TDWBAL8), 2914 igb_getreg(TDWBAL9), 2915 igb_getreg(TDWBAL10), 2916 igb_getreg(TDWBAL11), 2917 igb_getreg(TDWBAL12), 2918 igb_getreg(TDWBAL13), 2919 igb_getreg(TDWBAL14), 2920 igb_getreg(TDWBAL15), 2921 igb_getreg(TDWBAH0), 2922 igb_getreg(TDWBAH1), 2923 igb_getreg(TDWBAH2), 2924 igb_getreg(TDWBAH3), 2925 igb_getreg(TDWBAH4), 2926 igb_getreg(TDWBAH5), 2927 igb_getreg(TDWBAH6), 2928 igb_getreg(TDWBAH7), 2929 igb_getreg(TDWBAH8), 2930 igb_getreg(TDWBAH9), 2931 igb_getreg(TDWBAH10), 2932 igb_getreg(TDWBAH11), 2933 igb_getreg(TDWBAH12), 2934 igb_getreg(TDWBAH13), 2935 igb_getreg(TDWBAH14), 2936 igb_getreg(TDWBAH15), 2937 igb_getreg(PVTCTRL0), 2938 igb_getreg(PVTCTRL1), 2939 igb_getreg(PVTCTRL2), 2940 igb_getreg(PVTCTRL3), 2941 igb_getreg(PVTCTRL4), 2942 igb_getreg(PVTCTRL5), 2943 igb_getreg(PVTCTRL6), 2944 igb_getreg(PVTCTRL7), 2945 igb_getreg(PVTEIMS0), 2946 igb_getreg(PVTEIMS1), 2947 igb_getreg(PVTEIMS2), 2948 igb_getreg(PVTEIMS3), 2949 igb_getreg(PVTEIMS4), 2950 igb_getreg(PVTEIMS5), 2951 igb_getreg(PVTEIMS6), 2952 igb_getreg(PVTEIMS7), 2953 igb_getreg(PVTEIAC0), 2954 igb_getreg(PVTEIAC1), 2955 igb_getreg(PVTEIAC2), 2956 igb_getreg(PVTEIAC3), 2957 igb_getreg(PVTEIAC4), 2958 igb_getreg(PVTEIAC5), 2959 igb_getreg(PVTEIAC6), 2960 igb_getreg(PVTEIAC7), 2961 igb_getreg(PVTEIAM0), 2962 igb_getreg(PVTEIAM1), 2963 igb_getreg(PVTEIAM2), 2964 igb_getreg(PVTEIAM3), 2965 igb_getreg(PVTEIAM4), 2966 igb_getreg(PVTEIAM5), 2967 igb_getreg(PVTEIAM6), 2968 igb_getreg(PVTEIAM7), 2969 igb_getreg(PVFGPRC0), 2970 igb_getreg(PVFGPRC1), 2971 igb_getreg(PVFGPRC2), 2972 igb_getreg(PVFGPRC3), 2973 igb_getreg(PVFGPRC4), 2974 igb_getreg(PVFGPRC5), 2975 igb_getreg(PVFGPRC6), 2976 igb_getreg(PVFGPRC7), 2977 igb_getreg(PVFGPTC0), 2978 igb_getreg(PVFGPTC1), 2979 igb_getreg(PVFGPTC2), 2980 igb_getreg(PVFGPTC3), 2981 igb_getreg(PVFGPTC4), 2982 igb_getreg(PVFGPTC5), 2983 igb_getreg(PVFGPTC6), 2984 igb_getreg(PVFGPTC7), 2985 igb_getreg(PVFGORC0), 2986 igb_getreg(PVFGORC1), 2987 igb_getreg(PVFGORC2), 2988 igb_getreg(PVFGORC3), 2989 igb_getreg(PVFGORC4), 2990 igb_getreg(PVFGORC5), 2991 igb_getreg(PVFGORC6), 2992 igb_getreg(PVFGORC7), 2993 igb_getreg(PVFGOTC0), 2994 igb_getreg(PVFGOTC1), 2995 igb_getreg(PVFGOTC2), 2996 igb_getreg(PVFGOTC3), 2997 igb_getreg(PVFGOTC4), 2998 igb_getreg(PVFGOTC5), 2999 igb_getreg(PVFGOTC6), 3000 igb_getreg(PVFGOTC7), 3001 igb_getreg(PVFMPRC0), 3002 igb_getreg(PVFMPRC1), 3003 igb_getreg(PVFMPRC2), 3004 igb_getreg(PVFMPRC3), 3005 igb_getreg(PVFMPRC4), 3006 igb_getreg(PVFMPRC5), 3007 igb_getreg(PVFMPRC6), 3008 igb_getreg(PVFMPRC7), 3009 igb_getreg(PVFGPRLBC0), 3010 igb_getreg(PVFGPRLBC1), 3011 igb_getreg(PVFGPRLBC2), 3012 igb_getreg(PVFGPRLBC3), 3013 igb_getreg(PVFGPRLBC4), 3014 igb_getreg(PVFGPRLBC5), 3015 igb_getreg(PVFGPRLBC6), 3016 igb_getreg(PVFGPRLBC7), 3017 igb_getreg(PVFGPTLBC0), 3018 igb_getreg(PVFGPTLBC1), 3019 igb_getreg(PVFGPTLBC2), 3020 igb_getreg(PVFGPTLBC3), 3021 igb_getreg(PVFGPTLBC4), 3022 igb_getreg(PVFGPTLBC5), 3023 igb_getreg(PVFGPTLBC6), 3024 igb_getreg(PVFGPTLBC7), 3025 igb_getreg(PVFGORLBC0), 3026 igb_getreg(PVFGORLBC1), 3027 igb_getreg(PVFGORLBC2), 3028 igb_getreg(PVFGORLBC3), 3029 igb_getreg(PVFGORLBC4), 3030 igb_getreg(PVFGORLBC5), 3031 igb_getreg(PVFGORLBC6), 3032 igb_getreg(PVFGORLBC7), 3033 igb_getreg(PVFGOTLBC0), 3034 igb_getreg(PVFGOTLBC1), 3035 igb_getreg(PVFGOTLBC2), 3036 igb_getreg(PVFGOTLBC3), 3037 igb_getreg(PVFGOTLBC4), 3038 igb_getreg(PVFGOTLBC5), 3039 igb_getreg(PVFGOTLBC6), 3040 igb_getreg(PVFGOTLBC7), 3041 igb_getreg(RCTL), 3042 igb_getreg(MDIC), 3043 igb_getreg(FCRUC), 3044 igb_getreg(VET), 3045 igb_getreg(RDBAL0), 3046 igb_getreg(RDBAL1), 3047 igb_getreg(RDBAL2), 3048 igb_getreg(RDBAL3), 3049 igb_getreg(RDBAL4), 3050 igb_getreg(RDBAL5), 3051 igb_getreg(RDBAL6), 3052 igb_getreg(RDBAL7), 3053 igb_getreg(RDBAL8), 3054 igb_getreg(RDBAL9), 3055 igb_getreg(RDBAL10), 3056 igb_getreg(RDBAL11), 3057 igb_getreg(RDBAL12), 3058 igb_getreg(RDBAL13), 3059 igb_getreg(RDBAL14), 3060 igb_getreg(RDBAL15), 3061 igb_getreg(TDBAH0), 3062 igb_getreg(TDBAH1), 3063 igb_getreg(TDBAH2), 3064 igb_getreg(TDBAH3), 3065 igb_getreg(TDBAH4), 3066 igb_getreg(TDBAH5), 3067 igb_getreg(TDBAH6), 3068 igb_getreg(TDBAH7), 3069 igb_getreg(TDBAH8), 3070 igb_getreg(TDBAH9), 3071 igb_getreg(TDBAH10), 3072 igb_getreg(TDBAH11), 3073 igb_getreg(TDBAH12), 3074 igb_getreg(TDBAH13), 3075 igb_getreg(TDBAH14), 3076 igb_getreg(TDBAH15), 3077 igb_getreg(SCC), 3078 igb_getreg(COLC), 3079 igb_getreg(XOFFRXC), 3080 igb_getreg(IPAV), 3081 igb_getreg(GOTCL), 3082 igb_getreg(MGTPDC), 3083 igb_getreg(GCR), 3084 igb_getreg(MFVAL), 3085 igb_getreg(FUNCTAG), 3086 igb_getreg(GSCL_4), 3087 igb_getreg(GSCN_3), 3088 igb_getreg(MRQC), 3089 igb_getreg(FCT), 3090 igb_getreg(FLA), 3091 igb_getreg(RXDCTL0), 3092 igb_getreg(RXDCTL1), 3093 igb_getreg(RXDCTL2), 3094 igb_getreg(RXDCTL3), 3095 igb_getreg(RXDCTL4), 3096 igb_getreg(RXDCTL5), 3097 igb_getreg(RXDCTL6), 3098 igb_getreg(RXDCTL7), 3099 igb_getreg(RXDCTL8), 3100 igb_getreg(RXDCTL9), 3101 igb_getreg(RXDCTL10), 3102 igb_getreg(RXDCTL11), 3103 igb_getreg(RXDCTL12), 3104 igb_getreg(RXDCTL13), 3105 igb_getreg(RXDCTL14), 3106 igb_getreg(RXDCTL15), 3107 igb_getreg(RXSTMPL), 3108 igb_getreg(TIMADJH), 3109 igb_getreg(FCRTL), 3110 igb_getreg(XONRXC), 3111 igb_getreg(RFCTL), 3112 igb_getreg(GSCN_1), 3113 igb_getreg(FCAL), 3114 igb_getreg(GPIE), 3115 igb_getreg(TXPBS), 3116 igb_getreg(RLPML), 3117 3118 [TOTH] = igb_mac_read_clr8, 3119 [GOTCH] = igb_mac_read_clr8, 3120 [PRC64] = igb_mac_read_clr4, 3121 [PRC255] = igb_mac_read_clr4, 3122 [PRC1023] = igb_mac_read_clr4, 3123 [PTC64] = igb_mac_read_clr4, 3124 [PTC255] = igb_mac_read_clr4, 3125 [PTC1023] = igb_mac_read_clr4, 3126 [GPRC] = igb_mac_read_clr4, 3127 [TPT] = igb_mac_read_clr4, 3128 [RUC] = igb_mac_read_clr4, 3129 [BPRC] = igb_mac_read_clr4, 3130 [MPTC] = igb_mac_read_clr4, 3131 [IAC] = igb_mac_read_clr4, 3132 [ICR] = igb_mac_icr_read, 3133 [STATUS] = igb_get_status, 3134 [ICS] = igb_mac_ics_read, 3135 /* 3136 * 8.8.10: Reading the IMC register returns the value of the IMS register. 3137 */ 3138 [IMC] = igb_mac_ims_read, 3139 [TORH] = igb_mac_read_clr8, 3140 [GORCH] = igb_mac_read_clr8, 3141 [PRC127] = igb_mac_read_clr4, 3142 [PRC511] = igb_mac_read_clr4, 3143 [PRC1522] = igb_mac_read_clr4, 3144 [PTC127] = igb_mac_read_clr4, 3145 [PTC511] = igb_mac_read_clr4, 3146 [PTC1522] = igb_mac_read_clr4, 3147 [GPTC] = igb_mac_read_clr4, 3148 [TPR] = igb_mac_read_clr4, 3149 [ROC] = igb_mac_read_clr4, 3150 [MPRC] = igb_mac_read_clr4, 3151 [BPTC] = igb_mac_read_clr4, 3152 [TSCTC] = igb_mac_read_clr4, 3153 [CTRL] = igb_get_ctrl, 3154 [SWSM] = igb_mac_swsm_read, 3155 [IMS] = igb_mac_ims_read, 3156 [SYSTIML] = igb_get_systiml, 3157 [RXSATRH] = igb_get_rxsatrh, 3158 [TXSTMPH] = igb_get_txstmph, 3159 3160 [CRCERRS ... MPC] = igb_mac_readreg, 3161 [IP6AT ... IP6AT + 3] = igb_mac_readreg, 3162 [IP4AT ... IP4AT + 6] = igb_mac_readreg, 3163 [RA ... RA + 31] = igb_mac_readreg, 3164 [RA2 ... RA2 + 31] = igb_mac_readreg, 3165 [WUPM ... WUPM + 31] = igb_mac_readreg, 3166 [MTA ... MTA + E1000_MC_TBL_SIZE - 1] = igb_mac_readreg, 3167 [VFTA ... VFTA + E1000_VLAN_FILTER_TBL_SIZE - 1] = igb_mac_readreg, 3168 [FFMT ... FFMT + 254] = igb_mac_readreg, 3169 [MDEF ... MDEF + 7] = igb_mac_readreg, 3170 [FTFT ... FTFT + 254] = igb_mac_readreg, 3171 [RETA ... RETA + 31] = igb_mac_readreg, 3172 [RSSRK ... RSSRK + 9] = igb_mac_readreg, 3173 [MAVTV0 ... MAVTV3] = igb_mac_readreg, 3174 [EITR0 ... EITR0 + IGB_INTR_NUM - 1] = igb_mac_eitr_read, 3175 [PVTEICR0] = igb_mac_read_clr4, 3176 [PVTEICR1] = igb_mac_read_clr4, 3177 [PVTEICR2] = igb_mac_read_clr4, 3178 [PVTEICR3] = igb_mac_read_clr4, 3179 [PVTEICR4] = igb_mac_read_clr4, 3180 [PVTEICR5] = igb_mac_read_clr4, 3181 [PVTEICR6] = igb_mac_read_clr4, 3182 [PVTEICR7] = igb_mac_read_clr4, 3183 3184 /* IGB specific: */ 3185 [FWSM] = igb_mac_readreg, 3186 [SW_FW_SYNC] = igb_mac_readreg, 3187 [HTCBDPC] = igb_mac_read_clr4, 3188 [EICR] = igb_mac_read_clr4, 3189 [EIMS] = igb_mac_readreg, 3190 [EIAM] = igb_mac_readreg, 3191 [IVAR0 ... IVAR0 + 7] = igb_mac_readreg, 3192 igb_getreg(IVAR_MISC), 3193 igb_getreg(VT_CTL), 3194 [P2VMAILBOX0 ... P2VMAILBOX7] = igb_mac_readreg, 3195 [V2PMAILBOX0 ... V2PMAILBOX7] = igb_mac_vfmailbox_read, 3196 igb_getreg(MBVFICR), 3197 [VMBMEM0 ... VMBMEM0 + 127] = igb_mac_readreg, 3198 igb_getreg(MBVFIMR), 3199 igb_getreg(VFLRE), 3200 igb_getreg(VFRE), 3201 igb_getreg(VFTE), 3202 igb_getreg(QDE), 3203 igb_getreg(DTXSWC), 3204 igb_getreg(RPLOLR), 3205 [VLVF0 ... VLVF0 + E1000_VLVF_ARRAY_SIZE - 1] = igb_mac_readreg, 3206 [VMVIR0 ... VMVIR7] = igb_mac_readreg, 3207 [VMOLR0 ... VMOLR7] = igb_mac_readreg, 3208 [WVBR] = igb_mac_read_clr4, 3209 [RQDPC0] = igb_mac_read_clr4, 3210 [RQDPC1] = igb_mac_read_clr4, 3211 [RQDPC2] = igb_mac_read_clr4, 3212 [RQDPC3] = igb_mac_read_clr4, 3213 [RQDPC4] = igb_mac_read_clr4, 3214 [RQDPC5] = igb_mac_read_clr4, 3215 [RQDPC6] = igb_mac_read_clr4, 3216 [RQDPC7] = igb_mac_read_clr4, 3217 [RQDPC8] = igb_mac_read_clr4, 3218 [RQDPC9] = igb_mac_read_clr4, 3219 [RQDPC10] = igb_mac_read_clr4, 3220 [RQDPC11] = igb_mac_read_clr4, 3221 [RQDPC12] = igb_mac_read_clr4, 3222 [RQDPC13] = igb_mac_read_clr4, 3223 [RQDPC14] = igb_mac_read_clr4, 3224 [RQDPC15] = igb_mac_read_clr4, 3225 [VTIVAR ... VTIVAR + 7] = igb_mac_readreg, 3226 [VTIVAR_MISC ... VTIVAR_MISC + 7] = igb_mac_readreg, 3227 }; 3228 enum { IGB_NREADOPS = ARRAY_SIZE(igb_macreg_readops) }; 3229 3230 #define igb_putreg(x) [x] = igb_mac_writereg 3231 typedef void (*writeops)(IGBCore *, int, uint32_t); 3232 static const writeops igb_macreg_writeops[] = { 3233 igb_putreg(SWSM), 3234 igb_putreg(WUFC), 3235 igb_putreg(RDBAH0), 3236 igb_putreg(RDBAH1), 3237 igb_putreg(RDBAH2), 3238 igb_putreg(RDBAH3), 3239 igb_putreg(RDBAH4), 3240 igb_putreg(RDBAH5), 3241 igb_putreg(RDBAH6), 3242 igb_putreg(RDBAH7), 3243 igb_putreg(RDBAH8), 3244 igb_putreg(RDBAH9), 3245 igb_putreg(RDBAH10), 3246 igb_putreg(RDBAH11), 3247 igb_putreg(RDBAH12), 3248 igb_putreg(RDBAH13), 3249 igb_putreg(RDBAH14), 3250 igb_putreg(RDBAH15), 3251 igb_putreg(SRRCTL0), 3252 igb_putreg(SRRCTL1), 3253 igb_putreg(SRRCTL2), 3254 igb_putreg(SRRCTL3), 3255 igb_putreg(SRRCTL4), 3256 igb_putreg(SRRCTL5), 3257 igb_putreg(SRRCTL6), 3258 igb_putreg(SRRCTL7), 3259 igb_putreg(SRRCTL8), 3260 igb_putreg(SRRCTL9), 3261 igb_putreg(SRRCTL10), 3262 igb_putreg(SRRCTL11), 3263 igb_putreg(SRRCTL12), 3264 igb_putreg(SRRCTL13), 3265 igb_putreg(SRRCTL14), 3266 igb_putreg(SRRCTL15), 3267 igb_putreg(RXDCTL0), 3268 igb_putreg(RXDCTL1), 3269 igb_putreg(RXDCTL2), 3270 igb_putreg(RXDCTL3), 3271 igb_putreg(RXDCTL4), 3272 igb_putreg(RXDCTL5), 3273 igb_putreg(RXDCTL6), 3274 igb_putreg(RXDCTL7), 3275 igb_putreg(RXDCTL8), 3276 igb_putreg(RXDCTL9), 3277 igb_putreg(RXDCTL10), 3278 igb_putreg(RXDCTL11), 3279 igb_putreg(RXDCTL12), 3280 igb_putreg(RXDCTL13), 3281 igb_putreg(RXDCTL14), 3282 igb_putreg(RXDCTL15), 3283 igb_putreg(LEDCTL), 3284 igb_putreg(TCTL), 3285 igb_putreg(TCTL_EXT), 3286 igb_putreg(DTXCTL), 3287 igb_putreg(RXPBS), 3288 igb_putreg(RQDPC0), 3289 igb_putreg(FCAL), 3290 igb_putreg(FCRUC), 3291 igb_putreg(WUC), 3292 igb_putreg(WUS), 3293 igb_putreg(IPAV), 3294 igb_putreg(TDBAH0), 3295 igb_putreg(TDBAH1), 3296 igb_putreg(TDBAH2), 3297 igb_putreg(TDBAH3), 3298 igb_putreg(TDBAH4), 3299 igb_putreg(TDBAH5), 3300 igb_putreg(TDBAH6), 3301 igb_putreg(TDBAH7), 3302 igb_putreg(TDBAH8), 3303 igb_putreg(TDBAH9), 3304 igb_putreg(TDBAH10), 3305 igb_putreg(TDBAH11), 3306 igb_putreg(TDBAH12), 3307 igb_putreg(TDBAH13), 3308 igb_putreg(TDBAH14), 3309 igb_putreg(TDBAH15), 3310 igb_putreg(IAM), 3311 igb_putreg(MANC), 3312 igb_putreg(MANC2H), 3313 igb_putreg(MFVAL), 3314 igb_putreg(FACTPS), 3315 igb_putreg(FUNCTAG), 3316 igb_putreg(GSCL_1), 3317 igb_putreg(GSCL_2), 3318 igb_putreg(GSCL_3), 3319 igb_putreg(GSCL_4), 3320 igb_putreg(GSCN_0), 3321 igb_putreg(GSCN_1), 3322 igb_putreg(GSCN_2), 3323 igb_putreg(GSCN_3), 3324 igb_putreg(MRQC), 3325 igb_putreg(FLOP), 3326 igb_putreg(FLA), 3327 igb_putreg(TXDCTL0), 3328 igb_putreg(TXDCTL1), 3329 igb_putreg(TXDCTL2), 3330 igb_putreg(TXDCTL3), 3331 igb_putreg(TXDCTL4), 3332 igb_putreg(TXDCTL5), 3333 igb_putreg(TXDCTL6), 3334 igb_putreg(TXDCTL7), 3335 igb_putreg(TXDCTL8), 3336 igb_putreg(TXDCTL9), 3337 igb_putreg(TXDCTL10), 3338 igb_putreg(TXDCTL11), 3339 igb_putreg(TXDCTL12), 3340 igb_putreg(TXDCTL13), 3341 igb_putreg(TXDCTL14), 3342 igb_putreg(TXDCTL15), 3343 igb_putreg(TXCTL0), 3344 igb_putreg(TXCTL1), 3345 igb_putreg(TXCTL2), 3346 igb_putreg(TXCTL3), 3347 igb_putreg(TXCTL4), 3348 igb_putreg(TXCTL5), 3349 igb_putreg(TXCTL6), 3350 igb_putreg(TXCTL7), 3351 igb_putreg(TXCTL8), 3352 igb_putreg(TXCTL9), 3353 igb_putreg(TXCTL10), 3354 igb_putreg(TXCTL11), 3355 igb_putreg(TXCTL12), 3356 igb_putreg(TXCTL13), 3357 igb_putreg(TXCTL14), 3358 igb_putreg(TXCTL15), 3359 igb_putreg(TDWBAL0), 3360 igb_putreg(TDWBAL1), 3361 igb_putreg(TDWBAL2), 3362 igb_putreg(TDWBAL3), 3363 igb_putreg(TDWBAL4), 3364 igb_putreg(TDWBAL5), 3365 igb_putreg(TDWBAL6), 3366 igb_putreg(TDWBAL7), 3367 igb_putreg(TDWBAL8), 3368 igb_putreg(TDWBAL9), 3369 igb_putreg(TDWBAL10), 3370 igb_putreg(TDWBAL11), 3371 igb_putreg(TDWBAL12), 3372 igb_putreg(TDWBAL13), 3373 igb_putreg(TDWBAL14), 3374 igb_putreg(TDWBAL15), 3375 igb_putreg(TDWBAH0), 3376 igb_putreg(TDWBAH1), 3377 igb_putreg(TDWBAH2), 3378 igb_putreg(TDWBAH3), 3379 igb_putreg(TDWBAH4), 3380 igb_putreg(TDWBAH5), 3381 igb_putreg(TDWBAH6), 3382 igb_putreg(TDWBAH7), 3383 igb_putreg(TDWBAH8), 3384 igb_putreg(TDWBAH9), 3385 igb_putreg(TDWBAH10), 3386 igb_putreg(TDWBAH11), 3387 igb_putreg(TDWBAH12), 3388 igb_putreg(TDWBAH13), 3389 igb_putreg(TDWBAH14), 3390 igb_putreg(TDWBAH15), 3391 igb_putreg(TIPG), 3392 igb_putreg(RXSTMPH), 3393 igb_putreg(RXSTMPL), 3394 igb_putreg(RXSATRL), 3395 igb_putreg(RXSATRH), 3396 igb_putreg(TXSTMPL), 3397 igb_putreg(TXSTMPH), 3398 igb_putreg(SYSTIML), 3399 igb_putreg(SYSTIMH), 3400 igb_putreg(TIMADJL), 3401 igb_putreg(TSYNCRXCTL), 3402 igb_putreg(TSYNCTXCTL), 3403 igb_putreg(EEMNGCTL), 3404 igb_putreg(GPIE), 3405 igb_putreg(TXPBS), 3406 igb_putreg(RLPML), 3407 igb_putreg(VET), 3408 3409 [TDH0] = igb_set_16bit, 3410 [TDH1] = igb_set_16bit, 3411 [TDH2] = igb_set_16bit, 3412 [TDH3] = igb_set_16bit, 3413 [TDH4] = igb_set_16bit, 3414 [TDH5] = igb_set_16bit, 3415 [TDH6] = igb_set_16bit, 3416 [TDH7] = igb_set_16bit, 3417 [TDH8] = igb_set_16bit, 3418 [TDH9] = igb_set_16bit, 3419 [TDH10] = igb_set_16bit, 3420 [TDH11] = igb_set_16bit, 3421 [TDH12] = igb_set_16bit, 3422 [TDH13] = igb_set_16bit, 3423 [TDH14] = igb_set_16bit, 3424 [TDH15] = igb_set_16bit, 3425 [TDT0] = igb_set_tdt, 3426 [TDT1] = igb_set_tdt, 3427 [TDT2] = igb_set_tdt, 3428 [TDT3] = igb_set_tdt, 3429 [TDT4] = igb_set_tdt, 3430 [TDT5] = igb_set_tdt, 3431 [TDT6] = igb_set_tdt, 3432 [TDT7] = igb_set_tdt, 3433 [TDT8] = igb_set_tdt, 3434 [TDT9] = igb_set_tdt, 3435 [TDT10] = igb_set_tdt, 3436 [TDT11] = igb_set_tdt, 3437 [TDT12] = igb_set_tdt, 3438 [TDT13] = igb_set_tdt, 3439 [TDT14] = igb_set_tdt, 3440 [TDT15] = igb_set_tdt, 3441 [MDIC] = igb_set_mdic, 3442 [ICS] = igb_set_ics, 3443 [RDH0] = igb_set_16bit, 3444 [RDH1] = igb_set_16bit, 3445 [RDH2] = igb_set_16bit, 3446 [RDH3] = igb_set_16bit, 3447 [RDH4] = igb_set_16bit, 3448 [RDH5] = igb_set_16bit, 3449 [RDH6] = igb_set_16bit, 3450 [RDH7] = igb_set_16bit, 3451 [RDH8] = igb_set_16bit, 3452 [RDH9] = igb_set_16bit, 3453 [RDH10] = igb_set_16bit, 3454 [RDH11] = igb_set_16bit, 3455 [RDH12] = igb_set_16bit, 3456 [RDH13] = igb_set_16bit, 3457 [RDH14] = igb_set_16bit, 3458 [RDH15] = igb_set_16bit, 3459 [RDT0] = igb_set_rdt, 3460 [RDT1] = igb_set_rdt, 3461 [RDT2] = igb_set_rdt, 3462 [RDT3] = igb_set_rdt, 3463 [RDT4] = igb_set_rdt, 3464 [RDT5] = igb_set_rdt, 3465 [RDT6] = igb_set_rdt, 3466 [RDT7] = igb_set_rdt, 3467 [RDT8] = igb_set_rdt, 3468 [RDT9] = igb_set_rdt, 3469 [RDT10] = igb_set_rdt, 3470 [RDT11] = igb_set_rdt, 3471 [RDT12] = igb_set_rdt, 3472 [RDT13] = igb_set_rdt, 3473 [RDT14] = igb_set_rdt, 3474 [RDT15] = igb_set_rdt, 3475 [IMC] = igb_set_imc, 3476 [IMS] = igb_set_ims, 3477 [ICR] = igb_set_icr, 3478 [EECD] = igb_set_eecd, 3479 [RCTL] = igb_set_rx_control, 3480 [CTRL] = igb_set_ctrl, 3481 [EERD] = igb_set_eerd, 3482 [TDFH] = igb_set_13bit, 3483 [TDFT] = igb_set_13bit, 3484 [TDFHS] = igb_set_13bit, 3485 [TDFTS] = igb_set_13bit, 3486 [TDFPC] = igb_set_13bit, 3487 [RDFH] = igb_set_13bit, 3488 [RDFT] = igb_set_13bit, 3489 [RDFHS] = igb_set_13bit, 3490 [RDFTS] = igb_set_13bit, 3491 [RDFPC] = igb_set_13bit, 3492 [GCR] = igb_set_gcr, 3493 [RXCSUM] = igb_set_rxcsum, 3494 [TDLEN0] = igb_set_dlen, 3495 [TDLEN1] = igb_set_dlen, 3496 [TDLEN2] = igb_set_dlen, 3497 [TDLEN3] = igb_set_dlen, 3498 [TDLEN4] = igb_set_dlen, 3499 [TDLEN5] = igb_set_dlen, 3500 [TDLEN6] = igb_set_dlen, 3501 [TDLEN7] = igb_set_dlen, 3502 [TDLEN8] = igb_set_dlen, 3503 [TDLEN9] = igb_set_dlen, 3504 [TDLEN10] = igb_set_dlen, 3505 [TDLEN11] = igb_set_dlen, 3506 [TDLEN12] = igb_set_dlen, 3507 [TDLEN13] = igb_set_dlen, 3508 [TDLEN14] = igb_set_dlen, 3509 [TDLEN15] = igb_set_dlen, 3510 [RDLEN0] = igb_set_dlen, 3511 [RDLEN1] = igb_set_dlen, 3512 [RDLEN2] = igb_set_dlen, 3513 [RDLEN3] = igb_set_dlen, 3514 [RDLEN4] = igb_set_dlen, 3515 [RDLEN5] = igb_set_dlen, 3516 [RDLEN6] = igb_set_dlen, 3517 [RDLEN7] = igb_set_dlen, 3518 [RDLEN8] = igb_set_dlen, 3519 [RDLEN9] = igb_set_dlen, 3520 [RDLEN10] = igb_set_dlen, 3521 [RDLEN11] = igb_set_dlen, 3522 [RDLEN12] = igb_set_dlen, 3523 [RDLEN13] = igb_set_dlen, 3524 [RDLEN14] = igb_set_dlen, 3525 [RDLEN15] = igb_set_dlen, 3526 [TDBAL0] = igb_set_dbal, 3527 [TDBAL1] = igb_set_dbal, 3528 [TDBAL2] = igb_set_dbal, 3529 [TDBAL3] = igb_set_dbal, 3530 [TDBAL4] = igb_set_dbal, 3531 [TDBAL5] = igb_set_dbal, 3532 [TDBAL6] = igb_set_dbal, 3533 [TDBAL7] = igb_set_dbal, 3534 [TDBAL8] = igb_set_dbal, 3535 [TDBAL9] = igb_set_dbal, 3536 [TDBAL10] = igb_set_dbal, 3537 [TDBAL11] = igb_set_dbal, 3538 [TDBAL12] = igb_set_dbal, 3539 [TDBAL13] = igb_set_dbal, 3540 [TDBAL14] = igb_set_dbal, 3541 [TDBAL15] = igb_set_dbal, 3542 [RDBAL0] = igb_set_dbal, 3543 [RDBAL1] = igb_set_dbal, 3544 [RDBAL2] = igb_set_dbal, 3545 [RDBAL3] = igb_set_dbal, 3546 [RDBAL4] = igb_set_dbal, 3547 [RDBAL5] = igb_set_dbal, 3548 [RDBAL6] = igb_set_dbal, 3549 [RDBAL7] = igb_set_dbal, 3550 [RDBAL8] = igb_set_dbal, 3551 [RDBAL9] = igb_set_dbal, 3552 [RDBAL10] = igb_set_dbal, 3553 [RDBAL11] = igb_set_dbal, 3554 [RDBAL12] = igb_set_dbal, 3555 [RDBAL13] = igb_set_dbal, 3556 [RDBAL14] = igb_set_dbal, 3557 [RDBAL15] = igb_set_dbal, 3558 [STATUS] = igb_set_status, 3559 [PBACLR] = igb_set_pbaclr, 3560 [CTRL_EXT] = igb_set_ctrlext, 3561 [FCAH] = igb_set_16bit, 3562 [FCT] = igb_set_16bit, 3563 [FCTTV] = igb_set_16bit, 3564 [FCRTV] = igb_set_16bit, 3565 [FCRTH] = igb_set_fcrth, 3566 [FCRTL] = igb_set_fcrtl, 3567 [CTRL_DUP] = igb_set_ctrl, 3568 [RFCTL] = igb_set_rfctl, 3569 [TIMINCA] = igb_set_timinca, 3570 [TIMADJH] = igb_set_timadjh, 3571 3572 [IP6AT ... IP6AT + 3] = igb_mac_writereg, 3573 [IP4AT ... IP4AT + 6] = igb_mac_writereg, 3574 [RA] = igb_mac_writereg, 3575 [RA + 1] = igb_mac_setmacaddr, 3576 [RA + 2 ... RA + 31] = igb_mac_writereg, 3577 [RA2 ... RA2 + 31] = igb_mac_writereg, 3578 [WUPM ... WUPM + 31] = igb_mac_writereg, 3579 [MTA ... MTA + E1000_MC_TBL_SIZE - 1] = igb_mac_writereg, 3580 [VFTA ... VFTA + E1000_VLAN_FILTER_TBL_SIZE - 1] = igb_mac_writereg, 3581 [FFMT ... FFMT + 254] = igb_set_4bit, 3582 [MDEF ... MDEF + 7] = igb_mac_writereg, 3583 [FTFT ... FTFT + 254] = igb_mac_writereg, 3584 [RETA ... RETA + 31] = igb_mac_writereg, 3585 [RSSRK ... RSSRK + 9] = igb_mac_writereg, 3586 [MAVTV0 ... MAVTV3] = igb_mac_writereg, 3587 [EITR0 ... EITR0 + IGB_INTR_NUM - 1] = igb_set_eitr, 3588 3589 /* IGB specific: */ 3590 [FWSM] = igb_mac_writereg, 3591 [SW_FW_SYNC] = igb_mac_writereg, 3592 [EICR] = igb_set_eicr, 3593 [EICS] = igb_set_eics, 3594 [EIAC] = igb_set_eiac, 3595 [EIAM] = igb_set_eiam, 3596 [EIMC] = igb_set_eimc, 3597 [EIMS] = igb_set_eims, 3598 [IVAR0 ... IVAR0 + 7] = igb_mac_writereg, 3599 igb_putreg(IVAR_MISC), 3600 igb_putreg(VT_CTL), 3601 [P2VMAILBOX0 ... P2VMAILBOX7] = igb_set_pfmailbox, 3602 [V2PMAILBOX0 ... V2PMAILBOX7] = igb_set_vfmailbox, 3603 [MBVFICR] = igb_w1c, 3604 [VMBMEM0 ... VMBMEM0 + 127] = igb_mac_writereg, 3605 igb_putreg(MBVFIMR), 3606 [VFLRE] = igb_w1c, 3607 igb_putreg(VFRE), 3608 igb_putreg(VFTE), 3609 igb_putreg(QDE), 3610 igb_putreg(DTXSWC), 3611 igb_putreg(RPLOLR), 3612 [VLVF0 ... VLVF0 + E1000_VLVF_ARRAY_SIZE - 1] = igb_mac_writereg, 3613 [VMVIR0 ... VMVIR7] = igb_mac_writereg, 3614 [VMOLR0 ... VMOLR7] = igb_mac_writereg, 3615 [UTA ... UTA + E1000_MC_TBL_SIZE - 1] = igb_mac_writereg, 3616 [PVTCTRL0] = igb_set_vtctrl, 3617 [PVTCTRL1] = igb_set_vtctrl, 3618 [PVTCTRL2] = igb_set_vtctrl, 3619 [PVTCTRL3] = igb_set_vtctrl, 3620 [PVTCTRL4] = igb_set_vtctrl, 3621 [PVTCTRL5] = igb_set_vtctrl, 3622 [PVTCTRL6] = igb_set_vtctrl, 3623 [PVTCTRL7] = igb_set_vtctrl, 3624 [PVTEICS0] = igb_set_vteics, 3625 [PVTEICS1] = igb_set_vteics, 3626 [PVTEICS2] = igb_set_vteics, 3627 [PVTEICS3] = igb_set_vteics, 3628 [PVTEICS4] = igb_set_vteics, 3629 [PVTEICS5] = igb_set_vteics, 3630 [PVTEICS6] = igb_set_vteics, 3631 [PVTEICS7] = igb_set_vteics, 3632 [PVTEIMS0] = igb_set_vteims, 3633 [PVTEIMS1] = igb_set_vteims, 3634 [PVTEIMS2] = igb_set_vteims, 3635 [PVTEIMS3] = igb_set_vteims, 3636 [PVTEIMS4] = igb_set_vteims, 3637 [PVTEIMS5] = igb_set_vteims, 3638 [PVTEIMS6] = igb_set_vteims, 3639 [PVTEIMS7] = igb_set_vteims, 3640 [PVTEIMC0] = igb_set_vteimc, 3641 [PVTEIMC1] = igb_set_vteimc, 3642 [PVTEIMC2] = igb_set_vteimc, 3643 [PVTEIMC3] = igb_set_vteimc, 3644 [PVTEIMC4] = igb_set_vteimc, 3645 [PVTEIMC5] = igb_set_vteimc, 3646 [PVTEIMC6] = igb_set_vteimc, 3647 [PVTEIMC7] = igb_set_vteimc, 3648 [PVTEIAC0] = igb_set_vteiac, 3649 [PVTEIAC1] = igb_set_vteiac, 3650 [PVTEIAC2] = igb_set_vteiac, 3651 [PVTEIAC3] = igb_set_vteiac, 3652 [PVTEIAC4] = igb_set_vteiac, 3653 [PVTEIAC5] = igb_set_vteiac, 3654 [PVTEIAC6] = igb_set_vteiac, 3655 [PVTEIAC7] = igb_set_vteiac, 3656 [PVTEIAM0] = igb_set_vteiam, 3657 [PVTEIAM1] = igb_set_vteiam, 3658 [PVTEIAM2] = igb_set_vteiam, 3659 [PVTEIAM3] = igb_set_vteiam, 3660 [PVTEIAM4] = igb_set_vteiam, 3661 [PVTEIAM5] = igb_set_vteiam, 3662 [PVTEIAM6] = igb_set_vteiam, 3663 [PVTEIAM7] = igb_set_vteiam, 3664 [PVTEICR0] = igb_set_vteicr, 3665 [PVTEICR1] = igb_set_vteicr, 3666 [PVTEICR2] = igb_set_vteicr, 3667 [PVTEICR3] = igb_set_vteicr, 3668 [PVTEICR4] = igb_set_vteicr, 3669 [PVTEICR5] = igb_set_vteicr, 3670 [PVTEICR6] = igb_set_vteicr, 3671 [PVTEICR7] = igb_set_vteicr, 3672 [VTIVAR ... VTIVAR + 7] = igb_set_vtivar, 3673 [VTIVAR_MISC ... VTIVAR_MISC + 7] = igb_mac_writereg 3674 }; 3675 enum { IGB_NWRITEOPS = ARRAY_SIZE(igb_macreg_writeops) }; 3676 3677 enum { MAC_ACCESS_PARTIAL = 1 }; 3678 3679 /* 3680 * The array below combines alias offsets of the index values for the 3681 * MAC registers that have aliases, with the indication of not fully 3682 * implemented registers (lowest bit). This combination is possible 3683 * because all of the offsets are even. 3684 */ 3685 static const uint16_t mac_reg_access[E1000E_MAC_SIZE] = { 3686 /* Alias index offsets */ 3687 [FCRTL_A] = 0x07fe, 3688 [RDFH_A] = 0xe904, [RDFT_A] = 0xe904, 3689 [TDFH_A] = 0xed00, [TDFT_A] = 0xed00, 3690 [RA_A ... RA_A + 31] = 0x14f0, 3691 [VFTA_A ... VFTA_A + E1000_VLAN_FILTER_TBL_SIZE - 1] = 0x1400, 3692 3693 [RDBAL0_A] = 0x2600, 3694 [RDBAH0_A] = 0x2600, 3695 [RDLEN0_A] = 0x2600, 3696 [SRRCTL0_A] = 0x2600, 3697 [RDH0_A] = 0x2600, 3698 [RDT0_A] = 0x2600, 3699 [RXDCTL0_A] = 0x2600, 3700 [RXCTL0_A] = 0x2600, 3701 [RQDPC0_A] = 0x2600, 3702 [RDBAL1_A] = 0x25D0, 3703 [RDBAL2_A] = 0x25A0, 3704 [RDBAL3_A] = 0x2570, 3705 [RDBAH1_A] = 0x25D0, 3706 [RDBAH2_A] = 0x25A0, 3707 [RDBAH3_A] = 0x2570, 3708 [RDLEN1_A] = 0x25D0, 3709 [RDLEN2_A] = 0x25A0, 3710 [RDLEN3_A] = 0x2570, 3711 [SRRCTL1_A] = 0x25D0, 3712 [SRRCTL2_A] = 0x25A0, 3713 [SRRCTL3_A] = 0x2570, 3714 [RDH1_A] = 0x25D0, 3715 [RDH2_A] = 0x25A0, 3716 [RDH3_A] = 0x2570, 3717 [RDT1_A] = 0x25D0, 3718 [RDT2_A] = 0x25A0, 3719 [RDT3_A] = 0x2570, 3720 [RXDCTL1_A] = 0x25D0, 3721 [RXDCTL2_A] = 0x25A0, 3722 [RXDCTL3_A] = 0x2570, 3723 [RXCTL1_A] = 0x25D0, 3724 [RXCTL2_A] = 0x25A0, 3725 [RXCTL3_A] = 0x2570, 3726 [RQDPC1_A] = 0x25D0, 3727 [RQDPC2_A] = 0x25A0, 3728 [RQDPC3_A] = 0x2570, 3729 [TDBAL0_A] = 0x2A00, 3730 [TDBAH0_A] = 0x2A00, 3731 [TDLEN0_A] = 0x2A00, 3732 [TDH0_A] = 0x2A00, 3733 [TDT0_A] = 0x2A00, 3734 [TXCTL0_A] = 0x2A00, 3735 [TDWBAL0_A] = 0x2A00, 3736 [TDWBAH0_A] = 0x2A00, 3737 [TDBAL1_A] = 0x29D0, 3738 [TDBAL2_A] = 0x29A0, 3739 [TDBAL3_A] = 0x2970, 3740 [TDBAH1_A] = 0x29D0, 3741 [TDBAH2_A] = 0x29A0, 3742 [TDBAH3_A] = 0x2970, 3743 [TDLEN1_A] = 0x29D0, 3744 [TDLEN2_A] = 0x29A0, 3745 [TDLEN3_A] = 0x2970, 3746 [TDH1_A] = 0x29D0, 3747 [TDH2_A] = 0x29A0, 3748 [TDH3_A] = 0x2970, 3749 [TDT1_A] = 0x29D0, 3750 [TDT2_A] = 0x29A0, 3751 [TDT3_A] = 0x2970, 3752 [TXDCTL0_A] = 0x2A00, 3753 [TXDCTL1_A] = 0x29D0, 3754 [TXDCTL2_A] = 0x29A0, 3755 [TXDCTL3_A] = 0x2970, 3756 [TXCTL1_A] = 0x29D0, 3757 [TXCTL2_A] = 0x29A0, 3758 [TXCTL3_A] = 0x29D0, 3759 [TDWBAL1_A] = 0x29D0, 3760 [TDWBAL2_A] = 0x29A0, 3761 [TDWBAL3_A] = 0x2970, 3762 [TDWBAH1_A] = 0x29D0, 3763 [TDWBAH2_A] = 0x29A0, 3764 [TDWBAH3_A] = 0x2970, 3765 3766 /* Access options */ 3767 [RDFH] = MAC_ACCESS_PARTIAL, [RDFT] = MAC_ACCESS_PARTIAL, 3768 [RDFHS] = MAC_ACCESS_PARTIAL, [RDFTS] = MAC_ACCESS_PARTIAL, 3769 [RDFPC] = MAC_ACCESS_PARTIAL, 3770 [TDFH] = MAC_ACCESS_PARTIAL, [TDFT] = MAC_ACCESS_PARTIAL, 3771 [TDFHS] = MAC_ACCESS_PARTIAL, [TDFTS] = MAC_ACCESS_PARTIAL, 3772 [TDFPC] = MAC_ACCESS_PARTIAL, [EECD] = MAC_ACCESS_PARTIAL, 3773 [FLA] = MAC_ACCESS_PARTIAL, 3774 [FCAL] = MAC_ACCESS_PARTIAL, [FCAH] = MAC_ACCESS_PARTIAL, 3775 [FCT] = MAC_ACCESS_PARTIAL, [FCTTV] = MAC_ACCESS_PARTIAL, 3776 [FCRTV] = MAC_ACCESS_PARTIAL, [FCRTL] = MAC_ACCESS_PARTIAL, 3777 [FCRTH] = MAC_ACCESS_PARTIAL, 3778 [MAVTV0 ... MAVTV3] = MAC_ACCESS_PARTIAL 3779 }; 3780 3781 void 3782 igb_core_write(IGBCore *core, hwaddr addr, uint64_t val, unsigned size) 3783 { 3784 uint16_t index = igb_get_reg_index_with_offset(mac_reg_access, addr); 3785 3786 if (index < IGB_NWRITEOPS && igb_macreg_writeops[index]) { 3787 if (mac_reg_access[index] & MAC_ACCESS_PARTIAL) { 3788 trace_e1000e_wrn_regs_write_trivial(index << 2); 3789 } 3790 trace_e1000e_core_write(index << 2, size, val); 3791 igb_macreg_writeops[index](core, index, val); 3792 } else if (index < IGB_NREADOPS && igb_macreg_readops[index]) { 3793 trace_e1000e_wrn_regs_write_ro(index << 2, size, val); 3794 } else { 3795 trace_e1000e_wrn_regs_write_unknown(index << 2, size, val); 3796 } 3797 } 3798 3799 uint64_t 3800 igb_core_read(IGBCore *core, hwaddr addr, unsigned size) 3801 { 3802 uint64_t val; 3803 uint16_t index = igb_get_reg_index_with_offset(mac_reg_access, addr); 3804 3805 if (index < IGB_NREADOPS && igb_macreg_readops[index]) { 3806 if (mac_reg_access[index] & MAC_ACCESS_PARTIAL) { 3807 trace_e1000e_wrn_regs_read_trivial(index << 2); 3808 } 3809 val = igb_macreg_readops[index](core, index); 3810 trace_e1000e_core_read(index << 2, size, val); 3811 return val; 3812 } else { 3813 trace_e1000e_wrn_regs_read_unknown(index << 2, size); 3814 } 3815 return 0; 3816 } 3817 3818 static inline void 3819 igb_autoneg_pause(IGBCore *core) 3820 { 3821 timer_del(core->autoneg_timer); 3822 } 3823 3824 static void 3825 igb_autoneg_resume(IGBCore *core) 3826 { 3827 if (igb_have_autoneg(core) && 3828 !(core->phy[MII_BMSR] & MII_BMSR_AN_COMP)) { 3829 qemu_get_queue(core->owner_nic)->link_down = false; 3830 timer_mod(core->autoneg_timer, 3831 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 500); 3832 } 3833 } 3834 3835 static void 3836 igb_vm_state_change(void *opaque, bool running, RunState state) 3837 { 3838 IGBCore *core = opaque; 3839 3840 if (running) { 3841 trace_e1000e_vm_state_running(); 3842 igb_intrmgr_resume(core); 3843 igb_autoneg_resume(core); 3844 } else { 3845 trace_e1000e_vm_state_stopped(); 3846 igb_autoneg_pause(core); 3847 igb_intrmgr_pause(core); 3848 } 3849 } 3850 3851 void 3852 igb_core_pci_realize(IGBCore *core, 3853 const uint16_t *eeprom_templ, 3854 uint32_t eeprom_size, 3855 const uint8_t *macaddr) 3856 { 3857 int i; 3858 3859 core->autoneg_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, 3860 igb_autoneg_timer, core); 3861 igb_intrmgr_pci_realize(core); 3862 3863 core->vmstate = qemu_add_vm_change_state_handler(igb_vm_state_change, core); 3864 3865 for (i = 0; i < IGB_NUM_QUEUES; i++) { 3866 net_tx_pkt_init(&core->tx[i].tx_pkt, NULL, E1000E_MAX_TX_FRAGS); 3867 } 3868 3869 net_rx_pkt_init(&core->rx_pkt); 3870 3871 e1000x_core_prepare_eeprom(core->eeprom, 3872 eeprom_templ, 3873 eeprom_size, 3874 PCI_DEVICE_GET_CLASS(core->owner)->device_id, 3875 macaddr); 3876 igb_update_rx_offloads(core); 3877 } 3878 3879 void 3880 igb_core_pci_uninit(IGBCore *core) 3881 { 3882 int i; 3883 3884 timer_free(core->autoneg_timer); 3885 3886 igb_intrmgr_pci_unint(core); 3887 3888 qemu_del_vm_change_state_handler(core->vmstate); 3889 3890 for (i = 0; i < IGB_NUM_QUEUES; i++) { 3891 net_tx_pkt_reset(core->tx[i].tx_pkt, NULL); 3892 net_tx_pkt_uninit(core->tx[i].tx_pkt); 3893 } 3894 3895 net_rx_pkt_uninit(core->rx_pkt); 3896 } 3897 3898 static const uint16_t 3899 igb_phy_reg_init[] = { 3900 [MII_BMCR] = MII_BMCR_SPEED1000 | 3901 MII_BMCR_FD | 3902 MII_BMCR_AUTOEN, 3903 3904 [MII_BMSR] = MII_BMSR_EXTCAP | 3905 MII_BMSR_LINK_ST | 3906 MII_BMSR_AUTONEG | 3907 MII_BMSR_MFPS | 3908 MII_BMSR_EXTSTAT | 3909 MII_BMSR_10T_HD | 3910 MII_BMSR_10T_FD | 3911 MII_BMSR_100TX_HD | 3912 MII_BMSR_100TX_FD, 3913 3914 [MII_PHYID1] = IGP03E1000_E_PHY_ID >> 16, 3915 [MII_PHYID2] = (IGP03E1000_E_PHY_ID & 0xfff0) | 1, 3916 [MII_ANAR] = MII_ANAR_CSMACD | MII_ANAR_10 | 3917 MII_ANAR_10FD | MII_ANAR_TX | 3918 MII_ANAR_TXFD | MII_ANAR_PAUSE | 3919 MII_ANAR_PAUSE_ASYM, 3920 [MII_ANLPAR] = MII_ANLPAR_10 | MII_ANLPAR_10FD | 3921 MII_ANLPAR_TX | MII_ANLPAR_TXFD | 3922 MII_ANLPAR_T4 | MII_ANLPAR_PAUSE, 3923 [MII_ANER] = MII_ANER_NP | MII_ANER_NWAY, 3924 [MII_ANNP] = 0x1 | MII_ANNP_MP, 3925 [MII_CTRL1000] = MII_CTRL1000_HALF | MII_CTRL1000_FULL | 3926 MII_CTRL1000_PORT | MII_CTRL1000_MASTER, 3927 [MII_STAT1000] = MII_STAT1000_HALF | MII_STAT1000_FULL | 3928 MII_STAT1000_ROK | MII_STAT1000_LOK, 3929 [MII_EXTSTAT] = MII_EXTSTAT_1000T_HD | MII_EXTSTAT_1000T_FD, 3930 3931 [IGP01E1000_PHY_PORT_CONFIG] = BIT(5) | BIT(8), 3932 [IGP01E1000_PHY_PORT_STATUS] = IGP01E1000_PSSR_SPEED_1000MBPS, 3933 [IGP02E1000_PHY_POWER_MGMT] = BIT(0) | BIT(3) | IGP02E1000_PM_D3_LPLU | 3934 IGP01E1000_PSCFR_SMART_SPEED 3935 }; 3936 3937 static const uint32_t igb_mac_reg_init[] = { 3938 [LEDCTL] = 2 | (3 << 8) | BIT(15) | (6 << 16) | (7 << 24), 3939 [EEMNGCTL] = BIT(31), 3940 [TXDCTL0] = E1000_TXDCTL_QUEUE_ENABLE, 3941 [RXDCTL0] = E1000_RXDCTL_QUEUE_ENABLE | (1 << 16), 3942 [RXDCTL1] = 1 << 16, 3943 [RXDCTL2] = 1 << 16, 3944 [RXDCTL3] = 1 << 16, 3945 [RXDCTL4] = 1 << 16, 3946 [RXDCTL5] = 1 << 16, 3947 [RXDCTL6] = 1 << 16, 3948 [RXDCTL7] = 1 << 16, 3949 [RXDCTL8] = 1 << 16, 3950 [RXDCTL9] = 1 << 16, 3951 [RXDCTL10] = 1 << 16, 3952 [RXDCTL11] = 1 << 16, 3953 [RXDCTL12] = 1 << 16, 3954 [RXDCTL13] = 1 << 16, 3955 [RXDCTL14] = 1 << 16, 3956 [RXDCTL15] = 1 << 16, 3957 [TIPG] = 0x08 | (0x04 << 10) | (0x06 << 20), 3958 [CTRL] = E1000_CTRL_FD | E1000_CTRL_LRST | E1000_CTRL_SPD_1000 | 3959 E1000_CTRL_ADVD3WUC, 3960 [STATUS] = E1000_STATUS_PHYRA | BIT(31), 3961 [EECD] = E1000_EECD_FWE_DIS | E1000_EECD_PRES | 3962 (2 << E1000_EECD_SIZE_EX_SHIFT), 3963 [GCR] = E1000_L0S_ADJUST | 3964 E1000_GCR_CMPL_TMOUT_RESEND | 3965 E1000_GCR_CAP_VER2 | 3966 E1000_L1_ENTRY_LATENCY_MSB | 3967 E1000_L1_ENTRY_LATENCY_LSB, 3968 [RXCSUM] = E1000_RXCSUM_IPOFLD | E1000_RXCSUM_TUOFLD, 3969 [TXPBS] = 0x28, 3970 [RXPBS] = 0x40, 3971 [TCTL] = E1000_TCTL_PSP | (0xF << E1000_CT_SHIFT) | 3972 (0x40 << E1000_COLD_SHIFT) | (0x1 << 26) | (0xA << 28), 3973 [TCTL_EXT] = 0x40 | (0x42 << 10), 3974 [DTXCTL] = E1000_DTXCTL_8023LL | E1000_DTXCTL_SPOOF_INT, 3975 [VET] = ETH_P_VLAN | (ETH_P_VLAN << 16), 3976 3977 [V2PMAILBOX0 ... V2PMAILBOX0 + IGB_MAX_VF_FUNCTIONS - 1] = E1000_V2PMAILBOX_RSTI, 3978 [MBVFIMR] = 0xFF, 3979 [VFRE] = 0xFF, 3980 [VFTE] = 0xFF, 3981 [VMOLR0 ... VMOLR0 + 7] = 0x2600 | E1000_VMOLR_STRCRC, 3982 [RPLOLR] = E1000_RPLOLR_STRCRC, 3983 [RLPML] = 0x2600, 3984 [TXCTL0] = E1000_DCA_TXCTRL_DATA_RRO_EN | 3985 E1000_DCA_TXCTRL_TX_WB_RO_EN | 3986 E1000_DCA_TXCTRL_DESC_RRO_EN, 3987 [TXCTL1] = E1000_DCA_TXCTRL_DATA_RRO_EN | 3988 E1000_DCA_TXCTRL_TX_WB_RO_EN | 3989 E1000_DCA_TXCTRL_DESC_RRO_EN, 3990 [TXCTL2] = E1000_DCA_TXCTRL_DATA_RRO_EN | 3991 E1000_DCA_TXCTRL_TX_WB_RO_EN | 3992 E1000_DCA_TXCTRL_DESC_RRO_EN, 3993 [TXCTL3] = E1000_DCA_TXCTRL_DATA_RRO_EN | 3994 E1000_DCA_TXCTRL_TX_WB_RO_EN | 3995 E1000_DCA_TXCTRL_DESC_RRO_EN, 3996 [TXCTL4] = E1000_DCA_TXCTRL_DATA_RRO_EN | 3997 E1000_DCA_TXCTRL_TX_WB_RO_EN | 3998 E1000_DCA_TXCTRL_DESC_RRO_EN, 3999 [TXCTL5] = E1000_DCA_TXCTRL_DATA_RRO_EN | 4000 E1000_DCA_TXCTRL_TX_WB_RO_EN | 4001 E1000_DCA_TXCTRL_DESC_RRO_EN, 4002 [TXCTL6] = E1000_DCA_TXCTRL_DATA_RRO_EN | 4003 E1000_DCA_TXCTRL_TX_WB_RO_EN | 4004 E1000_DCA_TXCTRL_DESC_RRO_EN, 4005 [TXCTL7] = E1000_DCA_TXCTRL_DATA_RRO_EN | 4006 E1000_DCA_TXCTRL_TX_WB_RO_EN | 4007 E1000_DCA_TXCTRL_DESC_RRO_EN, 4008 [TXCTL8] = E1000_DCA_TXCTRL_DATA_RRO_EN | 4009 E1000_DCA_TXCTRL_TX_WB_RO_EN | 4010 E1000_DCA_TXCTRL_DESC_RRO_EN, 4011 [TXCTL9] = E1000_DCA_TXCTRL_DATA_RRO_EN | 4012 E1000_DCA_TXCTRL_TX_WB_RO_EN | 4013 E1000_DCA_TXCTRL_DESC_RRO_EN, 4014 [TXCTL10] = E1000_DCA_TXCTRL_DATA_RRO_EN | 4015 E1000_DCA_TXCTRL_TX_WB_RO_EN | 4016 E1000_DCA_TXCTRL_DESC_RRO_EN, 4017 [TXCTL11] = E1000_DCA_TXCTRL_DATA_RRO_EN | 4018 E1000_DCA_TXCTRL_TX_WB_RO_EN | 4019 E1000_DCA_TXCTRL_DESC_RRO_EN, 4020 [TXCTL12] = E1000_DCA_TXCTRL_DATA_RRO_EN | 4021 E1000_DCA_TXCTRL_TX_WB_RO_EN | 4022 E1000_DCA_TXCTRL_DESC_RRO_EN, 4023 [TXCTL13] = E1000_DCA_TXCTRL_DATA_RRO_EN | 4024 E1000_DCA_TXCTRL_TX_WB_RO_EN | 4025 E1000_DCA_TXCTRL_DESC_RRO_EN, 4026 [TXCTL14] = E1000_DCA_TXCTRL_DATA_RRO_EN | 4027 E1000_DCA_TXCTRL_TX_WB_RO_EN | 4028 E1000_DCA_TXCTRL_DESC_RRO_EN, 4029 [TXCTL15] = E1000_DCA_TXCTRL_DATA_RRO_EN | 4030 E1000_DCA_TXCTRL_TX_WB_RO_EN | 4031 E1000_DCA_TXCTRL_DESC_RRO_EN, 4032 }; 4033 4034 static void igb_reset(IGBCore *core, bool sw) 4035 { 4036 struct igb_tx *tx; 4037 int i; 4038 4039 timer_del(core->autoneg_timer); 4040 4041 igb_intrmgr_reset(core); 4042 4043 memset(core->phy, 0, sizeof core->phy); 4044 memcpy(core->phy, igb_phy_reg_init, sizeof igb_phy_reg_init); 4045 4046 for (i = 0; i < E1000E_MAC_SIZE; i++) { 4047 if (sw && 4048 (i == RXPBS || i == TXPBS || 4049 (i >= EITR0 && i < EITR0 + IGB_INTR_NUM))) { 4050 continue; 4051 } 4052 4053 core->mac[i] = i < ARRAY_SIZE(igb_mac_reg_init) ? 4054 igb_mac_reg_init[i] : 0; 4055 } 4056 4057 if (qemu_get_queue(core->owner_nic)->link_down) { 4058 igb_link_down(core); 4059 } 4060 4061 e1000x_reset_mac_addr(core->owner_nic, core->mac, core->permanent_mac); 4062 4063 for (int vfn = 0; vfn < IGB_MAX_VF_FUNCTIONS; vfn++) { 4064 /* Set RSTI, so VF can identify a PF reset is in progress */ 4065 core->mac[V2PMAILBOX0 + vfn] |= E1000_V2PMAILBOX_RSTI; 4066 } 4067 4068 for (i = 0; i < ARRAY_SIZE(core->tx); i++) { 4069 tx = &core->tx[i]; 4070 net_tx_pkt_reset(tx->tx_pkt, NULL); 4071 memset(tx->ctx, 0, sizeof(tx->ctx)); 4072 tx->first = true; 4073 tx->skip_cp = false; 4074 } 4075 } 4076 4077 void 4078 igb_core_reset(IGBCore *core) 4079 { 4080 igb_reset(core, false); 4081 } 4082 4083 void igb_core_pre_save(IGBCore *core) 4084 { 4085 int i; 4086 NetClientState *nc = qemu_get_queue(core->owner_nic); 4087 4088 /* 4089 * If link is down and auto-negotiation is supported and ongoing, 4090 * complete auto-negotiation immediately. This allows us to look 4091 * at MII_BMSR_AN_COMP to infer link status on load. 4092 */ 4093 if (nc->link_down && igb_have_autoneg(core)) { 4094 core->phy[MII_BMSR] |= MII_BMSR_AN_COMP; 4095 igb_update_flowctl_status(core); 4096 } 4097 4098 for (i = 0; i < ARRAY_SIZE(core->tx); i++) { 4099 if (net_tx_pkt_has_fragments(core->tx[i].tx_pkt)) { 4100 core->tx[i].skip_cp = true; 4101 } 4102 } 4103 } 4104 4105 int 4106 igb_core_post_load(IGBCore *core) 4107 { 4108 NetClientState *nc = qemu_get_queue(core->owner_nic); 4109 4110 /* 4111 * nc.link_down can't be migrated, so infer link_down according 4112 * to link status bit in core.mac[STATUS]. 4113 */ 4114 nc->link_down = (core->mac[STATUS] & E1000_STATUS_LU) == 0; 4115 4116 return 0; 4117 } 4118