2 * QLogic Fibre Channel HBA Driver
3 * Copyright (c) 2003-2013 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 | 0x017d | 0x004b,0x0141 |
15 * | | | 0x0144,0x0146 |
16 * | | | 0x015b-0x0160 |
17 * | | | 0x016e-0x0170 |
18 * | Mailbox commands | 0x1187 | 0x1018-0x1019 |
20 * | | | 0x1115-0x1116 |
21 * | | | 0x111a-0x111b |
22 * | | | 0x1155-0x1158 |
23 * | Device Discovery | 0x2095 | 0x2020-0x2022, |
24 * | | | 0x2011-0x2012, |
26 * | Queue Command and IO tracing | 0x3059 | 0x3006-0x300b |
27 * | | | 0x3027-0x3028 |
28 * | | | 0x303d-0x3041 |
29 * | | | 0x302d,0x3033 |
30 * | | | 0x3036,0x3038 |
32 * | DPC Thread | 0x4023 | 0x4002,0x4013 |
33 * | Async Events | 0x5087 | 0x502b-0x502f |
34 * | | | 0x5047,0x5052 |
35 * | | | 0x5084,0x5075 |
36 * | | | 0x503d,0x5044 |
37 * | Timer Routines | 0x6012 | |
38 * | User Space Interactions | 0x70e2 | 0x7018,0x702e |
39 * | | | 0x7020,0x7024 |
40 * | | | 0x7039,0x7045 |
41 * | | | 0x7073-0x7075 |
42 * | | | 0x70a5-0x70a6 |
43 * | | | 0x70a8,0x70ab |
44 * | | | 0x70ad-0x70ae |
45 * | | | 0x70d7-0x70db |
46 * | | | 0x70de-0x70df |
47 * | Task Management | 0x803d | 0x8025-0x8026 |
48 * | | | 0x800b,0x8039 |
49 * | AER/EEH | 0x9011 | |
50 * | Virtual Port | 0xa007 | |
51 * | ISP82XX Specific | 0xb14c | 0xb002,0xb024 |
52 * | | | 0xb09e,0xb0ae |
53 * | | | 0xb0e0-0xb0ef |
54 * | | | 0xb085,0xb0dc |
55 * | | | 0xb107,0xb108 |
56 * | | | 0xb111,0xb11e |
57 * | | | 0xb12c,0xb12d |
58 * | | | 0xb13a,0xb142 |
59 * | | | 0xb13c-0xb140 |
61 * | MultiQ | 0xc00c | |
62 * | Misc | 0xd2ff | 0xd017-0xd019 |
64 * | | | 0xd02e-0xd0ff |
65 * | | | 0xd101-0xd1fe |
66 * | | | 0xd212-0xd2fe |
67 * | Target Mode | 0xe070 | 0xe021 |
68 * | Target Mode Management | 0xf072 | 0xf002-0xf003 |
69 * | | | 0xf046-0xf049 |
70 * | Target Mode Task Management | 0x1000b | |
71 * ----------------------------------------------------------------------
76 #include <linux/delay.h>
78 static uint32_t ql_dbg_offset
= 0x800;
81 qla2xxx_prep_dump(struct qla_hw_data
*ha
, struct qla2xxx_fw_dump
*fw_dump
)
83 fw_dump
->fw_major_version
= htonl(ha
->fw_major_version
);
84 fw_dump
->fw_minor_version
= htonl(ha
->fw_minor_version
);
85 fw_dump
->fw_subminor_version
= htonl(ha
->fw_subminor_version
);
86 fw_dump
->fw_attributes
= htonl(ha
->fw_attributes
);
88 fw_dump
->vendor
= htonl(ha
->pdev
->vendor
);
89 fw_dump
->device
= htonl(ha
->pdev
->device
);
90 fw_dump
->subsystem_vendor
= htonl(ha
->pdev
->subsystem_vendor
);
91 fw_dump
->subsystem_device
= htonl(ha
->pdev
->subsystem_device
);
95 qla2xxx_copy_queues(struct qla_hw_data
*ha
, void *ptr
)
97 struct req_que
*req
= ha
->req_q_map
[0];
98 struct rsp_que
*rsp
= ha
->rsp_q_map
[0];
100 memcpy(ptr
, req
->ring
, req
->length
*
103 /* Response queue. */
104 ptr
+= req
->length
* sizeof(request_t
);
105 memcpy(ptr
, rsp
->ring
, rsp
->length
*
108 return ptr
+ (rsp
->length
* sizeof(response_t
));
112 qla27xx_dump_mpi_ram(struct qla_hw_data
*ha
, uint32_t addr
, uint32_t *ram
,
113 uint32_t ram_dwords
, void **nxt
)
116 uint32_t cnt
, stat
, timer
, dwords
, idx
;
118 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
119 dma_addr_t dump_dma
= ha
->gid_list_dma
;
120 uint32_t *dump
= (uint32_t *)ha
->gid_list
;
125 WRT_REG_WORD(®
->mailbox0
, MBC_LOAD_DUMP_MPI_RAM
);
126 clear_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
128 dwords
= qla2x00_gid_list_size(ha
) / 4;
129 for (cnt
= 0; cnt
< ram_dwords
&& rval
== QLA_SUCCESS
;
130 cnt
+= dwords
, addr
+= dwords
) {
131 if (cnt
+ dwords
> ram_dwords
)
132 dwords
= ram_dwords
- cnt
;
134 WRT_REG_WORD(®
->mailbox1
, LSW(addr
));
135 WRT_REG_WORD(®
->mailbox8
, MSW(addr
));
137 WRT_REG_WORD(®
->mailbox2
, MSW(dump_dma
));
138 WRT_REG_WORD(®
->mailbox3
, LSW(dump_dma
));
139 WRT_REG_WORD(®
->mailbox6
, MSW(MSD(dump_dma
)));
140 WRT_REG_WORD(®
->mailbox7
, LSW(MSD(dump_dma
)));
142 WRT_REG_WORD(®
->mailbox4
, MSW(dwords
));
143 WRT_REG_WORD(®
->mailbox5
, LSW(dwords
));
145 WRT_REG_WORD(®
->mailbox9
, 0);
146 WRT_REG_DWORD(®
->hccr
, HCCRX_SET_HOST_INT
);
148 ha
->flags
.mbox_int
= 0;
149 for (timer
= 6000000; timer
; timer
--) {
150 /* Check for pending interrupts. */
151 stat
= RD_REG_DWORD(®
->host_status
);
152 if (stat
& HSRX_RISC_INT
) {
155 if (stat
== 0x1 || stat
== 0x2 ||
156 stat
== 0x10 || stat
== 0x11) {
157 set_bit(MBX_INTERRUPT
,
160 mb0
= RD_REG_WORD(®
->mailbox0
);
161 mb1
= RD_REG_WORD(®
->mailbox1
);
163 WRT_REG_DWORD(®
->hccr
,
165 RD_REG_DWORD(®
->hccr
);
169 /* Clear this intr; it wasn't a mailbox intr */
170 WRT_REG_DWORD(®
->hccr
, HCCRX_CLR_RISC_INT
);
171 RD_REG_DWORD(®
->hccr
);
175 ha
->flags
.mbox_int
= 1;
177 if (test_and_clear_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
)) {
178 rval
= mb0
& MBS_MASK
;
179 for (idx
= 0; idx
< dwords
; idx
++)
180 ram
[cnt
+ idx
] = IS_QLA27XX(ha
) ?
181 le32_to_cpu(dump
[idx
]) : swab32(dump
[idx
]);
183 rval
= QLA_FUNCTION_FAILED
;
187 *nxt
= rval
== QLA_SUCCESS
? &ram
[cnt
] : NULL
;
192 qla24xx_dump_ram(struct qla_hw_data
*ha
, uint32_t addr
, uint32_t *ram
,
193 uint32_t ram_dwords
, void **nxt
)
196 uint32_t cnt
, stat
, timer
, dwords
, idx
;
198 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
199 dma_addr_t dump_dma
= ha
->gid_list_dma
;
200 uint32_t *dump
= (uint32_t *)ha
->gid_list
;
205 WRT_REG_WORD(®
->mailbox0
, MBC_DUMP_RISC_RAM_EXTENDED
);
206 clear_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
208 dwords
= qla2x00_gid_list_size(ha
) / 4;
209 for (cnt
= 0; cnt
< ram_dwords
&& rval
== QLA_SUCCESS
;
210 cnt
+= dwords
, addr
+= dwords
) {
211 if (cnt
+ dwords
> ram_dwords
)
212 dwords
= ram_dwords
- cnt
;
214 WRT_REG_WORD(®
->mailbox1
, LSW(addr
));
215 WRT_REG_WORD(®
->mailbox8
, MSW(addr
));
217 WRT_REG_WORD(®
->mailbox2
, MSW(dump_dma
));
218 WRT_REG_WORD(®
->mailbox3
, LSW(dump_dma
));
219 WRT_REG_WORD(®
->mailbox6
, MSW(MSD(dump_dma
)));
220 WRT_REG_WORD(®
->mailbox7
, LSW(MSD(dump_dma
)));
222 WRT_REG_WORD(®
->mailbox4
, MSW(dwords
));
223 WRT_REG_WORD(®
->mailbox5
, LSW(dwords
));
224 WRT_REG_DWORD(®
->hccr
, HCCRX_SET_HOST_INT
);
226 ha
->flags
.mbox_int
= 0;
227 for (timer
= 6000000; timer
; timer
--) {
228 /* Check for pending interrupts. */
229 stat
= RD_REG_DWORD(®
->host_status
);
230 if (stat
& HSRX_RISC_INT
) {
233 if (stat
== 0x1 || stat
== 0x2 ||
234 stat
== 0x10 || stat
== 0x11) {
235 set_bit(MBX_INTERRUPT
,
238 mb0
= RD_REG_WORD(®
->mailbox0
);
240 WRT_REG_DWORD(®
->hccr
,
242 RD_REG_DWORD(®
->hccr
);
246 /* Clear this intr; it wasn't a mailbox intr */
247 WRT_REG_DWORD(®
->hccr
, HCCRX_CLR_RISC_INT
);
248 RD_REG_DWORD(®
->hccr
);
252 ha
->flags
.mbox_int
= 1;
254 if (test_and_clear_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
)) {
255 rval
= mb0
& MBS_MASK
;
256 for (idx
= 0; idx
< dwords
; idx
++)
257 ram
[cnt
+ idx
] = IS_QLA27XX(ha
) ?
258 le32_to_cpu(dump
[idx
]) : swab32(dump
[idx
]);
260 rval
= QLA_FUNCTION_FAILED
;
264 *nxt
= rval
== QLA_SUCCESS
? &ram
[cnt
]: NULL
;
269 qla24xx_dump_memory(struct qla_hw_data
*ha
, uint32_t *code_ram
,
270 uint32_t cram_size
, void **nxt
)
275 rval
= qla24xx_dump_ram(ha
, 0x20000, code_ram
, cram_size
/ 4, nxt
);
276 if (rval
!= QLA_SUCCESS
)
279 /* External Memory. */
280 return qla24xx_dump_ram(ha
, 0x100000, *nxt
,
281 ha
->fw_memory_size
- 0x100000 + 1, nxt
);
285 qla24xx_read_window(struct device_reg_24xx __iomem
*reg
, uint32_t iobase
,
286 uint32_t count
, uint32_t *buf
)
288 uint32_t __iomem
*dmp_reg
;
290 WRT_REG_DWORD(®
->iobase_addr
, iobase
);
291 dmp_reg
= ®
->iobase_window
;
293 *buf
++ = htonl(RD_REG_DWORD(dmp_reg
++));
299 qla24xx_pause_risc(struct device_reg_24xx __iomem
*reg
)
301 int rval
= QLA_SUCCESS
;
304 WRT_REG_DWORD(®
->hccr
, HCCRX_SET_RISC_PAUSE
);
306 ((RD_REG_DWORD(®
->host_status
) & HSRX_RISC_PAUSED
) == 0) &&
307 rval
== QLA_SUCCESS
; cnt
--) {
311 rval
= QLA_FUNCTION_TIMEOUT
;
318 qla24xx_soft_reset(struct qla_hw_data
*ha
)
320 int rval
= QLA_SUCCESS
;
323 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
326 WRT_REG_DWORD(®
->ctrl_status
, CSRX_DMA_SHUTDOWN
|MWB_4096_BYTES
);
327 for (cnt
= 0; cnt
< 30000; cnt
++) {
328 if ((RD_REG_DWORD(®
->ctrl_status
) & CSRX_DMA_ACTIVE
) == 0)
334 WRT_REG_DWORD(®
->ctrl_status
,
335 CSRX_ISP_SOFT_RESET
|CSRX_DMA_SHUTDOWN
|MWB_4096_BYTES
);
336 pci_read_config_word(ha
->pdev
, PCI_COMMAND
, &wd
);
339 /* Wait for firmware to complete NVRAM accesses. */
340 mb0
= (uint32_t) RD_REG_WORD(®
->mailbox0
);
341 for (cnt
= 10000 ; cnt
&& mb0
; cnt
--) {
343 mb0
= (uint32_t) RD_REG_WORD(®
->mailbox0
);
347 /* Wait for soft-reset to complete. */
348 for (cnt
= 0; cnt
< 30000; cnt
++) {
349 if ((RD_REG_DWORD(®
->ctrl_status
) &
350 CSRX_ISP_SOFT_RESET
) == 0)
355 WRT_REG_DWORD(®
->hccr
, HCCRX_CLR_RISC_RESET
);
356 RD_REG_DWORD(®
->hccr
); /* PCI Posting. */
358 for (cnt
= 30000; RD_REG_WORD(®
->mailbox0
) != 0 &&
359 rval
== QLA_SUCCESS
; cnt
--) {
363 rval
= QLA_FUNCTION_TIMEOUT
;
370 qla2xxx_dump_ram(struct qla_hw_data
*ha
, uint32_t addr
, uint16_t *ram
,
371 uint32_t ram_words
, void **nxt
)
374 uint32_t cnt
, stat
, timer
, words
, idx
;
376 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
377 dma_addr_t dump_dma
= ha
->gid_list_dma
;
378 uint16_t *dump
= (uint16_t *)ha
->gid_list
;
383 WRT_MAILBOX_REG(ha
, reg
, 0, MBC_DUMP_RISC_RAM_EXTENDED
);
384 clear_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
386 words
= qla2x00_gid_list_size(ha
) / 2;
387 for (cnt
= 0; cnt
< ram_words
&& rval
== QLA_SUCCESS
;
388 cnt
+= words
, addr
+= words
) {
389 if (cnt
+ words
> ram_words
)
390 words
= ram_words
- cnt
;
392 WRT_MAILBOX_REG(ha
, reg
, 1, LSW(addr
));
393 WRT_MAILBOX_REG(ha
, reg
, 8, MSW(addr
));
395 WRT_MAILBOX_REG(ha
, reg
, 2, MSW(dump_dma
));
396 WRT_MAILBOX_REG(ha
, reg
, 3, LSW(dump_dma
));
397 WRT_MAILBOX_REG(ha
, reg
, 6, MSW(MSD(dump_dma
)));
398 WRT_MAILBOX_REG(ha
, reg
, 7, LSW(MSD(dump_dma
)));
400 WRT_MAILBOX_REG(ha
, reg
, 4, words
);
401 WRT_REG_WORD(®
->hccr
, HCCR_SET_HOST_INT
);
403 for (timer
= 6000000; timer
; timer
--) {
404 /* Check for pending interrupts. */
405 stat
= RD_REG_DWORD(®
->u
.isp2300
.host_status
);
406 if (stat
& HSR_RISC_INT
) {
409 if (stat
== 0x1 || stat
== 0x2) {
410 set_bit(MBX_INTERRUPT
,
413 mb0
= RD_MAILBOX_REG(ha
, reg
, 0);
415 /* Release mailbox registers. */
416 WRT_REG_WORD(®
->semaphore
, 0);
417 WRT_REG_WORD(®
->hccr
,
419 RD_REG_WORD(®
->hccr
);
421 } else if (stat
== 0x10 || stat
== 0x11) {
422 set_bit(MBX_INTERRUPT
,
425 mb0
= RD_MAILBOX_REG(ha
, reg
, 0);
427 WRT_REG_WORD(®
->hccr
,
429 RD_REG_WORD(®
->hccr
);
433 /* clear this intr; it wasn't a mailbox intr */
434 WRT_REG_WORD(®
->hccr
, HCCR_CLR_RISC_INT
);
435 RD_REG_WORD(®
->hccr
);
440 if (test_and_clear_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
)) {
441 rval
= mb0
& MBS_MASK
;
442 for (idx
= 0; idx
< words
; idx
++)
443 ram
[cnt
+ idx
] = swab16(dump
[idx
]);
445 rval
= QLA_FUNCTION_FAILED
;
449 *nxt
= rval
== QLA_SUCCESS
? &ram
[cnt
]: NULL
;
454 qla2xxx_read_window(struct device_reg_2xxx __iomem
*reg
, uint32_t count
,
457 uint16_t __iomem
*dmp_reg
= ®
->u
.isp2300
.fb_cmd
;
460 *buf
++ = htons(RD_REG_WORD(dmp_reg
++));
464 qla24xx_copy_eft(struct qla_hw_data
*ha
, void *ptr
)
469 memcpy(ptr
, ha
->eft
, ntohl(ha
->fw_dump
->eft_size
));
470 return ptr
+ ntohl(ha
->fw_dump
->eft_size
);
474 qla25xx_copy_fce(struct qla_hw_data
*ha
, void *ptr
, uint32_t **last_chain
)
478 struct qla2xxx_fce_chain
*fcec
= ptr
;
483 *last_chain
= &fcec
->type
;
484 fcec
->type
= __constant_htonl(DUMP_CHAIN_FCE
);
485 fcec
->chain_size
= htonl(sizeof(struct qla2xxx_fce_chain
) +
486 fce_calc_size(ha
->fce_bufs
));
487 fcec
->size
= htonl(fce_calc_size(ha
->fce_bufs
));
488 fcec
->addr_l
= htonl(LSD(ha
->fce_dma
));
489 fcec
->addr_h
= htonl(MSD(ha
->fce_dma
));
491 iter_reg
= fcec
->eregs
;
492 for (cnt
= 0; cnt
< 8; cnt
++)
493 *iter_reg
++ = htonl(ha
->fce_mb
[cnt
]);
495 memcpy(iter_reg
, ha
->fce
, ntohl(fcec
->size
));
497 return (char *)iter_reg
+ ntohl(fcec
->size
);
501 qla2xxx_copy_atioqueues(struct qla_hw_data
*ha
, void *ptr
,
502 uint32_t **last_chain
)
504 struct qla2xxx_mqueue_chain
*q
;
505 struct qla2xxx_mqueue_header
*qh
;
513 if (!ha
->tgt
.atio_ring
)
518 aqp
->length
= ha
->tgt
.atio_q_length
;
519 aqp
->ring
= ha
->tgt
.atio_ring
;
521 for (que
= 0; que
< num_queues
; que
++) {
522 /* aqp = ha->atio_q_map[que]; */
524 *last_chain
= &q
->type
;
525 q
->type
= __constant_htonl(DUMP_CHAIN_QUEUE
);
526 q
->chain_size
= htonl(
527 sizeof(struct qla2xxx_mqueue_chain
) +
528 sizeof(struct qla2xxx_mqueue_header
) +
529 (aqp
->length
* sizeof(request_t
)));
530 ptr
+= sizeof(struct qla2xxx_mqueue_chain
);
534 qh
->queue
= __constant_htonl(TYPE_ATIO_QUEUE
);
535 qh
->number
= htonl(que
);
536 qh
->size
= htonl(aqp
->length
* sizeof(request_t
));
537 ptr
+= sizeof(struct qla2xxx_mqueue_header
);
540 memcpy(ptr
, aqp
->ring
, aqp
->length
* sizeof(request_t
));
542 ptr
+= aqp
->length
* sizeof(request_t
);
549 qla25xx_copy_mqueues(struct qla_hw_data
*ha
, void *ptr
, uint32_t **last_chain
)
551 struct qla2xxx_mqueue_chain
*q
;
552 struct qla2xxx_mqueue_header
*qh
;
561 for (que
= 1; que
< ha
->max_req_queues
; que
++) {
562 req
= ha
->req_q_map
[que
];
568 *last_chain
= &q
->type
;
569 q
->type
= __constant_htonl(DUMP_CHAIN_QUEUE
);
570 q
->chain_size
= htonl(
571 sizeof(struct qla2xxx_mqueue_chain
) +
572 sizeof(struct qla2xxx_mqueue_header
) +
573 (req
->length
* sizeof(request_t
)));
574 ptr
+= sizeof(struct qla2xxx_mqueue_chain
);
578 qh
->queue
= __constant_htonl(TYPE_REQUEST_QUEUE
);
579 qh
->number
= htonl(que
);
580 qh
->size
= htonl(req
->length
* sizeof(request_t
));
581 ptr
+= sizeof(struct qla2xxx_mqueue_header
);
584 memcpy(ptr
, req
->ring
, req
->length
* sizeof(request_t
));
585 ptr
+= req
->length
* sizeof(request_t
);
588 /* Response queues */
589 for (que
= 1; que
< ha
->max_rsp_queues
; que
++) {
590 rsp
= ha
->rsp_q_map
[que
];
596 *last_chain
= &q
->type
;
597 q
->type
= __constant_htonl(DUMP_CHAIN_QUEUE
);
598 q
->chain_size
= htonl(
599 sizeof(struct qla2xxx_mqueue_chain
) +
600 sizeof(struct qla2xxx_mqueue_header
) +
601 (rsp
->length
* sizeof(response_t
)));
602 ptr
+= sizeof(struct qla2xxx_mqueue_chain
);
606 qh
->queue
= __constant_htonl(TYPE_RESPONSE_QUEUE
);
607 qh
->number
= htonl(que
);
608 qh
->size
= htonl(rsp
->length
* sizeof(response_t
));
609 ptr
+= sizeof(struct qla2xxx_mqueue_header
);
612 memcpy(ptr
, rsp
->ring
, rsp
->length
* sizeof(response_t
));
613 ptr
+= rsp
->length
* sizeof(response_t
);
620 qla25xx_copy_mq(struct qla_hw_data
*ha
, void *ptr
, uint32_t **last_chain
)
622 uint32_t cnt
, que_idx
;
624 struct qla2xxx_mq_chain
*mq
= ptr
;
625 device_reg_t __iomem
*reg
;
627 if (!ha
->mqenable
|| IS_QLA83XX(ha
) || IS_QLA27XX(ha
))
631 *last_chain
= &mq
->type
;
632 mq
->type
= __constant_htonl(DUMP_CHAIN_MQ
);
633 mq
->chain_size
= __constant_htonl(sizeof(struct qla2xxx_mq_chain
));
635 que_cnt
= ha
->max_req_queues
> ha
->max_rsp_queues
?
636 ha
->max_req_queues
: ha
->max_rsp_queues
;
637 mq
->count
= htonl(que_cnt
);
638 for (cnt
= 0; cnt
< que_cnt
; cnt
++) {
639 reg
= ISP_QUE_REG(ha
, cnt
);
642 htonl(RD_REG_DWORD(®
->isp25mq
.req_q_in
));
643 mq
->qregs
[que_idx
+1] =
644 htonl(RD_REG_DWORD(®
->isp25mq
.req_q_out
));
645 mq
->qregs
[que_idx
+2] =
646 htonl(RD_REG_DWORD(®
->isp25mq
.rsp_q_in
));
647 mq
->qregs
[que_idx
+3] =
648 htonl(RD_REG_DWORD(®
->isp25mq
.rsp_q_out
));
651 return ptr
+ sizeof(struct qla2xxx_mq_chain
);
655 qla2xxx_dump_post_process(scsi_qla_host_t
*vha
, int rval
)
657 struct qla_hw_data
*ha
= vha
->hw
;
659 if (rval
!= QLA_SUCCESS
) {
660 ql_log(ql_log_warn
, vha
, 0xd000,
661 "Failed to dump firmware (%x).\n", rval
);
664 ql_log(ql_log_info
, vha
, 0xd001,
665 "Firmware dump saved to temp buffer (%ld/%p).\n",
666 vha
->host_no
, ha
->fw_dump
);
668 qla2x00_post_uevent_work(vha
, QLA_UEVENT_CODE_FW_DUMP
);
673 * qla2300_fw_dump() - Dumps binary data from the 2300 firmware.
675 * @hardware_locked: Called with the hardware_lock
678 qla2300_fw_dump(scsi_qla_host_t
*vha
, int hardware_locked
)
682 struct qla_hw_data
*ha
= vha
->hw
;
683 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
684 uint16_t __iomem
*dmp_reg
;
686 struct qla2300_fw_dump
*fw
;
688 struct scsi_qla_host
*base_vha
= pci_get_drvdata(ha
->pdev
);
692 if (!hardware_locked
)
693 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
696 ql_log(ql_log_warn
, vha
, 0xd002,
697 "No buffer available for dump.\n");
698 goto qla2300_fw_dump_failed
;
702 ql_log(ql_log_warn
, vha
, 0xd003,
703 "Firmware has been previously dumped (%p) "
704 "-- ignoring request.\n",
706 goto qla2300_fw_dump_failed
;
708 fw
= &ha
->fw_dump
->isp
.isp23
;
709 qla2xxx_prep_dump(ha
, ha
->fw_dump
);
712 fw
->hccr
= htons(RD_REG_WORD(®
->hccr
));
715 WRT_REG_WORD(®
->hccr
, HCCR_PAUSE_RISC
);
716 if (IS_QLA2300(ha
)) {
718 (RD_REG_WORD(®
->hccr
) & HCCR_RISC_PAUSE
) == 0 &&
719 rval
== QLA_SUCCESS
; cnt
--) {
723 rval
= QLA_FUNCTION_TIMEOUT
;
726 RD_REG_WORD(®
->hccr
); /* PCI Posting. */
730 if (rval
== QLA_SUCCESS
) {
731 dmp_reg
= ®
->flash_address
;
732 for (cnt
= 0; cnt
< sizeof(fw
->pbiu_reg
) / 2; cnt
++)
733 fw
->pbiu_reg
[cnt
] = htons(RD_REG_WORD(dmp_reg
++));
735 dmp_reg
= ®
->u
.isp2300
.req_q_in
;
736 for (cnt
= 0; cnt
< sizeof(fw
->risc_host_reg
) / 2; cnt
++)
737 fw
->risc_host_reg
[cnt
] = htons(RD_REG_WORD(dmp_reg
++));
739 dmp_reg
= ®
->u
.isp2300
.mailbox0
;
740 for (cnt
= 0; cnt
< sizeof(fw
->mailbox_reg
) / 2; cnt
++)
741 fw
->mailbox_reg
[cnt
] = htons(RD_REG_WORD(dmp_reg
++));
743 WRT_REG_WORD(®
->ctrl_status
, 0x40);
744 qla2xxx_read_window(reg
, 32, fw
->resp_dma_reg
);
746 WRT_REG_WORD(®
->ctrl_status
, 0x50);
747 qla2xxx_read_window(reg
, 48, fw
->dma_reg
);
749 WRT_REG_WORD(®
->ctrl_status
, 0x00);
750 dmp_reg
= ®
->risc_hw
;
751 for (cnt
= 0; cnt
< sizeof(fw
->risc_hdw_reg
) / 2; cnt
++)
752 fw
->risc_hdw_reg
[cnt
] = htons(RD_REG_WORD(dmp_reg
++));
754 WRT_REG_WORD(®
->pcr
, 0x2000);
755 qla2xxx_read_window(reg
, 16, fw
->risc_gp0_reg
);
757 WRT_REG_WORD(®
->pcr
, 0x2200);
758 qla2xxx_read_window(reg
, 16, fw
->risc_gp1_reg
);
760 WRT_REG_WORD(®
->pcr
, 0x2400);
761 qla2xxx_read_window(reg
, 16, fw
->risc_gp2_reg
);
763 WRT_REG_WORD(®
->pcr
, 0x2600);
764 qla2xxx_read_window(reg
, 16, fw
->risc_gp3_reg
);
766 WRT_REG_WORD(®
->pcr
, 0x2800);
767 qla2xxx_read_window(reg
, 16, fw
->risc_gp4_reg
);
769 WRT_REG_WORD(®
->pcr
, 0x2A00);
770 qla2xxx_read_window(reg
, 16, fw
->risc_gp5_reg
);
772 WRT_REG_WORD(®
->pcr
, 0x2C00);
773 qla2xxx_read_window(reg
, 16, fw
->risc_gp6_reg
);
775 WRT_REG_WORD(®
->pcr
, 0x2E00);
776 qla2xxx_read_window(reg
, 16, fw
->risc_gp7_reg
);
778 WRT_REG_WORD(®
->ctrl_status
, 0x10);
779 qla2xxx_read_window(reg
, 64, fw
->frame_buf_hdw_reg
);
781 WRT_REG_WORD(®
->ctrl_status
, 0x20);
782 qla2xxx_read_window(reg
, 64, fw
->fpm_b0_reg
);
784 WRT_REG_WORD(®
->ctrl_status
, 0x30);
785 qla2xxx_read_window(reg
, 64, fw
->fpm_b1_reg
);
788 WRT_REG_WORD(®
->ctrl_status
, CSR_ISP_SOFT_RESET
);
789 for (cnt
= 0; cnt
< 30000; cnt
++) {
790 if ((RD_REG_WORD(®
->ctrl_status
) &
791 CSR_ISP_SOFT_RESET
) == 0)
798 if (!IS_QLA2300(ha
)) {
799 for (cnt
= 30000; RD_MAILBOX_REG(ha
, reg
, 0) != 0 &&
800 rval
== QLA_SUCCESS
; cnt
--) {
804 rval
= QLA_FUNCTION_TIMEOUT
;
809 if (rval
== QLA_SUCCESS
)
810 rval
= qla2xxx_dump_ram(ha
, 0x800, fw
->risc_ram
,
811 sizeof(fw
->risc_ram
) / 2, &nxt
);
813 /* Get stack SRAM. */
814 if (rval
== QLA_SUCCESS
)
815 rval
= qla2xxx_dump_ram(ha
, 0x10000, fw
->stack_ram
,
816 sizeof(fw
->stack_ram
) / 2, &nxt
);
819 if (rval
== QLA_SUCCESS
)
820 rval
= qla2xxx_dump_ram(ha
, 0x11000, fw
->data_ram
,
821 ha
->fw_memory_size
- 0x11000 + 1, &nxt
);
823 if (rval
== QLA_SUCCESS
)
824 qla2xxx_copy_queues(ha
, nxt
);
826 qla2xxx_dump_post_process(base_vha
, rval
);
828 qla2300_fw_dump_failed
:
829 if (!hardware_locked
)
830 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
834 * qla2100_fw_dump() - Dumps binary data from the 2100/2200 firmware.
836 * @hardware_locked: Called with the hardware_lock
839 qla2100_fw_dump(scsi_qla_host_t
*vha
, int hardware_locked
)
843 uint16_t risc_address
;
845 struct qla_hw_data
*ha
= vha
->hw
;
846 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
847 uint16_t __iomem
*dmp_reg
;
849 struct qla2100_fw_dump
*fw
;
850 struct scsi_qla_host
*base_vha
= pci_get_drvdata(ha
->pdev
);
856 if (!hardware_locked
)
857 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
860 ql_log(ql_log_warn
, vha
, 0xd004,
861 "No buffer available for dump.\n");
862 goto qla2100_fw_dump_failed
;
866 ql_log(ql_log_warn
, vha
, 0xd005,
867 "Firmware has been previously dumped (%p) "
868 "-- ignoring request.\n",
870 goto qla2100_fw_dump_failed
;
872 fw
= &ha
->fw_dump
->isp
.isp21
;
873 qla2xxx_prep_dump(ha
, ha
->fw_dump
);
876 fw
->hccr
= htons(RD_REG_WORD(®
->hccr
));
879 WRT_REG_WORD(®
->hccr
, HCCR_PAUSE_RISC
);
880 for (cnt
= 30000; (RD_REG_WORD(®
->hccr
) & HCCR_RISC_PAUSE
) == 0 &&
881 rval
== QLA_SUCCESS
; cnt
--) {
885 rval
= QLA_FUNCTION_TIMEOUT
;
887 if (rval
== QLA_SUCCESS
) {
888 dmp_reg
= ®
->flash_address
;
889 for (cnt
= 0; cnt
< sizeof(fw
->pbiu_reg
) / 2; cnt
++)
890 fw
->pbiu_reg
[cnt
] = htons(RD_REG_WORD(dmp_reg
++));
892 dmp_reg
= ®
->u
.isp2100
.mailbox0
;
893 for (cnt
= 0; cnt
< ha
->mbx_count
; cnt
++) {
895 dmp_reg
= ®
->u_end
.isp2200
.mailbox8
;
897 fw
->mailbox_reg
[cnt
] = htons(RD_REG_WORD(dmp_reg
++));
900 dmp_reg
= ®
->u
.isp2100
.unused_2
[0];
901 for (cnt
= 0; cnt
< sizeof(fw
->dma_reg
) / 2; cnt
++)
902 fw
->dma_reg
[cnt
] = htons(RD_REG_WORD(dmp_reg
++));
904 WRT_REG_WORD(®
->ctrl_status
, 0x00);
905 dmp_reg
= ®
->risc_hw
;
906 for (cnt
= 0; cnt
< sizeof(fw
->risc_hdw_reg
) / 2; cnt
++)
907 fw
->risc_hdw_reg
[cnt
] = htons(RD_REG_WORD(dmp_reg
++));
909 WRT_REG_WORD(®
->pcr
, 0x2000);
910 qla2xxx_read_window(reg
, 16, fw
->risc_gp0_reg
);
912 WRT_REG_WORD(®
->pcr
, 0x2100);
913 qla2xxx_read_window(reg
, 16, fw
->risc_gp1_reg
);
915 WRT_REG_WORD(®
->pcr
, 0x2200);
916 qla2xxx_read_window(reg
, 16, fw
->risc_gp2_reg
);
918 WRT_REG_WORD(®
->pcr
, 0x2300);
919 qla2xxx_read_window(reg
, 16, fw
->risc_gp3_reg
);
921 WRT_REG_WORD(®
->pcr
, 0x2400);
922 qla2xxx_read_window(reg
, 16, fw
->risc_gp4_reg
);
924 WRT_REG_WORD(®
->pcr
, 0x2500);
925 qla2xxx_read_window(reg
, 16, fw
->risc_gp5_reg
);
927 WRT_REG_WORD(®
->pcr
, 0x2600);
928 qla2xxx_read_window(reg
, 16, fw
->risc_gp6_reg
);
930 WRT_REG_WORD(®
->pcr
, 0x2700);
931 qla2xxx_read_window(reg
, 16, fw
->risc_gp7_reg
);
933 WRT_REG_WORD(®
->ctrl_status
, 0x10);
934 qla2xxx_read_window(reg
, 16, fw
->frame_buf_hdw_reg
);
936 WRT_REG_WORD(®
->ctrl_status
, 0x20);
937 qla2xxx_read_window(reg
, 64, fw
->fpm_b0_reg
);
939 WRT_REG_WORD(®
->ctrl_status
, 0x30);
940 qla2xxx_read_window(reg
, 64, fw
->fpm_b1_reg
);
943 WRT_REG_WORD(®
->ctrl_status
, CSR_ISP_SOFT_RESET
);
946 for (cnt
= 30000; RD_MAILBOX_REG(ha
, reg
, 0) != 0 &&
947 rval
== QLA_SUCCESS
; cnt
--) {
951 rval
= QLA_FUNCTION_TIMEOUT
;
955 if (rval
== QLA_SUCCESS
&& (IS_QLA2200(ha
) || (IS_QLA2100(ha
) &&
956 (RD_REG_WORD(®
->mctr
) & (BIT_1
| BIT_0
)) != 0))) {
958 WRT_REG_WORD(®
->hccr
, HCCR_PAUSE_RISC
);
960 (RD_REG_WORD(®
->hccr
) & HCCR_RISC_PAUSE
) == 0 &&
961 rval
== QLA_SUCCESS
; cnt
--) {
965 rval
= QLA_FUNCTION_TIMEOUT
;
967 if (rval
== QLA_SUCCESS
) {
968 /* Set memory configuration and timing. */
970 WRT_REG_WORD(®
->mctr
, 0xf1);
972 WRT_REG_WORD(®
->mctr
, 0xf2);
973 RD_REG_WORD(®
->mctr
); /* PCI Posting. */
976 WRT_REG_WORD(®
->hccr
, HCCR_RELEASE_RISC
);
980 if (rval
== QLA_SUCCESS
) {
982 risc_address
= 0x1000;
983 WRT_MAILBOX_REG(ha
, reg
, 0, MBC_READ_RAM_WORD
);
984 clear_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
);
986 for (cnt
= 0; cnt
< sizeof(fw
->risc_ram
) / 2 && rval
== QLA_SUCCESS
;
987 cnt
++, risc_address
++) {
988 WRT_MAILBOX_REG(ha
, reg
, 1, risc_address
);
989 WRT_REG_WORD(®
->hccr
, HCCR_SET_HOST_INT
);
991 for (timer
= 6000000; timer
!= 0; timer
--) {
992 /* Check for pending interrupts. */
993 if (RD_REG_WORD(®
->istatus
) & ISR_RISC_INT
) {
994 if (RD_REG_WORD(®
->semaphore
) & BIT_0
) {
995 set_bit(MBX_INTERRUPT
,
998 mb0
= RD_MAILBOX_REG(ha
, reg
, 0);
999 mb2
= RD_MAILBOX_REG(ha
, reg
, 2);
1001 WRT_REG_WORD(®
->semaphore
, 0);
1002 WRT_REG_WORD(®
->hccr
,
1004 RD_REG_WORD(®
->hccr
);
1007 WRT_REG_WORD(®
->hccr
, HCCR_CLR_RISC_INT
);
1008 RD_REG_WORD(®
->hccr
);
1013 if (test_and_clear_bit(MBX_INTERRUPT
, &ha
->mbx_cmd_flags
)) {
1014 rval
= mb0
& MBS_MASK
;
1015 fw
->risc_ram
[cnt
] = htons(mb2
);
1017 rval
= QLA_FUNCTION_FAILED
;
1021 if (rval
== QLA_SUCCESS
)
1022 qla2xxx_copy_queues(ha
, &fw
->risc_ram
[cnt
]);
1024 qla2xxx_dump_post_process(base_vha
, rval
);
1026 qla2100_fw_dump_failed
:
1027 if (!hardware_locked
)
1028 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1032 qla24xx_fw_dump(scsi_qla_host_t
*vha
, int hardware_locked
)
1036 uint32_t risc_address
;
1037 struct qla_hw_data
*ha
= vha
->hw
;
1038 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
1039 uint32_t __iomem
*dmp_reg
;
1041 uint16_t __iomem
*mbx_reg
;
1042 unsigned long flags
;
1043 struct qla24xx_fw_dump
*fw
;
1044 uint32_t ext_mem_cnt
;
1047 uint32_t *last_chain
= NULL
;
1048 struct scsi_qla_host
*base_vha
= pci_get_drvdata(ha
->pdev
);
1050 if (IS_P3P_TYPE(ha
))
1053 risc_address
= ext_mem_cnt
= 0;
1056 if (!hardware_locked
)
1057 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1060 ql_log(ql_log_warn
, vha
, 0xd006,
1061 "No buffer available for dump.\n");
1062 goto qla24xx_fw_dump_failed
;
1065 if (ha
->fw_dumped
) {
1066 ql_log(ql_log_warn
, vha
, 0xd007,
1067 "Firmware has been previously dumped (%p) "
1068 "-- ignoring request.\n",
1070 goto qla24xx_fw_dump_failed
;
1072 fw
= &ha
->fw_dump
->isp
.isp24
;
1073 qla2xxx_prep_dump(ha
, ha
->fw_dump
);
1075 fw
->host_status
= htonl(RD_REG_DWORD(®
->host_status
));
1078 rval
= qla24xx_pause_risc(reg
);
1079 if (rval
!= QLA_SUCCESS
)
1080 goto qla24xx_fw_dump_failed_0
;
1082 /* Host interface registers. */
1083 dmp_reg
= ®
->flash_addr
;
1084 for (cnt
= 0; cnt
< sizeof(fw
->host_reg
) / 4; cnt
++)
1085 fw
->host_reg
[cnt
] = htonl(RD_REG_DWORD(dmp_reg
++));
1087 /* Disable interrupts. */
1088 WRT_REG_DWORD(®
->ictrl
, 0);
1089 RD_REG_DWORD(®
->ictrl
);
1091 /* Shadow registers. */
1092 WRT_REG_DWORD(®
->iobase_addr
, 0x0F70);
1093 RD_REG_DWORD(®
->iobase_addr
);
1094 WRT_REG_DWORD(®
->iobase_select
, 0xB0000000);
1095 fw
->shadow_reg
[0] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1097 WRT_REG_DWORD(®
->iobase_select
, 0xB0100000);
1098 fw
->shadow_reg
[1] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1100 WRT_REG_DWORD(®
->iobase_select
, 0xB0200000);
1101 fw
->shadow_reg
[2] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1103 WRT_REG_DWORD(®
->iobase_select
, 0xB0300000);
1104 fw
->shadow_reg
[3] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1106 WRT_REG_DWORD(®
->iobase_select
, 0xB0400000);
1107 fw
->shadow_reg
[4] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1109 WRT_REG_DWORD(®
->iobase_select
, 0xB0500000);
1110 fw
->shadow_reg
[5] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1112 WRT_REG_DWORD(®
->iobase_select
, 0xB0600000);
1113 fw
->shadow_reg
[6] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1115 /* Mailbox registers. */
1116 mbx_reg
= ®
->mailbox0
;
1117 for (cnt
= 0; cnt
< sizeof(fw
->mailbox_reg
) / 2; cnt
++)
1118 fw
->mailbox_reg
[cnt
] = htons(RD_REG_WORD(mbx_reg
++));
1120 /* Transfer sequence registers. */
1121 iter_reg
= fw
->xseq_gp_reg
;
1122 iter_reg
= qla24xx_read_window(reg
, 0xBF00, 16, iter_reg
);
1123 iter_reg
= qla24xx_read_window(reg
, 0xBF10, 16, iter_reg
);
1124 iter_reg
= qla24xx_read_window(reg
, 0xBF20, 16, iter_reg
);
1125 iter_reg
= qla24xx_read_window(reg
, 0xBF30, 16, iter_reg
);
1126 iter_reg
= qla24xx_read_window(reg
, 0xBF40, 16, iter_reg
);
1127 iter_reg
= qla24xx_read_window(reg
, 0xBF50, 16, iter_reg
);
1128 iter_reg
= qla24xx_read_window(reg
, 0xBF60, 16, iter_reg
);
1129 qla24xx_read_window(reg
, 0xBF70, 16, iter_reg
);
1131 qla24xx_read_window(reg
, 0xBFE0, 16, fw
->xseq_0_reg
);
1132 qla24xx_read_window(reg
, 0xBFF0, 16, fw
->xseq_1_reg
);
1134 /* Receive sequence registers. */
1135 iter_reg
= fw
->rseq_gp_reg
;
1136 iter_reg
= qla24xx_read_window(reg
, 0xFF00, 16, iter_reg
);
1137 iter_reg
= qla24xx_read_window(reg
, 0xFF10, 16, iter_reg
);
1138 iter_reg
= qla24xx_read_window(reg
, 0xFF20, 16, iter_reg
);
1139 iter_reg
= qla24xx_read_window(reg
, 0xFF30, 16, iter_reg
);
1140 iter_reg
= qla24xx_read_window(reg
, 0xFF40, 16, iter_reg
);
1141 iter_reg
= qla24xx_read_window(reg
, 0xFF50, 16, iter_reg
);
1142 iter_reg
= qla24xx_read_window(reg
, 0xFF60, 16, iter_reg
);
1143 qla24xx_read_window(reg
, 0xFF70, 16, iter_reg
);
1145 qla24xx_read_window(reg
, 0xFFD0, 16, fw
->rseq_0_reg
);
1146 qla24xx_read_window(reg
, 0xFFE0, 16, fw
->rseq_1_reg
);
1147 qla24xx_read_window(reg
, 0xFFF0, 16, fw
->rseq_2_reg
);
1149 /* Command DMA registers. */
1150 qla24xx_read_window(reg
, 0x7100, 16, fw
->cmd_dma_reg
);
1153 iter_reg
= fw
->req0_dma_reg
;
1154 iter_reg
= qla24xx_read_window(reg
, 0x7200, 8, iter_reg
);
1155 dmp_reg
= ®
->iobase_q
;
1156 for (cnt
= 0; cnt
< 7; cnt
++)
1157 *iter_reg
++ = htonl(RD_REG_DWORD(dmp_reg
++));
1159 iter_reg
= fw
->resp0_dma_reg
;
1160 iter_reg
= qla24xx_read_window(reg
, 0x7300, 8, iter_reg
);
1161 dmp_reg
= ®
->iobase_q
;
1162 for (cnt
= 0; cnt
< 7; cnt
++)
1163 *iter_reg
++ = htonl(RD_REG_DWORD(dmp_reg
++));
1165 iter_reg
= fw
->req1_dma_reg
;
1166 iter_reg
= qla24xx_read_window(reg
, 0x7400, 8, iter_reg
);
1167 dmp_reg
= ®
->iobase_q
;
1168 for (cnt
= 0; cnt
< 7; cnt
++)
1169 *iter_reg
++ = htonl(RD_REG_DWORD(dmp_reg
++));
1171 /* Transmit DMA registers. */
1172 iter_reg
= fw
->xmt0_dma_reg
;
1173 iter_reg
= qla24xx_read_window(reg
, 0x7600, 16, iter_reg
);
1174 qla24xx_read_window(reg
, 0x7610, 16, iter_reg
);
1176 iter_reg
= fw
->xmt1_dma_reg
;
1177 iter_reg
= qla24xx_read_window(reg
, 0x7620, 16, iter_reg
);
1178 qla24xx_read_window(reg
, 0x7630, 16, iter_reg
);
1180 iter_reg
= fw
->xmt2_dma_reg
;
1181 iter_reg
= qla24xx_read_window(reg
, 0x7640, 16, iter_reg
);
1182 qla24xx_read_window(reg
, 0x7650, 16, iter_reg
);
1184 iter_reg
= fw
->xmt3_dma_reg
;
1185 iter_reg
= qla24xx_read_window(reg
, 0x7660, 16, iter_reg
);
1186 qla24xx_read_window(reg
, 0x7670, 16, iter_reg
);
1188 iter_reg
= fw
->xmt4_dma_reg
;
1189 iter_reg
= qla24xx_read_window(reg
, 0x7680, 16, iter_reg
);
1190 qla24xx_read_window(reg
, 0x7690, 16, iter_reg
);
1192 qla24xx_read_window(reg
, 0x76A0, 16, fw
->xmt_data_dma_reg
);
1194 /* Receive DMA registers. */
1195 iter_reg
= fw
->rcvt0_data_dma_reg
;
1196 iter_reg
= qla24xx_read_window(reg
, 0x7700, 16, iter_reg
);
1197 qla24xx_read_window(reg
, 0x7710, 16, iter_reg
);
1199 iter_reg
= fw
->rcvt1_data_dma_reg
;
1200 iter_reg
= qla24xx_read_window(reg
, 0x7720, 16, iter_reg
);
1201 qla24xx_read_window(reg
, 0x7730, 16, iter_reg
);
1203 /* RISC registers. */
1204 iter_reg
= fw
->risc_gp_reg
;
1205 iter_reg
= qla24xx_read_window(reg
, 0x0F00, 16, iter_reg
);
1206 iter_reg
= qla24xx_read_window(reg
, 0x0F10, 16, iter_reg
);
1207 iter_reg
= qla24xx_read_window(reg
, 0x0F20, 16, iter_reg
);
1208 iter_reg
= qla24xx_read_window(reg
, 0x0F30, 16, iter_reg
);
1209 iter_reg
= qla24xx_read_window(reg
, 0x0F40, 16, iter_reg
);
1210 iter_reg
= qla24xx_read_window(reg
, 0x0F50, 16, iter_reg
);
1211 iter_reg
= qla24xx_read_window(reg
, 0x0F60, 16, iter_reg
);
1212 qla24xx_read_window(reg
, 0x0F70, 16, iter_reg
);
1214 /* Local memory controller registers. */
1215 iter_reg
= fw
->lmc_reg
;
1216 iter_reg
= qla24xx_read_window(reg
, 0x3000, 16, iter_reg
);
1217 iter_reg
= qla24xx_read_window(reg
, 0x3010, 16, iter_reg
);
1218 iter_reg
= qla24xx_read_window(reg
, 0x3020, 16, iter_reg
);
1219 iter_reg
= qla24xx_read_window(reg
, 0x3030, 16, iter_reg
);
1220 iter_reg
= qla24xx_read_window(reg
, 0x3040, 16, iter_reg
);
1221 iter_reg
= qla24xx_read_window(reg
, 0x3050, 16, iter_reg
);
1222 qla24xx_read_window(reg
, 0x3060, 16, iter_reg
);
1224 /* Fibre Protocol Module registers. */
1225 iter_reg
= fw
->fpm_hdw_reg
;
1226 iter_reg
= qla24xx_read_window(reg
, 0x4000, 16, iter_reg
);
1227 iter_reg
= qla24xx_read_window(reg
, 0x4010, 16, iter_reg
);
1228 iter_reg
= qla24xx_read_window(reg
, 0x4020, 16, iter_reg
);
1229 iter_reg
= qla24xx_read_window(reg
, 0x4030, 16, iter_reg
);
1230 iter_reg
= qla24xx_read_window(reg
, 0x4040, 16, iter_reg
);
1231 iter_reg
= qla24xx_read_window(reg
, 0x4050, 16, iter_reg
);
1232 iter_reg
= qla24xx_read_window(reg
, 0x4060, 16, iter_reg
);
1233 iter_reg
= qla24xx_read_window(reg
, 0x4070, 16, iter_reg
);
1234 iter_reg
= qla24xx_read_window(reg
, 0x4080, 16, iter_reg
);
1235 iter_reg
= qla24xx_read_window(reg
, 0x4090, 16, iter_reg
);
1236 iter_reg
= qla24xx_read_window(reg
, 0x40A0, 16, iter_reg
);
1237 qla24xx_read_window(reg
, 0x40B0, 16, iter_reg
);
1239 /* Frame Buffer registers. */
1240 iter_reg
= fw
->fb_hdw_reg
;
1241 iter_reg
= qla24xx_read_window(reg
, 0x6000, 16, iter_reg
);
1242 iter_reg
= qla24xx_read_window(reg
, 0x6010, 16, iter_reg
);
1243 iter_reg
= qla24xx_read_window(reg
, 0x6020, 16, iter_reg
);
1244 iter_reg
= qla24xx_read_window(reg
, 0x6030, 16, iter_reg
);
1245 iter_reg
= qla24xx_read_window(reg
, 0x6040, 16, iter_reg
);
1246 iter_reg
= qla24xx_read_window(reg
, 0x6100, 16, iter_reg
);
1247 iter_reg
= qla24xx_read_window(reg
, 0x6130, 16, iter_reg
);
1248 iter_reg
= qla24xx_read_window(reg
, 0x6150, 16, iter_reg
);
1249 iter_reg
= qla24xx_read_window(reg
, 0x6170, 16, iter_reg
);
1250 iter_reg
= qla24xx_read_window(reg
, 0x6190, 16, iter_reg
);
1251 qla24xx_read_window(reg
, 0x61B0, 16, iter_reg
);
1253 rval
= qla24xx_soft_reset(ha
);
1254 if (rval
!= QLA_SUCCESS
)
1255 goto qla24xx_fw_dump_failed_0
;
1257 rval
= qla24xx_dump_memory(ha
, fw
->code_ram
, sizeof(fw
->code_ram
),
1259 if (rval
!= QLA_SUCCESS
)
1260 goto qla24xx_fw_dump_failed_0
;
1262 nxt
= qla2xxx_copy_queues(ha
, nxt
);
1264 qla24xx_copy_eft(ha
, nxt
);
1266 nxt_chain
= (void *)ha
->fw_dump
+ ha
->chain_offset
;
1267 nxt_chain
= qla2xxx_copy_atioqueues(ha
, nxt_chain
, &last_chain
);
1269 ha
->fw_dump
->version
|= __constant_htonl(DUMP_CHAIN_VARIANT
);
1270 *last_chain
|= __constant_htonl(DUMP_CHAIN_LAST
);
1273 /* Adjust valid length. */
1274 ha
->fw_dump_len
= (nxt_chain
- (void *)ha
->fw_dump
);
1276 qla24xx_fw_dump_failed_0
:
1277 qla2xxx_dump_post_process(base_vha
, rval
);
1279 qla24xx_fw_dump_failed
:
1280 if (!hardware_locked
)
1281 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1285 qla25xx_fw_dump(scsi_qla_host_t
*vha
, int hardware_locked
)
1289 uint32_t risc_address
;
1290 struct qla_hw_data
*ha
= vha
->hw
;
1291 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
1292 uint32_t __iomem
*dmp_reg
;
1294 uint16_t __iomem
*mbx_reg
;
1295 unsigned long flags
;
1296 struct qla25xx_fw_dump
*fw
;
1297 uint32_t ext_mem_cnt
;
1298 void *nxt
, *nxt_chain
;
1299 uint32_t *last_chain
= NULL
;
1300 struct scsi_qla_host
*base_vha
= pci_get_drvdata(ha
->pdev
);
1302 risc_address
= ext_mem_cnt
= 0;
1305 if (!hardware_locked
)
1306 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1309 ql_log(ql_log_warn
, vha
, 0xd008,
1310 "No buffer available for dump.\n");
1311 goto qla25xx_fw_dump_failed
;
1314 if (ha
->fw_dumped
) {
1315 ql_log(ql_log_warn
, vha
, 0xd009,
1316 "Firmware has been previously dumped (%p) "
1317 "-- ignoring request.\n",
1319 goto qla25xx_fw_dump_failed
;
1321 fw
= &ha
->fw_dump
->isp
.isp25
;
1322 qla2xxx_prep_dump(ha
, ha
->fw_dump
);
1323 ha
->fw_dump
->version
= __constant_htonl(2);
1325 fw
->host_status
= htonl(RD_REG_DWORD(®
->host_status
));
1328 rval
= qla24xx_pause_risc(reg
);
1329 if (rval
!= QLA_SUCCESS
)
1330 goto qla25xx_fw_dump_failed_0
;
1332 /* Host/Risc registers. */
1333 iter_reg
= fw
->host_risc_reg
;
1334 iter_reg
= qla24xx_read_window(reg
, 0x7000, 16, iter_reg
);
1335 qla24xx_read_window(reg
, 0x7010, 16, iter_reg
);
1337 /* PCIe registers. */
1338 WRT_REG_DWORD(®
->iobase_addr
, 0x7C00);
1339 RD_REG_DWORD(®
->iobase_addr
);
1340 WRT_REG_DWORD(®
->iobase_window
, 0x01);
1341 dmp_reg
= ®
->iobase_c4
;
1342 fw
->pcie_regs
[0] = htonl(RD_REG_DWORD(dmp_reg
++));
1343 fw
->pcie_regs
[1] = htonl(RD_REG_DWORD(dmp_reg
++));
1344 fw
->pcie_regs
[2] = htonl(RD_REG_DWORD(dmp_reg
));
1345 fw
->pcie_regs
[3] = htonl(RD_REG_DWORD(®
->iobase_window
));
1347 WRT_REG_DWORD(®
->iobase_window
, 0x00);
1348 RD_REG_DWORD(®
->iobase_window
);
1350 /* Host interface registers. */
1351 dmp_reg
= ®
->flash_addr
;
1352 for (cnt
= 0; cnt
< sizeof(fw
->host_reg
) / 4; cnt
++)
1353 fw
->host_reg
[cnt
] = htonl(RD_REG_DWORD(dmp_reg
++));
1355 /* Disable interrupts. */
1356 WRT_REG_DWORD(®
->ictrl
, 0);
1357 RD_REG_DWORD(®
->ictrl
);
1359 /* Shadow registers. */
1360 WRT_REG_DWORD(®
->iobase_addr
, 0x0F70);
1361 RD_REG_DWORD(®
->iobase_addr
);
1362 WRT_REG_DWORD(®
->iobase_select
, 0xB0000000);
1363 fw
->shadow_reg
[0] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1365 WRT_REG_DWORD(®
->iobase_select
, 0xB0100000);
1366 fw
->shadow_reg
[1] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1368 WRT_REG_DWORD(®
->iobase_select
, 0xB0200000);
1369 fw
->shadow_reg
[2] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1371 WRT_REG_DWORD(®
->iobase_select
, 0xB0300000);
1372 fw
->shadow_reg
[3] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1374 WRT_REG_DWORD(®
->iobase_select
, 0xB0400000);
1375 fw
->shadow_reg
[4] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1377 WRT_REG_DWORD(®
->iobase_select
, 0xB0500000);
1378 fw
->shadow_reg
[5] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1380 WRT_REG_DWORD(®
->iobase_select
, 0xB0600000);
1381 fw
->shadow_reg
[6] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1383 WRT_REG_DWORD(®
->iobase_select
, 0xB0700000);
1384 fw
->shadow_reg
[7] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1386 WRT_REG_DWORD(®
->iobase_select
, 0xB0800000);
1387 fw
->shadow_reg
[8] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1389 WRT_REG_DWORD(®
->iobase_select
, 0xB0900000);
1390 fw
->shadow_reg
[9] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1392 WRT_REG_DWORD(®
->iobase_select
, 0xB0A00000);
1393 fw
->shadow_reg
[10] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1395 /* RISC I/O register. */
1396 WRT_REG_DWORD(®
->iobase_addr
, 0x0010);
1397 fw
->risc_io_reg
= htonl(RD_REG_DWORD(®
->iobase_window
));
1399 /* Mailbox registers. */
1400 mbx_reg
= ®
->mailbox0
;
1401 for (cnt
= 0; cnt
< sizeof(fw
->mailbox_reg
) / 2; cnt
++)
1402 fw
->mailbox_reg
[cnt
] = htons(RD_REG_WORD(mbx_reg
++));
1404 /* Transfer sequence registers. */
1405 iter_reg
= fw
->xseq_gp_reg
;
1406 iter_reg
= qla24xx_read_window(reg
, 0xBF00, 16, iter_reg
);
1407 iter_reg
= qla24xx_read_window(reg
, 0xBF10, 16, iter_reg
);
1408 iter_reg
= qla24xx_read_window(reg
, 0xBF20, 16, iter_reg
);
1409 iter_reg
= qla24xx_read_window(reg
, 0xBF30, 16, iter_reg
);
1410 iter_reg
= qla24xx_read_window(reg
, 0xBF40, 16, iter_reg
);
1411 iter_reg
= qla24xx_read_window(reg
, 0xBF50, 16, iter_reg
);
1412 iter_reg
= qla24xx_read_window(reg
, 0xBF60, 16, iter_reg
);
1413 qla24xx_read_window(reg
, 0xBF70, 16, iter_reg
);
1415 iter_reg
= fw
->xseq_0_reg
;
1416 iter_reg
= qla24xx_read_window(reg
, 0xBFC0, 16, iter_reg
);
1417 iter_reg
= qla24xx_read_window(reg
, 0xBFD0, 16, iter_reg
);
1418 qla24xx_read_window(reg
, 0xBFE0, 16, iter_reg
);
1420 qla24xx_read_window(reg
, 0xBFF0, 16, fw
->xseq_1_reg
);
1422 /* Receive sequence registers. */
1423 iter_reg
= fw
->rseq_gp_reg
;
1424 iter_reg
= qla24xx_read_window(reg
, 0xFF00, 16, iter_reg
);
1425 iter_reg
= qla24xx_read_window(reg
, 0xFF10, 16, iter_reg
);
1426 iter_reg
= qla24xx_read_window(reg
, 0xFF20, 16, iter_reg
);
1427 iter_reg
= qla24xx_read_window(reg
, 0xFF30, 16, iter_reg
);
1428 iter_reg
= qla24xx_read_window(reg
, 0xFF40, 16, iter_reg
);
1429 iter_reg
= qla24xx_read_window(reg
, 0xFF50, 16, iter_reg
);
1430 iter_reg
= qla24xx_read_window(reg
, 0xFF60, 16, iter_reg
);
1431 qla24xx_read_window(reg
, 0xFF70, 16, iter_reg
);
1433 iter_reg
= fw
->rseq_0_reg
;
1434 iter_reg
= qla24xx_read_window(reg
, 0xFFC0, 16, iter_reg
);
1435 qla24xx_read_window(reg
, 0xFFD0, 16, iter_reg
);
1437 qla24xx_read_window(reg
, 0xFFE0, 16, fw
->rseq_1_reg
);
1438 qla24xx_read_window(reg
, 0xFFF0, 16, fw
->rseq_2_reg
);
1440 /* Auxiliary sequence registers. */
1441 iter_reg
= fw
->aseq_gp_reg
;
1442 iter_reg
= qla24xx_read_window(reg
, 0xB000, 16, iter_reg
);
1443 iter_reg
= qla24xx_read_window(reg
, 0xB010, 16, iter_reg
);
1444 iter_reg
= qla24xx_read_window(reg
, 0xB020, 16, iter_reg
);
1445 iter_reg
= qla24xx_read_window(reg
, 0xB030, 16, iter_reg
);
1446 iter_reg
= qla24xx_read_window(reg
, 0xB040, 16, iter_reg
);
1447 iter_reg
= qla24xx_read_window(reg
, 0xB050, 16, iter_reg
);
1448 iter_reg
= qla24xx_read_window(reg
, 0xB060, 16, iter_reg
);
1449 qla24xx_read_window(reg
, 0xB070, 16, iter_reg
);
1451 iter_reg
= fw
->aseq_0_reg
;
1452 iter_reg
= qla24xx_read_window(reg
, 0xB0C0, 16, iter_reg
);
1453 qla24xx_read_window(reg
, 0xB0D0, 16, iter_reg
);
1455 qla24xx_read_window(reg
, 0xB0E0, 16, fw
->aseq_1_reg
);
1456 qla24xx_read_window(reg
, 0xB0F0, 16, fw
->aseq_2_reg
);
1458 /* Command DMA registers. */
1459 qla24xx_read_window(reg
, 0x7100, 16, fw
->cmd_dma_reg
);
1462 iter_reg
= fw
->req0_dma_reg
;
1463 iter_reg
= qla24xx_read_window(reg
, 0x7200, 8, iter_reg
);
1464 dmp_reg
= ®
->iobase_q
;
1465 for (cnt
= 0; cnt
< 7; cnt
++)
1466 *iter_reg
++ = htonl(RD_REG_DWORD(dmp_reg
++));
1468 iter_reg
= fw
->resp0_dma_reg
;
1469 iter_reg
= qla24xx_read_window(reg
, 0x7300, 8, iter_reg
);
1470 dmp_reg
= ®
->iobase_q
;
1471 for (cnt
= 0; cnt
< 7; cnt
++)
1472 *iter_reg
++ = htonl(RD_REG_DWORD(dmp_reg
++));
1474 iter_reg
= fw
->req1_dma_reg
;
1475 iter_reg
= qla24xx_read_window(reg
, 0x7400, 8, iter_reg
);
1476 dmp_reg
= ®
->iobase_q
;
1477 for (cnt
= 0; cnt
< 7; cnt
++)
1478 *iter_reg
++ = htonl(RD_REG_DWORD(dmp_reg
++));
1480 /* Transmit DMA registers. */
1481 iter_reg
= fw
->xmt0_dma_reg
;
1482 iter_reg
= qla24xx_read_window(reg
, 0x7600, 16, iter_reg
);
1483 qla24xx_read_window(reg
, 0x7610, 16, iter_reg
);
1485 iter_reg
= fw
->xmt1_dma_reg
;
1486 iter_reg
= qla24xx_read_window(reg
, 0x7620, 16, iter_reg
);
1487 qla24xx_read_window(reg
, 0x7630, 16, iter_reg
);
1489 iter_reg
= fw
->xmt2_dma_reg
;
1490 iter_reg
= qla24xx_read_window(reg
, 0x7640, 16, iter_reg
);
1491 qla24xx_read_window(reg
, 0x7650, 16, iter_reg
);
1493 iter_reg
= fw
->xmt3_dma_reg
;
1494 iter_reg
= qla24xx_read_window(reg
, 0x7660, 16, iter_reg
);
1495 qla24xx_read_window(reg
, 0x7670, 16, iter_reg
);
1497 iter_reg
= fw
->xmt4_dma_reg
;
1498 iter_reg
= qla24xx_read_window(reg
, 0x7680, 16, iter_reg
);
1499 qla24xx_read_window(reg
, 0x7690, 16, iter_reg
);
1501 qla24xx_read_window(reg
, 0x76A0, 16, fw
->xmt_data_dma_reg
);
1503 /* Receive DMA registers. */
1504 iter_reg
= fw
->rcvt0_data_dma_reg
;
1505 iter_reg
= qla24xx_read_window(reg
, 0x7700, 16, iter_reg
);
1506 qla24xx_read_window(reg
, 0x7710, 16, iter_reg
);
1508 iter_reg
= fw
->rcvt1_data_dma_reg
;
1509 iter_reg
= qla24xx_read_window(reg
, 0x7720, 16, iter_reg
);
1510 qla24xx_read_window(reg
, 0x7730, 16, iter_reg
);
1512 /* RISC registers. */
1513 iter_reg
= fw
->risc_gp_reg
;
1514 iter_reg
= qla24xx_read_window(reg
, 0x0F00, 16, iter_reg
);
1515 iter_reg
= qla24xx_read_window(reg
, 0x0F10, 16, iter_reg
);
1516 iter_reg
= qla24xx_read_window(reg
, 0x0F20, 16, iter_reg
);
1517 iter_reg
= qla24xx_read_window(reg
, 0x0F30, 16, iter_reg
);
1518 iter_reg
= qla24xx_read_window(reg
, 0x0F40, 16, iter_reg
);
1519 iter_reg
= qla24xx_read_window(reg
, 0x0F50, 16, iter_reg
);
1520 iter_reg
= qla24xx_read_window(reg
, 0x0F60, 16, iter_reg
);
1521 qla24xx_read_window(reg
, 0x0F70, 16, iter_reg
);
1523 /* Local memory controller registers. */
1524 iter_reg
= fw
->lmc_reg
;
1525 iter_reg
= qla24xx_read_window(reg
, 0x3000, 16, iter_reg
);
1526 iter_reg
= qla24xx_read_window(reg
, 0x3010, 16, iter_reg
);
1527 iter_reg
= qla24xx_read_window(reg
, 0x3020, 16, iter_reg
);
1528 iter_reg
= qla24xx_read_window(reg
, 0x3030, 16, iter_reg
);
1529 iter_reg
= qla24xx_read_window(reg
, 0x3040, 16, iter_reg
);
1530 iter_reg
= qla24xx_read_window(reg
, 0x3050, 16, iter_reg
);
1531 iter_reg
= qla24xx_read_window(reg
, 0x3060, 16, iter_reg
);
1532 qla24xx_read_window(reg
, 0x3070, 16, iter_reg
);
1534 /* Fibre Protocol Module registers. */
1535 iter_reg
= fw
->fpm_hdw_reg
;
1536 iter_reg
= qla24xx_read_window(reg
, 0x4000, 16, iter_reg
);
1537 iter_reg
= qla24xx_read_window(reg
, 0x4010, 16, iter_reg
);
1538 iter_reg
= qla24xx_read_window(reg
, 0x4020, 16, iter_reg
);
1539 iter_reg
= qla24xx_read_window(reg
, 0x4030, 16, iter_reg
);
1540 iter_reg
= qla24xx_read_window(reg
, 0x4040, 16, iter_reg
);
1541 iter_reg
= qla24xx_read_window(reg
, 0x4050, 16, iter_reg
);
1542 iter_reg
= qla24xx_read_window(reg
, 0x4060, 16, iter_reg
);
1543 iter_reg
= qla24xx_read_window(reg
, 0x4070, 16, iter_reg
);
1544 iter_reg
= qla24xx_read_window(reg
, 0x4080, 16, iter_reg
);
1545 iter_reg
= qla24xx_read_window(reg
, 0x4090, 16, iter_reg
);
1546 iter_reg
= qla24xx_read_window(reg
, 0x40A0, 16, iter_reg
);
1547 qla24xx_read_window(reg
, 0x40B0, 16, iter_reg
);
1549 /* Frame Buffer registers. */
1550 iter_reg
= fw
->fb_hdw_reg
;
1551 iter_reg
= qla24xx_read_window(reg
, 0x6000, 16, iter_reg
);
1552 iter_reg
= qla24xx_read_window(reg
, 0x6010, 16, iter_reg
);
1553 iter_reg
= qla24xx_read_window(reg
, 0x6020, 16, iter_reg
);
1554 iter_reg
= qla24xx_read_window(reg
, 0x6030, 16, iter_reg
);
1555 iter_reg
= qla24xx_read_window(reg
, 0x6040, 16, iter_reg
);
1556 iter_reg
= qla24xx_read_window(reg
, 0x6100, 16, iter_reg
);
1557 iter_reg
= qla24xx_read_window(reg
, 0x6130, 16, iter_reg
);
1558 iter_reg
= qla24xx_read_window(reg
, 0x6150, 16, iter_reg
);
1559 iter_reg
= qla24xx_read_window(reg
, 0x6170, 16, iter_reg
);
1560 iter_reg
= qla24xx_read_window(reg
, 0x6190, 16, iter_reg
);
1561 iter_reg
= qla24xx_read_window(reg
, 0x61B0, 16, iter_reg
);
1562 qla24xx_read_window(reg
, 0x6F00, 16, iter_reg
);
1564 /* Multi queue registers */
1565 nxt_chain
= qla25xx_copy_mq(ha
, (void *)ha
->fw_dump
+ ha
->chain_offset
,
1568 rval
= qla24xx_soft_reset(ha
);
1569 if (rval
!= QLA_SUCCESS
)
1570 goto qla25xx_fw_dump_failed_0
;
1572 rval
= qla24xx_dump_memory(ha
, fw
->code_ram
, sizeof(fw
->code_ram
),
1574 if (rval
!= QLA_SUCCESS
)
1575 goto qla25xx_fw_dump_failed_0
;
1577 nxt
= qla2xxx_copy_queues(ha
, nxt
);
1579 qla24xx_copy_eft(ha
, nxt
);
1581 /* Chain entries -- started with MQ. */
1582 nxt_chain
= qla25xx_copy_fce(ha
, nxt_chain
, &last_chain
);
1583 nxt_chain
= qla25xx_copy_mqueues(ha
, nxt_chain
, &last_chain
);
1584 nxt_chain
= qla2xxx_copy_atioqueues(ha
, nxt_chain
, &last_chain
);
1586 ha
->fw_dump
->version
|= __constant_htonl(DUMP_CHAIN_VARIANT
);
1587 *last_chain
|= __constant_htonl(DUMP_CHAIN_LAST
);
1590 /* Adjust valid length. */
1591 ha
->fw_dump_len
= (nxt_chain
- (void *)ha
->fw_dump
);
1593 qla25xx_fw_dump_failed_0
:
1594 qla2xxx_dump_post_process(base_vha
, rval
);
1596 qla25xx_fw_dump_failed
:
1597 if (!hardware_locked
)
1598 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1602 qla81xx_fw_dump(scsi_qla_host_t
*vha
, int hardware_locked
)
1606 uint32_t risc_address
;
1607 struct qla_hw_data
*ha
= vha
->hw
;
1608 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
1609 uint32_t __iomem
*dmp_reg
;
1611 uint16_t __iomem
*mbx_reg
;
1612 unsigned long flags
;
1613 struct qla81xx_fw_dump
*fw
;
1614 uint32_t ext_mem_cnt
;
1615 void *nxt
, *nxt_chain
;
1616 uint32_t *last_chain
= NULL
;
1617 struct scsi_qla_host
*base_vha
= pci_get_drvdata(ha
->pdev
);
1619 risc_address
= ext_mem_cnt
= 0;
1622 if (!hardware_locked
)
1623 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1626 ql_log(ql_log_warn
, vha
, 0xd00a,
1627 "No buffer available for dump.\n");
1628 goto qla81xx_fw_dump_failed
;
1631 if (ha
->fw_dumped
) {
1632 ql_log(ql_log_warn
, vha
, 0xd00b,
1633 "Firmware has been previously dumped (%p) "
1634 "-- ignoring request.\n",
1636 goto qla81xx_fw_dump_failed
;
1638 fw
= &ha
->fw_dump
->isp
.isp81
;
1639 qla2xxx_prep_dump(ha
, ha
->fw_dump
);
1641 fw
->host_status
= htonl(RD_REG_DWORD(®
->host_status
));
1644 rval
= qla24xx_pause_risc(reg
);
1645 if (rval
!= QLA_SUCCESS
)
1646 goto qla81xx_fw_dump_failed_0
;
1648 /* Host/Risc registers. */
1649 iter_reg
= fw
->host_risc_reg
;
1650 iter_reg
= qla24xx_read_window(reg
, 0x7000, 16, iter_reg
);
1651 qla24xx_read_window(reg
, 0x7010, 16, iter_reg
);
1653 /* PCIe registers. */
1654 WRT_REG_DWORD(®
->iobase_addr
, 0x7C00);
1655 RD_REG_DWORD(®
->iobase_addr
);
1656 WRT_REG_DWORD(®
->iobase_window
, 0x01);
1657 dmp_reg
= ®
->iobase_c4
;
1658 fw
->pcie_regs
[0] = htonl(RD_REG_DWORD(dmp_reg
++));
1659 fw
->pcie_regs
[1] = htonl(RD_REG_DWORD(dmp_reg
++));
1660 fw
->pcie_regs
[2] = htonl(RD_REG_DWORD(dmp_reg
));
1661 fw
->pcie_regs
[3] = htonl(RD_REG_DWORD(®
->iobase_window
));
1663 WRT_REG_DWORD(®
->iobase_window
, 0x00);
1664 RD_REG_DWORD(®
->iobase_window
);
1666 /* Host interface registers. */
1667 dmp_reg
= ®
->flash_addr
;
1668 for (cnt
= 0; cnt
< sizeof(fw
->host_reg
) / 4; cnt
++)
1669 fw
->host_reg
[cnt
] = htonl(RD_REG_DWORD(dmp_reg
++));
1671 /* Disable interrupts. */
1672 WRT_REG_DWORD(®
->ictrl
, 0);
1673 RD_REG_DWORD(®
->ictrl
);
1675 /* Shadow registers. */
1676 WRT_REG_DWORD(®
->iobase_addr
, 0x0F70);
1677 RD_REG_DWORD(®
->iobase_addr
);
1678 WRT_REG_DWORD(®
->iobase_select
, 0xB0000000);
1679 fw
->shadow_reg
[0] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1681 WRT_REG_DWORD(®
->iobase_select
, 0xB0100000);
1682 fw
->shadow_reg
[1] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1684 WRT_REG_DWORD(®
->iobase_select
, 0xB0200000);
1685 fw
->shadow_reg
[2] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1687 WRT_REG_DWORD(®
->iobase_select
, 0xB0300000);
1688 fw
->shadow_reg
[3] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1690 WRT_REG_DWORD(®
->iobase_select
, 0xB0400000);
1691 fw
->shadow_reg
[4] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1693 WRT_REG_DWORD(®
->iobase_select
, 0xB0500000);
1694 fw
->shadow_reg
[5] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1696 WRT_REG_DWORD(®
->iobase_select
, 0xB0600000);
1697 fw
->shadow_reg
[6] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1699 WRT_REG_DWORD(®
->iobase_select
, 0xB0700000);
1700 fw
->shadow_reg
[7] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1702 WRT_REG_DWORD(®
->iobase_select
, 0xB0800000);
1703 fw
->shadow_reg
[8] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1705 WRT_REG_DWORD(®
->iobase_select
, 0xB0900000);
1706 fw
->shadow_reg
[9] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1708 WRT_REG_DWORD(®
->iobase_select
, 0xB0A00000);
1709 fw
->shadow_reg
[10] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
1711 /* RISC I/O register. */
1712 WRT_REG_DWORD(®
->iobase_addr
, 0x0010);
1713 fw
->risc_io_reg
= htonl(RD_REG_DWORD(®
->iobase_window
));
1715 /* Mailbox registers. */
1716 mbx_reg
= ®
->mailbox0
;
1717 for (cnt
= 0; cnt
< sizeof(fw
->mailbox_reg
) / 2; cnt
++)
1718 fw
->mailbox_reg
[cnt
] = htons(RD_REG_WORD(mbx_reg
++));
1720 /* Transfer sequence registers. */
1721 iter_reg
= fw
->xseq_gp_reg
;
1722 iter_reg
= qla24xx_read_window(reg
, 0xBF00, 16, iter_reg
);
1723 iter_reg
= qla24xx_read_window(reg
, 0xBF10, 16, iter_reg
);
1724 iter_reg
= qla24xx_read_window(reg
, 0xBF20, 16, iter_reg
);
1725 iter_reg
= qla24xx_read_window(reg
, 0xBF30, 16, iter_reg
);
1726 iter_reg
= qla24xx_read_window(reg
, 0xBF40, 16, iter_reg
);
1727 iter_reg
= qla24xx_read_window(reg
, 0xBF50, 16, iter_reg
);
1728 iter_reg
= qla24xx_read_window(reg
, 0xBF60, 16, iter_reg
);
1729 qla24xx_read_window(reg
, 0xBF70, 16, iter_reg
);
1731 iter_reg
= fw
->xseq_0_reg
;
1732 iter_reg
= qla24xx_read_window(reg
, 0xBFC0, 16, iter_reg
);
1733 iter_reg
= qla24xx_read_window(reg
, 0xBFD0, 16, iter_reg
);
1734 qla24xx_read_window(reg
, 0xBFE0, 16, iter_reg
);
1736 qla24xx_read_window(reg
, 0xBFF0, 16, fw
->xseq_1_reg
);
1738 /* Receive sequence registers. */
1739 iter_reg
= fw
->rseq_gp_reg
;
1740 iter_reg
= qla24xx_read_window(reg
, 0xFF00, 16, iter_reg
);
1741 iter_reg
= qla24xx_read_window(reg
, 0xFF10, 16, iter_reg
);
1742 iter_reg
= qla24xx_read_window(reg
, 0xFF20, 16, iter_reg
);
1743 iter_reg
= qla24xx_read_window(reg
, 0xFF30, 16, iter_reg
);
1744 iter_reg
= qla24xx_read_window(reg
, 0xFF40, 16, iter_reg
);
1745 iter_reg
= qla24xx_read_window(reg
, 0xFF50, 16, iter_reg
);
1746 iter_reg
= qla24xx_read_window(reg
, 0xFF60, 16, iter_reg
);
1747 qla24xx_read_window(reg
, 0xFF70, 16, iter_reg
);
1749 iter_reg
= fw
->rseq_0_reg
;
1750 iter_reg
= qla24xx_read_window(reg
, 0xFFC0, 16, iter_reg
);
1751 qla24xx_read_window(reg
, 0xFFD0, 16, iter_reg
);
1753 qla24xx_read_window(reg
, 0xFFE0, 16, fw
->rseq_1_reg
);
1754 qla24xx_read_window(reg
, 0xFFF0, 16, fw
->rseq_2_reg
);
1756 /* Auxiliary sequence registers. */
1757 iter_reg
= fw
->aseq_gp_reg
;
1758 iter_reg
= qla24xx_read_window(reg
, 0xB000, 16, iter_reg
);
1759 iter_reg
= qla24xx_read_window(reg
, 0xB010, 16, iter_reg
);
1760 iter_reg
= qla24xx_read_window(reg
, 0xB020, 16, iter_reg
);
1761 iter_reg
= qla24xx_read_window(reg
, 0xB030, 16, iter_reg
);
1762 iter_reg
= qla24xx_read_window(reg
, 0xB040, 16, iter_reg
);
1763 iter_reg
= qla24xx_read_window(reg
, 0xB050, 16, iter_reg
);
1764 iter_reg
= qla24xx_read_window(reg
, 0xB060, 16, iter_reg
);
1765 qla24xx_read_window(reg
, 0xB070, 16, iter_reg
);
1767 iter_reg
= fw
->aseq_0_reg
;
1768 iter_reg
= qla24xx_read_window(reg
, 0xB0C0, 16, iter_reg
);
1769 qla24xx_read_window(reg
, 0xB0D0, 16, iter_reg
);
1771 qla24xx_read_window(reg
, 0xB0E0, 16, fw
->aseq_1_reg
);
1772 qla24xx_read_window(reg
, 0xB0F0, 16, fw
->aseq_2_reg
);
1774 /* Command DMA registers. */
1775 qla24xx_read_window(reg
, 0x7100, 16, fw
->cmd_dma_reg
);
1778 iter_reg
= fw
->req0_dma_reg
;
1779 iter_reg
= qla24xx_read_window(reg
, 0x7200, 8, iter_reg
);
1780 dmp_reg
= ®
->iobase_q
;
1781 for (cnt
= 0; cnt
< 7; cnt
++)
1782 *iter_reg
++ = htonl(RD_REG_DWORD(dmp_reg
++));
1784 iter_reg
= fw
->resp0_dma_reg
;
1785 iter_reg
= qla24xx_read_window(reg
, 0x7300, 8, iter_reg
);
1786 dmp_reg
= ®
->iobase_q
;
1787 for (cnt
= 0; cnt
< 7; cnt
++)
1788 *iter_reg
++ = htonl(RD_REG_DWORD(dmp_reg
++));
1790 iter_reg
= fw
->req1_dma_reg
;
1791 iter_reg
= qla24xx_read_window(reg
, 0x7400, 8, iter_reg
);
1792 dmp_reg
= ®
->iobase_q
;
1793 for (cnt
= 0; cnt
< 7; cnt
++)
1794 *iter_reg
++ = htonl(RD_REG_DWORD(dmp_reg
++));
1796 /* Transmit DMA registers. */
1797 iter_reg
= fw
->xmt0_dma_reg
;
1798 iter_reg
= qla24xx_read_window(reg
, 0x7600, 16, iter_reg
);
1799 qla24xx_read_window(reg
, 0x7610, 16, iter_reg
);
1801 iter_reg
= fw
->xmt1_dma_reg
;
1802 iter_reg
= qla24xx_read_window(reg
, 0x7620, 16, iter_reg
);
1803 qla24xx_read_window(reg
, 0x7630, 16, iter_reg
);
1805 iter_reg
= fw
->xmt2_dma_reg
;
1806 iter_reg
= qla24xx_read_window(reg
, 0x7640, 16, iter_reg
);
1807 qla24xx_read_window(reg
, 0x7650, 16, iter_reg
);
1809 iter_reg
= fw
->xmt3_dma_reg
;
1810 iter_reg
= qla24xx_read_window(reg
, 0x7660, 16, iter_reg
);
1811 qla24xx_read_window(reg
, 0x7670, 16, iter_reg
);
1813 iter_reg
= fw
->xmt4_dma_reg
;
1814 iter_reg
= qla24xx_read_window(reg
, 0x7680, 16, iter_reg
);
1815 qla24xx_read_window(reg
, 0x7690, 16, iter_reg
);
1817 qla24xx_read_window(reg
, 0x76A0, 16, fw
->xmt_data_dma_reg
);
1819 /* Receive DMA registers. */
1820 iter_reg
= fw
->rcvt0_data_dma_reg
;
1821 iter_reg
= qla24xx_read_window(reg
, 0x7700, 16, iter_reg
);
1822 qla24xx_read_window(reg
, 0x7710, 16, iter_reg
);
1824 iter_reg
= fw
->rcvt1_data_dma_reg
;
1825 iter_reg
= qla24xx_read_window(reg
, 0x7720, 16, iter_reg
);
1826 qla24xx_read_window(reg
, 0x7730, 16, iter_reg
);
1828 /* RISC registers. */
1829 iter_reg
= fw
->risc_gp_reg
;
1830 iter_reg
= qla24xx_read_window(reg
, 0x0F00, 16, iter_reg
);
1831 iter_reg
= qla24xx_read_window(reg
, 0x0F10, 16, iter_reg
);
1832 iter_reg
= qla24xx_read_window(reg
, 0x0F20, 16, iter_reg
);
1833 iter_reg
= qla24xx_read_window(reg
, 0x0F30, 16, iter_reg
);
1834 iter_reg
= qla24xx_read_window(reg
, 0x0F40, 16, iter_reg
);
1835 iter_reg
= qla24xx_read_window(reg
, 0x0F50, 16, iter_reg
);
1836 iter_reg
= qla24xx_read_window(reg
, 0x0F60, 16, iter_reg
);
1837 qla24xx_read_window(reg
, 0x0F70, 16, iter_reg
);
1839 /* Local memory controller registers. */
1840 iter_reg
= fw
->lmc_reg
;
1841 iter_reg
= qla24xx_read_window(reg
, 0x3000, 16, iter_reg
);
1842 iter_reg
= qla24xx_read_window(reg
, 0x3010, 16, iter_reg
);
1843 iter_reg
= qla24xx_read_window(reg
, 0x3020, 16, iter_reg
);
1844 iter_reg
= qla24xx_read_window(reg
, 0x3030, 16, iter_reg
);
1845 iter_reg
= qla24xx_read_window(reg
, 0x3040, 16, iter_reg
);
1846 iter_reg
= qla24xx_read_window(reg
, 0x3050, 16, iter_reg
);
1847 iter_reg
= qla24xx_read_window(reg
, 0x3060, 16, iter_reg
);
1848 qla24xx_read_window(reg
, 0x3070, 16, iter_reg
);
1850 /* Fibre Protocol Module registers. */
1851 iter_reg
= fw
->fpm_hdw_reg
;
1852 iter_reg
= qla24xx_read_window(reg
, 0x4000, 16, iter_reg
);
1853 iter_reg
= qla24xx_read_window(reg
, 0x4010, 16, iter_reg
);
1854 iter_reg
= qla24xx_read_window(reg
, 0x4020, 16, iter_reg
);
1855 iter_reg
= qla24xx_read_window(reg
, 0x4030, 16, iter_reg
);
1856 iter_reg
= qla24xx_read_window(reg
, 0x4040, 16, iter_reg
);
1857 iter_reg
= qla24xx_read_window(reg
, 0x4050, 16, iter_reg
);
1858 iter_reg
= qla24xx_read_window(reg
, 0x4060, 16, iter_reg
);
1859 iter_reg
= qla24xx_read_window(reg
, 0x4070, 16, iter_reg
);
1860 iter_reg
= qla24xx_read_window(reg
, 0x4080, 16, iter_reg
);
1861 iter_reg
= qla24xx_read_window(reg
, 0x4090, 16, iter_reg
);
1862 iter_reg
= qla24xx_read_window(reg
, 0x40A0, 16, iter_reg
);
1863 iter_reg
= qla24xx_read_window(reg
, 0x40B0, 16, iter_reg
);
1864 iter_reg
= qla24xx_read_window(reg
, 0x40C0, 16, iter_reg
);
1865 qla24xx_read_window(reg
, 0x40D0, 16, iter_reg
);
1867 /* Frame Buffer registers. */
1868 iter_reg
= fw
->fb_hdw_reg
;
1869 iter_reg
= qla24xx_read_window(reg
, 0x6000, 16, iter_reg
);
1870 iter_reg
= qla24xx_read_window(reg
, 0x6010, 16, iter_reg
);
1871 iter_reg
= qla24xx_read_window(reg
, 0x6020, 16, iter_reg
);
1872 iter_reg
= qla24xx_read_window(reg
, 0x6030, 16, iter_reg
);
1873 iter_reg
= qla24xx_read_window(reg
, 0x6040, 16, iter_reg
);
1874 iter_reg
= qla24xx_read_window(reg
, 0x6100, 16, iter_reg
);
1875 iter_reg
= qla24xx_read_window(reg
, 0x6130, 16, iter_reg
);
1876 iter_reg
= qla24xx_read_window(reg
, 0x6150, 16, iter_reg
);
1877 iter_reg
= qla24xx_read_window(reg
, 0x6170, 16, iter_reg
);
1878 iter_reg
= qla24xx_read_window(reg
, 0x6190, 16, iter_reg
);
1879 iter_reg
= qla24xx_read_window(reg
, 0x61B0, 16, iter_reg
);
1880 iter_reg
= qla24xx_read_window(reg
, 0x61C0, 16, iter_reg
);
1881 qla24xx_read_window(reg
, 0x6F00, 16, iter_reg
);
1883 /* Multi queue registers */
1884 nxt_chain
= qla25xx_copy_mq(ha
, (void *)ha
->fw_dump
+ ha
->chain_offset
,
1887 rval
= qla24xx_soft_reset(ha
);
1888 if (rval
!= QLA_SUCCESS
)
1889 goto qla81xx_fw_dump_failed_0
;
1891 rval
= qla24xx_dump_memory(ha
, fw
->code_ram
, sizeof(fw
->code_ram
),
1893 if (rval
!= QLA_SUCCESS
)
1894 goto qla81xx_fw_dump_failed_0
;
1896 nxt
= qla2xxx_copy_queues(ha
, nxt
);
1898 qla24xx_copy_eft(ha
, nxt
);
1900 /* Chain entries -- started with MQ. */
1901 nxt_chain
= qla25xx_copy_fce(ha
, nxt_chain
, &last_chain
);
1902 nxt_chain
= qla25xx_copy_mqueues(ha
, nxt_chain
, &last_chain
);
1903 nxt_chain
= qla2xxx_copy_atioqueues(ha
, nxt_chain
, &last_chain
);
1905 ha
->fw_dump
->version
|= __constant_htonl(DUMP_CHAIN_VARIANT
);
1906 *last_chain
|= __constant_htonl(DUMP_CHAIN_LAST
);
1909 /* Adjust valid length. */
1910 ha
->fw_dump_len
= (nxt_chain
- (void *)ha
->fw_dump
);
1912 qla81xx_fw_dump_failed_0
:
1913 qla2xxx_dump_post_process(base_vha
, rval
);
1915 qla81xx_fw_dump_failed
:
1916 if (!hardware_locked
)
1917 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1921 qla83xx_fw_dump(scsi_qla_host_t
*vha
, int hardware_locked
)
1924 uint32_t cnt
, reg_data
;
1925 uint32_t risc_address
;
1926 struct qla_hw_data
*ha
= vha
->hw
;
1927 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
1928 uint32_t __iomem
*dmp_reg
;
1930 uint16_t __iomem
*mbx_reg
;
1931 unsigned long flags
;
1932 struct qla83xx_fw_dump
*fw
;
1933 uint32_t ext_mem_cnt
;
1934 void *nxt
, *nxt_chain
;
1935 uint32_t *last_chain
= NULL
;
1936 struct scsi_qla_host
*base_vha
= pci_get_drvdata(ha
->pdev
);
1938 risc_address
= ext_mem_cnt
= 0;
1941 if (!hardware_locked
)
1942 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1945 ql_log(ql_log_warn
, vha
, 0xd00c,
1946 "No buffer available for dump!!!\n");
1947 goto qla83xx_fw_dump_failed
;
1950 if (ha
->fw_dumped
) {
1951 ql_log(ql_log_warn
, vha
, 0xd00d,
1952 "Firmware has been previously dumped (%p) -- ignoring "
1953 "request...\n", ha
->fw_dump
);
1954 goto qla83xx_fw_dump_failed
;
1956 fw
= &ha
->fw_dump
->isp
.isp83
;
1957 qla2xxx_prep_dump(ha
, ha
->fw_dump
);
1959 fw
->host_status
= htonl(RD_REG_DWORD(®
->host_status
));
1962 rval
= qla24xx_pause_risc(reg
);
1963 if (rval
!= QLA_SUCCESS
)
1964 goto qla83xx_fw_dump_failed_0
;
1966 WRT_REG_DWORD(®
->iobase_addr
, 0x6000);
1967 dmp_reg
= ®
->iobase_window
;
1968 reg_data
= RD_REG_DWORD(dmp_reg
);
1969 WRT_REG_DWORD(dmp_reg
, 0);
1971 dmp_reg
= ®
->unused_4_1
[0];
1972 reg_data
= RD_REG_DWORD(dmp_reg
);
1973 WRT_REG_DWORD(dmp_reg
, 0);
1975 WRT_REG_DWORD(®
->iobase_addr
, 0x6010);
1976 dmp_reg
= ®
->unused_4_1
[2];
1977 reg_data
= RD_REG_DWORD(dmp_reg
);
1978 WRT_REG_DWORD(dmp_reg
, 0);
1980 /* select PCR and disable ecc checking and correction */
1981 WRT_REG_DWORD(®
->iobase_addr
, 0x0F70);
1982 RD_REG_DWORD(®
->iobase_addr
);
1983 WRT_REG_DWORD(®
->iobase_select
, 0x60000000); /* write to F0h = PCR */
1985 /* Host/Risc registers. */
1986 iter_reg
= fw
->host_risc_reg
;
1987 iter_reg
= qla24xx_read_window(reg
, 0x7000, 16, iter_reg
);
1988 iter_reg
= qla24xx_read_window(reg
, 0x7010, 16, iter_reg
);
1989 qla24xx_read_window(reg
, 0x7040, 16, iter_reg
);
1991 /* PCIe registers. */
1992 WRT_REG_DWORD(®
->iobase_addr
, 0x7C00);
1993 RD_REG_DWORD(®
->iobase_addr
);
1994 WRT_REG_DWORD(®
->iobase_window
, 0x01);
1995 dmp_reg
= ®
->iobase_c4
;
1996 fw
->pcie_regs
[0] = htonl(RD_REG_DWORD(dmp_reg
++));
1997 fw
->pcie_regs
[1] = htonl(RD_REG_DWORD(dmp_reg
++));
1998 fw
->pcie_regs
[2] = htonl(RD_REG_DWORD(dmp_reg
));
1999 fw
->pcie_regs
[3] = htonl(RD_REG_DWORD(®
->iobase_window
));
2001 WRT_REG_DWORD(®
->iobase_window
, 0x00);
2002 RD_REG_DWORD(®
->iobase_window
);
2004 /* Host interface registers. */
2005 dmp_reg
= ®
->flash_addr
;
2006 for (cnt
= 0; cnt
< sizeof(fw
->host_reg
) / 4; cnt
++)
2007 fw
->host_reg
[cnt
] = htonl(RD_REG_DWORD(dmp_reg
++));
2009 /* Disable interrupts. */
2010 WRT_REG_DWORD(®
->ictrl
, 0);
2011 RD_REG_DWORD(®
->ictrl
);
2013 /* Shadow registers. */
2014 WRT_REG_DWORD(®
->iobase_addr
, 0x0F70);
2015 RD_REG_DWORD(®
->iobase_addr
);
2016 WRT_REG_DWORD(®
->iobase_select
, 0xB0000000);
2017 fw
->shadow_reg
[0] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
2019 WRT_REG_DWORD(®
->iobase_select
, 0xB0100000);
2020 fw
->shadow_reg
[1] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
2022 WRT_REG_DWORD(®
->iobase_select
, 0xB0200000);
2023 fw
->shadow_reg
[2] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
2025 WRT_REG_DWORD(®
->iobase_select
, 0xB0300000);
2026 fw
->shadow_reg
[3] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
2028 WRT_REG_DWORD(®
->iobase_select
, 0xB0400000);
2029 fw
->shadow_reg
[4] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
2031 WRT_REG_DWORD(®
->iobase_select
, 0xB0500000);
2032 fw
->shadow_reg
[5] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
2034 WRT_REG_DWORD(®
->iobase_select
, 0xB0600000);
2035 fw
->shadow_reg
[6] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
2037 WRT_REG_DWORD(®
->iobase_select
, 0xB0700000);
2038 fw
->shadow_reg
[7] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
2040 WRT_REG_DWORD(®
->iobase_select
, 0xB0800000);
2041 fw
->shadow_reg
[8] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
2043 WRT_REG_DWORD(®
->iobase_select
, 0xB0900000);
2044 fw
->shadow_reg
[9] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
2046 WRT_REG_DWORD(®
->iobase_select
, 0xB0A00000);
2047 fw
->shadow_reg
[10] = htonl(RD_REG_DWORD(®
->iobase_sdata
));
2049 /* RISC I/O register. */
2050 WRT_REG_DWORD(®
->iobase_addr
, 0x0010);
2051 fw
->risc_io_reg
= htonl(RD_REG_DWORD(®
->iobase_window
));
2053 /* Mailbox registers. */
2054 mbx_reg
= ®
->mailbox0
;
2055 for (cnt
= 0; cnt
< sizeof(fw
->mailbox_reg
) / 2; cnt
++)
2056 fw
->mailbox_reg
[cnt
] = htons(RD_REG_WORD(mbx_reg
++));
2058 /* Transfer sequence registers. */
2059 iter_reg
= fw
->xseq_gp_reg
;
2060 iter_reg
= qla24xx_read_window(reg
, 0xBE00, 16, iter_reg
);
2061 iter_reg
= qla24xx_read_window(reg
, 0xBE10, 16, iter_reg
);
2062 iter_reg
= qla24xx_read_window(reg
, 0xBE20, 16, iter_reg
);
2063 iter_reg
= qla24xx_read_window(reg
, 0xBE30, 16, iter_reg
);
2064 iter_reg
= qla24xx_read_window(reg
, 0xBE40, 16, iter_reg
);
2065 iter_reg
= qla24xx_read_window(reg
, 0xBE50, 16, iter_reg
);
2066 iter_reg
= qla24xx_read_window(reg
, 0xBE60, 16, iter_reg
);
2067 iter_reg
= qla24xx_read_window(reg
, 0xBE70, 16, iter_reg
);
2068 iter_reg
= qla24xx_read_window(reg
, 0xBF00, 16, iter_reg
);
2069 iter_reg
= qla24xx_read_window(reg
, 0xBF10, 16, iter_reg
);
2070 iter_reg
= qla24xx_read_window(reg
, 0xBF20, 16, iter_reg
);
2071 iter_reg
= qla24xx_read_window(reg
, 0xBF30, 16, iter_reg
);
2072 iter_reg
= qla24xx_read_window(reg
, 0xBF40, 16, iter_reg
);
2073 iter_reg
= qla24xx_read_window(reg
, 0xBF50, 16, iter_reg
);
2074 iter_reg
= qla24xx_read_window(reg
, 0xBF60, 16, iter_reg
);
2075 qla24xx_read_window(reg
, 0xBF70, 16, iter_reg
);
2077 iter_reg
= fw
->xseq_0_reg
;
2078 iter_reg
= qla24xx_read_window(reg
, 0xBFC0, 16, iter_reg
);
2079 iter_reg
= qla24xx_read_window(reg
, 0xBFD0, 16, iter_reg
);
2080 qla24xx_read_window(reg
, 0xBFE0, 16, iter_reg
);
2082 qla24xx_read_window(reg
, 0xBFF0, 16, fw
->xseq_1_reg
);
2084 qla24xx_read_window(reg
, 0xBEF0, 16, fw
->xseq_2_reg
);
2086 /* Receive sequence registers. */
2087 iter_reg
= fw
->rseq_gp_reg
;
2088 iter_reg
= qla24xx_read_window(reg
, 0xFE00, 16, iter_reg
);
2089 iter_reg
= qla24xx_read_window(reg
, 0xFE10, 16, iter_reg
);
2090 iter_reg
= qla24xx_read_window(reg
, 0xFE20, 16, iter_reg
);
2091 iter_reg
= qla24xx_read_window(reg
, 0xFE30, 16, iter_reg
);
2092 iter_reg
= qla24xx_read_window(reg
, 0xFE40, 16, iter_reg
);
2093 iter_reg
= qla24xx_read_window(reg
, 0xFE50, 16, iter_reg
);
2094 iter_reg
= qla24xx_read_window(reg
, 0xFE60, 16, iter_reg
);
2095 iter_reg
= qla24xx_read_window(reg
, 0xFE70, 16, iter_reg
);
2096 iter_reg
= qla24xx_read_window(reg
, 0xFF00, 16, iter_reg
);
2097 iter_reg
= qla24xx_read_window(reg
, 0xFF10, 16, iter_reg
);
2098 iter_reg
= qla24xx_read_window(reg
, 0xFF20, 16, iter_reg
);
2099 iter_reg
= qla24xx_read_window(reg
, 0xFF30, 16, iter_reg
);
2100 iter_reg
= qla24xx_read_window(reg
, 0xFF40, 16, iter_reg
);
2101 iter_reg
= qla24xx_read_window(reg
, 0xFF50, 16, iter_reg
);
2102 iter_reg
= qla24xx_read_window(reg
, 0xFF60, 16, iter_reg
);
2103 qla24xx_read_window(reg
, 0xFF70, 16, iter_reg
);
2105 iter_reg
= fw
->rseq_0_reg
;
2106 iter_reg
= qla24xx_read_window(reg
, 0xFFC0, 16, iter_reg
);
2107 qla24xx_read_window(reg
, 0xFFD0, 16, iter_reg
);
2109 qla24xx_read_window(reg
, 0xFFE0, 16, fw
->rseq_1_reg
);
2110 qla24xx_read_window(reg
, 0xFFF0, 16, fw
->rseq_2_reg
);
2111 qla24xx_read_window(reg
, 0xFEF0, 16, fw
->rseq_3_reg
);
2113 /* Auxiliary sequence registers. */
2114 iter_reg
= fw
->aseq_gp_reg
;
2115 iter_reg
= qla24xx_read_window(reg
, 0xB000, 16, iter_reg
);
2116 iter_reg
= qla24xx_read_window(reg
, 0xB010, 16, iter_reg
);
2117 iter_reg
= qla24xx_read_window(reg
, 0xB020, 16, iter_reg
);
2118 iter_reg
= qla24xx_read_window(reg
, 0xB030, 16, iter_reg
);
2119 iter_reg
= qla24xx_read_window(reg
, 0xB040, 16, iter_reg
);
2120 iter_reg
= qla24xx_read_window(reg
, 0xB050, 16, iter_reg
);
2121 iter_reg
= qla24xx_read_window(reg
, 0xB060, 16, iter_reg
);
2122 iter_reg
= qla24xx_read_window(reg
, 0xB070, 16, iter_reg
);
2123 iter_reg
= qla24xx_read_window(reg
, 0xB100, 16, iter_reg
);
2124 iter_reg
= qla24xx_read_window(reg
, 0xB110, 16, iter_reg
);
2125 iter_reg
= qla24xx_read_window(reg
, 0xB120, 16, iter_reg
);
2126 iter_reg
= qla24xx_read_window(reg
, 0xB130, 16, iter_reg
);
2127 iter_reg
= qla24xx_read_window(reg
, 0xB140, 16, iter_reg
);
2128 iter_reg
= qla24xx_read_window(reg
, 0xB150, 16, iter_reg
);
2129 iter_reg
= qla24xx_read_window(reg
, 0xB160, 16, iter_reg
);
2130 qla24xx_read_window(reg
, 0xB170, 16, iter_reg
);
2132 iter_reg
= fw
->aseq_0_reg
;
2133 iter_reg
= qla24xx_read_window(reg
, 0xB0C0, 16, iter_reg
);
2134 qla24xx_read_window(reg
, 0xB0D0, 16, iter_reg
);
2136 qla24xx_read_window(reg
, 0xB0E0, 16, fw
->aseq_1_reg
);
2137 qla24xx_read_window(reg
, 0xB0F0, 16, fw
->aseq_2_reg
);
2138 qla24xx_read_window(reg
, 0xB1F0, 16, fw
->aseq_3_reg
);
2140 /* Command DMA registers. */
2141 iter_reg
= fw
->cmd_dma_reg
;
2142 iter_reg
= qla24xx_read_window(reg
, 0x7100, 16, iter_reg
);
2143 iter_reg
= qla24xx_read_window(reg
, 0x7120, 16, iter_reg
);
2144 iter_reg
= qla24xx_read_window(reg
, 0x7130, 16, iter_reg
);
2145 qla24xx_read_window(reg
, 0x71F0, 16, iter_reg
);
2148 iter_reg
= fw
->req0_dma_reg
;
2149 iter_reg
= qla24xx_read_window(reg
, 0x7200, 8, iter_reg
);
2150 dmp_reg
= ®
->iobase_q
;
2151 for (cnt
= 0; cnt
< 7; cnt
++)
2152 *iter_reg
++ = htonl(RD_REG_DWORD(dmp_reg
++));
2154 iter_reg
= fw
->resp0_dma_reg
;
2155 iter_reg
= qla24xx_read_window(reg
, 0x7300, 8, iter_reg
);
2156 dmp_reg
= ®
->iobase_q
;
2157 for (cnt
= 0; cnt
< 7; cnt
++)
2158 *iter_reg
++ = htonl(RD_REG_DWORD(dmp_reg
++));
2160 iter_reg
= fw
->req1_dma_reg
;
2161 iter_reg
= qla24xx_read_window(reg
, 0x7400, 8, iter_reg
);
2162 dmp_reg
= ®
->iobase_q
;
2163 for (cnt
= 0; cnt
< 7; cnt
++)
2164 *iter_reg
++ = htonl(RD_REG_DWORD(dmp_reg
++));
2166 /* Transmit DMA registers. */
2167 iter_reg
= fw
->xmt0_dma_reg
;
2168 iter_reg
= qla24xx_read_window(reg
, 0x7600, 16, iter_reg
);
2169 qla24xx_read_window(reg
, 0x7610, 16, iter_reg
);
2171 iter_reg
= fw
->xmt1_dma_reg
;
2172 iter_reg
= qla24xx_read_window(reg
, 0x7620, 16, iter_reg
);
2173 qla24xx_read_window(reg
, 0x7630, 16, iter_reg
);
2175 iter_reg
= fw
->xmt2_dma_reg
;
2176 iter_reg
= qla24xx_read_window(reg
, 0x7640, 16, iter_reg
);
2177 qla24xx_read_window(reg
, 0x7650, 16, iter_reg
);
2179 iter_reg
= fw
->xmt3_dma_reg
;
2180 iter_reg
= qla24xx_read_window(reg
, 0x7660, 16, iter_reg
);
2181 qla24xx_read_window(reg
, 0x7670, 16, iter_reg
);
2183 iter_reg
= fw
->xmt4_dma_reg
;
2184 iter_reg
= qla24xx_read_window(reg
, 0x7680, 16, iter_reg
);
2185 qla24xx_read_window(reg
, 0x7690, 16, iter_reg
);
2187 qla24xx_read_window(reg
, 0x76A0, 16, fw
->xmt_data_dma_reg
);
2189 /* Receive DMA registers. */
2190 iter_reg
= fw
->rcvt0_data_dma_reg
;
2191 iter_reg
= qla24xx_read_window(reg
, 0x7700, 16, iter_reg
);
2192 qla24xx_read_window(reg
, 0x7710, 16, iter_reg
);
2194 iter_reg
= fw
->rcvt1_data_dma_reg
;
2195 iter_reg
= qla24xx_read_window(reg
, 0x7720, 16, iter_reg
);
2196 qla24xx_read_window(reg
, 0x7730, 16, iter_reg
);
2198 /* RISC registers. */
2199 iter_reg
= fw
->risc_gp_reg
;
2200 iter_reg
= qla24xx_read_window(reg
, 0x0F00, 16, iter_reg
);
2201 iter_reg
= qla24xx_read_window(reg
, 0x0F10, 16, iter_reg
);
2202 iter_reg
= qla24xx_read_window(reg
, 0x0F20, 16, iter_reg
);
2203 iter_reg
= qla24xx_read_window(reg
, 0x0F30, 16, iter_reg
);
2204 iter_reg
= qla24xx_read_window(reg
, 0x0F40, 16, iter_reg
);
2205 iter_reg
= qla24xx_read_window(reg
, 0x0F50, 16, iter_reg
);
2206 iter_reg
= qla24xx_read_window(reg
, 0x0F60, 16, iter_reg
);
2207 qla24xx_read_window(reg
, 0x0F70, 16, iter_reg
);
2209 /* Local memory controller registers. */
2210 iter_reg
= fw
->lmc_reg
;
2211 iter_reg
= qla24xx_read_window(reg
, 0x3000, 16, iter_reg
);
2212 iter_reg
= qla24xx_read_window(reg
, 0x3010, 16, iter_reg
);
2213 iter_reg
= qla24xx_read_window(reg
, 0x3020, 16, iter_reg
);
2214 iter_reg
= qla24xx_read_window(reg
, 0x3030, 16, iter_reg
);
2215 iter_reg
= qla24xx_read_window(reg
, 0x3040, 16, iter_reg
);
2216 iter_reg
= qla24xx_read_window(reg
, 0x3050, 16, iter_reg
);
2217 iter_reg
= qla24xx_read_window(reg
, 0x3060, 16, iter_reg
);
2218 qla24xx_read_window(reg
, 0x3070, 16, iter_reg
);
2220 /* Fibre Protocol Module registers. */
2221 iter_reg
= fw
->fpm_hdw_reg
;
2222 iter_reg
= qla24xx_read_window(reg
, 0x4000, 16, iter_reg
);
2223 iter_reg
= qla24xx_read_window(reg
, 0x4010, 16, iter_reg
);
2224 iter_reg
= qla24xx_read_window(reg
, 0x4020, 16, iter_reg
);
2225 iter_reg
= qla24xx_read_window(reg
, 0x4030, 16, iter_reg
);
2226 iter_reg
= qla24xx_read_window(reg
, 0x4040, 16, iter_reg
);
2227 iter_reg
= qla24xx_read_window(reg
, 0x4050, 16, iter_reg
);
2228 iter_reg
= qla24xx_read_window(reg
, 0x4060, 16, iter_reg
);
2229 iter_reg
= qla24xx_read_window(reg
, 0x4070, 16, iter_reg
);
2230 iter_reg
= qla24xx_read_window(reg
, 0x4080, 16, iter_reg
);
2231 iter_reg
= qla24xx_read_window(reg
, 0x4090, 16, iter_reg
);
2232 iter_reg
= qla24xx_read_window(reg
, 0x40A0, 16, iter_reg
);
2233 iter_reg
= qla24xx_read_window(reg
, 0x40B0, 16, iter_reg
);
2234 iter_reg
= qla24xx_read_window(reg
, 0x40C0, 16, iter_reg
);
2235 iter_reg
= qla24xx_read_window(reg
, 0x40D0, 16, iter_reg
);
2236 iter_reg
= qla24xx_read_window(reg
, 0x40E0, 16, iter_reg
);
2237 qla24xx_read_window(reg
, 0x40F0, 16, iter_reg
);
2239 /* RQ0 Array registers. */
2240 iter_reg
= fw
->rq0_array_reg
;
2241 iter_reg
= qla24xx_read_window(reg
, 0x5C00, 16, iter_reg
);
2242 iter_reg
= qla24xx_read_window(reg
, 0x5C10, 16, iter_reg
);
2243 iter_reg
= qla24xx_read_window(reg
, 0x5C20, 16, iter_reg
);
2244 iter_reg
= qla24xx_read_window(reg
, 0x5C30, 16, iter_reg
);
2245 iter_reg
= qla24xx_read_window(reg
, 0x5C40, 16, iter_reg
);
2246 iter_reg
= qla24xx_read_window(reg
, 0x5C50, 16, iter_reg
);
2247 iter_reg
= qla24xx_read_window(reg
, 0x5C60, 16, iter_reg
);
2248 iter_reg
= qla24xx_read_window(reg
, 0x5C70, 16, iter_reg
);
2249 iter_reg
= qla24xx_read_window(reg
, 0x5C80, 16, iter_reg
);
2250 iter_reg
= qla24xx_read_window(reg
, 0x5C90, 16, iter_reg
);
2251 iter_reg
= qla24xx_read_window(reg
, 0x5CA0, 16, iter_reg
);
2252 iter_reg
= qla24xx_read_window(reg
, 0x5CB0, 16, iter_reg
);
2253 iter_reg
= qla24xx_read_window(reg
, 0x5CC0, 16, iter_reg
);
2254 iter_reg
= qla24xx_read_window(reg
, 0x5CD0, 16, iter_reg
);
2255 iter_reg
= qla24xx_read_window(reg
, 0x5CE0, 16, iter_reg
);
2256 qla24xx_read_window(reg
, 0x5CF0, 16, iter_reg
);
2258 /* RQ1 Array registers. */
2259 iter_reg
= fw
->rq1_array_reg
;
2260 iter_reg
= qla24xx_read_window(reg
, 0x5D00, 16, iter_reg
);
2261 iter_reg
= qla24xx_read_window(reg
, 0x5D10, 16, iter_reg
);
2262 iter_reg
= qla24xx_read_window(reg
, 0x5D20, 16, iter_reg
);
2263 iter_reg
= qla24xx_read_window(reg
, 0x5D30, 16, iter_reg
);
2264 iter_reg
= qla24xx_read_window(reg
, 0x5D40, 16, iter_reg
);
2265 iter_reg
= qla24xx_read_window(reg
, 0x5D50, 16, iter_reg
);
2266 iter_reg
= qla24xx_read_window(reg
, 0x5D60, 16, iter_reg
);
2267 iter_reg
= qla24xx_read_window(reg
, 0x5D70, 16, iter_reg
);
2268 iter_reg
= qla24xx_read_window(reg
, 0x5D80, 16, iter_reg
);
2269 iter_reg
= qla24xx_read_window(reg
, 0x5D90, 16, iter_reg
);
2270 iter_reg
= qla24xx_read_window(reg
, 0x5DA0, 16, iter_reg
);
2271 iter_reg
= qla24xx_read_window(reg
, 0x5DB0, 16, iter_reg
);
2272 iter_reg
= qla24xx_read_window(reg
, 0x5DC0, 16, iter_reg
);
2273 iter_reg
= qla24xx_read_window(reg
, 0x5DD0, 16, iter_reg
);
2274 iter_reg
= qla24xx_read_window(reg
, 0x5DE0, 16, iter_reg
);
2275 qla24xx_read_window(reg
, 0x5DF0, 16, iter_reg
);
2277 /* RP0 Array registers. */
2278 iter_reg
= fw
->rp0_array_reg
;
2279 iter_reg
= qla24xx_read_window(reg
, 0x5E00, 16, iter_reg
);
2280 iter_reg
= qla24xx_read_window(reg
, 0x5E10, 16, iter_reg
);
2281 iter_reg
= qla24xx_read_window(reg
, 0x5E20, 16, iter_reg
);
2282 iter_reg
= qla24xx_read_window(reg
, 0x5E30, 16, iter_reg
);
2283 iter_reg
= qla24xx_read_window(reg
, 0x5E40, 16, iter_reg
);
2284 iter_reg
= qla24xx_read_window(reg
, 0x5E50, 16, iter_reg
);
2285 iter_reg
= qla24xx_read_window(reg
, 0x5E60, 16, iter_reg
);
2286 iter_reg
= qla24xx_read_window(reg
, 0x5E70, 16, iter_reg
);
2287 iter_reg
= qla24xx_read_window(reg
, 0x5E80, 16, iter_reg
);
2288 iter_reg
= qla24xx_read_window(reg
, 0x5E90, 16, iter_reg
);
2289 iter_reg
= qla24xx_read_window(reg
, 0x5EA0, 16, iter_reg
);
2290 iter_reg
= qla24xx_read_window(reg
, 0x5EB0, 16, iter_reg
);
2291 iter_reg
= qla24xx_read_window(reg
, 0x5EC0, 16, iter_reg
);
2292 iter_reg
= qla24xx_read_window(reg
, 0x5ED0, 16, iter_reg
);
2293 iter_reg
= qla24xx_read_window(reg
, 0x5EE0, 16, iter_reg
);
2294 qla24xx_read_window(reg
, 0x5EF0, 16, iter_reg
);
2296 /* RP1 Array registers. */
2297 iter_reg
= fw
->rp1_array_reg
;
2298 iter_reg
= qla24xx_read_window(reg
, 0x5F00, 16, iter_reg
);
2299 iter_reg
= qla24xx_read_window(reg
, 0x5F10, 16, iter_reg
);
2300 iter_reg
= qla24xx_read_window(reg
, 0x5F20, 16, iter_reg
);
2301 iter_reg
= qla24xx_read_window(reg
, 0x5F30, 16, iter_reg
);
2302 iter_reg
= qla24xx_read_window(reg
, 0x5F40, 16, iter_reg
);
2303 iter_reg
= qla24xx_read_window(reg
, 0x5F50, 16, iter_reg
);
2304 iter_reg
= qla24xx_read_window(reg
, 0x5F60, 16, iter_reg
);
2305 iter_reg
= qla24xx_read_window(reg
, 0x5F70, 16, iter_reg
);
2306 iter_reg
= qla24xx_read_window(reg
, 0x5F80, 16, iter_reg
);
2307 iter_reg
= qla24xx_read_window(reg
, 0x5F90, 16, iter_reg
);
2308 iter_reg
= qla24xx_read_window(reg
, 0x5FA0, 16, iter_reg
);
2309 iter_reg
= qla24xx_read_window(reg
, 0x5FB0, 16, iter_reg
);
2310 iter_reg
= qla24xx_read_window(reg
, 0x5FC0, 16, iter_reg
);
2311 iter_reg
= qla24xx_read_window(reg
, 0x5FD0, 16, iter_reg
);
2312 iter_reg
= qla24xx_read_window(reg
, 0x5FE0, 16, iter_reg
);
2313 qla24xx_read_window(reg
, 0x5FF0, 16, iter_reg
);
2315 iter_reg
= fw
->at0_array_reg
;
2316 iter_reg
= qla24xx_read_window(reg
, 0x7080, 16, iter_reg
);
2317 iter_reg
= qla24xx_read_window(reg
, 0x7090, 16, iter_reg
);
2318 iter_reg
= qla24xx_read_window(reg
, 0x70A0, 16, iter_reg
);
2319 iter_reg
= qla24xx_read_window(reg
, 0x70B0, 16, iter_reg
);
2320 iter_reg
= qla24xx_read_window(reg
, 0x70C0, 16, iter_reg
);
2321 iter_reg
= qla24xx_read_window(reg
, 0x70D0, 16, iter_reg
);
2322 iter_reg
= qla24xx_read_window(reg
, 0x70E0, 16, iter_reg
);
2323 qla24xx_read_window(reg
, 0x70F0, 16, iter_reg
);
2325 /* I/O Queue Control registers. */
2326 qla24xx_read_window(reg
, 0x7800, 16, fw
->queue_control_reg
);
2328 /* Frame Buffer registers. */
2329 iter_reg
= fw
->fb_hdw_reg
;
2330 iter_reg
= qla24xx_read_window(reg
, 0x6000, 16, iter_reg
);
2331 iter_reg
= qla24xx_read_window(reg
, 0x6010, 16, iter_reg
);
2332 iter_reg
= qla24xx_read_window(reg
, 0x6020, 16, iter_reg
);
2333 iter_reg
= qla24xx_read_window(reg
, 0x6030, 16, iter_reg
);
2334 iter_reg
= qla24xx_read_window(reg
, 0x6040, 16, iter_reg
);
2335 iter_reg
= qla24xx_read_window(reg
, 0x6060, 16, iter_reg
);
2336 iter_reg
= qla24xx_read_window(reg
, 0x6070, 16, iter_reg
);
2337 iter_reg
= qla24xx_read_window(reg
, 0x6100, 16, iter_reg
);
2338 iter_reg
= qla24xx_read_window(reg
, 0x6130, 16, iter_reg
);
2339 iter_reg
= qla24xx_read_window(reg
, 0x6150, 16, iter_reg
);
2340 iter_reg
= qla24xx_read_window(reg
, 0x6170, 16, iter_reg
);
2341 iter_reg
= qla24xx_read_window(reg
, 0x6190, 16, iter_reg
);
2342 iter_reg
= qla24xx_read_window(reg
, 0x61B0, 16, iter_reg
);
2343 iter_reg
= qla24xx_read_window(reg
, 0x61C0, 16, iter_reg
);
2344 iter_reg
= qla24xx_read_window(reg
, 0x6530, 16, iter_reg
);
2345 iter_reg
= qla24xx_read_window(reg
, 0x6540, 16, iter_reg
);
2346 iter_reg
= qla24xx_read_window(reg
, 0x6550, 16, iter_reg
);
2347 iter_reg
= qla24xx_read_window(reg
, 0x6560, 16, iter_reg
);
2348 iter_reg
= qla24xx_read_window(reg
, 0x6570, 16, iter_reg
);
2349 iter_reg
= qla24xx_read_window(reg
, 0x6580, 16, iter_reg
);
2350 iter_reg
= qla24xx_read_window(reg
, 0x6590, 16, iter_reg
);
2351 iter_reg
= qla24xx_read_window(reg
, 0x65A0, 16, iter_reg
);
2352 iter_reg
= qla24xx_read_window(reg
, 0x65B0, 16, iter_reg
);
2353 iter_reg
= qla24xx_read_window(reg
, 0x65C0, 16, iter_reg
);
2354 iter_reg
= qla24xx_read_window(reg
, 0x65D0, 16, iter_reg
);
2355 iter_reg
= qla24xx_read_window(reg
, 0x65E0, 16, iter_reg
);
2356 qla24xx_read_window(reg
, 0x6F00, 16, iter_reg
);
2358 /* Multi queue registers */
2359 nxt_chain
= qla25xx_copy_mq(ha
, (void *)ha
->fw_dump
+ ha
->chain_offset
,
2362 rval
= qla24xx_soft_reset(ha
);
2363 if (rval
!= QLA_SUCCESS
) {
2364 ql_log(ql_log_warn
, vha
, 0xd00e,
2365 "SOFT RESET FAILED, forcing continuation of dump!!!\n");
2368 ql_log(ql_log_warn
, vha
, 0xd00f, "try a bigger hammer!!!\n");
2370 WRT_REG_DWORD(®
->hccr
, HCCRX_SET_RISC_RESET
);
2371 RD_REG_DWORD(®
->hccr
);
2373 WRT_REG_DWORD(®
->hccr
, HCCRX_REL_RISC_PAUSE
);
2374 RD_REG_DWORD(®
->hccr
);
2376 WRT_REG_DWORD(®
->hccr
, HCCRX_CLR_RISC_RESET
);
2377 RD_REG_DWORD(®
->hccr
);
2379 for (cnt
= 30000; cnt
&& (RD_REG_WORD(®
->mailbox0
)); cnt
--)
2384 nxt
+= sizeof(fw
->code_ram
);
2385 nxt
+= (ha
->fw_memory_size
- 0x100000 + 1);
2388 ql_log(ql_log_warn
, vha
, 0xd010,
2389 "bigger hammer success?\n");
2392 rval
= qla24xx_dump_memory(ha
, fw
->code_ram
, sizeof(fw
->code_ram
),
2394 if (rval
!= QLA_SUCCESS
)
2395 goto qla83xx_fw_dump_failed_0
;
2398 nxt
= qla2xxx_copy_queues(ha
, nxt
);
2400 qla24xx_copy_eft(ha
, nxt
);
2402 /* Chain entries -- started with MQ. */
2403 nxt_chain
= qla25xx_copy_fce(ha
, nxt_chain
, &last_chain
);
2404 nxt_chain
= qla25xx_copy_mqueues(ha
, nxt_chain
, &last_chain
);
2405 nxt_chain
= qla2xxx_copy_atioqueues(ha
, nxt_chain
, &last_chain
);
2407 ha
->fw_dump
->version
|= __constant_htonl(DUMP_CHAIN_VARIANT
);
2408 *last_chain
|= __constant_htonl(DUMP_CHAIN_LAST
);
2411 /* Adjust valid length. */
2412 ha
->fw_dump_len
= (nxt_chain
- (void *)ha
->fw_dump
);
2414 qla83xx_fw_dump_failed_0
:
2415 qla2xxx_dump_post_process(base_vha
, rval
);
2417 qla83xx_fw_dump_failed
:
2418 if (!hardware_locked
)
2419 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
2422 /****************************************************************************/
2423 /* Driver Debug Functions. */
2424 /****************************************************************************/
2427 ql_mask_match(uint32_t level
)
2429 if (ql2xextended_error_logging
== 1)
2430 ql2xextended_error_logging
= QL_DBG_DEFAULT1_MASK
;
2431 return (level
& ql2xextended_error_logging
) == level
;
2435 * This function is for formatting and logging debug information.
2436 * It is to be used when vha is available. It formats the message
2437 * and logs it to the messages file.
2439 * level: The level of the debug messages to be printed.
2440 * If ql2xextended_error_logging value is correctly set,
2441 * this message will appear in the messages file.
2442 * vha: Pointer to the scsi_qla_host_t.
2443 * id: This is a unique identifier for the level. It identifies the
2444 * part of the code from where the message originated.
2445 * msg: The message to be displayed.
2448 ql_dbg(uint32_t level
, scsi_qla_host_t
*vha
, int32_t id
, const char *fmt
, ...)
2451 struct va_format vaf
;
2453 if (!ql_mask_match(level
))
2462 const struct pci_dev
*pdev
= vha
->hw
->pdev
;
2463 /* <module-name> <pci-name> <msg-id>:<host> Message */
2464 pr_warn("%s [%s]-%04x:%ld: %pV",
2465 QL_MSGHDR
, dev_name(&(pdev
->dev
)), id
+ ql_dbg_offset
,
2466 vha
->host_no
, &vaf
);
2468 pr_warn("%s [%s]-%04x: : %pV",
2469 QL_MSGHDR
, "0000:00:00.0", id
+ ql_dbg_offset
, &vaf
);
2477 * This function is for formatting and logging debug information.
2478 * It is to be used when vha is not available and pci is available,
2479 * i.e., before host allocation. It formats the message and logs it
2480 * to the messages file.
2482 * level: The level of the debug messages to be printed.
2483 * If ql2xextended_error_logging value is correctly set,
2484 * this message will appear in the messages file.
2485 * pdev: Pointer to the struct pci_dev.
2486 * id: This is a unique id for the level. It identifies the part
2487 * of the code from where the message originated.
2488 * msg: The message to be displayed.
2491 ql_dbg_pci(uint32_t level
, struct pci_dev
*pdev
, int32_t id
,
2492 const char *fmt
, ...)
2495 struct va_format vaf
;
2499 if (!ql_mask_match(level
))
2507 /* <module-name> <dev-name>:<msg-id> Message */
2508 pr_warn("%s [%s]-%04x: : %pV",
2509 QL_MSGHDR
, dev_name(&(pdev
->dev
)), id
+ ql_dbg_offset
, &vaf
);
2515 * This function is for formatting and logging log messages.
2516 * It is to be used when vha is available. It formats the message
2517 * and logs it to the messages file. All the messages will be logged
2518 * irrespective of value of ql2xextended_error_logging.
2520 * level: The level of the log messages to be printed in the
2522 * vha: Pointer to the scsi_qla_host_t
2523 * id: This is a unique id for the level. It identifies the
2524 * part of the code from where the message originated.
2525 * msg: The message to be displayed.
2528 ql_log(uint32_t level
, scsi_qla_host_t
*vha
, int32_t id
, const char *fmt
, ...)
2531 struct va_format vaf
;
2534 if (level
> ql_errlev
)
2538 const struct pci_dev
*pdev
= vha
->hw
->pdev
;
2539 /* <module-name> <msg-id>:<host> Message */
2540 snprintf(pbuf
, sizeof(pbuf
), "%s [%s]-%04x:%ld: ",
2541 QL_MSGHDR
, dev_name(&(pdev
->dev
)), id
, vha
->host_no
);
2543 snprintf(pbuf
, sizeof(pbuf
), "%s [%s]-%04x: : ",
2544 QL_MSGHDR
, "0000:00:00.0", id
);
2546 pbuf
[sizeof(pbuf
) - 1] = 0;
2554 case ql_log_fatal
: /* FATAL LOG */
2555 pr_crit("%s%pV", pbuf
, &vaf
);
2558 pr_err("%s%pV", pbuf
, &vaf
);
2561 pr_warn("%s%pV", pbuf
, &vaf
);
2564 pr_info("%s%pV", pbuf
, &vaf
);
2572 * This function is for formatting and logging log messages.
2573 * It is to be used when vha is not available and pci is available,
2574 * i.e., before host allocation. It formats the message and logs
2575 * it to the messages file. All the messages are logged irrespective
2576 * of the value of ql2xextended_error_logging.
2578 * level: The level of the log messages to be printed in the
2580 * pdev: Pointer to the struct pci_dev.
2581 * id: This is a unique id for the level. It identifies the
2582 * part of the code from where the message originated.
2583 * msg: The message to be displayed.
2586 ql_log_pci(uint32_t level
, struct pci_dev
*pdev
, int32_t id
,
2587 const char *fmt
, ...)
2590 struct va_format vaf
;
2595 if (level
> ql_errlev
)
2598 /* <module-name> <dev-name>:<msg-id> Message */
2599 snprintf(pbuf
, sizeof(pbuf
), "%s [%s]-%04x: : ",
2600 QL_MSGHDR
, dev_name(&(pdev
->dev
)), id
);
2601 pbuf
[sizeof(pbuf
) - 1] = 0;
2609 case ql_log_fatal
: /* FATAL LOG */
2610 pr_crit("%s%pV", pbuf
, &vaf
);
2613 pr_err("%s%pV", pbuf
, &vaf
);
2616 pr_warn("%s%pV", pbuf
, &vaf
);
2619 pr_info("%s%pV", pbuf
, &vaf
);
2627 ql_dump_regs(uint32_t level
, scsi_qla_host_t
*vha
, int32_t id
)
2630 struct qla_hw_data
*ha
= vha
->hw
;
2631 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
2632 struct device_reg_24xx __iomem
*reg24
= &ha
->iobase
->isp24
;
2633 struct device_reg_82xx __iomem
*reg82
= &ha
->iobase
->isp82
;
2634 uint16_t __iomem
*mbx_reg
;
2636 if (!ql_mask_match(level
))
2639 if (IS_P3P_TYPE(ha
))
2640 mbx_reg
= ®82
->mailbox_in
[0];
2641 else if (IS_FWI2_CAPABLE(ha
))
2642 mbx_reg
= ®24
->mailbox0
;
2644 mbx_reg
= MAILBOX_REG(ha
, reg
, 0);
2646 ql_dbg(level
, vha
, id
, "Mailbox registers:\n");
2647 for (i
= 0; i
< 6; i
++)
2648 ql_dbg(level
, vha
, id
,
2649 "mbox[%d] 0x%04x\n", i
, RD_REG_WORD(mbx_reg
++));
2654 ql_dump_buffer(uint32_t level
, scsi_qla_host_t
*vha
, int32_t id
,
2655 uint8_t *b
, uint32_t size
)
2660 if (!ql_mask_match(level
))
2663 ql_dbg(level
, vha
, id
, " 0 1 2 3 4 5 6 7 8 "
2664 "9 Ah Bh Ch Dh Eh Fh\n");
2665 ql_dbg(level
, vha
, id
, "----------------------------------"
2666 "----------------------------\n");
2668 ql_dbg(level
, vha
, id
, " ");
2669 for (cnt
= 0; cnt
< size
;) {
2671 printk("%02x", (uint32_t) c
);
2679 ql_dbg(level
, vha
, id
, "\n");