1 /* 2 * QLogic iSCSI HBA Driver 3 * Copyright (c) 2003-2010 QLogic Corporation 4 * 5 * See LICENSE.qla4xxx for copyright and licensing details. 6 */ 7 8 #include <scsi/iscsi_if.h> 9 #include "ql4_def.h" 10 #include "ql4_glbl.h" 11 #include "ql4_dbg.h" 12 #include "ql4_inline.h" 13 14 static void ql4xxx_set_mac_number(struct scsi_qla_host *ha) 15 { 16 uint32_t value; 17 uint8_t func_number; 18 unsigned long flags; 19 20 /* Get the function number */ 21 spin_lock_irqsave(&ha->hardware_lock, flags); 22 value = readw(&ha->reg->ctrl_status); 23 spin_unlock_irqrestore(&ha->hardware_lock, flags); 24 25 func_number = (uint8_t) ((value >> 4) & 0x30); 26 switch (value & ISP_CONTROL_FN_MASK) { 27 case ISP_CONTROL_FN0_SCSI: 28 ha->mac_index = 1; 29 break; 30 case ISP_CONTROL_FN1_SCSI: 31 ha->mac_index = 3; 32 break; 33 default: 34 DEBUG2(printk("scsi%ld: %s: Invalid function number, " 35 "ispControlStatus = 0x%x\n", ha->host_no, 36 __func__, value)); 37 break; 38 } 39 DEBUG2(printk("scsi%ld: %s: mac_index %d.\n", ha->host_no, __func__, 40 ha->mac_index)); 41 } 42 43 /** 44 * qla4xxx_free_ddb - deallocate ddb 45 * @ha: pointer to host adapter structure. 46 * @ddb_entry: pointer to device database entry 47 * 48 * This routine marks a DDB entry INVALID 49 **/ 50 void qla4xxx_free_ddb(struct scsi_qla_host *ha, 51 struct ddb_entry *ddb_entry) 52 { 53 /* Remove device pointer from index mapping arrays */ 54 ha->fw_ddb_index_map[ddb_entry->fw_ddb_index] = 55 (struct ddb_entry *) INVALID_ENTRY; 56 ha->tot_ddbs--; 57 } 58 59 /** 60 * qla4xxx_init_response_q_entries() - Initializes response queue entries. 61 * @ha: HA context 62 * 63 * Beginning of request ring has initialization control block already built 64 * by nvram config routine. 65 **/ 66 static void qla4xxx_init_response_q_entries(struct scsi_qla_host *ha) 67 { 68 uint16_t cnt; 69 struct response *pkt; 70 71 pkt = (struct response *)ha->response_ptr; 72 for (cnt = 0; cnt < RESPONSE_QUEUE_DEPTH; cnt++) { 73 pkt->signature = RESPONSE_PROCESSED; 74 pkt++; 75 } 76 } 77 78 /** 79 * qla4xxx_init_rings - initialize hw queues 80 * @ha: pointer to host adapter structure. 81 * 82 * This routine initializes the internal queues for the specified adapter. 83 * The QLA4010 requires us to restart the queues at index 0. 84 * The QLA4000 doesn't care, so just default to QLA4010's requirement. 85 **/ 86 int qla4xxx_init_rings(struct scsi_qla_host *ha) 87 { 88 unsigned long flags = 0; 89 90 /* Initialize request queue. */ 91 spin_lock_irqsave(&ha->hardware_lock, flags); 92 ha->request_out = 0; 93 ha->request_in = 0; 94 ha->request_ptr = &ha->request_ring[ha->request_in]; 95 ha->req_q_count = REQUEST_QUEUE_DEPTH; 96 97 /* Initialize response queue. */ 98 ha->response_in = 0; 99 ha->response_out = 0; 100 ha->response_ptr = &ha->response_ring[ha->response_out]; 101 102 if (is_qla8022(ha)) { 103 writel(0, 104 (unsigned long __iomem *)&ha->qla4_8xxx_reg->req_q_out); 105 writel(0, 106 (unsigned long __iomem *)&ha->qla4_8xxx_reg->rsp_q_in); 107 writel(0, 108 (unsigned long __iomem *)&ha->qla4_8xxx_reg->rsp_q_out); 109 } else { 110 /* 111 * Initialize DMA Shadow registers. The firmware is really 112 * supposed to take care of this, but on some uniprocessor 113 * systems, the shadow registers aren't cleared-- causing 114 * the interrupt_handler to think there are responses to be 115 * processed when there aren't. 116 */ 117 ha->shadow_regs->req_q_out = __constant_cpu_to_le32(0); 118 ha->shadow_regs->rsp_q_in = __constant_cpu_to_le32(0); 119 wmb(); 120 121 writel(0, &ha->reg->req_q_in); 122 writel(0, &ha->reg->rsp_q_out); 123 readl(&ha->reg->rsp_q_out); 124 } 125 126 qla4xxx_init_response_q_entries(ha); 127 128 spin_unlock_irqrestore(&ha->hardware_lock, flags); 129 130 return QLA_SUCCESS; 131 } 132 133 /** 134 * qla4xxx_get_sys_info - validate adapter MAC address(es) 135 * @ha: pointer to host adapter structure. 136 * 137 **/ 138 int qla4xxx_get_sys_info(struct scsi_qla_host *ha) 139 { 140 struct flash_sys_info *sys_info; 141 dma_addr_t sys_info_dma; 142 int status = QLA_ERROR; 143 144 sys_info = dma_alloc_coherent(&ha->pdev->dev, sizeof(*sys_info), 145 &sys_info_dma, GFP_KERNEL); 146 if (sys_info == NULL) { 147 DEBUG2(printk("scsi%ld: %s: Unable to allocate dma buffer.\n", 148 ha->host_no, __func__)); 149 150 goto exit_get_sys_info_no_free; 151 } 152 memset(sys_info, 0, sizeof(*sys_info)); 153 154 /* Get flash sys info */ 155 if (qla4xxx_get_flash(ha, sys_info_dma, FLASH_OFFSET_SYS_INFO, 156 sizeof(*sys_info)) != QLA_SUCCESS) { 157 DEBUG2(printk("scsi%ld: %s: get_flash FLASH_OFFSET_SYS_INFO " 158 "failed\n", ha->host_no, __func__)); 159 160 goto exit_get_sys_info; 161 } 162 163 /* Save M.A.C. address & serial_number */ 164 memcpy(ha->my_mac, &sys_info->physAddr[0].address[0], 165 min(sizeof(ha->my_mac), 166 sizeof(sys_info->physAddr[0].address))); 167 memcpy(ha->serial_number, &sys_info->acSerialNumber, 168 min(sizeof(ha->serial_number), 169 sizeof(sys_info->acSerialNumber))); 170 171 status = QLA_SUCCESS; 172 173 exit_get_sys_info: 174 dma_free_coherent(&ha->pdev->dev, sizeof(*sys_info), sys_info, 175 sys_info_dma); 176 177 exit_get_sys_info_no_free: 178 return status; 179 } 180 181 /** 182 * qla4xxx_init_local_data - initialize adapter specific local data 183 * @ha: pointer to host adapter structure. 184 * 185 **/ 186 static int qla4xxx_init_local_data(struct scsi_qla_host *ha) 187 { 188 /* Initialize aen queue */ 189 ha->aen_q_count = MAX_AEN_ENTRIES; 190 191 return qla4xxx_get_firmware_status(ha); 192 } 193 194 static uint8_t 195 qla4xxx_wait_for_ip_config(struct scsi_qla_host *ha) 196 { 197 uint8_t ipv4_wait = 0; 198 uint8_t ipv6_wait = 0; 199 int8_t ip_address[IPv6_ADDR_LEN] = {0} ; 200 201 /* If both IPv4 & IPv6 are enabled, possibly only one 202 * IP address may be acquired, so check to see if we 203 * need to wait for another */ 204 if (is_ipv4_enabled(ha) && is_ipv6_enabled(ha)) { 205 if (((ha->addl_fw_state & FW_ADDSTATE_DHCPv4_ENABLED) != 0) && 206 ((ha->addl_fw_state & 207 FW_ADDSTATE_DHCPv4_LEASE_ACQUIRED) == 0)) { 208 ipv4_wait = 1; 209 } 210 if (((ha->ip_config.ipv6_addl_options & 211 IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE) != 0) && 212 ((ha->ip_config.ipv6_link_local_state == 213 IP_ADDRSTATE_ACQUIRING) || 214 (ha->ip_config.ipv6_addr0_state == 215 IP_ADDRSTATE_ACQUIRING) || 216 (ha->ip_config.ipv6_addr1_state == 217 IP_ADDRSTATE_ACQUIRING))) { 218 219 ipv6_wait = 1; 220 221 if ((ha->ip_config.ipv6_link_local_state == 222 IP_ADDRSTATE_PREFERRED) || 223 (ha->ip_config.ipv6_addr0_state == 224 IP_ADDRSTATE_PREFERRED) || 225 (ha->ip_config.ipv6_addr1_state == 226 IP_ADDRSTATE_PREFERRED)) { 227 DEBUG2(printk(KERN_INFO "scsi%ld: %s: " 228 "Preferred IP configured." 229 " Don't wait!\n", ha->host_no, 230 __func__)); 231 ipv6_wait = 0; 232 } 233 if (memcmp(&ha->ip_config.ipv6_default_router_addr, 234 ip_address, IPv6_ADDR_LEN) == 0) { 235 DEBUG2(printk(KERN_INFO "scsi%ld: %s: " 236 "No Router configured. " 237 "Don't wait!\n", ha->host_no, 238 __func__)); 239 ipv6_wait = 0; 240 } 241 if ((ha->ip_config.ipv6_default_router_state == 242 IPV6_RTRSTATE_MANUAL) && 243 (ha->ip_config.ipv6_link_local_state == 244 IP_ADDRSTATE_TENTATIVE) && 245 (memcmp(&ha->ip_config.ipv6_link_local_addr, 246 &ha->ip_config.ipv6_default_router_addr, 4) == 247 0)) { 248 DEBUG2(printk("scsi%ld: %s: LinkLocal Router & " 249 "IP configured. Don't wait!\n", 250 ha->host_no, __func__)); 251 ipv6_wait = 0; 252 } 253 } 254 if (ipv4_wait || ipv6_wait) { 255 DEBUG2(printk("scsi%ld: %s: Wait for additional " 256 "IP(s) \"", ha->host_no, __func__)); 257 if (ipv4_wait) 258 DEBUG2(printk("IPv4 ")); 259 if (ha->ip_config.ipv6_link_local_state == 260 IP_ADDRSTATE_ACQUIRING) 261 DEBUG2(printk("IPv6LinkLocal ")); 262 if (ha->ip_config.ipv6_addr0_state == 263 IP_ADDRSTATE_ACQUIRING) 264 DEBUG2(printk("IPv6Addr0 ")); 265 if (ha->ip_config.ipv6_addr1_state == 266 IP_ADDRSTATE_ACQUIRING) 267 DEBUG2(printk("IPv6Addr1 ")); 268 DEBUG2(printk("\"\n")); 269 } 270 } 271 272 return ipv4_wait|ipv6_wait; 273 } 274 275 static int qla4xxx_fw_ready(struct scsi_qla_host *ha) 276 { 277 uint32_t timeout_count; 278 int ready = 0; 279 280 DEBUG2(ql4_printk(KERN_INFO, ha, "Waiting for Firmware Ready..\n")); 281 for (timeout_count = ADAPTER_INIT_TOV; timeout_count > 0; 282 timeout_count--) { 283 if (test_and_clear_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags)) 284 qla4xxx_get_dhcp_ip_address(ha); 285 286 /* Get firmware state. */ 287 if (qla4xxx_get_firmware_state(ha) != QLA_SUCCESS) { 288 DEBUG2(printk("scsi%ld: %s: unable to get firmware " 289 "state\n", ha->host_no, __func__)); 290 break; 291 } 292 293 if (ha->firmware_state & FW_STATE_ERROR) { 294 DEBUG2(printk("scsi%ld: %s: an unrecoverable error has" 295 " occurred\n", ha->host_no, __func__)); 296 break; 297 298 } 299 if (ha->firmware_state & FW_STATE_CONFIG_WAIT) { 300 /* 301 * The firmware has not yet been issued an Initialize 302 * Firmware command, so issue it now. 303 */ 304 if (qla4xxx_initialize_fw_cb(ha) == QLA_ERROR) 305 break; 306 307 /* Go back and test for ready state - no wait. */ 308 continue; 309 } 310 311 if (ha->firmware_state & FW_STATE_WAIT_AUTOCONNECT) { 312 DEBUG2(printk(KERN_INFO "scsi%ld: %s: fwstate:" 313 "AUTOCONNECT in progress\n", 314 ha->host_no, __func__)); 315 } 316 317 if (ha->firmware_state & FW_STATE_CONFIGURING_IP) { 318 DEBUG2(printk(KERN_INFO "scsi%ld: %s: fwstate:" 319 " CONFIGURING IP\n", 320 ha->host_no, __func__)); 321 /* 322 * Check for link state after 15 secs and if link is 323 * still DOWN then, cable is unplugged. Ignore "DHCP 324 * in Progress/CONFIGURING IP" bit to check if firmware 325 * is in ready state or not after 15 secs. 326 * This is applicable for both 2.x & 3.x firmware 327 */ 328 if (timeout_count <= (ADAPTER_INIT_TOV - 15)) { 329 if (ha->addl_fw_state & FW_ADDSTATE_LINK_UP) { 330 DEBUG2(printk(KERN_INFO "scsi%ld: %s:" 331 " LINK UP (Cable plugged)\n", 332 ha->host_no, __func__)); 333 } else if (ha->firmware_state & 334 (FW_STATE_CONFIGURING_IP | 335 FW_STATE_READY)) { 336 DEBUG2(printk(KERN_INFO "scsi%ld: %s: " 337 "LINK DOWN (Cable unplugged)\n", 338 ha->host_no, __func__)); 339 ha->firmware_state = FW_STATE_READY; 340 } 341 } 342 } 343 344 if (ha->firmware_state == FW_STATE_READY) { 345 /* If DHCP IP Addr is available, retrieve it now. */ 346 if (test_and_clear_bit(DPC_GET_DHCP_IP_ADDR, 347 &ha->dpc_flags)) 348 qla4xxx_get_dhcp_ip_address(ha); 349 350 if (!qla4xxx_wait_for_ip_config(ha) || 351 timeout_count == 1) { 352 DEBUG2(ql4_printk(KERN_INFO, ha, 353 "Firmware Ready..\n")); 354 /* The firmware is ready to process SCSI 355 commands. */ 356 DEBUG2(ql4_printk(KERN_INFO, ha, 357 "scsi%ld: %s: MEDIA TYPE" 358 " - %s\n", ha->host_no, 359 __func__, (ha->addl_fw_state & 360 FW_ADDSTATE_OPTICAL_MEDIA) 361 != 0 ? "OPTICAL" : "COPPER")); 362 DEBUG2(ql4_printk(KERN_INFO, ha, 363 "scsi%ld: %s: DHCPv4 STATE" 364 " Enabled %s\n", ha->host_no, 365 __func__, (ha->addl_fw_state & 366 FW_ADDSTATE_DHCPv4_ENABLED) != 0 ? 367 "YES" : "NO")); 368 DEBUG2(ql4_printk(KERN_INFO, ha, 369 "scsi%ld: %s: LINK %s\n", 370 ha->host_no, __func__, 371 (ha->addl_fw_state & 372 FW_ADDSTATE_LINK_UP) != 0 ? 373 "UP" : "DOWN")); 374 DEBUG2(ql4_printk(KERN_INFO, ha, 375 "scsi%ld: %s: iSNS Service " 376 "Started %s\n", 377 ha->host_no, __func__, 378 (ha->addl_fw_state & 379 FW_ADDSTATE_ISNS_SVC_ENABLED) != 0 ? 380 "YES" : "NO")); 381 382 ready = 1; 383 break; 384 } 385 } 386 DEBUG2(printk("scsi%ld: %s: waiting on fw, state=%x:%x - " 387 "seconds expired= %d\n", ha->host_no, __func__, 388 ha->firmware_state, ha->addl_fw_state, 389 timeout_count)); 390 if (is_qla4032(ha) && 391 !(ha->addl_fw_state & FW_ADDSTATE_LINK_UP) && 392 (timeout_count < ADAPTER_INIT_TOV - 5)) { 393 break; 394 } 395 396 msleep(1000); 397 } /* end of for */ 398 399 if (timeout_count <= 0) 400 DEBUG2(printk("scsi%ld: %s: FW Initialization timed out!\n", 401 ha->host_no, __func__)); 402 403 if (ha->firmware_state & FW_STATE_CONFIGURING_IP) { 404 DEBUG2(printk("scsi%ld: %s: FW initialized, but is reporting " 405 "it's waiting to configure an IP address\n", 406 ha->host_no, __func__)); 407 ready = 1; 408 } else if (ha->firmware_state & FW_STATE_WAIT_AUTOCONNECT) { 409 DEBUG2(printk("scsi%ld: %s: FW initialized, but " 410 "auto-discovery still in process\n", 411 ha->host_no, __func__)); 412 ready = 1; 413 } 414 415 return ready; 416 } 417 418 /** 419 * qla4xxx_init_firmware - initializes the firmware. 420 * @ha: pointer to host adapter structure. 421 * 422 **/ 423 static int qla4xxx_init_firmware(struct scsi_qla_host *ha) 424 { 425 int status = QLA_ERROR; 426 427 if (is_aer_supported(ha) && 428 test_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags)) 429 return status; 430 431 /* For 82xx, stop firmware before initializing because if BIOS 432 * has previously initialized firmware, then driver's initialize 433 * firmware will fail. */ 434 if (is_qla8022(ha)) 435 qla4_8xxx_stop_firmware(ha); 436 437 ql4_printk(KERN_INFO, ha, "Initializing firmware..\n"); 438 if (qla4xxx_initialize_fw_cb(ha) == QLA_ERROR) { 439 DEBUG2(printk("scsi%ld: %s: Failed to initialize firmware " 440 "control block\n", ha->host_no, __func__)); 441 return status; 442 } 443 if (!qla4xxx_fw_ready(ha)) 444 return status; 445 446 return qla4xxx_get_firmware_status(ha); 447 } 448 449 static void qla4xxx_set_model_info(struct scsi_qla_host *ha) 450 { 451 uint16_t board_id_string[8]; 452 int i; 453 int size = sizeof(ha->nvram->isp4022.boardIdStr); 454 int offset = offsetof(struct eeprom_data, isp4022.boardIdStr) / 2; 455 456 for (i = 0; i < (size / 2) ; i++) { 457 board_id_string[i] = rd_nvram_word(ha, offset); 458 offset += 1; 459 } 460 461 memcpy(ha->model_name, board_id_string, size); 462 } 463 464 static int qla4xxx_config_nvram(struct scsi_qla_host *ha) 465 { 466 unsigned long flags; 467 union external_hw_config_reg extHwConfig; 468 469 DEBUG2(printk("scsi%ld: %s: Get EEProm parameters \n", ha->host_no, 470 __func__)); 471 if (ql4xxx_lock_flash(ha) != QLA_SUCCESS) 472 return QLA_ERROR; 473 if (ql4xxx_lock_nvram(ha) != QLA_SUCCESS) { 474 ql4xxx_unlock_flash(ha); 475 return QLA_ERROR; 476 } 477 478 /* Get EEPRom Parameters from NVRAM and validate */ 479 ql4_printk(KERN_INFO, ha, "Configuring NVRAM ...\n"); 480 if (qla4xxx_is_nvram_configuration_valid(ha) == QLA_SUCCESS) { 481 spin_lock_irqsave(&ha->hardware_lock, flags); 482 extHwConfig.Asuint32_t = 483 rd_nvram_word(ha, eeprom_ext_hw_conf_offset(ha)); 484 spin_unlock_irqrestore(&ha->hardware_lock, flags); 485 } else { 486 ql4_printk(KERN_WARNING, ha, 487 "scsi%ld: %s: EEProm checksum invalid. " 488 "Please update your EEPROM\n", ha->host_no, 489 __func__); 490 491 /* Attempt to set defaults */ 492 if (is_qla4010(ha)) 493 extHwConfig.Asuint32_t = 0x1912; 494 else if (is_qla4022(ha) | is_qla4032(ha)) 495 extHwConfig.Asuint32_t = 0x0023; 496 else 497 return QLA_ERROR; 498 } 499 500 if (is_qla4022(ha) || is_qla4032(ha)) 501 qla4xxx_set_model_info(ha); 502 else 503 strcpy(ha->model_name, "QLA4010"); 504 505 DEBUG(printk("scsi%ld: %s: Setting extHwConfig to 0xFFFF%04x\n", 506 ha->host_no, __func__, extHwConfig.Asuint32_t)); 507 508 spin_lock_irqsave(&ha->hardware_lock, flags); 509 writel((0xFFFF << 16) | extHwConfig.Asuint32_t, isp_ext_hw_conf(ha)); 510 readl(isp_ext_hw_conf(ha)); 511 spin_unlock_irqrestore(&ha->hardware_lock, flags); 512 513 ql4xxx_unlock_nvram(ha); 514 ql4xxx_unlock_flash(ha); 515 516 return QLA_SUCCESS; 517 } 518 519 /** 520 * qla4_8xxx_pci_config() - Setup ISP82xx PCI configuration registers. 521 * @ha: HA context 522 */ 523 void qla4_8xxx_pci_config(struct scsi_qla_host *ha) 524 { 525 pci_set_master(ha->pdev); 526 } 527 528 void qla4xxx_pci_config(struct scsi_qla_host *ha) 529 { 530 uint16_t w; 531 int status; 532 533 ql4_printk(KERN_INFO, ha, "Configuring PCI space...\n"); 534 535 pci_set_master(ha->pdev); 536 status = pci_set_mwi(ha->pdev); 537 /* 538 * We want to respect framework's setting of PCI configuration space 539 * command register and also want to make sure that all bits of 540 * interest to us are properly set in command register. 541 */ 542 pci_read_config_word(ha->pdev, PCI_COMMAND, &w); 543 w |= PCI_COMMAND_PARITY | PCI_COMMAND_SERR; 544 w &= ~PCI_COMMAND_INTX_DISABLE; 545 pci_write_config_word(ha->pdev, PCI_COMMAND, w); 546 } 547 548 static int qla4xxx_start_firmware_from_flash(struct scsi_qla_host *ha) 549 { 550 int status = QLA_ERROR; 551 unsigned long max_wait_time; 552 unsigned long flags; 553 uint32_t mbox_status; 554 555 ql4_printk(KERN_INFO, ha, "Starting firmware ...\n"); 556 557 /* 558 * Start firmware from flash ROM 559 * 560 * WORKAROUND: Stuff a non-constant value that the firmware can 561 * use as a seed for a random number generator in MB7 prior to 562 * setting BOOT_ENABLE. Fixes problem where the TCP 563 * connections use the same TCP ports after each reboot, 564 * causing some connections to not get re-established. 565 */ 566 DEBUG(printk("scsi%d: %s: Start firmware from flash ROM\n", 567 ha->host_no, __func__)); 568 569 spin_lock_irqsave(&ha->hardware_lock, flags); 570 writel(jiffies, &ha->reg->mailbox[7]); 571 if (is_qla4022(ha) | is_qla4032(ha)) 572 writel(set_rmask(NVR_WRITE_ENABLE), 573 &ha->reg->u1.isp4022.nvram); 574 575 writel(2, &ha->reg->mailbox[6]); 576 readl(&ha->reg->mailbox[6]); 577 578 writel(set_rmask(CSR_BOOT_ENABLE), &ha->reg->ctrl_status); 579 readl(&ha->reg->ctrl_status); 580 spin_unlock_irqrestore(&ha->hardware_lock, flags); 581 582 /* Wait for firmware to come UP. */ 583 DEBUG2(printk(KERN_INFO "scsi%ld: %s: Wait up to %d seconds for " 584 "boot firmware to complete...\n", 585 ha->host_no, __func__, FIRMWARE_UP_TOV)); 586 max_wait_time = jiffies + (FIRMWARE_UP_TOV * HZ); 587 do { 588 uint32_t ctrl_status; 589 590 spin_lock_irqsave(&ha->hardware_lock, flags); 591 ctrl_status = readw(&ha->reg->ctrl_status); 592 mbox_status = readw(&ha->reg->mailbox[0]); 593 spin_unlock_irqrestore(&ha->hardware_lock, flags); 594 595 if (ctrl_status & set_rmask(CSR_SCSI_PROCESSOR_INTR)) 596 break; 597 if (mbox_status == MBOX_STS_COMMAND_COMPLETE) 598 break; 599 600 DEBUG2(printk(KERN_INFO "scsi%ld: %s: Waiting for boot " 601 "firmware to complete... ctrl_sts=0x%x, remaining=%ld\n", 602 ha->host_no, __func__, ctrl_status, max_wait_time)); 603 604 msleep_interruptible(250); 605 } while (!time_after_eq(jiffies, max_wait_time)); 606 607 if (mbox_status == MBOX_STS_COMMAND_COMPLETE) { 608 DEBUG(printk(KERN_INFO "scsi%ld: %s: Firmware has started\n", 609 ha->host_no, __func__)); 610 611 spin_lock_irqsave(&ha->hardware_lock, flags); 612 writel(set_rmask(CSR_SCSI_PROCESSOR_INTR), 613 &ha->reg->ctrl_status); 614 readl(&ha->reg->ctrl_status); 615 spin_unlock_irqrestore(&ha->hardware_lock, flags); 616 617 status = QLA_SUCCESS; 618 } else { 619 printk(KERN_INFO "scsi%ld: %s: Boot firmware failed " 620 "- mbox status 0x%x\n", ha->host_no, __func__, 621 mbox_status); 622 status = QLA_ERROR; 623 } 624 return status; 625 } 626 627 int ql4xxx_lock_drvr_wait(struct scsi_qla_host *a) 628 { 629 #define QL4_LOCK_DRVR_WAIT 60 630 #define QL4_LOCK_DRVR_SLEEP 1 631 632 int drvr_wait = QL4_LOCK_DRVR_WAIT; 633 while (drvr_wait) { 634 if (ql4xxx_lock_drvr(a) == 0) { 635 ssleep(QL4_LOCK_DRVR_SLEEP); 636 if (drvr_wait) { 637 DEBUG2(printk("scsi%ld: %s: Waiting for " 638 "Global Init Semaphore(%d)...\n", 639 a->host_no, 640 __func__, drvr_wait)); 641 } 642 drvr_wait -= QL4_LOCK_DRVR_SLEEP; 643 } else { 644 DEBUG2(printk("scsi%ld: %s: Global Init Semaphore " 645 "acquired\n", a->host_no, __func__)); 646 return QLA_SUCCESS; 647 } 648 } 649 return QLA_ERROR; 650 } 651 652 /** 653 * qla4xxx_start_firmware - starts qla4xxx firmware 654 * @ha: Pointer to host adapter structure. 655 * 656 * This routine performs the necessary steps to start the firmware for 657 * the QLA4010 adapter. 658 **/ 659 int qla4xxx_start_firmware(struct scsi_qla_host *ha) 660 { 661 unsigned long flags = 0; 662 uint32_t mbox_status; 663 int status = QLA_ERROR; 664 int soft_reset = 1; 665 int config_chip = 0; 666 667 if (is_qla4022(ha) | is_qla4032(ha)) 668 ql4xxx_set_mac_number(ha); 669 670 if (ql4xxx_lock_drvr_wait(ha) != QLA_SUCCESS) 671 return QLA_ERROR; 672 673 spin_lock_irqsave(&ha->hardware_lock, flags); 674 675 DEBUG2(printk("scsi%ld: %s: port_ctrl = 0x%08X\n", ha->host_no, 676 __func__, readw(isp_port_ctrl(ha)))); 677 DEBUG(printk("scsi%ld: %s: port_status = 0x%08X\n", ha->host_no, 678 __func__, readw(isp_port_status(ha)))); 679 680 /* Is Hardware already initialized? */ 681 if ((readw(isp_port_ctrl(ha)) & 0x8000) != 0) { 682 DEBUG(printk("scsi%ld: %s: Hardware has already been " 683 "initialized\n", ha->host_no, __func__)); 684 685 /* Receive firmware boot acknowledgement */ 686 mbox_status = readw(&ha->reg->mailbox[0]); 687 688 DEBUG2(printk("scsi%ld: %s: H/W Config complete - mbox[0]= " 689 "0x%x\n", ha->host_no, __func__, mbox_status)); 690 691 /* Is firmware already booted? */ 692 if (mbox_status == 0) { 693 /* F/W not running, must be config by net driver */ 694 config_chip = 1; 695 soft_reset = 0; 696 } else { 697 writel(set_rmask(CSR_SCSI_PROCESSOR_INTR), 698 &ha->reg->ctrl_status); 699 readl(&ha->reg->ctrl_status); 700 writel(set_rmask(CSR_SCSI_COMPLETION_INTR), 701 &ha->reg->ctrl_status); 702 readl(&ha->reg->ctrl_status); 703 spin_unlock_irqrestore(&ha->hardware_lock, flags); 704 if (qla4xxx_get_firmware_state(ha) == QLA_SUCCESS) { 705 DEBUG2(printk("scsi%ld: %s: Get firmware " 706 "state -- state = 0x%x\n", 707 ha->host_no, 708 __func__, ha->firmware_state)); 709 /* F/W is running */ 710 if (ha->firmware_state & 711 FW_STATE_CONFIG_WAIT) { 712 DEBUG2(printk("scsi%ld: %s: Firmware " 713 "in known state -- " 714 "config and " 715 "boot, state = 0x%x\n", 716 ha->host_no, __func__, 717 ha->firmware_state)); 718 config_chip = 1; 719 soft_reset = 0; 720 } 721 } else { 722 DEBUG2(printk("scsi%ld: %s: Firmware in " 723 "unknown state -- resetting," 724 " state = " 725 "0x%x\n", ha->host_no, __func__, 726 ha->firmware_state)); 727 } 728 spin_lock_irqsave(&ha->hardware_lock, flags); 729 } 730 } else { 731 DEBUG(printk("scsi%ld: %s: H/W initialization hasn't been " 732 "started - resetting\n", ha->host_no, __func__)); 733 } 734 spin_unlock_irqrestore(&ha->hardware_lock, flags); 735 736 DEBUG(printk("scsi%ld: %s: Flags soft_rest=%d, config= %d\n ", 737 ha->host_no, __func__, soft_reset, config_chip)); 738 if (soft_reset) { 739 DEBUG(printk("scsi%ld: %s: Issue Soft Reset\n", ha->host_no, 740 __func__)); 741 status = qla4xxx_soft_reset(ha); /* NOTE: acquires drvr 742 * lock again, but ok */ 743 if (status == QLA_ERROR) { 744 DEBUG(printk("scsi%d: %s: Soft Reset failed!\n", 745 ha->host_no, __func__)); 746 ql4xxx_unlock_drvr(ha); 747 return QLA_ERROR; 748 } 749 config_chip = 1; 750 751 /* Reset clears the semaphore, so acquire again */ 752 if (ql4xxx_lock_drvr_wait(ha) != QLA_SUCCESS) 753 return QLA_ERROR; 754 } 755 756 if (config_chip) { 757 if ((status = qla4xxx_config_nvram(ha)) == QLA_SUCCESS) 758 status = qla4xxx_start_firmware_from_flash(ha); 759 } 760 761 ql4xxx_unlock_drvr(ha); 762 if (status == QLA_SUCCESS) { 763 if (test_and_clear_bit(AF_GET_CRASH_RECORD, &ha->flags)) 764 qla4xxx_get_crash_record(ha); 765 } else { 766 DEBUG(printk("scsi%ld: %s: Firmware has NOT started\n", 767 ha->host_no, __func__)); 768 } 769 return status; 770 } 771 /** 772 * qla4xxx_free_ddb_index - Free DDBs reserved by firmware 773 * @ha: pointer to adapter structure 774 * 775 * Since firmware is not running in autoconnect mode the DDB indices should 776 * be freed so that when login happens from user space there are free DDB 777 * indices available. 778 **/ 779 void qla4xxx_free_ddb_index(struct scsi_qla_host *ha) 780 { 781 int max_ddbs; 782 int ret; 783 uint32_t idx = 0, next_idx = 0; 784 uint32_t state = 0, conn_err = 0; 785 786 max_ddbs = is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX : 787 MAX_DEV_DB_ENTRIES; 788 789 for (idx = 0; idx < max_ddbs; idx = next_idx) { 790 ret = qla4xxx_get_fwddb_entry(ha, idx, NULL, 0, NULL, 791 &next_idx, &state, &conn_err, 792 NULL, NULL); 793 if (ret == QLA_ERROR) { 794 next_idx++; 795 continue; 796 } 797 if (state == DDB_DS_NO_CONNECTION_ACTIVE || 798 state == DDB_DS_SESSION_FAILED) { 799 DEBUG2(ql4_printk(KERN_INFO, ha, 800 "Freeing DDB index = 0x%x\n", idx)); 801 ret = qla4xxx_clear_ddb_entry(ha, idx); 802 if (ret == QLA_ERROR) 803 ql4_printk(KERN_ERR, ha, 804 "Unable to clear DDB index = " 805 "0x%x\n", idx); 806 } 807 if (next_idx == 0) 808 break; 809 } 810 } 811 812 /** 813 * qla4xxx_initialize_adapter - initiailizes hba 814 * @ha: Pointer to host adapter structure. 815 * 816 * This routine parforms all of the steps necessary to initialize the adapter. 817 * 818 **/ 819 int qla4xxx_initialize_adapter(struct scsi_qla_host *ha, int is_reset) 820 { 821 int status = QLA_ERROR; 822 823 ha->eeprom_cmd_data = 0; 824 825 ql4_printk(KERN_INFO, ha, "Configuring PCI space...\n"); 826 ha->isp_ops->pci_config(ha); 827 828 ha->isp_ops->disable_intrs(ha); 829 830 /* Initialize the Host adapter request/response queues and firmware */ 831 if (ha->isp_ops->start_firmware(ha) == QLA_ERROR) 832 goto exit_init_hba; 833 834 if (qla4xxx_about_firmware(ha) == QLA_ERROR) 835 goto exit_init_hba; 836 837 if (ha->isp_ops->get_sys_info(ha) == QLA_ERROR) 838 goto exit_init_hba; 839 840 if (qla4xxx_init_local_data(ha) == QLA_ERROR) 841 goto exit_init_hba; 842 843 status = qla4xxx_init_firmware(ha); 844 if (status == QLA_ERROR) 845 goto exit_init_hba; 846 847 if (is_reset == RESET_ADAPTER) 848 qla4xxx_build_ddb_list(ha, is_reset); 849 850 set_bit(AF_ONLINE, &ha->flags); 851 exit_init_hba: 852 if (is_qla8022(ha) && (status == QLA_ERROR)) { 853 /* Since interrupts are registered in start_firmware for 854 * 82xx, release them here if initialize_adapter fails */ 855 qla4xxx_free_irqs(ha); 856 } 857 858 DEBUG2(printk("scsi%ld: initialize adapter: %s\n", ha->host_no, 859 status == QLA_ERROR ? "FAILED" : "SUCCEEDED")); 860 return status; 861 } 862 863 int qla4xxx_ddb_change(struct scsi_qla_host *ha, uint32_t fw_ddb_index, 864 struct ddb_entry *ddb_entry, uint32_t state) 865 { 866 uint32_t old_fw_ddb_device_state; 867 int status = QLA_ERROR; 868 869 old_fw_ddb_device_state = ddb_entry->fw_ddb_device_state; 870 DEBUG2(ql4_printk(KERN_INFO, ha, 871 "%s: DDB - old state = 0x%x, new state = 0x%x for " 872 "index [%d]\n", __func__, 873 ddb_entry->fw_ddb_device_state, state, fw_ddb_index)); 874 875 ddb_entry->fw_ddb_device_state = state; 876 877 switch (old_fw_ddb_device_state) { 878 case DDB_DS_LOGIN_IN_PROCESS: 879 switch (state) { 880 case DDB_DS_SESSION_ACTIVE: 881 case DDB_DS_DISCOVERY: 882 ddb_entry->unblock_sess(ddb_entry->sess); 883 qla4xxx_update_session_conn_param(ha, ddb_entry); 884 status = QLA_SUCCESS; 885 break; 886 case DDB_DS_SESSION_FAILED: 887 case DDB_DS_NO_CONNECTION_ACTIVE: 888 iscsi_conn_login_event(ddb_entry->conn, 889 ISCSI_CONN_STATE_FREE); 890 status = QLA_SUCCESS; 891 break; 892 } 893 break; 894 case DDB_DS_SESSION_ACTIVE: 895 switch (state) { 896 case DDB_DS_SESSION_FAILED: 897 /* 898 * iscsi_session failure will cause userspace to 899 * stop the connection which in turn would block the 900 * iscsi_session and start relogin 901 */ 902 iscsi_session_failure(ddb_entry->sess->dd_data, 903 ISCSI_ERR_CONN_FAILED); 904 status = QLA_SUCCESS; 905 break; 906 case DDB_DS_NO_CONNECTION_ACTIVE: 907 clear_bit(fw_ddb_index, ha->ddb_idx_map); 908 status = QLA_SUCCESS; 909 break; 910 } 911 break; 912 case DDB_DS_SESSION_FAILED: 913 switch (state) { 914 case DDB_DS_SESSION_ACTIVE: 915 case DDB_DS_DISCOVERY: 916 ddb_entry->unblock_sess(ddb_entry->sess); 917 qla4xxx_update_session_conn_param(ha, ddb_entry); 918 status = QLA_SUCCESS; 919 break; 920 case DDB_DS_SESSION_FAILED: 921 iscsi_session_failure(ddb_entry->sess->dd_data, 922 ISCSI_ERR_CONN_FAILED); 923 status = QLA_SUCCESS; 924 break; 925 } 926 break; 927 default: 928 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Unknown Event\n", 929 __func__)); 930 break; 931 } 932 return status; 933 } 934 935 void qla4xxx_arm_relogin_timer(struct ddb_entry *ddb_entry) 936 { 937 /* 938 * This triggers a relogin. After the relogin_timer 939 * expires, the relogin gets scheduled. We must wait a 940 * minimum amount of time since receiving an 0x8014 AEN 941 * with failed device_state or a logout response before 942 * we can issue another relogin. 943 * 944 * Firmware pads this timeout: (time2wait +1). 945 * Driver retry to login should be longer than F/W. 946 * Otherwise F/W will fail 947 * set_ddb() mbx cmd with 0x4005 since it still 948 * counting down its time2wait. 949 */ 950 atomic_set(&ddb_entry->relogin_timer, 0); 951 atomic_set(&ddb_entry->retry_relogin_timer, 952 ddb_entry->default_time2wait + 4); 953 954 } 955 956 int qla4xxx_flash_ddb_change(struct scsi_qla_host *ha, uint32_t fw_ddb_index, 957 struct ddb_entry *ddb_entry, uint32_t state) 958 { 959 uint32_t old_fw_ddb_device_state; 960 int status = QLA_ERROR; 961 962 old_fw_ddb_device_state = ddb_entry->fw_ddb_device_state; 963 DEBUG2(ql4_printk(KERN_INFO, ha, 964 "%s: DDB - old state = 0x%x, new state = 0x%x for " 965 "index [%d]\n", __func__, 966 ddb_entry->fw_ddb_device_state, state, fw_ddb_index)); 967 968 ddb_entry->fw_ddb_device_state = state; 969 970 switch (old_fw_ddb_device_state) { 971 case DDB_DS_LOGIN_IN_PROCESS: 972 case DDB_DS_NO_CONNECTION_ACTIVE: 973 switch (state) { 974 case DDB_DS_SESSION_ACTIVE: 975 ddb_entry->unblock_sess(ddb_entry->sess); 976 qla4xxx_update_session_conn_fwddb_param(ha, ddb_entry); 977 status = QLA_SUCCESS; 978 break; 979 case DDB_DS_SESSION_FAILED: 980 iscsi_block_session(ddb_entry->sess); 981 if (!test_bit(DF_RELOGIN, &ddb_entry->flags)) 982 qla4xxx_arm_relogin_timer(ddb_entry); 983 status = QLA_SUCCESS; 984 break; 985 } 986 break; 987 case DDB_DS_SESSION_ACTIVE: 988 switch (state) { 989 case DDB_DS_SESSION_FAILED: 990 iscsi_block_session(ddb_entry->sess); 991 if (!test_bit(DF_RELOGIN, &ddb_entry->flags)) 992 qla4xxx_arm_relogin_timer(ddb_entry); 993 status = QLA_SUCCESS; 994 break; 995 } 996 break; 997 case DDB_DS_SESSION_FAILED: 998 switch (state) { 999 case DDB_DS_SESSION_ACTIVE: 1000 ddb_entry->unblock_sess(ddb_entry->sess); 1001 qla4xxx_update_session_conn_fwddb_param(ha, ddb_entry); 1002 status = QLA_SUCCESS; 1003 break; 1004 case DDB_DS_SESSION_FAILED: 1005 if (!test_bit(DF_RELOGIN, &ddb_entry->flags)) 1006 qla4xxx_arm_relogin_timer(ddb_entry); 1007 status = QLA_SUCCESS; 1008 break; 1009 } 1010 break; 1011 default: 1012 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Unknown Event\n", 1013 __func__)); 1014 break; 1015 } 1016 return status; 1017 } 1018 1019 /** 1020 * qla4xxx_process_ddb_changed - process ddb state change 1021 * @ha - Pointer to host adapter structure. 1022 * @fw_ddb_index - Firmware's device database index 1023 * @state - Device state 1024 * 1025 * This routine processes a Decive Database Changed AEN Event. 1026 **/ 1027 int qla4xxx_process_ddb_changed(struct scsi_qla_host *ha, 1028 uint32_t fw_ddb_index, 1029 uint32_t state, uint32_t conn_err) 1030 { 1031 struct ddb_entry *ddb_entry; 1032 int status = QLA_ERROR; 1033 1034 /* check for out of range index */ 1035 if (fw_ddb_index >= MAX_DDB_ENTRIES) 1036 goto exit_ddb_event; 1037 1038 /* Get the corresponging ddb entry */ 1039 ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, fw_ddb_index); 1040 /* Device does not currently exist in our database. */ 1041 if (ddb_entry == NULL) { 1042 ql4_printk(KERN_ERR, ha, "%s: No ddb_entry at FW index [%d]\n", 1043 __func__, fw_ddb_index); 1044 1045 if (state == DDB_DS_NO_CONNECTION_ACTIVE) 1046 clear_bit(fw_ddb_index, ha->ddb_idx_map); 1047 1048 goto exit_ddb_event; 1049 } 1050 1051 ddb_entry->ddb_change(ha, fw_ddb_index, ddb_entry, state); 1052 1053 exit_ddb_event: 1054 return status; 1055 } 1056 1057 /** 1058 * qla4xxx_login_flash_ddb - Login to target (DDB) 1059 * @cls_session: Pointer to the session to login 1060 * 1061 * This routine logins to the target. 1062 * Issues setddb and conn open mbx 1063 **/ 1064 void qla4xxx_login_flash_ddb(struct iscsi_cls_session *cls_session) 1065 { 1066 struct iscsi_session *sess; 1067 struct ddb_entry *ddb_entry; 1068 struct scsi_qla_host *ha; 1069 struct dev_db_entry *fw_ddb_entry = NULL; 1070 dma_addr_t fw_ddb_dma; 1071 uint32_t mbx_sts = 0; 1072 int ret; 1073 1074 sess = cls_session->dd_data; 1075 ddb_entry = sess->dd_data; 1076 ha = ddb_entry->ha; 1077 1078 if (!test_bit(AF_LINK_UP, &ha->flags)) 1079 return; 1080 1081 if (ddb_entry->ddb_type != FLASH_DDB) { 1082 DEBUG2(ql4_printk(KERN_INFO, ha, 1083 "Skipping login to non FLASH DB")); 1084 goto exit_login; 1085 } 1086 1087 fw_ddb_entry = dma_pool_alloc(ha->fw_ddb_dma_pool, GFP_KERNEL, 1088 &fw_ddb_dma); 1089 if (fw_ddb_entry == NULL) { 1090 DEBUG2(ql4_printk(KERN_ERR, ha, "Out of memory\n")); 1091 goto exit_login; 1092 } 1093 1094 if (ddb_entry->fw_ddb_index == INVALID_ENTRY) { 1095 ret = qla4xxx_get_ddb_index(ha, &ddb_entry->fw_ddb_index); 1096 if (ret == QLA_ERROR) 1097 goto exit_login; 1098 1099 ha->fw_ddb_index_map[ddb_entry->fw_ddb_index] = ddb_entry; 1100 ha->tot_ddbs++; 1101 } 1102 1103 memcpy(fw_ddb_entry, &ddb_entry->fw_ddb_entry, 1104 sizeof(struct dev_db_entry)); 1105 ddb_entry->sess->target_id = ddb_entry->fw_ddb_index; 1106 1107 ret = qla4xxx_set_ddb_entry(ha, ddb_entry->fw_ddb_index, 1108 fw_ddb_dma, &mbx_sts); 1109 if (ret == QLA_ERROR) { 1110 DEBUG2(ql4_printk(KERN_ERR, ha, "Set DDB failed\n")); 1111 goto exit_login; 1112 } 1113 1114 ddb_entry->fw_ddb_device_state = DDB_DS_LOGIN_IN_PROCESS; 1115 ret = qla4xxx_conn_open(ha, ddb_entry->fw_ddb_index); 1116 if (ret == QLA_ERROR) { 1117 ql4_printk(KERN_ERR, ha, "%s: Login failed: %s\n", __func__, 1118 sess->targetname); 1119 goto exit_login; 1120 } 1121 1122 exit_login: 1123 if (fw_ddb_entry) 1124 dma_pool_free(ha->fw_ddb_dma_pool, fw_ddb_entry, fw_ddb_dma); 1125 } 1126 1127