Lines Matching defs:adapter
133 if (hw->adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
173 static void e1000e_dump_ps_pages(struct e1000_adapter *adapter,
179 for (i = 0; i < adapter->rx_ps_pages; i++) {
193 * @adapter: board private structure
195 static void e1000e_dump(struct e1000_adapter *adapter)
197 struct net_device *netdev = adapter->netdev;
198 struct e1000_hw *hw = &adapter->hw;
200 struct e1000_ring *tx_ring = adapter->tx_ring;
207 struct e1000_ring *rx_ring = adapter->rx_ring;
219 if (!netif_msg_hw(adapter))
224 dev_info(&adapter->pdev->dev, "Net device Info\n");
231 dev_info(&adapter->pdev->dev, "Register Dump\n");
242 dev_info(&adapter->pdev->dev, "Tx Ring Summary\n");
253 if (!netif_msg_tx_done(adapter))
256 dev_info(&adapter->pdev->dev, "Tx Ring Dump\n");
312 if (netif_msg_pktdata(adapter) && buffer_info->skb)
320 dev_info(&adapter->pdev->dev, "Rx Ring Summary\n");
326 if (!netif_msg_rx_status(adapter))
329 dev_info(&adapter->pdev->dev, "Rx Ring Dump\n");
330 switch (adapter->rx_ps_pages) {
393 if (netif_msg_pktdata(adapter))
394 e1000e_dump_ps_pages(adapter,
455 if (netif_msg_pktdata(adapter) &&
461 adapter->rx_buffer_len,
482 * @adapter: board private structure
494 static void e1000e_systim_to_hwtstamp(struct e1000_adapter *adapter,
501 spin_lock_irqsave(&adapter->systim_lock, flags);
502 ns = timecounter_cyc2time(&adapter->tc, systim);
503 spin_unlock_irqrestore(&adapter->systim_lock, flags);
511 * @adapter: board private structure
519 static void e1000e_rx_hwtstamp(struct e1000_adapter *adapter, u32 status,
522 struct e1000_hw *hw = &adapter->hw;
525 if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP) ||
539 e1000e_systim_to_hwtstamp(adapter, skb_hwtstamps(skb), rxstmp);
541 adapter->flags2 &= ~FLAG2_CHECK_RX_HWTSTAMP;
546 * @adapter: board private structure
552 static void e1000_receive_skb(struct e1000_adapter *adapter,
558 e1000e_rx_hwtstamp(adapter, staterr, skb);
565 napi_gro_receive(&adapter->napi, skb);
570 * @adapter: board private structure
574 static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
583 if (!(adapter->netdev->features & NETIF_F_RXCSUM))
593 adapter->hw_csum_err++;
603 adapter->hw_csum_good++;
608 struct e1000_adapter *adapter = rx_ring->adapter;
609 struct e1000_hw *hw = &adapter->hw;
619 schedule_work(&adapter->reset_task);
625 struct e1000_adapter *adapter = tx_ring->adapter;
626 struct e1000_hw *hw = &adapter->hw;
636 schedule_work(&adapter->reset_task);
649 struct e1000_adapter *adapter = rx_ring->adapter;
650 struct net_device *netdev = adapter->netdev;
651 struct pci_dev *pdev = adapter->pdev;
656 unsigned int bufsz = adapter->rx_buffer_len;
671 adapter->alloc_rx_buff_failed++;
678 adapter->rx_buffer_len,
682 adapter->rx_dma_failed++;
696 if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
719 struct e1000_adapter *adapter = rx_ring->adapter;
720 struct net_device *netdev = adapter->netdev;
721 struct pci_dev *pdev = adapter->pdev;
736 if (j >= adapter->rx_ps_pages) {
745 adapter->alloc_rx_buff_failed++;
754 dev_err(&adapter->pdev->dev,
756 adapter->rx_dma_failed++;
768 skb = __netdev_alloc_skb_ip_align(netdev, adapter->rx_ps_bsize0,
772 adapter->alloc_rx_buff_failed++;
778 adapter->rx_ps_bsize0,
782 adapter->rx_dma_failed++;
798 if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
824 struct e1000_adapter *adapter = rx_ring->adapter;
825 struct net_device *netdev = adapter->netdev;
826 struct pci_dev *pdev = adapter->pdev;
846 adapter->alloc_rx_buff_failed++;
856 adapter->alloc_rx_buff_failed++;
867 adapter->alloc_rx_buff_failed++;
891 if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
917 struct e1000_adapter *adapter = rx_ring->adapter;
918 struct net_device *netdev = adapter->netdev;
919 struct pci_dev *pdev = adapter->pdev;
920 struct e1000_hw *hw = &adapter->hw;
958 adapter->rx_buffer_len, DMA_FROM_DEVICE);
970 adapter->flags2 |= FLAG2_IS_DISCARDING;
972 if (adapter->flags2 & FLAG2_IS_DISCARDING) {
978 adapter->flags2 &= ~FLAG2_IS_DISCARDING;
990 if (!(adapter->flags2 & FLAG2_CRC_STRIPPING)) {
1010 napi_alloc_skb(&adapter->napi, length);
1028 e1000_rx_checksum(adapter, staterr, skb);
1032 e1000_receive_skb(adapter, netdev, skb, staterr,
1040 adapter->alloc_rx_buf(rx_ring, cleaned_count,
1055 adapter->alloc_rx_buf(rx_ring, cleaned_count, GFP_ATOMIC);
1057 adapter->total_rx_bytes += total_rx_bytes;
1058 adapter->total_rx_packets += total_rx_packets;
1066 struct e1000_adapter *adapter = tx_ring->adapter;
1070 dma_unmap_page(&adapter->pdev->dev, buffer_info->dma,
1073 dma_unmap_single(&adapter->pdev->dev, buffer_info->dma,
1089 struct e1000_adapter *adapter = container_of(work,
1092 struct net_device *netdev = adapter->netdev;
1093 struct e1000_ring *tx_ring = adapter->tx_ring;
1097 struct e1000_hw *hw = &adapter->hw;
1101 if (test_bit(__E1000_DOWN, &adapter->state))
1104 if (!adapter->tx_hang_recheck && (adapter->flags2 & FLAG2_DMA_BURST)) {
1108 ew32(TIDV, adapter->tx_int_delay | E1000_TIDV_FPD);
1114 ew32(TIDV, adapter->tx_int_delay | E1000_TIDV_FPD);
1117 adapter->tx_hang_recheck = true;
1120 adapter->tx_hang_recheck = false;
1134 pci_read_config_word(adapter->pdev, PCI_STATUS, &pci_status);
1157 e1000e_dump(adapter);
1174 struct e1000_adapter *adapter = container_of(work, struct e1000_adapter,
1176 struct e1000_hw *hw = &adapter->hw;
1179 struct sk_buff *skb = adapter->tx_hwtstamp_skb;
1186 e1000e_systim_to_hwtstamp(adapter, &shhwtstamps, txstmp);
1191 adapter->tx_hwtstamp_skb = NULL;
1196 } else if (time_after(jiffies, adapter->tx_hwtstamp_start
1197 + adapter->tx_timeout_factor * HZ)) {
1198 dev_kfree_skb_any(adapter->tx_hwtstamp_skb);
1199 adapter->tx_hwtstamp_skb = NULL;
1200 adapter->tx_hwtstamp_timeouts++;
1204 schedule_work(&adapter->tx_hwtstamp_work);
1217 struct e1000_adapter *adapter = tx_ring->adapter;
1218 struct net_device *netdev = adapter->netdev;
1219 struct e1000_hw *hw = &adapter->hw;
1277 !(test_bit(__E1000_DOWN, &adapter->state))) {
1279 ++adapter->restart_queue;
1283 if (adapter->detect_tx_hung) {
1287 adapter->detect_tx_hung = false;
1290 + (adapter->tx_timeout_factor * HZ)) &&
1292 schedule_work(&adapter->print_hang_task);
1294 adapter->tx_hang_recheck = false;
1296 adapter->total_tx_bytes += total_tx_bytes;
1297 adapter->total_tx_packets += total_tx_packets;
1313 struct e1000_adapter *adapter = rx_ring->adapter;
1314 struct e1000_hw *hw = &adapter->hw;
1316 struct net_device *netdev = adapter->netdev;
1317 struct pci_dev *pdev = adapter->pdev;
1353 adapter->rx_ps_bsize0, DMA_FROM_DEVICE);
1358 adapter->flags2 |= FLAG2_IS_DISCARDING;
1360 if (adapter->flags2 & FLAG2_IS_DISCARDING) {
1364 adapter->flags2 &= ~FLAG2_IS_DISCARDING;
1396 ((length + l1) <= adapter->rx_ps_bsize0)) {
1411 if (!(adapter->flags2 & FLAG2_CRC_STRIPPING)) {
1440 if (!(adapter->flags2 & FLAG2_CRC_STRIPPING)) {
1449 e1000_rx_checksum(adapter, staterr, skb);
1455 adapter->rx_hdr_split++;
1457 e1000_receive_skb(adapter, netdev, skb, staterr,
1466 adapter->alloc_rx_buf(rx_ring, cleaned_count,
1481 adapter->alloc_rx_buf(rx_ring, cleaned_count, GFP_ATOMIC);
1483 adapter->total_rx_bytes += total_rx_bytes;
1484 adapter->total_rx_packets += total_rx_packets;
1509 struct e1000_adapter *adapter = rx_ring->adapter;
1510 struct net_device *netdev = adapter->netdev;
1511 struct pci_dev *pdev = adapter->pdev;
1622 e1000_rx_checksum(adapter, staterr, skb);
1637 e1000_receive_skb(adapter, netdev, skb, staterr,
1645 adapter->alloc_rx_buf(rx_ring, cleaned_count,
1660 adapter->alloc_rx_buf(rx_ring, cleaned_count, GFP_ATOMIC);
1662 adapter->total_rx_bytes += total_rx_bytes;
1663 adapter->total_rx_packets += total_rx_packets;
1673 struct e1000_adapter *adapter = rx_ring->adapter;
1676 struct pci_dev *pdev = adapter->pdev;
1683 if (adapter->clean_rx == e1000_clean_rx_irq)
1685 adapter->rx_buffer_len,
1687 else if (adapter->clean_rx == e1000_clean_jumbo_rx_irq)
1690 else if (adapter->clean_rx == e1000_clean_rx_irq_ps)
1692 adapter->rx_ps_bsize0,
1730 adapter->flags2 &= ~FLAG2_IS_DISCARDING;
1735 struct e1000_adapter *adapter = container_of(work,
1739 if (test_bit(__E1000_DOWN, &adapter->state))
1742 e1000e_gig_downshift_workaround_ich8lan(&adapter->hw);
1753 struct e1000_adapter *adapter = netdev_priv(netdev);
1754 struct e1000_hw *hw = &adapter->hw;
1763 if ((adapter->flags & FLAG_LSC_GIG_SPEED_DROP) &&
1765 schedule_work(&adapter->downshift_task);
1769 * adapter in watchdog
1772 adapter->flags & FLAG_RX_NEEDS_RESTART) {
1777 adapter->flags |= FLAG_RESTART_NOW;
1780 if (!test_bit(__E1000_DOWN, &adapter->state))
1781 mod_timer(&adapter->watchdog_timer, jiffies + 1);
1788 adapter->corr_errors +=
1790 adapter->uncorr_errors +=
1795 schedule_work(&adapter->reset_task);
1801 if (napi_schedule_prep(&adapter->napi)) {
1802 adapter->total_tx_bytes = 0;
1803 adapter->total_tx_packets = 0;
1804 adapter->total_rx_bytes = 0;
1805 adapter->total_rx_packets = 0;
1806 __napi_schedule(&adapter->napi);
1820 struct e1000_adapter *adapter = netdev_priv(netdev);
1821 struct e1000_hw *hw = &adapter->hw;
1824 if (!icr || test_bit(__E1000_DOWN, &adapter->state))
1828 * not set, then the adapter didn't send an interrupt
1843 if ((adapter->flags & FLAG_LSC_GIG_SPEED_DROP) &&
1845 schedule_work(&adapter->downshift_task);
1850 * reset adapter in watchdog
1853 (adapter->flags & FLAG_RX_NEEDS_RESTART)) {
1857 adapter->flags |= FLAG_RESTART_NOW;
1860 if (!test_bit(__E1000_DOWN, &adapter->state))
1861 mod_timer(&adapter->watchdog_timer, jiffies + 1);
1868 adapter->corr_errors +=
1870 adapter->uncorr_errors +=
1875 schedule_work(&adapter->reset_task);
1881 if (napi_schedule_prep(&adapter->napi)) {
1882 adapter->total_tx_bytes = 0;
1883 adapter->total_tx_packets = 0;
1884 adapter->total_rx_bytes = 0;
1885 adapter->total_rx_packets = 0;
1886 __napi_schedule(&adapter->napi);
1895 struct e1000_adapter *adapter = netdev_priv(netdev);
1896 struct e1000_hw *hw = &adapter->hw;
1899 if (icr & adapter->eiac_mask)
1900 ew32(ICS, (icr & adapter->eiac_mask));
1905 if (!test_bit(__E1000_DOWN, &adapter->state))
1906 mod_timer(&adapter->watchdog_timer, jiffies + 1);
1909 if (!test_bit(__E1000_DOWN, &adapter->state))
1918 struct e1000_adapter *adapter = netdev_priv(netdev);
1919 struct e1000_hw *hw = &adapter->hw;
1920 struct e1000_ring *tx_ring = adapter->tx_ring;
1922 adapter->total_tx_bytes = 0;
1923 adapter->total_tx_packets = 0;
1929 if (!test_bit(__E1000_DOWN, &adapter->state))
1930 ew32(IMS, adapter->tx_ring->ims_val);
1938 struct e1000_adapter *adapter = netdev_priv(netdev);
1939 struct e1000_ring *rx_ring = adapter->rx_ring;
1952 if (napi_schedule_prep(&adapter->napi)) {
1953 adapter->total_rx_bytes = 0;
1954 adapter->total_rx_packets = 0;
1955 __napi_schedule(&adapter->napi);
1962 * @adapter: board private structure
1967 static void e1000_configure_msix(struct e1000_adapter *adapter)
1969 struct e1000_hw *hw = &adapter->hw;
1970 struct e1000_ring *rx_ring = adapter->rx_ring;
1971 struct e1000_ring *tx_ring = adapter->tx_ring;
1975 adapter->eiac_mask = 0;
1987 adapter->eiac_mask |= rx_ring->ims_val;
2003 adapter->eiac_mask |= tx_ring->ims_val;
2027 void e1000e_reset_interrupt_capability(struct e1000_adapter *adapter)
2029 if (adapter->msix_entries) {
2030 pci_disable_msix(adapter->pdev);
2031 kfree(adapter->msix_entries);
2032 adapter->msix_entries = NULL;
2033 } else if (adapter->flags & FLAG_MSI_ENABLED) {
2034 pci_disable_msi(adapter->pdev);
2035 adapter->flags &= ~FLAG_MSI_ENABLED;
2041 * @adapter: board private structure
2046 void e1000e_set_interrupt_capability(struct e1000_adapter *adapter)
2051 switch (adapter->int_mode) {
2053 if (adapter->flags & FLAG_HAS_MSIX) {
2054 adapter->num_vectors = 3; /* RxQ0, TxQ0 and other */
2055 adapter->msix_entries = kcalloc(adapter->num_vectors,
2059 if (adapter->msix_entries) {
2060 struct e1000_adapter *a = adapter;
2062 for (i = 0; i < adapter->num_vectors; i++)
2063 adapter->msix_entries[i].entry = i;
2074 e1000e_reset_interrupt_capability(adapter);
2076 adapter->int_mode = E1000E_INT_MODE_MSI;
2079 if (!pci_enable_msi(adapter->pdev)) {
2080 adapter->flags |= FLAG_MSI_ENABLED;
2082 adapter->int_mode = E1000E_INT_MODE_LEGACY;
2092 adapter->num_vectors = 1;
2097 * @adapter: board private structure
2102 static int e1000_request_msix(struct e1000_adapter *adapter)
2104 struct net_device *netdev = adapter->netdev;
2108 snprintf(adapter->rx_ring->name,
2109 sizeof(adapter->rx_ring->name) - 1,
2112 memcpy(adapter->rx_ring->name, netdev->name, IFNAMSIZ);
2113 err = request_irq(adapter->msix_entries[vector].vector,
2114 e1000_intr_msix_rx, 0, adapter->rx_ring->name,
2118 adapter->rx_ring->itr_register = adapter->hw.hw_addr +
2120 adapter->rx_ring->itr_val = adapter->itr;
2124 snprintf(adapter->tx_ring->name,
2125 sizeof(adapter->tx_ring->name) - 1,
2128 memcpy(adapter->tx_ring->name, netdev->name, IFNAMSIZ);
2129 err = request_irq(adapter->msix_entries[vector].vector,
2130 e1000_intr_msix_tx, 0, adapter->tx_ring->name,
2134 adapter->tx_ring->itr_register = adapter->hw.hw_addr +
2136 adapter->tx_ring->itr_val = adapter->itr;
2139 err = request_irq(adapter->msix_entries[vector].vector,
2144 e1000_configure_msix(adapter);
2151 * @adapter: board private structure
2156 static int e1000_request_irq(struct e1000_adapter *adapter)
2158 struct net_device *netdev = adapter->netdev;
2161 if (adapter->msix_entries) {
2162 err = e1000_request_msix(adapter);
2166 e1000e_reset_interrupt_capability(adapter);
2167 adapter->int_mode = E1000E_INT_MODE_MSI;
2168 e1000e_set_interrupt_capability(adapter);
2170 if (adapter->flags & FLAG_MSI_ENABLED) {
2171 err = request_irq(adapter->pdev->irq, e1000_intr_msi, 0,
2177 e1000e_reset_interrupt_capability(adapter);
2178 adapter->int_mode = E1000E_INT_MODE_LEGACY;
2181 err = request_irq(adapter->pdev->irq, e1000_intr, IRQF_SHARED,
2189 static void e1000_free_irq(struct e1000_adapter *adapter)
2191 struct net_device *netdev = adapter->netdev;
2193 if (adapter->msix_entries) {
2196 free_irq(adapter->msix_entries[vector].vector, netdev);
2199 free_irq(adapter->msix_entries[vector].vector, netdev);
2203 free_irq(adapter->msix_entries[vector].vector, netdev);
2207 free_irq(adapter->pdev->irq, netdev);
2212 * @adapter: board private structure
2214 static void e1000_irq_disable(struct e1000_adapter *adapter)
2216 struct e1000_hw *hw = &adapter->hw;
2219 if (adapter->msix_entries)
2223 if (adapter->msix_entries) {
2226 for (i = 0; i < adapter->num_vectors; i++)
2227 synchronize_irq(adapter->msix_entries[i].vector);
2229 synchronize_irq(adapter->pdev->irq);
2235 * @adapter: board private structure
2237 static void e1000_irq_enable(struct e1000_adapter *adapter)
2239 struct e1000_hw *hw = &adapter->hw;
2241 if (adapter->msix_entries) {
2242 ew32(EIAC_82574, adapter->eiac_mask & E1000_EIAC_MASK_82574);
2243 ew32(IMS, adapter->eiac_mask | E1000_IMS_OTHER |
2255 * @adapter: address of board private structure
2262 void e1000e_get_hw_control(struct e1000_adapter *adapter)
2264 struct e1000_hw *hw = &adapter->hw;
2269 if (adapter->flags & FLAG_HAS_SWSM_ON_LOAD) {
2272 } else if (adapter->flags & FLAG_HAS_CTRLEXT_ON_LOAD) {
2280 * @adapter: address of board private structure
2288 void e1000e_release_hw_control(struct e1000_adapter *adapter)
2290 struct e1000_hw *hw = &adapter->hw;
2295 if (adapter->flags & FLAG_HAS_SWSM_ON_LOAD) {
2298 } else if (adapter->flags & FLAG_HAS_CTRLEXT_ON_LOAD) {
2306 * @adapter: board private structure
2309 static int e1000_alloc_ring_dma(struct e1000_adapter *adapter,
2312 struct pci_dev *pdev = adapter->pdev;
2330 struct e1000_adapter *adapter = tx_ring->adapter;
2342 err = e1000_alloc_ring_dma(adapter, tx_ring);
2364 struct e1000_adapter *adapter = rx_ring->adapter;
2388 err = e1000_alloc_ring_dma(adapter, rx_ring);
2415 struct e1000_adapter *adapter = tx_ring->adapter;
2425 netdev_reset_queue(adapter->netdev);
2443 struct e1000_adapter *adapter = tx_ring->adapter;
2444 struct pci_dev *pdev = adapter->pdev;
2464 struct e1000_adapter *adapter = rx_ring->adapter;
2465 struct pci_dev *pdev = adapter->pdev;
2483 * @itr_setting: current adapter->itr
2539 static void e1000_set_itr(struct e1000_adapter *adapter)
2542 u32 new_itr = adapter->itr;
2545 if (adapter->link_speed != SPEED_1000) {
2550 if (adapter->flags2 & FLAG2_DISABLE_AIM) {
2555 adapter->tx_itr = e1000_update_itr(adapter->tx_itr,
2556 adapter->total_tx_packets,
2557 adapter->total_tx_bytes);
2559 if (adapter->itr_setting == 3 && adapter->tx_itr == lowest_latency)
2560 adapter->tx_itr = low_latency;
2562 adapter->rx_itr = e1000_update_itr(adapter->rx_itr,
2563 adapter->total_rx_packets,
2564 adapter->total_rx_bytes);
2566 if (adapter->itr_setting == 3 && adapter->rx_itr == lowest_latency)
2567 adapter->rx_itr = low_latency;
2569 current_itr = max(adapter->rx_itr, adapter->tx_itr);
2587 if (new_itr != adapter->itr) {
2592 new_itr = new_itr > adapter->itr ?
2593 min(adapter->itr + (new_itr >> 2), new_itr) : new_itr;
2594 adapter->itr = new_itr;
2595 adapter->rx_ring->itr_val = new_itr;
2596 if (adapter->msix_entries)
2597 adapter->rx_ring->set_itr = 1;
2599 e1000e_write_itr(adapter, new_itr);
2605 * @adapter: address of board private structure
2608 * e1000e_write_itr determines if the adapter is in MSI-X mode
2612 void e1000e_write_itr(struct e1000_adapter *adapter, u32 itr)
2614 struct e1000_hw *hw = &adapter->hw;
2617 if (adapter->msix_entries) {
2620 for (vector = 0; vector < adapter->num_vectors; vector++)
2629 * @adapter: board private structure to initialize
2631 static int e1000_alloc_queues(struct e1000_adapter *adapter)
2635 adapter->tx_ring = kzalloc(size, GFP_KERNEL);
2636 if (!adapter->tx_ring)
2638 adapter->tx_ring->count = adapter->tx_ring_count;
2639 adapter->tx_ring->adapter = adapter;
2641 adapter->rx_ring = kzalloc(size, GFP_KERNEL);
2642 if (!adapter->rx_ring)
2644 adapter->rx_ring->count = adapter->rx_ring_count;
2645 adapter->rx_ring->adapter = adapter;
2650 kfree(adapter->rx_ring);
2651 kfree(adapter->tx_ring);
2662 struct e1000_adapter *adapter = container_of(napi, struct e1000_adapter,
2664 struct e1000_hw *hw = &adapter->hw;
2665 struct net_device *poll_dev = adapter->netdev;
2668 adapter = netdev_priv(poll_dev);
2670 if (!adapter->msix_entries ||
2671 (adapter->rx_ring->ims_val & adapter->tx_ring->ims_val))
2672 tx_cleaned = e1000_clean_tx_irq(adapter->tx_ring);
2674 adapter->clean_rx(adapter->rx_ring, &work_done, budget);
2683 if (adapter->itr_setting & 3)
2684 e1000_set_itr(adapter);
2685 if (!test_bit(__E1000_DOWN, &adapter->state)) {
2686 if (adapter->msix_entries)
2687 ew32(IMS, adapter->rx_ring->ims_val);
2689 e1000_irq_enable(adapter);
2699 struct e1000_adapter *adapter = netdev_priv(netdev);
2700 struct e1000_hw *hw = &adapter->hw;
2704 if ((adapter->hw.mng_cookie.status &
2706 (vid == adapter->mng_vlan_id))
2710 if (adapter->flags & FLAG_HAS_HW_VLAN_FILTER) {
2717 set_bit(vid, adapter->active_vlans);
2725 struct e1000_adapter *adapter = netdev_priv(netdev);
2726 struct e1000_hw *hw = &adapter->hw;
2729 if ((adapter->hw.mng_cookie.status &
2731 (vid == adapter->mng_vlan_id)) {
2733 e1000e_release_hw_control(adapter);
2738 if (adapter->flags & FLAG_HAS_HW_VLAN_FILTER) {
2745 clear_bit(vid, adapter->active_vlans);
2752 * @adapter: board private structure to initialize
2754 static void e1000e_vlan_filter_disable(struct e1000_adapter *adapter)
2756 struct net_device *netdev = adapter->netdev;
2757 struct e1000_hw *hw = &adapter->hw;
2760 if (adapter->flags & FLAG_HAS_HW_VLAN_FILTER) {
2766 if (adapter->mng_vlan_id != (u16)E1000_MNG_VLAN_NONE) {
2768 adapter->mng_vlan_id);
2769 adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
2776 * @adapter: board private structure to initialize
2778 static void e1000e_vlan_filter_enable(struct e1000_adapter *adapter)
2780 struct e1000_hw *hw = &adapter->hw;
2783 if (adapter->flags & FLAG_HAS_HW_VLAN_FILTER) {
2794 * @adapter: board private structure to initialize
2796 static void e1000e_vlan_strip_disable(struct e1000_adapter *adapter)
2798 struct e1000_hw *hw = &adapter->hw;
2809 * @adapter: board private structure to initialize
2811 static void e1000e_vlan_strip_enable(struct e1000_adapter *adapter)
2813 struct e1000_hw *hw = &adapter->hw;
2822 static void e1000_update_mng_vlan(struct e1000_adapter *adapter)
2824 struct net_device *netdev = adapter->netdev;
2825 u16 vid = adapter->hw.mng_cookie.vlan_id;
2826 u16 old_vid = adapter->mng_vlan_id;
2828 if (adapter->hw.mng_cookie.status & E1000_MNG_DHCP_COOKIE_STATUS_VLAN) {
2830 adapter->mng_vlan_id = vid;
2837 static void e1000_restore_vlan(struct e1000_adapter *adapter)
2841 e1000_vlan_rx_add_vid(adapter->netdev, htons(ETH_P_8021Q), 0);
2843 for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
2844 e1000_vlan_rx_add_vid(adapter->netdev, htons(ETH_P_8021Q), vid);
2847 static void e1000_init_manageability_pt(struct e1000_adapter *adapter)
2849 struct e1000_hw *hw = &adapter->hw;
2852 if (!(adapter->flags & FLAG_MNG_PT_ENABLED))
2911 * @adapter: board private structure
2915 static void e1000_configure_tx(struct e1000_adapter *adapter)
2917 struct e1000_hw *hw = &adapter->hw;
2918 struct e1000_ring *tx_ring = adapter->tx_ring;
2930 tx_ring->head = adapter->hw.hw_addr + E1000_TDH(0);
2931 tx_ring->tail = adapter->hw.hw_addr + E1000_TDT(0);
2934 if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
2940 ew32(TIDV, adapter->tx_int_delay);
2942 ew32(TADV, adapter->tx_abs_int_delay);
2944 if (adapter->flags2 & FLAG2_DMA_BURST) {
2970 if (adapter->flags & FLAG_TARC_SPEED_MODE_BIT) {
2981 if (adapter->flags & FLAG_TARC_SET_BIT_ZERO) {
2991 adapter->txd_cmd = E1000_TXD_CMD_EOP | E1000_TXD_CMD_IFCS;
2994 if (adapter->tx_int_delay)
2995 adapter->txd_cmd |= E1000_TXD_CMD_IDE;
2998 adapter->txd_cmd |= E1000_TXD_CMD_RS;
3028 * @adapter: Board private structure
3030 static void e1000_setup_rctl(struct e1000_adapter *adapter)
3032 struct e1000_hw *hw = &adapter->hw;
3043 if (adapter->netdev->mtu > ETH_DATA_LEN)
3057 (adapter->hw.mac.mc_filter_type << E1000_RCTL_MO_SHIFT);
3063 if (adapter->netdev->mtu <= ETH_DATA_LEN)
3072 if (adapter->flags2 & FLAG2_CRC_STRIPPING)
3095 switch (adapter->rx_buffer_len) {
3131 pages = PAGE_USE_COUNT(adapter->netdev->mtu);
3133 adapter->rx_ps_pages = pages;
3135 adapter->rx_ps_pages = 0;
3137 if (adapter->rx_ps_pages) {
3143 psrctl |= adapter->rx_ps_bsize0 >> E1000_PSRCTL_BSIZE0_SHIFT;
3145 switch (adapter->rx_ps_pages) {
3161 if (adapter->netdev->features & NETIF_F_RXALL) {
3179 adapter->flags &= ~FLAG_RESTART_NOW;
3184 * @adapter: board private structure
3188 static void e1000_configure_rx(struct e1000_adapter *adapter)
3190 struct e1000_hw *hw = &adapter->hw;
3191 struct e1000_ring *rx_ring = adapter->rx_ring;
3195 if (adapter->rx_ps_pages) {
3199 adapter->clean_rx = e1000_clean_rx_irq_ps;
3200 adapter->alloc_rx_buf = e1000_alloc_rx_buffers_ps;
3201 } else if (adapter->netdev->mtu > ETH_FRAME_LEN + ETH_FCS_LEN) {
3203 adapter->clean_rx = e1000_clean_jumbo_rx_irq;
3204 adapter->alloc_rx_buf = e1000_alloc_jumbo_rx_buffers;
3207 adapter->clean_rx = e1000_clean_rx_irq;
3208 adapter->alloc_rx_buf = e1000_alloc_rx_buffers;
3213 if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX))
3218 if (adapter->flags2 & FLAG2_DMA_BURST) {
3232 ew32(RDTR, adapter->rx_int_delay);
3235 ew32(RADV, adapter->rx_abs_int_delay);
3236 if ((adapter->itr_setting != 0) && (adapter->itr != 0))
3237 e1000e_write_itr(adapter, adapter->itr);
3255 rx_ring->head = adapter->hw.hw_addr + E1000_RDH(0);
3256 rx_ring->tail = adapter->hw.hw_addr + E1000_RDT(0);
3259 if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
3266 if (adapter->netdev->features & NETIF_F_RXCSUM)
3275 if (adapter->netdev->mtu > ETH_DATA_LEN) {
3278 adapter->max_frame_size) * 8 / 1000;
3280 if (adapter->flags & FLAG_IS_ICH) {
3286 dev_info(&adapter->pdev->dev,
3288 cpu_latency_qos_update_request(&adapter->pm_qos_req, lat);
3290 cpu_latency_qos_update_request(&adapter->pm_qos_req,
3309 struct e1000_adapter *adapter = netdev_priv(netdev);
3310 struct e1000_hw *hw = &adapter->hw;
3347 struct e1000_adapter *adapter = netdev_priv(netdev);
3348 struct e1000_hw *hw = &adapter->hw;
3358 if (adapter->flags & FLAG_RESET_OVERWRITES_LAA)
3404 struct e1000_adapter *adapter = netdev_priv(netdev);
3405 struct e1000_hw *hw = &adapter->hw;
3420 e1000e_vlan_filter_disable(adapter);
3435 e1000e_vlan_filter_enable(adapter);
3448 e1000e_vlan_strip_enable(adapter);
3450 e1000e_vlan_strip_disable(adapter);
3453 static void e1000e_setup_rss_hash(struct e1000_adapter *adapter)
3455 struct e1000_hw *hw = &adapter->hw;
3487 * @adapter: board private structure
3493 s32 e1000e_get_base_timinca(struct e1000_adapter *adapter, u32 *timinca)
3495 struct e1000_hw *hw = &adapter->hw;
3518 adapter->cc.shift = shift + INCPERIOD_SHIFT_96MHZ;
3526 adapter->cc.shift = shift + INCPERIOD_SHIFT_96MHZ;
3532 adapter->cc.shift = shift;
3540 adapter->cc.shift = shift;
3554 adapter->cc.shift = shift;
3560 adapter->cc.shift = shift;
3569 adapter->cc.shift = shift;
3583 * @adapter: board private structure
3597 static int e1000e_config_hwtstamp(struct e1000_adapter *adapter,
3600 struct e1000_hw *hw = &adapter->hw;
3609 if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))
3695 adapter->hwtstamp_config = *config;
3746 * @adapter: private board structure
3748 static void e1000_configure(struct e1000_adapter *adapter)
3750 struct e1000_ring *rx_ring = adapter->rx_ring;
3752 e1000e_set_rx_mode(adapter->netdev);
3754 e1000_restore_vlan(adapter);
3755 e1000_init_manageability_pt(adapter);
3757 e1000_configure_tx(adapter);
3759 if (adapter->netdev->features & NETIF_F_RXHASH)
3760 e1000e_setup_rss_hash(adapter);
3761 e1000_setup_rctl(adapter);
3762 e1000_configure_rx(adapter);
3763 adapter->alloc_rx_buf(rx_ring, e1000_desc_unused(rx_ring), GFP_KERNEL);
3768 * @adapter: address of board private structure
3774 void e1000e_power_up_phy(struct e1000_adapter *adapter)
3776 if (adapter->hw.phy.ops.power_up)
3777 adapter->hw.phy.ops.power_up(&adapter->hw);
3779 adapter->hw.mac.ops.setup_link(&adapter->hw);
3784 * @adapter: board private structure
3789 static void e1000_power_down_phy(struct e1000_adapter *adapter)
3791 if (adapter->hw.phy.ops.power_down)
3792 adapter->hw.phy.ops.power_down(&adapter->hw);
3797 * @adapter: board private structure
3804 static void e1000_flush_tx_ring(struct e1000_adapter *adapter)
3806 struct e1000_hw *hw = &adapter->hw;
3807 struct e1000_ring *tx_ring = adapter->tx_ring;
3832 * @adapter: board private structure
3836 static void e1000_flush_rx_ring(struct e1000_adapter *adapter)
3839 struct e1000_hw *hw = &adapter->hw;
3865 * @adapter: board private structure
3875 static void e1000_flush_desc_rings(struct e1000_adapter *adapter)
3879 struct e1000_hw *hw = &adapter->hw;
3887 pci_read_config_word(adapter->pdev, PCICFG_DESC_RING_STATUS,
3891 e1000_flush_tx_ring(adapter);
3893 pci_read_config_word(adapter->pdev, PCICFG_DESC_RING_STATUS,
3896 e1000_flush_rx_ring(adapter);
3901 * @adapter: board private structure
3908 static void e1000e_systim_reset(struct e1000_adapter *adapter)
3910 struct ptp_clock_info *info = &adapter->ptp_clock_info;
3911 struct e1000_hw *hw = &adapter->hw;
3916 if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))
3921 ret_val = info->adjfine(info, adapter->ptp_delta);
3924 ret_val = e1000e_get_base_timinca(adapter, &timinca);
3930 dev_warn(&adapter->pdev->dev,
3937 spin_lock_irqsave(&adapter->systim_lock, flags);
3938 timecounter_init(&adapter->tc, &adapter->cc,
3940 spin_unlock_irqrestore(&adapter->systim_lock, flags);
3943 e1000e_config_hwtstamp(adapter, &adapter->hwtstamp_config);
3948 * @adapter: board private structure
3955 void e1000e_reset(struct e1000_adapter *adapter)
3957 struct e1000_mac_info *mac = &adapter->hw.mac;
3958 struct e1000_fc_info *fc = &adapter->hw.fc;
3959 struct e1000_hw *hw = &adapter->hw;
3961 u32 pba = adapter->pba;
3967 if (adapter->max_frame_size > (VLAN_ETH_FRAME_LEN + ETH_FCS_LEN)) {
3983 min_tx_space = (adapter->max_frame_size +
3988 min_rx_space = adapter->max_frame_size;
4018 if (adapter->flags & FLAG_DISABLE_FC_PAUSE_TIME)
4028 if (adapter->netdev->mtu > ETH_DATA_LEN) {
4038 ((pba << 10) - adapter->max_frame_size));
4044 /* Workaround PCH LOM adapter hangs with certain network
4047 if (adapter->netdev->mtu > ETH_DATA_LEN) {
4069 if (adapter->netdev->mtu <= ETH_DATA_LEN) {
4087 adapter->tx_fifo_limit = min_t(u32, ((er32(PBA) >> 16) << 10) - 96,
4093 if (adapter->itr_setting & 0x3) {
4094 if ((adapter->max_frame_size * 2) > (pba << 10)) {
4095 if (!(adapter->flags2 & FLAG2_DISABLE_AIM)) {
4096 dev_info(&adapter->pdev->dev,
4098 adapter->flags2 |= FLAG2_DISABLE_AIM;
4099 e1000e_write_itr(adapter, 0);
4101 } else if (adapter->flags2 & FLAG2_DISABLE_AIM) {
4102 dev_info(&adapter->pdev->dev,
4104 adapter->flags2 &= ~FLAG2_DISABLE_AIM;
4105 adapter->itr = 20000;
4106 e1000e_write_itr(adapter, adapter->itr);
4111 e1000_flush_desc_rings(adapter);
4118 if (adapter->flags & FLAG_HAS_AMT)
4119 e1000e_get_hw_control(adapter);
4126 e1000_update_mng_vlan(adapter);
4134 e1000e_systim_reset(adapter);
4137 if (adapter->flags2 & FLAG2_HAS_EEE) {
4149 dev_err(&adapter->pdev->dev,
4156 dev_err(&adapter->pdev->dev,
4163 0 : adapter->eee_advert);
4168 if (!netif_running(adapter->netdev) &&
4169 !test_bit(__E1000_TESTING, &adapter->state))
4170 e1000_power_down_phy(adapter);
4174 if ((adapter->flags & FLAG_HAS_SMART_POWER_DOWN) &&
4175 !(adapter->flags & FLAG_SMART_POWER_DOWN)) {
4185 if (hw->mac.type >= e1000_pch_spt && adapter->int_mode == 0) {
4203 * @adapter: board private structure
4207 static void e1000e_trigger_lsc(struct e1000_adapter *adapter)
4209 struct e1000_hw *hw = &adapter->hw;
4211 if (adapter->msix_entries)
4217 void e1000e_up(struct e1000_adapter *adapter)
4220 e1000_configure(adapter);
4222 clear_bit(__E1000_DOWN, &adapter->state);
4224 if (adapter->msix_entries)
4225 e1000_configure_msix(adapter);
4226 e1000_irq_enable(adapter);
4230 e1000e_trigger_lsc(adapter);
4233 static void e1000e_flush_descriptors(struct e1000_adapter *adapter)
4235 struct e1000_hw *hw = &adapter->hw;
4237 if (!(adapter->flags2 & FLAG2_DMA_BURST))
4241 ew32(TIDV, adapter->tx_int_delay | E1000_TIDV_FPD);
4242 ew32(RDTR, adapter->rx_int_delay | E1000_RDTR_FPD);
4250 ew32(TIDV, adapter->tx_int_delay | E1000_TIDV_FPD);
4251 ew32(RDTR, adapter->rx_int_delay | E1000_RDTR_FPD);
4257 static void e1000e_update_stats(struct e1000_adapter *adapter);
4261 * @adapter: board private structure
4264 void e1000e_down(struct e1000_adapter *adapter, bool reset)
4266 struct net_device *netdev = adapter->netdev;
4267 struct e1000_hw *hw = &adapter->hw;
4273 set_bit(__E1000_DOWN, &adapter->state);
4279 if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX))
4294 e1000_irq_disable(adapter);
4296 napi_synchronize(&adapter->napi);
4298 del_timer_sync(&adapter->watchdog_timer);
4299 del_timer_sync(&adapter->phy_info_timer);
4301 spin_lock(&adapter->stats64_lock);
4302 e1000e_update_stats(adapter);
4303 spin_unlock(&adapter->stats64_lock);
4305 e1000e_flush_descriptors(adapter);
4307 adapter->link_speed = 0;
4308 adapter->link_duplex = 0;
4312 (adapter->netdev->mtu > ETH_DATA_LEN) &&
4316 if (!pci_channel_offline(adapter->pdev)) {
4318 e1000e_reset(adapter);
4320 e1000_flush_desc_rings(adapter);
4322 e1000_clean_tx_ring(adapter->tx_ring);
4323 e1000_clean_rx_ring(adapter->rx_ring);
4326 void e1000e_reinit_locked(struct e1000_adapter *adapter)
4329 while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
4331 e1000e_down(adapter, true);
4332 e1000e_up(adapter);
4333 clear_bit(__E1000_RESETTING, &adapter->state);
4379 * @adapter: board private structure
4383 u64 e1000e_read_systim(struct e1000_adapter *adapter,
4386 struct e1000_hw *hw = &adapter->hw;
4415 if (adapter->flags2 & FLAG2_CHECK_SYSTIM_OVERFLOW)
4427 struct e1000_adapter *adapter = container_of(cc, struct e1000_adapter,
4430 return e1000e_read_systim(adapter, NULL);
4435 * @adapter: board private structure to initialize
4441 static int e1000_sw_init(struct e1000_adapter *adapter)
4443 struct net_device *netdev = adapter->netdev;
4445 adapter->rx_buffer_len = VLAN_ETH_FRAME_LEN + ETH_FCS_LEN;
4446 adapter->rx_ps_bsize0 = 128;
4447 adapter->max_frame_size = netdev->mtu + VLAN_ETH_HLEN + ETH_FCS_LEN;
4448 adapter->min_frame_size = ETH_ZLEN + ETH_FCS_LEN;
4449 adapter->tx_ring_count = E1000_DEFAULT_TXD;
4450 adapter->rx_ring_count = E1000_DEFAULT_RXD;
4452 spin_lock_init(&adapter->stats64_lock);
4454 e1000e_set_interrupt_capability(adapter);
4456 if (e1000_alloc_queues(adapter))
4460 if (adapter->flags & FLAG_HAS_HW_TIMESTAMP) {
4461 adapter->cc.read = e1000e_cyclecounter_read;
4462 adapter->cc.mask = CYCLECOUNTER_MASK(64);
4463 adapter->cc.mult = 1;
4466 spin_lock_init(&adapter->systim_lock);
4467 INIT_WORK(&adapter->tx_hwtstamp_work, e1000e_tx_hwtstamp_work);
4471 e1000_irq_disable(adapter);
4473 set_bit(__E1000_DOWN, &adapter->state);
4485 struct e1000_adapter *adapter = netdev_priv(netdev);
4486 struct e1000_hw *hw = &adapter->hw;
4491 adapter->flags &= ~FLAG_MSI_TEST_FAILED;
4503 * @adapter: board private struct
4507 static int e1000_test_msi_interrupt(struct e1000_adapter *adapter)
4509 struct net_device *netdev = adapter->netdev;
4510 struct e1000_hw *hw = &adapter->hw;
4518 e1000_free_irq(adapter);
4519 e1000e_reset_interrupt_capability(adapter);
4524 adapter->flags |= FLAG_MSI_TEST_FAILED;
4526 err = pci_enable_msi(adapter->pdev);
4530 err = request_irq(adapter->pdev->irq, e1000_intr_msi_test, 0,
4533 pci_disable_msi(adapter->pdev);
4542 e1000_irq_enable(adapter);
4549 e1000_irq_disable(adapter);
4553 if (adapter->flags & FLAG_MSI_TEST_FAILED) {
4554 adapter->int_mode = E1000E_INT_MODE_LEGACY;
4560 free_irq(adapter->pdev->irq, netdev);
4561 pci_disable_msi(adapter->pdev);
4564 e1000e_set_interrupt_capability(adapter);
4565 return e1000_request_irq(adapter);
4570 * @adapter: board private struct
4574 static int e1000_test_msi(struct e1000_adapter *adapter)
4579 if (!(adapter->flags & FLAG_MSI_ENABLED))
4583 pci_read_config_word(adapter->pdev, PCI_COMMAND, &pci_cmd);
4585 pci_write_config_word(adapter->pdev, PCI_COMMAND,
4588 err = e1000_test_msi_interrupt(adapter);
4592 pci_read_config_word(adapter->pdev, PCI_COMMAND, &pci_cmd);
4594 pci_write_config_word(adapter->pdev, PCI_COMMAND, pci_cmd);
4614 struct e1000_adapter *adapter = netdev_priv(netdev);
4615 struct e1000_hw *hw = &adapter->hw;
4616 struct pci_dev *pdev = adapter->pdev;
4620 if (test_bit(__E1000_TESTING, &adapter->state))
4629 err = e1000e_setup_tx_resources(adapter->tx_ring);
4634 err = e1000e_setup_rx_resources(adapter->rx_ring);
4641 if (adapter->flags & FLAG_HAS_AMT) {
4642 e1000e_get_hw_control(adapter);
4643 e1000e_reset(adapter);
4646 e1000e_power_up_phy(adapter);
4648 adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
4649 if ((adapter->hw.mng_cookie.status & E1000_MNG_DHCP_COOKIE_STATUS_VLAN))
4650 e1000_update_mng_vlan(adapter);
4653 cpu_latency_qos_add_request(&adapter->pm_qos_req, PM_QOS_DEFAULT_VALUE);
4660 e1000_configure(adapter);
4662 err = e1000_request_irq(adapter);
4670 if (adapter->int_mode != E1000E_INT_MODE_LEGACY) {
4671 err = e1000_test_msi(adapter);
4679 clear_bit(__E1000_DOWN, &adapter->state);
4681 napi_enable(&adapter->napi);
4683 e1000_irq_enable(adapter);
4685 adapter->tx_hang_recheck = false;
4690 e1000e_trigger_lsc(adapter);
4695 cpu_latency_qos_remove_request(&adapter->pm_qos_req);
4696 e1000e_release_hw_control(adapter);
4697 e1000_power_down_phy(adapter);
4698 e1000e_free_rx_resources(adapter->rx_ring);
4700 e1000e_free_tx_resources(adapter->tx_ring);
4702 e1000e_reset(adapter);
4721 struct e1000_adapter *adapter = netdev_priv(netdev);
4722 struct pci_dev *pdev = adapter->pdev;
4725 while (test_bit(__E1000_RESETTING, &adapter->state) && count--)
4728 WARN_ON(test_bit(__E1000_RESETTING, &adapter->state));
4733 e1000e_down(adapter, true);
4734 e1000_free_irq(adapter);
4740 napi_disable(&adapter->napi);
4742 e1000e_free_tx_resources(adapter->tx_ring);
4743 e1000e_free_rx_resources(adapter->rx_ring);
4748 if (adapter->hw.mng_cookie.status & E1000_MNG_DHCP_COOKIE_STATUS_VLAN)
4750 adapter->mng_vlan_id);
4755 if ((adapter->flags & FLAG_HAS_AMT) &&
4756 !test_bit(__E1000_TESTING, &adapter->state))
4757 e1000e_release_hw_control(adapter);
4759 cpu_latency_qos_remove_request(&adapter->pm_qos_req);
4775 struct e1000_adapter *adapter = netdev_priv(netdev);
4776 struct e1000_hw *hw = &adapter->hw;
4783 memcpy(adapter->hw.mac.addr, addr->sa_data, netdev->addr_len);
4785 hw->mac.ops.rar_set(&adapter->hw, adapter->hw.mac.addr, 0);
4787 if (adapter->flags & FLAG_RESET_OVERWRITES_LAA) {
4789 e1000e_set_laa_state_82571(&adapter->hw, 1);
4798 hw->mac.ops.rar_set(&adapter->hw, adapter->hw.mac.addr,
4799 adapter->hw.mac.rar_entry_count - 1);
4815 struct e1000_adapter *adapter = container_of(work,
4818 struct e1000_hw *hw = &adapter->hw;
4820 if (test_bit(__E1000_DOWN, &adapter->state))
4832 * @t: pointer to timer_list containing private info adapter
4839 struct e1000_adapter *adapter = from_timer(adapter, t, phy_info_timer);
4841 if (test_bit(__E1000_DOWN, &adapter->state))
4844 schedule_work(&adapter->update_phy_task);
4849 * @adapter: board private structure
4853 static void e1000e_update_phy_stats(struct e1000_adapter *adapter)
4855 struct e1000_hw *hw = &adapter->hw;
4882 adapter->stats.scc += phy_data;
4888 adapter->stats.ecol += phy_data;
4894 adapter->stats.mcc += phy_data;
4900 adapter->stats.latecol += phy_data;
4912 adapter->stats.dc += phy_data;
4918 adapter->stats.tncrs += phy_data;
4926 * @adapter: board private structure
4928 static void e1000e_update_stats(struct e1000_adapter *adapter)
4930 struct net_device *netdev = adapter->netdev;
4931 struct e1000_hw *hw = &adapter->hw;
4932 struct pci_dev *pdev = adapter->pdev;
4934 /* Prevent stats update while adapter is being reset, or if the pci
4937 if (adapter->link_speed == 0)
4942 adapter->stats.crcerrs += er32(CRCERRS);
4943 adapter->stats.gprc += er32(GPRC);
4944 adapter->stats.gorc += er32(GORCL);
4946 adapter->stats.bprc += er32(BPRC);
4947 adapter->stats.mprc += er32(MPRC);
4948 adapter->stats.roc += er32(ROC);
4950 adapter->stats.mpc += er32(MPC);
4953 if (adapter->link_duplex == HALF_DUPLEX) {
4954 if (adapter->flags2 & FLAG2_HAS_PHY_STATS) {
4955 e1000e_update_phy_stats(adapter);
4957 adapter->stats.scc += er32(SCC);
4958 adapter->stats.ecol += er32(ECOL);
4959 adapter->stats.mcc += er32(MCC);
4960 adapter->stats.latecol += er32(LATECOL);
4961 adapter->stats.dc += er32(DC);
4967 adapter->stats.tncrs += er32(TNCRS);
4969 adapter->stats.colc += hw->mac.collision_delta;
4972 adapter->stats.xonrxc += er32(XONRXC);
4973 adapter->stats.xontxc += er32(XONTXC);
4974 adapter->stats.xoffrxc += er32(XOFFRXC);
4975 adapter->stats.xofftxc += er32(XOFFTXC);
4976 adapter->stats.gptc += er32(GPTC);
4977 adapter->stats.gotc += er32(GOTCL);
4979 adapter->stats.rnbc += er32(RNBC);
4980 adapter->stats.ruc += er32(RUC);
4982 adapter->stats.mptc += er32(MPTC);
4983 adapter->stats.bptc += er32(BPTC);
4988 adapter->stats.tpt += hw->mac.tx_packet_delta;
4990 adapter->stats.algnerrc += er32(ALGNERRC);
4991 adapter->stats.rxerrc += er32(RXERRC);
4992 adapter->stats.cexterr += er32(CEXTERR);
4993 adapter->stats.tsctc += er32(TSCTC);
4994 adapter->stats.tsctfc += er32(TSCTFC);
4997 netdev->stats.multicast = adapter->stats.mprc;
4998 netdev->stats.collisions = adapter->stats.colc;
5005 netdev->stats.rx_errors = adapter->stats.rxerrc +
5006 adapter->stats.crcerrs + adapter->stats.algnerrc +
5007 adapter->stats.ruc + adapter->stats.roc + adapter->stats.cexterr;
5008 netdev->stats.rx_length_errors = adapter->stats.ruc +
5009 adapter->stats.roc;
5010 netdev->stats.rx_crc_errors = adapter->stats.crcerrs;
5011 netdev->stats.rx_frame_errors = adapter->stats.algnerrc;
5012 netdev->stats.rx_missed_errors = adapter->stats.mpc;
5015 netdev->stats.tx_errors = adapter->stats.ecol + adapter->stats.latecol;
5016 netdev->stats.tx_aborted_errors = adapter->stats.ecol;
5017 netdev->stats.tx_window_errors = adapter->stats.latecol;
5018 netdev->stats.tx_carrier_errors = adapter->stats.tncrs;
5023 adapter->stats.mgptc += er32(MGTPTC);
5024 adapter->stats.mgprc += er32(MGTPRC);
5025 adapter->stats.mgpdc += er32(MGTPDC);
5031 adapter->corr_errors +=
5033 adapter->uncorr_errors +=
5041 * @adapter: board private structure
5043 static void e1000_phy_read_status(struct e1000_adapter *adapter)
5045 struct e1000_hw *hw = &adapter->hw;
5046 struct e1000_phy_regs *phy = &adapter->phy_regs;
5048 if (!pm_runtime_suspended((&adapter->pdev->dev)->parent) &&
5050 (adapter->hw.phy.media_type == e1000_media_type_copper)) {
5081 static void e1000_print_link_info(struct e1000_adapter *adapter)
5083 struct e1000_hw *hw = &adapter->hw;
5087 netdev_info(adapter->netdev,
5089 adapter->link_speed,
5090 adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half",
5096 static bool e1000e_has_link(struct e1000_adapter *adapter)
5098 struct e1000_hw *hw = &adapter->hw;
5138 static void e1000e_enable_receives(struct e1000_adapter *adapter)
5141 if ((adapter->flags & FLAG_RX_NEEDS_RESTART) &&
5142 (adapter->flags & FLAG_RESTART_NOW)) {
5143 struct e1000_hw *hw = &adapter->hw;
5147 adapter->flags &= ~FLAG_RESTART_NOW;
5151 static void e1000e_check_82574_phy_workaround(struct e1000_adapter *adapter)
5153 struct e1000_hw *hw = &adapter->hw;
5159 adapter->phy_hang_count++;
5161 adapter->phy_hang_count = 0;
5163 if (adapter->phy_hang_count > 1) {
5164 adapter->phy_hang_count = 0;
5166 schedule_work(&adapter->reset_task);
5172 * @t: pointer to timer_list containing private info adapter
5176 struct e1000_adapter *adapter = from_timer(adapter, t, watchdog_timer);
5179 schedule_work(&adapter->watchdog_task);
5186 struct e1000_adapter *adapter = container_of(work,
5189 struct net_device *netdev = adapter->netdev;
5190 struct e1000_mac_info *mac = &adapter->hw.mac;
5191 struct e1000_phy_info *phy = &adapter->hw.phy;
5192 struct e1000_ring *tx_ring = adapter->tx_ring;
5194 struct e1000_hw *hw = &adapter->hw;
5197 if (test_bit(__E1000_DOWN, &adapter->state))
5200 link = e1000e_has_link(adapter);
5205 e1000e_enable_receives(adapter);
5210 (adapter->mng_vlan_id != adapter->hw.mng_cookie.vlan_id))
5211 e1000_update_mng_vlan(adapter);
5233 e1000_phy_hw_reset(&adapter->hw);
5238 e1000_phy_read_status(adapter);
5239 mac->ops.get_link_up_info(&adapter->hw,
5240 &adapter->link_speed,
5241 &adapter->link_duplex);
5242 e1000_print_link_info(adapter);
5256 (adapter->link_speed == SPEED_10 ||
5257 adapter->link_speed == SPEED_100) &&
5258 (adapter->link_duplex == HALF_DUPLEX)) {
5268 adapter->tx_timeout_factor = 1;
5269 switch (adapter->link_speed) {
5272 adapter->tx_timeout_factor = 16;
5276 adapter->tx_timeout_factor = 10;
5283 if ((adapter->flags & FLAG_TARC_SPEED_MODE_BIT) &&
5308 if (!test_bit(__E1000_DOWN, &adapter->state))
5309 mod_timer(&adapter->phy_info_timer,
5314 adapter->link_speed = 0;
5315 adapter->link_duplex = 0;
5320 if (!test_bit(__E1000_DOWN, &adapter->state))
5321 mod_timer(&adapter->phy_info_timer,
5328 if (adapter->flags & FLAG_RX_NEEDS_RESTART)
5329 adapter->flags |= FLAG_RESTART_NOW;
5337 spin_lock(&adapter->stats64_lock);
5338 e1000e_update_stats(adapter);
5340 mac->tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
5341 adapter->tpt_old = adapter->stats.tpt;
5342 mac->collision_delta = adapter->stats.colc - adapter->colc_old;
5343 adapter->colc_old = adapter->stats.colc;
5345 adapter->gorc = adapter->stats.gorc - adapter->gorc_old;
5346 adapter->gorc_old = adapter->stats.gorc;
5347 adapter->gotc = adapter->stats.gotc - adapter->gotc_old;
5348 adapter->gotc_old = adapter->stats.gotc;
5349 spin_unlock(&adapter->stats64_lock);
5357 adapter->flags |= FLAG_RESTART_NOW;
5360 if (adapter->flags & FLAG_RESTART_NOW) {
5361 schedule_work(&adapter->reset_task);
5366 e1000e_update_adaptive(&adapter->hw);
5369 if (adapter->itr_setting == 4) {
5374 u32 goc = (adapter->gotc + adapter->gorc) / 10000;
5375 u32 dif = (adapter->gotc > adapter->gorc ?
5376 adapter->gotc - adapter->gorc :
5377 adapter->gorc - adapter->gotc) / 10000;
5380 e1000e_write_itr(adapter, itr);
5384 if (adapter->msix_entries)
5385 ew32(ICS, adapter->rx_ring->ims_val);
5390 e1000e_flush_descriptors(adapter);
5393 adapter->detect_tx_hung = true;
5399 hw->mac.ops.rar_set(hw, adapter->hw.mac.addr, 0);
5401 if (adapter->flags2 & FLAG2_CHECK_PHY_HANG)
5402 e1000e_check_82574_phy_workaround(adapter);
5405 if (adapter->hwtstamp_config.rx_filter != HWTSTAMP_FILTER_NONE) {
5406 if ((adapter->flags2 & FLAG2_CHECK_RX_HWTSTAMP) &&
5409 adapter->rx_hwtstamp_cleared++;
5411 adapter->flags2 |= FLAG2_CHECK_RX_HWTSTAMP;
5416 if (!test_bit(__E1000_DOWN, &adapter->state))
5417 mod_timer(&adapter->watchdog_timer,
5498 struct e1000_adapter *adapter = tx_ring->adapter;
5553 struct e1000_adapter *adapter = tx_ring->adapter;
5554 struct pci_dev *pdev = adapter->pdev;
5647 struct e1000_adapter *adapter = tx_ring->adapter;
5695 tx_desc->lower.data |= cpu_to_le32(adapter->txd_cmd);
5712 static int e1000_transfer_dhcp_info(struct e1000_adapter *adapter,
5715 struct e1000_hw *hw = &adapter->hw;
5719 !((skb_vlan_tag_get(skb) == adapter->hw.mng_cookie.vlan_id) &&
5720 (adapter->hw.mng_cookie.status &
5751 struct e1000_adapter *adapter = tx_ring->adapter;
5753 netif_stop_queue(adapter->netdev);
5767 netif_start_queue(adapter->netdev);
5768 ++adapter->restart_queue;
5784 struct e1000_adapter *adapter = netdev_priv(netdev);
5785 struct e1000_ring *tx_ring = adapter->tx_ring;
5796 if (test_bit(__E1000_DOWN, &adapter->state)) {
5842 count += DIV_ROUND_UP(len, adapter->tx_fifo_limit);
5847 adapter->tx_fifo_limit);
5849 if (adapter->hw.mac.tx_pkt_filtering)
5850 e1000_transfer_dhcp_info(adapter, skb);
5888 count = e1000_tx_map(tx_ring, skb, first, adapter->tx_fifo_limit,
5892 (adapter->flags & FLAG_HAS_HW_TIMESTAMP)) {
5893 if (!adapter->tx_hwtstamp_skb) {
5896 adapter->tx_hwtstamp_skb = skb_get(skb);
5897 adapter->tx_hwtstamp_start = jiffies;
5898 schedule_work(&adapter->tx_hwtstamp_work);
5900 adapter->tx_hwtstamp_skipped++;
5912 adapter->tx_fifo_limit) + 4));
5916 if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
5938 struct e1000_adapter *adapter = netdev_priv(netdev);
5941 adapter->tx_timeout_count++;
5942 schedule_work(&adapter->reset_task);
5947 struct e1000_adapter *adapter;
5948 adapter = container_of(work, struct e1000_adapter, reset_task);
5952 if (test_bit(__E1000_DOWN, &adapter->state)) {
5957 if (!(adapter->flags & FLAG_RESTART_NOW)) {
5958 e1000e_dump(adapter);
5959 e_err("Reset adapter unexpectedly\n");
5961 e1000e_reinit_locked(adapter);
5975 struct e1000_adapter *adapter = netdev_priv(netdev);
5977 spin_lock(&adapter->stats64_lock);
5978 e1000e_update_stats(adapter);
5980 stats->rx_bytes = adapter->stats.gorc;
5981 stats->rx_packets = adapter->stats.gprc;
5982 stats->tx_bytes = adapter->stats.gotc;
5983 stats->tx_packets = adapter->stats.gptc;
5984 stats->multicast = adapter->stats.mprc;
5985 stats->collisions = adapter->stats.colc;
5992 stats->rx_errors = adapter->stats.rxerrc +
5993 adapter->stats.crcerrs + adapter->stats.algnerrc +
5994 adapter->stats.ruc + adapter->stats.roc + adapter->stats.cexterr;
5995 stats->rx_length_errors = adapter->stats.ruc + adapter->stats.roc;
5996 stats->rx_crc_errors = adapter->stats.crcerrs;
5997 stats->rx_frame_errors = adapter->stats.algnerrc;
5998 stats->rx_missed_errors = adapter->stats.mpc;
6001 stats->tx_errors = adapter->stats.ecol + adapter->stats.latecol;
6002 stats->tx_aborted_errors = adapter->stats.ecol;
6003 stats->tx_window_errors = adapter->stats.latecol;
6004 stats->tx_carrier_errors = adapter->stats.tncrs;
6008 spin_unlock(&adapter->stats64_lock);
6020 struct e1000_adapter *adapter = netdev_priv(netdev);
6025 !(adapter->flags & FLAG_HAS_JUMBO_FRAMES)) {
6031 if ((adapter->hw.mac.type >= e1000_pch2lan) &&
6032 !(adapter->flags2 & FLAG2_CRC_STRIPPING) &&
6038 while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
6041 adapter->max_frame_size = max_frame;
6049 e1000e_down(adapter, true);
6060 adapter->rx_buffer_len = 2048;
6062 adapter->rx_buffer_len = 4096;
6066 adapter->rx_buffer_len = VLAN_ETH_FRAME_LEN + ETH_FCS_LEN;
6069 e1000e_up(adapter);
6071 e1000e_reset(adapter);
6075 clear_bit(__E1000_RESETTING, &adapter->state);
6083 struct e1000_adapter *adapter = netdev_priv(netdev);
6086 if (adapter->hw.phy.media_type != e1000_media_type_copper)
6091 data->phy_id = adapter->hw.phy.addr;
6094 e1000_phy_read_status(adapter);
6098 data->val_out = adapter->phy_regs.bmcr;
6101 data->val_out = adapter->phy_regs.bmsr;
6104 data->val_out = (adapter->hw.phy.id >> 16);
6107 data->val_out = (adapter->hw.phy.id & 0xFFFF);
6110 data->val_out = adapter->phy_regs.advertise;
6113 data->val_out = adapter->phy_regs.lpa;
6116 data->val_out = adapter->phy_regs.expansion;
6119 data->val_out = adapter->phy_regs.ctrl1000;
6122 data->val_out = adapter->phy_regs.stat1000;
6125 data->val_out = adapter->phy_regs.estatus;
6156 struct e1000_adapter *adapter = netdev_priv(netdev);
6163 ret_val = e1000e_config_hwtstamp(adapter, &config);
6191 struct e1000_adapter *adapter = netdev_priv(netdev);
6193 return copy_to_user(ifr->ifr_data, &adapter->hwtstamp_config,
6194 sizeof(adapter->hwtstamp_config)) ? -EFAULT : 0;
6213 static int e1000_init_phy_wakeup(struct e1000_adapter *adapter, u32 wufc)
6215 struct e1000_hw *hw = &adapter->hw;
6235 for (i = 0; i < adapter->hw.mac.mta_reg_count; i++) {
6244 hw->phy.ops.read_reg_page(&adapter->hw, BM_RCTL, &phy_reg);
6261 hw->phy.ops.write_reg_page(&adapter->hw, BM_RCTL, phy_reg);
6273 hw->phy.ops.write_reg_page(&adapter->hw, BM_WUFC, wufc);
6274 hw->phy.ops.write_reg_page(&adapter->hw, BM_WUC, wuc);
6290 struct e1000_adapter *adapter = netdev_priv(netdev);
6291 struct e1000_hw *hw = &adapter->hw;
6310 static void e1000e_s0ix_entry_flow(struct e1000_adapter *adapter)
6312 struct e1000_hw *hw = &adapter->hw;
6459 static void e1000e_s0ix_exit_flow(struct e1000_adapter *adapter)
6461 struct e1000_hw *hw = &adapter->hw;
6592 struct e1000_adapter *adapter = netdev_priv(netdev);
6603 while (test_bit(__E1000_RESETTING, &adapter->state) && count--)
6606 WARN_ON(test_bit(__E1000_RESETTING, &adapter->state));
6609 e1000e_down(adapter, false);
6610 e1000_free_irq(adapter);
6614 e1000e_reset_interrupt_capability(adapter);
6617 e1000e_disable_pcie_master(&adapter->hw);
6625 struct e1000_adapter *adapter = netdev_priv(netdev);
6626 struct e1000_hw *hw = &adapter->hw;
6634 wufc = adapter->wol;
6643 e1000_setup_rctl(adapter);
6655 if (!(adapter->flags2 & FLAG2_HAS_PHY_WAKEUP))
6659 if (adapter->hw.phy.media_type == e1000_media_type_fiber ||
6660 adapter->hw.phy.media_type ==
6669 e1000e_power_up_phy(adapter);
6671 if (adapter->flags & FLAG_IS_ICH)
6672 e1000_suspend_workarounds_ich8lan(&adapter->hw);
6674 if (adapter->flags2 & FLAG2_HAS_PHY_WAKEUP) {
6676 retval = e1000_init_phy_wakeup(adapter, wufc);
6688 e1000_power_down_phy(adapter);
6691 if (adapter->hw.phy.type == e1000_phy_igp_3) {
6692 e1000e_igp3_phy_powerdown_workaround_ich8lan(&adapter->hw);
6708 adapter->eee_advert && hw->dev_spec.ich8lan.eee_lp_ability) {
6716 if (adapter->eee_advert &
6720 if (adapter->eee_advert &
6735 e1000e_release_hw_control(adapter);
6748 if (adapter->flags & FLAG_IS_QUAD_PORT) {
6870 struct e1000_adapter *adapter = netdev_priv(netdev);
6873 e1000e_set_interrupt_capability(adapter);
6877 rc = e1000_request_irq(adapter);
6881 e1000e_up(adapter);
6894 struct e1000_adapter *adapter = netdev_priv(netdev);
6895 struct e1000_hw *hw = &adapter->hw;
6898 if (adapter->flags2 & FLAG2_DISABLE_ASPM_L0S)
6900 if (adapter->flags2 & FLAG2_DISABLE_ASPM_L1)
6908 e1000_resume_workarounds_pchlan(&adapter->hw);
6910 e1000e_power_up_phy(adapter);
6913 if (adapter->flags2 & FLAG2_HAS_PHY_WAKEUP) {
6916 e1e_rphy(&adapter->hw, BM_WUS, &phy_data);
6926 e1e_wphy(&adapter->hw, BM_WUS, ~0);
6942 e1000e_reset(adapter);
6944 e1000_init_manageability_pt(adapter);
6950 if (!(adapter->flags & FLAG_HAS_AMT))
6951 e1000e_get_hw_control(adapter);
6965 struct e1000_adapter *adapter = netdev_priv(netdev);
6978 if (adapter->flags2 & FLAG2_ENABLE_S0IX_FLOWS)
6979 e1000e_s0ix_entry_flow(adapter);
6988 struct e1000_adapter *adapter = netdev_priv(netdev);
6993 if (adapter->flags2 & FLAG2_ENABLE_S0IX_FLOWS)
6994 e1000e_s0ix_exit_flow(adapter);
7006 struct e1000_adapter *adapter = netdev_priv(netdev);
7009 eee_lp = adapter->hw.dev_spec.ich8lan.eee_lp_ability;
7011 if (!e1000e_has_link(adapter)) {
7012 adapter->hw.dev_spec.ich8lan.eee_lp_ability = eee_lp;
7023 struct e1000_adapter *adapter = netdev_priv(netdev);
7033 e1000e_up(adapter);
7042 struct e1000_adapter *adapter = netdev_priv(netdev);
7047 while (test_bit(__E1000_RESETTING, &adapter->state) && count--)
7050 WARN_ON(test_bit(__E1000_RESETTING, &adapter->state));
7053 e1000e_down(adapter, false);
7078 struct e1000_adapter *adapter = netdev_priv(netdev);
7080 if (adapter->msix_entries) {
7084 msix_irq = adapter->msix_entries[vector].vector;
7090 msix_irq = adapter->msix_entries[vector].vector;
7096 msix_irq = adapter->msix_entries[vector].vector;
7115 struct e1000_adapter *adapter = netdev_priv(netdev);
7117 switch (adapter->int_mode) {
7119 e1000_intr_msix(adapter->pdev->irq, netdev);
7122 if (disable_hardirq(adapter->pdev->irq))
7123 e1000_intr_msi(adapter->pdev->irq, netdev);
7124 enable_irq(adapter->pdev->irq);
7127 if (disable_hardirq(adapter->pdev->irq))
7128 e1000_intr(adapter->pdev->irq, netdev);
7129 enable_irq(adapter->pdev->irq);
7167 struct e1000_adapter *adapter = netdev_priv(netdev);
7168 struct e1000_hw *hw = &adapter->hw;
7173 if (adapter->flags2 & FLAG2_DISABLE_ASPM_L0S)
7175 if (adapter->flags2 & FLAG2_DISABLE_ASPM_L1)
7193 e1000e_reset(adapter);
7212 struct e1000_adapter *adapter = netdev_priv(netdev);
7214 e1000_init_manageability_pt(adapter);
7222 if (!(adapter->flags & FLAG_HAS_AMT))
7223 e1000e_get_hw_control(adapter);
7226 static void e1000_print_device_info(struct e1000_adapter *adapter)
7228 struct e1000_hw *hw = &adapter->hw;
7229 struct net_device *netdev = adapter->netdev;
7250 static void e1000_eeprom_checks(struct e1000_adapter *adapter)
7252 struct e1000_hw *hw = &adapter->hw;
7263 dev_warn(&adapter->pdev->dev,
7271 struct e1000_adapter *adapter = netdev_priv(netdev);
7272 struct e1000_hw *hw = &adapter->hw;
7292 struct e1000_adapter *adapter = netdev_priv(netdev);
7296 adapter->flags |= FLAG_TSO_FORCE;
7305 adapter->flags2 &= ~FLAG2_CRC_STRIPPING;
7308 * stripping is still disabled at the adapter level.
7310 if (adapter->flags2 & FLAG2_DFLT_CRC_STRIPPING)
7311 adapter->flags2 |= FLAG2_CRC_STRIPPING;
7313 adapter->flags2 &= ~FLAG2_CRC_STRIPPING;
7320 e1000e_reinit_locked(adapter);
7322 e1000e_reset(adapter);
7356 * e1000_probe initializes an adapter identified by a pci_dev structure.
7357 * The OS initialization, configuring of the adapter private structure,
7363 struct e1000_adapter *adapter;
7415 adapter = netdev_priv(netdev);
7416 hw = &adapter->hw;
7417 adapter->netdev = netdev;
7418 adapter->pdev = pdev;
7419 adapter->ei = ei;
7420 adapter->pba = ei->pba;
7421 adapter->flags = ei->flags;
7422 adapter->flags2 = ei->flags2;
7423 adapter->hw.adapter = adapter;
7424 adapter->hw.mac.type = ei->mac;
7425 adapter->max_hw_frame_size = ei->max_hw_frame_size;
7426 adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
7432 adapter->hw.hw_addr = ioremap(mmio_start, mmio_len);
7433 if (!adapter->hw.hw_addr)
7436 if ((adapter->flags & FLAG_HAS_FLASH) &&
7441 adapter->hw.flash_address = ioremap(flash_start, flash_len);
7442 if (!adapter->hw.flash_address)
7447 if (adapter->flags2 & FLAG2_HAS_EEE)
7448 adapter->eee_advert = MDIO_EEE_100TX | MDIO_EEE_1000T;
7454 netif_napi_add(netdev, &adapter->napi, e1000e_poll);
7460 adapter->bd_number = cards_found++;
7462 e1000e_check_options(adapter);
7464 /* setup adapter struct */
7465 err = e1000_sw_init(adapter);
7473 err = ei->get_variants(adapter);
7477 if ((adapter->flags & FLAG_IS_ICH) &&
7478 (adapter->flags & FLAG_READ_ONLY_NVM) &&
7480 e1000e_write_protect_nvm_ich8lan(&adapter->hw);
7482 hw->mac.ops.get_bus_info(&adapter->hw);
7484 adapter->hw.phy.autoneg_wait_to_complete = 0;
7487 if (adapter->hw.phy.media_type == e1000_media_type_copper) {
7488 adapter->hw.phy.mdix = AUTO_ALL_MODES;
7489 adapter->hw.phy.disable_polarity_correction = 0;
7490 adapter->hw.phy.ms_type = e1000_ms_hw_default;
7511 if (!(adapter->flags & FLAG_TSO_FORCE)) {
7512 switch (adapter->link_speed) {
7539 if (adapter->flags & FLAG_HAS_HW_VLAN_FILTER)
7554 netdev->max_mtu = adapter->max_hw_frame_size -
7557 if (e1000e_enable_mng_pass_thru(&adapter->hw))
7558 adapter->flags |= FLAG_MNG_PT_ENABLED;
7563 adapter->hw.mac.ops.reset_hw(&adapter->hw);
7569 if (e1000_validate_nvm_checksum(&adapter->hw) >= 0)
7578 e1000_eeprom_checks(adapter);
7581 if (e1000e_read_mac_addr(&adapter->hw))
7585 eth_hw_addr_set(netdev, adapter->hw.mac.addr);
7594 timer_setup(&adapter->watchdog_timer, e1000_watchdog, 0);
7595 timer_setup(&adapter->phy_info_timer, e1000_update_phy_info, 0);
7597 INIT_WORK(&adapter->reset_task, e1000_reset_task);
7598 INIT_WORK(&adapter->watchdog_task, e1000_watchdog_task);
7599 INIT_WORK(&adapter->downshift_task, e1000e_downshift_workaround);
7600 INIT_WORK(&adapter->update_phy_task, e1000e_update_phy_task);
7601 INIT_WORK(&adapter->print_hang_task, e1000_print_hw_hang);
7604 adapter->hw.mac.autoneg = 1;
7605 adapter->fc_autoneg = true;
7606 adapter->hw.fc.requested_mode = e1000_fc_default;
7607 adapter->hw.fc.current_mode = e1000_fc_default;
7608 adapter->hw.phy.autoneg_advertised = 0x2f;
7613 if (adapter->flags & FLAG_APME_IN_WUC) {
7619 adapter->flags2 |= FLAG2_HAS_PHY_WAKEUP;
7620 } else if (adapter->flags & FLAG_APME_IN_CTRL3) {
7621 if (adapter->flags & FLAG_APME_CHECK_PORT_B &&
7622 (adapter->hw.bus.func == 1))
7623 ret_val = e1000_read_nvm(&adapter->hw,
7627 ret_val = e1000_read_nvm(&adapter->hw,
7636 adapter->eeprom_wol |= E1000_WUFC_MAG;
7642 if (!(adapter->flags & FLAG_HAS_WOL))
7643 adapter->eeprom_wol = 0;
7646 adapter->wol = adapter->eeprom_wol;
7648 /* make sure adapter isn't asleep if manageability is enabled */
7649 if (adapter->wol || (adapter->flags & FLAG_MNG_PT_ENABLED) ||
7654 ret_val = e1000_read_nvm(&adapter->hw, 5, 1, &adapter->eeprom_vers);
7658 adapter->eeprom_vers = 0;
7662 e1000e_ptp_init(adapter);
7665 e1000e_reset(adapter);
7671 if (!(adapter->flags & FLAG_HAS_AMT))
7672 e1000e_get_hw_control(adapter);
7675 adapter->flags2 |= FLAG2_ENABLE_S0IX_FLOWS;
7685 e1000_print_device_info(adapter);
7695 if (!(adapter->flags & FLAG_HAS_AMT))
7696 e1000e_release_hw_control(adapter);
7699 e1000_phy_hw_reset(&adapter->hw);
7701 kfree(adapter->tx_ring);
7702 kfree(adapter->rx_ring);
7704 if ((adapter->hw.flash_address) && (hw->mac.type < e1000_pch_spt))
7705 iounmap(adapter->hw.flash_address);
7706 e1000e_reset_interrupt_capability(adapter);
7708 iounmap(adapter->hw.hw_addr);
7731 struct e1000_adapter *adapter = netdev_priv(netdev);
7733 e1000e_ptp_remove(adapter);
7738 set_bit(__E1000_DOWN, &adapter->state);
7739 del_timer_sync(&adapter->watchdog_timer);
7740 del_timer_sync(&adapter->phy_info_timer);
7742 cancel_work_sync(&adapter->reset_task);
7743 cancel_work_sync(&adapter->watchdog_task);
7744 cancel_work_sync(&adapter->downshift_task);
7745 cancel_work_sync(&adapter->update_phy_task);
7746 cancel_work_sync(&adapter->print_hang_task);
7748 if (adapter->flags & FLAG_HAS_HW_TIMESTAMP) {
7749 cancel_work_sync(&adapter->tx_hwtstamp_work);
7750 if (adapter->tx_hwtstamp_skb) {
7751 dev_consume_skb_any(adapter->tx_hwtstamp_skb);
7752 adapter->tx_hwtstamp_skb = NULL;
7764 e1000e_release_hw_control(adapter);
7766 e1000e_reset_interrupt_capability(adapter);
7767 kfree(adapter->tx_ring);
7768 kfree(adapter->rx_ring);
7770 iounmap(adapter->hw.hw_addr);
7771 if ((adapter->hw.flash_address) &&
7772 (adapter->hw.mac.type < e1000_pch_spt))
7773 iounmap(adapter->hw.flash_address);