1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 1999 - 2006 Intel Corporation. */ 3 4 #include "e1000.h" 5 #include <net/ip6_checksum.h> 6 #include <linux/io.h> 7 #include <linux/prefetch.h> 8 #include <linux/bitops.h> 9 #include <linux/if_vlan.h> 10 11 char e1000_driver_name[] = "e1000"; 12 static char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver"; 13 #define DRV_VERSION "7.3.21-k8-NAPI" 14 const char e1000_driver_version[] = DRV_VERSION; 15 static const char e1000_copyright[] = "Copyright (c) 1999-2006 Intel Corporation."; 16 17 /* e1000_pci_tbl - PCI Device ID Table 18 * 19 * Last entry must be all 0s 20 * 21 * Macro expands to... 22 * {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)} 23 */ 24 static const struct pci_device_id e1000_pci_tbl[] = { 25 INTEL_E1000_ETHERNET_DEVICE(0x1000), 26 INTEL_E1000_ETHERNET_DEVICE(0x1001), 27 INTEL_E1000_ETHERNET_DEVICE(0x1004), 28 INTEL_E1000_ETHERNET_DEVICE(0x1008), 29 INTEL_E1000_ETHERNET_DEVICE(0x1009), 30 INTEL_E1000_ETHERNET_DEVICE(0x100C), 31 INTEL_E1000_ETHERNET_DEVICE(0x100D), 32 INTEL_E1000_ETHERNET_DEVICE(0x100E), 33 INTEL_E1000_ETHERNET_DEVICE(0x100F), 34 INTEL_E1000_ETHERNET_DEVICE(0x1010), 35 INTEL_E1000_ETHERNET_DEVICE(0x1011), 36 INTEL_E1000_ETHERNET_DEVICE(0x1012), 37 INTEL_E1000_ETHERNET_DEVICE(0x1013), 38 INTEL_E1000_ETHERNET_DEVICE(0x1014), 39 INTEL_E1000_ETHERNET_DEVICE(0x1015), 40 INTEL_E1000_ETHERNET_DEVICE(0x1016), 41 INTEL_E1000_ETHERNET_DEVICE(0x1017), 42 INTEL_E1000_ETHERNET_DEVICE(0x1018), 43 INTEL_E1000_ETHERNET_DEVICE(0x1019), 44 INTEL_E1000_ETHERNET_DEVICE(0x101A), 45 INTEL_E1000_ETHERNET_DEVICE(0x101D), 46 INTEL_E1000_ETHERNET_DEVICE(0x101E), 47 INTEL_E1000_ETHERNET_DEVICE(0x1026), 48 INTEL_E1000_ETHERNET_DEVICE(0x1027), 49 INTEL_E1000_ETHERNET_DEVICE(0x1028), 50 INTEL_E1000_ETHERNET_DEVICE(0x1075), 51 INTEL_E1000_ETHERNET_DEVICE(0x1076), 52 INTEL_E1000_ETHERNET_DEVICE(0x1077), 53 INTEL_E1000_ETHERNET_DEVICE(0x1078), 54 INTEL_E1000_ETHERNET_DEVICE(0x1079), 55 INTEL_E1000_ETHERNET_DEVICE(0x107A), 56 INTEL_E1000_ETHERNET_DEVICE(0x107B), 57 INTEL_E1000_ETHERNET_DEVICE(0x107C), 58 INTEL_E1000_ETHERNET_DEVICE(0x108A), 59 INTEL_E1000_ETHERNET_DEVICE(0x1099), 60 INTEL_E1000_ETHERNET_DEVICE(0x10B5), 61 INTEL_E1000_ETHERNET_DEVICE(0x2E6E), 62 /* required last entry */ 63 {0,} 64 }; 65 66 MODULE_DEVICE_TABLE(pci, e1000_pci_tbl); 67 68 int e1000_up(struct e1000_adapter *adapter); 69 void e1000_down(struct e1000_adapter *adapter); 70 void e1000_reinit_locked(struct e1000_adapter *adapter); 71 void e1000_reset(struct e1000_adapter *adapter); 72 int e1000_setup_all_tx_resources(struct e1000_adapter *adapter); 73 int e1000_setup_all_rx_resources(struct e1000_adapter *adapter); 74 void e1000_free_all_tx_resources(struct e1000_adapter *adapter); 75 void e1000_free_all_rx_resources(struct e1000_adapter *adapter); 76 static int e1000_setup_tx_resources(struct e1000_adapter *adapter, 77 struct e1000_tx_ring *txdr); 78 static int e1000_setup_rx_resources(struct e1000_adapter *adapter, 79 struct e1000_rx_ring *rxdr); 80 static void e1000_free_tx_resources(struct e1000_adapter *adapter, 81 struct e1000_tx_ring *tx_ring); 82 static void e1000_free_rx_resources(struct e1000_adapter *adapter, 83 struct e1000_rx_ring *rx_ring); 84 void e1000_update_stats(struct e1000_adapter *adapter); 85 86 static int e1000_init_module(void); 87 static void e1000_exit_module(void); 88 static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent); 89 static void e1000_remove(struct pci_dev *pdev); 90 static int e1000_alloc_queues(struct e1000_adapter *adapter); 91 static int e1000_sw_init(struct e1000_adapter *adapter); 92 int e1000_open(struct net_device *netdev); 93 int e1000_close(struct net_device *netdev); 94 static void e1000_configure_tx(struct e1000_adapter *adapter); 95 static void e1000_configure_rx(struct e1000_adapter *adapter); 96 static void e1000_setup_rctl(struct e1000_adapter *adapter); 97 static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter); 98 static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter); 99 static void e1000_clean_tx_ring(struct e1000_adapter *adapter, 100 struct e1000_tx_ring *tx_ring); 101 static void e1000_clean_rx_ring(struct e1000_adapter *adapter, 102 struct e1000_rx_ring *rx_ring); 103 static void e1000_set_rx_mode(struct net_device *netdev); 104 static void e1000_update_phy_info_task(struct work_struct *work); 105 static void e1000_watchdog(struct work_struct *work); 106 static void e1000_82547_tx_fifo_stall_task(struct work_struct *work); 107 static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb, 108 struct net_device *netdev); 109 static int e1000_change_mtu(struct net_device *netdev, int new_mtu); 110 static int e1000_set_mac(struct net_device *netdev, void *p); 111 static irqreturn_t e1000_intr(int irq, void *data); 112 static bool e1000_clean_tx_irq(struct e1000_adapter *adapter, 113 struct e1000_tx_ring *tx_ring); 114 static int e1000_clean(struct napi_struct *napi, int budget); 115 static bool e1000_clean_rx_irq(struct e1000_adapter *adapter, 116 struct e1000_rx_ring *rx_ring, 117 int *work_done, int work_to_do); 118 static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter, 119 struct e1000_rx_ring *rx_ring, 120 int *work_done, int work_to_do); 121 static void e1000_alloc_dummy_rx_buffers(struct e1000_adapter *adapter, 122 struct e1000_rx_ring *rx_ring, 123 int cleaned_count) 124 { 125 } 126 static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter, 127 struct e1000_rx_ring *rx_ring, 128 int cleaned_count); 129 static void e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter, 130 struct e1000_rx_ring *rx_ring, 131 int cleaned_count); 132 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd); 133 static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr, 134 int cmd); 135 static void e1000_enter_82542_rst(struct e1000_adapter *adapter); 136 static void e1000_leave_82542_rst(struct e1000_adapter *adapter); 137 static void e1000_tx_timeout(struct net_device *dev, unsigned int txqueue); 138 static void e1000_reset_task(struct work_struct *work); 139 static void e1000_smartspeed(struct e1000_adapter *adapter); 140 static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter, 141 struct sk_buff *skb); 142 143 static bool e1000_vlan_used(struct e1000_adapter *adapter); 144 static void e1000_vlan_mode(struct net_device *netdev, 145 netdev_features_t features); 146 static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter, 147 bool filter_on); 148 static int e1000_vlan_rx_add_vid(struct net_device *netdev, 149 __be16 proto, u16 vid); 150 static int e1000_vlan_rx_kill_vid(struct net_device *netdev, 151 __be16 proto, u16 vid); 152 static void e1000_restore_vlan(struct e1000_adapter *adapter); 153 154 #ifdef CONFIG_PM 155 static int e1000_suspend(struct pci_dev *pdev, pm_message_t state); 156 static int e1000_resume(struct pci_dev *pdev); 157 #endif 158 static void e1000_shutdown(struct pci_dev *pdev); 159 160 #ifdef CONFIG_NET_POLL_CONTROLLER 161 /* for netdump / net console */ 162 static void e1000_netpoll (struct net_device *netdev); 163 #endif 164 165 #define COPYBREAK_DEFAULT 256 166 static unsigned int copybreak __read_mostly = COPYBREAK_DEFAULT; 167 module_param(copybreak, uint, 0644); 168 MODULE_PARM_DESC(copybreak, 169 "Maximum size of packet that is copied to a new buffer on receive"); 170 171 static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev, 172 pci_channel_state_t state); 173 static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev); 174 static void e1000_io_resume(struct pci_dev *pdev); 175 176 static const struct pci_error_handlers e1000_err_handler = { 177 .error_detected = e1000_io_error_detected, 178 .slot_reset = e1000_io_slot_reset, 179 .resume = e1000_io_resume, 180 }; 181 182 static struct pci_driver e1000_driver = { 183 .name = e1000_driver_name, 184 .id_table = e1000_pci_tbl, 185 .probe = e1000_probe, 186 .remove = e1000_remove, 187 #ifdef CONFIG_PM 188 /* Power Management Hooks */ 189 .suspend = e1000_suspend, 190 .resume = e1000_resume, 191 #endif 192 .shutdown = e1000_shutdown, 193 .err_handler = &e1000_err_handler 194 }; 195 196 MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>"); 197 MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver"); 198 MODULE_LICENSE("GPL v2"); 199 MODULE_VERSION(DRV_VERSION); 200 201 #define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK) 202 static int debug = -1; 203 module_param(debug, int, 0); 204 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)"); 205 206 /** 207 * e1000_get_hw_dev - return device 208 * used by hardware layer to print debugging information 209 * 210 **/ 211 struct net_device *e1000_get_hw_dev(struct e1000_hw *hw) 212 { 213 struct e1000_adapter *adapter = hw->back; 214 return adapter->netdev; 215 } 216 217 /** 218 * e1000_init_module - Driver Registration Routine 219 * 220 * e1000_init_module is the first routine called when the driver is 221 * loaded. All it does is register with the PCI subsystem. 222 **/ 223 static int __init e1000_init_module(void) 224 { 225 int ret; 226 pr_info("%s - version %s\n", e1000_driver_string, e1000_driver_version); 227 228 pr_info("%s\n", e1000_copyright); 229 230 ret = pci_register_driver(&e1000_driver); 231 if (copybreak != COPYBREAK_DEFAULT) { 232 if (copybreak == 0) 233 pr_info("copybreak disabled\n"); 234 else 235 pr_info("copybreak enabled for " 236 "packets <= %u bytes\n", copybreak); 237 } 238 return ret; 239 } 240 241 module_init(e1000_init_module); 242 243 /** 244 * e1000_exit_module - Driver Exit Cleanup Routine 245 * 246 * e1000_exit_module is called just before the driver is removed 247 * from memory. 248 **/ 249 static void __exit e1000_exit_module(void) 250 { 251 pci_unregister_driver(&e1000_driver); 252 } 253 254 module_exit(e1000_exit_module); 255 256 static int e1000_request_irq(struct e1000_adapter *adapter) 257 { 258 struct net_device *netdev = adapter->netdev; 259 irq_handler_t handler = e1000_intr; 260 int irq_flags = IRQF_SHARED; 261 int err; 262 263 err = request_irq(adapter->pdev->irq, handler, irq_flags, netdev->name, 264 netdev); 265 if (err) { 266 e_err(probe, "Unable to allocate interrupt Error: %d\n", err); 267 } 268 269 return err; 270 } 271 272 static void e1000_free_irq(struct e1000_adapter *adapter) 273 { 274 struct net_device *netdev = adapter->netdev; 275 276 free_irq(adapter->pdev->irq, netdev); 277 } 278 279 /** 280 * e1000_irq_disable - Mask off interrupt generation on the NIC 281 * @adapter: board private structure 282 **/ 283 static void e1000_irq_disable(struct e1000_adapter *adapter) 284 { 285 struct e1000_hw *hw = &adapter->hw; 286 287 ew32(IMC, ~0); 288 E1000_WRITE_FLUSH(); 289 synchronize_irq(adapter->pdev->irq); 290 } 291 292 /** 293 * e1000_irq_enable - Enable default interrupt generation settings 294 * @adapter: board private structure 295 **/ 296 static void e1000_irq_enable(struct e1000_adapter *adapter) 297 { 298 struct e1000_hw *hw = &adapter->hw; 299 300 ew32(IMS, IMS_ENABLE_MASK); 301 E1000_WRITE_FLUSH(); 302 } 303 304 static void e1000_update_mng_vlan(struct e1000_adapter *adapter) 305 { 306 struct e1000_hw *hw = &adapter->hw; 307 struct net_device *netdev = adapter->netdev; 308 u16 vid = hw->mng_cookie.vlan_id; 309 u16 old_vid = adapter->mng_vlan_id; 310 311 if (!e1000_vlan_used(adapter)) 312 return; 313 314 if (!test_bit(vid, adapter->active_vlans)) { 315 if (hw->mng_cookie.status & 316 E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) { 317 e1000_vlan_rx_add_vid(netdev, htons(ETH_P_8021Q), vid); 318 adapter->mng_vlan_id = vid; 319 } else { 320 adapter->mng_vlan_id = E1000_MNG_VLAN_NONE; 321 } 322 if ((old_vid != (u16)E1000_MNG_VLAN_NONE) && 323 (vid != old_vid) && 324 !test_bit(old_vid, adapter->active_vlans)) 325 e1000_vlan_rx_kill_vid(netdev, htons(ETH_P_8021Q), 326 old_vid); 327 } else { 328 adapter->mng_vlan_id = vid; 329 } 330 } 331 332 static void e1000_init_manageability(struct e1000_adapter *adapter) 333 { 334 struct e1000_hw *hw = &adapter->hw; 335 336 if (adapter->en_mng_pt) { 337 u32 manc = er32(MANC); 338 339 /* disable hardware interception of ARP */ 340 manc &= ~(E1000_MANC_ARP_EN); 341 342 ew32(MANC, manc); 343 } 344 } 345 346 static void e1000_release_manageability(struct e1000_adapter *adapter) 347 { 348 struct e1000_hw *hw = &adapter->hw; 349 350 if (adapter->en_mng_pt) { 351 u32 manc = er32(MANC); 352 353 /* re-enable hardware interception of ARP */ 354 manc |= E1000_MANC_ARP_EN; 355 356 ew32(MANC, manc); 357 } 358 } 359 360 /** 361 * e1000_configure - configure the hardware for RX and TX 362 * @adapter = private board structure 363 **/ 364 static void e1000_configure(struct e1000_adapter *adapter) 365 { 366 struct net_device *netdev = adapter->netdev; 367 int i; 368 369 e1000_set_rx_mode(netdev); 370 371 e1000_restore_vlan(adapter); 372 e1000_init_manageability(adapter); 373 374 e1000_configure_tx(adapter); 375 e1000_setup_rctl(adapter); 376 e1000_configure_rx(adapter); 377 /* call E1000_DESC_UNUSED which always leaves 378 * at least 1 descriptor unused to make sure 379 * next_to_use != next_to_clean 380 */ 381 for (i = 0; i < adapter->num_rx_queues; i++) { 382 struct e1000_rx_ring *ring = &adapter->rx_ring[i]; 383 adapter->alloc_rx_buf(adapter, ring, 384 E1000_DESC_UNUSED(ring)); 385 } 386 } 387 388 int e1000_up(struct e1000_adapter *adapter) 389 { 390 struct e1000_hw *hw = &adapter->hw; 391 392 /* hardware has been reset, we need to reload some things */ 393 e1000_configure(adapter); 394 395 clear_bit(__E1000_DOWN, &adapter->flags); 396 397 napi_enable(&adapter->napi); 398 399 e1000_irq_enable(adapter); 400 401 netif_wake_queue(adapter->netdev); 402 403 /* fire a link change interrupt to start the watchdog */ 404 ew32(ICS, E1000_ICS_LSC); 405 return 0; 406 } 407 408 /** 409 * e1000_power_up_phy - restore link in case the phy was powered down 410 * @adapter: address of board private structure 411 * 412 * The phy may be powered down to save power and turn off link when the 413 * driver is unloaded and wake on lan is not enabled (among others) 414 * *** this routine MUST be followed by a call to e1000_reset *** 415 **/ 416 void e1000_power_up_phy(struct e1000_adapter *adapter) 417 { 418 struct e1000_hw *hw = &adapter->hw; 419 u16 mii_reg = 0; 420 421 /* Just clear the power down bit to wake the phy back up */ 422 if (hw->media_type == e1000_media_type_copper) { 423 /* according to the manual, the phy will retain its 424 * settings across a power-down/up cycle 425 */ 426 e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg); 427 mii_reg &= ~MII_CR_POWER_DOWN; 428 e1000_write_phy_reg(hw, PHY_CTRL, mii_reg); 429 } 430 } 431 432 static void e1000_power_down_phy(struct e1000_adapter *adapter) 433 { 434 struct e1000_hw *hw = &adapter->hw; 435 436 /* Power down the PHY so no link is implied when interface is down * 437 * The PHY cannot be powered down if any of the following is true * 438 * (a) WoL is enabled 439 * (b) AMT is active 440 * (c) SoL/IDER session is active 441 */ 442 if (!adapter->wol && hw->mac_type >= e1000_82540 && 443 hw->media_type == e1000_media_type_copper) { 444 u16 mii_reg = 0; 445 446 switch (hw->mac_type) { 447 case e1000_82540: 448 case e1000_82545: 449 case e1000_82545_rev_3: 450 case e1000_82546: 451 case e1000_ce4100: 452 case e1000_82546_rev_3: 453 case e1000_82541: 454 case e1000_82541_rev_2: 455 case e1000_82547: 456 case e1000_82547_rev_2: 457 if (er32(MANC) & E1000_MANC_SMBUS_EN) 458 goto out; 459 break; 460 default: 461 goto out; 462 } 463 e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg); 464 mii_reg |= MII_CR_POWER_DOWN; 465 e1000_write_phy_reg(hw, PHY_CTRL, mii_reg); 466 msleep(1); 467 } 468 out: 469 return; 470 } 471 472 static void e1000_down_and_stop(struct e1000_adapter *adapter) 473 { 474 set_bit(__E1000_DOWN, &adapter->flags); 475 476 cancel_delayed_work_sync(&adapter->watchdog_task); 477 478 /* 479 * Since the watchdog task can reschedule other tasks, we should cancel 480 * it first, otherwise we can run into the situation when a work is 481 * still running after the adapter has been turned down. 482 */ 483 484 cancel_delayed_work_sync(&adapter->phy_info_task); 485 cancel_delayed_work_sync(&adapter->fifo_stall_task); 486 487 /* Only kill reset task if adapter is not resetting */ 488 if (!test_bit(__E1000_RESETTING, &adapter->flags)) 489 cancel_work_sync(&adapter->reset_task); 490 } 491 492 void e1000_down(struct e1000_adapter *adapter) 493 { 494 struct e1000_hw *hw = &adapter->hw; 495 struct net_device *netdev = adapter->netdev; 496 u32 rctl, tctl; 497 498 /* disable receives in the hardware */ 499 rctl = er32(RCTL); 500 ew32(RCTL, rctl & ~E1000_RCTL_EN); 501 /* flush and sleep below */ 502 503 netif_tx_disable(netdev); 504 505 /* disable transmits in the hardware */ 506 tctl = er32(TCTL); 507 tctl &= ~E1000_TCTL_EN; 508 ew32(TCTL, tctl); 509 /* flush both disables and wait for them to finish */ 510 E1000_WRITE_FLUSH(); 511 msleep(10); 512 513 /* Set the carrier off after transmits have been disabled in the 514 * hardware, to avoid race conditions with e1000_watchdog() (which 515 * may be running concurrently to us, checking for the carrier 516 * bit to decide whether it should enable transmits again). Such 517 * a race condition would result into transmission being disabled 518 * in the hardware until the next IFF_DOWN+IFF_UP cycle. 519 */ 520 netif_carrier_off(netdev); 521 522 napi_disable(&adapter->napi); 523 524 e1000_irq_disable(adapter); 525 526 /* Setting DOWN must be after irq_disable to prevent 527 * a screaming interrupt. Setting DOWN also prevents 528 * tasks from rescheduling. 529 */ 530 e1000_down_and_stop(adapter); 531 532 adapter->link_speed = 0; 533 adapter->link_duplex = 0; 534 535 e1000_reset(adapter); 536 e1000_clean_all_tx_rings(adapter); 537 e1000_clean_all_rx_rings(adapter); 538 } 539 540 void e1000_reinit_locked(struct e1000_adapter *adapter) 541 { 542 WARN_ON(in_interrupt()); 543 while (test_and_set_bit(__E1000_RESETTING, &adapter->flags)) 544 msleep(1); 545 546 /* only run the task if not already down */ 547 if (!test_bit(__E1000_DOWN, &adapter->flags)) { 548 e1000_down(adapter); 549 e1000_up(adapter); 550 } 551 552 clear_bit(__E1000_RESETTING, &adapter->flags); 553 } 554 555 void e1000_reset(struct e1000_adapter *adapter) 556 { 557 struct e1000_hw *hw = &adapter->hw; 558 u32 pba = 0, tx_space, min_tx_space, min_rx_space; 559 bool legacy_pba_adjust = false; 560 u16 hwm; 561 562 /* Repartition Pba for greater than 9k mtu 563 * To take effect CTRL.RST is required. 564 */ 565 566 switch (hw->mac_type) { 567 case e1000_82542_rev2_0: 568 case e1000_82542_rev2_1: 569 case e1000_82543: 570 case e1000_82544: 571 case e1000_82540: 572 case e1000_82541: 573 case e1000_82541_rev_2: 574 legacy_pba_adjust = true; 575 pba = E1000_PBA_48K; 576 break; 577 case e1000_82545: 578 case e1000_82545_rev_3: 579 case e1000_82546: 580 case e1000_ce4100: 581 case e1000_82546_rev_3: 582 pba = E1000_PBA_48K; 583 break; 584 case e1000_82547: 585 case e1000_82547_rev_2: 586 legacy_pba_adjust = true; 587 pba = E1000_PBA_30K; 588 break; 589 case e1000_undefined: 590 case e1000_num_macs: 591 break; 592 } 593 594 if (legacy_pba_adjust) { 595 if (hw->max_frame_size > E1000_RXBUFFER_8192) 596 pba -= 8; /* allocate more FIFO for Tx */ 597 598 if (hw->mac_type == e1000_82547) { 599 adapter->tx_fifo_head = 0; 600 adapter->tx_head_addr = pba << E1000_TX_HEAD_ADDR_SHIFT; 601 adapter->tx_fifo_size = 602 (E1000_PBA_40K - pba) << E1000_PBA_BYTES_SHIFT; 603 atomic_set(&adapter->tx_fifo_stall, 0); 604 } 605 } else if (hw->max_frame_size > ETH_FRAME_LEN + ETH_FCS_LEN) { 606 /* adjust PBA for jumbo frames */ 607 ew32(PBA, pba); 608 609 /* To maintain wire speed transmits, the Tx FIFO should be 610 * large enough to accommodate two full transmit packets, 611 * rounded up to the next 1KB and expressed in KB. Likewise, 612 * the Rx FIFO should be large enough to accommodate at least 613 * one full receive packet and is similarly rounded up and 614 * expressed in KB. 615 */ 616 pba = er32(PBA); 617 /* upper 16 bits has Tx packet buffer allocation size in KB */ 618 tx_space = pba >> 16; 619 /* lower 16 bits has Rx packet buffer allocation size in KB */ 620 pba &= 0xffff; 621 /* the Tx fifo also stores 16 bytes of information about the Tx 622 * but don't include ethernet FCS because hardware appends it 623 */ 624 min_tx_space = (hw->max_frame_size + 625 sizeof(struct e1000_tx_desc) - 626 ETH_FCS_LEN) * 2; 627 min_tx_space = ALIGN(min_tx_space, 1024); 628 min_tx_space >>= 10; 629 /* software strips receive CRC, so leave room for it */ 630 min_rx_space = hw->max_frame_size; 631 min_rx_space = ALIGN(min_rx_space, 1024); 632 min_rx_space >>= 10; 633 634 /* If current Tx allocation is less than the min Tx FIFO size, 635 * and the min Tx FIFO size is less than the current Rx FIFO 636 * allocation, take space away from current Rx allocation 637 */ 638 if (tx_space < min_tx_space && 639 ((min_tx_space - tx_space) < pba)) { 640 pba = pba - (min_tx_space - tx_space); 641 642 /* PCI/PCIx hardware has PBA alignment constraints */ 643 switch (hw->mac_type) { 644 case e1000_82545 ... e1000_82546_rev_3: 645 pba &= ~(E1000_PBA_8K - 1); 646 break; 647 default: 648 break; 649 } 650 651 /* if short on Rx space, Rx wins and must trump Tx 652 * adjustment or use Early Receive if available 653 */ 654 if (pba < min_rx_space) 655 pba = min_rx_space; 656 } 657 } 658 659 ew32(PBA, pba); 660 661 /* flow control settings: 662 * The high water mark must be low enough to fit one full frame 663 * (or the size used for early receive) above it in the Rx FIFO. 664 * Set it to the lower of: 665 * - 90% of the Rx FIFO size, and 666 * - the full Rx FIFO size minus the early receive size (for parts 667 * with ERT support assuming ERT set to E1000_ERT_2048), or 668 * - the full Rx FIFO size minus one full frame 669 */ 670 hwm = min(((pba << 10) * 9 / 10), 671 ((pba << 10) - hw->max_frame_size)); 672 673 hw->fc_high_water = hwm & 0xFFF8; /* 8-byte granularity */ 674 hw->fc_low_water = hw->fc_high_water - 8; 675 hw->fc_pause_time = E1000_FC_PAUSE_TIME; 676 hw->fc_send_xon = 1; 677 hw->fc = hw->original_fc; 678 679 /* Allow time for pending master requests to run */ 680 e1000_reset_hw(hw); 681 if (hw->mac_type >= e1000_82544) 682 ew32(WUC, 0); 683 684 if (e1000_init_hw(hw)) 685 e_dev_err("Hardware Error\n"); 686 e1000_update_mng_vlan(adapter); 687 688 /* if (adapter->hwflags & HWFLAGS_PHY_PWR_BIT) { */ 689 if (hw->mac_type >= e1000_82544 && 690 hw->autoneg == 1 && 691 hw->autoneg_advertised == ADVERTISE_1000_FULL) { 692 u32 ctrl = er32(CTRL); 693 /* clear phy power management bit if we are in gig only mode, 694 * which if enabled will attempt negotiation to 100Mb, which 695 * can cause a loss of link at power off or driver unload 696 */ 697 ctrl &= ~E1000_CTRL_SWDPIN3; 698 ew32(CTRL, ctrl); 699 } 700 701 /* Enable h/w to recognize an 802.1Q VLAN Ethernet packet */ 702 ew32(VET, ETHERNET_IEEE_VLAN_TYPE); 703 704 e1000_reset_adaptive(hw); 705 e1000_phy_get_info(hw, &adapter->phy_info); 706 707 e1000_release_manageability(adapter); 708 } 709 710 /* Dump the eeprom for users having checksum issues */ 711 static void e1000_dump_eeprom(struct e1000_adapter *adapter) 712 { 713 struct net_device *netdev = adapter->netdev; 714 struct ethtool_eeprom eeprom; 715 const struct ethtool_ops *ops = netdev->ethtool_ops; 716 u8 *data; 717 int i; 718 u16 csum_old, csum_new = 0; 719 720 eeprom.len = ops->get_eeprom_len(netdev); 721 eeprom.offset = 0; 722 723 data = kmalloc(eeprom.len, GFP_KERNEL); 724 if (!data) 725 return; 726 727 ops->get_eeprom(netdev, &eeprom, data); 728 729 csum_old = (data[EEPROM_CHECKSUM_REG * 2]) + 730 (data[EEPROM_CHECKSUM_REG * 2 + 1] << 8); 731 for (i = 0; i < EEPROM_CHECKSUM_REG * 2; i += 2) 732 csum_new += data[i] + (data[i + 1] << 8); 733 csum_new = EEPROM_SUM - csum_new; 734 735 pr_err("/*********************/\n"); 736 pr_err("Current EEPROM Checksum : 0x%04x\n", csum_old); 737 pr_err("Calculated : 0x%04x\n", csum_new); 738 739 pr_err("Offset Values\n"); 740 pr_err("======== ======\n"); 741 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 16, 1, data, 128, 0); 742 743 pr_err("Include this output when contacting your support provider.\n"); 744 pr_err("This is not a software error! Something bad happened to\n"); 745 pr_err("your hardware or EEPROM image. Ignoring this problem could\n"); 746 pr_err("result in further problems, possibly loss of data,\n"); 747 pr_err("corruption or system hangs!\n"); 748 pr_err("The MAC Address will be reset to 00:00:00:00:00:00,\n"); 749 pr_err("which is invalid and requires you to set the proper MAC\n"); 750 pr_err("address manually before continuing to enable this network\n"); 751 pr_err("device. Please inspect the EEPROM dump and report the\n"); 752 pr_err("issue to your hardware vendor or Intel Customer Support.\n"); 753 pr_err("/*********************/\n"); 754 755 kfree(data); 756 } 757 758 /** 759 * e1000_is_need_ioport - determine if an adapter needs ioport resources or not 760 * @pdev: PCI device information struct 761 * 762 * Return true if an adapter needs ioport resources 763 **/ 764 static int e1000_is_need_ioport(struct pci_dev *pdev) 765 { 766 switch (pdev->device) { 767 case E1000_DEV_ID_82540EM: 768 case E1000_DEV_ID_82540EM_LOM: 769 case E1000_DEV_ID_82540EP: 770 case E1000_DEV_ID_82540EP_LOM: 771 case E1000_DEV_ID_82540EP_LP: 772 case E1000_DEV_ID_82541EI: 773 case E1000_DEV_ID_82541EI_MOBILE: 774 case E1000_DEV_ID_82541ER: 775 case E1000_DEV_ID_82541ER_LOM: 776 case E1000_DEV_ID_82541GI: 777 case E1000_DEV_ID_82541GI_LF: 778 case E1000_DEV_ID_82541GI_MOBILE: 779 case E1000_DEV_ID_82544EI_COPPER: 780 case E1000_DEV_ID_82544EI_FIBER: 781 case E1000_DEV_ID_82544GC_COPPER: 782 case E1000_DEV_ID_82544GC_LOM: 783 case E1000_DEV_ID_82545EM_COPPER: 784 case E1000_DEV_ID_82545EM_FIBER: 785 case E1000_DEV_ID_82546EB_COPPER: 786 case E1000_DEV_ID_82546EB_FIBER: 787 case E1000_DEV_ID_82546EB_QUAD_COPPER: 788 return true; 789 default: 790 return false; 791 } 792 } 793 794 static netdev_features_t e1000_fix_features(struct net_device *netdev, 795 netdev_features_t features) 796 { 797 /* Since there is no support for separate Rx/Tx vlan accel 798 * enable/disable make sure Tx flag is always in same state as Rx. 799 */ 800 if (features & NETIF_F_HW_VLAN_CTAG_RX) 801 features |= NETIF_F_HW_VLAN_CTAG_TX; 802 else 803 features &= ~NETIF_F_HW_VLAN_CTAG_TX; 804 805 return features; 806 } 807 808 static int e1000_set_features(struct net_device *netdev, 809 netdev_features_t features) 810 { 811 struct e1000_adapter *adapter = netdev_priv(netdev); 812 netdev_features_t changed = features ^ netdev->features; 813 814 if (changed & NETIF_F_HW_VLAN_CTAG_RX) 815 e1000_vlan_mode(netdev, features); 816 817 if (!(changed & (NETIF_F_RXCSUM | NETIF_F_RXALL))) 818 return 0; 819 820 netdev->features = features; 821 adapter->rx_csum = !!(features & NETIF_F_RXCSUM); 822 823 if (netif_running(netdev)) 824 e1000_reinit_locked(adapter); 825 else 826 e1000_reset(adapter); 827 828 return 1; 829 } 830 831 static const struct net_device_ops e1000_netdev_ops = { 832 .ndo_open = e1000_open, 833 .ndo_stop = e1000_close, 834 .ndo_start_xmit = e1000_xmit_frame, 835 .ndo_set_rx_mode = e1000_set_rx_mode, 836 .ndo_set_mac_address = e1000_set_mac, 837 .ndo_tx_timeout = e1000_tx_timeout, 838 .ndo_change_mtu = e1000_change_mtu, 839 .ndo_do_ioctl = e1000_ioctl, 840 .ndo_validate_addr = eth_validate_addr, 841 .ndo_vlan_rx_add_vid = e1000_vlan_rx_add_vid, 842 .ndo_vlan_rx_kill_vid = e1000_vlan_rx_kill_vid, 843 #ifdef CONFIG_NET_POLL_CONTROLLER 844 .ndo_poll_controller = e1000_netpoll, 845 #endif 846 .ndo_fix_features = e1000_fix_features, 847 .ndo_set_features = e1000_set_features, 848 }; 849 850 /** 851 * e1000_init_hw_struct - initialize members of hw struct 852 * @adapter: board private struct 853 * @hw: structure used by e1000_hw.c 854 * 855 * Factors out initialization of the e1000_hw struct to its own function 856 * that can be called very early at init (just after struct allocation). 857 * Fields are initialized based on PCI device information and 858 * OS network device settings (MTU size). 859 * Returns negative error codes if MAC type setup fails. 860 */ 861 static int e1000_init_hw_struct(struct e1000_adapter *adapter, 862 struct e1000_hw *hw) 863 { 864 struct pci_dev *pdev = adapter->pdev; 865 866 /* PCI config space info */ 867 hw->vendor_id = pdev->vendor; 868 hw->device_id = pdev->device; 869 hw->subsystem_vendor_id = pdev->subsystem_vendor; 870 hw->subsystem_id = pdev->subsystem_device; 871 hw->revision_id = pdev->revision; 872 873 pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word); 874 875 hw->max_frame_size = adapter->netdev->mtu + 876 ENET_HEADER_SIZE + ETHERNET_FCS_SIZE; 877 hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE; 878 879 /* identify the MAC */ 880 if (e1000_set_mac_type(hw)) { 881 e_err(probe, "Unknown MAC Type\n"); 882 return -EIO; 883 } 884 885 switch (hw->mac_type) { 886 default: 887 break; 888 case e1000_82541: 889 case e1000_82547: 890 case e1000_82541_rev_2: 891 case e1000_82547_rev_2: 892 hw->phy_init_script = 1; 893 break; 894 } 895 896 e1000_set_media_type(hw); 897 e1000_get_bus_info(hw); 898 899 hw->wait_autoneg_complete = false; 900 hw->tbi_compatibility_en = true; 901 hw->adaptive_ifs = true; 902 903 /* Copper options */ 904 905 if (hw->media_type == e1000_media_type_copper) { 906 hw->mdix = AUTO_ALL_MODES; 907 hw->disable_polarity_correction = false; 908 hw->master_slave = E1000_MASTER_SLAVE; 909 } 910 911 return 0; 912 } 913 914 /** 915 * e1000_probe - Device Initialization Routine 916 * @pdev: PCI device information struct 917 * @ent: entry in e1000_pci_tbl 918 * 919 * Returns 0 on success, negative on failure 920 * 921 * e1000_probe initializes an adapter identified by a pci_dev structure. 922 * The OS initialization, configuring of the adapter private structure, 923 * and a hardware reset occur. 924 **/ 925 static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 926 { 927 struct net_device *netdev; 928 struct e1000_adapter *adapter = NULL; 929 struct e1000_hw *hw; 930 931 static int cards_found; 932 static int global_quad_port_a; /* global ksp3 port a indication */ 933 int i, err, pci_using_dac; 934 u16 eeprom_data = 0; 935 u16 tmp = 0; 936 u16 eeprom_apme_mask = E1000_EEPROM_APME; 937 int bars, need_ioport; 938 bool disable_dev = false; 939 940 /* do not allocate ioport bars when not needed */ 941 need_ioport = e1000_is_need_ioport(pdev); 942 if (need_ioport) { 943 bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO); 944 err = pci_enable_device(pdev); 945 } else { 946 bars = pci_select_bars(pdev, IORESOURCE_MEM); 947 err = pci_enable_device_mem(pdev); 948 } 949 if (err) 950 return err; 951 952 err = pci_request_selected_regions(pdev, bars, e1000_driver_name); 953 if (err) 954 goto err_pci_reg; 955 956 pci_set_master(pdev); 957 err = pci_save_state(pdev); 958 if (err) 959 goto err_alloc_etherdev; 960 961 err = -ENOMEM; 962 netdev = alloc_etherdev(sizeof(struct e1000_adapter)); 963 if (!netdev) 964 goto err_alloc_etherdev; 965 966 SET_NETDEV_DEV(netdev, &pdev->dev); 967 968 pci_set_drvdata(pdev, netdev); 969 adapter = netdev_priv(netdev); 970 adapter->netdev = netdev; 971 adapter->pdev = pdev; 972 adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE); 973 adapter->bars = bars; 974 adapter->need_ioport = need_ioport; 975 976 hw = &adapter->hw; 977 hw->back = adapter; 978 979 err = -EIO; 980 hw->hw_addr = pci_ioremap_bar(pdev, BAR_0); 981 if (!hw->hw_addr) 982 goto err_ioremap; 983 984 if (adapter->need_ioport) { 985 for (i = BAR_1; i < PCI_STD_NUM_BARS; i++) { 986 if (pci_resource_len(pdev, i) == 0) 987 continue; 988 if (pci_resource_flags(pdev, i) & IORESOURCE_IO) { 989 hw->io_base = pci_resource_start(pdev, i); 990 break; 991 } 992 } 993 } 994 995 /* make ready for any if (hw->...) below */ 996 err = e1000_init_hw_struct(adapter, hw); 997 if (err) 998 goto err_sw_init; 999 1000 /* there is a workaround being applied below that limits 1001 * 64-bit DMA addresses to 64-bit hardware. There are some 1002 * 32-bit adapters that Tx hang when given 64-bit DMA addresses 1003 */ 1004 pci_using_dac = 0; 1005 if ((hw->bus_type == e1000_bus_type_pcix) && 1006 !dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64))) { 1007 pci_using_dac = 1; 1008 } else { 1009 err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); 1010 if (err) { 1011 pr_err("No usable DMA config, aborting\n"); 1012 goto err_dma; 1013 } 1014 } 1015 1016 netdev->netdev_ops = &e1000_netdev_ops; 1017 e1000_set_ethtool_ops(netdev); 1018 netdev->watchdog_timeo = 5 * HZ; 1019 netif_napi_add(netdev, &adapter->napi, e1000_clean, 64); 1020 1021 strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1); 1022 1023 adapter->bd_number = cards_found; 1024 1025 /* setup the private structure */ 1026 1027 err = e1000_sw_init(adapter); 1028 if (err) 1029 goto err_sw_init; 1030 1031 err = -EIO; 1032 if (hw->mac_type == e1000_ce4100) { 1033 hw->ce4100_gbe_mdio_base_virt = 1034 ioremap(pci_resource_start(pdev, BAR_1), 1035 pci_resource_len(pdev, BAR_1)); 1036 1037 if (!hw->ce4100_gbe_mdio_base_virt) 1038 goto err_mdio_ioremap; 1039 } 1040 1041 if (hw->mac_type >= e1000_82543) { 1042 netdev->hw_features = NETIF_F_SG | 1043 NETIF_F_HW_CSUM | 1044 NETIF_F_HW_VLAN_CTAG_RX; 1045 netdev->features = NETIF_F_HW_VLAN_CTAG_TX | 1046 NETIF_F_HW_VLAN_CTAG_FILTER; 1047 } 1048 1049 if ((hw->mac_type >= e1000_82544) && 1050 (hw->mac_type != e1000_82547)) 1051 netdev->hw_features |= NETIF_F_TSO; 1052 1053 netdev->priv_flags |= IFF_SUPP_NOFCS; 1054 1055 netdev->features |= netdev->hw_features; 1056 netdev->hw_features |= (NETIF_F_RXCSUM | 1057 NETIF_F_RXALL | 1058 NETIF_F_RXFCS); 1059 1060 if (pci_using_dac) { 1061 netdev->features |= NETIF_F_HIGHDMA; 1062 netdev->vlan_features |= NETIF_F_HIGHDMA; 1063 } 1064 1065 netdev->vlan_features |= (NETIF_F_TSO | 1066 NETIF_F_HW_CSUM | 1067 NETIF_F_SG); 1068 1069 /* Do not set IFF_UNICAST_FLT for VMWare's 82545EM */ 1070 if (hw->device_id != E1000_DEV_ID_82545EM_COPPER || 1071 hw->subsystem_vendor_id != PCI_VENDOR_ID_VMWARE) 1072 netdev->priv_flags |= IFF_UNICAST_FLT; 1073 1074 /* MTU range: 46 - 16110 */ 1075 netdev->min_mtu = ETH_ZLEN - ETH_HLEN; 1076 netdev->max_mtu = MAX_JUMBO_FRAME_SIZE - (ETH_HLEN + ETH_FCS_LEN); 1077 1078 adapter->en_mng_pt = e1000_enable_mng_pass_thru(hw); 1079 1080 /* initialize eeprom parameters */ 1081 if (e1000_init_eeprom_params(hw)) { 1082 e_err(probe, "EEPROM initialization failed\n"); 1083 goto err_eeprom; 1084 } 1085 1086 /* before reading the EEPROM, reset the controller to 1087 * put the device in a known good starting state 1088 */ 1089 1090 e1000_reset_hw(hw); 1091 1092 /* make sure the EEPROM is good */ 1093 if (e1000_validate_eeprom_checksum(hw) < 0) { 1094 e_err(probe, "The EEPROM Checksum Is Not Valid\n"); 1095 e1000_dump_eeprom(adapter); 1096 /* set MAC address to all zeroes to invalidate and temporary 1097 * disable this device for the user. This blocks regular 1098 * traffic while still permitting ethtool ioctls from reaching 1099 * the hardware as well as allowing the user to run the 1100 * interface after manually setting a hw addr using 1101 * `ip set address` 1102 */ 1103 memset(hw->mac_addr, 0, netdev->addr_len); 1104 } else { 1105 /* copy the MAC address out of the EEPROM */ 1106 if (e1000_read_mac_addr(hw)) 1107 e_err(probe, "EEPROM Read Error\n"); 1108 } 1109 /* don't block initialization here due to bad MAC address */ 1110 memcpy(netdev->dev_addr, hw->mac_addr, netdev->addr_len); 1111 1112 if (!is_valid_ether_addr(netdev->dev_addr)) 1113 e_err(probe, "Invalid MAC Address\n"); 1114 1115 1116 INIT_DELAYED_WORK(&adapter->watchdog_task, e1000_watchdog); 1117 INIT_DELAYED_WORK(&adapter->fifo_stall_task, 1118 e1000_82547_tx_fifo_stall_task); 1119 INIT_DELAYED_WORK(&adapter->phy_info_task, e1000_update_phy_info_task); 1120 INIT_WORK(&adapter->reset_task, e1000_reset_task); 1121 1122 e1000_check_options(adapter); 1123 1124 /* Initial Wake on LAN setting 1125 * If APM wake is enabled in the EEPROM, 1126 * enable the ACPI Magic Packet filter 1127 */ 1128 1129 switch (hw->mac_type) { 1130 case e1000_82542_rev2_0: 1131 case e1000_82542_rev2_1: 1132 case e1000_82543: 1133 break; 1134 case e1000_82544: 1135 e1000_read_eeprom(hw, 1136 EEPROM_INIT_CONTROL2_REG, 1, &eeprom_data); 1137 eeprom_apme_mask = E1000_EEPROM_82544_APM; 1138 break; 1139 case e1000_82546: 1140 case e1000_82546_rev_3: 1141 if (er32(STATUS) & E1000_STATUS_FUNC_1) { 1142 e1000_read_eeprom(hw, 1143 EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data); 1144 break; 1145 } 1146 /* Fall Through */ 1147 default: 1148 e1000_read_eeprom(hw, 1149 EEPROM_INIT_CONTROL3_PORT_A, 1, &eeprom_data); 1150 break; 1151 } 1152 if (eeprom_data & eeprom_apme_mask) 1153 adapter->eeprom_wol |= E1000_WUFC_MAG; 1154 1155 /* now that we have the eeprom settings, apply the special cases 1156 * where the eeprom may be wrong or the board simply won't support 1157 * wake on lan on a particular port 1158 */ 1159 switch (pdev->device) { 1160 case E1000_DEV_ID_82546GB_PCIE: 1161 adapter->eeprom_wol = 0; 1162 break; 1163 case E1000_DEV_ID_82546EB_FIBER: 1164 case E1000_DEV_ID_82546GB_FIBER: 1165 /* Wake events only supported on port A for dual fiber 1166 * regardless of eeprom setting 1167 */ 1168 if (er32(STATUS) & E1000_STATUS_FUNC_1) 1169 adapter->eeprom_wol = 0; 1170 break; 1171 case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3: 1172 /* if quad port adapter, disable WoL on all but port A */ 1173 if (global_quad_port_a != 0) 1174 adapter->eeprom_wol = 0; 1175 else 1176 adapter->quad_port_a = true; 1177 /* Reset for multiple quad port adapters */ 1178 if (++global_quad_port_a == 4) 1179 global_quad_port_a = 0; 1180 break; 1181 } 1182 1183 /* initialize the wol settings based on the eeprom settings */ 1184 adapter->wol = adapter->eeprom_wol; 1185 device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol); 1186 1187 /* Auto detect PHY address */ 1188 if (hw->mac_type == e1000_ce4100) { 1189 for (i = 0; i < 32; i++) { 1190 hw->phy_addr = i; 1191 e1000_read_phy_reg(hw, PHY_ID2, &tmp); 1192 1193 if (tmp != 0 && tmp != 0xFF) 1194 break; 1195 } 1196 1197 if (i >= 32) 1198 goto err_eeprom; 1199 } 1200 1201 /* reset the hardware with the new settings */ 1202 e1000_reset(adapter); 1203 1204 strcpy(netdev->name, "eth%d"); 1205 err = register_netdev(netdev); 1206 if (err) 1207 goto err_register; 1208 1209 e1000_vlan_filter_on_off(adapter, false); 1210 1211 /* print bus type/speed/width info */ 1212 e_info(probe, "(PCI%s:%dMHz:%d-bit) %pM\n", 1213 ((hw->bus_type == e1000_bus_type_pcix) ? "-X" : ""), 1214 ((hw->bus_speed == e1000_bus_speed_133) ? 133 : 1215 (hw->bus_speed == e1000_bus_speed_120) ? 120 : 1216 (hw->bus_speed == e1000_bus_speed_100) ? 100 : 1217 (hw->bus_speed == e1000_bus_speed_66) ? 66 : 33), 1218 ((hw->bus_width == e1000_bus_width_64) ? 64 : 32), 1219 netdev->dev_addr); 1220 1221 /* carrier off reporting is important to ethtool even BEFORE open */ 1222 netif_carrier_off(netdev); 1223 1224 e_info(probe, "Intel(R) PRO/1000 Network Connection\n"); 1225 1226 cards_found++; 1227 return 0; 1228 1229 err_register: 1230 err_eeprom: 1231 e1000_phy_hw_reset(hw); 1232 1233 if (hw->flash_address) 1234 iounmap(hw->flash_address); 1235 kfree(adapter->tx_ring); 1236 kfree(adapter->rx_ring); 1237 err_dma: 1238 err_sw_init: 1239 err_mdio_ioremap: 1240 iounmap(hw->ce4100_gbe_mdio_base_virt); 1241 iounmap(hw->hw_addr); 1242 err_ioremap: 1243 disable_dev = !test_and_set_bit(__E1000_DISABLED, &adapter->flags); 1244 free_netdev(netdev); 1245 err_alloc_etherdev: 1246 pci_release_selected_regions(pdev, bars); 1247 err_pci_reg: 1248 if (!adapter || disable_dev) 1249 pci_disable_device(pdev); 1250 return err; 1251 } 1252 1253 /** 1254 * e1000_remove - Device Removal Routine 1255 * @pdev: PCI device information struct 1256 * 1257 * e1000_remove is called by the PCI subsystem to alert the driver 1258 * that it should release a PCI device. That could be caused by a 1259 * Hot-Plug event, or because the driver is going to be removed from 1260 * memory. 1261 **/ 1262 static void e1000_remove(struct pci_dev *pdev) 1263 { 1264 struct net_device *netdev = pci_get_drvdata(pdev); 1265 struct e1000_adapter *adapter = netdev_priv(netdev); 1266 struct e1000_hw *hw = &adapter->hw; 1267 bool disable_dev; 1268 1269 e1000_down_and_stop(adapter); 1270 e1000_release_manageability(adapter); 1271 1272 unregister_netdev(netdev); 1273 1274 e1000_phy_hw_reset(hw); 1275 1276 kfree(adapter->tx_ring); 1277 kfree(adapter->rx_ring); 1278 1279 if (hw->mac_type == e1000_ce4100) 1280 iounmap(hw->ce4100_gbe_mdio_base_virt); 1281 iounmap(hw->hw_addr); 1282 if (hw->flash_address) 1283 iounmap(hw->flash_address); 1284 pci_release_selected_regions(pdev, adapter->bars); 1285 1286 disable_dev = !test_and_set_bit(__E1000_DISABLED, &adapter->flags); 1287 free_netdev(netdev); 1288 1289 if (disable_dev) 1290 pci_disable_device(pdev); 1291 } 1292 1293 /** 1294 * e1000_sw_init - Initialize general software structures (struct e1000_adapter) 1295 * @adapter: board private structure to initialize 1296 * 1297 * e1000_sw_init initializes the Adapter private data structure. 1298 * e1000_init_hw_struct MUST be called before this function 1299 **/ 1300 static int e1000_sw_init(struct e1000_adapter *adapter) 1301 { 1302 adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE; 1303 1304 adapter->num_tx_queues = 1; 1305 adapter->num_rx_queues = 1; 1306 1307 if (e1000_alloc_queues(adapter)) { 1308 e_err(probe, "Unable to allocate memory for queues\n"); 1309 return -ENOMEM; 1310 } 1311 1312 /* Explicitly disable IRQ since the NIC can be in any state. */ 1313 e1000_irq_disable(adapter); 1314 1315 spin_lock_init(&adapter->stats_lock); 1316 1317 set_bit(__E1000_DOWN, &adapter->flags); 1318 1319 return 0; 1320 } 1321 1322 /** 1323 * e1000_alloc_queues - Allocate memory for all rings 1324 * @adapter: board private structure to initialize 1325 * 1326 * We allocate one ring per queue at run-time since we don't know the 1327 * number of queues at compile-time. 1328 **/ 1329 static int e1000_alloc_queues(struct e1000_adapter *adapter) 1330 { 1331 adapter->tx_ring = kcalloc(adapter->num_tx_queues, 1332 sizeof(struct e1000_tx_ring), GFP_KERNEL); 1333 if (!adapter->tx_ring) 1334 return -ENOMEM; 1335 1336 adapter->rx_ring = kcalloc(adapter->num_rx_queues, 1337 sizeof(struct e1000_rx_ring), GFP_KERNEL); 1338 if (!adapter->rx_ring) { 1339 kfree(adapter->tx_ring); 1340 return -ENOMEM; 1341 } 1342 1343 return E1000_SUCCESS; 1344 } 1345 1346 /** 1347 * e1000_open - Called when a network interface is made active 1348 * @netdev: network interface device structure 1349 * 1350 * Returns 0 on success, negative value on failure 1351 * 1352 * The open entry point is called when a network interface is made 1353 * active by the system (IFF_UP). At this point all resources needed 1354 * for transmit and receive operations are allocated, the interrupt 1355 * handler is registered with the OS, the watchdog task is started, 1356 * and the stack is notified that the interface is ready. 1357 **/ 1358 int e1000_open(struct net_device *netdev) 1359 { 1360 struct e1000_adapter *adapter = netdev_priv(netdev); 1361 struct e1000_hw *hw = &adapter->hw; 1362 int err; 1363 1364 /* disallow open during test */ 1365 if (test_bit(__E1000_TESTING, &adapter->flags)) 1366 return -EBUSY; 1367 1368 netif_carrier_off(netdev); 1369 1370 /* allocate transmit descriptors */ 1371 err = e1000_setup_all_tx_resources(adapter); 1372 if (err) 1373 goto err_setup_tx; 1374 1375 /* allocate receive descriptors */ 1376 err = e1000_setup_all_rx_resources(adapter); 1377 if (err) 1378 goto err_setup_rx; 1379 1380 e1000_power_up_phy(adapter); 1381 1382 adapter->mng_vlan_id = E1000_MNG_VLAN_NONE; 1383 if ((hw->mng_cookie.status & 1384 E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) { 1385 e1000_update_mng_vlan(adapter); 1386 } 1387 1388 /* before we allocate an interrupt, we must be ready to handle it. 1389 * Setting DEBUG_SHIRQ in the kernel makes it fire an interrupt 1390 * as soon as we call pci_request_irq, so we have to setup our 1391 * clean_rx handler before we do so. 1392 */ 1393 e1000_configure(adapter); 1394 1395 err = e1000_request_irq(adapter); 1396 if (err) 1397 goto err_req_irq; 1398 1399 /* From here on the code is the same as e1000_up() */ 1400 clear_bit(__E1000_DOWN, &adapter->flags); 1401 1402 napi_enable(&adapter->napi); 1403 1404 e1000_irq_enable(adapter); 1405 1406 netif_start_queue(netdev); 1407 1408 /* fire a link status change interrupt to start the watchdog */ 1409 ew32(ICS, E1000_ICS_LSC); 1410 1411 return E1000_SUCCESS; 1412 1413 err_req_irq: 1414 e1000_power_down_phy(adapter); 1415 e1000_free_all_rx_resources(adapter); 1416 err_setup_rx: 1417 e1000_free_all_tx_resources(adapter); 1418 err_setup_tx: 1419 e1000_reset(adapter); 1420 1421 return err; 1422 } 1423 1424 /** 1425 * e1000_close - Disables a network interface 1426 * @netdev: network interface device structure 1427 * 1428 * Returns 0, this is not allowed to fail 1429 * 1430 * The close entry point is called when an interface is de-activated 1431 * by the OS. The hardware is still under the drivers control, but 1432 * needs to be disabled. A global MAC reset is issued to stop the 1433 * hardware, and all transmit and receive resources are freed. 1434 **/ 1435 int e1000_close(struct net_device *netdev) 1436 { 1437 struct e1000_adapter *adapter = netdev_priv(netdev); 1438 struct e1000_hw *hw = &adapter->hw; 1439 int count = E1000_CHECK_RESET_COUNT; 1440 1441 while (test_and_set_bit(__E1000_RESETTING, &adapter->flags) && count--) 1442 usleep_range(10000, 20000); 1443 1444 WARN_ON(count < 0); 1445 1446 /* signal that we're down so that the reset task will no longer run */ 1447 set_bit(__E1000_DOWN, &adapter->flags); 1448 clear_bit(__E1000_RESETTING, &adapter->flags); 1449 1450 e1000_down(adapter); 1451 e1000_power_down_phy(adapter); 1452 e1000_free_irq(adapter); 1453 1454 e1000_free_all_tx_resources(adapter); 1455 e1000_free_all_rx_resources(adapter); 1456 1457 /* kill manageability vlan ID if supported, but not if a vlan with 1458 * the same ID is registered on the host OS (let 8021q kill it) 1459 */ 1460 if ((hw->mng_cookie.status & 1461 E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) && 1462 !test_bit(adapter->mng_vlan_id, adapter->active_vlans)) { 1463 e1000_vlan_rx_kill_vid(netdev, htons(ETH_P_8021Q), 1464 adapter->mng_vlan_id); 1465 } 1466 1467 return 0; 1468 } 1469 1470 /** 1471 * e1000_check_64k_bound - check that memory doesn't cross 64kB boundary 1472 * @adapter: address of board private structure 1473 * @start: address of beginning of memory 1474 * @len: length of memory 1475 **/ 1476 static bool e1000_check_64k_bound(struct e1000_adapter *adapter, void *start, 1477 unsigned long len) 1478 { 1479 struct e1000_hw *hw = &adapter->hw; 1480 unsigned long begin = (unsigned long)start; 1481 unsigned long end = begin + len; 1482 1483 /* First rev 82545 and 82546 need to not allow any memory 1484 * write location to cross 64k boundary due to errata 23 1485 */ 1486 if (hw->mac_type == e1000_82545 || 1487 hw->mac_type == e1000_ce4100 || 1488 hw->mac_type == e1000_82546) { 1489 return ((begin ^ (end - 1)) >> 16) == 0; 1490 } 1491 1492 return true; 1493 } 1494 1495 /** 1496 * e1000_setup_tx_resources - allocate Tx resources (Descriptors) 1497 * @adapter: board private structure 1498 * @txdr: tx descriptor ring (for a specific queue) to setup 1499 * 1500 * Return 0 on success, negative on failure 1501 **/ 1502 static int e1000_setup_tx_resources(struct e1000_adapter *adapter, 1503 struct e1000_tx_ring *txdr) 1504 { 1505 struct pci_dev *pdev = adapter->pdev; 1506 int size; 1507 1508 size = sizeof(struct e1000_tx_buffer) * txdr->count; 1509 txdr->buffer_info = vzalloc(size); 1510 if (!txdr->buffer_info) 1511 return -ENOMEM; 1512 1513 /* round up to nearest 4K */ 1514 1515 txdr->size = txdr->count * sizeof(struct e1000_tx_desc); 1516 txdr->size = ALIGN(txdr->size, 4096); 1517 1518 txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma, 1519 GFP_KERNEL); 1520 if (!txdr->desc) { 1521 setup_tx_desc_die: 1522 vfree(txdr->buffer_info); 1523 return -ENOMEM; 1524 } 1525 1526 /* Fix for errata 23, can't cross 64kB boundary */ 1527 if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) { 1528 void *olddesc = txdr->desc; 1529 dma_addr_t olddma = txdr->dma; 1530 e_err(tx_err, "txdr align check failed: %u bytes at %p\n", 1531 txdr->size, txdr->desc); 1532 /* Try again, without freeing the previous */ 1533 txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, 1534 &txdr->dma, GFP_KERNEL); 1535 /* Failed allocation, critical failure */ 1536 if (!txdr->desc) { 1537 dma_free_coherent(&pdev->dev, txdr->size, olddesc, 1538 olddma); 1539 goto setup_tx_desc_die; 1540 } 1541 1542 if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) { 1543 /* give up */ 1544 dma_free_coherent(&pdev->dev, txdr->size, txdr->desc, 1545 txdr->dma); 1546 dma_free_coherent(&pdev->dev, txdr->size, olddesc, 1547 olddma); 1548 e_err(probe, "Unable to allocate aligned memory " 1549 "for the transmit descriptor ring\n"); 1550 vfree(txdr->buffer_info); 1551 return -ENOMEM; 1552 } else { 1553 /* Free old allocation, new allocation was successful */ 1554 dma_free_coherent(&pdev->dev, txdr->size, olddesc, 1555 olddma); 1556 } 1557 } 1558 memset(txdr->desc, 0, txdr->size); 1559 1560 txdr->next_to_use = 0; 1561 txdr->next_to_clean = 0; 1562 1563 return 0; 1564 } 1565 1566 /** 1567 * e1000_setup_all_tx_resources - wrapper to allocate Tx resources 1568 * (Descriptors) for all queues 1569 * @adapter: board private structure 1570 * 1571 * Return 0 on success, negative on failure 1572 **/ 1573 int e1000_setup_all_tx_resources(struct e1000_adapter *adapter) 1574 { 1575 int i, err = 0; 1576 1577 for (i = 0; i < adapter->num_tx_queues; i++) { 1578 err = e1000_setup_tx_resources(adapter, &adapter->tx_ring[i]); 1579 if (err) { 1580 e_err(probe, "Allocation for Tx Queue %u failed\n", i); 1581 for (i-- ; i >= 0; i--) 1582 e1000_free_tx_resources(adapter, 1583 &adapter->tx_ring[i]); 1584 break; 1585 } 1586 } 1587 1588 return err; 1589 } 1590 1591 /** 1592 * e1000_configure_tx - Configure 8254x Transmit Unit after Reset 1593 * @adapter: board private structure 1594 * 1595 * Configure the Tx unit of the MAC after a reset. 1596 **/ 1597 static void e1000_configure_tx(struct e1000_adapter *adapter) 1598 { 1599 u64 tdba; 1600 struct e1000_hw *hw = &adapter->hw; 1601 u32 tdlen, tctl, tipg; 1602 u32 ipgr1, ipgr2; 1603 1604 /* Setup the HW Tx Head and Tail descriptor pointers */ 1605 1606 switch (adapter->num_tx_queues) { 1607 case 1: 1608 default: 1609 tdba = adapter->tx_ring[0].dma; 1610 tdlen = adapter->tx_ring[0].count * 1611 sizeof(struct e1000_tx_desc); 1612 ew32(TDLEN, tdlen); 1613 ew32(TDBAH, (tdba >> 32)); 1614 ew32(TDBAL, (tdba & 0x00000000ffffffffULL)); 1615 ew32(TDT, 0); 1616 ew32(TDH, 0); 1617 adapter->tx_ring[0].tdh = ((hw->mac_type >= e1000_82543) ? 1618 E1000_TDH : E1000_82542_TDH); 1619 adapter->tx_ring[0].tdt = ((hw->mac_type >= e1000_82543) ? 1620 E1000_TDT : E1000_82542_TDT); 1621 break; 1622 } 1623 1624 /* Set the default values for the Tx Inter Packet Gap timer */ 1625 if ((hw->media_type == e1000_media_type_fiber || 1626 hw->media_type == e1000_media_type_internal_serdes)) 1627 tipg = DEFAULT_82543_TIPG_IPGT_FIBER; 1628 else 1629 tipg = DEFAULT_82543_TIPG_IPGT_COPPER; 1630 1631 switch (hw->mac_type) { 1632 case e1000_82542_rev2_0: 1633 case e1000_82542_rev2_1: 1634 tipg = DEFAULT_82542_TIPG_IPGT; 1635 ipgr1 = DEFAULT_82542_TIPG_IPGR1; 1636 ipgr2 = DEFAULT_82542_TIPG_IPGR2; 1637 break; 1638 default: 1639 ipgr1 = DEFAULT_82543_TIPG_IPGR1; 1640 ipgr2 = DEFAULT_82543_TIPG_IPGR2; 1641 break; 1642 } 1643 tipg |= ipgr1 << E1000_TIPG_IPGR1_SHIFT; 1644 tipg |= ipgr2 << E1000_TIPG_IPGR2_SHIFT; 1645 ew32(TIPG, tipg); 1646 1647 /* Set the Tx Interrupt Delay register */ 1648 1649 ew32(TIDV, adapter->tx_int_delay); 1650 if (hw->mac_type >= e1000_82540) 1651 ew32(TADV, adapter->tx_abs_int_delay); 1652 1653 /* Program the Transmit Control Register */ 1654 1655 tctl = er32(TCTL); 1656 tctl &= ~E1000_TCTL_CT; 1657 tctl |= E1000_TCTL_PSP | E1000_TCTL_RTLC | 1658 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT); 1659 1660 e1000_config_collision_dist(hw); 1661 1662 /* Setup Transmit Descriptor Settings for eop descriptor */ 1663 adapter->txd_cmd = E1000_TXD_CMD_EOP | E1000_TXD_CMD_IFCS; 1664 1665 /* only set IDE if we are delaying interrupts using the timers */ 1666 if (adapter->tx_int_delay) 1667 adapter->txd_cmd |= E1000_TXD_CMD_IDE; 1668 1669 if (hw->mac_type < e1000_82543) 1670 adapter->txd_cmd |= E1000_TXD_CMD_RPS; 1671 else 1672 adapter->txd_cmd |= E1000_TXD_CMD_RS; 1673 1674 /* Cache if we're 82544 running in PCI-X because we'll 1675 * need this to apply a workaround later in the send path. 1676 */ 1677 if (hw->mac_type == e1000_82544 && 1678 hw->bus_type == e1000_bus_type_pcix) 1679 adapter->pcix_82544 = true; 1680 1681 ew32(TCTL, tctl); 1682 1683 } 1684 1685 /** 1686 * e1000_setup_rx_resources - allocate Rx resources (Descriptors) 1687 * @adapter: board private structure 1688 * @rxdr: rx descriptor ring (for a specific queue) to setup 1689 * 1690 * Returns 0 on success, negative on failure 1691 **/ 1692 static int e1000_setup_rx_resources(struct e1000_adapter *adapter, 1693 struct e1000_rx_ring *rxdr) 1694 { 1695 struct pci_dev *pdev = adapter->pdev; 1696 int size, desc_len; 1697 1698 size = sizeof(struct e1000_rx_buffer) * rxdr->count; 1699 rxdr->buffer_info = vzalloc(size); 1700 if (!rxdr->buffer_info) 1701 return -ENOMEM; 1702 1703 desc_len = sizeof(struct e1000_rx_desc); 1704 1705 /* Round up to nearest 4K */ 1706 1707 rxdr->size = rxdr->count * desc_len; 1708 rxdr->size = ALIGN(rxdr->size, 4096); 1709 1710 rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma, 1711 GFP_KERNEL); 1712 if (!rxdr->desc) { 1713 setup_rx_desc_die: 1714 vfree(rxdr->buffer_info); 1715 return -ENOMEM; 1716 } 1717 1718 /* Fix for errata 23, can't cross 64kB boundary */ 1719 if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) { 1720 void *olddesc = rxdr->desc; 1721 dma_addr_t olddma = rxdr->dma; 1722 e_err(rx_err, "rxdr align check failed: %u bytes at %p\n", 1723 rxdr->size, rxdr->desc); 1724 /* Try again, without freeing the previous */ 1725 rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, 1726 &rxdr->dma, GFP_KERNEL); 1727 /* Failed allocation, critical failure */ 1728 if (!rxdr->desc) { 1729 dma_free_coherent(&pdev->dev, rxdr->size, olddesc, 1730 olddma); 1731 goto setup_rx_desc_die; 1732 } 1733 1734 if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) { 1735 /* give up */ 1736 dma_free_coherent(&pdev->dev, rxdr->size, rxdr->desc, 1737 rxdr->dma); 1738 dma_free_coherent(&pdev->dev, rxdr->size, olddesc, 1739 olddma); 1740 e_err(probe, "Unable to allocate aligned memory for " 1741 "the Rx descriptor ring\n"); 1742 goto setup_rx_desc_die; 1743 } else { 1744 /* Free old allocation, new allocation was successful */ 1745 dma_free_coherent(&pdev->dev, rxdr->size, olddesc, 1746 olddma); 1747 } 1748 } 1749 memset(rxdr->desc, 0, rxdr->size); 1750 1751 rxdr->next_to_clean = 0; 1752 rxdr->next_to_use = 0; 1753 rxdr->rx_skb_top = NULL; 1754 1755 return 0; 1756 } 1757 1758 /** 1759 * e1000_setup_all_rx_resources - wrapper to allocate Rx resources 1760 * (Descriptors) for all queues 1761 * @adapter: board private structure 1762 * 1763 * Return 0 on success, negative on failure 1764 **/ 1765 int e1000_setup_all_rx_resources(struct e1000_adapter *adapter) 1766 { 1767 int i, err = 0; 1768 1769 for (i = 0; i < adapter->num_rx_queues; i++) { 1770 err = e1000_setup_rx_resources(adapter, &adapter->rx_ring[i]); 1771 if (err) { 1772 e_err(probe, "Allocation for Rx Queue %u failed\n", i); 1773 for (i-- ; i >= 0; i--) 1774 e1000_free_rx_resources(adapter, 1775 &adapter->rx_ring[i]); 1776 break; 1777 } 1778 } 1779 1780 return err; 1781 } 1782 1783 /** 1784 * e1000_setup_rctl - configure the receive control registers 1785 * @adapter: Board private structure 1786 **/ 1787 static void e1000_setup_rctl(struct e1000_adapter *adapter) 1788 { 1789 struct e1000_hw *hw = &adapter->hw; 1790 u32 rctl; 1791 1792 rctl = er32(RCTL); 1793 1794 rctl &= ~(3 << E1000_RCTL_MO_SHIFT); 1795 1796 rctl |= E1000_RCTL_BAM | E1000_RCTL_LBM_NO | 1797 E1000_RCTL_RDMTS_HALF | 1798 (hw->mc_filter_type << E1000_RCTL_MO_SHIFT); 1799 1800 if (hw->tbi_compatibility_on == 1) 1801 rctl |= E1000_RCTL_SBP; 1802 else 1803 rctl &= ~E1000_RCTL_SBP; 1804 1805 if (adapter->netdev->mtu <= ETH_DATA_LEN) 1806 rctl &= ~E1000_RCTL_LPE; 1807 else 1808 rctl |= E1000_RCTL_LPE; 1809 1810 /* Setup buffer sizes */ 1811 rctl &= ~E1000_RCTL_SZ_4096; 1812 rctl |= E1000_RCTL_BSEX; 1813 switch (adapter->rx_buffer_len) { 1814 case E1000_RXBUFFER_2048: 1815 default: 1816 rctl |= E1000_RCTL_SZ_2048; 1817 rctl &= ~E1000_RCTL_BSEX; 1818 break; 1819 case E1000_RXBUFFER_4096: 1820 rctl |= E1000_RCTL_SZ_4096; 1821 break; 1822 case E1000_RXBUFFER_8192: 1823 rctl |= E1000_RCTL_SZ_8192; 1824 break; 1825 case E1000_RXBUFFER_16384: 1826 rctl |= E1000_RCTL_SZ_16384; 1827 break; 1828 } 1829 1830 /* This is useful for sniffing bad packets. */ 1831 if (adapter->netdev->features & NETIF_F_RXALL) { 1832 /* UPE and MPE will be handled by normal PROMISC logic 1833 * in e1000e_set_rx_mode 1834 */ 1835 rctl |= (E1000_RCTL_SBP | /* Receive bad packets */ 1836 E1000_RCTL_BAM | /* RX All Bcast Pkts */ 1837 E1000_RCTL_PMCF); /* RX All MAC Ctrl Pkts */ 1838 1839 rctl &= ~(E1000_RCTL_VFE | /* Disable VLAN filter */ 1840 E1000_RCTL_DPF | /* Allow filtered pause */ 1841 E1000_RCTL_CFIEN); /* Dis VLAN CFIEN Filter */ 1842 /* Do not mess with E1000_CTRL_VME, it affects transmit as well, 1843 * and that breaks VLANs. 1844 */ 1845 } 1846 1847 ew32(RCTL, rctl); 1848 } 1849 1850 /** 1851 * e1000_configure_rx - Configure 8254x Receive Unit after Reset 1852 * @adapter: board private structure 1853 * 1854 * Configure the Rx unit of the MAC after a reset. 1855 **/ 1856 static void e1000_configure_rx(struct e1000_adapter *adapter) 1857 { 1858 u64 rdba; 1859 struct e1000_hw *hw = &adapter->hw; 1860 u32 rdlen, rctl, rxcsum; 1861 1862 if (adapter->netdev->mtu > ETH_DATA_LEN) { 1863 rdlen = adapter->rx_ring[0].count * 1864 sizeof(struct e1000_rx_desc); 1865 adapter->clean_rx = e1000_clean_jumbo_rx_irq; 1866 adapter->alloc_rx_buf = e1000_alloc_jumbo_rx_buffers; 1867 } else { 1868 rdlen = adapter->rx_ring[0].count * 1869 sizeof(struct e1000_rx_desc); 1870 adapter->clean_rx = e1000_clean_rx_irq; 1871 adapter->alloc_rx_buf = e1000_alloc_rx_buffers; 1872 } 1873 1874 /* disable receives while setting up the descriptors */ 1875 rctl = er32(RCTL); 1876 ew32(RCTL, rctl & ~E1000_RCTL_EN); 1877 1878 /* set the Receive Delay Timer Register */ 1879 ew32(RDTR, adapter->rx_int_delay); 1880 1881 if (hw->mac_type >= e1000_82540) { 1882 ew32(RADV, adapter->rx_abs_int_delay); 1883 if (adapter->itr_setting != 0) 1884 ew32(ITR, 1000000000 / (adapter->itr * 256)); 1885 } 1886 1887 /* Setup the HW Rx Head and Tail Descriptor Pointers and 1888 * the Base and Length of the Rx Descriptor Ring 1889 */ 1890 switch (adapter->num_rx_queues) { 1891 case 1: 1892 default: 1893 rdba = adapter->rx_ring[0].dma; 1894 ew32(RDLEN, rdlen); 1895 ew32(RDBAH, (rdba >> 32)); 1896 ew32(RDBAL, (rdba & 0x00000000ffffffffULL)); 1897 ew32(RDT, 0); 1898 ew32(RDH, 0); 1899 adapter->rx_ring[0].rdh = ((hw->mac_type >= e1000_82543) ? 1900 E1000_RDH : E1000_82542_RDH); 1901 adapter->rx_ring[0].rdt = ((hw->mac_type >= e1000_82543) ? 1902 E1000_RDT : E1000_82542_RDT); 1903 break; 1904 } 1905 1906 /* Enable 82543 Receive Checksum Offload for TCP and UDP */ 1907 if (hw->mac_type >= e1000_82543) { 1908 rxcsum = er32(RXCSUM); 1909 if (adapter->rx_csum) 1910 rxcsum |= E1000_RXCSUM_TUOFL; 1911 else 1912 /* don't need to clear IPPCSE as it defaults to 0 */ 1913 rxcsum &= ~E1000_RXCSUM_TUOFL; 1914 ew32(RXCSUM, rxcsum); 1915 } 1916 1917 /* Enable Receives */ 1918 ew32(RCTL, rctl | E1000_RCTL_EN); 1919 } 1920 1921 /** 1922 * e1000_free_tx_resources - Free Tx Resources per Queue 1923 * @adapter: board private structure 1924 * @tx_ring: Tx descriptor ring for a specific queue 1925 * 1926 * Free all transmit software resources 1927 **/ 1928 static void e1000_free_tx_resources(struct e1000_adapter *adapter, 1929 struct e1000_tx_ring *tx_ring) 1930 { 1931 struct pci_dev *pdev = adapter->pdev; 1932 1933 e1000_clean_tx_ring(adapter, tx_ring); 1934 1935 vfree(tx_ring->buffer_info); 1936 tx_ring->buffer_info = NULL; 1937 1938 dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc, 1939 tx_ring->dma); 1940 1941 tx_ring->desc = NULL; 1942 } 1943 1944 /** 1945 * e1000_free_all_tx_resources - Free Tx Resources for All Queues 1946 * @adapter: board private structure 1947 * 1948 * Free all transmit software resources 1949 **/ 1950 void e1000_free_all_tx_resources(struct e1000_adapter *adapter) 1951 { 1952 int i; 1953 1954 for (i = 0; i < adapter->num_tx_queues; i++) 1955 e1000_free_tx_resources(adapter, &adapter->tx_ring[i]); 1956 } 1957 1958 static void 1959 e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter, 1960 struct e1000_tx_buffer *buffer_info) 1961 { 1962 if (buffer_info->dma) { 1963 if (buffer_info->mapped_as_page) 1964 dma_unmap_page(&adapter->pdev->dev, buffer_info->dma, 1965 buffer_info->length, DMA_TO_DEVICE); 1966 else 1967 dma_unmap_single(&adapter->pdev->dev, buffer_info->dma, 1968 buffer_info->length, 1969 DMA_TO_DEVICE); 1970 buffer_info->dma = 0; 1971 } 1972 if (buffer_info->skb) { 1973 dev_kfree_skb_any(buffer_info->skb); 1974 buffer_info->skb = NULL; 1975 } 1976 buffer_info->time_stamp = 0; 1977 /* buffer_info must be completely set up in the transmit path */ 1978 } 1979 1980 /** 1981 * e1000_clean_tx_ring - Free Tx Buffers 1982 * @adapter: board private structure 1983 * @tx_ring: ring to be cleaned 1984 **/ 1985 static void e1000_clean_tx_ring(struct e1000_adapter *adapter, 1986 struct e1000_tx_ring *tx_ring) 1987 { 1988 struct e1000_hw *hw = &adapter->hw; 1989 struct e1000_tx_buffer *buffer_info; 1990 unsigned long size; 1991 unsigned int i; 1992 1993 /* Free all the Tx ring sk_buffs */ 1994 1995 for (i = 0; i < tx_ring->count; i++) { 1996 buffer_info = &tx_ring->buffer_info[i]; 1997 e1000_unmap_and_free_tx_resource(adapter, buffer_info); 1998 } 1999 2000 netdev_reset_queue(adapter->netdev); 2001 size = sizeof(struct e1000_tx_buffer) * tx_ring->count; 2002 memset(tx_ring->buffer_info, 0, size); 2003 2004 /* Zero out the descriptor ring */ 2005 2006 memset(tx_ring->desc, 0, tx_ring->size); 2007 2008 tx_ring->next_to_use = 0; 2009 tx_ring->next_to_clean = 0; 2010 tx_ring->last_tx_tso = false; 2011 2012 writel(0, hw->hw_addr + tx_ring->tdh); 2013 writel(0, hw->hw_addr + tx_ring->tdt); 2014 } 2015 2016 /** 2017 * e1000_clean_all_tx_rings - Free Tx Buffers for all queues 2018 * @adapter: board private structure 2019 **/ 2020 static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter) 2021 { 2022 int i; 2023 2024 for (i = 0; i < adapter->num_tx_queues; i++) 2025 e1000_clean_tx_ring(adapter, &adapter->tx_ring[i]); 2026 } 2027 2028 /** 2029 * e1000_free_rx_resources - Free Rx Resources 2030 * @adapter: board private structure 2031 * @rx_ring: ring to clean the resources from 2032 * 2033 * Free all receive software resources 2034 **/ 2035 static void e1000_free_rx_resources(struct e1000_adapter *adapter, 2036 struct e1000_rx_ring *rx_ring) 2037 { 2038 struct pci_dev *pdev = adapter->pdev; 2039 2040 e1000_clean_rx_ring(adapter, rx_ring); 2041 2042 vfree(rx_ring->buffer_info); 2043 rx_ring->buffer_info = NULL; 2044 2045 dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc, 2046 rx_ring->dma); 2047 2048 rx_ring->desc = NULL; 2049 } 2050 2051 /** 2052 * e1000_free_all_rx_resources - Free Rx Resources for All Queues 2053 * @adapter: board private structure 2054 * 2055 * Free all receive software resources 2056 **/ 2057 void e1000_free_all_rx_resources(struct e1000_adapter *adapter) 2058 { 2059 int i; 2060 2061 for (i = 0; i < adapter->num_rx_queues; i++) 2062 e1000_free_rx_resources(adapter, &adapter->rx_ring[i]); 2063 } 2064 2065 #define E1000_HEADROOM (NET_SKB_PAD + NET_IP_ALIGN) 2066 static unsigned int e1000_frag_len(const struct e1000_adapter *a) 2067 { 2068 return SKB_DATA_ALIGN(a->rx_buffer_len + E1000_HEADROOM) + 2069 SKB_DATA_ALIGN(sizeof(struct skb_shared_info)); 2070 } 2071 2072 static void *e1000_alloc_frag(const struct e1000_adapter *a) 2073 { 2074 unsigned int len = e1000_frag_len(a); 2075 u8 *data = netdev_alloc_frag(len); 2076 2077 if (likely(data)) 2078 data += E1000_HEADROOM; 2079 return data; 2080 } 2081 2082 /** 2083 * e1000_clean_rx_ring - Free Rx Buffers per Queue 2084 * @adapter: board private structure 2085 * @rx_ring: ring to free buffers from 2086 **/ 2087 static void e1000_clean_rx_ring(struct e1000_adapter *adapter, 2088 struct e1000_rx_ring *rx_ring) 2089 { 2090 struct e1000_hw *hw = &adapter->hw; 2091 struct e1000_rx_buffer *buffer_info; 2092 struct pci_dev *pdev = adapter->pdev; 2093 unsigned long size; 2094 unsigned int i; 2095 2096 /* Free all the Rx netfrags */ 2097 for (i = 0; i < rx_ring->count; i++) { 2098 buffer_info = &rx_ring->buffer_info[i]; 2099 if (adapter->clean_rx == e1000_clean_rx_irq) { 2100 if (buffer_info->dma) 2101 dma_unmap_single(&pdev->dev, buffer_info->dma, 2102 adapter->rx_buffer_len, 2103 DMA_FROM_DEVICE); 2104 if (buffer_info->rxbuf.data) { 2105 skb_free_frag(buffer_info->rxbuf.data); 2106 buffer_info->rxbuf.data = NULL; 2107 } 2108 } else if (adapter->clean_rx == e1000_clean_jumbo_rx_irq) { 2109 if (buffer_info->dma) 2110 dma_unmap_page(&pdev->dev, buffer_info->dma, 2111 adapter->rx_buffer_len, 2112 DMA_FROM_DEVICE); 2113 if (buffer_info->rxbuf.page) { 2114 put_page(buffer_info->rxbuf.page); 2115 buffer_info->rxbuf.page = NULL; 2116 } 2117 } 2118 2119 buffer_info->dma = 0; 2120 } 2121 2122 /* there also may be some cached data from a chained receive */ 2123 napi_free_frags(&adapter->napi); 2124 rx_ring->rx_skb_top = NULL; 2125 2126 size = sizeof(struct e1000_rx_buffer) * rx_ring->count; 2127 memset(rx_ring->buffer_info, 0, size); 2128 2129 /* Zero out the descriptor ring */ 2130 memset(rx_ring->desc, 0, rx_ring->size); 2131 2132 rx_ring->next_to_clean = 0; 2133 rx_ring->next_to_use = 0; 2134 2135 writel(0, hw->hw_addr + rx_ring->rdh); 2136 writel(0, hw->hw_addr + rx_ring->rdt); 2137 } 2138 2139 /** 2140 * e1000_clean_all_rx_rings - Free Rx Buffers for all queues 2141 * @adapter: board private structure 2142 **/ 2143 static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter) 2144 { 2145 int i; 2146 2147 for (i = 0; i < adapter->num_rx_queues; i++) 2148 e1000_clean_rx_ring(adapter, &adapter->rx_ring[i]); 2149 } 2150 2151 /* The 82542 2.0 (revision 2) needs to have the receive unit in reset 2152 * and memory write and invalidate disabled for certain operations 2153 */ 2154 static void e1000_enter_82542_rst(struct e1000_adapter *adapter) 2155 { 2156 struct e1000_hw *hw = &adapter->hw; 2157 struct net_device *netdev = adapter->netdev; 2158 u32 rctl; 2159 2160 e1000_pci_clear_mwi(hw); 2161 2162 rctl = er32(RCTL); 2163 rctl |= E1000_RCTL_RST; 2164 ew32(RCTL, rctl); 2165 E1000_WRITE_FLUSH(); 2166 mdelay(5); 2167 2168 if (netif_running(netdev)) 2169 e1000_clean_all_rx_rings(adapter); 2170 } 2171 2172 static void e1000_leave_82542_rst(struct e1000_adapter *adapter) 2173 { 2174 struct e1000_hw *hw = &adapter->hw; 2175 struct net_device *netdev = adapter->netdev; 2176 u32 rctl; 2177 2178 rctl = er32(RCTL); 2179 rctl &= ~E1000_RCTL_RST; 2180 ew32(RCTL, rctl); 2181 E1000_WRITE_FLUSH(); 2182 mdelay(5); 2183 2184 if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE) 2185 e1000_pci_set_mwi(hw); 2186 2187 if (netif_running(netdev)) { 2188 /* No need to loop, because 82542 supports only 1 queue */ 2189 struct e1000_rx_ring *ring = &adapter->rx_ring[0]; 2190 e1000_configure_rx(adapter); 2191 adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring)); 2192 } 2193 } 2194 2195 /** 2196 * e1000_set_mac - Change the Ethernet Address of the NIC 2197 * @netdev: network interface device structure 2198 * @p: pointer to an address structure 2199 * 2200 * Returns 0 on success, negative on failure 2201 **/ 2202 static int e1000_set_mac(struct net_device *netdev, void *p) 2203 { 2204 struct e1000_adapter *adapter = netdev_priv(netdev); 2205 struct e1000_hw *hw = &adapter->hw; 2206 struct sockaddr *addr = p; 2207 2208 if (!is_valid_ether_addr(addr->sa_data)) 2209 return -EADDRNOTAVAIL; 2210 2211 /* 82542 2.0 needs to be in reset to write receive address registers */ 2212 2213 if (hw->mac_type == e1000_82542_rev2_0) 2214 e1000_enter_82542_rst(adapter); 2215 2216 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len); 2217 memcpy(hw->mac_addr, addr->sa_data, netdev->addr_len); 2218 2219 e1000_rar_set(hw, hw->mac_addr, 0); 2220 2221 if (hw->mac_type == e1000_82542_rev2_0) 2222 e1000_leave_82542_rst(adapter); 2223 2224 return 0; 2225 } 2226 2227 /** 2228 * e1000_set_rx_mode - Secondary Unicast, Multicast and Promiscuous mode set 2229 * @netdev: network interface device structure 2230 * 2231 * The set_rx_mode entry point is called whenever the unicast or multicast 2232 * address lists or the network interface flags are updated. This routine is 2233 * responsible for configuring the hardware for proper unicast, multicast, 2234 * promiscuous mode, and all-multi behavior. 2235 **/ 2236 static void e1000_set_rx_mode(struct net_device *netdev) 2237 { 2238 struct e1000_adapter *adapter = netdev_priv(netdev); 2239 struct e1000_hw *hw = &adapter->hw; 2240 struct netdev_hw_addr *ha; 2241 bool use_uc = false; 2242 u32 rctl; 2243 u32 hash_value; 2244 int i, rar_entries = E1000_RAR_ENTRIES; 2245 int mta_reg_count = E1000_NUM_MTA_REGISTERS; 2246 u32 *mcarray = kcalloc(mta_reg_count, sizeof(u32), GFP_ATOMIC); 2247 2248 if (!mcarray) 2249 return; 2250 2251 /* Check for Promiscuous and All Multicast modes */ 2252 2253 rctl = er32(RCTL); 2254 2255 if (netdev->flags & IFF_PROMISC) { 2256 rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE); 2257 rctl &= ~E1000_RCTL_VFE; 2258 } else { 2259 if (netdev->flags & IFF_ALLMULTI) 2260 rctl |= E1000_RCTL_MPE; 2261 else 2262 rctl &= ~E1000_RCTL_MPE; 2263 /* Enable VLAN filter if there is a VLAN */ 2264 if (e1000_vlan_used(adapter)) 2265 rctl |= E1000_RCTL_VFE; 2266 } 2267 2268 if (netdev_uc_count(netdev) > rar_entries - 1) { 2269 rctl |= E1000_RCTL_UPE; 2270 } else if (!(netdev->flags & IFF_PROMISC)) { 2271 rctl &= ~E1000_RCTL_UPE; 2272 use_uc = true; 2273 } 2274 2275 ew32(RCTL, rctl); 2276 2277 /* 82542 2.0 needs to be in reset to write receive address registers */ 2278 2279 if (hw->mac_type == e1000_82542_rev2_0) 2280 e1000_enter_82542_rst(adapter); 2281 2282 /* load the first 14 addresses into the exact filters 1-14. Unicast 2283 * addresses take precedence to avoid disabling unicast filtering 2284 * when possible. 2285 * 2286 * RAR 0 is used for the station MAC address 2287 * if there are not 14 addresses, go ahead and clear the filters 2288 */ 2289 i = 1; 2290 if (use_uc) 2291 netdev_for_each_uc_addr(ha, netdev) { 2292 if (i == rar_entries) 2293 break; 2294 e1000_rar_set(hw, ha->addr, i++); 2295 } 2296 2297 netdev_for_each_mc_addr(ha, netdev) { 2298 if (i == rar_entries) { 2299 /* load any remaining addresses into the hash table */ 2300 u32 hash_reg, hash_bit, mta; 2301 hash_value = e1000_hash_mc_addr(hw, ha->addr); 2302 hash_reg = (hash_value >> 5) & 0x7F; 2303 hash_bit = hash_value & 0x1F; 2304 mta = (1 << hash_bit); 2305 mcarray[hash_reg] |= mta; 2306 } else { 2307 e1000_rar_set(hw, ha->addr, i++); 2308 } 2309 } 2310 2311 for (; i < rar_entries; i++) { 2312 E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0); 2313 E1000_WRITE_FLUSH(); 2314 E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0); 2315 E1000_WRITE_FLUSH(); 2316 } 2317 2318 /* write the hash table completely, write from bottom to avoid 2319 * both stupid write combining chipsets, and flushing each write 2320 */ 2321 for (i = mta_reg_count - 1; i >= 0 ; i--) { 2322 /* If we are on an 82544 has an errata where writing odd 2323 * offsets overwrites the previous even offset, but writing 2324 * backwards over the range solves the issue by always 2325 * writing the odd offset first 2326 */ 2327 E1000_WRITE_REG_ARRAY(hw, MTA, i, mcarray[i]); 2328 } 2329 E1000_WRITE_FLUSH(); 2330 2331 if (hw->mac_type == e1000_82542_rev2_0) 2332 e1000_leave_82542_rst(adapter); 2333 2334 kfree(mcarray); 2335 } 2336 2337 /** 2338 * e1000_update_phy_info_task - get phy info 2339 * @work: work struct contained inside adapter struct 2340 * 2341 * Need to wait a few seconds after link up to get diagnostic information from 2342 * the phy 2343 */ 2344 static void e1000_update_phy_info_task(struct work_struct *work) 2345 { 2346 struct e1000_adapter *adapter = container_of(work, 2347 struct e1000_adapter, 2348 phy_info_task.work); 2349 2350 e1000_phy_get_info(&adapter->hw, &adapter->phy_info); 2351 } 2352 2353 /** 2354 * e1000_82547_tx_fifo_stall_task - task to complete work 2355 * @work: work struct contained inside adapter struct 2356 **/ 2357 static void e1000_82547_tx_fifo_stall_task(struct work_struct *work) 2358 { 2359 struct e1000_adapter *adapter = container_of(work, 2360 struct e1000_adapter, 2361 fifo_stall_task.work); 2362 struct e1000_hw *hw = &adapter->hw; 2363 struct net_device *netdev = adapter->netdev; 2364 u32 tctl; 2365 2366 if (atomic_read(&adapter->tx_fifo_stall)) { 2367 if ((er32(TDT) == er32(TDH)) && 2368 (er32(TDFT) == er32(TDFH)) && 2369 (er32(TDFTS) == er32(TDFHS))) { 2370 tctl = er32(TCTL); 2371 ew32(TCTL, tctl & ~E1000_TCTL_EN); 2372 ew32(TDFT, adapter->tx_head_addr); 2373 ew32(TDFH, adapter->tx_head_addr); 2374 ew32(TDFTS, adapter->tx_head_addr); 2375 ew32(TDFHS, adapter->tx_head_addr); 2376 ew32(TCTL, tctl); 2377 E1000_WRITE_FLUSH(); 2378 2379 adapter->tx_fifo_head = 0; 2380 atomic_set(&adapter->tx_fifo_stall, 0); 2381 netif_wake_queue(netdev); 2382 } else if (!test_bit(__E1000_DOWN, &adapter->flags)) { 2383 schedule_delayed_work(&adapter->fifo_stall_task, 1); 2384 } 2385 } 2386 } 2387 2388 bool e1000_has_link(struct e1000_adapter *adapter) 2389 { 2390 struct e1000_hw *hw = &adapter->hw; 2391 bool link_active = false; 2392 2393 /* get_link_status is set on LSC (link status) interrupt or rx 2394 * sequence error interrupt (except on intel ce4100). 2395 * get_link_status will stay false until the 2396 * e1000_check_for_link establishes link for copper adapters 2397 * ONLY 2398 */ 2399 switch (hw->media_type) { 2400 case e1000_media_type_copper: 2401 if (hw->mac_type == e1000_ce4100) 2402 hw->get_link_status = 1; 2403 if (hw->get_link_status) { 2404 e1000_check_for_link(hw); 2405 link_active = !hw->get_link_status; 2406 } else { 2407 link_active = true; 2408 } 2409 break; 2410 case e1000_media_type_fiber: 2411 e1000_check_for_link(hw); 2412 link_active = !!(er32(STATUS) & E1000_STATUS_LU); 2413 break; 2414 case e1000_media_type_internal_serdes: 2415 e1000_check_for_link(hw); 2416 link_active = hw->serdes_has_link; 2417 break; 2418 default: 2419 break; 2420 } 2421 2422 return link_active; 2423 } 2424 2425 /** 2426 * e1000_watchdog - work function 2427 * @work: work struct contained inside adapter struct 2428 **/ 2429 static void e1000_watchdog(struct work_struct *work) 2430 { 2431 struct e1000_adapter *adapter = container_of(work, 2432 struct e1000_adapter, 2433 watchdog_task.work); 2434 struct e1000_hw *hw = &adapter->hw; 2435 struct net_device *netdev = adapter->netdev; 2436 struct e1000_tx_ring *txdr = adapter->tx_ring; 2437 u32 link, tctl; 2438 2439 link = e1000_has_link(adapter); 2440 if ((netif_carrier_ok(netdev)) && link) 2441 goto link_up; 2442 2443 if (link) { 2444 if (!netif_carrier_ok(netdev)) { 2445 u32 ctrl; 2446 /* update snapshot of PHY registers on LSC */ 2447 e1000_get_speed_and_duplex(hw, 2448 &adapter->link_speed, 2449 &adapter->link_duplex); 2450 2451 ctrl = er32(CTRL); 2452 pr_info("%s NIC Link is Up %d Mbps %s, " 2453 "Flow Control: %s\n", 2454 netdev->name, 2455 adapter->link_speed, 2456 adapter->link_duplex == FULL_DUPLEX ? 2457 "Full Duplex" : "Half Duplex", 2458 ((ctrl & E1000_CTRL_TFCE) && (ctrl & 2459 E1000_CTRL_RFCE)) ? "RX/TX" : ((ctrl & 2460 E1000_CTRL_RFCE) ? "RX" : ((ctrl & 2461 E1000_CTRL_TFCE) ? "TX" : "None"))); 2462 2463 /* adjust timeout factor according to speed/duplex */ 2464 adapter->tx_timeout_factor = 1; 2465 switch (adapter->link_speed) { 2466 case SPEED_10: 2467 adapter->tx_timeout_factor = 16; 2468 break; 2469 case SPEED_100: 2470 /* maybe add some timeout factor ? */ 2471 break; 2472 } 2473 2474 /* enable transmits in the hardware */ 2475 tctl = er32(TCTL); 2476 tctl |= E1000_TCTL_EN; 2477 ew32(TCTL, tctl); 2478 2479 netif_carrier_on(netdev); 2480 if (!test_bit(__E1000_DOWN, &adapter->flags)) 2481 schedule_delayed_work(&adapter->phy_info_task, 2482 2 * HZ); 2483 adapter->smartspeed = 0; 2484 } 2485 } else { 2486 if (netif_carrier_ok(netdev)) { 2487 adapter->link_speed = 0; 2488 adapter->link_duplex = 0; 2489 pr_info("%s NIC Link is Down\n", 2490 netdev->name); 2491 netif_carrier_off(netdev); 2492 2493 if (!test_bit(__E1000_DOWN, &adapter->flags)) 2494 schedule_delayed_work(&adapter->phy_info_task, 2495 2 * HZ); 2496 } 2497 2498 e1000_smartspeed(adapter); 2499 } 2500 2501 link_up: 2502 e1000_update_stats(adapter); 2503 2504 hw->tx_packet_delta = adapter->stats.tpt - adapter->tpt_old; 2505 adapter->tpt_old = adapter->stats.tpt; 2506 hw->collision_delta = adapter->stats.colc - adapter->colc_old; 2507 adapter->colc_old = adapter->stats.colc; 2508 2509 adapter->gorcl = adapter->stats.gorcl - adapter->gorcl_old; 2510 adapter->gorcl_old = adapter->stats.gorcl; 2511 adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old; 2512 adapter->gotcl_old = adapter->stats.gotcl; 2513 2514 e1000_update_adaptive(hw); 2515 2516 if (!netif_carrier_ok(netdev)) { 2517 if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) { 2518 /* We've lost link, so the controller stops DMA, 2519 * but we've got queued Tx work that's never going 2520 * to get done, so reset controller to flush Tx. 2521 * (Do the reset outside of interrupt context). 2522 */ 2523 adapter->tx_timeout_count++; 2524 schedule_work(&adapter->reset_task); 2525 /* exit immediately since reset is imminent */ 2526 return; 2527 } 2528 } 2529 2530 /* Simple mode for Interrupt Throttle Rate (ITR) */ 2531 if (hw->mac_type >= e1000_82540 && adapter->itr_setting == 4) { 2532 /* Symmetric Tx/Rx gets a reduced ITR=2000; 2533 * Total asymmetrical Tx or Rx gets ITR=8000; 2534 * everyone else is between 2000-8000. 2535 */ 2536 u32 goc = (adapter->gotcl + adapter->gorcl) / 10000; 2537 u32 dif = (adapter->gotcl > adapter->gorcl ? 2538 adapter->gotcl - adapter->gorcl : 2539 adapter->gorcl - adapter->gotcl) / 10000; 2540 u32 itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000; 2541 2542 ew32(ITR, 1000000000 / (itr * 256)); 2543 } 2544 2545 /* Cause software interrupt to ensure rx ring is cleaned */ 2546 ew32(ICS, E1000_ICS_RXDMT0); 2547 2548 /* Force detection of hung controller every watchdog period */ 2549 adapter->detect_tx_hung = true; 2550 2551 /* Reschedule the task */ 2552 if (!test_bit(__E1000_DOWN, &adapter->flags)) 2553 schedule_delayed_work(&adapter->watchdog_task, 2 * HZ); 2554 } 2555 2556 enum latency_range { 2557 lowest_latency = 0, 2558 low_latency = 1, 2559 bulk_latency = 2, 2560 latency_invalid = 255 2561 }; 2562 2563 /** 2564 * e1000_update_itr - update the dynamic ITR value based on statistics 2565 * @adapter: pointer to adapter 2566 * @itr_setting: current adapter->itr 2567 * @packets: the number of packets during this measurement interval 2568 * @bytes: the number of bytes during this measurement interval 2569 * 2570 * Stores a new ITR value based on packets and byte 2571 * counts during the last interrupt. The advantage of per interrupt 2572 * computation is faster updates and more accurate ITR for the current 2573 * traffic pattern. Constants in this function were computed 2574 * based on theoretical maximum wire speed and thresholds were set based 2575 * on testing data as well as attempting to minimize response time 2576 * while increasing bulk throughput. 2577 * this functionality is controlled by the InterruptThrottleRate module 2578 * parameter (see e1000_param.c) 2579 **/ 2580 static unsigned int e1000_update_itr(struct e1000_adapter *adapter, 2581 u16 itr_setting, int packets, int bytes) 2582 { 2583 unsigned int retval = itr_setting; 2584 struct e1000_hw *hw = &adapter->hw; 2585 2586 if (unlikely(hw->mac_type < e1000_82540)) 2587 goto update_itr_done; 2588 2589 if (packets == 0) 2590 goto update_itr_done; 2591 2592 switch (itr_setting) { 2593 case lowest_latency: 2594 /* jumbo frames get bulk treatment*/ 2595 if (bytes/packets > 8000) 2596 retval = bulk_latency; 2597 else if ((packets < 5) && (bytes > 512)) 2598 retval = low_latency; 2599 break; 2600 case low_latency: /* 50 usec aka 20000 ints/s */ 2601 if (bytes > 10000) { 2602 /* jumbo frames need bulk latency setting */ 2603 if (bytes/packets > 8000) 2604 retval = bulk_latency; 2605 else if ((packets < 10) || ((bytes/packets) > 1200)) 2606 retval = bulk_latency; 2607 else if ((packets > 35)) 2608 retval = lowest_latency; 2609 } else if (bytes/packets > 2000) 2610 retval = bulk_latency; 2611 else if (packets <= 2 && bytes < 512) 2612 retval = lowest_latency; 2613 break; 2614 case bulk_latency: /* 250 usec aka 4000 ints/s */ 2615 if (bytes > 25000) { 2616 if (packets > 35) 2617 retval = low_latency; 2618 } else if (bytes < 6000) { 2619 retval = low_latency; 2620 } 2621 break; 2622 } 2623 2624 update_itr_done: 2625 return retval; 2626 } 2627 2628 static void e1000_set_itr(struct e1000_adapter *adapter) 2629 { 2630 struct e1000_hw *hw = &adapter->hw; 2631 u16 current_itr; 2632 u32 new_itr = adapter->itr; 2633 2634 if (unlikely(hw->mac_type < e1000_82540)) 2635 return; 2636 2637 /* for non-gigabit speeds, just fix the interrupt rate at 4000 */ 2638 if (unlikely(adapter->link_speed != SPEED_1000)) { 2639 current_itr = 0; 2640 new_itr = 4000; 2641 goto set_itr_now; 2642 } 2643 2644 adapter->tx_itr = e1000_update_itr(adapter, adapter->tx_itr, 2645 adapter->total_tx_packets, 2646 adapter->total_tx_bytes); 2647 /* conservative mode (itr 3) eliminates the lowest_latency setting */ 2648 if (adapter->itr_setting == 3 && adapter->tx_itr == lowest_latency) 2649 adapter->tx_itr = low_latency; 2650 2651 adapter->rx_itr = e1000_update_itr(adapter, adapter->rx_itr, 2652 adapter->total_rx_packets, 2653 adapter->total_rx_bytes); 2654 /* conservative mode (itr 3) eliminates the lowest_latency setting */ 2655 if (adapter->itr_setting == 3 && adapter->rx_itr == lowest_latency) 2656 adapter->rx_itr = low_latency; 2657 2658 current_itr = max(adapter->rx_itr, adapter->tx_itr); 2659 2660 switch (current_itr) { 2661 /* counts and packets in update_itr are dependent on these numbers */ 2662 case lowest_latency: 2663 new_itr = 70000; 2664 break; 2665 case low_latency: 2666 new_itr = 20000; /* aka hwitr = ~200 */ 2667 break; 2668 case bulk_latency: 2669 new_itr = 4000; 2670 break; 2671 default: 2672 break; 2673 } 2674 2675 set_itr_now: 2676 if (new_itr != adapter->itr) { 2677 /* this attempts to bias the interrupt rate towards Bulk 2678 * by adding intermediate steps when interrupt rate is 2679 * increasing 2680 */ 2681 new_itr = new_itr > adapter->itr ? 2682 min(adapter->itr + (new_itr >> 2), new_itr) : 2683 new_itr; 2684 adapter->itr = new_itr; 2685 ew32(ITR, 1000000000 / (new_itr * 256)); 2686 } 2687 } 2688 2689 #define E1000_TX_FLAGS_CSUM 0x00000001 2690 #define E1000_TX_FLAGS_VLAN 0x00000002 2691 #define E1000_TX_FLAGS_TSO 0x00000004 2692 #define E1000_TX_FLAGS_IPV4 0x00000008 2693 #define E1000_TX_FLAGS_NO_FCS 0x00000010 2694 #define E1000_TX_FLAGS_VLAN_MASK 0xffff0000 2695 #define E1000_TX_FLAGS_VLAN_SHIFT 16 2696 2697 static int e1000_tso(struct e1000_adapter *adapter, 2698 struct e1000_tx_ring *tx_ring, struct sk_buff *skb, 2699 __be16 protocol) 2700 { 2701 struct e1000_context_desc *context_desc; 2702 struct e1000_tx_buffer *buffer_info; 2703 unsigned int i; 2704 u32 cmd_length = 0; 2705 u16 ipcse = 0, tucse, mss; 2706 u8 ipcss, ipcso, tucss, tucso, hdr_len; 2707 2708 if (skb_is_gso(skb)) { 2709 int err; 2710 2711 err = skb_cow_head(skb, 0); 2712 if (err < 0) 2713 return err; 2714 2715 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb); 2716 mss = skb_shinfo(skb)->gso_size; 2717 if (protocol == htons(ETH_P_IP)) { 2718 struct iphdr *iph = ip_hdr(skb); 2719 iph->tot_len = 0; 2720 iph->check = 0; 2721 tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr, 2722 iph->daddr, 0, 2723 IPPROTO_TCP, 2724 0); 2725 cmd_length = E1000_TXD_CMD_IP; 2726 ipcse = skb_transport_offset(skb) - 1; 2727 } else if (skb_is_gso_v6(skb)) { 2728 tcp_v6_gso_csum_prep(skb); 2729 ipcse = 0; 2730 } 2731 ipcss = skb_network_offset(skb); 2732 ipcso = (void *)&(ip_hdr(skb)->check) - (void *)skb->data; 2733 tucss = skb_transport_offset(skb); 2734 tucso = (void *)&(tcp_hdr(skb)->check) - (void *)skb->data; 2735 tucse = 0; 2736 2737 cmd_length |= (E1000_TXD_CMD_DEXT | E1000_TXD_CMD_TSE | 2738 E1000_TXD_CMD_TCP | (skb->len - (hdr_len))); 2739 2740 i = tx_ring->next_to_use; 2741 context_desc = E1000_CONTEXT_DESC(*tx_ring, i); 2742 buffer_info = &tx_ring->buffer_info[i]; 2743 2744 context_desc->lower_setup.ip_fields.ipcss = ipcss; 2745 context_desc->lower_setup.ip_fields.ipcso = ipcso; 2746 context_desc->lower_setup.ip_fields.ipcse = cpu_to_le16(ipcse); 2747 context_desc->upper_setup.tcp_fields.tucss = tucss; 2748 context_desc->upper_setup.tcp_fields.tucso = tucso; 2749 context_desc->upper_setup.tcp_fields.tucse = cpu_to_le16(tucse); 2750 context_desc->tcp_seg_setup.fields.mss = cpu_to_le16(mss); 2751 context_desc->tcp_seg_setup.fields.hdr_len = hdr_len; 2752 context_desc->cmd_and_length = cpu_to_le32(cmd_length); 2753 2754 buffer_info->time_stamp = jiffies; 2755 buffer_info->next_to_watch = i; 2756 2757 if (++i == tx_ring->count) 2758 i = 0; 2759 2760 tx_ring->next_to_use = i; 2761 2762 return true; 2763 } 2764 return false; 2765 } 2766 2767 static bool e1000_tx_csum(struct e1000_adapter *adapter, 2768 struct e1000_tx_ring *tx_ring, struct sk_buff *skb, 2769 __be16 protocol) 2770 { 2771 struct e1000_context_desc *context_desc; 2772 struct e1000_tx_buffer *buffer_info; 2773 unsigned int i; 2774 u8 css; 2775 u32 cmd_len = E1000_TXD_CMD_DEXT; 2776 2777 if (skb->ip_summed != CHECKSUM_PARTIAL) 2778 return false; 2779 2780 switch (protocol) { 2781 case cpu_to_be16(ETH_P_IP): 2782 if (ip_hdr(skb)->protocol == IPPROTO_TCP) 2783 cmd_len |= E1000_TXD_CMD_TCP; 2784 break; 2785 case cpu_to_be16(ETH_P_IPV6): 2786 /* XXX not handling all IPV6 headers */ 2787 if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP) 2788 cmd_len |= E1000_TXD_CMD_TCP; 2789 break; 2790 default: 2791 if (unlikely(net_ratelimit())) 2792 e_warn(drv, "checksum_partial proto=%x!\n", 2793 skb->protocol); 2794 break; 2795 } 2796 2797 css = skb_checksum_start_offset(skb); 2798 2799 i = tx_ring->next_to_use; 2800 buffer_info = &tx_ring->buffer_info[i]; 2801 context_desc = E1000_CONTEXT_DESC(*tx_ring, i); 2802 2803 context_desc->lower_setup.ip_config = 0; 2804 context_desc->upper_setup.tcp_fields.tucss = css; 2805 context_desc->upper_setup.tcp_fields.tucso = 2806 css + skb->csum_offset; 2807 context_desc->upper_setup.tcp_fields.tucse = 0; 2808 context_desc->tcp_seg_setup.data = 0; 2809 context_desc->cmd_and_length = cpu_to_le32(cmd_len); 2810 2811 buffer_info->time_stamp = jiffies; 2812 buffer_info->next_to_watch = i; 2813 2814 if (unlikely(++i == tx_ring->count)) 2815 i = 0; 2816 2817 tx_ring->next_to_use = i; 2818 2819 return true; 2820 } 2821 2822 #define E1000_MAX_TXD_PWR 12 2823 #define E1000_MAX_DATA_PER_TXD (1<<E1000_MAX_TXD_PWR) 2824 2825 static int e1000_tx_map(struct e1000_adapter *adapter, 2826 struct e1000_tx_ring *tx_ring, 2827 struct sk_buff *skb, unsigned int first, 2828 unsigned int max_per_txd, unsigned int nr_frags, 2829 unsigned int mss) 2830 { 2831 struct e1000_hw *hw = &adapter->hw; 2832 struct pci_dev *pdev = adapter->pdev; 2833 struct e1000_tx_buffer *buffer_info; 2834 unsigned int len = skb_headlen(skb); 2835 unsigned int offset = 0, size, count = 0, i; 2836 unsigned int f, bytecount, segs; 2837 2838 i = tx_ring->next_to_use; 2839 2840 while (len) { 2841 buffer_info = &tx_ring->buffer_info[i]; 2842 size = min(len, max_per_txd); 2843 /* Workaround for Controller erratum -- 2844 * descriptor for non-tso packet in a linear SKB that follows a 2845 * tso gets written back prematurely before the data is fully 2846 * DMA'd to the controller 2847 */ 2848 if (!skb->data_len && tx_ring->last_tx_tso && 2849 !skb_is_gso(skb)) { 2850 tx_ring->last_tx_tso = false; 2851 size -= 4; 2852 } 2853 2854 /* Workaround for premature desc write-backs 2855 * in TSO mode. Append 4-byte sentinel desc 2856 */ 2857 if (unlikely(mss && !nr_frags && size == len && size > 8)) 2858 size -= 4; 2859 /* work-around for errata 10 and it applies 2860 * to all controllers in PCI-X mode 2861 * The fix is to make sure that the first descriptor of a 2862 * packet is smaller than 2048 - 16 - 16 (or 2016) bytes 2863 */ 2864 if (unlikely((hw->bus_type == e1000_bus_type_pcix) && 2865 (size > 2015) && count == 0)) 2866 size = 2015; 2867 2868 /* Workaround for potential 82544 hang in PCI-X. Avoid 2869 * terminating buffers within evenly-aligned dwords. 2870 */ 2871 if (unlikely(adapter->pcix_82544 && 2872 !((unsigned long)(skb->data + offset + size - 1) & 4) && 2873 size > 4)) 2874 size -= 4; 2875 2876 buffer_info->length = size; 2877 /* set time_stamp *before* dma to help avoid a possible race */ 2878 buffer_info->time_stamp = jiffies; 2879 buffer_info->mapped_as_page = false; 2880 buffer_info->dma = dma_map_single(&pdev->dev, 2881 skb->data + offset, 2882 size, DMA_TO_DEVICE); 2883 if (dma_mapping_error(&pdev->dev, buffer_info->dma)) 2884 goto dma_error; 2885 buffer_info->next_to_watch = i; 2886 2887 len -= size; 2888 offset += size; 2889 count++; 2890 if (len) { 2891 i++; 2892 if (unlikely(i == tx_ring->count)) 2893 i = 0; 2894 } 2895 } 2896 2897 for (f = 0; f < nr_frags; f++) { 2898 const skb_frag_t *frag = &skb_shinfo(skb)->frags[f]; 2899 2900 len = skb_frag_size(frag); 2901 offset = 0; 2902 2903 while (len) { 2904 unsigned long bufend; 2905 i++; 2906 if (unlikely(i == tx_ring->count)) 2907 i = 0; 2908 2909 buffer_info = &tx_ring->buffer_info[i]; 2910 size = min(len, max_per_txd); 2911 /* Workaround for premature desc write-backs 2912 * in TSO mode. Append 4-byte sentinel desc 2913 */ 2914 if (unlikely(mss && f == (nr_frags-1) && 2915 size == len && size > 8)) 2916 size -= 4; 2917 /* Workaround for potential 82544 hang in PCI-X. 2918 * Avoid terminating buffers within evenly-aligned 2919 * dwords. 2920 */ 2921 bufend = (unsigned long) 2922 page_to_phys(skb_frag_page(frag)); 2923 bufend += offset + size - 1; 2924 if (unlikely(adapter->pcix_82544 && 2925 !(bufend & 4) && 2926 size > 4)) 2927 size -= 4; 2928 2929 buffer_info->length = size; 2930 buffer_info->time_stamp = jiffies; 2931 buffer_info->mapped_as_page = true; 2932 buffer_info->dma = skb_frag_dma_map(&pdev->dev, frag, 2933 offset, size, DMA_TO_DEVICE); 2934 if (dma_mapping_error(&pdev->dev, buffer_info->dma)) 2935 goto dma_error; 2936 buffer_info->next_to_watch = i; 2937 2938 len -= size; 2939 offset += size; 2940 count++; 2941 } 2942 } 2943 2944 segs = skb_shinfo(skb)->gso_segs ?: 1; 2945 /* multiply data chunks by size of headers */ 2946 bytecount = ((segs - 1) * skb_headlen(skb)) + skb->len; 2947 2948 tx_ring->buffer_info[i].skb = skb; 2949 tx_ring->buffer_info[i].segs = segs; 2950 tx_ring->buffer_info[i].bytecount = bytecount; 2951 tx_ring->buffer_info[first].next_to_watch = i; 2952 2953 return count; 2954 2955 dma_error: 2956 dev_err(&pdev->dev, "TX DMA map failed\n"); 2957 buffer_info->dma = 0; 2958 if (count) 2959 count--; 2960 2961 while (count--) { 2962 if (i == 0) 2963 i += tx_ring->count; 2964 i--; 2965 buffer_info = &tx_ring->buffer_info[i]; 2966 e1000_unmap_and_free_tx_resource(adapter, buffer_info); 2967 } 2968 2969 return 0; 2970 } 2971 2972 static void e1000_tx_queue(struct e1000_adapter *adapter, 2973 struct e1000_tx_ring *tx_ring, int tx_flags, 2974 int count) 2975 { 2976 struct e1000_tx_desc *tx_desc = NULL; 2977 struct e1000_tx_buffer *buffer_info; 2978 u32 txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS; 2979 unsigned int i; 2980 2981 if (likely(tx_flags & E1000_TX_FLAGS_TSO)) { 2982 txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D | 2983 E1000_TXD_CMD_TSE; 2984 txd_upper |= E1000_TXD_POPTS_TXSM << 8; 2985 2986 if (likely(tx_flags & E1000_TX_FLAGS_IPV4)) 2987 txd_upper |= E1000_TXD_POPTS_IXSM << 8; 2988 } 2989 2990 if (likely(tx_flags & E1000_TX_FLAGS_CSUM)) { 2991 txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 2992 txd_upper |= E1000_TXD_POPTS_TXSM << 8; 2993 } 2994 2995 if (unlikely(tx_flags & E1000_TX_FLAGS_VLAN)) { 2996 txd_lower |= E1000_TXD_CMD_VLE; 2997 txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK); 2998 } 2999 3000 if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS)) 3001 txd_lower &= ~(E1000_TXD_CMD_IFCS); 3002 3003 i = tx_ring->next_to_use; 3004 3005 while (count--) { 3006 buffer_info = &tx_ring->buffer_info[i]; 3007 tx_desc = E1000_TX_DESC(*tx_ring, i); 3008 tx_desc->buffer_addr = cpu_to_le64(buffer_info->dma); 3009 tx_desc->lower.data = 3010 cpu_to_le32(txd_lower | buffer_info->length); 3011 tx_desc->upper.data = cpu_to_le32(txd_upper); 3012 if (unlikely(++i == tx_ring->count)) 3013 i = 0; 3014 } 3015 3016 tx_desc->lower.data |= cpu_to_le32(adapter->txd_cmd); 3017 3018 /* txd_cmd re-enables FCS, so we'll re-disable it here as desired. */ 3019 if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS)) 3020 tx_desc->lower.data &= ~(cpu_to_le32(E1000_TXD_CMD_IFCS)); 3021 3022 /* Force memory writes to complete before letting h/w 3023 * know there are new descriptors to fetch. (Only 3024 * applicable for weak-ordered memory model archs, 3025 * such as IA-64). 3026 */ 3027 dma_wmb(); 3028 3029 tx_ring->next_to_use = i; 3030 } 3031 3032 /* 82547 workaround to avoid controller hang in half-duplex environment. 3033 * The workaround is to avoid queuing a large packet that would span 3034 * the internal Tx FIFO ring boundary by notifying the stack to resend 3035 * the packet at a later time. This gives the Tx FIFO an opportunity to 3036 * flush all packets. When that occurs, we reset the Tx FIFO pointers 3037 * to the beginning of the Tx FIFO. 3038 */ 3039 3040 #define E1000_FIFO_HDR 0x10 3041 #define E1000_82547_PAD_LEN 0x3E0 3042 3043 static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter, 3044 struct sk_buff *skb) 3045 { 3046 u32 fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head; 3047 u32 skb_fifo_len = skb->len + E1000_FIFO_HDR; 3048 3049 skb_fifo_len = ALIGN(skb_fifo_len, E1000_FIFO_HDR); 3050 3051 if (adapter->link_duplex != HALF_DUPLEX) 3052 goto no_fifo_stall_required; 3053 3054 if (atomic_read(&adapter->tx_fifo_stall)) 3055 return 1; 3056 3057 if (skb_fifo_len >= (E1000_82547_PAD_LEN + fifo_space)) { 3058 atomic_set(&adapter->tx_fifo_stall, 1); 3059 return 1; 3060 } 3061 3062 no_fifo_stall_required: 3063 adapter->tx_fifo_head += skb_fifo_len; 3064 if (adapter->tx_fifo_head >= adapter->tx_fifo_size) 3065 adapter->tx_fifo_head -= adapter->tx_fifo_size; 3066 return 0; 3067 } 3068 3069 static int __e1000_maybe_stop_tx(struct net_device *netdev, int size) 3070 { 3071 struct e1000_adapter *adapter = netdev_priv(netdev); 3072 struct e1000_tx_ring *tx_ring = adapter->tx_ring; 3073 3074 netif_stop_queue(netdev); 3075 /* Herbert's original patch had: 3076 * smp_mb__after_netif_stop_queue(); 3077 * but since that doesn't exist yet, just open code it. 3078 */ 3079 smp_mb(); 3080 3081 /* We need to check again in a case another CPU has just 3082 * made room available. 3083 */ 3084 if (likely(E1000_DESC_UNUSED(tx_ring) < size)) 3085 return -EBUSY; 3086 3087 /* A reprieve! */ 3088 netif_start_queue(netdev); 3089 ++adapter->restart_queue; 3090 return 0; 3091 } 3092 3093 static int e1000_maybe_stop_tx(struct net_device *netdev, 3094 struct e1000_tx_ring *tx_ring, int size) 3095 { 3096 if (likely(E1000_DESC_UNUSED(tx_ring) >= size)) 3097 return 0; 3098 return __e1000_maybe_stop_tx(netdev, size); 3099 } 3100 3101 #define TXD_USE_COUNT(S, X) (((S) + ((1 << (X)) - 1)) >> (X)) 3102 static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb, 3103 struct net_device *netdev) 3104 { 3105 struct e1000_adapter *adapter = netdev_priv(netdev); 3106 struct e1000_hw *hw = &adapter->hw; 3107 struct e1000_tx_ring *tx_ring; 3108 unsigned int first, max_per_txd = E1000_MAX_DATA_PER_TXD; 3109 unsigned int max_txd_pwr = E1000_MAX_TXD_PWR; 3110 unsigned int tx_flags = 0; 3111 unsigned int len = skb_headlen(skb); 3112 unsigned int nr_frags; 3113 unsigned int mss; 3114 int count = 0; 3115 int tso; 3116 unsigned int f; 3117 __be16 protocol = vlan_get_protocol(skb); 3118 3119 /* This goes back to the question of how to logically map a Tx queue 3120 * to a flow. Right now, performance is impacted slightly negatively 3121 * if using multiple Tx queues. If the stack breaks away from a 3122 * single qdisc implementation, we can look at this again. 3123 */ 3124 tx_ring = adapter->tx_ring; 3125 3126 /* On PCI/PCI-X HW, if packet size is less than ETH_ZLEN, 3127 * packets may get corrupted during padding by HW. 3128 * To WA this issue, pad all small packets manually. 3129 */ 3130 if (eth_skb_pad(skb)) 3131 return NETDEV_TX_OK; 3132 3133 mss = skb_shinfo(skb)->gso_size; 3134 /* The controller does a simple calculation to 3135 * make sure there is enough room in the FIFO before 3136 * initiating the DMA for each buffer. The calc is: 3137 * 4 = ceil(buffer len/mss). To make sure we don't 3138 * overrun the FIFO, adjust the max buffer len if mss 3139 * drops. 3140 */ 3141 if (mss) { 3142 u8 hdr_len; 3143 max_per_txd = min(mss << 2, max_per_txd); 3144 max_txd_pwr = fls(max_per_txd) - 1; 3145 3146 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb); 3147 if (skb->data_len && hdr_len == len) { 3148 switch (hw->mac_type) { 3149 case e1000_82544: { 3150 unsigned int pull_size; 3151 3152 /* Make sure we have room to chop off 4 bytes, 3153 * and that the end alignment will work out to 3154 * this hardware's requirements 3155 * NOTE: this is a TSO only workaround 3156 * if end byte alignment not correct move us 3157 * into the next dword 3158 */ 3159 if ((unsigned long)(skb_tail_pointer(skb) - 1) 3160 & 4) 3161 break; 3162 /* fall through */ 3163 pull_size = min((unsigned int)4, skb->data_len); 3164 if (!__pskb_pull_tail(skb, pull_size)) { 3165 e_err(drv, "__pskb_pull_tail " 3166 "failed.\n"); 3167 dev_kfree_skb_any(skb); 3168 return NETDEV_TX_OK; 3169 } 3170 len = skb_headlen(skb); 3171 break; 3172 } 3173 default: 3174 /* do nothing */ 3175 break; 3176 } 3177 } 3178 } 3179 3180 /* reserve a descriptor for the offload context */ 3181 if ((mss) || (skb->ip_summed == CHECKSUM_PARTIAL)) 3182 count++; 3183 count++; 3184 3185 /* Controller Erratum workaround */ 3186 if (!skb->data_len && tx_ring->last_tx_tso && !skb_is_gso(skb)) 3187 count++; 3188 3189 count += TXD_USE_COUNT(len, max_txd_pwr); 3190 3191 if (adapter->pcix_82544) 3192 count++; 3193 3194 /* work-around for errata 10 and it applies to all controllers 3195 * in PCI-X mode, so add one more descriptor to the count 3196 */ 3197 if (unlikely((hw->bus_type == e1000_bus_type_pcix) && 3198 (len > 2015))) 3199 count++; 3200 3201 nr_frags = skb_shinfo(skb)->nr_frags; 3202 for (f = 0; f < nr_frags; f++) 3203 count += TXD_USE_COUNT(skb_frag_size(&skb_shinfo(skb)->frags[f]), 3204 max_txd_pwr); 3205 if (adapter->pcix_82544) 3206 count += nr_frags; 3207 3208 /* need: count + 2 desc gap to keep tail from touching 3209 * head, otherwise try next time 3210 */ 3211 if (unlikely(e1000_maybe_stop_tx(netdev, tx_ring, count + 2))) 3212 return NETDEV_TX_BUSY; 3213 3214 if (unlikely((hw->mac_type == e1000_82547) && 3215 (e1000_82547_fifo_workaround(adapter, skb)))) { 3216 netif_stop_queue(netdev); 3217 if (!test_bit(__E1000_DOWN, &adapter->flags)) 3218 schedule_delayed_work(&adapter->fifo_stall_task, 1); 3219 return NETDEV_TX_BUSY; 3220 } 3221 3222 if (skb_vlan_tag_present(skb)) { 3223 tx_flags |= E1000_TX_FLAGS_VLAN; 3224 tx_flags |= (skb_vlan_tag_get(skb) << 3225 E1000_TX_FLAGS_VLAN_SHIFT); 3226 } 3227 3228 first = tx_ring->next_to_use; 3229 3230 tso = e1000_tso(adapter, tx_ring, skb, protocol); 3231 if (tso < 0) { 3232 dev_kfree_skb_any(skb); 3233 return NETDEV_TX_OK; 3234 } 3235 3236 if (likely(tso)) { 3237 if (likely(hw->mac_type != e1000_82544)) 3238 tx_ring->last_tx_tso = true; 3239 tx_flags |= E1000_TX_FLAGS_TSO; 3240 } else if (likely(e1000_tx_csum(adapter, tx_ring, skb, protocol))) 3241 tx_flags |= E1000_TX_FLAGS_CSUM; 3242 3243 if (protocol == htons(ETH_P_IP)) 3244 tx_flags |= E1000_TX_FLAGS_IPV4; 3245 3246 if (unlikely(skb->no_fcs)) 3247 tx_flags |= E1000_TX_FLAGS_NO_FCS; 3248 3249 count = e1000_tx_map(adapter, tx_ring, skb, first, max_per_txd, 3250 nr_frags, mss); 3251 3252 if (count) { 3253 /* The descriptors needed is higher than other Intel drivers 3254 * due to a number of workarounds. The breakdown is below: 3255 * Data descriptors: MAX_SKB_FRAGS + 1 3256 * Context Descriptor: 1 3257 * Keep head from touching tail: 2 3258 * Workarounds: 3 3259 */ 3260 int desc_needed = MAX_SKB_FRAGS + 7; 3261 3262 netdev_sent_queue(netdev, skb->len); 3263 skb_tx_timestamp(skb); 3264 3265 e1000_tx_queue(adapter, tx_ring, tx_flags, count); 3266 3267 /* 82544 potentially requires twice as many data descriptors 3268 * in order to guarantee buffers don't end on evenly-aligned 3269 * dwords 3270 */ 3271 if (adapter->pcix_82544) 3272 desc_needed += MAX_SKB_FRAGS + 1; 3273 3274 /* Make sure there is space in the ring for the next send. */ 3275 e1000_maybe_stop_tx(netdev, tx_ring, desc_needed); 3276 3277 if (!netdev_xmit_more() || 3278 netif_xmit_stopped(netdev_get_tx_queue(netdev, 0))) { 3279 writel(tx_ring->next_to_use, hw->hw_addr + tx_ring->tdt); 3280 } 3281 } else { 3282 dev_kfree_skb_any(skb); 3283 tx_ring->buffer_info[first].time_stamp = 0; 3284 tx_ring->next_to_use = first; 3285 } 3286 3287 return NETDEV_TX_OK; 3288 } 3289 3290 #define NUM_REGS 38 /* 1 based count */ 3291 static void e1000_regdump(struct e1000_adapter *adapter) 3292 { 3293 struct e1000_hw *hw = &adapter->hw; 3294 u32 regs[NUM_REGS]; 3295 u32 *regs_buff = regs; 3296 int i = 0; 3297 3298 static const char * const reg_name[] = { 3299 "CTRL", "STATUS", 3300 "RCTL", "RDLEN", "RDH", "RDT", "RDTR", 3301 "TCTL", "TDBAL", "TDBAH", "TDLEN", "TDH", "TDT", 3302 "TIDV", "TXDCTL", "TADV", "TARC0", 3303 "TDBAL1", "TDBAH1", "TDLEN1", "TDH1", "TDT1", 3304 "TXDCTL1", "TARC1", 3305 "CTRL_EXT", "ERT", "RDBAL", "RDBAH", 3306 "TDFH", "TDFT", "TDFHS", "TDFTS", "TDFPC", 3307 "RDFH", "RDFT", "RDFHS", "RDFTS", "RDFPC" 3308 }; 3309 3310 regs_buff[0] = er32(CTRL); 3311 regs_buff[1] = er32(STATUS); 3312 3313 regs_buff[2] = er32(RCTL); 3314 regs_buff[3] = er32(RDLEN); 3315 regs_buff[4] = er32(RDH); 3316 regs_buff[5] = er32(RDT); 3317 regs_buff[6] = er32(RDTR); 3318 3319 regs_buff[7] = er32(TCTL); 3320 regs_buff[8] = er32(TDBAL); 3321 regs_buff[9] = er32(TDBAH); 3322 regs_buff[10] = er32(TDLEN); 3323 regs_buff[11] = er32(TDH); 3324 regs_buff[12] = er32(TDT); 3325 regs_buff[13] = er32(TIDV); 3326 regs_buff[14] = er32(TXDCTL); 3327 regs_buff[15] = er32(TADV); 3328 regs_buff[16] = er32(TARC0); 3329 3330 regs_buff[17] = er32(TDBAL1); 3331 regs_buff[18] = er32(TDBAH1); 3332 regs_buff[19] = er32(TDLEN1); 3333 regs_buff[20] = er32(TDH1); 3334 regs_buff[21] = er32(TDT1); 3335 regs_buff[22] = er32(TXDCTL1); 3336 regs_buff[23] = er32(TARC1); 3337 regs_buff[24] = er32(CTRL_EXT); 3338 regs_buff[25] = er32(ERT); 3339 regs_buff[26] = er32(RDBAL0); 3340 regs_buff[27] = er32(RDBAH0); 3341 regs_buff[28] = er32(TDFH); 3342 regs_buff[29] = er32(TDFT); 3343 regs_buff[30] = er32(TDFHS); 3344 regs_buff[31] = er32(TDFTS); 3345 regs_buff[32] = er32(TDFPC); 3346 regs_buff[33] = er32(RDFH); 3347 regs_buff[34] = er32(RDFT); 3348 regs_buff[35] = er32(RDFHS); 3349 regs_buff[36] = er32(RDFTS); 3350 regs_buff[37] = er32(RDFPC); 3351 3352 pr_info("Register dump\n"); 3353 for (i = 0; i < NUM_REGS; i++) 3354 pr_info("%-15s %08x\n", reg_name[i], regs_buff[i]); 3355 } 3356 3357 /* 3358 * e1000_dump: Print registers, tx ring and rx ring 3359 */ 3360 static void e1000_dump(struct e1000_adapter *adapter) 3361 { 3362 /* this code doesn't handle multiple rings */ 3363 struct e1000_tx_ring *tx_ring = adapter->tx_ring; 3364 struct e1000_rx_ring *rx_ring = adapter->rx_ring; 3365 int i; 3366 3367 if (!netif_msg_hw(adapter)) 3368 return; 3369 3370 /* Print Registers */ 3371 e1000_regdump(adapter); 3372 3373 /* transmit dump */ 3374 pr_info("TX Desc ring0 dump\n"); 3375 3376 /* Transmit Descriptor Formats - DEXT[29] is 0 (Legacy) or 1 (Extended) 3377 * 3378 * Legacy Transmit Descriptor 3379 * +--------------------------------------------------------------+ 3380 * 0 | Buffer Address [63:0] (Reserved on Write Back) | 3381 * +--------------------------------------------------------------+ 3382 * 8 | Special | CSS | Status | CMD | CSO | Length | 3383 * +--------------------------------------------------------------+ 3384 * 63 48 47 36 35 32 31 24 23 16 15 0 3385 * 3386 * Extended Context Descriptor (DTYP=0x0) for TSO or checksum offload 3387 * 63 48 47 40 39 32 31 16 15 8 7 0 3388 * +----------------------------------------------------------------+ 3389 * 0 | TUCSE | TUCS0 | TUCSS | IPCSE | IPCS0 | IPCSS | 3390 * +----------------------------------------------------------------+ 3391 * 8 | MSS | HDRLEN | RSV | STA | TUCMD | DTYP | PAYLEN | 3392 * +----------------------------------------------------------------+ 3393 * 63 48 47 40 39 36 35 32 31 24 23 20 19 0 3394 * 3395 * Extended Data Descriptor (DTYP=0x1) 3396 * +----------------------------------------------------------------+ 3397 * 0 | Buffer Address [63:0] | 3398 * +----------------------------------------------------------------+ 3399 * 8 | VLAN tag | POPTS | Rsvd | Status | Command | DTYP | DTALEN | 3400 * +----------------------------------------------------------------+ 3401 * 63 48 47 40 39 36 35 32 31 24 23 20 19 0 3402 */ 3403 pr_info("Tc[desc] [Ce CoCsIpceCoS] [MssHlRSCm0Plen] [bi->dma ] leng ntw timestmp bi->skb\n"); 3404 pr_info("Td[desc] [address 63:0 ] [VlaPoRSCm1Dlen] [bi->dma ] leng ntw timestmp bi->skb\n"); 3405 3406 if (!netif_msg_tx_done(adapter)) 3407 goto rx_ring_summary; 3408 3409 for (i = 0; tx_ring->desc && (i < tx_ring->count); i++) { 3410 struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*tx_ring, i); 3411 struct e1000_tx_buffer *buffer_info = &tx_ring->buffer_info[i]; 3412 struct my_u { __le64 a; __le64 b; }; 3413 struct my_u *u = (struct my_u *)tx_desc; 3414 const char *type; 3415 3416 if (i == tx_ring->next_to_use && i == tx_ring->next_to_clean) 3417 type = "NTC/U"; 3418 else if (i == tx_ring->next_to_use) 3419 type = "NTU"; 3420 else if (i == tx_ring->next_to_clean) 3421 type = "NTC"; 3422 else 3423 type = ""; 3424 3425 pr_info("T%c[0x%03X] %016llX %016llX %016llX %04X %3X %016llX %p %s\n", 3426 ((le64_to_cpu(u->b) & (1<<20)) ? 'd' : 'c'), i, 3427 le64_to_cpu(u->a), le64_to_cpu(u->b), 3428 (u64)buffer_info->dma, buffer_info->length, 3429 buffer_info->next_to_watch, 3430 (u64)buffer_info->time_stamp, buffer_info->skb, type); 3431 } 3432 3433 rx_ring_summary: 3434 /* receive dump */ 3435 pr_info("\nRX Desc ring dump\n"); 3436 3437 /* Legacy Receive Descriptor Format 3438 * 3439 * +-----------------------------------------------------+ 3440 * | Buffer Address [63:0] | 3441 * +-----------------------------------------------------+ 3442 * | VLAN Tag | Errors | Status 0 | Packet csum | Length | 3443 * +-----------------------------------------------------+ 3444 * 63 48 47 40 39 32 31 16 15 0 3445 */ 3446 pr_info("R[desc] [address 63:0 ] [vl er S cks ln] [bi->dma ] [bi->skb]\n"); 3447 3448 if (!netif_msg_rx_status(adapter)) 3449 goto exit; 3450 3451 for (i = 0; rx_ring->desc && (i < rx_ring->count); i++) { 3452 struct e1000_rx_desc *rx_desc = E1000_RX_DESC(*rx_ring, i); 3453 struct e1000_rx_buffer *buffer_info = &rx_ring->buffer_info[i]; 3454 struct my_u { __le64 a; __le64 b; }; 3455 struct my_u *u = (struct my_u *)rx_desc; 3456 const char *type; 3457 3458 if (i == rx_ring->next_to_use) 3459 type = "NTU"; 3460 else if (i == rx_ring->next_to_clean) 3461 type = "NTC"; 3462 else 3463 type = ""; 3464 3465 pr_info("R[0x%03X] %016llX %016llX %016llX %p %s\n", 3466 i, le64_to_cpu(u->a), le64_to_cpu(u->b), 3467 (u64)buffer_info->dma, buffer_info->rxbuf.data, type); 3468 } /* for */ 3469 3470 /* dump the descriptor caches */ 3471 /* rx */ 3472 pr_info("Rx descriptor cache in 64bit format\n"); 3473 for (i = 0x6000; i <= 0x63FF ; i += 0x10) { 3474 pr_info("R%04X: %08X|%08X %08X|%08X\n", 3475 i, 3476 readl(adapter->hw.hw_addr + i+4), 3477 readl(adapter->hw.hw_addr + i), 3478 readl(adapter->hw.hw_addr + i+12), 3479 readl(adapter->hw.hw_addr + i+8)); 3480 } 3481 /* tx */ 3482 pr_info("Tx descriptor cache in 64bit format\n"); 3483 for (i = 0x7000; i <= 0x73FF ; i += 0x10) { 3484 pr_info("T%04X: %08X|%08X %08X|%08X\n", 3485 i, 3486 readl(adapter->hw.hw_addr + i+4), 3487 readl(adapter->hw.hw_addr + i), 3488 readl(adapter->hw.hw_addr + i+12), 3489 readl(adapter->hw.hw_addr + i+8)); 3490 } 3491 exit: 3492 return; 3493 } 3494 3495 /** 3496 * e1000_tx_timeout - Respond to a Tx Hang 3497 * @netdev: network interface device structure 3498 **/ 3499 static void e1000_tx_timeout(struct net_device *netdev, unsigned int txqueue) 3500 { 3501 struct e1000_adapter *adapter = netdev_priv(netdev); 3502 3503 /* Do the reset outside of interrupt context */ 3504 adapter->tx_timeout_count++; 3505 schedule_work(&adapter->reset_task); 3506 } 3507 3508 static void e1000_reset_task(struct work_struct *work) 3509 { 3510 struct e1000_adapter *adapter = 3511 container_of(work, struct e1000_adapter, reset_task); 3512 3513 e_err(drv, "Reset adapter\n"); 3514 e1000_reinit_locked(adapter); 3515 } 3516 3517 /** 3518 * e1000_change_mtu - Change the Maximum Transfer Unit 3519 * @netdev: network interface device structure 3520 * @new_mtu: new value for maximum frame size 3521 * 3522 * Returns 0 on success, negative on failure 3523 **/ 3524 static int e1000_change_mtu(struct net_device *netdev, int new_mtu) 3525 { 3526 struct e1000_adapter *adapter = netdev_priv(netdev); 3527 struct e1000_hw *hw = &adapter->hw; 3528 int max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN; 3529 3530 /* Adapter-specific max frame size limits. */ 3531 switch (hw->mac_type) { 3532 case e1000_undefined ... e1000_82542_rev2_1: 3533 if (max_frame > (ETH_FRAME_LEN + ETH_FCS_LEN)) { 3534 e_err(probe, "Jumbo Frames not supported.\n"); 3535 return -EINVAL; 3536 } 3537 break; 3538 default: 3539 /* Capable of supporting up to MAX_JUMBO_FRAME_SIZE limit. */ 3540 break; 3541 } 3542 3543 while (test_and_set_bit(__E1000_RESETTING, &adapter->flags)) 3544 msleep(1); 3545 /* e1000_down has a dependency on max_frame_size */ 3546 hw->max_frame_size = max_frame; 3547 if (netif_running(netdev)) { 3548 /* prevent buffers from being reallocated */ 3549 adapter->alloc_rx_buf = e1000_alloc_dummy_rx_buffers; 3550 e1000_down(adapter); 3551 } 3552 3553 /* NOTE: netdev_alloc_skb reserves 16 bytes, and typically NET_IP_ALIGN 3554 * means we reserve 2 more, this pushes us to allocate from the next 3555 * larger slab size. 3556 * i.e. RXBUFFER_2048 --> size-4096 slab 3557 * however with the new *_jumbo_rx* routines, jumbo receives will use 3558 * fragmented skbs 3559 */ 3560 3561 if (max_frame <= E1000_RXBUFFER_2048) 3562 adapter->rx_buffer_len = E1000_RXBUFFER_2048; 3563 else 3564 #if (PAGE_SIZE >= E1000_RXBUFFER_16384) 3565 adapter->rx_buffer_len = E1000_RXBUFFER_16384; 3566 #elif (PAGE_SIZE >= E1000_RXBUFFER_4096) 3567 adapter->rx_buffer_len = PAGE_SIZE; 3568 #endif 3569 3570 /* adjust allocation if LPE protects us, and we aren't using SBP */ 3571 if (!hw->tbi_compatibility_on && 3572 ((max_frame == (ETH_FRAME_LEN + ETH_FCS_LEN)) || 3573 (max_frame == MAXIMUM_ETHERNET_VLAN_SIZE))) 3574 adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE; 3575 3576 netdev_dbg(netdev, "changing MTU from %d to %d\n", 3577 netdev->mtu, new_mtu); 3578 netdev->mtu = new_mtu; 3579 3580 if (netif_running(netdev)) 3581 e1000_up(adapter); 3582 else 3583 e1000_reset(adapter); 3584 3585 clear_bit(__E1000_RESETTING, &adapter->flags); 3586 3587 return 0; 3588 } 3589 3590 /** 3591 * e1000_update_stats - Update the board statistics counters 3592 * @adapter: board private structure 3593 **/ 3594 void e1000_update_stats(struct e1000_adapter *adapter) 3595 { 3596 struct net_device *netdev = adapter->netdev; 3597 struct e1000_hw *hw = &adapter->hw; 3598 struct pci_dev *pdev = adapter->pdev; 3599 unsigned long flags; 3600 u16 phy_tmp; 3601 3602 #define PHY_IDLE_ERROR_COUNT_MASK 0x00FF 3603 3604 /* Prevent stats update while adapter is being reset, or if the pci 3605 * connection is down. 3606 */ 3607 if (adapter->link_speed == 0) 3608 return; 3609 if (pci_channel_offline(pdev)) 3610 return; 3611 3612 spin_lock_irqsave(&adapter->stats_lock, flags); 3613 3614 /* these counters are modified from e1000_tbi_adjust_stats, 3615 * called from the interrupt context, so they must only 3616 * be written while holding adapter->stats_lock 3617 */ 3618 3619 adapter->stats.crcerrs += er32(CRCERRS); 3620 adapter->stats.gprc += er32(GPRC); 3621 adapter->stats.gorcl += er32(GORCL); 3622 adapter->stats.gorch += er32(GORCH); 3623 adapter->stats.bprc += er32(BPRC); 3624 adapter->stats.mprc += er32(MPRC); 3625 adapter->stats.roc += er32(ROC); 3626 3627 adapter->stats.prc64 += er32(PRC64); 3628 adapter->stats.prc127 += er32(PRC127); 3629 adapter->stats.prc255 += er32(PRC255); 3630 adapter->stats.prc511 += er32(PRC511); 3631 adapter->stats.prc1023 += er32(PRC1023); 3632 adapter->stats.prc1522 += er32(PRC1522); 3633 3634 adapter->stats.symerrs += er32(SYMERRS); 3635 adapter->stats.mpc += er32(MPC); 3636 adapter->stats.scc += er32(SCC); 3637 adapter->stats.ecol += er32(ECOL); 3638 adapter->stats.mcc += er32(MCC); 3639 adapter->stats.latecol += er32(LATECOL); 3640 adapter->stats.dc += er32(DC); 3641 adapter->stats.sec += er32(SEC); 3642 adapter->stats.rlec += er32(RLEC); 3643 adapter->stats.xonrxc += er32(XONRXC); 3644 adapter->stats.xontxc += er32(XONTXC); 3645 adapter->stats.xoffrxc += er32(XOFFRXC); 3646 adapter->stats.xofftxc += er32(XOFFTXC); 3647 adapter->stats.fcruc += er32(FCRUC); 3648 adapter->stats.gptc += er32(GPTC); 3649 adapter->stats.gotcl += er32(GOTCL); 3650 adapter->stats.gotch += er32(GOTCH); 3651 adapter->stats.rnbc += er32(RNBC); 3652 adapter->stats.ruc += er32(RUC); 3653 adapter->stats.rfc += er32(RFC); 3654 adapter->stats.rjc += er32(RJC); 3655 adapter->stats.torl += er32(TORL); 3656 adapter->stats.torh += er32(TORH); 3657 adapter->stats.totl += er32(TOTL); 3658 adapter->stats.toth += er32(TOTH); 3659 adapter->stats.tpr += er32(TPR); 3660 3661 adapter->stats.ptc64 += er32(PTC64); 3662 adapter->stats.ptc127 += er32(PTC127); 3663 adapter->stats.ptc255 += er32(PTC255); 3664 adapter->stats.ptc511 += er32(PTC511); 3665 adapter->stats.ptc1023 += er32(PTC1023); 3666 adapter->stats.ptc1522 += er32(PTC1522); 3667 3668 adapter->stats.mptc += er32(MPTC); 3669 adapter->stats.bptc += er32(BPTC); 3670 3671 /* used for adaptive IFS */ 3672 3673 hw->tx_packet_delta = er32(TPT); 3674 adapter->stats.tpt += hw->tx_packet_delta; 3675 hw->collision_delta = er32(COLC); 3676 adapter->stats.colc += hw->collision_delta; 3677 3678 if (hw->mac_type >= e1000_82543) { 3679 adapter->stats.algnerrc += er32(ALGNERRC); 3680 adapter->stats.rxerrc += er32(RXERRC); 3681 adapter->stats.tncrs += er32(TNCRS); 3682 adapter->stats.cexterr += er32(CEXTERR); 3683 adapter->stats.tsctc += er32(TSCTC); 3684 adapter->stats.tsctfc += er32(TSCTFC); 3685 } 3686 3687 /* Fill out the OS statistics structure */ 3688 netdev->stats.multicast = adapter->stats.mprc; 3689 netdev->stats.collisions = adapter->stats.colc; 3690 3691 /* Rx Errors */ 3692 3693 /* RLEC on some newer hardware can be incorrect so build 3694 * our own version based on RUC and ROC 3695 */ 3696 netdev->stats.rx_errors = adapter->stats.rxerrc + 3697 adapter->stats.crcerrs + adapter->stats.algnerrc + 3698 adapter->stats.ruc + adapter->stats.roc + 3699 adapter->stats.cexterr; 3700 adapter->stats.rlerrc = adapter->stats.ruc + adapter->stats.roc; 3701 netdev->stats.rx_length_errors = adapter->stats.rlerrc; 3702 netdev->stats.rx_crc_errors = adapter->stats.crcerrs; 3703 netdev->stats.rx_frame_errors = adapter->stats.algnerrc; 3704 netdev->stats.rx_missed_errors = adapter->stats.mpc; 3705 3706 /* Tx Errors */ 3707 adapter->stats.txerrc = adapter->stats.ecol + adapter->stats.latecol; 3708 netdev->stats.tx_errors = adapter->stats.txerrc; 3709 netdev->stats.tx_aborted_errors = adapter->stats.ecol; 3710 netdev->stats.tx_window_errors = adapter->stats.latecol; 3711 netdev->stats.tx_carrier_errors = adapter->stats.tncrs; 3712 if (hw->bad_tx_carr_stats_fd && 3713 adapter->link_duplex == FULL_DUPLEX) { 3714 netdev->stats.tx_carrier_errors = 0; 3715 adapter->stats.tncrs = 0; 3716 } 3717 3718 /* Tx Dropped needs to be maintained elsewhere */ 3719 3720 /* Phy Stats */ 3721 if (hw->media_type == e1000_media_type_copper) { 3722 if ((adapter->link_speed == SPEED_1000) && 3723 (!e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_tmp))) { 3724 phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK; 3725 adapter->phy_stats.idle_errors += phy_tmp; 3726 } 3727 3728 if ((hw->mac_type <= e1000_82546) && 3729 (hw->phy_type == e1000_phy_m88) && 3730 !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp)) 3731 adapter->phy_stats.receive_errors += phy_tmp; 3732 } 3733 3734 /* Management Stats */ 3735 if (hw->has_smbus) { 3736 adapter->stats.mgptc += er32(MGTPTC); 3737 adapter->stats.mgprc += er32(MGTPRC); 3738 adapter->stats.mgpdc += er32(MGTPDC); 3739 } 3740 3741 spin_unlock_irqrestore(&adapter->stats_lock, flags); 3742 } 3743 3744 /** 3745 * e1000_intr - Interrupt Handler 3746 * @irq: interrupt number 3747 * @data: pointer to a network interface device structure 3748 **/ 3749 static irqreturn_t e1000_intr(int irq, void *data) 3750 { 3751 struct net_device *netdev = data; 3752 struct e1000_adapter *adapter = netdev_priv(netdev); 3753 struct e1000_hw *hw = &adapter->hw; 3754 u32 icr = er32(ICR); 3755 3756 if (unlikely((!icr))) 3757 return IRQ_NONE; /* Not our interrupt */ 3758 3759 /* we might have caused the interrupt, but the above 3760 * read cleared it, and just in case the driver is 3761 * down there is nothing to do so return handled 3762 */ 3763 if (unlikely(test_bit(__E1000_DOWN, &adapter->flags))) 3764 return IRQ_HANDLED; 3765 3766 if (unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) { 3767 hw->get_link_status = 1; 3768 /* guard against interrupt when we're going down */ 3769 if (!test_bit(__E1000_DOWN, &adapter->flags)) 3770 schedule_delayed_work(&adapter->watchdog_task, 1); 3771 } 3772 3773 /* disable interrupts, without the synchronize_irq bit */ 3774 ew32(IMC, ~0); 3775 E1000_WRITE_FLUSH(); 3776 3777 if (likely(napi_schedule_prep(&adapter->napi))) { 3778 adapter->total_tx_bytes = 0; 3779 adapter->total_tx_packets = 0; 3780 adapter->total_rx_bytes = 0; 3781 adapter->total_rx_packets = 0; 3782 __napi_schedule(&adapter->napi); 3783 } else { 3784 /* this really should not happen! if it does it is basically a 3785 * bug, but not a hard error, so enable ints and continue 3786 */ 3787 if (!test_bit(__E1000_DOWN, &adapter->flags)) 3788 e1000_irq_enable(adapter); 3789 } 3790 3791 return IRQ_HANDLED; 3792 } 3793 3794 /** 3795 * e1000_clean - NAPI Rx polling callback 3796 * @adapter: board private structure 3797 **/ 3798 static int e1000_clean(struct napi_struct *napi, int budget) 3799 { 3800 struct e1000_adapter *adapter = container_of(napi, struct e1000_adapter, 3801 napi); 3802 int tx_clean_complete = 0, work_done = 0; 3803 3804 tx_clean_complete = e1000_clean_tx_irq(adapter, &adapter->tx_ring[0]); 3805 3806 adapter->clean_rx(adapter, &adapter->rx_ring[0], &work_done, budget); 3807 3808 if (!tx_clean_complete || work_done == budget) 3809 return budget; 3810 3811 /* Exit the polling mode, but don't re-enable interrupts if stack might 3812 * poll us due to busy-polling 3813 */ 3814 if (likely(napi_complete_done(napi, work_done))) { 3815 if (likely(adapter->itr_setting & 3)) 3816 e1000_set_itr(adapter); 3817 if (!test_bit(__E1000_DOWN, &adapter->flags)) 3818 e1000_irq_enable(adapter); 3819 } 3820 3821 return work_done; 3822 } 3823 3824 /** 3825 * e1000_clean_tx_irq - Reclaim resources after transmit completes 3826 * @adapter: board private structure 3827 **/ 3828 static bool e1000_clean_tx_irq(struct e1000_adapter *adapter, 3829 struct e1000_tx_ring *tx_ring) 3830 { 3831 struct e1000_hw *hw = &adapter->hw; 3832 struct net_device *netdev = adapter->netdev; 3833 struct e1000_tx_desc *tx_desc, *eop_desc; 3834 struct e1000_tx_buffer *buffer_info; 3835 unsigned int i, eop; 3836 unsigned int count = 0; 3837 unsigned int total_tx_bytes = 0, total_tx_packets = 0; 3838 unsigned int bytes_compl = 0, pkts_compl = 0; 3839 3840 i = tx_ring->next_to_clean; 3841 eop = tx_ring->buffer_info[i].next_to_watch; 3842 eop_desc = E1000_TX_DESC(*tx_ring, eop); 3843 3844 while ((eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) && 3845 (count < tx_ring->count)) { 3846 bool cleaned = false; 3847 dma_rmb(); /* read buffer_info after eop_desc */ 3848 for ( ; !cleaned; count++) { 3849 tx_desc = E1000_TX_DESC(*tx_ring, i); 3850 buffer_info = &tx_ring->buffer_info[i]; 3851 cleaned = (i == eop); 3852 3853 if (cleaned) { 3854 total_tx_packets += buffer_info->segs; 3855 total_tx_bytes += buffer_info->bytecount; 3856 if (buffer_info->skb) { 3857 bytes_compl += buffer_info->skb->len; 3858 pkts_compl++; 3859 } 3860 3861 } 3862 e1000_unmap_and_free_tx_resource(adapter, buffer_info); 3863 tx_desc->upper.data = 0; 3864 3865 if (unlikely(++i == tx_ring->count)) 3866 i = 0; 3867 } 3868 3869 eop = tx_ring->buffer_info[i].next_to_watch; 3870 eop_desc = E1000_TX_DESC(*tx_ring, eop); 3871 } 3872 3873 /* Synchronize with E1000_DESC_UNUSED called from e1000_xmit_frame, 3874 * which will reuse the cleaned buffers. 3875 */ 3876 smp_store_release(&tx_ring->next_to_clean, i); 3877 3878 netdev_completed_queue(netdev, pkts_compl, bytes_compl); 3879 3880 #define TX_WAKE_THRESHOLD 32 3881 if (unlikely(count && netif_carrier_ok(netdev) && 3882 E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) { 3883 /* Make sure that anybody stopping the queue after this 3884 * sees the new next_to_clean. 3885 */ 3886 smp_mb(); 3887 3888 if (netif_queue_stopped(netdev) && 3889 !(test_bit(__E1000_DOWN, &adapter->flags))) { 3890 netif_wake_queue(netdev); 3891 ++adapter->restart_queue; 3892 } 3893 } 3894 3895 if (adapter->detect_tx_hung) { 3896 /* Detect a transmit hang in hardware, this serializes the 3897 * check with the clearing of time_stamp and movement of i 3898 */ 3899 adapter->detect_tx_hung = false; 3900 if (tx_ring->buffer_info[eop].time_stamp && 3901 time_after(jiffies, tx_ring->buffer_info[eop].time_stamp + 3902 (adapter->tx_timeout_factor * HZ)) && 3903 !(er32(STATUS) & E1000_STATUS_TXOFF)) { 3904 3905 /* detected Tx unit hang */ 3906 e_err(drv, "Detected Tx Unit Hang\n" 3907 " Tx Queue <%lu>\n" 3908 " TDH <%x>\n" 3909 " TDT <%x>\n" 3910 " next_to_use <%x>\n" 3911 " next_to_clean <%x>\n" 3912 "buffer_info[next_to_clean]\n" 3913 " time_stamp <%lx>\n" 3914 " next_to_watch <%x>\n" 3915 " jiffies <%lx>\n" 3916 " next_to_watch.status <%x>\n", 3917 (unsigned long)(tx_ring - adapter->tx_ring), 3918 readl(hw->hw_addr + tx_ring->tdh), 3919 readl(hw->hw_addr + tx_ring->tdt), 3920 tx_ring->next_to_use, 3921 tx_ring->next_to_clean, 3922 tx_ring->buffer_info[eop].time_stamp, 3923 eop, 3924 jiffies, 3925 eop_desc->upper.fields.status); 3926 e1000_dump(adapter); 3927 netif_stop_queue(netdev); 3928 } 3929 } 3930 adapter->total_tx_bytes += total_tx_bytes; 3931 adapter->total_tx_packets += total_tx_packets; 3932 netdev->stats.tx_bytes += total_tx_bytes; 3933 netdev->stats.tx_packets += total_tx_packets; 3934 return count < tx_ring->count; 3935 } 3936 3937 /** 3938 * e1000_rx_checksum - Receive Checksum Offload for 82543 3939 * @adapter: board private structure 3940 * @status_err: receive descriptor status and error fields 3941 * @csum: receive descriptor csum field 3942 * @sk_buff: socket buffer with received data 3943 **/ 3944 static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err, 3945 u32 csum, struct sk_buff *skb) 3946 { 3947 struct e1000_hw *hw = &adapter->hw; 3948 u16 status = (u16)status_err; 3949 u8 errors = (u8)(status_err >> 24); 3950 3951 skb_checksum_none_assert(skb); 3952 3953 /* 82543 or newer only */ 3954 if (unlikely(hw->mac_type < e1000_82543)) 3955 return; 3956 /* Ignore Checksum bit is set */ 3957 if (unlikely(status & E1000_RXD_STAT_IXSM)) 3958 return; 3959 /* TCP/UDP checksum error bit is set */ 3960 if (unlikely(errors & E1000_RXD_ERR_TCPE)) { 3961 /* let the stack verify checksum errors */ 3962 adapter->hw_csum_err++; 3963 return; 3964 } 3965 /* TCP/UDP Checksum has not been calculated */ 3966 if (!(status & E1000_RXD_STAT_TCPCS)) 3967 return; 3968 3969 /* It must be a TCP or UDP packet with a valid checksum */ 3970 if (likely(status & E1000_RXD_STAT_TCPCS)) { 3971 /* TCP checksum is good */ 3972 skb->ip_summed = CHECKSUM_UNNECESSARY; 3973 } 3974 adapter->hw_csum_good++; 3975 } 3976 3977 /** 3978 * e1000_consume_page - helper function for jumbo Rx path 3979 **/ 3980 static void e1000_consume_page(struct e1000_rx_buffer *bi, struct sk_buff *skb, 3981 u16 length) 3982 { 3983 bi->rxbuf.page = NULL; 3984 skb->len += length; 3985 skb->data_len += length; 3986 skb->truesize += PAGE_SIZE; 3987 } 3988 3989 /** 3990 * e1000_receive_skb - helper function to handle rx indications 3991 * @adapter: board private structure 3992 * @status: descriptor status field as written by hardware 3993 * @vlan: descriptor vlan field as written by hardware (no le/be conversion) 3994 * @skb: pointer to sk_buff to be indicated to stack 3995 */ 3996 static void e1000_receive_skb(struct e1000_adapter *adapter, u8 status, 3997 __le16 vlan, struct sk_buff *skb) 3998 { 3999 skb->protocol = eth_type_trans(skb, adapter->netdev); 4000 4001 if (status & E1000_RXD_STAT_VP) { 4002 u16 vid = le16_to_cpu(vlan) & E1000_RXD_SPC_VLAN_MASK; 4003 4004 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid); 4005 } 4006 napi_gro_receive(&adapter->napi, skb); 4007 } 4008 4009 /** 4010 * e1000_tbi_adjust_stats 4011 * @hw: Struct containing variables accessed by shared code 4012 * @frame_len: The length of the frame in question 4013 * @mac_addr: The Ethernet destination address of the frame in question 4014 * 4015 * Adjusts the statistic counters when a frame is accepted by TBI_ACCEPT 4016 */ 4017 static void e1000_tbi_adjust_stats(struct e1000_hw *hw, 4018 struct e1000_hw_stats *stats, 4019 u32 frame_len, const u8 *mac_addr) 4020 { 4021 u64 carry_bit; 4022 4023 /* First adjust the frame length. */ 4024 frame_len--; 4025 /* We need to adjust the statistics counters, since the hardware 4026 * counters overcount this packet as a CRC error and undercount 4027 * the packet as a good packet 4028 */ 4029 /* This packet should not be counted as a CRC error. */ 4030 stats->crcerrs--; 4031 /* This packet does count as a Good Packet Received. */ 4032 stats->gprc++; 4033 4034 /* Adjust the Good Octets received counters */ 4035 carry_bit = 0x80000000 & stats->gorcl; 4036 stats->gorcl += frame_len; 4037 /* If the high bit of Gorcl (the low 32 bits of the Good Octets 4038 * Received Count) was one before the addition, 4039 * AND it is zero after, then we lost the carry out, 4040 * need to add one to Gorch (Good Octets Received Count High). 4041 * This could be simplified if all environments supported 4042 * 64-bit integers. 4043 */ 4044 if (carry_bit && ((stats->gorcl & 0x80000000) == 0)) 4045 stats->gorch++; 4046 /* Is this a broadcast or multicast? Check broadcast first, 4047 * since the test for a multicast frame will test positive on 4048 * a broadcast frame. 4049 */ 4050 if (is_broadcast_ether_addr(mac_addr)) 4051 stats->bprc++; 4052 else if (is_multicast_ether_addr(mac_addr)) 4053 stats->mprc++; 4054 4055 if (frame_len == hw->max_frame_size) { 4056 /* In this case, the hardware has overcounted the number of 4057 * oversize frames. 4058 */ 4059 if (stats->roc > 0) 4060 stats->roc--; 4061 } 4062 4063 /* Adjust the bin counters when the extra byte put the frame in the 4064 * wrong bin. Remember that the frame_len was adjusted above. 4065 */ 4066 if (frame_len == 64) { 4067 stats->prc64++; 4068 stats->prc127--; 4069 } else if (frame_len == 127) { 4070 stats->prc127++; 4071 stats->prc255--; 4072 } else if (frame_len == 255) { 4073 stats->prc255++; 4074 stats->prc511--; 4075 } else if (frame_len == 511) { 4076 stats->prc511++; 4077 stats->prc1023--; 4078 } else if (frame_len == 1023) { 4079 stats->prc1023++; 4080 stats->prc1522--; 4081 } else if (frame_len == 1522) { 4082 stats->prc1522++; 4083 } 4084 } 4085 4086 static bool e1000_tbi_should_accept(struct e1000_adapter *adapter, 4087 u8 status, u8 errors, 4088 u32 length, const u8 *data) 4089 { 4090 struct e1000_hw *hw = &adapter->hw; 4091 u8 last_byte = *(data + length - 1); 4092 4093 if (TBI_ACCEPT(hw, status, errors, length, last_byte)) { 4094 unsigned long irq_flags; 4095 4096 spin_lock_irqsave(&adapter->stats_lock, irq_flags); 4097 e1000_tbi_adjust_stats(hw, &adapter->stats, length, data); 4098 spin_unlock_irqrestore(&adapter->stats_lock, irq_flags); 4099 4100 return true; 4101 } 4102 4103 return false; 4104 } 4105 4106 static struct sk_buff *e1000_alloc_rx_skb(struct e1000_adapter *adapter, 4107 unsigned int bufsz) 4108 { 4109 struct sk_buff *skb = napi_alloc_skb(&adapter->napi, bufsz); 4110 4111 if (unlikely(!skb)) 4112 adapter->alloc_rx_buff_failed++; 4113 return skb; 4114 } 4115 4116 /** 4117 * e1000_clean_jumbo_rx_irq - Send received data up the network stack; legacy 4118 * @adapter: board private structure 4119 * @rx_ring: ring to clean 4120 * @work_done: amount of napi work completed this call 4121 * @work_to_do: max amount of work allowed for this call to do 4122 * 4123 * the return value indicates whether actual cleaning was done, there 4124 * is no guarantee that everything was cleaned 4125 */ 4126 static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter, 4127 struct e1000_rx_ring *rx_ring, 4128 int *work_done, int work_to_do) 4129 { 4130 struct net_device *netdev = adapter->netdev; 4131 struct pci_dev *pdev = adapter->pdev; 4132 struct e1000_rx_desc *rx_desc, *next_rxd; 4133 struct e1000_rx_buffer *buffer_info, *next_buffer; 4134 u32 length; 4135 unsigned int i; 4136 int cleaned_count = 0; 4137 bool cleaned = false; 4138 unsigned int total_rx_bytes = 0, total_rx_packets = 0; 4139 4140 i = rx_ring->next_to_clean; 4141 rx_desc = E1000_RX_DESC(*rx_ring, i); 4142 buffer_info = &rx_ring->buffer_info[i]; 4143 4144 while (rx_desc->status & E1000_RXD_STAT_DD) { 4145 struct sk_buff *skb; 4146 u8 status; 4147 4148 if (*work_done >= work_to_do) 4149 break; 4150 (*work_done)++; 4151 dma_rmb(); /* read descriptor and rx_buffer_info after status DD */ 4152 4153 status = rx_desc->status; 4154 4155 if (++i == rx_ring->count) 4156 i = 0; 4157 4158 next_rxd = E1000_RX_DESC(*rx_ring, i); 4159 prefetch(next_rxd); 4160 4161 next_buffer = &rx_ring->buffer_info[i]; 4162 4163 cleaned = true; 4164 cleaned_count++; 4165 dma_unmap_page(&pdev->dev, buffer_info->dma, 4166 adapter->rx_buffer_len, DMA_FROM_DEVICE); 4167 buffer_info->dma = 0; 4168 4169 length = le16_to_cpu(rx_desc->length); 4170 4171 /* errors is only valid for DD + EOP descriptors */ 4172 if (unlikely((status & E1000_RXD_STAT_EOP) && 4173 (rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK))) { 4174 u8 *mapped = page_address(buffer_info->rxbuf.page); 4175 4176 if (e1000_tbi_should_accept(adapter, status, 4177 rx_desc->errors, 4178 length, mapped)) { 4179 length--; 4180 } else if (netdev->features & NETIF_F_RXALL) { 4181 goto process_skb; 4182 } else { 4183 /* an error means any chain goes out the window 4184 * too 4185 */ 4186 dev_kfree_skb(rx_ring->rx_skb_top); 4187 rx_ring->rx_skb_top = NULL; 4188 goto next_desc; 4189 } 4190 } 4191 4192 #define rxtop rx_ring->rx_skb_top 4193 process_skb: 4194 if (!(status & E1000_RXD_STAT_EOP)) { 4195 /* this descriptor is only the beginning (or middle) */ 4196 if (!rxtop) { 4197 /* this is the beginning of a chain */ 4198 rxtop = napi_get_frags(&adapter->napi); 4199 if (!rxtop) 4200 break; 4201 4202 skb_fill_page_desc(rxtop, 0, 4203 buffer_info->rxbuf.page, 4204 0, length); 4205 } else { 4206 /* this is the middle of a chain */ 4207 skb_fill_page_desc(rxtop, 4208 skb_shinfo(rxtop)->nr_frags, 4209 buffer_info->rxbuf.page, 0, length); 4210 } 4211 e1000_consume_page(buffer_info, rxtop, length); 4212 goto next_desc; 4213 } else { 4214 if (rxtop) { 4215 /* end of the chain */ 4216 skb_fill_page_desc(rxtop, 4217 skb_shinfo(rxtop)->nr_frags, 4218 buffer_info->rxbuf.page, 0, length); 4219 skb = rxtop; 4220 rxtop = NULL; 4221 e1000_consume_page(buffer_info, skb, length); 4222 } else { 4223 struct page *p; 4224 /* no chain, got EOP, this buf is the packet 4225 * copybreak to save the put_page/alloc_page 4226 */ 4227 p = buffer_info->rxbuf.page; 4228 if (length <= copybreak) { 4229 u8 *vaddr; 4230 4231 if (likely(!(netdev->features & NETIF_F_RXFCS))) 4232 length -= 4; 4233 skb = e1000_alloc_rx_skb(adapter, 4234 length); 4235 if (!skb) 4236 break; 4237 4238 vaddr = kmap_atomic(p); 4239 memcpy(skb_tail_pointer(skb), vaddr, 4240 length); 4241 kunmap_atomic(vaddr); 4242 /* re-use the page, so don't erase 4243 * buffer_info->rxbuf.page 4244 */ 4245 skb_put(skb, length); 4246 e1000_rx_checksum(adapter, 4247 status | rx_desc->errors << 24, 4248 le16_to_cpu(rx_desc->csum), skb); 4249 4250 total_rx_bytes += skb->len; 4251 total_rx_packets++; 4252 4253 e1000_receive_skb(adapter, status, 4254 rx_desc->special, skb); 4255 goto next_desc; 4256 } else { 4257 skb = napi_get_frags(&adapter->napi); 4258 if (!skb) { 4259 adapter->alloc_rx_buff_failed++; 4260 break; 4261 } 4262 skb_fill_page_desc(skb, 0, p, 0, 4263 length); 4264 e1000_consume_page(buffer_info, skb, 4265 length); 4266 } 4267 } 4268 } 4269 4270 /* Receive Checksum Offload XXX recompute due to CRC strip? */ 4271 e1000_rx_checksum(adapter, 4272 (u32)(status) | 4273 ((u32)(rx_desc->errors) << 24), 4274 le16_to_cpu(rx_desc->csum), skb); 4275 4276 total_rx_bytes += (skb->len - 4); /* don't count FCS */ 4277 if (likely(!(netdev->features & NETIF_F_RXFCS))) 4278 pskb_trim(skb, skb->len - 4); 4279 total_rx_packets++; 4280 4281 if (status & E1000_RXD_STAT_VP) { 4282 __le16 vlan = rx_desc->special; 4283 u16 vid = le16_to_cpu(vlan) & E1000_RXD_SPC_VLAN_MASK; 4284 4285 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid); 4286 } 4287 4288 napi_gro_frags(&adapter->napi); 4289 4290 next_desc: 4291 rx_desc->status = 0; 4292 4293 /* return some buffers to hardware, one at a time is too slow */ 4294 if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) { 4295 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); 4296 cleaned_count = 0; 4297 } 4298 4299 /* use prefetched values */ 4300 rx_desc = next_rxd; 4301 buffer_info = next_buffer; 4302 } 4303 rx_ring->next_to_clean = i; 4304 4305 cleaned_count = E1000_DESC_UNUSED(rx_ring); 4306 if (cleaned_count) 4307 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); 4308 4309 adapter->total_rx_packets += total_rx_packets; 4310 adapter->total_rx_bytes += total_rx_bytes; 4311 netdev->stats.rx_bytes += total_rx_bytes; 4312 netdev->stats.rx_packets += total_rx_packets; 4313 return cleaned; 4314 } 4315 4316 /* this should improve performance for small packets with large amounts 4317 * of reassembly being done in the stack 4318 */ 4319 static struct sk_buff *e1000_copybreak(struct e1000_adapter *adapter, 4320 struct e1000_rx_buffer *buffer_info, 4321 u32 length, const void *data) 4322 { 4323 struct sk_buff *skb; 4324 4325 if (length > copybreak) 4326 return NULL; 4327 4328 skb = e1000_alloc_rx_skb(adapter, length); 4329 if (!skb) 4330 return NULL; 4331 4332 dma_sync_single_for_cpu(&adapter->pdev->dev, buffer_info->dma, 4333 length, DMA_FROM_DEVICE); 4334 4335 skb_put_data(skb, data, length); 4336 4337 return skb; 4338 } 4339 4340 /** 4341 * e1000_clean_rx_irq - Send received data up the network stack; legacy 4342 * @adapter: board private structure 4343 * @rx_ring: ring to clean 4344 * @work_done: amount of napi work completed this call 4345 * @work_to_do: max amount of work allowed for this call to do 4346 */ 4347 static bool e1000_clean_rx_irq(struct e1000_adapter *adapter, 4348 struct e1000_rx_ring *rx_ring, 4349 int *work_done, int work_to_do) 4350 { 4351 struct net_device *netdev = adapter->netdev; 4352 struct pci_dev *pdev = adapter->pdev; 4353 struct e1000_rx_desc *rx_desc, *next_rxd; 4354 struct e1000_rx_buffer *buffer_info, *next_buffer; 4355 u32 length; 4356 unsigned int i; 4357 int cleaned_count = 0; 4358 bool cleaned = false; 4359 unsigned int total_rx_bytes = 0, total_rx_packets = 0; 4360 4361 i = rx_ring->next_to_clean; 4362 rx_desc = E1000_RX_DESC(*rx_ring, i); 4363 buffer_info = &rx_ring->buffer_info[i]; 4364 4365 while (rx_desc->status & E1000_RXD_STAT_DD) { 4366 struct sk_buff *skb; 4367 u8 *data; 4368 u8 status; 4369 4370 if (*work_done >= work_to_do) 4371 break; 4372 (*work_done)++; 4373 dma_rmb(); /* read descriptor and rx_buffer_info after status DD */ 4374 4375 status = rx_desc->status; 4376 length = le16_to_cpu(rx_desc->length); 4377 4378 data = buffer_info->rxbuf.data; 4379 prefetch(data); 4380 skb = e1000_copybreak(adapter, buffer_info, length, data); 4381 if (!skb) { 4382 unsigned int frag_len = e1000_frag_len(adapter); 4383 4384 skb = build_skb(data - E1000_HEADROOM, frag_len); 4385 if (!skb) { 4386 adapter->alloc_rx_buff_failed++; 4387 break; 4388 } 4389 4390 skb_reserve(skb, E1000_HEADROOM); 4391 dma_unmap_single(&pdev->dev, buffer_info->dma, 4392 adapter->rx_buffer_len, 4393 DMA_FROM_DEVICE); 4394 buffer_info->dma = 0; 4395 buffer_info->rxbuf.data = NULL; 4396 } 4397 4398 if (++i == rx_ring->count) 4399 i = 0; 4400 4401 next_rxd = E1000_RX_DESC(*rx_ring, i); 4402 prefetch(next_rxd); 4403 4404 next_buffer = &rx_ring->buffer_info[i]; 4405 4406 cleaned = true; 4407 cleaned_count++; 4408 4409 /* !EOP means multiple descriptors were used to store a single 4410 * packet, if thats the case we need to toss it. In fact, we 4411 * to toss every packet with the EOP bit clear and the next 4412 * frame that _does_ have the EOP bit set, as it is by 4413 * definition only a frame fragment 4414 */ 4415 if (unlikely(!(status & E1000_RXD_STAT_EOP))) 4416 adapter->discarding = true; 4417 4418 if (adapter->discarding) { 4419 /* All receives must fit into a single buffer */ 4420 netdev_dbg(netdev, "Receive packet consumed multiple buffers\n"); 4421 dev_kfree_skb(skb); 4422 if (status & E1000_RXD_STAT_EOP) 4423 adapter->discarding = false; 4424 goto next_desc; 4425 } 4426 4427 if (unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) { 4428 if (e1000_tbi_should_accept(adapter, status, 4429 rx_desc->errors, 4430 length, data)) { 4431 length--; 4432 } else if (netdev->features & NETIF_F_RXALL) { 4433 goto process_skb; 4434 } else { 4435 dev_kfree_skb(skb); 4436 goto next_desc; 4437 } 4438 } 4439 4440 process_skb: 4441 total_rx_bytes += (length - 4); /* don't count FCS */ 4442 total_rx_packets++; 4443 4444 if (likely(!(netdev->features & NETIF_F_RXFCS))) 4445 /* adjust length to remove Ethernet CRC, this must be 4446 * done after the TBI_ACCEPT workaround above 4447 */ 4448 length -= 4; 4449 4450 if (buffer_info->rxbuf.data == NULL) 4451 skb_put(skb, length); 4452 else /* copybreak skb */ 4453 skb_trim(skb, length); 4454 4455 /* Receive Checksum Offload */ 4456 e1000_rx_checksum(adapter, 4457 (u32)(status) | 4458 ((u32)(rx_desc->errors) << 24), 4459 le16_to_cpu(rx_desc->csum), skb); 4460 4461 e1000_receive_skb(adapter, status, rx_desc->special, skb); 4462 4463 next_desc: 4464 rx_desc->status = 0; 4465 4466 /* return some buffers to hardware, one at a time is too slow */ 4467 if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) { 4468 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); 4469 cleaned_count = 0; 4470 } 4471 4472 /* use prefetched values */ 4473 rx_desc = next_rxd; 4474 buffer_info = next_buffer; 4475 } 4476 rx_ring->next_to_clean = i; 4477 4478 cleaned_count = E1000_DESC_UNUSED(rx_ring); 4479 if (cleaned_count) 4480 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); 4481 4482 adapter->total_rx_packets += total_rx_packets; 4483 adapter->total_rx_bytes += total_rx_bytes; 4484 netdev->stats.rx_bytes += total_rx_bytes; 4485 netdev->stats.rx_packets += total_rx_packets; 4486 return cleaned; 4487 } 4488 4489 /** 4490 * e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers 4491 * @adapter: address of board private structure 4492 * @rx_ring: pointer to receive ring structure 4493 * @cleaned_count: number of buffers to allocate this pass 4494 **/ 4495 static void 4496 e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter, 4497 struct e1000_rx_ring *rx_ring, int cleaned_count) 4498 { 4499 struct pci_dev *pdev = adapter->pdev; 4500 struct e1000_rx_desc *rx_desc; 4501 struct e1000_rx_buffer *buffer_info; 4502 unsigned int i; 4503 4504 i = rx_ring->next_to_use; 4505 buffer_info = &rx_ring->buffer_info[i]; 4506 4507 while (cleaned_count--) { 4508 /* allocate a new page if necessary */ 4509 if (!buffer_info->rxbuf.page) { 4510 buffer_info->rxbuf.page = alloc_page(GFP_ATOMIC); 4511 if (unlikely(!buffer_info->rxbuf.page)) { 4512 adapter->alloc_rx_buff_failed++; 4513 break; 4514 } 4515 } 4516 4517 if (!buffer_info->dma) { 4518 buffer_info->dma = dma_map_page(&pdev->dev, 4519 buffer_info->rxbuf.page, 0, 4520 adapter->rx_buffer_len, 4521 DMA_FROM_DEVICE); 4522 if (dma_mapping_error(&pdev->dev, buffer_info->dma)) { 4523 put_page(buffer_info->rxbuf.page); 4524 buffer_info->rxbuf.page = NULL; 4525 buffer_info->dma = 0; 4526 adapter->alloc_rx_buff_failed++; 4527 break; 4528 } 4529 } 4530 4531 rx_desc = E1000_RX_DESC(*rx_ring, i); 4532 rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma); 4533 4534 if (unlikely(++i == rx_ring->count)) 4535 i = 0; 4536 buffer_info = &rx_ring->buffer_info[i]; 4537 } 4538 4539 if (likely(rx_ring->next_to_use != i)) { 4540 rx_ring->next_to_use = i; 4541 if (unlikely(i-- == 0)) 4542 i = (rx_ring->count - 1); 4543 4544 /* Force memory writes to complete before letting h/w 4545 * know there are new descriptors to fetch. (Only 4546 * applicable for weak-ordered memory model archs, 4547 * such as IA-64). 4548 */ 4549 dma_wmb(); 4550 writel(i, adapter->hw.hw_addr + rx_ring->rdt); 4551 } 4552 } 4553 4554 /** 4555 * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended 4556 * @adapter: address of board private structure 4557 **/ 4558 static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter, 4559 struct e1000_rx_ring *rx_ring, 4560 int cleaned_count) 4561 { 4562 struct e1000_hw *hw = &adapter->hw; 4563 struct pci_dev *pdev = adapter->pdev; 4564 struct e1000_rx_desc *rx_desc; 4565 struct e1000_rx_buffer *buffer_info; 4566 unsigned int i; 4567 unsigned int bufsz = adapter->rx_buffer_len; 4568 4569 i = rx_ring->next_to_use; 4570 buffer_info = &rx_ring->buffer_info[i]; 4571 4572 while (cleaned_count--) { 4573 void *data; 4574 4575 if (buffer_info->rxbuf.data) 4576 goto skip; 4577 4578 data = e1000_alloc_frag(adapter); 4579 if (!data) { 4580 /* Better luck next round */ 4581 adapter->alloc_rx_buff_failed++; 4582 break; 4583 } 4584 4585 /* Fix for errata 23, can't cross 64kB boundary */ 4586 if (!e1000_check_64k_bound(adapter, data, bufsz)) { 4587 void *olddata = data; 4588 e_err(rx_err, "skb align check failed: %u bytes at " 4589 "%p\n", bufsz, data); 4590 /* Try again, without freeing the previous */ 4591 data = e1000_alloc_frag(adapter); 4592 /* Failed allocation, critical failure */ 4593 if (!data) { 4594 skb_free_frag(olddata); 4595 adapter->alloc_rx_buff_failed++; 4596 break; 4597 } 4598 4599 if (!e1000_check_64k_bound(adapter, data, bufsz)) { 4600 /* give up */ 4601 skb_free_frag(data); 4602 skb_free_frag(olddata); 4603 adapter->alloc_rx_buff_failed++; 4604 break; 4605 } 4606 4607 /* Use new allocation */ 4608 skb_free_frag(olddata); 4609 } 4610 buffer_info->dma = dma_map_single(&pdev->dev, 4611 data, 4612 adapter->rx_buffer_len, 4613 DMA_FROM_DEVICE); 4614 if (dma_mapping_error(&pdev->dev, buffer_info->dma)) { 4615 skb_free_frag(data); 4616 buffer_info->dma = 0; 4617 adapter->alloc_rx_buff_failed++; 4618 break; 4619 } 4620 4621 /* XXX if it was allocated cleanly it will never map to a 4622 * boundary crossing 4623 */ 4624 4625 /* Fix for errata 23, can't cross 64kB boundary */ 4626 if (!e1000_check_64k_bound(adapter, 4627 (void *)(unsigned long)buffer_info->dma, 4628 adapter->rx_buffer_len)) { 4629 e_err(rx_err, "dma align check failed: %u bytes at " 4630 "%p\n", adapter->rx_buffer_len, 4631 (void *)(unsigned long)buffer_info->dma); 4632 4633 dma_unmap_single(&pdev->dev, buffer_info->dma, 4634 adapter->rx_buffer_len, 4635 DMA_FROM_DEVICE); 4636 4637 skb_free_frag(data); 4638 buffer_info->rxbuf.data = NULL; 4639 buffer_info->dma = 0; 4640 4641 adapter->alloc_rx_buff_failed++; 4642 break; 4643 } 4644 buffer_info->rxbuf.data = data; 4645 skip: 4646 rx_desc = E1000_RX_DESC(*rx_ring, i); 4647 rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma); 4648 4649 if (unlikely(++i == rx_ring->count)) 4650 i = 0; 4651 buffer_info = &rx_ring->buffer_info[i]; 4652 } 4653 4654 if (likely(rx_ring->next_to_use != i)) { 4655 rx_ring->next_to_use = i; 4656 if (unlikely(i-- == 0)) 4657 i = (rx_ring->count - 1); 4658 4659 /* Force memory writes to complete before letting h/w 4660 * know there are new descriptors to fetch. (Only 4661 * applicable for weak-ordered memory model archs, 4662 * such as IA-64). 4663 */ 4664 dma_wmb(); 4665 writel(i, hw->hw_addr + rx_ring->rdt); 4666 } 4667 } 4668 4669 /** 4670 * e1000_smartspeed - Workaround for SmartSpeed on 82541 and 82547 controllers. 4671 * @adapter: 4672 **/ 4673 static void e1000_smartspeed(struct e1000_adapter *adapter) 4674 { 4675 struct e1000_hw *hw = &adapter->hw; 4676 u16 phy_status; 4677 u16 phy_ctrl; 4678 4679 if ((hw->phy_type != e1000_phy_igp) || !hw->autoneg || 4680 !(hw->autoneg_advertised & ADVERTISE_1000_FULL)) 4681 return; 4682 4683 if (adapter->smartspeed == 0) { 4684 /* If Master/Slave config fault is asserted twice, 4685 * we assume back-to-back 4686 */ 4687 e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status); 4688 if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) 4689 return; 4690 e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status); 4691 if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) 4692 return; 4693 e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl); 4694 if (phy_ctrl & CR_1000T_MS_ENABLE) { 4695 phy_ctrl &= ~CR_1000T_MS_ENABLE; 4696 e1000_write_phy_reg(hw, PHY_1000T_CTRL, 4697 phy_ctrl); 4698 adapter->smartspeed++; 4699 if (!e1000_phy_setup_autoneg(hw) && 4700 !e1000_read_phy_reg(hw, PHY_CTRL, 4701 &phy_ctrl)) { 4702 phy_ctrl |= (MII_CR_AUTO_NEG_EN | 4703 MII_CR_RESTART_AUTO_NEG); 4704 e1000_write_phy_reg(hw, PHY_CTRL, 4705 phy_ctrl); 4706 } 4707 } 4708 return; 4709 } else if (adapter->smartspeed == E1000_SMARTSPEED_DOWNSHIFT) { 4710 /* If still no link, perhaps using 2/3 pair cable */ 4711 e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl); 4712 phy_ctrl |= CR_1000T_MS_ENABLE; 4713 e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_ctrl); 4714 if (!e1000_phy_setup_autoneg(hw) && 4715 !e1000_read_phy_reg(hw, PHY_CTRL, &phy_ctrl)) { 4716 phy_ctrl |= (MII_CR_AUTO_NEG_EN | 4717 MII_CR_RESTART_AUTO_NEG); 4718 e1000_write_phy_reg(hw, PHY_CTRL, phy_ctrl); 4719 } 4720 } 4721 /* Restart process after E1000_SMARTSPEED_MAX iterations */ 4722 if (adapter->smartspeed++ == E1000_SMARTSPEED_MAX) 4723 adapter->smartspeed = 0; 4724 } 4725 4726 /** 4727 * e1000_ioctl - 4728 * @netdev: 4729 * @ifreq: 4730 * @cmd: 4731 **/ 4732 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd) 4733 { 4734 switch (cmd) { 4735 case SIOCGMIIPHY: 4736 case SIOCGMIIREG: 4737 case SIOCSMIIREG: 4738 return e1000_mii_ioctl(netdev, ifr, cmd); 4739 default: 4740 return -EOPNOTSUPP; 4741 } 4742 } 4743 4744 /** 4745 * e1000_mii_ioctl - 4746 * @netdev: 4747 * @ifreq: 4748 * @cmd: 4749 **/ 4750 static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr, 4751 int cmd) 4752 { 4753 struct e1000_adapter *adapter = netdev_priv(netdev); 4754 struct e1000_hw *hw = &adapter->hw; 4755 struct mii_ioctl_data *data = if_mii(ifr); 4756 int retval; 4757 u16 mii_reg; 4758 unsigned long flags; 4759 4760 if (hw->media_type != e1000_media_type_copper) 4761 return -EOPNOTSUPP; 4762 4763 switch (cmd) { 4764 case SIOCGMIIPHY: 4765 data->phy_id = hw->phy_addr; 4766 break; 4767 case SIOCGMIIREG: 4768 spin_lock_irqsave(&adapter->stats_lock, flags); 4769 if (e1000_read_phy_reg(hw, data->reg_num & 0x1F, 4770 &data->val_out)) { 4771 spin_unlock_irqrestore(&adapter->stats_lock, flags); 4772 return -EIO; 4773 } 4774 spin_unlock_irqrestore(&adapter->stats_lock, flags); 4775 break; 4776 case SIOCSMIIREG: 4777 if (data->reg_num & ~(0x1F)) 4778 return -EFAULT; 4779 mii_reg = data->val_in; 4780 spin_lock_irqsave(&adapter->stats_lock, flags); 4781 if (e1000_write_phy_reg(hw, data->reg_num, 4782 mii_reg)) { 4783 spin_unlock_irqrestore(&adapter->stats_lock, flags); 4784 return -EIO; 4785 } 4786 spin_unlock_irqrestore(&adapter->stats_lock, flags); 4787 if (hw->media_type == e1000_media_type_copper) { 4788 switch (data->reg_num) { 4789 case PHY_CTRL: 4790 if (mii_reg & MII_CR_POWER_DOWN) 4791 break; 4792 if (mii_reg & MII_CR_AUTO_NEG_EN) { 4793 hw->autoneg = 1; 4794 hw->autoneg_advertised = 0x2F; 4795 } else { 4796 u32 speed; 4797 if (mii_reg & 0x40) 4798 speed = SPEED_1000; 4799 else if (mii_reg & 0x2000) 4800 speed = SPEED_100; 4801 else 4802 speed = SPEED_10; 4803 retval = e1000_set_spd_dplx( 4804 adapter, speed, 4805 ((mii_reg & 0x100) 4806 ? DUPLEX_FULL : 4807 DUPLEX_HALF)); 4808 if (retval) 4809 return retval; 4810 } 4811 if (netif_running(adapter->netdev)) 4812 e1000_reinit_locked(adapter); 4813 else 4814 e1000_reset(adapter); 4815 break; 4816 case M88E1000_PHY_SPEC_CTRL: 4817 case M88E1000_EXT_PHY_SPEC_CTRL: 4818 if (e1000_phy_reset(hw)) 4819 return -EIO; 4820 break; 4821 } 4822 } else { 4823 switch (data->reg_num) { 4824 case PHY_CTRL: 4825 if (mii_reg & MII_CR_POWER_DOWN) 4826 break; 4827 if (netif_running(adapter->netdev)) 4828 e1000_reinit_locked(adapter); 4829 else 4830 e1000_reset(adapter); 4831 break; 4832 } 4833 } 4834 break; 4835 default: 4836 return -EOPNOTSUPP; 4837 } 4838 return E1000_SUCCESS; 4839 } 4840 4841 void e1000_pci_set_mwi(struct e1000_hw *hw) 4842 { 4843 struct e1000_adapter *adapter = hw->back; 4844 int ret_val = pci_set_mwi(adapter->pdev); 4845 4846 if (ret_val) 4847 e_err(probe, "Error in setting MWI\n"); 4848 } 4849 4850 void e1000_pci_clear_mwi(struct e1000_hw *hw) 4851 { 4852 struct e1000_adapter *adapter = hw->back; 4853 4854 pci_clear_mwi(adapter->pdev); 4855 } 4856 4857 int e1000_pcix_get_mmrbc(struct e1000_hw *hw) 4858 { 4859 struct e1000_adapter *adapter = hw->back; 4860 return pcix_get_mmrbc(adapter->pdev); 4861 } 4862 4863 void e1000_pcix_set_mmrbc(struct e1000_hw *hw, int mmrbc) 4864 { 4865 struct e1000_adapter *adapter = hw->back; 4866 pcix_set_mmrbc(adapter->pdev, mmrbc); 4867 } 4868 4869 void e1000_io_write(struct e1000_hw *hw, unsigned long port, u32 value) 4870 { 4871 outl(value, port); 4872 } 4873 4874 static bool e1000_vlan_used(struct e1000_adapter *adapter) 4875 { 4876 u16 vid; 4877 4878 for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID) 4879 return true; 4880 return false; 4881 } 4882 4883 static void __e1000_vlan_mode(struct e1000_adapter *adapter, 4884 netdev_features_t features) 4885 { 4886 struct e1000_hw *hw = &adapter->hw; 4887 u32 ctrl; 4888 4889 ctrl = er32(CTRL); 4890 if (features & NETIF_F_HW_VLAN_CTAG_RX) { 4891 /* enable VLAN tag insert/strip */ 4892 ctrl |= E1000_CTRL_VME; 4893 } else { 4894 /* disable VLAN tag insert/strip */ 4895 ctrl &= ~E1000_CTRL_VME; 4896 } 4897 ew32(CTRL, ctrl); 4898 } 4899 static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter, 4900 bool filter_on) 4901 { 4902 struct e1000_hw *hw = &adapter->hw; 4903 u32 rctl; 4904 4905 if (!test_bit(__E1000_DOWN, &adapter->flags)) 4906 e1000_irq_disable(adapter); 4907 4908 __e1000_vlan_mode(adapter, adapter->netdev->features); 4909 if (filter_on) { 4910 /* enable VLAN receive filtering */ 4911 rctl = er32(RCTL); 4912 rctl &= ~E1000_RCTL_CFIEN; 4913 if (!(adapter->netdev->flags & IFF_PROMISC)) 4914 rctl |= E1000_RCTL_VFE; 4915 ew32(RCTL, rctl); 4916 e1000_update_mng_vlan(adapter); 4917 } else { 4918 /* disable VLAN receive filtering */ 4919 rctl = er32(RCTL); 4920 rctl &= ~E1000_RCTL_VFE; 4921 ew32(RCTL, rctl); 4922 } 4923 4924 if (!test_bit(__E1000_DOWN, &adapter->flags)) 4925 e1000_irq_enable(adapter); 4926 } 4927 4928 static void e1000_vlan_mode(struct net_device *netdev, 4929 netdev_features_t features) 4930 { 4931 struct e1000_adapter *adapter = netdev_priv(netdev); 4932 4933 if (!test_bit(__E1000_DOWN, &adapter->flags)) 4934 e1000_irq_disable(adapter); 4935 4936 __e1000_vlan_mode(adapter, features); 4937 4938 if (!test_bit(__E1000_DOWN, &adapter->flags)) 4939 e1000_irq_enable(adapter); 4940 } 4941 4942 static int e1000_vlan_rx_add_vid(struct net_device *netdev, 4943 __be16 proto, u16 vid) 4944 { 4945 struct e1000_adapter *adapter = netdev_priv(netdev); 4946 struct e1000_hw *hw = &adapter->hw; 4947 u32 vfta, index; 4948 4949 if ((hw->mng_cookie.status & 4950 E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) && 4951 (vid == adapter->mng_vlan_id)) 4952 return 0; 4953 4954 if (!e1000_vlan_used(adapter)) 4955 e1000_vlan_filter_on_off(adapter, true); 4956 4957 /* add VID to filter table */ 4958 index = (vid >> 5) & 0x7F; 4959 vfta = E1000_READ_REG_ARRAY(hw, VFTA, index); 4960 vfta |= (1 << (vid & 0x1F)); 4961 e1000_write_vfta(hw, index, vfta); 4962 4963 set_bit(vid, adapter->active_vlans); 4964 4965 return 0; 4966 } 4967 4968 static int e1000_vlan_rx_kill_vid(struct net_device *netdev, 4969 __be16 proto, u16 vid) 4970 { 4971 struct e1000_adapter *adapter = netdev_priv(netdev); 4972 struct e1000_hw *hw = &adapter->hw; 4973 u32 vfta, index; 4974 4975 if (!test_bit(__E1000_DOWN, &adapter->flags)) 4976 e1000_irq_disable(adapter); 4977 if (!test_bit(__E1000_DOWN, &adapter->flags)) 4978 e1000_irq_enable(adapter); 4979 4980 /* remove VID from filter table */ 4981 index = (vid >> 5) & 0x7F; 4982 vfta = E1000_READ_REG_ARRAY(hw, VFTA, index); 4983 vfta &= ~(1 << (vid & 0x1F)); 4984 e1000_write_vfta(hw, index, vfta); 4985 4986 clear_bit(vid, adapter->active_vlans); 4987 4988 if (!e1000_vlan_used(adapter)) 4989 e1000_vlan_filter_on_off(adapter, false); 4990 4991 return 0; 4992 } 4993 4994 static void e1000_restore_vlan(struct e1000_adapter *adapter) 4995 { 4996 u16 vid; 4997 4998 if (!e1000_vlan_used(adapter)) 4999 return; 5000 5001 e1000_vlan_filter_on_off(adapter, true); 5002 for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID) 5003 e1000_vlan_rx_add_vid(adapter->netdev, htons(ETH_P_8021Q), vid); 5004 } 5005 5006 int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx) 5007 { 5008 struct e1000_hw *hw = &adapter->hw; 5009 5010 hw->autoneg = 0; 5011 5012 /* Make sure dplx is at most 1 bit and lsb of speed is not set 5013 * for the switch() below to work 5014 */ 5015 if ((spd & 1) || (dplx & ~1)) 5016 goto err_inval; 5017 5018 /* Fiber NICs only allow 1000 gbps Full duplex */ 5019 if ((hw->media_type == e1000_media_type_fiber) && 5020 spd != SPEED_1000 && 5021 dplx != DUPLEX_FULL) 5022 goto err_inval; 5023 5024 switch (spd + dplx) { 5025 case SPEED_10 + DUPLEX_HALF: 5026 hw->forced_speed_duplex = e1000_10_half; 5027 break; 5028 case SPEED_10 + DUPLEX_FULL: 5029 hw->forced_speed_duplex = e1000_10_full; 5030 break; 5031 case SPEED_100 + DUPLEX_HALF: 5032 hw->forced_speed_duplex = e1000_100_half; 5033 break; 5034 case SPEED_100 + DUPLEX_FULL: 5035 hw->forced_speed_duplex = e1000_100_full; 5036 break; 5037 case SPEED_1000 + DUPLEX_FULL: 5038 hw->autoneg = 1; 5039 hw->autoneg_advertised = ADVERTISE_1000_FULL; 5040 break; 5041 case SPEED_1000 + DUPLEX_HALF: /* not supported */ 5042 default: 5043 goto err_inval; 5044 } 5045 5046 /* clear MDI, MDI(-X) override is only allowed when autoneg enabled */ 5047 hw->mdix = AUTO_ALL_MODES; 5048 5049 return 0; 5050 5051 err_inval: 5052 e_err(probe, "Unsupported Speed/Duplex configuration\n"); 5053 return -EINVAL; 5054 } 5055 5056 static int __e1000_shutdown(struct pci_dev *pdev, bool *enable_wake) 5057 { 5058 struct net_device *netdev = pci_get_drvdata(pdev); 5059 struct e1000_adapter *adapter = netdev_priv(netdev); 5060 struct e1000_hw *hw = &adapter->hw; 5061 u32 ctrl, ctrl_ext, rctl, status; 5062 u32 wufc = adapter->wol; 5063 #ifdef CONFIG_PM 5064 int retval = 0; 5065 #endif 5066 5067 netif_device_detach(netdev); 5068 5069 if (netif_running(netdev)) { 5070 int count = E1000_CHECK_RESET_COUNT; 5071 5072 while (test_bit(__E1000_RESETTING, &adapter->flags) && count--) 5073 usleep_range(10000, 20000); 5074 5075 WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags)); 5076 e1000_down(adapter); 5077 } 5078 5079 #ifdef CONFIG_PM 5080 retval = pci_save_state(pdev); 5081 if (retval) 5082 return retval; 5083 #endif 5084 5085 status = er32(STATUS); 5086 if (status & E1000_STATUS_LU) 5087 wufc &= ~E1000_WUFC_LNKC; 5088 5089 if (wufc) { 5090 e1000_setup_rctl(adapter); 5091 e1000_set_rx_mode(netdev); 5092 5093 rctl = er32(RCTL); 5094 5095 /* turn on all-multi mode if wake on multicast is enabled */ 5096 if (wufc & E1000_WUFC_MC) 5097 rctl |= E1000_RCTL_MPE; 5098 5099 /* enable receives in the hardware */ 5100 ew32(RCTL, rctl | E1000_RCTL_EN); 5101 5102 if (hw->mac_type >= e1000_82540) { 5103 ctrl = er32(CTRL); 5104 /* advertise wake from D3Cold */ 5105 #define E1000_CTRL_ADVD3WUC 0x00100000 5106 /* phy power management enable */ 5107 #define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000 5108 ctrl |= E1000_CTRL_ADVD3WUC | 5109 E1000_CTRL_EN_PHY_PWR_MGMT; 5110 ew32(CTRL, ctrl); 5111 } 5112 5113 if (hw->media_type == e1000_media_type_fiber || 5114 hw->media_type == e1000_media_type_internal_serdes) { 5115 /* keep the laser running in D3 */ 5116 ctrl_ext = er32(CTRL_EXT); 5117 ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA; 5118 ew32(CTRL_EXT, ctrl_ext); 5119 } 5120 5121 ew32(WUC, E1000_WUC_PME_EN); 5122 ew32(WUFC, wufc); 5123 } else { 5124 ew32(WUC, 0); 5125 ew32(WUFC, 0); 5126 } 5127 5128 e1000_release_manageability(adapter); 5129 5130 *enable_wake = !!wufc; 5131 5132 /* make sure adapter isn't asleep if manageability is enabled */ 5133 if (adapter->en_mng_pt) 5134 *enable_wake = true; 5135 5136 if (netif_running(netdev)) 5137 e1000_free_irq(adapter); 5138 5139 if (!test_and_set_bit(__E1000_DISABLED, &adapter->flags)) 5140 pci_disable_device(pdev); 5141 5142 return 0; 5143 } 5144 5145 #ifdef CONFIG_PM 5146 static int e1000_suspend(struct pci_dev *pdev, pm_message_t state) 5147 { 5148 int retval; 5149 bool wake; 5150 5151 retval = __e1000_shutdown(pdev, &wake); 5152 if (retval) 5153 return retval; 5154 5155 if (wake) { 5156 pci_prepare_to_sleep(pdev); 5157 } else { 5158 pci_wake_from_d3(pdev, false); 5159 pci_set_power_state(pdev, PCI_D3hot); 5160 } 5161 5162 return 0; 5163 } 5164 5165 static int e1000_resume(struct pci_dev *pdev) 5166 { 5167 struct net_device *netdev = pci_get_drvdata(pdev); 5168 struct e1000_adapter *adapter = netdev_priv(netdev); 5169 struct e1000_hw *hw = &adapter->hw; 5170 u32 err; 5171 5172 pci_set_power_state(pdev, PCI_D0); 5173 pci_restore_state(pdev); 5174 pci_save_state(pdev); 5175 5176 if (adapter->need_ioport) 5177 err = pci_enable_device(pdev); 5178 else 5179 err = pci_enable_device_mem(pdev); 5180 if (err) { 5181 pr_err("Cannot enable PCI device from suspend\n"); 5182 return err; 5183 } 5184 5185 /* flush memory to make sure state is correct */ 5186 smp_mb__before_atomic(); 5187 clear_bit(__E1000_DISABLED, &adapter->flags); 5188 pci_set_master(pdev); 5189 5190 pci_enable_wake(pdev, PCI_D3hot, 0); 5191 pci_enable_wake(pdev, PCI_D3cold, 0); 5192 5193 if (netif_running(netdev)) { 5194 err = e1000_request_irq(adapter); 5195 if (err) 5196 return err; 5197 } 5198 5199 e1000_power_up_phy(adapter); 5200 e1000_reset(adapter); 5201 ew32(WUS, ~0); 5202 5203 e1000_init_manageability(adapter); 5204 5205 if (netif_running(netdev)) 5206 e1000_up(adapter); 5207 5208 netif_device_attach(netdev); 5209 5210 return 0; 5211 } 5212 #endif 5213 5214 static void e1000_shutdown(struct pci_dev *pdev) 5215 { 5216 bool wake; 5217 5218 __e1000_shutdown(pdev, &wake); 5219 5220 if (system_state == SYSTEM_POWER_OFF) { 5221 pci_wake_from_d3(pdev, wake); 5222 pci_set_power_state(pdev, PCI_D3hot); 5223 } 5224 } 5225 5226 #ifdef CONFIG_NET_POLL_CONTROLLER 5227 /* Polling 'interrupt' - used by things like netconsole to send skbs 5228 * without having to re-enable interrupts. It's not called while 5229 * the interrupt routine is executing. 5230 */ 5231 static void e1000_netpoll(struct net_device *netdev) 5232 { 5233 struct e1000_adapter *adapter = netdev_priv(netdev); 5234 5235 if (disable_hardirq(adapter->pdev->irq)) 5236 e1000_intr(adapter->pdev->irq, netdev); 5237 enable_irq(adapter->pdev->irq); 5238 } 5239 #endif 5240 5241 /** 5242 * e1000_io_error_detected - called when PCI error is detected 5243 * @pdev: Pointer to PCI device 5244 * @state: The current pci connection state 5245 * 5246 * This function is called after a PCI bus error affecting 5247 * this device has been detected. 5248 */ 5249 static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev, 5250 pci_channel_state_t state) 5251 { 5252 struct net_device *netdev = pci_get_drvdata(pdev); 5253 struct e1000_adapter *adapter = netdev_priv(netdev); 5254 5255 netif_device_detach(netdev); 5256 5257 if (state == pci_channel_io_perm_failure) 5258 return PCI_ERS_RESULT_DISCONNECT; 5259 5260 if (netif_running(netdev)) 5261 e1000_down(adapter); 5262 5263 if (!test_and_set_bit(__E1000_DISABLED, &adapter->flags)) 5264 pci_disable_device(pdev); 5265 5266 /* Request a slot slot reset. */ 5267 return PCI_ERS_RESULT_NEED_RESET; 5268 } 5269 5270 /** 5271 * e1000_io_slot_reset - called after the pci bus has been reset. 5272 * @pdev: Pointer to PCI device 5273 * 5274 * Restart the card from scratch, as if from a cold-boot. Implementation 5275 * resembles the first-half of the e1000_resume routine. 5276 */ 5277 static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev) 5278 { 5279 struct net_device *netdev = pci_get_drvdata(pdev); 5280 struct e1000_adapter *adapter = netdev_priv(netdev); 5281 struct e1000_hw *hw = &adapter->hw; 5282 int err; 5283 5284 if (adapter->need_ioport) 5285 err = pci_enable_device(pdev); 5286 else 5287 err = pci_enable_device_mem(pdev); 5288 if (err) { 5289 pr_err("Cannot re-enable PCI device after reset.\n"); 5290 return PCI_ERS_RESULT_DISCONNECT; 5291 } 5292 5293 /* flush memory to make sure state is correct */ 5294 smp_mb__before_atomic(); 5295 clear_bit(__E1000_DISABLED, &adapter->flags); 5296 pci_set_master(pdev); 5297 5298 pci_enable_wake(pdev, PCI_D3hot, 0); 5299 pci_enable_wake(pdev, PCI_D3cold, 0); 5300 5301 e1000_reset(adapter); 5302 ew32(WUS, ~0); 5303 5304 return PCI_ERS_RESULT_RECOVERED; 5305 } 5306 5307 /** 5308 * e1000_io_resume - called when traffic can start flowing again. 5309 * @pdev: Pointer to PCI device 5310 * 5311 * This callback is called when the error recovery driver tells us that 5312 * its OK to resume normal operation. Implementation resembles the 5313 * second-half of the e1000_resume routine. 5314 */ 5315 static void e1000_io_resume(struct pci_dev *pdev) 5316 { 5317 struct net_device *netdev = pci_get_drvdata(pdev); 5318 struct e1000_adapter *adapter = netdev_priv(netdev); 5319 5320 e1000_init_manageability(adapter); 5321 5322 if (netif_running(netdev)) { 5323 if (e1000_up(adapter)) { 5324 pr_info("can't bring device back up after reset\n"); 5325 return; 5326 } 5327 } 5328 5329 netif_device_attach(netdev); 5330 } 5331 5332 /* e1000_main.c */ 5333