qla_isr.c 68 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560
  1. /*
  2. * QLogic Fibre Channel HBA Driver
  3. * Copyright (c) 2003-2010 QLogic Corporation
  4. *
  5. * See LICENSE.qla2xxx for copyright and licensing details.
  6. */
  7. #include "qla_def.h"
  8. #include <linux/delay.h>
  9. #include <linux/slab.h>
  10. #include <scsi/scsi_tcq.h>
  11. #include <scsi/scsi_bsg_fc.h>
  12. #include <scsi/scsi_eh.h>
  13. static void qla2x00_mbx_completion(scsi_qla_host_t *, uint16_t);
  14. static void qla2x00_process_completed_request(struct scsi_qla_host *,
  15. struct req_que *, uint32_t);
  16. static void qla2x00_status_entry(scsi_qla_host_t *, struct rsp_que *, void *);
  17. static void qla2x00_status_cont_entry(struct rsp_que *, sts_cont_entry_t *);
  18. static void qla2x00_error_entry(scsi_qla_host_t *, struct rsp_que *,
  19. sts_entry_t *);
  20. /**
  21. * qla2100_intr_handler() - Process interrupts for the ISP2100 and ISP2200.
  22. * @irq:
  23. * @dev_id: SCSI driver HA context
  24. *
  25. * Called by system whenever the host adapter generates an interrupt.
  26. *
  27. * Returns handled flag.
  28. */
  29. irqreturn_t
  30. qla2100_intr_handler(int irq, void *dev_id)
  31. {
  32. scsi_qla_host_t *vha;
  33. struct qla_hw_data *ha;
  34. struct device_reg_2xxx __iomem *reg;
  35. int status;
  36. unsigned long iter;
  37. uint16_t hccr;
  38. uint16_t mb[4];
  39. struct rsp_que *rsp;
  40. unsigned long flags;
  41. rsp = (struct rsp_que *) dev_id;
  42. if (!rsp) {
  43. printk(KERN_INFO
  44. "%s(): NULL response queue pointer\n", __func__);
  45. return (IRQ_NONE);
  46. }
  47. ha = rsp->hw;
  48. reg = &ha->iobase->isp;
  49. status = 0;
  50. spin_lock_irqsave(&ha->hardware_lock, flags);
  51. vha = pci_get_drvdata(ha->pdev);
  52. for (iter = 50; iter--; ) {
  53. hccr = RD_REG_WORD(&reg->hccr);
  54. if (hccr & HCCR_RISC_PAUSE) {
  55. if (pci_channel_offline(ha->pdev))
  56. break;
  57. /*
  58. * Issue a "HARD" reset in order for the RISC interrupt
  59. * bit to be cleared. Schedule a big hammmer to get
  60. * out of the RISC PAUSED state.
  61. */
  62. WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
  63. RD_REG_WORD(&reg->hccr);
  64. ha->isp_ops->fw_dump(vha, 1);
  65. set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
  66. break;
  67. } else if ((RD_REG_WORD(&reg->istatus) & ISR_RISC_INT) == 0)
  68. break;
  69. if (RD_REG_WORD(&reg->semaphore) & BIT_0) {
  70. WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
  71. RD_REG_WORD(&reg->hccr);
  72. /* Get mailbox data. */
  73. mb[0] = RD_MAILBOX_REG(ha, reg, 0);
  74. if (mb[0] > 0x3fff && mb[0] < 0x8000) {
  75. qla2x00_mbx_completion(vha, mb[0]);
  76. status |= MBX_INTERRUPT;
  77. } else if (mb[0] > 0x7fff && mb[0] < 0xc000) {
  78. mb[1] = RD_MAILBOX_REG(ha, reg, 1);
  79. mb[2] = RD_MAILBOX_REG(ha, reg, 2);
  80. mb[3] = RD_MAILBOX_REG(ha, reg, 3);
  81. qla2x00_async_event(vha, rsp, mb);
  82. } else {
  83. /*EMPTY*/
  84. DEBUG2(printk("scsi(%ld): Unrecognized "
  85. "interrupt type (%d).\n",
  86. vha->host_no, mb[0]));
  87. }
  88. /* Release mailbox registers. */
  89. WRT_REG_WORD(&reg->semaphore, 0);
  90. RD_REG_WORD(&reg->semaphore);
  91. } else {
  92. qla2x00_process_response_queue(rsp);
  93. WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
  94. RD_REG_WORD(&reg->hccr);
  95. }
  96. }
  97. spin_unlock_irqrestore(&ha->hardware_lock, flags);
  98. if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
  99. (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
  100. set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
  101. complete(&ha->mbx_intr_comp);
  102. }
  103. return (IRQ_HANDLED);
  104. }
  105. /**
  106. * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
  107. * @irq:
  108. * @dev_id: SCSI driver HA context
  109. *
  110. * Called by system whenever the host adapter generates an interrupt.
  111. *
  112. * Returns handled flag.
  113. */
  114. irqreturn_t
  115. qla2300_intr_handler(int irq, void *dev_id)
  116. {
  117. scsi_qla_host_t *vha;
  118. struct device_reg_2xxx __iomem *reg;
  119. int status;
  120. unsigned long iter;
  121. uint32_t stat;
  122. uint16_t hccr;
  123. uint16_t mb[4];
  124. struct rsp_que *rsp;
  125. struct qla_hw_data *ha;
  126. unsigned long flags;
  127. rsp = (struct rsp_que *) dev_id;
  128. if (!rsp) {
  129. printk(KERN_INFO
  130. "%s(): NULL response queue pointer\n", __func__);
  131. return (IRQ_NONE);
  132. }
  133. ha = rsp->hw;
  134. reg = &ha->iobase->isp;
  135. status = 0;
  136. spin_lock_irqsave(&ha->hardware_lock, flags);
  137. vha = pci_get_drvdata(ha->pdev);
  138. for (iter = 50; iter--; ) {
  139. stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
  140. if (stat & HSR_RISC_PAUSED) {
  141. if (unlikely(pci_channel_offline(ha->pdev)))
  142. break;
  143. hccr = RD_REG_WORD(&reg->hccr);
  144. if (hccr & (BIT_15 | BIT_13 | BIT_11 | BIT_8))
  145. qla_printk(KERN_INFO, ha, "Parity error -- "
  146. "HCCR=%x, Dumping firmware!\n", hccr);
  147. else
  148. qla_printk(KERN_INFO, ha, "RISC paused -- "
  149. "HCCR=%x, Dumping firmware!\n", hccr);
  150. /*
  151. * Issue a "HARD" reset in order for the RISC
  152. * interrupt bit to be cleared. Schedule a big
  153. * hammmer to get out of the RISC PAUSED state.
  154. */
  155. WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
  156. RD_REG_WORD(&reg->hccr);
  157. ha->isp_ops->fw_dump(vha, 1);
  158. set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
  159. break;
  160. } else if ((stat & HSR_RISC_INT) == 0)
  161. break;
  162. switch (stat & 0xff) {
  163. case 0x1:
  164. case 0x2:
  165. case 0x10:
  166. case 0x11:
  167. qla2x00_mbx_completion(vha, MSW(stat));
  168. status |= MBX_INTERRUPT;
  169. /* Release mailbox registers. */
  170. WRT_REG_WORD(&reg->semaphore, 0);
  171. break;
  172. case 0x12:
  173. mb[0] = MSW(stat);
  174. mb[1] = RD_MAILBOX_REG(ha, reg, 1);
  175. mb[2] = RD_MAILBOX_REG(ha, reg, 2);
  176. mb[3] = RD_MAILBOX_REG(ha, reg, 3);
  177. qla2x00_async_event(vha, rsp, mb);
  178. break;
  179. case 0x13:
  180. qla2x00_process_response_queue(rsp);
  181. break;
  182. case 0x15:
  183. mb[0] = MBA_CMPLT_1_16BIT;
  184. mb[1] = MSW(stat);
  185. qla2x00_async_event(vha, rsp, mb);
  186. break;
  187. case 0x16:
  188. mb[0] = MBA_SCSI_COMPLETION;
  189. mb[1] = MSW(stat);
  190. mb[2] = RD_MAILBOX_REG(ha, reg, 2);
  191. qla2x00_async_event(vha, rsp, mb);
  192. break;
  193. default:
  194. DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
  195. "(%d).\n",
  196. vha->host_no, stat & 0xff));
  197. break;
  198. }
  199. WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
  200. RD_REG_WORD_RELAXED(&reg->hccr);
  201. }
  202. spin_unlock_irqrestore(&ha->hardware_lock, flags);
  203. if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
  204. (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
  205. set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
  206. complete(&ha->mbx_intr_comp);
  207. }
  208. return (IRQ_HANDLED);
  209. }
  210. /**
  211. * qla2x00_mbx_completion() - Process mailbox command completions.
  212. * @ha: SCSI driver HA context
  213. * @mb0: Mailbox0 register
  214. */
  215. static void
  216. qla2x00_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
  217. {
  218. uint16_t cnt;
  219. uint16_t __iomem *wptr;
  220. struct qla_hw_data *ha = vha->hw;
  221. struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
  222. /* Load return mailbox registers. */
  223. ha->flags.mbox_int = 1;
  224. ha->mailbox_out[0] = mb0;
  225. wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 1);
  226. for (cnt = 1; cnt < ha->mbx_count; cnt++) {
  227. if (IS_QLA2200(ha) && cnt == 8)
  228. wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 8);
  229. if (cnt == 4 || cnt == 5)
  230. ha->mailbox_out[cnt] = qla2x00_debounce_register(wptr);
  231. else
  232. ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
  233. wptr++;
  234. }
  235. if (ha->mcp) {
  236. DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
  237. __func__, vha->host_no, ha->mcp->mb[0]));
  238. } else {
  239. DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
  240. __func__, vha->host_no));
  241. }
  242. }
  243. static void
  244. qla81xx_idc_event(scsi_qla_host_t *vha, uint16_t aen, uint16_t descr)
  245. {
  246. static char *event[] =
  247. { "Complete", "Request Notification", "Time Extension" };
  248. int rval;
  249. struct device_reg_24xx __iomem *reg24 = &vha->hw->iobase->isp24;
  250. uint16_t __iomem *wptr;
  251. uint16_t cnt, timeout, mb[QLA_IDC_ACK_REGS];
  252. /* Seed data -- mailbox1 -> mailbox7. */
  253. wptr = (uint16_t __iomem *)&reg24->mailbox1;
  254. for (cnt = 0; cnt < QLA_IDC_ACK_REGS; cnt++, wptr++)
  255. mb[cnt] = RD_REG_WORD(wptr);
  256. DEBUG2(printk("scsi(%ld): Inter-Driver Commucation %s -- "
  257. "%04x %04x %04x %04x %04x %04x %04x.\n", vha->host_no,
  258. event[aen & 0xff],
  259. mb[0], mb[1], mb[2], mb[3], mb[4], mb[5], mb[6]));
  260. /* Acknowledgement needed? [Notify && non-zero timeout]. */
  261. timeout = (descr >> 8) & 0xf;
  262. if (aen != MBA_IDC_NOTIFY || !timeout)
  263. return;
  264. DEBUG2(printk("scsi(%ld): Inter-Driver Commucation %s -- "
  265. "ACK timeout=%d.\n", vha->host_no, event[aen & 0xff], timeout));
  266. rval = qla2x00_post_idc_ack_work(vha, mb);
  267. if (rval != QLA_SUCCESS)
  268. qla_printk(KERN_WARNING, vha->hw,
  269. "IDC failed to post ACK.\n");
  270. }
  271. /**
  272. * qla2x00_async_event() - Process aynchronous events.
  273. * @ha: SCSI driver HA context
  274. * @mb: Mailbox registers (0 - 3)
  275. */
  276. void
  277. qla2x00_async_event(scsi_qla_host_t *vha, struct rsp_que *rsp, uint16_t *mb)
  278. {
  279. #define LS_UNKNOWN 2
  280. static char *link_speeds[] = { "1", "2", "?", "4", "8", "10" };
  281. char *link_speed;
  282. uint16_t handle_cnt;
  283. uint16_t cnt, mbx;
  284. uint32_t handles[5];
  285. struct qla_hw_data *ha = vha->hw;
  286. struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
  287. struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
  288. uint32_t rscn_entry, host_pid;
  289. uint8_t rscn_queue_index;
  290. unsigned long flags;
  291. /* Setup to process RIO completion. */
  292. handle_cnt = 0;
  293. if (IS_QLA8XXX_TYPE(ha))
  294. goto skip_rio;
  295. switch (mb[0]) {
  296. case MBA_SCSI_COMPLETION:
  297. handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
  298. handle_cnt = 1;
  299. break;
  300. case MBA_CMPLT_1_16BIT:
  301. handles[0] = mb[1];
  302. handle_cnt = 1;
  303. mb[0] = MBA_SCSI_COMPLETION;
  304. break;
  305. case MBA_CMPLT_2_16BIT:
  306. handles[0] = mb[1];
  307. handles[1] = mb[2];
  308. handle_cnt = 2;
  309. mb[0] = MBA_SCSI_COMPLETION;
  310. break;
  311. case MBA_CMPLT_3_16BIT:
  312. handles[0] = mb[1];
  313. handles[1] = mb[2];
  314. handles[2] = mb[3];
  315. handle_cnt = 3;
  316. mb[0] = MBA_SCSI_COMPLETION;
  317. break;
  318. case MBA_CMPLT_4_16BIT:
  319. handles[0] = mb[1];
  320. handles[1] = mb[2];
  321. handles[2] = mb[3];
  322. handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
  323. handle_cnt = 4;
  324. mb[0] = MBA_SCSI_COMPLETION;
  325. break;
  326. case MBA_CMPLT_5_16BIT:
  327. handles[0] = mb[1];
  328. handles[1] = mb[2];
  329. handles[2] = mb[3];
  330. handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
  331. handles[4] = (uint32_t)RD_MAILBOX_REG(ha, reg, 7);
  332. handle_cnt = 5;
  333. mb[0] = MBA_SCSI_COMPLETION;
  334. break;
  335. case MBA_CMPLT_2_32BIT:
  336. handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
  337. handles[1] = le32_to_cpu(
  338. ((uint32_t)(RD_MAILBOX_REG(ha, reg, 7) << 16)) |
  339. RD_MAILBOX_REG(ha, reg, 6));
  340. handle_cnt = 2;
  341. mb[0] = MBA_SCSI_COMPLETION;
  342. break;
  343. default:
  344. break;
  345. }
  346. skip_rio:
  347. switch (mb[0]) {
  348. case MBA_SCSI_COMPLETION: /* Fast Post */
  349. if (!vha->flags.online)
  350. break;
  351. for (cnt = 0; cnt < handle_cnt; cnt++)
  352. qla2x00_process_completed_request(vha, rsp->req,
  353. handles[cnt]);
  354. break;
  355. case MBA_RESET: /* Reset */
  356. DEBUG2(printk("scsi(%ld): Asynchronous RESET.\n",
  357. vha->host_no));
  358. set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
  359. break;
  360. case MBA_SYSTEM_ERR: /* System Error */
  361. mbx = IS_QLA81XX(ha) ? RD_REG_WORD(&reg24->mailbox7) : 0;
  362. qla_printk(KERN_INFO, ha,
  363. "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh "
  364. "mbx7=%xh.\n", mb[1], mb[2], mb[3], mbx);
  365. ha->isp_ops->fw_dump(vha, 1);
  366. if (IS_FWI2_CAPABLE(ha)) {
  367. if (mb[1] == 0 && mb[2] == 0) {
  368. qla_printk(KERN_ERR, ha,
  369. "Unrecoverable Hardware Error: adapter "
  370. "marked OFFLINE!\n");
  371. vha->flags.online = 0;
  372. } else
  373. set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
  374. } else if (mb[1] == 0) {
  375. qla_printk(KERN_INFO, ha,
  376. "Unrecoverable Hardware Error: adapter marked "
  377. "OFFLINE!\n");
  378. vha->flags.online = 0;
  379. } else
  380. set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
  381. break;
  382. case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
  383. DEBUG2(printk("scsi(%ld): ISP Request Transfer Error (%x).\n",
  384. vha->host_no, mb[1]));
  385. qla_printk(KERN_WARNING, ha,
  386. "ISP Request Transfer Error (%x).\n", mb[1]);
  387. set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
  388. break;
  389. case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
  390. DEBUG2(printk("scsi(%ld): ISP Response Transfer Error.\n",
  391. vha->host_no));
  392. qla_printk(KERN_WARNING, ha, "ISP Response Transfer Error.\n");
  393. set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
  394. break;
  395. case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
  396. DEBUG2(printk("scsi(%ld): Asynchronous WAKEUP_THRES.\n",
  397. vha->host_no));
  398. break;
  399. case MBA_LIP_OCCURRED: /* Loop Initialization Procedure */
  400. DEBUG2(printk("scsi(%ld): LIP occurred (%x).\n", vha->host_no,
  401. mb[1]));
  402. qla_printk(KERN_INFO, ha, "LIP occurred (%x).\n", mb[1]);
  403. if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
  404. atomic_set(&vha->loop_state, LOOP_DOWN);
  405. atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
  406. qla2x00_mark_all_devices_lost(vha, 1);
  407. }
  408. if (vha->vp_idx) {
  409. atomic_set(&vha->vp_state, VP_FAILED);
  410. fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
  411. }
  412. set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
  413. set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
  414. vha->flags.management_server_logged_in = 0;
  415. qla2x00_post_aen_work(vha, FCH_EVT_LIP, mb[1]);
  416. break;
  417. case MBA_LOOP_UP: /* Loop Up Event */
  418. if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
  419. link_speed = link_speeds[0];
  420. ha->link_data_rate = PORT_SPEED_1GB;
  421. } else {
  422. link_speed = link_speeds[LS_UNKNOWN];
  423. if (mb[1] < 5)
  424. link_speed = link_speeds[mb[1]];
  425. else if (mb[1] == 0x13)
  426. link_speed = link_speeds[5];
  427. ha->link_data_rate = mb[1];
  428. }
  429. DEBUG2(printk("scsi(%ld): Asynchronous LOOP UP (%s Gbps).\n",
  430. vha->host_no, link_speed));
  431. qla_printk(KERN_INFO, ha, "LOOP UP detected (%s Gbps).\n",
  432. link_speed);
  433. vha->flags.management_server_logged_in = 0;
  434. qla2x00_post_aen_work(vha, FCH_EVT_LINKUP, ha->link_data_rate);
  435. break;
  436. case MBA_LOOP_DOWN: /* Loop Down Event */
  437. mbx = IS_QLA81XX(ha) ? RD_REG_WORD(&reg24->mailbox4) : 0;
  438. DEBUG2(printk("scsi(%ld): Asynchronous LOOP DOWN "
  439. "(%x %x %x %x).\n", vha->host_no, mb[1], mb[2], mb[3],
  440. mbx));
  441. qla_printk(KERN_INFO, ha,
  442. "LOOP DOWN detected (%x %x %x %x).\n", mb[1], mb[2], mb[3],
  443. mbx);
  444. if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
  445. atomic_set(&vha->loop_state, LOOP_DOWN);
  446. atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
  447. vha->device_flags |= DFLG_NO_CABLE;
  448. qla2x00_mark_all_devices_lost(vha, 1);
  449. }
  450. if (vha->vp_idx) {
  451. atomic_set(&vha->vp_state, VP_FAILED);
  452. fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
  453. }
  454. vha->flags.management_server_logged_in = 0;
  455. ha->link_data_rate = PORT_SPEED_UNKNOWN;
  456. qla2x00_post_aen_work(vha, FCH_EVT_LINKDOWN, 0);
  457. break;
  458. case MBA_LIP_RESET: /* LIP reset occurred */
  459. DEBUG2(printk("scsi(%ld): Asynchronous LIP RESET (%x).\n",
  460. vha->host_no, mb[1]));
  461. qla_printk(KERN_INFO, ha,
  462. "LIP reset occurred (%x).\n", mb[1]);
  463. if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
  464. atomic_set(&vha->loop_state, LOOP_DOWN);
  465. atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
  466. qla2x00_mark_all_devices_lost(vha, 1);
  467. }
  468. if (vha->vp_idx) {
  469. atomic_set(&vha->vp_state, VP_FAILED);
  470. fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
  471. }
  472. set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
  473. ha->operating_mode = LOOP;
  474. vha->flags.management_server_logged_in = 0;
  475. qla2x00_post_aen_work(vha, FCH_EVT_LIPRESET, mb[1]);
  476. break;
  477. /* case MBA_DCBX_COMPLETE: */
  478. case MBA_POINT_TO_POINT: /* Point-to-Point */
  479. if (IS_QLA2100(ha))
  480. break;
  481. if (IS_QLA8XXX_TYPE(ha)) {
  482. DEBUG2(printk("scsi(%ld): DCBX Completed -- %04x %04x "
  483. "%04x\n", vha->host_no, mb[1], mb[2], mb[3]));
  484. if (ha->notify_dcbx_comp)
  485. complete(&ha->dcbx_comp);
  486. } else
  487. DEBUG2(printk("scsi(%ld): Asynchronous P2P MODE "
  488. "received.\n", vha->host_no));
  489. /*
  490. * Until there's a transition from loop down to loop up, treat
  491. * this as loop down only.
  492. */
  493. if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
  494. atomic_set(&vha->loop_state, LOOP_DOWN);
  495. if (!atomic_read(&vha->loop_down_timer))
  496. atomic_set(&vha->loop_down_timer,
  497. LOOP_DOWN_TIME);
  498. qla2x00_mark_all_devices_lost(vha, 1);
  499. }
  500. if (vha->vp_idx) {
  501. atomic_set(&vha->vp_state, VP_FAILED);
  502. fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
  503. }
  504. if (!(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)))
  505. set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
  506. set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
  507. set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
  508. ha->flags.gpsc_supported = 1;
  509. vha->flags.management_server_logged_in = 0;
  510. break;
  511. case MBA_CHG_IN_CONNECTION: /* Change in connection mode */
  512. if (IS_QLA2100(ha))
  513. break;
  514. DEBUG2(printk("scsi(%ld): Asynchronous Change In Connection "
  515. "received.\n",
  516. vha->host_no));
  517. qla_printk(KERN_INFO, ha,
  518. "Configuration change detected: value=%x.\n", mb[1]);
  519. if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
  520. atomic_set(&vha->loop_state, LOOP_DOWN);
  521. if (!atomic_read(&vha->loop_down_timer))
  522. atomic_set(&vha->loop_down_timer,
  523. LOOP_DOWN_TIME);
  524. qla2x00_mark_all_devices_lost(vha, 1);
  525. }
  526. if (vha->vp_idx) {
  527. atomic_set(&vha->vp_state, VP_FAILED);
  528. fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
  529. }
  530. set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
  531. set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
  532. break;
  533. case MBA_PORT_UPDATE: /* Port database update */
  534. /*
  535. * Handle only global and vn-port update events
  536. *
  537. * Relevant inputs:
  538. * mb[1] = N_Port handle of changed port
  539. * OR 0xffff for global event
  540. * mb[2] = New login state
  541. * 7 = Port logged out
  542. * mb[3] = LSB is vp_idx, 0xff = all vps
  543. *
  544. * Skip processing if:
  545. * Event is global, vp_idx is NOT all vps,
  546. * vp_idx does not match
  547. * Event is not global, vp_idx does not match
  548. */
  549. if (IS_QLA2XXX_MIDTYPE(ha) &&
  550. ((mb[1] == 0xffff && (mb[3] & 0xff) != 0xff) ||
  551. (mb[1] != 0xffff)) && vha->vp_idx != (mb[3] & 0xff))
  552. break;
  553. /* Global event -- port logout or port unavailable. */
  554. if (mb[1] == 0xffff && mb[2] == 0x7) {
  555. DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n",
  556. vha->host_no));
  557. DEBUG(printk(KERN_INFO
  558. "scsi(%ld): Port unavailable %04x %04x %04x.\n",
  559. vha->host_no, mb[1], mb[2], mb[3]));
  560. if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
  561. atomic_set(&vha->loop_state, LOOP_DOWN);
  562. atomic_set(&vha->loop_down_timer,
  563. LOOP_DOWN_TIME);
  564. vha->device_flags |= DFLG_NO_CABLE;
  565. qla2x00_mark_all_devices_lost(vha, 1);
  566. }
  567. if (vha->vp_idx) {
  568. atomic_set(&vha->vp_state, VP_FAILED);
  569. fc_vport_set_state(vha->fc_vport,
  570. FC_VPORT_FAILED);
  571. qla2x00_mark_all_devices_lost(vha, 1);
  572. }
  573. vha->flags.management_server_logged_in = 0;
  574. ha->link_data_rate = PORT_SPEED_UNKNOWN;
  575. break;
  576. }
  577. /*
  578. * If PORT UPDATE is global (received LIP_OCCURRED/LIP_RESET
  579. * event etc. earlier indicating loop is down) then process
  580. * it. Otherwise ignore it and Wait for RSCN to come in.
  581. */
  582. atomic_set(&vha->loop_down_timer, 0);
  583. if (atomic_read(&vha->loop_state) != LOOP_DOWN &&
  584. atomic_read(&vha->loop_state) != LOOP_DEAD) {
  585. DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE "
  586. "ignored %04x/%04x/%04x.\n", vha->host_no, mb[1],
  587. mb[2], mb[3]));
  588. break;
  589. }
  590. DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n",
  591. vha->host_no));
  592. DEBUG(printk(KERN_INFO
  593. "scsi(%ld): Port database changed %04x %04x %04x.\n",
  594. vha->host_no, mb[1], mb[2], mb[3]));
  595. /*
  596. * Mark all devices as missing so we will login again.
  597. */
  598. atomic_set(&vha->loop_state, LOOP_UP);
  599. qla2x00_mark_all_devices_lost(vha, 1);
  600. vha->flags.rscn_queue_overflow = 1;
  601. set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
  602. set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
  603. break;
  604. case MBA_RSCN_UPDATE: /* State Change Registration */
  605. /* Check if the Vport has issued a SCR */
  606. if (vha->vp_idx && test_bit(VP_SCR_NEEDED, &vha->vp_flags))
  607. break;
  608. /* Only handle SCNs for our Vport index. */
  609. if (ha->flags.npiv_supported && vha->vp_idx != (mb[3] & 0xff))
  610. break;
  611. DEBUG2(printk("scsi(%ld): Asynchronous RSCR UPDATE.\n",
  612. vha->host_no));
  613. DEBUG(printk(KERN_INFO
  614. "scsi(%ld): RSCN database changed -- %04x %04x %04x.\n",
  615. vha->host_no, mb[1], mb[2], mb[3]));
  616. rscn_entry = ((mb[1] & 0xff) << 16) | mb[2];
  617. host_pid = (vha->d_id.b.domain << 16) | (vha->d_id.b.area << 8)
  618. | vha->d_id.b.al_pa;
  619. if (rscn_entry == host_pid) {
  620. DEBUG(printk(KERN_INFO
  621. "scsi(%ld): Ignoring RSCN update to local host "
  622. "port ID (%06x)\n",
  623. vha->host_no, host_pid));
  624. break;
  625. }
  626. /* Ignore reserved bits from RSCN-payload. */
  627. rscn_entry = ((mb[1] & 0x3ff) << 16) | mb[2];
  628. rscn_queue_index = vha->rscn_in_ptr + 1;
  629. if (rscn_queue_index == MAX_RSCN_COUNT)
  630. rscn_queue_index = 0;
  631. if (rscn_queue_index != vha->rscn_out_ptr) {
  632. vha->rscn_queue[vha->rscn_in_ptr] = rscn_entry;
  633. vha->rscn_in_ptr = rscn_queue_index;
  634. } else {
  635. vha->flags.rscn_queue_overflow = 1;
  636. }
  637. atomic_set(&vha->loop_state, LOOP_UPDATE);
  638. atomic_set(&vha->loop_down_timer, 0);
  639. vha->flags.management_server_logged_in = 0;
  640. set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
  641. set_bit(RSCN_UPDATE, &vha->dpc_flags);
  642. qla2x00_post_aen_work(vha, FCH_EVT_RSCN, rscn_entry);
  643. break;
  644. /* case MBA_RIO_RESPONSE: */
  645. case MBA_ZIO_RESPONSE:
  646. DEBUG3(printk("scsi(%ld): [R|Z]IO update completion.\n",
  647. vha->host_no));
  648. if (IS_FWI2_CAPABLE(ha))
  649. qla24xx_process_response_queue(vha, rsp);
  650. else
  651. qla2x00_process_response_queue(rsp);
  652. break;
  653. case MBA_DISCARD_RND_FRAME:
  654. DEBUG2(printk("scsi(%ld): Discard RND Frame -- %04x %04x "
  655. "%04x.\n", vha->host_no, mb[1], mb[2], mb[3]));
  656. break;
  657. case MBA_TRACE_NOTIFICATION:
  658. DEBUG2(printk("scsi(%ld): Trace Notification -- %04x %04x.\n",
  659. vha->host_no, mb[1], mb[2]));
  660. break;
  661. case MBA_ISP84XX_ALERT:
  662. DEBUG2(printk("scsi(%ld): ISP84XX Alert Notification -- "
  663. "%04x %04x %04x\n", vha->host_no, mb[1], mb[2], mb[3]));
  664. spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
  665. switch (mb[1]) {
  666. case A84_PANIC_RECOVERY:
  667. qla_printk(KERN_INFO, ha, "Alert 84XX: panic recovery "
  668. "%04x %04x\n", mb[2], mb[3]);
  669. break;
  670. case A84_OP_LOGIN_COMPLETE:
  671. ha->cs84xx->op_fw_version = mb[3] << 16 | mb[2];
  672. DEBUG2(qla_printk(KERN_INFO, ha, "Alert 84XX:"
  673. "firmware version %x\n", ha->cs84xx->op_fw_version));
  674. break;
  675. case A84_DIAG_LOGIN_COMPLETE:
  676. ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
  677. DEBUG2(qla_printk(KERN_INFO, ha, "Alert 84XX:"
  678. "diagnostic firmware version %x\n",
  679. ha->cs84xx->diag_fw_version));
  680. break;
  681. case A84_GOLD_LOGIN_COMPLETE:
  682. ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
  683. ha->cs84xx->fw_update = 1;
  684. DEBUG2(qla_printk(KERN_INFO, ha, "Alert 84XX: gold "
  685. "firmware version %x\n",
  686. ha->cs84xx->gold_fw_version));
  687. break;
  688. default:
  689. qla_printk(KERN_ERR, ha,
  690. "Alert 84xx: Invalid Alert %04x %04x %04x\n",
  691. mb[1], mb[2], mb[3]);
  692. }
  693. spin_unlock_irqrestore(&ha->cs84xx->access_lock, flags);
  694. break;
  695. case MBA_DCBX_START:
  696. DEBUG2(printk("scsi(%ld): DCBX Started -- %04x %04x %04x\n",
  697. vha->host_no, mb[1], mb[2], mb[3]));
  698. break;
  699. case MBA_DCBX_PARAM_UPDATE:
  700. DEBUG2(printk("scsi(%ld): DCBX Parameters Updated -- "
  701. "%04x %04x %04x\n", vha->host_no, mb[1], mb[2], mb[3]));
  702. break;
  703. case MBA_FCF_CONF_ERR:
  704. DEBUG2(printk("scsi(%ld): FCF Configuration Error -- "
  705. "%04x %04x %04x\n", vha->host_no, mb[1], mb[2], mb[3]));
  706. break;
  707. case MBA_IDC_COMPLETE:
  708. case MBA_IDC_NOTIFY:
  709. case MBA_IDC_TIME_EXT:
  710. qla81xx_idc_event(vha, mb[0], mb[1]);
  711. break;
  712. }
  713. if (!vha->vp_idx && ha->num_vhosts)
  714. qla2x00_alert_all_vps(rsp, mb);
  715. }
  716. /**
  717. * qla2x00_process_completed_request() - Process a Fast Post response.
  718. * @ha: SCSI driver HA context
  719. * @index: SRB index
  720. */
  721. static void
  722. qla2x00_process_completed_request(struct scsi_qla_host *vha,
  723. struct req_que *req, uint32_t index)
  724. {
  725. srb_t *sp;
  726. struct qla_hw_data *ha = vha->hw;
  727. /* Validate handle. */
  728. if (index >= MAX_OUTSTANDING_COMMANDS) {
  729. DEBUG2(printk("scsi(%ld): Invalid SCSI completion handle %d.\n",
  730. vha->host_no, index));
  731. qla_printk(KERN_WARNING, ha,
  732. "Invalid SCSI completion handle %d.\n", index);
  733. set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
  734. return;
  735. }
  736. sp = req->outstanding_cmds[index];
  737. if (sp) {
  738. /* Free outstanding command slot. */
  739. req->outstanding_cmds[index] = NULL;
  740. /* Save ISP completion status */
  741. sp->cmd->result = DID_OK << 16;
  742. qla2x00_sp_compl(ha, sp);
  743. } else {
  744. DEBUG2(printk("scsi(%ld) Req:%d: Invalid ISP SCSI completion"
  745. " handle(0x%x)\n", vha->host_no, req->id, index));
  746. qla_printk(KERN_WARNING, ha,
  747. "Invalid ISP SCSI completion handle\n");
  748. set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
  749. }
  750. }
  751. static srb_t *
  752. qla2x00_get_sp_from_handle(scsi_qla_host_t *vha, const char *func,
  753. struct req_que *req, void *iocb)
  754. {
  755. struct qla_hw_data *ha = vha->hw;
  756. sts_entry_t *pkt = iocb;
  757. srb_t *sp = NULL;
  758. uint16_t index;
  759. index = LSW(pkt->handle);
  760. if (index >= MAX_OUTSTANDING_COMMANDS) {
  761. qla_printk(KERN_WARNING, ha,
  762. "%s: Invalid completion handle (%x).\n", func, index);
  763. set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
  764. goto done;
  765. }
  766. sp = req->outstanding_cmds[index];
  767. if (!sp) {
  768. qla_printk(KERN_WARNING, ha,
  769. "%s: Invalid completion handle (%x) -- timed-out.\n", func,
  770. index);
  771. return sp;
  772. }
  773. if (sp->handle != index) {
  774. qla_printk(KERN_WARNING, ha,
  775. "%s: SRB handle (%x) mismatch %x.\n", func, sp->handle,
  776. index);
  777. return NULL;
  778. }
  779. req->outstanding_cmds[index] = NULL;
  780. done:
  781. return sp;
  782. }
  783. static void
  784. qla2x00_mbx_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
  785. struct mbx_entry *mbx)
  786. {
  787. const char func[] = "MBX-IOCB";
  788. const char *type;
  789. fc_port_t *fcport;
  790. srb_t *sp;
  791. struct srb_iocb *lio;
  792. struct srb_ctx *ctx;
  793. uint16_t *data;
  794. uint16_t status;
  795. sp = qla2x00_get_sp_from_handle(vha, func, req, mbx);
  796. if (!sp)
  797. return;
  798. ctx = sp->ctx;
  799. lio = ctx->u.iocb_cmd;
  800. type = ctx->name;
  801. fcport = sp->fcport;
  802. data = lio->u.logio.data;
  803. data[0] = MBS_COMMAND_ERROR;
  804. data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
  805. QLA_LOGIO_LOGIN_RETRIED : 0;
  806. if (mbx->entry_status) {
  807. DEBUG2(printk(KERN_WARNING
  808. "scsi(%ld:%x): Async-%s error entry - portid=%02x%02x%02x "
  809. "entry-status=%x status=%x state-flag=%x "
  810. "status-flags=%x.\n",
  811. fcport->vha->host_no, sp->handle, type,
  812. fcport->d_id.b.domain, fcport->d_id.b.area,
  813. fcport->d_id.b.al_pa, mbx->entry_status,
  814. le16_to_cpu(mbx->status), le16_to_cpu(mbx->state_flags),
  815. le16_to_cpu(mbx->status_flags)));
  816. DEBUG2(qla2x00_dump_buffer((uint8_t *)mbx, sizeof(*mbx)));
  817. goto logio_done;
  818. }
  819. status = le16_to_cpu(mbx->status);
  820. if (status == 0x30 && ctx->type == SRB_LOGIN_CMD &&
  821. le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE)
  822. status = 0;
  823. if (!status && le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE) {
  824. DEBUG2(printk(KERN_DEBUG
  825. "scsi(%ld:%x): Async-%s complete - portid=%02x%02x%02x "
  826. "mbx1=%x.\n",
  827. fcport->vha->host_no, sp->handle, type,
  828. fcport->d_id.b.domain, fcport->d_id.b.area,
  829. fcport->d_id.b.al_pa, le16_to_cpu(mbx->mb1)));
  830. data[0] = MBS_COMMAND_COMPLETE;
  831. if (ctx->type == SRB_LOGIN_CMD) {
  832. fcport->port_type = FCT_TARGET;
  833. if (le16_to_cpu(mbx->mb1) & BIT_0)
  834. fcport->port_type = FCT_INITIATOR;
  835. else if (le16_to_cpu(mbx->mb1) & BIT_1)
  836. fcport->flags |= FCF_FCP2_DEVICE;
  837. }
  838. goto logio_done;
  839. }
  840. data[0] = le16_to_cpu(mbx->mb0);
  841. switch (data[0]) {
  842. case MBS_PORT_ID_USED:
  843. data[1] = le16_to_cpu(mbx->mb1);
  844. break;
  845. case MBS_LOOP_ID_USED:
  846. break;
  847. default:
  848. data[0] = MBS_COMMAND_ERROR;
  849. break;
  850. }
  851. DEBUG2(printk(KERN_WARNING
  852. "scsi(%ld:%x): Async-%s failed - portid=%02x%02x%02x status=%x "
  853. "mb0=%x mb1=%x mb2=%x mb6=%x mb7=%x.\n",
  854. fcport->vha->host_no, sp->handle, type, fcport->d_id.b.domain,
  855. fcport->d_id.b.area, fcport->d_id.b.al_pa, status,
  856. le16_to_cpu(mbx->mb0), le16_to_cpu(mbx->mb1),
  857. le16_to_cpu(mbx->mb2), le16_to_cpu(mbx->mb6),
  858. le16_to_cpu(mbx->mb7)));
  859. logio_done:
  860. lio->done(sp);
  861. }
  862. static void
  863. qla2x00_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
  864. sts_entry_t *pkt, int iocb_type)
  865. {
  866. const char func[] = "CT_IOCB";
  867. const char *type;
  868. struct qla_hw_data *ha = vha->hw;
  869. srb_t *sp;
  870. struct srb_ctx *sp_bsg;
  871. struct fc_bsg_job *bsg_job;
  872. uint16_t comp_status;
  873. sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
  874. if (!sp)
  875. return;
  876. sp_bsg = sp->ctx;
  877. bsg_job = sp_bsg->u.bsg_job;
  878. type = NULL;
  879. switch (sp_bsg->type) {
  880. case SRB_CT_CMD:
  881. type = "ct pass-through";
  882. break;
  883. default:
  884. qla_printk(KERN_WARNING, ha,
  885. "%s: Unrecognized SRB: (%p) type=%d.\n", func, sp,
  886. sp_bsg->type);
  887. return;
  888. }
  889. comp_status = le16_to_cpu(pkt->comp_status);
  890. /* return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
  891. * fc payload to the caller
  892. */
  893. bsg_job->reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
  894. bsg_job->reply_len = sizeof(struct fc_bsg_reply);
  895. if (comp_status != CS_COMPLETE) {
  896. if (comp_status == CS_DATA_UNDERRUN) {
  897. bsg_job->reply->result = DID_OK << 16;
  898. bsg_job->reply->reply_payload_rcv_len =
  899. le16_to_cpu(((sts_entry_t *)pkt)->rsp_info_len);
  900. DEBUG2(qla_printk(KERN_WARNING, ha,
  901. "scsi(%ld): CT pass-through-%s error "
  902. "comp_status-status=0x%x total_byte = 0x%x.\n",
  903. vha->host_no, type, comp_status,
  904. bsg_job->reply->reply_payload_rcv_len));
  905. } else {
  906. DEBUG2(qla_printk(KERN_WARNING, ha,
  907. "scsi(%ld): CT pass-through-%s error "
  908. "comp_status-status=0x%x.\n",
  909. vha->host_no, type, comp_status));
  910. bsg_job->reply->result = DID_ERROR << 16;
  911. bsg_job->reply->reply_payload_rcv_len = 0;
  912. }
  913. DEBUG2(qla2x00_dump_buffer((uint8_t *)pkt, sizeof(*pkt)));
  914. } else {
  915. bsg_job->reply->result = DID_OK << 16;;
  916. bsg_job->reply->reply_payload_rcv_len =
  917. bsg_job->reply_payload.payload_len;
  918. bsg_job->reply_len = 0;
  919. }
  920. dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
  921. bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
  922. dma_unmap_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
  923. bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
  924. if (sp_bsg->type == SRB_ELS_CMD_HST || sp_bsg->type == SRB_CT_CMD)
  925. kfree(sp->fcport);
  926. kfree(sp->ctx);
  927. mempool_free(sp, ha->srb_mempool);
  928. bsg_job->job_done(bsg_job);
  929. }
  930. static void
  931. qla24xx_els_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
  932. struct sts_entry_24xx *pkt, int iocb_type)
  933. {
  934. const char func[] = "ELS_CT_IOCB";
  935. const char *type;
  936. struct qla_hw_data *ha = vha->hw;
  937. srb_t *sp;
  938. struct srb_ctx *sp_bsg;
  939. struct fc_bsg_job *bsg_job;
  940. uint16_t comp_status;
  941. uint32_t fw_status[3];
  942. uint8_t* fw_sts_ptr;
  943. sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
  944. if (!sp)
  945. return;
  946. sp_bsg = sp->ctx;
  947. bsg_job = sp_bsg->u.bsg_job;
  948. type = NULL;
  949. switch (sp_bsg->type) {
  950. case SRB_ELS_CMD_RPT:
  951. case SRB_ELS_CMD_HST:
  952. type = "els";
  953. break;
  954. case SRB_CT_CMD:
  955. type = "ct pass-through";
  956. break;
  957. default:
  958. qla_printk(KERN_WARNING, ha,
  959. "%s: Unrecognized SRB: (%p) type=%d.\n", func, sp,
  960. sp_bsg->type);
  961. return;
  962. }
  963. comp_status = fw_status[0] = le16_to_cpu(pkt->comp_status);
  964. fw_status[1] = le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_1);
  965. fw_status[2] = le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_2);
  966. /* return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
  967. * fc payload to the caller
  968. */
  969. bsg_job->reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
  970. bsg_job->reply_len = sizeof(struct fc_bsg_reply) + sizeof(fw_status);
  971. if (comp_status != CS_COMPLETE) {
  972. if (comp_status == CS_DATA_UNDERRUN) {
  973. bsg_job->reply->result = DID_OK << 16;
  974. bsg_job->reply->reply_payload_rcv_len =
  975. le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->total_byte_count);
  976. DEBUG2(qla_printk(KERN_WARNING, ha,
  977. "scsi(%ld:0x%x): ELS-CT pass-through-%s error comp_status-status=0x%x "
  978. "error subcode 1=0x%x error subcode 2=0x%x total_byte = 0x%x.\n",
  979. vha->host_no, sp->handle, type, comp_status, fw_status[1], fw_status[2],
  980. le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->total_byte_count)));
  981. fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
  982. memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
  983. }
  984. else {
  985. DEBUG2(qla_printk(KERN_WARNING, ha,
  986. "scsi(%ld:0x%x): ELS-CT pass-through-%s error comp_status-status=0x%x "
  987. "error subcode 1=0x%x error subcode 2=0x%x.\n",
  988. vha->host_no, sp->handle, type, comp_status,
  989. le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_1),
  990. le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_2)));
  991. bsg_job->reply->result = DID_ERROR << 16;
  992. bsg_job->reply->reply_payload_rcv_len = 0;
  993. fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
  994. memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
  995. }
  996. DEBUG2(qla2x00_dump_buffer((uint8_t *)pkt, sizeof(*pkt)));
  997. }
  998. else {
  999. bsg_job->reply->result = DID_OK << 16;;
  1000. bsg_job->reply->reply_payload_rcv_len = bsg_job->reply_payload.payload_len;
  1001. bsg_job->reply_len = 0;
  1002. }
  1003. dma_unmap_sg(&ha->pdev->dev,
  1004. bsg_job->request_payload.sg_list,
  1005. bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
  1006. dma_unmap_sg(&ha->pdev->dev,
  1007. bsg_job->reply_payload.sg_list,
  1008. bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
  1009. if ((sp_bsg->type == SRB_ELS_CMD_HST) ||
  1010. (sp_bsg->type == SRB_CT_CMD))
  1011. kfree(sp->fcport);
  1012. kfree(sp->ctx);
  1013. mempool_free(sp, ha->srb_mempool);
  1014. bsg_job->job_done(bsg_job);
  1015. }
  1016. static void
  1017. qla24xx_logio_entry(scsi_qla_host_t *vha, struct req_que *req,
  1018. struct logio_entry_24xx *logio)
  1019. {
  1020. const char func[] = "LOGIO-IOCB";
  1021. const char *type;
  1022. fc_port_t *fcport;
  1023. srb_t *sp;
  1024. struct srb_iocb *lio;
  1025. struct srb_ctx *ctx;
  1026. uint16_t *data;
  1027. uint32_t iop[2];
  1028. sp = qla2x00_get_sp_from_handle(vha, func, req, logio);
  1029. if (!sp)
  1030. return;
  1031. ctx = sp->ctx;
  1032. lio = ctx->u.iocb_cmd;
  1033. type = ctx->name;
  1034. fcport = sp->fcport;
  1035. data = lio->u.logio.data;
  1036. data[0] = MBS_COMMAND_ERROR;
  1037. data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
  1038. QLA_LOGIO_LOGIN_RETRIED : 0;
  1039. if (logio->entry_status) {
  1040. DEBUG2(printk(KERN_WARNING
  1041. "scsi(%ld:%x): Async-%s error entry - "
  1042. "portid=%02x%02x%02x entry-status=%x.\n",
  1043. fcport->vha->host_no, sp->handle, type,
  1044. fcport->d_id.b.domain, fcport->d_id.b.area,
  1045. fcport->d_id.b.al_pa, logio->entry_status));
  1046. DEBUG2(qla2x00_dump_buffer((uint8_t *)logio, sizeof(*logio)));
  1047. goto logio_done;
  1048. }
  1049. if (le16_to_cpu(logio->comp_status) == CS_COMPLETE) {
  1050. DEBUG2(printk(KERN_DEBUG
  1051. "scsi(%ld:%x): Async-%s complete - portid=%02x%02x%02x "
  1052. "iop0=%x.\n",
  1053. fcport->vha->host_no, sp->handle, type,
  1054. fcport->d_id.b.domain, fcport->d_id.b.area,
  1055. fcport->d_id.b.al_pa,
  1056. le32_to_cpu(logio->io_parameter[0])));
  1057. data[0] = MBS_COMMAND_COMPLETE;
  1058. if (ctx->type != SRB_LOGIN_CMD)
  1059. goto logio_done;
  1060. iop[0] = le32_to_cpu(logio->io_parameter[0]);
  1061. if (iop[0] & BIT_4) {
  1062. fcport->port_type = FCT_TARGET;
  1063. if (iop[0] & BIT_8)
  1064. fcport->flags |= FCF_FCP2_DEVICE;
  1065. } else if (iop[0] & BIT_5)
  1066. fcport->port_type = FCT_INITIATOR;
  1067. if (logio->io_parameter[7] || logio->io_parameter[8])
  1068. fcport->supported_classes |= FC_COS_CLASS2;
  1069. if (logio->io_parameter[9] || logio->io_parameter[10])
  1070. fcport->supported_classes |= FC_COS_CLASS3;
  1071. goto logio_done;
  1072. }
  1073. iop[0] = le32_to_cpu(logio->io_parameter[0]);
  1074. iop[1] = le32_to_cpu(logio->io_parameter[1]);
  1075. switch (iop[0]) {
  1076. case LSC_SCODE_PORTID_USED:
  1077. data[0] = MBS_PORT_ID_USED;
  1078. data[1] = LSW(iop[1]);
  1079. break;
  1080. case LSC_SCODE_NPORT_USED:
  1081. data[0] = MBS_LOOP_ID_USED;
  1082. break;
  1083. case LSC_SCODE_CMD_FAILED:
  1084. if ((iop[1] & 0xff) == 0x05) {
  1085. data[0] = MBS_NOT_LOGGED_IN;
  1086. break;
  1087. }
  1088. /* Fall through. */
  1089. default:
  1090. data[0] = MBS_COMMAND_ERROR;
  1091. break;
  1092. }
  1093. DEBUG2(printk(KERN_WARNING
  1094. "scsi(%ld:%x): Async-%s failed - portid=%02x%02x%02x comp=%x "
  1095. "iop0=%x iop1=%x.\n",
  1096. fcport->vha->host_no, sp->handle, type, fcport->d_id.b.domain,
  1097. fcport->d_id.b.area, fcport->d_id.b.al_pa,
  1098. le16_to_cpu(logio->comp_status),
  1099. le32_to_cpu(logio->io_parameter[0]),
  1100. le32_to_cpu(logio->io_parameter[1])));
  1101. logio_done:
  1102. lio->done(sp);
  1103. }
  1104. static void
  1105. qla24xx_tm_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
  1106. struct tsk_mgmt_entry *tsk)
  1107. {
  1108. const char func[] = "TMF-IOCB";
  1109. const char *type;
  1110. fc_port_t *fcport;
  1111. srb_t *sp;
  1112. struct srb_iocb *iocb;
  1113. struct srb_ctx *ctx;
  1114. struct sts_entry_24xx *sts = (struct sts_entry_24xx *)tsk;
  1115. int error = 1;
  1116. sp = qla2x00_get_sp_from_handle(vha, func, req, tsk);
  1117. if (!sp)
  1118. return;
  1119. ctx = sp->ctx;
  1120. iocb = ctx->u.iocb_cmd;
  1121. type = ctx->name;
  1122. fcport = sp->fcport;
  1123. if (sts->entry_status) {
  1124. DEBUG2(printk(KERN_WARNING
  1125. "scsi(%ld:%x): Async-%s error - entry-status(%x).\n",
  1126. fcport->vha->host_no, sp->handle, type,
  1127. sts->entry_status));
  1128. } else if (sts->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
  1129. DEBUG2(printk(KERN_WARNING
  1130. "scsi(%ld:%x): Async-%s error - completion status(%x).\n",
  1131. fcport->vha->host_no, sp->handle, type,
  1132. sts->comp_status));
  1133. } else if (!(le16_to_cpu(sts->scsi_status) &
  1134. SS_RESPONSE_INFO_LEN_VALID)) {
  1135. DEBUG2(printk(KERN_WARNING
  1136. "scsi(%ld:%x): Async-%s error - no response info(%x).\n",
  1137. fcport->vha->host_no, sp->handle, type,
  1138. sts->scsi_status));
  1139. } else if (le32_to_cpu(sts->rsp_data_len) < 4) {
  1140. DEBUG2(printk(KERN_WARNING
  1141. "scsi(%ld:%x): Async-%s error - not enough response(%d).\n",
  1142. fcport->vha->host_no, sp->handle, type,
  1143. sts->rsp_data_len));
  1144. } else if (sts->data[3]) {
  1145. DEBUG2(printk(KERN_WARNING
  1146. "scsi(%ld:%x): Async-%s error - response(%x).\n",
  1147. fcport->vha->host_no, sp->handle, type,
  1148. sts->data[3]));
  1149. } else {
  1150. error = 0;
  1151. }
  1152. if (error) {
  1153. iocb->u.tmf.data = error;
  1154. DEBUG2(qla2x00_dump_buffer((uint8_t *)sts, sizeof(*sts)));
  1155. }
  1156. iocb->done(sp);
  1157. }
  1158. /**
  1159. * qla2x00_process_response_queue() - Process response queue entries.
  1160. * @ha: SCSI driver HA context
  1161. */
  1162. void
  1163. qla2x00_process_response_queue(struct rsp_que *rsp)
  1164. {
  1165. struct scsi_qla_host *vha;
  1166. struct qla_hw_data *ha = rsp->hw;
  1167. struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
  1168. sts_entry_t *pkt;
  1169. uint16_t handle_cnt;
  1170. uint16_t cnt;
  1171. vha = pci_get_drvdata(ha->pdev);
  1172. if (!vha->flags.online)
  1173. return;
  1174. while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
  1175. pkt = (sts_entry_t *)rsp->ring_ptr;
  1176. rsp->ring_index++;
  1177. if (rsp->ring_index == rsp->length) {
  1178. rsp->ring_index = 0;
  1179. rsp->ring_ptr = rsp->ring;
  1180. } else {
  1181. rsp->ring_ptr++;
  1182. }
  1183. if (pkt->entry_status != 0) {
  1184. DEBUG3(printk(KERN_INFO
  1185. "scsi(%ld): Process error entry.\n", vha->host_no));
  1186. qla2x00_error_entry(vha, rsp, pkt);
  1187. ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
  1188. wmb();
  1189. continue;
  1190. }
  1191. switch (pkt->entry_type) {
  1192. case STATUS_TYPE:
  1193. qla2x00_status_entry(vha, rsp, pkt);
  1194. break;
  1195. case STATUS_TYPE_21:
  1196. handle_cnt = ((sts21_entry_t *)pkt)->handle_count;
  1197. for (cnt = 0; cnt < handle_cnt; cnt++) {
  1198. qla2x00_process_completed_request(vha, rsp->req,
  1199. ((sts21_entry_t *)pkt)->handle[cnt]);
  1200. }
  1201. break;
  1202. case STATUS_TYPE_22:
  1203. handle_cnt = ((sts22_entry_t *)pkt)->handle_count;
  1204. for (cnt = 0; cnt < handle_cnt; cnt++) {
  1205. qla2x00_process_completed_request(vha, rsp->req,
  1206. ((sts22_entry_t *)pkt)->handle[cnt]);
  1207. }
  1208. break;
  1209. case STATUS_CONT_TYPE:
  1210. qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
  1211. break;
  1212. case MBX_IOCB_TYPE:
  1213. qla2x00_mbx_iocb_entry(vha, rsp->req,
  1214. (struct mbx_entry *)pkt);
  1215. break;
  1216. case CT_IOCB_TYPE:
  1217. qla2x00_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
  1218. break;
  1219. default:
  1220. /* Type Not Supported. */
  1221. DEBUG4(printk(KERN_WARNING
  1222. "scsi(%ld): Received unknown response pkt type %x "
  1223. "entry status=%x.\n",
  1224. vha->host_no, pkt->entry_type, pkt->entry_status));
  1225. break;
  1226. }
  1227. ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
  1228. wmb();
  1229. }
  1230. /* Adjust ring index */
  1231. WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), rsp->ring_index);
  1232. }
  1233. static inline void
  1234. qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t par_sense_len,
  1235. uint32_t sense_len, struct rsp_que *rsp)
  1236. {
  1237. struct scsi_cmnd *cp = sp->cmd;
  1238. if (sense_len >= SCSI_SENSE_BUFFERSIZE)
  1239. sense_len = SCSI_SENSE_BUFFERSIZE;
  1240. sp->request_sense_length = sense_len;
  1241. sp->request_sense_ptr = cp->sense_buffer;
  1242. if (sp->request_sense_length > par_sense_len)
  1243. sense_len = par_sense_len;
  1244. memcpy(cp->sense_buffer, sense_data, sense_len);
  1245. sp->request_sense_ptr += sense_len;
  1246. sp->request_sense_length -= sense_len;
  1247. if (sp->request_sense_length != 0)
  1248. rsp->status_srb = sp;
  1249. DEBUG5(printk("%s(): Check condition Sense data, scsi(%ld:%d:%d:%d) "
  1250. "cmd=%p pid=%ld\n", __func__, sp->fcport->vha->host_no,
  1251. cp->device->channel, cp->device->id, cp->device->lun, cp,
  1252. cp->serial_number));
  1253. if (sense_len)
  1254. DEBUG5(qla2x00_dump_buffer(cp->sense_buffer, sense_len));
  1255. }
  1256. struct scsi_dif_tuple {
  1257. __be16 guard; /* Checksum */
  1258. __be16 app_tag; /* APPL identifer */
  1259. __be32 ref_tag; /* Target LBA or indirect LBA */
  1260. };
  1261. /*
  1262. * Checks the guard or meta-data for the type of error
  1263. * detected by the HBA. In case of errors, we set the
  1264. * ASC/ASCQ fields in the sense buffer with ILLEGAL_REQUEST
  1265. * to indicate to the kernel that the HBA detected error.
  1266. */
  1267. static inline void
  1268. qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
  1269. {
  1270. struct scsi_cmnd *cmd = sp->cmd;
  1271. struct scsi_dif_tuple *ep =
  1272. (struct scsi_dif_tuple *)&sts24->data[20];
  1273. struct scsi_dif_tuple *ap =
  1274. (struct scsi_dif_tuple *)&sts24->data[12];
  1275. uint32_t e_ref_tag, a_ref_tag;
  1276. uint16_t e_app_tag, a_app_tag;
  1277. uint16_t e_guard, a_guard;
  1278. e_ref_tag = be32_to_cpu(ep->ref_tag);
  1279. a_ref_tag = be32_to_cpu(ap->ref_tag);
  1280. e_app_tag = be16_to_cpu(ep->app_tag);
  1281. a_app_tag = be16_to_cpu(ap->app_tag);
  1282. e_guard = be16_to_cpu(ep->guard);
  1283. a_guard = be16_to_cpu(ap->guard);
  1284. DEBUG18(printk(KERN_DEBUG
  1285. "%s(): iocb(s) %p Returned STATUS\n", __func__, sts24));
  1286. DEBUG18(printk(KERN_ERR "DIF ERROR in cmd 0x%x lba 0x%llx act ref"
  1287. " tag=0x%x, exp ref_tag=0x%x, act app tag=0x%x, exp app"
  1288. " tag=0x%x, act guard=0x%x, exp guard=0x%x\n",
  1289. cmd->cmnd[0], (u64)scsi_get_lba(cmd), a_ref_tag, e_ref_tag,
  1290. a_app_tag, e_app_tag, a_guard, e_guard));
  1291. /* check guard */
  1292. if (e_guard != a_guard) {
  1293. scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
  1294. 0x10, 0x1);
  1295. set_driver_byte(cmd, DRIVER_SENSE);
  1296. set_host_byte(cmd, DID_ABORT);
  1297. cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
  1298. return;
  1299. }
  1300. /* check appl tag */
  1301. if (e_app_tag != a_app_tag) {
  1302. scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
  1303. 0x10, 0x2);
  1304. set_driver_byte(cmd, DRIVER_SENSE);
  1305. set_host_byte(cmd, DID_ABORT);
  1306. cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
  1307. return;
  1308. }
  1309. /* check ref tag */
  1310. if (e_ref_tag != a_ref_tag) {
  1311. scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
  1312. 0x10, 0x3);
  1313. set_driver_byte(cmd, DRIVER_SENSE);
  1314. set_host_byte(cmd, DID_ABORT);
  1315. cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
  1316. return;
  1317. }
  1318. }
  1319. /**
  1320. * qla2x00_status_entry() - Process a Status IOCB entry.
  1321. * @ha: SCSI driver HA context
  1322. * @pkt: Entry pointer
  1323. */
  1324. static void
  1325. qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
  1326. {
  1327. srb_t *sp;
  1328. fc_port_t *fcport;
  1329. struct scsi_cmnd *cp;
  1330. sts_entry_t *sts;
  1331. struct sts_entry_24xx *sts24;
  1332. uint16_t comp_status;
  1333. uint16_t scsi_status;
  1334. uint16_t ox_id;
  1335. uint8_t lscsi_status;
  1336. int32_t resid;
  1337. uint32_t sense_len, par_sense_len, rsp_info_len, resid_len,
  1338. fw_resid_len;
  1339. uint8_t *rsp_info, *sense_data;
  1340. struct qla_hw_data *ha = vha->hw;
  1341. uint32_t handle;
  1342. uint16_t que;
  1343. struct req_que *req;
  1344. int logit = 1;
  1345. sts = (sts_entry_t *) pkt;
  1346. sts24 = (struct sts_entry_24xx *) pkt;
  1347. if (IS_FWI2_CAPABLE(ha)) {
  1348. comp_status = le16_to_cpu(sts24->comp_status);
  1349. scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
  1350. } else {
  1351. comp_status = le16_to_cpu(sts->comp_status);
  1352. scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
  1353. }
  1354. handle = (uint32_t) LSW(sts->handle);
  1355. que = MSW(sts->handle);
  1356. req = ha->req_q_map[que];
  1357. /* Fast path completion. */
  1358. if (comp_status == CS_COMPLETE && scsi_status == 0) {
  1359. qla2x00_process_completed_request(vha, req, handle);
  1360. return;
  1361. }
  1362. /* Validate handle. */
  1363. if (handle < MAX_OUTSTANDING_COMMANDS) {
  1364. sp = req->outstanding_cmds[handle];
  1365. req->outstanding_cmds[handle] = NULL;
  1366. } else
  1367. sp = NULL;
  1368. if (sp == NULL) {
  1369. qla_printk(KERN_WARNING, ha,
  1370. "scsi(%ld): Invalid status handle (0x%x).\n", vha->host_no,
  1371. sts->handle);
  1372. set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
  1373. qla2xxx_wake_dpc(vha);
  1374. return;
  1375. }
  1376. cp = sp->cmd;
  1377. if (cp == NULL) {
  1378. qla_printk(KERN_WARNING, ha,
  1379. "scsi(%ld): Command already returned (0x%x/%p).\n",
  1380. vha->host_no, sts->handle, sp);
  1381. return;
  1382. }
  1383. lscsi_status = scsi_status & STATUS_MASK;
  1384. fcport = sp->fcport;
  1385. ox_id = 0;
  1386. sense_len = par_sense_len = rsp_info_len = resid_len =
  1387. fw_resid_len = 0;
  1388. if (IS_FWI2_CAPABLE(ha)) {
  1389. if (scsi_status & SS_SENSE_LEN_VALID)
  1390. sense_len = le32_to_cpu(sts24->sense_len);
  1391. if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
  1392. rsp_info_len = le32_to_cpu(sts24->rsp_data_len);
  1393. if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER))
  1394. resid_len = le32_to_cpu(sts24->rsp_residual_count);
  1395. if (comp_status == CS_DATA_UNDERRUN)
  1396. fw_resid_len = le32_to_cpu(sts24->residual_len);
  1397. rsp_info = sts24->data;
  1398. sense_data = sts24->data;
  1399. host_to_fcp_swap(sts24->data, sizeof(sts24->data));
  1400. ox_id = le16_to_cpu(sts24->ox_id);
  1401. par_sense_len = sizeof(sts24->data);
  1402. } else {
  1403. if (scsi_status & SS_SENSE_LEN_VALID)
  1404. sense_len = le16_to_cpu(sts->req_sense_length);
  1405. if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
  1406. rsp_info_len = le16_to_cpu(sts->rsp_info_len);
  1407. resid_len = le32_to_cpu(sts->residual_length);
  1408. rsp_info = sts->rsp_info;
  1409. sense_data = sts->req_sense_data;
  1410. par_sense_len = sizeof(sts->req_sense_data);
  1411. }
  1412. /* Check for any FCP transport errors. */
  1413. if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
  1414. /* Sense data lies beyond any FCP RESPONSE data. */
  1415. if (IS_FWI2_CAPABLE(ha)) {
  1416. sense_data += rsp_info_len;
  1417. par_sense_len -= rsp_info_len;
  1418. }
  1419. if (rsp_info_len > 3 && rsp_info[3]) {
  1420. DEBUG2(qla_printk(KERN_INFO, ha,
  1421. "scsi(%ld:%d:%d): FCP I/O protocol failure "
  1422. "(0x%x/0x%x).\n", vha->host_no, cp->device->id,
  1423. cp->device->lun, rsp_info_len, rsp_info[3]));
  1424. cp->result = DID_BUS_BUSY << 16;
  1425. goto out;
  1426. }
  1427. }
  1428. /* Check for overrun. */
  1429. if (IS_FWI2_CAPABLE(ha) && comp_status == CS_COMPLETE &&
  1430. scsi_status & SS_RESIDUAL_OVER)
  1431. comp_status = CS_DATA_OVERRUN;
  1432. /*
  1433. * Based on Host and scsi status generate status code for Linux
  1434. */
  1435. switch (comp_status) {
  1436. case CS_COMPLETE:
  1437. case CS_QUEUE_FULL:
  1438. if (scsi_status == 0) {
  1439. cp->result = DID_OK << 16;
  1440. break;
  1441. }
  1442. if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
  1443. resid = resid_len;
  1444. scsi_set_resid(cp, resid);
  1445. if (!lscsi_status &&
  1446. ((unsigned)(scsi_bufflen(cp) - resid) <
  1447. cp->underflow)) {
  1448. qla_printk(KERN_INFO, ha,
  1449. "scsi(%ld:%d:%d): Mid-layer underflow "
  1450. "detected (0x%x of 0x%x bytes).\n",
  1451. vha->host_no, cp->device->id,
  1452. cp->device->lun, resid, scsi_bufflen(cp));
  1453. cp->result = DID_ERROR << 16;
  1454. break;
  1455. }
  1456. }
  1457. cp->result = DID_OK << 16 | lscsi_status;
  1458. if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
  1459. DEBUG2(qla_printk(KERN_INFO, ha,
  1460. "scsi(%ld:%d:%d) QUEUE FULL detected.\n",
  1461. vha->host_no, cp->device->id, cp->device->lun));
  1462. break;
  1463. }
  1464. logit = 0;
  1465. if (lscsi_status != SS_CHECK_CONDITION)
  1466. break;
  1467. memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
  1468. if (!(scsi_status & SS_SENSE_LEN_VALID))
  1469. break;
  1470. qla2x00_handle_sense(sp, sense_data, par_sense_len, sense_len,
  1471. rsp);
  1472. break;
  1473. case CS_DATA_UNDERRUN:
  1474. /* Use F/W calculated residual length. */
  1475. resid = IS_FWI2_CAPABLE(ha) ? fw_resid_len : resid_len;
  1476. scsi_set_resid(cp, resid);
  1477. if (scsi_status & SS_RESIDUAL_UNDER) {
  1478. if (IS_FWI2_CAPABLE(ha) && fw_resid_len != resid_len) {
  1479. DEBUG2(qla_printk(KERN_INFO, ha,
  1480. "scsi(%ld:%d:%d) Dropped frame(s) detected "
  1481. "(0x%x of 0x%x bytes).\n", vha->host_no,
  1482. cp->device->id, cp->device->lun, resid,
  1483. scsi_bufflen(cp)));
  1484. cp->result = DID_ERROR << 16 | lscsi_status;
  1485. break;
  1486. }
  1487. if (!lscsi_status &&
  1488. ((unsigned)(scsi_bufflen(cp) - resid) <
  1489. cp->underflow)) {
  1490. qla_printk(KERN_INFO, ha,
  1491. "scsi(%ld:%d:%d): Mid-layer underflow "
  1492. "detected (0x%x of 0x%x bytes).\n",
  1493. vha->host_no, cp->device->id,
  1494. cp->device->lun, resid, scsi_bufflen(cp));
  1495. cp->result = DID_ERROR << 16;
  1496. break;
  1497. }
  1498. } else if (!lscsi_status) {
  1499. DEBUG2(qla_printk(KERN_INFO, ha,
  1500. "scsi(%ld:%d:%d) Dropped frame(s) detected (0x%x "
  1501. "of 0x%x bytes).\n", vha->host_no, cp->device->id,
  1502. cp->device->lun, resid, scsi_bufflen(cp)));
  1503. cp->result = DID_ERROR << 16;
  1504. break;
  1505. }
  1506. cp->result = DID_OK << 16 | lscsi_status;
  1507. logit = 0;
  1508. /*
  1509. * Check to see if SCSI Status is non zero. If so report SCSI
  1510. * Status.
  1511. */
  1512. if (lscsi_status != 0) {
  1513. if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
  1514. DEBUG2(qla_printk(KERN_INFO, ha,
  1515. "scsi(%ld:%d:%d) QUEUE FULL detected.\n",
  1516. vha->host_no, cp->device->id,
  1517. cp->device->lun));
  1518. logit = 1;
  1519. break;
  1520. }
  1521. if (lscsi_status != SS_CHECK_CONDITION)
  1522. break;
  1523. memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
  1524. if (!(scsi_status & SS_SENSE_LEN_VALID))
  1525. break;
  1526. qla2x00_handle_sense(sp, sense_data, par_sense_len,
  1527. sense_len, rsp);
  1528. }
  1529. break;
  1530. case CS_PORT_LOGGED_OUT:
  1531. case CS_PORT_CONFIG_CHG:
  1532. case CS_PORT_BUSY:
  1533. case CS_INCOMPLETE:
  1534. case CS_PORT_UNAVAILABLE:
  1535. case CS_TIMEOUT:
  1536. /*
  1537. * We are going to have the fc class block the rport
  1538. * while we try to recover so instruct the mid layer
  1539. * to requeue until the class decides how to handle this.
  1540. */
  1541. cp->result = DID_TRANSPORT_DISRUPTED << 16;
  1542. if (comp_status == CS_TIMEOUT) {
  1543. if (IS_FWI2_CAPABLE(ha))
  1544. break;
  1545. else if ((le16_to_cpu(sts->status_flags) &
  1546. SF_LOGOUT_SENT) == 0)
  1547. break;
  1548. }
  1549. DEBUG2(qla_printk(KERN_INFO, ha,
  1550. "scsi(%ld:%d:%d) Port down status: port-state=0x%x\n",
  1551. vha->host_no, cp->device->id, cp->device->lun,
  1552. atomic_read(&fcport->state)));
  1553. if (atomic_read(&fcport->state) == FCS_ONLINE)
  1554. qla2x00_mark_device_lost(fcport->vha, fcport, 1, 1);
  1555. break;
  1556. case CS_RESET:
  1557. cp->result = DID_TRANSPORT_DISRUPTED << 16;
  1558. break;
  1559. case CS_ABORTED:
  1560. cp->result = DID_RESET << 16;
  1561. break;
  1562. case CS_DIF_ERROR:
  1563. qla2x00_handle_dif_error(sp, sts24);
  1564. break;
  1565. default:
  1566. cp->result = DID_ERROR << 16;
  1567. break;
  1568. }
  1569. out:
  1570. if (logit)
  1571. DEBUG2(qla_printk(KERN_INFO, ha,
  1572. "scsi(%ld:%d:%d) FCP command status: 0x%x-0x%x (0x%x) "
  1573. "oxid=0x%x ser=0x%lx cdb=%02x%02x%02x len=0x%x "
  1574. "rsp_info=0x%x resid=0x%x fw_resid=0x%x\n", vha->host_no,
  1575. cp->device->id, cp->device->lun, comp_status, scsi_status,
  1576. cp->result, ox_id, cp->serial_number, cp->cmnd[0],
  1577. cp->cmnd[1], cp->cmnd[2], scsi_bufflen(cp), rsp_info_len,
  1578. resid_len, fw_resid_len));
  1579. if (rsp->status_srb == NULL)
  1580. qla2x00_sp_compl(ha, sp);
  1581. }
  1582. /**
  1583. * qla2x00_status_cont_entry() - Process a Status Continuations entry.
  1584. * @ha: SCSI driver HA context
  1585. * @pkt: Entry pointer
  1586. *
  1587. * Extended sense data.
  1588. */
  1589. static void
  1590. qla2x00_status_cont_entry(struct rsp_que *rsp, sts_cont_entry_t *pkt)
  1591. {
  1592. uint8_t sense_sz = 0;
  1593. struct qla_hw_data *ha = rsp->hw;
  1594. srb_t *sp = rsp->status_srb;
  1595. struct scsi_cmnd *cp;
  1596. if (sp != NULL && sp->request_sense_length != 0) {
  1597. cp = sp->cmd;
  1598. if (cp == NULL) {
  1599. DEBUG2(printk("%s(): Cmd already returned back to OS "
  1600. "sp=%p.\n", __func__, sp));
  1601. qla_printk(KERN_INFO, ha,
  1602. "cmd is NULL: already returned to OS (sp=%p)\n",
  1603. sp);
  1604. rsp->status_srb = NULL;
  1605. return;
  1606. }
  1607. if (sp->request_sense_length > sizeof(pkt->data)) {
  1608. sense_sz = sizeof(pkt->data);
  1609. } else {
  1610. sense_sz = sp->request_sense_length;
  1611. }
  1612. /* Move sense data. */
  1613. if (IS_FWI2_CAPABLE(ha))
  1614. host_to_fcp_swap(pkt->data, sizeof(pkt->data));
  1615. memcpy(sp->request_sense_ptr, pkt->data, sense_sz);
  1616. DEBUG5(qla2x00_dump_buffer(sp->request_sense_ptr, sense_sz));
  1617. sp->request_sense_ptr += sense_sz;
  1618. sp->request_sense_length -= sense_sz;
  1619. /* Place command on done queue. */
  1620. if (sp->request_sense_length == 0) {
  1621. rsp->status_srb = NULL;
  1622. qla2x00_sp_compl(ha, sp);
  1623. }
  1624. }
  1625. }
  1626. /**
  1627. * qla2x00_error_entry() - Process an error entry.
  1628. * @ha: SCSI driver HA context
  1629. * @pkt: Entry pointer
  1630. */
  1631. static void
  1632. qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
  1633. {
  1634. srb_t *sp;
  1635. struct qla_hw_data *ha = vha->hw;
  1636. uint32_t handle = LSW(pkt->handle);
  1637. uint16_t que = MSW(pkt->handle);
  1638. struct req_que *req = ha->req_q_map[que];
  1639. #if defined(QL_DEBUG_LEVEL_2)
  1640. if (pkt->entry_status & RF_INV_E_ORDER)
  1641. qla_printk(KERN_ERR, ha, "%s: Invalid Entry Order\n", __func__);
  1642. else if (pkt->entry_status & RF_INV_E_COUNT)
  1643. qla_printk(KERN_ERR, ha, "%s: Invalid Entry Count\n", __func__);
  1644. else if (pkt->entry_status & RF_INV_E_PARAM)
  1645. qla_printk(KERN_ERR, ha,
  1646. "%s: Invalid Entry Parameter\n", __func__);
  1647. else if (pkt->entry_status & RF_INV_E_TYPE)
  1648. qla_printk(KERN_ERR, ha, "%s: Invalid Entry Type\n", __func__);
  1649. else if (pkt->entry_status & RF_BUSY)
  1650. qla_printk(KERN_ERR, ha, "%s: Busy\n", __func__);
  1651. else
  1652. qla_printk(KERN_ERR, ha, "%s: UNKNOWN flag error\n", __func__);
  1653. #endif
  1654. /* Validate handle. */
  1655. if (handle < MAX_OUTSTANDING_COMMANDS)
  1656. sp = req->outstanding_cmds[handle];
  1657. else
  1658. sp = NULL;
  1659. if (sp) {
  1660. /* Free outstanding command slot. */
  1661. req->outstanding_cmds[handle] = NULL;
  1662. /* Bad payload or header */
  1663. if (pkt->entry_status &
  1664. (RF_INV_E_ORDER | RF_INV_E_COUNT |
  1665. RF_INV_E_PARAM | RF_INV_E_TYPE)) {
  1666. sp->cmd->result = DID_ERROR << 16;
  1667. } else if (pkt->entry_status & RF_BUSY) {
  1668. sp->cmd->result = DID_BUS_BUSY << 16;
  1669. } else {
  1670. sp->cmd->result = DID_ERROR << 16;
  1671. }
  1672. qla2x00_sp_compl(ha, sp);
  1673. } else if (pkt->entry_type == COMMAND_A64_TYPE || pkt->entry_type ==
  1674. COMMAND_TYPE || pkt->entry_type == COMMAND_TYPE_7) {
  1675. DEBUG2(printk("scsi(%ld): Error entry - invalid handle\n",
  1676. vha->host_no));
  1677. qla_printk(KERN_WARNING, ha,
  1678. "Error entry - invalid handle\n");
  1679. set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
  1680. qla2xxx_wake_dpc(vha);
  1681. }
  1682. }
  1683. /**
  1684. * qla24xx_mbx_completion() - Process mailbox command completions.
  1685. * @ha: SCSI driver HA context
  1686. * @mb0: Mailbox0 register
  1687. */
  1688. static void
  1689. qla24xx_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
  1690. {
  1691. uint16_t cnt;
  1692. uint16_t __iomem *wptr;
  1693. struct qla_hw_data *ha = vha->hw;
  1694. struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
  1695. /* Load return mailbox registers. */
  1696. ha->flags.mbox_int = 1;
  1697. ha->mailbox_out[0] = mb0;
  1698. wptr = (uint16_t __iomem *)&reg->mailbox1;
  1699. for (cnt = 1; cnt < ha->mbx_count; cnt++) {
  1700. ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
  1701. wptr++;
  1702. }
  1703. if (ha->mcp) {
  1704. DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
  1705. __func__, vha->host_no, ha->mcp->mb[0]));
  1706. } else {
  1707. DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
  1708. __func__, vha->host_no));
  1709. }
  1710. }
  1711. /**
  1712. * qla24xx_process_response_queue() - Process response queue entries.
  1713. * @ha: SCSI driver HA context
  1714. */
  1715. void qla24xx_process_response_queue(struct scsi_qla_host *vha,
  1716. struct rsp_que *rsp)
  1717. {
  1718. struct sts_entry_24xx *pkt;
  1719. struct qla_hw_data *ha = vha->hw;
  1720. if (!vha->flags.online)
  1721. return;
  1722. while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
  1723. pkt = (struct sts_entry_24xx *)rsp->ring_ptr;
  1724. rsp->ring_index++;
  1725. if (rsp->ring_index == rsp->length) {
  1726. rsp->ring_index = 0;
  1727. rsp->ring_ptr = rsp->ring;
  1728. } else {
  1729. rsp->ring_ptr++;
  1730. }
  1731. if (pkt->entry_status != 0) {
  1732. DEBUG3(printk(KERN_INFO
  1733. "scsi(%ld): Process error entry.\n", vha->host_no));
  1734. qla2x00_error_entry(vha, rsp, (sts_entry_t *) pkt);
  1735. ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
  1736. wmb();
  1737. continue;
  1738. }
  1739. switch (pkt->entry_type) {
  1740. case STATUS_TYPE:
  1741. qla2x00_status_entry(vha, rsp, pkt);
  1742. break;
  1743. case STATUS_CONT_TYPE:
  1744. qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
  1745. break;
  1746. case VP_RPT_ID_IOCB_TYPE:
  1747. qla24xx_report_id_acquisition(vha,
  1748. (struct vp_rpt_id_entry_24xx *)pkt);
  1749. break;
  1750. case LOGINOUT_PORT_IOCB_TYPE:
  1751. qla24xx_logio_entry(vha, rsp->req,
  1752. (struct logio_entry_24xx *)pkt);
  1753. break;
  1754. case TSK_MGMT_IOCB_TYPE:
  1755. qla24xx_tm_iocb_entry(vha, rsp->req,
  1756. (struct tsk_mgmt_entry *)pkt);
  1757. break;
  1758. case CT_IOCB_TYPE:
  1759. qla24xx_els_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
  1760. clear_bit(MBX_INTERRUPT, &vha->hw->mbx_cmd_flags);
  1761. break;
  1762. case ELS_IOCB_TYPE:
  1763. qla24xx_els_ct_entry(vha, rsp->req, pkt, ELS_IOCB_TYPE);
  1764. break;
  1765. default:
  1766. /* Type Not Supported. */
  1767. DEBUG4(printk(KERN_WARNING
  1768. "scsi(%ld): Received unknown response pkt type %x "
  1769. "entry status=%x.\n",
  1770. vha->host_no, pkt->entry_type, pkt->entry_status));
  1771. break;
  1772. }
  1773. ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
  1774. wmb();
  1775. }
  1776. /* Adjust ring index */
  1777. if (IS_QLA82XX(ha)) {
  1778. struct device_reg_82xx __iomem *reg = &ha->iobase->isp82;
  1779. WRT_REG_DWORD(&reg->rsp_q_out[0], rsp->ring_index);
  1780. } else
  1781. WRT_REG_DWORD(rsp->rsp_q_out, rsp->ring_index);
  1782. }
  1783. static void
  1784. qla2xxx_check_risc_status(scsi_qla_host_t *vha)
  1785. {
  1786. int rval;
  1787. uint32_t cnt;
  1788. struct qla_hw_data *ha = vha->hw;
  1789. struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
  1790. if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha))
  1791. return;
  1792. rval = QLA_SUCCESS;
  1793. WRT_REG_DWORD(&reg->iobase_addr, 0x7C00);
  1794. RD_REG_DWORD(&reg->iobase_addr);
  1795. WRT_REG_DWORD(&reg->iobase_window, 0x0001);
  1796. for (cnt = 10000; (RD_REG_DWORD(&reg->iobase_window) & BIT_0) == 0 &&
  1797. rval == QLA_SUCCESS; cnt--) {
  1798. if (cnt) {
  1799. WRT_REG_DWORD(&reg->iobase_window, 0x0001);
  1800. udelay(10);
  1801. } else
  1802. rval = QLA_FUNCTION_TIMEOUT;
  1803. }
  1804. if (rval == QLA_SUCCESS)
  1805. goto next_test;
  1806. WRT_REG_DWORD(&reg->iobase_window, 0x0003);
  1807. for (cnt = 100; (RD_REG_DWORD(&reg->iobase_window) & BIT_0) == 0 &&
  1808. rval == QLA_SUCCESS; cnt--) {
  1809. if (cnt) {
  1810. WRT_REG_DWORD(&reg->iobase_window, 0x0003);
  1811. udelay(10);
  1812. } else
  1813. rval = QLA_FUNCTION_TIMEOUT;
  1814. }
  1815. if (rval != QLA_SUCCESS)
  1816. goto done;
  1817. next_test:
  1818. if (RD_REG_DWORD(&reg->iobase_c8) & BIT_3)
  1819. qla_printk(KERN_INFO, ha, "Additional code -- 0x55AA.\n");
  1820. done:
  1821. WRT_REG_DWORD(&reg->iobase_window, 0x0000);
  1822. RD_REG_DWORD(&reg->iobase_window);
  1823. }
  1824. /**
  1825. * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
  1826. * @irq:
  1827. * @dev_id: SCSI driver HA context
  1828. *
  1829. * Called by system whenever the host adapter generates an interrupt.
  1830. *
  1831. * Returns handled flag.
  1832. */
  1833. irqreturn_t
  1834. qla24xx_intr_handler(int irq, void *dev_id)
  1835. {
  1836. scsi_qla_host_t *vha;
  1837. struct qla_hw_data *ha;
  1838. struct device_reg_24xx __iomem *reg;
  1839. int status;
  1840. unsigned long iter;
  1841. uint32_t stat;
  1842. uint32_t hccr;
  1843. uint16_t mb[4];
  1844. struct rsp_que *rsp;
  1845. unsigned long flags;
  1846. rsp = (struct rsp_que *) dev_id;
  1847. if (!rsp) {
  1848. printk(KERN_INFO
  1849. "%s(): NULL response queue pointer\n", __func__);
  1850. return IRQ_NONE;
  1851. }
  1852. ha = rsp->hw;
  1853. reg = &ha->iobase->isp24;
  1854. status = 0;
  1855. if (unlikely(pci_channel_offline(ha->pdev)))
  1856. return IRQ_HANDLED;
  1857. spin_lock_irqsave(&ha->hardware_lock, flags);
  1858. vha = pci_get_drvdata(ha->pdev);
  1859. for (iter = 50; iter--; ) {
  1860. stat = RD_REG_DWORD(&reg->host_status);
  1861. if (stat & HSRX_RISC_PAUSED) {
  1862. if (unlikely(pci_channel_offline(ha->pdev)))
  1863. break;
  1864. hccr = RD_REG_DWORD(&reg->hccr);
  1865. qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, "
  1866. "Dumping firmware!\n", hccr);
  1867. qla2xxx_check_risc_status(vha);
  1868. ha->isp_ops->fw_dump(vha, 1);
  1869. set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
  1870. break;
  1871. } else if ((stat & HSRX_RISC_INT) == 0)
  1872. break;
  1873. switch (stat & 0xff) {
  1874. case 0x1:
  1875. case 0x2:
  1876. case 0x10:
  1877. case 0x11:
  1878. qla24xx_mbx_completion(vha, MSW(stat));
  1879. status |= MBX_INTERRUPT;
  1880. break;
  1881. case 0x12:
  1882. mb[0] = MSW(stat);
  1883. mb[1] = RD_REG_WORD(&reg->mailbox1);
  1884. mb[2] = RD_REG_WORD(&reg->mailbox2);
  1885. mb[3] = RD_REG_WORD(&reg->mailbox3);
  1886. qla2x00_async_event(vha, rsp, mb);
  1887. break;
  1888. case 0x13:
  1889. case 0x14:
  1890. qla24xx_process_response_queue(vha, rsp);
  1891. break;
  1892. default:
  1893. DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
  1894. "(%d).\n",
  1895. vha->host_no, stat & 0xff));
  1896. break;
  1897. }
  1898. WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
  1899. RD_REG_DWORD_RELAXED(&reg->hccr);
  1900. }
  1901. spin_unlock_irqrestore(&ha->hardware_lock, flags);
  1902. if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
  1903. (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
  1904. set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
  1905. complete(&ha->mbx_intr_comp);
  1906. }
  1907. return IRQ_HANDLED;
  1908. }
  1909. static irqreturn_t
  1910. qla24xx_msix_rsp_q(int irq, void *dev_id)
  1911. {
  1912. struct qla_hw_data *ha;
  1913. struct rsp_que *rsp;
  1914. struct device_reg_24xx __iomem *reg;
  1915. struct scsi_qla_host *vha;
  1916. unsigned long flags;
  1917. rsp = (struct rsp_que *) dev_id;
  1918. if (!rsp) {
  1919. printk(KERN_INFO
  1920. "%s(): NULL response queue pointer\n", __func__);
  1921. return IRQ_NONE;
  1922. }
  1923. ha = rsp->hw;
  1924. reg = &ha->iobase->isp24;
  1925. spin_lock_irqsave(&ha->hardware_lock, flags);
  1926. vha = pci_get_drvdata(ha->pdev);
  1927. qla24xx_process_response_queue(vha, rsp);
  1928. if (!ha->flags.disable_msix_handshake) {
  1929. WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
  1930. RD_REG_DWORD_RELAXED(&reg->hccr);
  1931. }
  1932. spin_unlock_irqrestore(&ha->hardware_lock, flags);
  1933. return IRQ_HANDLED;
  1934. }
  1935. static irqreturn_t
  1936. qla25xx_msix_rsp_q(int irq, void *dev_id)
  1937. {
  1938. struct qla_hw_data *ha;
  1939. struct rsp_que *rsp;
  1940. struct device_reg_24xx __iomem *reg;
  1941. unsigned long flags;
  1942. rsp = (struct rsp_que *) dev_id;
  1943. if (!rsp) {
  1944. printk(KERN_INFO
  1945. "%s(): NULL response queue pointer\n", __func__);
  1946. return IRQ_NONE;
  1947. }
  1948. ha = rsp->hw;
  1949. /* Clear the interrupt, if enabled, for this response queue */
  1950. if (rsp->options & ~BIT_6) {
  1951. reg = &ha->iobase->isp24;
  1952. spin_lock_irqsave(&ha->hardware_lock, flags);
  1953. WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
  1954. RD_REG_DWORD_RELAXED(&reg->hccr);
  1955. spin_unlock_irqrestore(&ha->hardware_lock, flags);
  1956. }
  1957. queue_work_on((int) (rsp->id - 1), ha->wq, &rsp->q_work);
  1958. return IRQ_HANDLED;
  1959. }
  1960. static irqreturn_t
  1961. qla24xx_msix_default(int irq, void *dev_id)
  1962. {
  1963. scsi_qla_host_t *vha;
  1964. struct qla_hw_data *ha;
  1965. struct rsp_que *rsp;
  1966. struct device_reg_24xx __iomem *reg;
  1967. int status;
  1968. uint32_t stat;
  1969. uint32_t hccr;
  1970. uint16_t mb[4];
  1971. unsigned long flags;
  1972. rsp = (struct rsp_que *) dev_id;
  1973. if (!rsp) {
  1974. DEBUG(printk(
  1975. "%s(): NULL response queue pointer\n", __func__));
  1976. return IRQ_NONE;
  1977. }
  1978. ha = rsp->hw;
  1979. reg = &ha->iobase->isp24;
  1980. status = 0;
  1981. spin_lock_irqsave(&ha->hardware_lock, flags);
  1982. vha = pci_get_drvdata(ha->pdev);
  1983. do {
  1984. stat = RD_REG_DWORD(&reg->host_status);
  1985. if (stat & HSRX_RISC_PAUSED) {
  1986. if (unlikely(pci_channel_offline(ha->pdev)))
  1987. break;
  1988. hccr = RD_REG_DWORD(&reg->hccr);
  1989. qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, "
  1990. "Dumping firmware!\n", hccr);
  1991. qla2xxx_check_risc_status(vha);
  1992. ha->isp_ops->fw_dump(vha, 1);
  1993. set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
  1994. break;
  1995. } else if ((stat & HSRX_RISC_INT) == 0)
  1996. break;
  1997. switch (stat & 0xff) {
  1998. case 0x1:
  1999. case 0x2:
  2000. case 0x10:
  2001. case 0x11:
  2002. qla24xx_mbx_completion(vha, MSW(stat));
  2003. status |= MBX_INTERRUPT;
  2004. break;
  2005. case 0x12:
  2006. mb[0] = MSW(stat);
  2007. mb[1] = RD_REG_WORD(&reg->mailbox1);
  2008. mb[2] = RD_REG_WORD(&reg->mailbox2);
  2009. mb[3] = RD_REG_WORD(&reg->mailbox3);
  2010. qla2x00_async_event(vha, rsp, mb);
  2011. break;
  2012. case 0x13:
  2013. case 0x14:
  2014. qla24xx_process_response_queue(vha, rsp);
  2015. break;
  2016. default:
  2017. DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
  2018. "(%d).\n",
  2019. vha->host_no, stat & 0xff));
  2020. break;
  2021. }
  2022. WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
  2023. } while (0);
  2024. spin_unlock_irqrestore(&ha->hardware_lock, flags);
  2025. if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
  2026. (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
  2027. set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
  2028. complete(&ha->mbx_intr_comp);
  2029. }
  2030. return IRQ_HANDLED;
  2031. }
  2032. /* Interrupt handling helpers. */
  2033. struct qla_init_msix_entry {
  2034. const char *name;
  2035. irq_handler_t handler;
  2036. };
  2037. static struct qla_init_msix_entry msix_entries[3] = {
  2038. { "qla2xxx (default)", qla24xx_msix_default },
  2039. { "qla2xxx (rsp_q)", qla24xx_msix_rsp_q },
  2040. { "qla2xxx (multiq)", qla25xx_msix_rsp_q },
  2041. };
  2042. static struct qla_init_msix_entry qla82xx_msix_entries[2] = {
  2043. { "qla2xxx (default)", qla82xx_msix_default },
  2044. { "qla2xxx (rsp_q)", qla82xx_msix_rsp_q },
  2045. };
  2046. static void
  2047. qla24xx_disable_msix(struct qla_hw_data *ha)
  2048. {
  2049. int i;
  2050. struct qla_msix_entry *qentry;
  2051. for (i = 0; i < ha->msix_count; i++) {
  2052. qentry = &ha->msix_entries[i];
  2053. if (qentry->have_irq)
  2054. free_irq(qentry->vector, qentry->rsp);
  2055. }
  2056. pci_disable_msix(ha->pdev);
  2057. kfree(ha->msix_entries);
  2058. ha->msix_entries = NULL;
  2059. ha->flags.msix_enabled = 0;
  2060. }
  2061. static int
  2062. qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
  2063. {
  2064. #define MIN_MSIX_COUNT 2
  2065. int i, ret;
  2066. struct msix_entry *entries;
  2067. struct qla_msix_entry *qentry;
  2068. entries = kzalloc(sizeof(struct msix_entry) * ha->msix_count,
  2069. GFP_KERNEL);
  2070. if (!entries)
  2071. return -ENOMEM;
  2072. for (i = 0; i < ha->msix_count; i++)
  2073. entries[i].entry = i;
  2074. ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
  2075. if (ret) {
  2076. if (ret < MIN_MSIX_COUNT)
  2077. goto msix_failed;
  2078. qla_printk(KERN_WARNING, ha,
  2079. "MSI-X: Failed to enable support -- %d/%d\n"
  2080. " Retry with %d vectors\n", ha->msix_count, ret, ret);
  2081. ha->msix_count = ret;
  2082. ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
  2083. if (ret) {
  2084. msix_failed:
  2085. qla_printk(KERN_WARNING, ha, "MSI-X: Failed to enable"
  2086. " support, giving up -- %d/%d\n",
  2087. ha->msix_count, ret);
  2088. goto msix_out;
  2089. }
  2090. ha->max_rsp_queues = ha->msix_count - 1;
  2091. }
  2092. ha->msix_entries = kzalloc(sizeof(struct qla_msix_entry) *
  2093. ha->msix_count, GFP_KERNEL);
  2094. if (!ha->msix_entries) {
  2095. ret = -ENOMEM;
  2096. goto msix_out;
  2097. }
  2098. ha->flags.msix_enabled = 1;
  2099. for (i = 0; i < ha->msix_count; i++) {
  2100. qentry = &ha->msix_entries[i];
  2101. qentry->vector = entries[i].vector;
  2102. qentry->entry = entries[i].entry;
  2103. qentry->have_irq = 0;
  2104. qentry->rsp = NULL;
  2105. }
  2106. /* Enable MSI-X vectors for the base queue */
  2107. for (i = 0; i < 2; i++) {
  2108. qentry = &ha->msix_entries[i];
  2109. if (IS_QLA82XX(ha)) {
  2110. ret = request_irq(qentry->vector,
  2111. qla82xx_msix_entries[i].handler,
  2112. 0, qla82xx_msix_entries[i].name, rsp);
  2113. } else {
  2114. ret = request_irq(qentry->vector,
  2115. msix_entries[i].handler,
  2116. 0, msix_entries[i].name, rsp);
  2117. }
  2118. if (ret) {
  2119. qla_printk(KERN_WARNING, ha,
  2120. "MSI-X: Unable to register handler -- %x/%d.\n",
  2121. qentry->vector, ret);
  2122. qla24xx_disable_msix(ha);
  2123. ha->mqenable = 0;
  2124. goto msix_out;
  2125. }
  2126. qentry->have_irq = 1;
  2127. qentry->rsp = rsp;
  2128. rsp->msix = qentry;
  2129. }
  2130. /* Enable MSI-X vector for response queue update for queue 0 */
  2131. if (ha->mqiobase && (ha->max_rsp_queues > 1 || ha->max_req_queues > 1))
  2132. ha->mqenable = 1;
  2133. msix_out:
  2134. kfree(entries);
  2135. return ret;
  2136. }
  2137. int
  2138. qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
  2139. {
  2140. int ret;
  2141. device_reg_t __iomem *reg = ha->iobase;
  2142. /* If possible, enable MSI-X. */
  2143. if (!IS_QLA2432(ha) && !IS_QLA2532(ha) &&
  2144. !IS_QLA8432(ha) && !IS_QLA8XXX_TYPE(ha))
  2145. goto skip_msi;
  2146. if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
  2147. (ha->pdev->subsystem_device == 0x7040 ||
  2148. ha->pdev->subsystem_device == 0x7041 ||
  2149. ha->pdev->subsystem_device == 0x1705)) {
  2150. DEBUG2(qla_printk(KERN_WARNING, ha,
  2151. "MSI-X: Unsupported ISP2432 SSVID/SSDID (0x%X,0x%X).\n",
  2152. ha->pdev->subsystem_vendor,
  2153. ha->pdev->subsystem_device));
  2154. goto skip_msi;
  2155. }
  2156. if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX ||
  2157. !QLA_MSIX_FW_MODE_1(ha->fw_attributes))) {
  2158. DEBUG2(qla_printk(KERN_WARNING, ha,
  2159. "MSI-X: Unsupported ISP2432 (0x%X, 0x%X).\n",
  2160. ha->pdev->revision, ha->fw_attributes));
  2161. goto skip_msix;
  2162. }
  2163. ret = qla24xx_enable_msix(ha, rsp);
  2164. if (!ret) {
  2165. DEBUG2(qla_printk(KERN_INFO, ha,
  2166. "MSI-X: Enabled (0x%X, 0x%X).\n", ha->chip_revision,
  2167. ha->fw_attributes));
  2168. goto clear_risc_ints;
  2169. }
  2170. qla_printk(KERN_WARNING, ha,
  2171. "MSI-X: Falling back-to MSI mode -- %d.\n", ret);
  2172. skip_msix:
  2173. if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
  2174. !IS_QLA8001(ha))
  2175. goto skip_msi;
  2176. ret = pci_enable_msi(ha->pdev);
  2177. if (!ret) {
  2178. DEBUG2(qla_printk(KERN_INFO, ha, "MSI: Enabled.\n"));
  2179. ha->flags.msi_enabled = 1;
  2180. } else
  2181. qla_printk(KERN_WARNING, ha,
  2182. "MSI-X: Falling back-to INTa mode -- %d.\n", ret);
  2183. skip_msi:
  2184. ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
  2185. IRQF_SHARED, QLA2XXX_DRIVER_NAME, rsp);
  2186. if (ret) {
  2187. qla_printk(KERN_WARNING, ha,
  2188. "Failed to reserve interrupt %d already in use.\n",
  2189. ha->pdev->irq);
  2190. goto fail;
  2191. }
  2192. ha->flags.inta_enabled = 1;
  2193. clear_risc_ints:
  2194. /*
  2195. * FIXME: Noted that 8014s were being dropped during NK testing.
  2196. * Timing deltas during MSI-X/INTa transitions?
  2197. */
  2198. if (IS_QLA81XX(ha) || IS_QLA82XX(ha))
  2199. goto fail;
  2200. spin_lock_irq(&ha->hardware_lock);
  2201. if (IS_FWI2_CAPABLE(ha)) {
  2202. WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_CLR_HOST_INT);
  2203. WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_CLR_RISC_INT);
  2204. } else {
  2205. WRT_REG_WORD(&reg->isp.semaphore, 0);
  2206. WRT_REG_WORD(&reg->isp.hccr, HCCR_CLR_RISC_INT);
  2207. WRT_REG_WORD(&reg->isp.hccr, HCCR_CLR_HOST_INT);
  2208. }
  2209. spin_unlock_irq(&ha->hardware_lock);
  2210. fail:
  2211. return ret;
  2212. }
  2213. void
  2214. qla2x00_free_irqs(scsi_qla_host_t *vha)
  2215. {
  2216. struct qla_hw_data *ha = vha->hw;
  2217. struct rsp_que *rsp = ha->rsp_q_map[0];
  2218. if (ha->flags.msix_enabled)
  2219. qla24xx_disable_msix(ha);
  2220. else if (ha->flags.msi_enabled) {
  2221. free_irq(ha->pdev->irq, rsp);
  2222. pci_disable_msi(ha->pdev);
  2223. } else
  2224. free_irq(ha->pdev->irq, rsp);
  2225. }
  2226. int qla25xx_request_irq(struct rsp_que *rsp)
  2227. {
  2228. struct qla_hw_data *ha = rsp->hw;
  2229. struct qla_init_msix_entry *intr = &msix_entries[2];
  2230. struct qla_msix_entry *msix = rsp->msix;
  2231. int ret;
  2232. ret = request_irq(msix->vector, intr->handler, 0, intr->name, rsp);
  2233. if (ret) {
  2234. qla_printk(KERN_WARNING, ha,
  2235. "MSI-X: Unable to register handler -- %x/%d.\n",
  2236. msix->vector, ret);
  2237. return ret;
  2238. }
  2239. msix->have_irq = 1;
  2240. msix->rsp = rsp;
  2241. return ret;
  2242. }