PageRenderTime 68ms CodeModel.GetById 28ms RepoModel.GetById 0ms app.codeStats 0ms

/drivers/e1000-6.x/src/e1000_main.c

https://github.com/bhesmans/click
C | 5042 lines | 3632 code | 711 blank | 699 comment | 558 complexity | d9e8f1bb3eb4ca7692a3fe71ae6225ac MD5 | raw file
Possible License(s): GPL-2.0, BSD-3-Clause

Large files files are truncated, but you can click here to view the full file

    

  1. /*******************************************************************************
    2. 

    3. 

  3.   
    4. 

  4.   Copyright(c) 1999 - 2005 Intel Corporation. All rights reserved.
    5. 

  5.   
    6. 

  6.   This program is free software; you can redistribute it and/or modify it 
    7. 

  7.   under the terms of the GNU General Public License as published by the Free 
    8. 

  8.   Software Foundation; either version 2 of the License, or (at your option) 
    9. 

  9.   any later version.
    10. 

  10.   
    11. 

  11.   This program is distributed in the hope that it will be useful, but WITHOUT 
    12. 

  12.   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
    13. 

  13.   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
    14. 

  14.   more details.
    15. 

  15.   
    16. 

  16.   You should have received a copy of the GNU General Public License along with
    17. 

  17.   this program; if not, write to the Free Software Foundation, Inc., 59 
    18. 

  18.   Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    19. 

  19.   
    20. 

  20.   The full GNU General Public License is included in this distribution in the
    21. 

  21.   file called LICENSE.
    22. 

  22.   
    23. 

  23.   Contact Information:
    24. 

  24.   Linux NICS <linux.nics@intel.com>
    25. 

  25.   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
    26. 

    27. 

  27. *******************************************************************************/
    28. 

  28. 

  29. #include "e1000.h"
    30. 

  30. 

  31. /* Change Log
    32. 

  32.  * 6.0.58       4/20/05
    33. 

  33.  *   o e1000_set_spd_dplx tests for compatible speed/duplex specification
    34. 

  34.  *     for fiber adapters
    35. 

  35.  * 6.0.57	4/19/05
    36. 

  36.  *   o Added code to fix register test failure for devices >= 82571
    37. 

  37.  *
    38. 

  38.  * 6.0.52	3/15/05
    39. 

  39.  *   o Added stats_lock around e1000_read_phy_reg commands to avoid concurrent
    40. 

  40.  *     calls, one from mii_ioctl and other from within update_stats while 
    41. 

  41.  *     processing MIIREG ioctl.
    42. 

  42.  *
    43. 

  43.  * 6.1.2	4/13/05
    44. 

  44.  *   o Fixed ethtool diagnostics
    45. 

  45.  *   o Enabled flow control to take default eeprom settings
    46. 

  46.  *   o Added stats_lock around e1000_read_phy_reg commands to avoid concurrent 
    47. 

  47.  *     calls, one from mii_ioctl and other from within update_stats while processing
    48. 

  48.  *     MIIREG ioctl. 
    49. 

  49.  * 6.0.55       3/23/05
    50. 

  50.  *   o Support for MODULE_VERSION
    51. 

  51.  *   o Fix APM setting for 82544 based adapters
    52. 

  52.  * 6.0.54	3/26/05
    53. 

  53.  *   o Added a timer to expire packets that were deferred for cleanup
    54. 

  54.  * 6.0.52	3/15/05
    55. 

  55.  *   o Added stats_lock around e1000_read_phy_reg commands to avoid concurrent
    56. 

  56.  *     calls, one from mii_ioctl and other from within update_stats while 
    57. 

  57.  *     processing MIIREG ioctl.
    58. 

  58.  * 6.0.47	3/2/05
    59. 

  59.  *   o Added enhanced functionality to the loopback diags to wrap the 
    60. 

  60.  *     descriptor rings
    61. 

  61.  *   o Added manageability vlan filtering workaround.
    62. 

  62.  *
    63. 

  63.  * 6.0.44+	2/15/05
    64. 

  64.  *   o Added code to handle raw packet based DHCP packets 
    65. 

  65.  *   o Added code to fix the errata 10 buffer overflow issue
    66. 

  66.  *   o Sync up with WR01-05
    67. 

  67.  *     o applied Anton's patch to resolve tx hang in hardware
    68. 

  68.  *     o e1000 timeouts with early writeback patch
    69. 

  69.  *   o Removed Queensport IDs
    70. 

  70.  *   o fixed driver panic if MAC receives a bad large packets when packet 
    71. 

  71.  *     split is enabled 
    72. 

  72.  *   o Applied Andrew Mortons patch - e1000 stops working after resume
    73. 

  73.  * 5.2.29       12/24/03
    74. 

  74.  *   o Bug fix: Endianess issue causing ethtool diags to fail on ppc.
    75. 

  75.  *   o Bug fix: Use pdev->irq instead of netdev->irq for MSI support.
    76. 

  76.  *   o Report driver message on user override of InterruptThrottleRate module
    77. 

  77.  *     parameter.
    78. 

  78.  *   o Bug fix: Change I/O address storage from uint32_t to unsigned long.
    79. 

  79.  *   o Feature: Added ethtool RINGPARAM support.
    80. 

  80.  *   o Feature: Added netpoll support.
    81. 

  81.  *   o Bug fix: Race between Tx queue and Tx clean fixed with a spin lock.
    82. 

  82.  *   o Bug fix: Allow 1000/Full setting for autoneg param for fiber connections.
    83. 

  83.  *              Jon D Mason [jonmason@us.ibm.com].
    84. 

  84.  *
    85. 

  85.  * 5.2.22	10/15/03
    86. 

  86.  *   o Bug fix: SERDES devices might be connected to a back-plane switch that
    87. 

  87.  *     doesn't support auto-neg, so add the capability to force 1000/Full.
    88. 

  88.  *     Also, since forcing 1000/Full, sample RxSynchronize bit to detect link
    89. 

  89.  *     state.
    90. 

  90.  *   o Bug fix: Flow control settings for hi/lo watermark didn't consider
    91. 

  91.  *     changes in the RX FIFO size, which could occur with Jumbo Frames or with
    92. 

  92.  *     the reduced FIFO in 82547.
    93. 

  93.  *   o Bug fix: Better propagation of error codes.
    94. 

  94.  *     [Janice Girouard (janiceg -a-t- us.ibm.com)]
    95. 

  95.  *   o Bug fix: hang under heavy Tx stress when running out of Tx descriptors;
    96. 

  96.  *     wasn't clearing context descriptor when backing out of send because of
    97. 

  97.  *     no-resource condition.
    98. 

  98.  *   o Bug fix: check netif_running in dev->poll so we don't have to hang in
    99. 

  99.  *     dev->close until all polls are finished.  [Rober Olsson
    100. 

  100.  *     (robert.olsson@data.slu.se)].
    101. 

  101.  *   o Revert TxDescriptor ring size back to 256 since change to 1024 wasn't
    102. 

  102.  *     accepted into the kernel.
    103. 

  103.  *
    104. 

  104.  * 5.2.16	8/8/03
    105. 

  105.  */
    106. 

  106. 

  107. char e1000_driver_name[] = "e1000";
    108. 

  108. char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
    109. 

  109. #ifndef CONFIG_E1000_NAPI
    110. 

  110. #define DRIVERNAPI
    111. 

  111. #else
    112. 

  112. #define DRIVERNAPI "-NAPI"
    113. 

  113. #endif
    114. 

  114. #define DRV_VERSION "6.1.16.2.DB"DRIVERNAPI
    115. 

  115. char e1000_driver_version[] = DRV_VERSION;
    116. 

  116. char e1000_copyright[] = "Copyright (c) 1999-2005 Intel Corporation.";
    117. 

  117. 

  118. #if !HAVE___NETIF_RECEIVE_SKB
    119. 

  119. #define netif_receive_skb(skb)		netif_receive_skb((skb), (skb)->protocol, 0)
    120. 

  120. #endif
    121. 

  121. 

  122. /* e1000_pci_tbl - PCI Device ID Table
    123. 

  123.  *
    124. 

  124.  * Last entry must be all 0s
    125. 

  125.  *
    126. 

  126.  * Macro expands to...
    127. 

  127.  *   {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}
    128. 

  128.  */
    129. 

  129. static struct pci_device_id e1000_pci_tbl[] = {
    130. 

  130. 	INTEL_E1000_ETHERNET_DEVICE(0x1000),
    131. 

  131. 	INTEL_E1000_ETHERNET_DEVICE(0x1001),
    132. 

  132. 	INTEL_E1000_ETHERNET_DEVICE(0x1004),
    133. 

  133. 	INTEL_E1000_ETHERNET_DEVICE(0x1008),
    134. 

  134. 	INTEL_E1000_ETHERNET_DEVICE(0x1009),
    135. 

  135. 	INTEL_E1000_ETHERNET_DEVICE(0x100C),
    136. 

  136. 	INTEL_E1000_ETHERNET_DEVICE(0x100D),
    137. 

  137. 	INTEL_E1000_ETHERNET_DEVICE(0x100E),
    138. 

  138. 	INTEL_E1000_ETHERNET_DEVICE(0x100F),
    139. 

  139. 	INTEL_E1000_ETHERNET_DEVICE(0x1010),
    140. 

  140. 	INTEL_E1000_ETHERNET_DEVICE(0x1011),
    141. 

  141. 	INTEL_E1000_ETHERNET_DEVICE(0x1012),
    142. 

  142. 	INTEL_E1000_ETHERNET_DEVICE(0x1013),
    143. 

  143. 	INTEL_E1000_ETHERNET_DEVICE(0x1014),
    144. 

  144. 	INTEL_E1000_ETHERNET_DEVICE(0x1015),
    145. 

  145. 	INTEL_E1000_ETHERNET_DEVICE(0x1016),
    146. 

  146. 	INTEL_E1000_ETHERNET_DEVICE(0x1017),
    147. 

  147. 	INTEL_E1000_ETHERNET_DEVICE(0x1018),
    148. 

  148. 	INTEL_E1000_ETHERNET_DEVICE(0x1019),
    149. 

  149. 	INTEL_E1000_ETHERNET_DEVICE(0x101A),
    150. 

  150. 	INTEL_E1000_ETHERNET_DEVICE(0x101D),
    151. 

  151. 	INTEL_E1000_ETHERNET_DEVICE(0x101E),
    152. 

  152. 	INTEL_E1000_ETHERNET_DEVICE(0x1026),
    153. 

  153. 	INTEL_E1000_ETHERNET_DEVICE(0x1027),
    154. 

  154. 	INTEL_E1000_ETHERNET_DEVICE(0x1028),
    155. 

  155. 	INTEL_E1000_ETHERNET_DEVICE(0x105E),
    156. 

  156. 	INTEL_E1000_ETHERNET_DEVICE(0x105F),
    157. 

  157. 	INTEL_E1000_ETHERNET_DEVICE(0x1060),
    158. 

  158. 	INTEL_E1000_ETHERNET_DEVICE(0x1075),
    159. 

  159. 	INTEL_E1000_ETHERNET_DEVICE(0x1076),
    160. 

  160. 	INTEL_E1000_ETHERNET_DEVICE(0x1077),
    161. 

  161. 	INTEL_E1000_ETHERNET_DEVICE(0x1078),
    162. 

  162. 	INTEL_E1000_ETHERNET_DEVICE(0x1079),
    163. 

  163. 	INTEL_E1000_ETHERNET_DEVICE(0x107A),
    164. 

  164. 	INTEL_E1000_ETHERNET_DEVICE(0x107B),
    165. 

  165. 	INTEL_E1000_ETHERNET_DEVICE(0x107C),
    166. 

  166. 	INTEL_E1000_ETHERNET_DEVICE(0x107D),
    167. 

  167. 	INTEL_E1000_ETHERNET_DEVICE(0x107E),
    168. 

  168. 	INTEL_E1000_ETHERNET_DEVICE(0x107F),
    169. 

  169. 	INTEL_E1000_ETHERNET_DEVICE(0x108A),
    170. 

  170. 	INTEL_E1000_ETHERNET_DEVICE(0x108B),
    171. 

  171. 	INTEL_E1000_ETHERNET_DEVICE(0x108C),
    172. 

  172. 	INTEL_E1000_ETHERNET_DEVICE(0x109A),
    173. 

  173.  	INTEL_E1000_ETHERNET_DEVICE(0x10A0),
    174. 

  174.  	INTEL_E1000_ETHERNET_DEVICE(0x10A1),
    175. 

  175. 	/* required last entry */
    176. 

  176. 	{0,}
    177. 

  177. };
    178. 

  178. 

  179. MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);
    180. 

  180. 

  181. int e1000_up(struct e1000_adapter *adapter);
    182. 

  182. void e1000_down(struct e1000_adapter *adapter);
    183. 

  183. void e1000_reset(struct e1000_adapter *adapter);
    184. 

  184. int e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx);
    185. 

  185. int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
    186. 

  186. int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
    187. 

  187. void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
    188. 

  188. void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
    189. 

  189. int e1000_setup_tx_resources(struct e1000_adapter *adapter,
    190. 

  190.                              struct e1000_tx_ring *txdr);
    191. 

  191. int e1000_setup_rx_resources(struct e1000_adapter *adapter,
    192. 

  192.                              struct e1000_rx_ring *rxdr);
    193. 

  193. void e1000_free_tx_resources(struct e1000_adapter *adapter,
    194. 

  194.                              struct e1000_tx_ring *tx_ring);
    195. 

  195. void e1000_free_rx_resources(struct e1000_adapter *adapter,
    196. 

  196.                              struct e1000_rx_ring *rx_ring);
    197. 

  197. void e1000_update_stats(struct e1000_adapter *adapter);
    198. 

  198. 

  199. static int e1000_init_module(void);
    200. 

  200. static void e1000_exit_module(void);
    201. 

  201. static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
    202. 

  202. static void __devexit e1000_remove(struct pci_dev *pdev);
    203. 

  203. static int e1000_alloc_queues(struct e1000_adapter *adapter);
    204. 

  204. #ifdef CONFIG_E1000_MQ
    205. 

  205. static void e1000_setup_queue_mapping(struct e1000_adapter *adapter);
    206. 

  206. #endif
    207. 

  207. static int e1000_sw_init(struct e1000_adapter *adapter);
    208. 

  208. static int e1000_open(struct net_device *netdev);
    209. 

  209. static int e1000_close(struct net_device *netdev);
    210. 

  210. static void e1000_configure_tx(struct e1000_adapter *adapter);
    211. 

  211. static void e1000_configure_rx(struct e1000_adapter *adapter);
    212. 

  212. static void e1000_setup_rctl(struct e1000_adapter *adapter);
    213. 

  213. static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter);
    214. 

  214. static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter);
    215. 

  215. static void e1000_clean_tx_ring(struct e1000_adapter *adapter,
    216. 

  216.                                 struct e1000_tx_ring *tx_ring);
    217. 

  217. static void e1000_clean_rx_ring(struct e1000_adapter *adapter,
    218. 

  218.                                 struct e1000_rx_ring *rx_ring);
    219. 

  219. static void e1000_set_multi(struct net_device *netdev);
    220. 

  220. static void e1000_update_phy_info(unsigned long data);
    221. 

  221. static void e1000_watchdog(unsigned long data);
    222. 

  222. static void e1000_watchdog_1(struct e1000_adapter *adapter);
    223. 

  223. 

  224. static void e1000_82547_tx_fifo_stall(unsigned long data);
    225. 

  225. static int e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev);
    226. 

  226. static struct net_device_stats * e1000_get_stats(struct net_device *netdev);
    227. 

  227. static int e1000_change_mtu(struct net_device *netdev, int new_mtu);
    228. 

  228. static int e1000_set_mac(struct net_device *netdev, void *p);
    229. 

  229. static irqreturn_t e1000_intr(int irq, void *data, struct pt_regs *regs);
    230. 

  230. static boolean_t e1000_clean_tx_irq(struct e1000_adapter *adapter,
    231. 

  231.                                     struct e1000_tx_ring *tx_ring);
    232. 

  232. #ifdef CONFIG_E1000_NAPI
    233. 

  233. static int e1000_clean(struct net_device *poll_dev, int *budget);
    234. 

  234. static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,
    235. 

  235.                                     struct e1000_rx_ring *rx_ring,
    236. 

  236.                                     int *work_done, int work_to_do);
    237. 

  237. static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
    238. 

  238.                                        struct e1000_rx_ring *rx_ring,
    239. 

  239.                                        int *work_done, int work_to_do);
    240. 

  240. #else
    241. 

  241. static boolean_t e1000_clean_rx_irq(struct e1000_adapter *adapter,
    242. 

  242.                                     struct e1000_rx_ring *rx_ring);
    243. 

  243. static boolean_t e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
    244. 

  244.                                        struct e1000_rx_ring *rx_ring);
    245. 

  245. #endif
    246. 

  246. static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
    247. 

  247.                                    struct e1000_rx_ring *rx_ring);
    248. 

  248. static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
    249. 

  249.                                       struct e1000_rx_ring *rx_ring);
    250. 

  250. static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd);
    251. 

  251. #ifdef SIOCGMIIPHY
    252. 

  252. static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
    253. 

  253. 			   int cmd);
    254. 

  254. #endif
    255. 

  255. void set_ethtool_ops(struct net_device *netdev);
    256. 

  256. extern int ethtool_ioctl(struct ifreq *ifr);
    257. 

  257. extern int e1000_bypass_ctrl_ioctl(struct net_device *netdev, struct ifreq *ifr);
    258. 

  258. static void e1000_enter_82542_rst(struct e1000_adapter *adapter);
    259. 

  259. static void e1000_leave_82542_rst(struct e1000_adapter *adapter);
    260. 

  260. static void e1000_tx_timeout(struct net_device *dev);
    261. 

  261. static void e1000_tx_timeout_task(struct net_device *dev);
    262. 

  262. static void e1000_smartspeed(struct e1000_adapter *adapter);
    263. 

  263. static inline int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
    264. 

  264. 					      struct sk_buff *skb);
    265. 

  265. 

  266. #ifdef NETIF_F_HW_VLAN_TX
    267. 

  267. static void e1000_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp);
    268. 

  268. static void e1000_vlan_rx_add_vid(struct net_device *netdev, uint16_t vid);
    269. 

  269. static void e1000_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid);
    270. 

  270. static void e1000_restore_vlan(struct e1000_adapter *adapter);
    271. 

  271. #endif
    272. 

  272. 

  273. static int e1000_notify_reboot(struct notifier_block *, unsigned long event, void *ptr);
    274. 

  274. static int e1000_suspend(struct pci_dev *pdev, uint32_t state);
    275. 

  275. #ifdef CONFIG_PM
    276. 

  276. static int e1000_resume(struct pci_dev *pdev);
    277. 

  277. #endif
    278. 

  278. 

  279. /* For Click polling */
    280. 

  280. static int e1000_tx_pqueue(struct net_device *dev, struct sk_buff *skb);
    281. 

  281. static int e1000_tx_start(struct net_device *dev);
    282. 

  282. static int e1000_rx_refill(struct net_device *dev, struct sk_buff **);
    283. 

  283. static int e1000_tx_eob(struct net_device *dev);
    284. 

  284. static struct sk_buff *e1000_tx_clean(struct net_device *dev);
    285. 

  285. static struct sk_buff *e1000_rx_poll(struct net_device *dev, int *want);
    286. 

  286. static int e1000_poll_on(struct net_device *dev);
    287. 

  287. static int e1000_poll_off(struct net_device *dev);
    288. 

  288. 

  289. #ifdef CONFIG_NET_POLL_CONTROLLER
    290. 

  290. /* for netdump / net console */
    291. 

  291. static void e1000_netpoll (struct net_device *netdev);
    292. 

  292. #endif
    293. 

  293. 

  294. #ifdef CONFIG_E1000_MQ
    295. 

  295. /* for multiple Rx queues */
    296. 

  296. void e1000_rx_schedule(void *data);
    297. 

  297. #endif
    298. 

  298. 

  299. struct notifier_block e1000_notifier_reboot = {
    300. 

  300. 	.notifier_call	= e1000_notify_reboot,
    301. 

  301. 	.next		= NULL,
    302. 

  302. 	.priority	= 0
    303. 

  303. };
    304. 

  304. 

  305. #undef DEBUG_PRINT
    306. 

  306. #ifdef DEBUG_PRINT
    307. 

  307. static void e1000_print_rx_buffer_info(struct e1000_buffer *bi);
    308. 

  308. static void e1000_print_rx_desc(struct e1000_rx_desc *rx_desc);
    309. 

  309. static void e1000_print_skb(struct sk_buff* skb);
    310. 

  310. #endif
    311. 

  311. 

  312. /* Exported from other modules */
    313. 

  313. 

  314. extern void e1000_check_options(struct e1000_adapter *adapter);
    315. 

  315. 

  316. static struct pci_driver e1000_driver = {
    317. 

  317. 	.name     = e1000_driver_name,
    318. 

  318. 	.id_table = e1000_pci_tbl,
    319. 

  319. 	.probe    = e1000_probe,
    320. 

  320. 	.remove   = __devexit_p(e1000_remove),
    321. 

  321. 	/* Power Managment Hooks */
    322. 

  322. #ifdef CONFIG_PM
    323. 

  323. 	.suspend  = e1000_suspend,
    324. 

  324. 	.resume   = e1000_resume
    325. 

  325. #endif
    326. 

  326. };
    327. 

  327. 

  328. MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
    329. 

  329. MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver");
    330. 

  330. MODULE_LICENSE("GPL");
    331. 

  331. MODULE_VERSION(DRV_VERSION);
    332. 

  332. 

  333. static int debug = NETIF_MSG_DRV | NETIF_MSG_PROBE;
    334. 

  334. module_param(debug, int, 0);
    335. 

  335. MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
    336. 

  336. 

  337. /**
    338. 

  338.  * e1000_init_module - Driver Registration Routine
    339. 

  339.  *
    340. 

  340.  * e1000_init_module is the first routine called when the driver is
    341. 

  341.  * loaded. All it does is register with the PCI subsystem.
    342. 

  342.  **/
    343. 

  343. 

  344. static int __init
    345. 

  345. e1000_init_module(void)
    346. 

  346. {
    347. 

  347. 	int ret;
    348. 

  348. 	printk(KERN_INFO "%s - version %s\n",
    349. 

  349. 	       e1000_driver_string, e1000_driver_version);
    350. 

  350. 

  351.         printk(KERN_INFO " w/ Click polling\n");
    352. 

  352. 	printk(KERN_INFO "%s\n", e1000_copyright);
    353. 

  353. 

  354. 	ret = pci_module_init(&e1000_driver);
    355. 

  355. 	if(ret >= 0) {
    356. 

  356. 		register_reboot_notifier(&e1000_notifier_reboot);
    357. 

  357. 	}
    358. 

  358. 	return ret;
    359. 

  359. }
    360. 

  360. 

  361. module_init(e1000_init_module);
    362. 

  362. 

  363. /**
    364. 

  364.  * e1000_exit_module - Driver Exit Cleanup Routine
    365. 

  365.  *
    366. 

  366.  * e1000_exit_module is called just before the driver is removed
    367. 

  367.  * from memory.
    368. 

  368.  **/
    369. 

  369. 

  370. static void __exit
    371. 

  371. e1000_exit_module(void)
    372. 

  372. {
    373. 

  373. 	unregister_reboot_notifier(&e1000_notifier_reboot);
    374. 

  374. 	pci_unregister_driver(&e1000_driver);
    375. 

  375. }
    376. 

  376. 

  377. module_exit(e1000_exit_module);
    378. 

  378. 

  379. /**
    380. 

  380.  * e1000_irq_disable - Mask off interrupt generation on the NIC
    381. 

  381.  * @adapter: board private structure
    382. 

  382.  **/
    383. 

  383. 

  384. static inline void
    385. 

  385. e1000_irq_disable(struct e1000_adapter *adapter)
    386. 

  386. {
    387. 

  387. 	atomic_inc(&adapter->irq_sem);
    388. 

  388. 	E1000_WRITE_REG(&adapter->hw, IMC, ~0);
    389. 

  389. 	E1000_WRITE_FLUSH(&adapter->hw);
    390. 

  390. 	synchronize_irq(adapter->pdev->irq);
    391. 

  391. }
    392. 

  392. 

  393. /**
    394. 

  394.  * e1000_irq_enable - Enable default interrupt generation settings
    395. 

  395.  * @adapter: board private structure
    396. 

  396.  **/
    397. 

  397. 

  398. static inline void
    399. 

  399. e1000_irq_enable(struct e1000_adapter *adapter)
    400. 

  400. {
    401. 

  401. 	if(likely(atomic_dec_and_test(&adapter->irq_sem))) {
    402. 

  402. 		E1000_WRITE_REG(&adapter->hw, IMS, IMS_ENABLE_MASK);
    403. 

  403. 		E1000_WRITE_FLUSH(&adapter->hw);
    404. 

  404. 	}
    405. 

  405. }
    406. 

  406. #ifdef NETIF_F_HW_VLAN_TX
    407. 

  407. void
    408. 

  408. e1000_update_mng_vlan(struct e1000_adapter *adapter)
    409. 

  409. {
    410. 

  410. 	struct net_device *netdev = adapter->netdev;
    411. 

  411. 	uint16_t vid = adapter->hw.mng_cookie.vlan_id;
    412. 

  412. 	uint16_t old_vid = adapter->mng_vlan_id;
    413. 

  413. 	if(adapter->vlgrp) {
    414. 

  414. 		if(!adapter->vlgrp->vlan_devices[vid]) {
    415. 

  415. 			if(adapter->hw.mng_cookie.status &
    416. 

  416. 				E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) {
    417. 

  417. 				e1000_vlan_rx_add_vid(netdev, vid);
    418. 

  418. 				adapter->mng_vlan_id = vid;
    419. 

  419. 			} else
    420. 

  420. 				adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
    421. 

  421. 				
    422. 

  422. 			if((old_vid != (uint16_t)E1000_MNG_VLAN_NONE) &&
    423. 

  423. 					(vid != old_vid) && 
    424. 

  424. 					!adapter->vlgrp->vlan_devices[old_vid])
    425. 

  425. 				e1000_vlan_rx_kill_vid(netdev, old_vid);
    426. 

  426. 		}
    427. 

  427. 	}
    428. 

  428. }
    429. 

  429. #endif
    430. 

  430. 	
    431. 

  431. int
    432. 

  432. e1000_up(struct e1000_adapter *adapter)
    433. 

  433. {
    434. 

  434. 	struct net_device *netdev = adapter->netdev;
    435. 

  435. 	int i, err;
    436. 

  436. 

  437. 	/* hardware has been reset, we need to reload some things */
    438. 

  438. 

  439. 	/* Reset the PHY if it was previously powered down */
    440. 

  440. 	if(adapter->hw.media_type == e1000_media_type_copper) {
    441. 

  441. 		uint16_t mii_reg;
    442. 

  442. 		e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &mii_reg);
    443. 

  443. 		if(mii_reg & MII_CR_POWER_DOWN)
    444. 

  444. 			e1000_phy_reset(&adapter->hw);
    445. 

  445. 	}
    446. 

  446. 

  447. 	e1000_set_multi(netdev);
    448. 

  448. 

  449. #ifdef NETIF_F_HW_VLAN_TX
    450. 

  450. 	e1000_restore_vlan(adapter);
    451. 

  451. #endif
    452. 

  452. 

  453. 	e1000_configure_tx(adapter);
    454. 

  454. 	e1000_setup_rctl(adapter);
    455. 

  455. 	e1000_configure_rx(adapter);
    456. 

  456. 	for (i = 0; i < adapter->num_queues; i++)
    457. 

  457. 		adapter->alloc_rx_buf(adapter, &adapter->rx_ring[i]);
    458. 

  458. 

  459. #ifdef CONFIG_PCI_MSI
    460. 

  460. 	if(adapter->hw.mac_type > e1000_82547_rev_2) {
    461. 

  461. 		adapter->have_msi = TRUE;
    462. 

  462. 		if((err = pci_enable_msi(adapter->pdev))) {
    463. 

  463. 			DPRINTK(PROBE, ERR,
    464. 

  464. 			 "Unable to allocate MSI interrupt Error: %d\n", err);
    465. 

  465. 			adapter->have_msi = FALSE;
    466. 

  466. 		}
    467. 

  467. 	}
    468. 

  468. #endif
    469. 

  469. 	if((err = request_irq(adapter->pdev->irq, &e1000_intr,
    470. 

  470. 		              SA_SHIRQ | SA_SAMPLE_RANDOM,
    471. 

  471. 		              netdev->name, netdev))) {
    472. 

  472. 		DPRINTK(PROBE, ERR,
    473. 

  473. 		    "Unable to allocate interrupt Error: %d\n", err);
    474. 

  474. 		return err;
    475. 

  475. 	}
    476. 

  476. 

  477. 	mod_timer(&adapter->watchdog_timer, jiffies);
    478. 

  478. 

  479. #ifdef CONFIG_E1000_NAPI
    480. 

  480. 	netif_poll_enable(netdev);
    481. 

  481. #endif
    482. 

  482. 	e1000_irq_enable(adapter);
    483. 

  483. 

  484. 	return 0;
    485. 

  485. }
    486. 

  486. 

  487. void
    488. 

  488. e1000_down(struct e1000_adapter *adapter)
    489. 

  489. {
    490. 

  490. 	struct net_device *netdev = adapter->netdev;
    491. 

  491. 

  492. 	e1000_irq_disable(adapter);
    493. 

  493. #ifdef CONFIG_E1000_MQ
    494. 

  494. 	while (atomic_read(&adapter->rx_sched_call_data.count) != 0);
    495. 

  495. #endif
    496. 

  496. 	free_irq(adapter->pdev->irq, netdev);
    497. 

  497. #ifdef CONFIG_PCI_MSI
    498. 

  498. 	if(adapter->hw.mac_type > e1000_82547_rev_2 &&
    499. 

  499. 	   adapter->have_msi == TRUE)
    500. 

  500. 		pci_disable_msi(adapter->pdev);
    501. 

  501. #endif
    502. 

  502. 	del_timer_sync(&adapter->tx_fifo_stall_timer);
    503. 

  503. 	del_timer_sync(&adapter->watchdog_timer);
    504. 

  504. 	del_timer_sync(&adapter->phy_info_timer);
    505. 

  505. 

  506. #ifdef CONFIG_E1000_NAPI
    507. 

  507. 	netif_poll_disable(netdev);
    508. 

  508. #endif
    509. 

  509. 	adapter->link_speed = 0;
    510. 

  510. 	adapter->link_duplex = 0;
    511. 

  511. 	netif_carrier_off(netdev);
    512. 

  512. 	netif_stop_queue(netdev);
    513. 

  513. 

  514. 	e1000_reset(adapter);
    515. 

  515. 	e1000_clean_all_tx_rings(adapter);
    516. 

  516. 	e1000_clean_all_rx_rings(adapter);
    517. 

  517. 

  518. 	/* If WoL is not enabled and management mode is not IAMT
    519. 

  519. 	 * Power down the PHY so no link is implied when interface is down */
    520. 

  520. 	if(!adapter->wol && adapter->hw.mac_type >= e1000_82540 &&
    521. 

  521. 	   adapter->hw.media_type == e1000_media_type_copper &&
    522. 

  522. 	   !e1000_check_mng_mode(&adapter->hw) &&
    523. 

  523. 	   !(E1000_READ_REG(&adapter->hw, MANC) & E1000_MANC_SMBUS_EN)) {
    524. 

  524. 		uint16_t mii_reg;
    525. 

  525. 		e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &mii_reg);
    526. 

  526. 		mii_reg |= MII_CR_POWER_DOWN;
    527. 

  527. 		e1000_write_phy_reg(&adapter->hw, PHY_CTRL, mii_reg);
    528. 

  528. 		mdelay(1);
    529. 

  529. 	}
    530. 

  530. }
    531. 

  531. 

  532. void
    533. 

  533. e1000_reset(struct e1000_adapter *adapter)
    534. 

  534. {
    535. 

  535. 	struct net_device *netdev = adapter->netdev;
    536. 

  536. 	uint32_t pba, manc;
    537. 

  537. 	uint16_t fc_high_water_mark = E1000_FC_HIGH_DIFF;
    538. 

  538. 	uint16_t fc_low_water_mark = E1000_FC_LOW_DIFF;
    539. 

  539. 

  540. 	/* Repartition Pba for greater than 9k mtu
    541. 

  541. 	 * To take effect CTRL.RST is required.
    542. 

  542. 	 */
    543. 

  543. 

  544. 	switch (adapter->hw.mac_type) {
    545. 

  545. 	case e1000_82547:
    546. 

  546. 	case e1000_82547_rev_2:
    547. 

  547. 		pba = E1000_PBA_30K;
    548. 

  548. 		break;
    549. 

  549. 	case e1000_82571:
    550. 

  550. 	case e1000_82572:
    551. 

  551. 		pba = E1000_PBA_38K;
    552. 

  552. 		break;
    553. 

  553. 	case e1000_82573:
    554. 

  554. 		pba = E1000_PBA_12K;
    555. 

  555. 		break;
    556. 

  556. 	default:
    557. 

  557. 		pba = E1000_PBA_48K;
    558. 

  558. 		break;
    559. 

  559. 	}
    560. 

  560. 

  561. 	if((adapter->hw.mac_type != e1000_82573) &&
    562. 

  562. 	   (adapter->rx_buffer_len > E1000_RXBUFFER_8192)) {
    563. 

  563. 		pba -= 8; /* allocate more FIFO for Tx */
    564. 

  564. 		/* send an XOFF when there is enough space in the
    565. 

  565. 		 * Rx FIFO to hold one extra full size Rx packet 
    566. 

  566. 		*/
    567. 

  567. 		fc_high_water_mark = netdev->mtu + ENET_HEADER_SIZE + 
    568. 

  568. 					ETHERNET_FCS_SIZE + 1;
    569. 

  569. 		fc_low_water_mark = fc_high_water_mark + 8;
    570. 

  570. 	}
    571. 

  571. 

  572. 

  573. 	if(adapter->hw.mac_type == e1000_82547) {
    574. 

  574. 		adapter->tx_fifo_head = 0;
    575. 

  575. 		adapter->tx_head_addr = pba << E1000_TX_HEAD_ADDR_SHIFT;
    576. 

  576. 		adapter->tx_fifo_size =
    577. 

  577. 			(E1000_PBA_40K - pba) << E1000_PBA_BYTES_SHIFT;
    578. 

  578. 		atomic_set(&adapter->tx_fifo_stall, 0);
    579. 

  579. 	}
    580. 

  580. 

  581. 	E1000_WRITE_REG(&adapter->hw, PBA, pba);
    582. 

  582. 

  583. 	/* flow control settings */
    584. 

  584. 	adapter->hw.fc_high_water = (pba << E1000_PBA_BYTES_SHIFT) -
    585. 

  585. 				    fc_high_water_mark;
    586. 

  586. 	adapter->hw.fc_low_water = (pba << E1000_PBA_BYTES_SHIFT) -
    587. 

  587. 				   fc_low_water_mark;
    588. 

  588. 	adapter->hw.fc_pause_time = E1000_FC_PAUSE_TIME;
    589. 

  589. 	adapter->hw.fc_send_xon = 1;
    590. 

  590. 	adapter->hw.fc = adapter->hw.original_fc;
    591. 

  591. 

  592. 	/* Allow time for pending master requests to run */
    593. 

  593. 	e1000_reset_hw(&adapter->hw);
    594. 

  594. 	if(adapter->hw.mac_type >= e1000_82544)
    595. 

  595. 		E1000_WRITE_REG(&adapter->hw, WUC, 0);
    596. 

  596. 	if(e1000_init_hw(&adapter->hw))
    597. 

  597. 		DPRINTK(PROBE, ERR, "Hardware Error\n");
    598. 

  598. #ifdef NETIF_F_HW_VLAN_TX
    599. 

  599. 	e1000_update_mng_vlan(adapter);
    600. 

  600. #endif
    601. 

  601. 	/* Enable h/w to recognize an 802.1Q VLAN Ethernet packet */
    602. 

  602. 	E1000_WRITE_REG(&adapter->hw, VET, ETHERNET_IEEE_VLAN_TYPE);
    603. 

  603. 

  604. 	e1000_reset_adaptive(&adapter->hw);
    605. 

  605. 	e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
    606. 

  606. 	if(adapter->en_mng_pt) {
    607. 

  607. 		manc = E1000_READ_REG(&adapter->hw, MANC);
    608. 

  608. 		manc |= (E1000_MANC_ARP_EN | E1000_MANC_EN_MNG2HOST);
    609. 

  609. 		E1000_WRITE_REG(&adapter->hw, MANC, manc);
    610. 

  610. 	}
    611. 

  611. }
    612. 

  612. 

  613. /**
    614. 

  614.  * e1000_probe - Device Initialization Routine
    615. 

  615.  * @pdev: PCI device information struct
    616. 

  616.  * @ent: entry in e1000_pci_tbl
    617. 

  617.  *
    618. 

  618.  * Returns 0 on success, negative on failure
    619. 

  619.  *
    620. 

  620.  * e1000_probe initializes an adapter identified by a pci_dev structure.
    621. 

  621.  * The OS initialization, configuring of the adapter private structure,
    622. 

  622.  * and a hardware reset occur.
    623. 

  623.  **/
    624. 

  624. 

  625. #define SHOW_INTERFACE(d) printk("Interface mac_type=%d\n", d->hw.mac_type)
    626. 

  626. 

  627. static int __devinit
    628. 

  628. e1000_probe(struct pci_dev *pdev,
    629. 

  629.             const struct pci_device_id *ent)
    630. 

  630. {
    631. 

  631. 	struct net_device *netdev;
    632. 

  632. 	struct e1000_adapter *adapter;
    633. 

  633. 	unsigned long mmio_start, mmio_len;
    634. 

  634. 	uint32_t ctrl_ext;
    635. 

  635. 	uint32_t swsm;
    636. 

  636. 

  637. 	static int cards_found = 0;
    638. 

  638. 	int i, err, pci_using_dac;
    639. 

  639. 	uint16_t eeprom_data;
    640. 

  640. 	uint16_t eeprom_apme_mask = E1000_EEPROM_APME;
    641. 

  641. 	if((err = pci_enable_device(pdev)))
    642. 

  642. 		return err;
    643. 

  643. 

  644. 	if(!(err = pci_set_dma_mask(pdev, PCI_DMA_64BIT))) {
    645. 

  645. 		pci_using_dac = 1;
    646. 

  646. 	} else {
    647. 

  647. 		if((err = pci_set_dma_mask(pdev, PCI_DMA_32BIT))) {
    648. 

  648. 			E1000_ERR("No usable DMA configuration, aborting\n");
    649. 

  649. 			return err;
    650. 

  650. 		}
    651. 

  651. 		pci_using_dac = 0;
    652. 

  652. 	}
    653. 

  653. 

  654. 	if((err = pci_request_regions(pdev, e1000_driver_name)))
    655. 

  655. 		return err;
    656. 

  656. 

  657. 	pci_set_master(pdev);
    658. 

  658. 

  659. 	netdev = alloc_etherdev(sizeof(struct e1000_adapter));
    660. 

  660. 	if(!netdev) {
    661. 

  661. 		err = -ENOMEM;
    662. 

  662. 		goto err_alloc_etherdev;
    663. 

  663. 	}
    664. 

  664. 

  665. 	SET_MODULE_OWNER(netdev);
    666. 

  666. 	SET_NETDEV_DEV(netdev, &pdev->dev);
    667. 

  667. 

  668. 	pci_set_drvdata(pdev, netdev);
    669. 

  669. 	adapter = netdev_priv(netdev);
    670. 

  670. 	adapter->netdev = netdev;
    671. 

  671. 	adapter->pdev = pdev;
    672. 

  672. 	adapter->hw.back = adapter;
    673. 

  673. 	adapter->msg_enable = (1 << debug) - 1;
    674. 

  674. 

  675. 	mmio_start = pci_resource_start(pdev, BAR_0);
    676. 

  676. 	mmio_len = pci_resource_len(pdev, BAR_0);
    677. 

  677. 

  678. 	SHOW_INTERFACE(adapter);
    679. 

  679. 	adapter->hw.hw_addr = ioremap(mmio_start, mmio_len);
    680. 

  680. 	if(!adapter->hw.hw_addr) {
    681. 

  681. 		err = -EIO;
    682. 

  682. 		goto err_ioremap;
    683. 

  683. 	}
    684. 

  684. 

  685. 	for(i = BAR_1; i <= BAR_5; i++) {
    686. 

  686. 		if(pci_resource_len(pdev, i) == 0)
    687. 

  687. 			continue;
    688. 

  688. 		if(pci_resource_flags(pdev, i) & IORESOURCE_IO) {
    689. 

  689. 			adapter->hw.io_base = pci_resource_start(pdev, i);
    690. 

  690. 			break;
    691. 

  691. 		}
    692. 

  692. 	}
    693. 

  693. 

  694. 	netdev->open = &e1000_open;
    695. 

  695. 	netdev->stop = &e1000_close;
    696. 

  696. 	netdev->hard_start_xmit = &e1000_xmit_frame;
    697. 

  697. 	netdev->get_stats = &e1000_get_stats;
    698. 

  698. 	netdev->set_multicast_list = &e1000_set_multi;
    699. 

  699. 	netdev->set_mac_address = &e1000_set_mac;
    700. 

  700. 	netdev->change_mtu = &e1000_change_mtu;
    701. 

  701. 	netdev->do_ioctl = &e1000_ioctl;
    702. 

  702. 	set_ethtool_ops(netdev);
    703. 

  703. #ifdef HAVE_TX_TIMEOUT
    704. 

  704. 	netdev->tx_timeout = &e1000_tx_timeout;
    705. 

  705. 	netdev->watchdog_timeo = 5 * HZ;
    706. 

  706. #endif
    707. 

  707. #ifdef CONFIG_E1000_NAPI
    708. 

  708. 	netdev->poll = &e1000_clean;
    709. 

  709. 	netdev->weight = 64;
    710. 

  710. #endif
    711. 

  711. #ifdef NETIF_F_HW_VLAN_TX
    712. 

  712. 	netdev->vlan_rx_register = e1000_vlan_rx_register;
    713. 

  713. 	netdev->vlan_rx_add_vid = e1000_vlan_rx_add_vid;
    714. 

  714. 	netdev->vlan_rx_kill_vid = e1000_vlan_rx_kill_vid;
    715. 

  715. #endif
    716. 

  716. 

  717.         /* Click - polling extensions */
    718. 

  718.         netdev->polling = 0;
    719. 

  719.         netdev->rx_poll = e1000_rx_poll;
    720. 

  720.         netdev->rx_refill = e1000_rx_refill;
    721. 

  721.         netdev->tx_queue = e1000_tx_pqueue;
    722. 

  722.         netdev->tx_eob = e1000_tx_eob;
    723. 

  723.         netdev->tx_start = e1000_tx_start;
    724. 

  724.         netdev->tx_clean = e1000_tx_clean;
    725. 

  725.         netdev->poll_off = e1000_poll_off;
    726. 

  726.         netdev->poll_on = e1000_poll_on;
    727. 

  727. 

  728. #ifdef CONFIG_NET_POLL_CONTROLLER
    729. 

  729. 	netdev->poll_controller = e1000_netpoll;
    730. 

  730. #endif
    731. 

  731. 	strcpy(netdev->name, pci_name(pdev));
    732. 

  732. 

  733. 	netdev->mem_start = mmio_start;
    734. 

  734. 	netdev->mem_end = mmio_start + mmio_len;
    735. 

  735. 	netdev->base_addr = adapter->hw.io_base;
    736. 

  736. 

  737. 	adapter->bd_number = cards_found;
    738. 

  738. 

  739. 	/* setup the private structure */
    740. 

  740. 

  741. 	if((err = e1000_sw_init(adapter)))
    742. 

  742. 		goto err_sw_init;
    743. 

  743. 

  744. 	if((err = e1000_check_phy_reset_block(&adapter->hw)))
    745. 

  745. 		DPRINTK(PROBE, INFO, "PHY reset is blocked due to SOL/IDER session.\n");
    746. 

  746. 

  747. #ifdef MAX_SKB_FRAGS
    748. 

  748. 	if(adapter->hw.mac_type >= e1000_82543) {
    749. 

  749. #ifdef NETIF_F_HW_VLAN_TX
    750. 

  750. 		netdev->features = NETIF_F_SG |
    751. 

  751. 				   NETIF_F_HW_CSUM |
    752. 

  752. 				   NETIF_F_HW_VLAN_TX |
    753. 

  753. 				   NETIF_F_HW_VLAN_RX |
    754. 

  754. 				   NETIF_F_HW_VLAN_FILTER;
    755. 

  755. #else
    756. 

  756. 		netdev->features = NETIF_F_SG | NETIF_F_HW_CSUM;
    757. 

  757. #endif
    758. 

  758. 	}
    759. 

  759. 

  760. #ifdef NETIF_F_TSO
    761. 

  761. 	if((adapter->hw.mac_type >= e1000_82544) &&
    762. 

  762. 	   (adapter->hw.mac_type != e1000_82547))
    763. 

  763. 		netdev->features |= NETIF_F_TSO;
    764. 

  764. 

  765. #ifdef NETIF_F_TSO_IPV6
    766. 

  766. 	if(adapter->hw.mac_type > e1000_82547_rev_2)
    767. 

  767. 		netdev->features |= NETIF_F_TSO_IPV6;
    768. 

  768. #endif
    769. 

  769. #endif
    770. 

  770. 	if(pci_using_dac)
    771. 

  771. 		netdev->features |= NETIF_F_HIGHDMA;
    772. 

  772. 

  773. #endif
    774. 

  774. #ifdef NETIF_F_LLTX
    775. 

  775. 	netdev->features |= NETIF_F_LLTX;
    776. 

  776. #endif
    777. 

  777. 

  778. 	adapter->en_mng_pt = e1000_enable_mng_pass_thru(&adapter->hw);
    779. 

  779. 

  780. 	/* before reading the EEPROM, reset the controller to 
    781. 

  781. 	 * put the device in a known good starting state */
    782. 

  782. 	
    783. 

  783. 	e1000_reset_hw(&adapter->hw);
    784. 

  784. 

  785. 	/* make sure the EEPROM is good */
    786. 

  786. 

  787. 	if(e1000_validate_eeprom_checksum(&adapter->hw) < 0) {
    788. 

  788. 		DPRINTK(PROBE, ERR, "The EEPROM Checksum Is Not Valid\n");
    789. 

  789. 		err = -EIO;
    790. 

  790. 		goto err_eeprom;
    791. 

  791. 	}
    792. 

  792. 

  793. 	/* copy the MAC address out of the EEPROM */
    794. 

  794. 

  795. 	if(e1000_read_mac_addr(&adapter->hw))
    796. 

  796. 		DPRINTK(PROBE, ERR, "EEPROM Read Error\n");
    797. 

  797. 	memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
    798. 

  798. 

  799. 	SHOW_INTERFACE(adapter);
    800. 

  800. 	if(!is_valid_ether_addr(netdev->dev_addr)) {
    801. 

  801. 		DPRINTK(PROBE, ERR, "Invalid MAC Address\n");
    802. 

  802. 		err = -EIO;
    803. 

  803. 		goto err_eeprom;
    804. 

  804. 	}
    805. 

  805. 

  806. 	e1000_read_part_num(&adapter->hw, &(adapter->part_num));
    807. 

  807. 

  808. 	e1000_get_bus_info(&adapter->hw);
    809. 

  809. 

  810. 	init_timer(&adapter->tx_fifo_stall_timer);
    811. 

  811. 	adapter->tx_fifo_stall_timer.function = &e1000_82547_tx_fifo_stall;
    812. 

  812. 	adapter->tx_fifo_stall_timer.data = (unsigned long) adapter;
    813. 

  813. 

  814. 	init_timer(&adapter->watchdog_timer);
    815. 

  815. 	adapter->watchdog_timer.function = &e1000_watchdog;
    816. 

  816. 	adapter->watchdog_timer.data = (unsigned long) adapter;
    817. 

  817. 

  818. 	init_timer(&adapter->phy_info_timer);
    819. 

  819. 	adapter->phy_info_timer.function = &e1000_update_phy_info;
    820. 

  820. 	adapter->phy_info_timer.data = (unsigned long) adapter;
    821. 

  821. 

  822. 	INIT_WORK(&adapter->tx_timeout_task,
    823. 

  823. 		(void (*)(void *))e1000_tx_timeout_task, netdev);
    824. 

  824. 

  825. 	/* we're going to reset, so assume we have no link for now */
    826. 

  826. 

  827. 	netif_carrier_off(netdev);
    828. 

  828. 	netif_stop_queue(netdev);
    829. 

  829. 

  830. 	e1000_check_options(adapter);
    831. 

  831. 

  832. 	/* Initial Wake on LAN setting
    833. 

  833. 	 * If APM wake is enabled in the EEPROM,
    834. 

  834. 	 * enable the ACPI Magic Packet filter
    835. 

  835. 	 */
    836. 

  836. 

  837. 	switch(adapter->hw.mac_type) {
    838. 

  838. 	case e1000_82542_rev2_0:
    839. 

  839. 	case e1000_82542_rev2_1:
    840. 

  840. 	case e1000_82543:
    841. 

  841. 		break;
    842. 

  842. 	case e1000_82544:
    843. 

  843. 		e1000_read_eeprom(&adapter->hw,
    844. 

  844. 			EEPROM_INIT_CONTROL2_REG, 1, &eeprom_data);
    845. 

  845. 		eeprom_apme_mask = E1000_EEPROM_82544_APM;
    846. 

  846. 		break;
    847. 

  847. 	case e1000_82546:
    848. 

  848. 	case e1000_82546_rev_3:
    849. 

  849. 		if((E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_FUNC_1)
    850. 

  850. 		   && (adapter->hw.media_type == e1000_media_type_copper)) {
    851. 

  851. 			e1000_read_eeprom(&adapter->hw,
    852. 

  852. 				EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
    853. 

  853. 			break;
    854. 

  854. 		}
    855. 

  855. 		/* Fall Through */
    856. 

  856. 	default:
    857. 

  857. 		e1000_read_eeprom(&adapter->hw,
    858. 

  858. 			EEPROM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
    859. 

  859. 		break;
    860. 

  860. 	}
    861. 

  861. 	if(eeprom_data & eeprom_apme_mask)
    862. 

  862. 		adapter->wol |= E1000_WUFC_MAG;
    863. 

  863. 

  864. 	/* reset the hardware with the new settings */
    865. 

  865. 	e1000_reset(adapter);
    866. 

  866. 

  867. 	/* Let firmware know the driver has taken over */
    868. 

  868. 	switch(adapter->hw.mac_type) {
    869. 

  869. 	case e1000_82571:
    870. 

  870. 	case e1000_82572:
    871. 

  871. 		ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
    872. 

  872. 		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,
    873. 

  873. 				ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
    874. 

  874. 		break;
    875. 

  875. 	case e1000_82573:
    876. 

  876. 		swsm = E1000_READ_REG(&adapter->hw, SWSM);
    877. 

  877. 		E1000_WRITE_REG(&adapter->hw, SWSM,
    878. 

  878. 				swsm | E1000_SWSM_DRV_LOAD);
    879. 

  879. 		break;
    880. 

  880. 	default:
    881. 

  881. 		break;
    882. 

  882. 	}
    883. 

  883. 

  884. 	strcpy(netdev->name, "eth%d");
    885. 

  885. 	if((err = register_netdev(netdev)))
    886. 

  886. 		goto err_register;
    887. 

  887. 

  888. 	DPRINTK(PROBE, INFO, "Intel(R) PRO/1000 Network Connection\n");
    889. 

  889. 

  890. 	cards_found++;
    891. 

  891. 	return 0;
    892. 

  892. 

  893. err_register:
    894. 

  894. err_sw_init:
    895. 

  895. err_eeprom:
    896. 

  896. 	iounmap(adapter->hw.hw_addr);
    897. 

  897. err_ioremap:
    898. 

  898. 	free_netdev(netdev);
    899. 

  899. err_alloc_etherdev:
    900. 

  900. 	pci_release_regions(pdev);
    901. 

  901. 	return err;
    902. 

  902. }
    903. 

  903. 

  904. /**
    905. 

  905.  * e1000_remove - Device Removal Routine
    906. 

  906.  * @pdev: PCI device information struct
    907. 

  907.  *
    908. 

  908.  * e1000_remove is called by the PCI subsystem to alert the driver
    909. 

  909.  * that it should release a PCI device.  The could be caused by a
    910. 

  910.  * Hot-Plug event, or because the driver is going to be removed from
    911. 

  911.  * memory.
    912. 

  912.  **/
    913. 

  913. 

  914. static void __devexit
    915. 

  915. e1000_remove(struct pci_dev *pdev)
    916. 

  916. {
    917. 

  917. 	struct net_device *netdev = pci_get_drvdata(pdev);
    918. 

  918. 	struct e1000_adapter *adapter = netdev_priv(netdev);
    919. 

  919. 	uint32_t ctrl_ext;
    920. 

  920. 	uint32_t manc, swsm;
    921. 

  921. #ifdef CONFIG_E1000_NAPI
    922. 

  922. 	int i;
    923. 

  923. #endif
    924. 

  924. 

  925. 	if(adapter->hw.mac_type >= e1000_82540 &&
    926. 

  926. 	   adapter->hw.media_type == e1000_media_type_copper) {
    927. 

  927. 		manc = E1000_READ_REG(&adapter->hw, MANC);
    928. 

  928. 		if(manc & E1000_MANC_SMBUS_EN) {
    929. 

  929. 			manc |= E1000_MANC_ARP_EN;
    930. 

  930. 			E1000_WRITE_REG(&adapter->hw, MANC, manc);
    931. 

  931. 		}
    932. 

  932. 	}
    933. 

  933. 

  934. 	switch(adapter->hw.mac_type) {
    935. 

  935. 	case e1000_82571:
    936. 

  936. 	case e1000_82572:
    937. 

  937. 		ctrl_ext = E1000_READ_REG(&adapter->hw, CTRL_EXT);
    938. 

  938. 		E1000_WRITE_REG(&adapter->hw, CTRL_EXT,
    939. 

  939. 				ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);
    940. 

  940. 		break;
    941. 

  941. 	case e1000_82573:
    942. 

  942. 		swsm = E1000_READ_REG(&adapter->hw, SWSM);
    943. 

  943. 		E1000_WRITE_REG(&adapter->hw, SWSM,
    944. 

  944. 				swsm & ~E1000_SWSM_DRV_LOAD);
    945. 

  945. 		break;
    946. 

  946. 

  947. 	default:
    948. 

  948. 		break;
    949. 

  949. 	}
    950. 

  950. 

  951. 	unregister_netdev(netdev);
    952. 

  952. #ifdef CONFIG_E1000_NAPI
    953. 

  953. 	for (i = 0; i < adapter->num_queues; i++)
    954. 

  954. 		__dev_put(&adapter->polling_netdev[i]);
    955. 

  955. #endif
    956. 

  956. 

  957. 	if(!e1000_check_phy_reset_block(&adapter->hw))
    958. 

  958. 		e1000_phy_hw_reset(&adapter->hw);
    959. 

  959. 

  960. 	kfree(adapter->tx_ring);
    961. 

  961. 	kfree(adapter->rx_ring);
    962. 

  962. #ifdef CONFIG_E1000_NAPI
    963. 

  963. 	kfree(adapter->polling_netdev);
    964. 

  964. #endif
    965. 

  965. 

  966. 	iounmap(adapter->hw.hw_addr);
    967. 

  967. 	pci_release_regions(pdev);
    968. 

  968. 

  969. #ifdef CONFIG_E1000_MQ
    970. 

  970. 	free_percpu(adapter->cpu_netdev);
    971. 

  971. 	free_percpu(adapter->cpu_tx_ring);
    972. 

  972. #endif
    973. 

  973. 	free_netdev(netdev);
    974. 

  974. }
    975. 

  975. 

  976. /**
    977. 

  977.  * e1000_sw_init - Initialize general software structures (struct e1000_adapter)
    978. 

  978.  * @adapter: board private structure to initialize
    979. 

  979.  *
    980. 

  980.  * e1000_sw_init initializes the Adapter private data structure.
    981. 

  981.  * Fields are initialized based on PCI device information and
    982. 

  982.  * OS network device settings (MTU size).
    983. 

  983.  **/
    984. 

  984. 

  985. static int __devinit
    986. 

  986. e1000_sw_init(struct e1000_adapter *adapter)
    987. 

  987. {
    988. 

  988. 	struct e1000_hw *hw = &adapter->hw;
    989. 

  989. 	struct net_device *netdev = adapter->netdev;
    990. 

  990. 	struct pci_dev *pdev = adapter->pdev;
    991. 

  991. #ifdef CONFIG_E1000_NAPI
    992. 

  992. 	int i;
    993. 

  993. #endif
    994. 

  994. 

  995. 	/* PCI config space info */
    996. 

  996. 

  997. 	hw->vendor_id = pdev->vendor;
    998. 

  998. 	hw->device_id = pdev->device;
    999. 

  999. 	hw->subsystem_vendor_id = pdev->subsystem_vendor;
    1000. 

  1000. 	hw->subsystem_id = pdev->subsystem_device;
    1001. 

  1001. 

  1002. 	pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id);
    1003. 

  1003. 

  1004. 	pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word);
    1005. 

  1005. 

  1006. 	adapter->rx_buffer_len = E1000_RXBUFFER_2048;
    1007. 

  1007. 	adapter->rx_ps_bsize0 = E1000_RXBUFFER_256;
    1008. 

  1008. 	hw->max_frame_size = netdev->mtu +
    1009. 

  1009. 			     ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
    1010. 

  1010. 	hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;
    1011. 

  1011. 

  1012. 	/* identify the MAC */
    1013. 

  1013. 	if(hw->device_id == 0x10A0 || hw->device_id == 0x10A1) {
    1014. 

  1014. 		DPRINTK(PROBE, INFO, "Setting MAC Type for Dewey Jones Beach Device\n");
    1015. 

  1015. 		hw->mac_type = e1000_82571;
    1016. 

  1016. 	}
    1017. 

  1017. 	else if(e1000_set_mac_type(hw)) {
    1018. 

  1018. 		DPRINTK(PROBE, ERR, "Unknown MAC Type\n");
    1019. 

  1019. 		return -EIO;
    1020. 

  1020. 	}
    1021. 

  1021. 

  1022. 	/* initialize eeprom parameters */
    1023. 

  1023. 

  1024. 	if(e1000_init_eeprom_params(hw)) {
    1025. 

  1025. 		E1000_ERR("EEPROM initialization failed\n");
    1026. 

  1026. 		return -EIO;
    1027. 

  1027. 	}
    1028. 

  1028. 

  1029. 	switch(hw->mac_type) {
    1030. 

  1030. 	default:
    1031. 

  1031. 		break;
    1032. 

  1032. 	case e1000_82541:
    1033. 

  1033. 	case e1000_82547:
    1034. 

  1034. 	case e1000_82541_rev_2:
    1035. 

  1035. 	case e1000_82547_rev_2:
    1036. 

  1036. 		hw->phy_init_script = 1;
    1037. 

  1037. 		break;
    1038. 

  1038. 	}
    1039. 

  1039. 

  1040. 	e1000_set_media_type(hw);
    1041. 

  1041. 

  1042. 	hw->wait_autoneg_complete = FALSE;
    1043. 

  1043. 	hw->tbi_compatibility_en = TRUE;
    1044. 

  1044. 	hw->adaptive_ifs = TRUE;
    1045. 

  1045. 

  1046. 	/* Copper options */
    1047. 

  1047. 

  1048. 	if(hw->media_type == e1000_media_type_copper) {
    1049. 

  1049. 		hw->mdix = AUTO_ALL_MODES;
    1050. 

  1050. 		hw->disable_polarity_correction = FALSE;
    1051. 

  1051. 		hw->master_slave = E1000_MASTER_SLAVE;
    1052. 

  1052. 	}
    1053. 

  1053. 

  1054. #ifdef CONFIG_E1000_MQ
    1055. 

  1055. 	/* Number of supported queues */
    1056. 

  1056. 	switch (hw->mac_type) {
    1057. 

  1057. 	case e1000_82571:
    1058. 

  1058. 	case e1000_82572:
    1059. 

  1059. 		adapter->num_queues = 2;
    1060. 

  1060. 		break;
    1061. 

  1061. 	default:
    1062. 

  1062. 		adapter->num_queues = 1;
    1063. 

  1063. 		break;
    1064. 

  1064. 	}
    1065. 

  1065. 	adapter->num_queues = min(adapter->num_queues, num_online_cpus());
    1066. 

  1066. #else
    1067. 

  1067. 	adapter->num_queues = 1;
    1068. 

  1068. #endif
    1069. 

  1069. 

  1070. 	if (e1000_alloc_queues(adapter)) {
    1071. 

  1071. 		DPRINTK(PROBE, ERR, "Unable to allocate memory for queues\n");
    1072. 

  1072. 		return -ENOMEM;
    1073. 

  1073. 	}
    1074. 

  1074. 

  1075. #ifdef CONFIG_E1000_NAPI
    1076. 

  1076. 	for (i = 0; i < adapter->num_queues; i++) {
    1077. 

  1077. 		adapter->polling_netdev[i].priv = adapter;
    1078. 

  1078. 		adapter->polling_netdev[i].poll = &e1000_clean;
    1079. 

  1079. 		adapter->polling_netdev[i].weight = 64;
    1080. 

  1080. 		dev_hold(&adapter->polling_netdev[i]);
    1081. 

  1081. 		set_bit(__LINK_STATE_START, &adapter->polling_netdev[i].state);
    1082. 

  1082. 	}
    1083. 

  1083. #endif
    1084. 

  1084. 

  1085. #ifdef CONFIG_E1000_MQ
    1086. 

  1086. 	e1000_setup_queue_mapping(adapter);
    1087. 

  1087. #endif
    1088. 

  1088. 

  1089. 	atomic_set(&adapter->irq_sem, 1);
    1090. 

  1090. 	spin_lock_init(&adapter->stats_lock);
    1091. 

  1091. 

  1092. 	return 0;
    1093. 

  1093. }
    1094. 

  1094. 

  1095. /**
    1096. 

  1096.  * e1000_alloc_queues - Allocate memory for all rings
    1097. 

  1097.  * @adapter: board private structure to initialize
    1098. 

  1098.  *
    1099. 

  1099.  * We allocate one ring per queue at run-time since we don't know the
    1100. 

  1100.  * number of queues at compile-time.  The polling_netdev array is
    1101. 

  1101.  * intended for Multiqueue, but should work fine with a single queue.
    1102. 

  1102.  **/
    1103. 

  1103. 

  1104. static int __devinit
    1105. 

  1105. e1000_alloc_queues(struct e1000_adapter *adapter)
    1106. 

  1106. {
    1107. 

  1107. 	int size;
    1108. 

  1108. 

  1109. 	size = sizeof(struct e1000_tx_ring) * adapter->num_queues;
    1110. 

  1110. 	adapter->tx_ring = kmalloc(size, GFP_KERNEL);
    1111. 

  1111. 	if (!adapter->tx_ring)
    1112. 

  1112. 		return -ENOMEM;
    1113. 

  1113. 	memset(adapter->tx_ring, 0, size);
    1114. 

  1114. 

  1115. 	size = sizeof(struct e1000_rx_ring) * adapter->num_queues;
    1116. 

  1116. 	adapter->rx_ring = kmalloc(size, GFP_KERNEL);
    1117. 

  1117. 	if (!adapter->rx_ring) {
    1118. 

  1118. 		kfree(adapter->tx_ring);
    1119. 

  1119. 		return -ENOMEM;
    1120. 

  1120. 	}
    1121. 

  1121. 	memset(adapter->rx_ring, 0, size);
    1122. 

  1122. 

  1123. #ifdef CONFIG_E1000_NAPI
    1124. 

  1124. 	size = sizeof(struct net_device) * adapter->num_queues;
    1125. 

  1125. 	adapter->polling_netdev = kmalloc(size, GFP_KERNEL);
    1126. 

  1126. 	if (!adapter->polling_netdev) {
    1127. 

  1127. 		kfree(adapter->tx_ring);
    1128. 

  1128. 		kfree(adapter->rx_ring);
    1129. 

  1129. 		return -ENOMEM;
    1130. 

  1130. 	}
    1131. 

  1131. 	memset(adapter->polling_netdev, 0, size);
    1132. 

  1132. #endif
    1133. 

  1133. 

  1134. 	return E1000_SUCCESS;
    1135. 

  1135. }
    1136. 

  1136. 

  1137. #ifdef CONFIG_E1000_MQ
    1138. 

  1138. static void __devinit
    1139. 

  1139. e1000_setup_queue_mapping(struct e1000_adapter *adapter)
    1140. 

  1140. {
    1141. 

  1141. 	int i, cpu;
    1142. 

  1142. 

  1143. 	adapter->rx_sched_call_data.func = e1000_rx_schedule;
    1144. 

  1144. 	adapter->rx_sched_call_data.info = adapter->netdev;
    1145. 

  1145. 	cpus_clear(adapter->rx_sched_call_data.cpumask);
    1146. 

  1146. 

  1147. 	adapter->cpu_netdev = alloc_percpu(struct net_device *);
    1148. 

  1148. 	adapter->cpu_tx_ring = alloc_percpu(struct e1000_tx_ring *);
    1149. 

  1149. 

  1150. 	lock_cpu_hotplug();
    1151. 

  1151. 	i = 0;
    1152. 

  1152. 	for_each_online_cpu(cpu) {
    1153. 

  1153. 		*per_cpu_ptr(adapter->cpu_tx_ring, cpu) = &adapter->tx_ring[i % adapter->num_queues];
    1154. 

  1154. 		/* This is incomplete because we'd like to assign separate
    1155. 

  1155. 		 * physical cpus to these netdev polling structures and
    1156. 

  1156. 		 * avoid saturating a subset of cpus.
    1157. 

  1157. 		 */
    1158. 

  1158. 		if (i < adapter->num_queues) {
    1159. 

  1159. 			*per_cpu_ptr(adapter->cpu_netdev, cpu) = &adapter->polling_netdev[i];
    1160. 

  1160. 			adapter->cpu_for_queue[i] = cpu;
    1161. 

  1161. 		} else
    1162. 

  1162. 			*per_cpu_ptr(adapter->cpu_netdev, cpu) = NULL;
    1163. 

  1163. 

  1164. 		i++;
    1165. 

  1165. 	}
    1166. 

  1166. 	unlock_cpu_hotplug();
    1167. 

  1167. }
    1168. 

  1168. #endif
    1169. 

  1169. 

  1170. /**
    1171. 

  1171.  * e1000_open - Called when a network interface is made active
    1172. 

  1172.  * @netdev: network interface device structure
    1173. 

  1173.  *
    1174. 

  1174.  * Returns 0 on success, negative value on failure
    1175. 

  1175.  *
    1176. 

  1176.  * The open entry point is called when a network interface is made
    1177. 

  1177.  * active by the system (IFF_UP).  At this point all resources needed
    1178. 

  1178.  * for transmit and receive operations are allocated, the interrupt
    1179. 

  1179.  * handler is registered with the OS, the watchdog timer is started,
    1180. 

  1180.  * and the stack is notified that the interface is ready.
    1181. 

  1181.  **/
    1182. 

  1182. 

  1183. static int
    1184. 

  1184. e1000_open(struct net_device *netdev)
    1185. 

  1185. {
    1186. 

  1186. 	struct e1000_adapter *adapter = netdev_priv(netdev);
    1187. 

  1187. 	int err;
    1188. 

  1188. 

  1189. 	/* allocate transmit descriptors */
    1190. 

  1190. 

  1191. 	if ((err = e1000_setup_all_tx_resources(adapter)))
    1192. 

  1192. 		goto err_setup_tx;
    1193. 

  1193. 

  1194. 	/* allocate receive descriptors */
    1195. 

  1195. 

  1196. 	if ((err = e1000_setup_all_rx_resources(adapter)))
    1197. 

  1197. 		goto err_setup_rx;
    1198. 

  1198. 

  1199. 	if ((err = e1000_up(adapter)))
    1200. 

  1200. 		goto err_up;
    1201. 

  1201. #ifdef NETIF_F_HW_VLAN_TX
    1202. 

  1202. 	adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
    1203. 

  1203. 	if ((adapter->hw.mng_cookie.status &
    1204. 

  1204. 			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
    1205. 

  1205. 		e1000_update_mng_vlan(adapter);
    1206. 

  1206. 	}
    1207. 

  1207. #endif
    1208. 

  1208. 

  1209. 	return E1000_SUCCESS;
    1210. 

  1210. 

  1211. err_up:
    1212. 

  1212. 	e1000_free_all_rx_resources(adapter);
    1213. 

  1213. err_setup_rx:
    1214. 

  1214. 	e1000_free_all_tx_resources(adapter);
    1215. 

  1215. err_setup_tx:
    1216. 

  1216. 	e1000_reset(adapter);
    1217. 

  1217. 

  1218. 	return err;
    1219. 

  1219. }
    1220. 

  1220. 

  1221. /**
    1222. 

  1222.  * e1000_close - Disables a network interface
    1223. 

  1223.  * @netdev: network interface device structure
    1224. 

  1224.  *
    1225. 

  1225.  * Returns 0, this is not allowed to fail
    1226. 

  1226.  *
    1227. 

  1227.  * The close entry point is called when an interface is de-activated
    1228. 

  1228.  * by the OS.  The hardware is still under the drivers control, but
    1229. 

  1229.  * needs to be disabled.  A global MAC reset is issued to stop the
    1230. 

  1230.  * hardware, and all transmit and receive resources are freed.
    1231. 

  1231.  **/
    1232. 

  1232. 

  1233. static int
    1234. 

  1234. e1000_close(struct net_device *netdev)
    1235. 

  1235. {
    1236. 

  1236. 	struct e1000_adapter *adapter = netdev_priv(netdev);
    1237. 

  1237. 

  1238. 	e1000_down(adapter);
    1239. 

  1239. 

  1240. 	e1000_free_all_tx_resources(adapter);
    1241. 

  1241. 	e1000_free_all_rx_resources(adapter);
    1242. 

  1242. 

  1243. #ifdef NETIF_F_HW_VLAN_TX
    1244. 

  1244. 	if((adapter->hw.mng_cookie.status &
    1245. 

  1245. 			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
    1246. 

  1246. 		e1000_vlan_rx_kill_vid(netdev, adapter->mng_vlan_id);
    1247. 

  1247. 	}
    1248. 

  1248. #endif
    1249. 

  1249. 	return 0;
    1250. 

  1250. }
    1251. 

  1251. 

  1252. /**
    1253. 

  1253.  * e1000_check_64k_bound - check that memory doesn't cross 64kB boundary
    1254. 

  1254.  * @adapter: address of board private structure
    1255. 

  1255.  * @start: address of beginning of memory
    1256. 

  1256.  * @len: length of memory
    1257. 

  1257.  **/
    1258. 

  1258. static inline boolean_t
    1259. 

  1259. e1000_check_64k_bound(struct e1000_adapter *adapter,
    1260. 

  1260. 		      void *start, unsigned long len)
    1261. 

  1261. {
    1262. 

  1262. 	unsigned long begin = (unsigned long) start;
    1263. 

  1263. 	unsigned long end = begin + len;
    1264. 

  1264. 

  1265. 	/* First rev 82545 and 82546 need to not allow any memory
    1266. 

  1266. 	 * write location to cross 64k boundary due to errata 23 */
    1267. 

  1267. 	if(adapter->hw.mac_type == e1000_82545 ||
    1268. 

  1268. 	    adapter->hw.mac_type == e1000_82546) {
    1269. 

  1269. 		return ((begin ^ (end - 1)) >> 16) != 0 ? FALSE : TRUE;
    1270. 

  1270. 	}
    1271. 

  1271. 

  1272. 	return TRUE;
    1273. 

  1273. }
    1274. 

  1274. 

  1275. /**
    1276. 

  1276.  * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
    1277. 

  1277.  * @adapter: board private structure
    1278. 

  1278.  * @txdr:    tx descriptor ring (for a specific queue) to setup
    1279. 

  1279.  *
    1280. 

  1280.  * Return 0 on success, negative on failure
    1281. 

  1281.  **/
    1282. 

  1282. 

  1283. int
    1284. 

  1284. e1000_setup_tx_resources(struct e1000_adapter *adapter,
    1285. 

  1285.                          struct e1000_tx_ring *txdr)
    1286. 

  1286. {
    1287. 

  1287. 	struct pci_dev *pdev = adapter->pdev;
    1288. 

  1288. 	int size;
    1289. 

  1289. 

  1290. 	size = sizeof(struct e1000_buffer) * txdr->count;
    1291. 

  1291. 	txdr->buffer_info = vmalloc(size);
    1292. 

  1292. 	if (!txdr->buffer_info) {
    1293. 

  1293. 		DPRINTK(PROBE, ERR,
    1294. 

  1294. 		"Unable to allocate memory for the transmit descriptor ring\n");
    1295. 

  1295. 		return -ENOMEM;
    1296. 

  1296. 	}
    1297. 

  1297. 	memset(txdr->buffer_info, 0, size);
    1298. 

  1298. 	memset(&txdr->previous_buffer_info, 0, sizeof(struct e1000_buffer));
    1299. 

  1299. 

  1300. 	/* round up to nearest 4K */
    1301. 

  1301. 

  1302. 	txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
    1303. 

  1303. 	E1000_ROUNDUP(txdr->size, 4096);
    1304. 

  1304. 

  1305. 	txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
    1306. 

  1306. 	if (!txdr->desc) {
    1307. 

  1307. setup_tx_desc_die:
    1308. 

  1308. 		vfree(txdr->buffer_info);
    1309. 

  1309. 		DPRINTK(PROBE, ERR,
    1310. 

  1310. 		"Unable to allocate memory for the transmit descriptor ring\n");
    1311. 

  1311. 		return -ENOMEM;
    1312. 

  1312. 	}
    1313. 

  1313. 

  1314. 	/* Fix for errata 23, can't cross 64kB boundary */
    1315. 

  1315. 	if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
    1316. 

  1316. 		void *olddesc = txdr->desc;
    1317. 

  1317. 		dma_addr_t olddma = txdr->dma;
    1318. 

  1318. 		DPRINTK(TX_ERR, ERR, "txdr align check failed: %u bytes "
    1319. 

  1319. 				     "at %p\n", txdr->size, txdr->desc);
    1320. 

  1320. 		/* Try again, without freeing the previous */
    1321. 

  1321. 		txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
    1322. 

  1322. 		/* Failed allocation, critical failure */
    1323. 

  1323. 		if (!txdr->desc) {
    1324. 

  1324. 			pci_free_consistent(pdev, txdr->size, olddesc, olddma);
    1325. 

  1325. 			goto setup_tx_desc_die;
    1326. 

  1326. 		}
    1327. 

  1327. 

  1328. 		if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
    1329. 

  1329. 			/* give up */
    1330. 

  1330. 			pci_free_consistent(pdev, txdr->size, txdr->desc,
    1331. 

  1331. 					    txdr->dma);
    1332. 

  1332. 			pci_free_consistent(pdev, txdr->size, olddesc, olddma);
    1333. 

  1333. 			DPRINTK(PROBE, ERR,
    1334. 

  1334. 				"Unable to allocate aligned memory "
    1335. 

  1335. 				"for the transmit descriptor ring\n");
    1336. 

  1336. 			vfree(txdr->buffer_info);
    1337. 

  1337. 			return -ENOMEM;
    1338. 

  1338. 		} else {
    1339. 

  1339. 			/* Free old allocation, new allocation was successful */
    1340. 

  1340. 			pci_free_consistent(pdev, txdr->size, olddesc, olddma);
    1341. 

  1341. 		}
    1342. 

  1342. 	}
    1343. 

  1343. 	memset(txdr->desc, 0, txdr->size);
    1344. 

  1344. 

  1345. 	txdr->next_to_use = 0;
    1346. 

  1346. 	txdr->next_to_clean = 0;
    1347. 

  1347. 	spin_lock_init(&txdr->tx_lock);
    1348. 

  1348. 

  1349. 	return 0;
    1350. 

  1350. }
    1351. 

  1351. 

  1352. /**
    1353. 

  1353.  * e1000_setup_all_tx_resources - wrapper to allocate Tx resources
    1354. 

  1354.  * 				  (Descriptors) for all queues
    1355. 

  1355.  * @adapter: board private structure
    1356. 

  1356.  *
    1357. 

  1357.  * If this function returns with an error, then it's possible one or
    1358. 

  1358.  * more of the rings is populated (while the rest are not).  It is the
    1359. 

  1359.  * callers duty to clean those orphaned rings.
    1360. 

  1360.  *
    1361. 

  1361.  * Return 0 on success, negative on failure
    1362. 

  1362.  **/
    1363. 

  1363. 

  1364. int
    1365. 

  1365. e1000_setup_all_tx_resources(struct e1000_adapter *adapter)
    1366. 

  1366. {
    1367. 

  1367. 	int i, err = 0;
    1368. 

  1368. 

  1369. 	for (i = 0; i < adapter->num_queues; i++) {
    1370. 

  1370. 		err = e1000_setup_tx_resources(adapter, &adapter->tx_ring[i]);
    1371. 

  1371. 		if (err) {
    1372. 

  1372. 			DPRINTK(PROBE, ERR,
    1373. 

  1373. 				"Allocation for Tx Queue %u failed\n", i);
    1374. 

  1374. 			break;
    1375. 

  1375. 		}
    1376. 

  1376. 	}
    1377. 

  1377. 

  1378. 	return err;
    1379. 

  1379. }
    1380. 

  1380. 

  1381. /**
    1382. 

  1382.  * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
    1383. 

  1383.  * @adapter: board private structure
    1384. 

  1384.  *
    1385. 

  1385.  * Configure the Tx unit of the MAC after a reset.
    1386. 

  1386.  **/
    1387. 

  1387. 

  1388. static void
    1389. 

  1389. e1000_configure_tx(struct e1000_adapter *adapter)
    1390. 

  1390. {
    1391. 

  1391. 	uint64_t tdba;
    1392. 

  1392. 	struct e1000_hw *hw = &adapter->hw;
    1393. 

  1393. 	uint32_t tdlen, tctl, tipg, tarc;
    1394. 

  1394. 

  1395. 	/* Setup the HW Tx Head and Tail descriptor pointers */
    1396. 

  1396. 

  1397. 	switch (adapter->num_queues) {
    1398. 

  1398. 	case 2:
    1399. 

  1399. 		tdba = adapter->tx_ring[1].dma;
    1400. 

  1400. 		tdlen = adapter->tx_ring[1].count *
    1401. 

  1401. 			sizeof(struct e1000_tx_desc);
    1402. 

  1402. 		E1000_WRITE_REG(hw, TDBAL1, (tdba & 0x00000000ffffffffULL));
    1403. 

  1403. 		E1000_WRITE_REG(hw, TDBAH1, (tdba >> 32));
    1404. 

  1404. 		E1000_WRITE_REG(hw, TDLEN1, tdlen);
    1405. 

  1405. 		E1000_WRITE_REG(hw, TDH1, 0);
    1406. 

  1406. 		E1000_WRITE_REG(hw, TDT1, 0);
    1407. 

  1407. 		adapter->tx_ring[1].tdh = E1000_TDH1;
    1408. 

  1408. 		adapter->tx_ring[1].tdt = E1000_TDT1;
    1409. 

  1409. 		/* Fall Through */
    1410. 

  1410. 	case 1:
    1411. 

  1411. 	default:
    1412. 

  1412. 		tdba = adapter->tx_ring[0].dma;
    1413. 

  1413. 		tdlen = adapter->tx_ring[0].count *
    1414. 

  1414. 			sizeof(struct e1000_tx_desc);
    1415. 

  1415. 		E1000_WRITE_REG(hw, TDBAL, (tdba & 0x00000000ffffffffULL));
    1416. 

  1416. 		E1000_WRITE_REG(hw, TDBAH, (tdba >> 32));
    1417. 

  1417. 		E1000_WRITE_REG(hw, TDLEN, tdlen);
    1418. 

  1418. 		E1000_WRITE_REG(hw, TDH, 0);
    1419. 

  1419. 		E1000_WRITE_REG(hw, TDT, 0);
    1420. 

  1420. 		adapter->tx_ring[0].tdh = E1000_TDH;
    1421. 

  1421. 		adapter->tx_ring[0].tdt = E1000_TDT;
    1422. 

  1422. 		break;
    1423. 

  1423. 	}
    1424. 

  1424. 

  1425. 	/* Set the default values for the Tx Inter Packet Gap timer */
    1426. 

  1426. 

  1427. 	switch (hw->mac_type) {
    1428. 

  1428. 	case e1000_82542_rev2_0:
    1429. 

  1429. 	case e1000_82542_rev2_1:
    1430. 

  1430. 		tipg = DEFAULT_82542_TIPG_IPGT;
    1431. 

  1431. 		tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
    1432. 

  1432. 		tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
    1433. 

  1433. 		break;
    1434. 

  1434. 	default:
    1435. 

  1435. 		if (hw->media_type == e1000_media_type_fiber ||
    1436. 

  1436. 		    hw->media_type == e1000_media_type_internal_serdes)
    1437. 

  1437. 			tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
    1438. 

  1438. 		else
    1439. 

  1439. 			tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
    1440. 

  1440. 		tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT;
    1441. 

  1441. 		tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT;
    1442. 

  1442. 	}
    1443. 

  1443. 	E1000_WRITE_REG(hw, TIPG, tipg);
    1444. 

  1444. 

  1445. 	/* Set the Tx Interrupt Delay register */
    1446. 

  1446. 

  1447. 	E1000_WRITE_REG(hw, TIDV, adapter->tx_int_delay);
    1448. 

  1448. 	if (hw->mac_type >= e1000_82540)
    1449. 

  1449. 		E1000_WRITE_REG(hw, TADV, adapter->tx_abs_int_delay);
    1450. 

  1450. 

  1451. 	/* Program the Transmit Control Register */
    1452. 

  1452. 

  1453. 	tctl = E1000_READ_REG(hw, TCTL);
    1454. 

  1454. 

  1455. 	tctl &= ~E1000_TCTL_CT;
    1456. 

  1456. 	tctl |= E1000_TCTL_EN | E1000_TCTL_PSP | E1000_TCTL_RTLC |
    1457. 

  1457. 		(E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
    1458. 

  1458. 

  1459. 	E1000_WRITE_REG(hw, TCTL, tctl);
    1460. 

  1460. 

  1461. 	if (hw->mac_type == e1000_82571 || hw->mac_type == e1000_82572) {
    1462. 

  1462. 		tarc = E1000_READ_REG(hw, TARC0);
    1463. 

  1463. 		/* disabled bit 21 to fix network problems when forced to 100/10 Mbps */
    1464. 

  1464. 		tarc |= (1 << 25);
    1465. 

  1465. 		E1000_WRITE_REG(hw, TARC0, tarc);
    1466. 

  1466. 		tarc = E1000_READ_REG(hw, TARC1);
    1467. 

  1467. 		tarc |= (1 << 25);
    1468. 

  1468. 		if (tctl & E1000_TCTL_MULR)
    1469. 

  1469. 			tarc &= ~(1 << 28);
    1470. 

  1470. 		else
    1471. 

  1471. 			tarc |= (1 << 28);
    1472. 

  1472. 		E1000_WRITE_REG(hw, TARC1, tarc);
    1473. 

  1473. 	}
    1474. 

  1474. 

  1475. 	e1000_config_collision_dist(hw);
    1476. 

  1476. 

  1477. 	/* Setup Transmit Descriptor Settings for eop descriptor */
    1478. 

  1478. 	adapter->txd_cmd = E1000_TXD_CMD_IDE | E1000_TXD_CMD_EOP |
    1479. 

  1479. 		E1000_TXD_CMD_IFCS;
    1480. 

  1480. 

  1481. 	if (hw->mac_type < e1000_82543)
    1482. 

  1482. 		adapter->txd_cmd |= E1000_TXD_CMD_RPS;
    1483. 

  1483. 	else
    1484. 

  1484. 		adapter->txd_cmd |= E1000_TXD_CMD_RS;
    1485. 

  1485. 

  1486. 	/* Cache if we're 82544 running in PCI-X because we'll
    1487. 

  1487. 	 * need this to apply a workaround later in the send path. */
    1488. 

  1488. 	if (hw->mac_type == e1000_82544 &&
    1489. 

  1489. 	    hw->bus_type == e1000_bus_type_pcix)
    1490. 

  1490. 		adapter->pcix_82544 = 1;
    1491. 

  1491. }
    1492. 

  1492. 

  1493. /**
    1494. 

  1494.  * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
    1495. 

  1495.  * @adapter: board private structure
    1496. 

  1496.  * @rxdr:    rx descriptor ring (for a specific queue) to setup
    1497. 

  1497.  *
    1498. 

  1498.  * Returns 0 on success, negative on failure
    1499. 

  1499.  **/
    1500. 

  1500. 

  1501. int
    1502. 

  1502. e1000_setup_rx_resources(struct e1000_adapter *adapter,
    1503. 

  1503.                          struct e1000_rx_ring *rxdr)
    1504. 

  1504. {
    1505. 

  1505. 	struct pci_dev *pdev = adapter->pdev;
    1506. 

  1506. 	int size, desc_len;
    1507. 

  1507. 

  1508. 	size = sizeof(struct e1000_buffer) * rxdr->count;
    1509. 

  1509. 	rxdr->buffer_info = vmalloc(size);
    1510. 

  1510. 	if (!rxdr->buffer_info) {
    1511. 

  1511. 		DPRINTK(PROBE, ERR,
    1512. 

  1512. 		"Unable to allocate memory for the receive descriptor ring\n");
    1513. 

  1513. 		return -ENOMEM;
    1514. 

  1514. 	}
    1515. 

  1515. 	memset(rxdr->buffer_info, 0, size);
    1516. 

  1516. 

  1517. 	size = sizeof(struct e1000_ps_page) * rxdr->count;
    1518. 

  1518. 	rxdr->ps_page = kmalloc(size, GFP_KERNEL);
    1519. 

  1519. 	if (!rxdr->ps_page) {
    1520. 

  1520. 		vfree(rxdr->buffer_info);
    1521. 

  1521. 		DPRINTK(PROBE, ERR,
    1522. 

  1522. 		"Unable to allocate memory for the receive descriptor ring\n");
    1523. 

  1523. 		return -ENOMEM;
    1524. 

  1524. 	}
    1525. 

  1525. 	memset(rxdr->ps_page, 0, size);
    1526. 

  1526. 

  1527. 	size = sizeof(struct e1000_ps_page_dma) * rxdr->count;
    1528. 

  1528. 	rxdr->ps_page_dma = kmalloc(size, GFP_KERNEL);
    1529. 

  1529. 	if (!rxdr->ps_page_dma) {
    1530. 

  1530. 		vfree(rxdr->buffer_info);
    1531. 

  1531. 		kfree(rxdr->ps_page);
    1532. 

  1532. 		DPRINTK(PROBE, ERR,
    1533. 

  1533. 		"Unable to allocate memory for the receive descriptor ring\n");
    1534. 

  1534. 		return -ENOMEM;
    1535. 

  1535. 	}
    1536. 

  1536. 	memset(rxdr->ps_page_dma, 0, size);
    1537. 

  1537. 

  1538. 	if (adapter->hw.mac_type <= e1000_82547_rev_2)
    1539. 

  1539. 		desc_len = sizeof(struct e1000_rx_desc);
    1540. 

  1540. 	else
    1541. 

  1541. 		desc_len = sizeof(union e1000_rx_desc_packet_split);
    1542. 

  1542. 

  1543. 	/* Round up to nearest 4K */
    1544. 

  1544. 

  1545. 	rxdr->size = rxdr->count * desc_len;
    1546. 

  1546. 	E1000_ROUNDUP(rxdr->size, 4096);
    1547. 

  1547. 

  1548. 	rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
    1549. 

  1549. 

  1550. 	if (!rxdr->desc) {
    1551. 

  1551. 		DPRINTK(PROBE, ERR,
    1552. 

  1552. 		"Unable to allocate memory for the receive descriptor ring\n");
    1553. 

  1553. setup_rx_desc_die:
    1554. 

  1554. 		vfree(rxdr->buffer_info);
    1555. 

  1555. 		kfree(rxdr->ps_page);
    1556. 

  1556. 		kfree(rxdr->ps_page_dma);
    1557. 

  1557. 		return -ENOMEM;
    1558. 

  1558. 	}
    1559. 

  1559. 

  1560. 	/* Fix for errata 23, can't cross 64kB boundary */
    1561. 

  1561. 	if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
    1562. 

  1562. 		void *olddesc = rxdr->desc;
    1563. 

  1563. 		dma_addr_t olddma = rxdr->dma;
    1564. 

  1564. 		DPRINTK(RX_ERR, ERR, "rxdr align check failed: %u bytes "
    1565. 

  1565. 				     "at %p\n", rxdr->size, rxdr->desc);
    1566. 

  1566. 		/* Try again, without freeing the previous */
    1567. 

  1567. 		rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
    1568. 

  1568. 		/* Failed allocation, critical failure */
    1569. 

  1569. 		if (!rxdr->desc) {
    1570. 

  1570. 			pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
    1571. 

  1571. 			DPRINTK(PROBE, ERR,
    1572. 

  1572. 				"Unable to allocate memory "
    1573. 

  1573. 				"for the receive descriptor ring\n");
    1574. 

  1574. 			goto setup_rx_desc_die;
    1575. 

  1575. 		}
    1576. 

  1576. 

  1577. 		if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
    1578. 

  1578. 			/* give up */
    1579. 

  1579. 			pci_free_consistent(pdev, rxdr->size, rxdr->desc,
    1580. 

  1580. 					    rxdr->dma);
    1581. 

  1581. 			pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
    1582. 

  1582. 			DPRINTK(PROBE, ERR,
    1583. 

  1583. 				"Unable to allocate aligned memory "
    1584. 

  1584. 				"for the receive descriptor ring\n");
    1585. 

  1585. 			goto setup_rx_desc_die;
    1586. 

  1586. 		} else {
    1587. 

  1587. 			/* Free old allocation, new allocation was successful */
    1588. 

  1588. 			pci_free_consistent(pdev, rxdr->size, olddesc, olddma);
    1589. 

  1589. 		}
    1590. 

  1590. 	}
    1591. 

  1591. 	memset(rxdr->desc, 0, rxdr->size);
    1592. 

  1592. 

  1593. 	rxdr->next_to_clean = 0;
    1594. 

  1594. 	rxdr->next_to_use = 0;
    1595. 

  1595. 

  1596. 	return 0;
    1597. 

  1597. }
    1598. 

  1598. 

  1599. /**
    1600. 

  1600.  * e1000_setup_all_rx_resources - wrapper to allocate Rx resources
    1601. 

  1601.  * 				  (Descriptors) for all queues
    1602. 

  1602.  * @adapter: board private structure
    1603. 

  1603.  *
    1604. 

  1604.  * If this function returns with an error, then it's possible one or
    1605. 

  1605.  * more of the rings is populated (while the rest are not).  It is the
    1606. 

  1606.  * callers duty to clean those orphaned rings.
    1607. 

  1607.  *
    1608. 

  1608.  * Return 0 on success, negative on failure
    1609. 

  1609.  **/
    1610. 

  1610. 

  1611. int
    1612. 

  1612. e1000_setup_all_rx_resources(struct e1000_adapter *adapter)
    1613. 

  1613. {
    1614. 

  1614. 	int i, err = 0;
    1615. 

  1615. 

  1616. 	for (i = 0; i < adapter->num_queues; i++) {
    1617. 

  1617. 		err = e1000_setup_rx_resources(adapter, &adapter->rx_ring[i]);
    1618. 

  1618. 		if (err) {
    1619. 

  1619. 			DPRINTK(PROBE, ERR,
    1620. 

  1620. 				"Allocation for Rx Queue %u failed\n", i);
    1621. 

  1621. 			break;
    1622. 

  1622. 		}
    1623. 

  1623. 	}
    1624. 

  1624. 

  1625. 	return err;
    1626. 

  1626. }
    1627. 

  1627. 

  1628. /**
    1629. 

  1629.  * e1000_setup_rctl - configure the receive control registers
    1630. 

  1630.  * @adapter: Board private structure
    1631. 

  1631.  **/
    1632. 

  1632. #define PAGE_USE_COUNT(S) (((S) >> PAGE_SHIFT) + \
    1633. 

  1633. 			(((S) & (PAGE_SIZE - 1)) ? 1 : 0))
    1634. 

  1634. static void
    1635. 

  1635. e1000_setup_rctl(struct e1000_adapter *adapter)
    1636. 

  1636. {
    1637. 

  1637. 	uint32_t rctl, rfctl;
    1638. 

  1638. 	uint32_t psrctl = 0;
    1639. 

  1639. #ifdef CONFIG_E1000_PACKET_SPLIT
    1640. 

  1640. 	uint32_t pages = 0;
    1641. 

  1641. #endif
    1642. 

  1642. 

  1643. 	rctl = E1000_READ_REG(&adapter->hw, RCTL);
    1644. 

  1644. 

  1645. 	rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
    1646. 

  1646. 

  1647. 	rctl |= E1000_RCTL_EN | E1000_RCTL_BAM |
    1648. 

  1648. 		E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
    1649. 

  1649. 		(adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT);
    1650. 

  1650. 

  1651. 	if(adapter->hw.tbi_compatibility_on == 1)
    1652. 

  1652. 		rctl |= E1000_RCTL_SBP;
    1653. 

  1653. 	else
    1654. 

  1654. 		rctl &= ~E1000_RCTL_SBP;
    1655. 

  1655. 

  1656. 	if(adapter->netdev->mtu <= ETH_DATA_LEN)
    1657. 

  1657. 		rctl &= ~E1000_RCTL_LPE;
    1658. 

  1658. 	else
    1659. 

  1659. 		rctl |= E1000_RCTL_LPE;
    1660. 

  1660. 

  1661. 	/* Setup buffer sizes */
    1662. 

  1662. 	if(adapter->hw.mac_type >= e1000_82571) {
    1663. 

  1663. 		/* We can now specify buffers in 1K increments.
    1664. 

  1664. 		 * BSIZE and BSEX are ignored in this case. */
    1665. 

  1665. 		rctl |= adapter->rx_buffer_len << 0x11;
    1666. 

  1666. 	} else {
    1667. 

  1667. 		rctl &= ~E1000_RCTL_SZ_4096;
    1668. 

  1668. 		rctl |= E1000_RCTL_BSEX; 
    1669. 

  1669. 		switch (adapter->rx_buffer_len) {
    1670. 

  1670. 		case E1000_RXBUFFER_2048:
    1671. 

  1671. 		default:
    1672. 

  1672. 			rctl |= E1000_RCTL_SZ_2048;
    1673. 

  1673. 			rctl &= ~E1000_RCTL_BSEX;
    1674. 

  1674. 			break;
    1675. 

  1675. 		case E1000_RXBUFFER_4096:
    1676. 

  1676. 			rctl |= E1000_RCTL_SZ_4096;
    1677. 

  1677. 			break;
    1678. 

  1678. 		case E1000…
    1679.

Large files files are truncated, but you can click here to view the full file