2 * QLogic iSCSI HBA Driver
3 * Copyright (c) 2003-2013 QLogic Corporation
5 * See LICENSE.qla4xxx for copyright and licensing details.
8 #include <scsi/iscsi_if.h>
12 #include "ql4_inline.h"
14 static void ql4xxx_set_mac_number(struct scsi_qla_host
*ha
)
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
);
25 func_number
= (uint8_t) ((value
>> 4) & 0x30);
26 switch (value
& ISP_CONTROL_FN_MASK
) {
27 case ISP_CONTROL_FN0_SCSI
:
30 case ISP_CONTROL_FN1_SCSI
:
34 DEBUG2(printk("scsi%ld: %s: Invalid function number, "
35 "ispControlStatus = 0x%x\n", ha
->host_no
,
39 DEBUG2(printk("scsi%ld: %s: mac_index %d.\n", ha
->host_no
, __func__
,
44 * qla4xxx_free_ddb - deallocate ddb
45 * @ha: pointer to host adapter structure.
46 * @ddb_entry: pointer to device database entry
48 * This routine marks a DDB entry INVALID
50 void qla4xxx_free_ddb(struct scsi_qla_host
*ha
,
51 struct ddb_entry
*ddb_entry
)
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
;
60 * qla4xxx_init_response_q_entries() - Initializes response queue entries.
63 * Beginning of request ring has initialization control block already built
64 * by nvram config routine.
66 static void qla4xxx_init_response_q_entries(struct scsi_qla_host
*ha
)
71 pkt
= (struct response
*)ha
->response_ptr
;
72 for (cnt
= 0; cnt
< RESPONSE_QUEUE_DEPTH
; cnt
++) {
73 pkt
->signature
= RESPONSE_PROCESSED
;
79 * qla4xxx_init_rings - initialize hw queues
80 * @ha: pointer to host adapter structure.
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.
86 int qla4xxx_init_rings(struct scsi_qla_host
*ha
)
88 unsigned long flags
= 0;
91 /* Initialize request queue. */
92 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
95 ha
->request_ptr
= &ha
->request_ring
[ha
->request_in
];
96 ha
->req_q_count
= REQUEST_QUEUE_DEPTH
;
98 /* Initialize response queue. */
100 ha
->response_out
= 0;
101 ha
->response_ptr
= &ha
->response_ring
[ha
->response_out
];
103 if (is_qla8022(ha
)) {
105 (unsigned long __iomem
*)&ha
->qla4_82xx_reg
->req_q_out
);
107 (unsigned long __iomem
*)&ha
->qla4_82xx_reg
->rsp_q_in
);
109 (unsigned long __iomem
*)&ha
->qla4_82xx_reg
->rsp_q_out
);
110 } else if (is_qla8032(ha
) || is_qla8042(ha
)) {
112 (unsigned long __iomem
*)&ha
->qla4_83xx_reg
->req_q_in
);
114 (unsigned long __iomem
*)&ha
->qla4_83xx_reg
->rsp_q_in
);
116 (unsigned long __iomem
*)&ha
->qla4_83xx_reg
->rsp_q_out
);
119 * Initialize DMA Shadow registers. The firmware is really
120 * supposed to take care of this, but on some uniprocessor
121 * systems, the shadow registers aren't cleared-- causing
122 * the interrupt_handler to think there are responses to be
123 * processed when there aren't.
125 ha
->shadow_regs
->req_q_out
= __constant_cpu_to_le32(0);
126 ha
->shadow_regs
->rsp_q_in
= __constant_cpu_to_le32(0);
129 writel(0, &ha
->reg
->req_q_in
);
130 writel(0, &ha
->reg
->rsp_q_out
);
131 readl(&ha
->reg
->rsp_q_out
);
134 qla4xxx_init_response_q_entries(ha
);
136 /* Initialize mailbox active array */
137 for (i
= 0; i
< MAX_MRB
; i
++)
138 ha
->active_mrb_array
[i
] = NULL
;
140 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
146 * qla4xxx_get_sys_info - validate adapter MAC address(es)
147 * @ha: pointer to host adapter structure.
150 int qla4xxx_get_sys_info(struct scsi_qla_host
*ha
)
152 struct flash_sys_info
*sys_info
;
153 dma_addr_t sys_info_dma
;
154 int status
= QLA_ERROR
;
156 sys_info
= dma_alloc_coherent(&ha
->pdev
->dev
, sizeof(*sys_info
),
157 &sys_info_dma
, GFP_KERNEL
);
158 if (sys_info
== NULL
) {
159 DEBUG2(printk("scsi%ld: %s: Unable to allocate dma buffer.\n",
160 ha
->host_no
, __func__
));
162 goto exit_get_sys_info_no_free
;
164 memset(sys_info
, 0, sizeof(*sys_info
));
166 /* Get flash sys info */
167 if (qla4xxx_get_flash(ha
, sys_info_dma
, FLASH_OFFSET_SYS_INFO
,
168 sizeof(*sys_info
)) != QLA_SUCCESS
) {
169 DEBUG2(printk("scsi%ld: %s: get_flash FLASH_OFFSET_SYS_INFO "
170 "failed\n", ha
->host_no
, __func__
));
172 goto exit_get_sys_info
;
175 /* Save M.A.C. address & serial_number */
176 memcpy(ha
->my_mac
, &sys_info
->physAddr
[0].address
[0],
177 min(sizeof(ha
->my_mac
),
178 sizeof(sys_info
->physAddr
[0].address
)));
179 memcpy(ha
->serial_number
, &sys_info
->acSerialNumber
,
180 min(sizeof(ha
->serial_number
),
181 sizeof(sys_info
->acSerialNumber
)));
183 status
= QLA_SUCCESS
;
186 dma_free_coherent(&ha
->pdev
->dev
, sizeof(*sys_info
), sys_info
,
189 exit_get_sys_info_no_free
:
194 * qla4xxx_init_local_data - initialize adapter specific local data
195 * @ha: pointer to host adapter structure.
198 static void qla4xxx_init_local_data(struct scsi_qla_host
*ha
)
200 /* Initialize aen queue */
201 ha
->aen_q_count
= MAX_AEN_ENTRIES
;
205 qla4xxx_wait_for_ip_config(struct scsi_qla_host
*ha
)
207 uint8_t ipv4_wait
= 0;
208 uint8_t ipv6_wait
= 0;
209 int8_t ip_address
[IPv6_ADDR_LEN
] = {0} ;
211 /* If both IPv4 & IPv6 are enabled, possibly only one
212 * IP address may be acquired, so check to see if we
213 * need to wait for another */
214 if (is_ipv4_enabled(ha
) && is_ipv6_enabled(ha
)) {
215 if (((ha
->addl_fw_state
& FW_ADDSTATE_DHCPv4_ENABLED
) != 0) &&
216 ((ha
->addl_fw_state
&
217 FW_ADDSTATE_DHCPv4_LEASE_ACQUIRED
) == 0)) {
220 if (((ha
->ip_config
.ipv6_addl_options
&
221 IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE
) != 0) &&
222 ((ha
->ip_config
.ipv6_link_local_state
==
223 IP_ADDRSTATE_ACQUIRING
) ||
224 (ha
->ip_config
.ipv6_addr0_state
==
225 IP_ADDRSTATE_ACQUIRING
) ||
226 (ha
->ip_config
.ipv6_addr1_state
==
227 IP_ADDRSTATE_ACQUIRING
))) {
231 if ((ha
->ip_config
.ipv6_link_local_state
==
232 IP_ADDRSTATE_PREFERRED
) ||
233 (ha
->ip_config
.ipv6_addr0_state
==
234 IP_ADDRSTATE_PREFERRED
) ||
235 (ha
->ip_config
.ipv6_addr1_state
==
236 IP_ADDRSTATE_PREFERRED
)) {
237 DEBUG2(printk(KERN_INFO
"scsi%ld: %s: "
238 "Preferred IP configured."
239 " Don't wait!\n", ha
->host_no
,
243 if (memcmp(&ha
->ip_config
.ipv6_default_router_addr
,
244 ip_address
, IPv6_ADDR_LEN
) == 0) {
245 DEBUG2(printk(KERN_INFO
"scsi%ld: %s: "
246 "No Router configured. "
247 "Don't wait!\n", ha
->host_no
,
251 if ((ha
->ip_config
.ipv6_default_router_state
==
252 IPV6_RTRSTATE_MANUAL
) &&
253 (ha
->ip_config
.ipv6_link_local_state
==
254 IP_ADDRSTATE_TENTATIVE
) &&
255 (memcmp(&ha
->ip_config
.ipv6_link_local_addr
,
256 &ha
->ip_config
.ipv6_default_router_addr
, 4) ==
258 DEBUG2(printk("scsi%ld: %s: LinkLocal Router & "
259 "IP configured. Don't wait!\n",
260 ha
->host_no
, __func__
));
264 if (ipv4_wait
|| ipv6_wait
) {
265 DEBUG2(printk("scsi%ld: %s: Wait for additional "
266 "IP(s) \"", ha
->host_no
, __func__
));
268 DEBUG2(printk("IPv4 "));
269 if (ha
->ip_config
.ipv6_link_local_state
==
270 IP_ADDRSTATE_ACQUIRING
)
271 DEBUG2(printk("IPv6LinkLocal "));
272 if (ha
->ip_config
.ipv6_addr0_state
==
273 IP_ADDRSTATE_ACQUIRING
)
274 DEBUG2(printk("IPv6Addr0 "));
275 if (ha
->ip_config
.ipv6_addr1_state
==
276 IP_ADDRSTATE_ACQUIRING
)
277 DEBUG2(printk("IPv6Addr1 "));
278 DEBUG2(printk("\"\n"));
282 return ipv4_wait
|ipv6_wait
;
286 * qla4xxx_alloc_fw_dump - Allocate memory for minidump data.
287 * @ha: pointer to host adapter structure.
289 void qla4xxx_alloc_fw_dump(struct scsi_qla_host
*ha
)
292 uint32_t capture_debug_level
;
293 int hdr_entry_bit
, k
;
295 dma_addr_t md_tmp_dma
;
296 struct qla4_8xxx_minidump_template_hdr
*md_hdr
;
299 ql4_printk(KERN_WARNING
, ha
,
300 "Firmware dump previously allocated.\n");
304 status
= qla4xxx_req_template_size(ha
);
305 if (status
!= QLA_SUCCESS
) {
306 ql4_printk(KERN_INFO
, ha
,
307 "scsi%ld: Failed to get template size\n",
312 clear_bit(AF_82XX_FW_DUMPED
, &ha
->flags
);
314 /* Allocate memory for saving the template */
315 md_tmp
= dma_alloc_coherent(&ha
->pdev
->dev
, ha
->fw_dump_tmplt_size
,
316 &md_tmp_dma
, GFP_KERNEL
);
318 /* Request template */
319 status
= qla4xxx_get_minidump_template(ha
, md_tmp_dma
);
320 if (status
!= QLA_SUCCESS
) {
321 ql4_printk(KERN_INFO
, ha
,
322 "scsi%ld: Failed to get minidump template\n",
327 md_hdr
= (struct qla4_8xxx_minidump_template_hdr
*)md_tmp
;
329 capture_debug_level
= md_hdr
->capture_debug_level
;
331 /* Get capture mask based on module loadtime setting. */
332 if (ql4xmdcapmask
>= 0x3 && ql4xmdcapmask
<= 0x7F)
333 ha
->fw_dump_capture_mask
= ql4xmdcapmask
;
335 ha
->fw_dump_capture_mask
= capture_debug_level
;
337 md_hdr
->driver_capture_mask
= ha
->fw_dump_capture_mask
;
339 DEBUG2(ql4_printk(KERN_INFO
, ha
, "Minimum num of entries = %d\n",
340 md_hdr
->num_of_entries
));
341 DEBUG2(ql4_printk(KERN_INFO
, ha
, "Dump template size = %d\n",
342 ha
->fw_dump_tmplt_size
));
343 DEBUG2(ql4_printk(KERN_INFO
, ha
, "Selected Capture mask =0x%x\n",
344 ha
->fw_dump_capture_mask
));
346 /* Calculate fw_dump_size */
347 for (hdr_entry_bit
= 0x2, k
= 1; (hdr_entry_bit
& 0xFF);
348 hdr_entry_bit
<<= 1, k
++) {
349 if (hdr_entry_bit
& ha
->fw_dump_capture_mask
)
350 ha
->fw_dump_size
+= md_hdr
->capture_size_array
[k
];
353 /* Total firmware dump size including command header */
354 ha
->fw_dump_size
+= ha
->fw_dump_tmplt_size
;
355 ha
->fw_dump
= vmalloc(ha
->fw_dump_size
);
359 DEBUG2(ql4_printk(KERN_INFO
, ha
,
360 "Minidump Tempalate Size = 0x%x KB\n",
361 ha
->fw_dump_tmplt_size
));
362 DEBUG2(ql4_printk(KERN_INFO
, ha
,
363 "Total Minidump size = 0x%x KB\n", ha
->fw_dump_size
));
365 memcpy(ha
->fw_dump
, md_tmp
, ha
->fw_dump_tmplt_size
);
366 ha
->fw_dump_tmplt_hdr
= ha
->fw_dump
;
369 dma_free_coherent(&ha
->pdev
->dev
, ha
->fw_dump_tmplt_size
,
373 static int qla4xxx_fw_ready(struct scsi_qla_host
*ha
)
375 uint32_t timeout_count
;
378 DEBUG2(ql4_printk(KERN_INFO
, ha
, "Waiting for Firmware Ready..\n"));
379 for (timeout_count
= ADAPTER_INIT_TOV
; timeout_count
> 0;
381 if (test_and_clear_bit(DPC_GET_DHCP_IP_ADDR
, &ha
->dpc_flags
))
382 qla4xxx_get_dhcp_ip_address(ha
);
384 /* Get firmware state. */
385 if (qla4xxx_get_firmware_state(ha
) != QLA_SUCCESS
) {
386 DEBUG2(printk("scsi%ld: %s: unable to get firmware "
387 "state\n", ha
->host_no
, __func__
));
391 if (ha
->firmware_state
& FW_STATE_ERROR
) {
392 DEBUG2(printk("scsi%ld: %s: an unrecoverable error has"
393 " occurred\n", ha
->host_no
, __func__
));
397 if (ha
->firmware_state
& FW_STATE_CONFIG_WAIT
) {
399 * The firmware has not yet been issued an Initialize
400 * Firmware command, so issue it now.
402 if (qla4xxx_initialize_fw_cb(ha
) == QLA_ERROR
)
405 /* Go back and test for ready state - no wait. */
409 if (ha
->firmware_state
& FW_STATE_WAIT_AUTOCONNECT
) {
410 DEBUG2(printk(KERN_INFO
"scsi%ld: %s: fwstate:"
411 "AUTOCONNECT in progress\n",
412 ha
->host_no
, __func__
));
415 if (ha
->firmware_state
& FW_STATE_CONFIGURING_IP
) {
416 DEBUG2(printk(KERN_INFO
"scsi%ld: %s: fwstate:"
418 ha
->host_no
, __func__
));
420 * Check for link state after 15 secs and if link is
421 * still DOWN then, cable is unplugged. Ignore "DHCP
422 * in Progress/CONFIGURING IP" bit to check if firmware
423 * is in ready state or not after 15 secs.
424 * This is applicable for both 2.x & 3.x firmware
426 if (timeout_count
<= (ADAPTER_INIT_TOV
- 15)) {
427 if (ha
->addl_fw_state
& FW_ADDSTATE_LINK_UP
) {
428 DEBUG2(printk(KERN_INFO
"scsi%ld: %s:"
429 " LINK UP (Cable plugged)\n",
430 ha
->host_no
, __func__
));
431 } else if (ha
->firmware_state
&
432 (FW_STATE_CONFIGURING_IP
|
434 DEBUG2(printk(KERN_INFO
"scsi%ld: %s: "
435 "LINK DOWN (Cable unplugged)\n",
436 ha
->host_no
, __func__
));
437 ha
->firmware_state
= FW_STATE_READY
;
442 if (ha
->firmware_state
== FW_STATE_READY
) {
443 /* If DHCP IP Addr is available, retrieve it now. */
444 if (test_and_clear_bit(DPC_GET_DHCP_IP_ADDR
,
446 qla4xxx_get_dhcp_ip_address(ha
);
448 if (!qla4xxx_wait_for_ip_config(ha
) ||
449 timeout_count
== 1) {
450 DEBUG2(ql4_printk(KERN_INFO
, ha
,
451 "Firmware Ready..\n"));
452 /* The firmware is ready to process SCSI
454 DEBUG2(ql4_printk(KERN_INFO
, ha
,
455 "scsi%ld: %s: MEDIA TYPE"
456 " - %s\n", ha
->host_no
,
457 __func__
, (ha
->addl_fw_state
&
458 FW_ADDSTATE_OPTICAL_MEDIA
)
459 != 0 ? "OPTICAL" : "COPPER"));
460 DEBUG2(ql4_printk(KERN_INFO
, ha
,
461 "scsi%ld: %s: DHCPv4 STATE"
462 " Enabled %s\n", ha
->host_no
,
463 __func__
, (ha
->addl_fw_state
&
464 FW_ADDSTATE_DHCPv4_ENABLED
) != 0 ?
466 DEBUG2(ql4_printk(KERN_INFO
, ha
,
467 "scsi%ld: %s: LINK %s\n",
468 ha
->host_no
, __func__
,
470 FW_ADDSTATE_LINK_UP
) != 0 ?
472 DEBUG2(ql4_printk(KERN_INFO
, ha
,
473 "scsi%ld: %s: iSNS Service "
475 ha
->host_no
, __func__
,
477 FW_ADDSTATE_ISNS_SVC_ENABLED
) != 0 ?
484 DEBUG2(printk("scsi%ld: %s: waiting on fw, state=%x:%x - "
485 "seconds expired= %d\n", ha
->host_no
, __func__
,
486 ha
->firmware_state
, ha
->addl_fw_state
,
488 if (is_qla4032(ha
) &&
489 !(ha
->addl_fw_state
& FW_ADDSTATE_LINK_UP
) &&
490 (timeout_count
< ADAPTER_INIT_TOV
- 5)) {
497 if (timeout_count
<= 0)
498 DEBUG2(printk("scsi%ld: %s: FW Initialization timed out!\n",
499 ha
->host_no
, __func__
));
501 if (ha
->firmware_state
& FW_STATE_CONFIGURING_IP
) {
502 DEBUG2(printk("scsi%ld: %s: FW initialized, but is reporting "
503 "it's waiting to configure an IP address\n",
504 ha
->host_no
, __func__
));
506 } else if (ha
->firmware_state
& FW_STATE_WAIT_AUTOCONNECT
) {
507 DEBUG2(printk("scsi%ld: %s: FW initialized, but "
508 "auto-discovery still in process\n",
509 ha
->host_no
, __func__
));
517 * qla4xxx_init_firmware - initializes the firmware.
518 * @ha: pointer to host adapter structure.
521 static int qla4xxx_init_firmware(struct scsi_qla_host
*ha
)
523 int status
= QLA_ERROR
;
525 if (is_aer_supported(ha
) &&
526 test_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE
, &ha
->flags
))
529 /* For 82xx, stop firmware before initializing because if BIOS
530 * has previously initialized firmware, then driver's initialize
531 * firmware will fail. */
533 qla4_8xxx_stop_firmware(ha
);
535 ql4_printk(KERN_INFO
, ha
, "Initializing firmware..\n");
536 if (qla4xxx_initialize_fw_cb(ha
) == QLA_ERROR
) {
537 DEBUG2(printk("scsi%ld: %s: Failed to initialize firmware "
538 "control block\n", ha
->host_no
, __func__
));
542 if (!qla4xxx_fw_ready(ha
))
545 if (is_qla80XX(ha
) && !test_bit(AF_INIT_DONE
, &ha
->flags
))
546 qla4xxx_alloc_fw_dump(ha
);
548 return qla4xxx_get_firmware_status(ha
);
551 static void qla4xxx_set_model_info(struct scsi_qla_host
*ha
)
553 uint16_t board_id_string
[8];
555 int size
= sizeof(ha
->nvram
->isp4022
.boardIdStr
);
556 int offset
= offsetof(struct eeprom_data
, isp4022
.boardIdStr
) / 2;
558 for (i
= 0; i
< (size
/ 2) ; i
++) {
559 board_id_string
[i
] = rd_nvram_word(ha
, offset
);
563 memcpy(ha
->model_name
, board_id_string
, size
);
566 static int qla4xxx_config_nvram(struct scsi_qla_host
*ha
)
569 union external_hw_config_reg extHwConfig
;
571 DEBUG2(printk("scsi%ld: %s: Get EEProm parameters \n", ha
->host_no
,
573 if (ql4xxx_lock_flash(ha
) != QLA_SUCCESS
)
575 if (ql4xxx_lock_nvram(ha
) != QLA_SUCCESS
) {
576 ql4xxx_unlock_flash(ha
);
580 /* Get EEPRom Parameters from NVRAM and validate */
581 ql4_printk(KERN_INFO
, ha
, "Configuring NVRAM ...\n");
582 if (qla4xxx_is_nvram_configuration_valid(ha
) == QLA_SUCCESS
) {
583 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
584 extHwConfig
.Asuint32_t
=
585 rd_nvram_word(ha
, eeprom_ext_hw_conf_offset(ha
));
586 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
588 ql4_printk(KERN_WARNING
, ha
,
589 "scsi%ld: %s: EEProm checksum invalid. "
590 "Please update your EEPROM\n", ha
->host_no
,
593 /* Attempt to set defaults */
595 extHwConfig
.Asuint32_t
= 0x1912;
596 else if (is_qla4022(ha
) | is_qla4032(ha
))
597 extHwConfig
.Asuint32_t
= 0x0023;
602 if (is_qla4022(ha
) || is_qla4032(ha
))
603 qla4xxx_set_model_info(ha
);
605 strcpy(ha
->model_name
, "QLA4010");
607 DEBUG(printk("scsi%ld: %s: Setting extHwConfig to 0xFFFF%04x\n",
608 ha
->host_no
, __func__
, extHwConfig
.Asuint32_t
));
610 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
611 writel((0xFFFF << 16) | extHwConfig
.Asuint32_t
, isp_ext_hw_conf(ha
));
612 readl(isp_ext_hw_conf(ha
));
613 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
615 ql4xxx_unlock_nvram(ha
);
616 ql4xxx_unlock_flash(ha
);
622 * qla4_8xxx_pci_config() - Setup ISP82xx PCI configuration registers.
625 void qla4_8xxx_pci_config(struct scsi_qla_host
*ha
)
627 pci_set_master(ha
->pdev
);
630 void qla4xxx_pci_config(struct scsi_qla_host
*ha
)
635 ql4_printk(KERN_INFO
, ha
, "Configuring PCI space...\n");
637 pci_set_master(ha
->pdev
);
638 status
= pci_set_mwi(ha
->pdev
);
640 * We want to respect framework's setting of PCI configuration space
641 * command register and also want to make sure that all bits of
642 * interest to us are properly set in command register.
644 pci_read_config_word(ha
->pdev
, PCI_COMMAND
, &w
);
645 w
|= PCI_COMMAND_PARITY
| PCI_COMMAND_SERR
;
646 w
&= ~PCI_COMMAND_INTX_DISABLE
;
647 pci_write_config_word(ha
->pdev
, PCI_COMMAND
, w
);
650 static int qla4xxx_start_firmware_from_flash(struct scsi_qla_host
*ha
)
652 int status
= QLA_ERROR
;
653 unsigned long max_wait_time
;
655 uint32_t mbox_status
;
657 ql4_printk(KERN_INFO
, ha
, "Starting firmware ...\n");
660 * Start firmware from flash ROM
662 * WORKAROUND: Stuff a non-constant value that the firmware can
663 * use as a seed for a random number generator in MB7 prior to
664 * setting BOOT_ENABLE. Fixes problem where the TCP
665 * connections use the same TCP ports after each reboot,
666 * causing some connections to not get re-established.
668 DEBUG(printk("scsi%d: %s: Start firmware from flash ROM\n",
669 ha
->host_no
, __func__
));
671 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
672 writel(jiffies
, &ha
->reg
->mailbox
[7]);
673 if (is_qla4022(ha
) | is_qla4032(ha
))
674 writel(set_rmask(NVR_WRITE_ENABLE
),
675 &ha
->reg
->u1
.isp4022
.nvram
);
677 writel(2, &ha
->reg
->mailbox
[6]);
678 readl(&ha
->reg
->mailbox
[6]);
680 writel(set_rmask(CSR_BOOT_ENABLE
), &ha
->reg
->ctrl_status
);
681 readl(&ha
->reg
->ctrl_status
);
682 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
684 /* Wait for firmware to come UP. */
685 DEBUG2(printk(KERN_INFO
"scsi%ld: %s: Wait up to %d seconds for "
686 "boot firmware to complete...\n",
687 ha
->host_no
, __func__
, FIRMWARE_UP_TOV
));
688 max_wait_time
= jiffies
+ (FIRMWARE_UP_TOV
* HZ
);
690 uint32_t ctrl_status
;
692 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
693 ctrl_status
= readw(&ha
->reg
->ctrl_status
);
694 mbox_status
= readw(&ha
->reg
->mailbox
[0]);
695 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
697 if (ctrl_status
& set_rmask(CSR_SCSI_PROCESSOR_INTR
))
699 if (mbox_status
== MBOX_STS_COMMAND_COMPLETE
)
702 DEBUG2(printk(KERN_INFO
"scsi%ld: %s: Waiting for boot "
703 "firmware to complete... ctrl_sts=0x%x, remaining=%ld\n",
704 ha
->host_no
, __func__
, ctrl_status
, max_wait_time
));
706 msleep_interruptible(250);
707 } while (!time_after_eq(jiffies
, max_wait_time
));
709 if (mbox_status
== MBOX_STS_COMMAND_COMPLETE
) {
710 DEBUG(printk(KERN_INFO
"scsi%ld: %s: Firmware has started\n",
711 ha
->host_no
, __func__
));
713 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
714 writel(set_rmask(CSR_SCSI_PROCESSOR_INTR
),
715 &ha
->reg
->ctrl_status
);
716 readl(&ha
->reg
->ctrl_status
);
717 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
719 status
= QLA_SUCCESS
;
721 printk(KERN_INFO
"scsi%ld: %s: Boot firmware failed "
722 "- mbox status 0x%x\n", ha
->host_no
, __func__
,
729 int ql4xxx_lock_drvr_wait(struct scsi_qla_host
*a
)
731 #define QL4_LOCK_DRVR_WAIT 60
732 #define QL4_LOCK_DRVR_SLEEP 1
734 int drvr_wait
= QL4_LOCK_DRVR_WAIT
;
736 if (ql4xxx_lock_drvr(a
) == 0) {
737 ssleep(QL4_LOCK_DRVR_SLEEP
);
739 DEBUG2(printk("scsi%ld: %s: Waiting for "
740 "Global Init Semaphore(%d)...\n",
742 __func__
, drvr_wait
));
744 drvr_wait
-= QL4_LOCK_DRVR_SLEEP
;
746 DEBUG2(printk("scsi%ld: %s: Global Init Semaphore "
747 "acquired\n", a
->host_no
, __func__
));
755 * qla4xxx_start_firmware - starts qla4xxx firmware
756 * @ha: Pointer to host adapter structure.
758 * This routine performs the necessary steps to start the firmware for
759 * the QLA4010 adapter.
761 int qla4xxx_start_firmware(struct scsi_qla_host
*ha
)
763 unsigned long flags
= 0;
764 uint32_t mbox_status
;
765 int status
= QLA_ERROR
;
769 if (is_qla4022(ha
) | is_qla4032(ha
))
770 ql4xxx_set_mac_number(ha
);
772 if (ql4xxx_lock_drvr_wait(ha
) != QLA_SUCCESS
)
775 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
777 DEBUG2(printk("scsi%ld: %s: port_ctrl = 0x%08X\n", ha
->host_no
,
778 __func__
, readw(isp_port_ctrl(ha
))));
779 DEBUG(printk("scsi%ld: %s: port_status = 0x%08X\n", ha
->host_no
,
780 __func__
, readw(isp_port_status(ha
))));
782 /* Is Hardware already initialized? */
783 if ((readw(isp_port_ctrl(ha
)) & 0x8000) != 0) {
784 DEBUG(printk("scsi%ld: %s: Hardware has already been "
785 "initialized\n", ha
->host_no
, __func__
));
787 /* Receive firmware boot acknowledgement */
788 mbox_status
= readw(&ha
->reg
->mailbox
[0]);
790 DEBUG2(printk("scsi%ld: %s: H/W Config complete - mbox[0]= "
791 "0x%x\n", ha
->host_no
, __func__
, mbox_status
));
793 /* Is firmware already booted? */
794 if (mbox_status
== 0) {
795 /* F/W not running, must be config by net driver */
799 writel(set_rmask(CSR_SCSI_PROCESSOR_INTR
),
800 &ha
->reg
->ctrl_status
);
801 readl(&ha
->reg
->ctrl_status
);
802 writel(set_rmask(CSR_SCSI_COMPLETION_INTR
),
803 &ha
->reg
->ctrl_status
);
804 readl(&ha
->reg
->ctrl_status
);
805 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
806 if (qla4xxx_get_firmware_state(ha
) == QLA_SUCCESS
) {
807 DEBUG2(printk("scsi%ld: %s: Get firmware "
808 "state -- state = 0x%x\n",
810 __func__
, ha
->firmware_state
));
812 if (ha
->firmware_state
&
813 FW_STATE_CONFIG_WAIT
) {
814 DEBUG2(printk("scsi%ld: %s: Firmware "
817 "boot, state = 0x%x\n",
818 ha
->host_no
, __func__
,
819 ha
->firmware_state
));
824 DEBUG2(printk("scsi%ld: %s: Firmware in "
825 "unknown state -- resetting,"
827 "0x%x\n", ha
->host_no
, __func__
,
828 ha
->firmware_state
));
830 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
833 DEBUG(printk("scsi%ld: %s: H/W initialization hasn't been "
834 "started - resetting\n", ha
->host_no
, __func__
));
836 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
838 DEBUG(printk("scsi%ld: %s: Flags soft_rest=%d, config= %d\n ",
839 ha
->host_no
, __func__
, soft_reset
, config_chip
));
841 DEBUG(printk("scsi%ld: %s: Issue Soft Reset\n", ha
->host_no
,
843 status
= qla4xxx_soft_reset(ha
); /* NOTE: acquires drvr
844 * lock again, but ok */
845 if (status
== QLA_ERROR
) {
846 DEBUG(printk("scsi%d: %s: Soft Reset failed!\n",
847 ha
->host_no
, __func__
));
848 ql4xxx_unlock_drvr(ha
);
853 /* Reset clears the semaphore, so acquire again */
854 if (ql4xxx_lock_drvr_wait(ha
) != QLA_SUCCESS
)
859 if ((status
= qla4xxx_config_nvram(ha
)) == QLA_SUCCESS
)
860 status
= qla4xxx_start_firmware_from_flash(ha
);
863 ql4xxx_unlock_drvr(ha
);
864 if (status
== QLA_SUCCESS
) {
865 if (test_and_clear_bit(AF_GET_CRASH_RECORD
, &ha
->flags
))
866 qla4xxx_get_crash_record(ha
);
868 DEBUG(printk("scsi%ld: %s: Firmware has NOT started\n",
869 ha
->host_no
, __func__
));
874 * qla4xxx_free_ddb_index - Free DDBs reserved by firmware
875 * @ha: pointer to adapter structure
877 * Since firmware is not running in autoconnect mode the DDB indices should
878 * be freed so that when login happens from user space there are free DDB
881 void qla4xxx_free_ddb_index(struct scsi_qla_host
*ha
)
885 uint32_t idx
= 0, next_idx
= 0;
886 uint32_t state
= 0, conn_err
= 0;
888 max_ddbs
= is_qla40XX(ha
) ? MAX_DEV_DB_ENTRIES_40XX
:
891 for (idx
= 0; idx
< max_ddbs
; idx
= next_idx
) {
892 ret
= qla4xxx_get_fwddb_entry(ha
, idx
, NULL
, 0, NULL
,
893 &next_idx
, &state
, &conn_err
,
895 if (ret
== QLA_ERROR
) {
899 if (state
== DDB_DS_NO_CONNECTION_ACTIVE
||
900 state
== DDB_DS_SESSION_FAILED
) {
901 DEBUG2(ql4_printk(KERN_INFO
, ha
,
902 "Freeing DDB index = 0x%x\n", idx
));
903 ret
= qla4xxx_clear_ddb_entry(ha
, idx
);
904 if (ret
== QLA_ERROR
)
905 ql4_printk(KERN_ERR
, ha
,
906 "Unable to clear DDB index = "
915 * qla4xxx_initialize_adapter - initiailizes hba
916 * @ha: Pointer to host adapter structure.
918 * This routine parforms all of the steps necessary to initialize the adapter.
921 int qla4xxx_initialize_adapter(struct scsi_qla_host
*ha
, int is_reset
)
923 int status
= QLA_ERROR
;
925 ha
->eeprom_cmd_data
= 0;
927 ql4_printk(KERN_INFO
, ha
, "Configuring PCI space...\n");
928 ha
->isp_ops
->pci_config(ha
);
930 ha
->isp_ops
->disable_intrs(ha
);
932 /* Initialize the Host adapter request/response queues and firmware */
933 if (ha
->isp_ops
->start_firmware(ha
) == QLA_ERROR
)
937 * For ISP83XX, mailbox and IOCB interrupts are enabled separately.
938 * Mailbox interrupts must be enabled prior to issuing any mailbox
939 * command in order to prevent the possibility of losing interrupts
940 * while switching from polling to interrupt mode. IOCB interrupts are
941 * enabled via isp_ops->enable_intrs.
943 if (is_qla8032(ha
) || is_qla8042(ha
))
944 qla4_83xx_enable_mbox_intrs(ha
);
946 if (qla4xxx_about_firmware(ha
) == QLA_ERROR
)
949 if (ha
->isp_ops
->get_sys_info(ha
) == QLA_ERROR
)
952 qla4xxx_init_local_data(ha
);
954 status
= qla4xxx_init_firmware(ha
);
955 if (status
== QLA_ERROR
)
958 if (is_reset
== RESET_ADAPTER
)
959 qla4xxx_build_ddb_list(ha
, is_reset
);
961 set_bit(AF_ONLINE
, &ha
->flags
);
963 if (is_qla80XX(ha
) && (status
== QLA_ERROR
)) {
964 /* Since interrupts are registered in start_firmware for
965 * 80XX, release them here if initialize_adapter fails */
966 qla4xxx_free_irqs(ha
);
969 DEBUG2(printk("scsi%ld: initialize adapter: %s\n", ha
->host_no
,
970 status
== QLA_ERROR
? "FAILED" : "SUCCEEDED"));
974 int qla4xxx_ddb_change(struct scsi_qla_host
*ha
, uint32_t fw_ddb_index
,
975 struct ddb_entry
*ddb_entry
, uint32_t state
)
977 uint32_t old_fw_ddb_device_state
;
978 int status
= QLA_ERROR
;
980 old_fw_ddb_device_state
= ddb_entry
->fw_ddb_device_state
;
981 DEBUG2(ql4_printk(KERN_INFO
, ha
,
982 "%s: DDB - old state = 0x%x, new state = 0x%x for "
983 "index [%d]\n", __func__
,
984 ddb_entry
->fw_ddb_device_state
, state
, fw_ddb_index
));
986 ddb_entry
->fw_ddb_device_state
= state
;
988 switch (old_fw_ddb_device_state
) {
989 case DDB_DS_LOGIN_IN_PROCESS
:
991 case DDB_DS_SESSION_ACTIVE
:
992 case DDB_DS_DISCOVERY
:
993 qla4xxx_update_session_conn_param(ha
, ddb_entry
);
994 ddb_entry
->unblock_sess(ddb_entry
->sess
);
995 status
= QLA_SUCCESS
;
997 case DDB_DS_SESSION_FAILED
:
998 case DDB_DS_NO_CONNECTION_ACTIVE
:
999 iscsi_conn_login_event(ddb_entry
->conn
,
1000 ISCSI_CONN_STATE_FREE
);
1001 status
= QLA_SUCCESS
;
1005 case DDB_DS_SESSION_ACTIVE
:
1006 case DDB_DS_DISCOVERY
:
1008 case DDB_DS_SESSION_FAILED
:
1010 * iscsi_session failure will cause userspace to
1011 * stop the connection which in turn would block the
1012 * iscsi_session and start relogin
1014 iscsi_session_failure(ddb_entry
->sess
->dd_data
,
1015 ISCSI_ERR_CONN_FAILED
);
1016 status
= QLA_SUCCESS
;
1018 case DDB_DS_NO_CONNECTION_ACTIVE
:
1019 clear_bit(fw_ddb_index
, ha
->ddb_idx_map
);
1020 status
= QLA_SUCCESS
;
1024 case DDB_DS_SESSION_FAILED
:
1026 case DDB_DS_SESSION_ACTIVE
:
1027 case DDB_DS_DISCOVERY
:
1028 ddb_entry
->unblock_sess(ddb_entry
->sess
);
1029 qla4xxx_update_session_conn_param(ha
, ddb_entry
);
1030 status
= QLA_SUCCESS
;
1032 case DDB_DS_SESSION_FAILED
:
1033 iscsi_session_failure(ddb_entry
->sess
->dd_data
,
1034 ISCSI_ERR_CONN_FAILED
);
1035 status
= QLA_SUCCESS
;
1040 DEBUG2(ql4_printk(KERN_INFO
, ha
, "%s: Unknown Event\n",
1047 void qla4xxx_arm_relogin_timer(struct ddb_entry
*ddb_entry
)
1050 * This triggers a relogin. After the relogin_timer
1051 * expires, the relogin gets scheduled. We must wait a
1052 * minimum amount of time since receiving an 0x8014 AEN
1053 * with failed device_state or a logout response before
1054 * we can issue another relogin.
1056 * Firmware pads this timeout: (time2wait +1).
1057 * Driver retry to login should be longer than F/W.
1058 * Otherwise F/W will fail
1059 * set_ddb() mbx cmd with 0x4005 since it still
1060 * counting down its time2wait.
1062 atomic_set(&ddb_entry
->relogin_timer
, 0);
1063 atomic_set(&ddb_entry
->retry_relogin_timer
,
1064 ddb_entry
->default_time2wait
+ 4);
1068 int qla4xxx_flash_ddb_change(struct scsi_qla_host
*ha
, uint32_t fw_ddb_index
,
1069 struct ddb_entry
*ddb_entry
, uint32_t state
)
1071 uint32_t old_fw_ddb_device_state
;
1072 int status
= QLA_ERROR
;
1074 old_fw_ddb_device_state
= ddb_entry
->fw_ddb_device_state
;
1075 DEBUG2(ql4_printk(KERN_INFO
, ha
,
1076 "%s: DDB - old state = 0x%x, new state = 0x%x for "
1077 "index [%d]\n", __func__
,
1078 ddb_entry
->fw_ddb_device_state
, state
, fw_ddb_index
));
1080 ddb_entry
->fw_ddb_device_state
= state
;
1082 switch (old_fw_ddb_device_state
) {
1083 case DDB_DS_LOGIN_IN_PROCESS
:
1084 case DDB_DS_NO_CONNECTION_ACTIVE
:
1086 case DDB_DS_SESSION_ACTIVE
:
1087 ddb_entry
->unblock_sess(ddb_entry
->sess
);
1088 qla4xxx_update_session_conn_fwddb_param(ha
, ddb_entry
);
1089 status
= QLA_SUCCESS
;
1091 case DDB_DS_SESSION_FAILED
:
1092 iscsi_block_session(ddb_entry
->sess
);
1093 if (!test_bit(DF_RELOGIN
, &ddb_entry
->flags
))
1094 qla4xxx_arm_relogin_timer(ddb_entry
);
1095 status
= QLA_SUCCESS
;
1099 case DDB_DS_SESSION_ACTIVE
:
1101 case DDB_DS_SESSION_FAILED
:
1102 iscsi_block_session(ddb_entry
->sess
);
1103 if (!test_bit(DF_RELOGIN
, &ddb_entry
->flags
))
1104 qla4xxx_arm_relogin_timer(ddb_entry
);
1105 status
= QLA_SUCCESS
;
1109 case DDB_DS_SESSION_FAILED
:
1111 case DDB_DS_SESSION_ACTIVE
:
1112 ddb_entry
->unblock_sess(ddb_entry
->sess
);
1113 qla4xxx_update_session_conn_fwddb_param(ha
, ddb_entry
);
1114 status
= QLA_SUCCESS
;
1116 case DDB_DS_SESSION_FAILED
:
1117 if (!test_bit(DF_RELOGIN
, &ddb_entry
->flags
))
1118 qla4xxx_arm_relogin_timer(ddb_entry
);
1119 status
= QLA_SUCCESS
;
1124 DEBUG2(ql4_printk(KERN_INFO
, ha
, "%s: Unknown Event\n",
1132 * qla4xxx_process_ddb_changed - process ddb state change
1133 * @ha - Pointer to host adapter structure.
1134 * @fw_ddb_index - Firmware's device database index
1135 * @state - Device state
1137 * This routine processes a Decive Database Changed AEN Event.
1139 int qla4xxx_process_ddb_changed(struct scsi_qla_host
*ha
,
1140 uint32_t fw_ddb_index
,
1141 uint32_t state
, uint32_t conn_err
)
1143 struct ddb_entry
*ddb_entry
;
1144 int status
= QLA_ERROR
;
1146 /* check for out of range index */
1147 if (fw_ddb_index
>= MAX_DDB_ENTRIES
)
1148 goto exit_ddb_event
;
1150 /* Get the corresponging ddb entry */
1151 ddb_entry
= qla4xxx_lookup_ddb_by_fw_index(ha
, fw_ddb_index
);
1152 /* Device does not currently exist in our database. */
1153 if (ddb_entry
== NULL
) {
1154 ql4_printk(KERN_ERR
, ha
, "%s: No ddb_entry at FW index [%d]\n",
1155 __func__
, fw_ddb_index
);
1157 if (state
== DDB_DS_NO_CONNECTION_ACTIVE
)
1158 clear_bit(fw_ddb_index
, ha
->ddb_idx_map
);
1160 goto exit_ddb_event
;
1163 ddb_entry
->ddb_change(ha
, fw_ddb_index
, ddb_entry
, state
);
1170 * qla4xxx_login_flash_ddb - Login to target (DDB)
1171 * @cls_session: Pointer to the session to login
1173 * This routine logins to the target.
1174 * Issues setddb and conn open mbx
1176 void qla4xxx_login_flash_ddb(struct iscsi_cls_session
*cls_session
)
1178 struct iscsi_session
*sess
;
1179 struct ddb_entry
*ddb_entry
;
1180 struct scsi_qla_host
*ha
;
1181 struct dev_db_entry
*fw_ddb_entry
= NULL
;
1182 dma_addr_t fw_ddb_dma
;
1183 uint32_t mbx_sts
= 0;
1186 sess
= cls_session
->dd_data
;
1187 ddb_entry
= sess
->dd_data
;
1190 if (!test_bit(AF_LINK_UP
, &ha
->flags
))
1193 if (ddb_entry
->ddb_type
!= FLASH_DDB
) {
1194 DEBUG2(ql4_printk(KERN_INFO
, ha
,
1195 "Skipping login to non FLASH DB"));
1199 fw_ddb_entry
= dma_pool_alloc(ha
->fw_ddb_dma_pool
, GFP_KERNEL
,
1201 if (fw_ddb_entry
== NULL
) {
1202 DEBUG2(ql4_printk(KERN_ERR
, ha
, "Out of memory\n"));
1206 if (ddb_entry
->fw_ddb_index
== INVALID_ENTRY
) {
1207 ret
= qla4xxx_get_ddb_index(ha
, &ddb_entry
->fw_ddb_index
);
1208 if (ret
== QLA_ERROR
)
1211 ha
->fw_ddb_index_map
[ddb_entry
->fw_ddb_index
] = ddb_entry
;
1215 memcpy(fw_ddb_entry
, &ddb_entry
->fw_ddb_entry
,
1216 sizeof(struct dev_db_entry
));
1217 ddb_entry
->sess
->target_id
= ddb_entry
->fw_ddb_index
;
1219 ret
= qla4xxx_set_ddb_entry(ha
, ddb_entry
->fw_ddb_index
,
1220 fw_ddb_dma
, &mbx_sts
);
1221 if (ret
== QLA_ERROR
) {
1222 DEBUG2(ql4_printk(KERN_ERR
, ha
, "Set DDB failed\n"));
1226 ddb_entry
->fw_ddb_device_state
= DDB_DS_LOGIN_IN_PROCESS
;
1227 ret
= qla4xxx_conn_open(ha
, ddb_entry
->fw_ddb_index
);
1228 if (ret
== QLA_ERROR
) {
1229 ql4_printk(KERN_ERR
, ha
, "%s: Login failed: %s\n", __func__
,
1236 dma_pool_free(ha
->fw_ddb_dma_pool
, fw_ddb_entry
, fw_ddb_dma
);