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