git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/qla2xxx/qla_dbg.c

   1 /*
   2  * QLogic Fibre Channel HBA Driver
   3  * Copyright (c)  2003-2005 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(scsi_qla_host_t *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(scsi_qla_host_t *ha, void *ptr)
  27 {
  28         /* Request queue. */
  29         memcpy(ptr, ha->request_ring, ha->request_q_length *
  30             sizeof(request_t));
  31
  32         /* Response queue. */
  33         ptr += ha->request_q_length * sizeof(request_t);
  34         memcpy(ptr, ha->response_ring, ha->response_q_length  *
  35             sizeof(response_t));
  36
  37         return ptr + (ha->response_q_length * sizeof(response_t));
  38 }
  39
  40 /**
  41  * qla2300_fw_dump() - Dumps binary data from the 2300 firmware.
  42  * @ha: HA context
  43  * @hardware_locked: Called with the hardware_lock
  44  */
  45 void
  46 qla2300_fw_dump(scsi_qla_host_t *ha, int hardware_locked)
  47 {
  48         int             rval;
  49         uint32_t        cnt, timer;
  50         uint32_t        risc_address;
  51         uint16_t        mb0, mb2;
  52
  53         uint32_t        stat;
  54         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
  55         uint16_t __iomem *dmp_reg;
  56         unsigned long   flags;
  57         struct qla2300_fw_dump  *fw;
  58         uint32_t        data_ram_cnt;
  59
  60         risc_address = data_ram_cnt = 0;
  61         mb0 = mb2 = 0;
  62         flags = 0;
  63
  64         if (!hardware_locked)
  65                 spin_lock_irqsave(&ha->hardware_lock, flags);
  66
  67         if (!ha->fw_dump) {
  68                 qla_printk(KERN_WARNING, ha,
  69                     "No buffer available for dump!!!\n");
  70                 goto qla2300_fw_dump_failed;
  71         }
  72
  73         if (ha->fw_dumped) {
  74                 qla_printk(KERN_WARNING, ha,
  75                     "Firmware has been previously dumped (%p) -- ignoring "
  76                     "request...\n", ha->fw_dump);
  77                 goto qla2300_fw_dump_failed;
  78         }
  79         fw = &ha->fw_dump->isp.isp23;
  80         qla2xxx_prep_dump(ha, ha->fw_dump);
  81
  82         rval = QLA_SUCCESS;
  83         fw->hccr = htons(RD_REG_WORD(&reg->hccr));
  84
  85         /* Pause RISC. */
  86         WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
  87         if (IS_QLA2300(ha)) {
  88                 for (cnt = 30000;
  89                     (RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) == 0 &&
  90                         rval == QLA_SUCCESS; cnt--) {
  91                         if (cnt)
  92                                 udelay(100);
  93                         else
  94                                 rval = QLA_FUNCTION_TIMEOUT;
  95                 }
  96         } else {
  97                 RD_REG_WORD(&reg->hccr);                /* PCI Posting. */
  98                 udelay(10);
  99         }
 100
 101         if (rval == QLA_SUCCESS) {
 102                 dmp_reg = (uint16_t __iomem *)(reg + 0);
 103                 for (cnt = 0; cnt < sizeof(fw->pbiu_reg) / 2; cnt++)
 104                         fw->pbiu_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 105
 106                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x10);
 107                 for (cnt = 0; cnt < sizeof(fw->risc_host_reg) / 2; cnt++)
 108                         fw->risc_host_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 109
 110                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x40);
 111                 for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2; cnt++)
 112                         fw->mailbox_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 113
 114                 WRT_REG_WORD(&reg->ctrl_status, 0x40);
 115                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 116                 for (cnt = 0; cnt < sizeof(fw->resp_dma_reg) / 2; cnt++)
 117                         fw->resp_dma_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 118
 119                 WRT_REG_WORD(&reg->ctrl_status, 0x50);
 120                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 121                 for (cnt = 0; cnt < sizeof(fw->dma_reg) / 2; cnt++)
 122                         fw->dma_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 123
 124                 WRT_REG_WORD(&reg->ctrl_status, 0x00);
 125                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0xA0);
 126                 for (cnt = 0; cnt < sizeof(fw->risc_hdw_reg) / 2; cnt++)
 127                         fw->risc_hdw_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 128
 129                 WRT_REG_WORD(&reg->pcr, 0x2000);
 130                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 131                 for (cnt = 0; cnt < sizeof(fw->risc_gp0_reg) / 2; cnt++)
 132                         fw->risc_gp0_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 133
 134                 WRT_REG_WORD(&reg->pcr, 0x2200);
 135                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 136                 for (cnt = 0; cnt < sizeof(fw->risc_gp1_reg) / 2; cnt++)
 137                         fw->risc_gp1_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 138
 139                 WRT_REG_WORD(&reg->pcr, 0x2400);
 140                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 141                 for (cnt = 0; cnt < sizeof(fw->risc_gp2_reg) / 2; cnt++)
 142                         fw->risc_gp2_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 143
 144                 WRT_REG_WORD(&reg->pcr, 0x2600);
 145                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 146                 for (cnt = 0; cnt < sizeof(fw->risc_gp3_reg) / 2; cnt++)
 147                         fw->risc_gp3_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 148
 149                 WRT_REG_WORD(&reg->pcr, 0x2800);
 150                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 151                 for (cnt = 0; cnt < sizeof(fw->risc_gp4_reg) / 2; cnt++)
 152                         fw->risc_gp4_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 153
 154                 WRT_REG_WORD(&reg->pcr, 0x2A00);
 155                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 156                 for (cnt = 0; cnt < sizeof(fw->risc_gp5_reg) / 2; cnt++)
 157                         fw->risc_gp5_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 158
 159                 WRT_REG_WORD(&reg->pcr, 0x2C00);
 160                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 161                 for (cnt = 0; cnt < sizeof(fw->risc_gp6_reg) / 2; cnt++)
 162                         fw->risc_gp6_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 163
 164                 WRT_REG_WORD(&reg->pcr, 0x2E00);
 165                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 166                 for (cnt = 0; cnt < sizeof(fw->risc_gp7_reg) / 2; cnt++)
 167                         fw->risc_gp7_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 168
 169                 WRT_REG_WORD(&reg->ctrl_status, 0x10);
 170                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 171                 for (cnt = 0; cnt < sizeof(fw->frame_buf_hdw_reg) / 2; cnt++)
 172                         fw->frame_buf_hdw_reg[cnt] =
 173                             htons(RD_REG_WORD(dmp_reg++));
 174
 175                 WRT_REG_WORD(&reg->ctrl_status, 0x20);
 176                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 177                 for (cnt = 0; cnt < sizeof(fw->fpm_b0_reg) / 2; cnt++)
 178                         fw->fpm_b0_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 179
 180                 WRT_REG_WORD(&reg->ctrl_status, 0x30);
 181                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 182                 for (cnt = 0; cnt < sizeof(fw->fpm_b1_reg) / 2; cnt++)
 183                         fw->fpm_b1_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 184
 185                 /* Reset RISC. */
 186                 WRT_REG_WORD(&reg->ctrl_status, CSR_ISP_SOFT_RESET);
 187                 for (cnt = 0; cnt < 30000; cnt++) {
 188                         if ((RD_REG_WORD(&reg->ctrl_status) &
 189                             CSR_ISP_SOFT_RESET) == 0)
 190                                 break;
 191
 192                         udelay(10);
 193                 }
 194         }
 195
 196         if (!IS_QLA2300(ha)) {
 197                 for (cnt = 30000; RD_MAILBOX_REG(ha, reg, 0) != 0 &&
 198                     rval == QLA_SUCCESS; cnt--) {
 199                         if (cnt)
 200                                 udelay(100);
 201                         else
 202                                 rval = QLA_FUNCTION_TIMEOUT;
 203                 }
 204         }
 205
 206         if (rval == QLA_SUCCESS) {
 207                 /* Get RISC SRAM. */
 208                 risc_address = 0x800;
 209                 WRT_MAILBOX_REG(ha, reg, 0, MBC_READ_RAM_WORD);
 210                 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 211         }
 212         for (cnt = 0; cnt < sizeof(fw->risc_ram) / 2 && rval == QLA_SUCCESS;
 213             cnt++, risc_address++) {
 214                 WRT_MAILBOX_REG(ha, reg, 1, (uint16_t)risc_address);
 215                 WRT_REG_WORD(&reg->hccr, HCCR_SET_HOST_INT);
 216
 217                 for (timer = 6000000; timer; timer--) {
 218                         /* Check for pending interrupts. */
 219                         stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
 220                         if (stat & HSR_RISC_INT) {
 221                                 stat &= 0xff;
 222
 223                                 if (stat == 0x1 || stat == 0x2) {
 224                                         set_bit(MBX_INTERRUPT,
 225                                             &ha->mbx_cmd_flags);
 226
 227                                         mb0 = RD_MAILBOX_REG(ha, reg, 0);
 228                                         mb2 = RD_MAILBOX_REG(ha, reg, 2);
 229
 230                                         /* Release mailbox registers. */
 231                                         WRT_REG_WORD(&reg->semaphore, 0);
 232                                         WRT_REG_WORD(&reg->hccr,
 233                                             HCCR_CLR_RISC_INT);
 234                                         RD_REG_WORD(&reg->hccr);
 235                                         break;
 236                                 } else if (stat == 0x10 || stat == 0x11) {
 237                                         set_bit(MBX_INTERRUPT,
 238                                             &ha->mbx_cmd_flags);
 239
 240                                         mb0 = RD_MAILBOX_REG(ha, reg, 0);
 241                                         mb2 = RD_MAILBOX_REG(ha, reg, 2);
 242
 243                                         WRT_REG_WORD(&reg->hccr,
 244                                             HCCR_CLR_RISC_INT);
 245                                         RD_REG_WORD(&reg->hccr);
 246                                         break;
 247                                 }
 248
 249                                 /* clear this intr; it wasn't a mailbox intr */
 250                                 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
 251                                 RD_REG_WORD(&reg->hccr);
 252                         }
 253                         udelay(5);
 254                 }
 255
 256                 if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
 257                         rval = mb0 & MBS_MASK;
 258                         fw->risc_ram[cnt] = htons(mb2);
 259                 } else {
 260                         rval = QLA_FUNCTION_FAILED;
 261                 }
 262         }
 263
 264         if (rval == QLA_SUCCESS) {
 265                 /* Get stack SRAM. */
 266                 risc_address = 0x10000;
 267                 WRT_MAILBOX_REG(ha, reg, 0, MBC_READ_RAM_EXTENDED);
 268                 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 269         }
 270         for (cnt = 0; cnt < sizeof(fw->stack_ram) / 2 && rval == QLA_SUCCESS;
 271             cnt++, risc_address++) {
 272                 WRT_MAILBOX_REG(ha, reg, 1, LSW(risc_address));
 273                 WRT_MAILBOX_REG(ha, reg, 8, MSW(risc_address));
 274                 WRT_REG_WORD(&reg->hccr, HCCR_SET_HOST_INT);
 275
 276                 for (timer = 6000000; timer; timer--) {
 277                         /* Check for pending interrupts. */
 278                         stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
 279                         if (stat & HSR_RISC_INT) {
 280                                 stat &= 0xff;
 281
 282                                 if (stat == 0x1 || stat == 0x2) {
 283                                         set_bit(MBX_INTERRUPT,
 284                                             &ha->mbx_cmd_flags);
 285
 286                                         mb0 = RD_MAILBOX_REG(ha, reg, 0);
 287                                         mb2 = RD_MAILBOX_REG(ha, reg, 2);
 288
 289                                         /* Release mailbox registers. */
 290                                         WRT_REG_WORD(&reg->semaphore, 0);
 291                                         WRT_REG_WORD(&reg->hccr,
 292                                             HCCR_CLR_RISC_INT);
 293                                         RD_REG_WORD(&reg->hccr);
 294                                         break;
 295                                 } else if (stat == 0x10 || stat == 0x11) {
 296                                         set_bit(MBX_INTERRUPT,
 297                                             &ha->mbx_cmd_flags);
 298
 299                                         mb0 = RD_MAILBOX_REG(ha, reg, 0);
 300                                         mb2 = RD_MAILBOX_REG(ha, reg, 2);
 301
 302                                         WRT_REG_WORD(&reg->hccr,
 303                                             HCCR_CLR_RISC_INT);
 304                                         RD_REG_WORD(&reg->hccr);
 305                                         break;
 306                                 }
 307
 308                                 /* clear this intr; it wasn't a mailbox intr */
 309                                 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
 310                                 RD_REG_WORD(&reg->hccr);
 311                         }
 312                         udelay(5);
 313                 }
 314
 315                 if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
 316                         rval = mb0 & MBS_MASK;
 317                         fw->stack_ram[cnt] = htons(mb2);
 318                 } else {
 319                         rval = QLA_FUNCTION_FAILED;
 320                 }
 321         }
 322
 323         if (rval == QLA_SUCCESS) {
 324                 /* Get data SRAM. */
 325                 risc_address = 0x11000;
 326                 data_ram_cnt = ha->fw_memory_size - risc_address + 1;
 327                 WRT_MAILBOX_REG(ha, reg, 0, MBC_READ_RAM_EXTENDED);
 328                 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 329         }
 330         for (cnt = 0; cnt < data_ram_cnt && rval == QLA_SUCCESS;
 331             cnt++, risc_address++) {
 332                 WRT_MAILBOX_REG(ha, reg, 1, LSW(risc_address));
 333                 WRT_MAILBOX_REG(ha, reg, 8, MSW(risc_address));
 334                 WRT_REG_WORD(&reg->hccr, HCCR_SET_HOST_INT);
 335
 336                 for (timer = 6000000; timer; timer--) {
 337                         /* Check for pending interrupts. */
 338                         stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
 339                         if (stat & HSR_RISC_INT) {
 340                                 stat &= 0xff;
 341
 342                                 if (stat == 0x1 || stat == 0x2) {
 343                                         set_bit(MBX_INTERRUPT,
 344                                             &ha->mbx_cmd_flags);
 345
 346                                         mb0 = RD_MAILBOX_REG(ha, reg, 0);
 347                                         mb2 = RD_MAILBOX_REG(ha, reg, 2);
 348
 349                                         /* Release mailbox registers. */
 350                                         WRT_REG_WORD(&reg->semaphore, 0);
 351                                         WRT_REG_WORD(&reg->hccr,
 352                                             HCCR_CLR_RISC_INT);
 353                                         RD_REG_WORD(&reg->hccr);
 354                                         break;
 355                                 } else if (stat == 0x10 || stat == 0x11) {
 356                                         set_bit(MBX_INTERRUPT,
 357                                             &ha->mbx_cmd_flags);
 358
 359                                         mb0 = RD_MAILBOX_REG(ha, reg, 0);
 360                                         mb2 = RD_MAILBOX_REG(ha, reg, 2);
 361
 362                                         WRT_REG_WORD(&reg->hccr,
 363                                             HCCR_CLR_RISC_INT);
 364                                         RD_REG_WORD(&reg->hccr);
 365                                         break;
 366                                 }
 367
 368                                 /* clear this intr; it wasn't a mailbox intr */
 369                                 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
 370                                 RD_REG_WORD(&reg->hccr);
 371                         }
 372                         udelay(5);
 373                 }
 374
 375                 if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
 376                         rval = mb0 & MBS_MASK;
 377                         fw->data_ram[cnt] = htons(mb2);
 378                 } else {
 379                         rval = QLA_FUNCTION_FAILED;
 380                 }
 381         }
 382
 383         if (rval == QLA_SUCCESS)
 384                 qla2xxx_copy_queues(ha, &fw->data_ram[cnt]);
 385
 386         if (rval != QLA_SUCCESS) {
 387                 qla_printk(KERN_WARNING, ha,
 388                     "Failed to dump firmware (%x)!!!\n", rval);
 389                 ha->fw_dumped = 0;
 390
 391         } else {
 392                 qla_printk(KERN_INFO, ha,
 393                     "Firmware dump saved to temp buffer (%ld/%p).\n",
 394                     ha->host_no, ha->fw_dump);
 395                 ha->fw_dumped = 1;
 396         }
 397
 398 qla2300_fw_dump_failed:
 399         if (!hardware_locked)
 400                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
 401 }
 402
 403 /**
 404  * qla2100_fw_dump() - Dumps binary data from the 2100/2200 firmware.
 405  * @ha: HA context
 406  * @hardware_locked: Called with the hardware_lock
 407  */
 408 void
 409 qla2100_fw_dump(scsi_qla_host_t *ha, int hardware_locked)
 410 {
 411         int             rval;
 412         uint32_t        cnt, timer;
 413         uint16_t        risc_address;
 414         uint16_t        mb0, mb2;
 415         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
 416         uint16_t __iomem *dmp_reg;
 417         unsigned long   flags;
 418         struct qla2100_fw_dump  *fw;
 419
 420         risc_address = 0;
 421         mb0 = mb2 = 0;
 422         flags = 0;
 423
 424         if (!hardware_locked)
 425                 spin_lock_irqsave(&ha->hardware_lock, flags);
 426
 427         if (!ha->fw_dump) {
 428                 qla_printk(KERN_WARNING, ha,
 429                     "No buffer available for dump!!!\n");
 430                 goto qla2100_fw_dump_failed;
 431         }
 432
 433         if (ha->fw_dumped) {
 434                 qla_printk(KERN_WARNING, ha,
 435                     "Firmware has been previously dumped (%p) -- ignoring "
 436                     "request...\n", ha->fw_dump);
 437                 goto qla2100_fw_dump_failed;
 438         }
 439         fw = &ha->fw_dump->isp.isp21;
 440         qla2xxx_prep_dump(ha, ha->fw_dump);
 441
 442         rval = QLA_SUCCESS;
 443         fw->hccr = htons(RD_REG_WORD(&reg->hccr));
 444
 445         /* Pause RISC. */
 446         WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
 447         for (cnt = 30000; (RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) == 0 &&
 448             rval == QLA_SUCCESS; cnt--) {
 449                 if (cnt)
 450                         udelay(100);
 451                 else
 452                         rval = QLA_FUNCTION_TIMEOUT;
 453         }
 454         if (rval == QLA_SUCCESS) {
 455                 dmp_reg = (uint16_t __iomem *)(reg + 0);
 456                 for (cnt = 0; cnt < sizeof(fw->pbiu_reg) / 2; cnt++)
 457                         fw->pbiu_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 458
 459                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x10);
 460                 for (cnt = 0; cnt < ha->mbx_count; cnt++) {
 461                         if (cnt == 8) {
 462                                 dmp_reg = (uint16_t __iomem *)
 463                                         ((uint8_t __iomem *)reg + 0xe0);
 464                         }
 465                         fw->mailbox_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 466                 }
 467
 468                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x20);
 469                 for (cnt = 0; cnt < sizeof(fw->dma_reg) / 2; cnt++)
 470                         fw->dma_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 471
 472                 WRT_REG_WORD(&reg->ctrl_status, 0x00);
 473                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0xA0);
 474                 for (cnt = 0; cnt < sizeof(fw->risc_hdw_reg) / 2; cnt++)
 475                         fw->risc_hdw_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 476
 477                 WRT_REG_WORD(&reg->pcr, 0x2000);
 478                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 479                 for (cnt = 0; cnt < sizeof(fw->risc_gp0_reg) / 2; cnt++)
 480                         fw->risc_gp0_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 481
 482                 WRT_REG_WORD(&reg->pcr, 0x2100);
 483                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 484                 for (cnt = 0; cnt < sizeof(fw->risc_gp1_reg) / 2; cnt++)
 485                         fw->risc_gp1_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 486
 487                 WRT_REG_WORD(&reg->pcr, 0x2200);
 488                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 489                 for (cnt = 0; cnt < sizeof(fw->risc_gp2_reg) / 2; cnt++)
 490                         fw->risc_gp2_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 491
 492                 WRT_REG_WORD(&reg->pcr, 0x2300);
 493                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 494                 for (cnt = 0; cnt < sizeof(fw->risc_gp3_reg) / 2; cnt++)
 495                         fw->risc_gp3_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 496
 497                 WRT_REG_WORD(&reg->pcr, 0x2400);
 498                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 499                 for (cnt = 0; cnt < sizeof(fw->risc_gp4_reg) / 2; cnt++)
 500                         fw->risc_gp4_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 501
 502                 WRT_REG_WORD(&reg->pcr, 0x2500);
 503                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 504                 for (cnt = 0; cnt < sizeof(fw->risc_gp5_reg) / 2; cnt++)
 505                         fw->risc_gp5_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 506
 507                 WRT_REG_WORD(&reg->pcr, 0x2600);
 508                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 509                 for (cnt = 0; cnt < sizeof(fw->risc_gp6_reg) / 2; cnt++)
 510                         fw->risc_gp6_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 511
 512                 WRT_REG_WORD(&reg->pcr, 0x2700);
 513                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 514                 for (cnt = 0; cnt < sizeof(fw->risc_gp7_reg) / 2; cnt++)
 515                         fw->risc_gp7_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 516
 517                 WRT_REG_WORD(&reg->ctrl_status, 0x10);
 518                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 519                 for (cnt = 0; cnt < sizeof(fw->frame_buf_hdw_reg) / 2; cnt++)
 520                         fw->frame_buf_hdw_reg[cnt] =
 521                             htons(RD_REG_WORD(dmp_reg++));
 522
 523                 WRT_REG_WORD(&reg->ctrl_status, 0x20);
 524                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 525                 for (cnt = 0; cnt < sizeof(fw->fpm_b0_reg) / 2; cnt++)
 526                         fw->fpm_b0_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 527
 528                 WRT_REG_WORD(&reg->ctrl_status, 0x30);
 529                 dmp_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 530                 for (cnt = 0; cnt < sizeof(fw->fpm_b1_reg) / 2; cnt++)
 531                         fw->fpm_b1_reg[cnt] = htons(RD_REG_WORD(dmp_reg++));
 532
 533                 /* Reset the ISP. */
 534                 WRT_REG_WORD(&reg->ctrl_status, CSR_ISP_SOFT_RESET);
 535         }
 536
 537         for (cnt = 30000; RD_MAILBOX_REG(ha, reg, 0) != 0 &&
 538             rval == QLA_SUCCESS; cnt--) {
 539                 if (cnt)
 540                         udelay(100);
 541                 else
 542                         rval = QLA_FUNCTION_TIMEOUT;
 543         }
 544
 545         /* Pause RISC. */
 546         if (rval == QLA_SUCCESS && (IS_QLA2200(ha) || (IS_QLA2100(ha) &&
 547             (RD_REG_WORD(&reg->mctr) & (BIT_1 | BIT_0)) != 0))) {
 548
 549                 WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
 550                 for (cnt = 30000;
 551                     (RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) == 0 &&
 552                     rval == QLA_SUCCESS; cnt--) {
 553                         if (cnt)
 554                                 udelay(100);
 555                         else
 556                                 rval = QLA_FUNCTION_TIMEOUT;
 557                 }
 558                 if (rval == QLA_SUCCESS) {
 559                         /* Set memory configuration and timing. */
 560                         if (IS_QLA2100(ha))
 561                                 WRT_REG_WORD(&reg->mctr, 0xf1);
 562                         else
 563                                 WRT_REG_WORD(&reg->mctr, 0xf2);
 564                         RD_REG_WORD(&reg->mctr);        /* PCI Posting. */
 565
 566                         /* Release RISC. */
 567                         WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
 568                 }
 569         }
 570
 571         if (rval == QLA_SUCCESS) {
 572                 /* Get RISC SRAM. */
 573                 risc_address = 0x1000;
 574                 WRT_MAILBOX_REG(ha, reg, 0, MBC_READ_RAM_WORD);
 575                 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 576         }
 577         for (cnt = 0; cnt < sizeof(fw->risc_ram) / 2 && rval == QLA_SUCCESS;
 578             cnt++, risc_address++) {
 579                 WRT_MAILBOX_REG(ha, reg, 1, risc_address);
 580                 WRT_REG_WORD(&reg->hccr, HCCR_SET_HOST_INT);
 581
 582                 for (timer = 6000000; timer != 0; timer--) {
 583                         /* Check for pending interrupts. */
 584                         if (RD_REG_WORD(&reg->istatus) & ISR_RISC_INT) {
 585                                 if (RD_REG_WORD(&reg->semaphore) & BIT_0) {
 586                                         set_bit(MBX_INTERRUPT,
 587                                             &ha->mbx_cmd_flags);
 588
 589                                         mb0 = RD_MAILBOX_REG(ha, reg, 0);
 590                                         mb2 = RD_MAILBOX_REG(ha, reg, 2);
 591
 592                                         WRT_REG_WORD(&reg->semaphore, 0);
 593                                         WRT_REG_WORD(&reg->hccr,
 594                                             HCCR_CLR_RISC_INT);
 595                                         RD_REG_WORD(&reg->hccr);
 596                                         break;
 597                                 }
 598                                 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
 599                                 RD_REG_WORD(&reg->hccr);
 600                         }
 601                         udelay(5);
 602                 }
 603
 604                 if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
 605                         rval = mb0 & MBS_MASK;
 606                         fw->risc_ram[cnt] = htons(mb2);
 607                 } else {
 608                         rval = QLA_FUNCTION_FAILED;
 609                 }
 610         }
 611
 612         if (rval == QLA_SUCCESS)
 613                 qla2xxx_copy_queues(ha, &fw->risc_ram[cnt]);
 614
 615         if (rval != QLA_SUCCESS) {
 616                 qla_printk(KERN_WARNING, ha,
 617                     "Failed to dump firmware (%x)!!!\n", rval);
 618                 ha->fw_dumped = 0;
 619
 620         } else {
 621                 qla_printk(KERN_INFO, ha,
 622                     "Firmware dump saved to temp buffer (%ld/%p).\n",
 623                     ha->host_no, ha->fw_dump);
 624                 ha->fw_dumped = 1;
 625         }
 626
 627 qla2100_fw_dump_failed:
 628         if (!hardware_locked)
 629                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
 630 }
 631
 632 void
 633 qla24xx_fw_dump(scsi_qla_host_t *ha, int hardware_locked)
 634 {
 635         int             rval;
 636         uint32_t        cnt, timer;
 637         uint32_t        risc_address;
 638         uint16_t        mb[4], wd;
 639
 640         uint32_t        stat;
 641         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
 642         uint32_t __iomem *dmp_reg;
 643         uint32_t        *iter_reg;
 644         uint16_t __iomem *mbx_reg;
 645         unsigned long   flags;
 646         struct qla24xx_fw_dump *fw;
 647         uint32_t        ext_mem_cnt;
 648         void            *eft;
 649
 650         risc_address = ext_mem_cnt = 0;
 651         memset(mb, 0, sizeof(mb));
 652         flags = 0;
 653
 654         if (!hardware_locked)
 655                 spin_lock_irqsave(&ha->hardware_lock, flags);
 656
 657         if (!ha->fw_dump) {
 658                 qla_printk(KERN_WARNING, ha,
 659                     "No buffer available for dump!!!\n");
 660                 goto qla24xx_fw_dump_failed;
 661         }
 662
 663         if (ha->fw_dumped) {
 664                 qla_printk(KERN_WARNING, ha,
 665                     "Firmware has been previously dumped (%p) -- ignoring "
 666                     "request...\n", ha->fw_dump);
 667                 goto qla24xx_fw_dump_failed;
 668         }
 669         fw = &ha->fw_dump->isp.isp24;
 670         qla2xxx_prep_dump(ha, ha->fw_dump);
 671
 672         rval = QLA_SUCCESS;
 673         fw->host_status = htonl(RD_REG_DWORD(&reg->host_status));
 674
 675         /* Pause RISC. */
 676         if ((RD_REG_DWORD(&reg->hccr) & HCCRX_RISC_PAUSE) == 0) {
 677                 WRT_REG_DWORD(&reg->hccr, HCCRX_SET_RISC_RESET |
 678                     HCCRX_CLR_HOST_INT);
 679                 RD_REG_DWORD(&reg->hccr);               /* PCI Posting. */
 680                 WRT_REG_DWORD(&reg->hccr, HCCRX_SET_RISC_PAUSE);
 681                 for (cnt = 30000;
 682                     (RD_REG_DWORD(&reg->hccr) & HCCRX_RISC_PAUSE) == 0 &&
 683                     rval == QLA_SUCCESS; cnt--) {
 684                         if (cnt)
 685                                 udelay(100);
 686                         else
 687                                 rval = QLA_FUNCTION_TIMEOUT;
 688                 }
 689         }
 690
 691         if (rval == QLA_SUCCESS) {
 692                 /* Host interface registers. */
 693                 dmp_reg = (uint32_t __iomem *)(reg + 0);
 694                 for (cnt = 0; cnt < sizeof(fw->host_reg) / 4; cnt++)
 695                         fw->host_reg[cnt] = htonl(RD_REG_DWORD(dmp_reg++));
 696
 697                 /* Disable interrupts. */
 698                 WRT_REG_DWORD(&reg->ictrl, 0);
 699                 RD_REG_DWORD(&reg->ictrl);
 700
 701                 /* Shadow registers. */
 702                 WRT_REG_DWORD(&reg->iobase_addr, 0x0F70);
 703                 RD_REG_DWORD(&reg->iobase_addr);
 704                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
 705                 WRT_REG_DWORD(dmp_reg, 0xB0000000);
 706                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
 707                 fw->shadow_reg[0] = htonl(RD_REG_DWORD(dmp_reg));
 708
 709                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
 710                 WRT_REG_DWORD(dmp_reg, 0xB0100000);
 711                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
 712                 fw->shadow_reg[1] = htonl(RD_REG_DWORD(dmp_reg));
 713
 714                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
 715                 WRT_REG_DWORD(dmp_reg, 0xB0200000);
 716                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
 717                 fw->shadow_reg[2] = htonl(RD_REG_DWORD(dmp_reg));
 718
 719                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
 720                 WRT_REG_DWORD(dmp_reg, 0xB0300000);
 721                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
 722                 fw->shadow_reg[3] = htonl(RD_REG_DWORD(dmp_reg));
 723
 724                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
 725                 WRT_REG_DWORD(dmp_reg, 0xB0400000);
 726                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
 727                 fw->shadow_reg[4] = htonl(RD_REG_DWORD(dmp_reg));
 728
 729                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
 730                 WRT_REG_DWORD(dmp_reg, 0xB0500000);
 731                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
 732                 fw->shadow_reg[5] = htonl(RD_REG_DWORD(dmp_reg));
 733
 734                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xF0);
 735                 WRT_REG_DWORD(dmp_reg, 0xB0600000);
 736                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xFC);
 737                 fw->shadow_reg[6] = htonl(RD_REG_DWORD(dmp_reg));
 738
 739                 /* Mailbox registers. */
 740                 mbx_reg = (uint16_t __iomem *)((uint8_t __iomem *)reg + 0x80);
 741                 for (cnt = 0; cnt < sizeof(fw->mailbox_reg) / 2; cnt++)
 742                         fw->mailbox_reg[cnt] = htons(RD_REG_WORD(mbx_reg++));
 743
 744                 /* Transfer sequence registers. */
 745                 iter_reg = fw->xseq_gp_reg;
 746                 WRT_REG_DWORD(&reg->iobase_addr, 0xBF00);
 747                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 748                 for (cnt = 0; cnt < 16; cnt++)
 749                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 750
 751                 WRT_REG_DWORD(&reg->iobase_addr, 0xBF10);
 752                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 753                 for (cnt = 0; cnt < 16; cnt++)
 754                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 755
 756                 WRT_REG_DWORD(&reg->iobase_addr, 0xBF20);
 757                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 758                 for (cnt = 0; cnt < 16; cnt++)
 759                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 760
 761                 WRT_REG_DWORD(&reg->iobase_addr, 0xBF30);
 762                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 763                 for (cnt = 0; cnt < 16; cnt++)
 764                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 765
 766                 WRT_REG_DWORD(&reg->iobase_addr, 0xBF40);
 767                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 768                 for (cnt = 0; cnt < 16; cnt++)
 769                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 770
 771                 WRT_REG_DWORD(&reg->iobase_addr, 0xBF50);
 772                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 773                 for (cnt = 0; cnt < 16; cnt++)
 774                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 775
 776                 WRT_REG_DWORD(&reg->iobase_addr, 0xBF60);
 777                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 778                 for (cnt = 0; cnt < 16; cnt++)
 779                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 780
 781                 WRT_REG_DWORD(&reg->iobase_addr, 0xBF70);
 782                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 783                 for (cnt = 0; cnt < 16; cnt++)
 784                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 785
 786                 WRT_REG_DWORD(&reg->iobase_addr, 0xBFE0);
 787                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 788                 for (cnt = 0; cnt < sizeof(fw->xseq_0_reg) / 4; cnt++)
 789                         fw->xseq_0_reg[cnt] = htonl(RD_REG_DWORD(dmp_reg++));
 790
 791                 WRT_REG_DWORD(&reg->iobase_addr, 0xBFF0);
 792                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 793                 for (cnt = 0; cnt < sizeof(fw->xseq_1_reg) / 4; cnt++)
 794                         fw->xseq_1_reg[cnt] = htonl(RD_REG_DWORD(dmp_reg++));
 795
 796                 /* Receive sequence registers. */
 797                 iter_reg = fw->rseq_gp_reg;
 798                 WRT_REG_DWORD(&reg->iobase_addr, 0xFF00);
 799                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 800                 for (cnt = 0; cnt < 16; cnt++)
 801                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 802
 803                 WRT_REG_DWORD(&reg->iobase_addr, 0xFF10);
 804                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 805                 for (cnt = 0; cnt < 16; cnt++)
 806                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 807
 808                 WRT_REG_DWORD(&reg->iobase_addr, 0xFF20);
 809                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 810                 for (cnt = 0; cnt < 16; cnt++)
 811                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 812
 813                 WRT_REG_DWORD(&reg->iobase_addr, 0xFF30);
 814                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 815                 for (cnt = 0; cnt < 16; cnt++)
 816                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 817
 818                 WRT_REG_DWORD(&reg->iobase_addr, 0xFF40);
 819                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 820                 for (cnt = 0; cnt < 16; cnt++)
 821                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 822
 823                 WRT_REG_DWORD(&reg->iobase_addr, 0xFF50);
 824                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 825                 for (cnt = 0; cnt < 16; cnt++)
 826                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 827
 828                 WRT_REG_DWORD(&reg->iobase_addr, 0xFF60);
 829                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 830                 for (cnt = 0; cnt < 16; cnt++)
 831                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 832
 833                 WRT_REG_DWORD(&reg->iobase_addr, 0xFF70);
 834                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 835                 for (cnt = 0; cnt < 16; cnt++)
 836                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 837
 838                 WRT_REG_DWORD(&reg->iobase_addr, 0xFFD0);
 839                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 840                 for (cnt = 0; cnt < sizeof(fw->rseq_0_reg) / 4; cnt++)
 841                         fw->rseq_0_reg[cnt] = htonl(RD_REG_DWORD(dmp_reg++));
 842
 843                 WRT_REG_DWORD(&reg->iobase_addr, 0xFFE0);
 844                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 845                 for (cnt = 0; cnt < sizeof(fw->rseq_1_reg) / 4; cnt++)
 846                         fw->rseq_1_reg[cnt] = htonl(RD_REG_DWORD(dmp_reg++));
 847
 848                 WRT_REG_DWORD(&reg->iobase_addr, 0xFFF0);
 849                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 850                 for (cnt = 0; cnt < sizeof(fw->rseq_2_reg) / 4; cnt++)
 851                         fw->rseq_2_reg[cnt] = htonl(RD_REG_DWORD(dmp_reg++));
 852
 853                 /* Command DMA registers. */
 854                 WRT_REG_DWORD(&reg->iobase_addr, 0x7100);
 855                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 856                 for (cnt = 0; cnt < sizeof(fw->cmd_dma_reg) / 4; cnt++)
 857                         fw->cmd_dma_reg[cnt] = htonl(RD_REG_DWORD(dmp_reg++));
 858
 859                 /* Queues. */
 860                 iter_reg = fw->req0_dma_reg;
 861                 WRT_REG_DWORD(&reg->iobase_addr, 0x7200);
 862                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 863                 for (cnt = 0; cnt < 8; cnt++)
 864                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 865
 866                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xE4);
 867                 for (cnt = 0; cnt < 7; cnt++)
 868                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 869
 870                 iter_reg = fw->resp0_dma_reg;
 871                 WRT_REG_DWORD(&reg->iobase_addr, 0x7300);
 872                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 873                 for (cnt = 0; cnt < 8; cnt++)
 874                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 875
 876                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xE4);
 877                 for (cnt = 0; cnt < 7; cnt++)
 878                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 879
 880                 iter_reg = fw->req1_dma_reg;
 881                 WRT_REG_DWORD(&reg->iobase_addr, 0x7400);
 882                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 883                 for (cnt = 0; cnt < 8; cnt++)
 884                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 885
 886                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xE4);
 887                 for (cnt = 0; cnt < 7; cnt++)
 888                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 889
 890                 /* Transmit DMA registers. */
 891                 iter_reg = fw->xmt0_dma_reg;
 892                 WRT_REG_DWORD(&reg->iobase_addr, 0x7600);
 893                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 894                 for (cnt = 0; cnt < 16; cnt++)
 895                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 896
 897                 WRT_REG_DWORD(&reg->iobase_addr, 0x7610);
 898                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 899                 for (cnt = 0; cnt < 16; cnt++)
 900                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 901
 902                 iter_reg = fw->xmt1_dma_reg;
 903                 WRT_REG_DWORD(&reg->iobase_addr, 0x7620);
 904                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 905                 for (cnt = 0; cnt < 16; cnt++)
 906                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 907
 908                 WRT_REG_DWORD(&reg->iobase_addr, 0x7630);
 909                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 910                 for (cnt = 0; cnt < 16; cnt++)
 911                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 912
 913                 iter_reg = fw->xmt2_dma_reg;
 914                 WRT_REG_DWORD(&reg->iobase_addr, 0x7640);
 915                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 916                 for (cnt = 0; cnt < 16; cnt++)
 917                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 918
 919                 WRT_REG_DWORD(&reg->iobase_addr, 0x7650);
 920                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 921                 for (cnt = 0; cnt < 16; cnt++)
 922                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 923
 924                 iter_reg = fw->xmt3_dma_reg;
 925                 WRT_REG_DWORD(&reg->iobase_addr, 0x7660);
 926                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 927                 for (cnt = 0; cnt < 16; cnt++)
 928                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 929
 930                 WRT_REG_DWORD(&reg->iobase_addr, 0x7670);
 931                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 932                 for (cnt = 0; cnt < 16; cnt++)
 933                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 934
 935                 iter_reg = fw->xmt4_dma_reg;
 936                 WRT_REG_DWORD(&reg->iobase_addr, 0x7680);
 937                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 938                 for (cnt = 0; cnt < 16; cnt++)
 939                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 940
 941                 WRT_REG_DWORD(&reg->iobase_addr, 0x7690);
 942                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 943                 for (cnt = 0; cnt < 16; cnt++)
 944                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 945
 946                 WRT_REG_DWORD(&reg->iobase_addr, 0x76A0);
 947                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 948                 for (cnt = 0; cnt < sizeof(fw->xmt_data_dma_reg) / 4; cnt++)
 949                         fw->xmt_data_dma_reg[cnt] =
 950                             htonl(RD_REG_DWORD(dmp_reg++));
 951
 952                 /* Receive DMA registers. */
 953                 iter_reg = fw->rcvt0_data_dma_reg;
 954                 WRT_REG_DWORD(&reg->iobase_addr, 0x7700);
 955                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 956                 for (cnt = 0; cnt < 16; cnt++)
 957                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 958
 959                 WRT_REG_DWORD(&reg->iobase_addr, 0x7710);
 960                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 961                 for (cnt = 0; cnt < 16; cnt++)
 962                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 963
 964                 iter_reg = fw->rcvt1_data_dma_reg;
 965                 WRT_REG_DWORD(&reg->iobase_addr, 0x7720);
 966                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 967                 for (cnt = 0; cnt < 16; cnt++)
 968                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 969
 970                 WRT_REG_DWORD(&reg->iobase_addr, 0x7730);
 971                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 972                 for (cnt = 0; cnt < 16; cnt++)
 973                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 974
 975                 /* RISC registers. */
 976                 iter_reg = fw->risc_gp_reg;
 977                 WRT_REG_DWORD(&reg->iobase_addr, 0x0F00);
 978                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 979                 for (cnt = 0; cnt < 16; cnt++)
 980                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 981
 982                 WRT_REG_DWORD(&reg->iobase_addr, 0x0F10);
 983                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 984                 for (cnt = 0; cnt < 16; cnt++)
 985                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 986
 987                 WRT_REG_DWORD(&reg->iobase_addr, 0x0F20);
 988                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 989                 for (cnt = 0; cnt < 16; cnt++)
 990                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 991
 992                 WRT_REG_DWORD(&reg->iobase_addr, 0x0F30);
 993                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 994                 for (cnt = 0; cnt < 16; cnt++)
 995                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
 996
 997                 WRT_REG_DWORD(&reg->iobase_addr, 0x0F40);
 998                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
 999                 for (cnt = 0; cnt < 16; cnt++)
1000                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1001
1002                 WRT_REG_DWORD(&reg->iobase_addr, 0x0F50);
1003                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1004                 for (cnt = 0; cnt < 16; cnt++)
1005                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1006
1007                 WRT_REG_DWORD(&reg->iobase_addr, 0x0F60);
1008                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1009                 for (cnt = 0; cnt < 16; cnt++)
1010                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1011
1012                 WRT_REG_DWORD(&reg->iobase_addr, 0x0F70);
1013                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1014                 for (cnt = 0; cnt < 16; cnt++)
1015                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1016
1017                 /* Local memory controller registers. */
1018                 iter_reg = fw->lmc_reg;
1019                 WRT_REG_DWORD(&reg->iobase_addr, 0x3000);
1020                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1021                 for (cnt = 0; cnt < 16; cnt++)
1022                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1023
1024                 WRT_REG_DWORD(&reg->iobase_addr, 0x3010);
1025                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1026                 for (cnt = 0; cnt < 16; cnt++)
1027                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1028
1029                 WRT_REG_DWORD(&reg->iobase_addr, 0x3020);
1030                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1031                 for (cnt = 0; cnt < 16; cnt++)
1032                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1033
1034                 WRT_REG_DWORD(&reg->iobase_addr, 0x3030);
1035                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1036                 for (cnt = 0; cnt < 16; cnt++)
1037                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1038
1039                 WRT_REG_DWORD(&reg->iobase_addr, 0x3040);
1040                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1041                 for (cnt = 0; cnt < 16; cnt++)
1042                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1043
1044                 WRT_REG_DWORD(&reg->iobase_addr, 0x3050);
1045                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1046                 for (cnt = 0; cnt < 16; cnt++)
1047                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1048
1049                 WRT_REG_DWORD(&reg->iobase_addr, 0x3060);
1050                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1051                 for (cnt = 0; cnt < 16; cnt++)
1052                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1053
1054                 /* Fibre Protocol Module registers. */
1055                 iter_reg = fw->fpm_hdw_reg;
1056                 WRT_REG_DWORD(&reg->iobase_addr, 0x4000);
1057                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1058                 for (cnt = 0; cnt < 16; cnt++)
1059                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1060
1061                 WRT_REG_DWORD(&reg->iobase_addr, 0x4010);
1062                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1063                 for (cnt = 0; cnt < 16; cnt++)
1064                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1065
1066                 WRT_REG_DWORD(&reg->iobase_addr, 0x4020);
1067                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1068                 for (cnt = 0; cnt < 16; cnt++)
1069                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1070
1071                 WRT_REG_DWORD(&reg->iobase_addr, 0x4030);
1072                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1073                 for (cnt = 0; cnt < 16; cnt++)
1074                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1075
1076                 WRT_REG_DWORD(&reg->iobase_addr, 0x4040);
1077                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1078                 for (cnt = 0; cnt < 16; cnt++)
1079                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1080
1081                 WRT_REG_DWORD(&reg->iobase_addr, 0x4050);
1082                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1083                 for (cnt = 0; cnt < 16; cnt++)
1084                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1085
1086                 WRT_REG_DWORD(&reg->iobase_addr, 0x4060);
1087                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1088                 for (cnt = 0; cnt < 16; cnt++)
1089                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1090
1091                 WRT_REG_DWORD(&reg->iobase_addr, 0x4070);
1092                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1093                 for (cnt = 0; cnt < 16; cnt++)
1094                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1095
1096                 WRT_REG_DWORD(&reg->iobase_addr, 0x4080);
1097                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1098                 for (cnt = 0; cnt < 16; cnt++)
1099                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1100
1101                 WRT_REG_DWORD(&reg->iobase_addr, 0x4090);
1102                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1103                 for (cnt = 0; cnt < 16; cnt++)
1104                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1105
1106                 WRT_REG_DWORD(&reg->iobase_addr, 0x40A0);
1107                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1108                 for (cnt = 0; cnt < 16; cnt++)
1109                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1110
1111                 WRT_REG_DWORD(&reg->iobase_addr, 0x40B0);
1112                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1113                 for (cnt = 0; cnt < 16; cnt++)
1114                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1115
1116                 /* Frame Buffer registers. */
1117                 iter_reg = fw->fb_hdw_reg;
1118                 WRT_REG_DWORD(&reg->iobase_addr, 0x6000);
1119                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1120                 for (cnt = 0; cnt < 16; cnt++)
1121                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1122
1123                 WRT_REG_DWORD(&reg->iobase_addr, 0x6010);
1124                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1125                 for (cnt = 0; cnt < 16; cnt++)
1126                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1127
1128                 WRT_REG_DWORD(&reg->iobase_addr, 0x6020);
1129                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1130                 for (cnt = 0; cnt < 16; cnt++)
1131                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1132
1133                 WRT_REG_DWORD(&reg->iobase_addr, 0x6030);
1134                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1135                 for (cnt = 0; cnt < 16; cnt++)
1136                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1137
1138                 WRT_REG_DWORD(&reg->iobase_addr, 0x6040);
1139                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1140                 for (cnt = 0; cnt < 16; cnt++)
1141                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1142
1143                 WRT_REG_DWORD(&reg->iobase_addr, 0x6100);
1144                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1145                 for (cnt = 0; cnt < 16; cnt++)
1146                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1147
1148                 WRT_REG_DWORD(&reg->iobase_addr, 0x6130);
1149                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1150                 for (cnt = 0; cnt < 16; cnt++)
1151                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1152
1153                 WRT_REG_DWORD(&reg->iobase_addr, 0x6150);
1154                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1155                 for (cnt = 0; cnt < 16; cnt++)
1156                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1157
1158                 WRT_REG_DWORD(&reg->iobase_addr, 0x6170);
1159                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1160                 for (cnt = 0; cnt < 16; cnt++)
1161                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1162
1163                 WRT_REG_DWORD(&reg->iobase_addr, 0x6190);
1164                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1165                 for (cnt = 0; cnt < 16; cnt++)
1166                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1167
1168                 WRT_REG_DWORD(&reg->iobase_addr, 0x61B0);
1169                 dmp_reg = (uint32_t __iomem *)((uint8_t __iomem *)reg + 0xC0);
1170                 for (cnt = 0; cnt < 16; cnt++)
1171                         *iter_reg++ = htonl(RD_REG_DWORD(dmp_reg++));
1172
1173                 /* Reset RISC. */
1174                 WRT_REG_DWORD(&reg->ctrl_status,
1175                     CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
1176                 for (cnt = 0; cnt < 30000; cnt++) {
1177                         if ((RD_REG_DWORD(&reg->ctrl_status) &
1178                             CSRX_DMA_ACTIVE) == 0)
1179                                 break;
1180
1181                         udelay(10);
1182                 }
1183
1184                 WRT_REG_DWORD(&reg->ctrl_status,
1185                     CSRX_ISP_SOFT_RESET|CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
1186                 pci_read_config_word(ha->pdev, PCI_COMMAND, &wd);
1187
1188                 udelay(100);
1189                 /* Wait for firmware to complete NVRAM accesses. */
1190                 mb[0] = (uint32_t) RD_REG_WORD(&reg->mailbox0);
1191                 for (cnt = 10000 ; cnt && mb[0]; cnt--) {
1192                         udelay(5);
1193                         mb[0] = (uint32_t) RD_REG_WORD(&reg->mailbox0);
1194                         barrier();
1195                 }
1196
1197                 /* Wait for soft-reset to complete. */
1198                 for (cnt = 0; cnt < 30000; cnt++) {
1199                         if ((RD_REG_DWORD(&reg->ctrl_status) &
1200                             CSRX_ISP_SOFT_RESET) == 0)
1201                                 break;
1202
1203                         udelay(10);
1204                 }
1205                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_RESET);
1206                 RD_REG_DWORD(&reg->hccr);             /* PCI Posting. */
1207         }
1208
1209         for (cnt = 30000; RD_REG_WORD(&reg->mailbox0) != 0 &&
1210             rval == QLA_SUCCESS; cnt--) {
1211                 if (cnt)
1212                         udelay(100);
1213                 else
1214                         rval = QLA_FUNCTION_TIMEOUT;
1215         }
1216
1217         /* Memory. */
1218         if (rval == QLA_SUCCESS) {
1219                 /* Code RAM. */
1220                 risc_address = 0x20000;
1221                 WRT_REG_WORD(&reg->mailbox0, MBC_READ_RAM_EXTENDED);
1222                 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
1223         }
1224         for (cnt = 0; cnt < sizeof(fw->code_ram) / 4 && rval == QLA_SUCCESS;
1225             cnt++, risc_address++) {
1226                 WRT_REG_WORD(&reg->mailbox1, LSW(risc_address));
1227                 WRT_REG_WORD(&reg->mailbox8, MSW(risc_address));
1228                 RD_REG_WORD(&reg->mailbox8);
1229                 WRT_REG_DWORD(&reg->hccr, HCCRX_SET_HOST_INT);
1230
1231                 for (timer = 6000000; timer; timer--) {
1232                         /* Check for pending interrupts. */
1233                         stat = RD_REG_DWORD(&reg->host_status);
1234                         if (stat & HSRX_RISC_INT) {
1235                                 stat &= 0xff;
1236
1237                                 if (stat == 0x1 || stat == 0x2 ||
1238                                     stat == 0x10 || stat == 0x11) {
1239                                         set_bit(MBX_INTERRUPT,
1240                                             &ha->mbx_cmd_flags);
1241
1242                                         mb[0] = RD_REG_WORD(&reg->mailbox0);
1243                                         mb[2] = RD_REG_WORD(&reg->mailbox2);
1244                                         mb[3] = RD_REG_WORD(&reg->mailbox3);
1245
1246                                         WRT_REG_DWORD(&reg->hccr,
1247                                             HCCRX_CLR_RISC_INT);
1248                                         RD_REG_DWORD(&reg->hccr);
1249                                         break;
1250                                 }
1251
1252                                 /* Clear this intr; it wasn't a mailbox intr */
1253                                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
1254                                 RD_REG_DWORD(&reg->hccr);
1255                         }
1256                         udelay(5);
1257                 }
1258
1259                 if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
1260                         rval = mb[0] & MBS_MASK;
1261                         fw->code_ram[cnt] = htonl((mb[3] << 16) | mb[2]);
1262                 } else {
1263                         rval = QLA_FUNCTION_FAILED;
1264                 }
1265         }
1266
1267         if (rval == QLA_SUCCESS) {
1268                 /* External Memory. */
1269                 risc_address = 0x100000;
1270                 ext_mem_cnt = ha->fw_memory_size - 0x100000 + 1;
1271                 WRT_REG_WORD(&reg->mailbox0, MBC_READ_RAM_EXTENDED);
1272                 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
1273         }
1274         for (cnt = 0; cnt < ext_mem_cnt && rval == QLA_SUCCESS;
1275             cnt++, risc_address++) {
1276                 WRT_REG_WORD(&reg->mailbox1, LSW(risc_address));
1277                 WRT_REG_WORD(&reg->mailbox8, MSW(risc_address));
1278                 RD_REG_WORD(&reg->mailbox8);
1279                 WRT_REG_DWORD(&reg->hccr, HCCRX_SET_HOST_INT);
1280
1281                 for (timer = 6000000; timer; timer--) {
1282                         /* Check for pending interrupts. */
1283                         stat = RD_REG_DWORD(&reg->host_status);
1284                         if (stat & HSRX_RISC_INT) {
1285                                 stat &= 0xff;
1286
1287                                 if (stat == 0x1 || stat == 0x2 ||
1288                                     stat == 0x10 || stat == 0x11) {
1289                                         set_bit(MBX_INTERRUPT,
1290                                             &ha->mbx_cmd_flags);
1291
1292                                         mb[0] = RD_REG_WORD(&reg->mailbox0);
1293                                         mb[2] = RD_REG_WORD(&reg->mailbox2);
1294                                         mb[3] = RD_REG_WORD(&reg->mailbox3);
1295
1296                                         WRT_REG_DWORD(&reg->hccr,
1297                                             HCCRX_CLR_RISC_INT);
1298                                         RD_REG_DWORD(&reg->hccr);
1299                                         break;
1300                                 }
1301
1302                                 /* Clear this intr; it wasn't a mailbox intr */
1303                                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
1304                                 RD_REG_DWORD(&reg->hccr);
1305                         }
1306                         udelay(5);
1307                 }
1308
1309                 if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags)) {
1310                         rval = mb[0] & MBS_MASK;
1311                         fw->ext_mem[cnt] = htonl((mb[3] << 16) | mb[2]);
1312                 } else {
1313                         rval = QLA_FUNCTION_FAILED;
1314                 }
1315         }
1316
1317         if (rval == QLA_SUCCESS) {
1318                 eft = qla2xxx_copy_queues(ha, &fw->ext_mem[cnt]);
1319                 if (ha->eft)
1320                         memcpy(eft, ha->eft, ntohl(ha->fw_dump->eft_size));
1321         }
1322
1323         if (rval != QLA_SUCCESS) {
1324                 qla_printk(KERN_WARNING, ha,
1325                     "Failed to dump firmware (%x)!!!\n", rval);
1326                 ha->fw_dumped = 0;
1327
1328         } else {
1329                 qla_printk(KERN_INFO, ha,
1330                     "Firmware dump saved to temp buffer (%ld/%p).\n",
1331                     ha->host_no, ha->fw_dump);
1332                 ha->fw_dumped = 1;
1333         }
1334
1335 qla24xx_fw_dump_failed:
1336         if (!hardware_locked)
1337                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1338 }
1339
1340 /****************************************************************************/
1341 /*                         Driver Debug Functions.                          */
1342 /****************************************************************************/
1343
1344 void
1345 qla2x00_dump_regs(scsi_qla_host_t *ha)
1346 {
1347         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1348
1349         printk("Mailbox registers:\n");
1350         printk("scsi(%ld): mbox 0 0x%04x \n",
1351             ha->host_no, RD_MAILBOX_REG(ha, reg, 0));
1352         printk("scsi(%ld): mbox 1 0x%04x \n",
1353             ha->host_no, RD_MAILBOX_REG(ha, reg, 1));
1354         printk("scsi(%ld): mbox 2 0x%04x \n",
1355             ha->host_no, RD_MAILBOX_REG(ha, reg, 2));
1356         printk("scsi(%ld): mbox 3 0x%04x \n",
1357             ha->host_no, RD_MAILBOX_REG(ha, reg, 3));
1358         printk("scsi(%ld): mbox 4 0x%04x \n",
1359             ha->host_no, RD_MAILBOX_REG(ha, reg, 4));
1360         printk("scsi(%ld): mbox 5 0x%04x \n",
1361             ha->host_no, RD_MAILBOX_REG(ha, reg, 5));
1362 }
1363
1364
1365 void
1366 qla2x00_dump_buffer(uint8_t * b, uint32_t size)
1367 {
1368         uint32_t cnt;
1369         uint8_t c;
1370
1371         printk(" 0   1   2   3   4   5   6   7   8   9  "
1372             "Ah  Bh  Ch  Dh  Eh  Fh\n");
1373         printk("----------------------------------------"
1374             "----------------------\n");
1375
1376         for (cnt = 0; cnt < size;) {
1377                 c = *b++;
1378                 printk("%02x",(uint32_t) c);
1379                 cnt++;
1380                 if (!(cnt % 16))
1381                         printk("\n");
1382                 else
1383                         printk("  ");
1384         }
1385         if (cnt % 16)
1386                 printk("\n");
1387 }
1388
1389 /**************************************************************************
1390  *   qla2x00_print_scsi_cmd
1391  *       Dumps out info about the scsi cmd and srb.
1392  *   Input
1393  *       cmd : struct scsi_cmnd
1394  **************************************************************************/
1395 void
1396 qla2x00_print_scsi_cmd(struct scsi_cmnd * cmd)
1397 {
1398         int i;
1399         struct scsi_qla_host *ha;
1400         srb_t *sp;
1401
1402         ha = (struct scsi_qla_host *)cmd->device->host->hostdata;
1403
1404         sp = (srb_t *) cmd->SCp.ptr;
1405         printk("SCSI Command @=0x%p, Handle=0x%p\n", cmd, cmd->host_scribble);
1406         printk("  chan=0x%02x, target=0x%02x, lun=0x%02x, cmd_len=0x%02x\n",
1407             cmd->device->channel, cmd->device->id, cmd->device->lun,
1408             cmd->cmd_len);
1409         printk(" CDB: ");
1410         for (i = 0; i < cmd->cmd_len; i++) {
1411                 printk("0x%02x ", cmd->cmnd[i]);
1412         }
1413         printk("\n  seg_cnt=%d, allowed=%d, retries=%d\n",
1414             cmd->use_sg, cmd->allowed, cmd->retries);
1415         printk("  request buffer=0x%p, request buffer len=0x%x\n",
1416             cmd->request_buffer, cmd->request_bufflen);
1417         printk("  tag=%d, transfersize=0x%x\n",
1418             cmd->tag, cmd->transfersize);
1419         printk("  serial_number=%lx, SP=%p\n", cmd->serial_number, sp);
1420         printk("  data direction=%d\n", cmd->sc_data_direction);
1421
1422         if (!sp)
1423                 return;
1424
1425         printk("  sp flags=0x%x\n", sp->flags);
1426 }
1427
1428 void
1429 qla2x00_dump_pkt(void *pkt)
1430 {
1431         uint32_t i;
1432         uint8_t *data = (uint8_t *) pkt;
1433
1434         for (i = 0; i < 64; i++) {
1435                 if (!(i % 4))
1436                         printk("\n%02x: ", i);
1437
1438                 printk("%02x ", data[i]);
1439         }
1440         printk("\n");
1441 }
1442
1443 #if defined(QL_DEBUG_ROUTINES)
1444 /*
1445  * qla2x00_formatted_dump_buffer
1446  *       Prints string plus buffer.
1447  *
1448  * Input:
1449  *       string  = Null terminated string (no newline at end).
1450  *       buffer  = buffer address.
1451  *       wd_size = word size 8, 16, 32 or 64 bits
1452  *       count   = number of words.
1453  */
1454 void
1455 qla2x00_formatted_dump_buffer(char *string, uint8_t * buffer,
1456                                 uint8_t wd_size, uint32_t count)
1457 {
1458         uint32_t cnt;
1459         uint16_t *buf16;
1460         uint32_t *buf32;
1461
1462         if (strcmp(string, "") != 0)
1463                 printk("%s\n",string);
1464
1465         switch (wd_size) {
1466                 case 8:
1467                         printk(" 0    1    2    3    4    5    6    7    "
1468                                 "8    9    Ah   Bh   Ch   Dh   Eh   Fh\n");
1469                         printk("-----------------------------------------"
1470                                 "-------------------------------------\n");
1471
1472                         for (cnt = 1; cnt <= count; cnt++, buffer++) {
1473                                 printk("%02x",*buffer);
1474                                 if (cnt % 16 == 0)
1475                                         printk("\n");
1476                                 else
1477                                         printk("  ");
1478                         }
1479                         if (cnt % 16 != 0)
1480                                 printk("\n");
1481                         break;
1482                 case 16:
1483                         printk("   0      2      4      6      8      Ah "
1484                                 "       Ch     Eh\n");
1485                         printk("-----------------------------------------"
1486                                 "-------------\n");
1487
1488                         buf16 = (uint16_t *) buffer;
1489                         for (cnt = 1; cnt <= count; cnt++, buf16++) {
1490                                 printk("%4x",*buf16);
1491
1492                                 if (cnt % 8 == 0)
1493                                         printk("\n");
1494                                 else if (*buf16 < 10)
1495                                         printk("   ");
1496                                 else
1497                                         printk("  ");
1498                         }
1499                         if (cnt % 8 != 0)
1500                                 printk("\n");
1501                         break;
1502                 case 32:
1503                         printk("       0          4          8          Ch\n");
1504                         printk("------------------------------------------\n");
1505
1506                         buf32 = (uint32_t *) buffer;
1507                         for (cnt = 1; cnt <= count; cnt++, buf32++) {
1508                                 printk("%8x", *buf32);
1509
1510                                 if (cnt % 4 == 0)
1511                                         printk("\n");
1512                                 else if (*buf32 < 10)
1513                                         printk("   ");
1514                                 else
1515                                         printk("  ");
1516                         }
1517                         if (cnt % 4 != 0)
1518                                 printk("\n");
1519                         break;
1520                 default:
1521                         break;
1522         }
1523 }
1524 #endif