2 * QLogic Fibre Channel HBA Driver
3 * Copyright (c) 2003-2014 QLogic Corporation
5 * See LICENSE.qla2xxx for copyright and licensing details.
9 * Table for showing the current message id in use for particular level
10 * Change this table for addition of log/debug messages.
11 * ----------------------------------------------------------------------
12 * | Level | Last Value Used | Holes |
13 * ----------------------------------------------------------------------
14 * | Module Init and Probe | 0x0193 | 0x0146 |
15 * | | | 0x015b-0x0160 |
17 * | Mailbox commands | 0x1206 | 0x11a2-0x11ff |
18 * | Device Discovery | 0x2134 | 0x210e-0x2116 |
20 * | | | 0x211c-0x2128 |
21 * | | | 0x212a-0x2134 |
22 * | Queue Command and IO tracing | 0x3074 | 0x300b |
23 * | | | 0x3027-0x3028 |
24 * | | | 0x303d-0x3041 |
25 * | | | 0x302d,0x3033 |
26 * | | | 0x3036,0x3038 |
28 * | DPC Thread | 0x4023 | 0x4002,0x4013 |
29 * | Async Events | 0x5090 | 0x502b-0x502f |
31 * | | | 0x5084,0x5075 |
32 * | | | 0x503d,0x5044 |
34 * | Timer Routines | 0x6012 | |
35 * | User Space Interactions | 0x70e3 | 0x7018,0x702e |
36 * | | | 0x7020,0x7024 |
37 * | | | 0x7039,0x7045 |
38 * | | | 0x7073-0x7075 |
39 * | | | 0x70a5-0x70a6 |
40 * | | | 0x70a8,0x70ab |
41 * | | | 0x70ad-0x70ae |
42 * | | | 0x70d0-0x70d6 |
43 * | | | 0x70d7-0x70db |
44 * | Task Management | 0x8042 | 0x8000 |
46 * | | | 0x8025,0x8026 |
47 * | | | 0x8031,0x8032 |
48 * | | | 0x8039,0x803c |
49 * | AER/EEH | 0x9011 | |
50 * | Virtual Port | 0xa007 | |
51 * | ISP82XX Specific | 0xb157 | 0xb002,0xb024 |
52 * | | | 0xb09e,0xb0ae |
53 * | | | 0xb0c3,0xb0c6 |
54 * | | | 0xb0e0-0xb0ef |
55 * | | | 0xb085,0xb0dc |
56 * | | | 0xb107,0xb108 |
57 * | | | 0xb111,0xb11e |
58 * | | | 0xb12c,0xb12d |
59 * | | | 0xb13a,0xb142 |
60 * | | | 0xb13c-0xb140 |
62 * | MultiQ | 0xc010 | |
63 * | Misc | 0xd303 | 0xd031-0xd0ff |
64 * | | | 0xd101-0xd1fe |
65 * | | | 0xd214-0xd2fe |
66 * | Target Mode | 0xe081 | |
67 * | Target Mode Management | 0xf09b | 0xf002 |
68 * | | | 0xf046-0xf049 |
69 * | Target Mode Task Management | 0x1000d | |
70 * ----------------------------------------------------------------------
75 #include <linux/delay.h>
76 #define CREATE_TRACE_POINTS
77 #include <trace/events/qla.h>
79 static uint32_t ql_dbg_offset = 0x800;
82 qla2xxx_prep_dump(struct qla_hw_data *ha, struct qla2xxx_fw_dump *fw_dump)
84 fw_dump->fw_major_version = htonl(ha->fw_major_version);
85 fw_dump->fw_minor_version = htonl(ha->fw_minor_version);
86 fw_dump->fw_subminor_version = htonl(ha->fw_subminor_version);
87 fw_dump->fw_attributes = htonl(ha->fw_attributes);
89 fw_dump->vendor = htonl(ha->pdev->vendor);
90 fw_dump->device = htonl(ha->pdev->device);
91 fw_dump->subsystem_vendor = htonl(ha->pdev->subsystem_vendor);
92 fw_dump->subsystem_device = htonl(ha->pdev->subsystem_device);
96 qla2xxx_copy_queues(struct qla_hw_data *ha, void *ptr)
98 struct req_que *req = ha->req_q_map[0];
99 struct rsp_que *rsp = ha->rsp_q_map[0];
101 memcpy(ptr, req->ring, req->length *
104 /* Response queue. */
105 ptr += req->length * sizeof(request_t);
106 memcpy(ptr, rsp->ring, rsp->length *
109 return ptr + (rsp->length * sizeof(response_t));
113 qla27xx_dump_mpi_ram(struct qla_hw_data *ha, uint32_t addr, uint32_t *ram,
114 uint32_t ram_dwords, void **nxt)
116 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
117 dma_addr_t dump_dma = ha->gid_list_dma;
118 uint32_t *chunk = (void *)ha->gid_list;
119 uint32_t dwords = qla2x00_gid_list_size(ha) / 4;
121 ulong i, j, timer = 6000000;
122 int rval = QLA_FUNCTION_FAILED;
124 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
125 for (i = 0; i < ram_dwords; i += dwords, addr += dwords) {
126 if (i + dwords > ram_dwords)
127 dwords = ram_dwords - i;
129 WRT_REG_WORD(®->mailbox0, MBC_LOAD_DUMP_MPI_RAM);
130 WRT_REG_WORD(®->mailbox1, LSW(addr));
131 WRT_REG_WORD(®->mailbox8, MSW(addr));
133 WRT_REG_WORD(®->mailbox2, MSW(LSD(dump_dma)));
134 WRT_REG_WORD(®->mailbox3, LSW(LSD(dump_dma)));
135 WRT_REG_WORD(®->mailbox6, MSW(MSD(dump_dma)));
136 WRT_REG_WORD(®->mailbox7, LSW(MSD(dump_dma)));
138 WRT_REG_WORD(®->mailbox4, MSW(dwords));
139 WRT_REG_WORD(®->mailbox5, LSW(dwords));
141 WRT_REG_WORD(®->mailbox9, 0);
142 WRT_REG_DWORD(®->hccr, HCCRX_SET_HOST_INT);
144 ha->flags.mbox_int = 0;
148 stat = RD_REG_DWORD(®->host_status);
149 /* Check for pending interrupts. */
150 if (!(stat & HSRX_RISC_INT))
154 if (stat != 0x1 && stat != 0x2 &&
155 stat != 0x10 && stat != 0x11) {
157 /* Clear this intr; it wasn't a mailbox intr */
158 WRT_REG_DWORD(®->hccr, HCCRX_CLR_RISC_INT);
159 RD_REG_DWORD(®->hccr);
163 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
164 rval = RD_REG_WORD(®->mailbox0) & MBS_MASK;
165 WRT_REG_DWORD(®->hccr, HCCRX_CLR_RISC_INT);
166 RD_REG_DWORD(®->hccr);
169 ha->flags.mbox_int = 1;
172 if (!test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
173 /* no interrupt, timed out*/
177 /* error completion status */
180 for (j = 0; j < dwords; j++) {
182 (IS_QLA27XX(ha) || IS_QLA28XX(ha)) ?
183 chunk[j] : swab32(chunk[j]);
192 qla24xx_dump_ram(struct qla_hw_data *ha, uint32_t addr, uint32_t *ram,
193 uint32_t ram_dwords, void **nxt)
195 int rval = QLA_FUNCTION_FAILED;
196 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
197 dma_addr_t dump_dma = ha->gid_list_dma;
198 uint32_t *chunk = (void *)ha->gid_list;
199 uint32_t dwords = qla2x00_gid_list_size(ha) / 4;
201 ulong i, j, timer = 6000000;
203 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
205 for (i = 0; i < ram_dwords; i += dwords, addr += dwords) {
206 if (i + dwords > ram_dwords)
207 dwords = ram_dwords - i;
209 WRT_REG_WORD(®->mailbox0, MBC_DUMP_RISC_RAM_EXTENDED);
210 WRT_REG_WORD(®->mailbox1, LSW(addr));
211 WRT_REG_WORD(®->mailbox8, MSW(addr));
213 WRT_REG_WORD(®->mailbox2, MSW(LSD(dump_dma)));
214 WRT_REG_WORD(®->mailbox3, LSW(LSD(dump_dma)));
215 WRT_REG_WORD(®->mailbox6, MSW(MSD(dump_dma)));
216 WRT_REG_WORD(®->mailbox7, LSW(MSD(dump_dma)));
218 WRT_REG_WORD(®->mailbox4, MSW(dwords));
219 WRT_REG_WORD(®->mailbox5, LSW(dwords));
220 WRT_REG_DWORD(®->hccr, HCCRX_SET_HOST_INT);
222 ha->flags.mbox_int = 0;
225 stat = RD_REG_DWORD(®->host_status);
227 /* Check for pending interrupts. */
228 if (!(stat & HSRX_RISC_INT))
232 if (stat != 0x1 && stat != 0x2 &&
233 stat != 0x10 && stat != 0x11) {
234 WRT_REG_DWORD(®->hccr, HCCRX_CLR_RISC_INT);
235 RD_REG_DWORD(®->hccr);
239 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
240 rval = RD_REG_WORD(®->mailbox0) & MBS_MASK;
241 WRT_REG_DWORD(®->hccr, HCCRX_CLR_RISC_INT);
242 RD_REG_DWORD(®->hccr);
245 ha->flags.mbox_int = 1;
248 if (!test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
249 /* no interrupt, timed out*/
253 /* error completion status */
256 for (j = 0; j < dwords; j++) {
258 (IS_QLA27XX(ha) || IS_QLA28XX(ha)) ?
259 chunk[j] : swab32(chunk[j]);
268 qla24xx_dump_memory(struct qla_hw_data *ha, uint32_t *code_ram,
269 uint32_t cram_size, void **nxt)
274 rval = qla24xx_dump_ram(ha, 0x20000, code_ram, cram_size / 4, nxt);
275 if (rval != QLA_SUCCESS)
278 set_bit(RISC_SRAM_DUMP_CMPL, &ha->fw_dump_cap_flags);
280 /* External Memory. */
281 rval = qla24xx_dump_ram(ha, 0x100000, *nxt,
282 ha->fw_memory_size - 0x100000 + 1, nxt);
283 if (rval == QLA_SUCCESS)
284 set_bit(RISC_EXT_MEM_DUMP_CMPL, &ha->fw_dump_cap_flags);
290 qla24xx_read_window(struct device_reg_24xx __iomem *reg, uint32_t iobase,
291 uint32_t count, uint32_t *buf)
293 uint32_t __iomem *dmp_reg;
295 WRT_REG_DWORD(®->iobase_addr, iobase);
296 dmp_reg = ®->iobase_window;
297 for ( ; count--; dmp_reg++)
298 *buf++ = htonl(RD_REG_DWORD(dmp_reg));
304 qla24xx_pause_risc(struct device_reg_24xx __iomem *reg, struct qla_hw_data *ha)
306 WRT_REG_DWORD(®->hccr, HCCRX_SET_RISC_PAUSE);
308 /* 100 usec delay is sufficient enough for hardware to pause RISC */
310 if (RD_REG_DWORD(®->host_status) & HSRX_RISC_PAUSED)
311 set_bit(RISC_PAUSE_CMPL, &ha->fw_dump_cap_flags);
315 qla24xx_soft_reset(struct qla_hw_data *ha)
317 int rval = QLA_SUCCESS;
320 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
323 * Reset RISC. The delay is dependent on system architecture.
324 * Driver can proceed with the reset sequence after waiting
325 * for a timeout period.
327 WRT_REG_DWORD(®->ctrl_status, CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
328 for (cnt = 0; cnt < 30000; cnt++) {
329 if ((RD_REG_DWORD(®->ctrl_status) & CSRX_DMA_ACTIVE) == 0)
334 if (!(RD_REG_DWORD(®->ctrl_status) & CSRX_DMA_ACTIVE))
335 set_bit(DMA_SHUTDOWN_CMPL, &ha->fw_dump_cap_flags);
337 WRT_REG_DWORD(®->ctrl_status,
338 CSRX_ISP_SOFT_RESET|CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
339 pci_read_config_word(ha->pdev, PCI_COMMAND, &wd);
343 /* Wait for soft-reset to complete. */
344 for (cnt = 0; cnt < 30000; cnt++) {
345 if ((RD_REG_DWORD(®->ctrl_status) &
346 CSRX_ISP_SOFT_RESET) == 0)
351 if (!(RD_REG_DWORD(®->ctrl_status) & CSRX_ISP_SOFT_RESET))
352 set_bit(ISP_RESET_CMPL, &ha->fw_dump_cap_flags);
354 WRT_REG_DWORD(®->hccr, HCCRX_CLR_RISC_RESET);
355 RD_REG_DWORD(®->hccr); /* PCI Posting. */
357 for (cnt = 10000; RD_REG_WORD(®->mailbox0) != 0 &&
358 rval == QLA_SUCCESS; cnt--) {
362 rval = QLA_FUNCTION_TIMEOUT;
364 if (rval == QLA_SUCCESS)
365 set_bit(RISC_RDY_AFT_RESET, &ha->fw_dump_cap_flags);
371 qla2xxx_dump_ram(struct qla_hw_data *ha, uint32_t addr, uint16_t *ram,
372 uint32_t ram_words, void **nxt)
375 uint32_t cnt, stat, timer, words, idx;
377 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
378 dma_addr_t dump_dma = ha->gid_list_dma;
379 uint16_t *dump = (uint16_t *)ha->gid_list;
384 WRT_MAILBOX_REG(ha, reg, 0, MBC_DUMP_RISC_RAM_EXTENDED);
385 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
387 words = qla2x00_gid_list_size(ha) / 2;
388 for (cnt = 0; cnt < ram_words && rval == QLA_SUCCESS;
389 cnt += words, addr += words) {
390 if (cnt + words > ram_words)
391 words = ram_words - cnt;
393 WRT_MAILBOX_REG(ha, reg, 1, LSW(addr));
394 WRT_MAILBOX_REG(ha, reg, 8, MSW(addr));
396 WRT_MAILBOX_REG(ha, reg, 2, MSW(dump_dma));
397 WRT_MAILBOX_REG(ha, reg, 3, LSW(dump_dma));
398 WRT_MAILBOX_REG(ha, reg, 6, MSW(MSD(dump_dma)));
399 WRT_MAILBOX_REG(ha, reg, 7, LSW(MSD(dump_dma)));
401 WRT_MAILBOX_REG(ha, reg, 4, words);
402 WRT_REG_WORD(®->hccr, HCCR_SET_HOST_INT);
404 for (timer = 6000000; timer; timer--) {
405 /* Check for pending interrupts. */
406 stat = RD_REG_DWORD(®->u.isp2300.host_status);
407 if (stat & HSR_RISC_INT) {
410 if (stat == 0x1 || stat == 0x2) {
411 set_bit(MBX_INTERRUPT,
414 mb0 = RD_MAILBOX_REG(ha, reg, 0);
416 /* Release mailbox registers. */
417 WRT_REG_WORD(®->semaphore, 0);
418 WRT_REG_WORD(®->hccr,
420 RD_REG_WORD(®->hccr);
422 } else if (stat == 0x10 || stat == 0x11) {
423 set_bit(MBX_INTERRUPT,
426 mb0 = RD_MAILBOX_REG(ha, reg, 0);
428 WRT_REG_WORD(®->hccr,
430 RD_REG_WORD(®->hccr);
434 /* clear this intr; it wasn't a mailbox intr */
435 WRT_REG_WORD(®->hccr, HCCR_CLR_RISC_INT);
436 RD_REG_WORD(®->hccr);
441 if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
442 rval = mb0 & MBS_MASK;
443 for (idx = 0; idx < words; idx++)
444 ram[cnt + idx] = swab16(dump[idx]);
446 rval = QLA_FUNCTION_FAILED;
450 *nxt = rval == QLA_SUCCESS ? &ram[cnt] : NULL;
455 qla2xxx_read_window(struct device_reg_2xxx __iomem *reg, uint32_t count,
458 uint16_t __iomem *dmp_reg = ®->u.isp2300.fb_cmd;
460 for ( ; count--; dmp_reg++)
461 *buf++ = htons(RD_REG_WORD(dmp_reg));
465 qla24xx_copy_eft(struct qla_hw_data *ha, void *ptr)
470 memcpy(ptr, ha->eft, ntohl(ha->fw_dump->eft_size));
471 return ptr + ntohl(ha->fw_dump->eft_size);
475 qla25xx_copy_fce(struct qla_hw_data *ha, void *ptr, uint32_t **last_chain)
479 struct qla2xxx_fce_chain *fcec = ptr;
484 *last_chain = &fcec->type;
485 fcec->type = htonl(DUMP_CHAIN_FCE);
486 fcec->chain_size = htonl(sizeof(struct qla2xxx_fce_chain) +
487 fce_calc_size(ha->fce_bufs));
488 fcec->size = htonl(fce_calc_size(ha->fce_bufs));
489 fcec->addr_l = htonl(LSD(ha->fce_dma));
490 fcec->addr_h = htonl(MSD(ha->fce_dma));
492 iter_reg = fcec->eregs;
493 for (cnt = 0; cnt < 8; cnt++)
494 *iter_reg++ = htonl(ha->fce_mb[cnt]);
496 memcpy(iter_reg, ha->fce, ntohl(fcec->size));
498 return (char *)iter_reg + ntohl(fcec->size);
502 qla25xx_copy_exlogin(struct qla_hw_data *ha, void *ptr, uint32_t **last_chain)
504 struct qla2xxx_offld_chain *c = ptr;
506 if (!ha->exlogin_buf)
509 *last_chain = &c->type;
511 c->type = cpu_to_be32(DUMP_CHAIN_EXLOGIN);
512 c->chain_size = cpu_to_be32(sizeof(struct qla2xxx_offld_chain) +
514 c->size = cpu_to_be32(ha->exlogin_size);
515 c->addr = cpu_to_be64(ha->exlogin_buf_dma);
517 ptr += sizeof(struct qla2xxx_offld_chain);
518 memcpy(ptr, ha->exlogin_buf, ha->exlogin_size);
520 return (char *)ptr + cpu_to_be32(c->size);
524 qla81xx_copy_exchoffld(struct qla_hw_data *ha, void *ptr, uint32_t **last_chain)
526 struct qla2xxx_offld_chain *c = ptr;
528 if (!ha->exchoffld_buf)
531 *last_chain = &c->type;
533 c->type = cpu_to_be32(DUMP_CHAIN_EXCHG);
534 c->chain_size = cpu_to_be32(sizeof(struct qla2xxx_offld_chain) +
536 c->size = cpu_to_be32(ha->exchoffld_size);
537 c->addr = cpu_to_be64(ha->exchoffld_buf_dma);
539 ptr += sizeof(struct qla2xxx_offld_chain);
540 memcpy(ptr, ha->exchoffld_buf, ha->exchoffld_size);
542 return (char *)ptr + cpu_to_be32(c->size);
546 qla2xxx_copy_atioqueues(struct qla_hw_data *ha, void *ptr,
547 uint32_t **last_chain)
549 struct qla2xxx_mqueue_chain *q;
550 struct qla2xxx_mqueue_header *qh;
558 if (!ha->tgt.atio_ring)
563 aqp->length = ha->tgt.atio_q_length;
564 aqp->ring = ha->tgt.atio_ring;
566 for (que = 0; que < num_queues; que++) {
567 /* aqp = ha->atio_q_map[que]; */
569 *last_chain = &q->type;
570 q->type = htonl(DUMP_CHAIN_QUEUE);
571 q->chain_size = htonl(
572 sizeof(struct qla2xxx_mqueue_chain) +
573 sizeof(struct qla2xxx_mqueue_header) +
574 (aqp->length * sizeof(request_t)));
575 ptr += sizeof(struct qla2xxx_mqueue_chain);
579 qh->queue = htonl(TYPE_ATIO_QUEUE);
580 qh->number = htonl(que);
581 qh->size = htonl(aqp->length * sizeof(request_t));
582 ptr += sizeof(struct qla2xxx_mqueue_header);
585 memcpy(ptr, aqp->ring, aqp->length * sizeof(request_t));
587 ptr += aqp->length * sizeof(request_t);
594 qla25xx_copy_mqueues(struct qla_hw_data *ha, void *ptr, uint32_t **last_chain)
596 struct qla2xxx_mqueue_chain *q;
597 struct qla2xxx_mqueue_header *qh;
606 for (que = 1; que < ha->max_req_queues; que++) {
607 req = ha->req_q_map[que];
613 *last_chain = &q->type;
614 q->type = htonl(DUMP_CHAIN_QUEUE);
615 q->chain_size = htonl(
616 sizeof(struct qla2xxx_mqueue_chain) +
617 sizeof(struct qla2xxx_mqueue_header) +
618 (req->length * sizeof(request_t)));
619 ptr += sizeof(struct qla2xxx_mqueue_chain);
623 qh->queue = htonl(TYPE_REQUEST_QUEUE);
624 qh->number = htonl(que);
625 qh->size = htonl(req->length * sizeof(request_t));
626 ptr += sizeof(struct qla2xxx_mqueue_header);
629 memcpy(ptr, req->ring, req->length * sizeof(request_t));
630 ptr += req->length * sizeof(request_t);
633 /* Response queues */
634 for (que = 1; que < ha->max_rsp_queues; que++) {
635 rsp = ha->rsp_q_map[que];
641 *last_chain = &q->type;
642 q->type = htonl(DUMP_CHAIN_QUEUE);
643 q->chain_size = htonl(
644 sizeof(struct qla2xxx_mqueue_chain) +
645 sizeof(struct qla2xxx_mqueue_header) +
646 (rsp->length * sizeof(response_t)));
647 ptr += sizeof(struct qla2xxx_mqueue_chain);
651 qh->queue = htonl(TYPE_RESPONSE_QUEUE);
652 qh->number = htonl(que);
653 qh->size = htonl(rsp->length * sizeof(response_t));
654 ptr += sizeof(struct qla2xxx_mqueue_header);
657 memcpy(ptr, rsp->ring, rsp->length * sizeof(response_t));
658 ptr += rsp->length * sizeof(response_t);
665 qla25xx_copy_mq(struct qla_hw_data *ha, void *ptr, uint32_t **last_chain)
667 uint32_t cnt, que_idx;
669 struct qla2xxx_mq_chain *mq = ptr;
672 if (!ha->mqenable || IS_QLA83XX(ha) || IS_QLA27XX(ha) ||
677 *last_chain = &mq->type;
678 mq->type = htonl(DUMP_CHAIN_MQ);
679 mq->chain_size = htonl(sizeof(struct qla2xxx_mq_chain));
681 que_cnt = ha->max_req_queues > ha->max_rsp_queues ?
682 ha->max_req_queues : ha->max_rsp_queues;
683 mq->count = htonl(que_cnt);
684 for (cnt = 0; cnt < que_cnt; cnt++) {
685 reg = ISP_QUE_REG(ha, cnt);
688 htonl(RD_REG_DWORD(®->isp25mq.req_q_in));
689 mq->qregs[que_idx+1] =
690 htonl(RD_REG_DWORD(®->isp25mq.req_q_out));
691 mq->qregs[que_idx+2] =
692 htonl(RD_REG_DWORD(®->isp25mq.rsp_q_in));
693 mq->qregs[que_idx+3] =
694 htonl(RD_REG_DWORD(®->isp25mq.rsp_q_out));
697 return ptr + sizeof(struct qla2xxx_mq_chain);
701 qla2xxx_dump_post_process(scsi_qla_host_t *vha, int rval)
703 struct qla_hw_data *ha = vha->hw;
705 if (rval != QLA_SUCCESS) {
706 ql_log(ql_log_warn, vha, 0xd000,
707 "Failed to dump firmware (%x), dump status flags (0x%lx).\n",
708 rval, ha->fw_dump_cap_flags);
711 ql_log(ql_log_info, vha, 0xd001,
712 "Firmware dump saved to temp buffer (%ld/%p), dump status flags (0x%lx).\n",
713 vha->host_no, ha->fw_dump, ha->fw_dump_cap_flags);
715 qla2x00_post_uevent_work(vha, QLA_UEVENT_CODE_FW_DUMP);
720 * qla2300_fw_dump() - Dumps binary data from the 2300 firmware.
722 * @hardware_locked: Called with the hardware_lock
725 qla2300_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
729 struct qla_hw_data *ha = vha->hw;
730 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
731 uint16_t __iomem *dmp_reg;
733 struct qla2300_fw_dump *fw;
735 struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
740 if (!hardware_locked)
741 spin_lock_irqsave(&ha->hardware_lock, flags);
745 ql_log(ql_log_warn, vha, 0xd002,
746 "No buffer available for dump.\n");
747 goto qla2300_fw_dump_failed;
751 ql_log(ql_log_warn, vha, 0xd003,
752 "Firmware has been previously dumped (%p) "
753 "-- ignoring request.\n",
755 goto qla2300_fw_dump_failed;
757 fw = &ha->fw_dump->isp.isp23;
758 qla2xxx_prep_dump(ha, ha->fw_dump);
761 fw->hccr = htons(RD_REG_WORD(®->hccr));
764 WRT_REG_WORD(®->hccr, HCCR_PAUSE_RISC);
765 if (IS_QLA2300(ha)) {
767 (RD_REG_WORD(®->hccr) & HCCR_RISC_PAUSE) == 0 &&
768 rval == QLA_SUCCESS; cnt--) {
772 rval = QLA_FUNCTION_TIMEOUT;
775 RD_REG_WORD(®->hccr); /* PCI Posting. */
779 if (rval == QLA_SUCCESS) {
780 dmp_reg = ®->flash_address;
781 for (cnt = 0; cnt < sizeof(fw->pbiu_reg) / 2; cnt++, dmp_reg++)
782 fw->pbiu_reg[cnt] = htons(RD_REG_WORD(dmp_reg));
784 dmp_reg = ®->u.isp2300.req_q_in;
785 for (cnt = 0; cnt < sizeof(fw->risc_host_reg) / 2;
787 fw->risc_host_reg[cnt] = htons(RD_REG_WORD(dmp_reg));
789 dmp_reg = ®->u.isp2300.mailbox0;
790 for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2;
792 fw->mailbox_reg[cnt] = htons(RD_REG_WORD(dmp_reg));
794 WRT_REG_WORD(®->ctrl_status, 0x40);
795 qla2xxx_read_window(reg, 32, fw->resp_dma_reg);
797 WRT_REG_WORD(®->ctrl_status, 0x50);
798 qla2xxx_read_window(reg, 48, fw->dma_reg);
800 WRT_REG_WORD(®->ctrl_status, 0x00);
801 dmp_reg = ®->risc_hw;
802 for (cnt = 0; cnt < sizeof(fw->risc_hdw_reg) / 2;
804 fw->risc_hdw_reg[cnt] = htons(RD_REG_WORD(dmp_reg));
806 WRT_REG_WORD(®->pcr, 0x2000);
807 qla2xxx_read_window(reg, 16, fw->risc_gp0_reg);
809 WRT_REG_WORD(®->pcr, 0x2200);
810 qla2xxx_read_window(reg, 16, fw->risc_gp1_reg);
812 WRT_REG_WORD(®->pcr, 0x2400);
813 qla2xxx_read_window(reg, 16, fw->risc_gp2_reg);
815 WRT_REG_WORD(®->pcr, 0x2600);
816 qla2xxx_read_window(reg, 16, fw->risc_gp3_reg);
818 WRT_REG_WORD(®->pcr, 0x2800);
819 qla2xxx_read_window(reg, 16, fw->risc_gp4_reg);
821 WRT_REG_WORD(®->pcr, 0x2A00);
822 qla2xxx_read_window(reg, 16, fw->risc_gp5_reg);
824 WRT_REG_WORD(®->pcr, 0x2C00);
825 qla2xxx_read_window(reg, 16, fw->risc_gp6_reg);
827 WRT_REG_WORD(®->pcr, 0x2E00);
828 qla2xxx_read_window(reg, 16, fw->risc_gp7_reg);
830 WRT_REG_WORD(®->ctrl_status, 0x10);
831 qla2xxx_read_window(reg, 64, fw->frame_buf_hdw_reg);
833 WRT_REG_WORD(®->ctrl_status, 0x20);
834 qla2xxx_read_window(reg, 64, fw->fpm_b0_reg);
836 WRT_REG_WORD(®->ctrl_status, 0x30);
837 qla2xxx_read_window(reg, 64, fw->fpm_b1_reg);
840 WRT_REG_WORD(®->ctrl_status, CSR_ISP_SOFT_RESET);
841 for (cnt = 0; cnt < 30000; cnt++) {
842 if ((RD_REG_WORD(®->ctrl_status) &
843 CSR_ISP_SOFT_RESET) == 0)
850 if (!IS_QLA2300(ha)) {
851 for (cnt = 30000; RD_MAILBOX_REG(ha, reg, 0) != 0 &&
852 rval == QLA_SUCCESS; cnt--) {
856 rval = QLA_FUNCTION_TIMEOUT;
861 if (rval == QLA_SUCCESS)
862 rval = qla2xxx_dump_ram(ha, 0x800, fw->risc_ram,
863 sizeof(fw->risc_ram) / 2, &nxt);
865 /* Get stack SRAM. */
866 if (rval == QLA_SUCCESS)
867 rval = qla2xxx_dump_ram(ha, 0x10000, fw->stack_ram,
868 sizeof(fw->stack_ram) / 2, &nxt);
871 if (rval == QLA_SUCCESS)
872 rval = qla2xxx_dump_ram(ha, 0x11000, fw->data_ram,
873 ha->fw_memory_size - 0x11000 + 1, &nxt);
875 if (rval == QLA_SUCCESS)
876 qla2xxx_copy_queues(ha, nxt);
878 qla2xxx_dump_post_process(base_vha, rval);
880 qla2300_fw_dump_failed:
882 if (!hardware_locked)
883 spin_unlock_irqrestore(&ha->hardware_lock, flags);
890 * qla2100_fw_dump() - Dumps binary data from the 2100/2200 firmware.
892 * @hardware_locked: Called with the hardware_lock
895 qla2100_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
899 uint16_t risc_address;
901 struct qla_hw_data *ha = vha->hw;
902 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
903 uint16_t __iomem *dmp_reg;
905 struct qla2100_fw_dump *fw;
906 struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
913 if (!hardware_locked)
914 spin_lock_irqsave(&ha->hardware_lock, flags);
918 ql_log(ql_log_warn, vha, 0xd004,
919 "No buffer available for dump.\n");
920 goto qla2100_fw_dump_failed;
924 ql_log(ql_log_warn, vha, 0xd005,
925 "Firmware has been previously dumped (%p) "
926 "-- ignoring request.\n",
928 goto qla2100_fw_dump_failed;
930 fw = &ha->fw_dump->isp.isp21;
931 qla2xxx_prep_dump(ha, ha->fw_dump);
934 fw->hccr = htons(RD_REG_WORD(®->hccr));
937 WRT_REG_WORD(®->hccr, HCCR_PAUSE_RISC);
938 for (cnt = 30000; (RD_REG_WORD(®->hccr) & HCCR_RISC_PAUSE) == 0 &&
939 rval == QLA_SUCCESS; cnt--) {
943 rval = QLA_FUNCTION_TIMEOUT;
945 if (rval == QLA_SUCCESS) {
946 dmp_reg = ®->flash_address;
947 for (cnt = 0; cnt < sizeof(fw->pbiu_reg) / 2; cnt++, dmp_reg++)
948 fw->pbiu_reg[cnt] = htons(RD_REG_WORD(dmp_reg));
950 dmp_reg = ®->u.isp2100.mailbox0;
951 for (cnt = 0; cnt < ha->mbx_count; cnt++, dmp_reg++) {
953 dmp_reg = ®->u_end.isp2200.mailbox8;
955 fw->mailbox_reg[cnt] = htons(RD_REG_WORD(dmp_reg));
958 dmp_reg = ®->u.isp2100.unused_2[0];
959 for (cnt = 0; cnt < sizeof(fw->dma_reg) / 2; cnt++, dmp_reg++)
960 fw->dma_reg[cnt] = htons(RD_REG_WORD(dmp_reg));
962 WRT_REG_WORD(®->ctrl_status, 0x00);
963 dmp_reg = ®->risc_hw;
964 for (cnt = 0; cnt < sizeof(fw->risc_hdw_reg) / 2; cnt++, dmp_reg++)
965 fw->risc_hdw_reg[cnt] = htons(RD_REG_WORD(dmp_reg));
967 WRT_REG_WORD(®->pcr, 0x2000);
968 qla2xxx_read_window(reg, 16, fw->risc_gp0_reg);
970 WRT_REG_WORD(®->pcr, 0x2100);
971 qla2xxx_read_window(reg, 16, fw->risc_gp1_reg);
973 WRT_REG_WORD(®->pcr, 0x2200);
974 qla2xxx_read_window(reg, 16, fw->risc_gp2_reg);
976 WRT_REG_WORD(®->pcr, 0x2300);
977 qla2xxx_read_window(reg, 16, fw->risc_gp3_reg);
979 WRT_REG_WORD(®->pcr, 0x2400);
980 qla2xxx_read_window(reg, 16, fw->risc_gp4_reg);
982 WRT_REG_WORD(®->pcr, 0x2500);
983 qla2xxx_read_window(reg, 16, fw->risc_gp5_reg);
985 WRT_REG_WORD(®->pcr, 0x2600);
986 qla2xxx_read_window(reg, 16, fw->risc_gp6_reg);
988 WRT_REG_WORD(®->pcr, 0x2700);
989 qla2xxx_read_window(reg, 16, fw->risc_gp7_reg);
991 WRT_REG_WORD(®->ctrl_status, 0x10);
992 qla2xxx_read_window(reg, 16, fw->frame_buf_hdw_reg);
994 WRT_REG_WORD(®->ctrl_status, 0x20);
995 qla2xxx_read_window(reg, 64, fw->fpm_b0_reg);
997 WRT_REG_WORD(®->ctrl_status, 0x30);
998 qla2xxx_read_window(reg, 64, fw->fpm_b1_reg);
1000 /* Reset the ISP. */
1001 WRT_REG_WORD(®->ctrl_status, CSR_ISP_SOFT_RESET);
1004 for (cnt = 30000; RD_MAILBOX_REG(ha, reg, 0) != 0 &&
1005 rval == QLA_SUCCESS; cnt--) {
1009 rval = QLA_FUNCTION_TIMEOUT;
1013 if (rval == QLA_SUCCESS && (IS_QLA2200(ha) || (IS_QLA2100(ha) &&
1014 (RD_REG_WORD(®->mctr) & (BIT_1 | BIT_0)) != 0))) {
1016 WRT_REG_WORD(®->hccr, HCCR_PAUSE_RISC);
1018 (RD_REG_WORD(®->hccr) & HCCR_RISC_PAUSE) == 0 &&
1019 rval == QLA_SUCCESS; cnt--) {
1023 rval = QLA_FUNCTION_TIMEOUT;
1025 if (rval == QLA_SUCCESS) {
1026 /* Set memory configuration and timing. */
1028 WRT_REG_WORD(®->mctr, 0xf1);
1030 WRT_REG_WORD(®->mctr, 0xf2);
1031 RD_REG_WORD(®->mctr); /* PCI Posting. */
1034 WRT_REG_WORD(®->hccr, HCCR_RELEASE_RISC);
1038 if (rval == QLA_SUCCESS) {
1039 /* Get RISC SRAM. */
1040 risc_address = 0x1000;
1041 WRT_MAILBOX_REG(ha, reg, 0, MBC_READ_RAM_WORD);
1042 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
1044 for (cnt = 0; cnt < sizeof(fw->risc_ram) / 2 && rval == QLA_SUCCESS;
1045 cnt++, risc_address++) {
1046 WRT_MAILBOX_REG(ha, reg, 1, risc_address);
1047 WRT_REG_WORD(®->hccr, HCCR_SET_HOST_INT);
1049 for (timer = 6000000; timer != 0; timer--) {
1050 /* Check for pending interrupts. */
1051 if (RD_REG_WORD(®->istatus) & ISR_RISC_INT) {
1052 if (RD_REG_WORD(®->semaphore) & BIT_0) {
1053 set_bit(MBX_INTERRUPT,
1054 &ha->mbx_cmd_flags);
1056 mb0 = RD_MAILBOX_REG(ha, reg, 0);
1057 mb2 = RD_MAILBOX_REG(ha, reg, 2);
1059 WRT_REG_WORD(®->semaphore, 0);
1060 WRT_REG_WORD(®->hccr,
1062 RD_REG_WORD(®->hccr);
1065 WRT_REG_WORD(®->hccr, HCCR_CLR_RISC_INT);
1066 RD_REG_WORD(®->hccr);
1071 if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
1072 rval = mb0 & MBS_MASK;
1073 fw->risc_ram[cnt] = htons(mb2);
1075 rval = QLA_FUNCTION_FAILED;
1079 if (rval == QLA_SUCCESS)
1080 qla2xxx_copy_queues(ha, &fw->risc_ram[cnt]);
1082 qla2xxx_dump_post_process(base_vha, rval);
1084 qla2100_fw_dump_failed:
1086 if (!hardware_locked)
1087 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1094 qla24xx_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
1098 struct qla_hw_data *ha = vha->hw;
1099 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1100 uint32_t __iomem *dmp_reg;
1102 uint16_t __iomem *mbx_reg;
1103 unsigned long flags;
1104 struct qla24xx_fw_dump *fw;
1107 uint32_t *last_chain = NULL;
1108 struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
1110 if (IS_P3P_TYPE(ha))
1114 ha->fw_dump_cap_flags = 0;
1117 if (!hardware_locked)
1118 spin_lock_irqsave(&ha->hardware_lock, flags);
1122 ql_log(ql_log_warn, vha, 0xd006,
1123 "No buffer available for dump.\n");
1124 goto qla24xx_fw_dump_failed;
1127 if (ha->fw_dumped) {
1128 ql_log(ql_log_warn, vha, 0xd007,
1129 "Firmware has been previously dumped (%p) "
1130 "-- ignoring request.\n",
1132 goto qla24xx_fw_dump_failed;
1135 fw = &ha->fw_dump->isp.isp24;
1136 qla2xxx_prep_dump(ha, ha->fw_dump);
1138 fw->host_status = htonl(RD_REG_DWORD(®->host_status));
1141 * Pause RISC. No need to track timeout, as resetting the chip
1142 * is the right approach incase of pause timeout
1144 qla24xx_pause_risc(reg, ha);
1146 /* Host interface registers. */
1147 dmp_reg = ®->flash_addr;
1148 for (cnt = 0; cnt < sizeof(fw->host_reg) / 4; cnt++, dmp_reg++)
1149 fw->host_reg[cnt] = htonl(RD_REG_DWORD(dmp_reg));
1151 /* Disable interrupts. */
1152 WRT_REG_DWORD(®->ictrl, 0);
1153 RD_REG_DWORD(®->ictrl);
1155 /* Shadow registers. */
1156 WRT_REG_DWORD(®->iobase_addr, 0x0F70);
1157 RD_REG_DWORD(®->iobase_addr);
1158 WRT_REG_DWORD(®->iobase_select, 0xB0000000);
1159 fw->shadow_reg[0] = htonl(RD_REG_DWORD(®->iobase_sdata));
1161 WRT_REG_DWORD(®->iobase_select, 0xB0100000);
1162 fw->shadow_reg[1] = htonl(RD_REG_DWORD(®->iobase_sdata));
1164 WRT_REG_DWORD(®->iobase_select, 0xB0200000);
1165 fw->shadow_reg[2] = htonl(RD_REG_DWORD(®->iobase_sdata));
1167 WRT_REG_DWORD(®->iobase_select, 0xB0300000);
1168 fw->shadow_reg[3] = htonl(RD_REG_DWORD(®->iobase_sdata));
1170 WRT_REG_DWORD(®->iobase_select, 0xB0400000);
1171 fw->shadow_reg[4] = htonl(RD_REG_DWORD(®->iobase_sdata));
1173 WRT_REG_DWORD(®->iobase_select, 0xB0500000);
1174 fw->shadow_reg[5] = htonl(RD_REG_DWORD(®->iobase_sdata));
1176 WRT_REG_DWORD(®->iobase_select, 0xB0600000);
1177 fw->shadow_reg[6] = htonl(RD_REG_DWORD(®->iobase_sdata));
1179 /* Mailbox registers. */
1180 mbx_reg = ®->mailbox0;
1181 for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2; cnt++, mbx_reg++)
1182 fw->mailbox_reg[cnt] = htons(RD_REG_WORD(mbx_reg));
1184 /* Transfer sequence registers. */
1185 iter_reg = fw->xseq_gp_reg;
1186 iter_reg = qla24xx_read_window(reg, 0xBF00, 16, iter_reg);
1187 iter_reg = qla24xx_read_window(reg, 0xBF10, 16, iter_reg);
1188 iter_reg = qla24xx_read_window(reg, 0xBF20, 16, iter_reg);
1189 iter_reg = qla24xx_read_window(reg, 0xBF30, 16, iter_reg);
1190 iter_reg = qla24xx_read_window(reg, 0xBF40, 16, iter_reg);
1191 iter_reg = qla24xx_read_window(reg, 0xBF50, 16, iter_reg);
1192 iter_reg = qla24xx_read_window(reg, 0xBF60, 16, iter_reg);
1193 qla24xx_read_window(reg, 0xBF70, 16, iter_reg);
1195 qla24xx_read_window(reg, 0xBFE0, 16, fw->xseq_0_reg);
1196 qla24xx_read_window(reg, 0xBFF0, 16, fw->xseq_1_reg);
1198 /* Receive sequence registers. */
1199 iter_reg = fw->rseq_gp_reg;
1200 iter_reg = qla24xx_read_window(reg, 0xFF00, 16, iter_reg);
1201 iter_reg = qla24xx_read_window(reg, 0xFF10, 16, iter_reg);
1202 iter_reg = qla24xx_read_window(reg, 0xFF20, 16, iter_reg);
1203 iter_reg = qla24xx_read_window(reg, 0xFF30, 16, iter_reg);
1204 iter_reg = qla24xx_read_window(reg, 0xFF40, 16, iter_reg);
1205 iter_reg = qla24xx_read_window(reg, 0xFF50, 16, iter_reg);
1206 iter_reg = qla24xx_read_window(reg, 0xFF60, 16, iter_reg);
1207 qla24xx_read_window(reg, 0xFF70, 16, iter_reg);
1209 qla24xx_read_window(reg, 0xFFD0, 16, fw->rseq_0_reg);
1210 qla24xx_read_window(reg, 0xFFE0, 16, fw->rseq_1_reg);
1211 qla24xx_read_window(reg, 0xFFF0, 16, fw->rseq_2_reg);
1213 /* Command DMA registers. */
1214 qla24xx_read_window(reg, 0x7100, 16, fw->cmd_dma_reg);
1217 iter_reg = fw->req0_dma_reg;
1218 iter_reg = qla24xx_read_window(reg, 0x7200, 8, iter_reg);
1219 dmp_reg = ®->iobase_q;
1220 for (cnt = 0; cnt < 7; cnt++, dmp_reg++)
1221 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg));
1223 iter_reg = fw->resp0_dma_reg;
1224 iter_reg = qla24xx_read_window(reg, 0x7300, 8, iter_reg);
1225 dmp_reg = ®->iobase_q;
1226 for (cnt = 0; cnt < 7; cnt++, dmp_reg++)
1227 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg));
1229 iter_reg = fw->req1_dma_reg;
1230 iter_reg = qla24xx_read_window(reg, 0x7400, 8, iter_reg);
1231 dmp_reg = ®->iobase_q;
1232 for (cnt = 0; cnt < 7; cnt++, dmp_reg++)
1233 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg));
1235 /* Transmit DMA registers. */
1236 iter_reg = fw->xmt0_dma_reg;
1237 iter_reg = qla24xx_read_window(reg, 0x7600, 16, iter_reg);
1238 qla24xx_read_window(reg, 0x7610, 16, iter_reg);
1240 iter_reg = fw->xmt1_dma_reg;
1241 iter_reg = qla24xx_read_window(reg, 0x7620, 16, iter_reg);
1242 qla24xx_read_window(reg, 0x7630, 16, iter_reg);
1244 iter_reg = fw->xmt2_dma_reg;
1245 iter_reg = qla24xx_read_window(reg, 0x7640, 16, iter_reg);
1246 qla24xx_read_window(reg, 0x7650, 16, iter_reg);
1248 iter_reg = fw->xmt3_dma_reg;
1249 iter_reg = qla24xx_read_window(reg, 0x7660, 16, iter_reg);
1250 qla24xx_read_window(reg, 0x7670, 16, iter_reg);
1252 iter_reg = fw->xmt4_dma_reg;
1253 iter_reg = qla24xx_read_window(reg, 0x7680, 16, iter_reg);
1254 qla24xx_read_window(reg, 0x7690, 16, iter_reg);
1256 qla24xx_read_window(reg, 0x76A0, 16, fw->xmt_data_dma_reg);
1258 /* Receive DMA registers. */
1259 iter_reg = fw->rcvt0_data_dma_reg;
1260 iter_reg = qla24xx_read_window(reg, 0x7700, 16, iter_reg);
1261 qla24xx_read_window(reg, 0x7710, 16, iter_reg);
1263 iter_reg = fw->rcvt1_data_dma_reg;
1264 iter_reg = qla24xx_read_window(reg, 0x7720, 16, iter_reg);
1265 qla24xx_read_window(reg, 0x7730, 16, iter_reg);
1267 /* RISC registers. */
1268 iter_reg = fw->risc_gp_reg;
1269 iter_reg = qla24xx_read_window(reg, 0x0F00, 16, iter_reg);
1270 iter_reg = qla24xx_read_window(reg, 0x0F10, 16, iter_reg);
1271 iter_reg = qla24xx_read_window(reg, 0x0F20, 16, iter_reg);
1272 iter_reg = qla24xx_read_window(reg, 0x0F30, 16, iter_reg);
1273 iter_reg = qla24xx_read_window(reg, 0x0F40, 16, iter_reg);
1274 iter_reg = qla24xx_read_window(reg, 0x0F50, 16, iter_reg);
1275 iter_reg = qla24xx_read_window(reg, 0x0F60, 16, iter_reg);
1276 qla24xx_read_window(reg, 0x0F70, 16, iter_reg);
1278 /* Local memory controller registers. */
1279 iter_reg = fw->lmc_reg;
1280 iter_reg = qla24xx_read_window(reg, 0x3000, 16, iter_reg);
1281 iter_reg = qla24xx_read_window(reg, 0x3010, 16, iter_reg);
1282 iter_reg = qla24xx_read_window(reg, 0x3020, 16, iter_reg);
1283 iter_reg = qla24xx_read_window(reg, 0x3030, 16, iter_reg);
1284 iter_reg = qla24xx_read_window(reg, 0x3040, 16, iter_reg);
1285 iter_reg = qla24xx_read_window(reg, 0x3050, 16, iter_reg);
1286 qla24xx_read_window(reg, 0x3060, 16, iter_reg);
1288 /* Fibre Protocol Module registers. */
1289 iter_reg = fw->fpm_hdw_reg;
1290 iter_reg = qla24xx_read_window(reg, 0x4000, 16, iter_reg);
1291 iter_reg = qla24xx_read_window(reg, 0x4010, 16, iter_reg);
1292 iter_reg = qla24xx_read_window(reg, 0x4020, 16, iter_reg);
1293 iter_reg = qla24xx_read_window(reg, 0x4030, 16, iter_reg);
1294 iter_reg = qla24xx_read_window(reg, 0x4040, 16, iter_reg);
1295 iter_reg = qla24xx_read_window(reg, 0x4050, 16, iter_reg);
1296 iter_reg = qla24xx_read_window(reg, 0x4060, 16, iter_reg);
1297 iter_reg = qla24xx_read_window(reg, 0x4070, 16, iter_reg);
1298 iter_reg = qla24xx_read_window(reg, 0x4080, 16, iter_reg);
1299 iter_reg = qla24xx_read_window(reg, 0x4090, 16, iter_reg);
1300 iter_reg = qla24xx_read_window(reg, 0x40A0, 16, iter_reg);
1301 qla24xx_read_window(reg, 0x40B0, 16, iter_reg);
1303 /* Frame Buffer registers. */
1304 iter_reg = fw->fb_hdw_reg;
1305 iter_reg = qla24xx_read_window(reg, 0x6000, 16, iter_reg);
1306 iter_reg = qla24xx_read_window(reg, 0x6010, 16, iter_reg);
1307 iter_reg = qla24xx_read_window(reg, 0x6020, 16, iter_reg);
1308 iter_reg = qla24xx_read_window(reg, 0x6030, 16, iter_reg);
1309 iter_reg = qla24xx_read_window(reg, 0x6040, 16, iter_reg);
1310 iter_reg = qla24xx_read_window(reg, 0x6100, 16, iter_reg);
1311 iter_reg = qla24xx_read_window(reg, 0x6130, 16, iter_reg);
1312 iter_reg = qla24xx_read_window(reg, 0x6150, 16, iter_reg);
1313 iter_reg = qla24xx_read_window(reg, 0x6170, 16, iter_reg);
1314 iter_reg = qla24xx_read_window(reg, 0x6190, 16, iter_reg);
1315 qla24xx_read_window(reg, 0x61B0, 16, iter_reg);
1317 rval = qla24xx_soft_reset(ha);
1318 if (rval != QLA_SUCCESS)
1319 goto qla24xx_fw_dump_failed_0;
1321 rval = qla24xx_dump_memory(ha, fw->code_ram, sizeof(fw->code_ram),
1323 if (rval != QLA_SUCCESS)
1324 goto qla24xx_fw_dump_failed_0;
1326 nxt = qla2xxx_copy_queues(ha, nxt);
1328 qla24xx_copy_eft(ha, nxt);
1330 nxt_chain = (void *)ha->fw_dump + ha->chain_offset;
1331 nxt_chain = qla2xxx_copy_atioqueues(ha, nxt_chain, &last_chain);
1333 ha->fw_dump->version |= htonl(DUMP_CHAIN_VARIANT);
1334 *last_chain |= htonl(DUMP_CHAIN_LAST);
1337 /* Adjust valid length. */
1338 ha->fw_dump_len = (nxt_chain - (void *)ha->fw_dump);
1340 qla24xx_fw_dump_failed_0:
1341 qla2xxx_dump_post_process(base_vha, rval);
1343 qla24xx_fw_dump_failed:
1345 if (!hardware_locked)
1346 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1353 qla25xx_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
1357 struct qla_hw_data *ha = vha->hw;
1358 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1359 uint32_t __iomem *dmp_reg;
1361 uint16_t __iomem *mbx_reg;
1362 unsigned long flags;
1363 struct qla25xx_fw_dump *fw;
1364 void *nxt, *nxt_chain;
1365 uint32_t *last_chain = NULL;
1366 struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
1369 ha->fw_dump_cap_flags = 0;
1372 if (!hardware_locked)
1373 spin_lock_irqsave(&ha->hardware_lock, flags);
1377 ql_log(ql_log_warn, vha, 0xd008,
1378 "No buffer available for dump.\n");
1379 goto qla25xx_fw_dump_failed;
1382 if (ha->fw_dumped) {
1383 ql_log(ql_log_warn, vha, 0xd009,
1384 "Firmware has been previously dumped (%p) "
1385 "-- ignoring request.\n",
1387 goto qla25xx_fw_dump_failed;
1390 fw = &ha->fw_dump->isp.isp25;
1391 qla2xxx_prep_dump(ha, ha->fw_dump);
1392 ha->fw_dump->version = htonl(2);
1394 fw->host_status = htonl(RD_REG_DWORD(®->host_status));
1397 * Pause RISC. No need to track timeout, as resetting the chip
1398 * is the right approach incase of pause timeout
1400 qla24xx_pause_risc(reg, ha);
1402 /* Host/Risc registers. */
1403 iter_reg = fw->host_risc_reg;
1404 iter_reg = qla24xx_read_window(reg, 0x7000, 16, iter_reg);
1405 qla24xx_read_window(reg, 0x7010, 16, iter_reg);
1407 /* PCIe registers. */
1408 WRT_REG_DWORD(®->iobase_addr, 0x7C00);
1409 RD_REG_DWORD(®->iobase_addr);
1410 WRT_REG_DWORD(®->iobase_window, 0x01);
1411 dmp_reg = ®->iobase_c4;
1412 fw->pcie_regs[0] = htonl(RD_REG_DWORD(dmp_reg));
1414 fw->pcie_regs[1] = htonl(RD_REG_DWORD(dmp_reg));
1416 fw->pcie_regs[2] = htonl(RD_REG_DWORD(dmp_reg));
1417 fw->pcie_regs[3] = htonl(RD_REG_DWORD(®->iobase_window));
1419 WRT_REG_DWORD(®->iobase_window, 0x00);
1420 RD_REG_DWORD(®->iobase_window);
1422 /* Host interface registers. */
1423 dmp_reg = ®->flash_addr;
1424 for (cnt = 0; cnt < sizeof(fw->host_reg) / 4; cnt++, dmp_reg++)
1425 fw->host_reg[cnt] = htonl(RD_REG_DWORD(dmp_reg));
1427 /* Disable interrupts. */
1428 WRT_REG_DWORD(®->ictrl, 0);
1429 RD_REG_DWORD(®->ictrl);
1431 /* Shadow registers. */
1432 WRT_REG_DWORD(®->iobase_addr, 0x0F70);
1433 RD_REG_DWORD(®->iobase_addr);
1434 WRT_REG_DWORD(®->iobase_select, 0xB0000000);
1435 fw->shadow_reg[0] = htonl(RD_REG_DWORD(®->iobase_sdata));
1437 WRT_REG_DWORD(®->iobase_select, 0xB0100000);
1438 fw->shadow_reg[1] = htonl(RD_REG_DWORD(®->iobase_sdata));
1440 WRT_REG_DWORD(®->iobase_select, 0xB0200000);
1441 fw->shadow_reg[2] = htonl(RD_REG_DWORD(®->iobase_sdata));
1443 WRT_REG_DWORD(®->iobase_select, 0xB0300000);
1444 fw->shadow_reg[3] = htonl(RD_REG_DWORD(®->iobase_sdata));
1446 WRT_REG_DWORD(®->iobase_select, 0xB0400000);
1447 fw->shadow_reg[4] = htonl(RD_REG_DWORD(®->iobase_sdata));
1449 WRT_REG_DWORD(®->iobase_select, 0xB0500000);
1450 fw->shadow_reg[5] = htonl(RD_REG_DWORD(®->iobase_sdata));
1452 WRT_REG_DWORD(®->iobase_select, 0xB0600000);
1453 fw->shadow_reg[6] = htonl(RD_REG_DWORD(®->iobase_sdata));
1455 WRT_REG_DWORD(®->iobase_select, 0xB0700000);
1456 fw->shadow_reg[7] = htonl(RD_REG_DWORD(®->iobase_sdata));
1458 WRT_REG_DWORD(®->iobase_select, 0xB0800000);
1459 fw->shadow_reg[8] = htonl(RD_REG_DWORD(®->iobase_sdata));
1461 WRT_REG_DWORD(®->iobase_select, 0xB0900000);
1462 fw->shadow_reg[9] = htonl(RD_REG_DWORD(®->iobase_sdata));
1464 WRT_REG_DWORD(®->iobase_select, 0xB0A00000);
1465 fw->shadow_reg[10] = htonl(RD_REG_DWORD(®->iobase_sdata));
1467 /* RISC I/O register. */
1468 WRT_REG_DWORD(®->iobase_addr, 0x0010);
1469 fw->risc_io_reg = htonl(RD_REG_DWORD(®->iobase_window));
1471 /* Mailbox registers. */
1472 mbx_reg = ®->mailbox0;
1473 for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2; cnt++, mbx_reg++)
1474 fw->mailbox_reg[cnt] = htons(RD_REG_WORD(mbx_reg));
1476 /* Transfer sequence registers. */
1477 iter_reg = fw->xseq_gp_reg;
1478 iter_reg = qla24xx_read_window(reg, 0xBF00, 16, iter_reg);
1479 iter_reg = qla24xx_read_window(reg, 0xBF10, 16, iter_reg);
1480 iter_reg = qla24xx_read_window(reg, 0xBF20, 16, iter_reg);
1481 iter_reg = qla24xx_read_window(reg, 0xBF30, 16, iter_reg);
1482 iter_reg = qla24xx_read_window(reg, 0xBF40, 16, iter_reg);
1483 iter_reg = qla24xx_read_window(reg, 0xBF50, 16, iter_reg);
1484 iter_reg = qla24xx_read_window(reg, 0xBF60, 16, iter_reg);
1485 qla24xx_read_window(reg, 0xBF70, 16, iter_reg);
1487 iter_reg = fw->xseq_0_reg;
1488 iter_reg = qla24xx_read_window(reg, 0xBFC0, 16, iter_reg);
1489 iter_reg = qla24xx_read_window(reg, 0xBFD0, 16, iter_reg);
1490 qla24xx_read_window(reg, 0xBFE0, 16, iter_reg);
1492 qla24xx_read_window(reg, 0xBFF0, 16, fw->xseq_1_reg);
1494 /* Receive sequence registers. */
1495 iter_reg = fw->rseq_gp_reg;
1496 iter_reg = qla24xx_read_window(reg, 0xFF00, 16, iter_reg);
1497 iter_reg = qla24xx_read_window(reg, 0xFF10, 16, iter_reg);
1498 iter_reg = qla24xx_read_window(reg, 0xFF20, 16, iter_reg);
1499 iter_reg = qla24xx_read_window(reg, 0xFF30, 16, iter_reg);
1500 iter_reg = qla24xx_read_window(reg, 0xFF40, 16, iter_reg);
1501 iter_reg = qla24xx_read_window(reg, 0xFF50, 16, iter_reg);
1502 iter_reg = qla24xx_read_window(reg, 0xFF60, 16, iter_reg);
1503 qla24xx_read_window(reg, 0xFF70, 16, iter_reg);
1505 iter_reg = fw->rseq_0_reg;
1506 iter_reg = qla24xx_read_window(reg, 0xFFC0, 16, iter_reg);
1507 qla24xx_read_window(reg, 0xFFD0, 16, iter_reg);
1509 qla24xx_read_window(reg, 0xFFE0, 16, fw->rseq_1_reg);
1510 qla24xx_read_window(reg, 0xFFF0, 16, fw->rseq_2_reg);
1512 /* Auxiliary sequence registers. */
1513 iter_reg = fw->aseq_gp_reg;
1514 iter_reg = qla24xx_read_window(reg, 0xB000, 16, iter_reg);
1515 iter_reg = qla24xx_read_window(reg, 0xB010, 16, iter_reg);
1516 iter_reg = qla24xx_read_window(reg, 0xB020, 16, iter_reg);
1517 iter_reg = qla24xx_read_window(reg, 0xB030, 16, iter_reg);
1518 iter_reg = qla24xx_read_window(reg, 0xB040, 16, iter_reg);
1519 iter_reg = qla24xx_read_window(reg, 0xB050, 16, iter_reg);
1520 iter_reg = qla24xx_read_window(reg, 0xB060, 16, iter_reg);
1521 qla24xx_read_window(reg, 0xB070, 16, iter_reg);
1523 iter_reg = fw->aseq_0_reg;
1524 iter_reg = qla24xx_read_window(reg, 0xB0C0, 16, iter_reg);
1525 qla24xx_read_window(reg, 0xB0D0, 16, iter_reg);
1527 qla24xx_read_window(reg, 0xB0E0, 16, fw->aseq_1_reg);
1528 qla24xx_read_window(reg, 0xB0F0, 16, fw->aseq_2_reg);
1530 /* Command DMA registers. */
1531 qla24xx_read_window(reg, 0x7100, 16, fw->cmd_dma_reg);
1534 iter_reg = fw->req0_dma_reg;
1535 iter_reg = qla24xx_read_window(reg, 0x7200, 8, iter_reg);
1536 dmp_reg = ®->iobase_q;
1537 for (cnt = 0; cnt < 7; cnt++, dmp_reg++)
1538 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg));
1540 iter_reg = fw->resp0_dma_reg;
1541 iter_reg = qla24xx_read_window(reg, 0x7300, 8, iter_reg);
1542 dmp_reg = ®->iobase_q;
1543 for (cnt = 0; cnt < 7; cnt++, dmp_reg++)
1544 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg));
1546 iter_reg = fw->req1_dma_reg;
1547 iter_reg = qla24xx_read_window(reg, 0x7400, 8, iter_reg);
1548 dmp_reg = ®->iobase_q;
1549 for (cnt = 0; cnt < 7; cnt++, dmp_reg++)
1550 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg));
1552 /* Transmit DMA registers. */
1553 iter_reg = fw->xmt0_dma_reg;
1554 iter_reg = qla24xx_read_window(reg, 0x7600, 16, iter_reg);
1555 qla24xx_read_window(reg, 0x7610, 16, iter_reg);
1557 iter_reg = fw->xmt1_dma_reg;
1558 iter_reg = qla24xx_read_window(reg, 0x7620, 16, iter_reg);
1559 qla24xx_read_window(reg, 0x7630, 16, iter_reg);
1561 iter_reg = fw->xmt2_dma_reg;
1562 iter_reg = qla24xx_read_window(reg, 0x7640, 16, iter_reg);
1563 qla24xx_read_window(reg, 0x7650, 16, iter_reg);
1565 iter_reg = fw->xmt3_dma_reg;
1566 iter_reg = qla24xx_read_window(reg, 0x7660, 16, iter_reg);
1567 qla24xx_read_window(reg, 0x7670, 16, iter_reg);
1569 iter_reg = fw->xmt4_dma_reg;
1570 iter_reg = qla24xx_read_window(reg, 0x7680, 16, iter_reg);
1571 qla24xx_read_window(reg, 0x7690, 16, iter_reg);
1573 qla24xx_read_window(reg, 0x76A0, 16, fw->xmt_data_dma_reg);
1575 /* Receive DMA registers. */
1576 iter_reg = fw->rcvt0_data_dma_reg;
1577 iter_reg = qla24xx_read_window(reg, 0x7700, 16, iter_reg);
1578 qla24xx_read_window(reg, 0x7710, 16, iter_reg);
1580 iter_reg = fw->rcvt1_data_dma_reg;
1581 iter_reg = qla24xx_read_window(reg, 0x7720, 16, iter_reg);
1582 qla24xx_read_window(reg, 0x7730, 16, iter_reg);
1584 /* RISC registers. */
1585 iter_reg = fw->risc_gp_reg;
1586 iter_reg = qla24xx_read_window(reg, 0x0F00, 16, iter_reg);
1587 iter_reg = qla24xx_read_window(reg, 0x0F10, 16, iter_reg);
1588 iter_reg = qla24xx_read_window(reg, 0x0F20, 16, iter_reg);
1589 iter_reg = qla24xx_read_window(reg, 0x0F30, 16, iter_reg);
1590 iter_reg = qla24xx_read_window(reg, 0x0F40, 16, iter_reg);
1591 iter_reg = qla24xx_read_window(reg, 0x0F50, 16, iter_reg);
1592 iter_reg = qla24xx_read_window(reg, 0x0F60, 16, iter_reg);
1593 qla24xx_read_window(reg, 0x0F70, 16, iter_reg);
1595 /* Local memory controller registers. */
1596 iter_reg = fw->lmc_reg;
1597 iter_reg = qla24xx_read_window(reg, 0x3000, 16, iter_reg);
1598 iter_reg = qla24xx_read_window(reg, 0x3010, 16, iter_reg);
1599 iter_reg = qla24xx_read_window(reg, 0x3020, 16, iter_reg);
1600 iter_reg = qla24xx_read_window(reg, 0x3030, 16, iter_reg);
1601 iter_reg = qla24xx_read_window(reg, 0x3040, 16, iter_reg);
1602 iter_reg = qla24xx_read_window(reg, 0x3050, 16, iter_reg);
1603 iter_reg = qla24xx_read_window(reg, 0x3060, 16, iter_reg);
1604 qla24xx_read_window(reg, 0x3070, 16, iter_reg);
1606 /* Fibre Protocol Module registers. */
1607 iter_reg = fw->fpm_hdw_reg;
1608 iter_reg = qla24xx_read_window(reg, 0x4000, 16, iter_reg);
1609 iter_reg = qla24xx_read_window(reg, 0x4010, 16, iter_reg);
1610 iter_reg = qla24xx_read_window(reg, 0x4020, 16, iter_reg);
1611 iter_reg = qla24xx_read_window(reg, 0x4030, 16, iter_reg);
1612 iter_reg = qla24xx_read_window(reg, 0x4040, 16, iter_reg);
1613 iter_reg = qla24xx_read_window(reg, 0x4050, 16, iter_reg);
1614 iter_reg = qla24xx_read_window(reg, 0x4060, 16, iter_reg);
1615 iter_reg = qla24xx_read_window(reg, 0x4070, 16, iter_reg);
1616 iter_reg = qla24xx_read_window(reg, 0x4080, 16, iter_reg);
1617 iter_reg = qla24xx_read_window(reg, 0x4090, 16, iter_reg);
1618 iter_reg = qla24xx_read_window(reg, 0x40A0, 16, iter_reg);
1619 qla24xx_read_window(reg, 0x40B0, 16, iter_reg);
1621 /* Frame Buffer registers. */
1622 iter_reg = fw->fb_hdw_reg;
1623 iter_reg = qla24xx_read_window(reg, 0x6000, 16, iter_reg);
1624 iter_reg = qla24xx_read_window(reg, 0x6010, 16, iter_reg);
1625 iter_reg = qla24xx_read_window(reg, 0x6020, 16, iter_reg);
1626 iter_reg = qla24xx_read_window(reg, 0x6030, 16, iter_reg);
1627 iter_reg = qla24xx_read_window(reg, 0x6040, 16, iter_reg);
1628 iter_reg = qla24xx_read_window(reg, 0x6100, 16, iter_reg);
1629 iter_reg = qla24xx_read_window(reg, 0x6130, 16, iter_reg);
1630 iter_reg = qla24xx_read_window(reg, 0x6150, 16, iter_reg);
1631 iter_reg = qla24xx_read_window(reg, 0x6170, 16, iter_reg);
1632 iter_reg = qla24xx_read_window(reg, 0x6190, 16, iter_reg);
1633 iter_reg = qla24xx_read_window(reg, 0x61B0, 16, iter_reg);
1634 qla24xx_read_window(reg, 0x6F00, 16, iter_reg);
1636 /* Multi queue registers */
1637 nxt_chain = qla25xx_copy_mq(ha, (void *)ha->fw_dump + ha->chain_offset,
1640 rval = qla24xx_soft_reset(ha);
1641 if (rval != QLA_SUCCESS)
1642 goto qla25xx_fw_dump_failed_0;
1644 rval = qla24xx_dump_memory(ha, fw->code_ram, sizeof(fw->code_ram),
1646 if (rval != QLA_SUCCESS)
1647 goto qla25xx_fw_dump_failed_0;
1649 nxt = qla2xxx_copy_queues(ha, nxt);
1651 qla24xx_copy_eft(ha, nxt);
1653 /* Chain entries -- started with MQ. */
1654 nxt_chain = qla25xx_copy_fce(ha, nxt_chain, &last_chain);
1655 nxt_chain = qla25xx_copy_mqueues(ha, nxt_chain, &last_chain);
1656 nxt_chain = qla2xxx_copy_atioqueues(ha, nxt_chain, &last_chain);
1657 nxt_chain = qla25xx_copy_exlogin(ha, nxt_chain, &last_chain);
1659 ha->fw_dump->version |= htonl(DUMP_CHAIN_VARIANT);
1660 *last_chain |= htonl(DUMP_CHAIN_LAST);
1663 /* Adjust valid length. */
1664 ha->fw_dump_len = (nxt_chain - (void *)ha->fw_dump);
1666 qla25xx_fw_dump_failed_0:
1667 qla2xxx_dump_post_process(base_vha, rval);
1669 qla25xx_fw_dump_failed:
1671 if (!hardware_locked)
1672 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1679 qla81xx_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
1683 struct qla_hw_data *ha = vha->hw;
1684 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1685 uint32_t __iomem *dmp_reg;
1687 uint16_t __iomem *mbx_reg;
1688 unsigned long flags;
1689 struct qla81xx_fw_dump *fw;
1690 void *nxt, *nxt_chain;
1691 uint32_t *last_chain = NULL;
1692 struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
1695 ha->fw_dump_cap_flags = 0;
1698 if (!hardware_locked)
1699 spin_lock_irqsave(&ha->hardware_lock, flags);
1703 ql_log(ql_log_warn, vha, 0xd00a,
1704 "No buffer available for dump.\n");
1705 goto qla81xx_fw_dump_failed;
1708 if (ha->fw_dumped) {
1709 ql_log(ql_log_warn, vha, 0xd00b,
1710 "Firmware has been previously dumped (%p) "
1711 "-- ignoring request.\n",
1713 goto qla81xx_fw_dump_failed;
1715 fw = &ha->fw_dump->isp.isp81;
1716 qla2xxx_prep_dump(ha, ha->fw_dump);
1718 fw->host_status = htonl(RD_REG_DWORD(®->host_status));
1721 * Pause RISC. No need to track timeout, as resetting the chip
1722 * is the right approach incase of pause timeout
1724 qla24xx_pause_risc(reg, ha);
1726 /* Host/Risc registers. */
1727 iter_reg = fw->host_risc_reg;
1728 iter_reg = qla24xx_read_window(reg, 0x7000, 16, iter_reg);
1729 qla24xx_read_window(reg, 0x7010, 16, iter_reg);
1731 /* PCIe registers. */
1732 WRT_REG_DWORD(®->iobase_addr, 0x7C00);
1733 RD_REG_DWORD(®->iobase_addr);
1734 WRT_REG_DWORD(®->iobase_window, 0x01);
1735 dmp_reg = ®->iobase_c4;
1736 fw->pcie_regs[0] = htonl(RD_REG_DWORD(dmp_reg));
1738 fw->pcie_regs[1] = htonl(RD_REG_DWORD(dmp_reg));
1740 fw->pcie_regs[2] = htonl(RD_REG_DWORD(dmp_reg));
1741 fw->pcie_regs[3] = htonl(RD_REG_DWORD(®->iobase_window));
1743 WRT_REG_DWORD(®->iobase_window, 0x00);
1744 RD_REG_DWORD(®->iobase_window);
1746 /* Host interface registers. */
1747 dmp_reg = ®->flash_addr;
1748 for (cnt = 0; cnt < sizeof(fw->host_reg) / 4; cnt++, dmp_reg++)
1749 fw->host_reg[cnt] = htonl(RD_REG_DWORD(dmp_reg));
1751 /* Disable interrupts. */
1752 WRT_REG_DWORD(®->ictrl, 0);
1753 RD_REG_DWORD(®->ictrl);
1755 /* Shadow registers. */
1756 WRT_REG_DWORD(®->iobase_addr, 0x0F70);
1757 RD_REG_DWORD(®->iobase_addr);
1758 WRT_REG_DWORD(®->iobase_select, 0xB0000000);
1759 fw->shadow_reg[0] = htonl(RD_REG_DWORD(®->iobase_sdata));
1761 WRT_REG_DWORD(®->iobase_select, 0xB0100000);
1762 fw->shadow_reg[1] = htonl(RD_REG_DWORD(®->iobase_sdata));
1764 WRT_REG_DWORD(®->iobase_select, 0xB0200000);
1765 fw->shadow_reg[2] = htonl(RD_REG_DWORD(®->iobase_sdata));
1767 WRT_REG_DWORD(®->iobase_select, 0xB0300000);
1768 fw->shadow_reg[3] = htonl(RD_REG_DWORD(®->iobase_sdata));
1770 WRT_REG_DWORD(®->iobase_select, 0xB0400000);
1771 fw->shadow_reg[4] = htonl(RD_REG_DWORD(®->iobase_sdata));
1773 WRT_REG_DWORD(®->iobase_select, 0xB0500000);
1774 fw->shadow_reg[5] = htonl(RD_REG_DWORD(®->iobase_sdata));
1776 WRT_REG_DWORD(®->iobase_select, 0xB0600000);
1777 fw->shadow_reg[6] = htonl(RD_REG_DWORD(®->iobase_sdata));
1779 WRT_REG_DWORD(®->iobase_select, 0xB0700000);
1780 fw->shadow_reg[7] = htonl(RD_REG_DWORD(®->iobase_sdata));
1782 WRT_REG_DWORD(®->iobase_select, 0xB0800000);
1783 fw->shadow_reg[8] = htonl(RD_REG_DWORD(®->iobase_sdata));
1785 WRT_REG_DWORD(®->iobase_select, 0xB0900000);
1786 fw->shadow_reg[9] = htonl(RD_REG_DWORD(®->iobase_sdata));
1788 WRT_REG_DWORD(®->iobase_select, 0xB0A00000);
1789 fw->shadow_reg[10] = htonl(RD_REG_DWORD(®->iobase_sdata));
1791 /* RISC I/O register. */
1792 WRT_REG_DWORD(®->iobase_addr, 0x0010);
1793 fw->risc_io_reg = htonl(RD_REG_DWORD(®->iobase_window));
1795 /* Mailbox registers. */
1796 mbx_reg = ®->mailbox0;
1797 for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2; cnt++, mbx_reg++)
1798 fw->mailbox_reg[cnt] = htons(RD_REG_WORD(mbx_reg));
1800 /* Transfer sequence registers. */
1801 iter_reg = fw->xseq_gp_reg;
1802 iter_reg = qla24xx_read_window(reg, 0xBF00, 16, iter_reg);
1803 iter_reg = qla24xx_read_window(reg, 0xBF10, 16, iter_reg);
1804 iter_reg = qla24xx_read_window(reg, 0xBF20, 16, iter_reg);
1805 iter_reg = qla24xx_read_window(reg, 0xBF30, 16, iter_reg);
1806 iter_reg = qla24xx_read_window(reg, 0xBF40, 16, iter_reg);
1807 iter_reg = qla24xx_read_window(reg, 0xBF50, 16, iter_reg);
1808 iter_reg = qla24xx_read_window(reg, 0xBF60, 16, iter_reg);
1809 qla24xx_read_window(reg, 0xBF70, 16, iter_reg);
1811 iter_reg = fw->xseq_0_reg;
1812 iter_reg = qla24xx_read_window(reg, 0xBFC0, 16, iter_reg);
1813 iter_reg = qla24xx_read_window(reg, 0xBFD0, 16, iter_reg);
1814 qla24xx_read_window(reg, 0xBFE0, 16, iter_reg);
1816 qla24xx_read_window(reg, 0xBFF0, 16, fw->xseq_1_reg);
1818 /* Receive sequence registers. */
1819 iter_reg = fw->rseq_gp_reg;
1820 iter_reg = qla24xx_read_window(reg, 0xFF00, 16, iter_reg);
1821 iter_reg = qla24xx_read_window(reg, 0xFF10, 16, iter_reg);
1822 iter_reg = qla24xx_read_window(reg, 0xFF20, 16, iter_reg);
1823 iter_reg = qla24xx_read_window(reg, 0xFF30, 16, iter_reg);
1824 iter_reg = qla24xx_read_window(reg, 0xFF40, 16, iter_reg);
1825 iter_reg = qla24xx_read_window(reg, 0xFF50, 16, iter_reg);
1826 iter_reg = qla24xx_read_window(reg, 0xFF60, 16, iter_reg);
1827 qla24xx_read_window(reg, 0xFF70, 16, iter_reg);
1829 iter_reg = fw->rseq_0_reg;
1830 iter_reg = qla24xx_read_window(reg, 0xFFC0, 16, iter_reg);
1831 qla24xx_read_window(reg, 0xFFD0, 16, iter_reg);
1833 qla24xx_read_window(reg, 0xFFE0, 16, fw->rseq_1_reg);
1834 qla24xx_read_window(reg, 0xFFF0, 16, fw->rseq_2_reg);
1836 /* Auxiliary sequence registers. */
1837 iter_reg = fw->aseq_gp_reg;
1838 iter_reg = qla24xx_read_window(reg, 0xB000, 16, iter_reg);
1839 iter_reg = qla24xx_read_window(reg, 0xB010, 16, iter_reg);
1840 iter_reg = qla24xx_read_window(reg, 0xB020, 16, iter_reg);
1841 iter_reg = qla24xx_read_window(reg, 0xB030, 16, iter_reg);
1842 iter_reg = qla24xx_read_window(reg, 0xB040, 16, iter_reg);
1843 iter_reg = qla24xx_read_window(reg, 0xB050, 16, iter_reg);
1844 iter_reg = qla24xx_read_window(reg, 0xB060, 16, iter_reg);
1845 qla24xx_read_window(reg, 0xB070, 16, iter_reg);
1847 iter_reg = fw->aseq_0_reg;
1848 iter_reg = qla24xx_read_window(reg, 0xB0C0, 16, iter_reg);
1849 qla24xx_read_window(reg, 0xB0D0, 16, iter_reg);
1851 qla24xx_read_window(reg, 0xB0E0, 16, fw->aseq_1_reg);
1852 qla24xx_read_window(reg, 0xB0F0, 16, fw->aseq_2_reg);
1854 /* Command DMA registers. */
1855 qla24xx_read_window(reg, 0x7100, 16, fw->cmd_dma_reg);
1858 iter_reg = fw->req0_dma_reg;
1859 iter_reg = qla24xx_read_window(reg, 0x7200, 8, iter_reg);
1860 dmp_reg = ®->iobase_q;
1861 for (cnt = 0; cnt < 7; cnt++, dmp_reg++)
1862 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg));
1864 iter_reg = fw->resp0_dma_reg;
1865 iter_reg = qla24xx_read_window(reg, 0x7300, 8, iter_reg);
1866 dmp_reg = ®->iobase_q;
1867 for (cnt = 0; cnt < 7; cnt++, dmp_reg++)
1868 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg));
1870 iter_reg = fw->req1_dma_reg;
1871 iter_reg = qla24xx_read_window(reg, 0x7400, 8, iter_reg);
1872 dmp_reg = ®->iobase_q;
1873 for (cnt = 0; cnt < 7; cnt++, dmp_reg++)
1874 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg));
1876 /* Transmit DMA registers. */
1877 iter_reg = fw->xmt0_dma_reg;
1878 iter_reg = qla24xx_read_window(reg, 0x7600, 16, iter_reg);
1879 qla24xx_read_window(reg, 0x7610, 16, iter_reg);
1881 iter_reg = fw->xmt1_dma_reg;
1882 iter_reg = qla24xx_read_window(reg, 0x7620, 16, iter_reg);
1883 qla24xx_read_window(reg, 0x7630, 16, iter_reg);
1885 iter_reg = fw->xmt2_dma_reg;
1886 iter_reg = qla24xx_read_window(reg, 0x7640, 16, iter_reg);
1887 qla24xx_read_window(reg, 0x7650, 16, iter_reg);
1889 iter_reg = fw->xmt3_dma_reg;
1890 iter_reg = qla24xx_read_window(reg, 0x7660, 16, iter_reg);
1891 qla24xx_read_window(reg, 0x7670, 16, iter_reg);
1893 iter_reg = fw->xmt4_dma_reg;
1894 iter_reg = qla24xx_read_window(reg, 0x7680, 16, iter_reg);
1895 qla24xx_read_window(reg, 0x7690, 16, iter_reg);
1897 qla24xx_read_window(reg, 0x76A0, 16, fw->xmt_data_dma_reg);
1899 /* Receive DMA registers. */
1900 iter_reg = fw->rcvt0_data_dma_reg;
1901 iter_reg = qla24xx_read_window(reg, 0x7700, 16, iter_reg);
1902 qla24xx_read_window(reg, 0x7710, 16, iter_reg);
1904 iter_reg = fw->rcvt1_data_dma_reg;
1905 iter_reg = qla24xx_read_window(reg, 0x7720, 16, iter_reg);
1906 qla24xx_read_window(reg, 0x7730, 16, iter_reg);
1908 /* RISC registers. */
1909 iter_reg = fw->risc_gp_reg;
1910 iter_reg = qla24xx_read_window(reg, 0x0F00, 16, iter_reg);
1911 iter_reg = qla24xx_read_window(reg, 0x0F10, 16, iter_reg);
1912 iter_reg = qla24xx_read_window(reg, 0x0F20, 16, iter_reg);
1913 iter_reg = qla24xx_read_window(reg, 0x0F30, 16, iter_reg);
1914 iter_reg = qla24xx_read_window(reg, 0x0F40, 16, iter_reg);
1915 iter_reg = qla24xx_read_window(reg, 0x0F50, 16, iter_reg);
1916 iter_reg = qla24xx_read_window(reg, 0x0F60, 16, iter_reg);
1917 qla24xx_read_window(reg, 0x0F70, 16, iter_reg);
1919 /* Local memory controller registers. */
1920 iter_reg = fw->lmc_reg;
1921 iter_reg = qla24xx_read_window(reg, 0x3000, 16, iter_reg);
1922 iter_reg = qla24xx_read_window(reg, 0x3010, 16, iter_reg);
1923 iter_reg = qla24xx_read_window(reg, 0x3020, 16, iter_reg);
1924 iter_reg = qla24xx_read_window(reg, 0x3030, 16, iter_reg);
1925 iter_reg = qla24xx_read_window(reg, 0x3040, 16, iter_reg);
1926 iter_reg = qla24xx_read_window(reg, 0x3050, 16, iter_reg);
1927 iter_reg = qla24xx_read_window(reg, 0x3060, 16, iter_reg);
1928 qla24xx_read_window(reg, 0x3070, 16, iter_reg);
1930 /* Fibre Protocol Module registers. */
1931 iter_reg = fw->fpm_hdw_reg;
1932 iter_reg = qla24xx_read_window(reg, 0x4000, 16, iter_reg);
1933 iter_reg = qla24xx_read_window(reg, 0x4010, 16, iter_reg);
1934 iter_reg = qla24xx_read_window(reg, 0x4020, 16, iter_reg);
1935 iter_reg = qla24xx_read_window(reg, 0x4030, 16, iter_reg);
1936 iter_reg = qla24xx_read_window(reg, 0x4040, 16, iter_reg);
1937 iter_reg = qla24xx_read_window(reg, 0x4050, 16, iter_reg);
1938 iter_reg = qla24xx_read_window(reg, 0x4060, 16, iter_reg);
1939 iter_reg = qla24xx_read_window(reg, 0x4070, 16, iter_reg);
1940 iter_reg = qla24xx_read_window(reg, 0x4080, 16, iter_reg);
1941 iter_reg = qla24xx_read_window(reg, 0x4090, 16, iter_reg);
1942 iter_reg = qla24xx_read_window(reg, 0x40A0, 16, iter_reg);
1943 iter_reg = qla24xx_read_window(reg, 0x40B0, 16, iter_reg);
1944 iter_reg = qla24xx_read_window(reg, 0x40C0, 16, iter_reg);
1945 qla24xx_read_window(reg, 0x40D0, 16, iter_reg);
1947 /* Frame Buffer registers. */
1948 iter_reg = fw->fb_hdw_reg;
1949 iter_reg = qla24xx_read_window(reg, 0x6000, 16, iter_reg);
1950 iter_reg = qla24xx_read_window(reg, 0x6010, 16, iter_reg);
1951 iter_reg = qla24xx_read_window(reg, 0x6020, 16, iter_reg);
1952 iter_reg = qla24xx_read_window(reg, 0x6030, 16, iter_reg);
1953 iter_reg = qla24xx_read_window(reg, 0x6040, 16, iter_reg);
1954 iter_reg = qla24xx_read_window(reg, 0x6100, 16, iter_reg);
1955 iter_reg = qla24xx_read_window(reg, 0x6130, 16, iter_reg);
1956 iter_reg = qla24xx_read_window(reg, 0x6150, 16, iter_reg);
1957 iter_reg = qla24xx_read_window(reg, 0x6170, 16, iter_reg);
1958 iter_reg = qla24xx_read_window(reg, 0x6190, 16, iter_reg);
1959 iter_reg = qla24xx_read_window(reg, 0x61B0, 16, iter_reg);
1960 iter_reg = qla24xx_read_window(reg, 0x61C0, 16, iter_reg);
1961 qla24xx_read_window(reg, 0x6F00, 16, iter_reg);
1963 /* Multi queue registers */
1964 nxt_chain = qla25xx_copy_mq(ha, (void *)ha->fw_dump + ha->chain_offset,
1967 rval = qla24xx_soft_reset(ha);
1968 if (rval != QLA_SUCCESS)
1969 goto qla81xx_fw_dump_failed_0;
1971 rval = qla24xx_dump_memory(ha, fw->code_ram, sizeof(fw->code_ram),
1973 if (rval != QLA_SUCCESS)
1974 goto qla81xx_fw_dump_failed_0;
1976 nxt = qla2xxx_copy_queues(ha, nxt);
1978 qla24xx_copy_eft(ha, nxt);
1980 /* Chain entries -- started with MQ. */
1981 nxt_chain = qla25xx_copy_fce(ha, nxt_chain, &last_chain);
1982 nxt_chain = qla25xx_copy_mqueues(ha, nxt_chain, &last_chain);
1983 nxt_chain = qla2xxx_copy_atioqueues(ha, nxt_chain, &last_chain);
1984 nxt_chain = qla25xx_copy_exlogin(ha, nxt_chain, &last_chain);
1985 nxt_chain = qla81xx_copy_exchoffld(ha, nxt_chain, &last_chain);
1987 ha->fw_dump->version |= htonl(DUMP_CHAIN_VARIANT);
1988 *last_chain |= htonl(DUMP_CHAIN_LAST);
1991 /* Adjust valid length. */
1992 ha->fw_dump_len = (nxt_chain - (void *)ha->fw_dump);
1994 qla81xx_fw_dump_failed_0:
1995 qla2xxx_dump_post_process(base_vha, rval);
1997 qla81xx_fw_dump_failed:
1999 if (!hardware_locked)
2000 spin_unlock_irqrestore(&ha->hardware_lock, flags);
2007 qla83xx_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
2011 struct qla_hw_data *ha = vha->hw;
2012 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
2013 uint32_t __iomem *dmp_reg;
2015 uint16_t __iomem *mbx_reg;
2016 unsigned long flags;
2017 struct qla83xx_fw_dump *fw;
2018 void *nxt, *nxt_chain;
2019 uint32_t *last_chain = NULL;
2020 struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
2023 ha->fw_dump_cap_flags = 0;
2026 if (!hardware_locked)
2027 spin_lock_irqsave(&ha->hardware_lock, flags);
2031 ql_log(ql_log_warn, vha, 0xd00c,
2032 "No buffer available for dump!!!\n");
2033 goto qla83xx_fw_dump_failed;
2036 if (ha->fw_dumped) {
2037 ql_log(ql_log_warn, vha, 0xd00d,
2038 "Firmware has been previously dumped (%p) -- ignoring "
2039 "request...\n", ha->fw_dump);
2040 goto qla83xx_fw_dump_failed;
2043 fw = &ha->fw_dump->isp.isp83;
2044 qla2xxx_prep_dump(ha, ha->fw_dump);
2046 fw->host_status = htonl(RD_REG_DWORD(®->host_status));
2049 * Pause RISC. No need to track timeout, as resetting the chip
2050 * is the right approach incase of pause timeout
2052 qla24xx_pause_risc(reg, ha);
2054 WRT_REG_DWORD(®->iobase_addr, 0x6000);
2055 dmp_reg = ®->iobase_window;
2056 RD_REG_DWORD(dmp_reg);
2057 WRT_REG_DWORD(dmp_reg, 0);
2059 dmp_reg = ®->unused_4_1[0];
2060 RD_REG_DWORD(dmp_reg);
2061 WRT_REG_DWORD(dmp_reg, 0);
2063 WRT_REG_DWORD(®->iobase_addr, 0x6010);
2064 dmp_reg = ®->unused_4_1[2];
2065 RD_REG_DWORD(dmp_reg);
2066 WRT_REG_DWORD(dmp_reg, 0);
2068 /* select PCR and disable ecc checking and correction */
2069 WRT_REG_DWORD(®->iobase_addr, 0x0F70);
2070 RD_REG_DWORD(®->iobase_addr);
2071 WRT_REG_DWORD(®->iobase_select, 0x60000000); /* write to F0h = PCR */
2073 /* Host/Risc registers. */
2074 iter_reg = fw->host_risc_reg;
2075 iter_reg = qla24xx_read_window(reg, 0x7000, 16, iter_reg);
2076 iter_reg = qla24xx_read_window(reg, 0x7010, 16, iter_reg);
2077 qla24xx_read_window(reg, 0x7040, 16, iter_reg);
2079 /* PCIe registers. */
2080 WRT_REG_DWORD(®->iobase_addr, 0x7C00);
2081 RD_REG_DWORD(®->iobase_addr);
2082 WRT_REG_DWORD(®->iobase_window, 0x01);
2083 dmp_reg = ®->iobase_c4;
2084 fw->pcie_regs[0] = htonl(RD_REG_DWORD(dmp_reg));
2086 fw->pcie_regs[1] = htonl(RD_REG_DWORD(dmp_reg));
2088 fw->pcie_regs[2] = htonl(RD_REG_DWORD(dmp_reg));
2089 fw->pcie_regs[3] = htonl(RD_REG_DWORD(®->iobase_window));
2091 WRT_REG_DWORD(®->iobase_window, 0x00);
2092 RD_REG_DWORD(®->iobase_window);
2094 /* Host interface registers. */
2095 dmp_reg = ®->flash_addr;
2096 for (cnt = 0; cnt < sizeof(fw->host_reg) / 4; cnt++, dmp_reg++)
2097 fw->host_reg[cnt] = htonl(RD_REG_DWORD(dmp_reg));
2099 /* Disable interrupts. */
2100 WRT_REG_DWORD(®->ictrl, 0);
2101 RD_REG_DWORD(®->ictrl);
2103 /* Shadow registers. */
2104 WRT_REG_DWORD(®->iobase_addr, 0x0F70);
2105 RD_REG_DWORD(®->iobase_addr);
2106 WRT_REG_DWORD(®->iobase_select, 0xB0000000);
2107 fw->shadow_reg[0] = htonl(RD_REG_DWORD(®->iobase_sdata));
2109 WRT_REG_DWORD(®->iobase_select, 0xB0100000);
2110 fw->shadow_reg[1] = htonl(RD_REG_DWORD(®->iobase_sdata));
2112 WRT_REG_DWORD(®->iobase_select, 0xB0200000);
2113 fw->shadow_reg[2] = htonl(RD_REG_DWORD(®->iobase_sdata));
2115 WRT_REG_DWORD(®->iobase_select, 0xB0300000);
2116 fw->shadow_reg[3] = htonl(RD_REG_DWORD(®->iobase_sdata));
2118 WRT_REG_DWORD(®->iobase_select, 0xB0400000);
2119 fw->shadow_reg[4] = htonl(RD_REG_DWORD(®->iobase_sdata));
2121 WRT_REG_DWORD(®->iobase_select, 0xB0500000);
2122 fw->shadow_reg[5] = htonl(RD_REG_DWORD(®->iobase_sdata));
2124 WRT_REG_DWORD(®->iobase_select, 0xB0600000);
2125 fw->shadow_reg[6] = htonl(RD_REG_DWORD(®->iobase_sdata));
2127 WRT_REG_DWORD(®->iobase_select, 0xB0700000);
2128 fw->shadow_reg[7] = htonl(RD_REG_DWORD(®->iobase_sdata));
2130 WRT_REG_DWORD(®->iobase_select, 0xB0800000);
2131 fw->shadow_reg[8] = htonl(RD_REG_DWORD(®->iobase_sdata));
2133 WRT_REG_DWORD(®->iobase_select, 0xB0900000);
2134 fw->shadow_reg[9] = htonl(RD_REG_DWORD(®->iobase_sdata));
2136 WRT_REG_DWORD(®->iobase_select, 0xB0A00000);
2137 fw->shadow_reg[10] = htonl(RD_REG_DWORD(®->iobase_sdata));
2139 /* RISC I/O register. */
2140 WRT_REG_DWORD(®->iobase_addr, 0x0010);
2141 fw->risc_io_reg = htonl(RD_REG_DWORD(®->iobase_window));
2143 /* Mailbox registers. */
2144 mbx_reg = ®->mailbox0;
2145 for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2; cnt++, mbx_reg++)
2146 fw->mailbox_reg[cnt] = htons(RD_REG_WORD(mbx_reg));
2148 /* Transfer sequence registers. */
2149 iter_reg = fw->xseq_gp_reg;
2150 iter_reg = qla24xx_read_window(reg, 0xBE00, 16, iter_reg);
2151 iter_reg = qla24xx_read_window(reg, 0xBE10, 16, iter_reg);
2152 iter_reg = qla24xx_read_window(reg, 0xBE20, 16, iter_reg);
2153 iter_reg = qla24xx_read_window(reg, 0xBE30, 16, iter_reg);
2154 iter_reg = qla24xx_read_window(reg, 0xBE40, 16, iter_reg);
2155 iter_reg = qla24xx_read_window(reg, 0xBE50, 16, iter_reg);
2156 iter_reg = qla24xx_read_window(reg, 0xBE60, 16, iter_reg);
2157 iter_reg = qla24xx_read_window(reg, 0xBE70, 16, iter_reg);
2158 iter_reg = qla24xx_read_window(reg, 0xBF00, 16, iter_reg);
2159 iter_reg = qla24xx_read_window(reg, 0xBF10, 16, iter_reg);
2160 iter_reg = qla24xx_read_window(reg, 0xBF20, 16, iter_reg);
2161 iter_reg = qla24xx_read_window(reg, 0xBF30, 16, iter_reg);
2162 iter_reg = qla24xx_read_window(reg, 0xBF40, 16, iter_reg);
2163 iter_reg = qla24xx_read_window(reg, 0xBF50, 16, iter_reg);
2164 iter_reg = qla24xx_read_window(reg, 0xBF60, 16, iter_reg);
2165 qla24xx_read_window(reg, 0xBF70, 16, iter_reg);
2167 iter_reg = fw->xseq_0_reg;
2168 iter_reg = qla24xx_read_window(reg, 0xBFC0, 16, iter_reg);
2169 iter_reg = qla24xx_read_window(reg, 0xBFD0, 16, iter_reg);
2170 qla24xx_read_window(reg, 0xBFE0, 16, iter_reg);
2172 qla24xx_read_window(reg, 0xBFF0, 16, fw->xseq_1_reg);
2174 qla24xx_read_window(reg, 0xBEF0, 16, fw->xseq_2_reg);
2176 /* Receive sequence registers. */
2177 iter_reg = fw->rseq_gp_reg;
2178 iter_reg = qla24xx_read_window(reg, 0xFE00, 16, iter_reg);
2179 iter_reg = qla24xx_read_window(reg, 0xFE10, 16, iter_reg);
2180 iter_reg = qla24xx_read_window(reg, 0xFE20, 16, iter_reg);
2181 iter_reg = qla24xx_read_window(reg, 0xFE30, 16, iter_reg);
2182 iter_reg = qla24xx_read_window(reg, 0xFE40, 16, iter_reg);
2183 iter_reg = qla24xx_read_window(reg, 0xFE50, 16, iter_reg);
2184 iter_reg = qla24xx_read_window(reg, 0xFE60, 16, iter_reg);
2185 iter_reg = qla24xx_read_window(reg, 0xFE70, 16, iter_reg);
2186 iter_reg = qla24xx_read_window(reg, 0xFF00, 16, iter_reg);
2187 iter_reg = qla24xx_read_window(reg, 0xFF10, 16, iter_reg);
2188 iter_reg = qla24xx_read_window(reg, 0xFF20, 16, iter_reg);
2189 iter_reg = qla24xx_read_window(reg, 0xFF30, 16, iter_reg);
2190 iter_reg = qla24xx_read_window(reg, 0xFF40, 16, iter_reg);
2191 iter_reg = qla24xx_read_window(reg, 0xFF50, 16, iter_reg);
2192 iter_reg = qla24xx_read_window(reg, 0xFF60, 16, iter_reg);
2193 qla24xx_read_window(reg, 0xFF70, 16, iter_reg);
2195 iter_reg = fw->rseq_0_reg;
2196 iter_reg = qla24xx_read_window(reg, 0xFFC0, 16, iter_reg);
2197 qla24xx_read_window(reg, 0xFFD0, 16, iter_reg);
2199 qla24xx_read_window(reg, 0xFFE0, 16, fw->rseq_1_reg);
2200 qla24xx_read_window(reg, 0xFFF0, 16, fw->rseq_2_reg);
2201 qla24xx_read_window(reg, 0xFEF0, 16, fw->rseq_3_reg);
2203 /* Auxiliary sequence registers. */
2204 iter_reg = fw->aseq_gp_reg;
2205 iter_reg = qla24xx_read_window(reg, 0xB000, 16, iter_reg);
2206 iter_reg = qla24xx_read_window(reg, 0xB010, 16, iter_reg);
2207 iter_reg = qla24xx_read_window(reg, 0xB020, 16, iter_reg);
2208 iter_reg = qla24xx_read_window(reg, 0xB030, 16, iter_reg);
2209 iter_reg = qla24xx_read_window(reg, 0xB040, 16, iter_reg);
2210 iter_reg = qla24xx_read_window(reg, 0xB050, 16, iter_reg);
2211 iter_reg = qla24xx_read_window(reg, 0xB060, 16, iter_reg);
2212 iter_reg = qla24xx_read_window(reg, 0xB070, 16, iter_reg);
2213 iter_reg = qla24xx_read_window(reg, 0xB100, 16, iter_reg);
2214 iter_reg = qla24xx_read_window(reg, 0xB110, 16, iter_reg);
2215 iter_reg = qla24xx_read_window(reg, 0xB120, 16, iter_reg);
2216 iter_reg = qla24xx_read_window(reg, 0xB130, 16, iter_reg);
2217 iter_reg = qla24xx_read_window(reg, 0xB140, 16, iter_reg);
2218 iter_reg = qla24xx_read_window(reg, 0xB150, 16, iter_reg);
2219 iter_reg = qla24xx_read_window(reg, 0xB160, 16, iter_reg);
2220 qla24xx_read_window(reg, 0xB170, 16, iter_reg);
2222 iter_reg = fw->aseq_0_reg;
2223 iter_reg = qla24xx_read_window(reg, 0xB0C0, 16, iter_reg);
2224 qla24xx_read_window(reg, 0xB0D0, 16, iter_reg);
2226 qla24xx_read_window(reg, 0xB0E0, 16, fw->aseq_1_reg);
2227 qla24xx_read_window(reg, 0xB0F0, 16, fw->aseq_2_reg);
2228 qla24xx_read_window(reg, 0xB1F0, 16, fw->aseq_3_reg);
2230 /* Command DMA registers. */
2231 iter_reg = fw->cmd_dma_reg;
2232 iter_reg = qla24xx_read_window(reg, 0x7100, 16, iter_reg);
2233 iter_reg = qla24xx_read_window(reg, 0x7120, 16, iter_reg);
2234 iter_reg = qla24xx_read_window(reg, 0x7130, 16, iter_reg);
2235 qla24xx_read_window(reg, 0x71F0, 16, iter_reg);
2238 iter_reg = fw->req0_dma_reg;
2239 iter_reg = qla24xx_read_window(reg, 0x7200, 8, iter_reg);
2240 dmp_reg = ®->iobase_q;
2241 for (cnt = 0; cnt < 7; cnt++, dmp_reg++)
2242 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg));
2244 iter_reg = fw->resp0_dma_reg;
2245 iter_reg = qla24xx_read_window(reg, 0x7300, 8, iter_reg);
2246 dmp_reg = ®->iobase_q;
2247 for (cnt = 0; cnt < 7; cnt++, dmp_reg++)
2248 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg));
2250 iter_reg = fw->req1_dma_reg;
2251 iter_reg = qla24xx_read_window(reg, 0x7400, 8, iter_reg);
2252 dmp_reg = ®->iobase_q;
2253 for (cnt = 0; cnt < 7; cnt++, dmp_reg++)
2254 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg));
2256 /* Transmit DMA registers. */
2257 iter_reg = fw->xmt0_dma_reg;
2258 iter_reg = qla24xx_read_window(reg, 0x7600, 16, iter_reg);
2259 qla24xx_read_window(reg, 0x7610, 16, iter_reg);
2261 iter_reg = fw->xmt1_dma_reg;
2262 iter_reg = qla24xx_read_window(reg, 0x7620, 16, iter_reg);
2263 qla24xx_read_window(reg, 0x7630, 16, iter_reg);
2265 iter_reg = fw->xmt2_dma_reg;
2266 iter_reg = qla24xx_read_window(reg, 0x7640, 16, iter_reg);
2267 qla24xx_read_window(reg, 0x7650, 16, iter_reg);
2269 iter_reg = fw->xmt3_dma_reg;
2270 iter_reg = qla24xx_read_window(reg, 0x7660, 16, iter_reg);
2271 qla24xx_read_window(reg, 0x7670, 16, iter_reg);
2273 iter_reg = fw->xmt4_dma_reg;
2274 iter_reg = qla24xx_read_window(reg, 0x7680, 16, iter_reg);
2275 qla24xx_read_window(reg, 0x7690, 16, iter_reg);
2277 qla24xx_read_window(reg, 0x76A0, 16, fw->xmt_data_dma_reg);
2279 /* Receive DMA registers. */
2280 iter_reg = fw->rcvt0_data_dma_reg;
2281 iter_reg = qla24xx_read_window(reg, 0x7700, 16, iter_reg);
2282 qla24xx_read_window(reg, 0x7710, 16, iter_reg);
2284 iter_reg = fw->rcvt1_data_dma_reg;
2285 iter_reg = qla24xx_read_window(reg, 0x7720, 16, iter_reg);
2286 qla24xx_read_window(reg, 0x7730, 16, iter_reg);
2288 /* RISC registers. */
2289 iter_reg = fw->risc_gp_reg;
2290 iter_reg = qla24xx_read_window(reg, 0x0F00, 16, iter_reg);
2291 iter_reg = qla24xx_read_window(reg, 0x0F10, 16, iter_reg);
2292 iter_reg = qla24xx_read_window(reg, 0x0F20, 16, iter_reg);
2293 iter_reg = qla24xx_read_window(reg, 0x0F30, 16, iter_reg);
2294 iter_reg = qla24xx_read_window(reg, 0x0F40, 16, iter_reg);
2295 iter_reg = qla24xx_read_window(reg, 0x0F50, 16, iter_reg);
2296 iter_reg = qla24xx_read_window(reg, 0x0F60, 16, iter_reg);
2297 qla24xx_read_window(reg, 0x0F70, 16, iter_reg);
2299 /* Local memory controller registers. */
2300 iter_reg = fw->lmc_reg;
2301 iter_reg = qla24xx_read_window(reg, 0x3000, 16, iter_reg);
2302 iter_reg = qla24xx_read_window(reg, 0x3010, 16, iter_reg);
2303 iter_reg = qla24xx_read_window(reg, 0x3020, 16, iter_reg);
2304 iter_reg = qla24xx_read_window(reg, 0x3030, 16, iter_reg);
2305 iter_reg = qla24xx_read_window(reg, 0x3040, 16, iter_reg);
2306 iter_reg = qla24xx_read_window(reg, 0x3050, 16, iter_reg);
2307 iter_reg = qla24xx_read_window(reg, 0x3060, 16, iter_reg);
2308 qla24xx_read_window(reg, 0x3070, 16, iter_reg);
2310 /* Fibre Protocol Module registers. */
2311 iter_reg = fw->fpm_hdw_reg;
2312 iter_reg = qla24xx_read_window(reg, 0x4000, 16, iter_reg);
2313 iter_reg = qla24xx_read_window(reg, 0x4010, 16, iter_reg);
2314 iter_reg = qla24xx_read_window(reg, 0x4020, 16, iter_reg);
2315 iter_reg = qla24xx_read_window(reg, 0x4030, 16, iter_reg);
2316 iter_reg = qla24xx_read_window(reg, 0x4040, 16, iter_reg);
2317 iter_reg = qla24xx_read_window(reg, 0x4050, 16, iter_reg);
2318 iter_reg = qla24xx_read_window(reg, 0x4060, 16, iter_reg);
2319 iter_reg = qla24xx_read_window(reg, 0x4070, 16, iter_reg);
2320 iter_reg = qla24xx_read_window(reg, 0x4080, 16, iter_reg);
2321 iter_reg = qla24xx_read_window(reg, 0x4090, 16, iter_reg);
2322 iter_reg = qla24xx_read_window(reg, 0x40A0, 16, iter_reg);
2323 iter_reg = qla24xx_read_window(reg, 0x40B0, 16, iter_reg);
2324 iter_reg = qla24xx_read_window(reg, 0x40C0, 16, iter_reg);
2325 iter_reg = qla24xx_read_window(reg, 0x40D0, 16, iter_reg);
2326 iter_reg = qla24xx_read_window(reg, 0x40E0, 16, iter_reg);
2327 qla24xx_read_window(reg, 0x40F0, 16, iter_reg);
2329 /* RQ0 Array registers. */
2330 iter_reg = fw->rq0_array_reg;
2331 iter_reg = qla24xx_read_window(reg, 0x5C00, 16, iter_reg);
2332 iter_reg = qla24xx_read_window(reg, 0x5C10, 16, iter_reg);
2333 iter_reg = qla24xx_read_window(reg, 0x5C20, 16, iter_reg);
2334 iter_reg = qla24xx_read_window(reg, 0x5C30, 16, iter_reg);
2335 iter_reg = qla24xx_read_window(reg, 0x5C40, 16, iter_reg);
2336 iter_reg = qla24xx_read_window(reg, 0x5C50, 16, iter_reg);
2337 iter_reg = qla24xx_read_window(reg, 0x5C60, 16, iter_reg);
2338 iter_reg = qla24xx_read_window(reg, 0x5C70, 16, iter_reg);
2339 iter_reg = qla24xx_read_window(reg, 0x5C80, 16, iter_reg);
2340 iter_reg = qla24xx_read_window(reg, 0x5C90, 16, iter_reg);
2341 iter_reg = qla24xx_read_window(reg, 0x5CA0, 16, iter_reg);
2342 iter_reg = qla24xx_read_window(reg, 0x5CB0, 16, iter_reg);
2343 iter_reg = qla24xx_read_window(reg, 0x5CC0, 16, iter_reg);
2344 iter_reg = qla24xx_read_window(reg, 0x5CD0, 16, iter_reg);
2345 iter_reg = qla24xx_read_window(reg, 0x5CE0, 16, iter_reg);
2346 qla24xx_read_window(reg, 0x5CF0, 16, iter_reg);
2348 /* RQ1 Array registers. */
2349 iter_reg = fw->rq1_array_reg;
2350 iter_reg = qla24xx_read_window(reg, 0x5D00, 16, iter_reg);
2351 iter_reg = qla24xx_read_window(reg, 0x5D10, 16, iter_reg);
2352 iter_reg = qla24xx_read_window(reg, 0x5D20, 16, iter_reg);
2353 iter_reg = qla24xx_read_window(reg, 0x5D30, 16, iter_reg);
2354 iter_reg = qla24xx_read_window(reg, 0x5D40, 16, iter_reg);
2355 iter_reg = qla24xx_read_window(reg, 0x5D50, 16, iter_reg);
2356 iter_reg = qla24xx_read_window(reg, 0x5D60, 16, iter_reg);
2357 iter_reg = qla24xx_read_window(reg, 0x5D70, 16, iter_reg);
2358 iter_reg = qla24xx_read_window(reg, 0x5D80, 16, iter_reg);
2359 iter_reg = qla24xx_read_window(reg, 0x5D90, 16, iter_reg);
2360 iter_reg = qla24xx_read_window(reg, 0x5DA0, 16, iter_reg);
2361 iter_reg = qla24xx_read_window(reg, 0x5DB0, 16, iter_reg);
2362 iter_reg = qla24xx_read_window(reg, 0x5DC0, 16, iter_reg);
2363 iter_reg = qla24xx_read_window(reg, 0x5DD0, 16, iter_reg);
2364 iter_reg = qla24xx_read_window(reg, 0x5DE0, 16, iter_reg);
2365 qla24xx_read_window(reg, 0x5DF0, 16, iter_reg);
2367 /* RP0 Array registers. */
2368 iter_reg = fw->rp0_array_reg;
2369 iter_reg = qla24xx_read_window(reg, 0x5E00, 16, iter_reg);
2370 iter_reg = qla24xx_read_window(reg, 0x5E10, 16, iter_reg);
2371 iter_reg = qla24xx_read_window(reg, 0x5E20, 16, iter_reg);
2372 iter_reg = qla24xx_read_window(reg, 0x5E30, 16, iter_reg);
2373 iter_reg = qla24xx_read_window(reg, 0x5E40, 16, iter_reg);
2374 iter_reg = qla24xx_read_window(reg, 0x5E50, 16, iter_reg);
2375 iter_reg = qla24xx_read_window(reg, 0x5E60, 16, iter_reg);
2376 iter_reg = qla24xx_read_window(reg, 0x5E70, 16, iter_reg);
2377 iter_reg = qla24xx_read_window(reg, 0x5E80, 16, iter_reg);
2378 iter_reg = qla24xx_read_window(reg, 0x5E90, 16, iter_reg);
2379 iter_reg = qla24xx_read_window(reg, 0x5EA0, 16, iter_reg);
2380 iter_reg = qla24xx_read_window(reg, 0x5EB0, 16, iter_reg);
2381 iter_reg = qla24xx_read_window(reg, 0x5EC0, 16, iter_reg);
2382 iter_reg = qla24xx_read_window(reg, 0x5ED0, 16, iter_reg);
2383 iter_reg = qla24xx_read_window(reg, 0x5EE0, 16, iter_reg);
2384 qla24xx_read_window(reg, 0x5EF0, 16, iter_reg);
2386 /* RP1 Array registers. */
2387 iter_reg = fw->rp1_array_reg;
2388 iter_reg = qla24xx_read_window(reg, 0x5F00, 16, iter_reg);
2389 iter_reg = qla24xx_read_window(reg, 0x5F10, 16, iter_reg);
2390 iter_reg = qla24xx_read_window(reg, 0x5F20, 16, iter_reg);
2391 iter_reg = qla24xx_read_window(reg, 0x5F30, 16, iter_reg);
2392 iter_reg = qla24xx_read_window(reg, 0x5F40, 16, iter_reg);
2393 iter_reg = qla24xx_read_window(reg, 0x5F50, 16, iter_reg);
2394 iter_reg = qla24xx_read_window(reg, 0x5F60, 16, iter_reg);
2395 iter_reg = qla24xx_read_window(reg, 0x5F70, 16, iter_reg);
2396 iter_reg = qla24xx_read_window(reg, 0x5F80, 16, iter_reg);
2397 iter_reg = qla24xx_read_window(reg, 0x5F90, 16, iter_reg);
2398 iter_reg = qla24xx_read_window(reg, 0x5FA0, 16, iter_reg);
2399 iter_reg = qla24xx_read_window(reg, 0x5FB0, 16, iter_reg);
2400 iter_reg = qla24xx_read_window(reg, 0x5FC0, 16, iter_reg);
2401 iter_reg = qla24xx_read_window(reg, 0x5FD0, 16, iter_reg);
2402 iter_reg = qla24xx_read_window(reg, 0x5FE0, 16, iter_reg);
2403 qla24xx_read_window(reg, 0x5FF0, 16, iter_reg);
2405 iter_reg = fw->at0_array_reg;
2406 iter_reg = qla24xx_read_window(reg, 0x7080, 16, iter_reg);
2407 iter_reg = qla24xx_read_window(reg, 0x7090, 16, iter_reg);
2408 iter_reg = qla24xx_read_window(reg, 0x70A0, 16, iter_reg);
2409 iter_reg = qla24xx_read_window(reg, 0x70B0, 16, iter_reg);
2410 iter_reg = qla24xx_read_window(reg, 0x70C0, 16, iter_reg);
2411 iter_reg = qla24xx_read_window(reg, 0x70D0, 16, iter_reg);
2412 iter_reg = qla24xx_read_window(reg, 0x70E0, 16, iter_reg);
2413 qla24xx_read_window(reg, 0x70F0, 16, iter_reg);
2415 /* I/O Queue Control registers. */
2416 qla24xx_read_window(reg, 0x7800, 16, fw->queue_control_reg);
2418 /* Frame Buffer registers. */
2419 iter_reg = fw->fb_hdw_reg;
2420 iter_reg = qla24xx_read_window(reg, 0x6000, 16, iter_reg);
2421 iter_reg = qla24xx_read_window(reg, 0x6010, 16, iter_reg);
2422 iter_reg = qla24xx_read_window(reg, 0x6020, 16, iter_reg);
2423 iter_reg = qla24xx_read_window(reg, 0x6030, 16, iter_reg);
2424 iter_reg = qla24xx_read_window(reg, 0x6040, 16, iter_reg);
2425 iter_reg = qla24xx_read_window(reg, 0x6060, 16, iter_reg);
2426 iter_reg = qla24xx_read_window(reg, 0x6070, 16, iter_reg);
2427 iter_reg = qla24xx_read_window(reg, 0x6100, 16, iter_reg);
2428 iter_reg = qla24xx_read_window(reg, 0x6130, 16, iter_reg);
2429 iter_reg = qla24xx_read_window(reg, 0x6150, 16, iter_reg);
2430 iter_reg = qla24xx_read_window(reg, 0x6170, 16, iter_reg);
2431 iter_reg = qla24xx_read_window(reg, 0x6190, 16, iter_reg);
2432 iter_reg = qla24xx_read_window(reg, 0x61B0, 16, iter_reg);
2433 iter_reg = qla24xx_read_window(reg, 0x61C0, 16, iter_reg);
2434 iter_reg = qla24xx_read_window(reg, 0x6530, 16, iter_reg);
2435 iter_reg = qla24xx_read_window(reg, 0x6540, 16, iter_reg);
2436 iter_reg = qla24xx_read_window(reg, 0x6550, 16, iter_reg);
2437 iter_reg = qla24xx_read_window(reg, 0x6560, 16, iter_reg);
2438 iter_reg = qla24xx_read_window(reg, 0x6570, 16, iter_reg);
2439 iter_reg = qla24xx_read_window(reg, 0x6580, 16, iter_reg);
2440 iter_reg = qla24xx_read_window(reg, 0x6590, 16, iter_reg);
2441 iter_reg = qla24xx_read_window(reg, 0x65A0, 16, iter_reg);
2442 iter_reg = qla24xx_read_window(reg, 0x65B0, 16, iter_reg);
2443 iter_reg = qla24xx_read_window(reg, 0x65C0, 16, iter_reg);
2444 iter_reg = qla24xx_read_window(reg, 0x65D0, 16, iter_reg);
2445 iter_reg = qla24xx_read_window(reg, 0x65E0, 16, iter_reg);
2446 qla24xx_read_window(reg, 0x6F00, 16, iter_reg);
2448 /* Multi queue registers */
2449 nxt_chain = qla25xx_copy_mq(ha, (void *)ha->fw_dump + ha->chain_offset,
2452 rval = qla24xx_soft_reset(ha);
2453 if (rval != QLA_SUCCESS) {
2454 ql_log(ql_log_warn, vha, 0xd00e,
2455 "SOFT RESET FAILED, forcing continuation of dump!!!\n");
2458 ql_log(ql_log_warn, vha, 0xd00f, "try a bigger hammer!!!\n");
2460 WRT_REG_DWORD(®->hccr, HCCRX_SET_RISC_RESET);
2461 RD_REG_DWORD(®->hccr);
2463 WRT_REG_DWORD(®->hccr, HCCRX_REL_RISC_PAUSE);
2464 RD_REG_DWORD(®->hccr);
2466 WRT_REG_DWORD(®->hccr, HCCRX_CLR_RISC_RESET);
2467 RD_REG_DWORD(®->hccr);
2469 for (cnt = 30000; cnt && (RD_REG_WORD(®->mailbox0)); cnt--)
2474 nxt += sizeof(fw->code_ram);
2475 nxt += (ha->fw_memory_size - 0x100000 + 1);
2478 set_bit(RISC_RDY_AFT_RESET, &ha->fw_dump_cap_flags);
2479 ql_log(ql_log_warn, vha, 0xd010,
2480 "bigger hammer success?\n");
2484 rval = qla24xx_dump_memory(ha, fw->code_ram, sizeof(fw->code_ram),
2486 if (rval != QLA_SUCCESS)
2487 goto qla83xx_fw_dump_failed_0;
2490 nxt = qla2xxx_copy_queues(ha, nxt);
2492 qla24xx_copy_eft(ha, nxt);
2494 /* Chain entries -- started with MQ. */
2495 nxt_chain = qla25xx_copy_fce(ha, nxt_chain, &last_chain);
2496 nxt_chain = qla25xx_copy_mqueues(ha, nxt_chain, &last_chain);
2497 nxt_chain = qla2xxx_copy_atioqueues(ha, nxt_chain, &last_chain);
2498 nxt_chain = qla25xx_copy_exlogin(ha, nxt_chain, &last_chain);
2499 nxt_chain = qla81xx_copy_exchoffld(ha, nxt_chain, &last_chain);
2501 ha->fw_dump->version |= htonl(DUMP_CHAIN_VARIANT);
2502 *last_chain |= htonl(DUMP_CHAIN_LAST);
2505 /* Adjust valid length. */
2506 ha->fw_dump_len = (nxt_chain - (void *)ha->fw_dump);
2508 qla83xx_fw_dump_failed_0:
2509 qla2xxx_dump_post_process(base_vha, rval);
2511 qla83xx_fw_dump_failed:
2513 if (!hardware_locked)
2514 spin_unlock_irqrestore(&ha->hardware_lock, flags);
2520 /****************************************************************************/
2521 /* Driver Debug Functions. */
2522 /****************************************************************************/
2525 * This function is for formatting and logging debug information.
2526 * It is to be used when vha is available. It formats the message
2527 * and logs it to the messages file.
2529 * level: The level of the debug messages to be printed.
2530 * If ql2xextended_error_logging value is correctly set,
2531 * this message will appear in the messages file.
2532 * vha: Pointer to the scsi_qla_host_t.
2533 * id: This is a unique identifier for the level. It identifies the
2534 * part of the code from where the message originated.
2535 * msg: The message to be displayed.
2538 ql_dbg(uint level, scsi_qla_host_t *vha, uint id, const char *fmt, ...)
2541 struct va_format vaf;
2549 if (!ql_mask_match(level)) {
2551 const struct pci_dev *pdev = vha->hw->pdev;
2552 /* <module-name> <msg-id>:<host> Message */
2553 snprintf(pbuf, sizeof(pbuf), "%s [%s]-%04x:%ld: ",
2554 QL_MSGHDR, dev_name(&(pdev->dev)), id,
2557 snprintf(pbuf, sizeof(pbuf), "%s [%s]-%04x: : ",
2558 QL_MSGHDR, "0000:00:00.0", id);
2560 pbuf[sizeof(pbuf) - 1] = 0;
2561 trace_ql_dbg_log(pbuf, &vaf);
2567 const struct pci_dev *pdev = vha->hw->pdev;
2568 /* <module-name> <pci-name> <msg-id>:<host> Message */
2569 pr_warn("%s [%s]-%04x:%ld: %pV",
2570 QL_MSGHDR, dev_name(&(pdev->dev)), id + ql_dbg_offset,
2571 vha->host_no, &vaf);
2573 pr_warn("%s [%s]-%04x: : %pV",
2574 QL_MSGHDR, "0000:00:00.0", id + ql_dbg_offset, &vaf);
2582 * This function is for formatting and logging debug information.
2583 * It is to be used when vha is not available and pci is available,
2584 * i.e., before host allocation. It formats the message and logs it
2585 * to the messages file.
2587 * level: The level of the debug messages to be printed.
2588 * If ql2xextended_error_logging value is correctly set,
2589 * this message will appear in the messages file.
2590 * pdev: Pointer to the struct pci_dev.
2591 * id: This is a unique id for the level. It identifies the part
2592 * of the code from where the message originated.
2593 * msg: The message to be displayed.
2596 ql_dbg_pci(uint level, struct pci_dev *pdev, uint id, const char *fmt, ...)
2599 struct va_format vaf;
2603 if (!ql_mask_match(level))
2611 /* <module-name> <dev-name>:<msg-id> Message */
2612 pr_warn("%s [%s]-%04x: : %pV",
2613 QL_MSGHDR, dev_name(&(pdev->dev)), id + ql_dbg_offset, &vaf);
2619 * This function is for formatting and logging log messages.
2620 * It is to be used when vha is available. It formats the message
2621 * and logs it to the messages file. All the messages will be logged
2622 * irrespective of value of ql2xextended_error_logging.
2624 * level: The level of the log messages to be printed in the
2626 * vha: Pointer to the scsi_qla_host_t
2627 * id: This is a unique id for the level. It identifies the
2628 * part of the code from where the message originated.
2629 * msg: The message to be displayed.
2632 ql_log(uint level, scsi_qla_host_t *vha, uint id, const char *fmt, ...)
2635 struct va_format vaf;
2638 if (level > ql_errlev)
2642 const struct pci_dev *pdev = vha->hw->pdev;
2643 /* <module-name> <msg-id>:<host> Message */
2644 snprintf(pbuf, sizeof(pbuf), "%s [%s]-%04x:%ld: ",
2645 QL_MSGHDR, dev_name(&(pdev->dev)), id, vha->host_no);
2647 snprintf(pbuf, sizeof(pbuf), "%s [%s]-%04x: : ",
2648 QL_MSGHDR, "0000:00:00.0", id);
2650 pbuf[sizeof(pbuf) - 1] = 0;
2658 case ql_log_fatal: /* FATAL LOG */
2659 pr_crit("%s%pV", pbuf, &vaf);
2662 pr_err("%s%pV", pbuf, &vaf);
2665 pr_warn("%s%pV", pbuf, &vaf);
2668 pr_info("%s%pV", pbuf, &vaf);
2676 * This function is for formatting and logging log messages.
2677 * It is to be used when vha is not available and pci is available,
2678 * i.e., before host allocation. It formats the message and logs
2679 * it to the messages file. All the messages are logged irrespective
2680 * of the value of ql2xextended_error_logging.
2682 * level: The level of the log messages to be printed in the
2684 * pdev: Pointer to the struct pci_dev.
2685 * id: This is a unique id for the level. It identifies the
2686 * part of the code from where the message originated.
2687 * msg: The message to be displayed.
2690 ql_log_pci(uint level, struct pci_dev *pdev, uint id, const char *fmt, ...)
2693 struct va_format vaf;
2698 if (level > ql_errlev)
2701 /* <module-name> <dev-name>:<msg-id> Message */
2702 snprintf(pbuf, sizeof(pbuf), "%s [%s]-%04x: : ",
2703 QL_MSGHDR, dev_name(&(pdev->dev)), id);
2704 pbuf[sizeof(pbuf) - 1] = 0;
2712 case ql_log_fatal: /* FATAL LOG */
2713 pr_crit("%s%pV", pbuf, &vaf);
2716 pr_err("%s%pV", pbuf, &vaf);
2719 pr_warn("%s%pV", pbuf, &vaf);
2722 pr_info("%s%pV", pbuf, &vaf);
2730 ql_dump_regs(uint level, scsi_qla_host_t *vha, uint id)
2733 struct qla_hw_data *ha = vha->hw;
2734 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
2735 struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
2736 struct device_reg_82xx __iomem *reg82 = &ha->iobase->isp82;
2737 uint16_t __iomem *mbx_reg;
2739 if (!ql_mask_match(level))
2742 if (IS_P3P_TYPE(ha))
2743 mbx_reg = ®82->mailbox_in[0];
2744 else if (IS_FWI2_CAPABLE(ha))
2745 mbx_reg = ®24->mailbox0;
2747 mbx_reg = MAILBOX_REG(ha, reg, 0);
2749 ql_dbg(level, vha, id, "Mailbox registers:\n");
2750 for (i = 0; i < 6; i++, mbx_reg++)
2751 ql_dbg(level, vha, id,
2752 "mbox[%d] %#04x\n", i, RD_REG_WORD(mbx_reg));
2757 ql_dump_buffer(uint level, scsi_qla_host_t *vha, uint id, const void *buf,
2762 if (!ql_mask_match(level))
2765 ql_dbg(level, vha, id,
2766 "%-+5d 0 1 2 3 4 5 6 7 8 9 A B C D E F\n", size);
2767 ql_dbg(level, vha, id,
2768 "----- -----------------------------------------------\n");
2769 for (cnt = 0; cnt < size; cnt += 16) {
2770 ql_dbg(level, vha, id, "%04x: ", cnt);
2771 print_hex_dump(KERN_CONT, "", DUMP_PREFIX_NONE, 16, 1,
2772 buf + cnt, min(16U, size - cnt), false);
2777 * This function is for formatting and logging log messages.
2778 * It is to be used when vha is available. It formats the message
2779 * and logs it to the messages file. All the messages will be logged
2780 * irrespective of value of ql2xextended_error_logging.
2782 * level: The level of the log messages to be printed in the
2784 * vha: Pointer to the scsi_qla_host_t
2785 * id: This is a unique id for the level. It identifies the
2786 * part of the code from where the message originated.
2787 * msg: The message to be displayed.
2790 ql_log_qp(uint32_t level, struct qla_qpair *qpair, int32_t id,
2791 const char *fmt, ...)
2794 struct va_format vaf;
2797 if (level > ql_errlev)
2800 if (qpair != NULL) {
2801 const struct pci_dev *pdev = qpair->pdev;
2802 /* <module-name> <msg-id>:<host> Message */
2803 snprintf(pbuf, sizeof(pbuf), "%s [%s]-%04x: ",
2804 QL_MSGHDR, dev_name(&(pdev->dev)), id);
2806 snprintf(pbuf, sizeof(pbuf), "%s [%s]-%04x: : ",
2807 QL_MSGHDR, "0000:00:00.0", id);
2809 pbuf[sizeof(pbuf) - 1] = 0;
2817 case ql_log_fatal: /* FATAL LOG */
2818 pr_crit("%s%pV", pbuf, &vaf);
2821 pr_err("%s%pV", pbuf, &vaf);
2824 pr_warn("%s%pV", pbuf, &vaf);
2827 pr_info("%s%pV", pbuf, &vaf);
2835 * This function is for formatting and logging debug information.
2836 * It is to be used when vha is available. It formats the message
2837 * and logs it to the messages file.
2839 * level: The level of the debug messages to be printed.
2840 * If ql2xextended_error_logging value is correctly set,
2841 * this message will appear in the messages file.
2842 * vha: Pointer to the scsi_qla_host_t.
2843 * id: This is a unique identifier for the level. It identifies the
2844 * part of the code from where the message originated.
2845 * msg: The message to be displayed.
2848 ql_dbg_qp(uint32_t level, struct qla_qpair *qpair, int32_t id,
2849 const char *fmt, ...)
2852 struct va_format vaf;
2854 if (!ql_mask_match(level))
2862 if (qpair != NULL) {
2863 const struct pci_dev *pdev = qpair->pdev;
2864 /* <module-name> <pci-name> <msg-id>:<host> Message */
2865 pr_warn("%s [%s]-%04x: %pV",
2866 QL_MSGHDR, dev_name(&(pdev->dev)), id + ql_dbg_offset,
2869 pr_warn("%s [%s]-%04x: : %pV",
2870 QL_MSGHDR, "0000:00:00.0", id + ql_dbg_offset, &vaf);