aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/e1000e
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/e1000e')
-rw-r--r--drivers/net/e1000e/82571.c273
-rw-r--r--drivers/net/e1000e/defines.h1
-rw-r--r--drivers/net/e1000e/e1000.h4
-rw-r--r--drivers/net/e1000e/ethtool.c3
-rw-r--r--drivers/net/e1000e/hw.h10
-rw-r--r--drivers/net/e1000e/ich8lan.c17
-rw-r--r--drivers/net/e1000e/lib.c4
-rw-r--r--drivers/net/e1000e/netdev.c225
8 files changed, 369 insertions, 168 deletions
diff --git a/drivers/net/e1000e/82571.c b/drivers/net/e1000e/82571.c
index 0890162953e9..6c01a2072c87 100644
--- a/drivers/net/e1000e/82571.c
+++ b/drivers/net/e1000e/82571.c
@@ -40,6 +40,7 @@
40 * 82573E Gigabit Ethernet Controller (Copper) 40 * 82573E Gigabit Ethernet Controller (Copper)
41 * 82573L Gigabit Ethernet Controller 41 * 82573L Gigabit Ethernet Controller
42 * 82574L Gigabit Network Connection 42 * 82574L Gigabit Network Connection
43 * 82583V Gigabit Network Connection
43 */ 44 */
44 45
45#include <linux/netdevice.h> 46#include <linux/netdevice.h>
@@ -61,6 +62,7 @@
61static s32 e1000_get_phy_id_82571(struct e1000_hw *hw); 62static s32 e1000_get_phy_id_82571(struct e1000_hw *hw);
62static s32 e1000_setup_copper_link_82571(struct e1000_hw *hw); 63static s32 e1000_setup_copper_link_82571(struct e1000_hw *hw);
63static s32 e1000_setup_fiber_serdes_link_82571(struct e1000_hw *hw); 64static s32 e1000_setup_fiber_serdes_link_82571(struct e1000_hw *hw);
65static s32 e1000_check_for_serdes_link_82571(struct e1000_hw *hw);
64static s32 e1000_write_nvm_eewr_82571(struct e1000_hw *hw, u16 offset, 66static s32 e1000_write_nvm_eewr_82571(struct e1000_hw *hw, u16 offset,
65 u16 words, u16 *data); 67 u16 words, u16 *data);
66static s32 e1000_fix_nvm_checksum_82571(struct e1000_hw *hw); 68static s32 e1000_fix_nvm_checksum_82571(struct e1000_hw *hw);
@@ -99,6 +101,7 @@ static s32 e1000_init_phy_params_82571(struct e1000_hw *hw)
99 phy->type = e1000_phy_m88; 101 phy->type = e1000_phy_m88;
100 break; 102 break;
101 case e1000_82574: 103 case e1000_82574:
104 case e1000_82583:
102 phy->type = e1000_phy_bm; 105 phy->type = e1000_phy_bm;
103 break; 106 break;
104 default: 107 default:
@@ -121,6 +124,7 @@ static s32 e1000_init_phy_params_82571(struct e1000_hw *hw)
121 return -E1000_ERR_PHY; 124 return -E1000_ERR_PHY;
122 break; 125 break;
123 case e1000_82574: 126 case e1000_82574:
127 case e1000_82583:
124 if (phy->id != BME1000_E_PHY_ID_R2) 128 if (phy->id != BME1000_E_PHY_ID_R2)
125 return -E1000_ERR_PHY; 129 return -E1000_ERR_PHY;
126 break; 130 break;
@@ -164,6 +168,7 @@ static s32 e1000_init_nvm_params_82571(struct e1000_hw *hw)
164 switch (hw->mac.type) { 168 switch (hw->mac.type) {
165 case e1000_82573: 169 case e1000_82573:
166 case e1000_82574: 170 case e1000_82574:
171 case e1000_82583:
167 if (((eecd >> 15) & 0x3) == 0x3) { 172 if (((eecd >> 15) & 0x3) == 0x3) {
168 nvm->type = e1000_nvm_flash_hw; 173 nvm->type = e1000_nvm_flash_hw;
169 nvm->word_size = 2048; 174 nvm->word_size = 2048;
@@ -250,7 +255,7 @@ static s32 e1000_init_mac_params_82571(struct e1000_adapter *adapter)
250 case e1000_media_type_internal_serdes: 255 case e1000_media_type_internal_serdes:
251 func->setup_physical_interface = 256 func->setup_physical_interface =
252 e1000_setup_fiber_serdes_link_82571; 257 e1000_setup_fiber_serdes_link_82571;
253 func->check_for_link = e1000e_check_for_serdes_link; 258 func->check_for_link = e1000_check_for_serdes_link_82571;
254 func->get_link_up_info = 259 func->get_link_up_info =
255 e1000e_get_speed_and_duplex_fiber_serdes; 260 e1000e_get_speed_and_duplex_fiber_serdes;
256 break; 261 break;
@@ -261,6 +266,7 @@ static s32 e1000_init_mac_params_82571(struct e1000_adapter *adapter)
261 266
262 switch (hw->mac.type) { 267 switch (hw->mac.type) {
263 case e1000_82574: 268 case e1000_82574:
269 case e1000_82583:
264 func->check_mng_mode = e1000_check_mng_mode_82574; 270 func->check_mng_mode = e1000_check_mng_mode_82574;
265 func->led_on = e1000_led_on_82574; 271 func->led_on = e1000_led_on_82574;
266 break; 272 break;
@@ -374,6 +380,7 @@ static s32 e1000_get_phy_id_82571(struct e1000_hw *hw)
374 return e1000e_get_phy_id(hw); 380 return e1000e_get_phy_id(hw);
375 break; 381 break;
376 case e1000_82574: 382 case e1000_82574:
383 case e1000_82583:
377 ret_val = e1e_rphy(hw, PHY_ID1, &phy_id); 384 ret_val = e1e_rphy(hw, PHY_ID1, &phy_id);
378 if (ret_val) 385 if (ret_val)
379 return ret_val; 386 return ret_val;
@@ -463,8 +470,15 @@ static s32 e1000_acquire_nvm_82571(struct e1000_hw *hw)
463 if (ret_val) 470 if (ret_val)
464 return ret_val; 471 return ret_val;
465 472
466 if (hw->mac.type != e1000_82573 && hw->mac.type != e1000_82574) 473 switch (hw->mac.type) {
474 case e1000_82573:
475 case e1000_82574:
476 case e1000_82583:
477 break;
478 default:
467 ret_val = e1000e_acquire_nvm(hw); 479 ret_val = e1000e_acquire_nvm(hw);
480 break;
481 }
468 482
469 if (ret_val) 483 if (ret_val)
470 e1000_put_hw_semaphore_82571(hw); 484 e1000_put_hw_semaphore_82571(hw);
@@ -504,6 +518,7 @@ static s32 e1000_write_nvm_82571(struct e1000_hw *hw, u16 offset, u16 words,
504 switch (hw->mac.type) { 518 switch (hw->mac.type) {
505 case e1000_82573: 519 case e1000_82573:
506 case e1000_82574: 520 case e1000_82574:
521 case e1000_82583:
507 ret_val = e1000_write_nvm_eewr_82571(hw, offset, words, data); 522 ret_val = e1000_write_nvm_eewr_82571(hw, offset, words, data);
508 break; 523 break;
509 case e1000_82571: 524 case e1000_82571:
@@ -778,7 +793,10 @@ static s32 e1000_reset_hw_82571(struct e1000_hw *hw)
778 * Must acquire the MDIO ownership before MAC reset. 793 * Must acquire the MDIO ownership before MAC reset.
779 * Ownership defaults to firmware after a reset. 794 * Ownership defaults to firmware after a reset.
780 */ 795 */
781 if (hw->mac.type == e1000_82573 || hw->mac.type == e1000_82574) { 796 switch (hw->mac.type) {
797 case e1000_82573:
798 case e1000_82574:
799 case e1000_82583:
782 extcnf_ctrl = er32(EXTCNF_CTRL); 800 extcnf_ctrl = er32(EXTCNF_CTRL);
783 extcnf_ctrl |= E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP; 801 extcnf_ctrl |= E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP;
784 802
@@ -794,6 +812,9 @@ static s32 e1000_reset_hw_82571(struct e1000_hw *hw)
794 msleep(2); 812 msleep(2);
795 i++; 813 i++;
796 } while (i < MDIO_OWNERSHIP_TIMEOUT); 814 } while (i < MDIO_OWNERSHIP_TIMEOUT);
815 break;
816 default:
817 break;
797 } 818 }
798 819
799 ctrl = er32(CTRL); 820 ctrl = er32(CTRL);
@@ -819,8 +840,16 @@ static s32 e1000_reset_hw_82571(struct e1000_hw *hw)
819 * Need to wait for Phy configuration completion before accessing 840 * Need to wait for Phy configuration completion before accessing
820 * NVM and Phy. 841 * NVM and Phy.
821 */ 842 */
822 if (hw->mac.type == e1000_82573 || hw->mac.type == e1000_82574) 843
844 switch (hw->mac.type) {
845 case e1000_82573:
846 case e1000_82574:
847 case e1000_82583:
823 msleep(25); 848 msleep(25);
849 break;
850 default:
851 break;
852 }
824 853
825 /* Clear any pending interrupt events. */ 854 /* Clear any pending interrupt events. */
826 ew32(IMC, 0xffffffff); 855 ew32(IMC, 0xffffffff);
@@ -830,6 +859,10 @@ static s32 e1000_reset_hw_82571(struct e1000_hw *hw)
830 hw->dev_spec.e82571.alt_mac_addr_is_present) 859 hw->dev_spec.e82571.alt_mac_addr_is_present)
831 e1000e_set_laa_state_82571(hw, true); 860 e1000e_set_laa_state_82571(hw, true);
832 861
862 /* Reinitialize the 82571 serdes link state machine */
863 if (hw->phy.media_type == e1000_media_type_internal_serdes)
864 hw->mac.serdes_link_state = e1000_serdes_link_down;
865
833 return 0; 866 return 0;
834} 867}
835 868
@@ -886,17 +919,22 @@ static s32 e1000_init_hw_82571(struct e1000_hw *hw)
886 ew32(TXDCTL(0), reg_data); 919 ew32(TXDCTL(0), reg_data);
887 920
888 /* ...for both queues. */ 921 /* ...for both queues. */
889 if (mac->type != e1000_82573 && mac->type != e1000_82574) { 922 switch (mac->type) {
923 case e1000_82573:
924 case e1000_82574:
925 case e1000_82583:
926 e1000e_enable_tx_pkt_filtering(hw);
927 reg_data = er32(GCR);
928 reg_data |= E1000_GCR_L1_ACT_WITHOUT_L0S_RX;
929 ew32(GCR, reg_data);
930 break;
931 default:
890 reg_data = er32(TXDCTL(1)); 932 reg_data = er32(TXDCTL(1));
891 reg_data = (reg_data & ~E1000_TXDCTL_WTHRESH) | 933 reg_data = (reg_data & ~E1000_TXDCTL_WTHRESH) |
892 E1000_TXDCTL_FULL_TX_DESC_WB | 934 E1000_TXDCTL_FULL_TX_DESC_WB |
893 E1000_TXDCTL_COUNT_DESC; 935 E1000_TXDCTL_COUNT_DESC;
894 ew32(TXDCTL(1), reg_data); 936 ew32(TXDCTL(1), reg_data);
895 } else { 937 break;
896 e1000e_enable_tx_pkt_filtering(hw);
897 reg_data = er32(GCR);
898 reg_data |= E1000_GCR_L1_ACT_WITHOUT_L0S_RX;
899 ew32(GCR, reg_data);
900 } 938 }
901 939
902 /* 940 /*
@@ -961,18 +999,30 @@ static void e1000_initialize_hw_bits_82571(struct e1000_hw *hw)
961 } 999 }
962 1000
963 /* Device Control */ 1001 /* Device Control */
964 if (hw->mac.type == e1000_82573 || hw->mac.type == e1000_82574) { 1002 switch (hw->mac.type) {
1003 case e1000_82573:
1004 case e1000_82574:
1005 case e1000_82583:
965 reg = er32(CTRL); 1006 reg = er32(CTRL);
966 reg &= ~(1 << 29); 1007 reg &= ~(1 << 29);
967 ew32(CTRL, reg); 1008 ew32(CTRL, reg);
1009 break;
1010 default:
1011 break;
968 } 1012 }
969 1013
970 /* Extended Device Control */ 1014 /* Extended Device Control */
971 if (hw->mac.type == e1000_82573 || hw->mac.type == e1000_82574) { 1015 switch (hw->mac.type) {
1016 case e1000_82573:
1017 case e1000_82574:
1018 case e1000_82583:
972 reg = er32(CTRL_EXT); 1019 reg = er32(CTRL_EXT);
973 reg &= ~(1 << 23); 1020 reg &= ~(1 << 23);
974 reg |= (1 << 22); 1021 reg |= (1 << 22);
975 ew32(CTRL_EXT, reg); 1022 ew32(CTRL_EXT, reg);
1023 break;
1024 default:
1025 break;
976 } 1026 }
977 1027
978 if (hw->mac.type == e1000_82571) { 1028 if (hw->mac.type == e1000_82571) {
@@ -980,9 +1030,23 @@ static void e1000_initialize_hw_bits_82571(struct e1000_hw *hw)
980 reg |= E1000_PBA_ECC_CORR_EN; 1030 reg |= E1000_PBA_ECC_CORR_EN;
981 ew32(PBA_ECC, reg); 1031 ew32(PBA_ECC, reg);
982 } 1032 }
1033 /*
1034 * Workaround for hardware errata.
1035 * Ensure that DMA Dynamic Clock gating is disabled on 82571 and 82572
1036 */
1037
1038 if ((hw->mac.type == e1000_82571) ||
1039 (hw->mac.type == e1000_82572)) {
1040 reg = er32(CTRL_EXT);
1041 reg &= ~E1000_CTRL_EXT_DMA_DYN_CLK_EN;
1042 ew32(CTRL_EXT, reg);
1043 }
1044
983 1045
984 /* PCI-Ex Control Registers */ 1046 /* PCI-Ex Control Registers */
985 if (hw->mac.type == e1000_82574) { 1047 switch (hw->mac.type) {
1048 case e1000_82574:
1049 case e1000_82583:
986 reg = er32(GCR); 1050 reg = er32(GCR);
987 reg |= (1 << 22); 1051 reg |= (1 << 22);
988 ew32(GCR, reg); 1052 ew32(GCR, reg);
@@ -990,6 +1054,9 @@ static void e1000_initialize_hw_bits_82571(struct e1000_hw *hw)
990 reg = er32(GCR2); 1054 reg = er32(GCR2);
991 reg |= 1; 1055 reg |= 1;
992 ew32(GCR2, reg); 1056 ew32(GCR2, reg);
1057 break;
1058 default:
1059 break;
993 } 1060 }
994 1061
995 return; 1062 return;
@@ -1009,7 +1076,10 @@ void e1000e_clear_vfta(struct e1000_hw *hw)
1009 u32 vfta_offset = 0; 1076 u32 vfta_offset = 0;
1010 u32 vfta_bit_in_reg = 0; 1077 u32 vfta_bit_in_reg = 0;
1011 1078
1012 if (hw->mac.type == e1000_82573 || hw->mac.type == e1000_82574) { 1079 switch (hw->mac.type) {
1080 case e1000_82573:
1081 case e1000_82574:
1082 case e1000_82583:
1013 if (hw->mng_cookie.vlan_id != 0) { 1083 if (hw->mng_cookie.vlan_id != 0) {
1014 /* 1084 /*
1015 * The VFTA is a 4096b bit-field, each identifying 1085 * The VFTA is a 4096b bit-field, each identifying
@@ -1024,6 +1094,9 @@ void e1000e_clear_vfta(struct e1000_hw *hw)
1024 vfta_bit_in_reg = 1 << (hw->mng_cookie.vlan_id & 1094 vfta_bit_in_reg = 1 << (hw->mng_cookie.vlan_id &
1025 E1000_VFTA_ENTRY_BIT_SHIFT_MASK); 1095 E1000_VFTA_ENTRY_BIT_SHIFT_MASK);
1026 } 1096 }
1097 break;
1098 default:
1099 break;
1027 } 1100 }
1028 for (offset = 0; offset < E1000_VLAN_FILTER_TBL_SIZE; offset++) { 1101 for (offset = 0; offset < E1000_VLAN_FILTER_TBL_SIZE; offset++) {
1029 /* 1102 /*
@@ -1122,9 +1195,16 @@ static s32 e1000_setup_link_82571(struct e1000_hw *hw)
1122 * the default flow control setting, so we explicitly 1195 * the default flow control setting, so we explicitly
1123 * set it to full. 1196 * set it to full.
1124 */ 1197 */
1125 if ((hw->mac.type == e1000_82573 || hw->mac.type == e1000_82574) && 1198 switch (hw->mac.type) {
1126 hw->fc.requested_mode == e1000_fc_default) 1199 case e1000_82573:
1127 hw->fc.requested_mode = e1000_fc_full; 1200 case e1000_82574:
1201 case e1000_82583:
1202 if (hw->fc.requested_mode == e1000_fc_default)
1203 hw->fc.requested_mode = e1000_fc_full;
1204 break;
1205 default:
1206 break;
1207 }
1128 1208
1129 return e1000e_setup_link(hw); 1209 return e1000e_setup_link(hw);
1130} 1210}
@@ -1203,6 +1283,131 @@ static s32 e1000_setup_fiber_serdes_link_82571(struct e1000_hw *hw)
1203} 1283}
1204 1284
1205/** 1285/**
1286 * e1000_check_for_serdes_link_82571 - Check for link (Serdes)
1287 * @hw: pointer to the HW structure
1288 *
1289 * Checks for link up on the hardware. If link is not up and we have
1290 * a signal, then we need to force link up.
1291 **/
1292static s32 e1000_check_for_serdes_link_82571(struct e1000_hw *hw)
1293{
1294 struct e1000_mac_info *mac = &hw->mac;
1295 u32 rxcw;
1296 u32 ctrl;
1297 u32 status;
1298 s32 ret_val = 0;
1299
1300 ctrl = er32(CTRL);
1301 status = er32(STATUS);
1302 rxcw = er32(RXCW);
1303
1304 if ((rxcw & E1000_RXCW_SYNCH) && !(rxcw & E1000_RXCW_IV)) {
1305
1306 /* Receiver is synchronized with no invalid bits. */
1307 switch (mac->serdes_link_state) {
1308 case e1000_serdes_link_autoneg_complete:
1309 if (!(status & E1000_STATUS_LU)) {
1310 /*
1311 * We have lost link, retry autoneg before
1312 * reporting link failure
1313 */
1314 mac->serdes_link_state =
1315 e1000_serdes_link_autoneg_progress;
1316 hw_dbg(hw, "AN_UP -> AN_PROG\n");
1317 }
1318 break;
1319
1320 case e1000_serdes_link_forced_up:
1321 /*
1322 * If we are receiving /C/ ordered sets, re-enable
1323 * auto-negotiation in the TXCW register and disable
1324 * forced link in the Device Control register in an
1325 * attempt to auto-negotiate with our link partner.
1326 */
1327 if (rxcw & E1000_RXCW_C) {
1328 /* Enable autoneg, and unforce link up */
1329 ew32(TXCW, mac->txcw);
1330 ew32(CTRL,
1331 (ctrl & ~E1000_CTRL_SLU));
1332 mac->serdes_link_state =
1333 e1000_serdes_link_autoneg_progress;
1334 hw_dbg(hw, "FORCED_UP -> AN_PROG\n");
1335 }
1336 break;
1337
1338 case e1000_serdes_link_autoneg_progress:
1339 /*
1340 * If the LU bit is set in the STATUS register,
1341 * autoneg has completed sucessfully. If not,
1342 * try foring the link because the far end may be
1343 * available but not capable of autonegotiation.
1344 */
1345 if (status & E1000_STATUS_LU) {
1346 mac->serdes_link_state =
1347 e1000_serdes_link_autoneg_complete;
1348 hw_dbg(hw, "AN_PROG -> AN_UP\n");
1349 } else {
1350 /*
1351 * Disable autoneg, force link up and
1352 * full duplex, and change state to forced
1353 */
1354 ew32(TXCW,
1355 (mac->txcw & ~E1000_TXCW_ANE));
1356 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FD);
1357 ew32(CTRL, ctrl);
1358
1359 /* Configure Flow Control after link up. */
1360 ret_val =
1361 e1000e_config_fc_after_link_up(hw);
1362 if (ret_val) {
1363 hw_dbg(hw, "Error config flow control\n");
1364 break;
1365 }
1366 mac->serdes_link_state =
1367 e1000_serdes_link_forced_up;
1368 hw_dbg(hw, "AN_PROG -> FORCED_UP\n");
1369 }
1370 mac->serdes_has_link = true;
1371 break;
1372
1373 case e1000_serdes_link_down:
1374 default:
1375 /* The link was down but the receiver has now gained
1376 * valid sync, so lets see if we can bring the link
1377 * up. */
1378 ew32(TXCW, mac->txcw);
1379 ew32(CTRL,
1380 (ctrl & ~E1000_CTRL_SLU));
1381 mac->serdes_link_state =
1382 e1000_serdes_link_autoneg_progress;
1383 hw_dbg(hw, "DOWN -> AN_PROG\n");
1384 break;
1385 }
1386 } else {
1387 if (!(rxcw & E1000_RXCW_SYNCH)) {
1388 mac->serdes_has_link = false;
1389 mac->serdes_link_state = e1000_serdes_link_down;
1390 hw_dbg(hw, "ANYSTATE -> DOWN\n");
1391 } else {
1392 /*
1393 * We have sync, and can tolerate one
1394 * invalid (IV) codeword before declaring
1395 * link down, so reread to look again
1396 */
1397 udelay(10);
1398 rxcw = er32(RXCW);
1399 if (rxcw & E1000_RXCW_IV) {
1400 mac->serdes_link_state = e1000_serdes_link_down;
1401 mac->serdes_has_link = false;
1402 hw_dbg(hw, "ANYSTATE -> DOWN\n");
1403 }
1404 }
1405 }
1406
1407 return ret_val;
1408}
1409
1410/**
1206 * e1000_valid_led_default_82571 - Verify a valid default LED config 1411 * e1000_valid_led_default_82571 - Verify a valid default LED config
1207 * @hw: pointer to the HW structure 1412 * @hw: pointer to the HW structure
1208 * @data: pointer to the NVM (EEPROM) 1413 * @data: pointer to the NVM (EEPROM)
@@ -1220,11 +1425,19 @@ static s32 e1000_valid_led_default_82571(struct e1000_hw *hw, u16 *data)
1220 return ret_val; 1425 return ret_val;
1221 } 1426 }
1222 1427
1223 if ((hw->mac.type == e1000_82573 || hw->mac.type == e1000_82574) && 1428 switch (hw->mac.type) {
1224 *data == ID_LED_RESERVED_F746) 1429 case e1000_82573:
1225 *data = ID_LED_DEFAULT_82573; 1430 case e1000_82574:
1226 else if (*data == ID_LED_RESERVED_0000 || *data == ID_LED_RESERVED_FFFF) 1431 case e1000_82583:
1227 *data = ID_LED_DEFAULT; 1432 if (*data == ID_LED_RESERVED_F746)
1433 *data = ID_LED_DEFAULT_82573;
1434 break;
1435 default:
1436 if (*data == ID_LED_RESERVED_0000 ||
1437 *data == ID_LED_RESERVED_FFFF)
1438 *data = ID_LED_DEFAULT;
1439 break;
1440 }
1228 1441
1229 return 0; 1442 return 0;
1230} 1443}
@@ -1517,3 +1730,19 @@ struct e1000_info e1000_82574_info = {
1517 .nvm_ops = &e82571_nvm_ops, 1730 .nvm_ops = &e82571_nvm_ops,
1518}; 1731};
1519 1732
1733struct e1000_info e1000_82583_info = {
1734 .mac = e1000_82583,
1735 .flags = FLAG_HAS_HW_VLAN_FILTER
1736 | FLAG_HAS_WOL
1737 | FLAG_APME_IN_CTRL3
1738 | FLAG_RX_CSUM_ENABLED
1739 | FLAG_HAS_SMART_POWER_DOWN
1740 | FLAG_HAS_AMT
1741 | FLAG_HAS_CTRLEXT_ON_LOAD,
1742 .pba = 20,
1743 .get_variants = e1000_get_variants_82571,
1744 .mac_ops = &e82571_mac_ops,
1745 .phy_ops = &e82_phy_ops_bm,
1746 .nvm_ops = &e82571_nvm_ops,
1747};
1748
diff --git a/drivers/net/e1000e/defines.h b/drivers/net/e1000e/defines.h
index e6caf29d4252..243aa499fe90 100644
--- a/drivers/net/e1000e/defines.h
+++ b/drivers/net/e1000e/defines.h
@@ -69,6 +69,7 @@
69#define E1000_CTRL_EXT_SDP7_DATA 0x00000080 /* Value of SW Definable Pin 7 */ 69#define E1000_CTRL_EXT_SDP7_DATA 0x00000080 /* Value of SW Definable Pin 7 */
70#define E1000_CTRL_EXT_EE_RST 0x00002000 /* Reinitialize from EEPROM */ 70#define E1000_CTRL_EXT_EE_RST 0x00002000 /* Reinitialize from EEPROM */
71#define E1000_CTRL_EXT_RO_DIS 0x00020000 /* Relaxed Ordering disable */ 71#define E1000_CTRL_EXT_RO_DIS 0x00020000 /* Relaxed Ordering disable */
72#define E1000_CTRL_EXT_DMA_DYN_CLK_EN 0x00080000 /* DMA Dynamic Clock Gating */
72#define E1000_CTRL_EXT_LINK_MODE_MASK 0x00C00000 73#define E1000_CTRL_EXT_LINK_MODE_MASK 0x00C00000
73#define E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES 0x00C00000 74#define E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES 0x00C00000
74#define E1000_CTRL_EXT_EIAME 0x01000000 75#define E1000_CTRL_EXT_EIAME 0x01000000
diff --git a/drivers/net/e1000e/e1000.h b/drivers/net/e1000e/e1000.h
index 37bcb190eef8..f37360aa12a8 100644
--- a/drivers/net/e1000e/e1000.h
+++ b/drivers/net/e1000e/e1000.h
@@ -101,6 +101,7 @@ enum e1000_boards {
101 board_82572, 101 board_82572,
102 board_82573, 102 board_82573,
103 board_82574, 103 board_82574,
104 board_82583,
104 board_80003es2lan, 105 board_80003es2lan,
105 board_ich8lan, 106 board_ich8lan,
106 board_ich9lan, 107 board_ich9lan,
@@ -195,8 +196,6 @@ struct e1000_adapter {
195 u16 link_duplex; 196 u16 link_duplex;
196 u16 eeprom_vers; 197 u16 eeprom_vers;
197 198
198 spinlock_t tx_queue_lock; /* prevent concurrent tail updates */
199
200 /* track device up/down/testing state */ 199 /* track device up/down/testing state */
201 unsigned long state; 200 unsigned long state;
202 201
@@ -401,6 +400,7 @@ extern struct e1000_info e1000_82571_info;
401extern struct e1000_info e1000_82572_info; 400extern struct e1000_info e1000_82572_info;
402extern struct e1000_info e1000_82573_info; 401extern struct e1000_info e1000_82573_info;
403extern struct e1000_info e1000_82574_info; 402extern struct e1000_info e1000_82574_info;
403extern struct e1000_info e1000_82583_info;
404extern struct e1000_info e1000_ich8_info; 404extern struct e1000_info e1000_ich8_info;
405extern struct e1000_info e1000_ich9_info; 405extern struct e1000_info e1000_ich9_info;
406extern struct e1000_info e1000_ich10_info; 406extern struct e1000_info e1000_ich10_info;
diff --git a/drivers/net/e1000e/ethtool.c b/drivers/net/e1000e/ethtool.c
index e48956d924b0..4d25ede88369 100644
--- a/drivers/net/e1000e/ethtool.c
+++ b/drivers/net/e1000e/ethtool.c
@@ -790,6 +790,7 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
790 break; 790 break;
791 case e1000_82573: 791 case e1000_82573:
792 case e1000_82574: 792 case e1000_82574:
793 case e1000_82583:
793 case e1000_ich8lan: 794 case e1000_ich8lan:
794 case e1000_ich9lan: 795 case e1000_ich9lan:
795 case e1000_ich10lan: 796 case e1000_ich10lan:
@@ -1589,7 +1590,7 @@ static int e1000_link_test(struct e1000_adapter *adapter, u64 *data)
1589 *data = 0; 1590 *data = 0;
1590 if (hw->phy.media_type == e1000_media_type_internal_serdes) { 1591 if (hw->phy.media_type == e1000_media_type_internal_serdes) {
1591 int i = 0; 1592 int i = 0;
1592 hw->mac.serdes_has_link = 0; 1593 hw->mac.serdes_has_link = false;
1593 1594
1594 /* 1595 /*
1595 * On some blade server designs, link establishment 1596 * On some blade server designs, link establishment
diff --git a/drivers/net/e1000e/hw.h b/drivers/net/e1000e/hw.h
index 2d4ce0492df0..11a2f203a01c 100644
--- a/drivers/net/e1000e/hw.h
+++ b/drivers/net/e1000e/hw.h
@@ -339,6 +339,7 @@ enum e1e_registers {
339#define E1000_DEV_ID_82573E_IAMT 0x108C 339#define E1000_DEV_ID_82573E_IAMT 0x108C
340#define E1000_DEV_ID_82573L 0x109A 340#define E1000_DEV_ID_82573L 0x109A
341#define E1000_DEV_ID_82574L 0x10D3 341#define E1000_DEV_ID_82574L 0x10D3
342#define E1000_DEV_ID_82583V 0x150C
342 343
343#define E1000_DEV_ID_80003ES2LAN_COPPER_DPT 0x1096 344#define E1000_DEV_ID_80003ES2LAN_COPPER_DPT 0x1096
344#define E1000_DEV_ID_80003ES2LAN_SERDES_DPT 0x1098 345#define E1000_DEV_ID_80003ES2LAN_SERDES_DPT 0x1098
@@ -376,6 +377,7 @@ enum e1000_mac_type {
376 e1000_82572, 377 e1000_82572,
377 e1000_82573, 378 e1000_82573,
378 e1000_82574, 379 e1000_82574,
380 e1000_82583,
379 e1000_80003es2lan, 381 e1000_80003es2lan,
380 e1000_ich8lan, 382 e1000_ich8lan,
381 e1000_ich9lan, 383 e1000_ich9lan,
@@ -459,6 +461,13 @@ enum e1000_smart_speed {
459 e1000_smart_speed_off 461 e1000_smart_speed_off
460}; 462};
461 463
464enum e1000_serdes_link_state {
465 e1000_serdes_link_down = 0,
466 e1000_serdes_link_autoneg_progress,
467 e1000_serdes_link_autoneg_complete,
468 e1000_serdes_link_forced_up
469};
470
462/* Receive Descriptor */ 471/* Receive Descriptor */
463struct e1000_rx_desc { 472struct e1000_rx_desc {
464 __le64 buffer_addr; /* Address of the descriptor's data buffer */ 473 __le64 buffer_addr; /* Address of the descriptor's data buffer */
@@ -787,6 +796,7 @@ struct e1000_mac_info {
787 bool in_ifs_mode; 796 bool in_ifs_mode;
788 bool serdes_has_link; 797 bool serdes_has_link;
789 bool tx_pkt_filtering; 798 bool tx_pkt_filtering;
799 enum e1000_serdes_link_state serdes_link_state;
790}; 800};
791 801
792struct e1000_phy_info { 802struct e1000_phy_info {
diff --git a/drivers/net/e1000e/ich8lan.c b/drivers/net/e1000e/ich8lan.c
index e415e81ecd3e..6d1aab6316ba 100644
--- a/drivers/net/e1000e/ich8lan.c
+++ b/drivers/net/e1000e/ich8lan.c
@@ -390,8 +390,6 @@ static s32 e1000_get_variants_ich8lan(struct e1000_adapter *adapter)
390} 390}
391 391
392static DEFINE_MUTEX(nvm_mutex); 392static DEFINE_MUTEX(nvm_mutex);
393static pid_t nvm_owner_pid = -1;
394static char nvm_owner_name[TASK_COMM_LEN] = "";
395 393
396/** 394/**
397 * e1000_acquire_swflag_ich8lan - Acquire software control flag 395 * e1000_acquire_swflag_ich8lan - Acquire software control flag
@@ -408,16 +406,7 @@ static s32 e1000_acquire_swflag_ich8lan(struct e1000_hw *hw)
408 406
409 might_sleep(); 407 might_sleep();
410 408
411 if (!mutex_trylock(&nvm_mutex)) { 409 mutex_lock(&nvm_mutex);
412 WARN(1, KERN_ERR "e1000e mutex contention. Owned by process "
413 "%s (pid %d), required by process %s (pid %d)\n",
414 nvm_owner_name, nvm_owner_pid,
415 current->comm, current->pid);
416
417 mutex_lock(&nvm_mutex);
418 }
419 nvm_owner_pid = current->pid;
420 strncpy(nvm_owner_name, current->comm, TASK_COMM_LEN);
421 410
422 while (timeout) { 411 while (timeout) {
423 extcnf_ctrl = er32(EXTCNF_CTRL); 412 extcnf_ctrl = er32(EXTCNF_CTRL);
@@ -435,8 +424,6 @@ static s32 e1000_acquire_swflag_ich8lan(struct e1000_hw *hw)
435 hw_dbg(hw, "FW or HW has locked the resource for too long.\n"); 424 hw_dbg(hw, "FW or HW has locked the resource for too long.\n");
436 extcnf_ctrl &= ~E1000_EXTCNF_CTRL_SWFLAG; 425 extcnf_ctrl &= ~E1000_EXTCNF_CTRL_SWFLAG;
437 ew32(EXTCNF_CTRL, extcnf_ctrl); 426 ew32(EXTCNF_CTRL, extcnf_ctrl);
438 nvm_owner_pid = -1;
439 strcpy(nvm_owner_name, "");
440 mutex_unlock(&nvm_mutex); 427 mutex_unlock(&nvm_mutex);
441 return -E1000_ERR_CONFIG; 428 return -E1000_ERR_CONFIG;
442 } 429 }
@@ -460,8 +447,6 @@ static void e1000_release_swflag_ich8lan(struct e1000_hw *hw)
460 extcnf_ctrl &= ~E1000_EXTCNF_CTRL_SWFLAG; 447 extcnf_ctrl &= ~E1000_EXTCNF_CTRL_SWFLAG;
461 ew32(EXTCNF_CTRL, extcnf_ctrl); 448 ew32(EXTCNF_CTRL, extcnf_ctrl);
462 449
463 nvm_owner_pid = -1;
464 strcpy(nvm_owner_name, "");
465 mutex_unlock(&nvm_mutex); 450 mutex_unlock(&nvm_mutex);
466} 451}
467 452
diff --git a/drivers/net/e1000e/lib.c b/drivers/net/e1000e/lib.c
index 66741104ffd1..ac2f34e1836d 100644
--- a/drivers/net/e1000e/lib.c
+++ b/drivers/net/e1000e/lib.c
@@ -501,7 +501,7 @@ s32 e1000e_check_for_fiber_link(struct e1000_hw *hw)
501 ew32(TXCW, mac->txcw); 501 ew32(TXCW, mac->txcw);
502 ew32(CTRL, (ctrl & ~E1000_CTRL_SLU)); 502 ew32(CTRL, (ctrl & ~E1000_CTRL_SLU));
503 503
504 mac->serdes_has_link = 1; 504 mac->serdes_has_link = true;
505 } 505 }
506 506
507 return 0; 507 return 0;
@@ -566,7 +566,7 @@ s32 e1000e_check_for_serdes_link(struct e1000_hw *hw)
566 ew32(TXCW, mac->txcw); 566 ew32(TXCW, mac->txcw);
567 ew32(CTRL, (ctrl & ~E1000_CTRL_SLU)); 567 ew32(CTRL, (ctrl & ~E1000_CTRL_SLU));
568 568
569 mac->serdes_has_link = 1; 569 mac->serdes_has_link = true;
570 } else if (!(E1000_TXCW_ANE & er32(TXCW))) { 570 } else if (!(E1000_TXCW_ANE & er32(TXCW))) {
571 /* 571 /*
572 * If we force link for non-auto-negotiation switch, check 572 * If we force link for non-auto-negotiation switch, check
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index 91817d0afcaf..d092eafde9bf 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -44,10 +44,11 @@
44#include <linux/cpu.h> 44#include <linux/cpu.h>
45#include <linux/smp.h> 45#include <linux/smp.h>
46#include <linux/pm_qos_params.h> 46#include <linux/pm_qos_params.h>
47#include <linux/aer.h>
47 48
48#include "e1000.h" 49#include "e1000.h"
49 50
50#define DRV_VERSION "0.3.3.3-k6" 51#define DRV_VERSION "0.3.3.4-k2"
51char e1000e_driver_name[] = "e1000e"; 52char e1000e_driver_name[] = "e1000e";
52const char e1000e_driver_version[] = DRV_VERSION; 53const char e1000e_driver_version[] = DRV_VERSION;
53 54
@@ -56,6 +57,7 @@ static const struct e1000_info *e1000_info_tbl[] = {
56 [board_82572] = &e1000_82572_info, 57 [board_82572] = &e1000_82572_info,
57 [board_82573] = &e1000_82573_info, 58 [board_82573] = &e1000_82573_info,
58 [board_82574] = &e1000_82574_info, 59 [board_82574] = &e1000_82574_info,
60 [board_82583] = &e1000_82583_info,
59 [board_80003es2lan] = &e1000_es2_info, 61 [board_80003es2lan] = &e1000_es2_info,
60 [board_ich8lan] = &e1000_ich8_info, 62 [board_ich8lan] = &e1000_ich8_info,
61 [board_ich9lan] = &e1000_ich9_info, 63 [board_ich9lan] = &e1000_ich9_info,
@@ -99,8 +101,8 @@ static void e1000_receive_skb(struct e1000_adapter *adapter,
99 skb->protocol = eth_type_trans(skb, netdev); 101 skb->protocol = eth_type_trans(skb, netdev);
100 102
101 if (adapter->vlgrp && (status & E1000_RXD_STAT_VP)) 103 if (adapter->vlgrp && (status & E1000_RXD_STAT_VP))
102 vlan_hwaccel_receive_skb(skb, adapter->vlgrp, 104 vlan_gro_receive(&adapter->napi, adapter->vlgrp,
103 le16_to_cpu(vlan)); 105 le16_to_cpu(vlan), skb);
104 else 106 else
105 napi_gro_receive(&adapter->napi, skb); 107 napi_gro_receive(&adapter->napi, skb);
106} 108}
@@ -565,15 +567,14 @@ next_desc:
565static void e1000_put_txbuf(struct e1000_adapter *adapter, 567static void e1000_put_txbuf(struct e1000_adapter *adapter,
566 struct e1000_buffer *buffer_info) 568 struct e1000_buffer *buffer_info)
567{ 569{
568 if (buffer_info->dma) { 570 buffer_info->dma = 0;
569 pci_unmap_page(adapter->pdev, buffer_info->dma,
570 buffer_info->length, PCI_DMA_TODEVICE);
571 buffer_info->dma = 0;
572 }
573 if (buffer_info->skb) { 571 if (buffer_info->skb) {
572 skb_dma_unmap(&adapter->pdev->dev, buffer_info->skb,
573 DMA_TO_DEVICE);
574 dev_kfree_skb_any(buffer_info->skb); 574 dev_kfree_skb_any(buffer_info->skb);
575 buffer_info->skb = NULL; 575 buffer_info->skb = NULL;
576 } 576 }
577 buffer_info->time_stamp = 0;
577} 578}
578 579
579static void e1000_print_tx_hang(struct e1000_adapter *adapter) 580static void e1000_print_tx_hang(struct e1000_adapter *adapter)
@@ -678,12 +679,10 @@ static bool e1000_clean_tx_irq(struct e1000_adapter *adapter)
678 } 679 }
679 680
680 if (adapter->detect_tx_hung) { 681 if (adapter->detect_tx_hung) {
681 /* 682 /* Detect a transmit hang in hardware, this serializes the
682 * Detect a transmit hang in hardware, this serializes the 683 * check with the clearing of time_stamp and movement of i */
683 * check with the clearing of time_stamp and movement of i
684 */
685 adapter->detect_tx_hung = 0; 684 adapter->detect_tx_hung = 0;
686 if (tx_ring->buffer_info[eop].dma && 685 if (tx_ring->buffer_info[eop].time_stamp &&
687 time_after(jiffies, tx_ring->buffer_info[eop].time_stamp 686 time_after(jiffies, tx_ring->buffer_info[eop].time_stamp
688 + (adapter->tx_timeout_factor * HZ)) 687 + (adapter->tx_timeout_factor * HZ))
689 && !(er32(STATUS) & E1000_STATUS_TXOFF)) { 688 && !(er32(STATUS) & E1000_STATUS_TXOFF)) {
@@ -1152,7 +1151,7 @@ static irqreturn_t e1000_intr_msi(int irq, void *data)
1152 * read ICR disables interrupts using IAM 1151 * read ICR disables interrupts using IAM
1153 */ 1152 */
1154 1153
1155 if (icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) { 1154 if (icr & E1000_ICR_LSC) {
1156 hw->mac.get_link_status = 1; 1155 hw->mac.get_link_status = 1;
1157 /* 1156 /*
1158 * ICH8 workaround-- Call gig speed drop workaround on cable 1157 * ICH8 workaround-- Call gig speed drop workaround on cable
@@ -1179,12 +1178,12 @@ static irqreturn_t e1000_intr_msi(int irq, void *data)
1179 mod_timer(&adapter->watchdog_timer, jiffies + 1); 1178 mod_timer(&adapter->watchdog_timer, jiffies + 1);
1180 } 1179 }
1181 1180
1182 if (netif_rx_schedule_prep(&adapter->napi)) { 1181 if (napi_schedule_prep(&adapter->napi)) {
1183 adapter->total_tx_bytes = 0; 1182 adapter->total_tx_bytes = 0;
1184 adapter->total_tx_packets = 0; 1183 adapter->total_tx_packets = 0;
1185 adapter->total_rx_bytes = 0; 1184 adapter->total_rx_bytes = 0;
1186 adapter->total_rx_packets = 0; 1185 adapter->total_rx_packets = 0;
1187 __netif_rx_schedule(&adapter->napi); 1186 __napi_schedule(&adapter->napi);
1188 } 1187 }
1189 1188
1190 return IRQ_HANDLED; 1189 return IRQ_HANDLED;
@@ -1218,7 +1217,7 @@ static irqreturn_t e1000_intr(int irq, void *data)
1218 * IMC write 1217 * IMC write
1219 */ 1218 */
1220 1219
1221 if (icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) { 1220 if (icr & E1000_ICR_LSC) {
1222 hw->mac.get_link_status = 1; 1221 hw->mac.get_link_status = 1;
1223 /* 1222 /*
1224 * ICH8 workaround-- Call gig speed drop workaround on cable 1223 * ICH8 workaround-- Call gig speed drop workaround on cable
@@ -1246,12 +1245,12 @@ static irqreturn_t e1000_intr(int irq, void *data)
1246 mod_timer(&adapter->watchdog_timer, jiffies + 1); 1245 mod_timer(&adapter->watchdog_timer, jiffies + 1);
1247 } 1246 }
1248 1247
1249 if (netif_rx_schedule_prep(&adapter->napi)) { 1248 if (napi_schedule_prep(&adapter->napi)) {
1250 adapter->total_tx_bytes = 0; 1249 adapter->total_tx_bytes = 0;
1251 adapter->total_tx_packets = 0; 1250 adapter->total_tx_packets = 0;
1252 adapter->total_rx_bytes = 0; 1251 adapter->total_rx_bytes = 0;
1253 adapter->total_rx_packets = 0; 1252 adapter->total_rx_packets = 0;
1254 __netif_rx_schedule(&adapter->napi); 1253 __napi_schedule(&adapter->napi);
1255 } 1254 }
1256 1255
1257 return IRQ_HANDLED; 1256 return IRQ_HANDLED;
@@ -1320,10 +1319,10 @@ static irqreturn_t e1000_intr_msix_rx(int irq, void *data)
1320 adapter->rx_ring->set_itr = 0; 1319 adapter->rx_ring->set_itr = 0;
1321 } 1320 }
1322 1321
1323 if (netif_rx_schedule_prep(&adapter->napi)) { 1322 if (napi_schedule_prep(&adapter->napi)) {
1324 adapter->total_rx_bytes = 0; 1323 adapter->total_rx_bytes = 0;
1325 adapter->total_rx_packets = 0; 1324 adapter->total_rx_packets = 0;
1326 __netif_rx_schedule(&adapter->napi); 1325 __napi_schedule(&adapter->napi);
1327 } 1326 }
1328 return IRQ_HANDLED; 1327 return IRQ_HANDLED;
1329} 1328}
@@ -1698,7 +1697,6 @@ int e1000e_setup_tx_resources(struct e1000_adapter *adapter)
1698 1697
1699 tx_ring->next_to_use = 0; 1698 tx_ring->next_to_use = 0;
1700 tx_ring->next_to_clean = 0; 1699 tx_ring->next_to_clean = 0;
1701 spin_lock_init(&adapter->tx_queue_lock);
1702 1700
1703 return 0; 1701 return 0;
1704err: 1702err:
@@ -2007,16 +2005,7 @@ static int e1000_clean(struct napi_struct *napi, int budget)
2007 !(adapter->rx_ring->ims_val & adapter->tx_ring->ims_val)) 2005 !(adapter->rx_ring->ims_val & adapter->tx_ring->ims_val))
2008 goto clean_rx; 2006 goto clean_rx;
2009 2007
2010 /* 2008 tx_cleaned = e1000_clean_tx_irq(adapter);
2011 * e1000_clean is called per-cpu. This lock protects
2012 * tx_ring from being cleaned by multiple cpus
2013 * simultaneously. A failure obtaining the lock means
2014 * tx_ring is currently being cleaned anyway.
2015 */
2016 if (spin_trylock(&adapter->tx_queue_lock)) {
2017 tx_cleaned = e1000_clean_tx_irq(adapter);
2018 spin_unlock(&adapter->tx_queue_lock);
2019 }
2020 2009
2021clean_rx: 2010clean_rx:
2022 adapter->clean_rx(adapter, &work_done, budget); 2011 adapter->clean_rx(adapter, &work_done, budget);
@@ -2028,7 +2017,7 @@ clean_rx:
2028 if (work_done < budget) { 2017 if (work_done < budget) {
2029 if (adapter->itr_setting & 3) 2018 if (adapter->itr_setting & 3)
2030 e1000_set_itr(adapter); 2019 e1000_set_itr(adapter);
2031 netif_rx_complete(napi); 2020 napi_complete(napi);
2032 if (adapter->msix_entries) 2021 if (adapter->msix_entries)
2033 ew32(IMS, adapter->rx_ring->ims_val); 2022 ew32(IMS, adapter->rx_ring->ims_val);
2034 else 2023 else
@@ -2922,8 +2911,6 @@ static int __devinit e1000_sw_init(struct e1000_adapter *adapter)
2922 if (e1000_alloc_queues(adapter)) 2911 if (e1000_alloc_queues(adapter))
2923 return -ENOMEM; 2912 return -ENOMEM;
2924 2913
2925 spin_lock_init(&adapter->tx_queue_lock);
2926
2927 /* Explicitly disable IRQ since the NIC can be in any state. */ 2914 /* Explicitly disable IRQ since the NIC can be in any state. */
2928 e1000_irq_disable(adapter); 2915 e1000_irq_disable(adapter);
2929 2916
@@ -3320,7 +3307,7 @@ void e1000e_update_stats(struct e1000_adapter *adapter)
3320 3307
3321 adapter->stats.algnerrc += er32(ALGNERRC); 3308 adapter->stats.algnerrc += er32(ALGNERRC);
3322 adapter->stats.rxerrc += er32(RXERRC); 3309 adapter->stats.rxerrc += er32(RXERRC);
3323 if (hw->mac.type != e1000_82574) 3310 if ((hw->mac.type != e1000_82574) && (hw->mac.type != e1000_82583))
3324 adapter->stats.tncrs += er32(TNCRS); 3311 adapter->stats.tncrs += er32(TNCRS);
3325 adapter->stats.cexterr += er32(CEXTERR); 3312 adapter->stats.cexterr += er32(CEXTERR);
3326 adapter->stats.tsctc += er32(TSCTC); 3313 adapter->stats.tsctc += er32(TSCTC);
@@ -3777,23 +3764,30 @@ static bool e1000_tx_csum(struct e1000_adapter *adapter, struct sk_buff *skb)
3777 unsigned int i; 3764 unsigned int i;
3778 u8 css; 3765 u8 css;
3779 u32 cmd_len = E1000_TXD_CMD_DEXT; 3766 u32 cmd_len = E1000_TXD_CMD_DEXT;
3767 __be16 protocol;
3780 3768
3781 if (skb->ip_summed != CHECKSUM_PARTIAL) 3769 if (skb->ip_summed != CHECKSUM_PARTIAL)
3782 return 0; 3770 return 0;
3783 3771
3772 if (skb->protocol == cpu_to_be16(ETH_P_8021Q))
3773 protocol = vlan_eth_hdr(skb)->h_vlan_encapsulated_proto;
3774 else
3775 protocol = skb->protocol;
3776
3784 switch (skb->protocol) { 3777 switch (skb->protocol) {
3785 case __constant_htons(ETH_P_IP): 3778 case cpu_to_be16(ETH_P_IP):
3786 if (ip_hdr(skb)->protocol == IPPROTO_TCP) 3779 if (ip_hdr(skb)->protocol == IPPROTO_TCP)
3787 cmd_len |= E1000_TXD_CMD_TCP; 3780 cmd_len |= E1000_TXD_CMD_TCP;
3788 break; 3781 break;
3789 case __constant_htons(ETH_P_IPV6): 3782 case cpu_to_be16(ETH_P_IPV6):
3790 /* XXX not handling all IPV6 headers */ 3783 /* XXX not handling all IPV6 headers */
3791 if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP) 3784 if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
3792 cmd_len |= E1000_TXD_CMD_TCP; 3785 cmd_len |= E1000_TXD_CMD_TCP;
3793 break; 3786 break;
3794 default: 3787 default:
3795 if (unlikely(net_ratelimit())) 3788 if (unlikely(net_ratelimit()))
3796 e_warn("checksum_partial proto=%x!\n", skb->protocol); 3789 e_warn("checksum_partial proto=%x!\n",
3790 be16_to_cpu(protocol));
3797 break; 3791 break;
3798 } 3792 }
3799 3793
@@ -3832,42 +3826,40 @@ static int e1000_tx_map(struct e1000_adapter *adapter,
3832{ 3826{
3833 struct e1000_ring *tx_ring = adapter->tx_ring; 3827 struct e1000_ring *tx_ring = adapter->tx_ring;
3834 struct e1000_buffer *buffer_info; 3828 struct e1000_buffer *buffer_info;
3835 unsigned int len = skb->len - skb->data_len; 3829 unsigned int len = skb_headlen(skb);
3836 unsigned int offset = 0, size, count = 0, i; 3830 unsigned int offset, size, count = 0, i;
3837 unsigned int f; 3831 unsigned int f;
3832 dma_addr_t *map;
3838 3833
3839 i = tx_ring->next_to_use; 3834 i = tx_ring->next_to_use;
3840 3835
3836 if (skb_dma_map(&adapter->pdev->dev, skb, DMA_TO_DEVICE)) {
3837 dev_err(&adapter->pdev->dev, "TX DMA map failed\n");
3838 adapter->tx_dma_failed++;
3839 return 0;
3840 }
3841
3842 map = skb_shinfo(skb)->dma_maps;
3843 offset = 0;
3844
3841 while (len) { 3845 while (len) {
3842 buffer_info = &tx_ring->buffer_info[i]; 3846 buffer_info = &tx_ring->buffer_info[i];
3843 size = min(len, max_per_txd); 3847 size = min(len, max_per_txd);
3844 3848
3845 /* Workaround for premature desc write-backs
3846 * in TSO mode. Append 4-byte sentinel desc */
3847 if (mss && !nr_frags && size == len && size > 8)
3848 size -= 4;
3849
3850 buffer_info->length = size; 3849 buffer_info->length = size;
3851 /* set time_stamp *before* dma to help avoid a possible race */
3852 buffer_info->time_stamp = jiffies; 3850 buffer_info->time_stamp = jiffies;
3853 buffer_info->dma =
3854 pci_map_single(adapter->pdev,
3855 skb->data + offset,
3856 size,
3857 PCI_DMA_TODEVICE);
3858 if (pci_dma_mapping_error(adapter->pdev, buffer_info->dma)) {
3859 dev_err(&adapter->pdev->dev, "TX DMA map failed\n");
3860 adapter->tx_dma_failed++;
3861 return -1;
3862 }
3863 buffer_info->next_to_watch = i; 3851 buffer_info->next_to_watch = i;
3852 buffer_info->dma = map[0] + offset;
3853 count++;
3864 3854
3865 len -= size; 3855 len -= size;
3866 offset += size; 3856 offset += size;
3867 count++; 3857
3868 i++; 3858 if (len) {
3869 if (i == tx_ring->count) 3859 i++;
3870 i = 0; 3860 if (i == tx_ring->count)
3861 i = 0;
3862 }
3871 } 3863 }
3872 3864
3873 for (f = 0; f < nr_frags; f++) { 3865 for (f = 0; f < nr_frags; f++) {
@@ -3875,49 +3867,27 @@ static int e1000_tx_map(struct e1000_adapter *adapter,
3875 3867
3876 frag = &skb_shinfo(skb)->frags[f]; 3868 frag = &skb_shinfo(skb)->frags[f];
3877 len = frag->size; 3869 len = frag->size;
3878 offset = frag->page_offset; 3870 offset = 0;
3879 3871
3880 while (len) { 3872 while (len) {
3873 i++;
3874 if (i == tx_ring->count)
3875 i = 0;
3876
3881 buffer_info = &tx_ring->buffer_info[i]; 3877 buffer_info = &tx_ring->buffer_info[i];
3882 size = min(len, max_per_txd); 3878 size = min(len, max_per_txd);
3883 /* Workaround for premature desc write-backs
3884 * in TSO mode. Append 4-byte sentinel desc */
3885 if (mss && f == (nr_frags-1) && size == len && size > 8)
3886 size -= 4;
3887 3879
3888 buffer_info->length = size; 3880 buffer_info->length = size;
3889 buffer_info->time_stamp = jiffies; 3881 buffer_info->time_stamp = jiffies;
3890 buffer_info->dma =
3891 pci_map_page(adapter->pdev,
3892 frag->page,
3893 offset,
3894 size,
3895 PCI_DMA_TODEVICE);
3896 if (pci_dma_mapping_error(adapter->pdev,
3897 buffer_info->dma)) {
3898 dev_err(&adapter->pdev->dev,
3899 "TX DMA page map failed\n");
3900 adapter->tx_dma_failed++;
3901 return -1;
3902 }
3903
3904 buffer_info->next_to_watch = i; 3882 buffer_info->next_to_watch = i;
3883 buffer_info->dma = map[f + 1] + offset;
3905 3884
3906 len -= size; 3885 len -= size;
3907 offset += size; 3886 offset += size;
3908 count++; 3887 count++;
3909
3910 i++;
3911 if (i == tx_ring->count)
3912 i = 0;
3913 } 3888 }
3914 } 3889 }
3915 3890
3916 if (i == 0)
3917 i = tx_ring->count - 1;
3918 else
3919 i--;
3920
3921 tx_ring->buffer_info[i].skb = skb; 3891 tx_ring->buffer_info[i].skb = skb;
3922 tx_ring->buffer_info[first].next_to_watch = i; 3892 tx_ring->buffer_info[first].next_to_watch = i;
3923 3893
@@ -4069,7 +4039,6 @@ static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
4069 unsigned int max_txd_pwr = E1000_MAX_TXD_PWR; 4039 unsigned int max_txd_pwr = E1000_MAX_TXD_PWR;
4070 unsigned int tx_flags = 0; 4040 unsigned int tx_flags = 0;
4071 unsigned int len = skb->len - skb->data_len; 4041 unsigned int len = skb->len - skb->data_len;
4072 unsigned long irq_flags;
4073 unsigned int nr_frags; 4042 unsigned int nr_frags;
4074 unsigned int mss; 4043 unsigned int mss;
4075 int count = 0; 4044 int count = 0;
@@ -4138,18 +4107,12 @@ static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
4138 if (adapter->hw.mac.tx_pkt_filtering) 4107 if (adapter->hw.mac.tx_pkt_filtering)
4139 e1000_transfer_dhcp_info(adapter, skb); 4108 e1000_transfer_dhcp_info(adapter, skb);
4140 4109
4141 if (!spin_trylock_irqsave(&adapter->tx_queue_lock, irq_flags))
4142 /* Collision - tell upper layer to requeue */
4143 return NETDEV_TX_LOCKED;
4144
4145 /* 4110 /*
4146 * need: count + 2 desc gap to keep tail from touching 4111 * need: count + 2 desc gap to keep tail from touching
4147 * head, otherwise try next time 4112 * head, otherwise try next time
4148 */ 4113 */
4149 if (e1000_maybe_stop_tx(netdev, count + 2)) { 4114 if (e1000_maybe_stop_tx(netdev, count + 2))
4150 spin_unlock_irqrestore(&adapter->tx_queue_lock, irq_flags);
4151 return NETDEV_TX_BUSY; 4115 return NETDEV_TX_BUSY;
4152 }
4153 4116
4154 if (adapter->vlgrp && vlan_tx_tag_present(skb)) { 4117 if (adapter->vlgrp && vlan_tx_tag_present(skb)) {
4155 tx_flags |= E1000_TX_FLAGS_VLAN; 4118 tx_flags |= E1000_TX_FLAGS_VLAN;
@@ -4161,7 +4124,6 @@ static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
4161 tso = e1000_tso(adapter, skb); 4124 tso = e1000_tso(adapter, skb);
4162 if (tso < 0) { 4125 if (tso < 0) {
4163 dev_kfree_skb_any(skb); 4126 dev_kfree_skb_any(skb);
4164 spin_unlock_irqrestore(&adapter->tx_queue_lock, irq_flags);
4165 return NETDEV_TX_OK; 4127 return NETDEV_TX_OK;
4166 } 4128 }
4167 4129
@@ -4178,22 +4140,20 @@ static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
4178 if (skb->protocol == htons(ETH_P_IP)) 4140 if (skb->protocol == htons(ETH_P_IP))
4179 tx_flags |= E1000_TX_FLAGS_IPV4; 4141 tx_flags |= E1000_TX_FLAGS_IPV4;
4180 4142
4143 /* if count is 0 then mapping error has occured */
4181 count = e1000_tx_map(adapter, skb, first, max_per_txd, nr_frags, mss); 4144 count = e1000_tx_map(adapter, skb, first, max_per_txd, nr_frags, mss);
4182 if (count < 0) { 4145 if (count) {
4183 /* handle pci_map_single() error in e1000_tx_map */ 4146 e1000_tx_queue(adapter, tx_flags, count);
4147 netdev->trans_start = jiffies;
4148 /* Make sure there is space in the ring for the next send. */
4149 e1000_maybe_stop_tx(netdev, MAX_SKB_FRAGS + 2);
4150
4151 } else {
4184 dev_kfree_skb_any(skb); 4152 dev_kfree_skb_any(skb);
4185 spin_unlock_irqrestore(&adapter->tx_queue_lock, irq_flags); 4153 tx_ring->buffer_info[first].time_stamp = 0;
4186 return NETDEV_TX_OK; 4154 tx_ring->next_to_use = first;
4187 } 4155 }
4188 4156
4189 e1000_tx_queue(adapter, tx_flags, count);
4190
4191 netdev->trans_start = jiffies;
4192
4193 /* Make sure there is space in the ring for the next send. */
4194 e1000_maybe_stop_tx(netdev, MAX_SKB_FRAGS + 2);
4195
4196 spin_unlock_irqrestore(&adapter->tx_queue_lock, irq_flags);
4197 return NETDEV_TX_OK; 4157 return NETDEV_TX_OK;
4198} 4158}
4199 4159
@@ -4543,6 +4503,14 @@ static int e1000_resume(struct pci_dev *pdev)
4543 return err; 4503 return err;
4544 } 4504 }
4545 4505
4506 /* AER (Advanced Error Reporting) hooks */
4507 err = pci_enable_pcie_error_reporting(pdev);
4508 if (err) {
4509 dev_err(&pdev->dev, "pci_enable_pcie_error_reporting failed "
4510 "0x%x\n", err);
4511 /* non-fatal, continue */
4512 }
4513
4546 pci_set_master(pdev); 4514 pci_set_master(pdev);
4547 4515
4548 pci_enable_wake(pdev, PCI_D3hot, 0); 4516 pci_enable_wake(pdev, PCI_D3hot, 0);
@@ -4637,24 +4605,29 @@ static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev)
4637 struct e1000_adapter *adapter = netdev_priv(netdev); 4605 struct e1000_adapter *adapter = netdev_priv(netdev);
4638 struct e1000_hw *hw = &adapter->hw; 4606 struct e1000_hw *hw = &adapter->hw;
4639 int err; 4607 int err;
4608 pci_ers_result_t result;
4640 4609
4641 e1000e_disable_l1aspm(pdev); 4610 e1000e_disable_l1aspm(pdev);
4642 err = pci_enable_device_mem(pdev); 4611 err = pci_enable_device_mem(pdev);
4643 if (err) { 4612 if (err) {
4644 dev_err(&pdev->dev, 4613 dev_err(&pdev->dev,
4645 "Cannot re-enable PCI device after reset.\n"); 4614 "Cannot re-enable PCI device after reset.\n");
4646 return PCI_ERS_RESULT_DISCONNECT; 4615 result = PCI_ERS_RESULT_DISCONNECT;
4647 } 4616 } else {
4648 pci_set_master(pdev); 4617 pci_set_master(pdev);
4649 pci_restore_state(pdev); 4618 pci_restore_state(pdev);
4650 4619
4651 pci_enable_wake(pdev, PCI_D3hot, 0); 4620 pci_enable_wake(pdev, PCI_D3hot, 0);
4652 pci_enable_wake(pdev, PCI_D3cold, 0); 4621 pci_enable_wake(pdev, PCI_D3cold, 0);
4653 4622
4654 e1000e_reset(adapter); 4623 e1000e_reset(adapter);
4655 ew32(WUS, ~0); 4624 ew32(WUS, ~0);
4625 result = PCI_ERS_RESULT_RECOVERED;
4626 }
4656 4627
4657 return PCI_ERS_RESULT_RECOVERED; 4628 pci_cleanup_aer_uncorrect_error_status(pdev);
4629
4630 return result;
4658} 4631}
4659 4632
4660/** 4633/**
@@ -4922,12 +4895,6 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
4922 if (pci_using_dac) 4895 if (pci_using_dac)
4923 netdev->features |= NETIF_F_HIGHDMA; 4896 netdev->features |= NETIF_F_HIGHDMA;
4924 4897
4925 /*
4926 * We should not be using LLTX anymore, but we are still Tx faster with
4927 * it.
4928 */
4929 netdev->features |= NETIF_F_LLTX;
4930
4931 if (e1000e_enable_mng_pass_thru(&adapter->hw)) 4898 if (e1000e_enable_mng_pass_thru(&adapter->hw))
4932 adapter->flags |= FLAG_MNG_PT_ENABLED; 4899 adapter->flags |= FLAG_MNG_PT_ENABLED;
4933 4900
@@ -5091,6 +5058,7 @@ static void __devexit e1000_remove(struct pci_dev *pdev)
5091{ 5058{
5092 struct net_device *netdev = pci_get_drvdata(pdev); 5059 struct net_device *netdev = pci_get_drvdata(pdev);
5093 struct e1000_adapter *adapter = netdev_priv(netdev); 5060 struct e1000_adapter *adapter = netdev_priv(netdev);
5061 int err;
5094 5062
5095 /* 5063 /*
5096 * flush_scheduled work may reschedule our watchdog task, so 5064 * flush_scheduled work may reschedule our watchdog task, so
@@ -5125,6 +5093,12 @@ static void __devexit e1000_remove(struct pci_dev *pdev)
5125 5093
5126 free_netdev(netdev); 5094 free_netdev(netdev);
5127 5095
5096 /* AER disable */
5097 err = pci_disable_pcie_error_reporting(pdev);
5098 if (err)
5099 dev_err(&pdev->dev,
5100 "pci_disable_pcie_error_reporting failed 0x%x\n", err);
5101
5128 pci_disable_device(pdev); 5102 pci_disable_device(pdev);
5129} 5103}
5130 5104
@@ -5156,6 +5130,7 @@ static struct pci_device_id e1000_pci_tbl[] = {
5156 { PCI_VDEVICE(INTEL, E1000_DEV_ID_82573L), board_82573 }, 5130 { PCI_VDEVICE(INTEL, E1000_DEV_ID_82573L), board_82573 },
5157 5131
5158 { PCI_VDEVICE(INTEL, E1000_DEV_ID_82574L), board_82574 }, 5132 { PCI_VDEVICE(INTEL, E1000_DEV_ID_82574L), board_82574 },
5133 { PCI_VDEVICE(INTEL, E1000_DEV_ID_82583V), board_82583 },
5159 5134
5160 { PCI_VDEVICE(INTEL, E1000_DEV_ID_80003ES2LAN_COPPER_DPT), 5135 { PCI_VDEVICE(INTEL, E1000_DEV_ID_80003ES2LAN_COPPER_DPT),
5161 board_80003es2lan }, 5136 board_80003es2lan },
generated by cgit v1.2.2 (git 2.25.0) at 2024-09-28 20:20:40 -0400