bfad.c 45 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2005-2014 Brocade Communications Systems, Inc.
  4. * Copyright (c) 2014- QLogic Corporation.
  5. * All rights reserved
  6. * www.qlogic.com
  7. *
  8. * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter.
  9. */
  10. /*
  11. * bfad.c Linux driver PCI interface module.
  12. */
  13. #include <linux/module.h>
  14. #include <linux/kthread.h>
  15. #include <linux/errno.h>
  16. #include <linux/sched.h>
  17. #include <linux/init.h>
  18. #include <linux/fs.h>
  19. #include <linux/pci.h>
  20. #include <linux/firmware.h>
  21. #include <linux/uaccess.h>
  22. #include <asm/fcntl.h>
  23. #include "bfad_drv.h"
  24. #include "bfad_im.h"
  25. #include "bfa_fcs.h"
  26. #include "bfa_defs.h"
  27. #include "bfa.h"
  28. BFA_TRC_FILE(LDRV, BFAD);
  29. DEFINE_MUTEX(bfad_mutex);
  30. LIST_HEAD(bfad_list);
  31. static int bfad_inst;
  32. static int num_sgpgs_parm;
  33. int supported_fc4s;
  34. char *host_name, *os_name, *os_patch;
  35. int num_rports, num_ios, num_tms;
  36. int num_fcxps, num_ufbufs;
  37. int reqq_size, rspq_size, num_sgpgs;
  38. int rport_del_timeout = BFA_FCS_RPORT_DEF_DEL_TIMEOUT;
  39. int bfa_lun_queue_depth = BFAD_LUN_QUEUE_DEPTH;
  40. int bfa_io_max_sge = BFAD_IO_MAX_SGE;
  41. int bfa_log_level = 3; /* WARNING log level */
  42. int ioc_auto_recover = BFA_TRUE;
  43. int bfa_linkup_delay = -1;
  44. int fdmi_enable = BFA_TRUE;
  45. int pcie_max_read_reqsz;
  46. int bfa_debugfs_enable = 1;
  47. int msix_disable_cb = 0, msix_disable_ct = 0;
  48. int max_xfer_size = BFAD_MAX_SECTORS >> 1;
  49. static int max_rport_logins = BFA_FCS_MAX_RPORT_LOGINS;
  50. /* Firmware releated */
  51. u32 bfi_image_cb_size, bfi_image_ct_size, bfi_image_ct2_size;
  52. u32 *bfi_image_cb, *bfi_image_ct, *bfi_image_ct2;
  53. #define BFAD_FW_FILE_CB "cbfw-3.2.5.1.bin"
  54. #define BFAD_FW_FILE_CT "ctfw-3.2.5.1.bin"
  55. #define BFAD_FW_FILE_CT2 "ct2fw-3.2.5.1.bin"
  56. static u32 *bfad_load_fwimg(struct pci_dev *pdev);
  57. static void bfad_free_fwimg(void);
  58. static void bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
  59. u32 *bfi_image_size, char *fw_name);
  60. static const char *msix_name_ct[] = {
  61. "ctrl",
  62. "cpe0", "cpe1", "cpe2", "cpe3",
  63. "rme0", "rme1", "rme2", "rme3" };
  64. static const char *msix_name_cb[] = {
  65. "cpe0", "cpe1", "cpe2", "cpe3",
  66. "rme0", "rme1", "rme2", "rme3",
  67. "eemc", "elpu0", "elpu1", "epss", "mlpu" };
  68. MODULE_FIRMWARE(BFAD_FW_FILE_CB);
  69. MODULE_FIRMWARE(BFAD_FW_FILE_CT);
  70. MODULE_FIRMWARE(BFAD_FW_FILE_CT2);
  71. module_param(os_name, charp, S_IRUGO | S_IWUSR);
  72. MODULE_PARM_DESC(os_name, "OS name of the hba host machine");
  73. module_param(os_patch, charp, S_IRUGO | S_IWUSR);
  74. MODULE_PARM_DESC(os_patch, "OS patch level of the hba host machine");
  75. module_param(host_name, charp, S_IRUGO | S_IWUSR);
  76. MODULE_PARM_DESC(host_name, "Hostname of the hba host machine");
  77. module_param(num_rports, int, S_IRUGO | S_IWUSR);
  78. MODULE_PARM_DESC(num_rports, "Max number of rports supported per port "
  79. "(physical/logical), default=1024");
  80. module_param(num_ios, int, S_IRUGO | S_IWUSR);
  81. MODULE_PARM_DESC(num_ios, "Max number of ioim requests, default=2000");
  82. module_param(num_tms, int, S_IRUGO | S_IWUSR);
  83. MODULE_PARM_DESC(num_tms, "Max number of task im requests, default=128");
  84. module_param(num_fcxps, int, S_IRUGO | S_IWUSR);
  85. MODULE_PARM_DESC(num_fcxps, "Max number of fcxp requests, default=64");
  86. module_param(num_ufbufs, int, S_IRUGO | S_IWUSR);
  87. MODULE_PARM_DESC(num_ufbufs, "Max number of unsolicited frame "
  88. "buffers, default=64");
  89. module_param(reqq_size, int, S_IRUGO | S_IWUSR);
  90. MODULE_PARM_DESC(reqq_size, "Max number of request queue elements, "
  91. "default=256");
  92. module_param(rspq_size, int, S_IRUGO | S_IWUSR);
  93. MODULE_PARM_DESC(rspq_size, "Max number of response queue elements, "
  94. "default=64");
  95. module_param(num_sgpgs, int, S_IRUGO | S_IWUSR);
  96. MODULE_PARM_DESC(num_sgpgs, "Number of scatter/gather pages, default=2048");
  97. module_param(rport_del_timeout, int, S_IRUGO | S_IWUSR);
  98. MODULE_PARM_DESC(rport_del_timeout, "Rport delete timeout, default=90 secs, "
  99. "Range[>0]");
  100. module_param(bfa_lun_queue_depth, int, S_IRUGO | S_IWUSR);
  101. MODULE_PARM_DESC(bfa_lun_queue_depth, "Lun queue depth, default=32, Range[>0]");
  102. module_param(bfa_io_max_sge, int, S_IRUGO | S_IWUSR);
  103. MODULE_PARM_DESC(bfa_io_max_sge, "Max io scatter/gather elements, default=255");
  104. module_param(bfa_log_level, int, S_IRUGO | S_IWUSR);
  105. MODULE_PARM_DESC(bfa_log_level, "Driver log level, default=3, "
  106. "Range[Critical:1|Error:2|Warning:3|Info:4]");
  107. module_param(ioc_auto_recover, int, S_IRUGO | S_IWUSR);
  108. MODULE_PARM_DESC(ioc_auto_recover, "IOC auto recovery, default=1, "
  109. "Range[off:0|on:1]");
  110. module_param(bfa_linkup_delay, int, S_IRUGO | S_IWUSR);
  111. MODULE_PARM_DESC(bfa_linkup_delay, "Link up delay, default=30 secs for "
  112. "boot port. Otherwise 10 secs in RHEL4 & 0 for "
  113. "[RHEL5, SLES10, ESX40] Range[>0]");
  114. module_param(msix_disable_cb, int, S_IRUGO | S_IWUSR);
  115. MODULE_PARM_DESC(msix_disable_cb, "Disable Message Signaled Interrupts for QLogic-415/425/815/825 cards, default=0 Range[false:0|true:1]");
  116. module_param(msix_disable_ct, int, S_IRUGO | S_IWUSR);
  117. MODULE_PARM_DESC(msix_disable_ct, "Disable Message Signaled Interrupts if possible for QLogic-1010/1020/804/1007/902/1741 cards, default=0, Range[false:0|true:1]");
  118. module_param(fdmi_enable, int, S_IRUGO | S_IWUSR);
  119. MODULE_PARM_DESC(fdmi_enable, "Enables fdmi registration, default=1, "
  120. "Range[false:0|true:1]");
  121. module_param(pcie_max_read_reqsz, int, S_IRUGO | S_IWUSR);
  122. MODULE_PARM_DESC(pcie_max_read_reqsz, "PCIe max read request size, default=0 "
  123. "(use system setting), Range[128|256|512|1024|2048|4096]");
  124. module_param(bfa_debugfs_enable, int, S_IRUGO | S_IWUSR);
  125. MODULE_PARM_DESC(bfa_debugfs_enable, "Enables debugfs feature, default=1,"
  126. " Range[false:0|true:1]");
  127. module_param(max_xfer_size, int, S_IRUGO | S_IWUSR);
  128. MODULE_PARM_DESC(max_xfer_size, "default=32MB,"
  129. " Range[64k|128k|256k|512k|1024k|2048k]");
  130. module_param(max_rport_logins, int, S_IRUGO | S_IWUSR);
  131. MODULE_PARM_DESC(max_rport_logins, "Max number of logins to initiator and target rports on a port (physical/logical), default=1024");
  132. static void
  133. bfad_sm_uninit(struct bfad_s *bfad, enum bfad_sm_event event);
  134. static void
  135. bfad_sm_created(struct bfad_s *bfad, enum bfad_sm_event event);
  136. static void
  137. bfad_sm_initializing(struct bfad_s *bfad, enum bfad_sm_event event);
  138. static void
  139. bfad_sm_operational(struct bfad_s *bfad, enum bfad_sm_event event);
  140. static void
  141. bfad_sm_stopping(struct bfad_s *bfad, enum bfad_sm_event event);
  142. static void
  143. bfad_sm_failed(struct bfad_s *bfad, enum bfad_sm_event event);
  144. static void
  145. bfad_sm_fcs_exit(struct bfad_s *bfad, enum bfad_sm_event event);
  146. /*
  147. * Beginning state for the driver instance, awaiting the pci_probe event
  148. */
  149. static void
  150. bfad_sm_uninit(struct bfad_s *bfad, enum bfad_sm_event event)
  151. {
  152. bfa_trc(bfad, event);
  153. switch (event) {
  154. case BFAD_E_CREATE:
  155. bfa_sm_set_state(bfad, bfad_sm_created);
  156. bfad->bfad_tsk = kthread_create(bfad_worker, (void *) bfad,
  157. "%s", "bfad_worker");
  158. if (IS_ERR(bfad->bfad_tsk)) {
  159. printk(KERN_INFO "bfad[%d]: Kernel thread "
  160. "creation failed!\n", bfad->inst_no);
  161. bfa_sm_send_event(bfad, BFAD_E_KTHREAD_CREATE_FAILED);
  162. }
  163. bfa_sm_send_event(bfad, BFAD_E_INIT);
  164. break;
  165. case BFAD_E_STOP:
  166. /* Ignore stop; already in uninit */
  167. break;
  168. default:
  169. bfa_sm_fault(bfad, event);
  170. }
  171. }
  172. /*
  173. * Driver Instance is created, awaiting event INIT to initialize the bfad
  174. */
  175. static void
  176. bfad_sm_created(struct bfad_s *bfad, enum bfad_sm_event event)
  177. {
  178. unsigned long flags;
  179. bfa_status_t ret;
  180. bfa_trc(bfad, event);
  181. switch (event) {
  182. case BFAD_E_INIT:
  183. bfa_sm_set_state(bfad, bfad_sm_initializing);
  184. init_completion(&bfad->comp);
  185. /* Enable Interrupt and wait bfa_init completion */
  186. if (bfad_setup_intr(bfad)) {
  187. printk(KERN_WARNING "bfad%d: bfad_setup_intr failed\n",
  188. bfad->inst_no);
  189. bfa_sm_send_event(bfad, BFAD_E_INIT_FAILED);
  190. break;
  191. }
  192. spin_lock_irqsave(&bfad->bfad_lock, flags);
  193. bfa_iocfc_init(&bfad->bfa);
  194. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  195. /* Set up interrupt handler for each vectors */
  196. if ((bfad->bfad_flags & BFAD_MSIX_ON) &&
  197. bfad_install_msix_handler(bfad)) {
  198. printk(KERN_WARNING "%s: install_msix failed, bfad%d\n",
  199. __func__, bfad->inst_no);
  200. }
  201. bfad_init_timer(bfad);
  202. wait_for_completion(&bfad->comp);
  203. if ((bfad->bfad_flags & BFAD_HAL_INIT_DONE)) {
  204. bfa_sm_send_event(bfad, BFAD_E_INIT_SUCCESS);
  205. } else {
  206. printk(KERN_WARNING
  207. "bfa %s: bfa init failed\n",
  208. bfad->pci_name);
  209. spin_lock_irqsave(&bfad->bfad_lock, flags);
  210. bfa_fcs_init(&bfad->bfa_fcs);
  211. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  212. ret = bfad_cfg_pport(bfad, BFA_LPORT_ROLE_FCP_IM);
  213. if (ret != BFA_STATUS_OK) {
  214. init_completion(&bfad->comp);
  215. spin_lock_irqsave(&bfad->bfad_lock, flags);
  216. bfad->pport.flags |= BFAD_PORT_DELETE;
  217. bfa_fcs_exit(&bfad->bfa_fcs);
  218. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  219. wait_for_completion(&bfad->comp);
  220. bfa_sm_send_event(bfad, BFAD_E_INIT_FAILED);
  221. break;
  222. }
  223. bfad->bfad_flags |= BFAD_HAL_INIT_FAIL;
  224. bfa_sm_send_event(bfad, BFAD_E_HAL_INIT_FAILED);
  225. }
  226. break;
  227. case BFAD_E_KTHREAD_CREATE_FAILED:
  228. bfa_sm_set_state(bfad, bfad_sm_uninit);
  229. break;
  230. default:
  231. bfa_sm_fault(bfad, event);
  232. }
  233. }
  234. static void
  235. bfad_sm_initializing(struct bfad_s *bfad, enum bfad_sm_event event)
  236. {
  237. int retval;
  238. unsigned long flags;
  239. bfa_trc(bfad, event);
  240. switch (event) {
  241. case BFAD_E_INIT_SUCCESS:
  242. kthread_stop(bfad->bfad_tsk);
  243. spin_lock_irqsave(&bfad->bfad_lock, flags);
  244. bfad->bfad_tsk = NULL;
  245. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  246. retval = bfad_start_ops(bfad);
  247. if (retval != BFA_STATUS_OK) {
  248. bfa_sm_set_state(bfad, bfad_sm_failed);
  249. break;
  250. }
  251. bfa_sm_set_state(bfad, bfad_sm_operational);
  252. break;
  253. case BFAD_E_INIT_FAILED:
  254. bfa_sm_set_state(bfad, bfad_sm_uninit);
  255. kthread_stop(bfad->bfad_tsk);
  256. spin_lock_irqsave(&bfad->bfad_lock, flags);
  257. bfad->bfad_tsk = NULL;
  258. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  259. break;
  260. case BFAD_E_HAL_INIT_FAILED:
  261. bfa_sm_set_state(bfad, bfad_sm_failed);
  262. break;
  263. default:
  264. bfa_sm_fault(bfad, event);
  265. }
  266. }
  267. static void
  268. bfad_sm_failed(struct bfad_s *bfad, enum bfad_sm_event event)
  269. {
  270. int retval;
  271. bfa_trc(bfad, event);
  272. switch (event) {
  273. case BFAD_E_INIT_SUCCESS:
  274. retval = bfad_start_ops(bfad);
  275. if (retval != BFA_STATUS_OK)
  276. break;
  277. bfa_sm_set_state(bfad, bfad_sm_operational);
  278. break;
  279. case BFAD_E_STOP:
  280. bfa_sm_set_state(bfad, bfad_sm_fcs_exit);
  281. bfa_sm_send_event(bfad, BFAD_E_FCS_EXIT_COMP);
  282. break;
  283. case BFAD_E_EXIT_COMP:
  284. bfa_sm_set_state(bfad, bfad_sm_uninit);
  285. bfad_remove_intr(bfad);
  286. del_timer_sync(&bfad->hal_tmo);
  287. break;
  288. default:
  289. bfa_sm_fault(bfad, event);
  290. }
  291. }
  292. static void
  293. bfad_sm_operational(struct bfad_s *bfad, enum bfad_sm_event event)
  294. {
  295. bfa_trc(bfad, event);
  296. switch (event) {
  297. case BFAD_E_STOP:
  298. bfa_sm_set_state(bfad, bfad_sm_fcs_exit);
  299. bfad_fcs_stop(bfad);
  300. break;
  301. default:
  302. bfa_sm_fault(bfad, event);
  303. }
  304. }
  305. static void
  306. bfad_sm_fcs_exit(struct bfad_s *bfad, enum bfad_sm_event event)
  307. {
  308. bfa_trc(bfad, event);
  309. switch (event) {
  310. case BFAD_E_FCS_EXIT_COMP:
  311. bfa_sm_set_state(bfad, bfad_sm_stopping);
  312. bfad_stop(bfad);
  313. break;
  314. default:
  315. bfa_sm_fault(bfad, event);
  316. }
  317. }
  318. static void
  319. bfad_sm_stopping(struct bfad_s *bfad, enum bfad_sm_event event)
  320. {
  321. bfa_trc(bfad, event);
  322. switch (event) {
  323. case BFAD_E_EXIT_COMP:
  324. bfa_sm_set_state(bfad, bfad_sm_uninit);
  325. bfad_remove_intr(bfad);
  326. del_timer_sync(&bfad->hal_tmo);
  327. bfad_im_probe_undo(bfad);
  328. bfad->bfad_flags &= ~BFAD_FC4_PROBE_DONE;
  329. bfad_uncfg_pport(bfad);
  330. break;
  331. default:
  332. bfa_sm_fault(bfad, event);
  333. break;
  334. }
  335. }
  336. /*
  337. * BFA callbacks
  338. */
  339. void
  340. bfad_hcb_comp(void *arg, bfa_status_t status)
  341. {
  342. struct bfad_hal_comp *fcomp = (struct bfad_hal_comp *)arg;
  343. fcomp->status = status;
  344. complete(&fcomp->comp);
  345. }
  346. /*
  347. * bfa_init callback
  348. */
  349. void
  350. bfa_cb_init(void *drv, bfa_status_t init_status)
  351. {
  352. struct bfad_s *bfad = drv;
  353. if (init_status == BFA_STATUS_OK) {
  354. bfad->bfad_flags |= BFAD_HAL_INIT_DONE;
  355. /*
  356. * If BFAD_HAL_INIT_FAIL flag is set:
  357. * Wake up the kernel thread to start
  358. * the bfad operations after HAL init done
  359. */
  360. if ((bfad->bfad_flags & BFAD_HAL_INIT_FAIL)) {
  361. bfad->bfad_flags &= ~BFAD_HAL_INIT_FAIL;
  362. wake_up_process(bfad->bfad_tsk);
  363. }
  364. }
  365. complete(&bfad->comp);
  366. }
  367. /*
  368. * BFA_FCS callbacks
  369. */
  370. struct bfad_port_s *
  371. bfa_fcb_lport_new(struct bfad_s *bfad, struct bfa_fcs_lport_s *port,
  372. enum bfa_lport_role roles, struct bfad_vf_s *vf_drv,
  373. struct bfad_vport_s *vp_drv)
  374. {
  375. bfa_status_t rc;
  376. struct bfad_port_s *port_drv;
  377. if (!vp_drv && !vf_drv) {
  378. port_drv = &bfad->pport;
  379. port_drv->pvb_type = BFAD_PORT_PHYS_BASE;
  380. } else if (!vp_drv && vf_drv) {
  381. port_drv = &vf_drv->base_port;
  382. port_drv->pvb_type = BFAD_PORT_VF_BASE;
  383. } else if (vp_drv && !vf_drv) {
  384. port_drv = &vp_drv->drv_port;
  385. port_drv->pvb_type = BFAD_PORT_PHYS_VPORT;
  386. } else {
  387. port_drv = &vp_drv->drv_port;
  388. port_drv->pvb_type = BFAD_PORT_VF_VPORT;
  389. }
  390. port_drv->fcs_port = port;
  391. port_drv->roles = roles;
  392. if (roles & BFA_LPORT_ROLE_FCP_IM) {
  393. rc = bfad_im_port_new(bfad, port_drv);
  394. if (rc != BFA_STATUS_OK) {
  395. bfad_im_port_delete(bfad, port_drv);
  396. port_drv = NULL;
  397. }
  398. }
  399. return port_drv;
  400. }
  401. /*
  402. * FCS RPORT alloc callback, after successful PLOGI by FCS
  403. */
  404. bfa_status_t
  405. bfa_fcb_rport_alloc(struct bfad_s *bfad, struct bfa_fcs_rport_s **rport,
  406. struct bfad_rport_s **rport_drv)
  407. {
  408. bfa_status_t rc = BFA_STATUS_OK;
  409. *rport_drv = kzalloc(sizeof(struct bfad_rport_s), GFP_ATOMIC);
  410. if (*rport_drv == NULL) {
  411. rc = BFA_STATUS_ENOMEM;
  412. goto ext;
  413. }
  414. *rport = &(*rport_drv)->fcs_rport;
  415. ext:
  416. return rc;
  417. }
  418. /*
  419. * FCS PBC VPORT Create
  420. */
  421. void
  422. bfa_fcb_pbc_vport_create(struct bfad_s *bfad, struct bfi_pbc_vport_s pbc_vport)
  423. {
  424. struct bfa_lport_cfg_s port_cfg = {0};
  425. struct bfad_vport_s *vport;
  426. int rc;
  427. vport = kzalloc(sizeof(struct bfad_vport_s), GFP_ATOMIC);
  428. if (!vport) {
  429. bfa_trc(bfad, 0);
  430. return;
  431. }
  432. vport->drv_port.bfad = bfad;
  433. port_cfg.roles = BFA_LPORT_ROLE_FCP_IM;
  434. port_cfg.pwwn = pbc_vport.vp_pwwn;
  435. port_cfg.nwwn = pbc_vport.vp_nwwn;
  436. port_cfg.preboot_vp = BFA_TRUE;
  437. rc = bfa_fcs_pbc_vport_create(&vport->fcs_vport, &bfad->bfa_fcs, 0,
  438. &port_cfg, vport);
  439. if (rc != BFA_STATUS_OK) {
  440. bfa_trc(bfad, 0);
  441. return;
  442. }
  443. list_add_tail(&vport->list_entry, &bfad->pbc_vport_list);
  444. }
  445. void
  446. bfad_hal_mem_release(struct bfad_s *bfad)
  447. {
  448. struct bfa_meminfo_s *hal_meminfo = &bfad->meminfo;
  449. struct bfa_mem_dma_s *dma_info, *dma_elem;
  450. struct bfa_mem_kva_s *kva_info, *kva_elem;
  451. struct list_head *dm_qe, *km_qe;
  452. dma_info = &hal_meminfo->dma_info;
  453. kva_info = &hal_meminfo->kva_info;
  454. /* Iterate through the KVA meminfo queue */
  455. list_for_each(km_qe, &kva_info->qe) {
  456. kva_elem = (struct bfa_mem_kva_s *) km_qe;
  457. vfree(kva_elem->kva);
  458. }
  459. /* Iterate through the DMA meminfo queue */
  460. list_for_each(dm_qe, &dma_info->qe) {
  461. dma_elem = (struct bfa_mem_dma_s *) dm_qe;
  462. dma_free_coherent(&bfad->pcidev->dev,
  463. dma_elem->mem_len, dma_elem->kva,
  464. (dma_addr_t) dma_elem->dma);
  465. }
  466. memset(hal_meminfo, 0, sizeof(struct bfa_meminfo_s));
  467. }
  468. void
  469. bfad_update_hal_cfg(struct bfa_iocfc_cfg_s *bfa_cfg)
  470. {
  471. if (num_rports > 0)
  472. bfa_cfg->fwcfg.num_rports = num_rports;
  473. if (num_ios > 0)
  474. bfa_cfg->fwcfg.num_ioim_reqs = num_ios;
  475. if (num_tms > 0)
  476. bfa_cfg->fwcfg.num_tskim_reqs = num_tms;
  477. if (num_fcxps > 0 && num_fcxps <= BFA_FCXP_MAX)
  478. bfa_cfg->fwcfg.num_fcxp_reqs = num_fcxps;
  479. if (num_ufbufs > 0 && num_ufbufs <= BFA_UF_MAX)
  480. bfa_cfg->fwcfg.num_uf_bufs = num_ufbufs;
  481. if (reqq_size > 0)
  482. bfa_cfg->drvcfg.num_reqq_elems = reqq_size;
  483. if (rspq_size > 0)
  484. bfa_cfg->drvcfg.num_rspq_elems = rspq_size;
  485. if (num_sgpgs > 0 && num_sgpgs <= BFA_SGPG_MAX)
  486. bfa_cfg->drvcfg.num_sgpgs = num_sgpgs;
  487. /*
  488. * populate the hal values back to the driver for sysfs use.
  489. * otherwise, the default values will be shown as 0 in sysfs
  490. */
  491. num_rports = bfa_cfg->fwcfg.num_rports;
  492. num_ios = bfa_cfg->fwcfg.num_ioim_reqs;
  493. num_tms = bfa_cfg->fwcfg.num_tskim_reqs;
  494. num_fcxps = bfa_cfg->fwcfg.num_fcxp_reqs;
  495. num_ufbufs = bfa_cfg->fwcfg.num_uf_bufs;
  496. reqq_size = bfa_cfg->drvcfg.num_reqq_elems;
  497. rspq_size = bfa_cfg->drvcfg.num_rspq_elems;
  498. num_sgpgs = bfa_cfg->drvcfg.num_sgpgs;
  499. }
  500. bfa_status_t
  501. bfad_hal_mem_alloc(struct bfad_s *bfad)
  502. {
  503. struct bfa_meminfo_s *hal_meminfo = &bfad->meminfo;
  504. struct bfa_mem_dma_s *dma_info, *dma_elem;
  505. struct bfa_mem_kva_s *kva_info, *kva_elem;
  506. struct list_head *dm_qe, *km_qe;
  507. bfa_status_t rc = BFA_STATUS_OK;
  508. dma_addr_t phys_addr;
  509. bfa_cfg_get_default(&bfad->ioc_cfg);
  510. bfad_update_hal_cfg(&bfad->ioc_cfg);
  511. bfad->cfg_data.ioc_queue_depth = bfad->ioc_cfg.fwcfg.num_ioim_reqs;
  512. bfa_cfg_get_meminfo(&bfad->ioc_cfg, hal_meminfo, &bfad->bfa);
  513. dma_info = &hal_meminfo->dma_info;
  514. kva_info = &hal_meminfo->kva_info;
  515. /* Iterate through the KVA meminfo queue */
  516. list_for_each(km_qe, &kva_info->qe) {
  517. kva_elem = (struct bfa_mem_kva_s *) km_qe;
  518. kva_elem->kva = vzalloc(kva_elem->mem_len);
  519. if (kva_elem->kva == NULL) {
  520. bfad_hal_mem_release(bfad);
  521. rc = BFA_STATUS_ENOMEM;
  522. goto ext;
  523. }
  524. }
  525. /* Iterate through the DMA meminfo queue */
  526. list_for_each(dm_qe, &dma_info->qe) {
  527. dma_elem = (struct bfa_mem_dma_s *) dm_qe;
  528. dma_elem->kva = dma_alloc_coherent(&bfad->pcidev->dev,
  529. dma_elem->mem_len,
  530. &phys_addr, GFP_KERNEL);
  531. if (dma_elem->kva == NULL) {
  532. bfad_hal_mem_release(bfad);
  533. rc = BFA_STATUS_ENOMEM;
  534. goto ext;
  535. }
  536. dma_elem->dma = phys_addr;
  537. memset(dma_elem->kva, 0, dma_elem->mem_len);
  538. }
  539. ext:
  540. return rc;
  541. }
  542. /*
  543. * Create a vport under a vf.
  544. */
  545. bfa_status_t
  546. bfad_vport_create(struct bfad_s *bfad, u16 vf_id,
  547. struct bfa_lport_cfg_s *port_cfg, struct device *dev)
  548. {
  549. struct bfad_vport_s *vport;
  550. int rc = BFA_STATUS_OK;
  551. unsigned long flags;
  552. struct completion fcomp;
  553. vport = kzalloc(sizeof(struct bfad_vport_s), GFP_KERNEL);
  554. if (!vport) {
  555. rc = BFA_STATUS_ENOMEM;
  556. goto ext;
  557. }
  558. vport->drv_port.bfad = bfad;
  559. spin_lock_irqsave(&bfad->bfad_lock, flags);
  560. rc = bfa_fcs_vport_create(&vport->fcs_vport, &bfad->bfa_fcs, vf_id,
  561. port_cfg, vport);
  562. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  563. if (rc != BFA_STATUS_OK)
  564. goto ext_free_vport;
  565. if (port_cfg->roles & BFA_LPORT_ROLE_FCP_IM) {
  566. rc = bfad_im_scsi_host_alloc(bfad, vport->drv_port.im_port,
  567. dev);
  568. if (rc != BFA_STATUS_OK)
  569. goto ext_free_fcs_vport;
  570. }
  571. spin_lock_irqsave(&bfad->bfad_lock, flags);
  572. bfa_fcs_vport_start(&vport->fcs_vport);
  573. list_add_tail(&vport->list_entry, &bfad->vport_list);
  574. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  575. return BFA_STATUS_OK;
  576. ext_free_fcs_vport:
  577. spin_lock_irqsave(&bfad->bfad_lock, flags);
  578. vport->comp_del = &fcomp;
  579. init_completion(vport->comp_del);
  580. bfa_fcs_vport_delete(&vport->fcs_vport);
  581. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  582. wait_for_completion(vport->comp_del);
  583. ext_free_vport:
  584. kfree(vport);
  585. ext:
  586. return rc;
  587. }
  588. void
  589. bfad_bfa_tmo(struct timer_list *t)
  590. {
  591. struct bfad_s *bfad = from_timer(bfad, t, hal_tmo);
  592. unsigned long flags;
  593. struct list_head doneq;
  594. spin_lock_irqsave(&bfad->bfad_lock, flags);
  595. bfa_timer_beat(&bfad->bfa.timer_mod);
  596. bfa_comp_deq(&bfad->bfa, &doneq);
  597. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  598. if (!list_empty(&doneq)) {
  599. bfa_comp_process(&bfad->bfa, &doneq);
  600. spin_lock_irqsave(&bfad->bfad_lock, flags);
  601. bfa_comp_free(&bfad->bfa, &doneq);
  602. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  603. }
  604. mod_timer(&bfad->hal_tmo,
  605. jiffies + msecs_to_jiffies(BFA_TIMER_FREQ));
  606. }
  607. void
  608. bfad_init_timer(struct bfad_s *bfad)
  609. {
  610. timer_setup(&bfad->hal_tmo, bfad_bfa_tmo, 0);
  611. mod_timer(&bfad->hal_tmo,
  612. jiffies + msecs_to_jiffies(BFA_TIMER_FREQ));
  613. }
  614. int
  615. bfad_pci_init(struct pci_dev *pdev, struct bfad_s *bfad)
  616. {
  617. int rc = -ENODEV;
  618. if (pci_enable_device(pdev)) {
  619. printk(KERN_ERR "pci_enable_device fail %p\n", pdev);
  620. goto out;
  621. }
  622. if (pci_request_regions(pdev, BFAD_DRIVER_NAME))
  623. goto out_disable_device;
  624. pci_set_master(pdev);
  625. rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
  626. if (rc) {
  627. rc = -ENODEV;
  628. printk(KERN_ERR "dma_set_mask_and_coherent fail %p\n", pdev);
  629. goto out_release_region;
  630. }
  631. /* Enable PCIE Advanced Error Recovery (AER) if kernel supports */
  632. pci_enable_pcie_error_reporting(pdev);
  633. bfad->pci_bar0_kva = pci_iomap(pdev, 0, pci_resource_len(pdev, 0));
  634. bfad->pci_bar2_kva = pci_iomap(pdev, 2, pci_resource_len(pdev, 2));
  635. if (bfad->pci_bar0_kva == NULL) {
  636. printk(KERN_ERR "Fail to map bar0\n");
  637. rc = -ENODEV;
  638. goto out_release_region;
  639. }
  640. bfad->hal_pcidev.pci_slot = PCI_SLOT(pdev->devfn);
  641. bfad->hal_pcidev.pci_func = PCI_FUNC(pdev->devfn);
  642. bfad->hal_pcidev.pci_bar_kva = bfad->pci_bar0_kva;
  643. bfad->hal_pcidev.device_id = pdev->device;
  644. bfad->hal_pcidev.ssid = pdev->subsystem_device;
  645. bfad->pci_name = pci_name(pdev);
  646. bfad->pci_attr.vendor_id = pdev->vendor;
  647. bfad->pci_attr.device_id = pdev->device;
  648. bfad->pci_attr.ssid = pdev->subsystem_device;
  649. bfad->pci_attr.ssvid = pdev->subsystem_vendor;
  650. bfad->pci_attr.pcifn = PCI_FUNC(pdev->devfn);
  651. bfad->pcidev = pdev;
  652. /* Adjust PCIe Maximum Read Request Size */
  653. if (pci_is_pcie(pdev) && pcie_max_read_reqsz) {
  654. if (pcie_max_read_reqsz >= 128 &&
  655. pcie_max_read_reqsz <= 4096 &&
  656. is_power_of_2(pcie_max_read_reqsz)) {
  657. int max_rq = pcie_get_readrq(pdev);
  658. printk(KERN_WARNING "BFA[%s]: "
  659. "pcie_max_read_request_size is %d, "
  660. "reset to %d\n", bfad->pci_name, max_rq,
  661. pcie_max_read_reqsz);
  662. pcie_set_readrq(pdev, pcie_max_read_reqsz);
  663. } else {
  664. printk(KERN_WARNING "BFA[%s]: invalid "
  665. "pcie_max_read_request_size %d ignored\n",
  666. bfad->pci_name, pcie_max_read_reqsz);
  667. }
  668. }
  669. pci_save_state(pdev);
  670. return 0;
  671. out_release_region:
  672. pci_release_regions(pdev);
  673. out_disable_device:
  674. pci_disable_device(pdev);
  675. out:
  676. return rc;
  677. }
  678. void
  679. bfad_pci_uninit(struct pci_dev *pdev, struct bfad_s *bfad)
  680. {
  681. pci_iounmap(pdev, bfad->pci_bar0_kva);
  682. pci_iounmap(pdev, bfad->pci_bar2_kva);
  683. pci_release_regions(pdev);
  684. /* Disable PCIE Advanced Error Recovery (AER) */
  685. pci_disable_pcie_error_reporting(pdev);
  686. pci_disable_device(pdev);
  687. }
  688. bfa_status_t
  689. bfad_drv_init(struct bfad_s *bfad)
  690. {
  691. bfa_status_t rc;
  692. unsigned long flags;
  693. bfad->cfg_data.rport_del_timeout = rport_del_timeout;
  694. bfad->cfg_data.lun_queue_depth = bfa_lun_queue_depth;
  695. bfad->cfg_data.io_max_sge = bfa_io_max_sge;
  696. bfad->cfg_data.binding_method = FCP_PWWN_BINDING;
  697. rc = bfad_hal_mem_alloc(bfad);
  698. if (rc != BFA_STATUS_OK) {
  699. printk(KERN_WARNING "bfad%d bfad_hal_mem_alloc failure\n",
  700. bfad->inst_no);
  701. printk(KERN_WARNING
  702. "Not enough memory to attach all QLogic BR-series HBA ports. System may need more memory.\n");
  703. return BFA_STATUS_FAILED;
  704. }
  705. bfad->bfa.trcmod = bfad->trcmod;
  706. bfad->bfa.plog = &bfad->plog_buf;
  707. bfa_plog_init(&bfad->plog_buf);
  708. bfa_plog_str(&bfad->plog_buf, BFA_PL_MID_DRVR, BFA_PL_EID_DRIVER_START,
  709. 0, "Driver Attach");
  710. bfa_attach(&bfad->bfa, bfad, &bfad->ioc_cfg, &bfad->meminfo,
  711. &bfad->hal_pcidev);
  712. /* FCS INIT */
  713. spin_lock_irqsave(&bfad->bfad_lock, flags);
  714. bfad->bfa_fcs.trcmod = bfad->trcmod;
  715. bfa_fcs_attach(&bfad->bfa_fcs, &bfad->bfa, bfad, BFA_FALSE);
  716. bfad->bfa_fcs.fdmi_enabled = fdmi_enable;
  717. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  718. bfad->bfad_flags |= BFAD_DRV_INIT_DONE;
  719. return BFA_STATUS_OK;
  720. }
  721. void
  722. bfad_drv_uninit(struct bfad_s *bfad)
  723. {
  724. unsigned long flags;
  725. spin_lock_irqsave(&bfad->bfad_lock, flags);
  726. init_completion(&bfad->comp);
  727. bfa_iocfc_stop(&bfad->bfa);
  728. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  729. wait_for_completion(&bfad->comp);
  730. del_timer_sync(&bfad->hal_tmo);
  731. bfa_isr_disable(&bfad->bfa);
  732. bfa_detach(&bfad->bfa);
  733. bfad_remove_intr(bfad);
  734. bfad_hal_mem_release(bfad);
  735. bfad->bfad_flags &= ~BFAD_DRV_INIT_DONE;
  736. }
  737. void
  738. bfad_drv_start(struct bfad_s *bfad)
  739. {
  740. unsigned long flags;
  741. spin_lock_irqsave(&bfad->bfad_lock, flags);
  742. bfa_iocfc_start(&bfad->bfa);
  743. bfa_fcs_pbc_vport_init(&bfad->bfa_fcs);
  744. bfa_fcs_fabric_modstart(&bfad->bfa_fcs);
  745. bfad->bfad_flags |= BFAD_HAL_START_DONE;
  746. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  747. if (bfad->im)
  748. flush_workqueue(bfad->im->drv_workq);
  749. }
  750. void
  751. bfad_fcs_stop(struct bfad_s *bfad)
  752. {
  753. unsigned long flags;
  754. spin_lock_irqsave(&bfad->bfad_lock, flags);
  755. init_completion(&bfad->comp);
  756. bfad->pport.flags |= BFAD_PORT_DELETE;
  757. bfa_fcs_exit(&bfad->bfa_fcs);
  758. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  759. wait_for_completion(&bfad->comp);
  760. bfa_sm_send_event(bfad, BFAD_E_FCS_EXIT_COMP);
  761. }
  762. void
  763. bfad_stop(struct bfad_s *bfad)
  764. {
  765. unsigned long flags;
  766. spin_lock_irqsave(&bfad->bfad_lock, flags);
  767. init_completion(&bfad->comp);
  768. bfa_iocfc_stop(&bfad->bfa);
  769. bfad->bfad_flags &= ~BFAD_HAL_START_DONE;
  770. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  771. wait_for_completion(&bfad->comp);
  772. bfa_sm_send_event(bfad, BFAD_E_EXIT_COMP);
  773. }
  774. bfa_status_t
  775. bfad_cfg_pport(struct bfad_s *bfad, enum bfa_lport_role role)
  776. {
  777. int rc = BFA_STATUS_OK;
  778. /* Allocate scsi_host for the physical port */
  779. if ((supported_fc4s & BFA_LPORT_ROLE_FCP_IM) &&
  780. (role & BFA_LPORT_ROLE_FCP_IM)) {
  781. if (bfad->pport.im_port == NULL) {
  782. rc = BFA_STATUS_FAILED;
  783. goto out;
  784. }
  785. rc = bfad_im_scsi_host_alloc(bfad, bfad->pport.im_port,
  786. &bfad->pcidev->dev);
  787. if (rc != BFA_STATUS_OK)
  788. goto out;
  789. bfad->pport.roles |= BFA_LPORT_ROLE_FCP_IM;
  790. }
  791. bfad->bfad_flags |= BFAD_CFG_PPORT_DONE;
  792. out:
  793. return rc;
  794. }
  795. void
  796. bfad_uncfg_pport(struct bfad_s *bfad)
  797. {
  798. if ((supported_fc4s & BFA_LPORT_ROLE_FCP_IM) &&
  799. (bfad->pport.roles & BFA_LPORT_ROLE_FCP_IM)) {
  800. bfad_im_scsi_host_free(bfad, bfad->pport.im_port);
  801. bfad_im_port_clean(bfad->pport.im_port);
  802. kfree(bfad->pport.im_port);
  803. bfad->pport.roles &= ~BFA_LPORT_ROLE_FCP_IM;
  804. }
  805. bfad->bfad_flags &= ~BFAD_CFG_PPORT_DONE;
  806. }
  807. bfa_status_t
  808. bfad_start_ops(struct bfad_s *bfad) {
  809. int retval;
  810. unsigned long flags;
  811. struct bfad_vport_s *vport, *vport_new;
  812. struct bfa_fcs_driver_info_s driver_info;
  813. /* Limit min/max. xfer size to [64k-32MB] */
  814. if (max_xfer_size < BFAD_MIN_SECTORS >> 1)
  815. max_xfer_size = BFAD_MIN_SECTORS >> 1;
  816. if (max_xfer_size > BFAD_MAX_SECTORS >> 1)
  817. max_xfer_size = BFAD_MAX_SECTORS >> 1;
  818. /* Fill the driver_info info to fcs*/
  819. memset(&driver_info, 0, sizeof(driver_info));
  820. strlcpy(driver_info.version, BFAD_DRIVER_VERSION,
  821. sizeof(driver_info.version));
  822. if (host_name)
  823. strlcpy(driver_info.host_machine_name, host_name,
  824. sizeof(driver_info.host_machine_name));
  825. if (os_name)
  826. strlcpy(driver_info.host_os_name, os_name,
  827. sizeof(driver_info.host_os_name));
  828. if (os_patch)
  829. strlcpy(driver_info.host_os_patch, os_patch,
  830. sizeof(driver_info.host_os_patch));
  831. strlcpy(driver_info.os_device_name, bfad->pci_name,
  832. sizeof(driver_info.os_device_name));
  833. /* FCS driver info init */
  834. spin_lock_irqsave(&bfad->bfad_lock, flags);
  835. bfa_fcs_driver_info_init(&bfad->bfa_fcs, &driver_info);
  836. if (bfad->bfad_flags & BFAD_CFG_PPORT_DONE)
  837. bfa_fcs_update_cfg(&bfad->bfa_fcs);
  838. else
  839. bfa_fcs_init(&bfad->bfa_fcs);
  840. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  841. if (!(bfad->bfad_flags & BFAD_CFG_PPORT_DONE)) {
  842. retval = bfad_cfg_pport(bfad, BFA_LPORT_ROLE_FCP_IM);
  843. if (retval != BFA_STATUS_OK)
  844. return BFA_STATUS_FAILED;
  845. }
  846. /* Setup fc host fixed attribute if the lk supports */
  847. bfad_fc_host_init(bfad->pport.im_port);
  848. /* BFAD level FC4 IM specific resource allocation */
  849. retval = bfad_im_probe(bfad);
  850. if (retval != BFA_STATUS_OK) {
  851. printk(KERN_WARNING "bfad_im_probe failed\n");
  852. if (bfa_sm_cmp_state(bfad, bfad_sm_initializing))
  853. bfa_sm_set_state(bfad, bfad_sm_failed);
  854. return BFA_STATUS_FAILED;
  855. } else
  856. bfad->bfad_flags |= BFAD_FC4_PROBE_DONE;
  857. bfad_drv_start(bfad);
  858. /* Complete pbc vport create */
  859. list_for_each_entry_safe(vport, vport_new, &bfad->pbc_vport_list,
  860. list_entry) {
  861. struct fc_vport_identifiers vid;
  862. struct fc_vport *fc_vport;
  863. char pwwn_buf[BFA_STRING_32];
  864. memset(&vid, 0, sizeof(vid));
  865. vid.roles = FC_PORT_ROLE_FCP_INITIATOR;
  866. vid.vport_type = FC_PORTTYPE_NPIV;
  867. vid.disable = false;
  868. vid.node_name = wwn_to_u64((u8 *)
  869. (&((vport->fcs_vport).lport.port_cfg.nwwn)));
  870. vid.port_name = wwn_to_u64((u8 *)
  871. (&((vport->fcs_vport).lport.port_cfg.pwwn)));
  872. fc_vport = fc_vport_create(bfad->pport.im_port->shost, 0, &vid);
  873. if (!fc_vport) {
  874. wwn2str(pwwn_buf, vid.port_name);
  875. printk(KERN_WARNING "bfad%d: failed to create pbc vport"
  876. " %s\n", bfad->inst_no, pwwn_buf);
  877. }
  878. list_del(&vport->list_entry);
  879. kfree(vport);
  880. }
  881. /*
  882. * If bfa_linkup_delay is set to -1 default; try to retrive the
  883. * value using the bfad_get_linkup_delay(); else use the
  884. * passed in module param value as the bfa_linkup_delay.
  885. */
  886. if (bfa_linkup_delay < 0) {
  887. bfa_linkup_delay = bfad_get_linkup_delay(bfad);
  888. bfad_rport_online_wait(bfad);
  889. bfa_linkup_delay = -1;
  890. } else
  891. bfad_rport_online_wait(bfad);
  892. BFA_LOG(KERN_INFO, bfad, bfa_log_level, "bfa device claimed\n");
  893. return BFA_STATUS_OK;
  894. }
  895. int
  896. bfad_worker(void *ptr)
  897. {
  898. struct bfad_s *bfad = ptr;
  899. unsigned long flags;
  900. if (kthread_should_stop())
  901. return 0;
  902. /* Send event BFAD_E_INIT_SUCCESS */
  903. bfa_sm_send_event(bfad, BFAD_E_INIT_SUCCESS);
  904. spin_lock_irqsave(&bfad->bfad_lock, flags);
  905. bfad->bfad_tsk = NULL;
  906. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  907. return 0;
  908. }
  909. /*
  910. * BFA driver interrupt functions
  911. */
  912. irqreturn_t
  913. bfad_intx(int irq, void *dev_id)
  914. {
  915. struct bfad_s *bfad = dev_id;
  916. struct list_head doneq;
  917. unsigned long flags;
  918. bfa_boolean_t rc;
  919. spin_lock_irqsave(&bfad->bfad_lock, flags);
  920. rc = bfa_intx(&bfad->bfa);
  921. if (!rc) {
  922. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  923. return IRQ_NONE;
  924. }
  925. bfa_comp_deq(&bfad->bfa, &doneq);
  926. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  927. if (!list_empty(&doneq)) {
  928. bfa_comp_process(&bfad->bfa, &doneq);
  929. spin_lock_irqsave(&bfad->bfad_lock, flags);
  930. bfa_comp_free(&bfad->bfa, &doneq);
  931. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  932. }
  933. return IRQ_HANDLED;
  934. }
  935. static irqreturn_t
  936. bfad_msix(int irq, void *dev_id)
  937. {
  938. struct bfad_msix_s *vec = dev_id;
  939. struct bfad_s *bfad = vec->bfad;
  940. struct list_head doneq;
  941. unsigned long flags;
  942. spin_lock_irqsave(&bfad->bfad_lock, flags);
  943. bfa_msix(&bfad->bfa, vec->msix.entry);
  944. bfa_comp_deq(&bfad->bfa, &doneq);
  945. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  946. if (!list_empty(&doneq)) {
  947. bfa_comp_process(&bfad->bfa, &doneq);
  948. spin_lock_irqsave(&bfad->bfad_lock, flags);
  949. bfa_comp_free(&bfad->bfa, &doneq);
  950. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  951. }
  952. return IRQ_HANDLED;
  953. }
  954. /*
  955. * Initialize the MSIX entry table.
  956. */
  957. static void
  958. bfad_init_msix_entry(struct bfad_s *bfad, struct msix_entry *msix_entries,
  959. int mask, int max_bit)
  960. {
  961. int i;
  962. int match = 0x00000001;
  963. for (i = 0, bfad->nvec = 0; i < MAX_MSIX_ENTRY; i++) {
  964. if (mask & match) {
  965. bfad->msix_tab[bfad->nvec].msix.entry = i;
  966. bfad->msix_tab[bfad->nvec].bfad = bfad;
  967. msix_entries[bfad->nvec].entry = i;
  968. bfad->nvec++;
  969. }
  970. match <<= 1;
  971. }
  972. }
  973. int
  974. bfad_install_msix_handler(struct bfad_s *bfad)
  975. {
  976. int i, error = 0;
  977. for (i = 0; i < bfad->nvec; i++) {
  978. sprintf(bfad->msix_tab[i].name, "bfa-%s-%s",
  979. bfad->pci_name,
  980. ((bfa_asic_id_cb(bfad->hal_pcidev.device_id)) ?
  981. msix_name_cb[i] : msix_name_ct[i]));
  982. error = request_irq(bfad->msix_tab[i].msix.vector,
  983. (irq_handler_t) bfad_msix, 0,
  984. bfad->msix_tab[i].name, &bfad->msix_tab[i]);
  985. bfa_trc(bfad, i);
  986. bfa_trc(bfad, bfad->msix_tab[i].msix.vector);
  987. if (error) {
  988. int j;
  989. for (j = 0; j < i; j++)
  990. free_irq(bfad->msix_tab[j].msix.vector,
  991. &bfad->msix_tab[j]);
  992. bfad->bfad_flags &= ~BFAD_MSIX_ON;
  993. pci_disable_msix(bfad->pcidev);
  994. return 1;
  995. }
  996. }
  997. return 0;
  998. }
  999. /*
  1000. * Setup MSIX based interrupt.
  1001. */
  1002. int
  1003. bfad_setup_intr(struct bfad_s *bfad)
  1004. {
  1005. int error;
  1006. u32 mask = 0, i, num_bit = 0, max_bit = 0;
  1007. struct msix_entry msix_entries[MAX_MSIX_ENTRY];
  1008. struct pci_dev *pdev = bfad->pcidev;
  1009. u16 reg;
  1010. /* Call BFA to get the msix map for this PCI function. */
  1011. bfa_msix_getvecs(&bfad->bfa, &mask, &num_bit, &max_bit);
  1012. /* Set up the msix entry table */
  1013. bfad_init_msix_entry(bfad, msix_entries, mask, max_bit);
  1014. if ((bfa_asic_id_ctc(pdev->device) && !msix_disable_ct) ||
  1015. (bfa_asic_id_cb(pdev->device) && !msix_disable_cb)) {
  1016. error = pci_enable_msix_exact(bfad->pcidev,
  1017. msix_entries, bfad->nvec);
  1018. /* In CT1 & CT2, try to allocate just one vector */
  1019. if (error == -ENOSPC && bfa_asic_id_ctc(pdev->device)) {
  1020. printk(KERN_WARNING "bfa %s: trying one msix "
  1021. "vector failed to allocate %d[%d]\n",
  1022. bfad->pci_name, bfad->nvec, error);
  1023. bfad->nvec = 1;
  1024. error = pci_enable_msix_exact(bfad->pcidev,
  1025. msix_entries, 1);
  1026. }
  1027. if (error) {
  1028. printk(KERN_WARNING "bfad%d: "
  1029. "pci_enable_msix_exact failed (%d), "
  1030. "use line based.\n",
  1031. bfad->inst_no, error);
  1032. goto line_based;
  1033. }
  1034. /* Disable INTX in MSI-X mode */
  1035. pci_read_config_word(pdev, PCI_COMMAND, &reg);
  1036. if (!(reg & PCI_COMMAND_INTX_DISABLE))
  1037. pci_write_config_word(pdev, PCI_COMMAND,
  1038. reg | PCI_COMMAND_INTX_DISABLE);
  1039. /* Save the vectors */
  1040. for (i = 0; i < bfad->nvec; i++) {
  1041. bfa_trc(bfad, msix_entries[i].vector);
  1042. bfad->msix_tab[i].msix.vector = msix_entries[i].vector;
  1043. }
  1044. bfa_msix_init(&bfad->bfa, bfad->nvec);
  1045. bfad->bfad_flags |= BFAD_MSIX_ON;
  1046. return 0;
  1047. }
  1048. line_based:
  1049. error = request_irq(bfad->pcidev->irq, (irq_handler_t)bfad_intx,
  1050. BFAD_IRQ_FLAGS, BFAD_DRIVER_NAME, bfad);
  1051. if (error)
  1052. return error;
  1053. bfad->bfad_flags |= BFAD_INTX_ON;
  1054. return 0;
  1055. }
  1056. void
  1057. bfad_remove_intr(struct bfad_s *bfad)
  1058. {
  1059. int i;
  1060. if (bfad->bfad_flags & BFAD_MSIX_ON) {
  1061. for (i = 0; i < bfad->nvec; i++)
  1062. free_irq(bfad->msix_tab[i].msix.vector,
  1063. &bfad->msix_tab[i]);
  1064. pci_disable_msix(bfad->pcidev);
  1065. bfad->bfad_flags &= ~BFAD_MSIX_ON;
  1066. } else if (bfad->bfad_flags & BFAD_INTX_ON) {
  1067. free_irq(bfad->pcidev->irq, bfad);
  1068. }
  1069. }
  1070. /*
  1071. * PCI probe entry.
  1072. */
  1073. int
  1074. bfad_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pid)
  1075. {
  1076. struct bfad_s *bfad;
  1077. int error = -ENODEV, retval, i;
  1078. /* For single port cards - only claim function 0 */
  1079. if ((pdev->device == BFA_PCI_DEVICE_ID_FC_8G1P) &&
  1080. (PCI_FUNC(pdev->devfn) != 0))
  1081. return -ENODEV;
  1082. bfad = kzalloc(sizeof(struct bfad_s), GFP_KERNEL);
  1083. if (!bfad) {
  1084. error = -ENOMEM;
  1085. goto out;
  1086. }
  1087. bfad->trcmod = kzalloc(sizeof(struct bfa_trc_mod_s), GFP_KERNEL);
  1088. if (!bfad->trcmod) {
  1089. printk(KERN_WARNING "Error alloc trace buffer!\n");
  1090. error = -ENOMEM;
  1091. goto out_alloc_trace_failure;
  1092. }
  1093. /* TRACE INIT */
  1094. bfa_trc_init(bfad->trcmod);
  1095. bfa_trc(bfad, bfad_inst);
  1096. /* AEN INIT */
  1097. INIT_LIST_HEAD(&bfad->free_aen_q);
  1098. INIT_LIST_HEAD(&bfad->active_aen_q);
  1099. for (i = 0; i < BFA_AEN_MAX_ENTRY; i++)
  1100. list_add_tail(&bfad->aen_list[i].qe, &bfad->free_aen_q);
  1101. if (!(bfad_load_fwimg(pdev))) {
  1102. kfree(bfad->trcmod);
  1103. goto out_alloc_trace_failure;
  1104. }
  1105. retval = bfad_pci_init(pdev, bfad);
  1106. if (retval) {
  1107. printk(KERN_WARNING "bfad_pci_init failure!\n");
  1108. error = retval;
  1109. goto out_pci_init_failure;
  1110. }
  1111. mutex_lock(&bfad_mutex);
  1112. bfad->inst_no = bfad_inst++;
  1113. list_add_tail(&bfad->list_entry, &bfad_list);
  1114. mutex_unlock(&bfad_mutex);
  1115. /* Initializing the state machine: State set to uninit */
  1116. bfa_sm_set_state(bfad, bfad_sm_uninit);
  1117. spin_lock_init(&bfad->bfad_lock);
  1118. spin_lock_init(&bfad->bfad_aen_spinlock);
  1119. pci_set_drvdata(pdev, bfad);
  1120. bfad->ref_count = 0;
  1121. bfad->pport.bfad = bfad;
  1122. INIT_LIST_HEAD(&bfad->pbc_vport_list);
  1123. INIT_LIST_HEAD(&bfad->vport_list);
  1124. /* Setup the debugfs node for this bfad */
  1125. if (bfa_debugfs_enable)
  1126. bfad_debugfs_init(&bfad->pport);
  1127. retval = bfad_drv_init(bfad);
  1128. if (retval != BFA_STATUS_OK)
  1129. goto out_drv_init_failure;
  1130. bfa_sm_send_event(bfad, BFAD_E_CREATE);
  1131. if (bfa_sm_cmp_state(bfad, bfad_sm_uninit))
  1132. goto out_bfad_sm_failure;
  1133. return 0;
  1134. out_bfad_sm_failure:
  1135. bfad_hal_mem_release(bfad);
  1136. out_drv_init_failure:
  1137. /* Remove the debugfs node for this bfad */
  1138. kfree(bfad->regdata);
  1139. bfad_debugfs_exit(&bfad->pport);
  1140. mutex_lock(&bfad_mutex);
  1141. bfad_inst--;
  1142. list_del(&bfad->list_entry);
  1143. mutex_unlock(&bfad_mutex);
  1144. bfad_pci_uninit(pdev, bfad);
  1145. out_pci_init_failure:
  1146. kfree(bfad->trcmod);
  1147. out_alloc_trace_failure:
  1148. kfree(bfad);
  1149. out:
  1150. return error;
  1151. }
  1152. /*
  1153. * PCI remove entry.
  1154. */
  1155. void
  1156. bfad_pci_remove(struct pci_dev *pdev)
  1157. {
  1158. struct bfad_s *bfad = pci_get_drvdata(pdev);
  1159. unsigned long flags;
  1160. bfa_trc(bfad, bfad->inst_no);
  1161. spin_lock_irqsave(&bfad->bfad_lock, flags);
  1162. if (bfad->bfad_tsk != NULL) {
  1163. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  1164. kthread_stop(bfad->bfad_tsk);
  1165. } else {
  1166. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  1167. }
  1168. /* Send Event BFAD_E_STOP */
  1169. bfa_sm_send_event(bfad, BFAD_E_STOP);
  1170. /* Driver detach and dealloc mem */
  1171. spin_lock_irqsave(&bfad->bfad_lock, flags);
  1172. bfa_detach(&bfad->bfa);
  1173. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  1174. bfad_hal_mem_release(bfad);
  1175. /* Remove the debugfs node for this bfad */
  1176. kfree(bfad->regdata);
  1177. bfad_debugfs_exit(&bfad->pport);
  1178. /* Cleaning the BFAD instance */
  1179. mutex_lock(&bfad_mutex);
  1180. bfad_inst--;
  1181. list_del(&bfad->list_entry);
  1182. mutex_unlock(&bfad_mutex);
  1183. bfad_pci_uninit(pdev, bfad);
  1184. kfree(bfad->trcmod);
  1185. kfree(bfad);
  1186. }
  1187. /*
  1188. * PCI Error Recovery entry, error detected.
  1189. */
  1190. static pci_ers_result_t
  1191. bfad_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
  1192. {
  1193. struct bfad_s *bfad = pci_get_drvdata(pdev);
  1194. unsigned long flags;
  1195. pci_ers_result_t ret = PCI_ERS_RESULT_NONE;
  1196. dev_printk(KERN_ERR, &pdev->dev,
  1197. "error detected state: %d - flags: 0x%x\n",
  1198. state, bfad->bfad_flags);
  1199. switch (state) {
  1200. case pci_channel_io_normal: /* non-fatal error */
  1201. spin_lock_irqsave(&bfad->bfad_lock, flags);
  1202. bfad->bfad_flags &= ~BFAD_EEH_BUSY;
  1203. /* Suspend/fail all bfa operations */
  1204. bfa_ioc_suspend(&bfad->bfa.ioc);
  1205. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  1206. del_timer_sync(&bfad->hal_tmo);
  1207. ret = PCI_ERS_RESULT_CAN_RECOVER;
  1208. break;
  1209. case pci_channel_io_frozen: /* fatal error */
  1210. init_completion(&bfad->comp);
  1211. spin_lock_irqsave(&bfad->bfad_lock, flags);
  1212. bfad->bfad_flags |= BFAD_EEH_BUSY;
  1213. /* Suspend/fail all bfa operations */
  1214. bfa_ioc_suspend(&bfad->bfa.ioc);
  1215. bfa_fcs_stop(&bfad->bfa_fcs);
  1216. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  1217. wait_for_completion(&bfad->comp);
  1218. bfad_remove_intr(bfad);
  1219. del_timer_sync(&bfad->hal_tmo);
  1220. pci_disable_device(pdev);
  1221. ret = PCI_ERS_RESULT_NEED_RESET;
  1222. break;
  1223. case pci_channel_io_perm_failure: /* PCI Card is DEAD */
  1224. spin_lock_irqsave(&bfad->bfad_lock, flags);
  1225. bfad->bfad_flags |= BFAD_EEH_BUSY |
  1226. BFAD_EEH_PCI_CHANNEL_IO_PERM_FAILURE;
  1227. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  1228. /* If the error_detected handler is called with the reason
  1229. * pci_channel_io_perm_failure - it will subsequently call
  1230. * pci_remove() entry point to remove the pci device from the
  1231. * system - So defer the cleanup to pci_remove(); cleaning up
  1232. * here causes inconsistent state during pci_remove().
  1233. */
  1234. ret = PCI_ERS_RESULT_DISCONNECT;
  1235. break;
  1236. default:
  1237. WARN_ON(1);
  1238. }
  1239. return ret;
  1240. }
  1241. static int restart_bfa(struct bfad_s *bfad)
  1242. {
  1243. unsigned long flags;
  1244. struct pci_dev *pdev = bfad->pcidev;
  1245. bfa_attach(&bfad->bfa, bfad, &bfad->ioc_cfg,
  1246. &bfad->meminfo, &bfad->hal_pcidev);
  1247. /* Enable Interrupt and wait bfa_init completion */
  1248. if (bfad_setup_intr(bfad)) {
  1249. dev_printk(KERN_WARNING, &pdev->dev,
  1250. "%s: bfad_setup_intr failed\n", bfad->pci_name);
  1251. bfa_sm_send_event(bfad, BFAD_E_INIT_FAILED);
  1252. return -1;
  1253. }
  1254. init_completion(&bfad->comp);
  1255. spin_lock_irqsave(&bfad->bfad_lock, flags);
  1256. bfa_iocfc_init(&bfad->bfa);
  1257. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  1258. /* Set up interrupt handler for each vectors */
  1259. if ((bfad->bfad_flags & BFAD_MSIX_ON) &&
  1260. bfad_install_msix_handler(bfad))
  1261. dev_printk(KERN_WARNING, &pdev->dev,
  1262. "%s: install_msix failed.\n", bfad->pci_name);
  1263. bfad_init_timer(bfad);
  1264. wait_for_completion(&bfad->comp);
  1265. bfad_drv_start(bfad);
  1266. return 0;
  1267. }
  1268. /*
  1269. * PCI Error Recovery entry, re-initialize the chip.
  1270. */
  1271. static pci_ers_result_t
  1272. bfad_pci_slot_reset(struct pci_dev *pdev)
  1273. {
  1274. struct bfad_s *bfad = pci_get_drvdata(pdev);
  1275. u8 byte;
  1276. int rc;
  1277. dev_printk(KERN_ERR, &pdev->dev,
  1278. "bfad_pci_slot_reset flags: 0x%x\n", bfad->bfad_flags);
  1279. if (pci_enable_device(pdev)) {
  1280. dev_printk(KERN_ERR, &pdev->dev, "Cannot re-enable "
  1281. "PCI device after reset.\n");
  1282. return PCI_ERS_RESULT_DISCONNECT;
  1283. }
  1284. pci_restore_state(pdev);
  1285. /*
  1286. * Read some byte (e.g. DMA max. payload size which can't
  1287. * be 0xff any time) to make sure - we did not hit another PCI error
  1288. * in the middle of recovery. If we did, then declare permanent failure.
  1289. */
  1290. pci_read_config_byte(pdev, 0x68, &byte);
  1291. if (byte == 0xff) {
  1292. dev_printk(KERN_ERR, &pdev->dev,
  1293. "slot_reset failed ... got another PCI error !\n");
  1294. goto out_disable_device;
  1295. }
  1296. pci_save_state(pdev);
  1297. pci_set_master(pdev);
  1298. rc = dma_set_mask_and_coherent(&bfad->pcidev->dev, DMA_BIT_MASK(64));
  1299. if (rc)
  1300. goto out_disable_device;
  1301. if (restart_bfa(bfad) == -1)
  1302. goto out_disable_device;
  1303. pci_enable_pcie_error_reporting(pdev);
  1304. dev_printk(KERN_WARNING, &pdev->dev,
  1305. "slot_reset completed flags: 0x%x!\n", bfad->bfad_flags);
  1306. return PCI_ERS_RESULT_RECOVERED;
  1307. out_disable_device:
  1308. pci_disable_device(pdev);
  1309. return PCI_ERS_RESULT_DISCONNECT;
  1310. }
  1311. static pci_ers_result_t
  1312. bfad_pci_mmio_enabled(struct pci_dev *pdev)
  1313. {
  1314. unsigned long flags;
  1315. struct bfad_s *bfad = pci_get_drvdata(pdev);
  1316. dev_printk(KERN_INFO, &pdev->dev, "mmio_enabled\n");
  1317. /* Fetch FW diagnostic information */
  1318. bfa_ioc_debug_save_ftrc(&bfad->bfa.ioc);
  1319. /* Cancel all pending IOs */
  1320. spin_lock_irqsave(&bfad->bfad_lock, flags);
  1321. init_completion(&bfad->comp);
  1322. bfa_fcs_stop(&bfad->bfa_fcs);
  1323. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  1324. wait_for_completion(&bfad->comp);
  1325. bfad_remove_intr(bfad);
  1326. del_timer_sync(&bfad->hal_tmo);
  1327. pci_disable_device(pdev);
  1328. return PCI_ERS_RESULT_NEED_RESET;
  1329. }
  1330. static void
  1331. bfad_pci_resume(struct pci_dev *pdev)
  1332. {
  1333. unsigned long flags;
  1334. struct bfad_s *bfad = pci_get_drvdata(pdev);
  1335. dev_printk(KERN_WARNING, &pdev->dev, "resume\n");
  1336. /* wait until the link is online */
  1337. bfad_rport_online_wait(bfad);
  1338. spin_lock_irqsave(&bfad->bfad_lock, flags);
  1339. bfad->bfad_flags &= ~BFAD_EEH_BUSY;
  1340. spin_unlock_irqrestore(&bfad->bfad_lock, flags);
  1341. }
  1342. struct pci_device_id bfad_id_table[] = {
  1343. {
  1344. .vendor = BFA_PCI_VENDOR_ID_BROCADE,
  1345. .device = BFA_PCI_DEVICE_ID_FC_8G2P,
  1346. .subvendor = PCI_ANY_ID,
  1347. .subdevice = PCI_ANY_ID,
  1348. },
  1349. {
  1350. .vendor = BFA_PCI_VENDOR_ID_BROCADE,
  1351. .device = BFA_PCI_DEVICE_ID_FC_8G1P,
  1352. .subvendor = PCI_ANY_ID,
  1353. .subdevice = PCI_ANY_ID,
  1354. },
  1355. {
  1356. .vendor = BFA_PCI_VENDOR_ID_BROCADE,
  1357. .device = BFA_PCI_DEVICE_ID_CT,
  1358. .subvendor = PCI_ANY_ID,
  1359. .subdevice = PCI_ANY_ID,
  1360. .class = (PCI_CLASS_SERIAL_FIBER << 8),
  1361. .class_mask = ~0,
  1362. },
  1363. {
  1364. .vendor = BFA_PCI_VENDOR_ID_BROCADE,
  1365. .device = BFA_PCI_DEVICE_ID_CT_FC,
  1366. .subvendor = PCI_ANY_ID,
  1367. .subdevice = PCI_ANY_ID,
  1368. .class = (PCI_CLASS_SERIAL_FIBER << 8),
  1369. .class_mask = ~0,
  1370. },
  1371. {
  1372. .vendor = BFA_PCI_VENDOR_ID_BROCADE,
  1373. .device = BFA_PCI_DEVICE_ID_CT2,
  1374. .subvendor = PCI_ANY_ID,
  1375. .subdevice = PCI_ANY_ID,
  1376. .class = (PCI_CLASS_SERIAL_FIBER << 8),
  1377. .class_mask = ~0,
  1378. },
  1379. {
  1380. .vendor = BFA_PCI_VENDOR_ID_BROCADE,
  1381. .device = BFA_PCI_DEVICE_ID_CT2_QUAD,
  1382. .subvendor = PCI_ANY_ID,
  1383. .subdevice = PCI_ANY_ID,
  1384. .class = (PCI_CLASS_SERIAL_FIBER << 8),
  1385. .class_mask = ~0,
  1386. },
  1387. {0, 0},
  1388. };
  1389. MODULE_DEVICE_TABLE(pci, bfad_id_table);
  1390. /*
  1391. * PCI error recovery handlers.
  1392. */
  1393. static struct pci_error_handlers bfad_err_handler = {
  1394. .error_detected = bfad_pci_error_detected,
  1395. .slot_reset = bfad_pci_slot_reset,
  1396. .mmio_enabled = bfad_pci_mmio_enabled,
  1397. .resume = bfad_pci_resume,
  1398. };
  1399. static struct pci_driver bfad_pci_driver = {
  1400. .name = BFAD_DRIVER_NAME,
  1401. .id_table = bfad_id_table,
  1402. .probe = bfad_pci_probe,
  1403. .remove = bfad_pci_remove,
  1404. .err_handler = &bfad_err_handler,
  1405. };
  1406. /*
  1407. * Driver module init.
  1408. */
  1409. static int __init
  1410. bfad_init(void)
  1411. {
  1412. int error = 0;
  1413. pr_info("QLogic BR-series BFA FC/FCOE SCSI driver - version: %s\n",
  1414. BFAD_DRIVER_VERSION);
  1415. if (num_sgpgs > 0)
  1416. num_sgpgs_parm = num_sgpgs;
  1417. error = bfad_im_module_init();
  1418. if (error) {
  1419. error = -ENOMEM;
  1420. printk(KERN_WARNING "bfad_im_module_init failure\n");
  1421. goto ext;
  1422. }
  1423. if (strcmp(FCPI_NAME, " fcpim") == 0)
  1424. supported_fc4s |= BFA_LPORT_ROLE_FCP_IM;
  1425. bfa_auto_recover = ioc_auto_recover;
  1426. bfa_fcs_rport_set_del_timeout(rport_del_timeout);
  1427. bfa_fcs_rport_set_max_logins(max_rport_logins);
  1428. error = pci_register_driver(&bfad_pci_driver);
  1429. if (error) {
  1430. printk(KERN_WARNING "pci_register_driver failure\n");
  1431. goto ext;
  1432. }
  1433. return 0;
  1434. ext:
  1435. bfad_im_module_exit();
  1436. return error;
  1437. }
  1438. /*
  1439. * Driver module exit.
  1440. */
  1441. static void __exit
  1442. bfad_exit(void)
  1443. {
  1444. pci_unregister_driver(&bfad_pci_driver);
  1445. bfad_im_module_exit();
  1446. bfad_free_fwimg();
  1447. }
  1448. /* Firmware handling */
  1449. static void
  1450. bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
  1451. u32 *bfi_image_size, char *fw_name)
  1452. {
  1453. const struct firmware *fw;
  1454. if (request_firmware(&fw, fw_name, &pdev->dev)) {
  1455. printk(KERN_ALERT "Can't locate firmware %s\n", fw_name);
  1456. *bfi_image = NULL;
  1457. goto out;
  1458. }
  1459. *bfi_image = vmalloc(fw->size);
  1460. if (NULL == *bfi_image) {
  1461. printk(KERN_ALERT "Fail to allocate buffer for fw image "
  1462. "size=%x!\n", (u32) fw->size);
  1463. goto out;
  1464. }
  1465. memcpy(*bfi_image, fw->data, fw->size);
  1466. *bfi_image_size = fw->size/sizeof(u32);
  1467. out:
  1468. release_firmware(fw);
  1469. }
  1470. static u32 *
  1471. bfad_load_fwimg(struct pci_dev *pdev)
  1472. {
  1473. if (bfa_asic_id_ct2(pdev->device)) {
  1474. if (bfi_image_ct2_size == 0)
  1475. bfad_read_firmware(pdev, &bfi_image_ct2,
  1476. &bfi_image_ct2_size, BFAD_FW_FILE_CT2);
  1477. return bfi_image_ct2;
  1478. } else if (bfa_asic_id_ct(pdev->device)) {
  1479. if (bfi_image_ct_size == 0)
  1480. bfad_read_firmware(pdev, &bfi_image_ct,
  1481. &bfi_image_ct_size, BFAD_FW_FILE_CT);
  1482. return bfi_image_ct;
  1483. } else if (bfa_asic_id_cb(pdev->device)) {
  1484. if (bfi_image_cb_size == 0)
  1485. bfad_read_firmware(pdev, &bfi_image_cb,
  1486. &bfi_image_cb_size, BFAD_FW_FILE_CB);
  1487. return bfi_image_cb;
  1488. }
  1489. return NULL;
  1490. }
  1491. static void
  1492. bfad_free_fwimg(void)
  1493. {
  1494. if (bfi_image_ct2_size && bfi_image_ct2)
  1495. vfree(bfi_image_ct2);
  1496. if (bfi_image_ct_size && bfi_image_ct)
  1497. vfree(bfi_image_ct);
  1498. if (bfi_image_cb_size && bfi_image_cb)
  1499. vfree(bfi_image_cb);
  1500. }
  1501. module_init(bfad_init);
  1502. module_exit(bfad_exit);
  1503. MODULE_LICENSE("GPL");
  1504. MODULE_DESCRIPTION("QLogic BR-series Fibre Channel HBA Driver" BFAD_PROTO_NAME);
  1505. MODULE_AUTHOR("QLogic Corporation");
  1506. MODULE_VERSION(BFAD_DRIVER_VERSION);