netxen_nic_main.c 35 KB

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