drivers/scsi/qla4xxx/ql4_mbx.c

   1 /*
   2  * QLogic iSCSI HBA Driver
   3  * Copyright (c)  2003-2006 QLogic Corporation
   4  *
   5  * See LICENSE.qla4xxx for copyright and licensing details.
   6  */
   7
   8 #include "ql4_def.h"
   9 #include "ql4_glbl.h"
  10 #include "ql4_dbg.h"
  11 #include "ql4_inline.h"
  12
  13
  14 /**
  15  * qla4xxx_mailbox_command - issues mailbox commands
  16  * @ha: Pointer to host adapter structure.
  17  * @inCount: number of mailbox registers to load.
  18  * @outCount: number of mailbox registers to return.
  19  * @mbx_cmd: data pointer for mailbox in registers.
  20  * @mbx_sts: data pointer for mailbox out registers.
  21  *
  22  * This routine sssue mailbox commands and waits for completion.
  23  * If outCount is 0, this routine completes successfully WITHOUT waiting
  24  * for the mailbox command to complete.
  25  **/
  26 static int qla4xxx_mailbox_command(struct scsi_qla_host *ha, uint8_t inCount,
  27                                    uint8_t outCount, uint32_t *mbx_cmd,
  28                                    uint32_t *mbx_sts)
  29 {
  30         int status = QLA_ERROR;
  31         uint8_t i;
  32         u_long wait_count;
  33         uint32_t intr_status;
  34         unsigned long flags = 0;
  35
  36         /* Make sure that pointers are valid */
  37         if (!mbx_cmd || !mbx_sts) {
  38                 DEBUG2(printk("scsi%ld: %s: Invalid mbx_cmd or mbx_sts "
  39                               "pointer\n", ha->host_no, __func__));
  40                 return status;
  41         }
  42         /* Mailbox code active */
  43         wait_count = MBOX_TOV * 100;
  44
  45         while (wait_count--) {
  46                 mutex_lock(&ha->mbox_sem);
  47                 if (!test_bit(AF_MBOX_COMMAND, &ha->flags)) {
  48                         set_bit(AF_MBOX_COMMAND, &ha->flags);
  49                         mutex_unlock(&ha->mbox_sem);
  50                         break;
  51                 }
  52                 mutex_unlock(&ha->mbox_sem);
  53                 if (!wait_count) {
  54                         DEBUG2(printk("scsi%ld: %s: mbox_sem failed\n",
  55                                 ha->host_no, __func__));
  56                         return status;
  57                 }
  58                 msleep(10);
  59         }
  60
  61         /* To prevent overwriting mailbox registers for a command that has
  62          * not yet been serviced, check to see if a previously issued
  63          * mailbox command is interrupting.
  64          * -----------------------------------------------------------------
  65          */
  66         spin_lock_irqsave(&ha->hardware_lock, flags);
  67         intr_status = readl(&ha->reg->ctrl_status);
  68         if (intr_status & CSR_SCSI_PROCESSOR_INTR) {
  69                 /* Service existing interrupt */
  70                 qla4xxx_interrupt_service_routine(ha, intr_status);
  71                 clear_bit(AF_MBOX_COMMAND_DONE, &ha->flags);
  72         }
  73
  74         /* Send the mailbox command to the firmware */
  75         ha->mbox_status_count = outCount;
  76         for (i = 0; i < outCount; i++)
  77                 ha->mbox_status[i] = 0;
  78
  79         /* Load all mailbox registers, except mailbox 0. */
  80         for (i = 1; i < inCount; i++)
  81                 writel(mbx_cmd[i], &ha->reg->mailbox[i]);
  82
  83         /* Wakeup firmware  */
  84         writel(mbx_cmd[0], &ha->reg->mailbox[0]);
  85         readl(&ha->reg->mailbox[0]);
  86         writel(set_rmask(CSR_INTR_RISC), &ha->reg->ctrl_status);
  87         readl(&ha->reg->ctrl_status);
  88         spin_unlock_irqrestore(&ha->hardware_lock, flags);
  89
  90         /* Wait for completion */
  91
  92         /*
  93          * If we don't want status, don't wait for the mailbox command to
  94          * complete.  For example, MBOX_CMD_RESET_FW doesn't return status,
  95          * you must poll the inbound Interrupt Mask for completion.
  96          */
  97         if (outCount == 0) {
  98                 status = QLA_SUCCESS;
  99                 goto mbox_exit;
 100         }
 101         /* Wait for command to complete */
 102         wait_count = jiffies + MBOX_TOV * HZ;
 103         while (test_bit(AF_MBOX_COMMAND_DONE, &ha->flags) == 0) {
 104                 if (time_after_eq(jiffies, wait_count))
 105                         break;
 106
 107                 spin_lock_irqsave(&ha->hardware_lock, flags);
 108                 intr_status = readl(&ha->reg->ctrl_status);
 109                 if (intr_status & INTR_PENDING) {
 110                         /*
 111                          * Service the interrupt.
 112                          * The ISR will save the mailbox status registers
 113                          * to a temporary storage location in the adapter
 114                          * structure.
 115                          */
 116                         ha->mbox_status_count = outCount;
 117                         qla4xxx_interrupt_service_routine(ha, intr_status);
 118                 }
 119                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
 120                 msleep(10);
 121         }
 122
 123         /* Check for mailbox timeout. */
 124         if (!test_bit(AF_MBOX_COMMAND_DONE, &ha->flags)) {
 125                 DEBUG2(printk("scsi%ld: Mailbox Cmd 0x%08X timed out ...,"
 126                               " Scheduling Adapter Reset\n", ha->host_no,
 127                               mbx_cmd[0]));
 128                 ha->mailbox_timeout_count++;
 129                 mbx_sts[0] = (-1);
 130                 set_bit(DPC_RESET_HA, &ha->dpc_flags);
 131                 goto mbox_exit;
 132         }
 133
 134         /*
 135          * Copy the mailbox out registers to the caller's mailbox in/out
 136          * structure.
 137          */
 138         spin_lock_irqsave(&ha->hardware_lock, flags);
 139         for (i = 0; i < outCount; i++)
 140                 mbx_sts[i] = ha->mbox_status[i];
 141
 142         /* Set return status and error flags (if applicable). */
 143         switch (ha->mbox_status[0]) {
 144         case MBOX_STS_COMMAND_COMPLETE:
 145                 status = QLA_SUCCESS;
 146                 break;
 147
 148         case MBOX_STS_INTERMEDIATE_COMPLETION:
 149                 status = QLA_SUCCESS;
 150                 break;
 151
 152         case MBOX_STS_BUSY:
 153                 DEBUG2( printk("scsi%ld: %s: Cmd = %08X, ISP BUSY\n",
 154                                ha->host_no, __func__, mbx_cmd[0]));
 155                 ha->mailbox_timeout_count++;
 156                 break;
 157
 158         default:
 159                 DEBUG2(printk("scsi%ld: %s: **** FAILED, cmd = %08X, "
 160                               "sts = %08X ****\n", ha->host_no, __func__,
 161                               mbx_cmd[0], mbx_sts[0]));
 162                 break;
 163         }
 164         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 165
 166 mbox_exit:
 167         mutex_lock(&ha->mbox_sem);
 168         clear_bit(AF_MBOX_COMMAND, &ha->flags);
 169         mutex_unlock(&ha->mbox_sem);
 170         clear_bit(AF_MBOX_COMMAND_DONE, &ha->flags);
 171
 172         return status;
 173 }
 174
 175 /**
 176  * qla4xxx_initialize_fw_cb - initializes firmware control block.
 177  * @ha: Pointer to host adapter structure.
 178  **/
 179 int qla4xxx_initialize_fw_cb(struct scsi_qla_host * ha)
 180 {
 181         struct init_fw_ctrl_blk *init_fw_cb;
 182         dma_addr_t init_fw_cb_dma;
 183         uint32_t mbox_cmd[MBOX_REG_COUNT];
 184         uint32_t mbox_sts[MBOX_REG_COUNT];
 185         int status = QLA_ERROR;
 186
 187         init_fw_cb = dma_alloc_coherent(&ha->pdev->dev,
 188                                         sizeof(struct init_fw_ctrl_blk),
 189                                         &init_fw_cb_dma, GFP_KERNEL);
 190         if (init_fw_cb == NULL) {
 191                 DEBUG2(printk("scsi%ld: %s: Unable to alloc init_cb\n",
 192                               ha->host_no, __func__));
 193                 return 10;
 194         }
 195         memset(init_fw_cb, 0, sizeof(struct init_fw_ctrl_blk));
 196
 197         /* Get Initialize Firmware Control Block. */
 198         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 199         memset(&mbox_sts, 0, sizeof(mbox_sts));
 200
 201         mbox_cmd[0] = MBOX_CMD_GET_INIT_FW_CTRL_BLOCK;
 202         mbox_cmd[2] = LSDW(init_fw_cb_dma);
 203         mbox_cmd[3] = MSDW(init_fw_cb_dma);
 204         mbox_cmd[4] = sizeof(struct init_fw_ctrl_blk);
 205
 206         if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 1, &mbox_cmd[0], &mbox_sts[0]) !=
 207             QLA_SUCCESS) {
 208                 dma_free_coherent(&ha->pdev->dev,
 209                                   sizeof(struct init_fw_ctrl_blk),
 210                                   init_fw_cb, init_fw_cb_dma);
 211                 return status;
 212         }
 213
 214         /* Initialize request and response queues. */
 215         qla4xxx_init_rings(ha);
 216
 217         /* Fill in the request and response queue information. */
 218         init_fw_cb->pri.rqq_consumer_idx = cpu_to_le16(ha->request_out);
 219         init_fw_cb->pri.compq_producer_idx = cpu_to_le16(ha->response_in);
 220         init_fw_cb->pri.rqq_len = __constant_cpu_to_le16(REQUEST_QUEUE_DEPTH);
 221         init_fw_cb->pri.compq_len = __constant_cpu_to_le16(RESPONSE_QUEUE_DEPTH);
 222         init_fw_cb->pri.rqq_addr_lo = cpu_to_le32(LSDW(ha->request_dma));
 223         init_fw_cb->pri.rqq_addr_hi = cpu_to_le32(MSDW(ha->request_dma));
 224         init_fw_cb->pri.compq_addr_lo = cpu_to_le32(LSDW(ha->response_dma));
 225         init_fw_cb->pri.compq_addr_hi = cpu_to_le32(MSDW(ha->response_dma));
 226         init_fw_cb->pri.shdwreg_addr_lo =
 227                 cpu_to_le32(LSDW(ha->shadow_regs_dma));
 228         init_fw_cb->pri.shdwreg_addr_hi =
 229                 cpu_to_le32(MSDW(ha->shadow_regs_dma));
 230
 231         /* Set up required options. */
 232         init_fw_cb->pri.fw_options |=
 233                 __constant_cpu_to_le16(FWOPT_SESSION_MODE |
 234                                        FWOPT_INITIATOR_MODE);
 235         init_fw_cb->pri.fw_options &= __constant_cpu_to_le16(~FWOPT_TARGET_MODE);
 236
 237         /* Save some info in adapter structure. */
 238         ha->firmware_options = le16_to_cpu(init_fw_cb->pri.fw_options);
 239         ha->tcp_options = le16_to_cpu(init_fw_cb->pri.ipv4_tcp_opts);
 240         ha->heartbeat_interval = init_fw_cb->pri.hb_interval;
 241         memcpy(ha->ip_address, init_fw_cb->pri.ipv4_addr,
 242                min(sizeof(ha->ip_address), sizeof(init_fw_cb->pri.ipv4_addr)));
 243         memcpy(ha->subnet_mask, init_fw_cb->pri.ipv4_subnet,
 244                min(sizeof(ha->subnet_mask), sizeof(init_fw_cb->pri.ipv4_subnet)));
 245         memcpy(ha->gateway, init_fw_cb->pri.ipv4_gw_addr,
 246                min(sizeof(ha->gateway), sizeof(init_fw_cb->pri.ipv4_gw_addr)));
 247         memcpy(ha->name_string, init_fw_cb->pri.iscsi_name,
 248                min(sizeof(ha->name_string),
 249                    sizeof(init_fw_cb->pri.iscsi_name)));
 250         /*memcpy(ha->alias, init_fw_cb->Alias,
 251                min(sizeof(ha->alias), sizeof(init_fw_cb->Alias)));*/
 252
 253         /* Save Command Line Paramater info */
 254         ha->port_down_retry_count = le16_to_cpu(init_fw_cb->pri.conn_ka_timeout);
 255         ha->discovery_wait = ql4xdiscoverywait;
 256
 257         /* Send Initialize Firmware Control Block. */
 258         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 259         memset(&mbox_sts, 0, sizeof(mbox_sts));
 260
 261         mbox_cmd[0] = MBOX_CMD_INITIALIZE_FIRMWARE;
 262         mbox_cmd[1] = 0;
 263         mbox_cmd[2] = LSDW(init_fw_cb_dma);
 264         mbox_cmd[3] = MSDW(init_fw_cb_dma);
 265         mbox_cmd[4] = sizeof(struct init_fw_ctrl_blk);
 266
 267         if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 1, &mbox_cmd[0], &mbox_sts[0]) ==
 268             QLA_SUCCESS)
 269                 status = QLA_SUCCESS;
 270          else {
 271                 DEBUG2(printk("scsi%ld: %s: MBOX_CMD_INITIALIZE_FIRMWARE "
 272                               "failed w/ status %04X\n", ha->host_no, __func__,
 273                               mbox_sts[0]));
 274         }
 275         dma_free_coherent(&ha->pdev->dev, sizeof(struct init_fw_ctrl_blk),
 276                           init_fw_cb, init_fw_cb_dma);
 277
 278         return status;
 279 }
 280
 281 /**
 282  * qla4xxx_get_dhcp_ip_address - gets HBA ip address via DHCP
 283  * @ha: Pointer to host adapter structure.
 284  **/
 285 int qla4xxx_get_dhcp_ip_address(struct scsi_qla_host * ha)
 286 {
 287         struct init_fw_ctrl_blk *init_fw_cb;
 288         dma_addr_t init_fw_cb_dma;
 289         uint32_t mbox_cmd[MBOX_REG_COUNT];
 290         uint32_t mbox_sts[MBOX_REG_COUNT];
 291
 292         init_fw_cb = dma_alloc_coherent(&ha->pdev->dev,
 293                                         sizeof(struct init_fw_ctrl_blk),
 294                                         &init_fw_cb_dma, GFP_KERNEL);
 295         if (init_fw_cb == NULL) {
 296                 printk("scsi%ld: %s: Unable to alloc init_cb\n", ha->host_no,
 297                        __func__);
 298                 return 10;
 299         }
 300
 301         /* Get Initialize Firmware Control Block. */
 302         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 303         memset(&mbox_sts, 0, sizeof(mbox_sts));
 304
 305         memset(init_fw_cb, 0, sizeof(struct init_fw_ctrl_blk));
 306         mbox_cmd[0] = MBOX_CMD_GET_INIT_FW_CTRL_BLOCK;
 307         mbox_cmd[2] = LSDW(init_fw_cb_dma);
 308         mbox_cmd[3] = MSDW(init_fw_cb_dma);
 309         mbox_cmd[4] = sizeof(struct init_fw_ctrl_blk);
 310
 311         if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 1, &mbox_cmd[0], &mbox_sts[0]) !=
 312             QLA_SUCCESS) {
 313                 DEBUG2(printk("scsi%ld: %s: Failed to get init_fw_ctrl_blk\n",
 314                               ha->host_no, __func__));
 315                 dma_free_coherent(&ha->pdev->dev,
 316                                   sizeof(struct init_fw_ctrl_blk),
 317                                   init_fw_cb, init_fw_cb_dma);
 318                 return QLA_ERROR;
 319         }
 320
 321         /* Save IP Address. */
 322         memcpy(ha->ip_address, init_fw_cb->pri.ipv4_addr,
 323                min(sizeof(ha->ip_address), sizeof(init_fw_cb->pri.ipv4_addr)));
 324         memcpy(ha->subnet_mask, init_fw_cb->pri.ipv4_subnet,
 325                min(sizeof(ha->subnet_mask), sizeof(init_fw_cb->pri.ipv4_subnet)));
 326         memcpy(ha->gateway, init_fw_cb->pri.ipv4_gw_addr,
 327                min(sizeof(ha->gateway), sizeof(init_fw_cb->pri.ipv4_gw_addr)));
 328
 329         dma_free_coherent(&ha->pdev->dev, sizeof(struct init_fw_ctrl_blk),
 330                           init_fw_cb, init_fw_cb_dma);
 331
 332         return QLA_SUCCESS;
 333 }
 334
 335 /**
 336  * qla4xxx_get_firmware_state - gets firmware state of HBA
 337  * @ha: Pointer to host adapter structure.
 338  **/
 339 int qla4xxx_get_firmware_state(struct scsi_qla_host * ha)
 340 {
 341         uint32_t mbox_cmd[MBOX_REG_COUNT];
 342         uint32_t mbox_sts[MBOX_REG_COUNT];
 343
 344         /* Get firmware version */
 345         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 346         memset(&mbox_sts, 0, sizeof(mbox_sts));
 347
 348         mbox_cmd[0] = MBOX_CMD_GET_FW_STATE;
 349
 350         if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 4, &mbox_cmd[0], &mbox_sts[0]) !=
 351             QLA_SUCCESS) {
 352                 DEBUG2(printk("scsi%ld: %s: MBOX_CMD_GET_FW_STATE failed w/ "
 353                               "status %04X\n", ha->host_no, __func__,
 354                               mbox_sts[0]));
 355                 return QLA_ERROR;
 356         }
 357         ha->firmware_state = mbox_sts[1];
 358         ha->board_id = mbox_sts[2];
 359         ha->addl_fw_state = mbox_sts[3];
 360         DEBUG2(printk("scsi%ld: %s firmware_state=0x%x\n",
 361                       ha->host_no, __func__, ha->firmware_state);)
 362
 363                 return QLA_SUCCESS;
 364 }
 365
 366 /**
 367  * qla4xxx_get_firmware_status - retrieves firmware status
 368  * @ha: Pointer to host adapter structure.
 369  **/
 370 int qla4xxx_get_firmware_status(struct scsi_qla_host * ha)
 371 {
 372         uint32_t mbox_cmd[MBOX_REG_COUNT];
 373         uint32_t mbox_sts[MBOX_REG_COUNT];
 374
 375         /* Get firmware version */
 376         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 377         memset(&mbox_sts, 0, sizeof(mbox_sts));
 378
 379         mbox_cmd[0] = MBOX_CMD_GET_FW_STATUS;
 380
 381         if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 3, &mbox_cmd[0], &mbox_sts[0]) !=
 382             QLA_SUCCESS) {
 383                 DEBUG2(printk("scsi%ld: %s: MBOX_CMD_GET_FW_STATUS failed w/ "
 384                               "status %04X\n", ha->host_no, __func__,
 385                               mbox_sts[0]));
 386                 return QLA_ERROR;
 387         }
 388         return QLA_SUCCESS;
 389 }
 390
 391 /**
 392  * qla4xxx_get_fwddb_entry - retrieves firmware ddb entry
 393  * @ha: Pointer to host adapter structure.
 394  * @fw_ddb_index: Firmware's device database index
 395  * @fw_ddb_entry: Pointer to firmware's device database entry structure
 396  * @num_valid_ddb_entries: Pointer to number of valid ddb entries
 397  * @next_ddb_index: Pointer to next valid device database index
 398  * @fw_ddb_device_state: Pointer to device state
 399  **/
 400 int qla4xxx_get_fwddb_entry(struct scsi_qla_host *ha,
 401                             uint16_t fw_ddb_index,
 402                             struct dev_db_entry *fw_ddb_entry,
 403                             dma_addr_t fw_ddb_entry_dma,
 404                             uint32_t *num_valid_ddb_entries,
 405                             uint32_t *next_ddb_index,
 406                             uint32_t *fw_ddb_device_state,
 407                             uint32_t *conn_err_detail,
 408                             uint16_t *tcp_source_port_num,
 409                             uint16_t *connection_id)
 410 {
 411         int status = QLA_ERROR;
 412         uint32_t mbox_cmd[MBOX_REG_COUNT];
 413         uint32_t mbox_sts[MBOX_REG_COUNT];
 414
 415         /* Make sure the device index is valid */
 416         if (fw_ddb_index >= MAX_DDB_ENTRIES) {
 417                 DEBUG2(printk("scsi%ld: %s: index [%d] out of range.\n",
 418                               ha->host_no, __func__, fw_ddb_index));
 419                 goto exit_get_fwddb;
 420         }
 421         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 422         memset(&mbox_sts, 0, sizeof(mbox_sts));
 423
 424         mbox_cmd[0] = MBOX_CMD_GET_DATABASE_ENTRY;
 425         mbox_cmd[1] = (uint32_t) fw_ddb_index;
 426         mbox_cmd[2] = LSDW(fw_ddb_entry_dma);
 427         mbox_cmd[3] = MSDW(fw_ddb_entry_dma);
 428         mbox_cmd[4] = sizeof(struct dev_db_entry);
 429
 430         if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 7, &mbox_cmd[0], &mbox_sts[0]) ==
 431             QLA_ERROR) {
 432                 DEBUG2(printk("scsi%ld: %s: MBOX_CMD_GET_DATABASE_ENTRY failed"
 433                               " with status 0x%04X\n", ha->host_no, __func__,
 434                               mbox_sts[0]));
 435                 goto exit_get_fwddb;
 436         }
 437         if (fw_ddb_index != mbox_sts[1]) {
 438                 DEBUG2(printk("scsi%ld: %s: index mismatch [%d] != [%d].\n",
 439                               ha->host_no, __func__, fw_ddb_index,
 440                               mbox_sts[1]));
 441                 goto exit_get_fwddb;
 442         }
 443         if (fw_ddb_entry) {
 444                 dev_info(&ha->pdev->dev, "DDB[%d] MB0 %04x Tot %d Next %d "
 445                            "State %04x ConnErr %08x %d.%d.%d.%d:%04d \"%s\"\n",
 446                            fw_ddb_index, mbox_sts[0], mbox_sts[2], mbox_sts[3],
 447                            mbox_sts[4], mbox_sts[5], fw_ddb_entry->ip_addr[0],
 448                            fw_ddb_entry->ip_addr[1], fw_ddb_entry->ip_addr[2],
 449                            fw_ddb_entry->ip_addr[3],
 450                            le16_to_cpu(fw_ddb_entry->port),
 451                            fw_ddb_entry->iscsi_name);
 452         }
 453         if (num_valid_ddb_entries)
 454                 *num_valid_ddb_entries = mbox_sts[2];
 455         if (next_ddb_index)
 456                 *next_ddb_index = mbox_sts[3];
 457         if (fw_ddb_device_state)
 458                 *fw_ddb_device_state = mbox_sts[4];
 459
 460         /*
 461          * RA: This mailbox has been changed to pass connection error and
 462          * details.  Its true for ISP4010 as per Version E - Not sure when it
 463          * was changed.  Get the time2wait from the fw_dd_entry field :
 464          * default_time2wait which we call it as minTime2Wait DEV_DB_ENTRY
 465          * struct.
 466          */
 467         if (conn_err_detail)
 468                 *conn_err_detail = mbox_sts[5];
 469         if (tcp_source_port_num)
 470                 *tcp_source_port_num = (uint16_t) mbox_sts[6] >> 16;
 471         if (connection_id)
 472                 *connection_id = (uint16_t) mbox_sts[6] & 0x00FF;
 473         status = QLA_SUCCESS;
 474
 475 exit_get_fwddb:
 476         return status;
 477 }
 478
 479 /**
 480  * qla4xxx_set_fwddb_entry - sets a ddb entry.
 481  * @ha: Pointer to host adapter structure.
 482  * @fw_ddb_index: Firmware's device database index
 483  * @fw_ddb_entry: Pointer to firmware's ddb entry structure, or NULL.
 484  *
 485  * This routine initializes or updates the adapter's device database
 486  * entry for the specified device. It also triggers a login for the
 487  * specified device. Therefore, it may also be used as a secondary
 488  * login routine when a NULL pointer is specified for the fw_ddb_entry.
 489  **/
 490 int qla4xxx_set_ddb_entry(struct scsi_qla_host * ha, uint16_t fw_ddb_index,
 491                           dma_addr_t fw_ddb_entry_dma)
 492 {
 493         uint32_t mbox_cmd[MBOX_REG_COUNT];
 494         uint32_t mbox_sts[MBOX_REG_COUNT];
 495
 496         /* Do not wait for completion. The firmware will send us an
 497          * ASTS_DATABASE_CHANGED (0x8014) to notify us of the login status.
 498          */
 499         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 500         memset(&mbox_sts, 0, sizeof(mbox_sts));
 501
 502         mbox_cmd[0] = MBOX_CMD_SET_DATABASE_ENTRY;
 503         mbox_cmd[1] = (uint32_t) fw_ddb_index;
 504         mbox_cmd[2] = LSDW(fw_ddb_entry_dma);
 505         mbox_cmd[3] = MSDW(fw_ddb_entry_dma);
 506         mbox_cmd[4] = sizeof(struct dev_db_entry);
 507
 508         return qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 1, &mbox_cmd[0], &mbox_sts[0]);
 509 }
 510
 511 /**
 512  * qla4xxx_get_crash_record - retrieves crash record.
 513  * @ha: Pointer to host adapter structure.
 514  *
 515  * This routine retrieves a crash record from the QLA4010 after an 8002h aen.
 516  **/
 517 void qla4xxx_get_crash_record(struct scsi_qla_host * ha)
 518 {
 519         uint32_t mbox_cmd[MBOX_REG_COUNT];
 520         uint32_t mbox_sts[MBOX_REG_COUNT];
 521         struct crash_record *crash_record = NULL;
 522         dma_addr_t crash_record_dma = 0;
 523         uint32_t crash_record_size = 0;
 524
 525         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 526         memset(&mbox_sts, 0, sizeof(mbox_cmd));
 527
 528         /* Get size of crash record. */
 529         mbox_cmd[0] = MBOX_CMD_GET_CRASH_RECORD;
 530
 531         if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 5, &mbox_cmd[0], &mbox_sts[0]) !=
 532             QLA_SUCCESS) {
 533                 DEBUG2(printk("scsi%ld: %s: ERROR: Unable to retrieve size!\n",
 534                               ha->host_no, __func__));
 535                 goto exit_get_crash_record;
 536         }
 537         crash_record_size = mbox_sts[4];
 538         if (crash_record_size == 0) {
 539                 DEBUG2(printk("scsi%ld: %s: ERROR: Crash record size is 0!\n",
 540                               ha->host_no, __func__));
 541                 goto exit_get_crash_record;
 542         }
 543
 544         /* Alloc Memory for Crash Record. */
 545         crash_record = dma_alloc_coherent(&ha->pdev->dev, crash_record_size,
 546                                           &crash_record_dma, GFP_KERNEL);
 547         if (crash_record == NULL)
 548                 goto exit_get_crash_record;
 549
 550         /* Get Crash Record. */
 551         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 552         memset(&mbox_sts, 0, sizeof(mbox_cmd));
 553
 554         mbox_cmd[0] = MBOX_CMD_GET_CRASH_RECORD;
 555         mbox_cmd[2] = LSDW(crash_record_dma);
 556         mbox_cmd[3] = MSDW(crash_record_dma);
 557         mbox_cmd[4] = crash_record_size;
 558
 559         if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 5, &mbox_cmd[0], &mbox_sts[0]) !=
 560             QLA_SUCCESS)
 561                 goto exit_get_crash_record;
 562
 563         /* Dump Crash Record. */
 564
 565 exit_get_crash_record:
 566         if (crash_record)
 567                 dma_free_coherent(&ha->pdev->dev, crash_record_size,
 568                                   crash_record, crash_record_dma);
 569 }
 570
 571 /**
 572  * qla4xxx_get_conn_event_log - retrieves connection event log
 573  * @ha: Pointer to host adapter structure.
 574  **/
 575 void qla4xxx_get_conn_event_log(struct scsi_qla_host * ha)
 576 {
 577         uint32_t mbox_cmd[MBOX_REG_COUNT];
 578         uint32_t mbox_sts[MBOX_REG_COUNT];
 579         struct conn_event_log_entry *event_log = NULL;
 580         dma_addr_t event_log_dma = 0;
 581         uint32_t event_log_size = 0;
 582         uint32_t num_valid_entries;
 583         uint32_t      oldest_entry = 0;
 584         uint32_t        max_event_log_entries;
 585         uint8_t         i;
 586
 587
 588         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 589         memset(&mbox_sts, 0, sizeof(mbox_cmd));
 590
 591         /* Get size of crash record. */
 592         mbox_cmd[0] = MBOX_CMD_GET_CONN_EVENT_LOG;
 593
 594         if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 5, &mbox_cmd[0], &mbox_sts[0]) !=
 595             QLA_SUCCESS)
 596                 goto exit_get_event_log;
 597
 598         event_log_size = mbox_sts[4];
 599         if (event_log_size == 0)
 600                 goto exit_get_event_log;
 601
 602         /* Alloc Memory for Crash Record. */
 603         event_log = dma_alloc_coherent(&ha->pdev->dev, event_log_size,
 604                                        &event_log_dma, GFP_KERNEL);
 605         if (event_log == NULL)
 606                 goto exit_get_event_log;
 607
 608         /* Get Crash Record. */
 609         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 610         memset(&mbox_sts, 0, sizeof(mbox_cmd));
 611
 612         mbox_cmd[0] = MBOX_CMD_GET_CONN_EVENT_LOG;
 613         mbox_cmd[2] = LSDW(event_log_dma);
 614         mbox_cmd[3] = MSDW(event_log_dma);
 615
 616         if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 5, &mbox_cmd[0], &mbox_sts[0]) !=
 617             QLA_SUCCESS) {
 618                 DEBUG2(printk("scsi%ld: %s: ERROR: Unable to retrieve event "
 619                               "log!\n", ha->host_no, __func__));
 620                 goto exit_get_event_log;
 621         }
 622
 623         /* Dump Event Log. */
 624         num_valid_entries = mbox_sts[1];
 625
 626         max_event_log_entries = event_log_size /
 627                 sizeof(struct conn_event_log_entry);
 628
 629         if (num_valid_entries > max_event_log_entries)
 630                 oldest_entry = num_valid_entries % max_event_log_entries;
 631
 632         DEBUG3(printk("scsi%ld: Connection Event Log Dump (%d entries):\n",
 633                       ha->host_no, num_valid_entries));
 634
 635         if (ql4xextended_error_logging == 3) {
 636                 if (oldest_entry == 0) {
 637                         /* Circular Buffer has not wrapped around */
 638                         for (i=0; i < num_valid_entries; i++) {
 639                                 qla4xxx_dump_buffer((uint8_t *)event_log+
 640                                                     (i*sizeof(*event_log)),
 641                                                     sizeof(*event_log));
 642                         }
 643                 }
 644                 else {
 645                         /* Circular Buffer has wrapped around -
 646                          * display accordingly*/
 647                         for (i=oldest_entry; i < max_event_log_entries; i++) {
 648                                 qla4xxx_dump_buffer((uint8_t *)event_log+
 649                                                     (i*sizeof(*event_log)),
 650                                                     sizeof(*event_log));
 651                         }
 652                         for (i=0; i < oldest_entry; i++) {
 653                                 qla4xxx_dump_buffer((uint8_t *)event_log+
 654                                                     (i*sizeof(*event_log)),
 655                                                     sizeof(*event_log));
 656                         }
 657                 }
 658         }
 659
 660 exit_get_event_log:
 661         if (event_log)
 662                 dma_free_coherent(&ha->pdev->dev, event_log_size, event_log,
 663                                   event_log_dma);
 664 }
 665
 666 /**
 667  * qla4xxx_reset_lun - issues LUN Reset
 668  * @ha: Pointer to host adapter structure.
 669  * @db_entry: Pointer to device database entry
 670  * @un_entry: Pointer to lun entry structure
 671  *
 672  * This routine performs a LUN RESET on the specified target/lun.
 673  * The caller must ensure that the ddb_entry and lun_entry pointers
 674  * are valid before calling this routine.
 675  **/
 676 int qla4xxx_reset_lun(struct scsi_qla_host * ha, struct ddb_entry * ddb_entry,
 677                       int lun)
 678 {
 679         uint32_t mbox_cmd[MBOX_REG_COUNT];
 680         uint32_t mbox_sts[MBOX_REG_COUNT];
 681         int status = QLA_SUCCESS;
 682
 683         DEBUG2(printk("scsi%ld:%d:%d: lun reset issued\n", ha->host_no,
 684                       ddb_entry->os_target_id, lun));
 685
 686         /*
 687          * Send lun reset command to ISP, so that the ISP will return all
 688          * outstanding requests with RESET status
 689          */
 690         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 691         memset(&mbox_sts, 0, sizeof(mbox_sts));
 692
 693         mbox_cmd[0] = MBOX_CMD_LUN_RESET;
 694         mbox_cmd[1] = ddb_entry->fw_ddb_index;
 695         mbox_cmd[2] = lun << 8;
 696         mbox_cmd[5] = 0x01;     /* Immediate Command Enable */
 697
 698         qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 1, &mbox_cmd[0], &mbox_sts[0]);
 699         if (mbox_sts[0] != MBOX_STS_COMMAND_COMPLETE &&
 700             mbox_sts[0] != MBOX_STS_COMMAND_ERROR)
 701                 status = QLA_ERROR;
 702
 703         return status;
 704 }
 705
 706 /**
 707  * qla4xxx_reset_target - issues target Reset
 708  * @ha: Pointer to host adapter structure.
 709  * @db_entry: Pointer to device database entry
 710  * @un_entry: Pointer to lun entry structure
 711  *
 712  * This routine performs a TARGET RESET on the specified target.
 713  * The caller must ensure that the ddb_entry pointers
 714  * are valid before calling this routine.
 715  **/
 716 int qla4xxx_reset_target(struct scsi_qla_host *ha,
 717                          struct ddb_entry *ddb_entry)
 718 {
 719         uint32_t mbox_cmd[MBOX_REG_COUNT];
 720         uint32_t mbox_sts[MBOX_REG_COUNT];
 721         int status = QLA_SUCCESS;
 722
 723         DEBUG2(printk("scsi%ld:%d: target reset issued\n", ha->host_no,
 724                       ddb_entry->os_target_id));
 725
 726         /*
 727          * Send target reset command to ISP, so that the ISP will return all
 728          * outstanding requests with RESET status
 729          */
 730         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 731         memset(&mbox_sts, 0, sizeof(mbox_sts));
 732
 733         mbox_cmd[0] = MBOX_CMD_TARGET_WARM_RESET;
 734         mbox_cmd[1] = ddb_entry->fw_ddb_index;
 735         mbox_cmd[5] = 0x01;     /* Immediate Command Enable */
 736
 737         qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 1, &mbox_cmd[0],
 738                                 &mbox_sts[0]);
 739         if (mbox_sts[0] != MBOX_STS_COMMAND_COMPLETE &&
 740             mbox_sts[0] != MBOX_STS_COMMAND_ERROR)
 741                 status = QLA_ERROR;
 742
 743         return status;
 744 }
 745
 746 int qla4xxx_get_flash(struct scsi_qla_host * ha, dma_addr_t dma_addr,
 747                       uint32_t offset, uint32_t len)
 748 {
 749         uint32_t mbox_cmd[MBOX_REG_COUNT];
 750         uint32_t mbox_sts[MBOX_REG_COUNT];
 751
 752         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 753         memset(&mbox_sts, 0, sizeof(mbox_sts));
 754
 755         mbox_cmd[0] = MBOX_CMD_READ_FLASH;
 756         mbox_cmd[1] = LSDW(dma_addr);
 757         mbox_cmd[2] = MSDW(dma_addr);
 758         mbox_cmd[3] = offset;
 759         mbox_cmd[4] = len;
 760
 761         if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 2, &mbox_cmd[0], &mbox_sts[0]) !=
 762             QLA_SUCCESS) {
 763                 DEBUG2(printk("scsi%ld: %s: MBOX_CMD_READ_FLASH, failed w/ "
 764                     "status %04X %04X, offset %08x, len %08x\n", ha->host_no,
 765                     __func__, mbox_sts[0], mbox_sts[1], offset, len));
 766                 return QLA_ERROR;
 767         }
 768         return QLA_SUCCESS;
 769 }
 770
 771 /**
 772  * qla4xxx_get_fw_version - gets firmware version
 773  * @ha: Pointer to host adapter structure.
 774  *
 775  * Retrieves the firmware version on HBA. In QLA4010, mailboxes 2 & 3 may
 776  * hold an address for data.  Make sure that we write 0 to those mailboxes,
 777  * if unused.
 778  **/
 779 int qla4xxx_get_fw_version(struct scsi_qla_host * ha)
 780 {
 781         uint32_t mbox_cmd[MBOX_REG_COUNT];
 782         uint32_t mbox_sts[MBOX_REG_COUNT];
 783
 784         /* Get firmware version. */
 785         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 786         memset(&mbox_sts, 0, sizeof(mbox_sts));
 787
 788         mbox_cmd[0] = MBOX_CMD_ABOUT_FW;
 789
 790         if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 5, &mbox_cmd[0], &mbox_sts[0]) !=
 791             QLA_SUCCESS) {
 792                 DEBUG2(printk("scsi%ld: %s: MBOX_CMD_ABOUT_FW failed w/ "
 793                     "status %04X\n", ha->host_no, __func__, mbox_sts[0]));
 794                 return QLA_ERROR;
 795         }
 796
 797         /* Save firmware version information. */
 798         ha->firmware_version[0] = mbox_sts[1];
 799         ha->firmware_version[1] = mbox_sts[2];
 800         ha->patch_number = mbox_sts[3];
 801         ha->build_number = mbox_sts[4];
 802
 803         return QLA_SUCCESS;
 804 }
 805
 806 static int qla4xxx_get_default_ddb(struct scsi_qla_host *ha,
 807                                    dma_addr_t dma_addr)
 808 {
 809         uint32_t mbox_cmd[MBOX_REG_COUNT];
 810         uint32_t mbox_sts[MBOX_REG_COUNT];
 811
 812         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 813         memset(&mbox_sts, 0, sizeof(mbox_sts));
 814
 815         mbox_cmd[0] = MBOX_CMD_GET_DATABASE_ENTRY_DEFAULTS;
 816         mbox_cmd[2] = LSDW(dma_addr);
 817         mbox_cmd[3] = MSDW(dma_addr);
 818
 819         if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 1, &mbox_cmd[0], &mbox_sts[0]) !=
 820             QLA_SUCCESS) {
 821                 DEBUG2(printk("scsi%ld: %s: failed status %04X\n",
 822                      ha->host_no, __func__, mbox_sts[0]));
 823                 return QLA_ERROR;
 824         }
 825         return QLA_SUCCESS;
 826 }
 827
 828 static int qla4xxx_req_ddb_entry(struct scsi_qla_host *ha, uint32_t *ddb_index)
 829 {
 830         uint32_t mbox_cmd[MBOX_REG_COUNT];
 831         uint32_t mbox_sts[MBOX_REG_COUNT];
 832
 833         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
 834         memset(&mbox_sts, 0, sizeof(mbox_sts));
 835
 836         mbox_cmd[0] = MBOX_CMD_REQUEST_DATABASE_ENTRY;
 837         mbox_cmd[1] = MAX_PRST_DEV_DB_ENTRIES;
 838
 839         if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 3, &mbox_cmd[0], &mbox_sts[0]) !=
 840             QLA_SUCCESS) {
 841                 if (mbox_sts[0] == MBOX_STS_COMMAND_ERROR) {
 842                         *ddb_index = mbox_sts[2];
 843                 } else {
 844                         DEBUG2(printk("scsi%ld: %s: failed status %04X\n",
 845                              ha->host_no, __func__, mbox_sts[0]));
 846                         return QLA_ERROR;
 847                 }
 848         } else {
 849                 *ddb_index = MAX_PRST_DEV_DB_ENTRIES;
 850         }
 851
 852         return QLA_SUCCESS;
 853 }
 854
 855
 856 int qla4xxx_send_tgts(struct scsi_qla_host *ha, char *ip, uint16_t port)
 857 {
 858         struct dev_db_entry *fw_ddb_entry;
 859         dma_addr_t fw_ddb_entry_dma;
 860         uint32_t ddb_index;
 861         int ret_val = QLA_SUCCESS;
 862
 863
 864         fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev,
 865                                           sizeof(*fw_ddb_entry),
 866                                           &fw_ddb_entry_dma, GFP_KERNEL);
 867         if (!fw_ddb_entry) {
 868                 DEBUG2(printk("scsi%ld: %s: Unable to allocate dma buffer.\n",
 869                               ha->host_no, __func__));
 870                 ret_val = QLA_ERROR;
 871                 goto qla4xxx_send_tgts_exit;
 872         }
 873
 874         ret_val = qla4xxx_get_default_ddb(ha, fw_ddb_entry_dma);
 875         if (ret_val != QLA_SUCCESS)
 876                 goto qla4xxx_send_tgts_exit;
 877
 878         ret_val = qla4xxx_req_ddb_entry(ha, &ddb_index);
 879         if (ret_val != QLA_SUCCESS)
 880                 goto qla4xxx_send_tgts_exit;
 881
 882         memset(fw_ddb_entry->iscsi_alias, 0,
 883                sizeof(fw_ddb_entry->iscsi_alias));
 884
 885         memset(fw_ddb_entry->iscsi_name, 0,
 886                sizeof(fw_ddb_entry->iscsi_name));
 887
 888         memset(fw_ddb_entry->ip_addr, 0, sizeof(fw_ddb_entry->ip_addr));
 889         memset(fw_ddb_entry->tgt_addr, 0,
 890                sizeof(fw_ddb_entry->tgt_addr));
 891
 892         fw_ddb_entry->options = (DDB_OPT_DISC_SESSION | DDB_OPT_TARGET);
 893         fw_ddb_entry->port = cpu_to_le16(ntohs(port));
 894
 895         fw_ddb_entry->ip_addr[0] = *ip;
 896         fw_ddb_entry->ip_addr[1] = *(ip + 1);
 897         fw_ddb_entry->ip_addr[2] = *(ip + 2);
 898         fw_ddb_entry->ip_addr[3] = *(ip + 3);
 899
 900         ret_val = qla4xxx_set_ddb_entry(ha, ddb_index, fw_ddb_entry_dma);
 901
 902 qla4xxx_send_tgts_exit:
 903         dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
 904                           fw_ddb_entry, fw_ddb_entry_dma);
 905         return ret_val;
 906 }
 907