开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
e1000_main.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：61k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

e1000_main.c：源码内容
  1. /*******************************************************************************
  3.   
  4.   Copyright(c) 1999 - 2002 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
  27. *******************************************************************************/
  29. #define __E1000_MAIN__
  30. #include "e1000.h"
  32. /* Change Log
  33.  *
  34.  * 4.4.12       10/15/02
  35.  *   o Clean up: use members of pci_device rather than direct calls to
  36.  *     pci_read_config_word.
  37.  *   o Bug fix: changed default flow control settings.
  38.  *   o Clean up: ethtool file now has an inclusive list for adapters in the
  39.  *     Wake-On-LAN capabilities instead of an exclusive list.
  40.  *   o Bug fix: miscellaneous WoL bug fixes.
  41.  *   o Added software interrupt for clearing rx ring
  42.  *   o Bug fix: easier to undo "forcing" of 1000/fd using ethtool.
  43.  *   o Now setting netdev->mem_end in e1000_probe.
  44.  *   o Clean up: Moved tx_timeout from interrupt context to process context
  45.  *     using schedule_task.
  46.  *
  47.  * 4.3.15      8/9/02
  48.  *   o Converted from Dual BSD/GPL license to GPL license.
  49.  *   o Clean up: use pci_[clear|set]_mwi rather than direct calls to
  50.  *     pci_write_config_word.
  51.  *   o Bug fix: added read-behind-write calls to post writes before delays.
  52.  *   o Bug fix: removed mdelay busy-waits in interrupt context.
  53.  *   o Clean up: direct clear of descriptor bits rather than using memset.
  54.  *   o Bug fix: added wmb() for ia-64 between descritor writes and advancing
  55.  *     descriptor tail.
  56.  *   o Feature: added locking mechanism for asf functionality.
  57.  *   o Feature: exposed two Tx and one Rx interrupt delay knobs for finer
  58.  *     control over interurpt rate tuning.
  59.  *   o Misc ethtool bug fixes.
  60.  *
  61.  * 4.3.2       7/5/02
  62.  */
  63.  
  64. char e1000_driver_name[] = "e1000";
  65. char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
  66. char e1000_driver_version[] = "4.4.12-k1";
  67. char e1000_copyright[] = "Copyright (c) 1999-2002 Intel Corporation.";
  69. /* e1000_pci_tbl - PCI Device ID Table
  70.  *
  71.  * Private driver_data field (last one) stores an index into e1000_strings
  72.  * Wildcard entries (PCI_ANY_ID) should come last
  73.  * Last entry must be all 0s
  74.  *
  75.  * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
  76.  *   Class, Class Mask, String Index }
  77.  */
  78. static struct pci_device_id e1000_pci_tbl[] __devinitdata = {
  79. /* Intel(R) PRO/1000 Network Connection */
  80. {0x8086, 0x1000, 0x8086, 0x1000, 0, 0, 0},
  81. {0x8086, 0x1001, 0x8086, 0x1003, 0, 0, 0},
  82. {0x8086, 0x1004, 0x8086, 0x1004, 0, 0, 0},
  83. {0x8086, 0x1008, 0x8086, 0x1107, 0, 0, 0},
  84. {0x8086, 0x1009, 0x8086, 0x1109, 0, 0, 0},
  85. {0x8086, 0x100C, 0x8086, 0x1112, 0, 0, 0},
  86. {0x8086, 0x100E, 0x8086, 0x001E, 0, 0, 0},
  87. /* Compaq Gigabit Ethernet Server Adapter */
  88. {0x8086, 0x1000, 0x0E11, PCI_ANY_ID, 0, 0, 1},
  89. {0x8086, 0x1001, 0x0E11, PCI_ANY_ID, 0, 0, 1},
  90. {0x8086, 0x1004, 0x0E11, PCI_ANY_ID, 0, 0, 1},
  91. /* IBM Mobile, Desktop & Server Adapters */
  92. {0x8086, 0x1000, 0x1014, PCI_ANY_ID, 0, 0, 2},
  93. {0x8086, 0x1001, 0x1014, PCI_ANY_ID, 0, 0, 2},
  94. {0x8086, 0x1004, 0x1014, PCI_ANY_ID, 0, 0, 2},
  95. /* Generic */
  96. {0x8086, 0x1000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  97. {0x8086, 0x1001, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  98. {0x8086, 0x1004, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  99. {0x8086, 0x1008, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  100. {0x8086, 0x1009, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  101. {0x8086, 0x100C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  102. {0x8086, 0x100D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  103. {0x8086, 0x100E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  104. {0x8086, 0x100F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  105. {0x8086, 0x1011, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  106. {0x8086, 0x1010, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  107. {0x8086, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  108. {0x8086, 0x1016, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  109. {0x8086, 0x1017, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  110. {0x8086, 0x101E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  111. /* required last entry */
  112. {0,}
  113. };
  115. MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);
  117. static char *e1000_strings[] = {
  118. "Intel(R) PRO/1000 Network Connection",
  119. "Compaq Gigabit Ethernet Server Adapter",
  120. "IBM Mobile, Desktop & Server Adapters"
  121. };
  123. /* Local Function Prototypes */
  125. int e1000_up(struct e1000_adapter *adapter);
  126. void e1000_down(struct e1000_adapter *adapter);
  127. void e1000_reset(struct e1000_adapter *adapter);
  129. static int e1000_init_module(void);
  130. static void e1000_exit_module(void);
  131. static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
  132. static void e1000_remove(struct pci_dev *pdev);
  133. static int e1000_sw_init(struct e1000_adapter *adapter);
  134. static int e1000_open(struct net_device *netdev);
  135. static int e1000_close(struct net_device *netdev);
  136. static int e1000_setup_tx_resources(struct e1000_adapter *adapter);
  137. static int e1000_setup_rx_resources(struct e1000_adapter *adapter);
  138. static void e1000_configure_tx(struct e1000_adapter *adapter);
  139. static void e1000_configure_rx(struct e1000_adapter *adapter);
  140. static void e1000_setup_rctl(struct e1000_adapter *adapter);
  141. static void e1000_clean_tx_ring(struct e1000_adapter *adapter);
  142. static void e1000_clean_rx_ring(struct e1000_adapter *adapter);
  143. static void e1000_free_tx_resources(struct e1000_adapter *adapter);
  144. static void e1000_free_rx_resources(struct e1000_adapter *adapter);
  145. static void e1000_set_multi(struct net_device *netdev);
  146. static void e1000_update_phy_info(unsigned long data);
  147. static void e1000_watchdog(unsigned long data);
  148. static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev);
  149. static struct net_device_stats * e1000_get_stats(struct net_device *netdev);
  150. static int e1000_change_mtu(struct net_device *netdev, int new_mtu);
  151. static int e1000_set_mac(struct net_device *netdev, void *p);
  152. static void e1000_update_stats(struct e1000_adapter *adapter);
  153. static inline void e1000_irq_disable(struct e1000_adapter *adapter);
  154. static inline void e1000_irq_enable(struct e1000_adapter *adapter);
  155. static void e1000_intr(int irq, void *data, struct pt_regs *regs);
  156. static void e1000_clean_tx_irq(struct e1000_adapter *adapter);
  157. static void e1000_clean_rx_irq(struct e1000_adapter *adapter);
  158. static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter);
  159. static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd);
  160. static void e1000_enter_82542_rst(struct e1000_adapter *adapter);
  161. static void e1000_leave_82542_rst(struct e1000_adapter *adapter);
  162. static inline void e1000_rx_checksum(struct e1000_adapter *adapter,
  163.                                      struct e1000_rx_desc *rx_desc,
  164.                                      struct sk_buff *skb);
  165. static void e1000_tx_timeout(struct net_device *dev);
  166. static void e1000_tx_timeout_task(struct net_device *dev);
  168. static void e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp);
  169. static void e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid);
  170. static void e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid);
  172. static int e1000_notify_reboot(struct notifier_block *, unsigned long event, void *ptr);
  173. static int e1000_notify_netdev(struct notifier_block *, unsigned long event, void *ptr);
  174. static int e1000_suspend(struct pci_dev *pdev, uint32_t state);
  175. #ifdef CONFIG_PM
  176. static int e1000_resume(struct pci_dev *pdev);
  177. #endif
  179. struct notifier_block e1000_notifier_reboot = {
  180. .notifier_call = e1000_notify_reboot,
  181. .next = NULL,
  182. .priority = 0
  183. };
  185. struct notifier_block e1000_notifier_netdev = {
  186. .notifier_call = e1000_notify_netdev,
  187. .next = NULL,
  188. .priority = 0
  189. };
  191. /* Exported from other modules */
  193. extern void e1000_check_options(struct e1000_adapter *adapter);
  194. extern void e1000_proc_dev_setup(struct e1000_adapter *adapter);
  195. extern void e1000_proc_dev_free(struct e1000_adapter *adapter);
  196. extern int e1000_ethtool_ioctl(struct net_device *netdev, struct ifreq *ifr);
  198. static struct pci_driver e1000_driver = {
  199. .name     = e1000_driver_name,
  200. .id_table = e1000_pci_tbl,
  201. .probe    = e1000_probe,
  202. .remove   = __devexit_p(e1000_remove),
  203. /* Power Managment Hooks */
  204. #ifdef CONFIG_PM
  205. .suspend  = e1000_suspend,
  206. .resume   = e1000_resume
  207. #endif
  208. };
  210. MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
  211. MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver");
  212. MODULE_LICENSE("GPL");
  214. /**
  215.  * e1000_init_module - Driver Registration Routine
  216.  *
  217.  * e1000_init_module is the first routine called when the driver is
  218.  * loaded. All it does is register with the PCI subsystem.
  219.  **/
  221. static int __init
  222. e1000_init_module(void)
  223. {
  224. int ret;
  225. printk(KERN_INFO "%s - version %sn",
  226.        e1000_driver_string, e1000_driver_version);
  228. printk(KERN_INFO "%sn", e1000_copyright);
  230. ret = pci_module_init(&e1000_driver);
  231. if(ret >= 0) {
  232. register_reboot_notifier(&e1000_notifier_reboot);
  233. register_netdevice_notifier(&e1000_notifier_netdev);
  234. }
  235. return ret;
  236. }
  238. module_init(e1000_init_module);
  240. /**
  241.  * e1000_exit_module - Driver Exit Cleanup Routine
  242.  *
  243.  * e1000_exit_module is called just before the driver is removed
  244.  * from memory.
  245.  **/
  247. static void __exit
  248. e1000_exit_module(void)
  249. {
  250. unregister_reboot_notifier(&e1000_notifier_reboot);
  251. unregister_netdevice_notifier(&e1000_notifier_netdev);
  252. pci_unregister_driver(&e1000_driver);
  253. }
  255. module_exit(e1000_exit_module);
  258. int
  259. e1000_up(struct e1000_adapter *adapter)
  260. {
  261. struct net_device *netdev = adapter->netdev;
  263. if(request_irq(netdev->irq, &e1000_intr, SA_SHIRQ | SA_SAMPLE_RANDOM,
  264.                netdev->name, netdev))
  265. return -1;
  267. /* hardware has been reset, we need to reload some things */
  269. e1000_set_multi(netdev);
  271. e1000_configure_tx(adapter);
  272. e1000_setup_rctl(adapter);
  273. e1000_configure_rx(adapter);
  274. e1000_alloc_rx_buffers(adapter);
  276. mod_timer(&adapter->watchdog_timer, jiffies);
  277. e1000_irq_enable(adapter);
  279. return 0;
  280. }
  282. void
  283. e1000_down(struct e1000_adapter *adapter)
  284. {
  285. struct net_device *netdev = adapter->netdev;
  287. e1000_irq_disable(adapter);
  288. free_irq(netdev->irq, netdev);
  289. del_timer_sync(&adapter->watchdog_timer);
  290. del_timer_sync(&adapter->phy_info_timer);
  291. adapter->link_speed = 0;
  292. adapter->link_duplex = 0;
  293. netif_carrier_off(netdev);
  294. netif_stop_queue(netdev);
  296. e1000_reset(adapter);
  297. e1000_clean_tx_ring(adapter);
  298. e1000_clean_rx_ring(adapter);
  299. }
  301. void
  302. e1000_reset(struct e1000_adapter *adapter)
  303. {
  304. /* Repartition Pba for greater than 9k mtu
  305.  * To take effect CTRL.RST is required.
  306.  */
  308. if(adapter->rx_buffer_len > E1000_RXBUFFER_8192)
  309. E1000_WRITE_REG(&adapter->hw, PBA, E1000_JUMBO_PBA);
  310. else
  311. E1000_WRITE_REG(&adapter->hw, PBA, E1000_DEFAULT_PBA);
  313. adapter->hw.fc = adapter->hw.original_fc;
  314. e1000_reset_hw(&adapter->hw);
  315. if(adapter->hw.mac_type >= e1000_82544)
  316. E1000_WRITE_REG(&adapter->hw, WUC, 0);
  317. e1000_init_hw(&adapter->hw);
  318. e1000_reset_adaptive(&adapter->hw);
  319. e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
  320. }
  322. /**
  323.  * e1000_probe - Device Initialization Routine
  324.  * @pdev: PCI device information struct
  325.  * @ent: entry in e1000_pci_tbl
  326.  *
  327.  * Returns 0 on success, negative on failure
  328.  *
  329.  * e1000_probe initializes an adapter identified by a pci_dev structure.
  330.  * The OS initialization, configuring of the adapter private structure,
  331.  * and a hardware reset occur.
  332.  **/
  334. static int __devinit
  335. e1000_probe(struct pci_dev *pdev,
  336.             const struct pci_device_id *ent)
  337. {
  338. struct net_device *netdev;
  339. struct e1000_adapter *adapter;
  340. static int cards_found = 0;
  341. unsigned long mmio_start;
  342. int mmio_len;
  343. int pci_using_dac;
  344. int i;
  346. if((i = pci_enable_device(pdev)))
  347. return i;
  349. if(!(i = pci_set_dma_mask(pdev, PCI_DMA_64BIT))) {
  350. pci_using_dac = 1;
  351. } else {
  352. if((i = pci_set_dma_mask(pdev, PCI_DMA_32BIT))) {
  353. E1000_ERR("No usable DMA configuration, abortingn");
  354. return i;
  355. }
  356. pci_using_dac = 0;
  357. }
  359. if((i = pci_request_regions(pdev, e1000_driver_name)))
  360. return i;
  362. pci_set_master(pdev);
  364. netdev = alloc_etherdev(sizeof(struct e1000_adapter));
  365. if(!netdev)
  366. goto err_alloc_etherdev;
  368. SET_MODULE_OWNER(netdev);
  370. pci_set_drvdata(pdev, netdev);
  371. adapter = netdev->priv;
  372. adapter->netdev = netdev;
  373. adapter->pdev = pdev;
  374. adapter->hw.back = adapter;
  376. mmio_start = pci_resource_start(pdev, BAR_0);
  377. mmio_len = pci_resource_len(pdev, BAR_0);
  379. adapter->hw.hw_addr = ioremap(mmio_start, mmio_len);
  380. if(!adapter->hw.hw_addr)
  381. goto err_ioremap;
  383. for(i = BAR_1; i <= BAR_5; i++) {
  384. if(pci_resource_len(pdev, i) == 0)
  385. continue;
  386. if(pci_resource_flags(pdev, i) & IORESOURCE_IO) {
  387. adapter->hw.io_base = pci_resource_start(pdev, i);
  388. break;
  389. }
  390. }
  392. netdev->open = &e1000_open;
  393. netdev->stop = &e1000_close;
  394. netdev->hard_start_xmit = &e1000_xmit_frame;
  395. netdev->get_stats = &e1000_get_stats;
  396. netdev->set_multicast_list = &e1000_set_multi;
  397. netdev->set_mac_address = &e1000_set_mac;
  398. netdev->change_mtu = &e1000_change_mtu;
  399. netdev->do_ioctl = &e1000_ioctl;
  400. netdev->tx_timeout = &e1000_tx_timeout;
  401. netdev->watchdog_timeo = HZ;
  402. netdev->vlan_rx_register = e1000_vlan_rx_register;
  403. netdev->vlan_rx_add_vid = e1000_vlan_rx_add_vid;
  404. netdev->vlan_rx_kill_vid = e1000_vlan_rx_kill_vid;
  406. netdev->irq = pdev->irq;
  407. netdev->mem_start = mmio_start;
  408. netdev->mem_end = mmio_start + mmio_len;
  409. netdev->base_addr = adapter->hw.io_base;
  411. adapter->bd_number = cards_found;
  412. adapter->id_string = e1000_strings[ent->driver_data];
  414. /* setup the private structure */
  416. if(e1000_sw_init(adapter))
  417. goto err_sw_init;
  419. if(adapter->hw.mac_type >= e1000_82543) {
  420. netdev->features = NETIF_F_SG |
  421.            NETIF_F_HW_CSUM |
  422.                    NETIF_F_HW_VLAN_TX |
  423.                    NETIF_F_HW_VLAN_RX |
  424.    NETIF_F_HW_VLAN_FILTER;
  425. } else {
  426. netdev->features = NETIF_F_SG;
  427. }
  429. if(pci_using_dac)
  430. netdev->features |= NETIF_F_HIGHDMA;
  432. /* make sure the EEPROM is good */
  434. if(e1000_validate_eeprom_checksum(&adapter->hw) < 0) {
  435. printk(KERN_ERR "The EEPROM Checksum Is Not Validn");
  436. goto err_eeprom;
  437. }
  439. /* copy the MAC address out of the EEPROM */
  441. e1000_read_mac_addr(&adapter->hw);
  442. memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
  444. if(!is_valid_ether_addr(netdev->dev_addr))
  445. goto err_eeprom;
  447. e1000_read_part_num(&adapter->hw, &(adapter->part_num));
  449. e1000_get_bus_info(&adapter->hw);
  451. if((adapter->hw.mac_type == e1000_82544) &&
  452.    (adapter->hw.bus_type == e1000_bus_type_pcix))
  454. adapter->max_data_per_txd = 4096;
  455. else
  456. adapter->max_data_per_txd = MAX_JUMBO_FRAME_SIZE;
  459. init_timer(&adapter->watchdog_timer);
  460. adapter->watchdog_timer.function = &e1000_watchdog;
  461. adapter->watchdog_timer.data = (unsigned long) adapter;
  463. init_timer(&adapter->phy_info_timer);
  464. adapter->phy_info_timer.function = &e1000_update_phy_info;
  465. adapter->phy_info_timer.data = (unsigned long) adapter;
  467. INIT_TQUEUE(&adapter->tx_timeout_task, 
  468. (void (*)(void *))e1000_tx_timeout_task, netdev);
  470. register_netdev(netdev);
  471. memcpy(adapter->ifname, netdev->name, IFNAMSIZ);
  472. adapter->ifname[IFNAMSIZ-1] = 0;
  474. /* we're going to reset, so assume we have no link for now */
  476. netif_carrier_off(netdev);
  477. netif_stop_queue(netdev);
  479. printk(KERN_INFO "%s: %sn", netdev->name, adapter->id_string);
  480. e1000_check_options(adapter);
  481. e1000_proc_dev_setup(adapter);
  483. /* Initial Wake on LAN setting
  484.  * If APM wake is enabled in the EEPROM,
  485.  * enable the ACPI Magic Packet filter
  486.  */
  488. if((adapter->hw.mac_type >= e1000_82544) &&
  489.    (E1000_READ_REG(&adapter->hw, WUC) & E1000_WUC_APME))
  490. adapter->wol |= E1000_WUFC_MAG;
  492. /* reset the hardware with the new settings */
  494. e1000_reset(adapter);
  496. cards_found++;
  497. return 0;
  499. err_sw_init:
  500. err_eeprom:
  501. iounmap(adapter->hw.hw_addr);
  502. err_ioremap:
  503. pci_release_regions(pdev);
  504. kfree(netdev);
  505. err_alloc_etherdev:
  506. return -ENOMEM;
  507. }
  509. /**
  510.  * e1000_remove - Device Removal Routine
  511.  * @pdev: PCI device information struct
  512.  *
  513.  * e1000_remove is called by the PCI subsystem to alert the driver
  514.  * that it should release a PCI device.  The could be caused by a
  515.  * Hot-Plug event, or because the driver is going to be removed from
  516.  * memory.
  517.  **/
  519. static void __devexit
  520. e1000_remove(struct pci_dev *pdev)
  521. {
  522. struct net_device *netdev = pci_get_drvdata(pdev);
  523. struct e1000_adapter *adapter = netdev->priv;
  524. uint32_t manc;
  526. if(adapter->hw.mac_type >= e1000_82540) {
  527. manc = E1000_READ_REG(&adapter->hw, MANC);
  528. if(manc & E1000_MANC_SMBUS_EN) {
  529. manc |= E1000_MANC_ARP_EN;
  530. E1000_WRITE_REG(&adapter->hw, MANC, manc);
  531. }
  532. }
  534. unregister_netdev(netdev);
  536. e1000_phy_hw_reset(&adapter->hw);
  538. e1000_proc_dev_free(adapter);
  540. iounmap(adapter->hw.hw_addr);
  541. pci_release_regions(pdev);
  543. kfree(netdev);
  544. }
  546. /**
  547.  * e1000_sw_init - Initialize general software structures (struct e1000_adapter)
  548.  * @adapter: board private structure to initialize
  549.  *
  550.  * e1000_sw_init initializes the Adapter private data structure.
  551.  * Fields are initialized based on PCI device information and
  552.  * OS network device settings (MTU size).
  553.  **/
  555. static int __devinit
  556. e1000_sw_init(struct e1000_adapter *adapter)
  557. {
  558. struct e1000_hw *hw = &adapter->hw;
  559. struct net_device *netdev = adapter->netdev;
  560. struct pci_dev *pdev = adapter->pdev;
  562. /* PCI config space info */
  564. hw->vendor_id = pdev->vendor;
  565. hw->device_id = pdev->device;
  566. hw->subsystem_vendor_id = pdev->subsystem_vendor;
  567. hw->subsystem_id = pdev->subsystem_device;
  569. pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id);
  570. pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word);
  572. adapter->rx_buffer_len = E1000_RXBUFFER_2048;
  573. hw->max_frame_size = netdev->mtu +
  574.                          ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
  575. hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;
  577. /* identify the MAC */
  579. if (e1000_set_mac_type(hw)) {
  580. E1000_ERR("Unknown MAC Typen");
  581. return -1;
  582. }
  584. /* flow control settings */
  586. hw->fc_high_water = E1000_FC_HIGH_THRESH;
  587. hw->fc_low_water = E1000_FC_LOW_THRESH;
  588. hw->fc_pause_time = E1000_FC_PAUSE_TIME;
  589. hw->fc_send_xon = 1;
  591. /* Media type - copper or fiber */
  593. if(hw->mac_type >= e1000_82543) {
  594. uint32_t status = E1000_READ_REG(hw, STATUS);
  596. if(status & E1000_STATUS_TBIMODE)
  597. hw->media_type = e1000_media_type_fiber;
  598. else
  599. hw->media_type = e1000_media_type_copper;
  600. } else {
  601. hw->media_type = e1000_media_type_fiber;
  602. }
  604. if(hw->mac_type < e1000_82543)
  605. hw->report_tx_early = 0;
  606. else
  607. hw->report_tx_early = 1;
  609. hw->wait_autoneg_complete = FALSE;
  610. hw->tbi_compatibility_en = TRUE;
  611. hw->adaptive_ifs = TRUE;
  613. /* Copper options */
  615. if(hw->media_type == e1000_media_type_copper) {
  616. hw->mdix = AUTO_ALL_MODES;
  617. hw->disable_polarity_correction = FALSE;
  618. }
  620. atomic_set(&adapter->irq_sem, 1);
  621. spin_lock_init(&adapter->stats_lock);
  623. return 0;
  624. }
  626. /**
  627.  * e1000_open - Called when a network interface is made active
  628.  * @netdev: network interface device structure
  629.  *
  630.  * Returns 0 on success, negative value on failure
  631.  *
  632.  * The open entry point is called when a network interface is made
  633.  * active by the system (IFF_UP).  At this point all resources needed
  634.  * for transmit and receive operations are allocated, the interrupt
  635.  * handler is registered with the OS, the watchdog timer is started,
  636.  * and the stack is notified that the interface is ready.
  637.  **/
  639. static int
  640. e1000_open(struct net_device *netdev)
  641. {
  642. struct e1000_adapter *adapter = netdev->priv;
  644. /* allocate transmit descriptors */
  646. if(e1000_setup_tx_resources(adapter))
  647. goto err_setup_tx;
  649. /* allocate receive descriptors */
  651. if(e1000_setup_rx_resources(adapter))
  652. goto err_setup_rx;
  654. if(e1000_up(adapter))
  655. goto err_up;
  657. return 0;
  659. err_up:
  660. e1000_free_rx_resources(adapter);
  661. err_setup_rx:
  662. e1000_free_tx_resources(adapter);
  663. err_setup_tx:
  664. e1000_reset(adapter);
  666. return -EBUSY;
  667. }
  669. /**
  670.  * e1000_close - Disables a network interface
  671.  * @netdev: network interface device structure
  672.  *
  673.  * Returns 0, this is not allowed to fail
  674.  *
  675.  * The close entry point is called when an interface is de-activated
  676.  * by the OS.  The hardware is still under the drivers control, but
  677.  * needs to be disabled.  A global MAC reset is issued to stop the
  678.  * hardware, and all transmit and receive resources are freed.
  679.  **/
  681. static int
  682. e1000_close(struct net_device *netdev)
  683. {
  684. struct e1000_adapter *adapter = netdev->priv;
  686. e1000_down(adapter);
  688. e1000_free_tx_resources(adapter);
  689. e1000_free_rx_resources(adapter);
  691. return 0;
  692. }
  694. /**
  695.  * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
  696.  * @adapter: board private structure
  697.  *
  698.  * Return 0 on success, negative on failure
  699.  **/
  701. static int
  702. e1000_setup_tx_resources(struct e1000_adapter *adapter)
  703. {
  704. struct e1000_desc_ring *txdr = &adapter->tx_ring;
  705. struct pci_dev *pdev = adapter->pdev;
  706. int size;
  708. size = sizeof(struct e1000_buffer) * txdr->count;
  709. txdr->buffer_info = kmalloc(size, GFP_KERNEL);
  710. if(!txdr->buffer_info) {
  711. return -ENOMEM;
  712. }
  713. memset(txdr->buffer_info, 0, size);
  715. /* round up to nearest 4K */
  717. txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
  718. E1000_ROUNDUP(txdr->size, 4096);
  720. txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
  721. if(!txdr->desc) {
  722. kfree(txdr->buffer_info);
  723. return -ENOMEM;
  724. }
  725. memset(txdr->desc, 0, txdr->size);
  727. txdr->next_to_use = 0;
  728. txdr->next_to_clean = 0;
  730. return 0;
  731. }
  733. /**
  734.  * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
  735.  * @adapter: board private structure
  736.  *
  737.  * Configure the Tx unit of the MAC after a reset.
  738.  **/
  740. static void
  741. e1000_configure_tx(struct e1000_adapter *adapter)
  742. {
  743. uint64_t tdba = adapter->tx_ring.dma;
  744. uint32_t tdlen = adapter->tx_ring.count * sizeof(struct e1000_tx_desc);
  745. uint32_t tctl, tipg;
  747. E1000_WRITE_REG(&adapter->hw, TDBAL, (tdba & 0x00000000ffffffffULL));
  748. E1000_WRITE_REG(&adapter->hw, TDBAH, (tdba >> 32));
  750. E1000_WRITE_REG(&adapter->hw, TDLEN, tdlen);
  752. /* Setup the HW Tx Head and Tail descriptor pointers */
  754. E1000_WRITE_REG(&adapter->hw, TDH, 0);
  755. E1000_WRITE_REG(&adapter->hw, TDT, 0);
  757. /* Set the default values for the Tx Inter Packet Gap timer */
  759. switch (adapter->hw.mac_type) {
  760. case e1000_82542_rev2_0:
  761. case e1000_82542_rev2_1:
  762. tipg = DEFAULT_82542_TIPG_IPGT;
  763. tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
  764. tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
  765. break;
  766. default:
  767. if(adapter->hw.media_type == e1000_media_type_fiber)
  768. tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
  769. else
  770. tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
  771. tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
  772. tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
  773. }
  774. E1000_WRITE_REG(&adapter->hw, TIPG, tipg);
  776. /* Set the Tx Interrupt Delay register */
  778. E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay);
  779. if(adapter->hw.mac_type >= e1000_82540)
  780. E1000_WRITE_REG(&adapter->hw, TADV, adapter->tx_abs_int_delay);
  782. /* Program the Transmit Control Register */
  784. tctl = E1000_READ_REG(&adapter->hw, TCTL);
  786. tctl &= ~E1000_TCTL_CT;
  787. tctl |= E1000_TCTL_EN | E1000_TCTL_PSP |
  788.        (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
  790. E1000_WRITE_REG(&adapter->hw, TCTL, tctl);
  792. e1000_config_collision_dist(&adapter->hw);
  794. /* Setup Transmit Descriptor Settings for this adapter */
  795. adapter->txd_cmd = E1000_TXD_CMD_IFCS | E1000_TXD_CMD_IDE;
  797. if(adapter->hw.report_tx_early == 1)
  798. adapter->txd_cmd |= E1000_TXD_CMD_RS;
  799. else
  800. adapter->txd_cmd |= E1000_TXD_CMD_RPS;
  801. }
  803. /**
  804.  * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
  805.  * @adapter: board private structure
  806.  *
  807.  * Returns 0 on success, negative on failure
  808.  **/
  810. static int
  811. e1000_setup_rx_resources(struct e1000_adapter *adapter)
  812. {
  813. struct e1000_desc_ring *rxdr = &adapter->rx_ring;
  814. struct pci_dev *pdev = adapter->pdev;
  815. int size;
  817. size = sizeof(struct e1000_buffer) * rxdr->count;
  818. rxdr->buffer_info = kmalloc(size, GFP_KERNEL);
  819. if(!rxdr->buffer_info) {
  820. return -ENOMEM;
  821. }
  822. memset(rxdr->buffer_info, 0, size);
  824. /* Round up to nearest 4K */
  826. rxdr->size = rxdr->count * sizeof(struct e1000_rx_desc);
  827. E1000_ROUNDUP(rxdr->size, 4096);
  829. rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
  831. if(!rxdr->desc) {
  832. kfree(rxdr->buffer_info);
  833. return -ENOMEM;
  834. }
  835. memset(rxdr->desc, 0, rxdr->size);
  837. rxdr->next_to_clean = 0;
  838. rxdr->next_to_use = 0;
  840. return 0;
  841. }
  843. /**
  844.  * e1000_setup_rctl - configure the receive control register
  845.  * @adapter: Board private structure
  846.  **/
  848. static void
  849. e1000_setup_rctl(struct e1000_adapter *adapter)
  850. {
  851. uint32_t rctl;
  853. rctl = E1000_READ_REG(&adapter->hw, RCTL);
  855. rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
  857. rctl |= E1000_RCTL_EN | E1000_RCTL_BAM |
  858.         E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
  859.         (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT);
  861. if(adapter->hw.tbi_compatibility_on == 1)
  862. rctl |= E1000_RCTL_SBP;
  863. else
  864. rctl &= ~E1000_RCTL_SBP;
  866. rctl &= ~(E1000_RCTL_SZ_4096);
  867. switch (adapter->rx_buffer_len) {
  868. case E1000_RXBUFFER_2048:
  869. default:
  870. rctl |= E1000_RCTL_SZ_2048;
  871. rctl &= ~(E1000_RCTL_BSEX | E1000_RCTL_LPE);
  872. break;
  873. case E1000_RXBUFFER_4096:
  874. rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
  875. break;
  876. case E1000_RXBUFFER_8192:
  877. rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
  878. break;
  879. case E1000_RXBUFFER_16384:
  880. rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE;
  881. break;
  882. }
  884. E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
  885. }
  887. /**
  888.  * e1000_configure_rx - Configure 8254x Receive Unit after Reset
  889.  * @adapter: board private structure
  890.  *
  891.  * Configure the Rx unit of the MAC after a reset.
  892.  **/
  894. static void
  895. e1000_configure_rx(struct e1000_adapter *adapter)
  896. {
  897. uint64_t rdba = adapter->rx_ring.dma;
  898. uint32_t rdlen = adapter->rx_ring.count * sizeof(struct e1000_rx_desc);
  899. uint32_t rctl;
  900. uint32_t rxcsum;
  902. /* make sure receives are disabled while setting up the descriptors */
  904. rctl = E1000_READ_REG(&adapter->hw, RCTL);
  905. E1000_WRITE_REG(&adapter->hw, RCTL, rctl & ~E1000_RCTL_EN);
  907. /* set the Receive Delay Timer Register */
  909. E1000_WRITE_REG(&adapter->hw, RDTR, adapter->rx_int_delay);
  911. if(adapter->hw.mac_type >= e1000_82540) {
  912. E1000_WRITE_REG(&adapter->hw, RADV, adapter->rx_abs_int_delay);
  914. /* Set the interrupt throttling rate.  Value is calculated
  915.  * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns) */
  916. #define MAX_INTS_PER_SEC        8000
  917. #define DEFAULT_ITR             1000000000/(MAX_INTS_PER_SEC * 256)
  918. E1000_WRITE_REG(&adapter->hw, ITR, DEFAULT_ITR);
  919. }
  921. /* Setup the Base and Length of the Rx Descriptor Ring */
  923. E1000_WRITE_REG(&adapter->hw, RDBAL, (rdba & 0x00000000ffffffffULL));
  924. E1000_WRITE_REG(&adapter->hw, RDBAH, (rdba >> 32));
  926. E1000_WRITE_REG(&adapter->hw, RDLEN, rdlen);
  928. /* Setup the HW Rx Head and Tail Descriptor Pointers */
  929. E1000_WRITE_REG(&adapter->hw, RDH, 0);
  930. E1000_WRITE_REG(&adapter->hw, RDT, 0);
  932. /* Enable 82543 Receive Checksum Offload for TCP and UDP */
  933. if((adapter->hw.mac_type >= e1000_82543) &&
  934.    (adapter->rx_csum == TRUE)) {
  935. rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM);
  936. rxcsum |= E1000_RXCSUM_TUOFL;
  937. E1000_WRITE_REG(&adapter->hw, RXCSUM, rxcsum);
  938. }
  940. /* Enable Receives */
  942. E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
  943. }
  945. /**
  946.  * e1000_free_tx_resources - Free Tx Resources
  947.  * @adapter: board private structure
  948.  *
  949.  * Free all transmit software resources
  950.  **/
  952. static void
  953. e1000_free_tx_resources(struct e1000_adapter *adapter)
  954. {
  955. struct pci_dev *pdev = adapter->pdev;
  957. e1000_clean_tx_ring(adapter);
  959. kfree(adapter->tx_ring.buffer_info);
  960. adapter->tx_ring.buffer_info = NULL;
  962. pci_free_consistent(pdev, adapter->tx_ring.size,
  963.                     adapter->tx_ring.desc, adapter->tx_ring.dma);
  965. adapter->tx_ring.desc = NULL;
  966. }
  968. /**
  969.  * e1000_clean_tx_ring - Free Tx Buffers
  970.  * @adapter: board private structure
  971.  **/
  973. static void
  974. e1000_clean_tx_ring(struct e1000_adapter *adapter)
  975. {
  976. struct pci_dev *pdev = adapter->pdev;
  977. unsigned long size;
  978. int i;
  980. /* Free all the Tx ring sk_buffs */
  982. for(i = 0; i < adapter->tx_ring.count; i++) {
  983. if(adapter->tx_ring.buffer_info[i].skb) {
  985. pci_unmap_page(pdev,
  986.                adapter->tx_ring.buffer_info[i].dma,
  987.                adapter->tx_ring.buffer_info[i].length,
  988.                PCI_DMA_TODEVICE);
  990. dev_kfree_skb(adapter->tx_ring.buffer_info[i].skb);
  992. adapter->tx_ring.buffer_info[i].skb = NULL;
  993. }
  994. }
  996. size = sizeof(struct e1000_buffer) * adapter->tx_ring.count;
  997. memset(adapter->tx_ring.buffer_info, 0, size);
  999. /* Zero out the descriptor ring */
  1001. memset(adapter->tx_ring.desc, 0, adapter->tx_ring.size);
  1003. adapter->tx_ring.next_to_use = 0;
  1004. adapter->tx_ring.next_to_clean = 0;
  1006. E1000_WRITE_REG(&adapter->hw, TDH, 0);
  1007. E1000_WRITE_REG(&adapter->hw, TDT, 0);
  1008. }
  1010. /**
  1011.  * e1000_free_rx_resources - Free Rx Resources
  1012.  * @adapter: board private structure
  1013.  *
  1014.  * Free all receive software resources
  1015.  **/
  1017. static void
  1018. e1000_free_rx_resources(struct e1000_adapter *adapter)
  1019. {
  1020. struct pci_dev *pdev = adapter->pdev;
  1022. e1000_clean_rx_ring(adapter);
  1024. kfree(adapter->rx_ring.buffer_info);
  1025. adapter->rx_ring.buffer_info = NULL;
  1027. pci_free_consistent(pdev, adapter->rx_ring.size,
  1028.                     adapter->rx_ring.desc, adapter->rx_ring.dma);
  1030. adapter->rx_ring.desc = NULL;
  1031. }
  1033. /**
  1034.  * e1000_clean_rx_ring - Free Rx Buffers
  1035.  * @adapter: board private structure
  1036.  **/
  1038. static void
  1039. e1000_clean_rx_ring(struct e1000_adapter *adapter)
  1040. {
  1041. struct pci_dev *pdev = adapter->pdev;
  1042. unsigned long size;
  1043. int i;
  1045. /* Free all the Rx ring sk_buffs */
  1047. for(i = 0; i < adapter->rx_ring.count; i++) {
  1048. if(adapter->rx_ring.buffer_info[i].skb) {
  1050. pci_unmap_single(pdev,
  1051.                  adapter->rx_ring.buffer_info[i].dma,
  1052.                  adapter->rx_ring.buffer_info[i].length,
  1053.                  PCI_DMA_FROMDEVICE);
  1055. dev_kfree_skb(adapter->rx_ring.buffer_info[i].skb);
  1057. adapter->rx_ring.buffer_info[i].skb = NULL;
  1058. }
  1059. }
  1061. size = sizeof(struct e1000_buffer) * adapter->rx_ring.count;
  1062. memset(adapter->rx_ring.buffer_info, 0, size);
  1064. /* Zero out the descriptor ring */
  1066. memset(adapter->rx_ring.desc, 0, adapter->rx_ring.size);
  1068. adapter->rx_ring.next_to_clean = 0;
  1069. adapter->rx_ring.next_to_use = 0;
  1071. E1000_WRITE_REG(&adapter->hw, RDH, 0);
  1072. E1000_WRITE_REG(&adapter->hw, RDT, 0);
  1073. }
  1075. /* The 82542 2.0 (revision 2) needs to have the receive unit in reset
  1076.  * and memory write and invalidate disabled for certain operations
  1077.  */
  1078. static void
  1079. e1000_enter_82542_rst(struct e1000_adapter *adapter)
  1080. {
  1081. struct net_device *netdev = adapter->netdev;
  1082. uint32_t rctl;
  1084. e1000_pci_clear_mwi(&adapter->hw);
  1086. rctl = E1000_READ_REG(&adapter->hw, RCTL);
  1087. rctl |= E1000_RCTL_RST;
  1088. E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
  1089. E1000_WRITE_FLUSH(&adapter->hw);
  1090. mdelay(5);
  1092. if(netif_running(netdev))
  1093. e1000_clean_rx_ring(adapter);
  1094. }
  1096. static void
  1097. e1000_leave_82542_rst(struct e1000_adapter *adapter)
  1098. {
  1099. struct net_device *netdev = adapter->netdev;
  1100. uint32_t rctl;
  1102. rctl = E1000_READ_REG(&adapter->hw, RCTL);
  1103. rctl &= ~E1000_RCTL_RST;
  1104. E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
  1105. E1000_WRITE_FLUSH(&adapter->hw);
  1106. mdelay(5);
  1108. if(adapter->hw.pci_cmd_word & PCI_COMMAND_INVALIDATE)
  1109. e1000_pci_set_mwi(&adapter->hw);
  1111. if(netif_running(netdev)) {
  1112. e1000_configure_rx(adapter);
  1113. e1000_alloc_rx_buffers(adapter);
  1114. }
  1115. }
  1117. /**
  1118.  * e1000_set_mac - Change the Ethernet Address of the NIC
  1119.  * @netdev: network interface device structure
  1120.  * @p: pointer to an address structure
  1121.  *
  1122.  * Returns 0 on success, negative on failure
  1123.  **/
  1125. static int
  1126. e1000_set_mac(struct net_device *netdev, void *p)
  1127. {
  1128. struct e1000_adapter *adapter = netdev->priv;
  1129. struct sockaddr *addr = p;
  1131. /* 82542 2.0 needs to be in reset to write receive address registers */
  1133. if(adapter->hw.mac_type == e1000_82542_rev2_0)
  1134. e1000_enter_82542_rst(adapter);
  1136. memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
  1137. memcpy(adapter->hw.mac_addr, addr->sa_data, netdev->addr_len);
  1139. e1000_rar_set(&adapter->hw, adapter->hw.mac_addr, 0);
  1141. if(adapter->hw.mac_type == e1000_82542_rev2_0)
  1142. e1000_leave_82542_rst(adapter);
  1144. return 0;
  1145. }
  1147. /**
  1148.  * e1000_set_multi - Multicast and Promiscuous mode set
  1149.  * @netdev: network interface device structure
  1150.  *
  1151.  * The set_multi entry point is called whenever the multicast address
  1152.  * list or the network interface flags are updated.  This routine is
  1153.  * resposible for configuring the hardware for proper multicast,
  1154.  * promiscuous mode, and all-multi behavior.
  1155.  **/
  1157. static void
  1158. e1000_set_multi(struct net_device *netdev)
  1159. {
  1160. struct e1000_adapter *adapter = netdev->priv;
  1161. struct e1000_hw *hw = &adapter->hw;
  1162. struct dev_mc_list *mc_ptr;
  1163. uint32_t rctl;
  1164. uint32_t hash_value;
  1165. int i;
  1167. /* Check for Promiscuous and All Multicast modes */
  1169. rctl = E1000_READ_REG(hw, RCTL);
  1171. if(netdev->flags & IFF_PROMISC) {
  1172. rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
  1173. } else if(netdev->flags & IFF_ALLMULTI) {
  1174. rctl |= E1000_RCTL_MPE;
  1175. rctl &= ~E1000_RCTL_UPE;
  1176. } else {
  1177. rctl &= ~(E1000_RCTL_UPE | E1000_RCTL_MPE);
  1178. }
  1180. E1000_WRITE_REG(hw, RCTL, rctl);
  1182. /* 82542 2.0 needs to be in reset to write receive address registers */
  1184. if(hw->mac_type == e1000_82542_rev2_0)
  1185. e1000_enter_82542_rst(adapter);
  1187. /* load the first 15 multicast address into the exact filters 1-15
  1188.  * RAR 0 is used for the station MAC adddress
  1189.  * if there are not 15 addresses, go ahead and clear the filters
  1190.  */
  1191. mc_ptr = netdev->mc_list;
  1193. for(i = 1; i < E1000_RAR_ENTRIES; i++) {
  1194. if(mc_ptr) {
  1195. e1000_rar_set(hw, mc_ptr->dmi_addr, i);
  1196. mc_ptr = mc_ptr->next;
  1197. } else {
  1198. E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
  1199. E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
  1200. }
  1201. }
  1203. /* clear the old settings from the multicast hash table */
  1205. for(i = 0; i < E1000_NUM_MTA_REGISTERS; i++)
  1206. E1000_WRITE_REG_ARRAY(hw, MTA, i, 0);
  1208. /* load any remaining addresses into the hash table */
  1210. for(; mc_ptr; mc_ptr = mc_ptr->next) {
  1211. hash_value = e1000_hash_mc_addr(hw, mc_ptr->dmi_addr);
  1212. e1000_mta_set(hw, hash_value);
  1213. }
  1215. if(hw->mac_type == e1000_82542_rev2_0)
  1216. e1000_leave_82542_rst(adapter);
  1217. }
  1220. /* need to wait a few seconds after link up to get diagnostic information from the phy */
  1222. static void
  1223. e1000_update_phy_info(unsigned long data)
  1224. {
  1225. struct e1000_adapter *adapter = (struct e1000_adapter *) data;
  1226. e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
  1227. }
  1229. /**
  1230.  * e1000_watchdog - Timer Call-back
  1231.  * @data: pointer to netdev cast into an unsigned long
  1232.  **/
  1234. static void
  1235. e1000_watchdog(unsigned long data)
  1236. {
  1237. struct e1000_adapter *adapter = (struct e1000_adapter *) data;
  1238. struct net_device *netdev = adapter->netdev;
  1239. struct e1000_desc_ring *txdr = &adapter->tx_ring;
  1240. int i;
  1242. e1000_check_for_link(&adapter->hw);
  1244. if(E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) {
  1245. if(!netif_carrier_ok(netdev)) {
  1246. e1000_get_speed_and_duplex(&adapter->hw,
  1247.                            &adapter->link_speed,
  1248.                            &adapter->link_duplex);
  1250. printk(KERN_INFO
  1251.        "e1000: %s NIC Link is Up %d Mbps %sn",
  1252.        netdev->name, adapter->link_speed,
  1253.        adapter->link_duplex == FULL_DUPLEX ?
  1254.        "Full Duplex" : "Half Duplex");
  1256. netif_carrier_on(netdev);
  1257. netif_wake_queue(netdev);
  1258. mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
  1259. }
  1260. } else {
  1261. if(netif_carrier_ok(netdev)) {
  1262. adapter->link_speed = 0;
  1263. adapter->link_duplex = 0;
  1264. printk(KERN_INFO
  1265.        "e1000: %s NIC Link is Downn",
  1266.        netdev->name);
  1267. netif_carrier_off(netdev);
  1268. netif_stop_queue(netdev);
  1269. mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ);
  1270. }
  1271. }
  1273. e1000_update_stats(adapter);
  1274. e1000_update_adaptive(&adapter->hw);
  1277. /* Cause software interrupt to ensure rx ring is cleaned */
  1278. E1000_WRITE_REG(&adapter->hw, ICS, E1000_ICS_RXDMT0);
  1280. /* Early detection of hung controller */
  1281. i = txdr->next_to_clean;
  1282. if(txdr->buffer_info[i].dma &&
  1283.    time_after(jiffies, txdr->buffer_info[i].time_stamp + HZ) &&
  1284.    !(E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF))
  1285. netif_stop_queue(netdev);
  1287. /* Reset the timer */
  1288. mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
  1289. }
  1291. #define E1000_TX_FLAGS_CSUM 0x00000001
  1292. #define E1000_TX_FLAGS_VLAN 0x00000002
  1293. #define E1000_TX_FLAGS_VLAN_MASK 0xffff0000
  1294. #define E1000_TX_FLAGS_VLAN_SHIFT 16
  1296. static inline boolean_t
  1297. e1000_tx_csum(struct e1000_adapter *adapter, struct sk_buff *skb)
  1298. {
  1299. struct e1000_context_desc *context_desc;
  1300. int i;
  1301. uint8_t css, cso;
  1303. if(skb->ip_summed == CHECKSUM_HW) {
  1304. css = skb->h.raw - skb->data;
  1305. cso = (skb->h.raw + skb->csum) - skb->data;
  1307. i = adapter->tx_ring.next_to_use;
  1308. context_desc = E1000_CONTEXT_DESC(adapter->tx_ring, i);
  1310. context_desc->upper_setup.tcp_fields.tucss = css;
  1311. context_desc->upper_setup.tcp_fields.tucso = cso;
  1312. context_desc->upper_setup.tcp_fields.tucse = 0;
  1313. context_desc->tcp_seg_setup.data = 0;
  1314. context_desc->cmd_and_length =
  1315. cpu_to_le32(adapter->txd_cmd | E1000_TXD_CMD_DEXT);
  1317. i = (i + 1) % adapter->tx_ring.count;
  1318. adapter->tx_ring.next_to_use = i;
  1320. return TRUE;
  1321. }
  1323. return FALSE;
  1324. }
  1326. static inline int
  1327. e1000_tx_map(struct e1000_adapter *adapter, struct sk_buff *skb)
  1328. {
  1329. struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
  1330. int len, offset, size, count, i;
  1332. int f;
  1333. len = skb->len - skb->data_len;
  1335. i = (tx_ring->next_to_use + tx_ring->count - 1) % tx_ring->count;
  1336. count = 0;
  1338. offset = 0;
  1340. while(len) {
  1341. i = (i + 1) % tx_ring->count;
  1342. size = min(len, adapter->max_data_per_txd);
  1343. tx_ring->buffer_info[i].length = size;
  1344. tx_ring->buffer_info[i].dma =
  1345. pci_map_single(adapter->pdev,
  1346. skb->data + offset,
  1347. size,
  1348. PCI_DMA_TODEVICE);
  1349. tx_ring->buffer_info[i].time_stamp = jiffies;
  1351. len -= size;
  1352. offset += size;
  1353. count++;
  1354. }
  1356. for(f = 0; f < skb_shinfo(skb)->nr_frags; f++) {
  1357. struct skb_frag_struct *frag;
  1359. frag = &skb_shinfo(skb)->frags[f];
  1360. len = frag->size;
  1361. offset = 0;
  1363. while(len) {
  1364. i = (i + 1) % tx_ring->count;
  1365. size = min(len, adapter->max_data_per_txd);
  1366. tx_ring->buffer_info[i].length = size;
  1367. tx_ring->buffer_info[i].dma =
  1368. pci_map_page(adapter->pdev,
  1369. frag->page,
  1370. frag->page_offset + offset,
  1371. size,
  1372. PCI_DMA_TODEVICE);
  1374. len -= size;
  1375. offset += size;
  1376. count++;
  1377. }
  1378. }
  1379. tx_ring->buffer_info[i].skb = skb;
  1381. return count;
  1382. }
  1384. static inline void
  1385. e1000_tx_queue(struct e1000_adapter *adapter, int count, int tx_flags)
  1386. {
  1387. struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
  1388. struct e1000_tx_desc *tx_desc = NULL;
  1389. uint32_t txd_upper, txd_lower;
  1390. int i;
  1392. txd_upper = 0;
  1393. txd_lower = adapter->txd_cmd;
  1395. if(tx_flags & E1000_TX_FLAGS_CSUM) {
  1396. txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
  1397. txd_upper |= E1000_TXD_POPTS_TXSM << 8;
  1398. }
  1400. if(tx_flags & E1000_TX_FLAGS_VLAN) {
  1401. txd_lower |= E1000_TXD_CMD_VLE;
  1402. txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
  1403. }
  1405. i = tx_ring->next_to_use;
  1407. while(count--) {
  1408. tx_desc = E1000_TX_DESC(*tx_ring, i);
  1409. tx_desc->buffer_addr = cpu_to_le64(tx_ring->buffer_info[i].dma);
  1410. tx_desc->lower.data =
  1411. cpu_to_le32(txd_lower | tx_ring->buffer_info[i].length);
  1412. tx_desc->upper.data = cpu_to_le32(txd_upper);
  1413. i = (i + 1) % tx_ring->count;
  1414. }
  1416. tx_desc->lower.data |= cpu_to_le32(E1000_TXD_CMD_EOP);
  1418. /* Force memory writes to complete before letting h/w
  1419.  * know there are new descriptors to fetch.  (Only
  1420.  * applicable for weak-ordered memory model archs,
  1421.  * such as IA-64). */
  1422. wmb();
  1424. tx_ring->next_to_use = i;
  1425. E1000_WRITE_REG(&adapter->hw, TDT, i);
  1426. }
  1428. #define TXD_USE_COUNT(S, X) (((S) / (X)) + (((S) % (X)) ? 1 : 0))
  1430. static int
  1431. e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
  1432. {
  1433. struct e1000_adapter *adapter = netdev->priv;
  1434. int tx_flags = 0, count;
  1436. int f;
  1438. count = TXD_USE_COUNT(skb->len - skb->data_len,
  1439.                       adapter->max_data_per_txd);
  1440. for(f = 0; f < skb_shinfo(skb)->nr_frags; f++)
  1441. count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size,
  1442.                        adapter->max_data_per_txd);
  1444. if(skb->ip_summed == CHECKSUM_HW)
  1445. count++;
  1447. if(E1000_DESC_UNUSED(&adapter->tx_ring) < count) {
  1448. netif_stop_queue(netdev);
  1449. return 1;
  1450. }
  1452. if(e1000_tx_csum(adapter, skb))
  1453. tx_flags |= E1000_TX_FLAGS_CSUM;
  1455. if(adapter->vlgrp && vlan_tx_tag_present(skb)) {
  1456. tx_flags |= E1000_TX_FLAGS_VLAN;
  1457. tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
  1458. }
  1460. count = e1000_tx_map(adapter, skb);
  1462. e1000_tx_queue(adapter, count, tx_flags);
  1464. netdev->trans_start = jiffies;
  1466. return 0;
  1467. }
  1469. /**
  1470.  * e1000_tx_timeout - Respond to a Tx Hang
  1471.  * @netdev: network interface device structure
  1472.  **/
  1474. static void
  1475. e1000_tx_timeout(struct net_device *netdev)
  1476. {
  1477. struct e1000_adapter *adapter = netdev->priv;
  1479. /* Do the reset outside of interrupt context */
  1480. schedule_task(&adapter->tx_timeout_task);
  1481. }
  1483. static void
  1484. e1000_tx_timeout_task(struct net_device *netdev)
  1485. {
  1486. struct e1000_adapter *adapter = netdev->priv;
  1488. netif_device_detach(netdev);
  1489. e1000_down(adapter);
  1490. e1000_up(adapter);
  1491. netif_device_attach(netdev);
  1492. }
  1494. /**
  1495.  * e1000_get_stats - Get System Network Statistics
  1496.  * @netdev: network interface device structure
  1497.  *
  1498.  * Returns the address of the device statistics structure.
  1499.  * The statistics are actually updated from the timer callback.
  1500.  **/
  1502. static struct net_device_stats *
  1503. e1000_get_stats(struct net_device *netdev)
  1504. {
  1505. struct e1000_adapter *adapter = netdev->priv;
  1507. return &adapter->net_stats;
  1508. }
  1510. /**
  1511.  * e1000_change_mtu - Change the Maximum Transfer Unit
  1512.  * @netdev: network interface device structure
  1513.  * @new_mtu: new value for maximum frame size
  1514.  *
  1515.  * Returns 0 on success, negative on failure
  1516.  **/
  1518. static int
  1519. e1000_change_mtu(struct net_device *netdev, int new_mtu)
  1520. {
  1521. struct e1000_adapter *adapter = netdev->priv;
  1522. int old_mtu = adapter->rx_buffer_len;
  1523. int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
  1525. if((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
  1526.    (max_frame > MAX_JUMBO_FRAME_SIZE)) {
  1527. E1000_ERR("Invalid MTU settingn");
  1528. return -EINVAL;
  1529. }
  1531. if(max_frame <= MAXIMUM_ETHERNET_FRAME_SIZE) {
  1532. adapter->rx_buffer_len = E1000_RXBUFFER_2048;
  1534. } else if(adapter->hw.mac_type < e1000_82543) {
  1535. E1000_ERR("Jumbo Frames not supported on 82542n");
  1536. return -EINVAL;
  1538. } else if(max_frame <= E1000_RXBUFFER_4096) {
  1539. adapter->rx_buffer_len = E1000_RXBUFFER_4096;
  1541. } else if(max_frame <= E1000_RXBUFFER_8192) {
  1542. adapter->rx_buffer_len = E1000_RXBUFFER_8192;
  1544. } else {
  1545. adapter->rx_buffer_len = E1000_RXBUFFER_16384;
  1546. }
  1548. if(old_mtu != adapter->rx_buffer_len && netif_running(netdev)) {
  1550. e1000_down(adapter);
  1551. e1000_up(adapter);
  1552. }
  1554. netdev->mtu = new_mtu;
  1555. adapter->hw.max_frame_size = max_frame;
  1557. return 0;
  1558. }
  1560. /**
  1561.  * e1000_update_stats - Update the board statistics counters
  1562.  * @adapter: board private structure
  1563.  **/
  1565. static void
  1566. e1000_update_stats(struct e1000_adapter *adapter)
  1567. {
  1568. struct e1000_hw *hw = &adapter->hw;
  1569. unsigned long flags;
  1570. uint16_t phy_tmp;
  1572. #define PHY_IDLE_ERROR_COUNT_MASK 0x00FF
  1574. spin_lock_irqsave(&adapter->stats_lock, flags);
  1576. /* these counters are modified from e1000_adjust_tbi_stats,
  1577.  * called from the interrupt context, so they must only
  1578.  * be written while holding adapter->stats_lock
  1579.  */
  1581. adapter->stats.crcerrs += E1000_READ_REG(hw, CRCERRS);
  1582. adapter->stats.gprc += E1000_READ_REG(hw, GPRC);
  1583. adapter->stats.gorcl += E1000_READ_REG(hw, GORCL);
  1584. adapter->stats.gorch += E1000_READ_REG(hw, GORCH);
  1585. adapter->stats.bprc += E1000_READ_REG(hw, BPRC);
  1586. adapter->stats.mprc += E1000_READ_REG(hw, MPRC);
  1587. adapter->stats.roc += E1000_READ_REG(hw, ROC);
  1588. adapter->stats.prc64 += E1000_READ_REG(hw, PRC64);
  1589. adapter->stats.prc127 += E1000_READ_REG(hw, PRC127);
  1590. adapter->stats.prc255 += E1000_READ_REG(hw, PRC255);
  1591. adapter->stats.prc511 += E1000_READ_REG(hw, PRC511);
  1592. adapter->stats.prc1023 += E1000_READ_REG(hw, PRC1023);
  1593. adapter->stats.prc1522 += E1000_READ_REG(hw, PRC1522);
  1595. spin_unlock_irqrestore(&adapter->stats_lock, flags);
  1597. /* the rest of the counters are only modified here */
  1599. adapter->stats.symerrs += E1000_READ_REG(hw, SYMERRS);
  1600. adapter->stats.mpc += E1000_READ_REG(hw, MPC);
  1601. adapter->stats.scc += E1000_READ_REG(hw, SCC);
  1602. adapter->stats.ecol += E1000_READ_REG(hw, ECOL);
  1603. adapter->stats.mcc += E1000_READ_REG(hw, MCC);
  1604. adapter->stats.latecol += E1000_READ_REG(hw, LATECOL);
  1605. adapter->stats.dc += E1000_READ_REG(hw, DC);
  1606. adapter->stats.sec += E1000_READ_REG(hw, SEC);
  1607. adapter->stats.rlec += E1000_READ_REG(hw, RLEC);
  1608. adapter->stats.xonrxc += E1000_READ_REG(hw, XONRXC);
  1609. adapter->stats.xontxc += E1000_READ_REG(hw, XONTXC);
  1610. adapter->stats.xoffrxc += E1000_READ_REG(hw, XOFFRXC);
  1611. adapter->stats.xofftxc += E1000_READ_REG(hw, XOFFTXC);
  1612. adapter->stats.fcruc += E1000_READ_REG(hw, FCRUC);
  1613. adapter->stats.gptc += E1000_READ_REG(hw, GPTC);
  1614. adapter->stats.gotcl += E1000_READ_REG(hw, GOTCL);
  1615. adapter->stats.gotch += E1000_READ_REG(hw, GOTCH);
  1616. adapter->stats.rnbc += E1000_READ_REG(hw, RNBC);
  1617. adapter->stats.ruc += E1000_READ_REG(hw, RUC);
  1618. adapter->stats.rfc += E1000_READ_REG(hw, RFC);
  1619. adapter->stats.rjc += E1000_READ_REG(hw, RJC);
  1620. adapter->stats.torl += E1000_READ_REG(hw, TORL);
  1621. adapter->stats.torh += E1000_READ_REG(hw, TORH);
  1622. adapter->stats.totl += E1000_READ_REG(hw, TOTL);
  1623. adapter->stats.toth += E1000_READ_REG(hw, TOTH);
  1624. adapter->stats.tpr += E1000_READ_REG(hw, TPR);
  1625. adapter->stats.ptc64 += E1000_READ_REG(hw, PTC64);
  1626. adapter->stats.ptc127 += E1000_READ_REG(hw, PTC127);
  1627. adapter->stats.ptc255 += E1000_READ_REG(hw, PTC255);
  1628. adapter->stats.ptc511 += E1000_READ_REG(hw, PTC511);
  1629. adapter->stats.ptc1023 += E1000_READ_REG(hw, PTC1023);
  1630. adapter->stats.ptc1522 += E1000_READ_REG(hw, PTC1522);
  1631. adapter->stats.mptc += E1000_READ_REG(hw, MPTC);
  1632. adapter->stats.bptc += E1000_READ_REG(hw, BPTC);
  1634. /* used for adaptive IFS */
  1636. hw->tx_packet_delta = E1000_READ_REG(hw, TPT);
  1637. adapter->stats.tpt += hw->tx_packet_delta;
  1638. hw->collision_delta = E1000_READ_REG(hw, COLC);
  1639. adapter->stats.colc += hw->collision_delta;
  1641. if(hw->mac_type >= e1000_82543) {
  1642. adapter->stats.algnerrc += E1000_READ_REG(hw, ALGNERRC);
  1643. adapter->stats.rxerrc += E1000_READ_REG(hw, RXERRC);
  1644. adapter->stats.tncrs += E1000_READ_REG(hw, TNCRS);
  1645. adapter->stats.cexterr += E1000_READ_REG(hw, CEXTERR);
  1646. adapter->stats.tsctc += E1000_READ_REG(hw, TSCTC);
  1647. adapter->stats.tsctfc += E1000_READ_REG(hw, TSCTFC);
  1648. }
  1650. /* Fill out the OS statistics structure */
  1652. adapter->net_stats.rx_packets = adapter->stats.gprc;
  1653. adapter->net_stats.tx_packets = adapter->stats.gptc;
  1654. adapter->net_stats.rx_bytes = adapter->stats.gorcl;
  1655. adapter->net_stats.tx_bytes = adapter->stats.gotcl;
  1656. adapter->net_stats.multicast = adapter->stats.mprc;
  1657. adapter->net_stats.collisions = adapter->stats.colc;
  1659. /* Rx Errors */
  1661. adapter->net_stats.rx_errors = adapter->stats.rxerrc +
  1662. adapter->stats.crcerrs + adapter->stats.algnerrc +
  1663. adapter->stats.rlec + adapter->stats.rnbc +
  1664. adapter->stats.mpc + adapter->stats.cexterr;
  1665. adapter->net_stats.rx_dropped = adapter->stats.rnbc;
  1666. adapter->net_stats.rx_length_errors = adapter->stats.rlec;
  1667. adapter->net_stats.rx_crc_errors = adapter->stats.crcerrs;
  1668. adapter->net_stats.rx_frame_errors = adapter->stats.algnerrc;
  1669. adapter->net_stats.rx_fifo_errors = adapter->stats.mpc;
  1670. adapter->net_stats.rx_missed_errors = adapter->stats.mpc;
  1672. /* Tx Errors */
  1674. adapter->net_stats.tx_errors = adapter->stats.ecol +
  1675.                                adapter->stats.latecol;
  1676. adapter->net_stats.tx_aborted_errors = adapter->stats.ecol;
  1677. adapter->net_stats.tx_window_errors = adapter->stats.latecol;
  1678. adapter->net_stats.tx_carrier_errors = adapter->stats.tncrs;
  1680. /* Tx Dropped needs to be maintained elsewhere */
  1682. /* Phy Stats */
  1684. if(hw->media_type == e1000_media_type_copper) {
  1685. if((adapter->link_speed == SPEED_1000) &&
  1686.    (!e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_tmp))) {
  1687. phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK;
  1688. adapter->phy_stats.idle_errors += phy_tmp;
  1689. }
  1691. if((hw->mac_type <= e1000_82546) &&
  1692.    !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp))
  1693. adapter->phy_stats.receive_errors += phy_tmp;
  1694. }
  1695. }
  1697. /**
  1698.  * e1000_irq_disable - Mask off interrupt generation on the NIC
  1699.  * @adapter: board private structure
  1700.  **/
  1702. static inline void
  1703. e1000_irq_disable(struct e1000_adapter *adapter)
  1704. {
  1705. atomic_inc(&adapter->irq_sem);
  1706. E1000_WRITE_REG(&adapter->hw, IMC, ~0);
  1707. E1000_WRITE_FLUSH(&adapter->hw);
  1708. synchronize_irq();
  1709. }
  1711. /**
  1712.  * e1000_irq_enable - Enable default interrupt generation settings
  1713.  * @adapter: board private structure
  1714.  **/
  1716. static inline void
  1717. e1000_irq_enable(struct e1000_adapter *adapter)
  1718. {
  1719. if(atomic_dec_and_test(&adapter->irq_sem)) {
  1720. E1000_WRITE_REG(&adapter->hw, IMS, IMS_ENABLE_MASK);
  1721. E1000_WRITE_FLUSH(&adapter->hw);
  1722. }
  1723. }
  1725. /**
  1726.  * e1000_intr - Interrupt Handler
  1727.  * @irq: interrupt number
  1728.  * @data: pointer to a network interface device structure
  1729.  * @pt_regs: CPU registers structure
  1730.  **/
  1732. static void
  1733. e1000_intr(int irq, void *data, struct pt_regs *regs)
  1734. {
  1735. struct net_device *netdev = data;
  1736. struct e1000_adapter *adapter = netdev->priv;
  1737. uint32_t icr;
  1738. int i = E1000_MAX_INTR;
  1740. while(i && (icr = E1000_READ_REG(&adapter->hw, ICR))) {
  1742. if(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) {
  1743. adapter->hw.get_link_status = 1;
  1744. mod_timer(&adapter->watchdog_timer, jiffies);
  1745. }
  1747. e1000_clean_rx_irq(adapter);
  1748. e1000_clean_tx_irq(adapter);
  1749. i--;
  1751. }
  1752. }
  1754. /**
  1755.  * e1000_clean_tx_irq - Reclaim resources after transmit completes
  1756.  * @adapter: board private structure
  1757.  **/
  1759. static void
  1760. e1000_clean_tx_irq(struct e1000_adapter *adapter)
  1761. {
  1762. struct e1000_desc_ring *tx_ring = &adapter->tx_ring;
  1763. struct net_device *netdev = adapter->netdev;
  1764. struct pci_dev *pdev = adapter->pdev;
  1765. struct e1000_tx_desc *tx_desc;
  1766. int i;
  1768. i = tx_ring->next_to_clean;
  1769. tx_desc = E1000_TX_DESC(*tx_ring, i);
  1771. while(tx_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) {
  1773. if(tx_ring->buffer_info[i].dma) {
  1775. pci_unmap_page(pdev,
  1776.                tx_ring->buffer_info[i].dma,
  1777.                tx_ring->buffer_info[i].length,
  1778.                PCI_DMA_TODEVICE);
  1780. tx_ring->buffer_info[i].dma = 0;
  1781. }
  1783. if(tx_ring->buffer_info[i].skb) {
  1785. dev_kfree_skb_any(tx_ring->buffer_info[i].skb);
  1787. tx_ring->buffer_info[i].skb = NULL;
  1788. }
  1790. tx_desc->upper.data = 0;
  1792. i = (i + 1) % tx_ring->count;
  1793. tx_desc = E1000_TX_DESC(*tx_ring, i);
  1794. }
  1796. tx_ring->next_to_clean = i;
  1798. if(netif_queue_stopped(netdev) && netif_carrier_ok(netdev) &&
  1799.    (E1000_DESC_UNUSED(tx_ring) > E1000_TX_QUEUE_WAKE)) {
  1801. netif_wake_queue(netdev);
  1802. }
  1803. }
  1805. /**
  1806.  * e1000_clean_rx_irq - Send received data up the network stack,
  1807.  * @adapter: board private structure
  1808.  **/
  1810. static void
  1811. e1000_clean_rx_irq(struct e1000_adapter *adapter)
  1812. {
  1813. struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
  1814. struct net_device *netdev = adapter->netdev;
  1815. struct pci_dev *pdev = adapter->pdev;
  1816. struct e1000_rx_desc *rx_desc;
  1817. struct sk_buff *skb;
  1818. unsigned long flags;
  1819. uint32_t length;
  1820. uint8_t last_byte;
  1821. int i;
  1823. i = rx_ring->next_to_clean;
  1824. rx_desc = E1000_RX_DESC(*rx_ring, i);
  1826. while(rx_desc->status & E1000_RXD_STAT_DD) {
  1828. pci_unmap_single(pdev,
  1829.                  rx_ring->buffer_info[i].dma,
  1830.                  rx_ring->buffer_info[i].length,
  1831.                  PCI_DMA_FROMDEVICE);
  1833. skb = rx_ring->buffer_info[i].skb;
  1834. length = le16_to_cpu(rx_desc->length);
  1836. if(!(rx_desc->status & E1000_RXD_STAT_EOP)) {
  1838. /* All receives must fit into a single buffer */
  1840. E1000_DBG("Receive packet consumed multiple buffersn");
  1842. dev_kfree_skb_irq(skb);
  1843. rx_desc->status = 0;
  1844. rx_ring->buffer_info[i].skb = NULL;
  1846. i = (i + 1) % rx_ring->count;
  1848. rx_desc = E1000_RX_DESC(*rx_ring, i);
  1849. continue;
  1850. }
  1852. if(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) {
  1854. last_byte = *(skb->data + length - 1);
  1856. if(TBI_ACCEPT(&adapter->hw, rx_desc->status,
  1857.               rx_desc->errors, length, last_byte)) {
  1859. spin_lock_irqsave(&adapter->stats_lock, flags);
  1861. e1000_tbi_adjust_stats(&adapter->hw,
  1862.                        &adapter->stats,
  1863.                        length, skb->data);
  1865. spin_unlock_irqrestore(&adapter->stats_lock,
  1866.                        flags);
  1867. length--;
  1868. } else {
  1870. dev_kfree_skb_irq(skb);
  1871. rx_desc->status = 0;
  1872. rx_ring->buffer_info[i].skb = NULL;
  1874. i = (i + 1) % rx_ring->count;
  1876. rx_desc = E1000_RX_DESC(*rx_ring, i);
  1877. continue;
  1878. }
  1879. }
  1881. /* Good Receive */
  1882. skb_put(skb, length - ETHERNET_FCS_SIZE);
  1884. /* Receive Checksum Offload */
  1885. e1000_rx_checksum(adapter, rx_desc, skb);
  1887. skb->protocol = eth_type_trans(skb, netdev);
  1888. if(adapter->vlgrp && (rx_desc->status & E1000_RXD_STAT_VP)) {
  1889. vlan_hwaccel_rx(skb, adapter->vlgrp,
  1890. (rx_desc->special & E1000_RXD_SPC_VLAN_MASK));
  1891. } else {
  1892. netif_rx(skb);
  1893. }
  1894. netdev->last_rx = jiffies;
  1896. rx_desc->status = 0;
  1897. rx_ring->buffer_info[i].skb = NULL;
  1899. i = (i + 1) % rx_ring->count;
  1901. rx_desc = E1000_RX_DESC(*rx_ring, i);
  1902. }
  1904. rx_ring->next_to_clean = i;
  1906. e1000_alloc_rx_buffers(adapter);
  1907. }
  1909. /**
  1910.  * e1000_alloc_rx_buffers - Replace used receive buffers
  1911.  * @data: address of board private structure
  1912.  **/
  1914. static void
  1915. e1000_alloc_rx_buffers(struct e1000_adapter *adapter)
  1916. {
  1917. struct e1000_desc_ring *rx_ring = &adapter->rx_ring;
  1918. struct net_device *netdev = adapter->netdev;
  1919. struct pci_dev *pdev = adapter->pdev;
  1920. struct e1000_rx_desc *rx_desc;
  1921. struct sk_buff *skb;
  1922. int reserve_len;
  1923. int i;
  1925. reserve_len = 2;
  1927. i = rx_ring->next_to_use;
  1929. while(!rx_ring->buffer_info[i].skb) {
  1930. rx_desc = E1000_RX_DESC(*rx_ring, i);
  1932. skb = dev_alloc_skb(adapter->rx_buffer_len + reserve_len);
  1934. if(!skb) {
  1935. /* Better luck next round */
  1936. break;
  1937. }
  1939. /* Make buffer alignment 2 beyond a 16 byte boundary
  1940.  * this will result in a 16 byte aligned IP header after
  1941.  * the 14 byte MAC header is removed
  1942.  */
  1943. skb_reserve(skb, reserve_len);
  1945. skb->dev = netdev;
  1947. rx_ring->buffer_info[i].skb = skb;
  1948. rx_ring->buffer_info[i].length = adapter->rx_buffer_len;
  1949. rx_ring->buffer_info[i].dma =
  1950. pci_map_single(pdev,
  1951.                skb->data,
  1952.                adapter->rx_buffer_len,
  1953.                PCI_DMA_FROMDEVICE);
  1955. rx_desc->buffer_addr = cpu_to_le64(rx_ring->buffer_info[i].dma);
  1957. if(!(i % E1000_RX_BUFFER_WRITE)) {
  1958. /* Force memory writes to complete before letting h/w
  1959.  * know there are new descriptors to fetch.  (Only
  1960.  * applicable for weak-ordered memory model archs,
  1961.  * such as IA-64). */
  1962. wmb();
  1964. E1000_WRITE_REG(&adapter->hw, RDT, i);
  1965. }
  1967. i = (i + 1) % rx_ring->count;
  1968. }
  1970. rx_ring->next_to_use = i;
  1971. }
  1973. /**
  1974.  * e1000_ioctl -
  1975.  * @netdev:
  1976.  * @ifreq:
  1977.  * @cmd:
  1978.  **/
  1980. static int
  1981. e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
  1982. {
  1983. switch (cmd) {
  1984. case SIOCETHTOOL:
  1985. return e1000_ethtool_ioctl(netdev, ifr);
  1986. default:
  1987. return -EOPNOTSUPP;
  1988. }
  1989. }
  1991. /**
  1992.  * e1000_rx_checksum - Receive Checksum Offload for 82543
  1993.  * @adapter: board private structure
  1994.  * @rx_desc: receive descriptor
  1995.  * @sk_buff: socket buffer with received data
  1996.  **/
  1998. static inline void
  1999. e1000_rx_checksum(struct e1000_adapter *adapter,
  2000.                   struct e1000_rx_desc *rx_desc,
  2001.                   struct sk_buff *skb)
  2002. {
  2003. /* 82543 or newer only */
  2004. if((adapter->hw.mac_type < e1000_82543) ||
  2005. /* Ignore Checksum bit is set */
  2006. (rx_desc->status & E1000_RXD_STAT_IXSM) ||
  2007. /* TCP Checksum has not been calculated */
  2008. (!(rx_desc->status & E1000_RXD_STAT_TCPCS))) {
  2009. skb->ip_summed = CHECKSUM_NONE;
  2010. return;
  2011. }
  2013. /* At this point we know the hardware did the TCP checksum */
  2014. /* now look at the TCP checksum error bit */
  2015. if(rx_desc->errors & E1000_RXD_ERR_TCPE) {
  2016. /* let the stack verify checksum errors */
  2017. skb->ip_summed = CHECKSUM_NONE;
  2018. adapter->hw_csum_err++;
  2019. } else {
  2020. /* TCP checksum is good */
  2021. skb->ip_summed = CHECKSUM_UNNECESSARY;
  2022. adapter->hw_csum_good++;
  2023. }
  2024. }
  2026. void
  2027. e1000_pci_set_mwi(struct e1000_hw *hw)
  2028. {
  2029. struct e1000_adapter *adapter = hw->back;
  2031. pci_set_mwi(adapter->pdev);
  2032. }
  2034. void
  2035. e1000_pci_clear_mwi(struct e1000_hw *hw)
  2036. {
  2037. struct e1000_adapter *adapter = hw->back;
  2039. pci_clear_mwi(adapter->pdev);
  2040. }
  2042. void
  2043. e1000_read_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
  2044. {
  2045. struct e1000_adapter *adapter = hw->back;
  2047. pci_read_config_word(adapter->pdev, reg, value);
  2048. }
  2050. void
  2051. e1000_write_pci_cfg(struct e1000_hw *hw, uint32_t reg, uint16_t *value)
  2052. {
  2053. struct e1000_adapter *adapter = hw->back;
  2055. pci_write_config_word(adapter->pdev, reg, *value);
  2056. }
  2058. uint32_t
  2059. e1000_io_read(struct e1000_hw *hw, uint32_t port)
  2060. {
  2061. return inl(port);
  2062. }
  2064. void
  2065. e1000_io_write(struct e1000_hw *hw, uint32_t port, uint32_t value)
  2066. {
  2067. outl(value, port);
  2068. }
  2070. static void
  2071. e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
  2072. {
  2073. struct e1000_adapter *adapter = netdev->priv;
  2074. uint32_t ctrl, rctl;
  2076. e1000_irq_disable(adapter);
  2077. adapter->vlgrp = grp;
  2079. if(grp) {
  2080. /* enable VLAN tag insert/strip */
  2082. E1000_WRITE_REG(&adapter->hw, VET, ETHERNET_IEEE_VLAN_TYPE);
  2084. ctrl = E1000_READ_REG(&adapter->hw, CTRL);
  2085. ctrl |= E1000_CTRL_VME;
  2086. E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
  2088. /* enable VLAN receive filtering */
  2090. rctl = E1000_READ_REG(&adapter->hw, RCTL);
  2091. rctl |= E1000_RCTL_VFE;
  2092. rctl &= ~E1000_RCTL_CFIEN;
  2093. E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
  2094. } else {
  2095. /* disable VLAN tag insert/strip */
  2097. ctrl = E1000_READ_REG(&adapter->hw, CTRL);
  2098. ctrl &= ~E1000_CTRL_VME;
  2099. E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
  2101. /* disable VLAN filtering */
  2103. rctl = E1000_READ_REG(&adapter->hw, RCTL);
  2104. rctl &= ~E1000_RCTL_VFE;
  2105. E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
  2106. }
  2108. e1000_irq_enable(adapter);
  2109. }
  2111. static void
  2112. e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid)
  2113. {
  2114. struct e1000_adapter *adapter = netdev->priv;
  2115. uint32_t vfta, index;
  2117. /* add VID to filter table */
  2119. index = (vid >> 5) & 0x7F;
  2120. vfta = E1000_READ_REG_ARRAY(&adapter->hw, VFTA, index);
  2121. vfta |= (1 << (vid & 0x1F));
  2122. e1000_write_vfta(&adapter->hw, index, vfta);
  2123. }
  2125. static void
  2126. e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid)
  2127. {
  2128. struct e1000_adapter *adapter = netdev->priv;
  2129. uint32_t vfta, index;
  2131. e1000_irq_disable(adapter);
  2133. if(adapter->vlgrp)
  2134. adapter->vlgrp->vlan_devices[vid] = NULL;
  2136. e1000_irq_enable(adapter);
  2138. /* remove VID from filter table*/
  2140. index = (vid >> 5) & 0x7F;
  2141. vfta = E1000_READ_REG_ARRAY(&adapter->hw, VFTA, index);
  2142. vfta &= ~(1 << (vid & 0x1F));
  2143. e1000_write_vfta(&adapter->hw, index, vfta);
  2144. }
  2146. static int
  2147. e1000_notify_reboot(struct notifier_block *nb, unsigned long event, void *p)
  2148. {
  2149. struct pci_dev *pdev = NULL;
  2151. switch(event) {
  2152. case SYS_DOWN:
  2153. case SYS_HALT:
  2154. case SYS_POWER_OFF:
  2155. pci_for_each_dev(pdev) {
  2156. if(pci_dev_driver(pdev) == &e1000_driver)
  2157. e1000_suspend(pdev, 3);
  2158. }
  2159. }
  2160. return NOTIFY_DONE;
  2161. }
  2163. static int
  2164. e1000_notify_netdev(struct notifier_block *nb, unsigned long event, void *p)
  2165. {
  2166. struct e1000_adapter *adapter;
  2167. struct net_device *netdev = p;
  2168. if(netdev == NULL)
  2169. return NOTIFY_DONE;
  2171. switch(event) {
  2172. case NETDEV_CHANGENAME:
  2173. if(netdev->open == e1000_open) {
  2174. adapter = netdev->priv;
  2175. /* rename the proc nodes the easy way */
  2176. e1000_proc_dev_free(adapter);
  2177. memcpy(adapter->ifname, netdev->name, IFNAMSIZ);
  2178. adapter->ifname[IFNAMSIZ-1] = 0;
  2179. e1000_proc_dev_setup(adapter);
  2180. }
  2181. break;
  2182. }
  2183. return NOTIFY_DONE;
  2184. }
  2186. static int
  2187. e1000_suspend(struct pci_dev *pdev, uint32_t state)
  2188. {
  2189. struct net_device *netdev = pci_get_drvdata(pdev);
  2190. struct e1000_adapter *adapter = netdev->priv;
  2191. uint32_t ctrl, ctrl_ext, rctl, manc;
  2193. netif_device_detach(netdev);
  2195. if(netif_running(netdev))
  2196. e1000_down(adapter);
  2198. if(adapter->wol) {
  2199. e1000_setup_rctl(adapter);
  2200. e1000_set_multi(netdev);
  2202. /* turn on all-multi mode if wake on multicast is enabled */
  2203. if(adapter->wol & E1000_WUFC_MC) {
  2204. rctl = E1000_READ_REG(&adapter->hw, RCTL);
  2205. rctl |= E1000_RCTL_MPE;
  2206. E1000_WRITE_REG(&adapter->hw, RCTL, rctl);
  2207. }
  2209. if(adapter->hw.mac_type >= e1000_82540) {
  2210. ctrl = E1000_READ_REG(&adapter->hw, CTRL);
  2211. /* advertise wake from D3Cold */
  2212. #define E1000_CTRL_ADVD3WUC 0x00100000
  2213. /* phy power management enable */
  2214. #define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000
  2215. ctrl |= E1000_CTRL_ADVD3WUC |
  2216. E1000_CTRL_EN_PHY_PWR_MGMT;
  2217. E1000_WRITE_REG(&adapter->hw, CTRL, ctrl);
  2218. }
  2220. if(adapter->hw.media_type == e1000_media_type_fiber) {
  2221. /* keep the laser running in D3 */
  2222. ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
  2223. ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA;
  2224. E1000_WRITE_REG(&adapter->hw, CTRL_EXT, ctrl_ext);
  2225. }
  2227. E1000_WRITE_REG(&adapter->hw, WUC, E1000_WUC_PME_EN);
  2228. E1000_WRITE_REG(&adapter->hw, WUFC, adapter->wol);
  2229. pci_enable_wake(pdev, 3, 1);
  2230. pci_enable_wake(pdev, 4, 1); /* 4 == D3 cold */
  2231. } else {
  2232. E1000_WRITE_REG(&adapter->hw, WUC, 0);
  2233. E1000_WRITE_REG(&adapter->hw, WUFC, 0);
  2234. pci_enable_wake(pdev, 3, 0);
  2235. pci_enable_wake(pdev, 4, 0); /* 4 == D3 cold */
  2236. }
  2238. pci_save_state(pdev, adapter->pci_state);
  2240. if(adapter->hw.mac_type >= e1000_82540) {
  2241. manc = E1000_READ_REG(&adapter->hw, MANC);
  2242. if(manc & E1000_MANC_SMBUS_EN) {
  2243. manc |= E1000_MANC_ARP_EN;
  2244. E1000_WRITE_REG(&adapter->hw, MANC, manc);
  2245. state = 0;
  2246. }
  2247. }
  2249. state = (state > 0) ? 3 : 0;
  2250. pci_set_power_state(pdev, state);
  2252. return 0;
  2253. }
  2255. #ifdef CONFIG_PM
  2256. static int
  2257. e1000_resume(struct pci_dev *pdev)
  2258. {
  2259. struct net_device *netdev = pci_get_drvdata(pdev);
  2260. struct e1000_adapter *adapter = netdev->priv;
  2261. uint32_t manc;
  2263. pci_set_power_state(pdev, 0);
  2264. pci_restore_state(pdev, adapter->pci_state);
  2266. pci_enable_wake(pdev, 3, 0);
  2267. pci_enable_wake(pdev, 4, 0); /* 4 == D3 cold */
  2269. e1000_reset(adapter);
  2270. E1000_WRITE_REG(&adapter->hw, WUS, ~0);
  2272. if(netif_running(netdev))
  2273. e1000_up(adapter);
  2275. netif_device_attach(netdev);
  2277. if(adapter->hw.mac_type >= e1000_82540) {
  2278. manc = E1000_READ_REG(&adapter->hw, MANC);
  2279. manc &= ~(E1000_MANC_ARP_EN);
  2280. E1000_WRITE_REG(&adapter->hw, MANC, manc);
  2281. }
  2283. return 0;
  2284. }
  2285. #endif
  2287. /* e1000_main.c */