netxen_nic_main.c 69 KB

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