netxen_nic_main.c 44 KB

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