netxen_nic_main.c 48 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952
  1. /*
  2. * Copyright (C) 2003 - 2009 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 Inc,
  26. * 18922 Forge Drive
  27. * Cupertino, CA 95014-0701
  28. *
  29. */
  30. #include <linux/vmalloc.h>
  31. #include <linux/interrupt.h>
  32. #include "netxen_nic_hw.h"
  33. #include "netxen_nic.h"
  34. #include "netxen_nic_phan_reg.h"
  35. #include <linux/dma-mapping.h>
  36. #include <linux/if_vlan.h>
  37. #include <net/ip.h>
  38. #include <linux/ipv6.h>
  39. #include <linux/inetdevice.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. static int port_mode = NETXEN_PORT_MODE_AUTO_NEG;
  47. /* Default to restricted 1G auto-neg mode */
  48. static int wol_port_mode = 5;
  49. static int use_msi = 1;
  50. static int use_msi_x = 1;
  51. /* Local functions to NetXen NIC driver */
  52. static int __devinit netxen_nic_probe(struct pci_dev *pdev,
  53. const struct pci_device_id *ent);
  54. static void __devexit netxen_nic_remove(struct pci_dev *pdev);
  55. static int netxen_nic_open(struct net_device *netdev);
  56. static int netxen_nic_close(struct net_device *netdev);
  57. static int netxen_nic_xmit_frame(struct sk_buff *, struct net_device *);
  58. static void netxen_tx_timeout(struct net_device *netdev);
  59. static void netxen_tx_timeout_task(struct work_struct *work);
  60. static void netxen_watchdog(unsigned long);
  61. static int netxen_nic_poll(struct napi_struct *napi, int budget);
  62. #ifdef CONFIG_NET_POLL_CONTROLLER
  63. static void netxen_nic_poll_controller(struct net_device *netdev);
  64. #endif
  65. static irqreturn_t netxen_intr(int irq, void *data);
  66. static irqreturn_t netxen_msi_intr(int irq, void *data);
  67. static irqreturn_t netxen_msix_intr(int irq, void *data);
  68. /* PCI Device ID Table */
  69. #define ENTRY(device) \
  70. {PCI_DEVICE(PCI_VENDOR_ID_NETXEN, (device)), \
  71. .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
  72. static struct pci_device_id netxen_pci_tbl[] __devinitdata = {
  73. ENTRY(PCI_DEVICE_ID_NX2031_10GXSR),
  74. ENTRY(PCI_DEVICE_ID_NX2031_10GCX4),
  75. ENTRY(PCI_DEVICE_ID_NX2031_4GCU),
  76. ENTRY(PCI_DEVICE_ID_NX2031_IMEZ),
  77. ENTRY(PCI_DEVICE_ID_NX2031_HMEZ),
  78. ENTRY(PCI_DEVICE_ID_NX2031_XG_MGMT),
  79. ENTRY(PCI_DEVICE_ID_NX2031_XG_MGMT2),
  80. ENTRY(PCI_DEVICE_ID_NX3031),
  81. {0,}
  82. };
  83. MODULE_DEVICE_TABLE(pci, netxen_pci_tbl);
  84. static struct workqueue_struct *netxen_workq;
  85. #define SCHEDULE_WORK(tp) queue_work(netxen_workq, tp)
  86. #define FLUSH_SCHEDULED_WORK() flush_workqueue(netxen_workq)
  87. static void netxen_watchdog(unsigned long);
  88. static uint32_t crb_cmd_producer[4] = {
  89. CRB_CMD_PRODUCER_OFFSET, CRB_CMD_PRODUCER_OFFSET_1,
  90. CRB_CMD_PRODUCER_OFFSET_2, CRB_CMD_PRODUCER_OFFSET_3
  91. };
  92. void
  93. netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
  94. struct nx_host_tx_ring *tx_ring)
  95. {
  96. NXWR32(adapter, tx_ring->crb_cmd_producer, tx_ring->producer);
  97. if (netxen_tx_avail(tx_ring) <= TX_STOP_THRESH) {
  98. netif_stop_queue(adapter->netdev);
  99. smp_mb();
  100. }
  101. }
  102. static uint32_t crb_cmd_consumer[4] = {
  103. CRB_CMD_CONSUMER_OFFSET, CRB_CMD_CONSUMER_OFFSET_1,
  104. CRB_CMD_CONSUMER_OFFSET_2, CRB_CMD_CONSUMER_OFFSET_3
  105. };
  106. static inline void
  107. netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
  108. struct nx_host_tx_ring *tx_ring)
  109. {
  110. NXWR32(adapter, tx_ring->crb_cmd_consumer, tx_ring->sw_consumer);
  111. }
  112. static uint32_t msi_tgt_status[8] = {
  113. ISR_INT_TARGET_STATUS, ISR_INT_TARGET_STATUS_F1,
  114. ISR_INT_TARGET_STATUS_F2, ISR_INT_TARGET_STATUS_F3,
  115. ISR_INT_TARGET_STATUS_F4, ISR_INT_TARGET_STATUS_F5,
  116. ISR_INT_TARGET_STATUS_F6, ISR_INT_TARGET_STATUS_F7
  117. };
  118. static struct netxen_legacy_intr_set legacy_intr[] = NX_LEGACY_INTR_CONFIG;
  119. static inline void netxen_nic_disable_int(struct nx_host_sds_ring *sds_ring)
  120. {
  121. struct netxen_adapter *adapter = sds_ring->adapter;
  122. NXWR32(adapter, sds_ring->crb_intr_mask, 0);
  123. }
  124. static inline void netxen_nic_enable_int(struct nx_host_sds_ring *sds_ring)
  125. {
  126. struct netxen_adapter *adapter = sds_ring->adapter;
  127. NXWR32(adapter, sds_ring->crb_intr_mask, 0x1);
  128. if (!NETXEN_IS_MSI_FAMILY(adapter))
  129. adapter->pci_write_immediate(adapter,
  130. adapter->legacy_intr.tgt_mask_reg, 0xfbff);
  131. }
  132. static int
  133. netxen_alloc_sds_rings(struct netxen_recv_context *recv_ctx, int count)
  134. {
  135. int size = sizeof(struct nx_host_sds_ring) * count;
  136. recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);
  137. return (recv_ctx->sds_rings == NULL);
  138. }
  139. static void
  140. netxen_free_sds_rings(struct netxen_recv_context *recv_ctx)
  141. {
  142. if (recv_ctx->sds_rings != NULL)
  143. kfree(recv_ctx->sds_rings);
  144. }
  145. static int
  146. netxen_napi_add(struct netxen_adapter *adapter, struct net_device *netdev)
  147. {
  148. int ring;
  149. struct nx_host_sds_ring *sds_ring;
  150. struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
  151. if (netxen_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
  152. return 1;
  153. for (ring = 0; ring < adapter->max_sds_rings; ring++) {
  154. sds_ring = &recv_ctx->sds_rings[ring];
  155. netif_napi_add(netdev, &sds_ring->napi,
  156. netxen_nic_poll, NETXEN_NETDEV_WEIGHT);
  157. }
  158. return 0;
  159. }
  160. static void
  161. netxen_napi_enable(struct netxen_adapter *adapter)
  162. {
  163. int ring;
  164. struct nx_host_sds_ring *sds_ring;
  165. struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
  166. for (ring = 0; ring < adapter->max_sds_rings; ring++) {
  167. sds_ring = &recv_ctx->sds_rings[ring];
  168. napi_enable(&sds_ring->napi);
  169. netxen_nic_enable_int(sds_ring);
  170. }
  171. }
  172. static void
  173. netxen_napi_disable(struct netxen_adapter *adapter)
  174. {
  175. int ring;
  176. struct nx_host_sds_ring *sds_ring;
  177. struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
  178. for (ring = 0; ring < adapter->max_sds_rings; ring++) {
  179. sds_ring = &recv_ctx->sds_rings[ring];
  180. netxen_nic_disable_int(sds_ring);
  181. napi_synchronize(&sds_ring->napi);
  182. napi_disable(&sds_ring->napi);
  183. }
  184. }
  185. static int nx_set_dma_mask(struct netxen_adapter *adapter, uint8_t revision_id)
  186. {
  187. struct pci_dev *pdev = adapter->pdev;
  188. uint64_t mask, cmask;
  189. adapter->pci_using_dac = 0;
  190. mask = DMA_BIT_MASK(32);
  191. /*
  192. * Consistent DMA mask is set to 32 bit because it cannot be set to
  193. * 35 bits. For P3 also leave it at 32 bits for now. Only the rings
  194. * come off this pool.
  195. */
  196. cmask = DMA_BIT_MASK(32);
  197. #ifndef CONFIG_IA64
  198. if (revision_id >= NX_P3_B0)
  199. mask = DMA_BIT_MASK(39);
  200. else if (revision_id == NX_P2_C1)
  201. mask = DMA_BIT_MASK(35);
  202. #endif
  203. if (pci_set_dma_mask(pdev, mask) == 0 &&
  204. pci_set_consistent_dma_mask(pdev, cmask) == 0) {
  205. adapter->pci_using_dac = 1;
  206. return 0;
  207. }
  208. return -EIO;
  209. }
  210. /* Update addressable range if firmware supports it */
  211. static int
  212. nx_update_dma_mask(struct netxen_adapter *adapter)
  213. {
  214. int change, shift, err;
  215. uint64_t mask, old_mask;
  216. struct pci_dev *pdev = adapter->pdev;
  217. change = 0;
  218. shift = NXRD32(adapter, CRB_DMA_SHIFT);
  219. if (shift >= 32)
  220. return 0;
  221. if (NX_IS_REVISION_P3(adapter->ahw.revision_id) && (shift > 9))
  222. change = 1;
  223. else if ((adapter->ahw.revision_id == NX_P2_C1) && (shift <= 4))
  224. change = 1;
  225. if (change) {
  226. old_mask = pdev->dma_mask;
  227. mask = (1ULL<<(32+shift)) - 1;
  228. err = pci_set_dma_mask(pdev, mask);
  229. if (err)
  230. return pci_set_dma_mask(pdev, old_mask);
  231. }
  232. return 0;
  233. }
  234. static void netxen_check_options(struct netxen_adapter *adapter)
  235. {
  236. if (adapter->ahw.port_type == NETXEN_NIC_XGBE)
  237. adapter->num_rxd = MAX_RCV_DESCRIPTORS_10G;
  238. else if (adapter->ahw.port_type == NETXEN_NIC_GBE)
  239. adapter->num_rxd = MAX_RCV_DESCRIPTORS_1G;
  240. adapter->msix_supported = 0;
  241. if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
  242. adapter->msix_supported = !!use_msi_x;
  243. adapter->rss_supported = !!use_msi_x;
  244. } else if (adapter->fw_version >= NETXEN_VERSION_CODE(3, 4, 336)) {
  245. switch (adapter->ahw.board_type) {
  246. case NETXEN_BRDTYPE_P2_SB31_10G:
  247. case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
  248. adapter->msix_supported = !!use_msi_x;
  249. adapter->rss_supported = !!use_msi_x;
  250. break;
  251. default:
  252. break;
  253. }
  254. }
  255. adapter->num_txd = MAX_CMD_DESCRIPTORS_HOST;
  256. adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS;
  257. adapter->num_lro_rxd = MAX_LRO_RCV_DESCRIPTORS;
  258. return;
  259. }
  260. static int
  261. netxen_check_hw_init(struct netxen_adapter *adapter, int first_boot)
  262. {
  263. u32 val, timeout;
  264. if (first_boot == 0x55555555) {
  265. /* This is the first boot after power up */
  266. NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
  267. if (!NX_IS_REVISION_P2(adapter->ahw.revision_id))
  268. return 0;
  269. /* PCI bus master workaround */
  270. first_boot = NXRD32(adapter, NETXEN_PCIE_REG(0x4));
  271. if (!(first_boot & 0x4)) {
  272. first_boot |= 0x4;
  273. NXWR32(adapter, NETXEN_PCIE_REG(0x4), first_boot);
  274. first_boot = NXRD32(adapter, NETXEN_PCIE_REG(0x4));
  275. }
  276. /* This is the first boot after power up */
  277. first_boot = NXRD32(adapter, NETXEN_ROMUSB_GLB_SW_RESET);
  278. if (first_boot != 0x80000f) {
  279. /* clear the register for future unloads/loads */
  280. NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), 0);
  281. return -EIO;
  282. }
  283. /* Start P2 boot loader */
  284. val = NXRD32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE);
  285. NXWR32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE, val | 0x1);
  286. timeout = 0;
  287. do {
  288. msleep(1);
  289. val = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
  290. if (++timeout > 5000)
  291. return -EIO;
  292. } while (val == NETXEN_BDINFO_MAGIC);
  293. }
  294. return 0;
  295. }
  296. static void netxen_set_port_mode(struct netxen_adapter *adapter)
  297. {
  298. u32 val, data;
  299. val = adapter->ahw.board_type;
  300. if ((val == NETXEN_BRDTYPE_P3_HMEZ) ||
  301. (val == NETXEN_BRDTYPE_P3_XG_LOM)) {
  302. if (port_mode == NETXEN_PORT_MODE_802_3_AP) {
  303. data = NETXEN_PORT_MODE_802_3_AP;
  304. NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
  305. } else if (port_mode == NETXEN_PORT_MODE_XG) {
  306. data = NETXEN_PORT_MODE_XG;
  307. NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
  308. } else if (port_mode == NETXEN_PORT_MODE_AUTO_NEG_1G) {
  309. data = NETXEN_PORT_MODE_AUTO_NEG_1G;
  310. NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
  311. } else if (port_mode == NETXEN_PORT_MODE_AUTO_NEG_XG) {
  312. data = NETXEN_PORT_MODE_AUTO_NEG_XG;
  313. NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
  314. } else {
  315. data = NETXEN_PORT_MODE_AUTO_NEG;
  316. NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
  317. }
  318. if ((wol_port_mode != NETXEN_PORT_MODE_802_3_AP) &&
  319. (wol_port_mode != NETXEN_PORT_MODE_XG) &&
  320. (wol_port_mode != NETXEN_PORT_MODE_AUTO_NEG_1G) &&
  321. (wol_port_mode != NETXEN_PORT_MODE_AUTO_NEG_XG)) {
  322. wol_port_mode = NETXEN_PORT_MODE_AUTO_NEG;
  323. }
  324. NXWR32(adapter, NETXEN_WOL_PORT_MODE, wol_port_mode);
  325. }
  326. }
  327. static void netxen_set_msix_bit(struct pci_dev *pdev, int enable)
  328. {
  329. u32 control;
  330. int pos;
  331. pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
  332. if (pos) {
  333. pci_read_config_dword(pdev, pos, &control);
  334. if (enable)
  335. control |= PCI_MSIX_FLAGS_ENABLE;
  336. else
  337. control = 0;
  338. pci_write_config_dword(pdev, pos, control);
  339. }
  340. }
  341. static void netxen_init_msix_entries(struct netxen_adapter *adapter, int count)
  342. {
  343. int i;
  344. for (i = 0; i < count; i++)
  345. adapter->msix_entries[i].entry = i;
  346. }
  347. static int
  348. netxen_read_mac_addr(struct netxen_adapter *adapter)
  349. {
  350. int i;
  351. unsigned char *p;
  352. __le64 mac_addr;
  353. struct net_device *netdev = adapter->netdev;
  354. struct pci_dev *pdev = adapter->pdev;
  355. if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
  356. if (netxen_p3_get_mac_addr(adapter, &mac_addr) != 0)
  357. return -EIO;
  358. } else {
  359. if (netxen_get_flash_mac_addr(adapter, &mac_addr) != 0)
  360. return -EIO;
  361. }
  362. p = (unsigned char *)&mac_addr;
  363. for (i = 0; i < 6; i++)
  364. netdev->dev_addr[i] = *(p + 5 - i);
  365. memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len);
  366. /* set station address */
  367. if (!is_valid_ether_addr(netdev->perm_addr))
  368. dev_warn(&pdev->dev, "Bad MAC address %pM.\n", netdev->dev_addr);
  369. return 0;
  370. }
  371. int netxen_nic_set_mac(struct net_device *netdev, void *p)
  372. {
  373. struct netxen_adapter *adapter = netdev_priv(netdev);
  374. struct sockaddr *addr = p;
  375. if (!is_valid_ether_addr(addr->sa_data))
  376. return -EINVAL;
  377. if (netif_running(netdev)) {
  378. netif_device_detach(netdev);
  379. netxen_napi_disable(adapter);
  380. }
  381. memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
  382. adapter->macaddr_set(adapter, addr->sa_data);
  383. if (netif_running(netdev)) {
  384. netif_device_attach(netdev);
  385. netxen_napi_enable(adapter);
  386. }
  387. return 0;
  388. }
  389. static void netxen_set_multicast_list(struct net_device *dev)
  390. {
  391. struct netxen_adapter *adapter = netdev_priv(dev);
  392. adapter->set_multi(dev);
  393. }
  394. static const struct net_device_ops netxen_netdev_ops = {
  395. .ndo_open = netxen_nic_open,
  396. .ndo_stop = netxen_nic_close,
  397. .ndo_start_xmit = netxen_nic_xmit_frame,
  398. .ndo_get_stats = netxen_nic_get_stats,
  399. .ndo_validate_addr = eth_validate_addr,
  400. .ndo_set_multicast_list = netxen_set_multicast_list,
  401. .ndo_set_mac_address = netxen_nic_set_mac,
  402. .ndo_change_mtu = netxen_nic_change_mtu,
  403. .ndo_tx_timeout = netxen_tx_timeout,
  404. #ifdef CONFIG_NET_POLL_CONTROLLER
  405. .ndo_poll_controller = netxen_nic_poll_controller,
  406. #endif
  407. };
  408. static void
  409. netxen_setup_intr(struct netxen_adapter *adapter)
  410. {
  411. struct netxen_legacy_intr_set *legacy_intrp;
  412. struct pci_dev *pdev = adapter->pdev;
  413. int err, num_msix;
  414. if (adapter->rss_supported) {
  415. num_msix = (num_online_cpus() >= MSIX_ENTRIES_PER_ADAPTER) ?
  416. MSIX_ENTRIES_PER_ADAPTER : 2;
  417. } else
  418. num_msix = 1;
  419. adapter->max_sds_rings = 1;
  420. adapter->flags &= ~(NETXEN_NIC_MSI_ENABLED | NETXEN_NIC_MSIX_ENABLED);
  421. if (adapter->ahw.revision_id >= NX_P3_B0)
  422. legacy_intrp = &legacy_intr[adapter->ahw.pci_func];
  423. else
  424. legacy_intrp = &legacy_intr[0];
  425. adapter->legacy_intr.int_vec_bit = legacy_intrp->int_vec_bit;
  426. adapter->legacy_intr.tgt_status_reg = legacy_intrp->tgt_status_reg;
  427. adapter->legacy_intr.tgt_mask_reg = legacy_intrp->tgt_mask_reg;
  428. adapter->legacy_intr.pci_int_reg = legacy_intrp->pci_int_reg;
  429. netxen_set_msix_bit(pdev, 0);
  430. if (adapter->msix_supported) {
  431. netxen_init_msix_entries(adapter, num_msix);
  432. err = pci_enable_msix(pdev, adapter->msix_entries, num_msix);
  433. if (err == 0) {
  434. adapter->flags |= NETXEN_NIC_MSIX_ENABLED;
  435. netxen_set_msix_bit(pdev, 1);
  436. if (adapter->rss_supported)
  437. adapter->max_sds_rings = num_msix;
  438. dev_info(&pdev->dev, "using msi-x interrupts\n");
  439. return;
  440. }
  441. if (err > 0)
  442. pci_disable_msix(pdev);
  443. /* fall through for msi */
  444. }
  445. if (use_msi && !pci_enable_msi(pdev)) {
  446. adapter->flags |= NETXEN_NIC_MSI_ENABLED;
  447. adapter->msi_tgt_status =
  448. msi_tgt_status[adapter->ahw.pci_func];
  449. dev_info(&pdev->dev, "using msi interrupts\n");
  450. adapter->msix_entries[0].vector = pdev->irq;
  451. return;
  452. }
  453. dev_info(&pdev->dev, "using legacy interrupts\n");
  454. adapter->msix_entries[0].vector = pdev->irq;
  455. }
  456. static void
  457. netxen_teardown_intr(struct netxen_adapter *adapter)
  458. {
  459. if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
  460. pci_disable_msix(adapter->pdev);
  461. if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
  462. pci_disable_msi(adapter->pdev);
  463. }
  464. static void
  465. netxen_cleanup_pci_map(struct netxen_adapter *adapter)
  466. {
  467. if (adapter->ahw.db_base != NULL)
  468. iounmap(adapter->ahw.db_base);
  469. if (adapter->ahw.pci_base0 != NULL)
  470. iounmap(adapter->ahw.pci_base0);
  471. if (adapter->ahw.pci_base1 != NULL)
  472. iounmap(adapter->ahw.pci_base1);
  473. if (adapter->ahw.pci_base2 != NULL)
  474. iounmap(adapter->ahw.pci_base2);
  475. }
  476. static int
  477. netxen_setup_pci_map(struct netxen_adapter *adapter)
  478. {
  479. void __iomem *mem_ptr0 = NULL;
  480. void __iomem *mem_ptr1 = NULL;
  481. void __iomem *mem_ptr2 = NULL;
  482. void __iomem *db_ptr = NULL;
  483. unsigned long mem_base, mem_len, db_base, db_len = 0, pci_len0 = 0;
  484. struct pci_dev *pdev = adapter->pdev;
  485. int pci_func = adapter->ahw.pci_func;
  486. int err = 0;
  487. /*
  488. * Set the CRB window to invalid. If any register in window 0 is
  489. * accessed it should set the window to 0 and then reset it to 1.
  490. */
  491. adapter->curr_window = 255;
  492. adapter->ahw.qdr_sn_window = -1;
  493. adapter->ahw.ddr_mn_window = -1;
  494. /* remap phys address */
  495. mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
  496. mem_len = pci_resource_len(pdev, 0);
  497. pci_len0 = 0;
  498. adapter->hw_write_wx = netxen_nic_hw_write_wx_128M;
  499. adapter->hw_read_wx = netxen_nic_hw_read_wx_128M;
  500. adapter->pci_read_immediate = netxen_nic_pci_read_immediate_128M;
  501. adapter->pci_write_immediate = netxen_nic_pci_write_immediate_128M;
  502. adapter->pci_set_window = netxen_nic_pci_set_window_128M;
  503. adapter->pci_mem_read = netxen_nic_pci_mem_read_128M;
  504. adapter->pci_mem_write = netxen_nic_pci_mem_write_128M;
  505. /* 128 Meg of memory */
  506. if (mem_len == NETXEN_PCI_128MB_SIZE) {
  507. mem_ptr0 = ioremap(mem_base, FIRST_PAGE_GROUP_SIZE);
  508. mem_ptr1 = ioremap(mem_base + SECOND_PAGE_GROUP_START,
  509. SECOND_PAGE_GROUP_SIZE);
  510. mem_ptr2 = ioremap(mem_base + THIRD_PAGE_GROUP_START,
  511. THIRD_PAGE_GROUP_SIZE);
  512. } else if (mem_len == NETXEN_PCI_32MB_SIZE) {
  513. mem_ptr1 = ioremap(mem_base, SECOND_PAGE_GROUP_SIZE);
  514. mem_ptr2 = ioremap(mem_base + THIRD_PAGE_GROUP_START -
  515. SECOND_PAGE_GROUP_START, THIRD_PAGE_GROUP_SIZE);
  516. } else if (mem_len == NETXEN_PCI_2MB_SIZE) {
  517. adapter->hw_write_wx = netxen_nic_hw_write_wx_2M;
  518. adapter->hw_read_wx = netxen_nic_hw_read_wx_2M;
  519. adapter->pci_read_immediate = netxen_nic_pci_read_immediate_2M;
  520. adapter->pci_write_immediate =
  521. netxen_nic_pci_write_immediate_2M;
  522. adapter->pci_set_window = netxen_nic_pci_set_window_2M;
  523. adapter->pci_mem_read = netxen_nic_pci_mem_read_2M;
  524. adapter->pci_mem_write = netxen_nic_pci_mem_write_2M;
  525. mem_ptr0 = pci_ioremap_bar(pdev, 0);
  526. if (mem_ptr0 == NULL) {
  527. dev_err(&pdev->dev, "failed to map PCI bar 0\n");
  528. return -EIO;
  529. }
  530. pci_len0 = mem_len;
  531. adapter->ahw.ddr_mn_window = 0;
  532. adapter->ahw.qdr_sn_window = 0;
  533. adapter->ahw.mn_win_crb = 0x100000 + PCIX_MN_WINDOW +
  534. (pci_func * 0x20);
  535. adapter->ahw.ms_win_crb = 0x100000 + PCIX_SN_WINDOW;
  536. if (pci_func < 4)
  537. adapter->ahw.ms_win_crb += (pci_func * 0x20);
  538. else
  539. adapter->ahw.ms_win_crb +=
  540. 0xA0 + ((pci_func - 4) * 0x10);
  541. } else {
  542. return -EIO;
  543. }
  544. dev_info(&pdev->dev, "%dMB memory map\n", (int)(mem_len>>20));
  545. adapter->ahw.pci_base0 = mem_ptr0;
  546. adapter->ahw.pci_len0 = pci_len0;
  547. adapter->ahw.pci_base1 = mem_ptr1;
  548. adapter->ahw.pci_base2 = mem_ptr2;
  549. if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
  550. goto skip_doorbell;
  551. db_base = pci_resource_start(pdev, 4); /* doorbell is on bar 4 */
  552. db_len = pci_resource_len(pdev, 4);
  553. if (db_len == 0) {
  554. printk(KERN_ERR "%s: doorbell is disabled\n",
  555. netxen_nic_driver_name);
  556. err = -EIO;
  557. goto err_out;
  558. }
  559. db_ptr = ioremap(db_base, NETXEN_DB_MAPSIZE_BYTES);
  560. if (!db_ptr) {
  561. printk(KERN_ERR "%s: Failed to allocate doorbell map.",
  562. netxen_nic_driver_name);
  563. err = -EIO;
  564. goto err_out;
  565. }
  566. skip_doorbell:
  567. adapter->ahw.db_base = db_ptr;
  568. adapter->ahw.db_len = db_len;
  569. return 0;
  570. err_out:
  571. netxen_cleanup_pci_map(adapter);
  572. return err;
  573. }
  574. static int
  575. netxen_start_firmware(struct netxen_adapter *adapter, int request_fw)
  576. {
  577. int val, err, first_boot;
  578. struct pci_dev *pdev = adapter->pdev;
  579. int first_driver = 0;
  580. if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
  581. first_driver = (adapter->portnum == 0);
  582. else
  583. first_driver = (adapter->ahw.pci_func == 0);
  584. if (!first_driver)
  585. goto wait_init;
  586. first_boot = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
  587. err = netxen_check_hw_init(adapter, first_boot);
  588. if (err) {
  589. dev_err(&pdev->dev, "error in init HW init sequence\n");
  590. return err;
  591. }
  592. if (request_fw)
  593. netxen_request_firmware(adapter);
  594. err = netxen_need_fw_reset(adapter);
  595. if (err <= 0)
  596. return err;
  597. if (first_boot != 0x55555555) {
  598. NXWR32(adapter, CRB_CMDPEG_STATE, 0);
  599. netxen_pinit_from_rom(adapter, 0);
  600. msleep(1);
  601. }
  602. NXWR32(adapter, CRB_DMA_SHIFT, 0x55555555);
  603. if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
  604. netxen_set_port_mode(adapter);
  605. netxen_load_firmware(adapter);
  606. if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
  607. /* Initialize multicast addr pool owners */
  608. val = 0x7654;
  609. if (adapter->ahw.port_type == NETXEN_NIC_XGBE)
  610. val |= 0x0f000000;
  611. NXWR32(adapter, NETXEN_MAC_ADDR_CNTL_REG, val);
  612. }
  613. err = netxen_init_dummy_dma(adapter);
  614. if (err)
  615. return err;
  616. /*
  617. * Tell the hardware our version number.
  618. */
  619. val = (_NETXEN_NIC_LINUX_MAJOR << 16)
  620. | ((_NETXEN_NIC_LINUX_MINOR << 8))
  621. | (_NETXEN_NIC_LINUX_SUBVERSION);
  622. NXWR32(adapter, CRB_DRIVER_VERSION, val);
  623. wait_init:
  624. /* Handshake with the card before we register the devices. */
  625. err = netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
  626. if (err) {
  627. netxen_free_dummy_dma(adapter);
  628. return err;
  629. }
  630. nx_update_dma_mask(adapter);
  631. netxen_nic_get_firmware_info(adapter);
  632. return 0;
  633. }
  634. static int
  635. netxen_nic_request_irq(struct netxen_adapter *adapter)
  636. {
  637. irq_handler_t handler;
  638. struct nx_host_sds_ring *sds_ring;
  639. int err, ring;
  640. unsigned long flags = IRQF_SAMPLE_RANDOM;
  641. struct net_device *netdev = adapter->netdev;
  642. struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
  643. if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
  644. handler = netxen_msix_intr;
  645. else if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
  646. handler = netxen_msi_intr;
  647. else {
  648. flags |= IRQF_SHARED;
  649. handler = netxen_intr;
  650. }
  651. adapter->irq = netdev->irq;
  652. for (ring = 0; ring < adapter->max_sds_rings; ring++) {
  653. sds_ring = &recv_ctx->sds_rings[ring];
  654. sprintf(sds_ring->name, "%s[%d]", netdev->name, ring);
  655. err = request_irq(sds_ring->irq, handler,
  656. flags, sds_ring->name, sds_ring);
  657. if (err)
  658. return err;
  659. }
  660. return 0;
  661. }
  662. static void
  663. netxen_nic_free_irq(struct netxen_adapter *adapter)
  664. {
  665. int ring;
  666. struct nx_host_sds_ring *sds_ring;
  667. struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
  668. for (ring = 0; ring < adapter->max_sds_rings; ring++) {
  669. sds_ring = &recv_ctx->sds_rings[ring];
  670. free_irq(sds_ring->irq, sds_ring);
  671. }
  672. }
  673. static void
  674. netxen_nic_init_coalesce_defaults(struct netxen_adapter *adapter)
  675. {
  676. adapter->coal.flags = NETXEN_NIC_INTR_DEFAULT;
  677. adapter->coal.normal.data.rx_time_us =
  678. NETXEN_DEFAULT_INTR_COALESCE_RX_TIME_US;
  679. adapter->coal.normal.data.rx_packets =
  680. NETXEN_DEFAULT_INTR_COALESCE_RX_PACKETS;
  681. adapter->coal.normal.data.tx_time_us =
  682. NETXEN_DEFAULT_INTR_COALESCE_TX_TIME_US;
  683. adapter->coal.normal.data.tx_packets =
  684. NETXEN_DEFAULT_INTR_COALESCE_TX_PACKETS;
  685. }
  686. static int
  687. netxen_nic_up(struct netxen_adapter *adapter, struct net_device *netdev)
  688. {
  689. int err;
  690. err = adapter->init_port(adapter, adapter->physical_port);
  691. if (err) {
  692. printk(KERN_ERR "%s: Failed to initialize port %d\n",
  693. netxen_nic_driver_name, adapter->portnum);
  694. return err;
  695. }
  696. if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
  697. adapter->macaddr_set(adapter, netdev->dev_addr);
  698. adapter->set_multi(netdev);
  699. adapter->set_mtu(adapter, netdev->mtu);
  700. adapter->ahw.linkup = 0;
  701. if (adapter->max_sds_rings > 1)
  702. netxen_config_rss(adapter, 1);
  703. if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
  704. netxen_config_intr_coalesce(adapter);
  705. netxen_napi_enable(adapter);
  706. if (adapter->capabilities & NX_FW_CAPABILITY_LINK_NOTIFICATION)
  707. netxen_linkevent_request(adapter, 1);
  708. else
  709. netxen_nic_set_link_parameters(adapter);
  710. mod_timer(&adapter->watchdog_timer, jiffies);
  711. return 0;
  712. }
  713. static void
  714. netxen_nic_down(struct netxen_adapter *adapter, struct net_device *netdev)
  715. {
  716. spin_lock(&adapter->tx_clean_lock);
  717. netif_carrier_off(netdev);
  718. netif_tx_disable(netdev);
  719. if (adapter->stop_port)
  720. adapter->stop_port(adapter);
  721. if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
  722. netxen_p3_free_mac_list(adapter);
  723. netxen_napi_disable(adapter);
  724. netxen_release_tx_buffers(adapter);
  725. spin_unlock(&adapter->tx_clean_lock);
  726. del_timer_sync(&adapter->watchdog_timer);
  727. FLUSH_SCHEDULED_WORK();
  728. }
  729. static int
  730. netxen_nic_attach(struct netxen_adapter *adapter)
  731. {
  732. struct net_device *netdev = adapter->netdev;
  733. struct pci_dev *pdev = adapter->pdev;
  734. int err, ring;
  735. struct nx_host_rds_ring *rds_ring;
  736. struct nx_host_tx_ring *tx_ring;
  737. err = netxen_init_firmware(adapter);
  738. if (err != 0) {
  739. printk(KERN_ERR "Failed to init firmware\n");
  740. return -EIO;
  741. }
  742. if (adapter->fw_major < 4)
  743. adapter->max_rds_rings = 3;
  744. else
  745. adapter->max_rds_rings = 2;
  746. err = netxen_alloc_sw_resources(adapter);
  747. if (err) {
  748. printk(KERN_ERR "%s: Error in setting sw resources\n",
  749. netdev->name);
  750. return err;
  751. }
  752. netxen_nic_clear_stats(adapter);
  753. err = netxen_alloc_hw_resources(adapter);
  754. if (err) {
  755. printk(KERN_ERR "%s: Error in setting hw resources\n",
  756. netdev->name);
  757. goto err_out_free_sw;
  758. }
  759. if (adapter->fw_major < 4) {
  760. tx_ring = adapter->tx_ring;
  761. tx_ring->crb_cmd_producer = crb_cmd_producer[adapter->portnum];
  762. tx_ring->crb_cmd_consumer = crb_cmd_consumer[adapter->portnum];
  763. tx_ring->producer = 0;
  764. tx_ring->sw_consumer = 0;
  765. netxen_nic_update_cmd_producer(adapter, tx_ring);
  766. netxen_nic_update_cmd_consumer(adapter, tx_ring);
  767. }
  768. for (ring = 0; ring < adapter->max_rds_rings; ring++) {
  769. rds_ring = &adapter->recv_ctx.rds_rings[ring];
  770. netxen_post_rx_buffers(adapter, ring, rds_ring);
  771. }
  772. err = netxen_nic_request_irq(adapter);
  773. if (err) {
  774. dev_err(&pdev->dev, "%s: failed to setup interrupt\n",
  775. netdev->name);
  776. goto err_out_free_rxbuf;
  777. }
  778. if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
  779. netxen_nic_init_coalesce_defaults(adapter);
  780. adapter->is_up = NETXEN_ADAPTER_UP_MAGIC;
  781. return 0;
  782. err_out_free_rxbuf:
  783. netxen_release_rx_buffers(adapter);
  784. netxen_free_hw_resources(adapter);
  785. err_out_free_sw:
  786. netxen_free_sw_resources(adapter);
  787. return err;
  788. }
  789. static void
  790. netxen_nic_detach(struct netxen_adapter *adapter)
  791. {
  792. netxen_free_hw_resources(adapter);
  793. netxen_release_rx_buffers(adapter);
  794. netxen_nic_free_irq(adapter);
  795. netxen_free_sw_resources(adapter);
  796. adapter->is_up = 0;
  797. }
  798. static int __devinit
  799. netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
  800. {
  801. struct net_device *netdev = NULL;
  802. struct netxen_adapter *adapter = NULL;
  803. int i = 0, err;
  804. int pci_func_id = PCI_FUNC(pdev->devfn);
  805. uint8_t revision_id;
  806. if (pdev->class != 0x020000) {
  807. printk(KERN_DEBUG "NetXen function %d, class %x will not "
  808. "be enabled.\n",pci_func_id, pdev->class);
  809. return -ENODEV;
  810. }
  811. if (pdev->revision >= NX_P3_A0 && pdev->revision < NX_P3_B1) {
  812. printk(KERN_WARNING "NetXen chip revisions between 0x%x-0x%x"
  813. "will not be enabled.\n",
  814. NX_P3_A0, NX_P3_B1);
  815. return -ENODEV;
  816. }
  817. if ((err = pci_enable_device(pdev)))
  818. return err;
  819. if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
  820. err = -ENODEV;
  821. goto err_out_disable_pdev;
  822. }
  823. if ((err = pci_request_regions(pdev, netxen_nic_driver_name)))
  824. goto err_out_disable_pdev;
  825. pci_set_master(pdev);
  826. netdev = alloc_etherdev(sizeof(struct netxen_adapter));
  827. if(!netdev) {
  828. printk(KERN_ERR"%s: Failed to allocate memory for the "
  829. "device block.Check system memory resource"
  830. " usage.\n", netxen_nic_driver_name);
  831. goto err_out_free_res;
  832. }
  833. SET_NETDEV_DEV(netdev, &pdev->dev);
  834. adapter = netdev_priv(netdev);
  835. adapter->netdev = netdev;
  836. adapter->pdev = pdev;
  837. adapter->ahw.pci_func = pci_func_id;
  838. revision_id = pdev->revision;
  839. adapter->ahw.revision_id = revision_id;
  840. err = nx_set_dma_mask(adapter, revision_id);
  841. if (err)
  842. goto err_out_free_netdev;
  843. rwlock_init(&adapter->adapter_lock);
  844. spin_lock_init(&adapter->tx_clean_lock);
  845. INIT_LIST_HEAD(&adapter->mac_list);
  846. err = netxen_setup_pci_map(adapter);
  847. if (err)
  848. goto err_out_free_netdev;
  849. /* This will be reset for mezz cards */
  850. adapter->portnum = pci_func_id;
  851. adapter->rx_csum = 1;
  852. adapter->mc_enabled = 0;
  853. if (NX_IS_REVISION_P3(revision_id))
  854. adapter->max_mc_count = 38;
  855. else
  856. adapter->max_mc_count = 16;
  857. netdev->netdev_ops = &netxen_netdev_ops;
  858. netdev->watchdog_timeo = 2*HZ;
  859. netxen_nic_change_mtu(netdev, netdev->mtu);
  860. SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
  861. netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
  862. netdev->features |= (NETIF_F_GRO);
  863. netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
  864. if (NX_IS_REVISION_P3(revision_id)) {
  865. netdev->features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
  866. netdev->vlan_features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
  867. }
  868. if (adapter->pci_using_dac) {
  869. netdev->features |= NETIF_F_HIGHDMA;
  870. netdev->vlan_features |= NETIF_F_HIGHDMA;
  871. }
  872. if (netxen_nic_get_board_info(adapter) != 0) {
  873. printk("%s: Error getting board config info.\n",
  874. netxen_nic_driver_name);
  875. err = -EIO;
  876. goto err_out_iounmap;
  877. }
  878. netxen_initialize_adapter_ops(adapter);
  879. /* Mezz cards have PCI function 0,2,3 enabled */
  880. switch (adapter->ahw.board_type) {
  881. case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ:
  882. case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ:
  883. if (pci_func_id >= 2)
  884. adapter->portnum = pci_func_id - 2;
  885. break;
  886. default:
  887. break;
  888. }
  889. err = netxen_start_firmware(adapter, 1);
  890. if (err)
  891. goto err_out_iounmap;
  892. /*
  893. * See if the firmware gave us a virtual-physical port mapping.
  894. */
  895. adapter->physical_port = adapter->portnum;
  896. if (adapter->fw_major < 4) {
  897. i = NXRD32(adapter, CRB_V2P(adapter->portnum));
  898. if (i != 0x55555555)
  899. adapter->physical_port = i;
  900. }
  901. netxen_check_options(adapter);
  902. netxen_setup_intr(adapter);
  903. netdev->irq = adapter->msix_entries[0].vector;
  904. if (netxen_napi_add(adapter, netdev))
  905. goto err_out_disable_msi;
  906. init_timer(&adapter->watchdog_timer);
  907. adapter->watchdog_timer.function = &netxen_watchdog;
  908. adapter->watchdog_timer.data = (unsigned long)adapter;
  909. INIT_WORK(&adapter->watchdog_task, netxen_watchdog_task);
  910. INIT_WORK(&adapter->tx_timeout_task, netxen_tx_timeout_task);
  911. err = netxen_read_mac_addr(adapter);
  912. if (err)
  913. dev_warn(&pdev->dev, "failed to read mac addr\n");
  914. netif_carrier_off(netdev);
  915. netif_stop_queue(netdev);
  916. if ((err = register_netdev(netdev))) {
  917. printk(KERN_ERR "%s: register_netdev failed port #%d"
  918. " aborting\n", netxen_nic_driver_name,
  919. adapter->portnum);
  920. err = -EIO;
  921. goto err_out_disable_msi;
  922. }
  923. pci_set_drvdata(pdev, adapter);
  924. switch (adapter->ahw.port_type) {
  925. case NETXEN_NIC_GBE:
  926. dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
  927. adapter->netdev->name);
  928. break;
  929. case NETXEN_NIC_XGBE:
  930. dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
  931. adapter->netdev->name);
  932. break;
  933. }
  934. return 0;
  935. err_out_disable_msi:
  936. netxen_teardown_intr(adapter);
  937. netxen_free_dummy_dma(adapter);
  938. err_out_iounmap:
  939. netxen_cleanup_pci_map(adapter);
  940. err_out_free_netdev:
  941. free_netdev(netdev);
  942. err_out_free_res:
  943. pci_release_regions(pdev);
  944. err_out_disable_pdev:
  945. pci_set_drvdata(pdev, NULL);
  946. pci_disable_device(pdev);
  947. return err;
  948. }
  949. static void __devexit netxen_nic_remove(struct pci_dev *pdev)
  950. {
  951. struct netxen_adapter *adapter;
  952. struct net_device *netdev;
  953. adapter = pci_get_drvdata(pdev);
  954. if (adapter == NULL)
  955. return;
  956. netdev = adapter->netdev;
  957. unregister_netdev(netdev);
  958. if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC) {
  959. netxen_nic_detach(adapter);
  960. }
  961. if (adapter->portnum == 0)
  962. netxen_free_dummy_dma(adapter);
  963. netxen_teardown_intr(adapter);
  964. netxen_free_sds_rings(&adapter->recv_ctx);
  965. netxen_cleanup_pci_map(adapter);
  966. netxen_release_firmware(adapter);
  967. pci_release_regions(pdev);
  968. pci_disable_device(pdev);
  969. pci_set_drvdata(pdev, NULL);
  970. free_netdev(netdev);
  971. }
  972. #ifdef CONFIG_PM
  973. static int
  974. netxen_nic_suspend(struct pci_dev *pdev, pm_message_t state)
  975. {
  976. struct netxen_adapter *adapter = pci_get_drvdata(pdev);
  977. struct net_device *netdev = adapter->netdev;
  978. netif_device_detach(netdev);
  979. if (netif_running(netdev))
  980. netxen_nic_down(adapter, netdev);
  981. if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC)
  982. netxen_nic_detach(adapter);
  983. pci_save_state(pdev);
  984. if (netxen_nic_wol_supported(adapter)) {
  985. pci_enable_wake(pdev, PCI_D3cold, 1);
  986. pci_enable_wake(pdev, PCI_D3hot, 1);
  987. }
  988. pci_disable_device(pdev);
  989. pci_set_power_state(pdev, pci_choose_state(pdev, state));
  990. return 0;
  991. }
  992. static int
  993. netxen_nic_resume(struct pci_dev *pdev)
  994. {
  995. struct netxen_adapter *adapter = pci_get_drvdata(pdev);
  996. struct net_device *netdev = adapter->netdev;
  997. int err;
  998. pci_set_power_state(pdev, PCI_D0);
  999. pci_restore_state(pdev);
  1000. err = pci_enable_device(pdev);
  1001. if (err)
  1002. return err;
  1003. adapter->curr_window = 255;
  1004. err = netxen_start_firmware(adapter, 0);
  1005. if (err) {
  1006. dev_err(&pdev->dev, "failed to start firmware\n");
  1007. return err;
  1008. }
  1009. if (netif_running(netdev)) {
  1010. err = netxen_nic_attach(adapter);
  1011. if (err)
  1012. return err;
  1013. err = netxen_nic_up(adapter, netdev);
  1014. if (err)
  1015. return err;
  1016. netif_device_attach(netdev);
  1017. }
  1018. return 0;
  1019. }
  1020. #endif
  1021. static int netxen_nic_open(struct net_device *netdev)
  1022. {
  1023. struct netxen_adapter *adapter = netdev_priv(netdev);
  1024. int err = 0;
  1025. if (adapter->driver_mismatch)
  1026. return -EIO;
  1027. if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC) {
  1028. err = netxen_nic_attach(adapter);
  1029. if (err)
  1030. return err;
  1031. }
  1032. err = netxen_nic_up(adapter, netdev);
  1033. if (err)
  1034. goto err_out;
  1035. netif_start_queue(netdev);
  1036. return 0;
  1037. err_out:
  1038. netxen_nic_detach(adapter);
  1039. return err;
  1040. }
  1041. /*
  1042. * netxen_nic_close - Disables a network interface entry point
  1043. */
  1044. static int netxen_nic_close(struct net_device *netdev)
  1045. {
  1046. struct netxen_adapter *adapter = netdev_priv(netdev);
  1047. netxen_nic_down(adapter, netdev);
  1048. return 0;
  1049. }
  1050. static void
  1051. netxen_tso_check(struct net_device *netdev,
  1052. struct nx_host_tx_ring *tx_ring,
  1053. struct cmd_desc_type0 *first_desc,
  1054. struct sk_buff *skb)
  1055. {
  1056. u8 opcode = TX_ETHER_PKT;
  1057. __be16 protocol = skb->protocol;
  1058. u16 flags = 0;
  1059. u32 producer;
  1060. int copied, offset, copy_len, hdr_len = 0, tso = 0;
  1061. struct cmd_desc_type0 *hwdesc;
  1062. if (protocol == cpu_to_be16(ETH_P_8021Q)) {
  1063. struct vlan_ethhdr *vh = (struct vlan_ethhdr *)skb->data;
  1064. protocol = vh->h_vlan_encapsulated_proto;
  1065. flags = FLAGS_VLAN_TAGGED;
  1066. }
  1067. if ((netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
  1068. skb_shinfo(skb)->gso_size > 0) {
  1069. hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
  1070. first_desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
  1071. first_desc->total_hdr_length = hdr_len;
  1072. opcode = (protocol == cpu_to_be16(ETH_P_IPV6)) ?
  1073. TX_TCP_LSO6 : TX_TCP_LSO;
  1074. tso = 1;
  1075. } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
  1076. u8 l4proto;
  1077. if (protocol == cpu_to_be16(ETH_P_IP)) {
  1078. l4proto = ip_hdr(skb)->protocol;
  1079. if (l4proto == IPPROTO_TCP)
  1080. opcode = TX_TCP_PKT;
  1081. else if(l4proto == IPPROTO_UDP)
  1082. opcode = TX_UDP_PKT;
  1083. } else if (protocol == cpu_to_be16(ETH_P_IPV6)) {
  1084. l4proto = ipv6_hdr(skb)->nexthdr;
  1085. if (l4proto == IPPROTO_TCP)
  1086. opcode = TX_TCPV6_PKT;
  1087. else if(l4proto == IPPROTO_UDP)
  1088. opcode = TX_UDPV6_PKT;
  1089. }
  1090. }
  1091. first_desc->tcp_hdr_offset = skb_transport_offset(skb);
  1092. first_desc->ip_hdr_offset = skb_network_offset(skb);
  1093. netxen_set_tx_flags_opcode(first_desc, flags, opcode);
  1094. if (!tso)
  1095. return;
  1096. /* For LSO, we need to copy the MAC/IP/TCP headers into
  1097. * the descriptor ring
  1098. */
  1099. producer = tx_ring->producer;
  1100. copied = 0;
  1101. offset = 2;
  1102. while (copied < hdr_len) {
  1103. copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
  1104. (hdr_len - copied));
  1105. hwdesc = &tx_ring->desc_head[producer];
  1106. tx_ring->cmd_buf_arr[producer].skb = NULL;
  1107. skb_copy_from_linear_data_offset(skb, copied,
  1108. (char *)hwdesc + offset, copy_len);
  1109. copied += copy_len;
  1110. offset = 0;
  1111. producer = get_next_index(producer, tx_ring->num_desc);
  1112. }
  1113. tx_ring->producer = producer;
  1114. barrier();
  1115. }
  1116. static void
  1117. netxen_clean_tx_dma_mapping(struct pci_dev *pdev,
  1118. struct netxen_cmd_buffer *pbuf, int last)
  1119. {
  1120. int k;
  1121. struct netxen_skb_frag *buffrag;
  1122. buffrag = &pbuf->frag_array[0];
  1123. pci_unmap_single(pdev, buffrag->dma,
  1124. buffrag->length, PCI_DMA_TODEVICE);
  1125. for (k = 1; k < last; k++) {
  1126. buffrag = &pbuf->frag_array[k];
  1127. pci_unmap_page(pdev, buffrag->dma,
  1128. buffrag->length, PCI_DMA_TODEVICE);
  1129. }
  1130. }
  1131. static inline void
  1132. netxen_clear_cmddesc(u64 *desc)
  1133. {
  1134. desc[0] = 0ULL;
  1135. desc[2] = 0ULL;
  1136. }
  1137. static int
  1138. netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
  1139. {
  1140. struct netxen_adapter *adapter = netdev_priv(netdev);
  1141. struct nx_host_tx_ring *tx_ring = adapter->tx_ring;
  1142. struct skb_frag_struct *frag;
  1143. struct netxen_cmd_buffer *pbuf;
  1144. struct netxen_skb_frag *buffrag;
  1145. struct cmd_desc_type0 *hwdesc, *first_desc;
  1146. struct pci_dev *pdev;
  1147. dma_addr_t temp_dma;
  1148. int i, k;
  1149. unsigned long offset;
  1150. u32 producer;
  1151. int len, frag_count, no_of_desc;
  1152. u32 num_txd = tx_ring->num_desc;
  1153. frag_count = skb_shinfo(skb)->nr_frags + 1;
  1154. /* 4 fragments per cmd des */
  1155. no_of_desc = (frag_count + 3) >> 2;
  1156. if (unlikely(no_of_desc + 2) > netxen_tx_avail(tx_ring)) {
  1157. netif_stop_queue(netdev);
  1158. return NETDEV_TX_BUSY;
  1159. }
  1160. producer = tx_ring->producer;
  1161. pdev = adapter->pdev;
  1162. len = skb->len - skb->data_len;
  1163. temp_dma = pci_map_single(pdev, skb->data, len, PCI_DMA_TODEVICE);
  1164. if (pci_dma_mapping_error(pdev, temp_dma))
  1165. goto drop_packet;
  1166. pbuf = &tx_ring->cmd_buf_arr[producer];
  1167. pbuf->skb = skb;
  1168. pbuf->frag_count = frag_count;
  1169. buffrag = &pbuf->frag_array[0];
  1170. buffrag->dma = temp_dma;
  1171. buffrag->length = len;
  1172. first_desc = hwdesc = &tx_ring->desc_head[producer];
  1173. netxen_clear_cmddesc((u64 *)hwdesc);
  1174. netxen_set_tx_frags_len(hwdesc, frag_count, skb->len);
  1175. netxen_set_tx_port(hwdesc, adapter->portnum);
  1176. hwdesc->buffer_length[0] = cpu_to_le16(len);
  1177. hwdesc->addr_buffer1 = cpu_to_le64(temp_dma);
  1178. for (i = 1, k = 1; i < frag_count; i++, k++) {
  1179. /* move to next desc. if there is a need */
  1180. if ((i & 0x3) == 0) {
  1181. k = 0;
  1182. producer = get_next_index(producer, num_txd);
  1183. hwdesc = &tx_ring->desc_head[producer];
  1184. netxen_clear_cmddesc((u64 *)hwdesc);
  1185. pbuf = &tx_ring->cmd_buf_arr[producer];
  1186. pbuf->skb = NULL;
  1187. }
  1188. buffrag = &pbuf->frag_array[i];
  1189. frag = &skb_shinfo(skb)->frags[i - 1];
  1190. len = frag->size;
  1191. offset = frag->page_offset;
  1192. temp_dma = pci_map_page(pdev, frag->page, offset,
  1193. len, PCI_DMA_TODEVICE);
  1194. if (pci_dma_mapping_error(pdev, temp_dma)) {
  1195. netxen_clean_tx_dma_mapping(pdev, pbuf, i);
  1196. goto drop_packet;
  1197. }
  1198. buffrag->dma = temp_dma;
  1199. buffrag->length = len;
  1200. hwdesc->buffer_length[k] = cpu_to_le16(len);
  1201. switch (k) {
  1202. case 0:
  1203. hwdesc->addr_buffer1 = cpu_to_le64(temp_dma);
  1204. break;
  1205. case 1:
  1206. hwdesc->addr_buffer2 = cpu_to_le64(temp_dma);
  1207. break;
  1208. case 2:
  1209. hwdesc->addr_buffer3 = cpu_to_le64(temp_dma);
  1210. break;
  1211. case 3:
  1212. hwdesc->addr_buffer4 = cpu_to_le64(temp_dma);
  1213. break;
  1214. }
  1215. }
  1216. tx_ring->producer = get_next_index(producer, num_txd);
  1217. netxen_tso_check(netdev, tx_ring, first_desc, skb);
  1218. netxen_nic_update_cmd_producer(adapter, tx_ring);
  1219. adapter->stats.txbytes += skb->len;
  1220. adapter->stats.xmitcalled++;
  1221. return NETDEV_TX_OK;
  1222. drop_packet:
  1223. adapter->stats.txdropped++;
  1224. dev_kfree_skb_any(skb);
  1225. return NETDEV_TX_OK;
  1226. }
  1227. static int netxen_nic_check_temp(struct netxen_adapter *adapter)
  1228. {
  1229. struct net_device *netdev = adapter->netdev;
  1230. uint32_t temp, temp_state, temp_val;
  1231. int rv = 0;
  1232. temp = NXRD32(adapter, CRB_TEMP_STATE);
  1233. temp_state = nx_get_temp_state(temp);
  1234. temp_val = nx_get_temp_val(temp);
  1235. if (temp_state == NX_TEMP_PANIC) {
  1236. printk(KERN_ALERT
  1237. "%s: Device temperature %d degrees C exceeds"
  1238. " maximum allowed. Hardware has been shut down.\n",
  1239. netdev->name, temp_val);
  1240. netif_device_detach(netdev);
  1241. netxen_nic_down(adapter, netdev);
  1242. netxen_nic_detach(adapter);
  1243. rv = 1;
  1244. } else if (temp_state == NX_TEMP_WARN) {
  1245. if (adapter->temp == NX_TEMP_NORMAL) {
  1246. printk(KERN_ALERT
  1247. "%s: Device temperature %d degrees C "
  1248. "exceeds operating range."
  1249. " Immediate action needed.\n",
  1250. netdev->name, temp_val);
  1251. }
  1252. } else {
  1253. if (adapter->temp == NX_TEMP_WARN) {
  1254. printk(KERN_INFO
  1255. "%s: Device temperature is now %d degrees C"
  1256. " in normal range.\n", netdev->name,
  1257. temp_val);
  1258. }
  1259. }
  1260. adapter->temp = temp_state;
  1261. return rv;
  1262. }
  1263. void netxen_advert_link_change(struct netxen_adapter *adapter, int linkup)
  1264. {
  1265. struct net_device *netdev = adapter->netdev;
  1266. if (adapter->ahw.linkup && !linkup) {
  1267. printk(KERN_INFO "%s: %s NIC Link is down\n",
  1268. netxen_nic_driver_name, netdev->name);
  1269. adapter->ahw.linkup = 0;
  1270. if (netif_running(netdev)) {
  1271. netif_carrier_off(netdev);
  1272. netif_stop_queue(netdev);
  1273. }
  1274. if (!adapter->has_link_events)
  1275. netxen_nic_set_link_parameters(adapter);
  1276. } else if (!adapter->ahw.linkup && linkup) {
  1277. printk(KERN_INFO "%s: %s NIC Link is up\n",
  1278. netxen_nic_driver_name, netdev->name);
  1279. adapter->ahw.linkup = 1;
  1280. if (netif_running(netdev)) {
  1281. netif_carrier_on(netdev);
  1282. netif_wake_queue(netdev);
  1283. }
  1284. if (!adapter->has_link_events)
  1285. netxen_nic_set_link_parameters(adapter);
  1286. }
  1287. }
  1288. static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
  1289. {
  1290. u32 val, port, linkup;
  1291. port = adapter->physical_port;
  1292. if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
  1293. val = NXRD32(adapter, CRB_XG_STATE_P3);
  1294. val = XG_LINK_STATE_P3(adapter->ahw.pci_func, val);
  1295. linkup = (val == XG_LINK_UP_P3);
  1296. } else {
  1297. val = NXRD32(adapter, CRB_XG_STATE);
  1298. if (adapter->ahw.port_type == NETXEN_NIC_GBE)
  1299. linkup = (val >> port) & 1;
  1300. else {
  1301. val = (val >> port*8) & 0xff;
  1302. linkup = (val == XG_LINK_UP);
  1303. }
  1304. }
  1305. netxen_advert_link_change(adapter, linkup);
  1306. }
  1307. static void netxen_watchdog(unsigned long v)
  1308. {
  1309. struct netxen_adapter *adapter = (struct netxen_adapter *)v;
  1310. SCHEDULE_WORK(&adapter->watchdog_task);
  1311. }
  1312. void netxen_watchdog_task(struct work_struct *work)
  1313. {
  1314. struct netxen_adapter *adapter =
  1315. container_of(work, struct netxen_adapter, watchdog_task);
  1316. if (netxen_nic_check_temp(adapter))
  1317. return;
  1318. if (!adapter->has_link_events)
  1319. netxen_nic_handle_phy_intr(adapter);
  1320. if (netif_running(adapter->netdev))
  1321. mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
  1322. }
  1323. static void netxen_tx_timeout(struct net_device *netdev)
  1324. {
  1325. struct netxen_adapter *adapter = (struct netxen_adapter *)
  1326. netdev_priv(netdev);
  1327. SCHEDULE_WORK(&adapter->tx_timeout_task);
  1328. }
  1329. static void netxen_tx_timeout_task(struct work_struct *work)
  1330. {
  1331. struct netxen_adapter *adapter =
  1332. container_of(work, struct netxen_adapter, tx_timeout_task);
  1333. if (!netif_running(adapter->netdev))
  1334. return;
  1335. printk(KERN_ERR "%s %s: transmit timeout, resetting.\n",
  1336. netxen_nic_driver_name, adapter->netdev->name);
  1337. netxen_napi_disable(adapter);
  1338. adapter->netdev->trans_start = jiffies;
  1339. netxen_napi_enable(adapter);
  1340. netif_wake_queue(adapter->netdev);
  1341. }
  1342. struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev)
  1343. {
  1344. struct netxen_adapter *adapter = netdev_priv(netdev);
  1345. struct net_device_stats *stats = &adapter->net_stats;
  1346. memset(stats, 0, sizeof(*stats));
  1347. stats->rx_packets = adapter->stats.no_rcv;
  1348. stats->tx_packets = adapter->stats.xmitfinished;
  1349. stats->rx_bytes = adapter->stats.rxbytes;
  1350. stats->tx_bytes = adapter->stats.txbytes;
  1351. stats->rx_dropped = adapter->stats.rxdropped;
  1352. stats->tx_dropped = adapter->stats.txdropped;
  1353. return stats;
  1354. }
  1355. static irqreturn_t netxen_intr(int irq, void *data)
  1356. {
  1357. struct nx_host_sds_ring *sds_ring = data;
  1358. struct netxen_adapter *adapter = sds_ring->adapter;
  1359. u32 status = 0;
  1360. status = adapter->pci_read_immediate(adapter, ISR_INT_VECTOR);
  1361. if (!(status & adapter->legacy_intr.int_vec_bit))
  1362. return IRQ_NONE;
  1363. if (adapter->ahw.revision_id >= NX_P3_B1) {
  1364. /* check interrupt state machine, to be sure */
  1365. status = adapter->pci_read_immediate(adapter,
  1366. ISR_INT_STATE_REG);
  1367. if (!ISR_LEGACY_INT_TRIGGERED(status))
  1368. return IRQ_NONE;
  1369. } else {
  1370. unsigned long our_int = 0;
  1371. our_int = NXRD32(adapter, CRB_INT_VECTOR);
  1372. /* not our interrupt */
  1373. if (!test_and_clear_bit((7 + adapter->portnum), &our_int))
  1374. return IRQ_NONE;
  1375. /* claim interrupt */
  1376. NXWR32(adapter, CRB_INT_VECTOR, (our_int & 0xffffffff));
  1377. }
  1378. /* clear interrupt */
  1379. if (adapter->fw_major < 4)
  1380. netxen_nic_disable_int(sds_ring);
  1381. adapter->pci_write_immediate(adapter,
  1382. adapter->legacy_intr.tgt_status_reg,
  1383. 0xffffffff);
  1384. /* read twice to ensure write is flushed */
  1385. adapter->pci_read_immediate(adapter, ISR_INT_VECTOR);
  1386. adapter->pci_read_immediate(adapter, ISR_INT_VECTOR);
  1387. napi_schedule(&sds_ring->napi);
  1388. return IRQ_HANDLED;
  1389. }
  1390. static irqreturn_t netxen_msi_intr(int irq, void *data)
  1391. {
  1392. struct nx_host_sds_ring *sds_ring = data;
  1393. struct netxen_adapter *adapter = sds_ring->adapter;
  1394. /* clear interrupt */
  1395. adapter->pci_write_immediate(adapter,
  1396. adapter->msi_tgt_status, 0xffffffff);
  1397. napi_schedule(&sds_ring->napi);
  1398. return IRQ_HANDLED;
  1399. }
  1400. static irqreturn_t netxen_msix_intr(int irq, void *data)
  1401. {
  1402. struct nx_host_sds_ring *sds_ring = data;
  1403. napi_schedule(&sds_ring->napi);
  1404. return IRQ_HANDLED;
  1405. }
  1406. static int netxen_nic_poll(struct napi_struct *napi, int budget)
  1407. {
  1408. struct nx_host_sds_ring *sds_ring =
  1409. container_of(napi, struct nx_host_sds_ring, napi);
  1410. struct netxen_adapter *adapter = sds_ring->adapter;
  1411. int tx_complete;
  1412. int work_done;
  1413. tx_complete = netxen_process_cmd_ring(adapter);
  1414. work_done = netxen_process_rcv_ring(sds_ring, budget);
  1415. if ((work_done < budget) && tx_complete) {
  1416. napi_complete(&sds_ring->napi);
  1417. if (netif_running(adapter->netdev))
  1418. netxen_nic_enable_int(sds_ring);
  1419. }
  1420. return work_done;
  1421. }
  1422. #ifdef CONFIG_NET_POLL_CONTROLLER
  1423. static void netxen_nic_poll_controller(struct net_device *netdev)
  1424. {
  1425. struct netxen_adapter *adapter = netdev_priv(netdev);
  1426. disable_irq(adapter->irq);
  1427. netxen_intr(adapter->irq, adapter);
  1428. enable_irq(adapter->irq);
  1429. }
  1430. #endif
  1431. #define is_netxen_netdev(dev) (dev->netdev_ops == &netxen_netdev_ops)
  1432. static int
  1433. netxen_destip_supported(struct netxen_adapter *adapter)
  1434. {
  1435. if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
  1436. return 0;
  1437. if (adapter->ahw.cut_through)
  1438. return 0;
  1439. return 1;
  1440. }
  1441. static int netxen_netdev_event(struct notifier_block *this,
  1442. unsigned long event, void *ptr)
  1443. {
  1444. struct netxen_adapter *adapter;
  1445. struct net_device *dev = (struct net_device *)ptr;
  1446. struct in_device *indev;
  1447. recheck:
  1448. if (dev == NULL)
  1449. goto done;
  1450. if (dev->priv_flags & IFF_802_1Q_VLAN) {
  1451. dev = vlan_dev_real_dev(dev);
  1452. goto recheck;
  1453. }
  1454. if (!is_netxen_netdev(dev))
  1455. goto done;
  1456. adapter = netdev_priv(dev);
  1457. if (!adapter || !netxen_destip_supported(adapter))
  1458. goto done;
  1459. if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
  1460. goto done;
  1461. indev = in_dev_get(dev);
  1462. if (!indev)
  1463. goto done;
  1464. for_ifa(indev) {
  1465. switch (event) {
  1466. case NETDEV_UP:
  1467. netxen_config_ipaddr(adapter,
  1468. ifa->ifa_address, NX_IP_UP);
  1469. break;
  1470. case NETDEV_DOWN:
  1471. netxen_config_ipaddr(adapter,
  1472. ifa->ifa_address, NX_IP_DOWN);
  1473. break;
  1474. default:
  1475. break;
  1476. }
  1477. } endfor_ifa(indev);
  1478. in_dev_put(indev);
  1479. done:
  1480. return NOTIFY_DONE;
  1481. }
  1482. static int
  1483. netxen_inetaddr_event(struct notifier_block *this,
  1484. unsigned long event, void *ptr)
  1485. {
  1486. struct netxen_adapter *adapter;
  1487. struct net_device *dev;
  1488. struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
  1489. dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
  1490. recheck:
  1491. if (dev == NULL || !netif_running(dev))
  1492. goto done;
  1493. if (dev->priv_flags & IFF_802_1Q_VLAN) {
  1494. dev = vlan_dev_real_dev(dev);
  1495. goto recheck;
  1496. }
  1497. if (!is_netxen_netdev(dev))
  1498. goto done;
  1499. adapter = netdev_priv(dev);
  1500. if (!adapter || !netxen_destip_supported(adapter))
  1501. goto done;
  1502. if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
  1503. goto done;
  1504. switch (event) {
  1505. case NETDEV_UP:
  1506. netxen_config_ipaddr(adapter, ifa->ifa_address, NX_IP_UP);
  1507. break;
  1508. case NETDEV_DOWN:
  1509. netxen_config_ipaddr(adapter, ifa->ifa_address, NX_IP_DOWN);
  1510. break;
  1511. default:
  1512. break;
  1513. }
  1514. done:
  1515. return NOTIFY_DONE;
  1516. }
  1517. static struct notifier_block netxen_netdev_cb = {
  1518. .notifier_call = netxen_netdev_event,
  1519. };
  1520. static struct notifier_block netxen_inetaddr_cb = {
  1521. .notifier_call = netxen_inetaddr_event,
  1522. };
  1523. static struct pci_driver netxen_driver = {
  1524. .name = netxen_nic_driver_name,
  1525. .id_table = netxen_pci_tbl,
  1526. .probe = netxen_nic_probe,
  1527. .remove = __devexit_p(netxen_nic_remove),
  1528. #ifdef CONFIG_PM
  1529. .suspend = netxen_nic_suspend,
  1530. .resume = netxen_nic_resume
  1531. #endif
  1532. };
  1533. /* Driver Registration on NetXen card */
  1534. static int __init netxen_init_module(void)
  1535. {
  1536. printk(KERN_INFO "%s\n", netxen_nic_driver_string);
  1537. if ((netxen_workq = create_singlethread_workqueue("netxen")) == NULL)
  1538. return -ENOMEM;
  1539. register_netdevice_notifier(&netxen_netdev_cb);
  1540. register_inetaddr_notifier(&netxen_inetaddr_cb);
  1541. return pci_register_driver(&netxen_driver);
  1542. }
  1543. module_init(netxen_init_module);
  1544. static void __exit netxen_exit_module(void)
  1545. {
  1546. pci_unregister_driver(&netxen_driver);
  1547. unregister_inetaddr_notifier(&netxen_inetaddr_cb);
  1548. unregister_netdevice_notifier(&netxen_netdev_cb);
  1549. destroy_workqueue(netxen_workq);
  1550. }
  1551. module_exit(netxen_exit_module);