aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/e1000e
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/e1000e')
-rw-r--r--drivers/net/e1000e/defines.h2
-rw-r--r--drivers/net/e1000e/e1000.h37
-rw-r--r--drivers/net/e1000e/ethtool.c55
-rw-r--r--drivers/net/e1000e/ich8lan.c78
-rw-r--r--drivers/net/e1000e/netdev.c499
-rw-r--r--drivers/net/e1000e/param.c86
6 files changed, 499 insertions, 258 deletions
diff --git a/drivers/net/e1000e/defines.h b/drivers/net/e1000e/defines.h
index f823b8ba5785..14b0e6cd3b8d 100644
--- a/drivers/net/e1000e/defines.h
+++ b/drivers/net/e1000e/defines.h
@@ -389,7 +389,7 @@
389 389
390/* Interrupt Cause Set */ 390/* Interrupt Cause Set */
391#define E1000_ICS_LSC E1000_ICR_LSC /* Link Status Change */ 391#define E1000_ICS_LSC E1000_ICR_LSC /* Link Status Change */
392#define E1000_ICS_RXDMT0 E1000_ICR_RXDMT0 /* rx desc min. threshold */ 392#define E1000_ICS_RXSEQ E1000_ICR_RXSEQ /* Rx sequence error */
393#define E1000_ICS_RXDMT0 E1000_ICR_RXDMT0 /* Rx desc min. threshold */ 393#define E1000_ICS_RXDMT0 E1000_ICR_RXDMT0 /* Rx desc min. threshold */
394 394
395/* Transmit Descriptor Control */ 395/* Transmit Descriptor Control */
diff --git a/drivers/net/e1000e/e1000.h b/drivers/net/e1000e/e1000.h
index 4a4f62e002b2..5ea6b60fa377 100644
--- a/drivers/net/e1000e/e1000.h
+++ b/drivers/net/e1000e/e1000.h
@@ -41,24 +41,25 @@
41 41
42struct e1000_info; 42struct e1000_info;
43 43
44#define ndev_printk(level, netdev, format, arg...) \ 44#define e_printk(level, adapter, format, arg...) \
45 printk(level "%s: " format, (netdev)->name, ## arg) 45 printk(level "%s: %s: " format, pci_name(adapter->pdev), \
46 adapter->netdev->name, ## arg)
46 47
47#ifdef DEBUG 48#ifdef DEBUG
48#define ndev_dbg(netdev, format, arg...) \ 49#define e_dbg(format, arg...) \
49 ndev_printk(KERN_DEBUG , netdev, format, ## arg) 50 e_printk(KERN_DEBUG , adapter, format, ## arg)
50#else 51#else
51#define ndev_dbg(netdev, format, arg...) do { (void)(netdev); } while (0) 52#define e_dbg(format, arg...) do { (void)(adapter); } while (0)
52#endif 53#endif
53 54
54#define ndev_err(netdev, format, arg...) \ 55#define e_err(format, arg...) \
55 ndev_printk(KERN_ERR , netdev, format, ## arg) 56 e_printk(KERN_ERR, adapter, format, ## arg)
56#define ndev_info(netdev, format, arg...) \ 57#define e_info(format, arg...) \
57 ndev_printk(KERN_INFO , netdev, format, ## arg) 58 e_printk(KERN_INFO, adapter, format, ## arg)
58#define ndev_warn(netdev, format, arg...) \ 59#define e_warn(format, arg...) \
59 ndev_printk(KERN_WARNING , netdev, format, ## arg) 60 e_printk(KERN_WARNING, adapter, format, ## arg)
60#define ndev_notice(netdev, format, arg...) \ 61#define e_notice(format, arg...) \
61 ndev_printk(KERN_NOTICE , netdev, format, ## arg) 62 e_printk(KERN_NOTICE, adapter, format, ## arg)
62 63
63 64
64/* Tx/Rx descriptor defines */ 65/* Tx/Rx descriptor defines */
@@ -256,7 +257,6 @@ struct e1000_adapter {
256 struct net_device *netdev; 257 struct net_device *netdev;
257 struct pci_dev *pdev; 258 struct pci_dev *pdev;
258 struct net_device_stats net_stats; 259 struct net_device_stats net_stats;
259 spinlock_t stats_lock; /* prevent concurrent stats updates */
260 260
261 /* structs defined in e1000_hw.h */ 261 /* structs defined in e1000_hw.h */
262 struct e1000_hw hw; 262 struct e1000_hw hw;
@@ -283,10 +283,8 @@ struct e1000_adapter {
283 unsigned long led_status; 283 unsigned long led_status;
284 284
285 unsigned int flags; 285 unsigned int flags;
286 286 struct work_struct downshift_task;
287 /* for ioport free */ 287 struct work_struct update_phy_task;
288 int bars;
289 int need_ioport;
290}; 288};
291 289
292struct e1000_info { 290struct e1000_info {
@@ -308,6 +306,7 @@ struct e1000_info {
308#define FLAG_HAS_CTRLEXT_ON_LOAD (1 << 5) 306#define FLAG_HAS_CTRLEXT_ON_LOAD (1 << 5)
309#define FLAG_HAS_SWSM_ON_LOAD (1 << 6) 307#define FLAG_HAS_SWSM_ON_LOAD (1 << 6)
310#define FLAG_HAS_JUMBO_FRAMES (1 << 7) 308#define FLAG_HAS_JUMBO_FRAMES (1 << 7)
309#define FLAG_READ_ONLY_NVM (1 << 8)
311#define FLAG_IS_ICH (1 << 9) 310#define FLAG_IS_ICH (1 << 9)
312#define FLAG_HAS_SMART_POWER_DOWN (1 << 11) 311#define FLAG_HAS_SMART_POWER_DOWN (1 << 11)
313#define FLAG_IS_QUAD_PORT_A (1 << 12) 312#define FLAG_IS_QUAD_PORT_A (1 << 12)
@@ -329,6 +328,7 @@ struct e1000_info {
329#define FLAG_RX_CSUM_ENABLED (1 << 28) 328#define FLAG_RX_CSUM_ENABLED (1 << 28)
330#define FLAG_TSO_FORCE (1 << 29) 329#define FLAG_TSO_FORCE (1 << 29)
331#define FLAG_RX_RESTART_NOW (1 << 30) 330#define FLAG_RX_RESTART_NOW (1 << 30)
331#define FLAG_MSI_TEST_FAILED (1 << 31)
332 332
333#define E1000_RX_DESC_PS(R, i) \ 333#define E1000_RX_DESC_PS(R, i) \
334 (&(((union e1000_rx_desc_packet_split *)((R).desc))[i])) 334 (&(((union e1000_rx_desc_packet_split *)((R).desc))[i]))
@@ -387,6 +387,7 @@ extern bool e1000e_enable_mng_pass_thru(struct e1000_hw *hw);
387extern bool e1000e_get_laa_state_82571(struct e1000_hw *hw); 387extern bool e1000e_get_laa_state_82571(struct e1000_hw *hw);
388extern void e1000e_set_laa_state_82571(struct e1000_hw *hw, bool state); 388extern void e1000e_set_laa_state_82571(struct e1000_hw *hw, bool state);
389 389
390extern void e1000e_write_protect_nvm_ich8lan(struct e1000_hw *hw);
390extern void e1000e_set_kmrn_lock_loss_workaround_ich8lan(struct e1000_hw *hw, 391extern void e1000e_set_kmrn_lock_loss_workaround_ich8lan(struct e1000_hw *hw,
391 bool state); 392 bool state);
392extern void e1000e_igp3_phy_powerdown_workaround_ich8lan(struct e1000_hw *hw); 393extern void e1000e_igp3_phy_powerdown_workaround_ich8lan(struct e1000_hw *hw);
diff --git a/drivers/net/e1000e/ethtool.c b/drivers/net/e1000e/ethtool.c
index 9350564065e7..33a3ff17b5d0 100644
--- a/drivers/net/e1000e/ethtool.c
+++ b/drivers/net/e1000e/ethtool.c
@@ -177,7 +177,7 @@ static u32 e1000_get_link(struct net_device *netdev)
177 u32 status; 177 u32 status;
178 178
179 status = er32(STATUS); 179 status = er32(STATUS);
180 return (status & E1000_STATUS_LU); 180 return (status & E1000_STATUS_LU) ? 1 : 0;
181} 181}
182 182
183static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u16 spddplx) 183static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u16 spddplx)
@@ -189,8 +189,7 @@ static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u16 spddplx)
189 /* Fiber NICs only allow 1000 gbps Full duplex */ 189 /* Fiber NICs only allow 1000 gbps Full duplex */
190 if ((adapter->hw.phy.media_type == e1000_media_type_fiber) && 190 if ((adapter->hw.phy.media_type == e1000_media_type_fiber) &&
191 spddplx != (SPEED_1000 + DUPLEX_FULL)) { 191 spddplx != (SPEED_1000 + DUPLEX_FULL)) {
192 ndev_err(adapter->netdev, "Unsupported Speed/Duplex " 192 e_err("Unsupported Speed/Duplex configuration\n");
193 "configuration\n");
194 return -EINVAL; 193 return -EINVAL;
195 } 194 }
196 195
@@ -213,8 +212,7 @@ static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u16 spddplx)
213 break; 212 break;
214 case SPEED_1000 + DUPLEX_HALF: /* not supported */ 213 case SPEED_1000 + DUPLEX_HALF: /* not supported */
215 default: 214 default:
216 ndev_err(adapter->netdev, "Unsupported Speed/Duplex " 215 e_err("Unsupported Speed/Duplex configuration\n");
217 "configuration\n");
218 return -EINVAL; 216 return -EINVAL;
219 } 217 }
220 return 0; 218 return 0;
@@ -231,8 +229,8 @@ static int e1000_set_settings(struct net_device *netdev,
231 * cannot be changed 229 * cannot be changed
232 */ 230 */
233 if (e1000_check_reset_block(hw)) { 231 if (e1000_check_reset_block(hw)) {
234 ndev_err(netdev, "Cannot change link " 232 e_err("Cannot change link characteristics when SoL/IDER is "
235 "characteristics when SoL/IDER is active.\n"); 233 "active.\n");
236 return -EINVAL; 234 return -EINVAL;
237 } 235 }
238 236
@@ -380,8 +378,7 @@ static int e1000_set_tso(struct net_device *netdev, u32 data)
380 netdev->features &= ~NETIF_F_TSO6; 378 netdev->features &= ~NETIF_F_TSO6;
381 } 379 }
382 380
383 ndev_info(netdev, "TSO is %s\n", 381 e_info("TSO is %s\n", data ? "Enabled" : "Disabled");
384 data ? "Enabled" : "Disabled");
385 adapter->flags |= FLAG_TSO_FORCE; 382 adapter->flags |= FLAG_TSO_FORCE;
386 return 0; 383 return 0;
387} 384}
@@ -435,6 +432,10 @@ static void e1000_get_regs(struct net_device *netdev,
435 regs_buff[11] = er32(TIDV); 432 regs_buff[11] = er32(TIDV);
436 433
437 regs_buff[12] = adapter->hw.phy.type; /* PHY type (IGP=1, M88=0) */ 434 regs_buff[12] = adapter->hw.phy.type; /* PHY type (IGP=1, M88=0) */
435
436 /* ethtool doesn't use anything past this point, so all this
437 * code is likely legacy junk for apps that may or may not
438 * exist */
438 if (hw->phy.type == e1000_phy_m88) { 439 if (hw->phy.type == e1000_phy_m88) {
439 e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, &phy_data); 440 e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
440 regs_buff[13] = (u32)phy_data; /* cable length */ 441 regs_buff[13] = (u32)phy_data; /* cable length */
@@ -450,7 +451,7 @@ static void e1000_get_regs(struct net_device *netdev,
450 regs_buff[22] = adapter->phy_stats.receive_errors; 451 regs_buff[22] = adapter->phy_stats.receive_errors;
451 regs_buff[23] = regs_buff[13]; /* mdix mode */ 452 regs_buff[23] = regs_buff[13]; /* mdix mode */
452 } 453 }
453 regs_buff[21] = adapter->phy_stats.idle_errors; /* phy idle errors */ 454 regs_buff[21] = 0; /* was idle_errors */
454 e1e_rphy(hw, PHY_1000T_STATUS, &phy_data); 455 e1e_rphy(hw, PHY_1000T_STATUS, &phy_data);
455 regs_buff[24] = (u32)phy_data; /* phy local receiver status */ 456 regs_buff[24] = (u32)phy_data; /* phy local receiver status */
456 regs_buff[25] = regs_buff[24]; /* phy remote receiver status */ 457 regs_buff[25] = regs_buff[24]; /* phy remote receiver status */
@@ -532,6 +533,9 @@ static int e1000_set_eeprom(struct net_device *netdev,
532 if (eeprom->magic != (adapter->pdev->vendor | (adapter->pdev->device << 16))) 533 if (eeprom->magic != (adapter->pdev->vendor | (adapter->pdev->device << 16)))
533 return -EFAULT; 534 return -EFAULT;
534 535
536 if (adapter->flags & FLAG_READ_ONLY_NVM)
537 return -EINVAL;
538
535 max_len = hw->nvm.word_size * 2; 539 max_len = hw->nvm.word_size * 2;
536 540
537 first_word = eeprom->offset >> 1; 541 first_word = eeprom->offset >> 1;
@@ -722,10 +726,9 @@ static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data,
722 (test[pat] & write)); 726 (test[pat] & write));
723 val = E1000_READ_REG_ARRAY(&adapter->hw, reg, offset); 727 val = E1000_READ_REG_ARRAY(&adapter->hw, reg, offset);
724 if (val != (test[pat] & write & mask)) { 728 if (val != (test[pat] & write & mask)) {
725 ndev_err(adapter->netdev, "pattern test reg %04X " 729 e_err("pattern test reg %04X failed: got 0x%08X "
726 "failed: got 0x%08X expected 0x%08X\n", 730 "expected 0x%08X\n", reg + offset, val,
727 reg + offset, 731 (test[pat] & write & mask));
728 val, (test[pat] & write & mask));
729 *data = reg; 732 *data = reg;
730 return 1; 733 return 1;
731 } 734 }
@@ -740,9 +743,8 @@ static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data,
740 __ew32(&adapter->hw, reg, write & mask); 743 __ew32(&adapter->hw, reg, write & mask);
741 val = __er32(&adapter->hw, reg); 744 val = __er32(&adapter->hw, reg);
742 if ((write & mask) != (val & mask)) { 745 if ((write & mask) != (val & mask)) {
743 ndev_err(adapter->netdev, "set/check reg %04X test failed: " 746 e_err("set/check reg %04X test failed: got 0x%08X "
744 "got 0x%08X expected 0x%08X\n", reg, (val & mask), 747 "expected 0x%08X\n", reg, (val & mask), (write & mask));
745 (write & mask));
746 *data = reg; 748 *data = reg;
747 return 1; 749 return 1;
748 } 750 }
@@ -766,7 +768,6 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
766{ 768{
767 struct e1000_hw *hw = &adapter->hw; 769 struct e1000_hw *hw = &adapter->hw;
768 struct e1000_mac_info *mac = &adapter->hw.mac; 770 struct e1000_mac_info *mac = &adapter->hw.mac;
769 struct net_device *netdev = adapter->netdev;
770 u32 value; 771 u32 value;
771 u32 before; 772 u32 before;
772 u32 after; 773 u32 after;
@@ -799,8 +800,8 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
799 ew32(STATUS, toggle); 800 ew32(STATUS, toggle);
800 after = er32(STATUS) & toggle; 801 after = er32(STATUS) & toggle;
801 if (value != after) { 802 if (value != after) {
802 ndev_err(netdev, "failed STATUS register test got: " 803 e_err("failed STATUS register test got: 0x%08X expected: "
803 "0x%08X expected: 0x%08X\n", after, value); 804 "0x%08X\n", after, value);
804 *data = 1; 805 *data = 1;
805 return 1; 806 return 1;
806 } 807 }
@@ -903,8 +904,7 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
903 *data = 1; 904 *data = 1;
904 return -1; 905 return -1;
905 } 906 }
906 ndev_info(netdev, "testing %s interrupt\n", 907 e_info("testing %s interrupt\n", (shared_int ? "shared" : "unshared"));
907 (shared_int ? "shared" : "unshared"));
908 908
909 /* Disable all the interrupts */ 909 /* Disable all the interrupts */
910 ew32(IMC, 0xFFFFFFFF); 910 ew32(IMC, 0xFFFFFFFF);
@@ -1526,8 +1526,7 @@ static int e1000_loopback_test(struct e1000_adapter *adapter, u64 *data)
1526 * sessions are active 1526 * sessions are active
1527 */ 1527 */
1528 if (e1000_check_reset_block(&adapter->hw)) { 1528 if (e1000_check_reset_block(&adapter->hw)) {
1529 ndev_err(adapter->netdev, "Cannot do PHY loopback test " 1529 e_err("Cannot do PHY loopback test when SoL/IDER is active.\n");
1530 "when SoL/IDER is active.\n");
1531 *data = 0; 1530 *data = 0;
1532 goto out; 1531 goto out;
1533 } 1532 }
@@ -1612,7 +1611,7 @@ static void e1000_diag_test(struct net_device *netdev,
1612 forced_speed_duplex = adapter->hw.mac.forced_speed_duplex; 1611 forced_speed_duplex = adapter->hw.mac.forced_speed_duplex;
1613 autoneg = adapter->hw.mac.autoneg; 1612 autoneg = adapter->hw.mac.autoneg;
1614 1613
1615 ndev_info(netdev, "offline testing starting\n"); 1614 e_info("offline testing starting\n");
1616 1615
1617 /* 1616 /*
1618 * Link test performed before hardware reset so autoneg doesn't 1617 * Link test performed before hardware reset so autoneg doesn't
@@ -1658,7 +1657,7 @@ static void e1000_diag_test(struct net_device *netdev,
1658 if (if_running) 1657 if (if_running)
1659 dev_open(netdev); 1658 dev_open(netdev);
1660 } else { 1659 } else {
1661 ndev_info(netdev, "online testing starting\n"); 1660 e_info("online testing starting\n");
1662 /* Online tests */ 1661 /* Online tests */
1663 if (e1000_link_test(adapter, &data[4])) 1662 if (e1000_link_test(adapter, &data[4]))
1664 eth_test->flags |= ETH_TEST_FL_FAILED; 1663 eth_test->flags |= ETH_TEST_FL_FAILED;
@@ -1694,8 +1693,8 @@ static void e1000_get_wol(struct net_device *netdev,
1694 wol->supported &= ~WAKE_UCAST; 1693 wol->supported &= ~WAKE_UCAST;
1695 1694
1696 if (adapter->wol & E1000_WUFC_EX) 1695 if (adapter->wol & E1000_WUFC_EX)
1697 ndev_err(netdev, "Interface does not support " 1696 e_err("Interface does not support directed (unicast) "
1698 "directed (unicast) frame wake-up packets\n"); 1697 "frame wake-up packets\n");
1699 } 1698 }
1700 1699
1701 if (adapter->wol & E1000_WUFC_EX) 1700 if (adapter->wol & E1000_WUFC_EX)
diff --git a/drivers/net/e1000e/ich8lan.c b/drivers/net/e1000e/ich8lan.c
index 9e38452a738c..bcd2bc477af2 100644
--- a/drivers/net/e1000e/ich8lan.c
+++ b/drivers/net/e1000e/ich8lan.c
@@ -58,6 +58,7 @@
58#define ICH_FLASH_HSFCTL 0x0006 58#define ICH_FLASH_HSFCTL 0x0006
59#define ICH_FLASH_FADDR 0x0008 59#define ICH_FLASH_FADDR 0x0008
60#define ICH_FLASH_FDATA0 0x0010 60#define ICH_FLASH_FDATA0 0x0010
61#define ICH_FLASH_PR0 0x0074
61 62
62#define ICH_FLASH_READ_COMMAND_TIMEOUT 500 63#define ICH_FLASH_READ_COMMAND_TIMEOUT 500
63#define ICH_FLASH_WRITE_COMMAND_TIMEOUT 500 64#define ICH_FLASH_WRITE_COMMAND_TIMEOUT 500
@@ -150,6 +151,19 @@ union ich8_hws_flash_regacc {
150 u16 regval; 151 u16 regval;
151}; 152};
152 153
154/* ICH Flash Protected Region */
155union ich8_flash_protected_range {
156 struct ich8_pr {
157 u32 base:13; /* 0:12 Protected Range Base */
158 u32 reserved1:2; /* 13:14 Reserved */
159 u32 rpe:1; /* 15 Read Protection Enable */
160 u32 limit:13; /* 16:28 Protected Range Limit */
161 u32 reserved2:2; /* 29:30 Reserved */
162 u32 wpe:1; /* 31 Write Protection Enable */
163 } range;
164 u32 regval;
165};
166
153static s32 e1000_setup_link_ich8lan(struct e1000_hw *hw); 167static s32 e1000_setup_link_ich8lan(struct e1000_hw *hw);
154static void e1000_clear_hw_cntrs_ich8lan(struct e1000_hw *hw); 168static void e1000_clear_hw_cntrs_ich8lan(struct e1000_hw *hw);
155static void e1000_initialize_hw_bits_ich8lan(struct e1000_hw *hw); 169static void e1000_initialize_hw_bits_ich8lan(struct e1000_hw *hw);
@@ -366,6 +380,9 @@ static s32 e1000_get_variants_ich8lan(struct e1000_adapter *adapter)
366 return 0; 380 return 0;
367} 381}
368 382
383static DEFINE_MUTEX(nvm_mutex);
384static pid_t nvm_owner = -1;
385
369/** 386/**
370 * e1000_acquire_swflag_ich8lan - Acquire software control flag 387 * e1000_acquire_swflag_ich8lan - Acquire software control flag
371 * @hw: pointer to the HW structure 388 * @hw: pointer to the HW structure
@@ -379,6 +396,15 @@ static s32 e1000_acquire_swflag_ich8lan(struct e1000_hw *hw)
379 u32 extcnf_ctrl; 396 u32 extcnf_ctrl;
380 u32 timeout = PHY_CFG_TIMEOUT; 397 u32 timeout = PHY_CFG_TIMEOUT;
381 398
399 might_sleep();
400
401 if (!mutex_trylock(&nvm_mutex)) {
402 WARN(1, KERN_ERR "e1000e mutex contention. Owned by pid %d\n",
403 nvm_owner);
404 mutex_lock(&nvm_mutex);
405 }
406 nvm_owner = current->pid;
407
382 while (timeout) { 408 while (timeout) {
383 extcnf_ctrl = er32(EXTCNF_CTRL); 409 extcnf_ctrl = er32(EXTCNF_CTRL);
384 extcnf_ctrl |= E1000_EXTCNF_CTRL_SWFLAG; 410 extcnf_ctrl |= E1000_EXTCNF_CTRL_SWFLAG;
@@ -393,6 +419,8 @@ static s32 e1000_acquire_swflag_ich8lan(struct e1000_hw *hw)
393 419
394 if (!timeout) { 420 if (!timeout) {
395 hw_dbg(hw, "FW or HW has locked the resource for too long.\n"); 421 hw_dbg(hw, "FW or HW has locked the resource for too long.\n");
422 nvm_owner = -1;
423 mutex_unlock(&nvm_mutex);
396 return -E1000_ERR_CONFIG; 424 return -E1000_ERR_CONFIG;
397 } 425 }
398 426
@@ -414,6 +442,9 @@ static void e1000_release_swflag_ich8lan(struct e1000_hw *hw)
414 extcnf_ctrl = er32(EXTCNF_CTRL); 442 extcnf_ctrl = er32(EXTCNF_CTRL);
415 extcnf_ctrl &= ~E1000_EXTCNF_CTRL_SWFLAG; 443 extcnf_ctrl &= ~E1000_EXTCNF_CTRL_SWFLAG;
416 ew32(EXTCNF_CTRL, extcnf_ctrl); 444 ew32(EXTCNF_CTRL, extcnf_ctrl);
445
446 nvm_owner = -1;
447 mutex_unlock(&nvm_mutex);
417} 448}
418 449
419/** 450/**
@@ -1284,6 +1315,7 @@ static s32 e1000_update_nvm_checksum_ich8lan(struct e1000_hw *hw)
1284 * programming failed. 1315 * programming failed.
1285 */ 1316 */
1286 if (ret_val) { 1317 if (ret_val) {
1318 /* Possibly read-only, see e1000e_write_protect_nvm_ich8lan() */
1287 hw_dbg(hw, "Flash commit failed.\n"); 1319 hw_dbg(hw, "Flash commit failed.\n");
1288 e1000_release_swflag_ich8lan(hw); 1320 e1000_release_swflag_ich8lan(hw);
1289 return ret_val; 1321 return ret_val;
@@ -1374,6 +1406,49 @@ static s32 e1000_validate_nvm_checksum_ich8lan(struct e1000_hw *hw)
1374} 1406}
1375 1407
1376/** 1408/**
1409 * e1000e_write_protect_nvm_ich8lan - Make the NVM read-only
1410 * @hw: pointer to the HW structure
1411 *
1412 * To prevent malicious write/erase of the NVM, set it to be read-only
1413 * so that the hardware ignores all write/erase cycles of the NVM via
1414 * the flash control registers. The shadow-ram copy of the NVM will
1415 * still be updated, however any updates to this copy will not stick
1416 * across driver reloads.
1417 **/
1418void e1000e_write_protect_nvm_ich8lan(struct e1000_hw *hw)
1419{
1420 union ich8_flash_protected_range pr0;
1421 union ich8_hws_flash_status hsfsts;
1422 u32 gfpreg;
1423 s32 ret_val;
1424
1425 ret_val = e1000_acquire_swflag_ich8lan(hw);
1426 if (ret_val)
1427 return;
1428
1429 gfpreg = er32flash(ICH_FLASH_GFPREG);
1430
1431 /* Write-protect GbE Sector of NVM */
1432 pr0.regval = er32flash(ICH_FLASH_PR0);
1433 pr0.range.base = gfpreg & FLASH_GFPREG_BASE_MASK;
1434 pr0.range.limit = ((gfpreg >> 16) & FLASH_GFPREG_BASE_MASK);
1435 pr0.range.wpe = true;
1436 ew32flash(ICH_FLASH_PR0, pr0.regval);
1437
1438 /*
1439 * Lock down a subset of GbE Flash Control Registers, e.g.
1440 * PR0 to prevent the write-protection from being lifted.
1441 * Once FLOCKDN is set, the registers protected by it cannot
1442 * be written until FLOCKDN is cleared by a hardware reset.
1443 */
1444 hsfsts.regval = er16flash(ICH_FLASH_HSFSTS);
1445 hsfsts.hsf_status.flockdn = true;
1446 ew32flash(ICH_FLASH_HSFSTS, hsfsts.regval);
1447
1448 e1000_release_swflag_ich8lan(hw);
1449}
1450
1451/**
1377 * e1000_write_flash_data_ich8lan - Writes bytes to the NVM 1452 * e1000_write_flash_data_ich8lan - Writes bytes to the NVM
1378 * @hw: pointer to the HW structure 1453 * @hw: pointer to the HW structure
1379 * @offset: The offset (in bytes) of the byte/word to read. 1454 * @offset: The offset (in bytes) of the byte/word to read.
@@ -1720,6 +1795,9 @@ static s32 e1000_reset_hw_ich8lan(struct e1000_hw *hw)
1720 ew32(CTRL, (ctrl | E1000_CTRL_RST)); 1795 ew32(CTRL, (ctrl | E1000_CTRL_RST));
1721 msleep(20); 1796 msleep(20);
1722 1797
1798 /* release the swflag because it is not reset by hardware reset */
1799 e1000_release_swflag_ich8lan(hw);
1800
1723 ret_val = e1000e_get_auto_rd_done(hw); 1801 ret_val = e1000e_get_auto_rd_done(hw);
1724 if (ret_val) { 1802 if (ret_val) {
1725 /* 1803 /*
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index d13677899767..b81c4237b5d3 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -47,7 +47,7 @@
47 47
48#include "e1000.h" 48#include "e1000.h"
49 49
50#define DRV_VERSION "0.3.3.3-k2" 50#define DRV_VERSION "0.3.3.3-k6"
51char e1000e_driver_name[] = "e1000e"; 51char e1000e_driver_name[] = "e1000e";
52const char e1000e_driver_version[] = DRV_VERSION; 52const char e1000e_driver_version[] = DRV_VERSION;
53 53
@@ -484,8 +484,8 @@ static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
484 * packet, also make sure the frame isn't just CRC only */ 484 * packet, also make sure the frame isn't just CRC only */
485 if (!(status & E1000_RXD_STAT_EOP) || (length <= 4)) { 485 if (!(status & E1000_RXD_STAT_EOP) || (length <= 4)) {
486 /* All receives must fit into a single buffer */ 486 /* All receives must fit into a single buffer */
487 ndev_dbg(netdev, "%s: Receive packet consumed " 487 e_dbg("%s: Receive packet consumed multiple buffers\n",
488 "multiple buffers\n", netdev->name); 488 netdev->name);
489 /* recycle */ 489 /* recycle */
490 buffer_info->skb = skb; 490 buffer_info->skb = skb;
491 goto next_desc; 491 goto next_desc;
@@ -510,9 +510,12 @@ static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
510 netdev_alloc_skb(netdev, length + NET_IP_ALIGN); 510 netdev_alloc_skb(netdev, length + NET_IP_ALIGN);
511 if (new_skb) { 511 if (new_skb) {
512 skb_reserve(new_skb, NET_IP_ALIGN); 512 skb_reserve(new_skb, NET_IP_ALIGN);
513 memcpy(new_skb->data - NET_IP_ALIGN, 513 skb_copy_to_linear_data_offset(new_skb,
514 skb->data - NET_IP_ALIGN, 514 -NET_IP_ALIGN,
515 length + NET_IP_ALIGN); 515 (skb->data -
516 NET_IP_ALIGN),
517 (length +
518 NET_IP_ALIGN));
516 /* save the skb in buffer_info as good */ 519 /* save the skb in buffer_info as good */
517 buffer_info->skb = skb; 520 buffer_info->skb = skb;
518 skb = new_skb; 521 skb = new_skb;
@@ -576,28 +579,26 @@ static void e1000_print_tx_hang(struct e1000_adapter *adapter)
576 unsigned int i = tx_ring->next_to_clean; 579 unsigned int i = tx_ring->next_to_clean;
577 unsigned int eop = tx_ring->buffer_info[i].next_to_watch; 580 unsigned int eop = tx_ring->buffer_info[i].next_to_watch;
578 struct e1000_tx_desc *eop_desc = E1000_TX_DESC(*tx_ring, eop); 581 struct e1000_tx_desc *eop_desc = E1000_TX_DESC(*tx_ring, eop);
579 struct net_device *netdev = adapter->netdev;
580 582
581 /* detected Tx unit hang */ 583 /* detected Tx unit hang */
582 ndev_err(netdev, 584 e_err("Detected Tx Unit Hang:\n"
583 "Detected Tx Unit Hang:\n" 585 " TDH <%x>\n"
584 " TDH <%x>\n" 586 " TDT <%x>\n"
585 " TDT <%x>\n" 587 " next_to_use <%x>\n"
586 " next_to_use <%x>\n" 588 " next_to_clean <%x>\n"
587 " next_to_clean <%x>\n" 589 "buffer_info[next_to_clean]:\n"
588 "buffer_info[next_to_clean]:\n" 590 " time_stamp <%lx>\n"
589 " time_stamp <%lx>\n" 591 " next_to_watch <%x>\n"
590 " next_to_watch <%x>\n" 592 " jiffies <%lx>\n"
591 " jiffies <%lx>\n" 593 " next_to_watch.status <%x>\n",
592 " next_to_watch.status <%x>\n", 594 readl(adapter->hw.hw_addr + tx_ring->head),
593 readl(adapter->hw.hw_addr + tx_ring->head), 595 readl(adapter->hw.hw_addr + tx_ring->tail),
594 readl(adapter->hw.hw_addr + tx_ring->tail), 596 tx_ring->next_to_use,
595 tx_ring->next_to_use, 597 tx_ring->next_to_clean,
596 tx_ring->next_to_clean, 598 tx_ring->buffer_info[eop].time_stamp,
597 tx_ring->buffer_info[eop].time_stamp, 599 eop,
598 eop, 600 jiffies,
599 jiffies, 601 eop_desc->upper.fields.status);
600 eop_desc->upper.fields.status);
601} 602}
602 603
603/** 604/**
@@ -747,8 +748,8 @@ static bool e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
747 buffer_info->dma = 0; 748 buffer_info->dma = 0;
748 749
749 if (!(staterr & E1000_RXD_STAT_EOP)) { 750 if (!(staterr & E1000_RXD_STAT_EOP)) {
750 ndev_dbg(netdev, "%s: Packet Split buffers didn't pick " 751 e_dbg("%s: Packet Split buffers didn't pick up the "
751 "up the full packet\n", netdev->name); 752 "full packet\n", netdev->name);
752 dev_kfree_skb_irq(skb); 753 dev_kfree_skb_irq(skb);
753 goto next_desc; 754 goto next_desc;
754 } 755 }
@@ -761,8 +762,8 @@ static bool e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
761 length = le16_to_cpu(rx_desc->wb.middle.length0); 762 length = le16_to_cpu(rx_desc->wb.middle.length0);
762 763
763 if (!length) { 764 if (!length) {
764 ndev_dbg(netdev, "%s: Last part of the packet spanning" 765 e_dbg("%s: Last part of the packet spanning multiple "
765 " multiple descriptors\n", netdev->name); 766 "descriptors\n", netdev->name);
766 dev_kfree_skb_irq(skb); 767 dev_kfree_skb_irq(skb);
767 goto next_desc; 768 goto next_desc;
768 } 769 }
@@ -1011,7 +1012,7 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
1011 1012
1012 /* eth type trans needs skb->data to point to something */ 1013 /* eth type trans needs skb->data to point to something */
1013 if (!pskb_may_pull(skb, ETH_HLEN)) { 1014 if (!pskb_may_pull(skb, ETH_HLEN)) {
1014 ndev_err(netdev, "pskb_may_pull failed.\n"); 1015 e_err("pskb_may_pull failed.\n");
1015 dev_kfree_skb(skb); 1016 dev_kfree_skb(skb);
1016 goto next_desc; 1017 goto next_desc;
1017 } 1018 }
@@ -1114,6 +1115,14 @@ static void e1000_clean_rx_ring(struct e1000_adapter *adapter)
1114 writel(0, adapter->hw.hw_addr + rx_ring->tail); 1115 writel(0, adapter->hw.hw_addr + rx_ring->tail);
1115} 1116}
1116 1117
1118static void e1000e_downshift_workaround(struct work_struct *work)
1119{
1120 struct e1000_adapter *adapter = container_of(work,
1121 struct e1000_adapter, downshift_task);
1122
1123 e1000e_gig_downshift_workaround_ich8lan(&adapter->hw);
1124}
1125
1117/** 1126/**
1118 * e1000_intr_msi - Interrupt Handler 1127 * e1000_intr_msi - Interrupt Handler
1119 * @irq: interrupt number 1128 * @irq: interrupt number
@@ -1138,7 +1147,7 @@ static irqreturn_t e1000_intr_msi(int irq, void *data)
1138 */ 1147 */
1139 if ((adapter->flags & FLAG_LSC_GIG_SPEED_DROP) && 1148 if ((adapter->flags & FLAG_LSC_GIG_SPEED_DROP) &&
1140 (!(er32(STATUS) & E1000_STATUS_LU))) 1149 (!(er32(STATUS) & E1000_STATUS_LU)))
1141 e1000e_gig_downshift_workaround_ich8lan(hw); 1150 schedule_work(&adapter->downshift_task);
1142 1151
1143 /* 1152 /*
1144 * 80003ES2LAN workaround-- For packet buffer work-around on 1153 * 80003ES2LAN workaround-- For packet buffer work-around on
@@ -1204,7 +1213,7 @@ static irqreturn_t e1000_intr(int irq, void *data)
1204 */ 1213 */
1205 if ((adapter->flags & FLAG_LSC_GIG_SPEED_DROP) && 1214 if ((adapter->flags & FLAG_LSC_GIG_SPEED_DROP) &&
1206 (!(er32(STATUS) & E1000_STATUS_LU))) 1215 (!(er32(STATUS) & E1000_STATUS_LU)))
1207 e1000e_gig_downshift_workaround_ich8lan(hw); 1216 schedule_work(&adapter->downshift_task);
1208 1217
1209 /* 1218 /*
1210 * 80003ES2LAN workaround-- 1219 * 80003ES2LAN workaround--
@@ -1235,28 +1244,36 @@ static irqreturn_t e1000_intr(int irq, void *data)
1235 return IRQ_HANDLED; 1244 return IRQ_HANDLED;
1236} 1245}
1237 1246
1247/**
1248 * e1000_request_irq - initialize interrupts
1249 *
1250 * Attempts to configure interrupts using the best available
1251 * capabilities of the hardware and kernel.
1252 **/
1238static int e1000_request_irq(struct e1000_adapter *adapter) 1253static int e1000_request_irq(struct e1000_adapter *adapter)
1239{ 1254{
1240 struct net_device *netdev = adapter->netdev; 1255 struct net_device *netdev = adapter->netdev;
1241 irq_handler_t handler = e1000_intr;
1242 int irq_flags = IRQF_SHARED; 1256 int irq_flags = IRQF_SHARED;
1243 int err; 1257 int err;
1244 1258
1245 if (!pci_enable_msi(adapter->pdev)) { 1259 if (!(adapter->flags & FLAG_MSI_TEST_FAILED)) {
1246 adapter->flags |= FLAG_MSI_ENABLED; 1260 err = pci_enable_msi(adapter->pdev);
1247 handler = e1000_intr_msi; 1261 if (!err) {
1248 irq_flags = 0; 1262 adapter->flags |= FLAG_MSI_ENABLED;
1263 irq_flags = 0;
1264 }
1249 } 1265 }
1250 1266
1251 err = request_irq(adapter->pdev->irq, handler, irq_flags, netdev->name, 1267 err = request_irq(adapter->pdev->irq,
1252 netdev); 1268 ((adapter->flags & FLAG_MSI_ENABLED) ?
1269 &e1000_intr_msi : &e1000_intr),
1270 irq_flags, netdev->name, netdev);
1253 if (err) { 1271 if (err) {
1254 ndev_err(netdev, 1272 if (adapter->flags & FLAG_MSI_ENABLED) {
1255 "Unable to allocate %s interrupt (return: %d)\n",
1256 adapter->flags & FLAG_MSI_ENABLED ? "MSI":"INTx",
1257 err);
1258 if (adapter->flags & FLAG_MSI_ENABLED)
1259 pci_disable_msi(adapter->pdev); 1273 pci_disable_msi(adapter->pdev);
1274 adapter->flags &= ~FLAG_MSI_ENABLED;
1275 }
1276 e_err("Unable to allocate interrupt, Error: %d\n", err);
1260 } 1277 }
1261 1278
1262 return err; 1279 return err;
@@ -1395,8 +1412,7 @@ int e1000e_setup_tx_resources(struct e1000_adapter *adapter)
1395 return 0; 1412 return 0;
1396err: 1413err:
1397 vfree(tx_ring->buffer_info); 1414 vfree(tx_ring->buffer_info);
1398 ndev_err(adapter->netdev, 1415 e_err("Unable to allocate memory for the transmit descriptor ring\n");
1399 "Unable to allocate memory for the transmit descriptor ring\n");
1400 return err; 1416 return err;
1401} 1417}
1402 1418
@@ -1450,8 +1466,7 @@ err_pages:
1450 } 1466 }
1451err: 1467err:
1452 vfree(rx_ring->buffer_info); 1468 vfree(rx_ring->buffer_info);
1453 ndev_err(adapter->netdev, 1469 e_err("Unable to allocate memory for the transmit descriptor ring\n");
1454 "Unable to allocate memory for the transmit descriptor ring\n");
1455 return err; 1470 return err;
1456} 1471}
1457 1472
@@ -2450,13 +2465,13 @@ void e1000e_reset(struct e1000_adapter *adapter)
2450 * For parts with AMT enabled, let the firmware know 2465 * For parts with AMT enabled, let the firmware know
2451 * that the network interface is in control 2466 * that the network interface is in control
2452 */ 2467 */
2453 if ((adapter->flags & FLAG_HAS_AMT) && e1000e_check_mng_mode(hw)) 2468 if (adapter->flags & FLAG_HAS_AMT)
2454 e1000_get_hw_control(adapter); 2469 e1000_get_hw_control(adapter);
2455 2470
2456 ew32(WUC, 0); 2471 ew32(WUC, 0);
2457 2472
2458 if (mac->ops.init_hw(hw)) 2473 if (mac->ops.init_hw(hw))
2459 ndev_err(adapter->netdev, "Hardware Error\n"); 2474 e_err("Hardware Error\n");
2460 2475
2461 e1000_update_mng_vlan(adapter); 2476 e1000_update_mng_vlan(adapter);
2462 2477
@@ -2585,19 +2600,146 @@ static int __devinit e1000_sw_init(struct e1000_adapter *adapter)
2585 /* Explicitly disable IRQ since the NIC can be in any state. */ 2600 /* Explicitly disable IRQ since the NIC can be in any state. */
2586 e1000_irq_disable(adapter); 2601 e1000_irq_disable(adapter);
2587 2602
2588 spin_lock_init(&adapter->stats_lock);
2589
2590 set_bit(__E1000_DOWN, &adapter->state); 2603 set_bit(__E1000_DOWN, &adapter->state);
2591 return 0; 2604 return 0;
2592 2605
2593err: 2606err:
2594 ndev_err(netdev, "Unable to allocate memory for queues\n"); 2607 e_err("Unable to allocate memory for queues\n");
2595 kfree(adapter->rx_ring); 2608 kfree(adapter->rx_ring);
2596 kfree(adapter->tx_ring); 2609 kfree(adapter->tx_ring);
2597 return -ENOMEM; 2610 return -ENOMEM;
2598} 2611}
2599 2612
2600/** 2613/**
2614 * e1000_intr_msi_test - Interrupt Handler
2615 * @irq: interrupt number
2616 * @data: pointer to a network interface device structure
2617 **/
2618static irqreturn_t e1000_intr_msi_test(int irq, void *data)
2619{
2620 struct net_device *netdev = data;
2621 struct e1000_adapter *adapter = netdev_priv(netdev);
2622 struct e1000_hw *hw = &adapter->hw;
2623 u32 icr = er32(ICR);
2624
2625 e_dbg("%s: icr is %08X\n", netdev->name, icr);
2626 if (icr & E1000_ICR_RXSEQ) {
2627 adapter->flags &= ~FLAG_MSI_TEST_FAILED;
2628 wmb();
2629 }
2630
2631 return IRQ_HANDLED;
2632}
2633
2634/**
2635 * e1000_test_msi_interrupt - Returns 0 for successful test
2636 * @adapter: board private struct
2637 *
2638 * code flow taken from tg3.c
2639 **/
2640static int e1000_test_msi_interrupt(struct e1000_adapter *adapter)
2641{
2642 struct net_device *netdev = adapter->netdev;
2643 struct e1000_hw *hw = &adapter->hw;
2644 int err;
2645
2646 /* poll_enable hasn't been called yet, so don't need disable */
2647 /* clear any pending events */
2648 er32(ICR);
2649
2650 /* free the real vector and request a test handler */
2651 e1000_free_irq(adapter);
2652
2653 /* Assume that the test fails, if it succeeds then the test
2654 * MSI irq handler will unset this flag */
2655 adapter->flags |= FLAG_MSI_TEST_FAILED;
2656
2657 err = pci_enable_msi(adapter->pdev);
2658 if (err)
2659 goto msi_test_failed;
2660
2661 err = request_irq(adapter->pdev->irq, &e1000_intr_msi_test, 0,
2662 netdev->name, netdev);
2663 if (err) {
2664 pci_disable_msi(adapter->pdev);
2665 goto msi_test_failed;
2666 }
2667
2668 wmb();
2669
2670 e1000_irq_enable(adapter);
2671
2672 /* fire an unusual interrupt on the test handler */
2673 ew32(ICS, E1000_ICS_RXSEQ);
2674 e1e_flush();
2675 msleep(50);
2676
2677 e1000_irq_disable(adapter);
2678
2679 rmb();
2680
2681 if (adapter->flags & FLAG_MSI_TEST_FAILED) {
2682 err = -EIO;
2683 e_info("MSI interrupt test failed!\n");
2684 }
2685
2686 free_irq(adapter->pdev->irq, netdev);
2687 pci_disable_msi(adapter->pdev);
2688
2689 if (err == -EIO)
2690 goto msi_test_failed;
2691
2692 /* okay so the test worked, restore settings */
2693 e_dbg("%s: MSI interrupt test succeeded!\n", netdev->name);
2694msi_test_failed:
2695 /* restore the original vector, even if it failed */
2696 e1000_request_irq(adapter);
2697 return err;
2698}
2699
2700/**
2701 * e1000_test_msi - Returns 0 if MSI test succeeds or INTx mode is restored
2702 * @adapter: board private struct
2703 *
2704 * code flow taken from tg3.c, called with e1000 interrupts disabled.
2705 **/
2706static int e1000_test_msi(struct e1000_adapter *adapter)
2707{
2708 int err;
2709 u16 pci_cmd;
2710
2711 if (!(adapter->flags & FLAG_MSI_ENABLED))
2712 return 0;
2713
2714 /* disable SERR in case the MSI write causes a master abort */
2715 pci_read_config_word(adapter->pdev, PCI_COMMAND, &pci_cmd);
2716 pci_write_config_word(adapter->pdev, PCI_COMMAND,
2717 pci_cmd & ~PCI_COMMAND_SERR);
2718
2719 err = e1000_test_msi_interrupt(adapter);
2720
2721 /* restore previous setting of command word */
2722 pci_write_config_word(adapter->pdev, PCI_COMMAND, pci_cmd);
2723
2724 /* success ! */
2725 if (!err)
2726 return 0;
2727
2728 /* EIO means MSI test failed */
2729 if (err != -EIO)
2730 return err;
2731
2732 /* back to INTx mode */
2733 e_warn("MSI interrupt test failed, using legacy interrupt.\n");
2734
2735 e1000_free_irq(adapter);
2736
2737 err = e1000_request_irq(adapter);
2738
2739 return err;
2740}
2741
2742/**
2601 * e1000_open - Called when a network interface is made active 2743 * e1000_open - Called when a network interface is made active
2602 * @netdev: network interface device structure 2744 * @netdev: network interface device structure
2603 * 2745 *
@@ -2640,8 +2782,7 @@ static int e1000_open(struct net_device *netdev)
2640 * If AMT is enabled, let the firmware know that the network 2782 * If AMT is enabled, let the firmware know that the network
2641 * interface is now open 2783 * interface is now open
2642 */ 2784 */
2643 if ((adapter->flags & FLAG_HAS_AMT) && 2785 if (adapter->flags & FLAG_HAS_AMT)
2644 e1000e_check_mng_mode(&adapter->hw))
2645 e1000_get_hw_control(adapter); 2786 e1000_get_hw_control(adapter);
2646 2787
2647 /* 2788 /*
@@ -2656,6 +2797,19 @@ static int e1000_open(struct net_device *netdev)
2656 if (err) 2797 if (err)
2657 goto err_req_irq; 2798 goto err_req_irq;
2658 2799
2800 /*
2801 * Work around PCIe errata with MSI interrupts causing some chipsets to
2802 * ignore e1000e MSI messages, which means we need to test our MSI
2803 * interrupt now
2804 */
2805 {
2806 err = e1000_test_msi(adapter);
2807 if (err) {
2808 e_err("Interrupt allocation failed\n");
2809 goto err_req_irq;
2810 }
2811 }
2812
2659 /* From here on the code is the same as e1000e_up() */ 2813 /* From here on the code is the same as e1000e_up() */
2660 clear_bit(__E1000_DOWN, &adapter->state); 2814 clear_bit(__E1000_DOWN, &adapter->state);
2661 2815
@@ -2719,8 +2873,7 @@ static int e1000_close(struct net_device *netdev)
2719 * If AMT is enabled, let the firmware know that the network 2873 * If AMT is enabled, let the firmware know that the network
2720 * interface is now closed 2874 * interface is now closed
2721 */ 2875 */
2722 if ((adapter->flags & FLAG_HAS_AMT) && 2876 if (adapter->flags & FLAG_HAS_AMT)
2723 e1000e_check_mng_mode(&adapter->hw))
2724 e1000_release_hw_control(adapter); 2877 e1000_release_hw_control(adapter);
2725 2878
2726 return 0; 2879 return 0;
@@ -2765,6 +2918,21 @@ static int e1000_set_mac(struct net_device *netdev, void *p)
2765 return 0; 2918 return 0;
2766} 2919}
2767 2920
2921/**
2922 * e1000e_update_phy_task - work thread to update phy
2923 * @work: pointer to our work struct
2924 *
2925 * this worker thread exists because we must acquire a
2926 * semaphore to read the phy, which we could msleep while
2927 * waiting for it, and we can't msleep in a timer.
2928 **/
2929static void e1000e_update_phy_task(struct work_struct *work)
2930{
2931 struct e1000_adapter *adapter = container_of(work,
2932 struct e1000_adapter, update_phy_task);
2933 e1000_get_phy_info(&adapter->hw);
2934}
2935
2768/* 2936/*
2769 * Need to wait a few seconds after link up to get diagnostic information from 2937 * Need to wait a few seconds after link up to get diagnostic information from
2770 * the phy 2938 * the phy
@@ -2772,7 +2940,7 @@ static int e1000_set_mac(struct net_device *netdev, void *p)
2772static void e1000_update_phy_info(unsigned long data) 2940static void e1000_update_phy_info(unsigned long data)
2773{ 2941{
2774 struct e1000_adapter *adapter = (struct e1000_adapter *) data; 2942 struct e1000_adapter *adapter = (struct e1000_adapter *) data;
2775 e1000_get_phy_info(&adapter->hw); 2943 schedule_work(&adapter->update_phy_task);
2776} 2944}
2777 2945
2778/** 2946/**
@@ -2783,10 +2951,6 @@ void e1000e_update_stats(struct e1000_adapter *adapter)
2783{ 2951{
2784 struct e1000_hw *hw = &adapter->hw; 2952 struct e1000_hw *hw = &adapter->hw;
2785 struct pci_dev *pdev = adapter->pdev; 2953 struct pci_dev *pdev = adapter->pdev;
2786 unsigned long irq_flags;
2787 u16 phy_tmp;
2788
2789#define PHY_IDLE_ERROR_COUNT_MASK 0x00FF
2790 2954
2791 /* 2955 /*
2792 * Prevent stats update while adapter is being reset, or if the pci 2956 * Prevent stats update while adapter is being reset, or if the pci
@@ -2797,14 +2961,6 @@ void e1000e_update_stats(struct e1000_adapter *adapter)
2797 if (pci_channel_offline(pdev)) 2961 if (pci_channel_offline(pdev))
2798 return; 2962 return;
2799 2963
2800 spin_lock_irqsave(&adapter->stats_lock, irq_flags);
2801
2802 /*
2803 * these counters are modified from e1000_adjust_tbi_stats,
2804 * called from the interrupt context, so they must only
2805 * be written while holding adapter->stats_lock
2806 */
2807
2808 adapter->stats.crcerrs += er32(CRCERRS); 2964 adapter->stats.crcerrs += er32(CRCERRS);
2809 adapter->stats.gprc += er32(GPRC); 2965 adapter->stats.gprc += er32(GPRC);
2810 adapter->stats.gorc += er32(GORCL); 2966 adapter->stats.gorc += er32(GORCL);
@@ -2875,21 +3031,10 @@ void e1000e_update_stats(struct e1000_adapter *adapter)
2875 3031
2876 /* Tx Dropped needs to be maintained elsewhere */ 3032 /* Tx Dropped needs to be maintained elsewhere */
2877 3033
2878 /* Phy Stats */
2879 if (hw->phy.media_type == e1000_media_type_copper) {
2880 if ((adapter->link_speed == SPEED_1000) &&
2881 (!e1e_rphy(hw, PHY_1000T_STATUS, &phy_tmp))) {
2882 phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK;
2883 adapter->phy_stats.idle_errors += phy_tmp;
2884 }
2885 }
2886
2887 /* Management Stats */ 3034 /* Management Stats */
2888 adapter->stats.mgptc += er32(MGTPTC); 3035 adapter->stats.mgptc += er32(MGTPTC);
2889 adapter->stats.mgprc += er32(MGTPRC); 3036 adapter->stats.mgprc += er32(MGTPRC);
2890 adapter->stats.mgpdc += er32(MGTPDC); 3037 adapter->stats.mgpdc += er32(MGTPDC);
2891
2892 spin_unlock_irqrestore(&adapter->stats_lock, irq_flags);
2893} 3038}
2894 3039
2895/** 3040/**
@@ -2901,10 +3046,6 @@ static void e1000_phy_read_status(struct e1000_adapter *adapter)
2901 struct e1000_hw *hw = &adapter->hw; 3046 struct e1000_hw *hw = &adapter->hw;
2902 struct e1000_phy_regs *phy = &adapter->phy_regs; 3047 struct e1000_phy_regs *phy = &adapter->phy_regs;
2903 int ret_val; 3048 int ret_val;
2904 unsigned long irq_flags;
2905
2906
2907 spin_lock_irqsave(&adapter->stats_lock, irq_flags);
2908 3049
2909 if ((er32(STATUS) & E1000_STATUS_LU) && 3050 if ((er32(STATUS) & E1000_STATUS_LU) &&
2910 (adapter->hw.phy.media_type == e1000_media_type_copper)) { 3051 (adapter->hw.phy.media_type == e1000_media_type_copper)) {
@@ -2917,8 +3058,7 @@ static void e1000_phy_read_status(struct e1000_adapter *adapter)
2917 ret_val |= e1e_rphy(hw, PHY_1000T_STATUS, &phy->stat1000); 3058 ret_val |= e1e_rphy(hw, PHY_1000T_STATUS, &phy->stat1000);
2918 ret_val |= e1e_rphy(hw, PHY_EXT_STATUS, &phy->estatus); 3059 ret_val |= e1e_rphy(hw, PHY_EXT_STATUS, &phy->estatus);
2919 if (ret_val) 3060 if (ret_val)
2920 ndev_warn(adapter->netdev, 3061 e_warn("Error reading PHY register\n");
2921 "Error reading PHY register\n");
2922 } else { 3062 } else {
2923 /* 3063 /*
2924 * Do not read PHY registers if link is not up 3064 * Do not read PHY registers if link is not up
@@ -2936,25 +3076,21 @@ static void e1000_phy_read_status(struct e1000_adapter *adapter)
2936 phy->stat1000 = 0; 3076 phy->stat1000 = 0;
2937 phy->estatus = (ESTATUS_1000_TFULL | ESTATUS_1000_THALF); 3077 phy->estatus = (ESTATUS_1000_TFULL | ESTATUS_1000_THALF);
2938 } 3078 }
2939
2940 spin_unlock_irqrestore(&adapter->stats_lock, irq_flags);
2941} 3079}
2942 3080
2943static void e1000_print_link_info(struct e1000_adapter *adapter) 3081static void e1000_print_link_info(struct e1000_adapter *adapter)
2944{ 3082{
2945 struct e1000_hw *hw = &adapter->hw; 3083 struct e1000_hw *hw = &adapter->hw;
2946 struct net_device *netdev = adapter->netdev;
2947 u32 ctrl = er32(CTRL); 3084 u32 ctrl = er32(CTRL);
2948 3085
2949 ndev_info(netdev, 3086 e_info("Link is Up %d Mbps %s, Flow Control: %s\n",
2950 "Link is Up %d Mbps %s, Flow Control: %s\n", 3087 adapter->link_speed,
2951 adapter->link_speed, 3088 (adapter->link_duplex == FULL_DUPLEX) ?
2952 (adapter->link_duplex == FULL_DUPLEX) ? 3089 "Full Duplex" : "Half Duplex",
2953 "Full Duplex" : "Half Duplex", 3090 ((ctrl & E1000_CTRL_TFCE) && (ctrl & E1000_CTRL_RFCE)) ?
2954 ((ctrl & E1000_CTRL_TFCE) && (ctrl & E1000_CTRL_RFCE)) ? 3091 "RX/TX" :
2955 "RX/TX" : 3092 ((ctrl & E1000_CTRL_RFCE) ? "RX" :
2956 ((ctrl & E1000_CTRL_RFCE) ? "RX" : 3093 ((ctrl & E1000_CTRL_TFCE) ? "TX" : "None" )));
2957 ((ctrl & E1000_CTRL_TFCE) ? "TX" : "None" )));
2958} 3094}
2959 3095
2960static bool e1000_has_link(struct e1000_adapter *adapter) 3096static bool e1000_has_link(struct e1000_adapter *adapter)
@@ -2994,8 +3130,7 @@ static bool e1000_has_link(struct e1000_adapter *adapter)
2994 if ((ret_val == E1000_ERR_PHY) && (hw->phy.type == e1000_phy_igp_3) && 3130 if ((ret_val == E1000_ERR_PHY) && (hw->phy.type == e1000_phy_igp_3) &&
2995 (er32(CTRL) & E1000_PHY_CTRL_GBE_DISABLE)) { 3131 (er32(CTRL) & E1000_PHY_CTRL_GBE_DISABLE)) {
2996 /* See e1000_kmrn_lock_loss_workaround_ich8lan() */ 3132 /* See e1000_kmrn_lock_loss_workaround_ich8lan() */
2997 ndev_info(adapter->netdev, 3133 e_info("Gigabit has been disabled, downgrading speed\n");
2998 "Gigabit has been disabled, downgrading speed\n");
2999 } 3134 }
3000 3135
3001 return link_active; 3136 return link_active;
@@ -3067,7 +3202,7 @@ static void e1000_watchdog_task(struct work_struct *work)
3067 case SPEED_10: 3202 case SPEED_10:
3068 txb2b = 0; 3203 txb2b = 0;
3069 netdev->tx_queue_len = 10; 3204 netdev->tx_queue_len = 10;
3070 adapter->tx_timeout_factor = 14; 3205 adapter->tx_timeout_factor = 16;
3071 break; 3206 break;
3072 case SPEED_100: 3207 case SPEED_100:
3073 txb2b = 0; 3208 txb2b = 0;
@@ -3096,8 +3231,7 @@ static void e1000_watchdog_task(struct work_struct *work)
3096 switch (adapter->link_speed) { 3231 switch (adapter->link_speed) {
3097 case SPEED_10: 3232 case SPEED_10:
3098 case SPEED_100: 3233 case SPEED_100:
3099 ndev_info(netdev, 3234 e_info("10/100 speed: disabling TSO\n");
3100 "10/100 speed: disabling TSO\n");
3101 netdev->features &= ~NETIF_F_TSO; 3235 netdev->features &= ~NETIF_F_TSO;
3102 netdev->features &= ~NETIF_F_TSO6; 3236 netdev->features &= ~NETIF_F_TSO6;
3103 break; 3237 break;
@@ -3130,7 +3264,7 @@ static void e1000_watchdog_task(struct work_struct *work)
3130 if (netif_carrier_ok(netdev)) { 3264 if (netif_carrier_ok(netdev)) {
3131 adapter->link_speed = 0; 3265 adapter->link_speed = 0;
3132 adapter->link_duplex = 0; 3266 adapter->link_duplex = 0;
3133 ndev_info(netdev, "Link is Down\n"); 3267 e_info("Link is Down\n");
3134 netif_carrier_off(netdev); 3268 netif_carrier_off(netdev);
3135 netif_tx_stop_all_queues(netdev); 3269 netif_tx_stop_all_queues(netdev);
3136 if (!test_bit(__E1000_DOWN, &adapter->state)) 3270 if (!test_bit(__E1000_DOWN, &adapter->state))
@@ -3604,8 +3738,7 @@ static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
3604 3738
3605 pull_size = min((unsigned int)4, skb->data_len); 3739 pull_size = min((unsigned int)4, skb->data_len);
3606 if (!__pskb_pull_tail(skb, pull_size)) { 3740 if (!__pskb_pull_tail(skb, pull_size)) {
3607 ndev_err(netdev, 3741 e_err("__pskb_pull_tail failed.\n");
3608 "__pskb_pull_tail failed.\n");
3609 dev_kfree_skb_any(skb); 3742 dev_kfree_skb_any(skb);
3610 return NETDEV_TX_OK; 3743 return NETDEV_TX_OK;
3611 } 3744 }
@@ -3735,27 +3868,27 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
3735 struct e1000_adapter *adapter = netdev_priv(netdev); 3868 struct e1000_adapter *adapter = netdev_priv(netdev);
3736 int max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN; 3869 int max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN;
3737 3870
3738 if ((max_frame < ETH_ZLEN + ETH_FCS_LEN) || 3871 if ((new_mtu < ETH_ZLEN + ETH_FCS_LEN + VLAN_HLEN) ||
3739 (max_frame > MAX_JUMBO_FRAME_SIZE)) { 3872 (max_frame > MAX_JUMBO_FRAME_SIZE)) {
3740 ndev_err(netdev, "Invalid MTU setting\n"); 3873 e_err("Invalid MTU setting\n");
3741 return -EINVAL; 3874 return -EINVAL;
3742 } 3875 }
3743 3876
3744 /* Jumbo frame size limits */ 3877 /* Jumbo frame size limits */
3745 if (max_frame > ETH_FRAME_LEN + ETH_FCS_LEN) { 3878 if (max_frame > ETH_FRAME_LEN + ETH_FCS_LEN) {
3746 if (!(adapter->flags & FLAG_HAS_JUMBO_FRAMES)) { 3879 if (!(adapter->flags & FLAG_HAS_JUMBO_FRAMES)) {
3747 ndev_err(netdev, "Jumbo Frames not supported.\n"); 3880 e_err("Jumbo Frames not supported.\n");
3748 return -EINVAL; 3881 return -EINVAL;
3749 } 3882 }
3750 if (adapter->hw.phy.type == e1000_phy_ife) { 3883 if (adapter->hw.phy.type == e1000_phy_ife) {
3751 ndev_err(netdev, "Jumbo Frames not supported.\n"); 3884 e_err("Jumbo Frames not supported.\n");
3752 return -EINVAL; 3885 return -EINVAL;
3753 } 3886 }
3754 } 3887 }
3755 3888
3756#define MAX_STD_JUMBO_FRAME_SIZE 9234 3889#define MAX_STD_JUMBO_FRAME_SIZE 9234
3757 if (max_frame > MAX_STD_JUMBO_FRAME_SIZE) { 3890 if (max_frame > MAX_STD_JUMBO_FRAME_SIZE) {
3758 ndev_err(netdev, "MTU > 9216 not supported.\n"); 3891 e_err("MTU > 9216 not supported.\n");
3759 return -EINVAL; 3892 return -EINVAL;
3760 } 3893 }
3761 3894
@@ -3792,8 +3925,7 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
3792 adapter->rx_buffer_len = ETH_FRAME_LEN + VLAN_HLEN 3925 adapter->rx_buffer_len = ETH_FRAME_LEN + VLAN_HLEN
3793 + ETH_FCS_LEN; 3926 + ETH_FCS_LEN;
3794 3927
3795 ndev_info(netdev, "changing MTU from %d to %d\n", 3928 e_info("changing MTU from %d to %d\n", netdev->mtu, new_mtu);
3796 netdev->mtu, new_mtu);
3797 netdev->mtu = new_mtu; 3929 netdev->mtu = new_mtu;
3798 3930
3799 if (netif_running(netdev)) 3931 if (netif_running(netdev))
@@ -4006,10 +4138,7 @@ static int e1000_resume(struct pci_dev *pdev)
4006 pci_restore_state(pdev); 4138 pci_restore_state(pdev);
4007 e1000e_disable_l1aspm(pdev); 4139 e1000e_disable_l1aspm(pdev);
4008 4140
4009 if (adapter->need_ioport) 4141 err = pci_enable_device_mem(pdev);
4010 err = pci_enable_device(pdev);
4011 else
4012 err = pci_enable_device_mem(pdev);
4013 if (err) { 4142 if (err) {
4014 dev_err(&pdev->dev, 4143 dev_err(&pdev->dev,
4015 "Cannot enable PCI device from suspend\n"); 4144 "Cannot enable PCI device from suspend\n");
@@ -4043,7 +4172,7 @@ static int e1000_resume(struct pci_dev *pdev)
4043 * is up. For all other cases, let the f/w know that the h/w is now 4172 * is up. For all other cases, let the f/w know that the h/w is now
4044 * under the control of the driver. 4173 * under the control of the driver.
4045 */ 4174 */
4046 if (!(adapter->flags & FLAG_HAS_AMT) || !e1000e_check_mng_mode(&adapter->hw)) 4175 if (!(adapter->flags & FLAG_HAS_AMT))
4047 e1000_get_hw_control(adapter); 4176 e1000_get_hw_control(adapter);
4048 4177
4049 return 0; 4178 return 0;
@@ -4111,10 +4240,7 @@ static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev)
4111 int err; 4240 int err;
4112 4241
4113 e1000e_disable_l1aspm(pdev); 4242 e1000e_disable_l1aspm(pdev);
4114 if (adapter->need_ioport) 4243 err = pci_enable_device_mem(pdev);
4115 err = pci_enable_device(pdev);
4116 else
4117 err = pci_enable_device_mem(pdev);
4118 if (err) { 4244 if (err) {
4119 dev_err(&pdev->dev, 4245 dev_err(&pdev->dev,
4120 "Cannot re-enable PCI device after reset.\n"); 4246 "Cannot re-enable PCI device after reset.\n");
@@ -4162,8 +4288,7 @@ static void e1000_io_resume(struct pci_dev *pdev)
4162 * is up. For all other cases, let the f/w know that the h/w is now 4288 * is up. For all other cases, let the f/w know that the h/w is now
4163 * under the control of the driver. 4289 * under the control of the driver.
4164 */ 4290 */
4165 if (!(adapter->flags & FLAG_HAS_AMT) || 4291 if (!(adapter->flags & FLAG_HAS_AMT))
4166 !e1000e_check_mng_mode(&adapter->hw))
4167 e1000_get_hw_control(adapter); 4292 e1000_get_hw_control(adapter);
4168 4293
4169} 4294}
@@ -4175,36 +4300,40 @@ static void e1000_print_device_info(struct e1000_adapter *adapter)
4175 u32 pba_num; 4300 u32 pba_num;
4176 4301
4177 /* print bus type/speed/width info */ 4302 /* print bus type/speed/width info */
4178 ndev_info(netdev, "(PCI Express:2.5GB/s:%s) " 4303 e_info("(PCI Express:2.5GB/s:%s) %02x:%02x:%02x:%02x:%02x:%02x\n",
4179 "%02x:%02x:%02x:%02x:%02x:%02x\n", 4304 /* bus width */
4180 /* bus width */ 4305 ((hw->bus.width == e1000_bus_width_pcie_x4) ? "Width x4" :
4181 ((hw->bus.width == e1000_bus_width_pcie_x4) ? "Width x4" : 4306 "Width x1"),
4182 "Width x1"), 4307 /* MAC address */
4183 /* MAC address */ 4308 netdev->dev_addr[0], netdev->dev_addr[1],
4184 netdev->dev_addr[0], netdev->dev_addr[1], 4309 netdev->dev_addr[2], netdev->dev_addr[3],
4185 netdev->dev_addr[2], netdev->dev_addr[3], 4310 netdev->dev_addr[4], netdev->dev_addr[5]);
4186 netdev->dev_addr[4], netdev->dev_addr[5]); 4311 e_info("Intel(R) PRO/%s Network Connection\n",
4187 ndev_info(netdev, "Intel(R) PRO/%s Network Connection\n", 4312 (hw->phy.type == e1000_phy_ife) ? "10/100" : "1000");
4188 (hw->phy.type == e1000_phy_ife)
4189 ? "10/100" : "1000");
4190 e1000e_read_pba_num(hw, &pba_num); 4313 e1000e_read_pba_num(hw, &pba_num);
4191 ndev_info(netdev, "MAC: %d, PHY: %d, PBA No: %06x-%03x\n", 4314 e_info("MAC: %d, PHY: %d, PBA No: %06x-%03x\n",
4192 hw->mac.type, hw->phy.type, 4315 hw->mac.type, hw->phy.type, (pba_num >> 8), (pba_num & 0xff));
4193 (pba_num >> 8), (pba_num & 0xff));
4194} 4316}
4195 4317
4196/** 4318static void e1000_eeprom_checks(struct e1000_adapter *adapter)
4197 * e1000e_is_need_ioport - determine if an adapter needs ioport resources or not
4198 * @pdev: PCI device information struct
4199 *
4200 * Returns true if an adapters needs ioport resources
4201 **/
4202static int e1000e_is_need_ioport(struct pci_dev *pdev)
4203{ 4319{
4204 switch (pdev->device) { 4320 struct e1000_hw *hw = &adapter->hw;
4205 /* Currently there are no adapters that need ioport resources */ 4321 int ret_val;
4206 default: 4322 u16 buf = 0;
4207 return false; 4323
4324 if (hw->mac.type != e1000_82573)
4325 return;
4326
4327 ret_val = e1000_read_nvm(hw, NVM_INIT_CONTROL2_REG, 1, &buf);
4328 if (!(le16_to_cpu(buf) & (1 << 0))) {
4329 /* Deep Smart Power Down (DSPD) */
4330 e_warn("Warning: detected DSPD enabled in EEPROM\n");
4331 }
4332
4333 ret_val = e1000_read_nvm(hw, NVM_INIT_3GIO_3, 1, &buf);
4334 if (le16_to_cpu(buf) & (3 << 2)) {
4335 /* ASPM enable */
4336 e_warn("Warning: detected ASPM enabled in EEPROM\n");
4208 } 4337 }
4209} 4338}
4210 4339
@@ -4233,19 +4362,10 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
4233 int i, err, pci_using_dac; 4362 int i, err, pci_using_dac;
4234 u16 eeprom_data = 0; 4363 u16 eeprom_data = 0;
4235 u16 eeprom_apme_mask = E1000_EEPROM_APME; 4364 u16 eeprom_apme_mask = E1000_EEPROM_APME;
4236 int bars, need_ioport;
4237 4365
4238 e1000e_disable_l1aspm(pdev); 4366 e1000e_disable_l1aspm(pdev);
4239 4367
4240 /* do not allocate ioport bars when not needed */ 4368 err = pci_enable_device_mem(pdev);
4241 need_ioport = e1000e_is_need_ioport(pdev);
4242 if (need_ioport) {
4243 bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO);
4244 err = pci_enable_device(pdev);
4245 } else {
4246 bars = pci_select_bars(pdev, IORESOURCE_MEM);
4247 err = pci_enable_device_mem(pdev);
4248 }
4249 if (err) 4369 if (err)
4250 return err; 4370 return err;
4251 4371
@@ -4268,7 +4388,9 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
4268 } 4388 }
4269 } 4389 }
4270 4390
4271 err = pci_request_selected_regions(pdev, bars, e1000e_driver_name); 4391 err = pci_request_selected_regions(pdev,
4392 pci_select_bars(pdev, IORESOURCE_MEM),
4393 e1000e_driver_name);
4272 if (err) 4394 if (err)
4273 goto err_pci_reg; 4395 goto err_pci_reg;
4274 4396
@@ -4293,8 +4415,6 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
4293 adapter->hw.adapter = adapter; 4415 adapter->hw.adapter = adapter;
4294 adapter->hw.mac.type = ei->mac; 4416 adapter->hw.mac.type = ei->mac;
4295 adapter->msg_enable = (1 << NETIF_MSG_DRV | NETIF_MSG_PROBE) - 1; 4417 adapter->msg_enable = (1 << NETIF_MSG_DRV | NETIF_MSG_PROBE) - 1;
4296 adapter->bars = bars;
4297 adapter->need_ioport = need_ioport;
4298 4418
4299 mmio_start = pci_resource_start(pdev, 0); 4419 mmio_start = pci_resource_start(pdev, 0);
4300 mmio_len = pci_resource_len(pdev, 0); 4420 mmio_len = pci_resource_len(pdev, 0);
@@ -4339,6 +4459,8 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
4339 4459
4340 adapter->bd_number = cards_found++; 4460 adapter->bd_number = cards_found++;
4341 4461
4462 e1000e_check_options(adapter);
4463
4342 /* setup adapter struct */ 4464 /* setup adapter struct */
4343 err = e1000_sw_init(adapter); 4465 err = e1000_sw_init(adapter);
4344 if (err) 4466 if (err)
@@ -4354,6 +4476,10 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
4354 if (err) 4476 if (err)
4355 goto err_hw_init; 4477 goto err_hw_init;
4356 4478
4479 if ((adapter->flags & FLAG_IS_ICH) &&
4480 (adapter->flags & FLAG_READ_ONLY_NVM))
4481 e1000e_write_protect_nvm_ich8lan(&adapter->hw);
4482
4357 hw->mac.ops.get_bus_info(&adapter->hw); 4483 hw->mac.ops.get_bus_info(&adapter->hw);
4358 4484
4359 adapter->hw.phy.autoneg_wait_to_complete = 0; 4485 adapter->hw.phy.autoneg_wait_to_complete = 0;
@@ -4366,8 +4492,7 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
4366 } 4492 }
4367 4493
4368 if (e1000_check_reset_block(&adapter->hw)) 4494 if (e1000_check_reset_block(&adapter->hw))
4369 ndev_info(netdev, 4495 e_info("PHY reset is blocked due to SOL/IDER session.\n");
4370 "PHY reset is blocked due to SOL/IDER session.\n");
4371 4496
4372 netdev->features = NETIF_F_SG | 4497 netdev->features = NETIF_F_SG |
4373 NETIF_F_HW_CSUM | 4498 NETIF_F_HW_CSUM |
@@ -4411,25 +4536,26 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
4411 if (e1000_validate_nvm_checksum(&adapter->hw) >= 0) 4536 if (e1000_validate_nvm_checksum(&adapter->hw) >= 0)
4412 break; 4537 break;
4413 if (i == 2) { 4538 if (i == 2) {
4414 ndev_err(netdev, "The NVM Checksum Is Not Valid\n"); 4539 e_err("The NVM Checksum Is Not Valid\n");
4415 err = -EIO; 4540 err = -EIO;
4416 goto err_eeprom; 4541 goto err_eeprom;
4417 } 4542 }
4418 } 4543 }
4419 4544
4545 e1000_eeprom_checks(adapter);
4546
4420 /* copy the MAC address out of the NVM */ 4547 /* copy the MAC address out of the NVM */
4421 if (e1000e_read_mac_addr(&adapter->hw)) 4548 if (e1000e_read_mac_addr(&adapter->hw))
4422 ndev_err(netdev, "NVM Read Error while reading MAC address\n"); 4549 e_err("NVM Read Error while reading MAC address\n");
4423 4550
4424 memcpy(netdev->dev_addr, adapter->hw.mac.addr, netdev->addr_len); 4551 memcpy(netdev->dev_addr, adapter->hw.mac.addr, netdev->addr_len);
4425 memcpy(netdev->perm_addr, adapter->hw.mac.addr, netdev->addr_len); 4552 memcpy(netdev->perm_addr, adapter->hw.mac.addr, netdev->addr_len);
4426 4553
4427 if (!is_valid_ether_addr(netdev->perm_addr)) { 4554 if (!is_valid_ether_addr(netdev->perm_addr)) {
4428 ndev_err(netdev, "Invalid MAC Address: " 4555 e_err("Invalid MAC Address: %02x:%02x:%02x:%02x:%02x:%02x\n",
4429 "%02x:%02x:%02x:%02x:%02x:%02x\n", 4556 netdev->perm_addr[0], netdev->perm_addr[1],
4430 netdev->perm_addr[0], netdev->perm_addr[1], 4557 netdev->perm_addr[2], netdev->perm_addr[3],
4431 netdev->perm_addr[2], netdev->perm_addr[3], 4558 netdev->perm_addr[4], netdev->perm_addr[5]);
4432 netdev->perm_addr[4], netdev->perm_addr[5]);
4433 err = -EIO; 4559 err = -EIO;
4434 goto err_eeprom; 4560 goto err_eeprom;
4435 } 4561 }
@@ -4444,8 +4570,8 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
4444 4570
4445 INIT_WORK(&adapter->reset_task, e1000_reset_task); 4571 INIT_WORK(&adapter->reset_task, e1000_reset_task);
4446 INIT_WORK(&adapter->watchdog_task, e1000_watchdog_task); 4572 INIT_WORK(&adapter->watchdog_task, e1000_watchdog_task);
4447 4573 INIT_WORK(&adapter->downshift_task, e1000e_downshift_workaround);
4448 e1000e_check_options(adapter); 4574 INIT_WORK(&adapter->update_phy_task, e1000e_update_phy_task);
4449 4575
4450 /* Initialize link parameters. User can change them with ethtool */ 4576 /* Initialize link parameters. User can change them with ethtool */
4451 adapter->hw.mac.autoneg = 1; 4577 adapter->hw.mac.autoneg = 1;
@@ -4499,8 +4625,7 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
4499 * is up. For all other cases, let the f/w know that the h/w is now 4625 * is up. For all other cases, let the f/w know that the h/w is now
4500 * under the control of the driver. 4626 * under the control of the driver.
4501 */ 4627 */
4502 if (!(adapter->flags & FLAG_HAS_AMT) || 4628 if (!(adapter->flags & FLAG_HAS_AMT))
4503 !e1000e_check_mng_mode(&adapter->hw))
4504 e1000_get_hw_control(adapter); 4629 e1000_get_hw_control(adapter);
4505 4630
4506 /* tell the stack to leave us alone until e1000_open() is called */ 4631 /* tell the stack to leave us alone until e1000_open() is called */
@@ -4517,24 +4642,25 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
4517 return 0; 4642 return 0;
4518 4643
4519err_register: 4644err_register:
4520err_hw_init: 4645 if (!(adapter->flags & FLAG_HAS_AMT))
4521 e1000_release_hw_control(adapter); 4646 e1000_release_hw_control(adapter);
4522err_eeprom: 4647err_eeprom:
4523 if (!e1000_check_reset_block(&adapter->hw)) 4648 if (!e1000_check_reset_block(&adapter->hw))
4524 e1000_phy_hw_reset(&adapter->hw); 4649 e1000_phy_hw_reset(&adapter->hw);
4650err_hw_init:
4525 4651
4526 if (adapter->hw.flash_address)
4527 iounmap(adapter->hw.flash_address);
4528
4529err_flashmap:
4530 kfree(adapter->tx_ring); 4652 kfree(adapter->tx_ring);
4531 kfree(adapter->rx_ring); 4653 kfree(adapter->rx_ring);
4532err_sw_init: 4654err_sw_init:
4655 if (adapter->hw.flash_address)
4656 iounmap(adapter->hw.flash_address);
4657err_flashmap:
4533 iounmap(adapter->hw.hw_addr); 4658 iounmap(adapter->hw.hw_addr);
4534err_ioremap: 4659err_ioremap:
4535 free_netdev(netdev); 4660 free_netdev(netdev);
4536err_alloc_etherdev: 4661err_alloc_etherdev:
4537 pci_release_selected_regions(pdev, bars); 4662 pci_release_selected_regions(pdev,
4663 pci_select_bars(pdev, IORESOURCE_MEM));
4538err_pci_reg: 4664err_pci_reg:
4539err_dma: 4665err_dma:
4540 pci_disable_device(pdev); 4666 pci_disable_device(pdev);
@@ -4582,7 +4708,8 @@ static void __devexit e1000_remove(struct pci_dev *pdev)
4582 iounmap(adapter->hw.hw_addr); 4708 iounmap(adapter->hw.hw_addr);
4583 if (adapter->hw.flash_address) 4709 if (adapter->hw.flash_address)
4584 iounmap(adapter->hw.flash_address); 4710 iounmap(adapter->hw.flash_address);
4585 pci_release_selected_regions(pdev, adapter->bars); 4711 pci_release_selected_regions(pdev,
4712 pci_select_bars(pdev, IORESOURCE_MEM));
4586 4713
4587 free_netdev(netdev); 4714 free_netdev(netdev);
4588 4715
diff --git a/drivers/net/e1000e/param.c b/drivers/net/e1000e/param.c
index a66b92efcf80..d91dbf7ba434 100644
--- a/drivers/net/e1000e/param.c
+++ b/drivers/net/e1000e/param.c
@@ -27,6 +27,7 @@
27*******************************************************************************/ 27*******************************************************************************/
28 28
29#include <linux/netdevice.h> 29#include <linux/netdevice.h>
30#include <linux/pci.h>
30 31
31#include "e1000.h" 32#include "e1000.h"
32 33
@@ -132,6 +133,15 @@ E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down");
132 */ 133 */
133E1000_PARAM(KumeranLockLoss, "Enable Kumeran lock loss workaround"); 134E1000_PARAM(KumeranLockLoss, "Enable Kumeran lock loss workaround");
134 135
136/*
137 * Write Protect NVM
138 *
139 * Valid Range: 0, 1
140 *
141 * Default Value: 1 (enabled)
142 */
143E1000_PARAM(WriteProtectNVM, "Write-protect NVM [WARNING: disabling this can lead to corrupted NVM]");
144
135struct e1000_option { 145struct e1000_option {
136 enum { enable_option, range_option, list_option } type; 146 enum { enable_option, range_option, list_option } type;
137 const char *name; 147 const char *name;
@@ -162,17 +172,16 @@ static int __devinit e1000_validate_option(unsigned int *value,
162 case enable_option: 172 case enable_option:
163 switch (*value) { 173 switch (*value) {
164 case OPTION_ENABLED: 174 case OPTION_ENABLED:
165 ndev_info(adapter->netdev, "%s Enabled\n", opt->name); 175 e_info("%s Enabled\n", opt->name);
166 return 0; 176 return 0;
167 case OPTION_DISABLED: 177 case OPTION_DISABLED:
168 ndev_info(adapter->netdev, "%s Disabled\n", opt->name); 178 e_info("%s Disabled\n", opt->name);
169 return 0; 179 return 0;
170 } 180 }
171 break; 181 break;
172 case range_option: 182 case range_option:
173 if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) { 183 if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) {
174 ndev_info(adapter->netdev, 184 e_info("%s set to %i\n", opt->name, *value);
175 "%s set to %i\n", opt->name, *value);
176 return 0; 185 return 0;
177 } 186 }
178 break; 187 break;
@@ -184,8 +193,7 @@ static int __devinit e1000_validate_option(unsigned int *value,
184 ent = &opt->arg.l.p[i]; 193 ent = &opt->arg.l.p[i];
185 if (*value == ent->i) { 194 if (*value == ent->i) {
186 if (ent->str[0] != '\0') 195 if (ent->str[0] != '\0')
187 ndev_info(adapter->netdev, "%s\n", 196 e_info("%s\n", ent->str);
188 ent->str);
189 return 0; 197 return 0;
190 } 198 }
191 } 199 }
@@ -195,8 +203,8 @@ static int __devinit e1000_validate_option(unsigned int *value,
195 BUG(); 203 BUG();
196 } 204 }
197 205
198 ndev_info(adapter->netdev, "Invalid %s value specified (%i) %s\n", 206 e_info("Invalid %s value specified (%i) %s\n", opt->name, *value,
199 opt->name, *value, opt->err); 207 opt->err);
200 *value = opt->def; 208 *value = opt->def;
201 return -1; 209 return -1;
202} 210}
@@ -213,13 +221,11 @@ static int __devinit e1000_validate_option(unsigned int *value,
213void __devinit e1000e_check_options(struct e1000_adapter *adapter) 221void __devinit e1000e_check_options(struct e1000_adapter *adapter)
214{ 222{
215 struct e1000_hw *hw = &adapter->hw; 223 struct e1000_hw *hw = &adapter->hw;
216 struct net_device *netdev = adapter->netdev;
217 int bd = adapter->bd_number; 224 int bd = adapter->bd_number;
218 225
219 if (bd >= E1000_MAX_NIC) { 226 if (bd >= E1000_MAX_NIC) {
220 ndev_notice(netdev, 227 e_notice("Warning: no configuration for board #%i\n", bd);
221 "Warning: no configuration for board #%i\n", bd); 228 e_notice("Using defaults for all values\n");
222 ndev_notice(netdev, "Using defaults for all values\n");
223 } 229 }
224 230
225 { /* Transmit Interrupt Delay */ 231 { /* Transmit Interrupt Delay */
@@ -313,32 +319,41 @@ void __devinit e1000e_check_options(struct e1000_adapter *adapter)
313 adapter->itr = InterruptThrottleRate[bd]; 319 adapter->itr = InterruptThrottleRate[bd];
314 switch (adapter->itr) { 320 switch (adapter->itr) {
315 case 0: 321 case 0:
316 ndev_info(netdev, "%s turned off\n", 322 e_info("%s turned off\n", opt.name);
317 opt.name);
318 break; 323 break;
319 case 1: 324 case 1:
320 ndev_info(netdev, 325 e_info("%s set to dynamic mode\n", opt.name);
321 "%s set to dynamic mode\n",
322 opt.name);
323 adapter->itr_setting = adapter->itr; 326 adapter->itr_setting = adapter->itr;
324 adapter->itr = 20000; 327 adapter->itr = 20000;
325 break; 328 break;
326 case 3: 329 case 3:
327 ndev_info(netdev, 330 e_info("%s set to dynamic conservative mode\n",
328 "%s set to dynamic conservative mode\n",
329 opt.name); 331 opt.name);
330 adapter->itr_setting = adapter->itr; 332 adapter->itr_setting = adapter->itr;
331 adapter->itr = 20000; 333 adapter->itr = 20000;
332 break; 334 break;
333 default: 335 default:
334 e1000_validate_option(&adapter->itr, &opt,
335 adapter);
336 /* 336 /*
337 * save the setting, because the dynamic bits 337 * Save the setting, because the dynamic bits
338 * change itr. clear the lower two bits 338 * change itr.
339 * because they are used as control
340 */ 339 */
341 adapter->itr_setting = adapter->itr & ~3; 340 if (e1000_validate_option(&adapter->itr, &opt,
341 adapter) &&
342 (adapter->itr == 3)) {
343 /*
344 * In case of invalid user value,
345 * default to conservative mode.
346 */
347 adapter->itr_setting = adapter->itr;
348 adapter->itr = 20000;
349 } else {
350 /*
351 * Clear the lower two bits because
352 * they are used as control.
353 */
354 adapter->itr_setting =
355 adapter->itr & ~3;
356 }
342 break; 357 break;
343 } 358 }
344 } else { 359 } else {
@@ -382,4 +397,25 @@ void __devinit e1000e_check_options(struct e1000_adapter *adapter)
382 opt.def); 397 opt.def);
383 } 398 }
384 } 399 }
400 { /* Write-protect NVM */
401 const struct e1000_option opt = {
402 .type = enable_option,
403 .name = "Write-protect NVM",
404 .err = "defaulting to Enabled",
405 .def = OPTION_ENABLED
406 };
407
408 if (adapter->flags & FLAG_IS_ICH) {
409 if (num_WriteProtectNVM > bd) {
410 unsigned int write_protect_nvm = WriteProtectNVM[bd];
411 e1000_validate_option(&write_protect_nvm, &opt,
412 adapter);
413 if (write_protect_nvm)
414 adapter->flags |= FLAG_READ_ONLY_NVM;
415 } else {
416 if (opt.def)
417 adapter->flags |= FLAG_READ_ONLY_NVM;
418 }
419 }
420 }
385} 421}
generated by cgit v1.2.2 (git 2.25.0) at 2026-01-07 20:34:56 -0500