netxen_nic_main.c 60 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540
  1. /*
  2. * Copyright (C) 2003 - 2009 NetXen, Inc.
  3. * Copyright (C) 2009 - QLogic Corporation.
  4. * All rights reserved.
  5. *
  6. * This program is free software; you can redistribute it and/or
  7. * modify it under the terms of the GNU General Public License
  8. * as published by the Free Software Foundation; either version 2
  9. * of the License, or (at your option) any later version.
  10. *
  11. * This program is distributed in the hope that it will be useful, but
  12. * WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. * GNU General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program; if not, write to the Free Software
  18. * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  19. * MA 02111-1307, USA.
  20. *
  21. * The full GNU General Public License is included in this distribution
  22. * in the file called LICENSE.
  23. *
  24. */
  25. #include <linux/vmalloc.h>
  26. #include <linux/interrupt.h>
  27. #include "netxen_nic_hw.h"
  28. #include "netxen_nic.h"
  29. #include <linux/dma-mapping.h>
  30. #include <linux/if_vlan.h>
  31. #include <net/ip.h>
  32. #include <linux/ipv6.h>
  33. #include <linux/inetdevice.h>
  34. MODULE_DESCRIPTION("NetXen Multi port (1/10) Gigabit Network Driver");
  35. MODULE_LICENSE("GPL");
  36. MODULE_VERSION(NETXEN_NIC_LINUX_VERSIONID);
  37. char netxen_nic_driver_name[] = "netxen_nic";
  38. static char netxen_nic_driver_string[] = "NetXen Network Driver version "
  39. NETXEN_NIC_LINUX_VERSIONID;
  40. static int port_mode = NETXEN_PORT_MODE_AUTO_NEG;
  41. /* Default to restricted 1G auto-neg mode */
  42. static int wol_port_mode = 5;
  43. static int use_msi = 1;
  44. static int use_msi_x = 1;
  45. /* Local functions to NetXen NIC driver */
  46. static int __devinit netxen_nic_probe(struct pci_dev *pdev,
  47. const struct pci_device_id *ent);
  48. static void __devexit netxen_nic_remove(struct pci_dev *pdev);
  49. static int netxen_nic_open(struct net_device *netdev);
  50. static int netxen_nic_close(struct net_device *netdev);
  51. static netdev_tx_t netxen_nic_xmit_frame(struct sk_buff *,
  52. struct net_device *);
  53. static void netxen_tx_timeout(struct net_device *netdev);
  54. static void netxen_tx_timeout_task(struct work_struct *work);
  55. static void netxen_fw_poll_work(struct work_struct *work);
  56. static void netxen_schedule_work(struct netxen_adapter *adapter,
  57. work_func_t func, int delay);
  58. static void netxen_cancel_fw_work(struct netxen_adapter *adapter);
  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 void netxen_create_sysfs_entries(struct netxen_adapter *adapter);
  64. static void netxen_remove_sysfs_entries(struct netxen_adapter *adapter);
  65. static int nx_decr_dev_ref_cnt(struct netxen_adapter *adapter);
  66. static int netxen_can_start_firmware(struct netxen_adapter *adapter);
  67. static irqreturn_t netxen_intr(int irq, void *data);
  68. static irqreturn_t netxen_msi_intr(int irq, void *data);
  69. static irqreturn_t netxen_msix_intr(int irq, void *data);
  70. static void netxen_config_indev_addr(struct net_device *dev, unsigned long);
  71. /* PCI Device ID Table */
  72. #define ENTRY(device) \
  73. {PCI_DEVICE(PCI_VENDOR_ID_NETXEN, (device)), \
  74. .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
  75. static struct pci_device_id netxen_pci_tbl[] __devinitdata = {
  76. ENTRY(PCI_DEVICE_ID_NX2031_10GXSR),
  77. ENTRY(PCI_DEVICE_ID_NX2031_10GCX4),
  78. ENTRY(PCI_DEVICE_ID_NX2031_4GCU),
  79. ENTRY(PCI_DEVICE_ID_NX2031_IMEZ),
  80. ENTRY(PCI_DEVICE_ID_NX2031_HMEZ),
  81. ENTRY(PCI_DEVICE_ID_NX2031_XG_MGMT),
  82. ENTRY(PCI_DEVICE_ID_NX2031_XG_MGMT2),
  83. ENTRY(PCI_DEVICE_ID_NX3031),
  84. {0,}
  85. };
  86. MODULE_DEVICE_TABLE(pci, netxen_pci_tbl);
  87. static uint32_t crb_cmd_producer[4] = {
  88. CRB_CMD_PRODUCER_OFFSET, CRB_CMD_PRODUCER_OFFSET_1,
  89. CRB_CMD_PRODUCER_OFFSET_2, CRB_CMD_PRODUCER_OFFSET_3
  90. };
  91. void
  92. netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
  93. struct nx_host_tx_ring *tx_ring)
  94. {
  95. NXWRIO(adapter, tx_ring->crb_cmd_producer, tx_ring->producer);
  96. if (netxen_tx_avail(tx_ring) <= TX_STOP_THRESH) {
  97. netif_stop_queue(adapter->netdev);
  98. smp_mb();
  99. }
  100. }
  101. static uint32_t crb_cmd_consumer[4] = {
  102. CRB_CMD_CONSUMER_OFFSET, CRB_CMD_CONSUMER_OFFSET_1,
  103. CRB_CMD_CONSUMER_OFFSET_2, CRB_CMD_CONSUMER_OFFSET_3
  104. };
  105. static inline void
  106. netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
  107. struct nx_host_tx_ring *tx_ring)
  108. {
  109. NXWRIO(adapter, tx_ring->crb_cmd_consumer, tx_ring->sw_consumer);
  110. }
  111. static uint32_t msi_tgt_status[8] = {
  112. ISR_INT_TARGET_STATUS, ISR_INT_TARGET_STATUS_F1,
  113. ISR_INT_TARGET_STATUS_F2, ISR_INT_TARGET_STATUS_F3,
  114. ISR_INT_TARGET_STATUS_F4, ISR_INT_TARGET_STATUS_F5,
  115. ISR_INT_TARGET_STATUS_F6, ISR_INT_TARGET_STATUS_F7
  116. };
  117. static struct netxen_legacy_intr_set legacy_intr[] = NX_LEGACY_INTR_CONFIG;
  118. static inline void netxen_nic_disable_int(struct nx_host_sds_ring *sds_ring)
  119. {
  120. struct netxen_adapter *adapter = sds_ring->adapter;
  121. NXWRIO(adapter, sds_ring->crb_intr_mask, 0);
  122. }
  123. static inline void netxen_nic_enable_int(struct nx_host_sds_ring *sds_ring)
  124. {
  125. struct netxen_adapter *adapter = sds_ring->adapter;
  126. NXWRIO(adapter, sds_ring->crb_intr_mask, 0x1);
  127. if (!NETXEN_IS_MSI_FAMILY(adapter))
  128. NXWRIO(adapter, adapter->tgt_mask_reg, 0xfbff);
  129. }
  130. static int
  131. netxen_alloc_sds_rings(struct netxen_recv_context *recv_ctx, int count)
  132. {
  133. int size = sizeof(struct nx_host_sds_ring) * count;
  134. recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);
  135. return (recv_ctx->sds_rings == NULL);
  136. }
  137. static void
  138. netxen_free_sds_rings(struct netxen_recv_context *recv_ctx)
  139. {
  140. if (recv_ctx->sds_rings != NULL)
  141. kfree(recv_ctx->sds_rings);
  142. recv_ctx->sds_rings = NULL;
  143. }
  144. static int
  145. netxen_napi_add(struct netxen_adapter *adapter, struct net_device *netdev)
  146. {
  147. int ring;
  148. struct nx_host_sds_ring *sds_ring;
  149. struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
  150. if (netxen_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
  151. return -ENOMEM;
  152. for (ring = 0; ring < adapter->max_sds_rings; ring++) {
  153. sds_ring = &recv_ctx->sds_rings[ring];
  154. netif_napi_add(netdev, &sds_ring->napi,
  155. netxen_nic_poll, NETXEN_NETDEV_WEIGHT);
  156. }
  157. return 0;
  158. }
  159. static void
  160. netxen_napi_del(struct netxen_adapter *adapter)
  161. {
  162. int ring;
  163. struct nx_host_sds_ring *sds_ring;
  164. struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
  165. for (ring = 0; ring < adapter->max_sds_rings; ring++) {
  166. sds_ring = &recv_ctx->sds_rings[ring];
  167. netif_napi_del(&sds_ring->napi);
  168. }
  169. netxen_free_sds_rings(&adapter->recv_ctx);
  170. }
  171. static void
  172. netxen_napi_enable(struct netxen_adapter *adapter)
  173. {
  174. int ring;
  175. struct nx_host_sds_ring *sds_ring;
  176. struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
  177. for (ring = 0; ring < adapter->max_sds_rings; ring++) {
  178. sds_ring = &recv_ctx->sds_rings[ring];
  179. napi_enable(&sds_ring->napi);
  180. netxen_nic_enable_int(sds_ring);
  181. }
  182. }
  183. static void
  184. netxen_napi_disable(struct netxen_adapter *adapter)
  185. {
  186. int ring;
  187. struct nx_host_sds_ring *sds_ring;
  188. struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
  189. for (ring = 0; ring < adapter->max_sds_rings; ring++) {
  190. sds_ring = &recv_ctx->sds_rings[ring];
  191. netxen_nic_disable_int(sds_ring);
  192. napi_synchronize(&sds_ring->napi);
  193. napi_disable(&sds_ring->napi);
  194. }
  195. }
  196. static int nx_set_dma_mask(struct netxen_adapter *adapter)
  197. {
  198. struct pci_dev *pdev = adapter->pdev;
  199. uint64_t mask, cmask;
  200. adapter->pci_using_dac = 0;
  201. mask = DMA_BIT_MASK(32);
  202. cmask = DMA_BIT_MASK(32);
  203. if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
  204. #ifndef CONFIG_IA64
  205. mask = DMA_BIT_MASK(35);
  206. #endif
  207. } else {
  208. mask = DMA_BIT_MASK(39);
  209. cmask = mask;
  210. }
  211. if (pci_set_dma_mask(pdev, mask) == 0 &&
  212. pci_set_consistent_dma_mask(pdev, cmask) == 0) {
  213. adapter->pci_using_dac = 1;
  214. return 0;
  215. }
  216. return -EIO;
  217. }
  218. /* Update addressable range if firmware supports it */
  219. static int
  220. nx_update_dma_mask(struct netxen_adapter *adapter)
  221. {
  222. int change, shift, err;
  223. uint64_t mask, old_mask, old_cmask;
  224. struct pci_dev *pdev = adapter->pdev;
  225. change = 0;
  226. shift = NXRD32(adapter, CRB_DMA_SHIFT);
  227. if (shift > 32)
  228. return 0;
  229. if (NX_IS_REVISION_P3(adapter->ahw.revision_id) && (shift > 9))
  230. change = 1;
  231. else if ((adapter->ahw.revision_id == NX_P2_C1) && (shift <= 4))
  232. change = 1;
  233. if (change) {
  234. old_mask = pdev->dma_mask;
  235. old_cmask = pdev->dev.coherent_dma_mask;
  236. mask = DMA_BIT_MASK(32+shift);
  237. err = pci_set_dma_mask(pdev, mask);
  238. if (err)
  239. goto err_out;
  240. if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
  241. err = pci_set_consistent_dma_mask(pdev, mask);
  242. if (err)
  243. goto err_out;
  244. }
  245. dev_info(&pdev->dev, "using %d-bit dma mask\n", 32+shift);
  246. }
  247. return 0;
  248. err_out:
  249. pci_set_dma_mask(pdev, old_mask);
  250. pci_set_consistent_dma_mask(pdev, old_cmask);
  251. return err;
  252. }
  253. static int
  254. netxen_check_hw_init(struct netxen_adapter *adapter, int first_boot)
  255. {
  256. u32 val, timeout;
  257. if (first_boot == 0x55555555) {
  258. /* This is the first boot after power up */
  259. NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
  260. if (!NX_IS_REVISION_P2(adapter->ahw.revision_id))
  261. return 0;
  262. /* PCI bus master workaround */
  263. first_boot = NXRD32(adapter, NETXEN_PCIE_REG(0x4));
  264. if (!(first_boot & 0x4)) {
  265. first_boot |= 0x4;
  266. NXWR32(adapter, NETXEN_PCIE_REG(0x4), first_boot);
  267. first_boot = NXRD32(adapter, NETXEN_PCIE_REG(0x4));
  268. }
  269. /* This is the first boot after power up */
  270. first_boot = NXRD32(adapter, NETXEN_ROMUSB_GLB_SW_RESET);
  271. if (first_boot != 0x80000f) {
  272. /* clear the register for future unloads/loads */
  273. NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), 0);
  274. return -EIO;
  275. }
  276. /* Start P2 boot loader */
  277. val = NXRD32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE);
  278. NXWR32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE, val | 0x1);
  279. timeout = 0;
  280. do {
  281. msleep(1);
  282. val = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
  283. if (++timeout > 5000)
  284. return -EIO;
  285. } while (val == NETXEN_BDINFO_MAGIC);
  286. }
  287. return 0;
  288. }
  289. static void netxen_set_port_mode(struct netxen_adapter *adapter)
  290. {
  291. u32 val, data;
  292. val = adapter->ahw.board_type;
  293. if ((val == NETXEN_BRDTYPE_P3_HMEZ) ||
  294. (val == NETXEN_BRDTYPE_P3_XG_LOM)) {
  295. if (port_mode == NETXEN_PORT_MODE_802_3_AP) {
  296. data = NETXEN_PORT_MODE_802_3_AP;
  297. NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
  298. } else if (port_mode == NETXEN_PORT_MODE_XG) {
  299. data = NETXEN_PORT_MODE_XG;
  300. NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
  301. } else if (port_mode == NETXEN_PORT_MODE_AUTO_NEG_1G) {
  302. data = NETXEN_PORT_MODE_AUTO_NEG_1G;
  303. NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
  304. } else if (port_mode == NETXEN_PORT_MODE_AUTO_NEG_XG) {
  305. data = NETXEN_PORT_MODE_AUTO_NEG_XG;
  306. NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
  307. } else {
  308. data = NETXEN_PORT_MODE_AUTO_NEG;
  309. NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
  310. }
  311. if ((wol_port_mode != NETXEN_PORT_MODE_802_3_AP) &&
  312. (wol_port_mode != NETXEN_PORT_MODE_XG) &&
  313. (wol_port_mode != NETXEN_PORT_MODE_AUTO_NEG_1G) &&
  314. (wol_port_mode != NETXEN_PORT_MODE_AUTO_NEG_XG)) {
  315. wol_port_mode = NETXEN_PORT_MODE_AUTO_NEG;
  316. }
  317. NXWR32(adapter, NETXEN_WOL_PORT_MODE, wol_port_mode);
  318. }
  319. }
  320. static void netxen_set_msix_bit(struct pci_dev *pdev, int enable)
  321. {
  322. u32 control;
  323. int pos;
  324. pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
  325. if (pos) {
  326. pci_read_config_dword(pdev, pos, &control);
  327. if (enable)
  328. control |= PCI_MSIX_FLAGS_ENABLE;
  329. else
  330. control = 0;
  331. pci_write_config_dword(pdev, pos, control);
  332. }
  333. }
  334. static void netxen_init_msix_entries(struct netxen_adapter *adapter, int count)
  335. {
  336. int i;
  337. for (i = 0; i < count; i++)
  338. adapter->msix_entries[i].entry = i;
  339. }
  340. static int
  341. netxen_read_mac_addr(struct netxen_adapter *adapter)
  342. {
  343. int i;
  344. unsigned char *p;
  345. __le64 mac_addr;
  346. struct net_device *netdev = adapter->netdev;
  347. struct pci_dev *pdev = adapter->pdev;
  348. if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
  349. if (netxen_p3_get_mac_addr(adapter, &mac_addr) != 0)
  350. return -EIO;
  351. } else {
  352. if (netxen_get_flash_mac_addr(adapter, &mac_addr) != 0)
  353. return -EIO;
  354. }
  355. p = (unsigned char *)&mac_addr;
  356. for (i = 0; i < 6; i++)
  357. netdev->dev_addr[i] = *(p + 5 - i);
  358. memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len);
  359. /* set station address */
  360. if (!is_valid_ether_addr(netdev->perm_addr))
  361. dev_warn(&pdev->dev, "Bad MAC address %pM.\n", netdev->dev_addr);
  362. return 0;
  363. }
  364. int netxen_nic_set_mac(struct net_device *netdev, void *p)
  365. {
  366. struct netxen_adapter *adapter = netdev_priv(netdev);
  367. struct sockaddr *addr = p;
  368. if (!is_valid_ether_addr(addr->sa_data))
  369. return -EINVAL;
  370. if (netif_running(netdev)) {
  371. netif_device_detach(netdev);
  372. netxen_napi_disable(adapter);
  373. }
  374. memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
  375. adapter->macaddr_set(adapter, addr->sa_data);
  376. if (netif_running(netdev)) {
  377. netif_device_attach(netdev);
  378. netxen_napi_enable(adapter);
  379. }
  380. return 0;
  381. }
  382. static void netxen_set_multicast_list(struct net_device *dev)
  383. {
  384. struct netxen_adapter *adapter = netdev_priv(dev);
  385. adapter->set_multi(dev);
  386. }
  387. static const struct net_device_ops netxen_netdev_ops = {
  388. .ndo_open = netxen_nic_open,
  389. .ndo_stop = netxen_nic_close,
  390. .ndo_start_xmit = netxen_nic_xmit_frame,
  391. .ndo_get_stats = netxen_nic_get_stats,
  392. .ndo_validate_addr = eth_validate_addr,
  393. .ndo_set_multicast_list = netxen_set_multicast_list,
  394. .ndo_set_mac_address = netxen_nic_set_mac,
  395. .ndo_change_mtu = netxen_nic_change_mtu,
  396. .ndo_tx_timeout = netxen_tx_timeout,
  397. #ifdef CONFIG_NET_POLL_CONTROLLER
  398. .ndo_poll_controller = netxen_nic_poll_controller,
  399. #endif
  400. };
  401. static void
  402. netxen_setup_intr(struct netxen_adapter *adapter)
  403. {
  404. struct netxen_legacy_intr_set *legacy_intrp;
  405. struct pci_dev *pdev = adapter->pdev;
  406. int err, num_msix;
  407. if (adapter->rss_supported) {
  408. num_msix = (num_online_cpus() >= MSIX_ENTRIES_PER_ADAPTER) ?
  409. MSIX_ENTRIES_PER_ADAPTER : 2;
  410. } else
  411. num_msix = 1;
  412. adapter->max_sds_rings = 1;
  413. adapter->flags &= ~(NETXEN_NIC_MSI_ENABLED | NETXEN_NIC_MSIX_ENABLED);
  414. if (adapter->ahw.revision_id >= NX_P3_B0)
  415. legacy_intrp = &legacy_intr[adapter->ahw.pci_func];
  416. else
  417. legacy_intrp = &legacy_intr[0];
  418. adapter->int_vec_bit = legacy_intrp->int_vec_bit;
  419. adapter->tgt_status_reg = netxen_get_ioaddr(adapter,
  420. legacy_intrp->tgt_status_reg);
  421. adapter->tgt_mask_reg = netxen_get_ioaddr(adapter,
  422. legacy_intrp->tgt_mask_reg);
  423. adapter->pci_int_reg = netxen_get_ioaddr(adapter,
  424. legacy_intrp->pci_int_reg);
  425. adapter->isr_int_vec = netxen_get_ioaddr(adapter, ISR_INT_VECTOR);
  426. if (adapter->ahw.revision_id >= NX_P3_B1)
  427. adapter->crb_int_state_reg = netxen_get_ioaddr(adapter,
  428. ISR_INT_STATE_REG);
  429. else
  430. adapter->crb_int_state_reg = netxen_get_ioaddr(adapter,
  431. CRB_INT_VECTOR);
  432. netxen_set_msix_bit(pdev, 0);
  433. if (adapter->msix_supported) {
  434. netxen_init_msix_entries(adapter, num_msix);
  435. err = pci_enable_msix(pdev, adapter->msix_entries, num_msix);
  436. if (err == 0) {
  437. adapter->flags |= NETXEN_NIC_MSIX_ENABLED;
  438. netxen_set_msix_bit(pdev, 1);
  439. if (adapter->rss_supported)
  440. adapter->max_sds_rings = num_msix;
  441. dev_info(&pdev->dev, "using msi-x interrupts\n");
  442. return;
  443. }
  444. if (err > 0)
  445. pci_disable_msix(pdev);
  446. /* fall through for msi */
  447. }
  448. if (use_msi && !pci_enable_msi(pdev)) {
  449. adapter->flags |= NETXEN_NIC_MSI_ENABLED;
  450. adapter->tgt_status_reg = netxen_get_ioaddr(adapter,
  451. msi_tgt_status[adapter->ahw.pci_func]);
  452. dev_info(&pdev->dev, "using msi interrupts\n");
  453. adapter->msix_entries[0].vector = pdev->irq;
  454. return;
  455. }
  456. dev_info(&pdev->dev, "using legacy interrupts\n");
  457. adapter->msix_entries[0].vector = pdev->irq;
  458. }
  459. static void
  460. netxen_teardown_intr(struct netxen_adapter *adapter)
  461. {
  462. if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
  463. pci_disable_msix(adapter->pdev);
  464. if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
  465. pci_disable_msi(adapter->pdev);
  466. }
  467. static void
  468. netxen_cleanup_pci_map(struct netxen_adapter *adapter)
  469. {
  470. if (adapter->ahw.db_base != NULL)
  471. iounmap(adapter->ahw.db_base);
  472. if (adapter->ahw.pci_base0 != NULL)
  473. iounmap(adapter->ahw.pci_base0);
  474. if (adapter->ahw.pci_base1 != NULL)
  475. iounmap(adapter->ahw.pci_base1);
  476. if (adapter->ahw.pci_base2 != NULL)
  477. iounmap(adapter->ahw.pci_base2);
  478. }
  479. static int
  480. netxen_setup_pci_map(struct netxen_adapter *adapter)
  481. {
  482. void __iomem *mem_ptr0 = NULL;
  483. void __iomem *mem_ptr1 = NULL;
  484. void __iomem *mem_ptr2 = NULL;
  485. void __iomem *db_ptr = NULL;
  486. resource_size_t mem_base, db_base;
  487. unsigned long mem_len, db_len = 0, pci_len0 = 0;
  488. struct pci_dev *pdev = adapter->pdev;
  489. int pci_func = adapter->ahw.pci_func;
  490. int err = 0;
  491. /*
  492. * Set the CRB window to invalid. If any register in window 0 is
  493. * accessed it should set the window to 0 and then reset it to 1.
  494. */
  495. adapter->curr_window = 255;
  496. adapter->ahw.qdr_sn_window = -1;
  497. adapter->ahw.ddr_mn_window = -1;
  498. /* remap phys address */
  499. mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
  500. mem_len = pci_resource_len(pdev, 0);
  501. pci_len0 = 0;
  502. /* 128 Meg of memory */
  503. if (mem_len == NETXEN_PCI_128MB_SIZE) {
  504. mem_ptr0 = ioremap(mem_base, FIRST_PAGE_GROUP_SIZE);
  505. mem_ptr1 = ioremap(mem_base + SECOND_PAGE_GROUP_START,
  506. SECOND_PAGE_GROUP_SIZE);
  507. mem_ptr2 = ioremap(mem_base + THIRD_PAGE_GROUP_START,
  508. THIRD_PAGE_GROUP_SIZE);
  509. } else if (mem_len == NETXEN_PCI_32MB_SIZE) {
  510. mem_ptr1 = ioremap(mem_base, SECOND_PAGE_GROUP_SIZE);
  511. mem_ptr2 = ioremap(mem_base + THIRD_PAGE_GROUP_START -
  512. SECOND_PAGE_GROUP_START, THIRD_PAGE_GROUP_SIZE);
  513. } else if (mem_len == NETXEN_PCI_2MB_SIZE) {
  514. mem_ptr0 = pci_ioremap_bar(pdev, 0);
  515. if (mem_ptr0 == NULL) {
  516. dev_err(&pdev->dev, "failed to map PCI bar 0\n");
  517. return -EIO;
  518. }
  519. pci_len0 = mem_len;
  520. adapter->ahw.ddr_mn_window = 0;
  521. adapter->ahw.qdr_sn_window = 0;
  522. adapter->ahw.mn_win_crb = NETXEN_PCI_CRBSPACE +
  523. 0x100000 + PCIX_MN_WINDOW + (pci_func * 0x20);
  524. adapter->ahw.ms_win_crb = NETXEN_PCI_CRBSPACE +
  525. 0x100000 + PCIX_SN_WINDOW;
  526. if (pci_func < 4)
  527. adapter->ahw.ms_win_crb += (pci_func * 0x20);
  528. else
  529. adapter->ahw.ms_win_crb +=
  530. 0xA0 + ((pci_func - 4) * 0x10);
  531. } else {
  532. return -EIO;
  533. }
  534. netxen_setup_hwops(adapter);
  535. dev_info(&pdev->dev, "%dMB memory map\n", (int)(mem_len>>20));
  536. adapter->ahw.pci_base0 = mem_ptr0;
  537. adapter->ahw.pci_len0 = pci_len0;
  538. adapter->ahw.pci_base1 = mem_ptr1;
  539. adapter->ahw.pci_base2 = mem_ptr2;
  540. if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
  541. goto skip_doorbell;
  542. db_base = pci_resource_start(pdev, 4); /* doorbell is on bar 4 */
  543. db_len = pci_resource_len(pdev, 4);
  544. if (db_len == 0) {
  545. printk(KERN_ERR "%s: doorbell is disabled\n",
  546. netxen_nic_driver_name);
  547. err = -EIO;
  548. goto err_out;
  549. }
  550. db_ptr = ioremap(db_base, NETXEN_DB_MAPSIZE_BYTES);
  551. if (!db_ptr) {
  552. printk(KERN_ERR "%s: Failed to allocate doorbell map.",
  553. netxen_nic_driver_name);
  554. err = -EIO;
  555. goto err_out;
  556. }
  557. skip_doorbell:
  558. adapter->ahw.db_base = db_ptr;
  559. adapter->ahw.db_len = db_len;
  560. return 0;
  561. err_out:
  562. netxen_cleanup_pci_map(adapter);
  563. return err;
  564. }
  565. static void
  566. netxen_check_options(struct netxen_adapter *adapter)
  567. {
  568. u32 fw_major, fw_minor, fw_build;
  569. char brd_name[NETXEN_MAX_SHORT_NAME];
  570. char serial_num[32];
  571. int i, offset, val;
  572. int *ptr32;
  573. struct pci_dev *pdev = adapter->pdev;
  574. adapter->driver_mismatch = 0;
  575. ptr32 = (int *)&serial_num;
  576. offset = NX_FW_SERIAL_NUM_OFFSET;
  577. for (i = 0; i < 8; i++) {
  578. if (netxen_rom_fast_read(adapter, offset, &val) == -1) {
  579. dev_err(&pdev->dev, "error reading board info\n");
  580. adapter->driver_mismatch = 1;
  581. return;
  582. }
  583. ptr32[i] = cpu_to_le32(val);
  584. offset += sizeof(u32);
  585. }
  586. fw_major = NXRD32(adapter, NETXEN_FW_VERSION_MAJOR);
  587. fw_minor = NXRD32(adapter, NETXEN_FW_VERSION_MINOR);
  588. fw_build = NXRD32(adapter, NETXEN_FW_VERSION_SUB);
  589. adapter->fw_version = NETXEN_VERSION_CODE(fw_major, fw_minor, fw_build);
  590. if (adapter->portnum == 0) {
  591. get_brd_name_by_type(adapter->ahw.board_type, brd_name);
  592. printk(KERN_INFO "NetXen %s Board S/N %s Chip rev 0x%x\n",
  593. brd_name, serial_num, adapter->ahw.revision_id);
  594. }
  595. if (adapter->fw_version < NETXEN_VERSION_CODE(3, 4, 216)) {
  596. adapter->driver_mismatch = 1;
  597. dev_warn(&pdev->dev, "firmware version %d.%d.%d unsupported\n",
  598. fw_major, fw_minor, fw_build);
  599. return;
  600. }
  601. if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
  602. i = NXRD32(adapter, NETXEN_SRE_MISC);
  603. adapter->ahw.cut_through = (i & 0x8000) ? 1 : 0;
  604. }
  605. dev_info(&pdev->dev, "firmware v%d.%d.%d [%s]\n",
  606. fw_major, fw_minor, fw_build,
  607. adapter->ahw.cut_through ? "cut-through" : "legacy");
  608. if (adapter->fw_version >= NETXEN_VERSION_CODE(4, 0, 222))
  609. adapter->capabilities = NXRD32(adapter, CRB_FW_CAPABILITIES_1);
  610. adapter->flags &= ~NETXEN_NIC_LRO_ENABLED;
  611. if (adapter->ahw.port_type == NETXEN_NIC_XGBE) {
  612. adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
  613. adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
  614. } else if (adapter->ahw.port_type == NETXEN_NIC_GBE) {
  615. adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
  616. adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
  617. }
  618. adapter->msix_supported = 0;
  619. if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
  620. adapter->msix_supported = !!use_msi_x;
  621. adapter->rss_supported = !!use_msi_x;
  622. } else if (adapter->fw_version >= NETXEN_VERSION_CODE(3, 4, 336)) {
  623. switch (adapter->ahw.board_type) {
  624. case NETXEN_BRDTYPE_P2_SB31_10G:
  625. case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
  626. adapter->msix_supported = !!use_msi_x;
  627. adapter->rss_supported = !!use_msi_x;
  628. break;
  629. default:
  630. break;
  631. }
  632. }
  633. adapter->num_txd = MAX_CMD_DESCRIPTORS;
  634. if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
  635. adapter->num_lro_rxd = MAX_LRO_RCV_DESCRIPTORS;
  636. adapter->max_rds_rings = 3;
  637. } else {
  638. adapter->num_lro_rxd = 0;
  639. adapter->max_rds_rings = 2;
  640. }
  641. }
  642. static int
  643. netxen_start_firmware(struct netxen_adapter *adapter)
  644. {
  645. int val, err, first_boot;
  646. struct pci_dev *pdev = adapter->pdev;
  647. /* required for NX2031 dummy dma */
  648. err = nx_set_dma_mask(adapter);
  649. if (err)
  650. return err;
  651. if (!netxen_can_start_firmware(adapter))
  652. goto wait_init;
  653. first_boot = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
  654. err = netxen_check_hw_init(adapter, first_boot);
  655. if (err) {
  656. dev_err(&pdev->dev, "error in init HW init sequence\n");
  657. return err;
  658. }
  659. netxen_request_firmware(adapter);
  660. err = netxen_need_fw_reset(adapter);
  661. if (err < 0)
  662. goto err_out;
  663. if (err == 0)
  664. goto ready;
  665. if (first_boot != 0x55555555) {
  666. NXWR32(adapter, CRB_CMDPEG_STATE, 0);
  667. netxen_pinit_from_rom(adapter, 0);
  668. msleep(1);
  669. }
  670. NXWR32(adapter, CRB_DMA_SHIFT, 0x55555555);
  671. NXWR32(adapter, NETXEN_PEG_HALT_STATUS1, 0);
  672. NXWR32(adapter, NETXEN_PEG_HALT_STATUS2, 0);
  673. if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
  674. netxen_set_port_mode(adapter);
  675. err = netxen_load_firmware(adapter);
  676. if (err)
  677. goto err_out;
  678. netxen_release_firmware(adapter);
  679. if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
  680. /* Initialize multicast addr pool owners */
  681. val = 0x7654;
  682. if (adapter->ahw.port_type == NETXEN_NIC_XGBE)
  683. val |= 0x0f000000;
  684. NXWR32(adapter, NETXEN_MAC_ADDR_CNTL_REG, val);
  685. }
  686. err = netxen_init_dummy_dma(adapter);
  687. if (err)
  688. goto err_out;
  689. /*
  690. * Tell the hardware our version number.
  691. */
  692. val = (_NETXEN_NIC_LINUX_MAJOR << 16)
  693. | ((_NETXEN_NIC_LINUX_MINOR << 8))
  694. | (_NETXEN_NIC_LINUX_SUBVERSION);
  695. NXWR32(adapter, CRB_DRIVER_VERSION, val);
  696. ready:
  697. NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_READY);
  698. wait_init:
  699. /* Handshake with the card before we register the devices. */
  700. err = netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
  701. if (err) {
  702. netxen_free_dummy_dma(adapter);
  703. goto err_out;
  704. }
  705. nx_update_dma_mask(adapter);
  706. netxen_check_options(adapter);
  707. adapter->need_fw_reset = 0;
  708. /* fall through and release firmware */
  709. err_out:
  710. netxen_release_firmware(adapter);
  711. return err;
  712. }
  713. static int
  714. netxen_nic_request_irq(struct netxen_adapter *adapter)
  715. {
  716. irq_handler_t handler;
  717. struct nx_host_sds_ring *sds_ring;
  718. int err, ring;
  719. unsigned long flags = IRQF_SAMPLE_RANDOM;
  720. struct net_device *netdev = adapter->netdev;
  721. struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
  722. if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
  723. handler = netxen_msix_intr;
  724. else if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
  725. handler = netxen_msi_intr;
  726. else {
  727. flags |= IRQF_SHARED;
  728. handler = netxen_intr;
  729. }
  730. adapter->irq = netdev->irq;
  731. for (ring = 0; ring < adapter->max_sds_rings; ring++) {
  732. sds_ring = &recv_ctx->sds_rings[ring];
  733. sprintf(sds_ring->name, "%s[%d]", netdev->name, ring);
  734. err = request_irq(sds_ring->irq, handler,
  735. flags, sds_ring->name, sds_ring);
  736. if (err)
  737. return err;
  738. }
  739. return 0;
  740. }
  741. static void
  742. netxen_nic_free_irq(struct netxen_adapter *adapter)
  743. {
  744. int ring;
  745. struct nx_host_sds_ring *sds_ring;
  746. struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
  747. for (ring = 0; ring < adapter->max_sds_rings; ring++) {
  748. sds_ring = &recv_ctx->sds_rings[ring];
  749. free_irq(sds_ring->irq, sds_ring);
  750. }
  751. }
  752. static void
  753. netxen_nic_init_coalesce_defaults(struct netxen_adapter *adapter)
  754. {
  755. adapter->coal.flags = NETXEN_NIC_INTR_DEFAULT;
  756. adapter->coal.normal.data.rx_time_us =
  757. NETXEN_DEFAULT_INTR_COALESCE_RX_TIME_US;
  758. adapter->coal.normal.data.rx_packets =
  759. NETXEN_DEFAULT_INTR_COALESCE_RX_PACKETS;
  760. adapter->coal.normal.data.tx_time_us =
  761. NETXEN_DEFAULT_INTR_COALESCE_TX_TIME_US;
  762. adapter->coal.normal.data.tx_packets =
  763. NETXEN_DEFAULT_INTR_COALESCE_TX_PACKETS;
  764. }
  765. static int
  766. netxen_nic_up(struct netxen_adapter *adapter, struct net_device *netdev)
  767. {
  768. int err;
  769. if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
  770. return -EIO;
  771. err = adapter->init_port(adapter, adapter->physical_port);
  772. if (err) {
  773. printk(KERN_ERR "%s: Failed to initialize port %d\n",
  774. netxen_nic_driver_name, adapter->portnum);
  775. return err;
  776. }
  777. if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
  778. adapter->macaddr_set(adapter, netdev->dev_addr);
  779. adapter->set_multi(netdev);
  780. adapter->set_mtu(adapter, netdev->mtu);
  781. adapter->ahw.linkup = 0;
  782. if (adapter->max_sds_rings > 1)
  783. netxen_config_rss(adapter, 1);
  784. if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
  785. netxen_config_intr_coalesce(adapter);
  786. if (adapter->capabilities & NX_FW_CAPABILITY_HW_LRO)
  787. netxen_config_hw_lro(adapter, NETXEN_NIC_LRO_ENABLED);
  788. netxen_napi_enable(adapter);
  789. if (adapter->capabilities & NX_FW_CAPABILITY_LINK_NOTIFICATION)
  790. netxen_linkevent_request(adapter, 1);
  791. else
  792. netxen_nic_set_link_parameters(adapter);
  793. set_bit(__NX_DEV_UP, &adapter->state);
  794. return 0;
  795. }
  796. static void
  797. netxen_nic_down(struct netxen_adapter *adapter, struct net_device *netdev)
  798. {
  799. if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
  800. return;
  801. clear_bit(__NX_DEV_UP, &adapter->state);
  802. spin_lock(&adapter->tx_clean_lock);
  803. netif_carrier_off(netdev);
  804. netif_tx_disable(netdev);
  805. if (adapter->stop_port)
  806. adapter->stop_port(adapter);
  807. if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
  808. netxen_p3_free_mac_list(adapter);
  809. adapter->set_promisc(adapter, NETXEN_NIU_NON_PROMISC_MODE);
  810. netxen_napi_disable(adapter);
  811. netxen_release_tx_buffers(adapter);
  812. spin_unlock(&adapter->tx_clean_lock);
  813. }
  814. static int
  815. netxen_nic_attach(struct netxen_adapter *adapter)
  816. {
  817. struct net_device *netdev = adapter->netdev;
  818. struct pci_dev *pdev = adapter->pdev;
  819. int err, ring;
  820. struct nx_host_rds_ring *rds_ring;
  821. struct nx_host_tx_ring *tx_ring;
  822. if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC)
  823. return 0;
  824. err = netxen_init_firmware(adapter);
  825. if (err)
  826. return err;
  827. err = netxen_napi_add(adapter, netdev);
  828. if (err)
  829. return err;
  830. err = netxen_alloc_sw_resources(adapter);
  831. if (err) {
  832. printk(KERN_ERR "%s: Error in setting sw resources\n",
  833. netdev->name);
  834. return err;
  835. }
  836. err = netxen_alloc_hw_resources(adapter);
  837. if (err) {
  838. printk(KERN_ERR "%s: Error in setting hw resources\n",
  839. netdev->name);
  840. goto err_out_free_sw;
  841. }
  842. if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
  843. tx_ring = adapter->tx_ring;
  844. tx_ring->crb_cmd_producer = netxen_get_ioaddr(adapter,
  845. crb_cmd_producer[adapter->portnum]);
  846. tx_ring->crb_cmd_consumer = netxen_get_ioaddr(adapter,
  847. crb_cmd_consumer[adapter->portnum]);
  848. tx_ring->producer = 0;
  849. tx_ring->sw_consumer = 0;
  850. netxen_nic_update_cmd_producer(adapter, tx_ring);
  851. netxen_nic_update_cmd_consumer(adapter, tx_ring);
  852. }
  853. for (ring = 0; ring < adapter->max_rds_rings; ring++) {
  854. rds_ring = &adapter->recv_ctx.rds_rings[ring];
  855. netxen_post_rx_buffers(adapter, ring, rds_ring);
  856. }
  857. err = netxen_nic_request_irq(adapter);
  858. if (err) {
  859. dev_err(&pdev->dev, "%s: failed to setup interrupt\n",
  860. netdev->name);
  861. goto err_out_free_rxbuf;
  862. }
  863. if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
  864. netxen_nic_init_coalesce_defaults(adapter);
  865. netxen_create_sysfs_entries(adapter);
  866. adapter->is_up = NETXEN_ADAPTER_UP_MAGIC;
  867. return 0;
  868. err_out_free_rxbuf:
  869. netxen_release_rx_buffers(adapter);
  870. netxen_free_hw_resources(adapter);
  871. err_out_free_sw:
  872. netxen_free_sw_resources(adapter);
  873. return err;
  874. }
  875. static void
  876. netxen_nic_detach(struct netxen_adapter *adapter)
  877. {
  878. if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
  879. return;
  880. netxen_remove_sysfs_entries(adapter);
  881. netxen_free_hw_resources(adapter);
  882. netxen_release_rx_buffers(adapter);
  883. netxen_nic_free_irq(adapter);
  884. netxen_napi_del(adapter);
  885. netxen_free_sw_resources(adapter);
  886. adapter->is_up = 0;
  887. }
  888. int
  889. netxen_nic_reset_context(struct netxen_adapter *adapter)
  890. {
  891. int err = 0;
  892. struct net_device *netdev = adapter->netdev;
  893. if (test_and_set_bit(__NX_RESETTING, &adapter->state))
  894. return -EBUSY;
  895. if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC) {
  896. netif_device_detach(netdev);
  897. if (netif_running(netdev))
  898. netxen_nic_down(adapter, netdev);
  899. netxen_nic_detach(adapter);
  900. if (netif_running(netdev)) {
  901. err = netxen_nic_attach(adapter);
  902. if (!err)
  903. err = netxen_nic_up(adapter, netdev);
  904. if (err)
  905. goto done;
  906. }
  907. netif_device_attach(netdev);
  908. }
  909. done:
  910. clear_bit(__NX_RESETTING, &adapter->state);
  911. return err;
  912. }
  913. static int
  914. netxen_setup_netdev(struct netxen_adapter *adapter,
  915. struct net_device *netdev)
  916. {
  917. int err = 0;
  918. struct pci_dev *pdev = adapter->pdev;
  919. adapter->rx_csum = 1;
  920. adapter->mc_enabled = 0;
  921. if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
  922. adapter->max_mc_count = 38;
  923. else
  924. adapter->max_mc_count = 16;
  925. netdev->netdev_ops = &netxen_netdev_ops;
  926. netdev->watchdog_timeo = 2*HZ;
  927. netxen_nic_change_mtu(netdev, netdev->mtu);
  928. SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
  929. netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
  930. netdev->features |= (NETIF_F_GRO);
  931. netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
  932. if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
  933. netdev->features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
  934. netdev->vlan_features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
  935. }
  936. if (adapter->pci_using_dac) {
  937. netdev->features |= NETIF_F_HIGHDMA;
  938. netdev->vlan_features |= NETIF_F_HIGHDMA;
  939. }
  940. if (adapter->capabilities & NX_FW_CAPABILITY_FVLANTX)
  941. netdev->features |= (NETIF_F_HW_VLAN_TX);
  942. if (adapter->capabilities & NX_FW_CAPABILITY_HW_LRO)
  943. netdev->features |= NETIF_F_LRO;
  944. netdev->irq = adapter->msix_entries[0].vector;
  945. INIT_WORK(&adapter->tx_timeout_task, netxen_tx_timeout_task);
  946. if (netxen_read_mac_addr(adapter))
  947. dev_warn(&pdev->dev, "failed to read mac addr\n");
  948. netif_carrier_off(netdev);
  949. netif_stop_queue(netdev);
  950. err = register_netdev(netdev);
  951. if (err) {
  952. dev_err(&pdev->dev, "failed to register net device\n");
  953. return err;
  954. }
  955. return 0;
  956. }
  957. static int __devinit
  958. netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
  959. {
  960. struct net_device *netdev = NULL;
  961. struct netxen_adapter *adapter = NULL;
  962. int i = 0, err;
  963. int pci_func_id = PCI_FUNC(pdev->devfn);
  964. uint8_t revision_id;
  965. if (pdev->class != 0x020000) {
  966. printk(KERN_DEBUG "NetXen function %d, class %x will not "
  967. "be enabled.\n",pci_func_id, pdev->class);
  968. return -ENODEV;
  969. }
  970. if (pdev->revision >= NX_P3_A0 && pdev->revision < NX_P3_B1) {
  971. printk(KERN_WARNING "NetXen chip revisions between 0x%x-0x%x"
  972. "will not be enabled.\n",
  973. NX_P3_A0, NX_P3_B1);
  974. return -ENODEV;
  975. }
  976. if ((err = pci_enable_device(pdev)))
  977. return err;
  978. if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
  979. err = -ENODEV;
  980. goto err_out_disable_pdev;
  981. }
  982. if ((err = pci_request_regions(pdev, netxen_nic_driver_name)))
  983. goto err_out_disable_pdev;
  984. pci_set_master(pdev);
  985. netdev = alloc_etherdev(sizeof(struct netxen_adapter));
  986. if(!netdev) {
  987. dev_err(&pdev->dev, "failed to allocate net_device\n");
  988. err = -ENOMEM;
  989. goto err_out_free_res;
  990. }
  991. SET_NETDEV_DEV(netdev, &pdev->dev);
  992. adapter = netdev_priv(netdev);
  993. adapter->netdev = netdev;
  994. adapter->pdev = pdev;
  995. adapter->ahw.pci_func = pci_func_id;
  996. revision_id = pdev->revision;
  997. adapter->ahw.revision_id = revision_id;
  998. rwlock_init(&adapter->adapter_lock);
  999. spin_lock_init(&adapter->tx_clean_lock);
  1000. INIT_LIST_HEAD(&adapter->mac_list);
  1001. err = netxen_setup_pci_map(adapter);
  1002. if (err)
  1003. goto err_out_free_netdev;
  1004. /* This will be reset for mezz cards */
  1005. adapter->portnum = pci_func_id;
  1006. err = netxen_nic_get_board_info(adapter);
  1007. if (err) {
  1008. dev_err(&pdev->dev, "Error getting board config info.\n");
  1009. goto err_out_iounmap;
  1010. }
  1011. /* Mezz cards have PCI function 0,2,3 enabled */
  1012. switch (adapter->ahw.board_type) {
  1013. case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ:
  1014. case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ:
  1015. if (pci_func_id >= 2)
  1016. adapter->portnum = pci_func_id - 2;
  1017. break;
  1018. default:
  1019. break;
  1020. }
  1021. err = netxen_start_firmware(adapter);
  1022. if (err)
  1023. goto err_out_iounmap;
  1024. /*
  1025. * See if the firmware gave us a virtual-physical port mapping.
  1026. */
  1027. adapter->physical_port = adapter->portnum;
  1028. if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
  1029. i = NXRD32(adapter, CRB_V2P(adapter->portnum));
  1030. if (i != 0x55555555)
  1031. adapter->physical_port = i;
  1032. }
  1033. netxen_nic_clear_stats(adapter);
  1034. netxen_setup_intr(adapter);
  1035. err = netxen_setup_netdev(adapter, netdev);
  1036. if (err)
  1037. goto err_out_disable_msi;
  1038. pci_set_drvdata(pdev, adapter);
  1039. netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
  1040. switch (adapter->ahw.port_type) {
  1041. case NETXEN_NIC_GBE:
  1042. dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
  1043. adapter->netdev->name);
  1044. break;
  1045. case NETXEN_NIC_XGBE:
  1046. dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
  1047. adapter->netdev->name);
  1048. break;
  1049. }
  1050. return 0;
  1051. err_out_disable_msi:
  1052. netxen_teardown_intr(adapter);
  1053. netxen_free_dummy_dma(adapter);
  1054. nx_decr_dev_ref_cnt(adapter);
  1055. err_out_iounmap:
  1056. netxen_cleanup_pci_map(adapter);
  1057. err_out_free_netdev:
  1058. free_netdev(netdev);
  1059. err_out_free_res:
  1060. pci_release_regions(pdev);
  1061. err_out_disable_pdev:
  1062. pci_set_drvdata(pdev, NULL);
  1063. pci_disable_device(pdev);
  1064. return err;
  1065. }
  1066. static void __devexit netxen_nic_remove(struct pci_dev *pdev)
  1067. {
  1068. struct netxen_adapter *adapter;
  1069. struct net_device *netdev;
  1070. adapter = pci_get_drvdata(pdev);
  1071. if (adapter == NULL)
  1072. return;
  1073. netdev = adapter->netdev;
  1074. netxen_cancel_fw_work(adapter);
  1075. unregister_netdev(netdev);
  1076. cancel_work_sync(&adapter->tx_timeout_task);
  1077. netxen_nic_detach(adapter);
  1078. nx_decr_dev_ref_cnt(adapter);
  1079. if (adapter->portnum == 0)
  1080. netxen_free_dummy_dma(adapter);
  1081. clear_bit(__NX_RESETTING, &adapter->state);
  1082. netxen_teardown_intr(adapter);
  1083. netxen_cleanup_pci_map(adapter);
  1084. netxen_release_firmware(adapter);
  1085. pci_release_regions(pdev);
  1086. pci_disable_device(pdev);
  1087. pci_set_drvdata(pdev, NULL);
  1088. free_netdev(netdev);
  1089. }
  1090. static int __netxen_nic_shutdown(struct pci_dev *pdev)
  1091. {
  1092. struct netxen_adapter *adapter = pci_get_drvdata(pdev);
  1093. struct net_device *netdev = adapter->netdev;
  1094. int retval;
  1095. netif_device_detach(netdev);
  1096. netxen_cancel_fw_work(adapter);
  1097. if (netif_running(netdev))
  1098. netxen_nic_down(adapter, netdev);
  1099. cancel_work_sync(&adapter->tx_timeout_task);
  1100. netxen_nic_detach(adapter);
  1101. if (adapter->portnum == 0)
  1102. netxen_free_dummy_dma(adapter);
  1103. nx_decr_dev_ref_cnt(adapter);
  1104. clear_bit(__NX_RESETTING, &adapter->state);
  1105. retval = pci_save_state(pdev);
  1106. if (retval)
  1107. return retval;
  1108. if (netxen_nic_wol_supported(adapter)) {
  1109. pci_enable_wake(pdev, PCI_D3cold, 1);
  1110. pci_enable_wake(pdev, PCI_D3hot, 1);
  1111. }
  1112. pci_disable_device(pdev);
  1113. return 0;
  1114. }
  1115. static void netxen_nic_shutdown(struct pci_dev *pdev)
  1116. {
  1117. if (__netxen_nic_shutdown(pdev))
  1118. return;
  1119. }
  1120. #ifdef CONFIG_PM
  1121. static int
  1122. netxen_nic_suspend(struct pci_dev *pdev, pm_message_t state)
  1123. {
  1124. int retval;
  1125. retval = __netxen_nic_shutdown(pdev);
  1126. if (retval)
  1127. return retval;
  1128. pci_set_power_state(pdev, pci_choose_state(pdev, state));
  1129. return 0;
  1130. }
  1131. static int
  1132. netxen_nic_resume(struct pci_dev *pdev)
  1133. {
  1134. struct netxen_adapter *adapter = pci_get_drvdata(pdev);
  1135. struct net_device *netdev = adapter->netdev;
  1136. int err;
  1137. pci_set_power_state(pdev, PCI_D0);
  1138. pci_restore_state(pdev);
  1139. err = pci_enable_device(pdev);
  1140. if (err)
  1141. return err;
  1142. adapter->curr_window = 255;
  1143. err = netxen_start_firmware(adapter);
  1144. if (err) {
  1145. dev_err(&pdev->dev, "failed to start firmware\n");
  1146. return err;
  1147. }
  1148. if (netif_running(netdev)) {
  1149. err = netxen_nic_attach(adapter);
  1150. if (err)
  1151. goto err_out;
  1152. err = netxen_nic_up(adapter, netdev);
  1153. if (err)
  1154. goto err_out_detach;
  1155. netif_device_attach(netdev);
  1156. netxen_config_indev_addr(netdev, NETDEV_UP);
  1157. }
  1158. netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
  1159. return 0;
  1160. err_out_detach:
  1161. netxen_nic_detach(adapter);
  1162. err_out:
  1163. nx_decr_dev_ref_cnt(adapter);
  1164. return err;
  1165. }
  1166. #endif
  1167. static int netxen_nic_open(struct net_device *netdev)
  1168. {
  1169. struct netxen_adapter *adapter = netdev_priv(netdev);
  1170. int err = 0;
  1171. if (adapter->driver_mismatch)
  1172. return -EIO;
  1173. err = netxen_nic_attach(adapter);
  1174. if (err)
  1175. return err;
  1176. err = netxen_nic_up(adapter, netdev);
  1177. if (err)
  1178. goto err_out;
  1179. netif_start_queue(netdev);
  1180. return 0;
  1181. err_out:
  1182. netxen_nic_detach(adapter);
  1183. return err;
  1184. }
  1185. /*
  1186. * netxen_nic_close - Disables a network interface entry point
  1187. */
  1188. static int netxen_nic_close(struct net_device *netdev)
  1189. {
  1190. struct netxen_adapter *adapter = netdev_priv(netdev);
  1191. netxen_nic_down(adapter, netdev);
  1192. return 0;
  1193. }
  1194. static void
  1195. netxen_tso_check(struct net_device *netdev,
  1196. struct nx_host_tx_ring *tx_ring,
  1197. struct cmd_desc_type0 *first_desc,
  1198. struct sk_buff *skb)
  1199. {
  1200. u8 opcode = TX_ETHER_PKT;
  1201. __be16 protocol = skb->protocol;
  1202. u16 flags = 0, vid = 0;
  1203. u32 producer;
  1204. int copied, offset, copy_len, hdr_len = 0, tso = 0, vlan_oob = 0;
  1205. struct cmd_desc_type0 *hwdesc;
  1206. struct vlan_ethhdr *vh;
  1207. if (protocol == cpu_to_be16(ETH_P_8021Q)) {
  1208. vh = (struct vlan_ethhdr *)skb->data;
  1209. protocol = vh->h_vlan_encapsulated_proto;
  1210. flags = FLAGS_VLAN_TAGGED;
  1211. } else if (vlan_tx_tag_present(skb)) {
  1212. flags = FLAGS_VLAN_OOB;
  1213. vid = vlan_tx_tag_get(skb);
  1214. netxen_set_tx_vlan_tci(first_desc, vid);
  1215. vlan_oob = 1;
  1216. }
  1217. if ((netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
  1218. skb_shinfo(skb)->gso_size > 0) {
  1219. hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
  1220. first_desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
  1221. first_desc->total_hdr_length = hdr_len;
  1222. if (vlan_oob) {
  1223. first_desc->total_hdr_length += VLAN_HLEN;
  1224. first_desc->tcp_hdr_offset = VLAN_HLEN;
  1225. first_desc->ip_hdr_offset = VLAN_HLEN;
  1226. /* Only in case of TSO on vlan device */
  1227. flags |= FLAGS_VLAN_TAGGED;
  1228. }
  1229. opcode = (protocol == cpu_to_be16(ETH_P_IPV6)) ?
  1230. TX_TCP_LSO6 : TX_TCP_LSO;
  1231. tso = 1;
  1232. } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
  1233. u8 l4proto;
  1234. if (protocol == cpu_to_be16(ETH_P_IP)) {
  1235. l4proto = ip_hdr(skb)->protocol;
  1236. if (l4proto == IPPROTO_TCP)
  1237. opcode = TX_TCP_PKT;
  1238. else if(l4proto == IPPROTO_UDP)
  1239. opcode = TX_UDP_PKT;
  1240. } else if (protocol == cpu_to_be16(ETH_P_IPV6)) {
  1241. l4proto = ipv6_hdr(skb)->nexthdr;
  1242. if (l4proto == IPPROTO_TCP)
  1243. opcode = TX_TCPV6_PKT;
  1244. else if(l4proto == IPPROTO_UDP)
  1245. opcode = TX_UDPV6_PKT;
  1246. }
  1247. }
  1248. first_desc->tcp_hdr_offset += skb_transport_offset(skb);
  1249. first_desc->ip_hdr_offset += skb_network_offset(skb);
  1250. netxen_set_tx_flags_opcode(first_desc, flags, opcode);
  1251. if (!tso)
  1252. return;
  1253. /* For LSO, we need to copy the MAC/IP/TCP headers into
  1254. * the descriptor ring
  1255. */
  1256. producer = tx_ring->producer;
  1257. copied = 0;
  1258. offset = 2;
  1259. if (vlan_oob) {
  1260. /* Create a TSO vlan header template for firmware */
  1261. hwdesc = &tx_ring->desc_head[producer];
  1262. tx_ring->cmd_buf_arr[producer].skb = NULL;
  1263. copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
  1264. hdr_len + VLAN_HLEN);
  1265. vh = (struct vlan_ethhdr *)((char *)hwdesc + 2);
  1266. skb_copy_from_linear_data(skb, vh, 12);
  1267. vh->h_vlan_proto = htons(ETH_P_8021Q);
  1268. vh->h_vlan_TCI = htons(vid);
  1269. skb_copy_from_linear_data_offset(skb, 12,
  1270. (char *)vh + 16, copy_len - 16);
  1271. copied = copy_len - VLAN_HLEN;
  1272. offset = 0;
  1273. producer = get_next_index(producer, tx_ring->num_desc);
  1274. }
  1275. while (copied < hdr_len) {
  1276. copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
  1277. (hdr_len - copied));
  1278. hwdesc = &tx_ring->desc_head[producer];
  1279. tx_ring->cmd_buf_arr[producer].skb = NULL;
  1280. skb_copy_from_linear_data_offset(skb, copied,
  1281. (char *)hwdesc + offset, copy_len);
  1282. copied += copy_len;
  1283. offset = 0;
  1284. producer = get_next_index(producer, tx_ring->num_desc);
  1285. }
  1286. tx_ring->producer = producer;
  1287. barrier();
  1288. }
  1289. static int
  1290. netxen_map_tx_skb(struct pci_dev *pdev,
  1291. struct sk_buff *skb, struct netxen_cmd_buffer *pbuf)
  1292. {
  1293. struct netxen_skb_frag *nf;
  1294. struct skb_frag_struct *frag;
  1295. int i, nr_frags;
  1296. dma_addr_t map;
  1297. nr_frags = skb_shinfo(skb)->nr_frags;
  1298. nf = &pbuf->frag_array[0];
  1299. map = pci_map_single(pdev, skb->data,
  1300. skb_headlen(skb), PCI_DMA_TODEVICE);
  1301. if (pci_dma_mapping_error(pdev, map))
  1302. goto out_err;
  1303. nf->dma = map;
  1304. nf->length = skb_headlen(skb);
  1305. for (i = 0; i < nr_frags; i++) {
  1306. frag = &skb_shinfo(skb)->frags[i];
  1307. nf = &pbuf->frag_array[i+1];
  1308. map = pci_map_page(pdev, frag->page, frag->page_offset,
  1309. frag->size, PCI_DMA_TODEVICE);
  1310. if (pci_dma_mapping_error(pdev, map))
  1311. goto unwind;
  1312. nf->dma = map;
  1313. nf->length = frag->size;
  1314. }
  1315. return 0;
  1316. unwind:
  1317. while (--i >= 0) {
  1318. nf = &pbuf->frag_array[i+1];
  1319. pci_unmap_page(pdev, nf->dma, nf->length, PCI_DMA_TODEVICE);
  1320. }
  1321. nf = &pbuf->frag_array[0];
  1322. pci_unmap_single(pdev, nf->dma, skb_headlen(skb), PCI_DMA_TODEVICE);
  1323. out_err:
  1324. return -ENOMEM;
  1325. }
  1326. static inline void
  1327. netxen_clear_cmddesc(u64 *desc)
  1328. {
  1329. desc[0] = 0ULL;
  1330. desc[2] = 0ULL;
  1331. }
  1332. static netdev_tx_t
  1333. netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
  1334. {
  1335. struct netxen_adapter *adapter = netdev_priv(netdev);
  1336. struct nx_host_tx_ring *tx_ring = adapter->tx_ring;
  1337. struct netxen_cmd_buffer *pbuf;
  1338. struct netxen_skb_frag *buffrag;
  1339. struct cmd_desc_type0 *hwdesc, *first_desc;
  1340. struct pci_dev *pdev;
  1341. int i, k;
  1342. u32 producer;
  1343. int frag_count, no_of_desc;
  1344. u32 num_txd = tx_ring->num_desc;
  1345. frag_count = skb_shinfo(skb)->nr_frags + 1;
  1346. /* 4 fragments per cmd des */
  1347. no_of_desc = (frag_count + 3) >> 2;
  1348. if (unlikely(no_of_desc + 2 > netxen_tx_avail(tx_ring))) {
  1349. netif_stop_queue(netdev);
  1350. return NETDEV_TX_BUSY;
  1351. }
  1352. producer = tx_ring->producer;
  1353. pbuf = &tx_ring->cmd_buf_arr[producer];
  1354. pdev = adapter->pdev;
  1355. if (netxen_map_tx_skb(pdev, skb, pbuf))
  1356. goto drop_packet;
  1357. pbuf->skb = skb;
  1358. pbuf->frag_count = frag_count;
  1359. first_desc = hwdesc = &tx_ring->desc_head[producer];
  1360. netxen_clear_cmddesc((u64 *)hwdesc);
  1361. netxen_set_tx_frags_len(first_desc, frag_count, skb->len);
  1362. netxen_set_tx_port(first_desc, adapter->portnum);
  1363. for (i = 0; i < frag_count; i++) {
  1364. k = i % 4;
  1365. if ((k == 0) && (i > 0)) {
  1366. /* move to next desc.*/
  1367. producer = get_next_index(producer, num_txd);
  1368. hwdesc = &tx_ring->desc_head[producer];
  1369. netxen_clear_cmddesc((u64 *)hwdesc);
  1370. tx_ring->cmd_buf_arr[producer].skb = NULL;
  1371. }
  1372. buffrag = &pbuf->frag_array[i];
  1373. hwdesc->buffer_length[k] = cpu_to_le16(buffrag->length);
  1374. switch (k) {
  1375. case 0:
  1376. hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
  1377. break;
  1378. case 1:
  1379. hwdesc->addr_buffer2 = cpu_to_le64(buffrag->dma);
  1380. break;
  1381. case 2:
  1382. hwdesc->addr_buffer3 = cpu_to_le64(buffrag->dma);
  1383. break;
  1384. case 3:
  1385. hwdesc->addr_buffer4 = cpu_to_le64(buffrag->dma);
  1386. break;
  1387. }
  1388. }
  1389. tx_ring->producer = get_next_index(producer, num_txd);
  1390. netxen_tso_check(netdev, tx_ring, first_desc, skb);
  1391. netxen_nic_update_cmd_producer(adapter, tx_ring);
  1392. adapter->stats.txbytes += skb->len;
  1393. adapter->stats.xmitcalled++;
  1394. return NETDEV_TX_OK;
  1395. drop_packet:
  1396. adapter->stats.txdropped++;
  1397. dev_kfree_skb_any(skb);
  1398. return NETDEV_TX_OK;
  1399. }
  1400. static int netxen_nic_check_temp(struct netxen_adapter *adapter)
  1401. {
  1402. struct net_device *netdev = adapter->netdev;
  1403. uint32_t temp, temp_state, temp_val;
  1404. int rv = 0;
  1405. temp = NXRD32(adapter, CRB_TEMP_STATE);
  1406. temp_state = nx_get_temp_state(temp);
  1407. temp_val = nx_get_temp_val(temp);
  1408. if (temp_state == NX_TEMP_PANIC) {
  1409. printk(KERN_ALERT
  1410. "%s: Device temperature %d degrees C exceeds"
  1411. " maximum allowed. Hardware has been shut down.\n",
  1412. netdev->name, temp_val);
  1413. rv = 1;
  1414. } else if (temp_state == NX_TEMP_WARN) {
  1415. if (adapter->temp == NX_TEMP_NORMAL) {
  1416. printk(KERN_ALERT
  1417. "%s: Device temperature %d degrees C "
  1418. "exceeds operating range."
  1419. " Immediate action needed.\n",
  1420. netdev->name, temp_val);
  1421. }
  1422. } else {
  1423. if (adapter->temp == NX_TEMP_WARN) {
  1424. printk(KERN_INFO
  1425. "%s: Device temperature is now %d degrees C"
  1426. " in normal range.\n", netdev->name,
  1427. temp_val);
  1428. }
  1429. }
  1430. adapter->temp = temp_state;
  1431. return rv;
  1432. }
  1433. void netxen_advert_link_change(struct netxen_adapter *adapter, int linkup)
  1434. {
  1435. struct net_device *netdev = adapter->netdev;
  1436. if (adapter->ahw.linkup && !linkup) {
  1437. printk(KERN_INFO "%s: %s NIC Link is down\n",
  1438. netxen_nic_driver_name, netdev->name);
  1439. adapter->ahw.linkup = 0;
  1440. if (netif_running(netdev)) {
  1441. netif_carrier_off(netdev);
  1442. netif_stop_queue(netdev);
  1443. }
  1444. adapter->link_changed = !adapter->has_link_events;
  1445. } else if (!adapter->ahw.linkup && linkup) {
  1446. printk(KERN_INFO "%s: %s NIC Link is up\n",
  1447. netxen_nic_driver_name, netdev->name);
  1448. adapter->ahw.linkup = 1;
  1449. if (netif_running(netdev)) {
  1450. netif_carrier_on(netdev);
  1451. netif_wake_queue(netdev);
  1452. }
  1453. adapter->link_changed = !adapter->has_link_events;
  1454. }
  1455. }
  1456. static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
  1457. {
  1458. u32 val, port, linkup;
  1459. port = adapter->physical_port;
  1460. if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
  1461. val = NXRD32(adapter, CRB_XG_STATE_P3);
  1462. val = XG_LINK_STATE_P3(adapter->ahw.pci_func, val);
  1463. linkup = (val == XG_LINK_UP_P3);
  1464. } else {
  1465. val = NXRD32(adapter, CRB_XG_STATE);
  1466. if (adapter->ahw.port_type == NETXEN_NIC_GBE)
  1467. linkup = (val >> port) & 1;
  1468. else {
  1469. val = (val >> port*8) & 0xff;
  1470. linkup = (val == XG_LINK_UP);
  1471. }
  1472. }
  1473. netxen_advert_link_change(adapter, linkup);
  1474. }
  1475. static void netxen_tx_timeout(struct net_device *netdev)
  1476. {
  1477. struct netxen_adapter *adapter = netdev_priv(netdev);
  1478. if (test_bit(__NX_RESETTING, &adapter->state))
  1479. return;
  1480. dev_err(&netdev->dev, "transmit timeout, resetting.\n");
  1481. schedule_work(&adapter->tx_timeout_task);
  1482. }
  1483. static void netxen_tx_timeout_task(struct work_struct *work)
  1484. {
  1485. struct netxen_adapter *adapter =
  1486. container_of(work, struct netxen_adapter, tx_timeout_task);
  1487. if (!netif_running(adapter->netdev))
  1488. return;
  1489. if (test_and_set_bit(__NX_RESETTING, &adapter->state))
  1490. return;
  1491. if (++adapter->tx_timeo_cnt >= NX_MAX_TX_TIMEOUTS)
  1492. goto request_reset;
  1493. if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
  1494. /* try to scrub interrupt */
  1495. netxen_napi_disable(adapter);
  1496. adapter->netdev->trans_start = jiffies;
  1497. netxen_napi_enable(adapter);
  1498. netif_wake_queue(adapter->netdev);
  1499. clear_bit(__NX_RESETTING, &adapter->state);
  1500. } else {
  1501. clear_bit(__NX_RESETTING, &adapter->state);
  1502. if (!netxen_nic_reset_context(adapter)) {
  1503. adapter->netdev->trans_start = jiffies;
  1504. return;
  1505. }
  1506. /* context reset failed, fall through for fw reset */
  1507. }
  1508. request_reset:
  1509. adapter->need_fw_reset = 1;
  1510. }
  1511. struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev)
  1512. {
  1513. struct netxen_adapter *adapter = netdev_priv(netdev);
  1514. struct net_device_stats *stats = &adapter->net_stats;
  1515. memset(stats, 0, sizeof(*stats));
  1516. stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
  1517. stats->tx_packets = adapter->stats.xmitfinished;
  1518. stats->rx_bytes = adapter->stats.rxbytes;
  1519. stats->tx_bytes = adapter->stats.txbytes;
  1520. stats->rx_dropped = adapter->stats.rxdropped;
  1521. stats->tx_dropped = adapter->stats.txdropped;
  1522. return stats;
  1523. }
  1524. static irqreturn_t netxen_intr(int irq, void *data)
  1525. {
  1526. struct nx_host_sds_ring *sds_ring = data;
  1527. struct netxen_adapter *adapter = sds_ring->adapter;
  1528. u32 status = 0;
  1529. status = readl(adapter->isr_int_vec);
  1530. if (!(status & adapter->int_vec_bit))
  1531. return IRQ_NONE;
  1532. if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
  1533. /* check interrupt state machine, to be sure */
  1534. status = readl(adapter->crb_int_state_reg);
  1535. if (!ISR_LEGACY_INT_TRIGGERED(status))
  1536. return IRQ_NONE;
  1537. } else {
  1538. unsigned long our_int = 0;
  1539. our_int = readl(adapter->crb_int_state_reg);
  1540. /* not our interrupt */
  1541. if (!test_and_clear_bit((7 + adapter->portnum), &our_int))
  1542. return IRQ_NONE;
  1543. /* claim interrupt */
  1544. writel((our_int & 0xffffffff), adapter->crb_int_state_reg);
  1545. /* clear interrupt */
  1546. netxen_nic_disable_int(sds_ring);
  1547. }
  1548. writel(0xffffffff, adapter->tgt_status_reg);
  1549. /* read twice to ensure write is flushed */
  1550. readl(adapter->isr_int_vec);
  1551. readl(adapter->isr_int_vec);
  1552. napi_schedule(&sds_ring->napi);
  1553. return IRQ_HANDLED;
  1554. }
  1555. static irqreturn_t netxen_msi_intr(int irq, void *data)
  1556. {
  1557. struct nx_host_sds_ring *sds_ring = data;
  1558. struct netxen_adapter *adapter = sds_ring->adapter;
  1559. /* clear interrupt */
  1560. writel(0xffffffff, adapter->tgt_status_reg);
  1561. napi_schedule(&sds_ring->napi);
  1562. return IRQ_HANDLED;
  1563. }
  1564. static irqreturn_t netxen_msix_intr(int irq, void *data)
  1565. {
  1566. struct nx_host_sds_ring *sds_ring = data;
  1567. napi_schedule(&sds_ring->napi);
  1568. return IRQ_HANDLED;
  1569. }
  1570. static int netxen_nic_poll(struct napi_struct *napi, int budget)
  1571. {
  1572. struct nx_host_sds_ring *sds_ring =
  1573. container_of(napi, struct nx_host_sds_ring, napi);
  1574. struct netxen_adapter *adapter = sds_ring->adapter;
  1575. int tx_complete;
  1576. int work_done;
  1577. tx_complete = netxen_process_cmd_ring(adapter);
  1578. work_done = netxen_process_rcv_ring(sds_ring, budget);
  1579. if ((work_done < budget) && tx_complete) {
  1580. napi_complete(&sds_ring->napi);
  1581. if (netif_running(adapter->netdev))
  1582. netxen_nic_enable_int(sds_ring);
  1583. }
  1584. return work_done;
  1585. }
  1586. #ifdef CONFIG_NET_POLL_CONTROLLER
  1587. static void netxen_nic_poll_controller(struct net_device *netdev)
  1588. {
  1589. struct netxen_adapter *adapter = netdev_priv(netdev);
  1590. disable_irq(adapter->irq);
  1591. netxen_intr(adapter->irq, adapter);
  1592. enable_irq(adapter->irq);
  1593. }
  1594. #endif
  1595. static int
  1596. nx_incr_dev_ref_cnt(struct netxen_adapter *adapter)
  1597. {
  1598. int count;
  1599. if (netxen_api_lock(adapter))
  1600. return -EIO;
  1601. count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
  1602. NXWR32(adapter, NX_CRB_DEV_REF_COUNT, ++count);
  1603. netxen_api_unlock(adapter);
  1604. return count;
  1605. }
  1606. static int
  1607. nx_decr_dev_ref_cnt(struct netxen_adapter *adapter)
  1608. {
  1609. int count;
  1610. if (netxen_api_lock(adapter))
  1611. return -EIO;
  1612. count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
  1613. WARN_ON(count == 0);
  1614. NXWR32(adapter, NX_CRB_DEV_REF_COUNT, --count);
  1615. if (count == 0)
  1616. NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_COLD);
  1617. netxen_api_unlock(adapter);
  1618. return count;
  1619. }
  1620. static void
  1621. nx_dev_request_reset(struct netxen_adapter *adapter)
  1622. {
  1623. u32 state;
  1624. if (netxen_api_lock(adapter))
  1625. return;
  1626. state = NXRD32(adapter, NX_CRB_DEV_STATE);
  1627. if (state != NX_DEV_INITALIZING)
  1628. NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_NEED_RESET);
  1629. netxen_api_unlock(adapter);
  1630. }
  1631. static int
  1632. netxen_can_start_firmware(struct netxen_adapter *adapter)
  1633. {
  1634. int count;
  1635. int can_start = 0;
  1636. if (netxen_api_lock(adapter))
  1637. return 0;
  1638. count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
  1639. if ((count < 0) || (count >= NX_MAX_PCI_FUNC))
  1640. count = 0;
  1641. if (count == 0) {
  1642. can_start = 1;
  1643. NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_INITALIZING);
  1644. }
  1645. NXWR32(adapter, NX_CRB_DEV_REF_COUNT, ++count);
  1646. netxen_api_unlock(adapter);
  1647. return can_start;
  1648. }
  1649. static void
  1650. netxen_schedule_work(struct netxen_adapter *adapter,
  1651. work_func_t func, int delay)
  1652. {
  1653. INIT_DELAYED_WORK(&adapter->fw_work, func);
  1654. schedule_delayed_work(&adapter->fw_work, delay);
  1655. }
  1656. static void
  1657. netxen_cancel_fw_work(struct netxen_adapter *adapter)
  1658. {
  1659. while (test_and_set_bit(__NX_RESETTING, &adapter->state))
  1660. msleep(10);
  1661. cancel_delayed_work_sync(&adapter->fw_work);
  1662. }
  1663. static void
  1664. netxen_attach_work(struct work_struct *work)
  1665. {
  1666. struct netxen_adapter *adapter = container_of(work,
  1667. struct netxen_adapter, fw_work.work);
  1668. struct net_device *netdev = adapter->netdev;
  1669. int err = 0;
  1670. if (netif_running(netdev)) {
  1671. err = netxen_nic_attach(adapter);
  1672. if (err)
  1673. goto done;
  1674. err = netxen_nic_up(adapter, netdev);
  1675. if (err) {
  1676. netxen_nic_detach(adapter);
  1677. goto done;
  1678. }
  1679. netxen_config_indev_addr(netdev, NETDEV_UP);
  1680. }
  1681. netif_device_attach(netdev);
  1682. done:
  1683. adapter->fw_fail_cnt = 0;
  1684. clear_bit(__NX_RESETTING, &adapter->state);
  1685. netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
  1686. }
  1687. static void
  1688. netxen_fwinit_work(struct work_struct *work)
  1689. {
  1690. struct netxen_adapter *adapter = container_of(work,
  1691. struct netxen_adapter, fw_work.work);
  1692. int dev_state;
  1693. dev_state = NXRD32(adapter, NX_CRB_DEV_STATE);
  1694. switch (dev_state) {
  1695. case NX_DEV_COLD:
  1696. case NX_DEV_READY:
  1697. if (!netxen_start_firmware(adapter)) {
  1698. netxen_schedule_work(adapter, netxen_attach_work, 0);
  1699. return;
  1700. }
  1701. break;
  1702. case NX_DEV_INITALIZING:
  1703. if (++adapter->fw_wait_cnt < FW_POLL_THRESH) {
  1704. netxen_schedule_work(adapter,
  1705. netxen_fwinit_work, 2 * FW_POLL_DELAY);
  1706. return;
  1707. }
  1708. break;
  1709. case NX_DEV_FAILED:
  1710. default:
  1711. break;
  1712. }
  1713. nx_incr_dev_ref_cnt(adapter);
  1714. clear_bit(__NX_RESETTING, &adapter->state);
  1715. }
  1716. static void
  1717. netxen_detach_work(struct work_struct *work)
  1718. {
  1719. struct netxen_adapter *adapter = container_of(work,
  1720. struct netxen_adapter, fw_work.work);
  1721. struct net_device *netdev = adapter->netdev;
  1722. int ref_cnt, delay;
  1723. u32 status;
  1724. netif_device_detach(netdev);
  1725. if (netif_running(netdev))
  1726. netxen_nic_down(adapter, netdev);
  1727. netxen_nic_detach(adapter);
  1728. status = NXRD32(adapter, NETXEN_PEG_HALT_STATUS1);
  1729. ref_cnt = nx_decr_dev_ref_cnt(adapter);
  1730. if (status & NX_RCODE_FATAL_ERROR)
  1731. return;
  1732. if (adapter->temp == NX_TEMP_PANIC)
  1733. return;
  1734. delay = (ref_cnt == 0) ? 0 : (2 * FW_POLL_DELAY);
  1735. adapter->fw_wait_cnt = 0;
  1736. netxen_schedule_work(adapter, netxen_fwinit_work, delay);
  1737. }
  1738. static int
  1739. netxen_check_health(struct netxen_adapter *adapter)
  1740. {
  1741. u32 state, heartbit;
  1742. struct net_device *netdev = adapter->netdev;
  1743. if (netxen_nic_check_temp(adapter))
  1744. goto detach;
  1745. if (adapter->need_fw_reset) {
  1746. nx_dev_request_reset(adapter);
  1747. goto detach;
  1748. }
  1749. state = NXRD32(adapter, NX_CRB_DEV_STATE);
  1750. if (state == NX_DEV_NEED_RESET)
  1751. goto detach;
  1752. if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
  1753. return 0;
  1754. heartbit = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);
  1755. if (heartbit != adapter->heartbit) {
  1756. adapter->heartbit = heartbit;
  1757. adapter->fw_fail_cnt = 0;
  1758. return 0;
  1759. }
  1760. if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
  1761. return 0;
  1762. clear_bit(__NX_FW_ATTACHED, &adapter->state);
  1763. dev_info(&netdev->dev, "firmware hang detected\n");
  1764. detach:
  1765. if (!test_and_set_bit(__NX_RESETTING, &adapter->state))
  1766. netxen_schedule_work(adapter, netxen_detach_work, 0);
  1767. return 1;
  1768. }
  1769. static void
  1770. netxen_fw_poll_work(struct work_struct *work)
  1771. {
  1772. struct netxen_adapter *adapter = container_of(work,
  1773. struct netxen_adapter, fw_work.work);
  1774. if (test_bit(__NX_RESETTING, &adapter->state))
  1775. goto reschedule;
  1776. if (test_bit(__NX_DEV_UP, &adapter->state)) {
  1777. if (!adapter->has_link_events) {
  1778. netxen_nic_handle_phy_intr(adapter);
  1779. if (adapter->link_changed)
  1780. netxen_nic_set_link_parameters(adapter);
  1781. }
  1782. }
  1783. if (netxen_check_health(adapter))
  1784. return;
  1785. reschedule:
  1786. netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
  1787. }
  1788. static ssize_t
  1789. netxen_store_bridged_mode(struct device *dev,
  1790. struct device_attribute *attr, const char *buf, size_t len)
  1791. {
  1792. struct net_device *net = to_net_dev(dev);
  1793. struct netxen_adapter *adapter = netdev_priv(net);
  1794. unsigned long new;
  1795. int ret = -EINVAL;
  1796. if (!(adapter->capabilities & NX_FW_CAPABILITY_BDG))
  1797. goto err_out;
  1798. if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
  1799. goto err_out;
  1800. if (strict_strtoul(buf, 2, &new))
  1801. goto err_out;
  1802. if (!netxen_config_bridged_mode(adapter, !!new))
  1803. ret = len;
  1804. err_out:
  1805. return ret;
  1806. }
  1807. static ssize_t
  1808. netxen_show_bridged_mode(struct device *dev,
  1809. struct device_attribute *attr, char *buf)
  1810. {
  1811. struct net_device *net = to_net_dev(dev);
  1812. struct netxen_adapter *adapter;
  1813. int bridged_mode = 0;
  1814. adapter = netdev_priv(net);
  1815. if (adapter->capabilities & NX_FW_CAPABILITY_BDG)
  1816. bridged_mode = !!(adapter->flags & NETXEN_NIC_BRIDGE_ENABLED);
  1817. return sprintf(buf, "%d\n", bridged_mode);
  1818. }
  1819. static struct device_attribute dev_attr_bridged_mode = {
  1820. .attr = {.name = "bridged_mode", .mode = (S_IRUGO | S_IWUSR)},
  1821. .show = netxen_show_bridged_mode,
  1822. .store = netxen_store_bridged_mode,
  1823. };
  1824. static void
  1825. netxen_create_sysfs_entries(struct netxen_adapter *adapter)
  1826. {
  1827. struct net_device *netdev = adapter->netdev;
  1828. struct device *dev = &netdev->dev;
  1829. if (adapter->capabilities & NX_FW_CAPABILITY_BDG) {
  1830. /* bridged_mode control */
  1831. if (device_create_file(dev, &dev_attr_bridged_mode)) {
  1832. dev_warn(&netdev->dev,
  1833. "failed to create bridged_mode sysfs entry\n");
  1834. }
  1835. }
  1836. }
  1837. static void
  1838. netxen_remove_sysfs_entries(struct netxen_adapter *adapter)
  1839. {
  1840. struct net_device *netdev = adapter->netdev;
  1841. struct device *dev = &netdev->dev;
  1842. if (adapter->capabilities & NX_FW_CAPABILITY_BDG)
  1843. device_remove_file(dev, &dev_attr_bridged_mode);
  1844. }
  1845. #ifdef CONFIG_INET
  1846. #define is_netxen_netdev(dev) (dev->netdev_ops == &netxen_netdev_ops)
  1847. static int
  1848. netxen_destip_supported(struct netxen_adapter *adapter)
  1849. {
  1850. if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
  1851. return 0;
  1852. if (adapter->ahw.cut_through)
  1853. return 0;
  1854. return 1;
  1855. }
  1856. static void
  1857. netxen_config_indev_addr(struct net_device *dev, unsigned long event)
  1858. {
  1859. struct in_device *indev;
  1860. struct netxen_adapter *adapter = netdev_priv(dev);
  1861. if (!netxen_destip_supported(adapter))
  1862. return;
  1863. indev = in_dev_get(dev);
  1864. if (!indev)
  1865. return;
  1866. for_ifa(indev) {
  1867. switch (event) {
  1868. case NETDEV_UP:
  1869. netxen_config_ipaddr(adapter,
  1870. ifa->ifa_address, NX_IP_UP);
  1871. break;
  1872. case NETDEV_DOWN:
  1873. netxen_config_ipaddr(adapter,
  1874. ifa->ifa_address, NX_IP_DOWN);
  1875. break;
  1876. default:
  1877. break;
  1878. }
  1879. } endfor_ifa(indev);
  1880. in_dev_put(indev);
  1881. return;
  1882. }
  1883. static int netxen_netdev_event(struct notifier_block *this,
  1884. unsigned long event, void *ptr)
  1885. {
  1886. struct netxen_adapter *adapter;
  1887. struct net_device *dev = (struct net_device *)ptr;
  1888. recheck:
  1889. if (dev == NULL)
  1890. goto done;
  1891. if (dev->priv_flags & IFF_802_1Q_VLAN) {
  1892. dev = vlan_dev_real_dev(dev);
  1893. goto recheck;
  1894. }
  1895. if (!is_netxen_netdev(dev))
  1896. goto done;
  1897. adapter = netdev_priv(dev);
  1898. if (!adapter)
  1899. goto done;
  1900. if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
  1901. goto done;
  1902. netxen_config_indev_addr(dev, event);
  1903. done:
  1904. return NOTIFY_DONE;
  1905. }
  1906. static int
  1907. netxen_inetaddr_event(struct notifier_block *this,
  1908. unsigned long event, void *ptr)
  1909. {
  1910. struct netxen_adapter *adapter;
  1911. struct net_device *dev;
  1912. struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
  1913. dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
  1914. recheck:
  1915. if (dev == NULL || !netif_running(dev))
  1916. goto done;
  1917. if (dev->priv_flags & IFF_802_1Q_VLAN) {
  1918. dev = vlan_dev_real_dev(dev);
  1919. goto recheck;
  1920. }
  1921. if (!is_netxen_netdev(dev))
  1922. goto done;
  1923. adapter = netdev_priv(dev);
  1924. if (!adapter || !netxen_destip_supported(adapter))
  1925. goto done;
  1926. if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
  1927. goto done;
  1928. switch (event) {
  1929. case NETDEV_UP:
  1930. netxen_config_ipaddr(adapter, ifa->ifa_address, NX_IP_UP);
  1931. break;
  1932. case NETDEV_DOWN:
  1933. netxen_config_ipaddr(adapter, ifa->ifa_address, NX_IP_DOWN);
  1934. break;
  1935. default:
  1936. break;
  1937. }
  1938. done:
  1939. return NOTIFY_DONE;
  1940. }
  1941. static struct notifier_block netxen_netdev_cb = {
  1942. .notifier_call = netxen_netdev_event,
  1943. };
  1944. static struct notifier_block netxen_inetaddr_cb = {
  1945. .notifier_call = netxen_inetaddr_event,
  1946. };
  1947. #else
  1948. static void
  1949. netxen_config_indev_addr(struct net_device *dev, unsigned long event)
  1950. { }
  1951. #endif
  1952. static struct pci_driver netxen_driver = {
  1953. .name = netxen_nic_driver_name,
  1954. .id_table = netxen_pci_tbl,
  1955. .probe = netxen_nic_probe,
  1956. .remove = __devexit_p(netxen_nic_remove),
  1957. #ifdef CONFIG_PM
  1958. .suspend = netxen_nic_suspend,
  1959. .resume = netxen_nic_resume,
  1960. #endif
  1961. .shutdown = netxen_nic_shutdown
  1962. };
  1963. static int __init netxen_init_module(void)
  1964. {
  1965. printk(KERN_INFO "%s\n", netxen_nic_driver_string);
  1966. #ifdef CONFIG_INET
  1967. register_netdevice_notifier(&netxen_netdev_cb);
  1968. register_inetaddr_notifier(&netxen_inetaddr_cb);
  1969. #endif
  1970. return pci_register_driver(&netxen_driver);
  1971. }
  1972. module_init(netxen_init_module);
  1973. static void __exit netxen_exit_module(void)
  1974. {
  1975. pci_unregister_driver(&netxen_driver);
  1976. #ifdef CONFIG_INET
  1977. unregister_inetaddr_notifier(&netxen_inetaddr_cb);
  1978. unregister_netdevice_notifier(&netxen_netdev_cb);
  1979. #endif
  1980. }
  1981. module_exit(netxen_exit_module);