Merge commit 'kumar/kumar-next' into next
[linux-2.6] / drivers / scsi / qla2xxx / qla_dbg.c
1 /*
2  * QLogic Fibre Channel HBA Driver
3  * Copyright (c)  2003-2008 QLogic Corporation
4  *
5  * See LICENSE.qla2xxx for copyright and licensing details.
6  */
7 #include "qla_def.h"
8
9 #include <linux/delay.h>
10
11 static inline void
12 qla2xxx_prep_dump(struct qla_hw_data *ha, struct qla2xxx_fw_dump *fw_dump)
13 {
14         fw_dump->fw_major_version = htonl(ha->fw_major_version);
15         fw_dump->fw_minor_version = htonl(ha->fw_minor_version);
16         fw_dump->fw_subminor_version = htonl(ha->fw_subminor_version);
17         fw_dump->fw_attributes = htonl(ha->fw_attributes);
18
19         fw_dump->vendor = htonl(ha->pdev->vendor);
20         fw_dump->device = htonl(ha->pdev->device);
21         fw_dump->subsystem_vendor = htonl(ha->pdev->subsystem_vendor);
22         fw_dump->subsystem_device = htonl(ha->pdev->subsystem_device);
23 }
24
25 static inline void *
26 qla2xxx_copy_queues(struct qla_hw_data *ha, void *ptr)
27 {
28         struct req_que *req = ha->req_q_map[0];
29         struct rsp_que *rsp = ha->rsp_q_map[0];
30         /* Request queue. */
31         memcpy(ptr, req->ring, req->length *
32             sizeof(request_t));
33
34         /* Response queue. */
35         ptr += req->length * sizeof(request_t);
36         memcpy(ptr, rsp->ring, rsp->length  *
37             sizeof(response_t));
38
39         return ptr + (rsp->length * sizeof(response_t));
40 }
41
42 static int
43 qla24xx_dump_ram(struct qla_hw_data *ha, uint32_t addr, uint32_t *ram,
44     uint32_t ram_dwords, void **nxt)
45 {
46         int rval;
47         uint32_t cnt, stat, timer, dwords, idx;
48         uint16_t mb0;
49         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
50         dma_addr_t dump_dma = ha->gid_list_dma;
51         uint32_t *dump = (uint32_t *)ha->gid_list;
52
53         rval = QLA_SUCCESS;
54         mb0 = 0;
55
56         WRT_REG_WORD(&reg->mailbox0, MBC_DUMP_RISC_RAM_EXTENDED);
57         clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
58
59         dwords = GID_LIST_SIZE / 4;
60         for (cnt = 0; cnt < ram_dwords && rval == QLA_SUCCESS;
61             cnt += dwords, addr += dwords) {
62                 if (cnt + dwords > ram_dwords)
63                         dwords = ram_dwords - cnt;
64
65                 WRT_REG_WORD(&reg->mailbox1, LSW(addr));
66                 WRT_REG_WORD(&reg->mailbox8, MSW(addr));
67
68                 WRT_REG_WORD(&reg->mailbox2, MSW(dump_dma));
69                 WRT_REG_WORD(&reg->mailbox3, LSW(dump_dma));
70                 WRT_REG_WORD(&reg->mailbox6, MSW(MSD(dump_dma)));
71                 WRT_REG_WORD(&reg->mailbox7, LSW(MSD(dump_dma)));
72
73                 WRT_REG_WORD(&reg->mailbox4, MSW(dwords));
74                 WRT_REG_WORD(&reg->mailbox5, LSW(dwords));
75                 WRT_REG_DWORD(&reg->hccr, HCCRX_SET_HOST_INT);
76
77                 for (timer = 6000000; timer; timer--) {
78                         /* Check for pending interrupts. */
79                         stat = RD_REG_DWORD(&reg->host_status);
80                         if (stat & HSRX_RISC_INT) {
81                                 stat &= 0xff;
82
83                                 if (stat == 0x1 || stat == 0x2 ||
84                                     stat == 0x10 || stat == 0x11) {
85                                         set_bit(MBX_INTERRUPT,
86                                             &ha->mbx_cmd_flags);
87
88                                         mb0 = RD_REG_WORD(&reg->mailbox0);
89
90                                         WRT_REG_DWORD(&reg->hccr,
91                                             HCCRX_CLR_RISC_INT);
92                                         RD_REG_DWORD(&reg->hccr);
93                                         break;
94                                 }
95
96                                 /* Clear this intr; it wasn't a mailbox intr */
97                                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
98                                 RD_REG_DWORD(&reg->hccr);
99                         }
100                         udelay(5);
101                 }
102
103                 if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
104                         rval = mb0 & MBS_MASK;
105                         for (idx = 0; idx < dwords; idx++)
106                                 ram[cnt + idx] = swab32(dump[idx]);
107                 } else {
108                         rval = QLA_FUNCTION_FAILED;
109                 }
110         }
111
112         *nxt = rval == QLA_SUCCESS ? &ram[cnt]: NULL;
113         return rval;
114 }
115
116 static int
117 qla24xx_dump_memory(struct qla_hw_data *ha, uint32_t *code_ram,
118     uint32_t cram_size, void **nxt)
119 {
120         int rval;
121
122         /* Code RAM. */
123         rval = qla24xx_dump_ram(ha, 0x20000, code_ram, cram_size / 4, nxt);
124         if (rval != QLA_SUCCESS)
125                 return rval;
126
127         /* External Memory. */
128         return qla24xx_dump_ram(ha, 0x100000, *nxt,
129             ha->fw_memory_size - 0x100000 + 1, nxt);
130 }
131
132 static uint32_t *
133 qla24xx_read_window(struct device_reg_24xx __iomem *reg, uint32_t iobase,
134     uint32_t count, uint32_t *buf)
135 {
136         uint32_t __iomem *dmp_reg;
137
138         WRT_REG_DWORD(&reg->iobase_addr, iobase);
139         dmp_reg = &reg->iobase_window;
140         while (count--)
141                 *buf++ = htonl(RD_REG_DWORD(dmp_reg++));
142
143         return buf;
144 }
145
146 static inline int
147 qla24xx_pause_risc(struct device_reg_24xx __iomem *reg)
148 {
149         int rval = QLA_SUCCESS;
150         uint32_t cnt;
151
152         if (RD_REG_DWORD(&reg->hccr) & HCCRX_RISC_PAUSE)
153                 return rval;
154
155         WRT_REG_DWORD(&reg->hccr, HCCRX_SET_RISC_PAUSE);
156         for (cnt = 30000; (RD_REG_DWORD(&reg->hccr) & HCCRX_RISC_PAUSE) == 0 &&
157             rval == QLA_SUCCESS; cnt--) {
158                 if (cnt)
159                         udelay(100);
160                 else
161                         rval = QLA_FUNCTION_TIMEOUT;
162         }
163
164         return rval;
165 }
166
167 static int
168 qla24xx_soft_reset(struct qla_hw_data *ha)
169 {
170         int rval = QLA_SUCCESS;
171         uint32_t cnt;
172         uint16_t mb0, wd;
173         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
174
175         /* Reset RISC. */
176         WRT_REG_DWORD(&reg->ctrl_status, CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
177         for (cnt = 0; cnt < 30000; cnt++) {
178                 if ((RD_REG_DWORD(&reg->ctrl_status) & CSRX_DMA_ACTIVE) == 0)
179                         break;
180
181                 udelay(10);
182         }
183
184         WRT_REG_DWORD(&reg->ctrl_status,
185             CSRX_ISP_SOFT_RESET|CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
186         pci_read_config_word(ha->pdev, PCI_COMMAND, &wd);
187
188         udelay(100);
189         /* Wait for firmware to complete NVRAM accesses. */
190         mb0 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
191         for (cnt = 10000 ; cnt && mb0; cnt--) {
192                 udelay(5);
193                 mb0 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
194                 barrier();
195         }
196
197         /* Wait for soft-reset to complete. */
198         for (cnt = 0; cnt < 30000; cnt++) {
199                 if ((RD_REG_DWORD(&reg->ctrl_status) &
200                     CSRX_ISP_SOFT_RESET) == 0)
201                         break;
202
203                 udelay(10);
204         }
205         WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_RESET);
206         RD_REG_DWORD(&reg->hccr);             /* PCI Posting. */
207
208         for (cnt = 30000; RD_REG_WORD(&reg->mailbox0) != 0 &&
209             rval == QLA_SUCCESS; cnt--) {
210                 if (cnt)
211                         udelay(100);
212                 else
213                         rval = QLA_FUNCTION_TIMEOUT;
214         }
215
216         return rval;
217 }
218
219 static int
220 qla2xxx_dump_ram(struct qla_hw_data *ha, uint32_t addr, uint16_t *ram,
221     uint16_t ram_words, void **nxt)
222 {
223         int rval;
224         uint32_t cnt, stat, timer, words, idx;
225         uint16_t mb0;
226         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
227         dma_addr_t dump_dma = ha->gid_list_dma;
228         uint16_t *dump = (uint16_t *)ha->gid_list;
229
230         rval = QLA_SUCCESS;
231         mb0 = 0;
232
233         WRT_MAILBOX_REG(ha, reg, 0, MBC_DUMP_RISC_RAM_EXTENDED);
234         clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
235
236         words = GID_LIST_SIZE / 2;
237         for (cnt = 0; cnt < ram_words && rval == QLA_SUCCESS;
238             cnt += words, addr += words) {
239                 if (cnt + words > ram_words)
240                         words = ram_words - cnt;
241
242                 WRT_MAILBOX_REG(ha, reg, 1, LSW(addr));
243                 WRT_MAILBOX_REG(ha, reg, 8, MSW(addr));
244
245                 WRT_MAILBOX_REG(ha, reg, 2, MSW(dump_dma));
246                 WRT_MAILBOX_REG(ha, reg, 3, LSW(dump_dma));
247                 WRT_MAILBOX_REG(ha, reg, 6, MSW(MSD(dump_dma)));
248                 WRT_MAILBOX_REG(ha, reg, 7, LSW(MSD(dump_dma)));
249
250                 WRT_MAILBOX_REG(ha, reg, 4, words);
251                 WRT_REG_WORD(&reg->hccr, HCCR_SET_HOST_INT);
252
253                 for (timer = 6000000; timer; timer--) {
254                         /* Check for pending interrupts. */
255                         stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
256                         if (stat & HSR_RISC_INT) {
257                                 stat &= 0xff;
258
259                                 if (stat == 0x1 || stat == 0x2) {
260                                         set_bit(MBX_INTERRUPT,
261                                             &ha->mbx_cmd_flags);
262
263                                         mb0 = RD_MAILBOX_REG(ha, reg, 0);
264
265                                         /* Release mailbox registers. */
266                                         WRT_REG_WORD(&reg->semaphore, 0);
267                                         WRT_REG_WORD(&reg->hccr,
268                                             HCCR_CLR_RISC_INT);
269                                         RD_REG_WORD(&reg->hccr);
270                                         break;
271                                 } else if (stat == 0x10 || stat == 0x11) {
272                                         set_bit(MBX_INTERRUPT,
273                                             &ha->mbx_cmd_flags);
274
275                                         mb0 = RD_MAILBOX_REG(ha, reg, 0);
276
277                                         WRT_REG_WORD(&reg->hccr,
278                                             HCCR_CLR_RISC_INT);
279                                         RD_REG_WORD(&reg->hccr);
280                                         break;
281                                 }
282
283                                 /* clear this intr; it wasn't a mailbox intr */
284                                 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
285                                 RD_REG_WORD(&reg->hccr);
286                         }
287                         udelay(5);
288                 }
289
290                 if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
291                         rval = mb0 & MBS_MASK;
292                         for (idx = 0; idx < words; idx++)
293                                 ram[cnt + idx] = swab16(dump[idx]);
294                 } else {
295                         rval = QLA_FUNCTION_FAILED;
296                 }
297         }
298
299         *nxt = rval == QLA_SUCCESS ? &ram[cnt]: NULL;
300         return rval;
301 }
302
303 static inline void
304 qla2xxx_read_window(struct device_reg_2xxx __iomem *reg, uint32_t count,
305     uint16_t *buf)
306 {
307         uint16_t __iomem *dmp_reg = &reg->u.isp2300.fb_cmd;
308
309         while (count--)
310                 *buf++ = htons(RD_REG_WORD(dmp_reg++));
311 }
312
313 /**
314  * qla2300_fw_dump() - Dumps binary data from the 2300 firmware.
315  * @ha: HA context
316  * @hardware_locked: Called with the hardware_lock
317  */
318 void
319 qla2300_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
320 {
321         int             rval;
322         uint32_t        cnt;
323         struct qla_hw_data *ha = vha->hw;
324         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
325         uint16_t __iomem *dmp_reg;
326         unsigned long   flags;
327         struct qla2300_fw_dump  *fw;
328         void            *nxt;
329         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
330
331         flags = 0;
332
333         if (!hardware_locked)
334                 spin_lock_irqsave(&ha->hardware_lock, flags);
335
336         if (!ha->fw_dump) {
337                 qla_printk(KERN_WARNING, ha,
338                     "No buffer available for dump!!!\n");
339                 goto qla2300_fw_dump_failed;
340         }
341
342         if (ha->fw_dumped) {
343                 qla_printk(KERN_WARNING, ha,
344                     "Firmware has been previously dumped (%p) -- ignoring "
345                     "request...\n", ha->fw_dump);
346                 goto qla2300_fw_dump_failed;
347         }
348         fw = &ha->fw_dump->isp.isp23;
349         qla2xxx_prep_dump(ha, ha->fw_dump);
350
351         rval = QLA_SUCCESS;
352         fw->hccr = htons(RD_REG_WORD(&reg->hccr));
353
354         /* Pause RISC. */
355         WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
356         if (IS_QLA2300(ha)) {
357                 for (cnt = 30000;
358                     (RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) == 0 &&
359                         rval == QLA_SUCCESS; cnt--) {
360                         if (cnt)
361                                 udelay(100);
362                         else
363                                 rval = QLA_FUNCTION_TIMEOUT;
364                 }
365         } else {
366                 RD_REG_WORD(&reg->hccr);                /* PCI Posting. */
367                 udelay(10);
368         }
369
370         if (rval == QLA_SUCCESS) {
371                 dmp_reg = &reg->flash_address;
372                 for (cnt = 0; cnt < sizeof(fw->pbiu_reg) / 2; cnt++)
373                         fw->pbiu_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
374
375                 dmp_reg = &reg->u.isp2300.req_q_in;
376                 for (cnt = 0; cnt < sizeof(fw->risc_host_reg) / 2; cnt++)
377                         fw->risc_host_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
378
379                 dmp_reg = &reg->u.isp2300.mailbox0;
380                 for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2; cnt++)
381                         fw->mailbox_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
382
383                 WRT_REG_WORD(&reg->ctrl_status, 0x40);
384                 qla2xxx_read_window(reg, 32, fw->resp_dma_reg);
385
386                 WRT_REG_WORD(&reg->ctrl_status, 0x50);
387                 qla2xxx_read_window(reg, 48, fw->dma_reg);
388
389                 WRT_REG_WORD(&reg->ctrl_status, 0x00);
390                 dmp_reg = &reg->risc_hw;
391                 for (cnt = 0; cnt < sizeof(fw->risc_hdw_reg) / 2; cnt++)
392                         fw->risc_hdw_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
393
394                 WRT_REG_WORD(&reg->pcr, 0x2000);
395                 qla2xxx_read_window(reg, 16, fw->risc_gp0_reg);
396
397                 WRT_REG_WORD(&reg->pcr, 0x2200);
398                 qla2xxx_read_window(reg, 16, fw->risc_gp1_reg);
399
400                 WRT_REG_WORD(&reg->pcr, 0x2400);
401                 qla2xxx_read_window(reg, 16, fw->risc_gp2_reg);
402
403                 WRT_REG_WORD(&reg->pcr, 0x2600);
404                 qla2xxx_read_window(reg, 16, fw->risc_gp3_reg);
405
406                 WRT_REG_WORD(&reg->pcr, 0x2800);
407                 qla2xxx_read_window(reg, 16, fw->risc_gp4_reg);
408
409                 WRT_REG_WORD(&reg->pcr, 0x2A00);
410                 qla2xxx_read_window(reg, 16, fw->risc_gp5_reg);
411
412                 WRT_REG_WORD(&reg->pcr, 0x2C00);
413                 qla2xxx_read_window(reg, 16, fw->risc_gp6_reg);
414
415                 WRT_REG_WORD(&reg->pcr, 0x2E00);
416                 qla2xxx_read_window(reg, 16, fw->risc_gp7_reg);
417
418                 WRT_REG_WORD(&reg->ctrl_status, 0x10);
419                 qla2xxx_read_window(reg, 64, fw->frame_buf_hdw_reg);
420
421                 WRT_REG_WORD(&reg->ctrl_status, 0x20);
422                 qla2xxx_read_window(reg, 64, fw->fpm_b0_reg);
423
424                 WRT_REG_WORD(&reg->ctrl_status, 0x30);
425                 qla2xxx_read_window(reg, 64, fw->fpm_b1_reg);
426
427                 /* Reset RISC. */
428                 WRT_REG_WORD(&reg->ctrl_status, CSR_ISP_SOFT_RESET);
429                 for (cnt = 0; cnt < 30000; cnt++) {
430                         if ((RD_REG_WORD(&reg->ctrl_status) &
431                             CSR_ISP_SOFT_RESET) == 0)
432                                 break;
433
434                         udelay(10);
435                 }
436         }
437
438         if (!IS_QLA2300(ha)) {
439                 for (cnt = 30000; RD_MAILBOX_REG(ha, reg, 0) != 0 &&
440                     rval == QLA_SUCCESS; cnt--) {
441                         if (cnt)
442                                 udelay(100);
443                         else
444                                 rval = QLA_FUNCTION_TIMEOUT;
445                 }
446         }
447
448         /* Get RISC SRAM. */
449         if (rval == QLA_SUCCESS)
450                 rval = qla2xxx_dump_ram(ha, 0x800, fw->risc_ram,
451                     sizeof(fw->risc_ram) / 2, &nxt);
452
453         /* Get stack SRAM. */
454         if (rval == QLA_SUCCESS)
455                 rval = qla2xxx_dump_ram(ha, 0x10000, fw->stack_ram,
456                     sizeof(fw->stack_ram) / 2, &nxt);
457
458         /* Get data SRAM. */
459         if (rval == QLA_SUCCESS)
460                 rval = qla2xxx_dump_ram(ha, 0x11000, fw->data_ram,
461                     ha->fw_memory_size - 0x11000 + 1, &nxt);
462
463         if (rval == QLA_SUCCESS)
464                 qla2xxx_copy_queues(ha, nxt);
465
466         if (rval != QLA_SUCCESS) {
467                 qla_printk(KERN_WARNING, ha,
468                     "Failed to dump firmware (%x)!!!\n", rval);
469                 ha->fw_dumped = 0;
470
471         } else {
472                 qla_printk(KERN_INFO, ha,
473                     "Firmware dump saved to temp buffer (%ld/%p).\n",
474                     base_vha->host_no, ha->fw_dump);
475                 ha->fw_dumped = 1;
476         }
477
478 qla2300_fw_dump_failed:
479         if (!hardware_locked)
480                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
481 }
482
483 /**
484  * qla2100_fw_dump() - Dumps binary data from the 2100/2200 firmware.
485  * @ha: HA context
486  * @hardware_locked: Called with the hardware_lock
487  */
488 void
489 qla2100_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
490 {
491         int             rval;
492         uint32_t        cnt, timer;
493         uint16_t        risc_address;
494         uint16_t        mb0, mb2;
495         struct qla_hw_data *ha = vha->hw;
496         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
497         uint16_t __iomem *dmp_reg;
498         unsigned long   flags;
499         struct qla2100_fw_dump  *fw;
500         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
501
502         risc_address = 0;
503         mb0 = mb2 = 0;
504         flags = 0;
505
506         if (!hardware_locked)
507                 spin_lock_irqsave(&ha->hardware_lock, flags);
508
509         if (!ha->fw_dump) {
510                 qla_printk(KERN_WARNING, ha,
511                     "No buffer available for dump!!!\n");
512                 goto qla2100_fw_dump_failed;
513         }
514
515         if (ha->fw_dumped) {
516                 qla_printk(KERN_WARNING, ha,
517                     "Firmware has been previously dumped (%p) -- ignoring "
518                     "request...\n", ha->fw_dump);
519                 goto qla2100_fw_dump_failed;
520         }
521         fw = &ha->fw_dump->isp.isp21;
522         qla2xxx_prep_dump(ha, ha->fw_dump);
523
524         rval = QLA_SUCCESS;
525         fw->hccr = htons(RD_REG_WORD(&reg->hccr));
526
527         /* Pause RISC. */
528         WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
529         for (cnt = 30000; (RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) == 0 &&
530             rval == QLA_SUCCESS; cnt--) {
531                 if (cnt)
532                         udelay(100);
533                 else
534                         rval = QLA_FUNCTION_TIMEOUT;
535         }
536         if (rval == QLA_SUCCESS) {
537                 dmp_reg = &reg->flash_address;
538                 for (cnt = 0; cnt < sizeof(fw->pbiu_reg) / 2; cnt++)
539                         fw->pbiu_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
540
541                 dmp_reg = &reg->u.isp2100.mailbox0;
542                 for (cnt = 0; cnt < ha->mbx_count; cnt++) {
543                         if (cnt == 8)
544                                 dmp_reg = &reg->u_end.isp2200.mailbox8;
545
546                         fw->mailbox_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
547                 }
548
549                 dmp_reg = &reg->u.isp2100.unused_2[0];
550                 for (cnt = 0; cnt < sizeof(fw->dma_reg) / 2; cnt++)
551                         fw->dma_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
552
553                 WRT_REG_WORD(&reg->ctrl_status, 0x00);
554                 dmp_reg = &reg->risc_hw;
555                 for (cnt = 0; cnt < sizeof(fw->risc_hdw_reg) / 2; cnt++)
556                         fw->risc_hdw_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
557
558                 WRT_REG_WORD(&reg->pcr, 0x2000);
559                 qla2xxx_read_window(reg, 16, fw->risc_gp0_reg);
560
561                 WRT_REG_WORD(&reg->pcr, 0x2100);
562                 qla2xxx_read_window(reg, 16, fw->risc_gp1_reg);
563
564                 WRT_REG_WORD(&reg->pcr, 0x2200);
565                 qla2xxx_read_window(reg, 16, fw->risc_gp2_reg);
566
567                 WRT_REG_WORD(&reg->pcr, 0x2300);
568                 qla2xxx_read_window(reg, 16, fw->risc_gp3_reg);
569
570                 WRT_REG_WORD(&reg->pcr, 0x2400);
571                 qla2xxx_read_window(reg, 16, fw->risc_gp4_reg);
572
573                 WRT_REG_WORD(&reg->pcr, 0x2500);
574                 qla2xxx_read_window(reg, 16, fw->risc_gp5_reg);
575
576                 WRT_REG_WORD(&reg->pcr, 0x2600);
577                 qla2xxx_read_window(reg, 16, fw->risc_gp6_reg);
578
579                 WRT_REG_WORD(&reg->pcr, 0x2700);
580                 qla2xxx_read_window(reg, 16, fw->risc_gp7_reg);
581
582                 WRT_REG_WORD(&reg->ctrl_status, 0x10);
583                 qla2xxx_read_window(reg, 16, fw->frame_buf_hdw_reg);
584
585                 WRT_REG_WORD(&reg->ctrl_status, 0x20);
586                 qla2xxx_read_window(reg, 64, fw->fpm_b0_reg);
587
588                 WRT_REG_WORD(&reg->ctrl_status, 0x30);
589                 qla2xxx_read_window(reg, 64, fw->fpm_b1_reg);
590
591                 /* Reset the ISP. */
592                 WRT_REG_WORD(&reg->ctrl_status, CSR_ISP_SOFT_RESET);
593         }
594
595         for (cnt = 30000; RD_MAILBOX_REG(ha, reg, 0) != 0 &&
596             rval == QLA_SUCCESS; cnt--) {
597                 if (cnt)
598                         udelay(100);
599                 else
600                         rval = QLA_FUNCTION_TIMEOUT;
601         }
602
603         /* Pause RISC. */
604         if (rval == QLA_SUCCESS && (IS_QLA2200(ha) || (IS_QLA2100(ha) &&
605             (RD_REG_WORD(&reg->mctr) & (BIT_1 | BIT_0)) != 0))) {
606
607                 WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
608                 for (cnt = 30000;
609                     (RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) == 0 &&
610                     rval == QLA_SUCCESS; cnt--) {
611                         if (cnt)
612                                 udelay(100);
613                         else
614                                 rval = QLA_FUNCTION_TIMEOUT;
615                 }
616                 if (rval == QLA_SUCCESS) {
617                         /* Set memory configuration and timing. */
618                         if (IS_QLA2100(ha))
619                                 WRT_REG_WORD(&reg->mctr, 0xf1);
620                         else
621                                 WRT_REG_WORD(&reg->mctr, 0xf2);
622                         RD_REG_WORD(&reg->mctr);        /* PCI Posting. */
623
624                         /* Release RISC. */
625                         WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
626                 }
627         }
628
629         if (rval == QLA_SUCCESS) {
630                 /* Get RISC SRAM. */
631                 risc_address = 0x1000;
632                 WRT_MAILBOX_REG(ha, reg, 0, MBC_READ_RAM_WORD);
633                 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
634         }
635         for (cnt = 0; cnt < sizeof(fw->risc_ram) / 2 && rval == QLA_SUCCESS;
636             cnt++, risc_address++) {
637                 WRT_MAILBOX_REG(ha, reg, 1, risc_address);
638                 WRT_REG_WORD(&reg->hccr, HCCR_SET_HOST_INT);
639
640                 for (timer = 6000000; timer != 0; timer--) {
641                         /* Check for pending interrupts. */
642                         if (RD_REG_WORD(&reg->istatus) & ISR_RISC_INT) {
643                                 if (RD_REG_WORD(&reg->semaphore) & BIT_0) {
644                                         set_bit(MBX_INTERRUPT,
645                                             &ha->mbx_cmd_flags);
646
647                                         mb0 = RD_MAILBOX_REG(ha, reg, 0);
648                                         mb2 = RD_MAILBOX_REG(ha, reg, 2);
649
650                                         WRT_REG_WORD(&reg->semaphore, 0);
651                                         WRT_REG_WORD(&reg->hccr,
652                                             HCCR_CLR_RISC_INT);
653                                         RD_REG_WORD(&reg->hccr);
654                                         break;
655                                 }
656                                 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
657                                 RD_REG_WORD(&reg->hccr);
658                         }
659                         udelay(5);
660                 }
661
662                 if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
663                         rval = mb0 & MBS_MASK;
664                         fw->risc_ram[cnt] = htons(mb2);
665                 } else {
666                         rval = QLA_FUNCTION_FAILED;
667                 }
668         }
669
670         if (rval == QLA_SUCCESS)
671                 qla2xxx_copy_queues(ha, &fw->risc_ram[cnt]);
672
673         if (rval != QLA_SUCCESS) {
674                 qla_printk(KERN_WARNING, ha,
675                     "Failed to dump firmware (%x)!!!\n", rval);
676                 ha->fw_dumped = 0;
677
678         } else {
679                 qla_printk(KERN_INFO, ha,
680                     "Firmware dump saved to temp buffer (%ld/%p).\n",
681                     base_vha->host_no, ha->fw_dump);
682                 ha->fw_dumped = 1;
683         }
684
685 qla2100_fw_dump_failed:
686         if (!hardware_locked)
687                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
688 }
689
690 void
691 qla24xx_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
692 {
693         int             rval;
694         uint32_t        cnt;
695         uint32_t        risc_address;
696         struct qla_hw_data *ha = vha->hw;
697         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
698         uint32_t __iomem *dmp_reg;
699         uint32_t        *iter_reg;
700         uint16_t __iomem *mbx_reg;
701         unsigned long   flags;
702         struct qla24xx_fw_dump *fw;
703         uint32_t        ext_mem_cnt;
704         void            *nxt;
705         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
706
707         risc_address = ext_mem_cnt = 0;
708         flags = 0;
709
710         if (!hardware_locked)
711                 spin_lock_irqsave(&ha->hardware_lock, flags);
712
713         if (!ha->fw_dump) {
714                 qla_printk(KERN_WARNING, ha,
715                     "No buffer available for dump!!!\n");
716                 goto qla24xx_fw_dump_failed;
717         }
718
719         if (ha->fw_dumped) {
720                 qla_printk(KERN_WARNING, ha,
721                     "Firmware has been previously dumped (%p) -- ignoring "
722                     "request...\n", ha->fw_dump);
723                 goto qla24xx_fw_dump_failed;
724         }
725         fw = &ha->fw_dump->isp.isp24;
726         qla2xxx_prep_dump(ha, ha->fw_dump);
727
728         fw->host_status = htonl(RD_REG_DWORD(&reg->host_status));
729
730         /* Pause RISC. */
731         rval = qla24xx_pause_risc(reg);
732         if (rval != QLA_SUCCESS)
733                 goto qla24xx_fw_dump_failed_0;
734
735         /* Host interface registers. */
736         dmp_reg = &reg->flash_addr;
737         for (cnt = 0; cnt < sizeof(fw->host_reg) / 4; cnt++)
738                 fw->host_reg[cnt] = htonl(RD_REG_DWORD(dmp_reg++));
739
740         /* Disable interrupts. */
741         WRT_REG_DWORD(&reg->ictrl, 0);
742         RD_REG_DWORD(&reg->ictrl);
743
744         /* Shadow registers. */
745         WRT_REG_DWORD(&reg->iobase_addr, 0x0F70);
746         RD_REG_DWORD(&reg->iobase_addr);
747         WRT_REG_DWORD(&reg->iobase_select, 0xB0000000);
748         fw->shadow_reg[0] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
749
750         WRT_REG_DWORD(&reg->iobase_select, 0xB0100000);
751         fw->shadow_reg[1] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
752
753         WRT_REG_DWORD(&reg->iobase_select, 0xB0200000);
754         fw->shadow_reg[2] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
755
756         WRT_REG_DWORD(&reg->iobase_select, 0xB0300000);
757         fw->shadow_reg[3] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
758
759         WRT_REG_DWORD(&reg->iobase_select, 0xB0400000);
760         fw->shadow_reg[4] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
761
762         WRT_REG_DWORD(&reg->iobase_select, 0xB0500000);
763         fw->shadow_reg[5] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
764
765         WRT_REG_DWORD(&reg->iobase_select, 0xB0600000);
766         fw->shadow_reg[6] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
767
768         /* Mailbox registers. */
769         mbx_reg = &reg->mailbox0;
770         for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2; cnt++)
771                 fw->mailbox_reg[cnt] = htons(RD_REG_WORD(mbx_reg++));
772
773         /* Transfer sequence registers. */
774         iter_reg = fw->xseq_gp_reg;
775         iter_reg = qla24xx_read_window(reg, 0xBF00, 16, iter_reg);
776         iter_reg = qla24xx_read_window(reg, 0xBF10, 16, iter_reg);
777         iter_reg = qla24xx_read_window(reg, 0xBF20, 16, iter_reg);
778         iter_reg = qla24xx_read_window(reg, 0xBF30, 16, iter_reg);
779         iter_reg = qla24xx_read_window(reg, 0xBF40, 16, iter_reg);
780         iter_reg = qla24xx_read_window(reg, 0xBF50, 16, iter_reg);
781         iter_reg = qla24xx_read_window(reg, 0xBF60, 16, iter_reg);
782         qla24xx_read_window(reg, 0xBF70, 16, iter_reg);
783
784         qla24xx_read_window(reg, 0xBFE0, 16, fw->xseq_0_reg);
785         qla24xx_read_window(reg, 0xBFF0, 16, fw->xseq_1_reg);
786
787         /* Receive sequence registers. */
788         iter_reg = fw->rseq_gp_reg;
789         iter_reg = qla24xx_read_window(reg, 0xFF00, 16, iter_reg);
790         iter_reg = qla24xx_read_window(reg, 0xFF10, 16, iter_reg);
791         iter_reg = qla24xx_read_window(reg, 0xFF20, 16, iter_reg);
792         iter_reg = qla24xx_read_window(reg, 0xFF30, 16, iter_reg);
793         iter_reg = qla24xx_read_window(reg, 0xFF40, 16, iter_reg);
794         iter_reg = qla24xx_read_window(reg, 0xFF50, 16, iter_reg);
795         iter_reg = qla24xx_read_window(reg, 0xFF60, 16, iter_reg);
796         qla24xx_read_window(reg, 0xFF70, 16, iter_reg);
797
798         qla24xx_read_window(reg, 0xFFD0, 16, fw->rseq_0_reg);
799         qla24xx_read_window(reg, 0xFFE0, 16, fw->rseq_1_reg);
800         qla24xx_read_window(reg, 0xFFF0, 16, fw->rseq_2_reg);
801
802         /* Command DMA registers. */
803         qla24xx_read_window(reg, 0x7100, 16, fw->cmd_dma_reg);
804
805         /* Queues. */
806         iter_reg = fw->req0_dma_reg;
807         iter_reg = qla24xx_read_window(reg, 0x7200, 8, iter_reg);
808         dmp_reg = &reg->iobase_q;
809         for (cnt = 0; cnt < 7; cnt++)
810                 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
811
812         iter_reg = fw->resp0_dma_reg;
813         iter_reg = qla24xx_read_window(reg, 0x7300, 8, iter_reg);
814         dmp_reg = &reg->iobase_q;
815         for (cnt = 0; cnt < 7; cnt++)
816                 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
817
818         iter_reg = fw->req1_dma_reg;
819         iter_reg = qla24xx_read_window(reg, 0x7400, 8, iter_reg);
820         dmp_reg = &reg->iobase_q;
821         for (cnt = 0; cnt < 7; cnt++)
822                 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
823
824         /* Transmit DMA registers. */
825         iter_reg = fw->xmt0_dma_reg;
826         iter_reg = qla24xx_read_window(reg, 0x7600, 16, iter_reg);
827         qla24xx_read_window(reg, 0x7610, 16, iter_reg);
828
829         iter_reg = fw->xmt1_dma_reg;
830         iter_reg = qla24xx_read_window(reg, 0x7620, 16, iter_reg);
831         qla24xx_read_window(reg, 0x7630, 16, iter_reg);
832
833         iter_reg = fw->xmt2_dma_reg;
834         iter_reg = qla24xx_read_window(reg, 0x7640, 16, iter_reg);
835         qla24xx_read_window(reg, 0x7650, 16, iter_reg);
836
837         iter_reg = fw->xmt3_dma_reg;
838         iter_reg = qla24xx_read_window(reg, 0x7660, 16, iter_reg);
839         qla24xx_read_window(reg, 0x7670, 16, iter_reg);
840
841         iter_reg = fw->xmt4_dma_reg;
842         iter_reg = qla24xx_read_window(reg, 0x7680, 16, iter_reg);
843         qla24xx_read_window(reg, 0x7690, 16, iter_reg);
844
845         qla24xx_read_window(reg, 0x76A0, 16, fw->xmt_data_dma_reg);
846
847         /* Receive DMA registers. */
848         iter_reg = fw->rcvt0_data_dma_reg;
849         iter_reg = qla24xx_read_window(reg, 0x7700, 16, iter_reg);
850         qla24xx_read_window(reg, 0x7710, 16, iter_reg);
851
852         iter_reg = fw->rcvt1_data_dma_reg;
853         iter_reg = qla24xx_read_window(reg, 0x7720, 16, iter_reg);
854         qla24xx_read_window(reg, 0x7730, 16, iter_reg);
855
856         /* RISC registers. */
857         iter_reg = fw->risc_gp_reg;
858         iter_reg = qla24xx_read_window(reg, 0x0F00, 16, iter_reg);
859         iter_reg = qla24xx_read_window(reg, 0x0F10, 16, iter_reg);
860         iter_reg = qla24xx_read_window(reg, 0x0F20, 16, iter_reg);
861         iter_reg = qla24xx_read_window(reg, 0x0F30, 16, iter_reg);
862         iter_reg = qla24xx_read_window(reg, 0x0F40, 16, iter_reg);
863         iter_reg = qla24xx_read_window(reg, 0x0F50, 16, iter_reg);
864         iter_reg = qla24xx_read_window(reg, 0x0F60, 16, iter_reg);
865         qla24xx_read_window(reg, 0x0F70, 16, iter_reg);
866
867         /* Local memory controller registers. */
868         iter_reg = fw->lmc_reg;
869         iter_reg = qla24xx_read_window(reg, 0x3000, 16, iter_reg);
870         iter_reg = qla24xx_read_window(reg, 0x3010, 16, iter_reg);
871         iter_reg = qla24xx_read_window(reg, 0x3020, 16, iter_reg);
872         iter_reg = qla24xx_read_window(reg, 0x3030, 16, iter_reg);
873         iter_reg = qla24xx_read_window(reg, 0x3040, 16, iter_reg);
874         iter_reg = qla24xx_read_window(reg, 0x3050, 16, iter_reg);
875         qla24xx_read_window(reg, 0x3060, 16, iter_reg);
876
877         /* Fibre Protocol Module registers. */
878         iter_reg = fw->fpm_hdw_reg;
879         iter_reg = qla24xx_read_window(reg, 0x4000, 16, iter_reg);
880         iter_reg = qla24xx_read_window(reg, 0x4010, 16, iter_reg);
881         iter_reg = qla24xx_read_window(reg, 0x4020, 16, iter_reg);
882         iter_reg = qla24xx_read_window(reg, 0x4030, 16, iter_reg);
883         iter_reg = qla24xx_read_window(reg, 0x4040, 16, iter_reg);
884         iter_reg = qla24xx_read_window(reg, 0x4050, 16, iter_reg);
885         iter_reg = qla24xx_read_window(reg, 0x4060, 16, iter_reg);
886         iter_reg = qla24xx_read_window(reg, 0x4070, 16, iter_reg);
887         iter_reg = qla24xx_read_window(reg, 0x4080, 16, iter_reg);
888         iter_reg = qla24xx_read_window(reg, 0x4090, 16, iter_reg);
889         iter_reg = qla24xx_read_window(reg, 0x40A0, 16, iter_reg);
890         qla24xx_read_window(reg, 0x40B0, 16, iter_reg);
891
892         /* Frame Buffer registers. */
893         iter_reg = fw->fb_hdw_reg;
894         iter_reg = qla24xx_read_window(reg, 0x6000, 16, iter_reg);
895         iter_reg = qla24xx_read_window(reg, 0x6010, 16, iter_reg);
896         iter_reg = qla24xx_read_window(reg, 0x6020, 16, iter_reg);
897         iter_reg = qla24xx_read_window(reg, 0x6030, 16, iter_reg);
898         iter_reg = qla24xx_read_window(reg, 0x6040, 16, iter_reg);
899         iter_reg = qla24xx_read_window(reg, 0x6100, 16, iter_reg);
900         iter_reg = qla24xx_read_window(reg, 0x6130, 16, iter_reg);
901         iter_reg = qla24xx_read_window(reg, 0x6150, 16, iter_reg);
902         iter_reg = qla24xx_read_window(reg, 0x6170, 16, iter_reg);
903         iter_reg = qla24xx_read_window(reg, 0x6190, 16, iter_reg);
904         qla24xx_read_window(reg, 0x61B0, 16, iter_reg);
905
906         rval = qla24xx_soft_reset(ha);
907         if (rval != QLA_SUCCESS)
908                 goto qla24xx_fw_dump_failed_0;
909
910         rval = qla24xx_dump_memory(ha, fw->code_ram, sizeof(fw->code_ram),
911             &nxt);
912         if (rval != QLA_SUCCESS)
913                 goto qla24xx_fw_dump_failed_0;
914
915         nxt = qla2xxx_copy_queues(ha, nxt);
916         if (ha->eft)
917                 memcpy(nxt, ha->eft, ntohl(ha->fw_dump->eft_size));
918
919 qla24xx_fw_dump_failed_0:
920         if (rval != QLA_SUCCESS) {
921                 qla_printk(KERN_WARNING, ha,
922                     "Failed to dump firmware (%x)!!!\n", rval);
923                 ha->fw_dumped = 0;
924
925         } else {
926                 qla_printk(KERN_INFO, ha,
927                     "Firmware dump saved to temp buffer (%ld/%p).\n",
928                     base_vha->host_no, ha->fw_dump);
929                 ha->fw_dumped = 1;
930         }
931
932 qla24xx_fw_dump_failed:
933         if (!hardware_locked)
934                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
935 }
936
937 void
938 qla25xx_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
939 {
940         int             rval;
941         uint32_t        cnt;
942         uint32_t        risc_address;
943         struct qla_hw_data *ha = vha->hw;
944         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
945         struct device_reg_25xxmq __iomem *reg25;
946         uint32_t __iomem *dmp_reg;
947         uint32_t        *iter_reg;
948         uint16_t __iomem *mbx_reg;
949         unsigned long   flags;
950         struct qla25xx_fw_dump *fw;
951         uint32_t        ext_mem_cnt;
952         void            *nxt;
953         struct qla2xxx_fce_chain *fcec;
954         struct qla2xxx_mq_chain *mq = NULL;
955         uint32_t        qreg_size;
956         uint8_t         req_cnt, rsp_cnt, que_cnt;
957         uint32_t        que_idx;
958         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
959
960         risc_address = ext_mem_cnt = 0;
961         flags = 0;
962
963         if (!hardware_locked)
964                 spin_lock_irqsave(&ha->hardware_lock, flags);
965
966         if (!ha->fw_dump) {
967                 qla_printk(KERN_WARNING, ha,
968                     "No buffer available for dump!!!\n");
969                 goto qla25xx_fw_dump_failed;
970         }
971
972         if (ha->fw_dumped) {
973                 qla_printk(KERN_WARNING, ha,
974                     "Firmware has been previously dumped (%p) -- ignoring "
975                     "request...\n", ha->fw_dump);
976                 goto qla25xx_fw_dump_failed;
977         }
978         fw = &ha->fw_dump->isp.isp25;
979         qla2xxx_prep_dump(ha, ha->fw_dump);
980         ha->fw_dump->version = __constant_htonl(2);
981
982         fw->host_status = htonl(RD_REG_DWORD(&reg->host_status));
983
984         /* Pause RISC. */
985         rval = qla24xx_pause_risc(reg);
986         if (rval != QLA_SUCCESS)
987                 goto qla25xx_fw_dump_failed_0;
988
989         /* Host/Risc registers. */
990         iter_reg = fw->host_risc_reg;
991         iter_reg = qla24xx_read_window(reg, 0x7000, 16, iter_reg);
992         qla24xx_read_window(reg, 0x7010, 16, iter_reg);
993
994         /* PCIe registers. */
995         WRT_REG_DWORD(&reg->iobase_addr, 0x7C00);
996         RD_REG_DWORD(&reg->iobase_addr);
997         WRT_REG_DWORD(&reg->iobase_window, 0x01);
998         dmp_reg = &reg->iobase_c4;
999         fw->pcie_regs[0] = htonl(RD_REG_DWORD(dmp_reg++));
1000         fw->pcie_regs[1] = htonl(RD_REG_DWORD(dmp_reg++));
1001         fw->pcie_regs[2] = htonl(RD_REG_DWORD(dmp_reg));
1002         fw->pcie_regs[3] = htonl(RD_REG_DWORD(&reg->iobase_window));
1003
1004         /* Multi queue registers */
1005         if (ha->mqenable) {
1006                 qreg_size = sizeof(struct qla2xxx_mq_chain);
1007                 mq = kzalloc(qreg_size, GFP_KERNEL);
1008                 if (!mq)
1009                         goto qla25xx_fw_dump_failed_0;
1010                 req_cnt = find_first_zero_bit(ha->req_qid_map, ha->max_queues);
1011                 rsp_cnt = find_first_zero_bit(ha->rsp_qid_map, ha->max_queues);
1012                 que_cnt = req_cnt > rsp_cnt ? req_cnt : rsp_cnt;
1013                 mq->count = htonl(que_cnt);
1014                 mq->chain_size = htonl(qreg_size);
1015                 mq->type = __constant_htonl(DUMP_CHAIN_MQ);
1016                 for (cnt = 0; cnt < que_cnt; cnt++) {
1017                         reg25 = (struct device_reg_25xxmq *) ((void *)
1018                                 ha->mqiobase + cnt * QLA_QUE_PAGE);
1019                         que_idx = cnt * 4;
1020                         mq->qregs[que_idx] = htonl(reg25->req_q_in);
1021                         mq->qregs[que_idx+1] = htonl(reg25->req_q_out);
1022                         mq->qregs[que_idx+2] = htonl(reg25->rsp_q_in);
1023                         mq->qregs[que_idx+3] = htonl(reg25->rsp_q_out);
1024                 }
1025         }
1026         WRT_REG_DWORD(&reg->iobase_window, 0x00);
1027         RD_REG_DWORD(&reg->iobase_window);
1028
1029         /* Host interface registers. */
1030         dmp_reg = &reg->flash_addr;
1031         for (cnt = 0; cnt < sizeof(fw->host_reg) / 4; cnt++)
1032                 fw->host_reg[cnt] = htonl(RD_REG_DWORD(dmp_reg++));
1033
1034         /* Disable interrupts. */
1035         WRT_REG_DWORD(&reg->ictrl, 0);
1036         RD_REG_DWORD(&reg->ictrl);
1037
1038         /* Shadow registers. */
1039         WRT_REG_DWORD(&reg->iobase_addr, 0x0F70);
1040         RD_REG_DWORD(&reg->iobase_addr);
1041         WRT_REG_DWORD(&reg->iobase_select, 0xB0000000);
1042         fw->shadow_reg[0] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
1043
1044         WRT_REG_DWORD(&reg->iobase_select, 0xB0100000);
1045         fw->shadow_reg[1] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
1046
1047         WRT_REG_DWORD(&reg->iobase_select, 0xB0200000);
1048         fw->shadow_reg[2] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
1049
1050         WRT_REG_DWORD(&reg->iobase_select, 0xB0300000);
1051         fw->shadow_reg[3] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
1052
1053         WRT_REG_DWORD(&reg->iobase_select, 0xB0400000);
1054         fw->shadow_reg[4] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
1055
1056         WRT_REG_DWORD(&reg->iobase_select, 0xB0500000);
1057         fw->shadow_reg[5] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
1058
1059         WRT_REG_DWORD(&reg->iobase_select, 0xB0600000);
1060         fw->shadow_reg[6] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
1061
1062         WRT_REG_DWORD(&reg->iobase_select, 0xB0700000);
1063         fw->shadow_reg[7] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
1064
1065         WRT_REG_DWORD(&reg->iobase_select, 0xB0800000);
1066         fw->shadow_reg[8] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
1067
1068         WRT_REG_DWORD(&reg->iobase_select, 0xB0900000);
1069         fw->shadow_reg[9] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
1070
1071         WRT_REG_DWORD(&reg->iobase_select, 0xB0A00000);
1072         fw->shadow_reg[10] = htonl(RD_REG_DWORD(&reg->iobase_sdata));
1073
1074         /* RISC I/O register. */
1075         WRT_REG_DWORD(&reg->iobase_addr, 0x0010);
1076         fw->risc_io_reg = htonl(RD_REG_DWORD(&reg->iobase_window));
1077
1078         /* Mailbox registers. */
1079         mbx_reg = &reg->mailbox0;
1080         for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2; cnt++)
1081                 fw->mailbox_reg[cnt] = htons(RD_REG_WORD(mbx_reg++));
1082
1083         /* Transfer sequence registers. */
1084         iter_reg = fw->xseq_gp_reg;
1085         iter_reg = qla24xx_read_window(reg, 0xBF00, 16, iter_reg);
1086         iter_reg = qla24xx_read_window(reg, 0xBF10, 16, iter_reg);
1087         iter_reg = qla24xx_read_window(reg, 0xBF20, 16, iter_reg);
1088         iter_reg = qla24xx_read_window(reg, 0xBF30, 16, iter_reg);
1089         iter_reg = qla24xx_read_window(reg, 0xBF40, 16, iter_reg);
1090         iter_reg = qla24xx_read_window(reg, 0xBF50, 16, iter_reg);
1091         iter_reg = qla24xx_read_window(reg, 0xBF60, 16, iter_reg);
1092         qla24xx_read_window(reg, 0xBF70, 16, iter_reg);
1093
1094         iter_reg = fw->xseq_0_reg;
1095         iter_reg = qla24xx_read_window(reg, 0xBFC0, 16, iter_reg);
1096         iter_reg = qla24xx_read_window(reg, 0xBFD0, 16, iter_reg);
1097         qla24xx_read_window(reg, 0xBFE0, 16, iter_reg);
1098
1099         qla24xx_read_window(reg, 0xBFF0, 16, fw->xseq_1_reg);
1100
1101         /* Receive sequence registers. */
1102         iter_reg = fw->rseq_gp_reg;
1103         iter_reg = qla24xx_read_window(reg, 0xFF00, 16, iter_reg);
1104         iter_reg = qla24xx_read_window(reg, 0xFF10, 16, iter_reg);
1105         iter_reg = qla24xx_read_window(reg, 0xFF20, 16, iter_reg);
1106         iter_reg = qla24xx_read_window(reg, 0xFF30, 16, iter_reg);
1107         iter_reg = qla24xx_read_window(reg, 0xFF40, 16, iter_reg);
1108         iter_reg = qla24xx_read_window(reg, 0xFF50, 16, iter_reg);
1109         iter_reg = qla24xx_read_window(reg, 0xFF60, 16, iter_reg);
1110         qla24xx_read_window(reg, 0xFF70, 16, iter_reg);
1111
1112         iter_reg = fw->rseq_0_reg;
1113         iter_reg = qla24xx_read_window(reg, 0xFFC0, 16, iter_reg);
1114         qla24xx_read_window(reg, 0xFFD0, 16, iter_reg);
1115
1116         qla24xx_read_window(reg, 0xFFE0, 16, fw->rseq_1_reg);
1117         qla24xx_read_window(reg, 0xFFF0, 16, fw->rseq_2_reg);
1118
1119         /* Auxiliary sequence registers. */
1120         iter_reg = fw->aseq_gp_reg;
1121         iter_reg = qla24xx_read_window(reg, 0xB000, 16, iter_reg);
1122         iter_reg = qla24xx_read_window(reg, 0xB010, 16, iter_reg);
1123         iter_reg = qla24xx_read_window(reg, 0xB020, 16, iter_reg);
1124         iter_reg = qla24xx_read_window(reg, 0xB030, 16, iter_reg);
1125         iter_reg = qla24xx_read_window(reg, 0xB040, 16, iter_reg);
1126         iter_reg = qla24xx_read_window(reg, 0xB050, 16, iter_reg);
1127         iter_reg = qla24xx_read_window(reg, 0xB060, 16, iter_reg);
1128         qla24xx_read_window(reg, 0xB070, 16, iter_reg);
1129
1130         iter_reg = fw->aseq_0_reg;
1131         iter_reg = qla24xx_read_window(reg, 0xB0C0, 16, iter_reg);
1132         qla24xx_read_window(reg, 0xB0D0, 16, iter_reg);
1133
1134         qla24xx_read_window(reg, 0xB0E0, 16, fw->aseq_1_reg);
1135         qla24xx_read_window(reg, 0xB0F0, 16, fw->aseq_2_reg);
1136
1137         /* Command DMA registers. */
1138         qla24xx_read_window(reg, 0x7100, 16, fw->cmd_dma_reg);
1139
1140         /* Queues. */
1141         iter_reg = fw->req0_dma_reg;
1142         iter_reg = qla24xx_read_window(reg, 0x7200, 8, iter_reg);
1143         dmp_reg = &reg->iobase_q;
1144         for (cnt = 0; cnt < 7; cnt++)
1145                 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1146
1147         iter_reg = fw->resp0_dma_reg;
1148         iter_reg = qla24xx_read_window(reg, 0x7300, 8, iter_reg);
1149         dmp_reg = &reg->iobase_q;
1150         for (cnt = 0; cnt < 7; cnt++)
1151                 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1152
1153         iter_reg = fw->req1_dma_reg;
1154         iter_reg = qla24xx_read_window(reg, 0x7400, 8, iter_reg);
1155         dmp_reg = &reg->iobase_q;
1156         for (cnt = 0; cnt < 7; cnt++)
1157                 *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1158
1159         /* Transmit DMA registers. */
1160         iter_reg = fw->xmt0_dma_reg;
1161         iter_reg = qla24xx_read_window(reg, 0x7600, 16, iter_reg);
1162         qla24xx_read_window(reg, 0x7610, 16, iter_reg);
1163
1164         iter_reg = fw->xmt1_dma_reg;
1165         iter_reg = qla24xx_read_window(reg, 0x7620, 16, iter_reg);
1166         qla24xx_read_window(reg, 0x7630, 16, iter_reg);
1167
1168         iter_reg = fw->xmt2_dma_reg;
1169         iter_reg = qla24xx_read_window(reg, 0x7640, 16, iter_reg);
1170         qla24xx_read_window(reg, 0x7650, 16, iter_reg);
1171
1172         iter_reg = fw->xmt3_dma_reg;
1173         iter_reg = qla24xx_read_window(reg, 0x7660, 16, iter_reg);
1174         qla24xx_read_window(reg, 0x7670, 16, iter_reg);
1175
1176         iter_reg = fw->xmt4_dma_reg;
1177         iter_reg = qla24xx_read_window(reg, 0x7680, 16, iter_reg);
1178         qla24xx_read_window(reg, 0x7690, 16, iter_reg);
1179
1180         qla24xx_read_window(reg, 0x76A0, 16, fw->xmt_data_dma_reg);
1181
1182         /* Receive DMA registers. */
1183         iter_reg = fw->rcvt0_data_dma_reg;
1184         iter_reg = qla24xx_read_window(reg, 0x7700, 16, iter_reg);
1185         qla24xx_read_window(reg, 0x7710, 16, iter_reg);
1186
1187         iter_reg = fw->rcvt1_data_dma_reg;
1188         iter_reg = qla24xx_read_window(reg, 0x7720, 16, iter_reg);
1189         qla24xx_read_window(reg, 0x7730, 16, iter_reg);
1190
1191         /* RISC registers. */
1192         iter_reg = fw->risc_gp_reg;
1193         iter_reg = qla24xx_read_window(reg, 0x0F00, 16, iter_reg);
1194         iter_reg = qla24xx_read_window(reg, 0x0F10, 16, iter_reg);
1195         iter_reg = qla24xx_read_window(reg, 0x0F20, 16, iter_reg);
1196         iter_reg = qla24xx_read_window(reg, 0x0F30, 16, iter_reg);
1197         iter_reg = qla24xx_read_window(reg, 0x0F40, 16, iter_reg);
1198         iter_reg = qla24xx_read_window(reg, 0x0F50, 16, iter_reg);
1199         iter_reg = qla24xx_read_window(reg, 0x0F60, 16, iter_reg);
1200         qla24xx_read_window(reg, 0x0F70, 16, iter_reg);
1201
1202         /* Local memory controller registers. */
1203         iter_reg = fw->lmc_reg;
1204         iter_reg = qla24xx_read_window(reg, 0x3000, 16, iter_reg);
1205         iter_reg = qla24xx_read_window(reg, 0x3010, 16, iter_reg);
1206         iter_reg = qla24xx_read_window(reg, 0x3020, 16, iter_reg);
1207         iter_reg = qla24xx_read_window(reg, 0x3030, 16, iter_reg);
1208         iter_reg = qla24xx_read_window(reg, 0x3040, 16, iter_reg);
1209         iter_reg = qla24xx_read_window(reg, 0x3050, 16, iter_reg);
1210         iter_reg = qla24xx_read_window(reg, 0x3060, 16, iter_reg);
1211         qla24xx_read_window(reg, 0x3070, 16, iter_reg);
1212
1213         /* Fibre Protocol Module registers. */
1214         iter_reg = fw->fpm_hdw_reg;
1215         iter_reg = qla24xx_read_window(reg, 0x4000, 16, iter_reg);
1216         iter_reg = qla24xx_read_window(reg, 0x4010, 16, iter_reg);
1217         iter_reg = qla24xx_read_window(reg, 0x4020, 16, iter_reg);
1218         iter_reg = qla24xx_read_window(reg, 0x4030, 16, iter_reg);
1219         iter_reg = qla24xx_read_window(reg, 0x4040, 16, iter_reg);
1220         iter_reg = qla24xx_read_window(reg, 0x4050, 16, iter_reg);
1221         iter_reg = qla24xx_read_window(reg, 0x4060, 16, iter_reg);
1222         iter_reg = qla24xx_read_window(reg, 0x4070, 16, iter_reg);
1223         iter_reg = qla24xx_read_window(reg, 0x4080, 16, iter_reg);
1224         iter_reg = qla24xx_read_window(reg, 0x4090, 16, iter_reg);
1225         iter_reg = qla24xx_read_window(reg, 0x40A0, 16, iter_reg);
1226         qla24xx_read_window(reg, 0x40B0, 16, iter_reg);
1227
1228         /* Frame Buffer registers. */
1229         iter_reg = fw->fb_hdw_reg;
1230         iter_reg = qla24xx_read_window(reg, 0x6000, 16, iter_reg);
1231         iter_reg = qla24xx_read_window(reg, 0x6010, 16, iter_reg);
1232         iter_reg = qla24xx_read_window(reg, 0x6020, 16, iter_reg);
1233         iter_reg = qla24xx_read_window(reg, 0x6030, 16, iter_reg);
1234         iter_reg = qla24xx_read_window(reg, 0x6040, 16, iter_reg);
1235         iter_reg = qla24xx_read_window(reg, 0x6100, 16, iter_reg);
1236         iter_reg = qla24xx_read_window(reg, 0x6130, 16, iter_reg);
1237         iter_reg = qla24xx_read_window(reg, 0x6150, 16, iter_reg);
1238         iter_reg = qla24xx_read_window(reg, 0x6170, 16, iter_reg);
1239         iter_reg = qla24xx_read_window(reg, 0x6190, 16, iter_reg);
1240         iter_reg = qla24xx_read_window(reg, 0x61B0, 16, iter_reg);
1241         qla24xx_read_window(reg, 0x6F00, 16, iter_reg);
1242
1243         rval = qla24xx_soft_reset(ha);
1244         if (rval != QLA_SUCCESS)
1245                 goto qla25xx_fw_dump_failed_0;
1246
1247         rval = qla24xx_dump_memory(ha, fw->code_ram, sizeof(fw->code_ram),
1248             &nxt);
1249         if (rval != QLA_SUCCESS)
1250                 goto qla25xx_fw_dump_failed_0;
1251
1252         /* Fibre Channel Trace Buffer. */
1253         nxt = qla2xxx_copy_queues(ha, nxt);
1254         if (ha->eft)
1255                 memcpy(nxt, ha->eft, ntohl(ha->fw_dump->eft_size));
1256
1257         /* Fibre Channel Event Buffer. */
1258         if (!ha->fce)
1259                 goto qla25xx_fw_dump_failed_0;
1260
1261         ha->fw_dump->version |= __constant_htonl(DUMP_CHAIN_VARIANT);
1262
1263         if (ha->mqenable) {
1264                 nxt = nxt + ntohl(ha->fw_dump->eft_size);
1265                 memcpy(nxt, mq, qreg_size);
1266                 kfree(mq);
1267                 fcec = nxt + qreg_size;
1268         } else {
1269                 fcec = nxt + ntohl(ha->fw_dump->eft_size);
1270         }
1271         fcec->type = __constant_htonl(DUMP_CHAIN_FCE | DUMP_CHAIN_LAST);
1272         fcec->chain_size = htonl(sizeof(struct qla2xxx_fce_chain) +
1273             fce_calc_size(ha->fce_bufs));
1274         fcec->size = htonl(fce_calc_size(ha->fce_bufs));
1275         fcec->addr_l = htonl(LSD(ha->fce_dma));
1276         fcec->addr_h = htonl(MSD(ha->fce_dma));
1277
1278         iter_reg = fcec->eregs;
1279         for (cnt = 0; cnt < 8; cnt++)
1280                 *iter_reg++ = htonl(ha->fce_mb[cnt]);
1281
1282         memcpy(iter_reg, ha->fce, ntohl(fcec->size));
1283
1284 qla25xx_fw_dump_failed_0:
1285         if (rval != QLA_SUCCESS) {
1286                 qla_printk(KERN_WARNING, ha,
1287                     "Failed to dump firmware (%x)!!!\n", rval);
1288                 ha->fw_dumped = 0;
1289
1290         } else {
1291                 qla_printk(KERN_INFO, ha,
1292                     "Firmware dump saved to temp buffer (%ld/%p).\n",
1293                     base_vha->host_no, ha->fw_dump);
1294                 ha->fw_dumped = 1;
1295         }
1296
1297 qla25xx_fw_dump_failed:
1298         if (!hardware_locked)
1299                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1300 }
1301 /****************************************************************************/
1302 /*                         Driver Debug Functions.                          */
1303 /****************************************************************************/
1304
1305 void
1306 qla2x00_dump_regs(scsi_qla_host_t *vha)
1307 {
1308         int i;
1309         struct qla_hw_data *ha = vha->hw;
1310         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1311         struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
1312         uint16_t __iomem *mbx_reg;
1313
1314         mbx_reg = IS_FWI2_CAPABLE(ha) ? &reg24->mailbox0:
1315             MAILBOX_REG(ha, reg, 0);
1316
1317         printk("Mailbox registers:\n");
1318         for (i = 0; i < 6; i++)
1319                 printk("scsi(%ld): mbox %d 0x%04x \n", vha->host_no, i,
1320                     RD_REG_WORD(mbx_reg++));
1321 }
1322
1323
1324 void
1325 qla2x00_dump_buffer(uint8_t * b, uint32_t size)
1326 {
1327         uint32_t cnt;
1328         uint8_t c;
1329
1330         printk(" 0   1   2   3   4   5   6   7   8   9  "
1331             "Ah  Bh  Ch  Dh  Eh  Fh\n");
1332         printk("----------------------------------------"
1333             "----------------------\n");
1334
1335         for (cnt = 0; cnt < size;) {
1336                 c = *b++;
1337                 printk("%02x",(uint32_t) c);
1338                 cnt++;
1339                 if (!(cnt % 16))
1340                         printk("\n");
1341                 else
1342                         printk("  ");
1343         }
1344         if (cnt % 16)
1345                 printk("\n");
1346 }
1347
1348