144 static void e1000_82547_tx_fifo_stall(unsigned long data); |
144 static void e1000_82547_tx_fifo_stall(unsigned long data); |
145 static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev); |
145 static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev); |
146 static struct net_device_stats * e1000_get_stats(struct net_device *netdev); |
146 static struct net_device_stats * e1000_get_stats(struct net_device *netdev); |
147 static int e1000_change_mtu(struct net_device *netdev, int new_mtu); |
147 static int e1000_change_mtu(struct net_device *netdev, int new_mtu); |
148 static int e1000_set_mac(struct net_device *netdev, void *p); |
148 static int e1000_set_mac(struct net_device *netdev, void *p); |
|
149 void ec_poll(struct net_device *); |
149 static irqreturn_t e1000_intr(int irq, void *data, struct pt_regs *regs); |
150 static irqreturn_t e1000_intr(int irq, void *data, struct pt_regs *regs); |
150 static boolean_t e1000_clean_tx_irq(struct e1000_adapter *adapter, |
151 static boolean_t e1000_clean_tx_irq(struct e1000_adapter *adapter, |
151 struct e1000_tx_ring *tx_ring); |
152 struct e1000_tx_ring *tx_ring); |
152 #ifdef CONFIG_E1000_NAPI |
153 #ifdef CONFIG_E1000_NAPI |
153 static int e1000_clean(struct net_device *poll_dev, int *budget); |
154 static int e1000_clean(struct net_device *poll_dev, int *budget); |
961 * of the driver. */ |
962 * of the driver. */ |
962 if (adapter->hw.mac_type != e1000_82573 || |
963 if (adapter->hw.mac_type != e1000_82573 || |
963 !e1000_check_mng_mode(&adapter->hw)) |
964 !e1000_check_mng_mode(&adapter->hw)) |
964 e1000_get_hw_control(adapter); |
965 e1000_get_hw_control(adapter); |
965 |
966 |
966 strcpy(netdev->name, "eth%d"); |
967 // offer device to EtherCAT master module |
967 if ((err = register_netdev(netdev))) |
968 if (ecdev_offer(netdev, ec_poll, THIS_MODULE, &adapter->ecdev)) { |
|
969 DPRINTK(PROBE, ERR, "Failed to offer device.\n"); |
968 goto err_register; |
970 goto err_register; |
|
971 } |
|
972 |
|
973 if (adapter->ecdev) { |
|
974 if (ecdev_open(adapter->ecdev)) { |
|
975 ecdev_withdraw(adapter->ecdev); |
|
976 goto err_register; |
|
977 } |
|
978 } else { |
|
979 strcpy(netdev->name, "eth%d"); |
|
980 if ((err = register_netdev(netdev))) |
|
981 goto err_register; |
|
982 } |
|
983 |
|
984 return 0; |
969 |
985 |
970 DPRINTK(PROBE, INFO, "Intel(R) PRO/1000 Network Connection\n"); |
986 DPRINTK(PROBE, INFO, "Intel(R) PRO/1000 Network Connection\n"); |
971 |
987 |
972 cards_found++; |
988 cards_found++; |
973 return 0; |
989 return 0; |
1020 |
1036 |
1021 /* Release control of h/w to f/w. If f/w is AMT enabled, this |
1037 /* Release control of h/w to f/w. If f/w is AMT enabled, this |
1022 * would have already happened in close and is redundant. */ |
1038 * would have already happened in close and is redundant. */ |
1023 e1000_release_hw_control(adapter); |
1039 e1000_release_hw_control(adapter); |
1024 |
1040 |
1025 unregister_netdev(netdev); |
1041 if (adapter->ecdev) { |
|
1042 ecdev_close(adapter->ecdev); |
|
1043 ecdev_withdraw(adapter->ecdev); |
|
1044 } else { |
|
1045 unregister_netdev(netdev); |
|
1046 } |
1026 #ifdef CONFIG_E1000_NAPI |
1047 #ifdef CONFIG_E1000_NAPI |
1027 for (i = 0; i < adapter->num_rx_queues; i++) |
1048 for (i = 0; i < adapter->num_rx_queues; i++) |
1028 dev_put(&adapter->polling_netdev[i]); |
1049 dev_put(&adapter->polling_netdev[i]); |
1029 #endif |
1050 #endif |
1030 |
1051 |
1267 struct e1000_adapter *adapter = netdev_priv(netdev); |
1288 struct e1000_adapter *adapter = netdev_priv(netdev); |
1268 |
1289 |
1269 WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags)); |
1290 WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags)); |
1270 e1000_down(adapter); |
1291 e1000_down(adapter); |
1271 e1000_power_down_phy(adapter); |
1292 e1000_power_down_phy(adapter); |
1272 e1000_free_irq(adapter); |
1293 if (!adapter->ecdev) e1000_free_irq(adapter); |
1273 |
1294 |
1274 e1000_free_all_tx_resources(adapter); |
1295 e1000_free_all_tx_resources(adapter); |
1275 e1000_free_all_rx_resources(adapter); |
1296 e1000_free_all_rx_resources(adapter); |
1276 |
1297 |
1277 if ((adapter->hw.mng_cookie.status & |
1298 if ((adapter->hw.mng_cookie.status & |
2117 rctl |= E1000_RCTL_RST; |
2138 rctl |= E1000_RCTL_RST; |
2118 E1000_WRITE_REG(&adapter->hw, RCTL, rctl); |
2139 E1000_WRITE_REG(&adapter->hw, RCTL, rctl); |
2119 E1000_WRITE_FLUSH(&adapter->hw); |
2140 E1000_WRITE_FLUSH(&adapter->hw); |
2120 mdelay(5); |
2141 mdelay(5); |
2121 |
2142 |
2122 if (!adapter->ecdev || netif_running(netdev)) |
2143 if (!adapter->ecdev && netif_running(netdev)) |
2123 e1000_clean_all_rx_rings(adapter); |
2144 e1000_clean_all_rx_rings(adapter); |
2124 } |
2145 } |
2125 |
2146 |
2126 static void |
2147 static void |
2127 e1000_leave_82542_rst(struct e1000_adapter *adapter) |
2148 e1000_leave_82542_rst(struct e1000_adapter *adapter) |
2136 mdelay(5); |
2157 mdelay(5); |
2137 |
2158 |
2138 if (adapter->hw.pci_cmd_word & PCI_COMMAND_INVALIDATE) |
2159 if (adapter->hw.pci_cmd_word & PCI_COMMAND_INVALIDATE) |
2139 e1000_pci_set_mwi(&adapter->hw); |
2160 e1000_pci_set_mwi(&adapter->hw); |
2140 |
2161 |
2141 if (!adapter->ecdev || netif_running(netdev)) { |
2162 if (!adapter->ecdev && netif_running(netdev)) { |
2142 /* No need to loop, because 82542 supports only 1 queue */ |
2163 /* No need to loop, because 82542 supports only 1 queue */ |
2143 struct e1000_rx_ring *ring = &adapter->rx_ring[0]; |
2164 struct e1000_rx_ring *ring = &adapter->rx_ring[0]; |
2144 e1000_configure_rx(adapter); |
2165 e1000_configure_rx(adapter); |
2145 adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring)); |
2166 adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring)); |
2146 } |
2167 } |
2366 link = !adapter->hw.serdes_link_down; |
2387 link = !adapter->hw.serdes_link_down; |
2367 else |
2388 else |
2368 link = E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU; |
2389 link = E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU; |
2369 |
2390 |
2370 if (link) { |
2391 if (link) { |
2371 if ((adapter->ecdev && !ecdev_link_up(adapter->ecdev)) |
2392 if ((adapter->ecdev && !ecdev_get_link(adapter->ecdev)) |
2372 || (!adapter->ecdev && !netif_carrier_ok(netdev))) { |
2393 || (!adapter->ecdev && !netif_carrier_ok(netdev))) { |
2373 boolean_t txb2b = 1; |
2394 boolean_t txb2b = 1; |
2374 e1000_get_speed_and_duplex(&adapter->hw, |
2395 e1000_get_speed_and_duplex(&adapter->hw, |
2375 &adapter->link_speed, |
2396 &adapter->link_speed, |
2376 &adapter->link_duplex); |
2397 &adapter->link_duplex); |
2377 |
2398 |
2434 tctl = E1000_READ_REG(&adapter->hw, TCTL); |
2455 tctl = E1000_READ_REG(&adapter->hw, TCTL); |
2435 tctl |= E1000_TCTL_EN; |
2456 tctl |= E1000_TCTL_EN; |
2436 E1000_WRITE_REG(&adapter->hw, TCTL, tctl); |
2457 E1000_WRITE_REG(&adapter->hw, TCTL, tctl); |
2437 |
2458 |
2438 if (adapter->ecdev) { |
2459 if (adapter->ecdev) { |
2439 ecdev_link_state(1); |
2460 ecdev_set_link(adapter->ecdev, 1); |
2440 } else { |
2461 } else { |
2441 netif_carrier_on(netdev); |
2462 netif_carrier_on(netdev); |
2442 netif_wake_queue(netdev); |
2463 netif_wake_queue(netdev); |
2443 } |
2464 } |
2444 mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ); |
2465 mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ); |
2445 adapter->smartspeed = 0; |
2466 adapter->smartspeed = 0; |
2446 } |
2467 } |
2447 } else { |
2468 } else { |
2448 if ((adapter->ecdev && ecdev_link_up(adapter->ecdev)) |
2469 if ((adapter->ecdev && ecdev_get_link(adapter->ecdev)) |
2449 || (!adapter->ecdev && netif_carrier_ok(netdev))) { |
2470 || (!adapter->ecdev && netif_carrier_ok(netdev))) { |
2450 adapter->link_speed = 0; |
2471 adapter->link_speed = 0; |
2451 adapter->link_duplex = 0; |
2472 adapter->link_duplex = 0; |
2452 DPRINTK(LINK, INFO, "NIC Link is Down\n"); |
2473 DPRINTK(LINK, INFO, "NIC Link is Down\n"); |
2453 if (adapter->ecdev) { |
2474 if (adapter->ecdev) { |
2454 ecdev_link_state(0); |
2475 ecdev_set_link(adapter->ecdev, 0); |
2455 } else { |
2476 } else { |
2456 netif_carrier_off(netdev); |
2477 netif_carrier_off(netdev); |
2457 netif_stop_queue(netdev); |
2478 netif_stop_queue(netdev); |
2458 } |
2479 } |
2459 mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ); |
2480 mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ); |
2460 |
2481 |
2461 /* 80003ES2LAN workaround-- |
2482 /* 80003ES2LAN workaround-- |
2462 * For packet buffer work-around on link down event; |
2483 * For packet buffer work-around on link down event; |
2463 * disable receives in the ISR and |
2484 * disable receives in the ISR and |
2484 adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old; |
2505 adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old; |
2485 adapter->gotcl_old = adapter->stats.gotcl; |
2506 adapter->gotcl_old = adapter->stats.gotcl; |
2486 |
2507 |
2487 e1000_update_adaptive(&adapter->hw); |
2508 e1000_update_adaptive(&adapter->hw); |
2488 |
2509 |
2489 if ((adapter->ecdev && !ecdev_link_up(adapter->ecdev)) |
2510 if ((adapter->ecdev && !ecdev_get_link(adapter->ecdev)) |
2490 || (!adapter->ecdev && !netif_carrier_ok(netdev))) { |
2511 || (!adapter->ecdev && !netif_carrier_ok(netdev))) { |
2491 if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) { |
2512 if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) { |
2492 /* We've lost link, so the controller stops DMA, |
2513 /* We've lost link, so the controller stops DMA, |
2493 * but we've got queued Tx work that's never going |
2514 * but we've got queued Tx work that's never going |
2494 * to get done, so reset controller to flush Tx. |
2515 * to get done, so reset controller to flush Tx. |
2495 * (Do the reset outside of interrupt context). */ |
2516 * (Do the reset outside of interrupt context). */ |
2891 struct e1000_tx_ring *tx_ring; |
2912 struct e1000_tx_ring *tx_ring; |
2892 unsigned int first, max_per_txd = E1000_MAX_DATA_PER_TXD; |
2913 unsigned int first, max_per_txd = E1000_MAX_DATA_PER_TXD; |
2893 unsigned int max_txd_pwr = E1000_MAX_TXD_PWR; |
2914 unsigned int max_txd_pwr = E1000_MAX_TXD_PWR; |
2894 unsigned int tx_flags = 0; |
2915 unsigned int tx_flags = 0; |
2895 unsigned int len = skb->len; |
2916 unsigned int len = skb->len; |
2896 unsigned long flags; |
2917 unsigned long flags = 0; |
2897 unsigned int nr_frags = 0; |
2918 unsigned int nr_frags = 0; |
2898 unsigned int mss = 0; |
2919 unsigned int mss = 0; |
2899 int count = 0; |
2920 int count = 0; |
2900 int tso; |
2921 int tso; |
2901 unsigned int f; |
2922 unsigned int f; |
2902 len -= skb->data_len; |
2923 len -= skb->data_len; |
2903 |
2924 |
2904 tx_ring = adapter->tx_ring; |
2925 tx_ring = adapter->tx_ring; |
2905 |
2926 |
2906 if (unlikely(skb->len <= 0)) { |
2927 if (unlikely(skb->len <= 0)) { |
2907 if (!adapter->ecdev) |
2928 if (!adapter->ecdev) |
2908 dev_kfree_skb_any(skb); |
2929 dev_kfree_skb_any(skb); |
2909 return NETDEV_TX_OK; |
2930 return NETDEV_TX_OK; |
2910 } |
2931 } |
2911 |
2932 |
2912 #ifdef NETIF_F_TSO |
2933 #ifdef NETIF_F_TSO |
2913 mss = skb_shinfo(skb)->gso_size; |
2934 mss = skb_shinfo(skb)->gso_size; |
2936 pull_size = min((unsigned int)4, skb->data_len); |
2957 pull_size = min((unsigned int)4, skb->data_len); |
2937 if (!__pskb_pull_tail(skb, pull_size)) { |
2958 if (!__pskb_pull_tail(skb, pull_size)) { |
2938 DPRINTK(DRV, ERR, |
2959 DPRINTK(DRV, ERR, |
2939 "__pskb_pull_tail failed.\n"); |
2960 "__pskb_pull_tail failed.\n"); |
2940 if (!adapter->ecdev) |
2961 if (!adapter->ecdev) |
2941 dev_kfree_skb_any(skb); |
2962 dev_kfree_skb_any(skb); |
2942 return NETDEV_TX_OK; |
2963 return NETDEV_TX_OK; |
2943 } |
2964 } |
2944 len = skb->len - skb->data_len; |
2965 len = skb->len - skb->data_len; |
2945 break; |
2966 break; |
2946 default: |
2967 default: |
2987 |
3008 |
2988 if (adapter->hw.tx_pkt_filtering && |
3009 if (adapter->hw.tx_pkt_filtering && |
2989 (adapter->hw.mac_type == e1000_82573)) |
3010 (adapter->hw.mac_type == e1000_82573)) |
2990 e1000_transfer_dhcp_info(adapter, skb); |
3011 e1000_transfer_dhcp_info(adapter, skb); |
2991 |
3012 |
2992 if (!adapter->ecdev) { |
3013 if (!adapter->ecdev) { |
2993 local_irq_save(flags); |
3014 local_irq_save(flags); |
2994 if (!spin_trylock(&tx_ring->tx_lock)) { |
3015 if (!spin_trylock(&tx_ring->tx_lock)) { |
2995 /* Collision - tell upper layer to requeue */ |
3016 /* Collision - tell upper layer to requeue */ |
2996 local_irq_restore(flags); |
3017 local_irq_restore(flags); |
2997 return NETDEV_TX_LOCKED; |
3018 return NETDEV_TX_LOCKED; |
2998 } |
3019 } |
2999 } |
3020 } |
3000 |
3021 |
3001 /* need: count + 2 desc gap to keep tail from touching |
3022 /* need: count + 2 desc gap to keep tail from touching |
3002 * head, otherwise try next time */ |
3023 * head, otherwise try next time */ |
3003 if (unlikely(E1000_DESC_UNUSED(tx_ring) < count + 2)) { |
3024 if (unlikely(E1000_DESC_UNUSED(tx_ring) < count + 2)) { |
3004 if (!adapter->ecdev) { |
3025 if (!adapter->ecdev) { |
3005 netif_stop_queue(netdev); |
3026 netif_stop_queue(netdev); |
3006 spin_unlock_irqrestore(&tx_ring->tx_lock, flags); |
3027 spin_unlock_irqrestore(&tx_ring->tx_lock, flags); |
3007 } |
3028 } |
3008 return NETDEV_TX_BUSY; |
3029 return NETDEV_TX_BUSY; |
3009 } |
3030 } |
3010 |
3031 |
3011 if (unlikely(adapter->hw.mac_type == e1000_82547)) { |
3032 if (unlikely(adapter->hw.mac_type == e1000_82547)) { |
3012 if (unlikely(e1000_82547_fifo_workaround(adapter, skb))) { |
3033 if (unlikely(e1000_82547_fifo_workaround(adapter, skb))) { |
3013 if (!adapter->ecdev) |
3034 if (!adapter->ecdev) |
3014 netif_stop_queue(netdev); |
3035 netif_stop_queue(netdev); |
3015 mod_timer(&adapter->tx_fifo_stall_timer, jiffies); |
3036 mod_timer(&adapter->tx_fifo_stall_timer, jiffies); |
3016 if (!adapter->ecdev) |
3037 if (!adapter->ecdev) |
3017 spin_unlock_irqrestore(&tx_ring->tx_lock, flags); |
3038 spin_unlock_irqrestore(&tx_ring->tx_lock, flags); |
3018 return NETDEV_TX_BUSY; |
3039 return NETDEV_TX_BUSY; |
3019 } |
3040 } |
3020 } |
3041 } |
3021 |
3042 |
3022 if (unlikely(adapter->vlgrp && vlan_tx_tag_present(skb))) { |
3043 if (unlikely(adapter->vlgrp && vlan_tx_tag_present(skb))) { |
3026 |
3047 |
3027 first = tx_ring->next_to_use; |
3048 first = tx_ring->next_to_use; |
3028 |
3049 |
3029 tso = e1000_tso(adapter, tx_ring, skb); |
3050 tso = e1000_tso(adapter, tx_ring, skb); |
3030 if (tso < 0) { |
3051 if (tso < 0) { |
3031 if (!adapter->ecdev) { |
3052 if (!adapter->ecdev) { |
3032 dev_kfree_skb_any(skb); |
3053 dev_kfree_skb_any(skb); |
3033 spin_unlock_irqrestore(&tx_ring->tx_lock, flags); |
3054 spin_unlock_irqrestore(&tx_ring->tx_lock, flags); |
3034 } |
3055 } |
3035 return NETDEV_TX_OK; |
3056 return NETDEV_TX_OK; |
3036 } |
3057 } |
3037 |
3058 |
3038 if (likely(tso)) { |
3059 if (likely(tso)) { |
3039 tx_ring->last_tx_tso = 1; |
3060 tx_ring->last_tx_tso = 1; |
3053 |
3074 |
3054 netdev->trans_start = jiffies; |
3075 netdev->trans_start = jiffies; |
3055 |
3076 |
3056 /* Make sure there is space in the ring for the next send. */ |
3077 /* Make sure there is space in the ring for the next send. */ |
3057 if (!adapter->ecdev) { |
3078 if (!adapter->ecdev) { |
3058 if (unlikely(E1000_DESC_UNUSED(tx_ring) < MAX_SKB_FRAGS + 2)) |
3079 if (unlikely(E1000_DESC_UNUSED(tx_ring) < MAX_SKB_FRAGS + 2)) |
3059 netif_stop_queue(netdev); |
3080 netif_stop_queue(netdev); |
3060 |
3081 |
3061 spin_unlock_irqrestore(&tx_ring->tx_lock, flags); |
3082 spin_unlock_irqrestore(&tx_ring->tx_lock, flags); |
3062 } |
3083 } |
3063 return NETDEV_TX_OK; |
3084 return NETDEV_TX_OK; |
3064 } |
3085 } |
3065 |
3086 |
3066 /** |
3087 /** |
3067 * e1000_tx_timeout - Respond to a Tx Hang |
3088 * e1000_tx_timeout - Respond to a Tx Hang |
3219 if (adapter->link_speed == 0) |
3240 if (adapter->link_speed == 0) |
3220 return; |
3241 return; |
3221 if (pdev->error_state && pdev->error_state != pci_channel_io_normal) |
3242 if (pdev->error_state && pdev->error_state != pci_channel_io_normal) |
3222 return; |
3243 return; |
3223 |
3244 |
3224 if (!adapter->ecdev) |
3245 if (!adapter->ecdev) |
3225 spin_lock_irqsave(&adapter->stats_lock, flags); |
3246 spin_lock_irqsave(&adapter->stats_lock, flags); |
3226 |
3247 |
3227 /* these counters are modified from e1000_adjust_tbi_stats, |
3248 /* these counters are modified from e1000_adjust_tbi_stats, |
3228 * called from the interrupt context, so they must only |
3249 * called from the interrupt context, so they must only |
3229 * be written while holding adapter->stats_lock |
3250 * be written while holding adapter->stats_lock |
3230 */ |
3251 */ |
3361 (hw->phy_type == e1000_phy_m88) && |
3382 (hw->phy_type == e1000_phy_m88) && |
3362 !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp)) |
3383 !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp)) |
3363 adapter->phy_stats.receive_errors += phy_tmp; |
3384 adapter->phy_stats.receive_errors += phy_tmp; |
3364 } |
3385 } |
3365 |
3386 |
3366 if (!adapter->ecdev) |
3387 if (!adapter->ecdev) |
3367 spin_unlock_irqrestore(&adapter->stats_lock, flags); |
3388 spin_unlock_irqrestore(&adapter->stats_lock, flags); |
|
3389 } |
|
3390 |
|
3391 void ec_poll(struct net_device *dev) |
|
3392 { |
|
3393 e1000_intr(0, dev, NULL); |
3368 } |
3394 } |
3369 |
3395 |
3370 /** |
3396 /** |
3371 * e1000_intr - Interrupt Handler |
3397 * e1000_intr - Interrupt Handler |
3372 * @irq: interrupt number |
3398 * @irq: interrupt number |
3405 /* 80003ES2LAN workaround-- |
3431 /* 80003ES2LAN workaround-- |
3406 * For packet buffer work-around on link down event; |
3432 * For packet buffer work-around on link down event; |
3407 * disable receives here in the ISR and |
3433 * disable receives here in the ISR and |
3408 * reset adapter in watchdog |
3434 * reset adapter in watchdog |
3409 */ |
3435 */ |
3410 if (((adapter->ecdev && ecdev_link_up(adapter->ecdev)) |
3436 if (((adapter->ecdev && ecdev_get_link(adapter->ecdev)) |
3411 || (!adapter->ecdev && netif_carrier_ok(netdev))) && |
3437 || (!adapter->ecdev && netif_carrier_ok(netdev))) && |
3412 (adapter->hw.mac_type == e1000_80003es2lan)) { |
3438 (adapter->hw.mac_type == e1000_80003es2lan)) { |
3413 /* disable receives */ |
3439 /* disable receives */ |
3414 rctl = E1000_READ_REG(hw, RCTL); |
3440 rctl = E1000_READ_REG(hw, RCTL); |
3415 E1000_WRITE_REG(hw, RCTL, rctl & ~E1000_RCTL_EN); |
3441 E1000_WRITE_REG(hw, RCTL, rctl & ~E1000_RCTL_EN); |
3416 } |
3442 } |
3417 mod_timer(&adapter->watchdog_timer, jiffies); |
3443 mod_timer(&adapter->watchdog_timer, jiffies); |
3421 if (unlikely(hw->mac_type < e1000_82571)) { |
3447 if (unlikely(hw->mac_type < e1000_82571)) { |
3422 atomic_inc(&adapter->irq_sem); |
3448 atomic_inc(&adapter->irq_sem); |
3423 E1000_WRITE_REG(hw, IMC, ~0); |
3449 E1000_WRITE_REG(hw, IMC, ~0); |
3424 E1000_WRITE_FLUSH(hw); |
3450 E1000_WRITE_FLUSH(hw); |
3425 } |
3451 } |
3426 if (!adapter->ecdev) { |
3452 if (!adapter->ecdev) { |
3427 if (likely(netif_rx_schedule_prep(netdev))) |
3453 if (likely(netif_rx_schedule_prep(netdev))) |
3428 __netif_rx_schedule(netdev); |
3454 __netif_rx_schedule(netdev); |
3429 else |
3455 else |
3430 e1000_irq_enable(adapter); |
3456 e1000_irq_enable(adapter); |
3431 } |
3457 } |
3432 #else |
3458 #else |
3433 /* Writing IMC and IMS is needed for 82547. |
3459 /* Writing IMC and IMS is needed for 82547. |
3434 * Due to Hub Link bus being occupied, an interrupt |
3460 * Due to Hub Link bus being occupied, an interrupt |
3435 * de-assertion message is not able to be sent. |
3461 * de-assertion message is not able to be sent. |
3436 * When an interrupt assertion message is generated later, |
3462 * When an interrupt assertion message is generated later, |
3437 * two messages are re-ordered and sent out. |
3463 * two messages are re-ordered and sent out. |
3438 * That causes APIC to think 82547 is in de-assertion |
3464 * That causes APIC to think 82547 is in de-assertion |
3439 * state, while 82547 is in assertion state, resulting |
3465 * state, while 82547 is in assertion state, resulting |
3554 |
3579 |
3555 tx_ring->next_to_clean = i; |
3580 tx_ring->next_to_clean = i; |
3556 |
3581 |
3557 #define TX_WAKE_THRESHOLD 32 |
3582 #define TX_WAKE_THRESHOLD 32 |
3558 if (unlikely(!adapter->ecdev && cleaned && netif_queue_stopped(netdev) && |
3583 if (unlikely(!adapter->ecdev && cleaned && netif_queue_stopped(netdev) && |
3559 netif_carrier_ok(netdev))) { |
3584 netif_carrier_ok(netdev))) { |
3560 spin_lock(&tx_ring->tx_lock); |
3585 spin_lock(&tx_ring->tx_lock); |
3561 if (netif_queue_stopped(netdev) && |
3586 if (netif_queue_stopped(netdev) && |
3562 (E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) |
3587 (E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) |
3563 netif_wake_queue(netdev); |
3588 netif_wake_queue(netdev); |
3564 spin_unlock(&tx_ring->tx_lock); |
3589 spin_unlock(&tx_ring->tx_lock); |
3565 } |
3590 } |
3566 |
3591 |
3567 if (adapter->detect_tx_hung) { |
3592 if (adapter->detect_tx_hung) { |
3584 "buffer_info[next_to_clean]\n" |
3609 "buffer_info[next_to_clean]\n" |
3585 " time_stamp <%lx>\n" |
3610 " time_stamp <%lx>\n" |
3586 " next_to_watch <%x>\n" |
3611 " next_to_watch <%x>\n" |
3587 " jiffies <%lx>\n" |
3612 " jiffies <%lx>\n" |
3588 " next_to_watch.status <%x>\n", |
3613 " next_to_watch.status <%x>\n", |
3589 (unsigned long)((tx_ring - adapter->tx_ring) / |
3614 (unsigned long)((tx_ring - adapter->tx_ring) / |
3590 sizeof(struct e1000_tx_ring)), |
3615 sizeof(struct e1000_tx_ring)), |
3591 readl(adapter->hw.hw_addr + tx_ring->tdh), |
3616 readl(adapter->hw.hw_addr + tx_ring->tdh), |
3592 readl(adapter->hw.hw_addr + tx_ring->tdt), |
3617 readl(adapter->hw.hw_addr + tx_ring->tdt), |
3593 tx_ring->next_to_use, |
3618 tx_ring->next_to_use, |
3594 tx_ring->next_to_clean, |
3619 tx_ring->next_to_clean, |
3595 tx_ring->buffer_info[eop].time_stamp, |
3620 tx_ring->buffer_info[eop].time_stamp, |
3596 eop, |
3621 eop, |
3597 jiffies, |
3622 jiffies, |
3598 eop_desc->upper.fields.status); |
3623 eop_desc->upper.fields.status); |
3599 netif_stop_queue(netdev); |
3624 if (!adapter->ecdev) netif_stop_queue(netdev); |
3600 } |
3625 } |
3601 } |
3626 } |
3602 return cleaned; |
3627 return cleaned; |
3603 } |
3628 } |
3604 |
3629 |
3725 } |
3750 } |
3726 |
3751 |
3727 if (!adapter->ecdev && unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) { |
3752 if (!adapter->ecdev && unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) { |
3728 last_byte = *(skb->data + length - 1); |
3753 last_byte = *(skb->data + length - 1); |
3729 if (TBI_ACCEPT(&adapter->hw, status, |
3754 if (TBI_ACCEPT(&adapter->hw, status, |
3730 rx_desc->errors, length, last_byte)) { |
3755 rx_desc->errors, length, last_byte)) { |
3731 spin_lock_irqsave(&adapter->stats_lock, flags); |
3756 spin_lock_irqsave(&adapter->stats_lock, flags); |
3732 e1000_tbi_adjust_stats(&adapter->hw, |
3757 e1000_tbi_adjust_stats(&adapter->hw, |
3733 &adapter->stats, |
3758 &adapter->stats, |
3734 length, skb->data); |
3759 length, skb->data); |
3735 spin_unlock_irqrestore(&adapter->stats_lock, |
3760 spin_unlock_irqrestore(&adapter->stats_lock, |
3736 flags); |
3761 flags); |
3737 length--; |
3762 length--; |
3738 } else { |
3763 } else { |
3739 /* recycle */ |
3764 /* recycle */ |
3740 buffer_info->skb = skb; |
3765 buffer_info->skb = skb; |
3741 goto next_desc; |
3766 goto next_desc; |
3746 * performance for small packets with large amounts |
3771 * performance for small packets with large amounts |
3747 * of reassembly being done in the stack */ |
3772 * of reassembly being done in the stack */ |
3748 #define E1000_CB_LENGTH 256 |
3773 #define E1000_CB_LENGTH 256 |
3749 if (!adapter->ecdev && length < E1000_CB_LENGTH) { |
3774 if (!adapter->ecdev && length < E1000_CB_LENGTH) { |
3750 struct sk_buff *new_skb = |
3775 struct sk_buff *new_skb = |
3751 netdev_alloc_skb(netdev, length + NET_IP_ALIGN); |
3776 netdev_alloc_skb(netdev, length + NET_IP_ALIGN); |
3752 if (new_skb) { |
3777 if (new_skb) { |
3753 skb_reserve(new_skb, NET_IP_ALIGN); |
3778 skb_reserve(new_skb, NET_IP_ALIGN); |
3754 new_skb->dev = netdev; |
3779 new_skb->dev = netdev; |
3755 memcpy(new_skb->data - NET_IP_ALIGN, |
3780 memcpy(new_skb->data - NET_IP_ALIGN, |
3756 skb->data - NET_IP_ALIGN, |
3781 skb->data - NET_IP_ALIGN, |
3757 length + NET_IP_ALIGN); |
3782 length + NET_IP_ALIGN); |
3758 /* save the skb in buffer_info as good */ |
3783 /* save the skb in buffer_info as good */ |
3759 buffer_info->skb = skb; |
3784 buffer_info->skb = skb; |
3760 skb = new_skb; |
3785 skb = new_skb; |
3761 skb_put(skb, length); |
3786 skb_put(skb, length); |
3762 } |
3787 } |
3769 e1000_rx_checksum(adapter, |
3794 e1000_rx_checksum(adapter, |
3770 (uint32_t)(status) | |
3795 (uint32_t)(status) | |
3771 ((uint32_t)(rx_desc->errors) << 24), |
3796 ((uint32_t)(rx_desc->errors) << 24), |
3772 le16_to_cpu(rx_desc->csum), skb); |
3797 le16_to_cpu(rx_desc->csum), skb); |
3773 |
3798 |
3774 skb->protocol = eth_type_trans(skb, netdev); |
3799 if (adapter->ecdev) { |
|
3800 ecdev_receive(adapter->ecdev, skb->data, length); |
|
3801 } else { |
|
3802 skb->protocol = eth_type_trans(skb, netdev); |
3775 #ifdef CONFIG_E1000_NAPI |
3803 #ifdef CONFIG_E1000_NAPI |
3776 if (unlikely(adapter->vlgrp && |
3804 if (unlikely(adapter->vlgrp && |
3777 (status & E1000_RXD_STAT_VP))) { |
3805 (status & E1000_RXD_STAT_VP))) { |
3778 vlan_hwaccel_receive_skb(skb, adapter->vlgrp, |
3806 vlan_hwaccel_receive_skb(skb, adapter->vlgrp, |
3779 le16_to_cpu(rx_desc->special) & |
3807 le16_to_cpu(rx_desc->special) & |
3780 E1000_RXD_SPC_VLAN_MASK); |
3808 E1000_RXD_SPC_VLAN_MASK); |
3781 } else { |
3809 } else { |
3782 netif_receive_skb(skb); |
3810 netif_receive_skb(skb); |
3783 } |
3811 } |
3784 #else /* CONFIG_E1000_NAPI */ |
3812 #else /* CONFIG_E1000_NAPI */ |
3785 if (unlikely(adapter->vlgrp && |
3813 if (unlikely(adapter->vlgrp && |
3786 (status & E1000_RXD_STAT_VP))) { |
3814 (status & E1000_RXD_STAT_VP))) { |
3787 vlan_hwaccel_rx(skb, adapter->vlgrp, |
3815 vlan_hwaccel_rx(skb, adapter->vlgrp, |
3788 le16_to_cpu(rx_desc->special) & |
3816 le16_to_cpu(rx_desc->special) & |
3789 E1000_RXD_SPC_VLAN_MASK); |
3817 E1000_RXD_SPC_VLAN_MASK); |
3790 } else { |
3818 } else { |
3791 netif_rx(skb); |
3819 netif_rx(skb); |
3792 } |
3820 } |
3793 #endif /* CONFIG_E1000_NAPI */ |
3821 #endif /* CONFIG_E1000_NAPI */ |
|
3822 } |
3794 netdev->last_rx = jiffies; |
3823 netdev->last_rx = jiffies; |
3795 |
3824 |
3796 next_desc: |
3825 next_desc: |
3797 rx_desc->status = 0; |
3826 rx_desc->status = 0; |
3798 |
3827 |
3873 PCI_DMA_FROMDEVICE); |
3902 PCI_DMA_FROMDEVICE); |
3874 |
3903 |
3875 if (unlikely(!(staterr & E1000_RXD_STAT_EOP))) { |
3904 if (unlikely(!(staterr & E1000_RXD_STAT_EOP))) { |
3876 E1000_DBG("%s: Packet Split buffers didn't pick up" |
3905 E1000_DBG("%s: Packet Split buffers didn't pick up" |
3877 " the full packet\n", netdev->name); |
3906 " the full packet\n", netdev->name); |
3878 dev_kfree_skb_irq(skb); |
3907 if (!adapter->ecdev) dev_kfree_skb_irq(skb); |
3879 goto next_desc; |
3908 goto next_desc; |
3880 } |
3909 } |
3881 |
3910 |
3882 if (unlikely(staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK)) { |
3911 if (unlikely(staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK)) { |
3883 dev_kfree_skb_irq(skb); |
3912 if (!adapter->ecdev) dev_kfree_skb_irq(skb); |
3884 goto next_desc; |
3913 goto next_desc; |
3885 } |
3914 } |
3886 |
3915 |
3887 length = le16_to_cpu(rx_desc->wb.middle.length0); |
3916 length = le16_to_cpu(rx_desc->wb.middle.length0); |
3888 |
3917 |
3889 if (unlikely(!length)) { |
3918 if (unlikely(!length)) { |
3890 E1000_DBG("%s: Last part of the packet spanning" |
3919 E1000_DBG("%s: Last part of the packet spanning" |
3891 " multiple descriptors\n", netdev->name); |
3920 " multiple descriptors\n", netdev->name); |
3892 dev_kfree_skb_irq(skb); |
3921 if (!adapter->ecdev) dev_kfree_skb_irq(skb); |
3893 goto next_desc; |
3922 goto next_desc; |
3894 } |
3923 } |
3895 |
3924 |
3896 /* Good Receive */ |
3925 /* Good Receive */ |
3897 skb_put(skb, length); |
3926 skb_put(skb, length); |
3945 pskb_trim(skb, skb->len - 4); |
3974 pskb_trim(skb, skb->len - 4); |
3946 |
3975 |
3947 copydone: |
3976 copydone: |
3948 e1000_rx_checksum(adapter, staterr, |
3977 e1000_rx_checksum(adapter, staterr, |
3949 le16_to_cpu(rx_desc->wb.lower.hi_dword.csum_ip.csum), skb); |
3978 le16_to_cpu(rx_desc->wb.lower.hi_dword.csum_ip.csum), skb); |
3950 skb->protocol = eth_type_trans(skb, netdev); |
|
3951 |
3979 |
3952 if (likely(rx_desc->wb.upper.header_status & |
3980 if (likely(rx_desc->wb.upper.header_status & |
3953 cpu_to_le16(E1000_RXDPS_HDRSTAT_HDRSP))) |
3981 cpu_to_le16(E1000_RXDPS_HDRSTAT_HDRSP))) |
3954 adapter->rx_hdr_split++; |
3982 adapter->rx_hdr_split++; |
|
3983 if (adapter->ecdev) { |
|
3984 ecdev_receive(adapter->ecdev, skb->data, length); |
|
3985 } else { |
|
3986 skb->protocol = eth_type_trans(skb, netdev); |
3955 #ifdef CONFIG_E1000_NAPI |
3987 #ifdef CONFIG_E1000_NAPI |
3956 if (unlikely(adapter->vlgrp && (staterr & E1000_RXD_STAT_VP))) { |
3988 if (unlikely(adapter->vlgrp && (staterr & E1000_RXD_STAT_VP))) { |
3957 vlan_hwaccel_receive_skb(skb, adapter->vlgrp, |
3989 vlan_hwaccel_receive_skb(skb, adapter->vlgrp, |
3958 le16_to_cpu(rx_desc->wb.middle.vlan) & |
3990 le16_to_cpu(rx_desc->wb.middle.vlan) & |
3959 E1000_RXD_SPC_VLAN_MASK); |
3991 E1000_RXD_SPC_VLAN_MASK); |
3960 } else { |
3992 } else { |
3961 netif_receive_skb(skb); |
3993 netif_receive_skb(skb); |
3962 } |
3994 } |
3963 #else /* CONFIG_E1000_NAPI */ |
3995 #else /* CONFIG_E1000_NAPI */ |
3964 if (unlikely(adapter->vlgrp && (staterr & E1000_RXD_STAT_VP))) { |
3996 if (unlikely(adapter->vlgrp && (staterr & E1000_RXD_STAT_VP))) { |
3965 vlan_hwaccel_rx(skb, adapter->vlgrp, |
3997 vlan_hwaccel_rx(skb, adapter->vlgrp, |
3966 le16_to_cpu(rx_desc->wb.middle.vlan) & |
3998 le16_to_cpu(rx_desc->wb.middle.vlan) & |
3967 E1000_RXD_SPC_VLAN_MASK); |
3999 E1000_RXD_SPC_VLAN_MASK); |
3968 } else { |
4000 } else { |
3969 netif_rx(skb); |
4001 netif_rx(skb); |
3970 } |
4002 } |
3971 #endif /* CONFIG_E1000_NAPI */ |
4003 #endif /* CONFIG_E1000_NAPI */ |
|
4004 } |
3972 netdev->last_rx = jiffies; |
4005 netdev->last_rx = jiffies; |
3973 |
4006 |
3974 next_desc: |
4007 next_desc: |
3975 rx_desc->wb.middle.status_error &= cpu_to_le32(~0xFF); |
4008 rx_desc->wb.middle.status_error &= cpu_to_le32(~0xFF); |
3976 buffer_info->skb = NULL; |
4009 if (!adapter->ecdev) buffer_info->skb = NULL; |
3977 |
4010 |
3978 /* return some buffers to hardware, one at a time is too slow */ |
4011 /* return some buffers to hardware, one at a time is too slow */ |
3979 if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) { |
4012 if (unlikely(!adapter->ecdev && cleaned_count >= E1000_RX_BUFFER_WRITE)) { |
3980 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); |
4013 adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); |
3981 cleaned_count = 0; |
4014 cleaned_count = 0; |
3982 } |
4015 } |
3983 |
4016 |
3984 /* use prefetched values */ |
4017 /* use prefetched values */ |
4721 } |
4757 } |
4722 |
4758 |
4723 if (adapter->hw.phy_type == e1000_phy_igp_3) |
4759 if (adapter->hw.phy_type == e1000_phy_igp_3) |
4724 e1000_phy_powerdown_workaround(&adapter->hw); |
4760 e1000_phy_powerdown_workaround(&adapter->hw); |
4725 |
4761 |
4726 if (netif_running(netdev)) |
4762 if (!adapter->ecdev && netif_running(netdev)) |
4727 e1000_free_irq(adapter); |
4763 e1000_free_irq(adapter); |
4728 |
4764 |
4729 /* Release control of h/w to f/w. If f/w is AMT enabled, this |
4765 /* Release control of h/w to f/w. If f/w is AMT enabled, this |
4730 * would have already happened in close and is redundant. */ |
4766 * would have already happened in close and is redundant. */ |
4731 e1000_release_hw_control(adapter); |
4767 e1000_release_hw_control(adapter); |
4763 E1000_WRITE_REG(&adapter->hw, WUS, ~0); |
4799 E1000_WRITE_REG(&adapter->hw, WUS, ~0); |
4764 |
4800 |
4765 if (adapter->ecdev || netif_running(netdev)) |
4801 if (adapter->ecdev || netif_running(netdev)) |
4766 e1000_up(adapter); |
4802 e1000_up(adapter); |
4767 |
4803 |
4768 if (adapter->ecdev) netif_device_attach(netdev); |
4804 if (!adapter->ecdev) netif_device_attach(netdev); |
4769 |
4805 |
4770 /* FIXME: this code is incorrect for PCI Express */ |
4806 /* FIXME: this code is incorrect for PCI Express */ |
4771 if (adapter->hw.mac_type >= e1000_82540 && |
4807 if (adapter->hw.mac_type >= e1000_82540 && |
4772 adapter->hw.mac_type != e1000_ich8lan && |
4808 adapter->hw.mac_type != e1000_ich8lan && |
4773 adapter->hw.media_type == e1000_media_type_copper) { |
4809 adapter->hw.media_type == e1000_media_type_copper) { |
4825 static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state) |
4861 static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state) |
4826 { |
4862 { |
4827 struct net_device *netdev = pci_get_drvdata(pdev); |
4863 struct net_device *netdev = pci_get_drvdata(pdev); |
4828 struct e1000_adapter *adapter = netdev->priv; |
4864 struct e1000_adapter *adapter = netdev->priv; |
4829 |
4865 |
4830 netif_device_detach(netdev); |
4866 if (!adapter->ecdev) |
4831 |
4867 netif_device_detach(netdev); |
4832 if (netif_running(netdev)) |
4868 |
|
4869 if (adapter->ecdev || netif_running(netdev)) |
4833 e1000_down(adapter); |
4870 e1000_down(adapter); |
4834 |
4871 |
4835 /* Request a slot slot reset. */ |
4872 /* Request a slot slot reset. */ |
4836 return PCI_ERS_RESULT_NEED_RESET; |
4873 return PCI_ERS_RESULT_NEED_RESET; |
4837 } |
4874 } |
4879 { |
4916 { |
4880 struct net_device *netdev = pci_get_drvdata(pdev); |
4917 struct net_device *netdev = pci_get_drvdata(pdev); |
4881 struct e1000_adapter *adapter = netdev->priv; |
4918 struct e1000_adapter *adapter = netdev->priv; |
4882 uint32_t manc, swsm; |
4919 uint32_t manc, swsm; |
4883 |
4920 |
4884 if (netif_running(netdev)) { |
4921 if (adapter->ecdev || netif_running(netdev)) { |
4885 if (e1000_up(adapter)) { |
4922 if (e1000_up(adapter)) { |
4886 printk("e1000: can't bring device back up after reset\n"); |
4923 printk("e1000: can't bring device back up after reset\n"); |
4887 return; |
4924 return; |
4888 } |
4925 } |
4889 } |
4926 } |
4890 |
4927 |
4891 netif_device_attach(netdev); |
4928 if (!adapter->ecdev) |
|
4929 netif_device_attach(netdev); |
4892 |
4930 |
4893 if (adapter->hw.mac_type >= e1000_82540 && |
4931 if (adapter->hw.mac_type >= e1000_82540 && |
4894 adapter->hw.media_type == e1000_media_type_copper) { |
4932 adapter->hw.media_type == e1000_media_type_copper) { |
4895 manc = E1000_READ_REG(&adapter->hw, MANC); |
4933 manc = E1000_READ_REG(&adapter->hw, MANC); |
4896 manc &= ~(E1000_MANC_ARP_EN); |
4934 manc &= ~(E1000_MANC_ARP_EN); |