diff options
author | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
---|---|---|
committer | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
commit | fcc9d2e5a6c89d22b8b773a64fb4ad21ac318446 (patch) | |
tree | a57612d1888735a2ec7972891b68c1ac5ec8faea /drivers/net/ixgb/ixgb_main.c | |
parent | 8dea78da5cee153b8af9c07a2745f6c55057fe12 (diff) |
Diffstat (limited to 'drivers/net/ixgb/ixgb_main.c')
-rw-r--r-- | drivers/net/ixgb/ixgb_main.c | 2332 |
1 files changed, 2332 insertions, 0 deletions
diff --git a/drivers/net/ixgb/ixgb_main.c b/drivers/net/ixgb/ixgb_main.c new file mode 100644 index 00000000000..6a130eb51cf --- /dev/null +++ b/drivers/net/ixgb/ixgb_main.c | |||
@@ -0,0 +1,2332 @@ | |||
1 | /******************************************************************************* | ||
2 | |||
3 | Intel PRO/10GbE Linux driver | ||
4 | Copyright(c) 1999 - 2008 Intel Corporation. | ||
5 | |||
6 | This program is free software; you can redistribute it and/or modify it | ||
7 | under the terms and conditions of the GNU General Public License, | ||
8 | version 2, as published by the Free Software Foundation. | ||
9 | |||
10 | This program is distributed in the hope it will be useful, but WITHOUT | ||
11 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
12 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
13 | more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License along with | ||
16 | this program; if not, write to the Free Software Foundation, Inc., | ||
17 | 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. | ||
18 | |||
19 | The full GNU General Public License is included in this distribution in | ||
20 | the file called "COPYING". | ||
21 | |||
22 | Contact Information: | ||
23 | Linux NICS <linux.nics@intel.com> | ||
24 | e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> | ||
25 | Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 | ||
26 | |||
27 | *******************************************************************************/ | ||
28 | |||
29 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt | ||
30 | |||
31 | #include <linux/prefetch.h> | ||
32 | #include "ixgb.h" | ||
33 | |||
34 | char ixgb_driver_name[] = "ixgb"; | ||
35 | static char ixgb_driver_string[] = "Intel(R) PRO/10GbE Network Driver"; | ||
36 | |||
37 | #define DRIVERNAPI "-NAPI" | ||
38 | #define DRV_VERSION "1.0.135-k2" DRIVERNAPI | ||
39 | const char ixgb_driver_version[] = DRV_VERSION; | ||
40 | static const char ixgb_copyright[] = "Copyright (c) 1999-2008 Intel Corporation."; | ||
41 | |||
42 | #define IXGB_CB_LENGTH 256 | ||
43 | static unsigned int copybreak __read_mostly = IXGB_CB_LENGTH; | ||
44 | module_param(copybreak, uint, 0644); | ||
45 | MODULE_PARM_DESC(copybreak, | ||
46 | "Maximum size of packet that is copied to a new buffer on receive"); | ||
47 | |||
48 | /* ixgb_pci_tbl - PCI Device ID Table | ||
49 | * | ||
50 | * Wildcard entries (PCI_ANY_ID) should come last | ||
51 | * Last entry must be all 0s | ||
52 | * | ||
53 | * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, | ||
54 | * Class, Class Mask, private data (not used) } | ||
55 | */ | ||
56 | static DEFINE_PCI_DEVICE_TABLE(ixgb_pci_tbl) = { | ||
57 | {INTEL_VENDOR_ID, IXGB_DEVICE_ID_82597EX, | ||
58 | PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, | ||
59 | {INTEL_VENDOR_ID, IXGB_DEVICE_ID_82597EX_CX4, | ||
60 | PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, | ||
61 | {INTEL_VENDOR_ID, IXGB_DEVICE_ID_82597EX_SR, | ||
62 | PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, | ||
63 | {INTEL_VENDOR_ID, IXGB_DEVICE_ID_82597EX_LR, | ||
64 | PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, | ||
65 | |||
66 | /* required last entry */ | ||
67 | {0,} | ||
68 | }; | ||
69 | |||
70 | MODULE_DEVICE_TABLE(pci, ixgb_pci_tbl); | ||
71 | |||
72 | /* Local Function Prototypes */ | ||
73 | static int ixgb_init_module(void); | ||
74 | static void ixgb_exit_module(void); | ||
75 | static int ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent); | ||
76 | static void __devexit ixgb_remove(struct pci_dev *pdev); | ||
77 | static int ixgb_sw_init(struct ixgb_adapter *adapter); | ||
78 | static int ixgb_open(struct net_device *netdev); | ||
79 | static int ixgb_close(struct net_device *netdev); | ||
80 | static void ixgb_configure_tx(struct ixgb_adapter *adapter); | ||
81 | static void ixgb_configure_rx(struct ixgb_adapter *adapter); | ||
82 | static void ixgb_setup_rctl(struct ixgb_adapter *adapter); | ||
83 | static void ixgb_clean_tx_ring(struct ixgb_adapter *adapter); | ||
84 | static void ixgb_clean_rx_ring(struct ixgb_adapter *adapter); | ||
85 | static void ixgb_set_multi(struct net_device *netdev); | ||
86 | static void ixgb_watchdog(unsigned long data); | ||
87 | static netdev_tx_t ixgb_xmit_frame(struct sk_buff *skb, | ||
88 | struct net_device *netdev); | ||
89 | static struct net_device_stats *ixgb_get_stats(struct net_device *netdev); | ||
90 | static int ixgb_change_mtu(struct net_device *netdev, int new_mtu); | ||
91 | static int ixgb_set_mac(struct net_device *netdev, void *p); | ||
92 | static irqreturn_t ixgb_intr(int irq, void *data); | ||
93 | static bool ixgb_clean_tx_irq(struct ixgb_adapter *adapter); | ||
94 | |||
95 | static int ixgb_clean(struct napi_struct *, int); | ||
96 | static bool ixgb_clean_rx_irq(struct ixgb_adapter *, int *, int); | ||
97 | static void ixgb_alloc_rx_buffers(struct ixgb_adapter *, int); | ||
98 | |||
99 | static void ixgb_tx_timeout(struct net_device *dev); | ||
100 | static void ixgb_tx_timeout_task(struct work_struct *work); | ||
101 | |||
102 | static void ixgb_vlan_strip_enable(struct ixgb_adapter *adapter); | ||
103 | static void ixgb_vlan_strip_disable(struct ixgb_adapter *adapter); | ||
104 | static void ixgb_vlan_rx_add_vid(struct net_device *netdev, u16 vid); | ||
105 | static void ixgb_vlan_rx_kill_vid(struct net_device *netdev, u16 vid); | ||
106 | static void ixgb_restore_vlan(struct ixgb_adapter *adapter); | ||
107 | |||
108 | #ifdef CONFIG_NET_POLL_CONTROLLER | ||
109 | /* for netdump / net console */ | ||
110 | static void ixgb_netpoll(struct net_device *dev); | ||
111 | #endif | ||
112 | |||
113 | static pci_ers_result_t ixgb_io_error_detected (struct pci_dev *pdev, | ||
114 | enum pci_channel_state state); | ||
115 | static pci_ers_result_t ixgb_io_slot_reset (struct pci_dev *pdev); | ||
116 | static void ixgb_io_resume (struct pci_dev *pdev); | ||
117 | |||
118 | static struct pci_error_handlers ixgb_err_handler = { | ||
119 | .error_detected = ixgb_io_error_detected, | ||
120 | .slot_reset = ixgb_io_slot_reset, | ||
121 | .resume = ixgb_io_resume, | ||
122 | }; | ||
123 | |||
124 | static struct pci_driver ixgb_driver = { | ||
125 | .name = ixgb_driver_name, | ||
126 | .id_table = ixgb_pci_tbl, | ||
127 | .probe = ixgb_probe, | ||
128 | .remove = __devexit_p(ixgb_remove), | ||
129 | .err_handler = &ixgb_err_handler | ||
130 | }; | ||
131 | |||
132 | MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>"); | ||
133 | MODULE_DESCRIPTION("Intel(R) PRO/10GbE Network Driver"); | ||
134 | MODULE_LICENSE("GPL"); | ||
135 | MODULE_VERSION(DRV_VERSION); | ||
136 | |||
137 | #define DEFAULT_DEBUG_LEVEL_SHIFT 3 | ||
138 | static int debug = DEFAULT_DEBUG_LEVEL_SHIFT; | ||
139 | module_param(debug, int, 0); | ||
140 | MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)"); | ||
141 | |||
142 | /** | ||
143 | * ixgb_init_module - Driver Registration Routine | ||
144 | * | ||
145 | * ixgb_init_module is the first routine called when the driver is | ||
146 | * loaded. All it does is register with the PCI subsystem. | ||
147 | **/ | ||
148 | |||
149 | static int __init | ||
150 | ixgb_init_module(void) | ||
151 | { | ||
152 | pr_info("%s - version %s\n", ixgb_driver_string, ixgb_driver_version); | ||
153 | pr_info("%s\n", ixgb_copyright); | ||
154 | |||
155 | return pci_register_driver(&ixgb_driver); | ||
156 | } | ||
157 | |||
158 | module_init(ixgb_init_module); | ||
159 | |||
160 | /** | ||
161 | * ixgb_exit_module - Driver Exit Cleanup Routine | ||
162 | * | ||
163 | * ixgb_exit_module is called just before the driver is removed | ||
164 | * from memory. | ||
165 | **/ | ||
166 | |||
167 | static void __exit | ||
168 | ixgb_exit_module(void) | ||
169 | { | ||
170 | pci_unregister_driver(&ixgb_driver); | ||
171 | } | ||
172 | |||
173 | module_exit(ixgb_exit_module); | ||
174 | |||
175 | /** | ||
176 | * ixgb_irq_disable - Mask off interrupt generation on the NIC | ||
177 | * @adapter: board private structure | ||
178 | **/ | ||
179 | |||
180 | static void | ||
181 | ixgb_irq_disable(struct ixgb_adapter *adapter) | ||
182 | { | ||
183 | IXGB_WRITE_REG(&adapter->hw, IMC, ~0); | ||
184 | IXGB_WRITE_FLUSH(&adapter->hw); | ||
185 | synchronize_irq(adapter->pdev->irq); | ||
186 | } | ||
187 | |||
188 | /** | ||
189 | * ixgb_irq_enable - Enable default interrupt generation settings | ||
190 | * @adapter: board private structure | ||
191 | **/ | ||
192 | |||
193 | static void | ||
194 | ixgb_irq_enable(struct ixgb_adapter *adapter) | ||
195 | { | ||
196 | u32 val = IXGB_INT_RXT0 | IXGB_INT_RXDMT0 | | ||
197 | IXGB_INT_TXDW | IXGB_INT_LSC; | ||
198 | if (adapter->hw.subsystem_vendor_id == SUN_SUBVENDOR_ID) | ||
199 | val |= IXGB_INT_GPI0; | ||
200 | IXGB_WRITE_REG(&adapter->hw, IMS, val); | ||
201 | IXGB_WRITE_FLUSH(&adapter->hw); | ||
202 | } | ||
203 | |||
204 | int | ||
205 | ixgb_up(struct ixgb_adapter *adapter) | ||
206 | { | ||
207 | struct net_device *netdev = adapter->netdev; | ||
208 | int err, irq_flags = IRQF_SHARED; | ||
209 | int max_frame = netdev->mtu + ENET_HEADER_SIZE + ENET_FCS_LENGTH; | ||
210 | struct ixgb_hw *hw = &adapter->hw; | ||
211 | |||
212 | /* hardware has been reset, we need to reload some things */ | ||
213 | |||
214 | ixgb_rar_set(hw, netdev->dev_addr, 0); | ||
215 | ixgb_set_multi(netdev); | ||
216 | |||
217 | ixgb_restore_vlan(adapter); | ||
218 | |||
219 | ixgb_configure_tx(adapter); | ||
220 | ixgb_setup_rctl(adapter); | ||
221 | ixgb_configure_rx(adapter); | ||
222 | ixgb_alloc_rx_buffers(adapter, IXGB_DESC_UNUSED(&adapter->rx_ring)); | ||
223 | |||
224 | /* disable interrupts and get the hardware into a known state */ | ||
225 | IXGB_WRITE_REG(&adapter->hw, IMC, 0xffffffff); | ||
226 | |||
227 | /* only enable MSI if bus is in PCI-X mode */ | ||
228 | if (IXGB_READ_REG(&adapter->hw, STATUS) & IXGB_STATUS_PCIX_MODE) { | ||
229 | err = pci_enable_msi(adapter->pdev); | ||
230 | if (!err) { | ||
231 | adapter->have_msi = 1; | ||
232 | irq_flags = 0; | ||
233 | } | ||
234 | /* proceed to try to request regular interrupt */ | ||
235 | } | ||
236 | |||
237 | err = request_irq(adapter->pdev->irq, ixgb_intr, irq_flags, | ||
238 | netdev->name, netdev); | ||
239 | if (err) { | ||
240 | if (adapter->have_msi) | ||
241 | pci_disable_msi(adapter->pdev); | ||
242 | netif_err(adapter, probe, adapter->netdev, | ||
243 | "Unable to allocate interrupt Error: %d\n", err); | ||
244 | return err; | ||
245 | } | ||
246 | |||
247 | if ((hw->max_frame_size != max_frame) || | ||
248 | (hw->max_frame_size != | ||
249 | (IXGB_READ_REG(hw, MFS) >> IXGB_MFS_SHIFT))) { | ||
250 | |||
251 | hw->max_frame_size = max_frame; | ||
252 | |||
253 | IXGB_WRITE_REG(hw, MFS, hw->max_frame_size << IXGB_MFS_SHIFT); | ||
254 | |||
255 | if (hw->max_frame_size > | ||
256 | IXGB_MAX_ENET_FRAME_SIZE_WITHOUT_FCS + ENET_FCS_LENGTH) { | ||
257 | u32 ctrl0 = IXGB_READ_REG(hw, CTRL0); | ||
258 | |||
259 | if (!(ctrl0 & IXGB_CTRL0_JFE)) { | ||
260 | ctrl0 |= IXGB_CTRL0_JFE; | ||
261 | IXGB_WRITE_REG(hw, CTRL0, ctrl0); | ||
262 | } | ||
263 | } | ||
264 | } | ||
265 | |||
266 | clear_bit(__IXGB_DOWN, &adapter->flags); | ||
267 | |||
268 | napi_enable(&adapter->napi); | ||
269 | ixgb_irq_enable(adapter); | ||
270 | |||
271 | netif_wake_queue(netdev); | ||
272 | |||
273 | mod_timer(&adapter->watchdog_timer, jiffies); | ||
274 | |||
275 | return 0; | ||
276 | } | ||
277 | |||
278 | void | ||
279 | ixgb_down(struct ixgb_adapter *adapter, bool kill_watchdog) | ||
280 | { | ||
281 | struct net_device *netdev = adapter->netdev; | ||
282 | |||
283 | /* prevent the interrupt handler from restarting watchdog */ | ||
284 | set_bit(__IXGB_DOWN, &adapter->flags); | ||
285 | |||
286 | napi_disable(&adapter->napi); | ||
287 | /* waiting for NAPI to complete can re-enable interrupts */ | ||
288 | ixgb_irq_disable(adapter); | ||
289 | free_irq(adapter->pdev->irq, netdev); | ||
290 | |||
291 | if (adapter->have_msi) | ||
292 | pci_disable_msi(adapter->pdev); | ||
293 | |||
294 | if (kill_watchdog) | ||
295 | del_timer_sync(&adapter->watchdog_timer); | ||
296 | |||
297 | adapter->link_speed = 0; | ||
298 | adapter->link_duplex = 0; | ||
299 | netif_carrier_off(netdev); | ||
300 | netif_stop_queue(netdev); | ||
301 | |||
302 | ixgb_reset(adapter); | ||
303 | ixgb_clean_tx_ring(adapter); | ||
304 | ixgb_clean_rx_ring(adapter); | ||
305 | } | ||
306 | |||
307 | void | ||
308 | ixgb_reset(struct ixgb_adapter *adapter) | ||
309 | { | ||
310 | struct ixgb_hw *hw = &adapter->hw; | ||
311 | |||
312 | ixgb_adapter_stop(hw); | ||
313 | if (!ixgb_init_hw(hw)) | ||
314 | netif_err(adapter, probe, adapter->netdev, "ixgb_init_hw failed\n"); | ||
315 | |||
316 | /* restore frame size information */ | ||
317 | IXGB_WRITE_REG(hw, MFS, hw->max_frame_size << IXGB_MFS_SHIFT); | ||
318 | if (hw->max_frame_size > | ||
319 | IXGB_MAX_ENET_FRAME_SIZE_WITHOUT_FCS + ENET_FCS_LENGTH) { | ||
320 | u32 ctrl0 = IXGB_READ_REG(hw, CTRL0); | ||
321 | if (!(ctrl0 & IXGB_CTRL0_JFE)) { | ||
322 | ctrl0 |= IXGB_CTRL0_JFE; | ||
323 | IXGB_WRITE_REG(hw, CTRL0, ctrl0); | ||
324 | } | ||
325 | } | ||
326 | } | ||
327 | |||
328 | static const struct net_device_ops ixgb_netdev_ops = { | ||
329 | .ndo_open = ixgb_open, | ||
330 | .ndo_stop = ixgb_close, | ||
331 | .ndo_start_xmit = ixgb_xmit_frame, | ||
332 | .ndo_get_stats = ixgb_get_stats, | ||
333 | .ndo_set_multicast_list = ixgb_set_multi, | ||
334 | .ndo_validate_addr = eth_validate_addr, | ||
335 | .ndo_set_mac_address = ixgb_set_mac, | ||
336 | .ndo_change_mtu = ixgb_change_mtu, | ||
337 | .ndo_tx_timeout = ixgb_tx_timeout, | ||
338 | .ndo_vlan_rx_add_vid = ixgb_vlan_rx_add_vid, | ||
339 | .ndo_vlan_rx_kill_vid = ixgb_vlan_rx_kill_vid, | ||
340 | #ifdef CONFIG_NET_POLL_CONTROLLER | ||
341 | .ndo_poll_controller = ixgb_netpoll, | ||
342 | #endif | ||
343 | }; | ||
344 | |||
345 | /** | ||
346 | * ixgb_probe - Device Initialization Routine | ||
347 | * @pdev: PCI device information struct | ||
348 | * @ent: entry in ixgb_pci_tbl | ||
349 | * | ||
350 | * Returns 0 on success, negative on failure | ||
351 | * | ||
352 | * ixgb_probe initializes an adapter identified by a pci_dev structure. | ||
353 | * The OS initialization, configuring of the adapter private structure, | ||
354 | * and a hardware reset occur. | ||
355 | **/ | ||
356 | |||
357 | static int __devinit | ||
358 | ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) | ||
359 | { | ||
360 | struct net_device *netdev = NULL; | ||
361 | struct ixgb_adapter *adapter; | ||
362 | static int cards_found = 0; | ||
363 | int pci_using_dac; | ||
364 | int i; | ||
365 | int err; | ||
366 | |||
367 | err = pci_enable_device(pdev); | ||
368 | if (err) | ||
369 | return err; | ||
370 | |||
371 | pci_using_dac = 0; | ||
372 | err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64)); | ||
373 | if (!err) { | ||
374 | err = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64)); | ||
375 | if (!err) | ||
376 | pci_using_dac = 1; | ||
377 | } else { | ||
378 | err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32)); | ||
379 | if (err) { | ||
380 | err = dma_set_coherent_mask(&pdev->dev, | ||
381 | DMA_BIT_MASK(32)); | ||
382 | if (err) { | ||
383 | pr_err("No usable DMA configuration, aborting\n"); | ||
384 | goto err_dma_mask; | ||
385 | } | ||
386 | } | ||
387 | } | ||
388 | |||
389 | err = pci_request_regions(pdev, ixgb_driver_name); | ||
390 | if (err) | ||
391 | goto err_request_regions; | ||
392 | |||
393 | pci_set_master(pdev); | ||
394 | |||
395 | netdev = alloc_etherdev(sizeof(struct ixgb_adapter)); | ||
396 | if (!netdev) { | ||
397 | err = -ENOMEM; | ||
398 | goto err_alloc_etherdev; | ||
399 | } | ||
400 | |||
401 | SET_NETDEV_DEV(netdev, &pdev->dev); | ||
402 | |||
403 | pci_set_drvdata(pdev, netdev); | ||
404 | adapter = netdev_priv(netdev); | ||
405 | adapter->netdev = netdev; | ||
406 | adapter->pdev = pdev; | ||
407 | adapter->hw.back = adapter; | ||
408 | adapter->msg_enable = netif_msg_init(debug, DEFAULT_DEBUG_LEVEL_SHIFT); | ||
409 | |||
410 | adapter->hw.hw_addr = pci_ioremap_bar(pdev, BAR_0); | ||
411 | if (!adapter->hw.hw_addr) { | ||
412 | err = -EIO; | ||
413 | goto err_ioremap; | ||
414 | } | ||
415 | |||
416 | for (i = BAR_1; i <= BAR_5; i++) { | ||
417 | if (pci_resource_len(pdev, i) == 0) | ||
418 | continue; | ||
419 | if (pci_resource_flags(pdev, i) & IORESOURCE_IO) { | ||
420 | adapter->hw.io_base = pci_resource_start(pdev, i); | ||
421 | break; | ||
422 | } | ||
423 | } | ||
424 | |||
425 | netdev->netdev_ops = &ixgb_netdev_ops; | ||
426 | ixgb_set_ethtool_ops(netdev); | ||
427 | netdev->watchdog_timeo = 5 * HZ; | ||
428 | netif_napi_add(netdev, &adapter->napi, ixgb_clean, 64); | ||
429 | |||
430 | strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1); | ||
431 | |||
432 | adapter->bd_number = cards_found; | ||
433 | adapter->link_speed = 0; | ||
434 | adapter->link_duplex = 0; | ||
435 | |||
436 | /* setup the private structure */ | ||
437 | |||
438 | err = ixgb_sw_init(adapter); | ||
439 | if (err) | ||
440 | goto err_sw_init; | ||
441 | |||
442 | netdev->features = NETIF_F_SG | | ||
443 | NETIF_F_HW_CSUM | | ||
444 | NETIF_F_HW_VLAN_TX | | ||
445 | NETIF_F_HW_VLAN_RX | | ||
446 | NETIF_F_HW_VLAN_FILTER; | ||
447 | netdev->features |= NETIF_F_TSO; | ||
448 | |||
449 | if (pci_using_dac) { | ||
450 | netdev->features |= NETIF_F_HIGHDMA; | ||
451 | netdev->vlan_features |= NETIF_F_HIGHDMA; | ||
452 | } | ||
453 | |||
454 | /* make sure the EEPROM is good */ | ||
455 | |||
456 | if (!ixgb_validate_eeprom_checksum(&adapter->hw)) { | ||
457 | netif_err(adapter, probe, adapter->netdev, | ||
458 | "The EEPROM Checksum Is Not Valid\n"); | ||
459 | err = -EIO; | ||
460 | goto err_eeprom; | ||
461 | } | ||
462 | |||
463 | ixgb_get_ee_mac_addr(&adapter->hw, netdev->dev_addr); | ||
464 | memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len); | ||
465 | |||
466 | if (!is_valid_ether_addr(netdev->perm_addr)) { | ||
467 | netif_err(adapter, probe, adapter->netdev, "Invalid MAC Address\n"); | ||
468 | err = -EIO; | ||
469 | goto err_eeprom; | ||
470 | } | ||
471 | |||
472 | adapter->part_num = ixgb_get_ee_pba_number(&adapter->hw); | ||
473 | |||
474 | init_timer(&adapter->watchdog_timer); | ||
475 | adapter->watchdog_timer.function = ixgb_watchdog; | ||
476 | adapter->watchdog_timer.data = (unsigned long)adapter; | ||
477 | |||
478 | INIT_WORK(&adapter->tx_timeout_task, ixgb_tx_timeout_task); | ||
479 | |||
480 | strcpy(netdev->name, "eth%d"); | ||
481 | err = register_netdev(netdev); | ||
482 | if (err) | ||
483 | goto err_register; | ||
484 | |||
485 | /* carrier off reporting is important to ethtool even BEFORE open */ | ||
486 | netif_carrier_off(netdev); | ||
487 | |||
488 | netif_info(adapter, probe, adapter->netdev, | ||
489 | "Intel(R) PRO/10GbE Network Connection\n"); | ||
490 | ixgb_check_options(adapter); | ||
491 | /* reset the hardware with the new settings */ | ||
492 | |||
493 | ixgb_reset(adapter); | ||
494 | |||
495 | cards_found++; | ||
496 | return 0; | ||
497 | |||
498 | err_register: | ||
499 | err_sw_init: | ||
500 | err_eeprom: | ||
501 | iounmap(adapter->hw.hw_addr); | ||
502 | err_ioremap: | ||
503 | free_netdev(netdev); | ||
504 | err_alloc_etherdev: | ||
505 | pci_release_regions(pdev); | ||
506 | err_request_regions: | ||
507 | err_dma_mask: | ||
508 | pci_disable_device(pdev); | ||
509 | return err; | ||
510 | } | ||
511 | |||
512 | /** | ||
513 | * ixgb_remove - Device Removal Routine | ||
514 | * @pdev: PCI device information struct | ||
515 | * | ||
516 | * ixgb_remove is called by the PCI subsystem to alert the driver | ||
517 | * that it should release a PCI device. The could be caused by a | ||
518 | * Hot-Plug event, or because the driver is going to be removed from | ||
519 | * memory. | ||
520 | **/ | ||
521 | |||
522 | static void __devexit | ||
523 | ixgb_remove(struct pci_dev *pdev) | ||
524 | { | ||
525 | struct net_device *netdev = pci_get_drvdata(pdev); | ||
526 | struct ixgb_adapter *adapter = netdev_priv(netdev); | ||
527 | |||
528 | cancel_work_sync(&adapter->tx_timeout_task); | ||
529 | |||
530 | unregister_netdev(netdev); | ||
531 | |||
532 | iounmap(adapter->hw.hw_addr); | ||
533 | pci_release_regions(pdev); | ||
534 | |||
535 | free_netdev(netdev); | ||
536 | pci_disable_device(pdev); | ||
537 | } | ||
538 | |||
539 | /** | ||
540 | * ixgb_sw_init - Initialize general software structures (struct ixgb_adapter) | ||
541 | * @adapter: board private structure to initialize | ||
542 | * | ||
543 | * ixgb_sw_init initializes the Adapter private data structure. | ||
544 | * Fields are initialized based on PCI device information and | ||
545 | * OS network device settings (MTU size). | ||
546 | **/ | ||
547 | |||
548 | static int __devinit | ||
549 | ixgb_sw_init(struct ixgb_adapter *adapter) | ||
550 | { | ||
551 | struct ixgb_hw *hw = &adapter->hw; | ||
552 | struct net_device *netdev = adapter->netdev; | ||
553 | struct pci_dev *pdev = adapter->pdev; | ||
554 | |||
555 | /* PCI config space info */ | ||
556 | |||
557 | hw->vendor_id = pdev->vendor; | ||
558 | hw->device_id = pdev->device; | ||
559 | hw->subsystem_vendor_id = pdev->subsystem_vendor; | ||
560 | hw->subsystem_id = pdev->subsystem_device; | ||
561 | |||
562 | hw->max_frame_size = netdev->mtu + ENET_HEADER_SIZE + ENET_FCS_LENGTH; | ||
563 | adapter->rx_buffer_len = hw->max_frame_size + 8; /* + 8 for errata */ | ||
564 | |||
565 | if ((hw->device_id == IXGB_DEVICE_ID_82597EX) || | ||
566 | (hw->device_id == IXGB_DEVICE_ID_82597EX_CX4) || | ||
567 | (hw->device_id == IXGB_DEVICE_ID_82597EX_LR) || | ||
568 | (hw->device_id == IXGB_DEVICE_ID_82597EX_SR)) | ||
569 | hw->mac_type = ixgb_82597; | ||
570 | else { | ||
571 | /* should never have loaded on this device */ | ||
572 | netif_err(adapter, probe, adapter->netdev, "unsupported device id\n"); | ||
573 | } | ||
574 | |||
575 | /* enable flow control to be programmed */ | ||
576 | hw->fc.send_xon = 1; | ||
577 | |||
578 | set_bit(__IXGB_DOWN, &adapter->flags); | ||
579 | return 0; | ||
580 | } | ||
581 | |||
582 | /** | ||
583 | * ixgb_open - Called when a network interface is made active | ||
584 | * @netdev: network interface device structure | ||
585 | * | ||
586 | * Returns 0 on success, negative value on failure | ||
587 | * | ||
588 | * The open entry point is called when a network interface is made | ||
589 | * active by the system (IFF_UP). At this point all resources needed | ||
590 | * for transmit and receive operations are allocated, the interrupt | ||
591 | * handler is registered with the OS, the watchdog timer is started, | ||
592 | * and the stack is notified that the interface is ready. | ||
593 | **/ | ||
594 | |||
595 | static int | ||
596 | ixgb_open(struct net_device *netdev) | ||
597 | { | ||
598 | struct ixgb_adapter *adapter = netdev_priv(netdev); | ||
599 | int err; | ||
600 | |||
601 | /* allocate transmit descriptors */ | ||
602 | err = ixgb_setup_tx_resources(adapter); | ||
603 | if (err) | ||
604 | goto err_setup_tx; | ||
605 | |||
606 | netif_carrier_off(netdev); | ||
607 | |||
608 | /* allocate receive descriptors */ | ||
609 | |||
610 | err = ixgb_setup_rx_resources(adapter); | ||
611 | if (err) | ||
612 | goto err_setup_rx; | ||
613 | |||
614 | err = ixgb_up(adapter); | ||
615 | if (err) | ||
616 | goto err_up; | ||
617 | |||
618 | netif_start_queue(netdev); | ||
619 | |||
620 | return 0; | ||
621 | |||
622 | err_up: | ||
623 | ixgb_free_rx_resources(adapter); | ||
624 | err_setup_rx: | ||
625 | ixgb_free_tx_resources(adapter); | ||
626 | err_setup_tx: | ||
627 | ixgb_reset(adapter); | ||
628 | |||
629 | return err; | ||
630 | } | ||
631 | |||
632 | /** | ||
633 | * ixgb_close - Disables a network interface | ||
634 | * @netdev: network interface device structure | ||
635 | * | ||
636 | * Returns 0, this is not allowed to fail | ||
637 | * | ||
638 | * The close entry point is called when an interface is de-activated | ||
639 | * by the OS. The hardware is still under the drivers control, but | ||
640 | * needs to be disabled. A global MAC reset is issued to stop the | ||
641 | * hardware, and all transmit and receive resources are freed. | ||
642 | **/ | ||
643 | |||
644 | static int | ||
645 | ixgb_close(struct net_device *netdev) | ||
646 | { | ||
647 | struct ixgb_adapter *adapter = netdev_priv(netdev); | ||
648 | |||
649 | ixgb_down(adapter, true); | ||
650 | |||
651 | ixgb_free_tx_resources(adapter); | ||
652 | ixgb_free_rx_resources(adapter); | ||
653 | |||
654 | return 0; | ||
655 | } | ||
656 | |||
657 | /** | ||
658 | * ixgb_setup_tx_resources - allocate Tx resources (Descriptors) | ||
659 | * @adapter: board private structure | ||
660 | * | ||
661 | * Return 0 on success, negative on failure | ||
662 | **/ | ||
663 | |||
664 | int | ||
665 | ixgb_setup_tx_resources(struct ixgb_adapter *adapter) | ||
666 | { | ||
667 | struct ixgb_desc_ring *txdr = &adapter->tx_ring; | ||
668 | struct pci_dev *pdev = adapter->pdev; | ||
669 | int size; | ||
670 | |||
671 | size = sizeof(struct ixgb_buffer) * txdr->count; | ||
672 | txdr->buffer_info = vzalloc(size); | ||
673 | if (!txdr->buffer_info) { | ||
674 | netif_err(adapter, probe, adapter->netdev, | ||
675 | "Unable to allocate transmit descriptor ring memory\n"); | ||
676 | return -ENOMEM; | ||
677 | } | ||
678 | |||
679 | /* round up to nearest 4K */ | ||
680 | |||
681 | txdr->size = txdr->count * sizeof(struct ixgb_tx_desc); | ||
682 | txdr->size = ALIGN(txdr->size, 4096); | ||
683 | |||
684 | txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma, | ||
685 | GFP_KERNEL); | ||
686 | if (!txdr->desc) { | ||
687 | vfree(txdr->buffer_info); | ||
688 | netif_err(adapter, probe, adapter->netdev, | ||
689 | "Unable to allocate transmit descriptor memory\n"); | ||
690 | return -ENOMEM; | ||
691 | } | ||
692 | memset(txdr->desc, 0, txdr->size); | ||
693 | |||
694 | txdr->next_to_use = 0; | ||
695 | txdr->next_to_clean = 0; | ||
696 | |||
697 | return 0; | ||
698 | } | ||
699 | |||
700 | /** | ||
701 | * ixgb_configure_tx - Configure 82597 Transmit Unit after Reset. | ||
702 | * @adapter: board private structure | ||
703 | * | ||
704 | * Configure the Tx unit of the MAC after a reset. | ||
705 | **/ | ||
706 | |||
707 | static void | ||
708 | ixgb_configure_tx(struct ixgb_adapter *adapter) | ||
709 | { | ||
710 | u64 tdba = adapter->tx_ring.dma; | ||
711 | u32 tdlen = adapter->tx_ring.count * sizeof(struct ixgb_tx_desc); | ||
712 | u32 tctl; | ||
713 | struct ixgb_hw *hw = &adapter->hw; | ||
714 | |||
715 | /* Setup the Base and Length of the Tx Descriptor Ring | ||
716 | * tx_ring.dma can be either a 32 or 64 bit value | ||
717 | */ | ||
718 | |||
719 | IXGB_WRITE_REG(hw, TDBAL, (tdba & 0x00000000ffffffffULL)); | ||
720 | IXGB_WRITE_REG(hw, TDBAH, (tdba >> 32)); | ||
721 | |||
722 | IXGB_WRITE_REG(hw, TDLEN, tdlen); | ||
723 | |||
724 | /* Setup the HW Tx Head and Tail descriptor pointers */ | ||
725 | |||
726 | IXGB_WRITE_REG(hw, TDH, 0); | ||
727 | IXGB_WRITE_REG(hw, TDT, 0); | ||
728 | |||
729 | /* don't set up txdctl, it induces performance problems if configured | ||
730 | * incorrectly */ | ||
731 | /* Set the Tx Interrupt Delay register */ | ||
732 | |||
733 | IXGB_WRITE_REG(hw, TIDV, adapter->tx_int_delay); | ||
734 | |||
735 | /* Program the Transmit Control Register */ | ||
736 | |||
737 | tctl = IXGB_TCTL_TCE | IXGB_TCTL_TXEN | IXGB_TCTL_TPDE; | ||
738 | IXGB_WRITE_REG(hw, TCTL, tctl); | ||
739 | |||
740 | /* Setup Transmit Descriptor Settings for this adapter */ | ||
741 | adapter->tx_cmd_type = | ||
742 | IXGB_TX_DESC_TYPE | | ||
743 | (adapter->tx_int_delay_enable ? IXGB_TX_DESC_CMD_IDE : 0); | ||
744 | } | ||
745 | |||
746 | /** | ||
747 | * ixgb_setup_rx_resources - allocate Rx resources (Descriptors) | ||
748 | * @adapter: board private structure | ||
749 | * | ||
750 | * Returns 0 on success, negative on failure | ||
751 | **/ | ||
752 | |||
753 | int | ||
754 | ixgb_setup_rx_resources(struct ixgb_adapter *adapter) | ||
755 | { | ||
756 | struct ixgb_desc_ring *rxdr = &adapter->rx_ring; | ||
757 | struct pci_dev *pdev = adapter->pdev; | ||
758 | int size; | ||
759 | |||
760 | size = sizeof(struct ixgb_buffer) * rxdr->count; | ||
761 | rxdr->buffer_info = vzalloc(size); | ||
762 | if (!rxdr->buffer_info) { | ||
763 | netif_err(adapter, probe, adapter->netdev, | ||
764 | "Unable to allocate receive descriptor ring\n"); | ||
765 | return -ENOMEM; | ||
766 | } | ||
767 | |||
768 | /* Round up to nearest 4K */ | ||
769 | |||
770 | rxdr->size = rxdr->count * sizeof(struct ixgb_rx_desc); | ||
771 | rxdr->size = ALIGN(rxdr->size, 4096); | ||
772 | |||
773 | rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma, | ||
774 | GFP_KERNEL); | ||
775 | |||
776 | if (!rxdr->desc) { | ||
777 | vfree(rxdr->buffer_info); | ||
778 | netif_err(adapter, probe, adapter->netdev, | ||
779 | "Unable to allocate receive descriptors\n"); | ||
780 | return -ENOMEM; | ||
781 | } | ||
782 | memset(rxdr->desc, 0, rxdr->size); | ||
783 | |||
784 | rxdr->next_to_clean = 0; | ||
785 | rxdr->next_to_use = 0; | ||
786 | |||
787 | return 0; | ||
788 | } | ||
789 | |||
790 | /** | ||
791 | * ixgb_setup_rctl - configure the receive control register | ||
792 | * @adapter: Board private structure | ||
793 | **/ | ||
794 | |||
795 | static void | ||
796 | ixgb_setup_rctl(struct ixgb_adapter *adapter) | ||
797 | { | ||
798 | u32 rctl; | ||
799 | |||
800 | rctl = IXGB_READ_REG(&adapter->hw, RCTL); | ||
801 | |||
802 | rctl &= ~(3 << IXGB_RCTL_MO_SHIFT); | ||
803 | |||
804 | rctl |= | ||
805 | IXGB_RCTL_BAM | IXGB_RCTL_RDMTS_1_2 | | ||
806 | IXGB_RCTL_RXEN | IXGB_RCTL_CFF | | ||
807 | (adapter->hw.mc_filter_type << IXGB_RCTL_MO_SHIFT); | ||
808 | |||
809 | rctl |= IXGB_RCTL_SECRC; | ||
810 | |||
811 | if (adapter->rx_buffer_len <= IXGB_RXBUFFER_2048) | ||
812 | rctl |= IXGB_RCTL_BSIZE_2048; | ||
813 | else if (adapter->rx_buffer_len <= IXGB_RXBUFFER_4096) | ||
814 | rctl |= IXGB_RCTL_BSIZE_4096; | ||
815 | else if (adapter->rx_buffer_len <= IXGB_RXBUFFER_8192) | ||
816 | rctl |= IXGB_RCTL_BSIZE_8192; | ||
817 | else if (adapter->rx_buffer_len <= IXGB_RXBUFFER_16384) | ||
818 | rctl |= IXGB_RCTL_BSIZE_16384; | ||
819 | |||
820 | IXGB_WRITE_REG(&adapter->hw, RCTL, rctl); | ||
821 | } | ||
822 | |||
823 | /** | ||
824 | * ixgb_configure_rx - Configure 82597 Receive Unit after Reset. | ||
825 | * @adapter: board private structure | ||
826 | * | ||
827 | * Configure the Rx unit of the MAC after a reset. | ||
828 | **/ | ||
829 | |||
830 | static void | ||
831 | ixgb_configure_rx(struct ixgb_adapter *adapter) | ||
832 | { | ||
833 | u64 rdba = adapter->rx_ring.dma; | ||
834 | u32 rdlen = adapter->rx_ring.count * sizeof(struct ixgb_rx_desc); | ||
835 | struct ixgb_hw *hw = &adapter->hw; | ||
836 | u32 rctl; | ||
837 | u32 rxcsum; | ||
838 | |||
839 | /* make sure receives are disabled while setting up the descriptors */ | ||
840 | |||
841 | rctl = IXGB_READ_REG(hw, RCTL); | ||
842 | IXGB_WRITE_REG(hw, RCTL, rctl & ~IXGB_RCTL_RXEN); | ||
843 | |||
844 | /* set the Receive Delay Timer Register */ | ||
845 | |||
846 | IXGB_WRITE_REG(hw, RDTR, adapter->rx_int_delay); | ||
847 | |||
848 | /* Setup the Base and Length of the Rx Descriptor Ring */ | ||
849 | |||
850 | IXGB_WRITE_REG(hw, RDBAL, (rdba & 0x00000000ffffffffULL)); | ||
851 | IXGB_WRITE_REG(hw, RDBAH, (rdba >> 32)); | ||
852 | |||
853 | IXGB_WRITE_REG(hw, RDLEN, rdlen); | ||
854 | |||
855 | /* Setup the HW Rx Head and Tail Descriptor Pointers */ | ||
856 | IXGB_WRITE_REG(hw, RDH, 0); | ||
857 | IXGB_WRITE_REG(hw, RDT, 0); | ||
858 | |||
859 | /* due to the hardware errata with RXDCTL, we are unable to use any of | ||
860 | * the performance enhancing features of it without causing other | ||
861 | * subtle bugs, some of the bugs could include receive length | ||
862 | * corruption at high data rates (WTHRESH > 0) and/or receive | ||
863 | * descriptor ring irregularites (particularly in hardware cache) */ | ||
864 | IXGB_WRITE_REG(hw, RXDCTL, 0); | ||
865 | |||
866 | /* Enable Receive Checksum Offload for TCP and UDP */ | ||
867 | if (adapter->rx_csum) { | ||
868 | rxcsum = IXGB_READ_REG(hw, RXCSUM); | ||
869 | rxcsum |= IXGB_RXCSUM_TUOFL; | ||
870 | IXGB_WRITE_REG(hw, RXCSUM, rxcsum); | ||
871 | } | ||
872 | |||
873 | /* Enable Receives */ | ||
874 | |||
875 | IXGB_WRITE_REG(hw, RCTL, rctl); | ||
876 | } | ||
877 | |||
878 | /** | ||
879 | * ixgb_free_tx_resources - Free Tx Resources | ||
880 | * @adapter: board private structure | ||
881 | * | ||
882 | * Free all transmit software resources | ||
883 | **/ | ||
884 | |||
885 | void | ||
886 | ixgb_free_tx_resources(struct ixgb_adapter *adapter) | ||
887 | { | ||
888 | struct pci_dev *pdev = adapter->pdev; | ||
889 | |||
890 | ixgb_clean_tx_ring(adapter); | ||
891 | |||
892 | vfree(adapter->tx_ring.buffer_info); | ||
893 | adapter->tx_ring.buffer_info = NULL; | ||
894 | |||
895 | dma_free_coherent(&pdev->dev, adapter->tx_ring.size, | ||
896 | adapter->tx_ring.desc, adapter->tx_ring.dma); | ||
897 | |||
898 | adapter->tx_ring.desc = NULL; | ||
899 | } | ||
900 | |||
901 | static void | ||
902 | ixgb_unmap_and_free_tx_resource(struct ixgb_adapter *adapter, | ||
903 | struct ixgb_buffer *buffer_info) | ||
904 | { | ||
905 | if (buffer_info->dma) { | ||
906 | if (buffer_info->mapped_as_page) | ||
907 | dma_unmap_page(&adapter->pdev->dev, buffer_info->dma, | ||
908 | buffer_info->length, DMA_TO_DEVICE); | ||
909 | else | ||
910 | dma_unmap_single(&adapter->pdev->dev, buffer_info->dma, | ||
911 | buffer_info->length, DMA_TO_DEVICE); | ||
912 | buffer_info->dma = 0; | ||
913 | } | ||
914 | |||
915 | if (buffer_info->skb) { | ||
916 | dev_kfree_skb_any(buffer_info->skb); | ||
917 | buffer_info->skb = NULL; | ||
918 | } | ||
919 | buffer_info->time_stamp = 0; | ||
920 | /* these fields must always be initialized in tx | ||
921 | * buffer_info->length = 0; | ||
922 | * buffer_info->next_to_watch = 0; */ | ||
923 | } | ||
924 | |||
925 | /** | ||
926 | * ixgb_clean_tx_ring - Free Tx Buffers | ||
927 | * @adapter: board private structure | ||
928 | **/ | ||
929 | |||
930 | static void | ||
931 | ixgb_clean_tx_ring(struct ixgb_adapter *adapter) | ||
932 | { | ||
933 | struct ixgb_desc_ring *tx_ring = &adapter->tx_ring; | ||
934 | struct ixgb_buffer *buffer_info; | ||
935 | unsigned long size; | ||
936 | unsigned int i; | ||
937 | |||
938 | /* Free all the Tx ring sk_buffs */ | ||
939 | |||
940 | for (i = 0; i < tx_ring->count; i++) { | ||
941 | buffer_info = &tx_ring->buffer_info[i]; | ||
942 | ixgb_unmap_and_free_tx_resource(adapter, buffer_info); | ||
943 | } | ||
944 | |||
945 | size = sizeof(struct ixgb_buffer) * tx_ring->count; | ||
946 | memset(tx_ring->buffer_info, 0, size); | ||
947 | |||
948 | /* Zero out the descriptor ring */ | ||
949 | |||
950 | memset(tx_ring->desc, 0, tx_ring->size); | ||
951 | |||
952 | tx_ring->next_to_use = 0; | ||
953 | tx_ring->next_to_clean = 0; | ||
954 | |||
955 | IXGB_WRITE_REG(&adapter->hw, TDH, 0); | ||
956 | IXGB_WRITE_REG(&adapter->hw, TDT, 0); | ||
957 | } | ||
958 | |||
959 | /** | ||
960 | * ixgb_free_rx_resources - Free Rx Resources | ||
961 | * @adapter: board private structure | ||
962 | * | ||
963 | * Free all receive software resources | ||
964 | **/ | ||
965 | |||
966 | void | ||
967 | ixgb_free_rx_resources(struct ixgb_adapter *adapter) | ||
968 | { | ||
969 | struct ixgb_desc_ring *rx_ring = &adapter->rx_ring; | ||
970 | struct pci_dev *pdev = adapter->pdev; | ||
971 | |||
972 | ixgb_clean_rx_ring(adapter); | ||
973 | |||
974 | vfree(rx_ring->buffer_info); | ||
975 | rx_ring->buffer_info = NULL; | ||
976 | |||
977 | dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc, | ||
978 | rx_ring->dma); | ||
979 | |||
980 | rx_ring->desc = NULL; | ||
981 | } | ||
982 | |||
983 | /** | ||
984 | * ixgb_clean_rx_ring - Free Rx Buffers | ||
985 | * @adapter: board private structure | ||
986 | **/ | ||
987 | |||
988 | static void | ||
989 | ixgb_clean_rx_ring(struct ixgb_adapter *adapter) | ||
990 | { | ||
991 | struct ixgb_desc_ring *rx_ring = &adapter->rx_ring; | ||
992 | struct ixgb_buffer *buffer_info; | ||
993 | struct pci_dev *pdev = adapter->pdev; | ||
994 | unsigned long size; | ||
995 | unsigned int i; | ||
996 | |||
997 | /* Free all the Rx ring sk_buffs */ | ||
998 | |||
999 | for (i = 0; i < rx_ring->count; i++) { | ||
1000 | buffer_info = &rx_ring->buffer_info[i]; | ||
1001 | if (buffer_info->dma) { | ||
1002 | dma_unmap_single(&pdev->dev, | ||
1003 | buffer_info->dma, | ||
1004 | buffer_info->length, | ||
1005 | DMA_FROM_DEVICE); | ||
1006 | buffer_info->dma = 0; | ||
1007 | buffer_info->length = 0; | ||
1008 | } | ||
1009 | |||
1010 | if (buffer_info->skb) { | ||
1011 | dev_kfree_skb(buffer_info->skb); | ||
1012 | buffer_info->skb = NULL; | ||
1013 | } | ||
1014 | } | ||
1015 | |||
1016 | size = sizeof(struct ixgb_buffer) * rx_ring->count; | ||
1017 | memset(rx_ring->buffer_info, 0, size); | ||
1018 | |||
1019 | /* Zero out the descriptor ring */ | ||
1020 | |||
1021 | memset(rx_ring->desc, 0, rx_ring->size); | ||
1022 | |||
1023 | rx_ring->next_to_clean = 0; | ||
1024 | rx_ring->next_to_use = 0; | ||
1025 | |||
1026 | IXGB_WRITE_REG(&adapter->hw, RDH, 0); | ||
1027 | IXGB_WRITE_REG(&adapter->hw, RDT, 0); | ||
1028 | } | ||
1029 | |||
1030 | /** | ||
1031 | * ixgb_set_mac - Change the Ethernet Address of the NIC | ||
1032 | * @netdev: network interface device structure | ||
1033 | * @p: pointer to an address structure | ||
1034 | * | ||
1035 | * Returns 0 on success, negative on failure | ||
1036 | **/ | ||
1037 | |||
1038 | static int | ||
1039 | ixgb_set_mac(struct net_device *netdev, void *p) | ||
1040 | { | ||
1041 | struct ixgb_adapter *adapter = netdev_priv(netdev); | ||
1042 | struct sockaddr *addr = p; | ||
1043 | |||
1044 | if (!is_valid_ether_addr(addr->sa_data)) | ||
1045 | return -EADDRNOTAVAIL; | ||
1046 | |||
1047 | memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len); | ||
1048 | |||
1049 | ixgb_rar_set(&adapter->hw, addr->sa_data, 0); | ||
1050 | |||
1051 | return 0; | ||
1052 | } | ||
1053 | |||
1054 | /** | ||
1055 | * ixgb_set_multi - Multicast and Promiscuous mode set | ||
1056 | * @netdev: network interface device structure | ||
1057 | * | ||
1058 | * The set_multi entry point is called whenever the multicast address | ||
1059 | * list or the network interface flags are updated. This routine is | ||
1060 | * responsible for configuring the hardware for proper multicast, | ||
1061 | * promiscuous mode, and all-multi behavior. | ||
1062 | **/ | ||
1063 | |||
1064 | static void | ||
1065 | ixgb_set_multi(struct net_device *netdev) | ||
1066 | { | ||
1067 | struct ixgb_adapter *adapter = netdev_priv(netdev); | ||
1068 | struct ixgb_hw *hw = &adapter->hw; | ||
1069 | struct netdev_hw_addr *ha; | ||
1070 | u32 rctl; | ||
1071 | int i; | ||
1072 | |||
1073 | /* Check for Promiscuous and All Multicast modes */ | ||
1074 | |||
1075 | rctl = IXGB_READ_REG(hw, RCTL); | ||
1076 | |||
1077 | if (netdev->flags & IFF_PROMISC) { | ||
1078 | rctl |= (IXGB_RCTL_UPE | IXGB_RCTL_MPE); | ||
1079 | /* disable VLAN filtering */ | ||
1080 | rctl &= ~IXGB_RCTL_CFIEN; | ||
1081 | rctl &= ~IXGB_RCTL_VFE; | ||
1082 | } else { | ||
1083 | if (netdev->flags & IFF_ALLMULTI) { | ||
1084 | rctl |= IXGB_RCTL_MPE; | ||
1085 | rctl &= ~IXGB_RCTL_UPE; | ||
1086 | } else { | ||
1087 | rctl &= ~(IXGB_RCTL_UPE | IXGB_RCTL_MPE); | ||
1088 | } | ||
1089 | /* enable VLAN filtering */ | ||
1090 | rctl |= IXGB_RCTL_VFE; | ||
1091 | rctl &= ~IXGB_RCTL_CFIEN; | ||
1092 | } | ||
1093 | |||
1094 | if (netdev_mc_count(netdev) > IXGB_MAX_NUM_MULTICAST_ADDRESSES) { | ||
1095 | rctl |= IXGB_RCTL_MPE; | ||
1096 | IXGB_WRITE_REG(hw, RCTL, rctl); | ||
1097 | } else { | ||
1098 | u8 mta[IXGB_MAX_NUM_MULTICAST_ADDRESSES * | ||
1099 | IXGB_ETH_LENGTH_OF_ADDRESS]; | ||
1100 | |||
1101 | IXGB_WRITE_REG(hw, RCTL, rctl); | ||
1102 | |||
1103 | i = 0; | ||
1104 | netdev_for_each_mc_addr(ha, netdev) | ||
1105 | memcpy(&mta[i++ * IXGB_ETH_LENGTH_OF_ADDRESS], | ||
1106 | ha->addr, IXGB_ETH_LENGTH_OF_ADDRESS); | ||
1107 | |||
1108 | ixgb_mc_addr_list_update(hw, mta, netdev_mc_count(netdev), 0); | ||
1109 | } | ||
1110 | |||
1111 | if (netdev->features & NETIF_F_HW_VLAN_RX) | ||
1112 | ixgb_vlan_strip_enable(adapter); | ||
1113 | else | ||
1114 | ixgb_vlan_strip_disable(adapter); | ||
1115 | |||
1116 | } | ||
1117 | |||
1118 | /** | ||
1119 | * ixgb_watchdog - Timer Call-back | ||
1120 | * @data: pointer to netdev cast into an unsigned long | ||
1121 | **/ | ||
1122 | |||
1123 | static void | ||
1124 | ixgb_watchdog(unsigned long data) | ||
1125 | { | ||
1126 | struct ixgb_adapter *adapter = (struct ixgb_adapter *)data; | ||
1127 | struct net_device *netdev = adapter->netdev; | ||
1128 | struct ixgb_desc_ring *txdr = &adapter->tx_ring; | ||
1129 | |||
1130 | ixgb_check_for_link(&adapter->hw); | ||
1131 | |||
1132 | if (ixgb_check_for_bad_link(&adapter->hw)) { | ||
1133 | /* force the reset path */ | ||
1134 | netif_stop_queue(netdev); | ||
1135 | } | ||
1136 | |||
1137 | if (adapter->hw.link_up) { | ||
1138 | if (!netif_carrier_ok(netdev)) { | ||
1139 | netdev_info(netdev, | ||
1140 | "NIC Link is Up 10 Gbps Full Duplex, Flow Control: %s\n", | ||
1141 | (adapter->hw.fc.type == ixgb_fc_full) ? | ||
1142 | "RX/TX" : | ||
1143 | (adapter->hw.fc.type == ixgb_fc_rx_pause) ? | ||
1144 | "RX" : | ||
1145 | (adapter->hw.fc.type == ixgb_fc_tx_pause) ? | ||
1146 | "TX" : "None"); | ||
1147 | adapter->link_speed = 10000; | ||
1148 | adapter->link_duplex = FULL_DUPLEX; | ||
1149 | netif_carrier_on(netdev); | ||
1150 | } | ||
1151 | } else { | ||
1152 | if (netif_carrier_ok(netdev)) { | ||
1153 | adapter->link_speed = 0; | ||
1154 | adapter->link_duplex = 0; | ||
1155 | netdev_info(netdev, "NIC Link is Down\n"); | ||
1156 | netif_carrier_off(netdev); | ||
1157 | } | ||
1158 | } | ||
1159 | |||
1160 | ixgb_update_stats(adapter); | ||
1161 | |||
1162 | if (!netif_carrier_ok(netdev)) { | ||
1163 | if (IXGB_DESC_UNUSED(txdr) + 1 < txdr->count) { | ||
1164 | /* We've lost link, so the controller stops DMA, | ||
1165 | * but we've got queued Tx work that's never going | ||
1166 | * to get done, so reset controller to flush Tx. | ||
1167 | * (Do the reset outside of interrupt context). */ | ||
1168 | schedule_work(&adapter->tx_timeout_task); | ||
1169 | /* return immediately since reset is imminent */ | ||
1170 | return; | ||
1171 | } | ||
1172 | } | ||
1173 | |||
1174 | /* Force detection of hung controller every watchdog period */ | ||
1175 | adapter->detect_tx_hung = true; | ||
1176 | |||
1177 | /* generate an interrupt to force clean up of any stragglers */ | ||
1178 | IXGB_WRITE_REG(&adapter->hw, ICS, IXGB_INT_TXDW); | ||
1179 | |||
1180 | /* Reset the timer */ | ||
1181 | mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ); | ||
1182 | } | ||
1183 | |||
1184 | #define IXGB_TX_FLAGS_CSUM 0x00000001 | ||
1185 | #define IXGB_TX_FLAGS_VLAN 0x00000002 | ||
1186 | #define IXGB_TX_FLAGS_TSO 0x00000004 | ||
1187 | |||
1188 | static int | ||
1189 | ixgb_tso(struct ixgb_adapter *adapter, struct sk_buff *skb) | ||
1190 | { | ||
1191 | struct ixgb_context_desc *context_desc; | ||
1192 | unsigned int i; | ||
1193 | u8 ipcss, ipcso, tucss, tucso, hdr_len; | ||
1194 | u16 ipcse, tucse, mss; | ||
1195 | int err; | ||
1196 | |||
1197 | if (likely(skb_is_gso(skb))) { | ||
1198 | struct ixgb_buffer *buffer_info; | ||
1199 | struct iphdr *iph; | ||
1200 | |||
1201 | if (skb_header_cloned(skb)) { | ||
1202 | err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC); | ||
1203 | if (err) | ||
1204 | return err; | ||
1205 | } | ||
1206 | |||
1207 | hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb); | ||
1208 | mss = skb_shinfo(skb)->gso_size; | ||
1209 | iph = ip_hdr(skb); | ||
1210 | iph->tot_len = 0; | ||
1211 | iph->check = 0; | ||
1212 | tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr, | ||
1213 | iph->daddr, 0, | ||
1214 | IPPROTO_TCP, 0); | ||
1215 | ipcss = skb_network_offset(skb); | ||
1216 | ipcso = (void *)&(iph->check) - (void *)skb->data; | ||
1217 | ipcse = skb_transport_offset(skb) - 1; | ||
1218 | tucss = skb_transport_offset(skb); | ||
1219 | tucso = (void *)&(tcp_hdr(skb)->check) - (void *)skb->data; | ||
1220 | tucse = 0; | ||
1221 | |||
1222 | i = adapter->tx_ring.next_to_use; | ||
1223 | context_desc = IXGB_CONTEXT_DESC(adapter->tx_ring, i); | ||
1224 | buffer_info = &adapter->tx_ring.buffer_info[i]; | ||
1225 | WARN_ON(buffer_info->dma != 0); | ||
1226 | |||
1227 | context_desc->ipcss = ipcss; | ||
1228 | context_desc->ipcso = ipcso; | ||
1229 | context_desc->ipcse = cpu_to_le16(ipcse); | ||
1230 | context_desc->tucss = tucss; | ||
1231 | context_desc->tucso = tucso; | ||
1232 | context_desc->tucse = cpu_to_le16(tucse); | ||
1233 | context_desc->mss = cpu_to_le16(mss); | ||
1234 | context_desc->hdr_len = hdr_len; | ||
1235 | context_desc->status = 0; | ||
1236 | context_desc->cmd_type_len = cpu_to_le32( | ||
1237 | IXGB_CONTEXT_DESC_TYPE | ||
1238 | | IXGB_CONTEXT_DESC_CMD_TSE | ||
1239 | | IXGB_CONTEXT_DESC_CMD_IP | ||
1240 | | IXGB_CONTEXT_DESC_CMD_TCP | ||
1241 | | IXGB_CONTEXT_DESC_CMD_IDE | ||
1242 | | (skb->len - (hdr_len))); | ||
1243 | |||
1244 | |||
1245 | if (++i == adapter->tx_ring.count) i = 0; | ||
1246 | adapter->tx_ring.next_to_use = i; | ||
1247 | |||
1248 | return 1; | ||
1249 | } | ||
1250 | |||
1251 | return 0; | ||
1252 | } | ||
1253 | |||
1254 | static bool | ||
1255 | ixgb_tx_csum(struct ixgb_adapter *adapter, struct sk_buff *skb) | ||
1256 | { | ||
1257 | struct ixgb_context_desc *context_desc; | ||
1258 | unsigned int i; | ||
1259 | u8 css, cso; | ||
1260 | |||
1261 | if (likely(skb->ip_summed == CHECKSUM_PARTIAL)) { | ||
1262 | struct ixgb_buffer *buffer_info; | ||
1263 | css = skb_checksum_start_offset(skb); | ||
1264 | cso = css + skb->csum_offset; | ||
1265 | |||
1266 | i = adapter->tx_ring.next_to_use; | ||
1267 | context_desc = IXGB_CONTEXT_DESC(adapter->tx_ring, i); | ||
1268 | buffer_info = &adapter->tx_ring.buffer_info[i]; | ||
1269 | WARN_ON(buffer_info->dma != 0); | ||
1270 | |||
1271 | context_desc->tucss = css; | ||
1272 | context_desc->tucso = cso; | ||
1273 | context_desc->tucse = 0; | ||
1274 | /* zero out any previously existing data in one instruction */ | ||
1275 | *(u32 *)&(context_desc->ipcss) = 0; | ||
1276 | context_desc->status = 0; | ||
1277 | context_desc->hdr_len = 0; | ||
1278 | context_desc->mss = 0; | ||
1279 | context_desc->cmd_type_len = | ||
1280 | cpu_to_le32(IXGB_CONTEXT_DESC_TYPE | ||
1281 | | IXGB_TX_DESC_CMD_IDE); | ||
1282 | |||
1283 | if (++i == adapter->tx_ring.count) i = 0; | ||
1284 | adapter->tx_ring.next_to_use = i; | ||
1285 | |||
1286 | return true; | ||
1287 | } | ||
1288 | |||
1289 | return false; | ||
1290 | } | ||
1291 | |||
1292 | #define IXGB_MAX_TXD_PWR 14 | ||
1293 | #define IXGB_MAX_DATA_PER_TXD (1<<IXGB_MAX_TXD_PWR) | ||
1294 | |||
1295 | static int | ||
1296 | ixgb_tx_map(struct ixgb_adapter *adapter, struct sk_buff *skb, | ||
1297 | unsigned int first) | ||
1298 | { | ||
1299 | struct ixgb_desc_ring *tx_ring = &adapter->tx_ring; | ||
1300 | struct pci_dev *pdev = adapter->pdev; | ||
1301 | struct ixgb_buffer *buffer_info; | ||
1302 | int len = skb_headlen(skb); | ||
1303 | unsigned int offset = 0, size, count = 0, i; | ||
1304 | unsigned int mss = skb_shinfo(skb)->gso_size; | ||
1305 | unsigned int nr_frags = skb_shinfo(skb)->nr_frags; | ||
1306 | unsigned int f; | ||
1307 | |||
1308 | i = tx_ring->next_to_use; | ||
1309 | |||
1310 | while (len) { | ||
1311 | buffer_info = &tx_ring->buffer_info[i]; | ||
1312 | size = min(len, IXGB_MAX_DATA_PER_TXD); | ||
1313 | /* Workaround for premature desc write-backs | ||
1314 | * in TSO mode. Append 4-byte sentinel desc */ | ||
1315 | if (unlikely(mss && !nr_frags && size == len && size > 8)) | ||
1316 | size -= 4; | ||
1317 | |||
1318 | buffer_info->length = size; | ||
1319 | WARN_ON(buffer_info->dma != 0); | ||
1320 | buffer_info->time_stamp = jiffies; | ||
1321 | buffer_info->mapped_as_page = false; | ||
1322 | buffer_info->dma = dma_map_single(&pdev->dev, | ||
1323 | skb->data + offset, | ||
1324 | size, DMA_TO_DEVICE); | ||
1325 | if (dma_mapping_error(&pdev->dev, buffer_info->dma)) | ||
1326 | goto dma_error; | ||
1327 | buffer_info->next_to_watch = 0; | ||
1328 | |||
1329 | len -= size; | ||
1330 | offset += size; | ||
1331 | count++; | ||
1332 | if (len) { | ||
1333 | i++; | ||
1334 | if (i == tx_ring->count) | ||
1335 | i = 0; | ||
1336 | } | ||
1337 | } | ||
1338 | |||
1339 | for (f = 0; f < nr_frags; f++) { | ||
1340 | struct skb_frag_struct *frag; | ||
1341 | |||
1342 | frag = &skb_shinfo(skb)->frags[f]; | ||
1343 | len = frag->size; | ||
1344 | offset = frag->page_offset; | ||
1345 | |||
1346 | while (len) { | ||
1347 | i++; | ||
1348 | if (i == tx_ring->count) | ||
1349 | i = 0; | ||
1350 | |||
1351 | buffer_info = &tx_ring->buffer_info[i]; | ||
1352 | size = min(len, IXGB_MAX_DATA_PER_TXD); | ||
1353 | |||
1354 | /* Workaround for premature desc write-backs | ||
1355 | * in TSO mode. Append 4-byte sentinel desc */ | ||
1356 | if (unlikely(mss && (f == (nr_frags - 1)) | ||
1357 | && size == len && size > 8)) | ||
1358 | size -= 4; | ||
1359 | |||
1360 | buffer_info->length = size; | ||
1361 | buffer_info->time_stamp = jiffies; | ||
1362 | buffer_info->mapped_as_page = true; | ||
1363 | buffer_info->dma = | ||
1364 | dma_map_page(&pdev->dev, frag->page, | ||
1365 | offset, size, DMA_TO_DEVICE); | ||
1366 | if (dma_mapping_error(&pdev->dev, buffer_info->dma)) | ||
1367 | goto dma_error; | ||
1368 | buffer_info->next_to_watch = 0; | ||
1369 | |||
1370 | len -= size; | ||
1371 | offset += size; | ||
1372 | count++; | ||
1373 | } | ||
1374 | } | ||
1375 | tx_ring->buffer_info[i].skb = skb; | ||
1376 | tx_ring->buffer_info[first].next_to_watch = i; | ||
1377 | |||
1378 | return count; | ||
1379 | |||
1380 | dma_error: | ||
1381 | dev_err(&pdev->dev, "TX DMA map failed\n"); | ||
1382 | buffer_info->dma = 0; | ||
1383 | if (count) | ||
1384 | count--; | ||
1385 | |||
1386 | while (count--) { | ||
1387 | if (i==0) | ||
1388 | i += tx_ring->count; | ||
1389 | i--; | ||
1390 | buffer_info = &tx_ring->buffer_info[i]; | ||
1391 | ixgb_unmap_and_free_tx_resource(adapter, buffer_info); | ||
1392 | } | ||
1393 | |||
1394 | return 0; | ||
1395 | } | ||
1396 | |||
1397 | static void | ||
1398 | ixgb_tx_queue(struct ixgb_adapter *adapter, int count, int vlan_id,int tx_flags) | ||
1399 | { | ||
1400 | struct ixgb_desc_ring *tx_ring = &adapter->tx_ring; | ||
1401 | struct ixgb_tx_desc *tx_desc = NULL; | ||
1402 | struct ixgb_buffer *buffer_info; | ||
1403 | u32 cmd_type_len = adapter->tx_cmd_type; | ||
1404 | u8 status = 0; | ||
1405 | u8 popts = 0; | ||
1406 | unsigned int i; | ||
1407 | |||
1408 | if (tx_flags & IXGB_TX_FLAGS_TSO) { | ||
1409 | cmd_type_len |= IXGB_TX_DESC_CMD_TSE; | ||
1410 | popts |= (IXGB_TX_DESC_POPTS_IXSM | IXGB_TX_DESC_POPTS_TXSM); | ||
1411 | } | ||
1412 | |||
1413 | if (tx_flags & IXGB_TX_FLAGS_CSUM) | ||
1414 | popts |= IXGB_TX_DESC_POPTS_TXSM; | ||
1415 | |||
1416 | if (tx_flags & IXGB_TX_FLAGS_VLAN) | ||
1417 | cmd_type_len |= IXGB_TX_DESC_CMD_VLE; | ||
1418 | |||
1419 | i = tx_ring->next_to_use; | ||
1420 | |||
1421 | while (count--) { | ||
1422 | buffer_info = &tx_ring->buffer_info[i]; | ||
1423 | tx_desc = IXGB_TX_DESC(*tx_ring, i); | ||
1424 | tx_desc->buff_addr = cpu_to_le64(buffer_info->dma); | ||
1425 | tx_desc->cmd_type_len = | ||
1426 | cpu_to_le32(cmd_type_len | buffer_info->length); | ||
1427 | tx_desc->status = status; | ||
1428 | tx_desc->popts = popts; | ||
1429 | tx_desc->vlan = cpu_to_le16(vlan_id); | ||
1430 | |||
1431 | if (++i == tx_ring->count) i = 0; | ||
1432 | } | ||
1433 | |||
1434 | tx_desc->cmd_type_len |= | ||
1435 | cpu_to_le32(IXGB_TX_DESC_CMD_EOP | IXGB_TX_DESC_CMD_RS); | ||
1436 | |||
1437 | /* Force memory writes to complete before letting h/w | ||
1438 | * know there are new descriptors to fetch. (Only | ||
1439 | * applicable for weak-ordered memory model archs, | ||
1440 | * such as IA-64). */ | ||
1441 | wmb(); | ||
1442 | |||
1443 | tx_ring->next_to_use = i; | ||
1444 | IXGB_WRITE_REG(&adapter->hw, TDT, i); | ||
1445 | } | ||
1446 | |||
1447 | static int __ixgb_maybe_stop_tx(struct net_device *netdev, int size) | ||
1448 | { | ||
1449 | struct ixgb_adapter *adapter = netdev_priv(netdev); | ||
1450 | struct ixgb_desc_ring *tx_ring = &adapter->tx_ring; | ||
1451 | |||
1452 | netif_stop_queue(netdev); | ||
1453 | /* Herbert's original patch had: | ||
1454 | * smp_mb__after_netif_stop_queue(); | ||
1455 | * but since that doesn't exist yet, just open code it. */ | ||
1456 | smp_mb(); | ||
1457 | |||
1458 | /* We need to check again in a case another CPU has just | ||
1459 | * made room available. */ | ||
1460 | if (likely(IXGB_DESC_UNUSED(tx_ring) < size)) | ||
1461 | return -EBUSY; | ||
1462 | |||
1463 | /* A reprieve! */ | ||
1464 | netif_start_queue(netdev); | ||
1465 | ++adapter->restart_queue; | ||
1466 | return 0; | ||
1467 | } | ||
1468 | |||
1469 | static int ixgb_maybe_stop_tx(struct net_device *netdev, | ||
1470 | struct ixgb_desc_ring *tx_ring, int size) | ||
1471 | { | ||
1472 | if (likely(IXGB_DESC_UNUSED(tx_ring) >= size)) | ||
1473 | return 0; | ||
1474 | return __ixgb_maybe_stop_tx(netdev, size); | ||
1475 | } | ||
1476 | |||
1477 | |||
1478 | /* Tx Descriptors needed, worst case */ | ||
1479 | #define TXD_USE_COUNT(S) (((S) >> IXGB_MAX_TXD_PWR) + \ | ||
1480 | (((S) & (IXGB_MAX_DATA_PER_TXD - 1)) ? 1 : 0)) | ||
1481 | #define DESC_NEEDED TXD_USE_COUNT(IXGB_MAX_DATA_PER_TXD) /* skb->date */ + \ | ||
1482 | MAX_SKB_FRAGS * TXD_USE_COUNT(PAGE_SIZE) + 1 /* for context */ \ | ||
1483 | + 1 /* one more needed for sentinel TSO workaround */ | ||
1484 | |||
1485 | static netdev_tx_t | ||
1486 | ixgb_xmit_frame(struct sk_buff *skb, struct net_device *netdev) | ||
1487 | { | ||
1488 | struct ixgb_adapter *adapter = netdev_priv(netdev); | ||
1489 | unsigned int first; | ||
1490 | unsigned int tx_flags = 0; | ||
1491 | int vlan_id = 0; | ||
1492 | int count = 0; | ||
1493 | int tso; | ||
1494 | |||
1495 | if (test_bit(__IXGB_DOWN, &adapter->flags)) { | ||
1496 | dev_kfree_skb(skb); | ||
1497 | return NETDEV_TX_OK; | ||
1498 | } | ||
1499 | |||
1500 | if (skb->len <= 0) { | ||
1501 | dev_kfree_skb(skb); | ||
1502 | return NETDEV_TX_OK; | ||
1503 | } | ||
1504 | |||
1505 | if (unlikely(ixgb_maybe_stop_tx(netdev, &adapter->tx_ring, | ||
1506 | DESC_NEEDED))) | ||
1507 | return NETDEV_TX_BUSY; | ||
1508 | |||
1509 | if (vlan_tx_tag_present(skb)) { | ||
1510 | tx_flags |= IXGB_TX_FLAGS_VLAN; | ||
1511 | vlan_id = vlan_tx_tag_get(skb); | ||
1512 | } | ||
1513 | |||
1514 | first = adapter->tx_ring.next_to_use; | ||
1515 | |||
1516 | tso = ixgb_tso(adapter, skb); | ||
1517 | if (tso < 0) { | ||
1518 | dev_kfree_skb(skb); | ||
1519 | return NETDEV_TX_OK; | ||
1520 | } | ||
1521 | |||
1522 | if (likely(tso)) | ||
1523 | tx_flags |= IXGB_TX_FLAGS_TSO; | ||
1524 | else if (ixgb_tx_csum(adapter, skb)) | ||
1525 | tx_flags |= IXGB_TX_FLAGS_CSUM; | ||
1526 | |||
1527 | count = ixgb_tx_map(adapter, skb, first); | ||
1528 | |||
1529 | if (count) { | ||
1530 | ixgb_tx_queue(adapter, count, vlan_id, tx_flags); | ||
1531 | /* Make sure there is space in the ring for the next send. */ | ||
1532 | ixgb_maybe_stop_tx(netdev, &adapter->tx_ring, DESC_NEEDED); | ||
1533 | |||
1534 | } else { | ||
1535 | dev_kfree_skb_any(skb); | ||
1536 | adapter->tx_ring.buffer_info[first].time_stamp = 0; | ||
1537 | adapter->tx_ring.next_to_use = first; | ||
1538 | } | ||
1539 | |||
1540 | return NETDEV_TX_OK; | ||
1541 | } | ||
1542 | |||
1543 | /** | ||
1544 | * ixgb_tx_timeout - Respond to a Tx Hang | ||
1545 | * @netdev: network interface device structure | ||
1546 | **/ | ||
1547 | |||
1548 | static void | ||
1549 | ixgb_tx_timeout(struct net_device *netdev) | ||
1550 | { | ||
1551 | struct ixgb_adapter *adapter = netdev_priv(netdev); | ||
1552 | |||
1553 | /* Do the reset outside of interrupt context */ | ||
1554 | schedule_work(&adapter->tx_timeout_task); | ||
1555 | } | ||
1556 | |||
1557 | static void | ||
1558 | ixgb_tx_timeout_task(struct work_struct *work) | ||
1559 | { | ||
1560 | struct ixgb_adapter *adapter = | ||
1561 | container_of(work, struct ixgb_adapter, tx_timeout_task); | ||
1562 | |||
1563 | adapter->tx_timeout_count++; | ||
1564 | ixgb_down(adapter, true); | ||
1565 | ixgb_up(adapter); | ||
1566 | } | ||
1567 | |||
1568 | /** | ||
1569 | * ixgb_get_stats - Get System Network Statistics | ||
1570 | * @netdev: network interface device structure | ||
1571 | * | ||
1572 | * Returns the address of the device statistics structure. | ||
1573 | * The statistics are actually updated from the timer callback. | ||
1574 | **/ | ||
1575 | |||
1576 | static struct net_device_stats * | ||
1577 | ixgb_get_stats(struct net_device *netdev) | ||
1578 | { | ||
1579 | return &netdev->stats; | ||
1580 | } | ||
1581 | |||
1582 | /** | ||
1583 | * ixgb_change_mtu - Change the Maximum Transfer Unit | ||
1584 | * @netdev: network interface device structure | ||
1585 | * @new_mtu: new value for maximum frame size | ||
1586 | * | ||
1587 | * Returns 0 on success, negative on failure | ||
1588 | **/ | ||
1589 | |||
1590 | static int | ||
1591 | ixgb_change_mtu(struct net_device *netdev, int new_mtu) | ||
1592 | { | ||
1593 | struct ixgb_adapter *adapter = netdev_priv(netdev); | ||
1594 | int max_frame = new_mtu + ENET_HEADER_SIZE + ENET_FCS_LENGTH; | ||
1595 | int old_max_frame = netdev->mtu + ENET_HEADER_SIZE + ENET_FCS_LENGTH; | ||
1596 | |||
1597 | /* MTU < 68 is an error for IPv4 traffic, just don't allow it */ | ||
1598 | if ((new_mtu < 68) || | ||
1599 | (max_frame > IXGB_MAX_JUMBO_FRAME_SIZE + ENET_FCS_LENGTH)) { | ||
1600 | netif_err(adapter, probe, adapter->netdev, | ||
1601 | "Invalid MTU setting %d\n", new_mtu); | ||
1602 | return -EINVAL; | ||
1603 | } | ||
1604 | |||
1605 | if (old_max_frame == max_frame) | ||
1606 | return 0; | ||
1607 | |||
1608 | if (netif_running(netdev)) | ||
1609 | ixgb_down(adapter, true); | ||
1610 | |||
1611 | adapter->rx_buffer_len = max_frame + 8; /* + 8 for errata */ | ||
1612 | |||
1613 | netdev->mtu = new_mtu; | ||
1614 | |||
1615 | if (netif_running(netdev)) | ||
1616 | ixgb_up(adapter); | ||
1617 | |||
1618 | return 0; | ||
1619 | } | ||
1620 | |||
1621 | /** | ||
1622 | * ixgb_update_stats - Update the board statistics counters. | ||
1623 | * @adapter: board private structure | ||
1624 | **/ | ||
1625 | |||
1626 | void | ||
1627 | ixgb_update_stats(struct ixgb_adapter *adapter) | ||
1628 | { | ||
1629 | struct net_device *netdev = adapter->netdev; | ||
1630 | struct pci_dev *pdev = adapter->pdev; | ||
1631 | |||
1632 | /* Prevent stats update while adapter is being reset */ | ||
1633 | if (pci_channel_offline(pdev)) | ||
1634 | return; | ||
1635 | |||
1636 | if ((netdev->flags & IFF_PROMISC) || (netdev->flags & IFF_ALLMULTI) || | ||
1637 | (netdev_mc_count(netdev) > IXGB_MAX_NUM_MULTICAST_ADDRESSES)) { | ||
1638 | u64 multi = IXGB_READ_REG(&adapter->hw, MPRCL); | ||
1639 | u32 bcast_l = IXGB_READ_REG(&adapter->hw, BPRCL); | ||
1640 | u32 bcast_h = IXGB_READ_REG(&adapter->hw, BPRCH); | ||
1641 | u64 bcast = ((u64)bcast_h << 32) | bcast_l; | ||
1642 | |||
1643 | multi |= ((u64)IXGB_READ_REG(&adapter->hw, MPRCH) << 32); | ||
1644 | /* fix up multicast stats by removing broadcasts */ | ||
1645 | if (multi >= bcast) | ||
1646 | multi -= bcast; | ||
1647 | |||
1648 | adapter->stats.mprcl += (multi & 0xFFFFFFFF); | ||
1649 | adapter->stats.mprch += (multi >> 32); | ||
1650 | adapter->stats.bprcl += bcast_l; | ||
1651 | adapter->stats.bprch += bcast_h; | ||
1652 | } else { | ||
1653 | adapter->stats.mprcl += IXGB_READ_REG(&adapter->hw, MPRCL); | ||
1654 | adapter->stats.mprch += IXGB_READ_REG(&adapter->hw, MPRCH); | ||
1655 | adapter->stats.bprcl += IXGB_READ_REG(&adapter->hw, BPRCL); | ||
1656 | adapter->stats.bprch += IXGB_READ_REG(&adapter->hw, BPRCH); | ||
1657 | } | ||
1658 | adapter->stats.tprl += IXGB_READ_REG(&adapter->hw, TPRL); | ||
1659 | adapter->stats.tprh += IXGB_READ_REG(&adapter->hw, TPRH); | ||
1660 | adapter->stats.gprcl += IXGB_READ_REG(&adapter->hw, GPRCL); | ||
1661 | adapter->stats.gprch += IXGB_READ_REG(&adapter->hw, GPRCH); | ||
1662 | adapter->stats.uprcl += IXGB_READ_REG(&adapter->hw, UPRCL); | ||
1663 | adapter->stats.uprch += IXGB_READ_REG(&adapter->hw, UPRCH); | ||
1664 | adapter->stats.vprcl += IXGB_READ_REG(&adapter->hw, VPRCL); | ||
1665 | adapter->stats.vprch += IXGB_READ_REG(&adapter->hw, VPRCH); | ||
1666 | adapter->stats.jprcl += IXGB_READ_REG(&adapter->hw, JPRCL); | ||
1667 | adapter->stats.jprch += IXGB_READ_REG(&adapter->hw, JPRCH); | ||
1668 | adapter->stats.gorcl += IXGB_READ_REG(&adapter->hw, GORCL); | ||
1669 | adapter->stats.gorch += IXGB_READ_REG(&adapter->hw, GORCH); | ||
1670 | adapter->stats.torl += IXGB_READ_REG(&adapter->hw, TORL); | ||
1671 | adapter->stats.torh += IXGB_READ_REG(&adapter->hw, TORH); | ||
1672 | adapter->stats.rnbc += IXGB_READ_REG(&adapter->hw, RNBC); | ||
1673 | adapter->stats.ruc += IXGB_READ_REG(&adapter->hw, RUC); | ||
1674 | adapter->stats.roc += IXGB_READ_REG(&adapter->hw, ROC); | ||
1675 | adapter->stats.rlec += IXGB_READ_REG(&adapter->hw, RLEC); | ||
1676 | adapter->stats.crcerrs += IXGB_READ_REG(&adapter->hw, CRCERRS); | ||
1677 | adapter->stats.icbc += IXGB_READ_REG(&adapter->hw, ICBC); | ||
1678 | adapter->stats.ecbc += IXGB_READ_REG(&adapter->hw, ECBC); | ||
1679 | adapter->stats.mpc += IXGB_READ_REG(&adapter->hw, MPC); | ||
1680 | adapter->stats.tptl += IXGB_READ_REG(&adapter->hw, TPTL); | ||
1681 | adapter->stats.tpth += IXGB_READ_REG(&adapter->hw, TPTH); | ||
1682 | adapter->stats.gptcl += IXGB_READ_REG(&adapter->hw, GPTCL); | ||
1683 | adapter->stats.gptch += IXGB_READ_REG(&adapter->hw, GPTCH); | ||
1684 | adapter->stats.bptcl += IXGB_READ_REG(&adapter->hw, BPTCL); | ||
1685 | adapter->stats.bptch += IXGB_READ_REG(&adapter->hw, BPTCH); | ||
1686 | adapter->stats.mptcl += IXGB_READ_REG(&adapter->hw, MPTCL); | ||
1687 | adapter->stats.mptch += IXGB_READ_REG(&adapter->hw, MPTCH); | ||
1688 | adapter->stats.uptcl += IXGB_READ_REG(&adapter->hw, UPTCL); | ||
1689 | adapter->stats.uptch += IXGB_READ_REG(&adapter->hw, UPTCH); | ||
1690 | adapter->stats.vptcl += IXGB_READ_REG(&adapter->hw, VPTCL); | ||
1691 | adapter->stats.vptch += IXGB_READ_REG(&adapter->hw, VPTCH); | ||
1692 | adapter->stats.jptcl += IXGB_READ_REG(&adapter->hw, JPTCL); | ||
1693 | adapter->stats.jptch += IXGB_READ_REG(&adapter->hw, JPTCH); | ||
1694 | adapter->stats.gotcl += IXGB_READ_REG(&adapter->hw, GOTCL); | ||
1695 | adapter->stats.gotch += IXGB_READ_REG(&adapter->hw, GOTCH); | ||
1696 | adapter->stats.totl += IXGB_READ_REG(&adapter->hw, TOTL); | ||
1697 | adapter->stats.toth += IXGB_READ_REG(&adapter->hw, TOTH); | ||
1698 | adapter->stats.dc += IXGB_READ_REG(&adapter->hw, DC); | ||
1699 | adapter->stats.plt64c += IXGB_READ_REG(&adapter->hw, PLT64C); | ||
1700 | adapter->stats.tsctc += IXGB_READ_REG(&adapter->hw, TSCTC); | ||
1701 | adapter->stats.tsctfc += IXGB_READ_REG(&adapter->hw, TSCTFC); | ||
1702 | adapter->stats.ibic += IXGB_READ_REG(&adapter->hw, IBIC); | ||
1703 | adapter->stats.rfc += IXGB_READ_REG(&adapter->hw, RFC); | ||
1704 | adapter->stats.lfc += IXGB_READ_REG(&adapter->hw, LFC); | ||
1705 | adapter->stats.pfrc += IXGB_READ_REG(&adapter->hw, PFRC); | ||
1706 | adapter->stats.pftc += IXGB_READ_REG(&adapter->hw, PFTC); | ||
1707 | adapter->stats.mcfrc += IXGB_READ_REG(&adapter->hw, MCFRC); | ||
1708 | adapter->stats.mcftc += IXGB_READ_REG(&adapter->hw, MCFTC); | ||
1709 | adapter->stats.xonrxc += IXGB_READ_REG(&adapter->hw, XONRXC); | ||
1710 | adapter->stats.xontxc += IXGB_READ_REG(&adapter->hw, XONTXC); | ||
1711 | adapter->stats.xoffrxc += IXGB_READ_REG(&adapter->hw, XOFFRXC); | ||
1712 | adapter->stats.xofftxc += IXGB_READ_REG(&adapter->hw, XOFFTXC); | ||
1713 | adapter->stats.rjc += IXGB_READ_REG(&adapter->hw, RJC); | ||
1714 | |||
1715 | /* Fill out the OS statistics structure */ | ||
1716 | |||
1717 | netdev->stats.rx_packets = adapter->stats.gprcl; | ||
1718 | netdev->stats.tx_packets = adapter->stats.gptcl; | ||
1719 | netdev->stats.rx_bytes = adapter->stats.gorcl; | ||
1720 | netdev->stats.tx_bytes = adapter->stats.gotcl; | ||
1721 | netdev->stats.multicast = adapter->stats.mprcl; | ||
1722 | netdev->stats.collisions = 0; | ||
1723 | |||
1724 | /* ignore RLEC as it reports errors for padded (<64bytes) frames | ||
1725 | * with a length in the type/len field */ | ||
1726 | netdev->stats.rx_errors = | ||
1727 | /* adapter->stats.rnbc + */ adapter->stats.crcerrs + | ||
1728 | adapter->stats.ruc + | ||
1729 | adapter->stats.roc /*+ adapter->stats.rlec */ + | ||
1730 | adapter->stats.icbc + | ||
1731 | adapter->stats.ecbc + adapter->stats.mpc; | ||
1732 | |||
1733 | /* see above | ||
1734 | * netdev->stats.rx_length_errors = adapter->stats.rlec; | ||
1735 | */ | ||
1736 | |||
1737 | netdev->stats.rx_crc_errors = adapter->stats.crcerrs; | ||
1738 | netdev->stats.rx_fifo_errors = adapter->stats.mpc; | ||
1739 | netdev->stats.rx_missed_errors = adapter->stats.mpc; | ||
1740 | netdev->stats.rx_over_errors = adapter->stats.mpc; | ||
1741 | |||
1742 | netdev->stats.tx_errors = 0; | ||
1743 | netdev->stats.rx_frame_errors = 0; | ||
1744 | netdev->stats.tx_aborted_errors = 0; | ||
1745 | netdev->stats.tx_carrier_errors = 0; | ||
1746 | netdev->stats.tx_fifo_errors = 0; | ||
1747 | netdev->stats.tx_heartbeat_errors = 0; | ||
1748 | netdev->stats.tx_window_errors = 0; | ||
1749 | } | ||
1750 | |||
1751 | #define IXGB_MAX_INTR 10 | ||
1752 | /** | ||
1753 | * ixgb_intr - Interrupt Handler | ||
1754 | * @irq: interrupt number | ||
1755 | * @data: pointer to a network interface device structure | ||
1756 | **/ | ||
1757 | |||
1758 | static irqreturn_t | ||
1759 | ixgb_intr(int irq, void *data) | ||
1760 | { | ||
1761 | struct net_device *netdev = data; | ||
1762 | struct ixgb_adapter *adapter = netdev_priv(netdev); | ||
1763 | struct ixgb_hw *hw = &adapter->hw; | ||
1764 | u32 icr = IXGB_READ_REG(hw, ICR); | ||
1765 | |||
1766 | if (unlikely(!icr)) | ||
1767 | return IRQ_NONE; /* Not our interrupt */ | ||
1768 | |||
1769 | if (unlikely(icr & (IXGB_INT_RXSEQ | IXGB_INT_LSC))) | ||
1770 | if (!test_bit(__IXGB_DOWN, &adapter->flags)) | ||
1771 | mod_timer(&adapter->watchdog_timer, jiffies); | ||
1772 | |||
1773 | if (napi_schedule_prep(&adapter->napi)) { | ||
1774 | |||
1775 | /* Disable interrupts and register for poll. The flush | ||
1776 | of the posted write is intentionally left out. | ||
1777 | */ | ||
1778 | |||
1779 | IXGB_WRITE_REG(&adapter->hw, IMC, ~0); | ||
1780 | __napi_schedule(&adapter->napi); | ||
1781 | } | ||
1782 | return IRQ_HANDLED; | ||
1783 | } | ||
1784 | |||
1785 | /** | ||
1786 | * ixgb_clean - NAPI Rx polling callback | ||
1787 | * @adapter: board private structure | ||
1788 | **/ | ||
1789 | |||
1790 | static int | ||
1791 | ixgb_clean(struct napi_struct *napi, int budget) | ||
1792 | { | ||
1793 | struct ixgb_adapter *adapter = container_of(napi, struct ixgb_adapter, napi); | ||
1794 | int work_done = 0; | ||
1795 | |||
1796 | ixgb_clean_tx_irq(adapter); | ||
1797 | ixgb_clean_rx_irq(adapter, &work_done, budget); | ||
1798 | |||
1799 | /* If budget not fully consumed, exit the polling mode */ | ||
1800 | if (work_done < budget) { | ||
1801 | napi_complete(napi); | ||
1802 | if (!test_bit(__IXGB_DOWN, &adapter->flags)) | ||
1803 | ixgb_irq_enable(adapter); | ||
1804 | } | ||
1805 | |||
1806 | return work_done; | ||
1807 | } | ||
1808 | |||
1809 | /** | ||
1810 | * ixgb_clean_tx_irq - Reclaim resources after transmit completes | ||
1811 | * @adapter: board private structure | ||
1812 | **/ | ||
1813 | |||
1814 | static bool | ||
1815 | ixgb_clean_tx_irq(struct ixgb_adapter *adapter) | ||
1816 | { | ||
1817 | struct ixgb_desc_ring *tx_ring = &adapter->tx_ring; | ||
1818 | struct net_device *netdev = adapter->netdev; | ||
1819 | struct ixgb_tx_desc *tx_desc, *eop_desc; | ||
1820 | struct ixgb_buffer *buffer_info; | ||
1821 | unsigned int i, eop; | ||
1822 | bool cleaned = false; | ||
1823 | |||
1824 | i = tx_ring->next_to_clean; | ||
1825 | eop = tx_ring->buffer_info[i].next_to_watch; | ||
1826 | eop_desc = IXGB_TX_DESC(*tx_ring, eop); | ||
1827 | |||
1828 | while (eop_desc->status & IXGB_TX_DESC_STATUS_DD) { | ||
1829 | |||
1830 | rmb(); /* read buffer_info after eop_desc */ | ||
1831 | for (cleaned = false; !cleaned; ) { | ||
1832 | tx_desc = IXGB_TX_DESC(*tx_ring, i); | ||
1833 | buffer_info = &tx_ring->buffer_info[i]; | ||
1834 | |||
1835 | if (tx_desc->popts & | ||
1836 | (IXGB_TX_DESC_POPTS_TXSM | | ||
1837 | IXGB_TX_DESC_POPTS_IXSM)) | ||
1838 | adapter->hw_csum_tx_good++; | ||
1839 | |||
1840 | ixgb_unmap_and_free_tx_resource(adapter, buffer_info); | ||
1841 | |||
1842 | *(u32 *)&(tx_desc->status) = 0; | ||
1843 | |||
1844 | cleaned = (i == eop); | ||
1845 | if (++i == tx_ring->count) i = 0; | ||
1846 | } | ||
1847 | |||
1848 | eop = tx_ring->buffer_info[i].next_to_watch; | ||
1849 | eop_desc = IXGB_TX_DESC(*tx_ring, eop); | ||
1850 | } | ||
1851 | |||
1852 | tx_ring->next_to_clean = i; | ||
1853 | |||
1854 | if (unlikely(cleaned && netif_carrier_ok(netdev) && | ||
1855 | IXGB_DESC_UNUSED(tx_ring) >= DESC_NEEDED)) { | ||
1856 | /* Make sure that anybody stopping the queue after this | ||
1857 | * sees the new next_to_clean. */ | ||
1858 | smp_mb(); | ||
1859 | |||
1860 | if (netif_queue_stopped(netdev) && | ||
1861 | !(test_bit(__IXGB_DOWN, &adapter->flags))) { | ||
1862 | netif_wake_queue(netdev); | ||
1863 | ++adapter->restart_queue; | ||
1864 | } | ||
1865 | } | ||
1866 | |||
1867 | if (adapter->detect_tx_hung) { | ||
1868 | /* detect a transmit hang in hardware, this serializes the | ||
1869 | * check with the clearing of time_stamp and movement of i */ | ||
1870 | adapter->detect_tx_hung = false; | ||
1871 | if (tx_ring->buffer_info[eop].time_stamp && | ||
1872 | time_after(jiffies, tx_ring->buffer_info[eop].time_stamp + HZ) | ||
1873 | && !(IXGB_READ_REG(&adapter->hw, STATUS) & | ||
1874 | IXGB_STATUS_TXOFF)) { | ||
1875 | /* detected Tx unit hang */ | ||
1876 | netif_err(adapter, drv, adapter->netdev, | ||
1877 | "Detected Tx Unit Hang\n" | ||
1878 | " TDH <%x>\n" | ||
1879 | " TDT <%x>\n" | ||
1880 | " next_to_use <%x>\n" | ||
1881 | " next_to_clean <%x>\n" | ||
1882 | "buffer_info[next_to_clean]\n" | ||
1883 | " time_stamp <%lx>\n" | ||
1884 | " next_to_watch <%x>\n" | ||
1885 | " jiffies <%lx>\n" | ||
1886 | " next_to_watch.status <%x>\n", | ||
1887 | IXGB_READ_REG(&adapter->hw, TDH), | ||
1888 | IXGB_READ_REG(&adapter->hw, TDT), | ||
1889 | tx_ring->next_to_use, | ||
1890 | tx_ring->next_to_clean, | ||
1891 | tx_ring->buffer_info[eop].time_stamp, | ||
1892 | eop, | ||
1893 | jiffies, | ||
1894 | eop_desc->status); | ||
1895 | netif_stop_queue(netdev); | ||
1896 | } | ||
1897 | } | ||
1898 | |||
1899 | return cleaned; | ||
1900 | } | ||
1901 | |||
1902 | /** | ||
1903 | * ixgb_rx_checksum - Receive Checksum Offload for 82597. | ||
1904 | * @adapter: board private structure | ||
1905 | * @rx_desc: receive descriptor | ||
1906 | * @sk_buff: socket buffer with received data | ||
1907 | **/ | ||
1908 | |||
1909 | static void | ||
1910 | ixgb_rx_checksum(struct ixgb_adapter *adapter, | ||
1911 | struct ixgb_rx_desc *rx_desc, | ||
1912 | struct sk_buff *skb) | ||
1913 | { | ||
1914 | /* Ignore Checksum bit is set OR | ||
1915 | * TCP Checksum has not been calculated | ||
1916 | */ | ||
1917 | if ((rx_desc->status & IXGB_RX_DESC_STATUS_IXSM) || | ||
1918 | (!(rx_desc->status & IXGB_RX_DESC_STATUS_TCPCS))) { | ||
1919 | skb_checksum_none_assert(skb); | ||
1920 | return; | ||
1921 | } | ||
1922 | |||
1923 | /* At this point we know the hardware did the TCP checksum */ | ||
1924 | /* now look at the TCP checksum error bit */ | ||
1925 | if (rx_desc->errors & IXGB_RX_DESC_ERRORS_TCPE) { | ||
1926 | /* let the stack verify checksum errors */ | ||
1927 | skb_checksum_none_assert(skb); | ||
1928 | adapter->hw_csum_rx_error++; | ||
1929 | } else { | ||
1930 | /* TCP checksum is good */ | ||
1931 | skb->ip_summed = CHECKSUM_UNNECESSARY; | ||
1932 | adapter->hw_csum_rx_good++; | ||
1933 | } | ||
1934 | } | ||
1935 | |||
1936 | /* | ||
1937 | * this should improve performance for small packets with large amounts | ||
1938 | * of reassembly being done in the stack | ||
1939 | */ | ||
1940 | static void ixgb_check_copybreak(struct net_device *netdev, | ||
1941 | struct ixgb_buffer *buffer_info, | ||
1942 | u32 length, struct sk_buff **skb) | ||
1943 | { | ||
1944 | struct sk_buff *new_skb; | ||
1945 | |||
1946 | if (length > copybreak) | ||
1947 | return; | ||
1948 | |||
1949 | new_skb = netdev_alloc_skb_ip_align(netdev, length); | ||
1950 | if (!new_skb) | ||
1951 | return; | ||
1952 | |||
1953 | skb_copy_to_linear_data_offset(new_skb, -NET_IP_ALIGN, | ||
1954 | (*skb)->data - NET_IP_ALIGN, | ||
1955 | length + NET_IP_ALIGN); | ||
1956 | /* save the skb in buffer_info as good */ | ||
1957 | buffer_info->skb = *skb; | ||
1958 | *skb = new_skb; | ||
1959 | } | ||
1960 | |||
1961 | /** | ||
1962 | * ixgb_clean_rx_irq - Send received data up the network stack, | ||
1963 | * @adapter: board private structure | ||
1964 | **/ | ||
1965 | |||
1966 | static bool | ||
1967 | ixgb_clean_rx_irq(struct ixgb_adapter *adapter, int *work_done, int work_to_do) | ||
1968 | { | ||
1969 | struct ixgb_desc_ring *rx_ring = &adapter->rx_ring; | ||
1970 | struct net_device *netdev = adapter->netdev; | ||
1971 | struct pci_dev *pdev = adapter->pdev; | ||
1972 | struct ixgb_rx_desc *rx_desc, *next_rxd; | ||
1973 | struct ixgb_buffer *buffer_info, *next_buffer, *next2_buffer; | ||
1974 | u32 length; | ||
1975 | unsigned int i, j; | ||
1976 | int cleaned_count = 0; | ||
1977 | bool cleaned = false; | ||
1978 | |||
1979 | i = rx_ring->next_to_clean; | ||
1980 | rx_desc = IXGB_RX_DESC(*rx_ring, i); | ||
1981 | buffer_info = &rx_ring->buffer_info[i]; | ||
1982 | |||
1983 | while (rx_desc->status & IXGB_RX_DESC_STATUS_DD) { | ||
1984 | struct sk_buff *skb; | ||
1985 | u8 status; | ||
1986 | |||
1987 | if (*work_done >= work_to_do) | ||
1988 | break; | ||
1989 | |||
1990 | (*work_done)++; | ||
1991 | rmb(); /* read descriptor and rx_buffer_info after status DD */ | ||
1992 | status = rx_desc->status; | ||
1993 | skb = buffer_info->skb; | ||
1994 | buffer_info->skb = NULL; | ||
1995 | |||
1996 | prefetch(skb->data - NET_IP_ALIGN); | ||
1997 | |||
1998 | if (++i == rx_ring->count) | ||
1999 | i = 0; | ||
2000 | next_rxd = IXGB_RX_DESC(*rx_ring, i); | ||
2001 | prefetch(next_rxd); | ||
2002 | |||
2003 | j = i + 1; | ||
2004 | if (j == rx_ring->count) | ||
2005 | j = 0; | ||
2006 | next2_buffer = &rx_ring->buffer_info[j]; | ||
2007 | prefetch(next2_buffer); | ||
2008 | |||
2009 | next_buffer = &rx_ring->buffer_info[i]; | ||
2010 | |||
2011 | cleaned = true; | ||
2012 | cleaned_count++; | ||
2013 | |||
2014 | dma_unmap_single(&pdev->dev, | ||
2015 | buffer_info->dma, | ||
2016 | buffer_info->length, | ||
2017 | DMA_FROM_DEVICE); | ||
2018 | buffer_info->dma = 0; | ||
2019 | |||
2020 | length = le16_to_cpu(rx_desc->length); | ||
2021 | rx_desc->length = 0; | ||
2022 | |||
2023 | if (unlikely(!(status & IXGB_RX_DESC_STATUS_EOP))) { | ||
2024 | |||
2025 | /* All receives must fit into a single buffer */ | ||
2026 | |||
2027 | IXGB_DBG("Receive packet consumed multiple buffers " | ||
2028 | "length<%x>\n", length); | ||
2029 | |||
2030 | dev_kfree_skb_irq(skb); | ||
2031 | goto rxdesc_done; | ||
2032 | } | ||
2033 | |||
2034 | if (unlikely(rx_desc->errors & | ||
2035 | (IXGB_RX_DESC_ERRORS_CE | IXGB_RX_DESC_ERRORS_SE | | ||
2036 | IXGB_RX_DESC_ERRORS_P | IXGB_RX_DESC_ERRORS_RXE))) { | ||
2037 | dev_kfree_skb_irq(skb); | ||
2038 | goto rxdesc_done; | ||
2039 | } | ||
2040 | |||
2041 | ixgb_check_copybreak(netdev, buffer_info, length, &skb); | ||
2042 | |||
2043 | /* Good Receive */ | ||
2044 | skb_put(skb, length); | ||
2045 | |||
2046 | /* Receive Checksum Offload */ | ||
2047 | ixgb_rx_checksum(adapter, rx_desc, skb); | ||
2048 | |||
2049 | skb->protocol = eth_type_trans(skb, netdev); | ||
2050 | if (status & IXGB_RX_DESC_STATUS_VP) | ||
2051 | __vlan_hwaccel_put_tag(skb, | ||
2052 | le16_to_cpu(rx_desc->special)); | ||
2053 | |||
2054 | netif_receive_skb(skb); | ||
2055 | |||
2056 | rxdesc_done: | ||
2057 | /* clean up descriptor, might be written over by hw */ | ||
2058 | rx_desc->status = 0; | ||
2059 | |||
2060 | /* return some buffers to hardware, one at a time is too slow */ | ||
2061 | if (unlikely(cleaned_count >= IXGB_RX_BUFFER_WRITE)) { | ||
2062 | ixgb_alloc_rx_buffers(adapter, cleaned_count); | ||
2063 | cleaned_count = 0; | ||
2064 | } | ||
2065 | |||
2066 | /* use prefetched values */ | ||
2067 | rx_desc = next_rxd; | ||
2068 | buffer_info = next_buffer; | ||
2069 | } | ||
2070 | |||
2071 | rx_ring->next_to_clean = i; | ||
2072 | |||
2073 | cleaned_count = IXGB_DESC_UNUSED(rx_ring); | ||
2074 | if (cleaned_count) | ||
2075 | ixgb_alloc_rx_buffers(adapter, cleaned_count); | ||
2076 | |||
2077 | return cleaned; | ||
2078 | } | ||
2079 | |||
2080 | /** | ||
2081 | * ixgb_alloc_rx_buffers - Replace used receive buffers | ||
2082 | * @adapter: address of board private structure | ||
2083 | **/ | ||
2084 | |||
2085 | static void | ||
2086 | ixgb_alloc_rx_buffers(struct ixgb_adapter *adapter, int cleaned_count) | ||
2087 | { | ||
2088 | struct ixgb_desc_ring *rx_ring = &adapter->rx_ring; | ||
2089 | struct net_device *netdev = adapter->netdev; | ||
2090 | struct pci_dev *pdev = adapter->pdev; | ||
2091 | struct ixgb_rx_desc *rx_desc; | ||
2092 | struct ixgb_buffer *buffer_info; | ||
2093 | struct sk_buff *skb; | ||
2094 | unsigned int i; | ||
2095 | long cleancount; | ||
2096 | |||
2097 | i = rx_ring->next_to_use; | ||
2098 | buffer_info = &rx_ring->buffer_info[i]; | ||
2099 | cleancount = IXGB_DESC_UNUSED(rx_ring); | ||
2100 | |||
2101 | |||
2102 | /* leave three descriptors unused */ | ||
2103 | while (--cleancount > 2 && cleaned_count--) { | ||
2104 | /* recycle! its good for you */ | ||
2105 | skb = buffer_info->skb; | ||
2106 | if (skb) { | ||
2107 | skb_trim(skb, 0); | ||
2108 | goto map_skb; | ||
2109 | } | ||
2110 | |||
2111 | skb = netdev_alloc_skb_ip_align(netdev, adapter->rx_buffer_len); | ||
2112 | if (unlikely(!skb)) { | ||
2113 | /* Better luck next round */ | ||
2114 | adapter->alloc_rx_buff_failed++; | ||
2115 | break; | ||
2116 | } | ||
2117 | |||
2118 | buffer_info->skb = skb; | ||
2119 | buffer_info->length = adapter->rx_buffer_len; | ||
2120 | map_skb: | ||
2121 | buffer_info->dma = dma_map_single(&pdev->dev, | ||
2122 | skb->data, | ||
2123 | adapter->rx_buffer_len, | ||
2124 | DMA_FROM_DEVICE); | ||
2125 | |||
2126 | rx_desc = IXGB_RX_DESC(*rx_ring, i); | ||
2127 | rx_desc->buff_addr = cpu_to_le64(buffer_info->dma); | ||
2128 | /* guarantee DD bit not set now before h/w gets descriptor | ||
2129 | * this is the rest of the workaround for h/w double | ||
2130 | * writeback. */ | ||
2131 | rx_desc->status = 0; | ||
2132 | |||
2133 | |||
2134 | if (++i == rx_ring->count) i = 0; | ||
2135 | buffer_info = &rx_ring->buffer_info[i]; | ||
2136 | } | ||
2137 | |||
2138 | if (likely(rx_ring->next_to_use != i)) { | ||
2139 | rx_ring->next_to_use = i; | ||
2140 | if (unlikely(i-- == 0)) | ||
2141 | i = (rx_ring->count - 1); | ||
2142 | |||
2143 | /* Force memory writes to complete before letting h/w | ||
2144 | * know there are new descriptors to fetch. (Only | ||
2145 | * applicable for weak-ordered memory model archs, such | ||
2146 | * as IA-64). */ | ||
2147 | wmb(); | ||
2148 | IXGB_WRITE_REG(&adapter->hw, RDT, i); | ||
2149 | } | ||
2150 | } | ||
2151 | |||
2152 | static void | ||
2153 | ixgb_vlan_strip_enable(struct ixgb_adapter *adapter) | ||
2154 | { | ||
2155 | u32 ctrl; | ||
2156 | |||
2157 | /* enable VLAN tag insert/strip */ | ||
2158 | ctrl = IXGB_READ_REG(&adapter->hw, CTRL0); | ||
2159 | ctrl |= IXGB_CTRL0_VME; | ||
2160 | IXGB_WRITE_REG(&adapter->hw, CTRL0, ctrl); | ||
2161 | } | ||
2162 | |||
2163 | static void | ||
2164 | ixgb_vlan_strip_disable(struct ixgb_adapter *adapter) | ||
2165 | { | ||
2166 | u32 ctrl; | ||
2167 | |||
2168 | /* disable VLAN tag insert/strip */ | ||
2169 | ctrl = IXGB_READ_REG(&adapter->hw, CTRL0); | ||
2170 | ctrl &= ~IXGB_CTRL0_VME; | ||
2171 | IXGB_WRITE_REG(&adapter->hw, CTRL0, ctrl); | ||
2172 | } | ||
2173 | |||
2174 | static void | ||
2175 | ixgb_vlan_rx_add_vid(struct net_device *netdev, u16 vid) | ||
2176 | { | ||
2177 | struct ixgb_adapter *adapter = netdev_priv(netdev); | ||
2178 | u32 vfta, index; | ||
2179 | |||
2180 | /* add VID to filter table */ | ||
2181 | |||
2182 | index = (vid >> 5) & 0x7F; | ||
2183 | vfta = IXGB_READ_REG_ARRAY(&adapter->hw, VFTA, index); | ||
2184 | vfta |= (1 << (vid & 0x1F)); | ||
2185 | ixgb_write_vfta(&adapter->hw, index, vfta); | ||
2186 | set_bit(vid, adapter->active_vlans); | ||
2187 | } | ||
2188 | |||
2189 | static void | ||
2190 | ixgb_vlan_rx_kill_vid(struct net_device *netdev, u16 vid) | ||
2191 | { | ||
2192 | struct ixgb_adapter *adapter = netdev_priv(netdev); | ||
2193 | u32 vfta, index; | ||
2194 | |||
2195 | /* remove VID from filter table */ | ||
2196 | |||
2197 | index = (vid >> 5) & 0x7F; | ||
2198 | vfta = IXGB_READ_REG_ARRAY(&adapter->hw, VFTA, index); | ||
2199 | vfta &= ~(1 << (vid & 0x1F)); | ||
2200 | ixgb_write_vfta(&adapter->hw, index, vfta); | ||
2201 | clear_bit(vid, adapter->active_vlans); | ||
2202 | } | ||
2203 | |||
2204 | static void | ||
2205 | ixgb_restore_vlan(struct ixgb_adapter *adapter) | ||
2206 | { | ||
2207 | u16 vid; | ||
2208 | |||
2209 | for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID) | ||
2210 | ixgb_vlan_rx_add_vid(adapter->netdev, vid); | ||
2211 | } | ||
2212 | |||
2213 | #ifdef CONFIG_NET_POLL_CONTROLLER | ||
2214 | /* | ||
2215 | * Polling 'interrupt' - used by things like netconsole to send skbs | ||
2216 | * without having to re-enable interrupts. It's not called while | ||
2217 | * the interrupt routine is executing. | ||
2218 | */ | ||
2219 | |||
2220 | static void ixgb_netpoll(struct net_device *dev) | ||
2221 | { | ||
2222 | struct ixgb_adapter *adapter = netdev_priv(dev); | ||
2223 | |||
2224 | disable_irq(adapter->pdev->irq); | ||
2225 | ixgb_intr(adapter->pdev->irq, dev); | ||
2226 | enable_irq(adapter->pdev->irq); | ||
2227 | } | ||
2228 | #endif | ||
2229 | |||
2230 | /** | ||
2231 | * ixgb_io_error_detected() - called when PCI error is detected | ||
2232 | * @pdev pointer to pci device with error | ||
2233 | * @state pci channel state after error | ||
2234 | * | ||
2235 | * This callback is called by the PCI subsystem whenever | ||
2236 | * a PCI bus error is detected. | ||
2237 | */ | ||
2238 | static pci_ers_result_t ixgb_io_error_detected(struct pci_dev *pdev, | ||
2239 | enum pci_channel_state state) | ||
2240 | { | ||
2241 | struct net_device *netdev = pci_get_drvdata(pdev); | ||
2242 | struct ixgb_adapter *adapter = netdev_priv(netdev); | ||
2243 | |||
2244 | netif_device_detach(netdev); | ||
2245 | |||
2246 | if (state == pci_channel_io_perm_failure) | ||
2247 | return PCI_ERS_RESULT_DISCONNECT; | ||
2248 | |||
2249 | if (netif_running(netdev)) | ||
2250 | ixgb_down(adapter, true); | ||
2251 | |||
2252 | pci_disable_device(pdev); | ||
2253 | |||
2254 | /* Request a slot reset. */ | ||
2255 | return PCI_ERS_RESULT_NEED_RESET; | ||
2256 | } | ||
2257 | |||
2258 | /** | ||
2259 | * ixgb_io_slot_reset - called after the pci bus has been reset. | ||
2260 | * @pdev pointer to pci device with error | ||
2261 | * | ||
2262 | * This callback is called after the PCI bus has been reset. | ||
2263 | * Basically, this tries to restart the card from scratch. | ||
2264 | * This is a shortened version of the device probe/discovery code, | ||
2265 | * it resembles the first-half of the ixgb_probe() routine. | ||
2266 | */ | ||
2267 | static pci_ers_result_t ixgb_io_slot_reset(struct pci_dev *pdev) | ||
2268 | { | ||
2269 | struct net_device *netdev = pci_get_drvdata(pdev); | ||
2270 | struct ixgb_adapter *adapter = netdev_priv(netdev); | ||
2271 | |||
2272 | if (pci_enable_device(pdev)) { | ||
2273 | netif_err(adapter, probe, adapter->netdev, | ||
2274 | "Cannot re-enable PCI device after reset\n"); | ||
2275 | return PCI_ERS_RESULT_DISCONNECT; | ||
2276 | } | ||
2277 | |||
2278 | /* Perform card reset only on one instance of the card */ | ||
2279 | if (0 != PCI_FUNC (pdev->devfn)) | ||
2280 | return PCI_ERS_RESULT_RECOVERED; | ||
2281 | |||
2282 | pci_set_master(pdev); | ||
2283 | |||
2284 | netif_carrier_off(netdev); | ||
2285 | netif_stop_queue(netdev); | ||
2286 | ixgb_reset(adapter); | ||
2287 | |||
2288 | /* Make sure the EEPROM is good */ | ||
2289 | if (!ixgb_validate_eeprom_checksum(&adapter->hw)) { | ||
2290 | netif_err(adapter, probe, adapter->netdev, | ||
2291 | "After reset, the EEPROM checksum is not valid\n"); | ||
2292 | return PCI_ERS_RESULT_DISCONNECT; | ||
2293 | } | ||
2294 | ixgb_get_ee_mac_addr(&adapter->hw, netdev->dev_addr); | ||
2295 | memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len); | ||
2296 | |||
2297 | if (!is_valid_ether_addr(netdev->perm_addr)) { | ||
2298 | netif_err(adapter, probe, adapter->netdev, | ||
2299 | "After reset, invalid MAC address\n"); | ||
2300 | return PCI_ERS_RESULT_DISCONNECT; | ||
2301 | } | ||
2302 | |||
2303 | return PCI_ERS_RESULT_RECOVERED; | ||
2304 | } | ||
2305 | |||
2306 | /** | ||
2307 | * ixgb_io_resume - called when its OK to resume normal operations | ||
2308 | * @pdev pointer to pci device with error | ||
2309 | * | ||
2310 | * The error recovery driver tells us that its OK to resume | ||
2311 | * normal operation. Implementation resembles the second-half | ||
2312 | * of the ixgb_probe() routine. | ||
2313 | */ | ||
2314 | static void ixgb_io_resume(struct pci_dev *pdev) | ||
2315 | { | ||
2316 | struct net_device *netdev = pci_get_drvdata(pdev); | ||
2317 | struct ixgb_adapter *adapter = netdev_priv(netdev); | ||
2318 | |||
2319 | pci_set_master(pdev); | ||
2320 | |||
2321 | if (netif_running(netdev)) { | ||
2322 | if (ixgb_up(adapter)) { | ||
2323 | pr_err("can't bring device back up after reset\n"); | ||
2324 | return; | ||
2325 | } | ||
2326 | } | ||
2327 | |||
2328 | netif_device_attach(netdev); | ||
2329 | mod_timer(&adapter->watchdog_timer, jiffies); | ||
2330 | } | ||
2331 | |||
2332 | /* ixgb_main.c */ | ||