netxen_nic_main.c 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260
  1. /*
  2. * Copyright (C) 2003 - 2006 NetXen, Inc.
  3. * All rights reserved.
  4. *
  5. * This program is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU General Public License
  7. * as published by the Free Software Foundation; either version 2
  8. * of the License, or (at your option) any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful, but
  11. * WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License
  16. * along with this program; if not, write to the Free Software
  17. * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18. * MA 02111-1307, USA.
  19. *
  20. * The full GNU General Public License is included in this distribution
  21. * in the file called LICENSE.
  22. *
  23. * Contact Information:
  24. * info@netxen.com
  25. * NetXen,
  26. * 3965 Freedom Circle, Fourth floor,
  27. * Santa Clara, CA 95054
  28. *
  29. *
  30. * Main source file for NetXen NIC Driver on Linux
  31. *
  32. */
  33. #include <linux/vmalloc.h>
  34. #include <linux/highmem.h>
  35. #include "netxen_nic_hw.h"
  36. #include "netxen_nic.h"
  37. #include "netxen_nic_phan_reg.h"
  38. #include <linux/dma-mapping.h>
  39. #include <linux/vmalloc.h>
  40. #include <net/ip.h>
  41. MODULE_DESCRIPTION("NetXen Multi port (1/10) Gigabit Network Driver");
  42. MODULE_LICENSE("GPL");
  43. MODULE_VERSION(NETXEN_NIC_LINUX_VERSIONID);
  44. char netxen_nic_driver_name[] = "netxen-nic";
  45. static char netxen_nic_driver_string[] = "NetXen Network Driver version "
  46. NETXEN_NIC_LINUX_VERSIONID;
  47. #define NETXEN_NETDEV_WEIGHT 120
  48. #define NETXEN_ADAPTER_UP_MAGIC 777
  49. #define NETXEN_NIC_PEG_TUNE 0
  50. u8 nx_p2_id = NX_P2_C0;
  51. #define DMA_32BIT_MASK 0x00000000ffffffffULL
  52. #define DMA_35BIT_MASK 0x00000007ffffffffULL
  53. /* Local functions to NetXen NIC driver */
  54. static int __devinit netxen_nic_probe(struct pci_dev *pdev,
  55. const struct pci_device_id *ent);
  56. static void __devexit netxen_nic_remove(struct pci_dev *pdev);
  57. static int netxen_nic_open(struct net_device *netdev);
  58. static int netxen_nic_close(struct net_device *netdev);
  59. static int netxen_nic_xmit_frame(struct sk_buff *, struct net_device *);
  60. static void netxen_tx_timeout(struct net_device *netdev);
  61. static void netxen_tx_timeout_task(struct work_struct *work);
  62. static void netxen_watchdog(unsigned long);
  63. static int netxen_handle_int(struct netxen_adapter *, struct net_device *);
  64. static int netxen_nic_poll(struct net_device *dev, int *budget);
  65. #ifdef CONFIG_NET_POLL_CONTROLLER
  66. static void netxen_nic_poll_controller(struct net_device *netdev);
  67. #endif
  68. static irqreturn_t netxen_intr(int irq, void *data);
  69. int physical_port[] = {0, 1, 2, 3};
  70. /* PCI Device ID Table */
  71. static struct pci_device_id netxen_pci_tbl[] __devinitdata = {
  72. {PCI_DEVICE(0x4040, 0x0001)},
  73. {PCI_DEVICE(0x4040, 0x0002)},
  74. {PCI_DEVICE(0x4040, 0x0003)},
  75. {PCI_DEVICE(0x4040, 0x0004)},
  76. {PCI_DEVICE(0x4040, 0x0005)},
  77. {PCI_DEVICE(0x4040, 0x0024)},
  78. {PCI_DEVICE(0x4040, 0x0025)},
  79. {0,}
  80. };
  81. MODULE_DEVICE_TABLE(pci, netxen_pci_tbl);
  82. struct workqueue_struct *netxen_workq;
  83. static void netxen_watchdog(unsigned long);
  84. static inline void netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
  85. uint32_t crb_producer)
  86. {
  87. switch (adapter->portnum) {
  88. case 0:
  89. writel(crb_producer, NETXEN_CRB_NORMALIZE
  90. (adapter, CRB_CMD_PRODUCER_OFFSET));
  91. return;
  92. case 1:
  93. writel(crb_producer, NETXEN_CRB_NORMALIZE
  94. (adapter, CRB_CMD_PRODUCER_OFFSET_1));
  95. return;
  96. case 2:
  97. writel(crb_producer, NETXEN_CRB_NORMALIZE
  98. (adapter, CRB_CMD_PRODUCER_OFFSET_2));
  99. return;
  100. case 3:
  101. writel(crb_producer, NETXEN_CRB_NORMALIZE
  102. (adapter, CRB_CMD_PRODUCER_OFFSET_3));
  103. return;
  104. default:
  105. printk(KERN_WARNING "We tried to update "
  106. "CRB_CMD_PRODUCER_OFFSET for invalid "
  107. "PCI function id %d\n",
  108. adapter->portnum);
  109. return;
  110. }
  111. }
  112. static inline void netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
  113. u32 crb_consumer)
  114. {
  115. switch (adapter->portnum) {
  116. case 0:
  117. writel(crb_consumer, NETXEN_CRB_NORMALIZE
  118. (adapter, CRB_CMD_CONSUMER_OFFSET));
  119. return;
  120. case 1:
  121. writel(crb_consumer, NETXEN_CRB_NORMALIZE
  122. (adapter, CRB_CMD_CONSUMER_OFFSET_1));
  123. return;
  124. case 2:
  125. writel(crb_consumer, NETXEN_CRB_NORMALIZE
  126. (adapter, CRB_CMD_CONSUMER_OFFSET_2));
  127. return;
  128. case 3:
  129. writel(crb_consumer, NETXEN_CRB_NORMALIZE
  130. (adapter, CRB_CMD_CONSUMER_OFFSET_3));
  131. return;
  132. default:
  133. printk(KERN_WARNING "We tried to update "
  134. "CRB_CMD_PRODUCER_OFFSET for invalid "
  135. "PCI function id %d\n",
  136. adapter->portnum);
  137. return;
  138. }
  139. }
  140. #define ADAPTER_LIST_SIZE 12
  141. int netxen_cards_found;
  142. /*
  143. * netxen_nic_probe()
  144. *
  145. * The Linux system will invoke this after identifying the vendor ID and
  146. * device Id in the pci_tbl supported by this module.
  147. *
  148. * A quad port card has one operational PCI config space, (function 0),
  149. * which is used to access all four ports.
  150. *
  151. * This routine will initialize the adapter, and setup the global parameters
  152. * along with the port's specific structure.
  153. */
  154. static int __devinit
  155. netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
  156. {
  157. struct net_device *netdev = NULL;
  158. struct netxen_adapter *adapter = NULL;
  159. void __iomem *mem_ptr0 = NULL;
  160. void __iomem *mem_ptr1 = NULL;
  161. void __iomem *mem_ptr2 = NULL;
  162. unsigned long first_page_group_end;
  163. unsigned long first_page_group_start;
  164. u8 __iomem *db_ptr = NULL;
  165. unsigned long mem_base, mem_len, db_base, db_len;
  166. int pci_using_dac, i = 0, err;
  167. int ring;
  168. struct netxen_recv_context *recv_ctx = NULL;
  169. struct netxen_rcv_desc_ctx *rcv_desc = NULL;
  170. struct netxen_cmd_buffer *cmd_buf_arr = NULL;
  171. u64 mac_addr[FLASH_NUM_PORTS + 1];
  172. int valid_mac = 0;
  173. u32 val;
  174. int pci_func_id = PCI_FUNC(pdev->devfn);
  175. printk(KERN_INFO "%s \n", netxen_nic_driver_string);
  176. if (pdev->class != 0x020000) {
  177. printk(KERN_ERR"NetXen function %d, class %x will not"
  178. "be enabled.\n",pci_func_id, pdev->class);
  179. return -ENODEV;
  180. }
  181. if ((err = pci_enable_device(pdev)))
  182. return err;
  183. if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
  184. err = -ENODEV;
  185. goto err_out_disable_pdev;
  186. }
  187. if ((err = pci_request_regions(pdev, netxen_nic_driver_name)))
  188. goto err_out_disable_pdev;
  189. pci_set_master(pdev);
  190. pci_read_config_byte(pdev, PCI_REVISION_ID, &nx_p2_id);
  191. if (nx_p2_id == NX_P2_C1 &&
  192. (pci_set_dma_mask(pdev, DMA_35BIT_MASK) == 0) &&
  193. (pci_set_consistent_dma_mask(pdev, DMA_35BIT_MASK) == 0)) {
  194. pci_using_dac = 1;
  195. } else {
  196. if ((err = pci_set_dma_mask(pdev, DMA_32BIT_MASK)) ||
  197. (err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)))
  198. goto err_out_free_res;
  199. pci_using_dac = 0;
  200. }
  201. netdev = alloc_etherdev(sizeof(struct netxen_adapter));
  202. if(!netdev) {
  203. printk(KERN_ERR"%s: Failed to allocate memory for the "
  204. "device block.Check system memory resource"
  205. " usage.\n", netxen_nic_driver_name);
  206. goto err_out_free_res;
  207. }
  208. SET_MODULE_OWNER(netdev);
  209. SET_NETDEV_DEV(netdev, &pdev->dev);
  210. adapter = netdev->priv;
  211. memset(adapter, 0 , sizeof(struct netxen_adapter));
  212. adapter->ahw.pdev = pdev;
  213. adapter->ahw.pci_func = pci_func_id;
  214. spin_lock_init(&adapter->tx_lock);
  215. spin_lock_init(&adapter->lock);
  216. /* remap phys address */
  217. mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
  218. mem_len = pci_resource_len(pdev, 0);
  219. /* 128 Meg of memory */
  220. if (mem_len == NETXEN_PCI_128MB_SIZE) {
  221. mem_ptr0 = ioremap(mem_base, FIRST_PAGE_GROUP_SIZE);
  222. mem_ptr1 = ioremap(mem_base + SECOND_PAGE_GROUP_START,
  223. SECOND_PAGE_GROUP_SIZE);
  224. mem_ptr2 = ioremap(mem_base + THIRD_PAGE_GROUP_START,
  225. THIRD_PAGE_GROUP_SIZE);
  226. first_page_group_start = FIRST_PAGE_GROUP_START;
  227. first_page_group_end = FIRST_PAGE_GROUP_END;
  228. } else if (mem_len == NETXEN_PCI_32MB_SIZE) {
  229. mem_ptr1 = ioremap(mem_base, SECOND_PAGE_GROUP_SIZE);
  230. mem_ptr2 = ioremap(mem_base + THIRD_PAGE_GROUP_START -
  231. SECOND_PAGE_GROUP_START, THIRD_PAGE_GROUP_SIZE);
  232. first_page_group_start = 0;
  233. first_page_group_end = 0;
  234. } else {
  235. err = -EIO;
  236. goto err_out_free_netdev;
  237. }
  238. if (((mem_ptr0 == 0UL) && (mem_len == NETXEN_PCI_128MB_SIZE)) ||
  239. (mem_ptr1 == 0UL) || (mem_ptr2 == 0UL)) {
  240. DPRINTK(ERR,
  241. "Cannot remap adapter memory aborting.:"
  242. "0 -> %p, 1 -> %p, 2 -> %p\n",
  243. mem_ptr0, mem_ptr1, mem_ptr2);
  244. err = -EIO;
  245. goto err_out_iounmap;
  246. }
  247. db_base = pci_resource_start(pdev, 4); /* doorbell is on bar 4 */
  248. db_len = pci_resource_len(pdev, 4);
  249. if (db_len == 0) {
  250. printk(KERN_ERR "%s: doorbell is disabled\n",
  251. netxen_nic_driver_name);
  252. err = -EIO;
  253. goto err_out_iounmap;
  254. }
  255. DPRINTK(INFO, "doorbell ioremap from %lx a size of %lx\n", db_base,
  256. db_len);
  257. db_ptr = ioremap(db_base, NETXEN_DB_MAPSIZE_BYTES);
  258. if (!db_ptr) {
  259. printk(KERN_ERR "%s: Failed to allocate doorbell map.",
  260. netxen_nic_driver_name);
  261. err = -EIO;
  262. goto err_out_iounmap;
  263. }
  264. DPRINTK(INFO, "doorbell ioremaped at %p\n", db_ptr);
  265. adapter->ahw.pci_base0 = mem_ptr0;
  266. adapter->ahw.first_page_group_start = first_page_group_start;
  267. adapter->ahw.first_page_group_end = first_page_group_end;
  268. adapter->ahw.pci_base1 = mem_ptr1;
  269. adapter->ahw.pci_base2 = mem_ptr2;
  270. adapter->ahw.db_base = db_ptr;
  271. adapter->ahw.db_len = db_len;
  272. adapter->netdev = netdev;
  273. adapter->pdev = pdev;
  274. adapter->portnum = pci_func_id;
  275. netdev->open = netxen_nic_open;
  276. netdev->stop = netxen_nic_close;
  277. netdev->hard_start_xmit = netxen_nic_xmit_frame;
  278. netdev->get_stats = netxen_nic_get_stats;
  279. netdev->set_multicast_list = netxen_nic_set_multi;
  280. netdev->set_mac_address = netxen_nic_set_mac;
  281. netdev->change_mtu = netxen_nic_change_mtu;
  282. netdev->tx_timeout = netxen_tx_timeout;
  283. netdev->watchdog_timeo = HZ;
  284. netxen_nic_change_mtu(netdev, netdev->mtu);
  285. SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
  286. netdev->poll = netxen_nic_poll;
  287. netdev->weight = NETXEN_NETDEV_WEIGHT;
  288. #ifdef CONFIG_NET_POLL_CONTROLLER
  289. netdev->poll_controller = netxen_nic_poll_controller;
  290. #endif
  291. /* ScatterGather support */
  292. netdev->features = NETIF_F_SG;
  293. netdev->features |= NETIF_F_IP_CSUM;
  294. netdev->features |= NETIF_F_TSO;
  295. if (pci_using_dac)
  296. netdev->features |= NETIF_F_HIGHDMA;
  297. if (pci_enable_msi(pdev)) {
  298. adapter->flags &= ~NETXEN_NIC_MSI_ENABLED;
  299. printk(KERN_WARNING "%s: unable to allocate MSI interrupt"
  300. " error\n", netxen_nic_driver_name);
  301. } else
  302. adapter->flags |= NETXEN_NIC_MSI_ENABLED;
  303. netdev->irq = pdev->irq;
  304. INIT_WORK(&adapter->tx_timeout_task, netxen_tx_timeout_task);
  305. /*
  306. * Set the CRB window to invalid. If any register in window 0 is
  307. * accessed it should set the window to 0 and then reset it to 1.
  308. */
  309. adapter->curr_window = 255;
  310. /* initialize the adapter */
  311. netxen_initialize_adapter_hw(adapter);
  312. #ifdef CONFIG_PPC
  313. if ((adapter->ahw.boardcfg.board_type ==
  314. NETXEN_BRDTYPE_P2_SB31_10G_IMEZ) &&
  315. (pci_func_id == 2))
  316. goto err_out_free_adapter;
  317. #endif /* CONFIG_PPC */
  318. /*
  319. * Adapter in our case is quad port so initialize it before
  320. * initializing the ports
  321. */
  322. netxen_initialize_adapter_ops(adapter);
  323. adapter->max_tx_desc_count = MAX_CMD_DESCRIPTORS_HOST;
  324. if ((adapter->ahw.boardcfg.board_type == NETXEN_BRDTYPE_P2_SB35_4G) ||
  325. (adapter->ahw.boardcfg.board_type ==
  326. NETXEN_BRDTYPE_P2_SB31_2G))
  327. adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS_1G;
  328. else
  329. adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS;
  330. adapter->max_jumbo_rx_desc_count = MAX_JUMBO_RCV_DESCRIPTORS;
  331. adapter->max_lro_rx_desc_count = MAX_LRO_RCV_DESCRIPTORS;
  332. cmd_buf_arr = (struct netxen_cmd_buffer *)vmalloc(TX_RINGSIZE);
  333. if (cmd_buf_arr == NULL) {
  334. printk(KERN_ERR
  335. "%s: Could not allocate cmd_buf_arr memory:%d\n",
  336. netxen_nic_driver_name, (int)TX_RINGSIZE);
  337. err = -ENOMEM;
  338. goto err_out_free_adapter;
  339. }
  340. memset(cmd_buf_arr, 0, TX_RINGSIZE);
  341. adapter->cmd_buf_arr = cmd_buf_arr;
  342. for (i = 0; i < MAX_RCV_CTX; ++i) {
  343. recv_ctx = &adapter->recv_ctx[i];
  344. for (ring = 0; ring < NUM_RCV_DESC_RINGS; ring++) {
  345. rcv_desc = &recv_ctx->rcv_desc[ring];
  346. switch (RCV_DESC_TYPE(ring)) {
  347. case RCV_DESC_NORMAL:
  348. rcv_desc->max_rx_desc_count =
  349. adapter->max_rx_desc_count;
  350. rcv_desc->flags = RCV_DESC_NORMAL;
  351. rcv_desc->dma_size = RX_DMA_MAP_LEN;
  352. rcv_desc->skb_size = MAX_RX_BUFFER_LENGTH;
  353. break;
  354. case RCV_DESC_JUMBO:
  355. rcv_desc->max_rx_desc_count =
  356. adapter->max_jumbo_rx_desc_count;
  357. rcv_desc->flags = RCV_DESC_JUMBO;
  358. rcv_desc->dma_size = RX_JUMBO_DMA_MAP_LEN;
  359. rcv_desc->skb_size = MAX_RX_JUMBO_BUFFER_LENGTH;
  360. break;
  361. case RCV_RING_LRO:
  362. rcv_desc->max_rx_desc_count =
  363. adapter->max_lro_rx_desc_count;
  364. rcv_desc->flags = RCV_DESC_LRO;
  365. rcv_desc->dma_size = RX_LRO_DMA_MAP_LEN;
  366. rcv_desc->skb_size = MAX_RX_LRO_BUFFER_LENGTH;
  367. break;
  368. }
  369. rcv_desc->rx_buf_arr = (struct netxen_rx_buffer *)
  370. vmalloc(RCV_BUFFSIZE);
  371. if (rcv_desc->rx_buf_arr == NULL) {
  372. printk(KERN_ERR "%s: Could not allocate"
  373. "rcv_desc->rx_buf_arr memory:%d\n",
  374. netxen_nic_driver_name,
  375. (int)RCV_BUFFSIZE);
  376. err = -ENOMEM;
  377. goto err_out_free_rx_buffer;
  378. }
  379. memset(rcv_desc->rx_buf_arr, 0, RCV_BUFFSIZE);
  380. }
  381. }
  382. netxen_initialize_adapter_sw(adapter); /* initialize the buffers in adapter */
  383. /* Mezz cards have PCI function 0,2,3 enabled */
  384. if ((adapter->ahw.boardcfg.board_type == NETXEN_BRDTYPE_P2_SB31_10G_IMEZ)
  385. && (pci_func_id >= 2))
  386. adapter->portnum = pci_func_id - 2;
  387. #ifdef CONFIG_IA64
  388. if(adapter->portnum == 0) {
  389. netxen_pinit_from_rom(adapter, 0);
  390. udelay(500);
  391. netxen_load_firmware(adapter);
  392. }
  393. #endif
  394. init_timer(&adapter->watchdog_timer);
  395. adapter->ahw.xg_linkup = 0;
  396. adapter->watchdog_timer.function = &netxen_watchdog;
  397. adapter->watchdog_timer.data = (unsigned long)adapter;
  398. INIT_WORK(&adapter->watchdog_task, netxen_watchdog_task);
  399. adapter->ahw.pdev = pdev;
  400. adapter->proc_cmd_buf_counter = 0;
  401. adapter->ahw.revision_id = nx_p2_id;
  402. /* make sure Window == 1 */
  403. netxen_nic_pci_change_crbwindow(adapter, 1);
  404. netxen_nic_update_cmd_producer(adapter, 0);
  405. netxen_nic_update_cmd_consumer(adapter, 0);
  406. writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_HOST_CMD_ADDR_LO));
  407. if (netxen_is_flash_supported(adapter) == 0 &&
  408. netxen_get_flash_mac_addr(adapter, mac_addr) == 0)
  409. valid_mac = 1;
  410. else
  411. valid_mac = 0;
  412. if (valid_mac) {
  413. unsigned char *p = (unsigned char *)&mac_addr[adapter->portnum];
  414. netdev->dev_addr[0] = *(p + 5);
  415. netdev->dev_addr[1] = *(p + 4);
  416. netdev->dev_addr[2] = *(p + 3);
  417. netdev->dev_addr[3] = *(p + 2);
  418. netdev->dev_addr[4] = *(p + 1);
  419. netdev->dev_addr[5] = *(p + 0);
  420. memcpy(netdev->perm_addr, netdev->dev_addr,
  421. netdev->addr_len);
  422. if (!is_valid_ether_addr(netdev->perm_addr)) {
  423. printk(KERN_ERR "%s: Bad MAC address "
  424. "%02x:%02x:%02x:%02x:%02x:%02x.\n",
  425. netxen_nic_driver_name,
  426. netdev->dev_addr[0],
  427. netdev->dev_addr[1],
  428. netdev->dev_addr[2],
  429. netdev->dev_addr[3],
  430. netdev->dev_addr[4],
  431. netdev->dev_addr[5]);
  432. } else {
  433. if (adapter->macaddr_set)
  434. adapter->macaddr_set(adapter,
  435. netdev->dev_addr);
  436. }
  437. }
  438. if (adapter->portnum == 0) {
  439. err = netxen_initialize_adapter_offload(adapter);
  440. if (err)
  441. goto err_out_free_rx_buffer;
  442. val = readl(NETXEN_CRB_NORMALIZE(adapter,
  443. NETXEN_CAM_RAM(0x1fc)));
  444. if (val == 0x55555555) {
  445. /* This is the first boot after power up */
  446. val = readl(NETXEN_CRB_NORMALIZE(adapter,
  447. NETXEN_ROMUSB_GLB_SW_RESET));
  448. printk(KERN_INFO"NetXen: read 0x%08x for reset reg.\n",val);
  449. if (val != 0x80000f) {
  450. /* clear the register for future unloads/loads */
  451. writel(0, NETXEN_CRB_NORMALIZE(adapter,
  452. NETXEN_CAM_RAM(0x1fc)));
  453. printk(KERN_ERR "ERROR in NetXen HW init sequence.\n");
  454. err = -ENODEV;
  455. goto err_out_free_dev;
  456. }
  457. /* clear the register for future unloads/loads */
  458. writel(0, NETXEN_CRB_NORMALIZE(adapter,
  459. NETXEN_CAM_RAM(0x1fc)));
  460. }
  461. printk(KERN_INFO "State: 0x%0x\n",
  462. readl(NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE)));
  463. /*
  464. * Tell the hardware our version number.
  465. */
  466. i = (_NETXEN_NIC_LINUX_MAJOR << 16)
  467. | ((_NETXEN_NIC_LINUX_MINOR << 8))
  468. | (_NETXEN_NIC_LINUX_SUBVERSION);
  469. writel(i, NETXEN_CRB_NORMALIZE(adapter, CRB_DRIVER_VERSION));
  470. /* Unlock the HW, prompting the boot sequence */
  471. writel(1,
  472. NETXEN_CRB_NORMALIZE(adapter,
  473. NETXEN_ROMUSB_GLB_PEGTUNE_DONE));
  474. /* Handshake with the card before we register the devices. */
  475. netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
  476. }
  477. /*
  478. * See if the firmware gave us a virtual-physical port mapping.
  479. */
  480. i = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_V2P(adapter->portnum)));
  481. if (i != 0x55555555)
  482. physical_port[adapter->portnum] = i;
  483. netif_carrier_off(netdev);
  484. netif_stop_queue(netdev);
  485. if ((err = register_netdev(netdev))) {
  486. printk(KERN_ERR "%s: register_netdev failed port #%d"
  487. " aborting\n", netxen_nic_driver_name,
  488. adapter->portnum);
  489. err = -EIO;
  490. goto err_out_free_dev;
  491. }
  492. pci_set_drvdata(pdev, adapter);
  493. switch (adapter->ahw.board_type) {
  494. case NETXEN_NIC_GBE:
  495. printk(KERN_INFO "%s: QUAD GbE board initialized\n",
  496. netxen_nic_driver_name);
  497. break;
  498. case NETXEN_NIC_XGBE:
  499. printk(KERN_INFO "%s: XGbE board initialized\n",
  500. netxen_nic_driver_name);
  501. break;
  502. }
  503. adapter->driver_mismatch = 0;
  504. return 0;
  505. err_out_free_dev:
  506. if (adapter->portnum == 0)
  507. netxen_free_adapter_offload(adapter);
  508. err_out_free_rx_buffer:
  509. for (i = 0; i < MAX_RCV_CTX; ++i) {
  510. recv_ctx = &adapter->recv_ctx[i];
  511. for (ring = 0; ring < NUM_RCV_DESC_RINGS; ring++) {
  512. rcv_desc = &recv_ctx->rcv_desc[ring];
  513. if (rcv_desc->rx_buf_arr != NULL) {
  514. vfree(rcv_desc->rx_buf_arr);
  515. rcv_desc->rx_buf_arr = NULL;
  516. }
  517. }
  518. }
  519. vfree(cmd_buf_arr);
  520. err_out_free_adapter:
  521. if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
  522. pci_disable_msi(pdev);
  523. pci_set_drvdata(pdev, NULL);
  524. if (db_ptr)
  525. iounmap(db_ptr);
  526. err_out_iounmap:
  527. if (mem_ptr0)
  528. iounmap(mem_ptr0);
  529. if (mem_ptr1)
  530. iounmap(mem_ptr1);
  531. if (mem_ptr2)
  532. iounmap(mem_ptr2);
  533. err_out_free_netdev:
  534. free_netdev(netdev);
  535. err_out_free_res:
  536. pci_release_regions(pdev);
  537. err_out_disable_pdev:
  538. pci_disable_device(pdev);
  539. return err;
  540. }
  541. static void __devexit netxen_nic_remove(struct pci_dev *pdev)
  542. {
  543. struct netxen_adapter *adapter;
  544. struct net_device *netdev;
  545. struct netxen_rx_buffer *buffer;
  546. struct netxen_recv_context *recv_ctx;
  547. struct netxen_rcv_desc_ctx *rcv_desc;
  548. int i;
  549. int ctxid, ring;
  550. adapter = pci_get_drvdata(pdev);
  551. if (adapter == NULL)
  552. return;
  553. netdev = adapter->netdev;
  554. netxen_nic_disable_int(adapter);
  555. if (adapter->irq)
  556. free_irq(adapter->irq, adapter);
  557. if (adapter->stop_port)
  558. adapter->stop_port(adapter);
  559. if ((adapter->flags & NETXEN_NIC_MSI_ENABLED))
  560. pci_disable_msi(pdev);
  561. if (adapter->portnum == 0)
  562. netxen_free_adapter_offload(adapter);
  563. if (adapter->irq)
  564. free_irq(adapter->irq, adapter);
  565. if(adapter->portnum == 0) {
  566. /* leave the hw in the same state as reboot */
  567. writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
  568. netxen_pinit_from_rom(adapter, 0);
  569. udelay(500);
  570. netxen_load_firmware(adapter);
  571. netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
  572. }
  573. if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC)
  574. netxen_free_hw_resources(adapter);
  575. for (ctxid = 0; ctxid < MAX_RCV_CTX; ++ctxid) {
  576. recv_ctx = &adapter->recv_ctx[ctxid];
  577. for (ring = 0; ring < NUM_RCV_DESC_RINGS; ring++) {
  578. rcv_desc = &recv_ctx->rcv_desc[ring];
  579. for (i = 0; i < rcv_desc->max_rx_desc_count; ++i) {
  580. buffer = &(rcv_desc->rx_buf_arr[i]);
  581. if (buffer->state == NETXEN_BUFFER_FREE)
  582. continue;
  583. pci_unmap_single(pdev, buffer->dma,
  584. rcv_desc->dma_size,
  585. PCI_DMA_FROMDEVICE);
  586. if (buffer->skb != NULL)
  587. dev_kfree_skb_any(buffer->skb);
  588. }
  589. vfree(rcv_desc->rx_buf_arr);
  590. }
  591. }
  592. unregister_netdev(netdev);
  593. vfree(adapter->cmd_buf_arr);
  594. iounmap(adapter->ahw.db_base);
  595. iounmap(adapter->ahw.pci_base0);
  596. iounmap(adapter->ahw.pci_base1);
  597. iounmap(adapter->ahw.pci_base2);
  598. pci_release_regions(pdev);
  599. pci_disable_device(pdev);
  600. pci_set_drvdata(pdev, NULL);
  601. free_netdev(netdev);
  602. }
  603. /*
  604. * Called when a network interface is made active
  605. * @returns 0 on success, negative value on failure
  606. */
  607. static int netxen_nic_open(struct net_device *netdev)
  608. {
  609. struct netxen_adapter *adapter = (struct netxen_adapter *)netdev->priv;
  610. int err = 0;
  611. int ctx, ring;
  612. if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC) {
  613. err = netxen_init_firmware(adapter);
  614. if (err != 0) {
  615. printk(KERN_ERR "Failed to init firmware\n");
  616. return -EIO;
  617. }
  618. netxen_nic_flash_print(adapter);
  619. /* setup all the resources for the Phantom... */
  620. /* this include the descriptors for rcv, tx, and status */
  621. netxen_nic_clear_stats(adapter);
  622. err = netxen_nic_hw_resources(adapter);
  623. if (err) {
  624. printk(KERN_ERR "Error in setting hw resources:%d\n",
  625. err);
  626. return err;
  627. }
  628. for (ctx = 0; ctx < MAX_RCV_CTX; ++ctx) {
  629. for (ring = 0; ring < NUM_RCV_DESC_RINGS; ring++)
  630. netxen_post_rx_buffers(adapter, ctx, ring);
  631. }
  632. adapter->irq = adapter->ahw.pdev->irq;
  633. err = request_irq(adapter->ahw.pdev->irq, netxen_intr,
  634. IRQF_SHARED|IRQF_SAMPLE_RANDOM, netdev->name,
  635. adapter);
  636. if (err) {
  637. printk(KERN_ERR "request_irq failed with: %d\n", err);
  638. netxen_free_hw_resources(adapter);
  639. return err;
  640. }
  641. adapter->is_up = NETXEN_ADAPTER_UP_MAGIC;
  642. }
  643. if (!adapter->driver_mismatch)
  644. mod_timer(&adapter->watchdog_timer, jiffies);
  645. netxen_nic_enable_int(adapter);
  646. /* Done here again so that even if phantom sw overwrote it,
  647. * we set it */
  648. if (adapter->macaddr_set)
  649. adapter->macaddr_set(adapter, netdev->dev_addr);
  650. if (adapter->init_port
  651. && adapter->init_port(adapter, adapter->portnum) != 0) {
  652. del_timer_sync(&adapter->watchdog_timer);
  653. printk(KERN_ERR "%s: Failed to initialize port %d\n",
  654. netxen_nic_driver_name, adapter->portnum);
  655. return -EIO;
  656. }
  657. netxen_nic_set_link_parameters(adapter);
  658. netxen_nic_set_multi(netdev);
  659. if (adapter->set_mtu)
  660. adapter->set_mtu(adapter, netdev->mtu);
  661. if (!adapter->driver_mismatch)
  662. netif_start_queue(netdev);
  663. return 0;
  664. }
  665. /*
  666. * netxen_nic_close - Disables a network interface entry point
  667. */
  668. static int netxen_nic_close(struct net_device *netdev)
  669. {
  670. struct netxen_adapter *adapter = netdev_priv(netdev);
  671. int i, j;
  672. struct netxen_cmd_buffer *cmd_buff;
  673. struct netxen_skb_frag *buffrag;
  674. netif_carrier_off(netdev);
  675. netif_stop_queue(netdev);
  676. cmd_buff = adapter->cmd_buf_arr;
  677. for (i = 0; i < adapter->max_tx_desc_count; i++) {
  678. buffrag = cmd_buff->frag_array;
  679. if (buffrag->dma) {
  680. pci_unmap_single(adapter->pdev, buffrag->dma,
  681. buffrag->length, PCI_DMA_TODEVICE);
  682. buffrag->dma = (u64) NULL;
  683. }
  684. for (j = 0; j < cmd_buff->frag_count; j++) {
  685. buffrag++;
  686. if (buffrag->dma) {
  687. pci_unmap_page(adapter->pdev, buffrag->dma,
  688. buffrag->length,
  689. PCI_DMA_TODEVICE);
  690. buffrag->dma = (u64) NULL;
  691. }
  692. }
  693. /* Free the skb we received in netxen_nic_xmit_frame */
  694. if (cmd_buff->skb) {
  695. dev_kfree_skb_any(cmd_buff->skb);
  696. cmd_buff->skb = NULL;
  697. }
  698. cmd_buff++;
  699. }
  700. FLUSH_SCHEDULED_WORK();
  701. del_timer_sync(&adapter->watchdog_timer);
  702. return 0;
  703. }
  704. static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
  705. {
  706. struct netxen_adapter *adapter = netdev_priv(netdev);
  707. struct netxen_hardware_context *hw = &adapter->ahw;
  708. unsigned int first_seg_len = skb->len - skb->data_len;
  709. struct netxen_skb_frag *buffrag;
  710. unsigned int i;
  711. u32 producer = 0;
  712. u32 saved_producer = 0;
  713. struct cmd_desc_type0 *hwdesc;
  714. int k;
  715. struct netxen_cmd_buffer *pbuf = NULL;
  716. static int dropped_packet = 0;
  717. int frag_count;
  718. u32 local_producer = 0;
  719. u32 max_tx_desc_count = 0;
  720. u32 last_cmd_consumer = 0;
  721. int no_of_desc;
  722. adapter->stats.xmitcalled++;
  723. frag_count = skb_shinfo(skb)->nr_frags + 1;
  724. if (unlikely(skb->len <= 0)) {
  725. dev_kfree_skb_any(skb);
  726. adapter->stats.badskblen++;
  727. return NETDEV_TX_OK;
  728. }
  729. if (frag_count > MAX_BUFFERS_PER_CMD) {
  730. printk("%s: %s netxen_nic_xmit_frame: frag_count (%d)"
  731. "too large, can handle only %d frags\n",
  732. netxen_nic_driver_name, netdev->name,
  733. frag_count, MAX_BUFFERS_PER_CMD);
  734. adapter->stats.txdropped++;
  735. if ((++dropped_packet & 0xff) == 0xff)
  736. printk("%s: %s droppped packets = %d\n",
  737. netxen_nic_driver_name, netdev->name,
  738. dropped_packet);
  739. return NETDEV_TX_OK;
  740. }
  741. /*
  742. * Everything is set up. Now, we just need to transmit it out.
  743. * Note that we have to copy the contents of buffer over to
  744. * right place. Later on, this can be optimized out by de-coupling the
  745. * producer index from the buffer index.
  746. */
  747. retry_getting_window:
  748. spin_lock_bh(&adapter->tx_lock);
  749. if (adapter->total_threads >= MAX_XMIT_PRODUCERS) {
  750. spin_unlock_bh(&adapter->tx_lock);
  751. /*
  752. * Yield CPU
  753. */
  754. if (!in_atomic())
  755. schedule();
  756. else {
  757. for (i = 0; i < 20; i++)
  758. cpu_relax(); /*This a nop instr on i386 */
  759. }
  760. goto retry_getting_window;
  761. }
  762. local_producer = adapter->cmd_producer;
  763. /* There 4 fragments per descriptor */
  764. no_of_desc = (frag_count + 3) >> 2;
  765. if (netdev->features & NETIF_F_TSO) {
  766. if (skb_shinfo(skb)->gso_size > 0) {
  767. no_of_desc++;
  768. if ((ip_hdrlen(skb) + tcp_hdrlen(skb) +
  769. sizeof(struct ethhdr)) >
  770. (sizeof(struct cmd_desc_type0) - 2)) {
  771. no_of_desc++;
  772. }
  773. }
  774. }
  775. k = adapter->cmd_producer;
  776. max_tx_desc_count = adapter->max_tx_desc_count;
  777. last_cmd_consumer = adapter->last_cmd_consumer;
  778. if ((k + no_of_desc) >=
  779. ((last_cmd_consumer <= k) ? last_cmd_consumer + max_tx_desc_count :
  780. last_cmd_consumer)) {
  781. netif_stop_queue(netdev);
  782. adapter->flags |= NETXEN_NETDEV_STATUS;
  783. spin_unlock_bh(&adapter->tx_lock);
  784. return NETDEV_TX_BUSY;
  785. }
  786. k = get_index_range(k, max_tx_desc_count, no_of_desc);
  787. adapter->cmd_producer = k;
  788. adapter->total_threads++;
  789. adapter->num_threads++;
  790. spin_unlock_bh(&adapter->tx_lock);
  791. /* Copy the descriptors into the hardware */
  792. producer = local_producer;
  793. saved_producer = producer;
  794. hwdesc = &hw->cmd_desc_head[producer];
  795. memset(hwdesc, 0, sizeof(struct cmd_desc_type0));
  796. /* Take skb->data itself */
  797. pbuf = &adapter->cmd_buf_arr[producer];
  798. if ((netdev->features & NETIF_F_TSO) && skb_shinfo(skb)->gso_size > 0) {
  799. pbuf->mss = skb_shinfo(skb)->gso_size;
  800. hwdesc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
  801. } else {
  802. pbuf->mss = 0;
  803. hwdesc->mss = 0;
  804. }
  805. pbuf->total_length = skb->len;
  806. pbuf->skb = skb;
  807. pbuf->cmd = TX_ETHER_PKT;
  808. pbuf->frag_count = frag_count;
  809. pbuf->port = adapter->portnum;
  810. buffrag = &pbuf->frag_array[0];
  811. buffrag->dma = pci_map_single(adapter->pdev, skb->data, first_seg_len,
  812. PCI_DMA_TODEVICE);
  813. buffrag->length = first_seg_len;
  814. netxen_set_cmd_desc_totallength(hwdesc, skb->len);
  815. netxen_set_cmd_desc_num_of_buff(hwdesc, frag_count);
  816. netxen_set_cmd_desc_opcode(hwdesc, TX_ETHER_PKT);
  817. netxen_set_cmd_desc_port(hwdesc, adapter->portnum);
  818. netxen_set_cmd_desc_ctxid(hwdesc, adapter->portnum);
  819. hwdesc->buffer1_length = cpu_to_le16(first_seg_len);
  820. hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
  821. for (i = 1, k = 1; i < frag_count; i++, k++) {
  822. struct skb_frag_struct *frag;
  823. int len, temp_len;
  824. unsigned long offset;
  825. dma_addr_t temp_dma;
  826. /* move to next desc. if there is a need */
  827. if ((i & 0x3) == 0) {
  828. k = 0;
  829. producer = get_next_index(producer,
  830. adapter->max_tx_desc_count);
  831. hwdesc = &hw->cmd_desc_head[producer];
  832. memset(hwdesc, 0, sizeof(struct cmd_desc_type0));
  833. }
  834. frag = &skb_shinfo(skb)->frags[i - 1];
  835. len = frag->size;
  836. offset = frag->page_offset;
  837. temp_len = len;
  838. temp_dma = pci_map_page(adapter->pdev, frag->page, offset,
  839. len, PCI_DMA_TODEVICE);
  840. buffrag++;
  841. buffrag->dma = temp_dma;
  842. buffrag->length = temp_len;
  843. DPRINTK(INFO, "for loop. i=%d k=%d\n", i, k);
  844. switch (k) {
  845. case 0:
  846. hwdesc->buffer1_length = cpu_to_le16(temp_len);
  847. hwdesc->addr_buffer1 = cpu_to_le64(temp_dma);
  848. break;
  849. case 1:
  850. hwdesc->buffer2_length = cpu_to_le16(temp_len);
  851. hwdesc->addr_buffer2 = cpu_to_le64(temp_dma);
  852. break;
  853. case 2:
  854. hwdesc->buffer3_length = cpu_to_le16(temp_len);
  855. hwdesc->addr_buffer3 = cpu_to_le64(temp_dma);
  856. break;
  857. case 3:
  858. hwdesc->buffer4_length = cpu_to_le16(temp_len);
  859. hwdesc->addr_buffer4 = cpu_to_le64(temp_dma);
  860. break;
  861. }
  862. frag++;
  863. }
  864. producer = get_next_index(producer, adapter->max_tx_desc_count);
  865. /* might change opcode to TX_TCP_LSO */
  866. netxen_tso_check(adapter, &hw->cmd_desc_head[saved_producer], skb);
  867. /* For LSO, we need to copy the MAC/IP/TCP headers into
  868. * the descriptor ring
  869. */
  870. if (netxen_get_cmd_desc_opcode(&hw->cmd_desc_head[saved_producer])
  871. == TX_TCP_LSO) {
  872. int hdr_len, first_hdr_len, more_hdr;
  873. hdr_len = hw->cmd_desc_head[saved_producer].total_hdr_length;
  874. if (hdr_len > (sizeof(struct cmd_desc_type0) - 2)) {
  875. first_hdr_len = sizeof(struct cmd_desc_type0) - 2;
  876. more_hdr = 1;
  877. } else {
  878. first_hdr_len = hdr_len;
  879. more_hdr = 0;
  880. }
  881. /* copy the MAC/IP/TCP headers to the cmd descriptor list */
  882. hwdesc = &hw->cmd_desc_head[producer];
  883. /* copy the first 64 bytes */
  884. memcpy(((void *)hwdesc) + 2,
  885. (void *)(skb->data), first_hdr_len);
  886. producer = get_next_index(producer, max_tx_desc_count);
  887. if (more_hdr) {
  888. hwdesc = &hw->cmd_desc_head[producer];
  889. /* copy the next 64 bytes - should be enough except
  890. * for pathological case
  891. */
  892. skb_copy_from_linear_data_offset(skb, first_hdr_len,
  893. hwdesc,
  894. (hdr_len -
  895. first_hdr_len));
  896. producer = get_next_index(producer, max_tx_desc_count);
  897. }
  898. }
  899. i = netxen_get_cmd_desc_totallength(&hw->cmd_desc_head[saved_producer]);
  900. hw->cmd_desc_head[saved_producer].flags_opcode =
  901. cpu_to_le16(hw->cmd_desc_head[saved_producer].flags_opcode);
  902. hw->cmd_desc_head[saved_producer].num_of_buffers_total_length =
  903. cpu_to_le32(hw->cmd_desc_head[saved_producer].
  904. num_of_buffers_total_length);
  905. spin_lock_bh(&adapter->tx_lock);
  906. adapter->stats.txbytes += i;
  907. /* Code to update the adapter considering how many producer threads
  908. are currently working */
  909. if ((--adapter->num_threads) == 0) {
  910. /* This is the last thread */
  911. u32 crb_producer = adapter->cmd_producer;
  912. netxen_nic_update_cmd_producer(adapter, crb_producer);
  913. wmb();
  914. adapter->total_threads = 0;
  915. }
  916. adapter->stats.xmitfinished++;
  917. spin_unlock_bh(&adapter->tx_lock);
  918. netdev->trans_start = jiffies;
  919. DPRINTK(INFO, "wrote CMD producer %x to phantom\n", producer);
  920. DPRINTK(INFO, "Done. Send\n");
  921. return NETDEV_TX_OK;
  922. }
  923. static void netxen_watchdog(unsigned long v)
  924. {
  925. struct netxen_adapter *adapter = (struct netxen_adapter *)v;
  926. SCHEDULE_WORK(&adapter->watchdog_task);
  927. }
  928. static void netxen_tx_timeout(struct net_device *netdev)
  929. {
  930. struct netxen_adapter *adapter = (struct netxen_adapter *)
  931. netdev_priv(netdev);
  932. SCHEDULE_WORK(&adapter->tx_timeout_task);
  933. }
  934. static void netxen_tx_timeout_task(struct work_struct *work)
  935. {
  936. struct netxen_adapter *adapter =
  937. container_of(work, struct netxen_adapter, tx_timeout_task);
  938. unsigned long flags;
  939. printk(KERN_ERR "%s %s: transmit timeout, resetting.\n",
  940. netxen_nic_driver_name, adapter->netdev->name);
  941. spin_lock_irqsave(&adapter->lock, flags);
  942. netxen_nic_close(adapter->netdev);
  943. netxen_nic_open(adapter->netdev);
  944. spin_unlock_irqrestore(&adapter->lock, flags);
  945. adapter->netdev->trans_start = jiffies;
  946. netif_wake_queue(adapter->netdev);
  947. }
  948. static int
  949. netxen_handle_int(struct netxen_adapter *adapter, struct net_device *netdev)
  950. {
  951. u32 ret = 0;
  952. DPRINTK(INFO, "Entered handle ISR\n");
  953. adapter->stats.ints++;
  954. if (!(adapter->flags & NETXEN_NIC_MSI_ENABLED)) {
  955. int count = 0;
  956. u32 mask;
  957. u32 our_int = 0;
  958. our_int = readl(NETXEN_CRB_NORMALIZE(adapter, CRB_INT_VECTOR));
  959. /* not our interrupt */
  960. if ((our_int & (0x80 << adapter->portnum)) == 0)
  961. return ret;
  962. netxen_nic_disable_int(adapter);
  963. /* Window = 0 or 1 */
  964. do {
  965. writel(0xffffffff, PCI_OFFSET_SECOND_RANGE(adapter,
  966. ISR_INT_TARGET_STATUS));
  967. mask = readl(pci_base_offset(adapter, ISR_INT_VECTOR));
  968. } while (((mask & 0x80) != 0) && (++count < 32));
  969. if ((mask & 0x80) != 0)
  970. printk("Could not disable interrupt completely\n");
  971. }
  972. if (netxen_nic_rx_has_work(adapter) || netxen_nic_tx_has_work(adapter)) {
  973. if (netif_rx_schedule_prep(netdev)) {
  974. /*
  975. * Interrupts are already disabled.
  976. */
  977. __netif_rx_schedule(netdev);
  978. } else {
  979. static unsigned int intcount = 0;
  980. if ((++intcount & 0xfff) == 0xfff)
  981. printk(KERN_ERR
  982. "%s: %s interrupt %d while in poll\n",
  983. netxen_nic_driver_name, netdev->name,
  984. intcount);
  985. }
  986. ret = 1;
  987. }
  988. if (ret == 0) {
  989. netxen_nic_enable_int(adapter);
  990. }
  991. return ret;
  992. }
  993. /*
  994. * netxen_intr - Interrupt Handler
  995. * @irq: interrupt number
  996. * data points to adapter stucture (which may be handling more than 1 port
  997. */
  998. irqreturn_t netxen_intr(int irq, void *data)
  999. {
  1000. struct netxen_adapter *adapter;
  1001. struct net_device *netdev;
  1002. if (unlikely(!irq)) {
  1003. return IRQ_NONE; /* Not our interrupt */
  1004. }
  1005. adapter = (struct netxen_adapter *)data;
  1006. netdev = adapter->netdev;
  1007. /* process our status queue (for all 4 ports) */
  1008. if (netif_running(netdev))
  1009. netxen_handle_int(adapter, netdev);
  1010. return IRQ_HANDLED;
  1011. }
  1012. static int netxen_nic_poll(struct net_device *netdev, int *budget)
  1013. {
  1014. struct netxen_adapter *adapter = netdev_priv(netdev);
  1015. int work_to_do = min(*budget, netdev->quota);
  1016. int done = 1;
  1017. int ctx;
  1018. int this_work_done;
  1019. int work_done = 0;
  1020. DPRINTK(INFO, "polling for %d descriptors\n", *budget);
  1021. work_done = 0;
  1022. for (ctx = 0; ctx < MAX_RCV_CTX; ++ctx) {
  1023. /*
  1024. * Fairness issue. This will give undue weight to the
  1025. * receive context 0.
  1026. */
  1027. /*
  1028. * To avoid starvation, we give each of our receivers,
  1029. * a fraction of the quota. Sometimes, it might happen that we
  1030. * have enough quota to process every packet, but since all the
  1031. * packets are on one context, it gets only half of the quota,
  1032. * and ends up not processing it.
  1033. */
  1034. this_work_done = netxen_process_rcv_ring(adapter, ctx,
  1035. work_to_do /
  1036. MAX_RCV_CTX);
  1037. work_done += this_work_done;
  1038. }
  1039. netdev->quota -= work_done;
  1040. *budget -= work_done;
  1041. if (work_done >= work_to_do && netxen_nic_rx_has_work(adapter) != 0)
  1042. done = 0;
  1043. if (netxen_process_cmd_ring((unsigned long)adapter) == 0)
  1044. done = 0;
  1045. DPRINTK(INFO, "new work_done: %d work_to_do: %d\n",
  1046. work_done, work_to_do);
  1047. if (done) {
  1048. netif_rx_complete(netdev);
  1049. netxen_nic_enable_int(adapter);
  1050. }
  1051. return !done;
  1052. }
  1053. #ifdef CONFIG_NET_POLL_CONTROLLER
  1054. static void netxen_nic_poll_controller(struct net_device *netdev)
  1055. {
  1056. struct netxen_adapter *adapter = netdev_priv(netdev);
  1057. disable_irq(adapter->irq);
  1058. netxen_intr(adapter->irq, adapter);
  1059. enable_irq(adapter->irq);
  1060. }
  1061. #endif
  1062. static struct pci_driver netxen_driver = {
  1063. .name = netxen_nic_driver_name,
  1064. .id_table = netxen_pci_tbl,
  1065. .probe = netxen_nic_probe,
  1066. .remove = __devexit_p(netxen_nic_remove)
  1067. };
  1068. /* Driver Registration on NetXen card */
  1069. static int __init netxen_init_module(void)
  1070. {
  1071. if ((netxen_workq = create_singlethread_workqueue("netxen")) == 0)
  1072. return -ENOMEM;
  1073. return pci_register_driver(&netxen_driver);
  1074. }
  1075. module_init(netxen_init_module);
  1076. static void __exit netxen_exit_module(void)
  1077. {
  1078. /*
  1079. * Wait for some time to allow the dma to drain, if any.
  1080. */
  1081. pci_unregister_driver(&netxen_driver);
  1082. destroy_workqueue(netxen_workq);
  1083. }
  1084. module_exit(netxen_exit_module);