2 * QLogic iSCSI HBA Driver
3 * Copyright (c) 2003-2012 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
)) {
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 int qla4xxx_init_local_data(struct scsi_qla_host
*ha
)
200 /* Initialize aen queue */
201 ha
->aen_q_count
= MAX_AEN_ENTRIES
;
203 return qla4xxx_get_firmware_status(ha
);
207 qla4xxx_wait_for_ip_config(struct scsi_qla_host
*ha
)
209 uint8_t ipv4_wait
= 0;
210 uint8_t ipv6_wait
= 0;
211 int8_t ip_address
[IPv6_ADDR_LEN
] = {0} ;
213 /* If both IPv4 & IPv6 are enabled, possibly only one
214 * IP address may be acquired, so check to see if we
215 * need to wait for another */
216 if (is_ipv4_enabled(ha
) && is_ipv6_enabled(ha
)) {
217 if (((ha
->addl_fw_state
& FW_ADDSTATE_DHCPv4_ENABLED
) != 0) &&
218 ((ha
->addl_fw_state
&
219 FW_ADDSTATE_DHCPv4_LEASE_ACQUIRED
) == 0)) {
222 if (((ha
->ip_config
.ipv6_addl_options
&
223 IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE
) != 0) &&
224 ((ha
->ip_config
.ipv6_link_local_state
==
225 IP_ADDRSTATE_ACQUIRING
) ||
226 (ha
->ip_config
.ipv6_addr0_state
==
227 IP_ADDRSTATE_ACQUIRING
) ||
228 (ha
->ip_config
.ipv6_addr1_state
==
229 IP_ADDRSTATE_ACQUIRING
))) {
233 if ((ha
->ip_config
.ipv6_link_local_state
==
234 IP_ADDRSTATE_PREFERRED
) ||
235 (ha
->ip_config
.ipv6_addr0_state
==
236 IP_ADDRSTATE_PREFERRED
) ||
237 (ha
->ip_config
.ipv6_addr1_state
==
238 IP_ADDRSTATE_PREFERRED
)) {
239 DEBUG2(printk(KERN_INFO
"scsi%ld: %s: "
240 "Preferred IP configured."
241 " Don't wait!\n", ha
->host_no
,
245 if (memcmp(&ha
->ip_config
.ipv6_default_router_addr
,
246 ip_address
, IPv6_ADDR_LEN
) == 0) {
247 DEBUG2(printk(KERN_INFO
"scsi%ld: %s: "
248 "No Router configured. "
249 "Don't wait!\n", ha
->host_no
,
253 if ((ha
->ip_config
.ipv6_default_router_state
==
254 IPV6_RTRSTATE_MANUAL
) &&
255 (ha
->ip_config
.ipv6_link_local_state
==
256 IP_ADDRSTATE_TENTATIVE
) &&
257 (memcmp(&ha
->ip_config
.ipv6_link_local_addr
,
258 &ha
->ip_config
.ipv6_default_router_addr
, 4) ==
260 DEBUG2(printk("scsi%ld: %s: LinkLocal Router & "
261 "IP configured. Don't wait!\n",
262 ha
->host_no
, __func__
));
266 if (ipv4_wait
|| ipv6_wait
) {
267 DEBUG2(printk("scsi%ld: %s: Wait for additional "
268 "IP(s) \"", ha
->host_no
, __func__
));
270 DEBUG2(printk("IPv4 "));
271 if (ha
->ip_config
.ipv6_link_local_state
==
272 IP_ADDRSTATE_ACQUIRING
)
273 DEBUG2(printk("IPv6LinkLocal "));
274 if (ha
->ip_config
.ipv6_addr0_state
==
275 IP_ADDRSTATE_ACQUIRING
)
276 DEBUG2(printk("IPv6Addr0 "));
277 if (ha
->ip_config
.ipv6_addr1_state
==
278 IP_ADDRSTATE_ACQUIRING
)
279 DEBUG2(printk("IPv6Addr1 "));
280 DEBUG2(printk("\"\n"));
284 return ipv4_wait
|ipv6_wait
;
288 * qla4xxx_alloc_fw_dump - Allocate memory for minidump data.
289 * @ha: pointer to host adapter structure.
291 void qla4xxx_alloc_fw_dump(struct scsi_qla_host
*ha
)
294 uint32_t capture_debug_level
;
295 int hdr_entry_bit
, k
;
297 dma_addr_t md_tmp_dma
;
298 struct qla4_8xxx_minidump_template_hdr
*md_hdr
;
301 ql4_printk(KERN_WARNING
, ha
,
302 "Firmware dump previously allocated.\n");
306 status
= qla4xxx_req_template_size(ha
);
307 if (status
!= QLA_SUCCESS
) {
308 ql4_printk(KERN_INFO
, ha
,
309 "scsi%ld: Failed to get template size\n",
314 clear_bit(AF_82XX_FW_DUMPED
, &ha
->flags
);
316 /* Allocate memory for saving the template */
317 md_tmp
= dma_alloc_coherent(&ha
->pdev
->dev
, ha
->fw_dump_tmplt_size
,
318 &md_tmp_dma
, GFP_KERNEL
);
320 /* Request template */
321 status
= qla4xxx_get_minidump_template(ha
, md_tmp_dma
);
322 if (status
!= QLA_SUCCESS
) {
323 ql4_printk(KERN_INFO
, ha
,
324 "scsi%ld: Failed to get minidump template\n",
329 md_hdr
= (struct qla4_8xxx_minidump_template_hdr
*)md_tmp
;
331 capture_debug_level
= md_hdr
->capture_debug_level
;
333 /* Get capture mask based on module loadtime setting. */
334 if (ql4xmdcapmask
>= 0x3 && ql4xmdcapmask
<= 0x7F)
335 ha
->fw_dump_capture_mask
= ql4xmdcapmask
;
337 ha
->fw_dump_capture_mask
= capture_debug_level
;
339 md_hdr
->driver_capture_mask
= ha
->fw_dump_capture_mask
;
341 DEBUG2(ql4_printk(KERN_INFO
, ha
, "Minimum num of entries = %d\n",
342 md_hdr
->num_of_entries
));
343 DEBUG2(ql4_printk(KERN_INFO
, ha
, "Dump template size = %d\n",
344 ha
->fw_dump_tmplt_size
));
345 DEBUG2(ql4_printk(KERN_INFO
, ha
, "Selected Capture mask =0x%x\n",
346 ha
->fw_dump_capture_mask
));
348 /* Calculate fw_dump_size */
349 for (hdr_entry_bit
= 0x2, k
= 1; (hdr_entry_bit
& 0xFF);
350 hdr_entry_bit
<<= 1, k
++) {
351 if (hdr_entry_bit
& ha
->fw_dump_capture_mask
)
352 ha
->fw_dump_size
+= md_hdr
->capture_size_array
[k
];
355 /* Total firmware dump size including command header */
356 ha
->fw_dump_size
+= ha
->fw_dump_tmplt_size
;
357 ha
->fw_dump
= vmalloc(ha
->fw_dump_size
);
361 DEBUG2(ql4_printk(KERN_INFO
, ha
,
362 "Minidump Tempalate Size = 0x%x KB\n",
363 ha
->fw_dump_tmplt_size
));
364 DEBUG2(ql4_printk(KERN_INFO
, ha
,
365 "Total Minidump size = 0x%x KB\n", ha
->fw_dump_size
));
367 memcpy(ha
->fw_dump
, md_tmp
, ha
->fw_dump_tmplt_size
);
368 ha
->fw_dump_tmplt_hdr
= ha
->fw_dump
;
371 dma_free_coherent(&ha
->pdev
->dev
, ha
->fw_dump_tmplt_size
,
375 static int qla4xxx_fw_ready(struct scsi_qla_host
*ha
)
377 uint32_t timeout_count
;
380 DEBUG2(ql4_printk(KERN_INFO
, ha
, "Waiting for Firmware Ready..\n"));
381 for (timeout_count
= ADAPTER_INIT_TOV
; timeout_count
> 0;
383 if (test_and_clear_bit(DPC_GET_DHCP_IP_ADDR
, &ha
->dpc_flags
))
384 qla4xxx_get_dhcp_ip_address(ha
);
386 /* Get firmware state. */
387 if (qla4xxx_get_firmware_state(ha
) != QLA_SUCCESS
) {
388 DEBUG2(printk("scsi%ld: %s: unable to get firmware "
389 "state\n", ha
->host_no
, __func__
));
393 if (ha
->firmware_state
& FW_STATE_ERROR
) {
394 DEBUG2(printk("scsi%ld: %s: an unrecoverable error has"
395 " occurred\n", ha
->host_no
, __func__
));
399 if (ha
->firmware_state
& FW_STATE_CONFIG_WAIT
) {
401 * The firmware has not yet been issued an Initialize
402 * Firmware command, so issue it now.
404 if (qla4xxx_initialize_fw_cb(ha
) == QLA_ERROR
)
407 /* Go back and test for ready state - no wait. */
411 if (ha
->firmware_state
& FW_STATE_WAIT_AUTOCONNECT
) {
412 DEBUG2(printk(KERN_INFO
"scsi%ld: %s: fwstate:"
413 "AUTOCONNECT in progress\n",
414 ha
->host_no
, __func__
));
417 if (ha
->firmware_state
& FW_STATE_CONFIGURING_IP
) {
418 DEBUG2(printk(KERN_INFO
"scsi%ld: %s: fwstate:"
420 ha
->host_no
, __func__
));
422 * Check for link state after 15 secs and if link is
423 * still DOWN then, cable is unplugged. Ignore "DHCP
424 * in Progress/CONFIGURING IP" bit to check if firmware
425 * is in ready state or not after 15 secs.
426 * This is applicable for both 2.x & 3.x firmware
428 if (timeout_count
<= (ADAPTER_INIT_TOV
- 15)) {
429 if (ha
->addl_fw_state
& FW_ADDSTATE_LINK_UP
) {
430 DEBUG2(printk(KERN_INFO
"scsi%ld: %s:"
431 " LINK UP (Cable plugged)\n",
432 ha
->host_no
, __func__
));
433 } else if (ha
->firmware_state
&
434 (FW_STATE_CONFIGURING_IP
|
436 DEBUG2(printk(KERN_INFO
"scsi%ld: %s: "
437 "LINK DOWN (Cable unplugged)\n",
438 ha
->host_no
, __func__
));
439 ha
->firmware_state
= FW_STATE_READY
;
444 if (ha
->firmware_state
== FW_STATE_READY
) {
445 /* If DHCP IP Addr is available, retrieve it now. */
446 if (test_and_clear_bit(DPC_GET_DHCP_IP_ADDR
,
448 qla4xxx_get_dhcp_ip_address(ha
);
450 if (!qla4xxx_wait_for_ip_config(ha
) ||
451 timeout_count
== 1) {
452 DEBUG2(ql4_printk(KERN_INFO
, ha
,
453 "Firmware Ready..\n"));
454 /* The firmware is ready to process SCSI
456 DEBUG2(ql4_printk(KERN_INFO
, ha
,
457 "scsi%ld: %s: MEDIA TYPE"
458 " - %s\n", ha
->host_no
,
459 __func__
, (ha
->addl_fw_state
&
460 FW_ADDSTATE_OPTICAL_MEDIA
)
461 != 0 ? "OPTICAL" : "COPPER"));
462 DEBUG2(ql4_printk(KERN_INFO
, ha
,
463 "scsi%ld: %s: DHCPv4 STATE"
464 " Enabled %s\n", ha
->host_no
,
465 __func__
, (ha
->addl_fw_state
&
466 FW_ADDSTATE_DHCPv4_ENABLED
) != 0 ?
468 DEBUG2(ql4_printk(KERN_INFO
, ha
,
469 "scsi%ld: %s: LINK %s\n",
470 ha
->host_no
, __func__
,
472 FW_ADDSTATE_LINK_UP
) != 0 ?
474 DEBUG2(ql4_printk(KERN_INFO
, ha
,
475 "scsi%ld: %s: iSNS Service "
477 ha
->host_no
, __func__
,
479 FW_ADDSTATE_ISNS_SVC_ENABLED
) != 0 ?
486 DEBUG2(printk("scsi%ld: %s: waiting on fw, state=%x:%x - "
487 "seconds expired= %d\n", ha
->host_no
, __func__
,
488 ha
->firmware_state
, ha
->addl_fw_state
,
490 if (is_qla4032(ha
) &&
491 !(ha
->addl_fw_state
& FW_ADDSTATE_LINK_UP
) &&
492 (timeout_count
< ADAPTER_INIT_TOV
- 5)) {
499 if (timeout_count
<= 0)
500 DEBUG2(printk("scsi%ld: %s: FW Initialization timed out!\n",
501 ha
->host_no
, __func__
));
503 if (ha
->firmware_state
& FW_STATE_CONFIGURING_IP
) {
504 DEBUG2(printk("scsi%ld: %s: FW initialized, but is reporting "
505 "it's waiting to configure an IP address\n",
506 ha
->host_no
, __func__
));
508 } else if (ha
->firmware_state
& FW_STATE_WAIT_AUTOCONNECT
) {
509 DEBUG2(printk("scsi%ld: %s: FW initialized, but "
510 "auto-discovery still in process\n",
511 ha
->host_no
, __func__
));
519 * qla4xxx_init_firmware - initializes the firmware.
520 * @ha: pointer to host adapter structure.
523 static int qla4xxx_init_firmware(struct scsi_qla_host
*ha
)
525 int status
= QLA_ERROR
;
527 if (is_aer_supported(ha
) &&
528 test_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE
, &ha
->flags
))
531 /* For 82xx, stop firmware before initializing because if BIOS
532 * has previously initialized firmware, then driver's initialize
533 * firmware will fail. */
535 qla4_8xxx_stop_firmware(ha
);
537 ql4_printk(KERN_INFO
, ha
, "Initializing firmware..\n");
538 if (qla4xxx_initialize_fw_cb(ha
) == QLA_ERROR
) {
539 DEBUG2(printk("scsi%ld: %s: Failed to initialize firmware "
540 "control block\n", ha
->host_no
, __func__
));
544 if (!qla4xxx_fw_ready(ha
))
547 if (is_qla80XX(ha
) && !test_bit(AF_INIT_DONE
, &ha
->flags
))
548 qla4xxx_alloc_fw_dump(ha
);
550 return qla4xxx_get_firmware_status(ha
);
553 static void qla4xxx_set_model_info(struct scsi_qla_host
*ha
)
555 uint16_t board_id_string
[8];
557 int size
= sizeof(ha
->nvram
->isp4022
.boardIdStr
);
558 int offset
= offsetof(struct eeprom_data
, isp4022
.boardIdStr
) / 2;
560 for (i
= 0; i
< (size
/ 2) ; i
++) {
561 board_id_string
[i
] = rd_nvram_word(ha
, offset
);
565 memcpy(ha
->model_name
, board_id_string
, size
);
568 static int qla4xxx_config_nvram(struct scsi_qla_host
*ha
)
571 union external_hw_config_reg extHwConfig
;
573 DEBUG2(printk("scsi%ld: %s: Get EEProm parameters \n", ha
->host_no
,
575 if (ql4xxx_lock_flash(ha
) != QLA_SUCCESS
)
577 if (ql4xxx_lock_nvram(ha
) != QLA_SUCCESS
) {
578 ql4xxx_unlock_flash(ha
);
582 /* Get EEPRom Parameters from NVRAM and validate */
583 ql4_printk(KERN_INFO
, ha
, "Configuring NVRAM ...\n");
584 if (qla4xxx_is_nvram_configuration_valid(ha
) == QLA_SUCCESS
) {
585 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
586 extHwConfig
.Asuint32_t
=
587 rd_nvram_word(ha
, eeprom_ext_hw_conf_offset(ha
));
588 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
590 ql4_printk(KERN_WARNING
, ha
,
591 "scsi%ld: %s: EEProm checksum invalid. "
592 "Please update your EEPROM\n", ha
->host_no
,
595 /* Attempt to set defaults */
597 extHwConfig
.Asuint32_t
= 0x1912;
598 else if (is_qla4022(ha
) | is_qla4032(ha
))
599 extHwConfig
.Asuint32_t
= 0x0023;
604 if (is_qla4022(ha
) || is_qla4032(ha
))
605 qla4xxx_set_model_info(ha
);
607 strcpy(ha
->model_name
, "QLA4010");
609 DEBUG(printk("scsi%ld: %s: Setting extHwConfig to 0xFFFF%04x\n",
610 ha
->host_no
, __func__
, extHwConfig
.Asuint32_t
));
612 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
613 writel((0xFFFF << 16) | extHwConfig
.Asuint32_t
, isp_ext_hw_conf(ha
));
614 readl(isp_ext_hw_conf(ha
));
615 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
617 ql4xxx_unlock_nvram(ha
);
618 ql4xxx_unlock_flash(ha
);
624 * qla4_8xxx_pci_config() - Setup ISP82xx PCI configuration registers.
627 void qla4_8xxx_pci_config(struct scsi_qla_host
*ha
)
629 pci_set_master(ha
->pdev
);
632 void qla4xxx_pci_config(struct scsi_qla_host
*ha
)
637 ql4_printk(KERN_INFO
, ha
, "Configuring PCI space...\n");
639 pci_set_master(ha
->pdev
);
640 status
= pci_set_mwi(ha
->pdev
);
642 * We want to respect framework's setting of PCI configuration space
643 * command register and also want to make sure that all bits of
644 * interest to us are properly set in command register.
646 pci_read_config_word(ha
->pdev
, PCI_COMMAND
, &w
);
647 w
|= PCI_COMMAND_PARITY
| PCI_COMMAND_SERR
;
648 w
&= ~PCI_COMMAND_INTX_DISABLE
;
649 pci_write_config_word(ha
->pdev
, PCI_COMMAND
, w
);
652 static int qla4xxx_start_firmware_from_flash(struct scsi_qla_host
*ha
)
654 int status
= QLA_ERROR
;
655 unsigned long max_wait_time
;
657 uint32_t mbox_status
;
659 ql4_printk(KERN_INFO
, ha
, "Starting firmware ...\n");
662 * Start firmware from flash ROM
664 * WORKAROUND: Stuff a non-constant value that the firmware can
665 * use as a seed for a random number generator in MB7 prior to
666 * setting BOOT_ENABLE. Fixes problem where the TCP
667 * connections use the same TCP ports after each reboot,
668 * causing some connections to not get re-established.
670 DEBUG(printk("scsi%d: %s: Start firmware from flash ROM\n",
671 ha
->host_no
, __func__
));
673 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
674 writel(jiffies
, &ha
->reg
->mailbox
[7]);
675 if (is_qla4022(ha
) | is_qla4032(ha
))
676 writel(set_rmask(NVR_WRITE_ENABLE
),
677 &ha
->reg
->u1
.isp4022
.nvram
);
679 writel(2, &ha
->reg
->mailbox
[6]);
680 readl(&ha
->reg
->mailbox
[6]);
682 writel(set_rmask(CSR_BOOT_ENABLE
), &ha
->reg
->ctrl_status
);
683 readl(&ha
->reg
->ctrl_status
);
684 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
686 /* Wait for firmware to come UP. */
687 DEBUG2(printk(KERN_INFO
"scsi%ld: %s: Wait up to %d seconds for "
688 "boot firmware to complete...\n",
689 ha
->host_no
, __func__
, FIRMWARE_UP_TOV
));
690 max_wait_time
= jiffies
+ (FIRMWARE_UP_TOV
* HZ
);
692 uint32_t ctrl_status
;
694 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
695 ctrl_status
= readw(&ha
->reg
->ctrl_status
);
696 mbox_status
= readw(&ha
->reg
->mailbox
[0]);
697 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
699 if (ctrl_status
& set_rmask(CSR_SCSI_PROCESSOR_INTR
))
701 if (mbox_status
== MBOX_STS_COMMAND_COMPLETE
)
704 DEBUG2(printk(KERN_INFO
"scsi%ld: %s: Waiting for boot "
705 "firmware to complete... ctrl_sts=0x%x, remaining=%ld\n",
706 ha
->host_no
, __func__
, ctrl_status
, max_wait_time
));
708 msleep_interruptible(250);
709 } while (!time_after_eq(jiffies
, max_wait_time
));
711 if (mbox_status
== MBOX_STS_COMMAND_COMPLETE
) {
712 DEBUG(printk(KERN_INFO
"scsi%ld: %s: Firmware has started\n",
713 ha
->host_no
, __func__
));
715 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
716 writel(set_rmask(CSR_SCSI_PROCESSOR_INTR
),
717 &ha
->reg
->ctrl_status
);
718 readl(&ha
->reg
->ctrl_status
);
719 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
721 status
= QLA_SUCCESS
;
723 printk(KERN_INFO
"scsi%ld: %s: Boot firmware failed "
724 "- mbox status 0x%x\n", ha
->host_no
, __func__
,
731 int ql4xxx_lock_drvr_wait(struct scsi_qla_host
*a
)
733 #define QL4_LOCK_DRVR_WAIT 60
734 #define QL4_LOCK_DRVR_SLEEP 1
736 int drvr_wait
= QL4_LOCK_DRVR_WAIT
;
738 if (ql4xxx_lock_drvr(a
) == 0) {
739 ssleep(QL4_LOCK_DRVR_SLEEP
);
741 DEBUG2(printk("scsi%ld: %s: Waiting for "
742 "Global Init Semaphore(%d)...\n",
744 __func__
, drvr_wait
));
746 drvr_wait
-= QL4_LOCK_DRVR_SLEEP
;
748 DEBUG2(printk("scsi%ld: %s: Global Init Semaphore "
749 "acquired\n", a
->host_no
, __func__
));
757 * qla4xxx_start_firmware - starts qla4xxx firmware
758 * @ha: Pointer to host adapter structure.
760 * This routine performs the necessary steps to start the firmware for
761 * the QLA4010 adapter.
763 int qla4xxx_start_firmware(struct scsi_qla_host
*ha
)
765 unsigned long flags
= 0;
766 uint32_t mbox_status
;
767 int status
= QLA_ERROR
;
771 if (is_qla4022(ha
) | is_qla4032(ha
))
772 ql4xxx_set_mac_number(ha
);
774 if (ql4xxx_lock_drvr_wait(ha
) != QLA_SUCCESS
)
777 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
779 DEBUG2(printk("scsi%ld: %s: port_ctrl = 0x%08X\n", ha
->host_no
,
780 __func__
, readw(isp_port_ctrl(ha
))));
781 DEBUG(printk("scsi%ld: %s: port_status = 0x%08X\n", ha
->host_no
,
782 __func__
, readw(isp_port_status(ha
))));
784 /* Is Hardware already initialized? */
785 if ((readw(isp_port_ctrl(ha
)) & 0x8000) != 0) {
786 DEBUG(printk("scsi%ld: %s: Hardware has already been "
787 "initialized\n", ha
->host_no
, __func__
));
789 /* Receive firmware boot acknowledgement */
790 mbox_status
= readw(&ha
->reg
->mailbox
[0]);
792 DEBUG2(printk("scsi%ld: %s: H/W Config complete - mbox[0]= "
793 "0x%x\n", ha
->host_no
, __func__
, mbox_status
));
795 /* Is firmware already booted? */
796 if (mbox_status
== 0) {
797 /* F/W not running, must be config by net driver */
801 writel(set_rmask(CSR_SCSI_PROCESSOR_INTR
),
802 &ha
->reg
->ctrl_status
);
803 readl(&ha
->reg
->ctrl_status
);
804 writel(set_rmask(CSR_SCSI_COMPLETION_INTR
),
805 &ha
->reg
->ctrl_status
);
806 readl(&ha
->reg
->ctrl_status
);
807 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
808 if (qla4xxx_get_firmware_state(ha
) == QLA_SUCCESS
) {
809 DEBUG2(printk("scsi%ld: %s: Get firmware "
810 "state -- state = 0x%x\n",
812 __func__
, ha
->firmware_state
));
814 if (ha
->firmware_state
&
815 FW_STATE_CONFIG_WAIT
) {
816 DEBUG2(printk("scsi%ld: %s: Firmware "
819 "boot, state = 0x%x\n",
820 ha
->host_no
, __func__
,
821 ha
->firmware_state
));
826 DEBUG2(printk("scsi%ld: %s: Firmware in "
827 "unknown state -- resetting,"
829 "0x%x\n", ha
->host_no
, __func__
,
830 ha
->firmware_state
));
832 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
835 DEBUG(printk("scsi%ld: %s: H/W initialization hasn't been "
836 "started - resetting\n", ha
->host_no
, __func__
));
838 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
840 DEBUG(printk("scsi%ld: %s: Flags soft_rest=%d, config= %d\n ",
841 ha
->host_no
, __func__
, soft_reset
, config_chip
));
843 DEBUG(printk("scsi%ld: %s: Issue Soft Reset\n", ha
->host_no
,
845 status
= qla4xxx_soft_reset(ha
); /* NOTE: acquires drvr
846 * lock again, but ok */
847 if (status
== QLA_ERROR
) {
848 DEBUG(printk("scsi%d: %s: Soft Reset failed!\n",
849 ha
->host_no
, __func__
));
850 ql4xxx_unlock_drvr(ha
);
855 /* Reset clears the semaphore, so acquire again */
856 if (ql4xxx_lock_drvr_wait(ha
) != QLA_SUCCESS
)
861 if ((status
= qla4xxx_config_nvram(ha
)) == QLA_SUCCESS
)
862 status
= qla4xxx_start_firmware_from_flash(ha
);
865 ql4xxx_unlock_drvr(ha
);
866 if (status
== QLA_SUCCESS
) {
867 if (test_and_clear_bit(AF_GET_CRASH_RECORD
, &ha
->flags
))
868 qla4xxx_get_crash_record(ha
);
870 DEBUG(printk("scsi%ld: %s: Firmware has NOT started\n",
871 ha
->host_no
, __func__
));
876 * qla4xxx_free_ddb_index - Free DDBs reserved by firmware
877 * @ha: pointer to adapter structure
879 * Since firmware is not running in autoconnect mode the DDB indices should
880 * be freed so that when login happens from user space there are free DDB
883 void qla4xxx_free_ddb_index(struct scsi_qla_host
*ha
)
887 uint32_t idx
= 0, next_idx
= 0;
888 uint32_t state
= 0, conn_err
= 0;
890 max_ddbs
= is_qla40XX(ha
) ? MAX_DEV_DB_ENTRIES_40XX
:
893 for (idx
= 0; idx
< max_ddbs
; idx
= next_idx
) {
894 ret
= qla4xxx_get_fwddb_entry(ha
, idx
, NULL
, 0, NULL
,
895 &next_idx
, &state
, &conn_err
,
897 if (ret
== QLA_ERROR
) {
901 if (state
== DDB_DS_NO_CONNECTION_ACTIVE
||
902 state
== DDB_DS_SESSION_FAILED
) {
903 DEBUG2(ql4_printk(KERN_INFO
, ha
,
904 "Freeing DDB index = 0x%x\n", idx
));
905 ret
= qla4xxx_clear_ddb_entry(ha
, idx
);
906 if (ret
== QLA_ERROR
)
907 ql4_printk(KERN_ERR
, ha
,
908 "Unable to clear DDB index = "
917 * qla4xxx_initialize_adapter - initiailizes hba
918 * @ha: Pointer to host adapter structure.
920 * This routine parforms all of the steps necessary to initialize the adapter.
923 int qla4xxx_initialize_adapter(struct scsi_qla_host
*ha
, int is_reset
)
925 int status
= QLA_ERROR
;
927 ha
->eeprom_cmd_data
= 0;
929 ql4_printk(KERN_INFO
, ha
, "Configuring PCI space...\n");
930 ha
->isp_ops
->pci_config(ha
);
932 ha
->isp_ops
->disable_intrs(ha
);
934 /* Initialize the Host adapter request/response queues and firmware */
935 if (ha
->isp_ops
->start_firmware(ha
) == QLA_ERROR
)
939 * For ISP83XX, mailbox and IOCB interrupts are enabled separately.
940 * Mailbox interrupts must be enabled prior to issuing any mailbox
941 * command in order to prevent the possibility of losing interrupts
942 * while switching from polling to interrupt mode. IOCB interrupts are
943 * enabled via isp_ops->enable_intrs.
946 qla4_83xx_enable_mbox_intrs(ha
);
948 if (qla4xxx_about_firmware(ha
) == QLA_ERROR
)
951 if (ha
->isp_ops
->get_sys_info(ha
) == QLA_ERROR
)
954 if (qla4xxx_init_local_data(ha
) == QLA_ERROR
)
957 status
= qla4xxx_init_firmware(ha
);
958 if (status
== QLA_ERROR
)
961 if (is_reset
== RESET_ADAPTER
)
962 qla4xxx_build_ddb_list(ha
, is_reset
);
964 set_bit(AF_ONLINE
, &ha
->flags
);
966 if (is_qla80XX(ha
) && (status
== QLA_ERROR
)) {
967 /* Since interrupts are registered in start_firmware for
968 * 80XX, release them here if initialize_adapter fails */
969 qla4xxx_free_irqs(ha
);
972 DEBUG2(printk("scsi%ld: initialize adapter: %s\n", ha
->host_no
,
973 status
== QLA_ERROR
? "FAILED" : "SUCCEEDED"));
977 int qla4xxx_ddb_change(struct scsi_qla_host
*ha
, uint32_t fw_ddb_index
,
978 struct ddb_entry
*ddb_entry
, uint32_t state
)
980 uint32_t old_fw_ddb_device_state
;
981 int status
= QLA_ERROR
;
983 old_fw_ddb_device_state
= ddb_entry
->fw_ddb_device_state
;
984 DEBUG2(ql4_printk(KERN_INFO
, ha
,
985 "%s: DDB - old state = 0x%x, new state = 0x%x for "
986 "index [%d]\n", __func__
,
987 ddb_entry
->fw_ddb_device_state
, state
, fw_ddb_index
));
989 ddb_entry
->fw_ddb_device_state
= state
;
991 switch (old_fw_ddb_device_state
) {
992 case DDB_DS_LOGIN_IN_PROCESS
:
994 case DDB_DS_SESSION_ACTIVE
:
995 case DDB_DS_DISCOVERY
:
996 qla4xxx_update_session_conn_param(ha
, ddb_entry
);
997 ddb_entry
->unblock_sess(ddb_entry
->sess
);
998 status
= QLA_SUCCESS
;
1000 case DDB_DS_SESSION_FAILED
:
1001 case DDB_DS_NO_CONNECTION_ACTIVE
:
1002 iscsi_conn_login_event(ddb_entry
->conn
,
1003 ISCSI_CONN_STATE_FREE
);
1004 status
= QLA_SUCCESS
;
1008 case DDB_DS_SESSION_ACTIVE
:
1009 case DDB_DS_DISCOVERY
:
1011 case DDB_DS_SESSION_FAILED
:
1013 * iscsi_session failure will cause userspace to
1014 * stop the connection which in turn would block the
1015 * iscsi_session and start relogin
1017 iscsi_session_failure(ddb_entry
->sess
->dd_data
,
1018 ISCSI_ERR_CONN_FAILED
);
1019 status
= QLA_SUCCESS
;
1021 case DDB_DS_NO_CONNECTION_ACTIVE
:
1022 clear_bit(fw_ddb_index
, ha
->ddb_idx_map
);
1023 status
= QLA_SUCCESS
;
1027 case DDB_DS_SESSION_FAILED
:
1029 case DDB_DS_SESSION_ACTIVE
:
1030 case DDB_DS_DISCOVERY
:
1031 ddb_entry
->unblock_sess(ddb_entry
->sess
);
1032 qla4xxx_update_session_conn_param(ha
, ddb_entry
);
1033 status
= QLA_SUCCESS
;
1035 case DDB_DS_SESSION_FAILED
:
1036 iscsi_session_failure(ddb_entry
->sess
->dd_data
,
1037 ISCSI_ERR_CONN_FAILED
);
1038 status
= QLA_SUCCESS
;
1043 DEBUG2(ql4_printk(KERN_INFO
, ha
, "%s: Unknown Event\n",
1050 void qla4xxx_arm_relogin_timer(struct ddb_entry
*ddb_entry
)
1053 * This triggers a relogin. After the relogin_timer
1054 * expires, the relogin gets scheduled. We must wait a
1055 * minimum amount of time since receiving an 0x8014 AEN
1056 * with failed device_state or a logout response before
1057 * we can issue another relogin.
1059 * Firmware pads this timeout: (time2wait +1).
1060 * Driver retry to login should be longer than F/W.
1061 * Otherwise F/W will fail
1062 * set_ddb() mbx cmd with 0x4005 since it still
1063 * counting down its time2wait.
1065 atomic_set(&ddb_entry
->relogin_timer
, 0);
1066 atomic_set(&ddb_entry
->retry_relogin_timer
,
1067 ddb_entry
->default_time2wait
+ 4);
1071 int qla4xxx_flash_ddb_change(struct scsi_qla_host
*ha
, uint32_t fw_ddb_index
,
1072 struct ddb_entry
*ddb_entry
, uint32_t state
)
1074 uint32_t old_fw_ddb_device_state
;
1075 int status
= QLA_ERROR
;
1077 old_fw_ddb_device_state
= ddb_entry
->fw_ddb_device_state
;
1078 DEBUG2(ql4_printk(KERN_INFO
, ha
,
1079 "%s: DDB - old state = 0x%x, new state = 0x%x for "
1080 "index [%d]\n", __func__
,
1081 ddb_entry
->fw_ddb_device_state
, state
, fw_ddb_index
));
1083 ddb_entry
->fw_ddb_device_state
= state
;
1085 switch (old_fw_ddb_device_state
) {
1086 case DDB_DS_LOGIN_IN_PROCESS
:
1087 case DDB_DS_NO_CONNECTION_ACTIVE
:
1089 case DDB_DS_SESSION_ACTIVE
:
1090 ddb_entry
->unblock_sess(ddb_entry
->sess
);
1091 qla4xxx_update_session_conn_fwddb_param(ha
, ddb_entry
);
1092 status
= QLA_SUCCESS
;
1094 case DDB_DS_SESSION_FAILED
:
1095 iscsi_block_session(ddb_entry
->sess
);
1096 if (!test_bit(DF_RELOGIN
, &ddb_entry
->flags
))
1097 qla4xxx_arm_relogin_timer(ddb_entry
);
1098 status
= QLA_SUCCESS
;
1102 case DDB_DS_SESSION_ACTIVE
:
1104 case DDB_DS_SESSION_FAILED
:
1105 iscsi_block_session(ddb_entry
->sess
);
1106 if (!test_bit(DF_RELOGIN
, &ddb_entry
->flags
))
1107 qla4xxx_arm_relogin_timer(ddb_entry
);
1108 status
= QLA_SUCCESS
;
1112 case DDB_DS_SESSION_FAILED
:
1114 case DDB_DS_SESSION_ACTIVE
:
1115 ddb_entry
->unblock_sess(ddb_entry
->sess
);
1116 qla4xxx_update_session_conn_fwddb_param(ha
, ddb_entry
);
1117 status
= QLA_SUCCESS
;
1119 case DDB_DS_SESSION_FAILED
:
1120 if (!test_bit(DF_RELOGIN
, &ddb_entry
->flags
))
1121 qla4xxx_arm_relogin_timer(ddb_entry
);
1122 status
= QLA_SUCCESS
;
1127 DEBUG2(ql4_printk(KERN_INFO
, ha
, "%s: Unknown Event\n",
1135 * qla4xxx_process_ddb_changed - process ddb state change
1136 * @ha - Pointer to host adapter structure.
1137 * @fw_ddb_index - Firmware's device database index
1138 * @state - Device state
1140 * This routine processes a Decive Database Changed AEN Event.
1142 int qla4xxx_process_ddb_changed(struct scsi_qla_host
*ha
,
1143 uint32_t fw_ddb_index
,
1144 uint32_t state
, uint32_t conn_err
)
1146 struct ddb_entry
*ddb_entry
;
1147 int status
= QLA_ERROR
;
1149 /* check for out of range index */
1150 if (fw_ddb_index
>= MAX_DDB_ENTRIES
)
1151 goto exit_ddb_event
;
1153 /* Get the corresponging ddb entry */
1154 ddb_entry
= qla4xxx_lookup_ddb_by_fw_index(ha
, fw_ddb_index
);
1155 /* Device does not currently exist in our database. */
1156 if (ddb_entry
== NULL
) {
1157 ql4_printk(KERN_ERR
, ha
, "%s: No ddb_entry at FW index [%d]\n",
1158 __func__
, fw_ddb_index
);
1160 if (state
== DDB_DS_NO_CONNECTION_ACTIVE
)
1161 clear_bit(fw_ddb_index
, ha
->ddb_idx_map
);
1163 goto exit_ddb_event
;
1166 ddb_entry
->ddb_change(ha
, fw_ddb_index
, ddb_entry
, state
);
1173 * qla4xxx_login_flash_ddb - Login to target (DDB)
1174 * @cls_session: Pointer to the session to login
1176 * This routine logins to the target.
1177 * Issues setddb and conn open mbx
1179 void qla4xxx_login_flash_ddb(struct iscsi_cls_session
*cls_session
)
1181 struct iscsi_session
*sess
;
1182 struct ddb_entry
*ddb_entry
;
1183 struct scsi_qla_host
*ha
;
1184 struct dev_db_entry
*fw_ddb_entry
= NULL
;
1185 dma_addr_t fw_ddb_dma
;
1186 uint32_t mbx_sts
= 0;
1189 sess
= cls_session
->dd_data
;
1190 ddb_entry
= sess
->dd_data
;
1193 if (!test_bit(AF_LINK_UP
, &ha
->flags
))
1196 if (ddb_entry
->ddb_type
!= FLASH_DDB
) {
1197 DEBUG2(ql4_printk(KERN_INFO
, ha
,
1198 "Skipping login to non FLASH DB"));
1202 fw_ddb_entry
= dma_pool_alloc(ha
->fw_ddb_dma_pool
, GFP_KERNEL
,
1204 if (fw_ddb_entry
== NULL
) {
1205 DEBUG2(ql4_printk(KERN_ERR
, ha
, "Out of memory\n"));
1209 if (ddb_entry
->fw_ddb_index
== INVALID_ENTRY
) {
1210 ret
= qla4xxx_get_ddb_index(ha
, &ddb_entry
->fw_ddb_index
);
1211 if (ret
== QLA_ERROR
)
1214 ha
->fw_ddb_index_map
[ddb_entry
->fw_ddb_index
] = ddb_entry
;
1218 memcpy(fw_ddb_entry
, &ddb_entry
->fw_ddb_entry
,
1219 sizeof(struct dev_db_entry
));
1220 ddb_entry
->sess
->target_id
= ddb_entry
->fw_ddb_index
;
1222 ret
= qla4xxx_set_ddb_entry(ha
, ddb_entry
->fw_ddb_index
,
1223 fw_ddb_dma
, &mbx_sts
);
1224 if (ret
== QLA_ERROR
) {
1225 DEBUG2(ql4_printk(KERN_ERR
, ha
, "Set DDB failed\n"));
1229 ddb_entry
->fw_ddb_device_state
= DDB_DS_LOGIN_IN_PROCESS
;
1230 ret
= qla4xxx_conn_open(ha
, ddb_entry
->fw_ddb_index
);
1231 if (ret
== QLA_ERROR
) {
1232 ql4_printk(KERN_ERR
, ha
, "%s: Login failed: %s\n", __func__
,
1239 dma_pool_free(ha
->fw_ddb_dma_pool
, fw_ddb_entry
, fw_ddb_dma
);