1 /*******************************************************************************
2
3
4 Copyright(c) 1999 - 2004 Intel Corporation. All rights reserved.
5
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 2 of the License, or (at your option)
9 any later version.
10
11 This program is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 more details.
15
16 You should have received a copy of the GNU General Public License along with
17 this program; if not, write to the Free Software Foundation, Inc., 59
18 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
20 The full GNU General Public License is included in this distribution in the
21 file called LICENSE.
22
23 Contact Information:
24 Linux NICS <linux.nics@intel.com>
25 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
26
27 *******************************************************************************/
28
29 #include "e1000.h"
30
31 /* Change Log
32 * 5.3.12 6/7/04
33 * - kcompat NETIF_MSG for older kernels (2.4.9) <sean.p.mcdermott@intel.com>
34 * - if_mii support and associated kcompat for older kernels
35 * - More errlogging support from Jon Mason <jonmason@us.ibm.com>
36 * - Fix TSO issues on PPC64 machines -- Jon Mason <jonmason@us.ibm.com>
37 *
38 * 5.6.5 11/01/04
39 * - Enabling NETIF_F_SG without checksum offload is illegal -
40 John Mason <jdmason@us.ibm.com>
41 * 5.6.3 10/26/04
42 * - Remove redundant initialization - Jamal Hadi
43 * - Reset buffer_info->dma in tx resource cleanup logic
44 * 5.6.2 10/12/04
45 * - Avoid filling tx_ring completely - shemminger@osdl.org
46 * - Replace schedule_timeout() with msleep()/msleep_interruptible() -
47 * nacc@us.ibm.com
48 * - Sparse cleanup - shemminger@osdl.org
49 * - Fix tx resource cleanup logic
50 * - LLTX support - ak@suse.de and hadi@cyberus.ca
51 */
52
53 char e1000_driver_name[] = "e1000";
54 char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
55 #ifndef CONFIG_E1000_NAPI
56 #define DRIVERNAPI
57 #else
58 #define DRIVERNAPI "-NAPI"
59 #endif
60 char e1000_driver_version[] = "5.6.10.1-k2"DRIVERNAPI;
61 char e1000_copyright[] = "Copyright (c) 1999-2004 Intel Corporation.";
62
63 /* e1000_pci_tbl - PCI Device ID Table
64 *
65 * Last entry must be all 0s
66 *
67 * Macro expands to...
68 * {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}
69 */
70 static struct pci_device_id e1000_pci_tbl[] = {
71 INTEL_E1000_ETHERNET_DEVICE(0x1000),
72 INTEL_E1000_ETHERNET_DEVICE(0x1001),
73 INTEL_E1000_ETHERNET_DEVICE(0x1004),
74 INTEL_E1000_ETHERNET_DEVICE(0x1008),
75 INTEL_E1000_ETHERNET_DEVICE(0x1009),
76 INTEL_E1000_ETHERNET_DEVICE(0x100C),
77 INTEL_E1000_ETHERNET_DEVICE(0x100D),
78 INTEL_E1000_ETHERNET_DEVICE(0x100E),
79 INTEL_E1000_ETHERNET_DEVICE(0x100F),
80 INTEL_E1000_ETHERNET_DEVICE(0x1010),
81 INTEL_E1000_ETHERNET_DEVICE(0x1011),
82 INTEL_E1000_ETHERNET_DEVICE(0x1012),
83 INTEL_E1000_ETHERNET_DEVICE(0x1013),
84 INTEL_E1000_ETHERNET_DEVICE(0x1015),
85 INTEL_E1000_ETHERNET_DEVICE(0x1016),
86 INTEL_E1000_ETHERNET_DEVICE(0x1017),
87 INTEL_E1000_ETHERNET_DEVICE(0x1018),
88 INTEL_E1000_ETHERNET_DEVICE(0x1019),
89 INTEL_E1000_ETHERNET_DEVICE(0x101D),
90 INTEL_E1000_ETHERNET_DEVICE(0x101E),
91 INTEL_E1000_ETHERNET_DEVICE(0x1026),
92 INTEL_E1000_ETHERNET_DEVICE(0x1027),
93 INTEL_E1000_ETHERNET_DEVICE(0x1028),
94 INTEL_E1000_ETHERNET_DEVICE(0x1075),
95 INTEL_E1000_ETHERNET_DEVICE(0x1076),
96 INTEL_E1000_ETHERNET_DEVICE(0x1077),
97 INTEL_E1000_ETHERNET_DEVICE(0x1078),
98 INTEL_E1000_ETHERNET_DEVICE(0x1079),
99 INTEL_E1000_ETHERNET_DEVICE(0x107A),
100 INTEL_E1000_ETHERNET_DEVICE(0x107B),
101 INTEL_E1000_ETHERNET_DEVICE(0x107C),
102 INTEL_E1000_ETHERNET_DEVICE(0x108A),
103 /* required last entry */
104 {0,}
105 };
106
107 MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);
108
109 int e1000_up(struct e1000_adapter *adapter);
110 void e1000_down(struct e1000_adapter *adapter);
111 void e1000_reset(struct e1000_adapter *adapter);
112 int e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx);
113 int e1000_setup_tx_resources(struct e1000_adapter *adapter);
114 int e1000_setup_rx_resources(struct e1000_adapter *adapter);
115 void e1000_free_tx_resources(struct e1000_adapter *adapter);
116 void e1000_free_rx_resources(struct e1000_adapter *adapter);
117 void e1000_update_stats(struct e1000_adapter *adapter);
118
119 /* Local Function Prototypes */
120
121 static int e1000_init_module(void);
122 static void e1000_exit_module(void);
123 static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
124 static void __devexit e1000_remove(struct pci_dev *pdev);
125 static int e1000_sw_init(struct e1000_adapter *adapter);
126 static int e1000_open(struct net_device *netdev);
127 static int e1000_close(struct net_device *netdev);
128 static void e1000_configure_tx(struct e1000_adapter *adapter);
129 static void e1000_configure_rx(struct e1000_adapter *adapter);
130 static void e1000_setup_rctl(struct e1000_adapter *adapter);
131 static void e1000_clean_tx_ring(struct e1000_adapter *adapter);
132 static void e1000_clean_rx_ring(struct e1000_adapter *adapter);
133 static void e1000_set_multi(struct net_device *netdev);
134 static void e1000_update_phy_info(unsigned long data);
135 static void e1000_watchdog(unsigned long data);
136 static void e1000_82547_tx_fifo_stall(unsigned long data);
137 static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev);
138 static struct net_device_stats * e1000_get_stats(struct net_device *netdev);
139 static int e1000_change_mtu(struct net_device *netdev, int new_mtu);
140 static int e1000_set_mac(struct net_device *netdev, void *p);
141 static irqreturn_t e1000_intr(int irq, void *data, struct pt_regs *regs);
142 static boolean_t e1000_clean_tx_irq(struct e1000_adapter *adapter);
143 #ifdef CONFIG_E1000_NAPI
144 static int e1000_clean(struct net_device *netdev, int *budget);
145 static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,
146 int *work_done, int work_to_do);
147 #else
148 static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter);
149 #endif
150 static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter);
151 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd);
152 static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
153 int cmd);
154 void e1000_set_ethtool_ops(struct net_device *netdev);
155 static void e1000_enter_82542_rst(struct e1000_adapter *adapter);
156 static void e1000_leave_82542_rst(struct e1000_adapter *adapter);
157 static void e1000_tx_timeout(struct net_device *dev);
158 static void e1000_tx_timeout_task(struct net_device *dev);
159 static void e1000_smartspeed(struct e1000_adapter *adapter);
160 static inline int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
161 struct sk_buff *skb);
162
163 static void e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp);
164 static void e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid);
165 static void e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid);
166 static void e1000_restore_vlan(struct e1000_adapter *adapter);
167
168 static int e1000_notify_reboot(struct notifier_block *, unsigned long event, void *ptr);
169 static int e1000_suspend(struct pci_dev *pdev, uint32_t state);
170 #ifdef CONFIG_PM
171 static int e1000_resume(struct pci_dev *pdev);
172 #endif
173
174 #ifdef CONFIG_NET_POLL_CONTROLLER
175 /* for netdump / net console */
176 static void e1000_netpoll (struct net_device *netdev);
177 #endif
178
179 struct notifier_block e1000_notifier_reboot = {
180 .notifier_call = e1000_notify_reboot,
181 .next = NULL,
182 .priority = 0
183 };
184
185 /* Exported from other modules */
186
187 extern void e1000_check_options(struct e1000_adapter *adapter);
188
189 static struct pci_driver e1000_driver = {
190 .name = e1000_driver_name,
191 .id_table = e1000_pci_tbl,
192 .probe = e1000_probe,
193 .remove = __devexit_p(e1000_remove),
194 /* Power Managment Hooks */
195 #ifdef CONFIG_PM
196 .suspend = e1000_suspend,
197 .resume = e1000_resume
198 #endif
199 };
200
201 MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
202 MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver");
203 MODULE_LICENSE("GPL");
204
205 static int debug = NETIF_MSG_DRV | NETIF_MSG_PROBE;
206 module_param(debug, int, 0);
207 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
208
209 /**
210 * e1000_init_module - Driver Registration Routine
211 *
212 * e1000_init_module is the first routine called when the driver is
213 * loaded. All it does is register with the PCI subsystem.
214 **/
215
216 static int __init
217 e1000_init_module(void)
218 {
219 int ret;
220 printk(KERN_INFO "%s - version %s\n",
221 e1000_driver_string, e1000_driver_version);
222
223 printk(KERN_INFO "%s\n", e1000_copyright);
224
225 ret = pci_module_init(&e1000_driver);
226 if(ret >= 0) {
227 register_reboot_notifier(&e1000_notifier_reboot);
228 }
229 return ret;
230 }
231
232 module_init(e1000_init_module);
233
234 /**
235 * e1000_exit_module - Driver Exit Cleanup Routine
236 *
237 * e1000_exit_module is called just before the driver is removed
238 * from memory.
239 **/
240
241 static void __exit
242 e1000_exit_module(void)
243 {
244 unregister_reboot_notifier(&e1000_notifier_reboot);
245 pci_unregister_driver(&e1000_driver);
246 }
247
248 module_exit(e1000_exit_module);
249
250 /**
251 * e1000_irq_disable - Mask off interrupt generation on the NIC
252 * @adapter: board private structure
253 **/
254
255 static inline void
256 e1000_irq_disable(struct e1000_adapter *adapter)
257 {
258 atomic_inc(&adapter->irq_sem);
259 E1000_WRITE_REG(&adapter->hw, IMC, ~0);
260 E1000_WRITE_FLUSH(&adapter->hw);
261 synchronize_irq(adapter->pdev->irq);
262 }
263
264 /**
265 * e1000_irq_enable - Enable default interrupt generation settings
266 * @adapter: board private structure
267 **/
268
269 static inline void
270 e1000_irq_enable(struct e1000_adapter *adapter)
271 {
272 if(likely(atomic_dec_and_test(&adapter->irq_sem))) {
273 E1000_WRITE_REG(&adapter->hw, IMS, IMS_ENABLE_MASK);
274 E1000_WRITE_FLUSH(&adapter->hw);
275 }
276 }
277
278 int
279 e1000_up(struct e1000_adapter *adapter)
280 {
281 struct net_device *netdev = adapter->netdev;
282 int err;
283
284 /* hardware has been reset, we need to reload some things */
285
286 /* Reset the PHY if it was previously powered down */
287 if(adapter->hw.media_type == e1000_media_type_copper) {
288 uint16_t mii_reg;
289 e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &mii_reg);
290 if(mii_reg & MII_CR_POWER_DOWN)
291 e1000_phy_reset(&adapter->hw);
292 }
293
294 e1000_set_multi(netdev);
295
296 e1000_restore_vlan(adapter);
297
298 e1000_configure_tx(adapter);
299 e1000_setup_rctl(adapter);
300 e1000_configure_rx(adapter);
301 e1000_alloc_rx_buffers(adapter);
302
303 if((err = request_irq(adapter->pdev->irq, &e1000_intr,
304 SA_SHIRQ | SA_SAMPLE_RANDOM,
305 netdev->name, netdev)))
306 return err;
307
308 mod_timer(&adapter->watchdog_timer, jiffies);
309 e1000_irq_enable(adapter);
310
311 return 0;
312 }
313
314 void
315 e1000_down(struct e1000_adapter *adapter)
316 {
317 struct net_device *netdev = adapter->netdev;
318
319 e1000_irq_disable(adapter);
320 free_irq(adapter->pdev->irq, netdev);
321 del_timer_sync(&adapter->tx_fifo_stall_timer);
322 del_timer_sync(&adapter->watchdog_timer);
323 del_timer_sync(&adapter->phy_info_timer);
324 adapter->link_speed = 0;
325 adapter->link_duplex = 0;
326 netif_carrier_off(netdev);
327 netif_stop_queue(netdev);
328
329 e1000_reset(adapter);
330 e1000_clean_tx_ring(adapter);
331 e1000_clean_rx_ring(adapter);
332
333 /* If WoL is not enabled
334 * Power down the PHY so no link is implied when interface is down */
335 if(!adapter->wol && adapter->hw.media_type == e1000_media_type_copper) {
336 uint16_t mii_reg;
337 e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &mii_reg);
338 mii_reg |= MII_CR_POWER_DOWN;
339 e1000_write_phy_reg(&adapter->hw, PHY_CTRL, mii_reg);
340 }
341 }
342
343 void
344 e1000_reset(struct e1000_adapter *adapter)
345 {
346 uint32_t pba;
347
348 /* Repartition Pba for greater than 9k mtu
349 * To take effect CTRL.RST is required.
350 */
351
352 if(adapter->hw.mac_type < e1000_82547) {
353 if(adapter->rx_buffer_len > E1000_RXBUFFER_8192)
354 pba = E1000_PBA_40K;
355 else
356 pba = E1000_PBA_48K;
357 } else {
358 if(adapter->rx_buffer_len > E1000_RXBUFFER_8192)
359 pba = E1000_PBA_22K;
360 else
361 pba = E1000_PBA_30K;
362 adapter->tx_fifo_head = 0;
363 adapter->tx_head_addr = pba << E1000_TX_HEAD_ADDR_SHIFT;
364 adapter->tx_fifo_size =
365 (E1000_PBA_40K - pba) << E1000_PBA_BYTES_SHIFT;
366 atomic_set(&adapter->tx_fifo_stall, 0);
367 }
368 E1000_WRITE_REG(&adapter->hw, PBA, pba);
369
370 /* flow control settings */
371 adapter->hw.fc_high_water = (pba << E1000_PBA_BYTES_SHIFT) -
372 E1000_FC_HIGH_DIFF;
373 adapter->hw.fc_low_water = (pba << E1000_PBA_BYTES_SHIFT) -
374 E1000_FC_LOW_DIFF;
375 adapter->hw.fc_pause_time = E1000_FC_PAUSE_TIME;
376 adapter->hw.fc_send_xon = 1;
377 adapter->hw.fc = adapter->hw.original_fc;
378
379 e1000_reset_hw(&adapter->hw);
380 if(adapter->hw.mac_type >= e1000_82544)
381 E1000_WRITE_REG(&adapter->hw, WUC, 0);
382 if(e1000_init_hw(&adapter->hw))
383 DPRINTK(PROBE, ERR, "Hardware Error\n");
384
385 /* Enable h/w to recognize an 802.1Q VLAN Ethernet packet */
386 E1000_WRITE_REG(&adapter->hw, VET, ETHERNET_IEEE_VLAN_TYPE);
387
388 e1000_reset_adaptive(&adapter->hw);
389 e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
390 }
391
392 /**
393 * e1000_probe - Device Initialization Routine
394 * @pdev: PCI device information struct
395 * @ent: entry in e1000_pci_tbl
396 *
397 * Returns 0 on success, negative on failure
398 *
399 * e1000_probe initializes an adapter identified by a pci_dev structure.
400 * The OS initialization, configuring of the adapter private structure,
401 * and a hardware reset occur.
402 **/
403
404 static int __devinit
405 e1000_probe(struct pci_dev *pdev,
406 const struct pci_device_id *ent)
407 {
408 struct net_device *netdev;
409 struct e1000_adapter *adapter;
410 static int cards_found = 0;
411 unsigned long mmio_start;
412 int mmio_len;
413 int pci_using_dac;
414 int i;
415 int err;
416 uint16_t eeprom_data;
417
418 if((err = pci_enable_device(pdev)))
419 return err;
420
421 if(!(err = pci_set_dma_mask(pdev, DMA_64BIT_MASK))) {
422 pci_using_dac = 1;
423 } else {
424 if((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK))) {
425 E1000_ERR("No usable DMA configuration, aborting\n");
426 return err;
427 }
428 pci_using_dac = 0;
429 }
430
431 if((err = pci_request_regions(pdev, e1000_driver_name)))
432 return err;
433
434 pci_set_master(pdev);
435
436 netdev = alloc_etherdev(sizeof(struct e1000_adapter));
437 if(!netdev) {
438 err = -ENOMEM;
439 goto err_alloc_etherdev;
440 }
441
442 SET_MODULE_OWNER(netdev);
443 SET_NETDEV_DEV(netdev, &pdev->dev);
444
445 pci_set_drvdata(pdev, netdev);
446 adapter = netdev->priv;
447 adapter->netdev = netdev;
448 adapter->pdev = pdev;
449 adapter->hw.back = adapter;
450 adapter->msg_enable = (1 << debug) - 1;
451
452 mmio_start = pci_resource_start(pdev, BAR_0);
453 mmio_len = pci_resource_len(pdev, BAR_0);
454
455 adapter->hw.hw_addr = ioremap(mmio_start, mmio_len);
456 if(!adapter->hw.hw_addr) {
457 err = -EIO;
458 goto err_ioremap;
459 }
460
461 for(i = BAR_1; i <= BAR_5; i++) {
462 if(pci_resource_len(pdev, i) == 0)
463 continue;
464 if(pci_resource_flags(pdev, i) & IORESOURCE_IO) {
465 adapter->hw.io_base = pci_resource_start(pdev, i);
466 break;
467 }
468 }
469
470 netdev->open = &e1000_open;
471 netdev->stop = &e1000_close;
472 netdev->hard_start_xmit = &e1000_xmit_frame;
473 netdev->get_stats = &e1000_get_stats;
474 netdev->set_multicast_list = &e1000_set_multi;
475 netdev->set_mac_address = &e1000_set_mac;
476 netdev->change_mtu = &e1000_change_mtu;
477 netdev->do_ioctl = &e1000_ioctl;
478 e1000_set_ethtool_ops(netdev);
479 netdev->tx_timeout = &e1000_tx_timeout;
480 netdev->watchdog_timeo = 5 * HZ;
481 #ifdef CONFIG_E1000_NAPI
482 netdev->poll = &e1000_clean;
483 netdev->weight = 64;
484 #endif
485 netdev->vlan_rx_register = e1000_vlan_rx_register;
486 netdev->vlan_rx_add_vid = e1000_vlan_rx_add_vid;
487 netdev->vlan_rx_kill_vid = e1000_vlan_rx_kill_vid;
488 #ifdef CONFIG_NET_POLL_CONTROLLER
489 netdev->poll_controller = e1000_netpoll;
490 #endif
491 strcpy(netdev->name, pci_name(pdev));
492
493 netdev->mem_start = mmio_start;
494 netdev->mem_end = mmio_start + mmio_len;
495 netdev->base_addr = adapter->hw.io_base;
496
497 adapter->bd_number = cards_found;
498
499 /* setup the private structure */
500
501 if((err = e1000_sw_init(adapter)))
502 goto err_sw_init;
503
504 if(adapter->hw.mac_type >= e1000_82543) {
505 netdev->features = NETIF_F_SG |
506 NETIF_F_HW_CSUM |
507 NETIF_F_HW_VLAN_TX |
508 NETIF_F_HW_VLAN_RX |
509 NETIF_F_HW_VLAN_FILTER;
510 }
511
512 #ifdef NETIF_F_TSO
513 /* Disbaled for now until root-cause is found for
514 * hangs reported against non-IA archs. TSO can be
515 * enabled using ethtool -K eth<x> tso on */
516 if((adapter->hw.mac_type >= e1000_82544) &&
517 (adapter->hw.mac_type != e1000_82547))
518 netdev->features |= NETIF_F_TSO;
519 #endif
520 if(pci_using_dac)
521 netdev->features |= NETIF_F_HIGHDMA;
522
523 /* hard_start_xmit is safe against parallel locking */
524 netdev->features |= NETIF_F_LLTX;
525
526 /* before reading the EEPROM, reset the controller to
527 * put the device in a known good starting state */
528
529 e1000_reset_hw(&adapter->hw);
530
531 /* make sure the EEPROM is good */
532
533 if(e1000_validate_eeprom_checksum(&adapter->hw) < 0) {
534 DPRINTK(PROBE, ERR, "The EEPROM Checksum Is Not Valid\n");
535 err = -EIO;
536 goto err_eeprom;
537 }
538
539 /* copy the MAC address out of the EEPROM */
540
541 if (e1000_read_mac_addr(&adapter->hw))
542 DPRINTK(PROBE, ERR, "EEPROM Read Error\n");
543 memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
544
545 if(!is_valid_ether_addr(netdev->dev_addr)) {
546 DPRINTK(PROBE, ERR, "Invalid MAC Address\n");
547 err = -EIO;
548 goto err_eeprom;
549 }
550
551 e1000_read_part_num(&adapter->hw, &(adapter->part_num));
552
553 e1000_get_bus_info(&adapter->hw);
554
555 init_timer(&adapter->tx_fifo_stall_timer);
556 adapter->tx_fifo_stall_timer.function = &e1000_82547_tx_fifo_stall;
557 adapter->tx_fifo_stall_timer.data = (unsigned long) adapter;
558
559 init_timer(&adapter->watchdog_timer);
560 adapter->watchdog_timer.function = &e1000_watchdog;
561 adapter->watchdog_timer.data = (unsigned long) adapter;
562
563 init_timer(&adapter->phy_info_timer);
564 adapter->phy_info_timer.function = &e1000_update_phy_info;
565 adapter->phy_info_timer.data = (unsigned long) adapter;
566
567 INIT_WORK(&adapter->tx_timeout_task,
568 (void (*)(void *))e1000_tx_timeout_task, netdev);
569
570 /* we're going to reset, so assume we have no link for now */
571
572 netif_carrier_off(netdev);
573 netif_stop_queue(netdev);
574
575 e1000_check_options(adapter);
576
577 /* Initial Wake on LAN setting
578 * If APM wake is enabled in the EEPROM,
579 * enable the ACPI Magic Packet filter
580 */
581
582 switch(adapter->hw.mac_type) {
583 case e1000_82542_rev2_0:
584 case e1000_82542_rev2_1:
585 case e1000_82543:
586 break;
587 case e1000_82546:
588 case e1000_82546_rev_3:
589 if((E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_FUNC_1)
590 && (adapter->hw.media_type == e1000_media_type_copper)) {
591 e1000_read_eeprom(&adapter->hw,
592 EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
593 break;
594 }
595 /* Fall Through */
596 default:
597 e1000_read_eeprom(&adapter->hw,
598 EEPROM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
599 break;
600 }
601 if(eeprom_data & E1000_EEPROM_APME)
602 adapter->wol |= E1000_WUFC_MAG;
603
604 /* reset the hardware with the new settings */
605 e1000_reset(adapter);
606
607 strcpy(netdev->name, "eth%d");
608 if((err = register_netdev(netdev)))
609 goto err_register;
610
611 DPRINTK(PROBE, INFO, "Intel(R) PRO/1000 Network Connection\n");
612
613 cards_found++;
614 return 0;
615
616 err_register:
617 err_sw_init:
618 err_eeprom:
619 iounmap(adapter->hw.hw_addr);
620 err_ioremap:
621 free_netdev(netdev);
622 err_alloc_etherdev:
623 pci_release_regions(pdev);
624 return err;
625 }
626
627 /**
628 * e1000_remove - Device Removal Routine
629 * @pdev: PCI device information struct
630 *
631 * e1000_remove is called by the PCI subsystem to alert the driver
632 * that it should release a PCI device. The could be caused by a
633 * Hot-Plug event, or because the driver is going to be removed from
634 * memory.
635 **/
636
637 static void __devexit
638 e1000_remove(struct pci_dev *pdev)
639 {
640 struct net_device *netdev = pci_get_drvdata(pdev);
641 struct e1000_adapter *adapter = netdev->priv;
642 uint32_t manc;
643
644 if(adapter->hw.mac_type >= e1000_82540 &&
645 adapter->hw.media_type == e1000_media_type_copper) {
646 manc = E1000_READ_REG(&adapter->hw, MANC);
647 if(manc & E1000_MANC_SMBUS_EN) {
648 manc |= E1000_MANC_ARP_EN;
649 E1000_WRITE_REG(&adapter->hw, MANC, manc);
650 }
651 }
652
653 unregister_netdev(netdev);
654
655 e1000_phy_hw_reset(&adapter->hw);
656
657 iounmap(adapter->hw.hw_addr);
658 pci_release_regions(pdev);
659
660 free_netdev(netdev);
661
662 pci_disable_device(pdev);
663 }
664
665 /**
666 * e1000_sw_init - Initialize general software structures (struct e1000_adapter)
667 * @adapter: board private structure to initialize
668 *
669 * e1000_sw_init initializes the Adapter private data structure.
670 * Fields are initialized based on PCI device information and
671 * OS network device settings (MTU size).
672 **/
673
674 static int __devinit
675 e1000_sw_init(struct e1000_adapter *adapter)
676 {
677 struct e1000_hw *hw = &adapter->hw;
678 struct net_device *netdev = adapter->netdev;
679 struct pci_dev *pdev = adapter->pdev;
680
681 /* PCI config space info */
682
683 hw->vendor_id = pdev->vendor;
684 hw->device_id = pdev->device;
685 hw->subsystem_vendor_id = pdev->subsystem_vendor;
686 hw->subsystem_id = pdev->subsystem_device;
687
688 pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id);
689
690 pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word);
691
692 adapter->rx_buffer_len = E1000_RXBUFFER_2048;
693 hw->max_frame_size = netdev->mtu +
694 ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
695 hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;
696
697 /* identify the MAC */
698
699 if(e1000_set_mac_type(hw)) {
700 DPRINTK(PROBE, ERR, "Unknown MAC Type\n");
701 return -EIO;
702 }
703
704 /* initialize eeprom parameters */
705
706 e1000_init_eeprom_params(hw);
707
708 switch(hw->mac_type) {
709 default:
710 break;
711 case e1000_82541:
712 case e1000_82547:
713 case e1000_82541_rev_2:
714 case e1000_82547_rev_2:
715 hw->phy_init_script = 1;
716 break;
717 }
718
719 e1000_set_media_type(hw);
720
721 hw->wait_autoneg_complete = FALSE;
722 hw->tbi_compatibility_en = TRUE;
723 hw->adaptive_ifs = TRUE;
724
725 /* Copper options */
726
727 if(hw->media_type == e1000_media_type_copper) {
728 hw->mdix = AUTO_ALL_MODES;
729 hw->disable_polarity_correction = FALSE;
730 hw->master_slave = E1000_MASTER_SLAVE;
731 }
732
733 atomic_set(&adapter->irq_sem, 1);
734 spin_lock_init(&adapter->stats_lock);
735 spin_lock_init(&adapter->tx_lock);
736
737 return 0;
738 }
739
740 /**
741 * e1000_open - Called when a network interface is made active
742 * @netdev: network interface device structure
743 *
744 * Returns 0 on success, negative value on failure
745 *
746 * The open entry point is called when a network interface is made
747 * active by the system (IFF_UP). At this point all resources needed
748 * for transmit and receive operations are allocated, the interrupt
749 * handler is registered with the OS, the watchdog timer is started,
750 * and the stack is notified that the interface is ready.
751 **/
752
753 static int
754 e1000_open(struct net_device *netdev)
755 {
756 struct e1000_adapter *adapter = netdev->priv;
757 int err;
758
759 /* allocate transmit descriptors */
760
761 if((err = e1000_setup_tx_resources(adapter)))
762 goto err_setup_tx;
763
764 /* allocate receive descriptors */
765
766 if((err = e1000_setup_rx_resources(adapter)))
767 goto err_setup_rx;
768
769 if((err = e1000_up(adapter)))
770 goto err_up;
771
772 return E1000_SUCCESS;
773
774 err_up:
775 e1000_free_rx_resources(adapter);
776 err_setup_rx:
777 e1000_free_tx_resources(adapter);
778 err_setup_tx:
779 e1000_reset(adapter);
780
781 return err;
782 }
783
784 /**
785 * e1000_close - Disables a network interface
786 * @netdev: network interface device structure
787 *
788 * Returns 0, this is not allowed to fail
789 *
790 * The close entry point is called when an interface is de-activated
791 * by the OS. The hardware is still under the drivers control, but
792 * needs to be disabled. A global MAC reset is issued to stop the
793 * hardware, and all transmit and receive resources are freed.
794 **/
795
796 static int
797 e1000_close(struct net_device *netdev)
798 {
799 struct e1000_adapter *adapter = netdev->priv;
800
801 e1000_down(adapter);
802
803 e1000_free_tx_resources(adapter);
804 e1000_free_rx_resources(adapter);
805
806 return 0;
807 }
808
809 /**
810 * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
811 * @adapter: board private structure
812 *
813 * Return 0 on success, negative on failure
814 **/
815
816 int
817 e1000_setup_tx_resources(struct e1000_adapter *adapter)
818 {
819 struct e1000_desc_ring *txdr = &adapter->tx_ring;
820 struct pci_dev *pdev = adapter->pdev;
821 int size;
822
823 size = sizeof(struct e1000_buffer) * txdr->count;
824 txdr->buffer_info = vmalloc(size);
825 if(!txdr->buffer_info) {
826 DPRINTK(PROBE, ERR,
827 "Unble to Allocate Memory for the Transmit descriptor ring\n");
828 return -ENOMEM;
829 }
830 memset(txdr->buffer_info, 0, size);
831
832 /* round up to nearest 4K */
833
834 txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
835 E1000_ROUNDUP(txdr->size, 4096);
836
837 txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
838 if(!txdr->desc) {
839 DPRINTK(PROBE, ERR,
840 "Unble to Allocate Memory for the Transmit descriptor ring\n");
841 vfree(txdr->buffer_info);
842 return -ENOMEM;
843 }
844 memset(txdr->desc, 0, txdr->size);
845
846 txdr->next_to_use = 0;
847 txdr->next_to_clean = 0;
848
849 return 0;
850 }
851
852 /**
853 * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
854 * @adapter: board private structure
855 *
856 * Configure the Tx unit of the MAC after a reset.
857 **/
858
859 static void
860 e1000_configure_tx(struct e1000_adapter *adapter)
861 {
862 uint64_t tdba = adapter->tx_ring.dma;
863 uint32_t tdlen = adapter->tx_ring.count * sizeof(struct e1000_tx_desc);
864 uint32_t tctl, tipg;
865
866 E1000_WRITE_REG(&adapter->hw, TDBAL, (tdba & 0x00000000ffffffffULL));
867 E1000_WRITE_REG(&adapter->hw, TDBAH, (tdba >> 32));
868
869 E1000_WRITE_REG(&adapter->hw, TDLEN, tdlen);
870
871 /* Setup the HW Tx Head and Tail descriptor pointers */
872
873 E1000_WRITE_REG(&adapter->hw, TDH, 0);
874 E1000_WRITE_REG(&adapter->hw, TDT, 0);
875
876 /* Set the default values for the Tx Inter Packet Gap timer */
877
878 switch (adapter->hw.mac_type) {
879 case e1000_82542_rev2_0:
880 case e1000_82542_rev2_1:
881 tipg = DEFAULT_82542_TIPG_IPGT;
882 tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
883 tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
884 break;
885 default:
886 if(adapter->hw.media_type == e1000_media_type_fiber ||
887 adapter->hw.media_type == e1000_media_type_internal_serdes)
888 tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
889 else
890 tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
891 tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
892 tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
893 }
894 E1000_WRITE_REG(&adapter->hw, TIPG, tipg);
895
896 /* Set the Tx Interrupt Delay register */
897
898 E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay);
899 if(adapter->hw.mac_type >= e1000_82540)
900 E1000_WRITE_REG(&adapter->hw, TADV, adapter->tx_abs_int_delay);
901
902 /* Program the Transmit Control Register */
903
904 tctl = E1000_READ_REG(&adapter->hw, TCTL);
905
906 tctl &= ~E1000_TCTL_CT;
907 tctl |= E1000_TCTL_EN | E1000_TCTL_PSP |
908 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
909
910 E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
911
912 e1000_config_collision_dist(&adapter->hw);
913
914 /* Setup Transmit Descriptor Settings for eop descriptor */
915 adapter->txd_cmd = E1000_TXD_CMD_IDE | E1000_TXD_CMD_EOP |
916 E1000_TXD_CMD_IFCS;
917
918 if(adapter->hw.mac_type < e1000_82543)
919 adapter->txd_cmd |= E1000_TXD_CMD_RPS;
920 else
921 adapter->txd_cmd |= E1000_TXD_CMD_RS;
922
923 /* Cache if we're 82544 running in PCI-X because we'll
924 * need this to apply a workaround later in the send path. */
925 if(adapter->hw.mac_type == e1000_82544 &&
926 adapter->hw.bus_type == e1000_bus_type_pcix)
927 adapter->pcix_82544 = 1;
928 }
929
930 /**
931 * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
932 * @adapter: board private structure
933 *
934 * Returns 0 on success, negative on failure
935 **/
936
937 int
938 e1000_setup_rx_resources(struct e1000_adapter *adapter)
939 {
940 struct e1000_desc_ring *rxdr = &adapter->rx_ring;
941 struct pci_dev *pdev = adapter->pdev;
942 int size;
943
944 size = sizeof(struct e1000_buffer) * rxdr->count;
945 rxdr->buffer_info = vmalloc(size);
946 if(!rxdr->buffer_info) {
947 DPRINTK(PROBE, ERR,
948 "Unble to Allocate Memory for the Recieve descriptor ring\n");
949 return -ENOMEM;
950 }
951 memset(rxdr->buffer_info, 0, size);
952
953 /* Round up to nearest 4K */
954
955 rxdr->size = rxdr->count * sizeof(struct e1000_rx_desc);
956 E1000_ROUNDUP(rxdr->size, 4096);
957
958 rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
959
960 if(!rxdr->desc) {
961 DPRINTK(PROBE, ERR,
962 "Unble to Allocate Memory for the Recieve descriptor ring\n");
963 vfree(rxdr->buffer_info);
964 return -ENOMEM;
965 }
966 memset(rxdr->desc, 0, rxdr->size);
967
968 rxdr->next_to_clean = 0;
969 rxdr->next_to_use = 0;
970
971 return 0;
972 }
973
974 /**
975 * e1000_setup_rctl - configure the receive control register
976 * @adapter: Board private structure
977 **/
978
979 static void
980 e1000_setup_rctl(struct e1000_adapter *adapter)
981 {
982 uint32_t rctl;
983
984 rctl = E1000_READ_REG(&adapter->hw, RCTL);
985
986 rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
987
988 rctl |= E1000_RCTL_EN | E1000_RCTL_BAM |
989 E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
990 (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT);
991
992 if(adapter->hw.tbi_compatibility_on == 1)
993 rctl |= E1000_RCTL_SBP;
994 else
995 rctl &= ~E1000_RCTL_SBP;
996
997 /* Setup buffer sizes */
998 rctl &= ~(E1000_RCTL_SZ_4096);
999 rctl |= (E1000_RCTL_BSEX | E1000_RCTL_LPE);
1000 switch (adapter->rx_buffer_len) {
1001 case E1000_RXBUFFER_2048:
1002 default:
1003 rctl |= E1000_RCTL_SZ_2048;
1004 rctl &= ~(E1000_RCTL_BSEX | E1000_RCTL_LPE);
1005 break;
1006 case E1000_RXBUFFER_4096:
1007 rctl |= E1000_RCTL_SZ_4096;
1008 break;
1009 case E1000_RXBUFFER_8192:
1010 rctl |= E1000_RCTL_SZ_8192;
1011 break;
1012 case E1000_RXBUFFER_16384:
1013 rctl |= E1000_RCTL_SZ_16384;
1014 break;
1015 }
1016
1017 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
1018 }
1019
1020 /**
1021 * e1000_configure_rx - Configure 8254x Receive Unit after Reset
1022 * @adapter: board private structure
1023 *
1024 * Configure the Rx unit of the MAC after a reset.
1025 **/
1026
1027 static void
1028 e1000_configure_rx(struct e1000_adapter *adapter)
1029 {
1030 uint64_t rdba = adapter->rx_ring.dma;
1031 uint32_t rdlen = adapter->rx_ring.count * sizeof(struct e1000_rx_desc);
1032 uint32_t rctl;
1033 uint32_t rxcsum;
1034
1035 /* disable receives while setting up the descriptors */
1036 rctl = E1000_READ_REG(&adapter->hw, RCTL);
1037 E1000_WRITE_REG(&adapter->hw, RCTL, rctl & ~E1000_RCTL_EN);
1038
1039 /* set the Receive Delay Timer Register */
1040 E1000_WRITE_REG(&adapter->hw, RDTR, adapter->rx_int_delay);
1041
1042 if(adapter->hw.mac_type >= e1000_82540) {
1043 E1000_WRITE_REG(&adapter->hw, RADV, adapter->rx_abs_int_delay);
1044 if(adapter->itr > 1)
1045 E1000_WRITE_REG(&adapter->hw, ITR,
1046 1000000000 / (adapter->itr * 256));
1047 }
1048
1049 /* Setup the Base and Length of the Rx Descriptor Ring */
1050 E1000_WRITE_REG(&adapter->hw, RDBAL, (rdba & 0x00000000ffffffffULL));
1051 E1000_WRITE_REG(&adapter->hw, RDBAH, (rdba >> 32));
1052
1053 E1000_WRITE_REG(&adapter->hw, RDLEN, rdlen);
1054
1055 /* Setup the HW Rx Head and Tail Descriptor Pointers */
1056 E1000_WRITE_REG(&adapter->hw, RDH, 0);
1057 E1000_WRITE_REG(&adapter->hw, RDT, 0);
1058
1059 /* Enable 82543 Receive Checksum Offload for TCP and UDP */
1060 if((adapter->hw.mac_type >= e1000_82543) &&
1061 (adapter->rx_csum == TRUE)) {
1062 rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM);
1063 rxcsum |= E1000_RXCSUM_TUOFL;
1064 E1000_WRITE_REG(&adapter->hw, RXCSUM, rxcsum);
1065 }
1066
1067 /* Enable Receives */
1068 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
1069 }
1070
1071 /**
1072 * e1000_free_tx_resources - Free Tx Resources
1073 * @adapter: board private structure
1074 *
1075 * Free all transmit software resources
1076 **/
1077
1078 void
1079 e1000_free_tx_resources(struct e1000_adapter *adapter)
1080 {
1081 struct pci_dev *pdev = adapter->pdev;
1082
1083 e1000_clean_tx_ring(adapter);
1084
1085 vfree(adapter->tx_ring.buffer_info);
1086 adapter->tx_ring.buffer_info = NULL;
1087
1088 pci_free_consistent(pdev, adapter->tx_ring.size,
1089 adapter->tx_ring.desc, adapter->tx_ring.dma);
1090
1091 adapter->tx_ring.desc = NULL;
1092 }
1093
1094 static inline void
1095 e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter,
1096 struct e1000_buffer *buffer_info)
1097 {
1098 struct pci_dev *pdev = adapter->pdev;
1099 if(buffer_info->dma) {
1100 pci_unmap_page(pdev,
1101 buffer_info->dma,
1102 buffer_info->length,
1103 PCI_DMA_TODEVICE);
1104 buffer_info->dma = 0;
1105 }
1106 if(buffer_info->skb) {
1107 dev_kfree_skb_any(buffer_info->skb);
1108 buffer_info->skb = NULL;
1109 }
1110 }
1111
1112 /**
1113 * e1000_clean_tx_ring - Free Tx Buffers
1114 * @adapter: board private structure
1115 **/
1116
1117 static void
1118 e1000_clean_tx_ring(struct e1000_adapter *adapter)
1119 {
1120 struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
1121 struct e1000_buffer *buffer_info;
1122 unsigned long size;
1123 unsigned int i;
1124
1125 /* Free all the Tx ring sk_buffs */
1126
1127 for(i = 0; i < tx_ring->count; i++) {
1128 buffer_info = &tx_ring->buffer_info[i];
1129 e1000_unmap_and_free_tx_resource(adapter, buffer_info);
1130 }
1131
1132 size = sizeof(struct e1000_buffer) * tx_ring->count;
1133 memset(tx_ring->buffer_info, 0, size);
1134
1135 /* Zero out the descriptor ring */
1136
1137 memset(tx_ring->desc, 0, tx_ring->size);
1138
1139 tx_ring->next_to_use = 0;
1140 tx_ring->next_to_clean = 0;
1141
1142 E1000_WRITE_REG(&adapter->hw, TDH, 0);
1143 E1000_WRITE_REG(&adapter->hw, TDT, 0);
1144 }
1145
1146 /**
1147 * e1000_free_rx_resources - Free Rx Resources
1148 * @adapter: board private structure
1149 *
1150 * Free all receive software resources
1151 **/
1152
1153 void
1154 e1000_free_rx_resources(struct e1000_adapter *adapter)
1155 {
1156 struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
1157 struct pci_dev *pdev = adapter->pdev;
1158
1159 e1000_clean_rx_ring(adapter);
1160
1161 vfree(rx_ring->buffer_info);
1162 rx_ring->buffer_info = NULL;
1163
1164 pci_free_consistent(pdev, rx_ring->size, rx_ring->desc, rx_ring->dma);
1165
1166 rx_ring->desc = NULL;
1167 }
1168
1169 /**
1170 * e1000_clean_rx_ring - Free Rx Buffers
1171 * @adapter: board private structure
1172 **/
1173
1174 static void
1175 e1000_clean_rx_ring(struct e1000_adapter *adapter)
1176 {
1177 struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
1178 struct e1000_buffer *buffer_info;
1179 struct pci_dev *pdev = adapter->pdev;
1180 unsigned long size;
1181 unsigned int i;
1182
1183 /* Free all the Rx ring sk_buffs */
1184
1185 for(i = 0; i < rx_ring->count; i++) {
1186 buffer_info = &rx_ring->buffer_info[i];
1187 if(buffer_info->skb) {
1188
1189 pci_unmap_single(pdev,
1190 buffer_info->dma,
1191 buffer_info->length,
1192 PCI_DMA_FROMDEVICE);
1193
1194 dev_kfree_skb(buffer_info->skb);
1195 buffer_info->skb = NULL;
1196 }
1197 }
1198
1199 size = sizeof(struct e1000_buffer) * rx_ring->count;
1200 memset(rx_ring->buffer_info, 0, size);
1201
1202 /* Zero out the descriptor ring */
1203
1204 memset(rx_ring->desc, 0, rx_ring->size);
1205
1206 rx_ring->next_to_clean = 0;
1207 rx_ring->next_to_use = 0;
1208
1209 E1000_WRITE_REG(&adapter->hw, RDH, 0);
1210 E1000_WRITE_REG(&adapter->hw, RDT, 0);
1211 }
1212
1213 /* The 82542 2.0 (revision 2) needs to have the receive unit in reset
1214 * and memory write and invalidate disabled for certain operations
1215 */
1216 static void
1217 e1000_enter_82542_rst(struct e1000_adapter *adapter)
1218 {
1219 struct net_device *netdev = adapter->netdev;
1220 uint32_t rctl;
1221
1222 e1000_pci_clear_mwi(&adapter->hw);
1223
1224 rctl = E1000_READ_REG(&adapter->hw, RCTL);
1225 rctl |= E1000_RCTL_RST;
1226 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
1227 E1000_WRITE_FLUSH(&adapter->hw);
1228 mdelay(5);
1229
1230 if(netif_running(netdev))
1231 e1000_clean_rx_ring(adapter);
1232 }
1233
1234 static void
1235 e1000_leave_82542_rst(struct e1000_adapter *adapter)
1236 {
1237 struct net_device *netdev = adapter->netdev;
1238 uint32_t rctl;
1239
1240 rctl = E1000_READ_REG(&adapter->hw, RCTL);
1241 rctl &= ~E1000_RCTL_RST;
1242 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
1243 E1000_WRITE_FLUSH(&adapter->hw);
1244 mdelay(5);
1245
1246 if(adapter->hw.pci_cmd_word & PCI_COMMAND_INVALIDATE)
1247 e1000_pci_set_mwi(&adapter->hw);
1248
1249 if(netif_running(netdev)) {
1250 e1000_configure_rx(adapter);
1251 e1000_alloc_rx_buffers(adapter);
1252 }
1253 }
1254
1255 /**
1256 * e1000_set_mac - Change the Ethernet Address of the NIC
1257 * @netdev: network interface device structure
1258 * @p: pointer to an address structure
1259 *
1260 * Returns 0 on success, negative on failure
1261 **/
1262
1263 static int
1264 e1000_set_mac(struct net_device *netdev, void *p)
1265 {
1266 struct e1000_adapter *adapter = netdev->priv;
1267 struct sockaddr *addr = p;
1268
1269 if(!is_valid_ether_addr(addr->sa_data))
1270 return -EADDRNOTAVAIL;
1271
1272 /* 82542 2.0 needs to be in reset to write receive address registers */
1273
1274 if(adapter->hw.mac_type == e1000_82542_rev2_0)
1275 e1000_enter_82542_rst(adapter);
1276
1277 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
1278 memcpy(adapter->hw.mac_addr, addr->sa_data, netdev->addr_len);
1279
1280 e1000_rar_set(&adapter->hw, adapter->hw.mac_addr, 0);
1281
1282 if(adapter->hw.mac_type == e1000_82542_rev2_0)
1283 e1000_leave_82542_rst(adapter);
1284
1285 return 0;
1286 }
1287
1288 /**
1289 * e1000_set_multi - Multicast and Promiscuous mode set
1290 * @netdev: network interface device structure
1291 *
1292 * The set_multi entry point is called whenever the multicast address
1293 * list or the network interface flags are updated. This routine is
1294 * responsible for configuring the hardware for proper multicast,
1295 * promiscuous mode, and all-multi behavior.
1296 **/
1297
1298 static void
1299 e1000_set_multi(struct net_device *netdev)
1300 {
1301 struct e1000_adapter *adapter = netdev->priv;
1302 struct e1000_hw *hw = &adapter->hw;
1303 struct dev_mc_list *mc_ptr;
1304 uint32_t rctl;
1305 uint32_t hash_value;
1306 int i;
1307 unsigned long flags;
1308
1309 /* Check for Promiscuous and All Multicast modes */
1310
1311 spin_lock_irqsave(&adapter->tx_lock, flags);
1312
1313 rctl = E1000_READ_REG(hw, RCTL);
1314
1315 if(netdev->flags & IFF_PROMISC) {
1316 rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
1317 } else if(netdev->flags & IFF_ALLMULTI) {
1318 rctl |= E1000_RCTL_MPE;
1319 rctl &= ~E1000_RCTL_UPE;
1320 } else {
1321 rctl &= ~(E1000_RCTL_UPE | E1000_RCTL_MPE);
1322 }
1323
1324 E1000_WRITE_REG(hw, RCTL, rctl);
1325
1326 /* 82542 2.0 needs to be in reset to write receive address registers */
1327
1328 if(hw->mac_type == e1000_82542_rev2_0)
1329 e1000_enter_82542_rst(adapter);
1330
1331 /* load the first 14 multicast address into the exact filters 1-14
1332 * RAR 0 is used for the station MAC adddress
1333 * if there are not 14 addresses, go ahead and clear the filters
1334 */
1335 mc_ptr = netdev->mc_list;
1336
1337 for(i = 1; i < E1000_RAR_ENTRIES; i++) {
1338 if(mc_ptr) {
1339 e1000_rar_set(hw, mc_ptr->dmi_addr, i);
1340 mc_ptr = mc_ptr->next;
1341 } else {
1342 E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
1343 E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
1344 }
1345 }
1346
1347 /* clear the old settings from the multicast hash table */
1348
1349 for(i = 0; i < E1000_NUM_MTA_REGISTERS; i++)
1350 E1000_WRITE_REG_ARRAY(hw, MTA, i, 0);
1351
1352 /* load any remaining addresses into the hash table */
1353
1354 for(; mc_ptr; mc_ptr = mc_ptr->next) {
1355 hash_value = e1000_hash_mc_addr(hw, mc_ptr->dmi_addr);
1356 e1000_mta_set(hw, hash_value);
1357 }
1358
1359 if(hw->mac_type == e1000_82542_rev2_0)
1360 e1000_leave_82542_rst(adapter);
1361
1362 spin_unlock_irqrestore(&adapter->tx_lock, flags);
1363 }
1364
1365 /* Need to wait a few seconds after link up to get diagnostic information from
1366 * the phy */
1367
1368 static void
1369 e1000_update_phy_info(unsigned long data)
1370 {
1371 struct e1000_adapter *adapter = (struct e1000_adapter *) data;
1372 e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
1373 }
1374
1375 /**
1376 * e1000_82547_tx_fifo_stall - Timer Call-back
1377 * @data: pointer to adapter cast into an unsigned long
1378 **/
1379
1380 static void
1381 e1000_82547_tx_fifo_stall(unsigned long data)
1382 {
1383 struct e1000_adapter *adapter = (struct e1000_adapter *) data;
1384 struct net_device *netdev = adapter->netdev;
1385 uint32_t tctl;
1386
1387 if(atomic_read(&adapter->tx_fifo_stall)) {
1388 if((E1000_READ_REG(&adapter->hw, TDT) ==
1389 E1000_READ_REG(&adapter->hw, TDH)) &&
1390 (E1000_READ_REG(&adapter->hw, TDFT) ==
1391 E1000_READ_REG(&adapter->hw, TDFH)) &&
1392 (E1000_READ_REG(&adapter->hw, TDFTS) ==
1393 E1000_READ_REG(&adapter->hw, TDFHS))) {
1394 tctl = E1000_READ_REG(&adapter->hw, TCTL);
1395 E1000_WRITE_REG(&adapter->hw, TCTL,
1396 tctl & ~E1000_TCTL_EN);
1397 E1000_WRITE_REG(&adapter->hw, TDFT,
1398 adapter->tx_head_addr);
1399 E1000_WRITE_REG(&adapter->hw, TDFH,
1400 adapter->tx_head_addr);
1401 E1000_WRITE_REG(&adapter->hw, TDFTS,
1402 adapter->tx_head_addr);
1403 E1000_WRITE_REG(&adapter->hw, TDFHS,
1404 adapter->tx_head_addr);
1405 E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
1406 E1000_WRITE_FLUSH(&adapter->hw);
1407
1408 adapter->tx_fifo_head = 0;
1409 atomic_set(&adapter->tx_fifo_stall, 0);
1410 netif_wake_queue(netdev);
1411 } else {
1412 mod_timer(&adapter->tx_fifo_stall_timer, jiffies + 1);
1413 }
1414 }
1415 }
1416
1417 /**
1418 * e1000_watchdog - Timer Call-back
1419 * @data: pointer to netdev cast into an unsigned long
1420 **/
1421
1422 static void
1423 e1000_watchdog(unsigned long data)
1424 {
1425 struct e1000_adapter *adapter = (struct e1000_adapter *) data;
1426 struct net_device *netdev = adapter->netdev;
1427 struct e1000_desc_ring *txdr = &adapter->tx_ring;
1428 unsigned int i;
1429 uint32_t link;
1430
1431 e1000_check_for_link(&adapter->hw);
1432
1433 if((adapter->hw.media_type == e1000_media_type_internal_serdes) &&
1434 !(E1000_READ_REG(&adapter->hw, TXCW) & E1000_TXCW_ANE))
1435 link = !adapter->hw.serdes_link_down;
1436 else
1437 link = E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU;
1438
1439 if(link) {
1440 if(!netif_carrier_ok(netdev)) {
1441 e1000_get_speed_and_duplex(&adapter->hw,
1442 &adapter->link_speed,
1443 &adapter->link_duplex);
1444
1445 DPRINTK(LINK, INFO, "NIC Link is Up %d Mbps %s\n",
1446 adapter->link_speed,
1447 adapter->link_duplex == FULL_DUPLEX ?
1448 "Full Duplex" : "Half Duplex");
1449
1450 netif_carrier_on(netdev);
1451 netif_wake_queue(netdev);
1452 mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
1453 adapter->smartspeed = 0;
1454 }
1455 } else {
1456 if(netif_carrier_ok(netdev)) {
1457 adapter->link_speed = 0;
1458 adapter->link_duplex = 0;
1459 DPRINTK(LINK, INFO, "NIC Link is Down\n");
1460 netif_carrier_off(netdev);
1461 netif_stop_queue(netdev);
1462 mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
1463 }
1464
1465 e1000_smartspeed(adapter);
1466 }
1467
1468 e1000_update_stats(adapter);
1469
1470 adapter->hw.tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
1471 adapter->tpt_old = adapter->stats.tpt;
1472 adapter->hw.collision_delta = adapter->stats.colc - adapter->colc_old;
1473 adapter->colc_old = adapter->stats.colc;
1474
1475 adapter->gorcl = adapter->stats.gorcl - adapter->gorcl_old;
1476 adapter->gorcl_old = adapter->stats.gorcl;
1477 adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old;
1478 adapter->gotcl_old = adapter->stats.gotcl;
1479
1480 e1000_update_adaptive(&adapter->hw);
1481
1482 if(!netif_carrier_ok(netdev)) {
1483 if(E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
1484 /* We've lost link, so the controller stops DMA,
1485 * but we've got queued Tx work that's never going
1486 * to get done, so reset controller to flush Tx.
1487 * (Do the reset outside of interrupt context). */
1488 schedule_work(&adapter->tx_timeout_task);
1489 }
1490 }
1491
1492 /* Dynamic mode for Interrupt Throttle Rate (ITR) */
1493 if(adapter->hw.mac_type >= e1000_82540 && adapter->itr == 1) {
1494 /* Symmetric Tx/Rx gets a reduced ITR=2000; Total
1495 * asymmetrical Tx or Rx gets ITR=8000; everyone
1496 * else is between 2000-8000. */
1497 uint32_t goc = (adapter->gotcl + adapter->gorcl) / 10000;
1498 uint32_t dif = (adapter->gotcl > adapter->gorcl ?
1499 adapter->gotcl - adapter->gorcl :
1500 adapter->gorcl - adapter->gotcl) / 10000;
1501 uint32_t itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000;
1502 E1000_WRITE_REG(&adapter->hw, ITR, 1000000000 / (itr * 256));
1503 }
1504
1505 /* Cause software interrupt to ensure rx ring is cleaned */
1506 E1000_WRITE_REG(&adapter->hw, ICS, E1000_ICS_RXDMT0);
1507
1508 /* Early detection of hung controller */
1509 i = txdr->next_to_clean;
1510 if(txdr->buffer_info[i].dma &&
1511 time_after(jiffies, txdr->buffer_info[i].time_stamp + HZ) &&
1512 !(E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF))
1513 netif_stop_queue(netdev);
1514
1515 /* Reset the timer */
1516 mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
1517 }
1518
1519 #define E1000_TX_FLAGS_CSUM 0x00000001
1520 #define E1000_TX_FLAGS_VLAN 0x00000002
1521 #define E1000_TX_FLAGS_TSO 0x00000004
1522 #define E1000_TX_FLAGS_VLAN_MASK 0xffff0000
1523 #define E1000_TX_FLAGS_VLAN_SHIFT 16
1524
1525 static inline boolean_t
1526 e1000_tso(struct e1000_adapter *adapter, struct sk_buff *skb)
1527 {
1528 #ifdef NETIF_F_TSO
1529 struct e1000_context_desc *context_desc;
1530 unsigned int i;
1531 uint32_t cmd_length = 0;
1532 uint16_t ipcse, tucse, mss;
1533 uint8_t ipcss, ipcso, tucss, tucso, hdr_len;
1534
1535 if(skb_shinfo(skb)->tso_size) {
1536 hdr_len = ((skb->h.raw - skb->data) + (skb->h.th->doff << 2));
1537 mss = skb_shinfo(skb)->tso_size;
1538 skb->nh.iph->tot_len = 0;
1539 skb->nh.iph->check = 0;
1540 skb->h.th->check = ~csum_tcpudp_magic(skb->nh.iph->saddr,
1541 skb->nh.iph->daddr,
1542 0,
1543 IPPROTO_TCP,
1544 0);
1545 ipcss = skb->nh.raw - skb->data;
1546 ipcso = (void *)&(skb->nh.iph->check) - (void *)skb->data;
1547 ipcse = skb->h.raw - skb->data - 1;
1548 tucss = skb->h.raw - skb->data;
1549 tucso = (void *)&(skb->h.th->check) - (void *)skb->data;
1550 tucse = 0;
1551
1552 cmd_length |= (E1000_TXD_CMD_DEXT | E1000_TXD_CMD_TSE |
1553 E1000_TXD_CMD_IP | E1000_TXD_CMD_TCP |
1554 (skb->len - (hdr_len)));
1555
1556 i = adapter->tx_ring.next_to_use;
1557 context_desc = E1000_CONTEXT_DESC(adapter->tx_ring, i);
1558
1559 context_desc->lower_setup.ip_fields.ipcss = ipcss;
1560 context_desc->lower_setup.ip_fields.ipcso = ipcso;
1561 context_desc->lower_setup.ip_fields.ipcse = cpu_to_le16(ipcse);
1562 context_desc->upper_setup.tcp_fields.tucss = tucss;
1563 context_desc->upper_setup.tcp_fields.tucso = tucso;
1564 context_desc->upper_setup.tcp_fields.tucse = cpu_to_le16(tucse);
1565 context_desc->tcp_seg_setup.fields.mss = cpu_to_le16(mss);
1566 context_desc->tcp_seg_setup.fields.hdr_len = hdr_len;
1567 context_desc->cmd_and_length = cpu_to_le32(cmd_length);
1568
1569 if(++i == adapter->tx_ring.count) i = 0;
1570 adapter->tx_ring.next_to_use = i;
1571
1572 return TRUE;
1573 }
1574 #endif
1575
1576 return FALSE;
1577 }
1578
1579 static inline boolean_t
1580 e1000_tx_csum(struct e1000_adapter *adapter, struct sk_buff *skb)
1581 {
1582 struct e1000_context_desc *context_desc;
1583 unsigned int i;
1584 uint8_t css;
1585
1586 if(likely(skb->ip_summed == CHECKSUM_HW)) {
1587 css = skb->h.raw - skb->data;
1588
1589 i = adapter->tx_ring.next_to_use;
1590 context_desc = E1000_CONTEXT_DESC(adapter->tx_ring, i);
1591
1592 context_desc->upper_setup.tcp_fields.tucss = css;
1593 context_desc->upper_setup.tcp_fields.tucso = css + skb->csum;
1594 context_desc->upper_setup.tcp_fields.tucse = 0;
1595 context_desc->tcp_seg_setup.data = 0;
1596 context_desc->cmd_and_length = cpu_to_le32(E1000_TXD_CMD_DEXT);
1597
1598 if(unlikely(++i == adapter->tx_ring.count)) i = 0;
1599 adapter->tx_ring.next_to_use = i;
1600
1601 return TRUE;
1602 }
1603
1604 return FALSE;
1605 }
1606
1607 #define E1000_MAX_TXD_PWR 12
1608 #define E1000_MAX_DATA_PER_TXD (1<<E1000_MAX_TXD_PWR)
1609
1610 static inline int
1611 e1000_tx_map(struct e1000_adapter *adapter, struct sk_buff *skb,
1612 unsigned int first, unsigned int max_per_txd,
1613 unsigned int nr_frags, unsigned int mss)
1614 {
1615 struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
1616 struct e1000_buffer *buffer_info;
1617 unsigned int len = skb->len;
1618 unsigned int offset = 0, size, count = 0, i;
1619 unsigned int f;
1620 len -= skb->data_len;
1621
1622 i = tx_ring->next_to_use;
1623
1624 while(len) {
1625 buffer_info = &tx_ring->buffer_info[i];
1626 size = min(len, max_per_txd);
1627 #ifdef NETIF_F_TSO
1628 /* Workaround for premature desc write-backs
1629 * in TSO mode. Append 4-byte sentinel desc */
1630 if(unlikely(mss && !nr_frags && size == len && size > 8))
1631 size -= 4;
1632 #endif
1633 /* Workaround for potential 82544 hang in PCI-X. Avoid
1634 * terminating buffers within evenly-aligned dwords. */
1635 if(unlikely(adapter->pcix_82544 &&
1636 !((unsigned long)(skb->data + offset + size - 1) & 4) &&
1637 size > 4))
1638 size -= 4;
1639
1640 buffer_info->length = size;
1641 buffer_info->dma =
1642 pci_map_single(adapter->pdev,
1643 skb->data + offset,
1644 size,
1645 PCI_DMA_TODEVICE);
1646 buffer_info->time_stamp = jiffies;
1647
1648 len -= size;
1649 offset += size;
1650 count++;
1651 if(unlikely(++i == tx_ring->count)) i = 0;
1652 }
1653
1654 for(f = 0; f < nr_frags; f++) {
1655 struct skb_frag_struct *frag;
1656
1657 frag = &skb_shinfo(skb)->frags[f];
1658 len = frag->size;
1659 offset = frag->page_offset;
1660
1661 while(len) {
1662 buffer_info = &tx_ring->buffer_info[i];
1663 size = min(len, max_per_txd);
1664 #ifdef NETIF_F_TSO
1665 /* Workaround for premature desc write-backs
1666 * in TSO mode. Append 4-byte sentinel desc */
1667 if(unlikely(mss && f == (nr_frags-1) && size == len && size > 8))
1668 size -= 4;
1669 #endif
1670 /* Workaround for potential 82544 hang in PCI-X.
1671 * Avoid terminating buffers within evenly-aligned
1672 * dwords. */
1673 if(unlikely(adapter->pcix_82544 &&
1674 !((unsigned long)(frag->page+offset+size-1) & 4) &&
1675 size > 4))
1676 size -= 4;
1677
1678 buffer_info->length = size;
1679 buffer_info->dma =
1680 pci_map_page(adapter->pdev,
1681 frag->page,
1682 offset,
1683 size,
1684 PCI_DMA_TODEVICE);
1685 buffer_info->time_stamp = jiffies;
1686
1687 len -= size;
1688 offset += size;
1689 count++;
1690 if(unlikely(++i == tx_ring->count)) i = 0;
1691 }
1692 }
1693
1694 i = (i == 0) ? tx_ring->count - 1 : i - 1;
1695 tx_ring->buffer_info[i].skb = skb;
1696 tx_ring->buffer_info[first].next_to_watch = i;
1697
1698 return count;
1699 }
1700
1701 static inline void
1702 e1000_tx_queue(struct e1000_adapter *adapter, int count, int tx_flags)
1703 {
1704 struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
1705 struct e1000_tx_desc *tx_desc = NULL;
1706 struct e1000_buffer *buffer_info;
1707 uint32_t txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
1708 unsigned int i;
1709
1710 if(likely(tx_flags & E1000_TX_FLAGS_TSO)) {
1711 txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D |
1712 E1000_TXD_CMD_TSE;
1713 txd_upper |= (E1000_TXD_POPTS_IXSM | E1000_TXD_POPTS_TXSM) << 8;
1714 }
1715
1716 if(likely(tx_flags & E1000_TX_FLAGS_CSUM)) {
1717 txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
1718 txd_upper |= E1000_TXD_POPTS_TXSM << 8;
1719 }
1720
1721 if(unlikely(tx_flags & E1000_TX_FLAGS_VLAN)) {
1722 txd_lower |= E1000_TXD_CMD_VLE;
1723 txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
1724 }
1725
1726 i = tx_ring->next_to_use;
1727
1728 while(count--) {
1729 buffer_info = &tx_ring->buffer_info[i];
1730 tx_desc = E1000_TX_DESC(*tx_ring, i);
1731 tx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
1732 tx_desc->lower.data =
1733 cpu_to_le32(txd_lower | buffer_info->length);
1734 tx_desc->upper.data = cpu_to_le32(txd_upper);
1735 if(unlikely(++i == tx_ring->count)) i = 0;
1736 }
1737
1738 tx_desc->lower.data |= cpu_to_le32(adapter->txd_cmd);
1739
1740 /* Force memory writes to complete before letting h/w
1741 * know there are new descriptors to fetch. (Only
1742 * applicable for weak-ordered memory model archs,
1743 * such as IA-64). */
1744 wmb();
1745
1746 tx_ring->next_to_use = i;
1747 E1000_WRITE_REG(&adapter->hw, TDT, i);
1748 }
1749
1750 /**
1751 * 82547 workaround to avoid controller hang in half-duplex environment.
1752 * The workaround is to avoid queuing a large packet that would span
1753 * the internal Tx FIFO ring boundary by notifying the stack to resend
1754 * the packet at a later time. This gives the Tx FIFO an opportunity to
1755 * flush all packets. When that occurs, we reset the Tx FIFO pointers
1756 * to the beginning of the Tx FIFO.
1757 **/
1758
1759 #define E1000_FIFO_HDR 0x10
1760 #define E1000_82547_PAD_LEN 0x3E0
1761
1762 static inline int
1763 e1000_82547_fifo_workaround(struct e1000_adapter *adapter, struct sk_buff *skb)
1764 {
1765 uint32_t fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
1766 uint32_t skb_fifo_len = skb->len + E1000_FIFO_HDR;
1767
1768 E1000_ROUNDUP(skb_fifo_len, E1000_FIFO_HDR);
1769
1770 if(adapter->link_duplex != HALF_DUPLEX)
1771 goto no_fifo_stall_required;
1772
1773 if(atomic_read(&adapter->tx_fifo_stall))
1774 return 1;
1775
1776 if(skb_fifo_len >= (E1000_82547_PAD_LEN + fifo_space)) {
1777 atomic_set(&adapter->tx_fifo_stall, 1);
1778 return 1;
1779 }
1780
1781 no_fifo_stall_required:
1782 adapter->tx_fifo_head += skb_fifo_len;
1783 if(adapter->tx_fifo_head >= adapter->tx_fifo_size)
1784 adapter->tx_fifo_head -= adapter->tx_fifo_size;
1785 return 0;
1786 }
1787
1788 #define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 )
1789 static int
1790 e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
1791 {
1792 struct e1000_adapter *adapter = netdev->priv;
1793 unsigned int first, max_per_txd = E1000_MAX_DATA_PER_TXD;
1794 unsigned int max_txd_pwr = E1000_MAX_TXD_PWR;
1795 unsigned int tx_flags = 0;
1796 unsigned int len = skb->len;
1797 unsigned long flags;
1798 unsigned int nr_frags = 0;
1799 unsigned int mss = 0;
1800 int count = 0;
1801 unsigned int f;
1802 len -= skb->data_len;
1803
1804 if(unlikely(skb->len <= 0)) {
1805 dev_kfree_skb_any(skb);
1806 return NETDEV_TX_OK;
1807 }
1808
1809 #ifdef NETIF_F_TSO
1810 mss = skb_shinfo(skb)->tso_size;
1811 /* The controller does a simple calculation to
1812 * make sure there is enough room in the FIFO before
1813 * initiating the DMA for each buffer. The calc is:
1814 * 4 = ceil(buffer len/mss). To make sure we don't
1815 * overrun the FIFO, adjust the max buffer len if mss
1816 * drops. */
1817 if(mss) {
1818 max_per_txd = min(mss << 2, max_per_txd);
1819 max_txd_pwr = fls(max_per_txd) - 1;
1820 }
1821
1822 if((mss) || (skb->ip_summed == CHECKSUM_HW))
1823 count++;
1824 count++; /* for sentinel desc */
1825 #else
1826 if(skb->ip_summed == CHECKSUM_HW)
1827 count++;
1828 #endif
1829 count += TXD_USE_COUNT(len, max_txd_pwr);
1830
1831 if(adapter->pcix_82544)
1832 count++;
1833
1834 nr_frags = skb_shinfo(skb)->nr_frags;
1835 for(f = 0; f < nr_frags; f++)
1836 count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size,
1837 max_txd_pwr);
1838 if(adapter->pcix_82544)
1839 count += nr_frags;
1840
1841 local_irq_save(flags);
1842 if (!spin_trylock(&adapter->tx_lock)) {
1843 /* Collision - tell upper layer to requeue */
1844 local_irq_restore(flags);
1845 return NETDEV_TX_LOCKED;
1846 }
1847
1848 /* need: count + 2 desc gap to keep tail from touching
1849 * head, otherwise try next time */
1850 if(unlikely(E1000_DESC_UNUSED(&adapter->tx_ring) < count + 2)) {
1851 netif_stop_queue(netdev);
1852 spin_unlock_irqrestore(&adapter->tx_lock, flags);
1853 return NETDEV_TX_BUSY;
1854 }
1855
1856 if(unlikely(adapter->hw.mac_type == e1000_82547)) {
1857 if(unlikely(e1000_82547_fifo_workaround(adapter, skb))) {
1858 netif_stop_queue(netdev);
1859 mod_timer(&adapter->tx_fifo_stall_timer, jiffies);
1860 spin_unlock_irqrestore(&adapter->tx_lock, flags);
1861 return NETDEV_TX_BUSY;
1862 }
1863 }
1864
1865 if(unlikely(adapter->vlgrp && vlan_tx_tag_present(skb))) {
1866 tx_flags |= E1000_TX_FLAGS_VLAN;
1867 tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
1868 }
1869
1870 first = adapter->tx_ring.next_to_use;
1871
1872 if(likely(e1000_tso(adapter, skb)))
1873 tx_flags |= E1000_TX_FLAGS_TSO;
1874 else if(likely(e1000_tx_csum(adapter, skb)))
1875 tx_flags |= E1000_TX_FLAGS_CSUM;
1876
1877 e1000_tx_queue(adapter,
1878 e1000_tx_map(adapter, skb, first, max_per_txd, nr_frags, mss),
1879 tx_flags);
1880
1881 netdev->trans_start = jiffies;
1882
1883 /* Make sure there is space in the ring for the next send. */
1884 if(unlikely(E1000_DESC_UNUSED(&adapter->tx_ring) < MAX_SKB_FRAGS + 2))
1885 netif_stop_queue(netdev);
1886
1887 spin_unlock_irqrestore(&adapter->tx_lock, flags);
1888 return NETDEV_TX_OK;
1889 }
1890
1891 /**
1892 * e1000_tx_timeout - Respond to a Tx Hang
1893 * @netdev: network interface device structure
1894 **/
1895
1896 static void
1897 e1000_tx_timeout(struct net_device *netdev)
1898 {
1899 struct e1000_adapter *adapter = netdev->priv;
1900
1901 /* Do the reset outside of interrupt context */
1902 schedule_work(&adapter->tx_timeout_task);
1903 }
1904
1905 static void
1906 e1000_tx_timeout_task(struct net_device *netdev)
1907 {
1908 struct e1000_adapter *adapter = netdev->priv;
1909
1910 e1000_down(adapter);
1911 e1000_up(adapter);
1912 }
1913
1914 /**
1915 * e1000_get_stats - Get System Network Statistics
1916 * @netdev: network interface device structure
1917 *
1918 * Returns the address of the device statistics structure.
1919 * The statistics are actually updated from the timer callback.
1920 **/
1921
1922 static struct net_device_stats *
1923 e1000_get_stats(struct net_device *netdev)
1924 {
1925 struct e1000_adapter *adapter = netdev->priv;
1926
1927 e1000_update_stats(adapter);
1928 return &adapter->net_stats;
1929 }
1930
1931 /**
1932 * e1000_change_mtu - Change the Maximum Transfer Unit
1933 * @netdev: network interface device structure
1934 * @new_mtu: new value for maximum frame size
1935 *
1936 * Returns 0 on success, negative on failure
1937 **/
1938
1939 static int
1940 e1000_change_mtu(struct net_device *netdev, int new_mtu)
1941 {
1942 struct e1000_adapter *adapter = netdev->priv;
1943 int old_mtu = adapter->rx_buffer_len;
1944 int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
1945
1946 if((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
1947 (max_frame > MAX_JUMBO_FRAME_SIZE)) {
1948 DPRINTK(PROBE, ERR, "Invalid MTU setting\n");
1949 return -EINVAL;
1950 }
1951
1952 if(max_frame <= MAXIMUM_ETHERNET_FRAME_SIZE) {
1953 adapter->rx_buffer_len = E1000_RXBUFFER_2048;
1954
1955 } else if(adapter->hw.mac_type < e1000_82543) {
1956 DPRINTK(PROBE, ERR, "Jumbo Frames not supported on 82542\n");
1957 return -EINVAL;
1958
1959 } else if(max_frame <= E1000_RXBUFFER_4096) {
1960 adapter->rx_buffer_len = E1000_RXBUFFER_4096;
1961
1962 } else if(max_frame <= E1000_RXBUFFER_8192) {
1963 adapter->rx_buffer_len = E1000_RXBUFFER_8192;
1964
1965 } else {
1966 adapter->rx_buffer_len = E1000_RXBUFFER_16384;
1967 }
1968
1969 if(old_mtu != adapter->rx_buffer_len && netif_running(netdev)) {
1970 e1000_down(adapter);
1971 e1000_up(adapter);
1972 }
1973
1974 netdev->mtu = new_mtu;
1975 adapter->hw.max_frame_size = max_frame;
1976
1977 return 0;
1978 }
1979
1980 /**
1981 * e1000_update_stats - Update the board statistics counters
1982 * @adapter: board private structure
1983 **/
1984
1985 void
1986 e1000_update_stats(struct e1000_adapter *adapter)
1987 {
1988 struct e1000_hw *hw = &adapter->hw;
1989 unsigned long flags;
1990 uint16_t phy_tmp;
1991
1992 #define PHY_IDLE_ERROR_COUNT_MASK 0x00FF
1993
1994 spin_lock_irqsave(&adapter->stats_lock, flags);
1995
1996 /* these counters are modified from e1000_adjust_tbi_stats,
1997 * called from the interrupt context, so they must only
1998 * be written while holding adapter->stats_lock
1999 */
2000
2001 adapter->stats.crcerrs += E1000_READ_REG(hw, CRCERRS);
2002 adapter->stats.gprc += E1000_READ_REG(hw, GPRC);
2003 adapter->stats.gorcl += E1000_READ_REG(hw, GORCL);
2004 adapter->stats.gorch += E1000_READ_REG(hw, GORCH);
2005 adapter->stats.bprc += E1000_READ_REG(hw, BPRC);
2006 adapter->stats.mprc += E1000_READ_REG(hw, MPRC);
2007 adapter->stats.roc += E1000_READ_REG(hw, ROC);
2008 adapter->stats.prc64 += E1000_READ_REG(hw, PRC64);
2009 adapter->stats.prc127 += E1000_READ_REG(hw, PRC127);
2010 adapter->stats.prc255 += E1000_READ_REG(hw, PRC255);
2011 adapter->stats.prc511 += E1000_READ_REG(hw, PRC511);
2012 adapter->stats.prc1023 += E1000_READ_REG(hw, PRC1023);
2013 adapter->stats.prc1522 += E1000_READ_REG(hw, PRC1522);
2014
2015 adapter->stats.symerrs += E1000_READ_REG(hw, SYMERRS);
2016 adapter->stats.mpc += E1000_READ_REG(hw, MPC);
2017 adapter->stats.scc += E1000_READ_REG(hw, SCC);
2018 adapter->stats.ecol += E1000_READ_REG(hw, ECOL);
2019 adapter->stats.mcc += E1000_READ_REG(hw, MCC);
2020 adapter->stats.latecol += E1000_READ_REG(hw, LATECOL);
2021 adapter->stats.dc += E1000_READ_REG(hw, DC);
2022 adapter->stats.sec += E1000_READ_REG(hw, SEC);
2023 adapter->stats.rlec += E1000_READ_REG(hw, RLEC);
2024 adapter->stats.xonrxc += E1000_READ_REG(hw, XONRXC);
2025 adapter->stats.xontxc += E1000_READ_REG(hw, XONTXC);
2026 adapter->stats.xoffrxc += E1000_READ_REG(hw, XOFFRXC);
2027 adapter->stats.xofftxc += E1000_READ_REG(hw, XOFFTXC);
2028 adapter->stats.fcruc += E1000_READ_REG(hw, FCRUC);
2029 adapter->stats.gptc += E1000_READ_REG(hw, GPTC);
2030 adapter->stats.gotcl += E1000_READ_REG(hw, GOTCL);
2031 adapter->stats.gotch += E1000_READ_REG(hw, GOTCH);
2032 adapter->stats.rnbc += E1000_READ_REG(hw, RNBC);
2033 adapter->stats.ruc += E1000_READ_REG(hw, RUC);
2034 adapter->stats.rfc += E1000_READ_REG(hw, RFC);
2035 adapter->stats.rjc += E1000_READ_REG(hw, RJC);
2036 adapter->stats.torl += E1000_READ_REG(hw, TORL);
2037 adapter->stats.torh += E1000_READ_REG(hw, TORH);
2038 adapter->stats.totl += E1000_READ_REG(hw, TOTL);
2039 adapter->stats.toth += E1000_READ_REG(hw, TOTH);
2040 adapter->stats.tpr += E1000_READ_REG(hw, TPR);
2041 adapter->stats.ptc64 += E1000_READ_REG(hw, PTC64);
2042 adapter->stats.ptc127 += E1000_READ_REG(hw, PTC127);
2043 adapter->stats.ptc255 += E1000_READ_REG(hw, PTC255);
2044 adapter->stats.ptc511 += E1000_READ_REG(hw, PTC511);
2045 adapter->stats.ptc1023 += E1000_READ_REG(hw, PTC1023);
2046 adapter->stats.ptc1522 += E1000_READ_REG(hw, PTC1522);
2047 adapter->stats.mptc += E1000_READ_REG(hw, MPTC);
2048 adapter->stats.bptc += E1000_READ_REG(hw, BPTC);
2049
2050 /* used for adaptive IFS */
2051
2052 hw->tx_packet_delta = E1000_READ_REG(hw, TPT);
2053 adapter->stats.tpt += hw->tx_packet_delta;
2054 hw->collision_delta = E1000_READ_REG(hw, COLC);
2055 adapter->stats.colc += hw->collision_delta;
2056
2057 if(hw->mac_type >= e1000_82543) {
2058 adapter->stats.algnerrc += E1000_READ_REG(hw, ALGNERRC);
2059 adapter->stats.rxerrc += E1000_READ_REG(hw, RXERRC);
2060 adapter->stats.tncrs += E1000_READ_REG(hw, TNCRS);
2061 adapter->stats.cexterr += E1000_READ_REG(hw, CEXTERR);
2062 adapter->stats.tsctc += E1000_READ_REG(hw, TSCTC);
2063 adapter->stats.tsctfc += E1000_READ_REG(hw, TSCTFC);
2064 }
2065
2066 /* Fill out the OS statistics structure */
2067
2068 adapter->net_stats.rx_packets = adapter->stats.gprc;
2069 adapter->net_stats.tx_packets = adapter->stats.gptc;
2070 adapter->net_stats.rx_bytes = adapter->stats.gorcl;
2071 adapter->net_stats.tx_bytes = adapter->stats.gotcl;
2072 adapter->net_stats.multicast = adapter->stats.mprc;
2073 adapter->net_stats.collisions = adapter->stats.colc;
2074
2075 /* Rx Errors */
2076
2077 adapter->net_stats.rx_errors = adapter->stats.rxerrc +
2078 adapter->stats.crcerrs + adapter->stats.algnerrc +
2079 adapter->stats.rlec + adapter->stats.rnbc +
2080 adapter->stats.mpc + adapter->stats.cexterr;
2081 adapter->net_stats.rx_dropped = adapter->stats.rnbc;
2082 adapter->net_stats.rx_length_errors = adapter->stats.rlec;
2083 adapter->net_stats.rx_crc_errors = adapter->stats.crcerrs;
2084 adapter->net_stats.rx_frame_errors = adapter->stats.algnerrc;
2085 adapter->net_stats.rx_fifo_errors = adapter->stats.mpc;
2086 adapter->net_stats.rx_missed_errors = adapter->stats.mpc;
2087
2088 /* Tx Errors */
2089
2090 adapter->net_stats.tx_errors = adapter->stats.ecol +
2091 adapter->stats.latecol;
2092 adapter->net_stats.tx_aborted_errors = adapter->stats.ecol;
2093 adapter->net_stats.tx_window_errors = adapter->stats.latecol;
2094 adapter->net_stats.tx_carrier_errors = adapter->stats.tncrs;
2095
2096 /* Tx Dropped needs to be maintained elsewhere */
2097
2098 /* Phy Stats */
2099
2100 if(hw->media_type == e1000_media_type_copper) {
2101 if((adapter->link_speed == SPEED_1000) &&
2102 (!e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_tmp))) {
2103 phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK;
2104 adapter->phy_stats.idle_errors += phy_tmp;
2105 }
2106
2107 if((hw->mac_type <= e1000_82546) &&
2108 (hw->phy_type == e1000_phy_m88) &&
2109 !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp))
2110 adapter->phy_stats.receive_errors += phy_tmp;
2111 }
2112
2113 spin_unlock_irqrestore(&adapter->stats_lock, flags);
2114 }
2115
2116 /**
2117 * e1000_intr - Interrupt Handler
2118 * @irq: interrupt number
2119 * @data: pointer to a network interface device structure
2120 * @pt_regs: CPU registers structure
2121 **/
2122
2123 static irqreturn_t
2124 e1000_intr(int irq, void *data, struct pt_regs *regs)
2125 {
2126 struct net_device *netdev = data;
2127 struct e1000_adapter *adapter = netdev->priv;
2128 struct e1000_hw *hw = &adapter->hw;
2129 uint32_t icr = E1000_READ_REG(hw, ICR);
2130 #ifndef CONFIG_E1000_NAPI
2131 unsigned int i;
2132 #endif
2133
2134 if(unlikely(!icr))
2135 return IRQ_NONE; /* Not our interrupt */
2136
2137 if(unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) {
2138 hw->get_link_status = 1;
2139 mod_timer(&adapter->watchdog_timer, jiffies);
2140 }
2141
2142 #ifdef CONFIG_E1000_NAPI
2143 if(likely(netif_rx_schedule_prep(netdev))) {
2144
2145 /* Disable interrupts and register for poll. The flush
2146 of the posted write is intentionally left out.
2147 */
2148
2149 atomic_inc(&adapter->irq_sem);
2150 E1000_WRITE_REG(hw, IMC, ~0);
2151 __netif_rx_schedule(netdev);
2152 }
2153 #else
2154 for(i = 0; i < E1000_MAX_INTR; i++)
2155 if(unlikely(!e1000_clean_rx_irq(adapter) &
2156 !e1000_clean_tx_irq(adapter)))
2157 break;
2158 #endif
2159
2160 return IRQ_HANDLED;
2161 }
2162
2163 #ifdef CONFIG_E1000_NAPI
2164 /**
2165 * e1000_clean - NAPI Rx polling callback
2166 * @adapter: board private structure
2167 **/
2168
2169 static int
2170 e1000_clean(struct net_device *netdev, int *budget)
2171 {
2172 struct e1000_adapter *adapter = netdev->priv;
2173 int work_to_do = min(*budget, netdev->quota);
2174 int tx_cleaned;
2175 int work_done = 0;
2176
2177 if (!netif_carrier_ok(netdev))
2178 goto quit_polling;
2179
2180 tx_cleaned = e1000_clean_tx_irq(adapter);
2181 e1000_clean_rx_irq(adapter, &work_done, work_to_do);
2182
2183 *budget -= work_done;
2184 netdev->quota -= work_done;
2185
2186 /* if no Rx and Tx cleanup work was done, exit the polling mode */
2187 if(!tx_cleaned || (work_done < work_to_do) ||
2188 !netif_running(netdev)) {
2189 quit_polling: netif_rx_complete(netdev);
2190 e1000_irq_enable(adapter);
2191 return 0;
2192 }
2193
2194 return (work_done >= work_to_do);
2195 }
2196
2197 #endif
2198 /**
2199 * e1000_clean_tx_irq - Reclaim resources after transmit completes
2200 * @adapter: board private structure
2201 **/
2202
2203 static boolean_t
2204 e1000_clean_tx_irq(struct e1000_adapter *adapter)
2205 {
2206 struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
2207 struct net_device *netdev = adapter->netdev;
2208 struct e1000_tx_desc *tx_desc, *eop_desc;
2209 struct e1000_buffer *buffer_info;
2210 unsigned int i, eop;
2211 boolean_t cleaned = FALSE;
2212
2213 i = tx_ring->next_to_clean;
2214 eop = tx_ring->buffer_info[i].next_to_watch;
2215 eop_desc = E1000_TX_DESC(*tx_ring, eop);
2216
2217 while(eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) {
2218 for(cleaned = FALSE; !cleaned; ) {
2219 tx_desc = E1000_TX_DESC(*tx_ring, i);
2220 buffer_info = &tx_ring->buffer_info[i];
2221
2222 e1000_unmap_and_free_tx_resource(adapter, buffer_info);
2223 tx_desc->buffer_addr = 0;
2224 tx_desc->lower.data = 0;
2225 tx_desc->upper.data = 0;
2226
2227 cleaned = (i == eop);
2228 if(unlikely(++i == tx_ring->count)) i = 0;
2229 }
2230
2231 eop = tx_ring->buffer_info[i].next_to_watch;
2232 eop_desc = E1000_TX_DESC(*tx_ring, eop);
2233 }
2234
2235 tx_ring->next_to_clean = i;
2236
2237 spin_lock(&adapter->tx_lock);
2238
2239 if(unlikely(cleaned && netif_queue_stopped(netdev) &&
2240 netif_carrier_ok(netdev)))
2241 netif_wake_queue(netdev);
2242
2243 spin_unlock(&adapter->tx_lock);
2244
2245 return cleaned;
2246 }
2247
2248 /**
2249 * e1000_rx_checksum - Receive Checksum Offload for 82543
2250 * @adapter: board private structure
2251 * @rx_desc: receive descriptor
2252 * @sk_buff: socket buffer with received data
2253 **/
2254
2255 static inline void
2256 e1000_rx_checksum(struct e1000_adapter *adapter,
2257 struct e1000_rx_desc *rx_desc,
2258 struct sk_buff *skb)
2259 {
2260 /* 82543 or newer only */
2261 if(unlikely((adapter->hw.mac_type < e1000_82543) ||
2262 /* Ignore Checksum bit is set */
2263 (rx_desc->status & E1000_RXD_STAT_IXSM) ||
2264 /* TCP Checksum has not been calculated */
2265 (!(rx_desc->status & E1000_RXD_STAT_TCPCS)))) {
2266 skb->ip_summed = CHECKSUM_NONE;
2267 return;
2268 }
2269
2270 /* At this point we know the hardware did the TCP checksum */
2271 /* now look at the TCP checksum error bit */
2272 if(rx_desc->errors & E1000_RXD_ERR_TCPE) {
2273 /* let the stack verify checksum errors */
2274 skb->ip_summed = CHECKSUM_NONE;
2275 adapter->hw_csum_err++;
2276 } else {
2277 /* TCP checksum is good */
2278 skb->ip_summed = CHECKSUM_UNNECESSARY;
2279 adapter->hw_csum_good++;
2280 }
2281 }
2282
2283 /**
2284 * e1000_clean_rx_irq - Send received data up the network stack
2285 * @adapter: board private structure
2286 **/
2287
2288 static boolean_t
2289 #ifdef CONFIG_E1000_NAPI
2290 e1000_clean_rx_irq(struct e1000_adapter *adapter, int *work_done,
2291 int work_to_do)
2292 #else
2293 e1000_clean_rx_irq(struct e1000_adapter *adapter)
2294 #endif
2295 {
2296 struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
2297 struct net_device *netdev = adapter->netdev;
2298 struct pci_dev *pdev = adapter->pdev;
2299 struct e1000_rx_desc *rx_desc;
2300 struct e1000_buffer *buffer_info;
2301 struct sk_buff *skb;
2302 unsigned long flags;
2303 uint32_t length;
2304 uint8_t last_byte;
2305 unsigned int i;
2306 boolean_t cleaned = FALSE;
2307
2308 i = rx_ring->next_to_clean;
2309 rx_desc = E1000_RX_DESC(*rx_ring, i);
2310
2311 while(rx_desc->status & E1000_RXD_STAT_DD) {
2312 buffer_info = &rx_ring->buffer_info[i];
2313 #ifdef CONFIG_E1000_NAPI
2314 if(*work_done >= work_to_do)
2315 break;
2316 (*work_done)++;
2317 #endif
2318 cleaned = TRUE;
2319
2320 pci_unmap_single(pdev,
2321 buffer_info->dma,
2322 buffer_info->length,
2323 PCI_DMA_FROMDEVICE);
2324
2325 skb = buffer_info->skb;
2326 length = le16_to_cpu(rx_desc->length);
2327
2328 if(unlikely(!(rx_desc->status & E1000_RXD_STAT_EOP))) {
2329 /* All receives must fit into a single buffer */
2330 E1000_DBG("%s: Receive packet consumed multiple"
2331 " buffers\n", netdev->name);
2332 dev_kfree_skb_irq(skb);
2333 goto next_desc;
2334 }
2335
2336 if(unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {
2337 last_byte = *(skb->data + length - 1);
2338 if(TBI_ACCEPT(&adapter->hw, rx_desc->status,
2339 rx_desc->errors, length, last_byte)) {
2340 spin_lock_irqsave(&adapter->stats_lock, flags);
2341 e1000_tbi_adjust_stats(&adapter->hw,
2342 &adapter->stats,
2343 length, skb->data);
2344 spin_unlock_irqrestore(&adapter->stats_lock,
2345 flags);
2346 length--;
2347 } else {
2348 dev_kfree_skb_irq(skb);
2349 goto next_desc;
2350 }
2351 }
2352
2353 /* Good Receive */
2354 skb_put(skb, length - ETHERNET_FCS_SIZE);
2355
2356 /* Receive Checksum Offload */
2357 e1000_rx_checksum(adapter, rx_desc, skb);
2358
2359 skb->protocol = eth_type_trans(skb, netdev);
2360 #ifdef CONFIG_E1000_NAPI
2361 if(unlikely(adapter->vlgrp &&
2362 (rx_desc->status & E1000_RXD_STAT_VP))) {
2363 vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
2364 le16_to_cpu(rx_desc->special) &
2365 E1000_RXD_SPC_VLAN_MASK);
2366 } else {
2367 netif_receive_skb(skb);
2368 }
2369 #else /* CONFIG_E1000_NAPI */
2370 if(unlikely(adapter->vlgrp &&
2371 (rx_desc->status & E1000_RXD_STAT_VP))) {
2372 vlan_hwaccel_rx(skb, adapter->vlgrp,
2373 le16_to_cpu(rx_desc->special) &
2374 E1000_RXD_SPC_VLAN_MASK);
2375 } else {
2376 netif_rx(skb);
2377 }
2378 #endif /* CONFIG_E1000_NAPI */
2379 netdev->last_rx = jiffies;
2380
2381 next_desc:
2382 rx_desc->status = 0;
2383 buffer_info->skb = NULL;
2384 if(unlikely(++i == rx_ring->count)) i = 0;
2385
2386 rx_desc = E1000_RX_DESC(*rx_ring, i);
2387 }
2388
2389 rx_ring->next_to_clean = i;
2390
2391 e1000_alloc_rx_buffers(adapter);
2392
2393 return cleaned;
2394 }
2395
2396 /**
2397 * e1000_alloc_rx_buffers - Replace used receive buffers
2398 * @adapter: address of board private structure
2399 **/
2400
2401 static void
2402 e1000_alloc_rx_buffers(struct e1000_adapter *adapter)
2403 {
2404 struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
2405 struct net_device *netdev = adapter->netdev;
2406 struct pci_dev *pdev = adapter->pdev;
2407 struct e1000_rx_desc *rx_desc;
2408 struct e1000_buffer *buffer_info;
2409 struct sk_buff *skb;
2410 unsigned int i;
2411
2412 i = rx_ring->next_to_use;
2413 buffer_info = &rx_ring->buffer_info[i];
2414
2415 while(!buffer_info->skb) {
2416 skb = dev_alloc_skb(adapter->rx_buffer_len + NET_IP_ALIGN);
2417
2418 if(unlikely(!skb)) {
2419 /* Better luck next round */
2420 break;
2421 }
2422
2423 /* Make buffer alignment 2 beyond a 16 byte boundary
2424 * this will result in a 16 byte aligned IP header after
2425 * the 14 byte MAC header is removed
2426 */
2427 skb_reserve(skb, NET_IP_ALIGN);
2428
2429 skb->dev = netdev;
2430
2431 buffer_info->skb = skb;
2432 buffer_info->length = adapter->rx_buffer_len;
2433 buffer_info->dma = pci_map_single(pdev,
2434 skb->data,
2435 adapter->rx_buffer_len,
2436 PCI_DMA_FROMDEVICE);
2437
2438 rx_desc = E1000_RX_DESC(*rx_ring, i);
2439 rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
2440
2441 if(unlikely((i & ~(E1000_RX_BUFFER_WRITE - 1)) == i)) {
2442 /* Force memory writes to complete before letting h/w
2443 * know there are new descriptors to fetch. (Only
2444 * applicable for weak-ordered memory model archs,
2445 * such as IA-64). */
2446 wmb();
2447
2448 E1000_WRITE_REG(&adapter->hw, RDT, i);
2449 }
2450
2451 if(unlikely(++i == rx_ring->count)) i = 0;
2452 buffer_info = &rx_ring->buffer_info[i];
2453 }
2454
2455 rx_ring->next_to_use = i;
2456 }
2457
2458 /**
2459 * e1000_smartspeed - Workaround for SmartSpeed on 82541 and 82547 controllers.
2460 * @adapter:
2461 **/
2462
2463 static void
2464 e1000_smartspeed(struct e1000_adapter *adapter)
2465 {
2466 uint16_t phy_status;
2467 uint16_t phy_ctrl;
2468
2469 if((adapter->hw.phy_type != e1000_phy_igp) || !adapter->hw.autoneg ||
2470 !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL))
2471 return;
2472
2473 if(adapter->smartspeed == 0) {
2474 /* If Master/Slave config fault is asserted twice,
2475 * we assume back-to-back */
2476 e1000_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_status);
2477 if(!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
2478 e1000_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_status);
2479 if(!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
2480 e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_ctrl);
2481 if(phy_ctrl & CR_1000T_MS_ENABLE) {
2482 phy_ctrl &= ~CR_1000T_MS_ENABLE;
2483 e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL,
2484 phy_ctrl);
2485 adapter->smartspeed++;
2486 if(!e1000_phy_setup_autoneg(&adapter->hw) &&
2487 !e1000_read_phy_reg(&adapter->hw, PHY_CTRL,
2488 &phy_ctrl)) {
2489 phy_ctrl |= (MII_CR_AUTO_NEG_EN |
2490 MII_CR_RESTART_AUTO_NEG);
2491 e1000_write_phy_reg(&adapter->hw, PHY_CTRL,
2492 phy_ctrl);
2493 }
2494 }
2495 return;
2496 } else if(adapter->smartspeed == E1000_SMARTSPEED_DOWNSHIFT) {
2497 /* If still no link, perhaps using 2/3 pair cable */
2498 e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_ctrl);
2499 phy_ctrl |= CR_1000T_MS_ENABLE;
2500 e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_ctrl);
2501 if(!e1000_phy_setup_autoneg(&adapter->hw) &&
2502 !e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_ctrl)) {
2503 phy_ctrl |= (MII_CR_AUTO_NEG_EN |
2504 MII_CR_RESTART_AUTO_NEG);
2505 e1000_write_phy_reg(&adapter->hw, PHY_CTRL, phy_ctrl);
2506 }
2507 }
2508 /* Restart process after E1000_SMARTSPEED_MAX iterations */
2509 if(adapter->smartspeed++ == E1000_SMARTSPEED_MAX)
2510 adapter->smartspeed = 0;
2511 }
2512
2513 /**
2514 * e1000_ioctl -
2515 * @netdev:
2516 * @ifreq:
2517 * @cmd:
2518 **/
2519
2520 static int
2521 e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
2522 {
2523 switch (cmd) {
2524 case SIOCGMIIPHY:
2525 case SIOCGMIIREG:
2526 case SIOCSMIIREG:
2527 return e1000_mii_ioctl(netdev, ifr, cmd);
2528 default:
2529 return -EOPNOTSUPP;
2530 }
2531 }
2532
2533 /**
2534 * e1000_mii_ioctl -
2535 * @netdev:
2536 * @ifreq:
2537 * @cmd:
2538 **/
2539
2540 static int
2541 e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
2542 {
2543 struct e1000_adapter *adapter = netdev->priv;
2544 struct mii_ioctl_data *data = if_mii(ifr);
2545 int retval;
2546 uint16_t mii_reg;
2547 uint16_t spddplx;
2548
2549 if(adapter->hw.media_type != e1000_media_type_copper)
2550 return -EOPNOTSUPP;
2551
2552 switch (cmd) {
2553 case SIOCGMIIPHY:
2554 data->phy_id = adapter->hw.phy_addr;
2555 break;
2556 case SIOCGMIIREG:
2557 if (!capable(CAP_NET_ADMIN))
2558 return -EPERM;
2559 if (e1000_read_phy_reg(&adapter->hw, data->reg_num & 0x1F,
2560 &data->val_out))
2561 return -EIO;
2562 break;
2563 case SIOCSMIIREG:
2564 if (!capable(CAP_NET_ADMIN))
2565 return -EPERM;
2566 if (data->reg_num & ~(0x1F))
2567 return -EFAULT;
2568 mii_reg = data->val_in;
2569 if (e1000_write_phy_reg(&adapter->hw, data->reg_num,
2570 mii_reg))
2571 return -EIO;
2572 if (adapter->hw.phy_type == e1000_phy_m88) {
2573 switch (data->reg_num) {
2574 case PHY_CTRL:
2575 if(mii_reg & MII_CR_POWER_DOWN)
2576 break;
2577 if(mii_reg & MII_CR_AUTO_NEG_EN) {
2578 adapter->hw.autoneg = 1;
2579 adapter->hw.autoneg_advertised = 0x2F;
2580 } else {
2581 if (mii_reg & 0x40)
2582 spddplx = SPEED_1000;
2583 else if (mii_reg & 0x2000)
2584 spddplx = SPEED_100;
2585 else
2586 spddplx = SPEED_10;
2587 spddplx += (mii_reg & 0x100)
2588 ? FULL_DUPLEX :
2589 HALF_DUPLEX;
2590 retval = e1000_set_spd_dplx(adapter,
2591 spddplx);
2592 if(retval)
2593 return retval;
2594 }
2595 if(netif_running(adapter->netdev)) {
2596 e1000_down(adapter);
2597 e1000_up(adapter);
2598 } else
2599 e1000_reset(adapter);
2600 break;
2601 case M88E1000_PHY_SPEC_CTRL:
2602 case M88E1000_EXT_PHY_SPEC_CTRL:
2603 if (e1000_phy_reset(&adapter->hw))
2604 return -EIO;
2605 break;
2606 }
2607 } else {
2608 switch (data->reg_num) {
2609 case PHY_CTRL:
2610 if(mii_reg & MII_CR_POWER_DOWN)
2611 break;
2612 if(netif_running(adapter->netdev)) {
2613 e1000_down(adapter);
2614 e1000_up(adapter);
2615 } else
2616 e1000_reset(adapter);
2617 break;
2618 }
2619 }
2620 break;
2621 default:
2622 return -EOPNOTSUPP;
2623 }
2624 return E1000_SUCCESS;
2625 }
2626
2627 void
2628 e1000_pci_set_mwi(struct e1000_hw *hw)
2629 {
2630 struct e1000_adapter *adapter = hw->back;
2631
2632 int ret;
2633 ret = pci_set_mwi(adapter->pdev);
2634 }
2635
2636 void
2637 e1000_pci_clear_mwi(struct e1000_hw *hw)
2638 {
2639 struct e1000_adapter *adapter = hw->back;
2640
2641 pci_clear_mwi(adapter->pdev);
2642 }
2643
2644 void
2645 e1000_read_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
2646 {
2647 struct e1000_adapter *adapter = hw->back;
2648
2649 pci_read_config_word(adapter->pdev, reg, value);
2650 }
2651
2652 void
2653 e1000_write_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
2654 {
2655 struct e1000_adapter *adapter = hw->back;
2656
2657 pci_write_config_word(adapter->pdev, reg, *value);
2658 }
2659
2660 uint32_t
2661 e1000_io_read(struct e1000_hw *hw, unsigned long port)
2662 {
2663 return inl(port);
2664 }
2665
2666 void
2667 e1000_io_write(struct e1000_hw *hw, unsigned long port, uint32_t value)
2668 {
2669 outl(value, port);
2670 }
2671
2672 static void
2673 e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
2674 {
2675 struct e1000_adapter *adapter = netdev->priv;
2676 uint32_t ctrl, rctl;
2677
2678 e1000_irq_disable(adapter);
2679 adapter->vlgrp = grp;
2680
2681 if(grp) {
2682 /* enable VLAN tag insert/strip */
2683 ctrl = E1000_READ_REG(&adapter->hw, CTRL);
2684 ctrl |= E1000_CTRL_VME;
2685 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
2686
2687 /* enable VLAN receive filtering */
2688 rctl = E1000_READ_REG(&adapter->hw, RCTL);
2689 rctl |= E1000_RCTL_VFE;
2690 rctl &= ~E1000_RCTL_CFIEN;
2691 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
2692 } else {
2693 /* disable VLAN tag insert/strip */
2694 ctrl = E1000_READ_REG(&adapter->hw, CTRL);
2695 ctrl &= ~E1000_CTRL_VME;
2696 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
2697
2698 /* disable VLAN filtering */
2699 rctl = E1000_READ_REG(&adapter->hw, RCTL);
2700 rctl &= ~E1000_RCTL_VFE;
2701 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
2702 }
2703
2704 e1000_irq_enable(adapter);
2705 }
2706
2707 static void
2708 e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid)
2709 {
2710 struct e1000_adapter *adapter = netdev->priv;
2711 uint32_t vfta, index;
2712
2713 /* add VID to filter table */
2714 index = (vid >> 5) & 0x7F;
2715 vfta = E1000_READ_REG_ARRAY(&adapter->hw, VFTA, index);
2716 vfta |= (1 << (vid & 0x1F));
2717 e1000_write_vfta(&adapter->hw, index, vfta);
2718 }
2719
2720 static void
2721 e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid)
2722 {
2723 struct e1000_adapter *adapter = netdev->priv;
2724 uint32_t vfta, index;
2725
2726 e1000_irq_disable(adapter);
2727
2728 if(adapter->vlgrp)
2729 adapter->vlgrp->vlan_devices[vid] = NULL;
2730
2731 e1000_irq_enable(adapter);
2732
2733 /* remove VID from filter table */
2734 index = (vid >> 5) & 0x7F;
2735 vfta = E1000_READ_REG_ARRAY(&adapter->hw, VFTA, index);
2736 vfta &= ~(1 << (vid & 0x1F));
2737 e1000_write_vfta(&adapter->hw, index, vfta);
2738 }
2739
2740 static void
2741 e1000_restore_vlan(struct e1000_adapter *adapter)
2742 {
2743 e1000_vlan_rx_register(adapter->netdev, adapter->vlgrp);
2744
2745 if(adapter->vlgrp) {
2746 uint16_t vid;
2747 for(vid = 0; vid < VLAN_GROUP_ARRAY_LEN; vid++) {
2748 if(!adapter->vlgrp->vlan_devices[vid])
2749 continue;
2750 e1000_vlan_rx_add_vid(adapter->netdev, vid);
2751 }
2752 }
2753 }
2754
2755 int
2756 e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx)
2757 {
2758 adapter->hw.autoneg = 0;
2759
2760 switch(spddplx) {
2761 case SPEED_10 + DUPLEX_HALF:
2762 adapter->hw.forced_speed_duplex = e1000_10_half;
2763 break;
2764 case SPEED_10 + DUPLEX_FULL:
2765 adapter->hw.forced_speed_duplex = e1000_10_full;
2766 break;
2767 case SPEED_100 + DUPLEX_HALF:
2768 adapter->hw.forced_speed_duplex = e1000_100_half;
2769 break;
2770 case SPEED_100 + DUPLEX_FULL:
2771 adapter->hw.forced_speed_duplex = e1000_100_full;
2772 break;
2773 case SPEED_1000 + DUPLEX_FULL:
2774 adapter->hw.autoneg = 1;
2775 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;
2776 break;
2777 case SPEED_1000 + DUPLEX_HALF: /* not supported */
2778 default:
2779 DPRINTK(PROBE, ERR,
2780 "Unsupported Speed/Duplexity configuration\n");
2781 return -EINVAL;
2782 }
2783 return 0;
2784 }
2785
2786 static int
2787 e1000_notify_reboot(struct notifier_block *nb, unsigned long event, void *p)
2788 {
2789 struct pci_dev *pdev = NULL;
2790
2791 switch(event) {
2792 case SYS_DOWN:
2793 case SYS_HALT:
2794 case SYS_POWER_OFF:
2795 while((pdev = pci_find_device(PCI_ANY_ID, PCI_ANY_ID, pdev))) {
2796 if(pci_dev_driver(pdev) == &e1000_driver)
2797 e1000_suspend(pdev, 3);
2798 }
2799 }
2800 return NOTIFY_DONE;
2801 }
2802
2803 static int
2804 e1000_suspend(struct pci_dev *pdev, uint32_t state)
2805 {
2806 struct net_device *netdev = pci_get_drvdata(pdev);
2807 struct e1000_adapter *adapter = netdev->priv;
2808 uint32_t ctrl, ctrl_ext, rctl, manc, status;
2809 uint32_t wufc = adapter->wol;
2810
2811 netif_device_detach(netdev);
2812
2813 if(netif_running(netdev))
2814 e1000_down(adapter);
2815
2816 status = E1000_READ_REG(&adapter->hw, STATUS);
2817 if(status & E1000_STATUS_LU)
2818 wufc &= ~E1000_WUFC_LNKC;
2819
2820 if(wufc) {
2821 e1000_setup_rctl(adapter);
2822 e1000_set_multi(netdev);
2823
2824 /* turn on all-multi mode if wake on multicast is enabled */
2825 if(adapter->wol & E1000_WUFC_MC) {
2826 rctl = E1000_READ_REG(&adapter->hw, RCTL);
2827 rctl |= E1000_RCTL_MPE;
2828 E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
2829 }
2830
2831 if(adapter->hw.mac_type >= e1000_82540) {
2832 ctrl = E1000_READ_REG(&adapter->hw, CTRL);
2833 /* advertise wake from D3Cold */
2834 #define E1000_CTRL_ADVD3WUC 0x00100000
2835 /* phy power management enable */
2836 #define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000
2837 ctrl |= E1000_CTRL_ADVD3WUC |
2838 E1000_CTRL_EN_PHY_PWR_MGMT;
2839 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
2840 }
2841
2842 if(adapter->hw.media_type == e1000_media_type_fiber ||
2843 adapter->hw.media_type == e1000_media_type_internal_serdes) {
2844 /* keep the laser running in D3 */
2845 ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
2846 ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA;
2847 E1000_WRITE_REG(&adapter->hw, CTRL_EXT, ctrl_ext);
2848 }
2849
2850 E1000_WRITE_REG(&adapter->hw, WUC, E1000_WUC_PME_EN);
2851 E1000_WRITE_REG(&adapter->hw, WUFC, wufc);
2852 pci_enable_wake(pdev, 3, 1);
2853 pci_enable_wake(pdev, 4, 1); /* 4 == D3 cold */
2854 } else {
2855 E1000_WRITE_REG(&adapter->hw, WUC, 0);
2856 E1000_WRITE_REG(&adapter->hw, WUFC, 0);
2857 pci_enable_wake(pdev, 3, 0);
2858 pci_enable_wake(pdev, 4, 0); /* 4 == D3 cold */
2859 }
2860
2861 pci_save_state(pdev);
2862
2863 if(adapter->hw.mac_type >= e1000_82540 &&
2864 adapter->hw.media_type == e1000_media_type_copper) {
2865 manc = E1000_READ_REG(&adapter->hw, MANC);
2866 if(manc & E1000_MANC_SMBUS_EN) {
2867 manc |= E1000_MANC_ARP_EN;
2868 E1000_WRITE_REG(&adapter->hw, MANC, manc);
2869 pci_enable_wake(pdev, 3, 1);
2870 pci_enable_wake(pdev, 4, 1); /* 4 == D3 cold */
2871 }
2872 }
2873
2874 pci_disable_device(pdev);
2875
2876 state = (state > 0) ? 3 : 0;
2877 pci_set_power_state(pdev, state);
2878
2879 return 0;
2880 }
2881
2882 #ifdef CONFIG_PM
2883 static int
2884 e1000_resume(struct pci_dev *pdev)
2885 {
2886 struct net_device *netdev = pci_get_drvdata(pdev);
2887 struct e1000_adapter *adapter = netdev->priv;
2888 uint32_t manc, ret;
2889
2890 pci_set_power_state(pdev, 0);
2891 pci_restore_state(pdev);
2892 ret = pci_enable_device(pdev);
2893 if (pdev->is_busmaster)
2894 pci_set_master(pdev);
2895
2896 pci_enable_wake(pdev, 3, 0);
2897 pci_enable_wake(pdev, 4, 0); /* 4 == D3 cold */
2898
2899 e1000_reset(adapter);
2900 E1000_WRITE_REG(&adapter->hw, WUS, ~0);
2901
2902 if(netif_running(netdev))
2903 e1000_up(adapter);
2904
2905 netif_device_attach(netdev);
2906
2907 if(adapter->hw.mac_type >= e1000_82540 &&
2908 adapter->hw.media_type == e1000_media_type_copper) {
2909 manc = E1000_READ_REG(&adapter->hw, MANC);
2910 manc &= ~(E1000_MANC_ARP_EN);
2911 E1000_WRITE_REG(&adapter->hw, MANC, manc);
2912 }
2913
2914 return 0;
2915 }
2916 #endif
2917
2918 #ifdef CONFIG_NET_POLL_CONTROLLER
2919 /*
2920 * Polling 'interrupt' - used by things like netconsole to send skbs
2921 * without having to re-enable interrupts. It's not called while
2922 * the interrupt routine is executing.
2923 */
2924 static void
2925 e1000_netpoll (struct net_device *netdev)
2926 {
2927 struct e1000_adapter *adapter = netdev->priv;
2928 disable_irq(adapter->pdev->irq);
2929 e1000_intr(adapter->pdev->irq, netdev, NULL);
2930 enable_irq(adapter->pdev->irq);
2931 }
2932 #endif
2933
2934 /* e1000_main.c */
2935
|
This page was automatically generated by the
LXR engine.
|