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