2 * QLogic Fibre Channel HBA Driver
3 * Copyright (c) 2003-2008 QLogic Corporation
5 * See LICENSE.qla2xxx for copyright and licensing details.
9 #include <linux/delay.h>
10 #include <linux/vmalloc.h>
12 #include "qla_devtbl.h"
19 * QLogic ISP2x00 Hardware Support Function Prototypes.
21 static int qla2x00_isp_firmware(scsi_qla_host_t
*);
22 static void qla2x00_resize_request_q(scsi_qla_host_t
*);
23 static int qla2x00_setup_chip(scsi_qla_host_t
*);
24 static void qla2x00_init_response_q_entries(scsi_qla_host_t
*);
25 static int qla2x00_init_rings(scsi_qla_host_t
*);
26 static int qla2x00_fw_ready(scsi_qla_host_t
*);
27 static int qla2x00_configure_hba(scsi_qla_host_t
*);
28 static int qla2x00_configure_loop(scsi_qla_host_t
*);
29 static int qla2x00_configure_local_loop(scsi_qla_host_t
*);
30 static int qla2x00_configure_fabric(scsi_qla_host_t
*);
31 static int qla2x00_find_all_fabric_devs(scsi_qla_host_t
*, struct list_head
*);
32 static int qla2x00_device_resync(scsi_qla_host_t
*);
33 static int qla2x00_fabric_dev_login(scsi_qla_host_t
*, fc_port_t
*,
36 static int qla2x00_restart_isp(scsi_qla_host_t
*);
38 static int qla2x00_find_new_loop_id(scsi_qla_host_t
*ha
, fc_port_t
*dev
);
40 static struct qla_chip_state_84xx
*qla84xx_get_chip(struct scsi_qla_host
*);
41 static int qla84xx_init_chip(scsi_qla_host_t
*);
43 /****************************************************************************/
44 /* QLogic ISP2x00 Hardware Support Functions. */
45 /****************************************************************************/
48 * qla2x00_initialize_adapter
52 * ha = adapter block pointer.
58 qla2x00_initialize_adapter(scsi_qla_host_t
*ha
)
62 /* Clear adapter flags. */
64 ha
->flags
.reset_active
= 0;
65 atomic_set(&ha
->loop_down_timer
, LOOP_DOWN_TIME
);
66 atomic_set(&ha
->loop_state
, LOOP_DOWN
);
67 ha
->device_flags
= DFLG_NO_CABLE
;
69 ha
->flags
.management_server_logged_in
= 0;
70 ha
->marker_needed
= 0;
72 ha
->isp_abort_cnt
= 0;
73 ha
->beacon_blink_led
= 0;
74 set_bit(REGISTER_FDMI_NEEDED
, &ha
->dpc_flags
);
76 qla_printk(KERN_INFO
, ha
, "Configuring PCI space...\n");
77 rval
= ha
->isp_ops
->pci_config(ha
);
79 DEBUG2(printk("scsi(%ld): Unable to configure PCI space.\n",
84 ha
->isp_ops
->reset_chip(ha
);
86 rval
= qla2xxx_get_flash_info(ha
);
88 DEBUG2(printk("scsi(%ld): Unable to validate FLASH data.\n",
93 ha
->isp_ops
->get_flash_version(ha
, ha
->request_ring
);
95 qla_printk(KERN_INFO
, ha
, "Configure NVRAM parameters...\n");
97 ha
->isp_ops
->nvram_config(ha
);
99 if (ha
->flags
.disable_serdes
) {
100 /* Mask HBA via NVRAM settings? */
101 qla_printk(KERN_INFO
, ha
, "Masking HBA WWPN "
102 "%02x%02x%02x%02x%02x%02x%02x%02x (via NVRAM).\n",
103 ha
->port_name
[0], ha
->port_name
[1],
104 ha
->port_name
[2], ha
->port_name
[3],
105 ha
->port_name
[4], ha
->port_name
[5],
106 ha
->port_name
[6], ha
->port_name
[7]);
107 return QLA_FUNCTION_FAILED
;
110 qla_printk(KERN_INFO
, ha
, "Verifying loaded RISC code...\n");
112 if (qla2x00_isp_firmware(ha
) != QLA_SUCCESS
) {
113 rval
= ha
->isp_ops
->chip_diag(ha
);
116 rval
= qla2x00_setup_chip(ha
);
120 if (IS_QLA84XX(ha
)) {
121 ha
->cs84xx
= qla84xx_get_chip(ha
);
123 qla_printk(KERN_ERR
, ha
,
124 "Unable to configure ISP84XX.\n");
125 return QLA_FUNCTION_FAILED
;
128 rval
= qla2x00_init_rings(ha
);
134 * qla2100_pci_config() - Setup ISP21xx PCI configuration registers.
137 * Returns 0 on success.
140 qla2100_pci_config(scsi_qla_host_t
*ha
)
144 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
146 pci_set_master(ha
->pdev
);
147 pci_try_set_mwi(ha
->pdev
);
149 pci_read_config_word(ha
->pdev
, PCI_COMMAND
, &w
);
150 w
|= (PCI_COMMAND_PARITY
| PCI_COMMAND_SERR
);
151 pci_write_config_word(ha
->pdev
, PCI_COMMAND
, w
);
153 pci_disable_rom(ha
->pdev
);
155 /* Get PCI bus information. */
156 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
157 ha
->pci_attr
= RD_REG_WORD(®
->ctrl_status
);
158 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
164 * qla2300_pci_config() - Setup ISP23xx PCI configuration registers.
167 * Returns 0 on success.
170 qla2300_pci_config(scsi_qla_host_t
*ha
)
173 unsigned long flags
= 0;
175 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
177 pci_set_master(ha
->pdev
);
178 pci_try_set_mwi(ha
->pdev
);
180 pci_read_config_word(ha
->pdev
, PCI_COMMAND
, &w
);
181 w
|= (PCI_COMMAND_PARITY
| PCI_COMMAND_SERR
);
183 if (IS_QLA2322(ha
) || IS_QLA6322(ha
))
184 w
&= ~PCI_COMMAND_INTX_DISABLE
;
185 pci_write_config_word(ha
->pdev
, PCI_COMMAND
, w
);
188 * If this is a 2300 card and not 2312, reset the
189 * COMMAND_INVALIDATE due to a bug in the 2300. Unfortunately,
190 * the 2310 also reports itself as a 2300 so we need to get the
191 * fb revision level -- a 6 indicates it really is a 2300 and
194 if (IS_QLA2300(ha
)) {
195 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
198 WRT_REG_WORD(®
->hccr
, HCCR_PAUSE_RISC
);
199 for (cnt
= 0; cnt
< 30000; cnt
++) {
200 if ((RD_REG_WORD(®
->hccr
) & HCCR_RISC_PAUSE
) != 0)
206 /* Select FPM registers. */
207 WRT_REG_WORD(®
->ctrl_status
, 0x20);
208 RD_REG_WORD(®
->ctrl_status
);
210 /* Get the fb rev level */
211 ha
->fb_rev
= RD_FB_CMD_REG(ha
, reg
);
213 if (ha
->fb_rev
== FPM_2300
)
214 pci_clear_mwi(ha
->pdev
);
216 /* Deselect FPM registers. */
217 WRT_REG_WORD(®
->ctrl_status
, 0x0);
218 RD_REG_WORD(®
->ctrl_status
);
220 /* Release RISC module. */
221 WRT_REG_WORD(®
->hccr
, HCCR_RELEASE_RISC
);
222 for (cnt
= 0; cnt
< 30000; cnt
++) {
223 if ((RD_REG_WORD(®
->hccr
) & HCCR_RISC_PAUSE
) == 0)
229 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
232 pci_write_config_byte(ha
->pdev
, PCI_LATENCY_TIMER
, 0x80);
234 pci_disable_rom(ha
->pdev
);
236 /* Get PCI bus information. */
237 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
238 ha
->pci_attr
= RD_REG_WORD(®
->ctrl_status
);
239 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
245 * qla24xx_pci_config() - Setup ISP24xx PCI configuration registers.
248 * Returns 0 on success.
251 qla24xx_pci_config(scsi_qla_host_t
*ha
)
254 unsigned long flags
= 0;
255 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
257 pci_set_master(ha
->pdev
);
258 pci_try_set_mwi(ha
->pdev
);
260 pci_read_config_word(ha
->pdev
, PCI_COMMAND
, &w
);
261 w
|= (PCI_COMMAND_PARITY
| PCI_COMMAND_SERR
);
262 w
&= ~PCI_COMMAND_INTX_DISABLE
;
263 pci_write_config_word(ha
->pdev
, PCI_COMMAND
, w
);
265 pci_write_config_byte(ha
->pdev
, PCI_LATENCY_TIMER
, 0x80);
267 /* PCI-X -- adjust Maximum Memory Read Byte Count (2048). */
268 if (pci_find_capability(ha
->pdev
, PCI_CAP_ID_PCIX
))
269 pcix_set_mmrbc(ha
->pdev
, 2048);
271 /* PCIe -- adjust Maximum Read Request Size (2048). */
272 if (pci_find_capability(ha
->pdev
, PCI_CAP_ID_EXP
))
273 pcie_set_readrq(ha
->pdev
, 2048);
275 pci_disable_rom(ha
->pdev
);
277 ha
->chip_revision
= ha
->pdev
->revision
;
279 /* Get PCI bus information. */
280 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
281 ha
->pci_attr
= RD_REG_DWORD(®
->ctrl_status
);
282 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
288 * qla25xx_pci_config() - Setup ISP25xx PCI configuration registers.
291 * Returns 0 on success.
294 qla25xx_pci_config(scsi_qla_host_t
*ha
)
298 pci_set_master(ha
->pdev
);
299 pci_try_set_mwi(ha
->pdev
);
301 pci_read_config_word(ha
->pdev
, PCI_COMMAND
, &w
);
302 w
|= (PCI_COMMAND_PARITY
| PCI_COMMAND_SERR
);
303 w
&= ~PCI_COMMAND_INTX_DISABLE
;
304 pci_write_config_word(ha
->pdev
, PCI_COMMAND
, w
);
306 /* PCIe -- adjust Maximum Read Request Size (2048). */
307 if (pci_find_capability(ha
->pdev
, PCI_CAP_ID_EXP
))
308 pcie_set_readrq(ha
->pdev
, 2048);
310 pci_disable_rom(ha
->pdev
);
312 ha
->chip_revision
= ha
->pdev
->revision
;
318 * qla2x00_isp_firmware() - Choose firmware image.
321 * Returns 0 on success.
324 qla2x00_isp_firmware(scsi_qla_host_t
*ha
)
327 uint16_t loop_id
, topo
, sw_cap
;
328 uint8_t domain
, area
, al_pa
;
330 /* Assume loading risc code */
331 rval
= QLA_FUNCTION_FAILED
;
333 if (ha
->flags
.disable_risc_code_load
) {
334 DEBUG2(printk("scsi(%ld): RISC CODE NOT loaded\n",
336 qla_printk(KERN_INFO
, ha
, "RISC CODE NOT loaded\n");
338 /* Verify checksum of loaded RISC code. */
339 rval
= qla2x00_verify_checksum(ha
, ha
->fw_srisc_address
);
340 if (rval
== QLA_SUCCESS
) {
341 /* And, verify we are not in ROM code. */
342 rval
= qla2x00_get_adapter_id(ha
, &loop_id
, &al_pa
,
343 &area
, &domain
, &topo
, &sw_cap
);
348 DEBUG2_3(printk("scsi(%ld): **** Load RISC code ****\n",
356 * qla2x00_reset_chip() - Reset ISP chip.
359 * Returns 0 on success.
362 qla2x00_reset_chip(scsi_qla_host_t
*ha
)
364 unsigned long flags
= 0;
365 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
369 ha
->isp_ops
->disable_intrs(ha
);
371 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
373 /* Turn off master enable */
375 pci_read_config_word(ha
->pdev
, PCI_COMMAND
, &cmd
);
376 cmd
&= ~PCI_COMMAND_MASTER
;
377 pci_write_config_word(ha
->pdev
, PCI_COMMAND
, cmd
);
379 if (!IS_QLA2100(ha
)) {
381 WRT_REG_WORD(®
->hccr
, HCCR_PAUSE_RISC
);
382 if (IS_QLA2200(ha
) || IS_QLA2300(ha
)) {
383 for (cnt
= 0; cnt
< 30000; cnt
++) {
384 if ((RD_REG_WORD(®
->hccr
) &
385 HCCR_RISC_PAUSE
) != 0)
390 RD_REG_WORD(®
->hccr
); /* PCI Posting. */
394 /* Select FPM registers. */
395 WRT_REG_WORD(®
->ctrl_status
, 0x20);
396 RD_REG_WORD(®
->ctrl_status
); /* PCI Posting. */
398 /* FPM Soft Reset. */
399 WRT_REG_WORD(®
->fpm_diag_config
, 0x100);
400 RD_REG_WORD(®
->fpm_diag_config
); /* PCI Posting. */
402 /* Toggle Fpm Reset. */
403 if (!IS_QLA2200(ha
)) {
404 WRT_REG_WORD(®
->fpm_diag_config
, 0x0);
405 RD_REG_WORD(®
->fpm_diag_config
); /* PCI Posting. */
408 /* Select frame buffer registers. */
409 WRT_REG_WORD(®
->ctrl_status
, 0x10);
410 RD_REG_WORD(®
->ctrl_status
); /* PCI Posting. */
412 /* Reset frame buffer FIFOs. */
413 if (IS_QLA2200(ha
)) {
414 WRT_FB_CMD_REG(ha
, reg
, 0xa000);
415 RD_FB_CMD_REG(ha
, reg
); /* PCI Posting. */
417 WRT_FB_CMD_REG(ha
, reg
, 0x00fc);
419 /* Read back fb_cmd until zero or 3 seconds max */
420 for (cnt
= 0; cnt
< 3000; cnt
++) {
421 if ((RD_FB_CMD_REG(ha
, reg
) & 0xff) == 0)
427 /* Select RISC module registers. */
428 WRT_REG_WORD(®
->ctrl_status
, 0);
429 RD_REG_WORD(®
->ctrl_status
); /* PCI Posting. */
431 /* Reset RISC processor. */
432 WRT_REG_WORD(®
->hccr
, HCCR_RESET_RISC
);
433 RD_REG_WORD(®
->hccr
); /* PCI Posting. */
435 /* Release RISC processor. */
436 WRT_REG_WORD(®
->hccr
, HCCR_RELEASE_RISC
);
437 RD_REG_WORD(®
->hccr
); /* PCI Posting. */
440 WRT_REG_WORD(®
->hccr
, HCCR_CLR_RISC_INT
);
441 WRT_REG_WORD(®
->hccr
, HCCR_CLR_HOST_INT
);
443 /* Reset ISP chip. */
444 WRT_REG_WORD(®
->ctrl_status
, CSR_ISP_SOFT_RESET
);
446 /* Wait for RISC to recover from reset. */
447 if (IS_QLA2100(ha
) || IS_QLA2200(ha
) || IS_QLA2300(ha
)) {
449 * It is necessary to for a delay here since the card doesn't
450 * respond to PCI reads during a reset. On some architectures
451 * this will result in an MCA.
454 for (cnt
= 30000; cnt
; cnt
--) {
455 if ((RD_REG_WORD(®
->ctrl_status
) &
456 CSR_ISP_SOFT_RESET
) == 0)
463 /* Reset RISC processor. */
464 WRT_REG_WORD(®
->hccr
, HCCR_RESET_RISC
);
466 WRT_REG_WORD(®
->semaphore
, 0);
468 /* Release RISC processor. */
469 WRT_REG_WORD(®
->hccr
, HCCR_RELEASE_RISC
);
470 RD_REG_WORD(®
->hccr
); /* PCI Posting. */
472 if (IS_QLA2100(ha
) || IS_QLA2200(ha
) || IS_QLA2300(ha
)) {
473 for (cnt
= 0; cnt
< 30000; cnt
++) {
474 if (RD_MAILBOX_REG(ha
, reg
, 0) != MBS_BUSY
)
482 /* Turn on master enable */
483 cmd
|= PCI_COMMAND_MASTER
;
484 pci_write_config_word(ha
->pdev
, PCI_COMMAND
, cmd
);
486 /* Disable RISC pause on FPM parity error. */
487 if (!IS_QLA2100(ha
)) {
488 WRT_REG_WORD(®
->hccr
, HCCR_DISABLE_PARITY_PAUSE
);
489 RD_REG_WORD(®
->hccr
); /* PCI Posting. */
492 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
496 * qla24xx_reset_risc() - Perform full reset of ISP24xx RISC.
499 * Returns 0 on success.
502 qla24xx_reset_risc(scsi_qla_host_t
*ha
)
505 unsigned long flags
= 0;
506 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
510 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
513 WRT_REG_DWORD(®
->ctrl_status
, CSRX_DMA_SHUTDOWN
|MWB_4096_BYTES
);
514 for (cnt
= 0; cnt
< 30000; cnt
++) {
515 if ((RD_REG_DWORD(®
->ctrl_status
) & CSRX_DMA_ACTIVE
) == 0)
521 WRT_REG_DWORD(®
->ctrl_status
,
522 CSRX_ISP_SOFT_RESET
|CSRX_DMA_SHUTDOWN
|MWB_4096_BYTES
);
523 pci_read_config_word(ha
->pdev
, PCI_COMMAND
, &wd
);
526 /* Wait for firmware to complete NVRAM accesses. */
527 d2
= (uint32_t) RD_REG_WORD(®
->mailbox0
);
528 for (cnt
= 10000 ; cnt
&& d2
; cnt
--) {
530 d2
= (uint32_t) RD_REG_WORD(®
->mailbox0
);
536 /* Wait for soft-reset to complete. */
537 d2
= RD_REG_DWORD(®
->ctrl_status
);
538 for (cnt
= 6000000 ; cnt
&& (d2
& CSRX_ISP_SOFT_RESET
); cnt
--) {
540 d2
= RD_REG_DWORD(®
->ctrl_status
);
543 if (cnt
== 0 || hw_evt
)
544 qla2xxx_hw_event_log(ha
, HW_EVENT_RESET_ERR
,
545 RD_REG_WORD(®
->mailbox1
), RD_REG_WORD(®
->mailbox2
),
546 RD_REG_WORD(®
->mailbox3
));
548 WRT_REG_DWORD(®
->hccr
, HCCRX_SET_RISC_RESET
);
549 RD_REG_DWORD(®
->hccr
);
551 WRT_REG_DWORD(®
->hccr
, HCCRX_REL_RISC_PAUSE
);
552 RD_REG_DWORD(®
->hccr
);
554 WRT_REG_DWORD(®
->hccr
, HCCRX_CLR_RISC_RESET
);
555 RD_REG_DWORD(®
->hccr
);
557 d2
= (uint32_t) RD_REG_WORD(®
->mailbox0
);
558 for (cnt
= 6000000 ; cnt
&& d2
; cnt
--) {
560 d2
= (uint32_t) RD_REG_WORD(®
->mailbox0
);
564 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
568 * qla24xx_reset_chip() - Reset ISP24xx chip.
571 * Returns 0 on success.
574 qla24xx_reset_chip(scsi_qla_host_t
*ha
)
576 ha
->isp_ops
->disable_intrs(ha
);
578 /* Perform RISC reset. */
579 qla24xx_reset_risc(ha
);
583 * qla2x00_chip_diag() - Test chip for proper operation.
586 * Returns 0 on success.
589 qla2x00_chip_diag(scsi_qla_host_t
*ha
)
592 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
593 unsigned long flags
= 0;
598 /* Assume a failed state */
599 rval
= QLA_FUNCTION_FAILED
;
601 DEBUG3(printk("scsi(%ld): Testing device at %lx.\n",
602 ha
->host_no
, (u_long
)®
->flash_address
));
604 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
606 /* Reset ISP chip. */
607 WRT_REG_WORD(®
->ctrl_status
, CSR_ISP_SOFT_RESET
);
610 * We need to have a delay here since the card will not respond while
611 * in reset causing an MCA on some architectures.
614 data
= qla2x00_debounce_register(®
->ctrl_status
);
615 for (cnt
= 6000000 ; cnt
&& (data
& CSR_ISP_SOFT_RESET
); cnt
--) {
617 data
= RD_REG_WORD(®
->ctrl_status
);
622 goto chip_diag_failed
;
624 DEBUG3(printk("scsi(%ld): Reset register cleared by chip reset\n",
627 /* Reset RISC processor. */
628 WRT_REG_WORD(®
->hccr
, HCCR_RESET_RISC
);
629 WRT_REG_WORD(®
->hccr
, HCCR_RELEASE_RISC
);
631 /* Workaround for QLA2312 PCI parity error */
632 if (IS_QLA2100(ha
) || IS_QLA2200(ha
) || IS_QLA2300(ha
)) {
633 data
= qla2x00_debounce_register(MAILBOX_REG(ha
, reg
, 0));
634 for (cnt
= 6000000; cnt
&& (data
== MBS_BUSY
); cnt
--) {
636 data
= RD_MAILBOX_REG(ha
, reg
, 0);
643 goto chip_diag_failed
;
645 /* Check product ID of chip */
646 DEBUG3(printk("scsi(%ld): Checking product ID of chip\n", ha
->host_no
));
648 mb
[1] = RD_MAILBOX_REG(ha
, reg
, 1);
649 mb
[2] = RD_MAILBOX_REG(ha
, reg
, 2);
650 mb
[3] = RD_MAILBOX_REG(ha
, reg
, 3);
651 mb
[4] = qla2x00_debounce_register(MAILBOX_REG(ha
, reg
, 4));
652 if (mb
[1] != PROD_ID_1
|| (mb
[2] != PROD_ID_2
&& mb
[2] != PROD_ID_2a
) ||
653 mb
[3] != PROD_ID_3
) {
654 qla_printk(KERN_WARNING
, ha
,
655 "Wrong product ID = 0x%x,0x%x,0x%x\n", mb
[1], mb
[2], mb
[3]);
657 goto chip_diag_failed
;
659 ha
->product_id
[0] = mb
[1];
660 ha
->product_id
[1] = mb
[2];
661 ha
->product_id
[2] = mb
[3];
662 ha
->product_id
[3] = mb
[4];
664 /* Adjust fw RISC transfer size */
665 if (ha
->request_q_length
> 1024)
666 ha
->fw_transfer_size
= REQUEST_ENTRY_SIZE
* 1024;
668 ha
->fw_transfer_size
= REQUEST_ENTRY_SIZE
*
669 ha
->request_q_length
;
671 if (IS_QLA2200(ha
) &&
672 RD_MAILBOX_REG(ha
, reg
, 7) == QLA2200A_RISC_ROM_VER
) {
673 /* Limit firmware transfer size with a 2200A */
674 DEBUG3(printk("scsi(%ld): Found QLA2200A chip.\n",
677 ha
->device_type
|= DT_ISP2200A
;
678 ha
->fw_transfer_size
= 128;
681 /* Wrap Incoming Mailboxes Test. */
682 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
684 DEBUG3(printk("scsi(%ld): Checking mailboxes.\n", ha
->host_no
));
685 rval
= qla2x00_mbx_reg_test(ha
);
687 DEBUG(printk("scsi(%ld): Failed mailbox send register test\n",
689 qla_printk(KERN_WARNING
, ha
,
690 "Failed mailbox send register test\n");
693 /* Flag a successful rval */
696 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
700 DEBUG2_3(printk("scsi(%ld): Chip diagnostics **** FAILED "
701 "****\n", ha
->host_no
));
703 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
709 * qla24xx_chip_diag() - Test ISP24xx for proper operation.
712 * Returns 0 on success.
715 qla24xx_chip_diag(scsi_qla_host_t
*ha
)
719 /* Perform RISC reset. */
720 qla24xx_reset_risc(ha
);
722 ha
->fw_transfer_size
= REQUEST_ENTRY_SIZE
* ha
->request_q_length
;
724 rval
= qla2x00_mbx_reg_test(ha
);
726 DEBUG(printk("scsi(%ld): Failed mailbox send register test\n",
728 qla_printk(KERN_WARNING
, ha
,
729 "Failed mailbox send register test\n");
731 /* Flag a successful rval */
739 qla2x00_alloc_fw_dump(scsi_qla_host_t
*ha
)
742 uint32_t dump_size
, fixed_size
, mem_size
, req_q_size
, rsp_q_size
,
748 qla_printk(KERN_WARNING
, ha
,
749 "Firmware dump previously allocated.\n");
754 fixed_size
= mem_size
= eft_size
= fce_size
= 0;
755 if (IS_QLA2100(ha
) || IS_QLA2200(ha
)) {
756 fixed_size
= sizeof(struct qla2100_fw_dump
);
757 } else if (IS_QLA23XX(ha
)) {
758 fixed_size
= offsetof(struct qla2300_fw_dump
, data_ram
);
759 mem_size
= (ha
->fw_memory_size
- 0x11000 + 1) *
761 } else if (IS_FWI2_CAPABLE(ha
)) {
762 fixed_size
= IS_QLA25XX(ha
) ?
763 offsetof(struct qla25xx_fw_dump
, ext_mem
):
764 offsetof(struct qla24xx_fw_dump
, ext_mem
);
765 mem_size
= (ha
->fw_memory_size
- 0x100000 + 1) *
768 /* Allocate memory for Fibre Channel Event Buffer. */
772 tc
= dma_alloc_coherent(&ha
->pdev
->dev
, FCE_SIZE
, &tc_dma
,
775 qla_printk(KERN_WARNING
, ha
, "Unable to allocate "
776 "(%d KB) for FCE.\n", FCE_SIZE
/ 1024);
780 memset(tc
, 0, FCE_SIZE
);
781 rval
= qla2x00_enable_fce_trace(ha
, tc_dma
, FCE_NUM_BUFFERS
,
782 ha
->fce_mb
, &ha
->fce_bufs
);
784 qla_printk(KERN_WARNING
, ha
, "Unable to initialize "
785 "FCE (%d).\n", rval
);
786 dma_free_coherent(&ha
->pdev
->dev
, FCE_SIZE
, tc
,
788 ha
->flags
.fce_enabled
= 0;
792 qla_printk(KERN_INFO
, ha
, "Allocated (%d KB) for FCE...\n",
795 fce_size
= sizeof(struct qla2xxx_fce_chain
) + EFT_SIZE
;
796 ha
->flags
.fce_enabled
= 1;
797 ha
->fce_dma
= tc_dma
;
800 /* Allocate memory for Extended Trace Buffer. */
801 tc
= dma_alloc_coherent(&ha
->pdev
->dev
, EFT_SIZE
, &tc_dma
,
804 qla_printk(KERN_WARNING
, ha
, "Unable to allocate "
805 "(%d KB) for EFT.\n", EFT_SIZE
/ 1024);
809 memset(tc
, 0, EFT_SIZE
);
810 rval
= qla2x00_enable_eft_trace(ha
, tc_dma
, EFT_NUM_BUFFERS
);
812 qla_printk(KERN_WARNING
, ha
, "Unable to initialize "
813 "EFT (%d).\n", rval
);
814 dma_free_coherent(&ha
->pdev
->dev
, EFT_SIZE
, tc
,
819 qla_printk(KERN_INFO
, ha
, "Allocated (%d KB) for EFT...\n",
823 ha
->eft_dma
= tc_dma
;
827 req_q_size
= ha
->request_q_length
* sizeof(request_t
);
828 rsp_q_size
= ha
->response_q_length
* sizeof(response_t
);
830 dump_size
= offsetof(struct qla2xxx_fw_dump
, isp
);
831 dump_size
+= fixed_size
+ mem_size
+ req_q_size
+ rsp_q_size
+
834 ha
->fw_dump
= vmalloc(dump_size
);
836 qla_printk(KERN_WARNING
, ha
, "Unable to allocate (%d KB) for "
837 "firmware dump!!!\n", dump_size
/ 1024);
840 dma_free_coherent(&ha
->pdev
->dev
, eft_size
, ha
->eft
,
848 qla_printk(KERN_INFO
, ha
, "Allocated (%d KB) for firmware dump...\n",
851 ha
->fw_dump_len
= dump_size
;
852 ha
->fw_dump
->signature
[0] = 'Q';
853 ha
->fw_dump
->signature
[1] = 'L';
854 ha
->fw_dump
->signature
[2] = 'G';
855 ha
->fw_dump
->signature
[3] = 'C';
856 ha
->fw_dump
->version
= __constant_htonl(1);
858 ha
->fw_dump
->fixed_size
= htonl(fixed_size
);
859 ha
->fw_dump
->mem_size
= htonl(mem_size
);
860 ha
->fw_dump
->req_q_size
= htonl(req_q_size
);
861 ha
->fw_dump
->rsp_q_size
= htonl(rsp_q_size
);
863 ha
->fw_dump
->eft_size
= htonl(eft_size
);
864 ha
->fw_dump
->eft_addr_l
= htonl(LSD(ha
->eft_dma
));
865 ha
->fw_dump
->eft_addr_h
= htonl(MSD(ha
->eft_dma
));
867 ha
->fw_dump
->header_size
=
868 htonl(offsetof(struct qla2xxx_fw_dump
, isp
));
872 * qla2x00_resize_request_q() - Resize request queue given available ISP memory.
875 * Returns 0 on success.
878 qla2x00_resize_request_q(scsi_qla_host_t
*ha
)
881 uint16_t fw_iocb_cnt
= 0;
882 uint16_t request_q_length
= REQUEST_ENTRY_CNT_2XXX_EXT_MEM
;
883 dma_addr_t request_dma
;
884 request_t
*request_ring
;
886 /* Valid only on recent ISPs. */
887 if (IS_QLA2100(ha
) || IS_QLA2200(ha
))
890 /* Retrieve IOCB counts available to the firmware. */
891 rval
= qla2x00_get_resource_cnts(ha
, NULL
, NULL
, NULL
, &fw_iocb_cnt
,
892 &ha
->max_npiv_vports
);
895 /* No point in continuing if current settings are sufficient. */
896 if (fw_iocb_cnt
< 1024)
898 if (ha
->request_q_length
>= request_q_length
)
901 /* Attempt to claim larger area for request queue. */
902 request_ring
= dma_alloc_coherent(&ha
->pdev
->dev
,
903 (request_q_length
+ 1) * sizeof(request_t
), &request_dma
,
905 if (request_ring
== NULL
)
908 /* Resize successful, report extensions. */
909 qla_printk(KERN_INFO
, ha
, "Extended memory detected (%d KB)...\n",
910 (ha
->fw_memory_size
+ 1) / 1024);
911 qla_printk(KERN_INFO
, ha
, "Resizing request queue depth "
912 "(%d -> %d)...\n", ha
->request_q_length
, request_q_length
);
914 /* Clear old allocations. */
915 dma_free_coherent(&ha
->pdev
->dev
,
916 (ha
->request_q_length
+ 1) * sizeof(request_t
), ha
->request_ring
,
919 /* Begin using larger queue. */
920 ha
->request_q_length
= request_q_length
;
921 ha
->request_ring
= request_ring
;
922 ha
->request_dma
= request_dma
;
926 * qla2x00_setup_chip() - Load and start RISC firmware.
929 * Returns 0 on success.
932 qla2x00_setup_chip(scsi_qla_host_t
*ha
)
935 uint32_t srisc_address
= 0;
936 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
939 if (!IS_FWI2_CAPABLE(ha
) && !IS_QLA2100(ha
) && !IS_QLA2200(ha
)) {
940 /* Disable SRAM, Instruction RAM and GP RAM parity. */
941 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
942 WRT_REG_WORD(®
->hccr
, (HCCR_ENABLE_PARITY
+ 0x0));
943 RD_REG_WORD(®
->hccr
);
944 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
947 /* Load firmware sequences */
948 rval
= ha
->isp_ops
->load_risc(ha
, &srisc_address
);
949 if (rval
== QLA_SUCCESS
) {
950 DEBUG(printk("scsi(%ld): Verifying Checksum of loaded RISC "
951 "code.\n", ha
->host_no
));
953 rval
= qla2x00_verify_checksum(ha
, srisc_address
);
954 if (rval
== QLA_SUCCESS
) {
955 /* Start firmware execution. */
956 DEBUG(printk("scsi(%ld): Checksum OK, start "
957 "firmware.\n", ha
->host_no
));
959 rval
= qla2x00_execute_fw(ha
, srisc_address
);
960 /* Retrieve firmware information. */
961 if (rval
== QLA_SUCCESS
&& ha
->fw_major_version
== 0) {
962 qla2x00_get_fw_version(ha
,
963 &ha
->fw_major_version
,
964 &ha
->fw_minor_version
,
965 &ha
->fw_subminor_version
,
966 &ha
->fw_attributes
, &ha
->fw_memory_size
);
967 ha
->flags
.npiv_supported
= 0;
968 if ((IS_QLA24XX(ha
) || IS_QLA25XX(ha
) ||
970 (ha
->fw_attributes
& BIT_2
)) {
971 ha
->flags
.npiv_supported
= 1;
972 if ((!ha
->max_npiv_vports
) ||
973 ((ha
->max_npiv_vports
+ 1) %
974 MIN_MULTI_ID_FABRIC
))
975 ha
->max_npiv_vports
=
976 MIN_MULTI_ID_FABRIC
- 1;
978 qla2x00_resize_request_q(ha
);
981 qla2x00_alloc_fw_dump(ha
);
984 DEBUG2(printk(KERN_INFO
985 "scsi(%ld): ISP Firmware failed checksum.\n",
990 if (!IS_FWI2_CAPABLE(ha
) && !IS_QLA2100(ha
) && !IS_QLA2200(ha
)) {
991 /* Enable proper parity. */
992 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
995 WRT_REG_WORD(®
->hccr
, HCCR_ENABLE_PARITY
+ 0x1);
997 /* SRAM, Instruction RAM and GP RAM parity */
998 WRT_REG_WORD(®
->hccr
, HCCR_ENABLE_PARITY
+ 0x7);
999 RD_REG_WORD(®
->hccr
);
1000 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1004 DEBUG2_3(printk("scsi(%ld): Setup chip **** FAILED ****.\n",
1012 * qla2x00_init_response_q_entries() - Initializes response queue entries.
1015 * Beginning of request ring has initialization control block already built
1016 * by nvram config routine.
1018 * Returns 0 on success.
1021 qla2x00_init_response_q_entries(scsi_qla_host_t
*ha
)
1026 pkt
= ha
->response_ring_ptr
;
1027 for (cnt
= 0; cnt
< ha
->response_q_length
; cnt
++) {
1028 pkt
->signature
= RESPONSE_PROCESSED
;
1035 * qla2x00_update_fw_options() - Read and process firmware options.
1038 * Returns 0 on success.
1041 qla2x00_update_fw_options(scsi_qla_host_t
*ha
)
1043 uint16_t swing
, emphasis
, tx_sens
, rx_sens
;
1045 memset(ha
->fw_options
, 0, sizeof(ha
->fw_options
));
1046 qla2x00_get_fw_options(ha
, ha
->fw_options
);
1048 if (IS_QLA2100(ha
) || IS_QLA2200(ha
))
1051 /* Serial Link options. */
1052 DEBUG3(printk("scsi(%ld): Serial link options:\n",
1054 DEBUG3(qla2x00_dump_buffer((uint8_t *)&ha
->fw_seriallink_options
,
1055 sizeof(ha
->fw_seriallink_options
)));
1057 ha
->fw_options
[1] &= ~FO1_SET_EMPHASIS_SWING
;
1058 if (ha
->fw_seriallink_options
[3] & BIT_2
) {
1059 ha
->fw_options
[1] |= FO1_SET_EMPHASIS_SWING
;
1062 swing
= ha
->fw_seriallink_options
[2] & (BIT_2
| BIT_1
| BIT_0
);
1063 emphasis
= (ha
->fw_seriallink_options
[2] &
1064 (BIT_4
| BIT_3
)) >> 3;
1065 tx_sens
= ha
->fw_seriallink_options
[0] &
1066 (BIT_3
| BIT_2
| BIT_1
| BIT_0
);
1067 rx_sens
= (ha
->fw_seriallink_options
[0] &
1068 (BIT_7
| BIT_6
| BIT_5
| BIT_4
)) >> 4;
1069 ha
->fw_options
[10] = (emphasis
<< 14) | (swing
<< 8);
1070 if (IS_QLA2300(ha
) || IS_QLA2312(ha
) || IS_QLA6312(ha
)) {
1073 ha
->fw_options
[10] |= (tx_sens
<< 4) | rx_sens
;
1074 } else if (IS_QLA2322(ha
) || IS_QLA6322(ha
))
1075 ha
->fw_options
[10] |= BIT_5
|
1076 ((rx_sens
& (BIT_1
| BIT_0
)) << 2) |
1077 (tx_sens
& (BIT_1
| BIT_0
));
1080 swing
= (ha
->fw_seriallink_options
[2] &
1081 (BIT_7
| BIT_6
| BIT_5
)) >> 5;
1082 emphasis
= ha
->fw_seriallink_options
[3] & (BIT_1
| BIT_0
);
1083 tx_sens
= ha
->fw_seriallink_options
[1] &
1084 (BIT_3
| BIT_2
| BIT_1
| BIT_0
);
1085 rx_sens
= (ha
->fw_seriallink_options
[1] &
1086 (BIT_7
| BIT_6
| BIT_5
| BIT_4
)) >> 4;
1087 ha
->fw_options
[11] = (emphasis
<< 14) | (swing
<< 8);
1088 if (IS_QLA2300(ha
) || IS_QLA2312(ha
) || IS_QLA6312(ha
)) {
1091 ha
->fw_options
[11] |= (tx_sens
<< 4) | rx_sens
;
1092 } else if (IS_QLA2322(ha
) || IS_QLA6322(ha
))
1093 ha
->fw_options
[11] |= BIT_5
|
1094 ((rx_sens
& (BIT_1
| BIT_0
)) << 2) |
1095 (tx_sens
& (BIT_1
| BIT_0
));
1099 /* Return command IOCBs without waiting for an ABTS to complete. */
1100 ha
->fw_options
[3] |= BIT_13
;
1103 if (ha
->flags
.enable_led_scheme
)
1104 ha
->fw_options
[2] |= BIT_12
;
1106 /* Detect ISP6312. */
1108 ha
->fw_options
[2] |= BIT_13
;
1110 /* Update firmware options. */
1111 qla2x00_set_fw_options(ha
, ha
->fw_options
);
1115 qla24xx_update_fw_options(scsi_qla_host_t
*ha
)
1119 /* Update Serial Link options. */
1120 if ((le16_to_cpu(ha
->fw_seriallink_options24
[0]) & BIT_0
) == 0)
1123 rval
= qla2x00_set_serdes_params(ha
,
1124 le16_to_cpu(ha
->fw_seriallink_options24
[1]),
1125 le16_to_cpu(ha
->fw_seriallink_options24
[2]),
1126 le16_to_cpu(ha
->fw_seriallink_options24
[3]));
1127 if (rval
!= QLA_SUCCESS
) {
1128 qla_printk(KERN_WARNING
, ha
,
1129 "Unable to update Serial Link options (%x).\n", rval
);
1134 qla2x00_config_rings(struct scsi_qla_host
*ha
)
1136 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
1138 /* Setup ring parameters in initialization control block. */
1139 ha
->init_cb
->request_q_outpointer
= __constant_cpu_to_le16(0);
1140 ha
->init_cb
->response_q_inpointer
= __constant_cpu_to_le16(0);
1141 ha
->init_cb
->request_q_length
= cpu_to_le16(ha
->request_q_length
);
1142 ha
->init_cb
->response_q_length
= cpu_to_le16(ha
->response_q_length
);
1143 ha
->init_cb
->request_q_address
[0] = cpu_to_le32(LSD(ha
->request_dma
));
1144 ha
->init_cb
->request_q_address
[1] = cpu_to_le32(MSD(ha
->request_dma
));
1145 ha
->init_cb
->response_q_address
[0] = cpu_to_le32(LSD(ha
->response_dma
));
1146 ha
->init_cb
->response_q_address
[1] = cpu_to_le32(MSD(ha
->response_dma
));
1148 WRT_REG_WORD(ISP_REQ_Q_IN(ha
, reg
), 0);
1149 WRT_REG_WORD(ISP_REQ_Q_OUT(ha
, reg
), 0);
1150 WRT_REG_WORD(ISP_RSP_Q_IN(ha
, reg
), 0);
1151 WRT_REG_WORD(ISP_RSP_Q_OUT(ha
, reg
), 0);
1152 RD_REG_WORD(ISP_RSP_Q_OUT(ha
, reg
)); /* PCI Posting. */
1156 qla24xx_config_rings(struct scsi_qla_host
*ha
)
1158 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
1159 struct init_cb_24xx
*icb
;
1161 /* Setup ring parameters in initialization control block. */
1162 icb
= (struct init_cb_24xx
*)ha
->init_cb
;
1163 icb
->request_q_outpointer
= __constant_cpu_to_le16(0);
1164 icb
->response_q_inpointer
= __constant_cpu_to_le16(0);
1165 icb
->request_q_length
= cpu_to_le16(ha
->request_q_length
);
1166 icb
->response_q_length
= cpu_to_le16(ha
->response_q_length
);
1167 icb
->request_q_address
[0] = cpu_to_le32(LSD(ha
->request_dma
));
1168 icb
->request_q_address
[1] = cpu_to_le32(MSD(ha
->request_dma
));
1169 icb
->response_q_address
[0] = cpu_to_le32(LSD(ha
->response_dma
));
1170 icb
->response_q_address
[1] = cpu_to_le32(MSD(ha
->response_dma
));
1172 WRT_REG_DWORD(®
->req_q_in
, 0);
1173 WRT_REG_DWORD(®
->req_q_out
, 0);
1174 WRT_REG_DWORD(®
->rsp_q_in
, 0);
1175 WRT_REG_DWORD(®
->rsp_q_out
, 0);
1176 RD_REG_DWORD(®
->rsp_q_out
);
1180 * qla2x00_init_rings() - Initializes firmware.
1183 * Beginning of request ring has initialization control block already built
1184 * by nvram config routine.
1186 * Returns 0 on success.
1189 qla2x00_init_rings(scsi_qla_host_t
*ha
)
1192 unsigned long flags
= 0;
1194 struct mid_init_cb_24xx
*mid_init_cb
=
1195 (struct mid_init_cb_24xx
*) ha
->init_cb
;
1197 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
1199 /* Clear outstanding commands array. */
1200 for (cnt
= 0; cnt
< MAX_OUTSTANDING_COMMANDS
; cnt
++)
1201 ha
->outstanding_cmds
[cnt
] = NULL
;
1203 ha
->current_outstanding_cmd
= 0;
1205 /* Clear RSCN queue. */
1206 ha
->rscn_in_ptr
= 0;
1207 ha
->rscn_out_ptr
= 0;
1209 /* Initialize firmware. */
1210 ha
->request_ring_ptr
= ha
->request_ring
;
1211 ha
->req_ring_index
= 0;
1212 ha
->req_q_cnt
= ha
->request_q_length
;
1213 ha
->response_ring_ptr
= ha
->response_ring
;
1214 ha
->rsp_ring_index
= 0;
1216 /* Initialize response queue entries */
1217 qla2x00_init_response_q_entries(ha
);
1219 ha
->isp_ops
->config_rings(ha
);
1221 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
1223 /* Update any ISP specific firmware options before initialization. */
1224 ha
->isp_ops
->update_fw_options(ha
);
1226 DEBUG(printk("scsi(%ld): Issue init firmware.\n", ha
->host_no
));
1228 if (ha
->flags
.npiv_supported
)
1229 mid_init_cb
->count
= cpu_to_le16(ha
->max_npiv_vports
);
1231 mid_init_cb
->options
= __constant_cpu_to_le16(BIT_1
);
1233 rval
= qla2x00_init_firmware(ha
, ha
->init_cb_size
);
1235 DEBUG2_3(printk("scsi(%ld): Init firmware **** FAILED ****.\n",
1238 DEBUG3(printk("scsi(%ld): Init firmware -- success.\n",
1246 * qla2x00_fw_ready() - Waits for firmware ready.
1249 * Returns 0 on success.
1252 qla2x00_fw_ready(scsi_qla_host_t
*ha
)
1255 unsigned long wtime
, mtime
, cs84xx_time
;
1256 uint16_t min_wait
; /* Minimum wait time if loop is down */
1257 uint16_t wait_time
; /* Wait time if loop is coming ready */
1262 /* 20 seconds for loop down. */
1266 * Firmware should take at most one RATOV to login, plus 5 seconds for
1267 * our own processing.
1269 if ((wait_time
= (ha
->retry_count
*ha
->login_timeout
) + 5) < min_wait
) {
1270 wait_time
= min_wait
;
1273 /* Min wait time if loop down */
1274 mtime
= jiffies
+ (min_wait
* HZ
);
1276 /* wait time before firmware ready */
1277 wtime
= jiffies
+ (wait_time
* HZ
);
1279 /* Wait for ISP to finish LIP */
1280 if (!ha
->flags
.init_done
)
1281 qla_printk(KERN_INFO
, ha
, "Waiting for LIP to complete...\n");
1283 DEBUG3(printk("scsi(%ld): Waiting for LIP to complete...\n",
1287 rval
= qla2x00_get_firmware_state(ha
, state
);
1288 if (rval
== QLA_SUCCESS
) {
1289 if (state
[0] < FSTATE_LOSS_OF_SYNC
) {
1290 ha
->device_flags
&= ~DFLG_NO_CABLE
;
1292 if (IS_QLA84XX(ha
) && state
[0] != FSTATE_READY
) {
1293 DEBUG16(printk("scsi(%ld): fw_state=%x "
1294 "84xx=%x.\n", ha
->host_no
, state
[0],
1296 if ((state
[2] & FSTATE_LOGGED_IN
) &&
1297 (state
[2] & FSTATE_WAITING_FOR_VERIFY
)) {
1298 DEBUG16(printk("scsi(%ld): Sending "
1299 "verify iocb.\n", ha
->host_no
));
1301 cs84xx_time
= jiffies
;
1302 rval
= qla84xx_init_chip(ha
);
1303 if (rval
!= QLA_SUCCESS
)
1306 /* Add time taken to initialize. */
1307 cs84xx_time
= jiffies
- cs84xx_time
;
1308 wtime
+= cs84xx_time
;
1309 mtime
+= cs84xx_time
;
1310 DEBUG16(printk("scsi(%ld): Increasing "
1311 "wait time by %ld. New time %ld\n",
1312 ha
->host_no
, cs84xx_time
, wtime
));
1314 } else if (state
[0] == FSTATE_READY
) {
1315 DEBUG(printk("scsi(%ld): F/W Ready - OK \n",
1318 qla2x00_get_retry_cnt(ha
, &ha
->retry_count
,
1319 &ha
->login_timeout
, &ha
->r_a_tov
);
1325 rval
= QLA_FUNCTION_FAILED
;
1327 if (atomic_read(&ha
->loop_down_timer
) &&
1328 state
[0] != FSTATE_READY
) {
1329 /* Loop down. Timeout on min_wait for states
1330 * other than Wait for Login.
1332 if (time_after_eq(jiffies
, mtime
)) {
1333 qla_printk(KERN_INFO
, ha
,
1334 "Cable is unplugged...\n");
1336 ha
->device_flags
|= DFLG_NO_CABLE
;
1341 /* Mailbox cmd failed. Timeout on min_wait. */
1342 if (time_after_eq(jiffies
, mtime
))
1346 if (time_after_eq(jiffies
, wtime
))
1349 /* Delay for a while */
1352 DEBUG3(printk("scsi(%ld): fw_state=%x curr time=%lx.\n",
1353 ha
->host_no
, state
[0], jiffies
));
1356 DEBUG(printk("scsi(%ld): fw_state=%x curr time=%lx.\n",
1357 ha
->host_no
, state
[0], jiffies
));
1360 DEBUG2_3(printk("scsi(%ld): Firmware ready **** FAILED ****.\n",
1368 * qla2x00_configure_hba
1369 * Setup adapter context.
1372 * ha = adapter state pointer.
1381 qla2x00_configure_hba(scsi_qla_host_t
*ha
)
1390 char connect_type
[22];
1392 /* Get host addresses. */
1393 rval
= qla2x00_get_adapter_id(ha
,
1394 &loop_id
, &al_pa
, &area
, &domain
, &topo
, &sw_cap
);
1395 if (rval
!= QLA_SUCCESS
) {
1396 if (LOOP_TRANSITION(ha
) || atomic_read(&ha
->loop_down_timer
) ||
1397 (rval
== QLA_COMMAND_ERROR
&& loop_id
== 0x7)) {
1398 DEBUG2(printk("%s(%ld) Loop is in a transition state\n",
1399 __func__
, ha
->host_no
));
1401 qla_printk(KERN_WARNING
, ha
,
1402 "ERROR -- Unable to get host loop ID.\n");
1403 set_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
1409 qla_printk(KERN_INFO
, ha
,
1410 "Cannot get topology - retrying.\n");
1411 return (QLA_FUNCTION_FAILED
);
1414 ha
->loop_id
= loop_id
;
1417 ha
->min_external_loopid
= SNS_FIRST_LOOP_ID
;
1418 ha
->operating_mode
= LOOP
;
1423 DEBUG3(printk("scsi(%ld): HBA in NL topology.\n",
1425 ha
->current_topology
= ISP_CFG_NL
;
1426 strcpy(connect_type
, "(Loop)");
1430 DEBUG3(printk("scsi(%ld): HBA in FL topology.\n",
1432 ha
->switch_cap
= sw_cap
;
1433 ha
->current_topology
= ISP_CFG_FL
;
1434 strcpy(connect_type
, "(FL_Port)");
1438 DEBUG3(printk("scsi(%ld): HBA in N P2P topology.\n",
1440 ha
->operating_mode
= P2P
;
1441 ha
->current_topology
= ISP_CFG_N
;
1442 strcpy(connect_type
, "(N_Port-to-N_Port)");
1446 DEBUG3(printk("scsi(%ld): HBA in F P2P topology.\n",
1448 ha
->switch_cap
= sw_cap
;
1449 ha
->operating_mode
= P2P
;
1450 ha
->current_topology
= ISP_CFG_F
;
1451 strcpy(connect_type
, "(F_Port)");
1455 DEBUG3(printk("scsi(%ld): HBA in unknown topology %x. "
1457 ha
->host_no
, topo
));
1458 ha
->current_topology
= ISP_CFG_NL
;
1459 strcpy(connect_type
, "(Loop)");
1463 /* Save Host port and loop ID. */
1464 /* byte order - Big Endian */
1465 ha
->d_id
.b
.domain
= domain
;
1466 ha
->d_id
.b
.area
= area
;
1467 ha
->d_id
.b
.al_pa
= al_pa
;
1469 if (!ha
->flags
.init_done
)
1470 qla_printk(KERN_INFO
, ha
,
1471 "Topology - %s, Host Loop address 0x%x\n",
1472 connect_type
, ha
->loop_id
);
1475 DEBUG2_3(printk("scsi(%ld): FAILED.\n", ha
->host_no
));
1477 DEBUG3(printk("scsi(%ld): exiting normally.\n", ha
->host_no
));
1484 qla2x00_set_model_info(scsi_qla_host_t
*ha
, uint8_t *model
, size_t len
, char *def
)
1489 if (memcmp(model
, BINZERO
, len
) != 0) {
1490 strncpy(ha
->model_number
, model
, len
);
1491 st
= en
= ha
->model_number
;
1494 if (*en
!= 0x20 && *en
!= 0x00)
1499 index
= (ha
->pdev
->subsystem_device
& 0xff);
1500 if (ha
->pdev
->subsystem_vendor
== PCI_VENDOR_ID_QLOGIC
&&
1501 index
< QLA_MODEL_NAMES
)
1502 strncpy(ha
->model_desc
,
1503 qla2x00_model_name
[index
* 2 + 1],
1504 sizeof(ha
->model_desc
) - 1);
1506 index
= (ha
->pdev
->subsystem_device
& 0xff);
1507 if (ha
->pdev
->subsystem_vendor
== PCI_VENDOR_ID_QLOGIC
&&
1508 index
< QLA_MODEL_NAMES
) {
1509 strcpy(ha
->model_number
,
1510 qla2x00_model_name
[index
* 2]);
1511 strncpy(ha
->model_desc
,
1512 qla2x00_model_name
[index
* 2 + 1],
1513 sizeof(ha
->model_desc
) - 1);
1515 strcpy(ha
->model_number
, def
);
1518 if (IS_FWI2_CAPABLE(ha
))
1519 qla2xxx_get_vpd_field(ha
, "\x82", ha
->model_desc
,
1520 sizeof(ha
->model_desc
));
1523 /* On sparc systems, obtain port and node WWN from firmware
1526 static void qla2xxx_nvram_wwn_from_ofw(scsi_qla_host_t
*ha
, nvram_t
*nv
)
1529 struct pci_dev
*pdev
= ha
->pdev
;
1530 struct device_node
*dp
= pci_device_to_OF_node(pdev
);
1534 val
= of_get_property(dp
, "port-wwn", &len
);
1535 if (val
&& len
>= WWN_SIZE
)
1536 memcpy(nv
->port_name
, val
, WWN_SIZE
);
1538 val
= of_get_property(dp
, "node-wwn", &len
);
1539 if (val
&& len
>= WWN_SIZE
)
1540 memcpy(nv
->node_name
, val
, WWN_SIZE
);
1545 * NVRAM configuration for ISP 2xxx
1548 * ha = adapter block pointer.
1551 * initialization control block in response_ring
1552 * host adapters parameters in host adapter block
1558 qla2x00_nvram_config(scsi_qla_host_t
*ha
)
1563 uint8_t *dptr1
, *dptr2
;
1564 init_cb_t
*icb
= ha
->init_cb
;
1565 nvram_t
*nv
= ha
->nvram
;
1566 uint8_t *ptr
= ha
->nvram
;
1567 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
1571 /* Determine NVRAM starting address. */
1572 ha
->nvram_size
= sizeof(nvram_t
);
1574 if (!IS_QLA2100(ha
) && !IS_QLA2200(ha
) && !IS_QLA2300(ha
))
1575 if ((RD_REG_WORD(®
->ctrl_status
) >> 14) == 1)
1576 ha
->nvram_base
= 0x80;
1578 /* Get NVRAM data and calculate checksum. */
1579 ha
->isp_ops
->read_nvram(ha
, ptr
, ha
->nvram_base
, ha
->nvram_size
);
1580 for (cnt
= 0, chksum
= 0; cnt
< ha
->nvram_size
; cnt
++)
1583 DEBUG5(printk("scsi(%ld): Contents of NVRAM\n", ha
->host_no
));
1584 DEBUG5(qla2x00_dump_buffer((uint8_t *)nv
, ha
->nvram_size
));
1586 /* Bad NVRAM data, set defaults parameters. */
1587 if (chksum
|| nv
->id
[0] != 'I' || nv
->id
[1] != 'S' ||
1588 nv
->id
[2] != 'P' || nv
->id
[3] != ' ' || nv
->nvram_version
< 1) {
1589 /* Reset NVRAM data. */
1590 qla_printk(KERN_WARNING
, ha
, "Inconsistent NVRAM detected: "
1591 "checksum=0x%x id=%c version=0x%x.\n", chksum
, nv
->id
[0],
1593 qla_printk(KERN_WARNING
, ha
, "Falling back to functioning (yet "
1594 "invalid -- WWPN) defaults.\n");
1597 qla2xxx_hw_event_log(ha
, HW_EVENT_NVRAM_CHKSUM_ERR
, 0,
1598 MSW(chksum
), LSW(chksum
));
1601 * Set default initialization control block.
1603 memset(nv
, 0, ha
->nvram_size
);
1604 nv
->parameter_block_version
= ICB_VERSION
;
1606 if (IS_QLA23XX(ha
)) {
1607 nv
->firmware_options
[0] = BIT_2
| BIT_1
;
1608 nv
->firmware_options
[1] = BIT_7
| BIT_5
;
1609 nv
->add_firmware_options
[0] = BIT_5
;
1610 nv
->add_firmware_options
[1] = BIT_5
| BIT_4
;
1611 nv
->frame_payload_size
= __constant_cpu_to_le16(2048);
1612 nv
->special_options
[1] = BIT_7
;
1613 } else if (IS_QLA2200(ha
)) {
1614 nv
->firmware_options
[0] = BIT_2
| BIT_1
;
1615 nv
->firmware_options
[1] = BIT_7
| BIT_5
;
1616 nv
->add_firmware_options
[0] = BIT_5
;
1617 nv
->add_firmware_options
[1] = BIT_5
| BIT_4
;
1618 nv
->frame_payload_size
= __constant_cpu_to_le16(1024);
1619 } else if (IS_QLA2100(ha
)) {
1620 nv
->firmware_options
[0] = BIT_3
| BIT_1
;
1621 nv
->firmware_options
[1] = BIT_5
;
1622 nv
->frame_payload_size
= __constant_cpu_to_le16(1024);
1625 nv
->max_iocb_allocation
= __constant_cpu_to_le16(256);
1626 nv
->execution_throttle
= __constant_cpu_to_le16(16);
1627 nv
->retry_count
= 8;
1628 nv
->retry_delay
= 1;
1630 nv
->port_name
[0] = 33;
1631 nv
->port_name
[3] = 224;
1632 nv
->port_name
[4] = 139;
1634 qla2xxx_nvram_wwn_from_ofw(ha
, nv
);
1636 nv
->login_timeout
= 4;
1639 * Set default host adapter parameters
1641 nv
->host_p
[1] = BIT_2
;
1642 nv
->reset_delay
= 5;
1643 nv
->port_down_retry_count
= 8;
1644 nv
->max_luns_per_target
= __constant_cpu_to_le16(8);
1645 nv
->link_down_timeout
= 60;
1650 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
1652 * The SN2 does not provide BIOS emulation which means you can't change
1653 * potentially bogus BIOS settings. Force the use of default settings
1654 * for link rate and frame size. Hope that the rest of the settings
1657 if (ia64_platform_is("sn2")) {
1658 nv
->frame_payload_size
= __constant_cpu_to_le16(2048);
1660 nv
->special_options
[1] = BIT_7
;
1664 /* Reset Initialization control block */
1665 memset(icb
, 0, ha
->init_cb_size
);
1668 * Setup driver NVRAM options.
1670 nv
->firmware_options
[0] |= (BIT_6
| BIT_1
);
1671 nv
->firmware_options
[0] &= ~(BIT_5
| BIT_4
);
1672 nv
->firmware_options
[1] |= (BIT_5
| BIT_0
);
1673 nv
->firmware_options
[1] &= ~BIT_4
;
1675 if (IS_QLA23XX(ha
)) {
1676 nv
->firmware_options
[0] |= BIT_2
;
1677 nv
->firmware_options
[0] &= ~BIT_3
;
1678 nv
->add_firmware_options
[1] |= BIT_5
| BIT_4
;
1680 if (IS_QLA2300(ha
)) {
1681 if (ha
->fb_rev
== FPM_2310
) {
1682 strcpy(ha
->model_number
, "QLA2310");
1684 strcpy(ha
->model_number
, "QLA2300");
1687 qla2x00_set_model_info(ha
, nv
->model_number
,
1688 sizeof(nv
->model_number
), "QLA23xx");
1690 } else if (IS_QLA2200(ha
)) {
1691 nv
->firmware_options
[0] |= BIT_2
;
1693 * 'Point-to-point preferred, else loop' is not a safe
1694 * connection mode setting.
1696 if ((nv
->add_firmware_options
[0] & (BIT_6
| BIT_5
| BIT_4
)) ==
1698 /* Force 'loop preferred, else point-to-point'. */
1699 nv
->add_firmware_options
[0] &= ~(BIT_6
| BIT_5
| BIT_4
);
1700 nv
->add_firmware_options
[0] |= BIT_5
;
1702 strcpy(ha
->model_number
, "QLA22xx");
1703 } else /*if (IS_QLA2100(ha))*/ {
1704 strcpy(ha
->model_number
, "QLA2100");
1708 * Copy over NVRAM RISC parameter block to initialization control block.
1710 dptr1
= (uint8_t *)icb
;
1711 dptr2
= (uint8_t *)&nv
->parameter_block_version
;
1712 cnt
= (uint8_t *)&icb
->request_q_outpointer
- (uint8_t *)&icb
->version
;
1714 *dptr1
++ = *dptr2
++;
1716 /* Copy 2nd half. */
1717 dptr1
= (uint8_t *)icb
->add_firmware_options
;
1718 cnt
= (uint8_t *)icb
->reserved_3
- (uint8_t *)icb
->add_firmware_options
;
1720 *dptr1
++ = *dptr2
++;
1722 /* Use alternate WWN? */
1723 if (nv
->host_p
[1] & BIT_7
) {
1724 memcpy(icb
->node_name
, nv
->alternate_node_name
, WWN_SIZE
);
1725 memcpy(icb
->port_name
, nv
->alternate_port_name
, WWN_SIZE
);
1728 /* Prepare nodename */
1729 if ((icb
->firmware_options
[1] & BIT_6
) == 0) {
1731 * Firmware will apply the following mask if the nodename was
1734 memcpy(icb
->node_name
, icb
->port_name
, WWN_SIZE
);
1735 icb
->node_name
[0] &= 0xF0;
1739 * Set host adapter parameters.
1741 if (nv
->host_p
[0] & BIT_7
)
1742 ql2xextended_error_logging
= 1;
1743 ha
->flags
.disable_risc_code_load
= ((nv
->host_p
[0] & BIT_4
) ? 1 : 0);
1744 /* Always load RISC code on non ISP2[12]00 chips. */
1745 if (!IS_QLA2100(ha
) && !IS_QLA2200(ha
))
1746 ha
->flags
.disable_risc_code_load
= 0;
1747 ha
->flags
.enable_lip_reset
= ((nv
->host_p
[1] & BIT_1
) ? 1 : 0);
1748 ha
->flags
.enable_lip_full_login
= ((nv
->host_p
[1] & BIT_2
) ? 1 : 0);
1749 ha
->flags
.enable_target_reset
= ((nv
->host_p
[1] & BIT_3
) ? 1 : 0);
1750 ha
->flags
.enable_led_scheme
= (nv
->special_options
[1] & BIT_4
) ? 1 : 0;
1751 ha
->flags
.disable_serdes
= 0;
1753 ha
->operating_mode
=
1754 (icb
->add_firmware_options
[0] & (BIT_6
| BIT_5
| BIT_4
)) >> 4;
1756 memcpy(ha
->fw_seriallink_options
, nv
->seriallink_options
,
1757 sizeof(ha
->fw_seriallink_options
));
1759 /* save HBA serial number */
1760 ha
->serial0
= icb
->port_name
[5];
1761 ha
->serial1
= icb
->port_name
[6];
1762 ha
->serial2
= icb
->port_name
[7];
1763 ha
->node_name
= icb
->node_name
;
1764 ha
->port_name
= icb
->port_name
;
1766 icb
->execution_throttle
= __constant_cpu_to_le16(0xFFFF);
1768 ha
->retry_count
= nv
->retry_count
;
1770 /* Set minimum login_timeout to 4 seconds. */
1771 if (nv
->login_timeout
< ql2xlogintimeout
)
1772 nv
->login_timeout
= ql2xlogintimeout
;
1773 if (nv
->login_timeout
< 4)
1774 nv
->login_timeout
= 4;
1775 ha
->login_timeout
= nv
->login_timeout
;
1776 icb
->login_timeout
= nv
->login_timeout
;
1778 /* Set minimum RATOV to 100 tenths of a second. */
1781 ha
->loop_reset_delay
= nv
->reset_delay
;
1783 /* Link Down Timeout = 0:
1785 * When Port Down timer expires we will start returning
1786 * I/O's to OS with "DID_NO_CONNECT".
1788 * Link Down Timeout != 0:
1790 * The driver waits for the link to come up after link down
1791 * before returning I/Os to OS with "DID_NO_CONNECT".
1793 if (nv
->link_down_timeout
== 0) {
1794 ha
->loop_down_abort_time
=
1795 (LOOP_DOWN_TIME
- LOOP_DOWN_TIMEOUT
);
1797 ha
->link_down_timeout
= nv
->link_down_timeout
;
1798 ha
->loop_down_abort_time
=
1799 (LOOP_DOWN_TIME
- ha
->link_down_timeout
);
1803 * Need enough time to try and get the port back.
1805 ha
->port_down_retry_count
= nv
->port_down_retry_count
;
1806 if (qlport_down_retry
)
1807 ha
->port_down_retry_count
= qlport_down_retry
;
1808 /* Set login_retry_count */
1809 ha
->login_retry_count
= nv
->retry_count
;
1810 if (ha
->port_down_retry_count
== nv
->port_down_retry_count
&&
1811 ha
->port_down_retry_count
> 3)
1812 ha
->login_retry_count
= ha
->port_down_retry_count
;
1813 else if (ha
->port_down_retry_count
> (int)ha
->login_retry_count
)
1814 ha
->login_retry_count
= ha
->port_down_retry_count
;
1815 if (ql2xloginretrycount
)
1816 ha
->login_retry_count
= ql2xloginretrycount
;
1818 icb
->lun_enables
= __constant_cpu_to_le16(0);
1819 icb
->command_resource_count
= 0;
1820 icb
->immediate_notify_resource_count
= 0;
1821 icb
->timeout
= __constant_cpu_to_le16(0);
1823 if (IS_QLA2100(ha
) || IS_QLA2200(ha
)) {
1825 icb
->firmware_options
[0] &= ~BIT_3
;
1826 icb
->add_firmware_options
[0] &=
1827 ~(BIT_3
| BIT_2
| BIT_1
| BIT_0
);
1828 icb
->add_firmware_options
[0] |= BIT_2
;
1829 icb
->response_accumulation_timer
= 3;
1830 icb
->interrupt_delay_timer
= 5;
1832 ha
->flags
.process_response_queue
= 1;
1835 if (!ha
->flags
.init_done
) {
1836 ha
->zio_mode
= icb
->add_firmware_options
[0] &
1837 (BIT_3
| BIT_2
| BIT_1
| BIT_0
);
1838 ha
->zio_timer
= icb
->interrupt_delay_timer
?
1839 icb
->interrupt_delay_timer
: 2;
1841 icb
->add_firmware_options
[0] &=
1842 ~(BIT_3
| BIT_2
| BIT_1
| BIT_0
);
1843 ha
->flags
.process_response_queue
= 0;
1844 if (ha
->zio_mode
!= QLA_ZIO_DISABLED
) {
1845 ha
->zio_mode
= QLA_ZIO_MODE_6
;
1847 DEBUG2(printk("scsi(%ld): ZIO mode %d enabled; timer "
1848 "delay (%d us).\n", ha
->host_no
, ha
->zio_mode
,
1849 ha
->zio_timer
* 100));
1850 qla_printk(KERN_INFO
, ha
,
1851 "ZIO mode %d enabled; timer delay (%d us).\n",
1852 ha
->zio_mode
, ha
->zio_timer
* 100);
1854 icb
->add_firmware_options
[0] |= (uint8_t)ha
->zio_mode
;
1855 icb
->interrupt_delay_timer
= (uint8_t)ha
->zio_timer
;
1856 ha
->flags
.process_response_queue
= 1;
1861 DEBUG2_3(printk(KERN_WARNING
1862 "scsi(%ld): NVRAM configuration failed!\n", ha
->host_no
));
1868 qla2x00_rport_del(void *data
)
1870 fc_port_t
*fcport
= data
;
1871 struct fc_rport
*rport
;
1873 spin_lock_irq(fcport
->ha
->host
->host_lock
);
1874 rport
= fcport
->drport
;
1875 fcport
->drport
= NULL
;
1876 spin_unlock_irq(fcport
->ha
->host
->host_lock
);
1878 fc_remote_port_delete(rport
);
1882 * qla2x00_alloc_fcport() - Allocate a generic fcport.
1884 * @flags: allocation flags
1886 * Returns a pointer to the allocated fcport, or NULL, if none available.
1889 qla2x00_alloc_fcport(scsi_qla_host_t
*ha
, gfp_t flags
)
1893 fcport
= kzalloc(sizeof(fc_port_t
), flags
);
1897 /* Setup fcport template structure. */
1899 fcport
->vp_idx
= ha
->vp_idx
;
1900 fcport
->port_type
= FCT_UNKNOWN
;
1901 fcport
->loop_id
= FC_NO_LOOP_ID
;
1902 atomic_set(&fcport
->state
, FCS_UNCONFIGURED
);
1903 fcport
->flags
= FCF_RLC_SUPPORT
;
1904 fcport
->supported_classes
= FC_COS_UNSPECIFIED
;
1910 * qla2x00_configure_loop
1911 * Updates Fibre Channel Device Database with what is actually on loop.
1914 * ha = adapter block pointer.
1919 * 2 = database was full and device was not configured.
1922 qla2x00_configure_loop(scsi_qla_host_t
*ha
)
1925 unsigned long flags
, save_flags
;
1929 /* Get Initiator ID */
1930 if (test_bit(LOCAL_LOOP_UPDATE
, &ha
->dpc_flags
)) {
1931 rval
= qla2x00_configure_hba(ha
);
1932 if (rval
!= QLA_SUCCESS
) {
1933 DEBUG(printk("scsi(%ld): Unable to configure HBA.\n",
1939 save_flags
= flags
= ha
->dpc_flags
;
1940 DEBUG(printk("scsi(%ld): Configure loop -- dpc flags =0x%lx\n",
1941 ha
->host_no
, flags
));
1944 * If we have both an RSCN and PORT UPDATE pending then handle them
1945 * both at the same time.
1947 clear_bit(LOCAL_LOOP_UPDATE
, &ha
->dpc_flags
);
1948 clear_bit(RSCN_UPDATE
, &ha
->dpc_flags
);
1950 /* Determine what we need to do */
1951 if (ha
->current_topology
== ISP_CFG_FL
&&
1952 (test_bit(LOCAL_LOOP_UPDATE
, &flags
))) {
1954 ha
->flags
.rscn_queue_overflow
= 1;
1955 set_bit(RSCN_UPDATE
, &flags
);
1957 } else if (ha
->current_topology
== ISP_CFG_F
&&
1958 (test_bit(LOCAL_LOOP_UPDATE
, &flags
))) {
1960 ha
->flags
.rscn_queue_overflow
= 1;
1961 set_bit(RSCN_UPDATE
, &flags
);
1962 clear_bit(LOCAL_LOOP_UPDATE
, &flags
);
1964 } else if (ha
->current_topology
== ISP_CFG_N
) {
1965 clear_bit(RSCN_UPDATE
, &flags
);
1967 } else if (!ha
->flags
.online
||
1968 (test_bit(ABORT_ISP_ACTIVE
, &flags
))) {
1970 ha
->flags
.rscn_queue_overflow
= 1;
1971 set_bit(RSCN_UPDATE
, &flags
);
1972 set_bit(LOCAL_LOOP_UPDATE
, &flags
);
1975 if (test_bit(LOCAL_LOOP_UPDATE
, &flags
)) {
1976 if (test_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
)) {
1977 rval
= QLA_FUNCTION_FAILED
;
1979 rval
= qla2x00_configure_local_loop(ha
);
1983 if (rval
== QLA_SUCCESS
&& test_bit(RSCN_UPDATE
, &flags
)) {
1984 if (LOOP_TRANSITION(ha
)) {
1985 rval
= QLA_FUNCTION_FAILED
;
1987 rval
= qla2x00_configure_fabric(ha
);
1991 if (rval
== QLA_SUCCESS
) {
1992 if (atomic_read(&ha
->loop_down_timer
) ||
1993 test_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
)) {
1994 rval
= QLA_FUNCTION_FAILED
;
1996 atomic_set(&ha
->loop_state
, LOOP_READY
);
1998 DEBUG(printk("scsi(%ld): LOOP READY\n", ha
->host_no
));
2003 DEBUG2_3(printk("%s(%ld): *** FAILED ***\n",
2004 __func__
, ha
->host_no
));
2006 DEBUG3(printk("%s: exiting normally\n", __func__
));
2009 /* Restore state if a resync event occurred during processing */
2010 if (test_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
)) {
2011 if (test_bit(LOCAL_LOOP_UPDATE
, &save_flags
))
2012 set_bit(LOCAL_LOOP_UPDATE
, &ha
->dpc_flags
);
2013 if (test_bit(RSCN_UPDATE
, &save_flags
)) {
2014 ha
->flags
.rscn_queue_overflow
= 1;
2015 set_bit(RSCN_UPDATE
, &ha
->dpc_flags
);
2025 * qla2x00_configure_local_loop
2026 * Updates Fibre Channel Device Database with local loop devices.
2029 * ha = adapter block pointer.
2035 qla2x00_configure_local_loop(scsi_qla_host_t
*ha
)
2040 fc_port_t
*fcport
, *new_fcport
;
2046 uint8_t domain
, area
, al_pa
;
2047 scsi_qla_host_t
*pha
= to_qla_parent(ha
);
2051 entries
= MAX_FIBRE_DEVICES
;
2053 DEBUG3(printk("scsi(%ld): Getting FCAL position map\n", ha
->host_no
));
2054 DEBUG3(qla2x00_get_fcal_position_map(ha
, NULL
));
2056 /* Get list of logged in devices. */
2057 memset(ha
->gid_list
, 0, GID_LIST_SIZE
);
2058 rval
= qla2x00_get_id_list(ha
, ha
->gid_list
, ha
->gid_list_dma
,
2060 if (rval
!= QLA_SUCCESS
)
2061 goto cleanup_allocation
;
2063 DEBUG3(printk("scsi(%ld): Entries in ID list (%d)\n",
2064 ha
->host_no
, entries
));
2065 DEBUG3(qla2x00_dump_buffer((uint8_t *)ha
->gid_list
,
2066 entries
* sizeof(struct gid_list_info
)));
2068 /* Allocate temporary fcport for any new fcports discovered. */
2069 new_fcport
= qla2x00_alloc_fcport(ha
, GFP_KERNEL
);
2070 if (new_fcport
== NULL
) {
2071 rval
= QLA_MEMORY_ALLOC_FAILED
;
2072 goto cleanup_allocation
;
2074 new_fcport
->flags
&= ~FCF_FABRIC_DEVICE
;
2077 * Mark local devices that were present with FCF_DEVICE_LOST for now.
2079 list_for_each_entry(fcport
, &pha
->fcports
, list
) {
2080 if (fcport
->vp_idx
!= ha
->vp_idx
)
2083 if (atomic_read(&fcport
->state
) == FCS_ONLINE
&&
2084 fcport
->port_type
!= FCT_BROADCAST
&&
2085 (fcport
->flags
& FCF_FABRIC_DEVICE
) == 0) {
2087 DEBUG(printk("scsi(%ld): Marking port lost, "
2089 ha
->host_no
, fcport
->loop_id
));
2091 atomic_set(&fcport
->state
, FCS_DEVICE_LOST
);
2092 fcport
->flags
&= ~FCF_FARP_DONE
;
2096 /* Add devices to port list. */
2097 id_iter
= (char *)ha
->gid_list
;
2098 for (index
= 0; index
< entries
; index
++) {
2099 domain
= ((struct gid_list_info
*)id_iter
)->domain
;
2100 area
= ((struct gid_list_info
*)id_iter
)->area
;
2101 al_pa
= ((struct gid_list_info
*)id_iter
)->al_pa
;
2102 if (IS_QLA2100(ha
) || IS_QLA2200(ha
))
2103 loop_id
= (uint16_t)
2104 ((struct gid_list_info
*)id_iter
)->loop_id_2100
;
2106 loop_id
= le16_to_cpu(
2107 ((struct gid_list_info
*)id_iter
)->loop_id
);
2108 id_iter
+= ha
->gid_list_info_size
;
2110 /* Bypass reserved domain fields. */
2111 if ((domain
& 0xf0) == 0xf0)
2114 /* Bypass if not same domain and area of adapter. */
2115 if (area
&& domain
&&
2116 (area
!= ha
->d_id
.b
.area
|| domain
!= ha
->d_id
.b
.domain
))
2119 /* Bypass invalid local loop ID. */
2120 if (loop_id
> LAST_LOCAL_LOOP_ID
)
2123 /* Fill in member data. */
2124 new_fcport
->d_id
.b
.domain
= domain
;
2125 new_fcport
->d_id
.b
.area
= area
;
2126 new_fcport
->d_id
.b
.al_pa
= al_pa
;
2127 new_fcport
->loop_id
= loop_id
;
2128 new_fcport
->vp_idx
= ha
->vp_idx
;
2129 rval2
= qla2x00_get_port_database(ha
, new_fcport
, 0);
2130 if (rval2
!= QLA_SUCCESS
) {
2131 DEBUG2(printk("scsi(%ld): Failed to retrieve fcport "
2132 "information -- get_port_database=%x, "
2134 ha
->host_no
, rval2
, new_fcport
->loop_id
));
2135 DEBUG2(printk("scsi(%ld): Scheduling resync...\n",
2137 set_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
);
2141 /* Check for matching device in port list. */
2144 list_for_each_entry(fcport
, &pha
->fcports
, list
) {
2145 if (fcport
->vp_idx
!= ha
->vp_idx
)
2148 if (memcmp(new_fcport
->port_name
, fcport
->port_name
,
2152 fcport
->flags
&= ~(FCF_FABRIC_DEVICE
|
2153 FCF_PERSISTENT_BOUND
);
2154 fcport
->loop_id
= new_fcport
->loop_id
;
2155 fcport
->port_type
= new_fcport
->port_type
;
2156 fcport
->d_id
.b24
= new_fcport
->d_id
.b24
;
2157 memcpy(fcport
->node_name
, new_fcport
->node_name
,
2165 /* New device, add to fcports list. */
2166 new_fcport
->flags
&= ~FCF_PERSISTENT_BOUND
;
2168 new_fcport
->ha
= ha
;
2169 new_fcport
->vp_idx
= ha
->vp_idx
;
2170 list_add_tail(&new_fcport
->vp_fcport
,
2173 list_add_tail(&new_fcport
->list
, &pha
->fcports
);
2175 /* Allocate a new replacement fcport. */
2176 fcport
= new_fcport
;
2177 new_fcport
= qla2x00_alloc_fcport(ha
, GFP_KERNEL
);
2178 if (new_fcport
== NULL
) {
2179 rval
= QLA_MEMORY_ALLOC_FAILED
;
2180 goto cleanup_allocation
;
2182 new_fcport
->flags
&= ~FCF_FABRIC_DEVICE
;
2185 /* Base iIDMA settings on HBA port speed. */
2186 fcport
->fp_speed
= ha
->link_data_rate
;
2188 qla2x00_update_fcport(ha
, fcport
);
2196 if (rval
!= QLA_SUCCESS
) {
2197 DEBUG2(printk("scsi(%ld): Configure local loop error exit: "
2198 "rval=%x\n", ha
->host_no
, rval
));
2202 ha
->device_flags
|= DFLG_LOCAL_DEVICES
;
2203 ha
->device_flags
&= ~DFLG_RETRY_LOCAL_DEVICES
;
2210 qla2x00_iidma_fcport(scsi_qla_host_t
*ha
, fc_port_t
*fcport
)
2212 #define LS_UNKNOWN 2
2213 static char *link_speeds
[5] = { "1", "2", "?", "4", "8" };
2217 if (!IS_IIDMA_CAPABLE(ha
))
2220 if (fcport
->fp_speed
== PORT_SPEED_UNKNOWN
||
2221 fcport
->fp_speed
> ha
->link_data_rate
)
2224 rval
= qla2x00_set_idma_speed(ha
, fcport
->loop_id
, fcport
->fp_speed
,
2226 if (rval
!= QLA_SUCCESS
) {
2227 DEBUG2(printk("scsi(%ld): Unable to adjust iIDMA "
2228 "%02x%02x%02x%02x%02x%02x%02x%02x -- %04x %x %04x %04x.\n",
2229 ha
->host_no
, fcport
->port_name
[0], fcport
->port_name
[1],
2230 fcport
->port_name
[2], fcport
->port_name
[3],
2231 fcport
->port_name
[4], fcport
->port_name
[5],
2232 fcport
->port_name
[6], fcport
->port_name
[7], rval
,
2233 fcport
->fp_speed
, mb
[0], mb
[1]));
2235 DEBUG2(qla_printk(KERN_INFO
, ha
,
2236 "iIDMA adjusted to %s GB/s on "
2237 "%02x%02x%02x%02x%02x%02x%02x%02x.\n",
2238 link_speeds
[fcport
->fp_speed
], fcport
->port_name
[0],
2239 fcport
->port_name
[1], fcport
->port_name
[2],
2240 fcport
->port_name
[3], fcport
->port_name
[4],
2241 fcport
->port_name
[5], fcport
->port_name
[6],
2242 fcport
->port_name
[7]));
2247 qla2x00_reg_remote_port(scsi_qla_host_t
*ha
, fc_port_t
*fcport
)
2249 struct fc_rport_identifiers rport_ids
;
2250 struct fc_rport
*rport
;
2253 qla2x00_rport_del(fcport
);
2255 rport_ids
.node_name
= wwn_to_u64(fcport
->node_name
);
2256 rport_ids
.port_name
= wwn_to_u64(fcport
->port_name
);
2257 rport_ids
.port_id
= fcport
->d_id
.b
.domain
<< 16 |
2258 fcport
->d_id
.b
.area
<< 8 | fcport
->d_id
.b
.al_pa
;
2259 rport_ids
.roles
= FC_RPORT_ROLE_UNKNOWN
;
2260 fcport
->rport
= rport
= fc_remote_port_add(ha
->host
, 0, &rport_ids
);
2262 qla_printk(KERN_WARNING
, ha
,
2263 "Unable to allocate fc remote port!\n");
2266 spin_lock_irq(fcport
->ha
->host
->host_lock
);
2267 *((fc_port_t
**)rport
->dd_data
) = fcport
;
2268 spin_unlock_irq(fcport
->ha
->host
->host_lock
);
2270 rport
->supported_classes
= fcport
->supported_classes
;
2272 rport_ids
.roles
= FC_RPORT_ROLE_UNKNOWN
;
2273 if (fcport
->port_type
== FCT_INITIATOR
)
2274 rport_ids
.roles
|= FC_RPORT_ROLE_FCP_INITIATOR
;
2275 if (fcport
->port_type
== FCT_TARGET
)
2276 rport_ids
.roles
|= FC_RPORT_ROLE_FCP_TARGET
;
2277 fc_remote_port_rolechg(rport
, rport_ids
.roles
);
2281 * qla2x00_update_fcport
2282 * Updates device on list.
2285 * ha = adapter block pointer.
2286 * fcport = port structure pointer.
2296 qla2x00_update_fcport(scsi_qla_host_t
*ha
, fc_port_t
*fcport
)
2298 scsi_qla_host_t
*pha
= to_qla_parent(ha
);
2301 fcport
->login_retry
= 0;
2302 fcport
->port_login_retry_count
= pha
->port_down_retry_count
*
2304 atomic_set(&fcport
->port_down_timer
, pha
->port_down_retry_count
*
2306 fcport
->flags
&= ~FCF_LOGIN_NEEDED
;
2308 qla2x00_iidma_fcport(ha
, fcport
);
2310 atomic_set(&fcport
->state
, FCS_ONLINE
);
2312 qla2x00_reg_remote_port(ha
, fcport
);
2316 * qla2x00_configure_fabric
2317 * Setup SNS devices with loop ID's.
2320 * ha = adapter block pointer.
2327 qla2x00_configure_fabric(scsi_qla_host_t
*ha
)
2330 fc_port_t
*fcport
, *fcptemp
;
2331 uint16_t next_loopid
;
2332 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2334 LIST_HEAD(new_fcports
);
2335 scsi_qla_host_t
*pha
= to_qla_parent(ha
);
2337 /* If FL port exists, then SNS is present */
2338 if (IS_FWI2_CAPABLE(ha
))
2339 loop_id
= NPH_F_PORT
;
2341 loop_id
= SNS_FL_PORT
;
2342 rval
= qla2x00_get_port_name(ha
, loop_id
, ha
->fabric_node_name
, 1);
2343 if (rval
!= QLA_SUCCESS
) {
2344 DEBUG2(printk("scsi(%ld): MBC_GET_PORT_NAME Failed, No FL "
2345 "Port\n", ha
->host_no
));
2347 ha
->device_flags
&= ~SWITCH_FOUND
;
2348 return (QLA_SUCCESS
);
2350 ha
->device_flags
|= SWITCH_FOUND
;
2352 /* Mark devices that need re-synchronization. */
2353 rval2
= qla2x00_device_resync(ha
);
2354 if (rval2
== QLA_RSCNS_HANDLED
) {
2355 /* No point doing the scan, just continue. */
2356 return (QLA_SUCCESS
);
2360 if (ql2xfdmienable
&&
2361 test_and_clear_bit(REGISTER_FDMI_NEEDED
, &ha
->dpc_flags
))
2362 qla2x00_fdmi_register(ha
);
2364 /* Ensure we are logged into the SNS. */
2365 if (IS_FWI2_CAPABLE(ha
))
2368 loop_id
= SIMPLE_NAME_SERVER
;
2369 ha
->isp_ops
->fabric_login(ha
, loop_id
, 0xff, 0xff,
2370 0xfc, mb
, BIT_1
| BIT_0
);
2371 if (mb
[0] != MBS_COMMAND_COMPLETE
) {
2372 DEBUG2(qla_printk(KERN_INFO
, ha
,
2373 "Failed SNS login: loop_id=%x mb[0]=%x mb[1]=%x "
2374 "mb[2]=%x mb[6]=%x mb[7]=%x\n", loop_id
,
2375 mb
[0], mb
[1], mb
[2], mb
[6], mb
[7]));
2376 return (QLA_SUCCESS
);
2379 if (test_and_clear_bit(REGISTER_FC4_NEEDED
, &ha
->dpc_flags
)) {
2380 if (qla2x00_rft_id(ha
)) {
2382 DEBUG2(printk("scsi(%ld): Register FC-4 "
2383 "TYPE failed.\n", ha
->host_no
));
2385 if (qla2x00_rff_id(ha
)) {
2387 DEBUG2(printk("scsi(%ld): Register FC-4 "
2388 "Features failed.\n", ha
->host_no
));
2390 if (qla2x00_rnn_id(ha
)) {
2392 DEBUG2(printk("scsi(%ld): Register Node Name "
2393 "failed.\n", ha
->host_no
));
2394 } else if (qla2x00_rsnn_nn(ha
)) {
2396 DEBUG2(printk("scsi(%ld): Register Symbolic "
2397 "Node Name failed.\n", ha
->host_no
));
2401 rval
= qla2x00_find_all_fabric_devs(ha
, &new_fcports
);
2402 if (rval
!= QLA_SUCCESS
)
2406 * Logout all previous fabric devices marked lost, except
2409 list_for_each_entry(fcport
, &pha
->fcports
, list
) {
2410 if (fcport
->vp_idx
!=ha
->vp_idx
)
2413 if (test_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
))
2416 if ((fcport
->flags
& FCF_FABRIC_DEVICE
) == 0)
2419 if (atomic_read(&fcport
->state
) == FCS_DEVICE_LOST
) {
2420 qla2x00_mark_device_lost(ha
, fcport
,
2421 ql2xplogiabsentdevice
, 0);
2422 if (fcport
->loop_id
!= FC_NO_LOOP_ID
&&
2423 (fcport
->flags
& FCF_TAPE_PRESENT
) == 0 &&
2424 fcport
->port_type
!= FCT_INITIATOR
&&
2425 fcport
->port_type
!= FCT_BROADCAST
) {
2426 ha
->isp_ops
->fabric_logout(ha
,
2428 fcport
->d_id
.b
.domain
,
2429 fcport
->d_id
.b
.area
,
2430 fcport
->d_id
.b
.al_pa
);
2431 fcport
->loop_id
= FC_NO_LOOP_ID
;
2436 /* Starting free loop ID. */
2437 next_loopid
= pha
->min_external_loopid
;
2440 * Scan through our port list and login entries that need to be
2443 list_for_each_entry(fcport
, &pha
->fcports
, list
) {
2444 if (fcport
->vp_idx
!= ha
->vp_idx
)
2447 if (atomic_read(&ha
->loop_down_timer
) ||
2448 test_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
))
2451 if ((fcport
->flags
& FCF_FABRIC_DEVICE
) == 0 ||
2452 (fcport
->flags
& FCF_LOGIN_NEEDED
) == 0)
2455 if (fcport
->loop_id
== FC_NO_LOOP_ID
) {
2456 fcport
->loop_id
= next_loopid
;
2457 rval
= qla2x00_find_new_loop_id(
2458 to_qla_parent(ha
), fcport
);
2459 if (rval
!= QLA_SUCCESS
) {
2460 /* Ran out of IDs to use */
2464 /* Login and update database */
2465 qla2x00_fabric_dev_login(ha
, fcport
, &next_loopid
);
2468 /* Exit if out of loop IDs. */
2469 if (rval
!= QLA_SUCCESS
) {
2474 * Login and add the new devices to our port list.
2476 list_for_each_entry_safe(fcport
, fcptemp
, &new_fcports
, list
) {
2477 if (atomic_read(&ha
->loop_down_timer
) ||
2478 test_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
))
2481 /* Find a new loop ID to use. */
2482 fcport
->loop_id
= next_loopid
;
2483 rval
= qla2x00_find_new_loop_id(to_qla_parent(ha
),
2485 if (rval
!= QLA_SUCCESS
) {
2486 /* Ran out of IDs to use */
2490 /* Login and update database */
2491 qla2x00_fabric_dev_login(ha
, fcport
, &next_loopid
);
2495 fcport
->vp_idx
= ha
->vp_idx
;
2496 list_add_tail(&fcport
->vp_fcport
,
2498 list_move_tail(&fcport
->list
,
2499 &ha
->parent
->fcports
);
2501 list_move_tail(&fcport
->list
, &ha
->fcports
);
2505 /* Free all new device structures not processed. */
2506 list_for_each_entry_safe(fcport
, fcptemp
, &new_fcports
, list
) {
2507 list_del(&fcport
->list
);
2512 DEBUG2(printk("scsi(%ld): Configure fabric error exit: "
2513 "rval=%d\n", ha
->host_no
, rval
));
2521 * qla2x00_find_all_fabric_devs
2524 * ha = adapter block pointer.
2525 * dev = database device entry pointer.
2534 qla2x00_find_all_fabric_devs(scsi_qla_host_t
*ha
, struct list_head
*new_fcports
)
2538 fc_port_t
*fcport
, *new_fcport
, *fcptemp
;
2543 int first_dev
, last_dev
;
2544 port_id_t wrap
, nxt_d_id
;
2548 scsi_qla_host_t
*vha
;
2549 scsi_qla_host_t
*pha
= to_qla_parent(ha
);
2553 /* Try GID_PT to get device list, else GAN. */
2554 swl
= kcalloc(MAX_FIBRE_DEVICES
, sizeof(sw_info_t
), GFP_KERNEL
);
2557 DEBUG2(printk("scsi(%ld): GID_PT allocations failed, fallback "
2558 "on GA_NXT\n", ha
->host_no
));
2560 if (qla2x00_gid_pt(ha
, swl
) != QLA_SUCCESS
) {
2563 } else if (qla2x00_gpn_id(ha
, swl
) != QLA_SUCCESS
) {
2566 } else if (qla2x00_gnn_id(ha
, swl
) != QLA_SUCCESS
) {
2569 } else if (ql2xiidmaenable
&&
2570 qla2x00_gfpn_id(ha
, swl
) == QLA_SUCCESS
) {
2571 qla2x00_gpsc(ha
, swl
);
2576 /* Allocate temporary fcport for any new fcports discovered. */
2577 new_fcport
= qla2x00_alloc_fcport(ha
, GFP_KERNEL
);
2578 if (new_fcport
== NULL
) {
2580 return (QLA_MEMORY_ALLOC_FAILED
);
2582 new_fcport
->flags
|= (FCF_FABRIC_DEVICE
| FCF_LOGIN_NEEDED
);
2583 new_fcport
->vp_idx
= ha
->vp_idx
;
2584 /* Set start port ID scan at adapter ID. */
2588 /* Starting free loop ID. */
2589 loop_id
= pha
->min_external_loopid
;
2590 for (; loop_id
<= ha
->last_loop_id
; loop_id
++) {
2591 if (qla2x00_is_reserved_id(ha
, loop_id
))
2594 if (atomic_read(&ha
->loop_down_timer
) || LOOP_TRANSITION(ha
))
2599 wrap
.b24
= new_fcport
->d_id
.b24
;
2601 new_fcport
->d_id
.b24
= swl
[swl_idx
].d_id
.b24
;
2602 memcpy(new_fcport
->node_name
,
2603 swl
[swl_idx
].node_name
, WWN_SIZE
);
2604 memcpy(new_fcport
->port_name
,
2605 swl
[swl_idx
].port_name
, WWN_SIZE
);
2606 memcpy(new_fcport
->fabric_port_name
,
2607 swl
[swl_idx
].fabric_port_name
, WWN_SIZE
);
2608 new_fcport
->fp_speed
= swl
[swl_idx
].fp_speed
;
2610 if (swl
[swl_idx
].d_id
.b
.rsvd_1
!= 0) {
2616 /* Send GA_NXT to the switch */
2617 rval
= qla2x00_ga_nxt(ha
, new_fcport
);
2618 if (rval
!= QLA_SUCCESS
) {
2619 qla_printk(KERN_WARNING
, ha
,
2620 "SNS scan failed -- assuming zero-entry "
2622 list_for_each_entry_safe(fcport
, fcptemp
,
2623 new_fcports
, list
) {
2624 list_del(&fcport
->list
);
2632 /* If wrap on switch device list, exit. */
2634 wrap
.b24
= new_fcport
->d_id
.b24
;
2636 } else if (new_fcport
->d_id
.b24
== wrap
.b24
) {
2637 DEBUG2(printk("scsi(%ld): device wrap (%02x%02x%02x)\n",
2638 ha
->host_no
, new_fcport
->d_id
.b
.domain
,
2639 new_fcport
->d_id
.b
.area
, new_fcport
->d_id
.b
.al_pa
));
2643 /* Bypass if same physical adapter. */
2644 if (new_fcport
->d_id
.b24
== pha
->d_id
.b24
)
2647 /* Bypass virtual ports of the same host. */
2648 if (pha
->num_vhosts
) {
2649 for_each_mapped_vp_idx(pha
, vp_index
) {
2652 list_for_each_entry(vha
, &pha
->vp_list
,
2654 if (vp_index
== vha
->vp_idx
) {
2665 new_fcport
->d_id
.b24
== vha
->d_id
.b24
)
2669 if (vp_index
<= pha
->max_npiv_vports
)
2673 /* Bypass if same domain and area of adapter. */
2674 if (((new_fcport
->d_id
.b24
& 0xffff00) ==
2675 (ha
->d_id
.b24
& 0xffff00)) && ha
->current_topology
==
2679 /* Bypass reserved domain fields. */
2680 if ((new_fcport
->d_id
.b
.domain
& 0xf0) == 0xf0)
2683 /* Locate matching device in database. */
2685 list_for_each_entry(fcport
, &pha
->fcports
, list
) {
2686 if (new_fcport
->vp_idx
!= fcport
->vp_idx
)
2688 if (memcmp(new_fcport
->port_name
, fcport
->port_name
,
2694 /* Update port state. */
2695 memcpy(fcport
->fabric_port_name
,
2696 new_fcport
->fabric_port_name
, WWN_SIZE
);
2697 fcport
->fp_speed
= new_fcport
->fp_speed
;
2700 * If address the same and state FCS_ONLINE, nothing
2703 if (fcport
->d_id
.b24
== new_fcport
->d_id
.b24
&&
2704 atomic_read(&fcport
->state
) == FCS_ONLINE
) {
2709 * If device was not a fabric device before.
2711 if ((fcport
->flags
& FCF_FABRIC_DEVICE
) == 0) {
2712 fcport
->d_id
.b24
= new_fcport
->d_id
.b24
;
2713 fcport
->loop_id
= FC_NO_LOOP_ID
;
2714 fcport
->flags
|= (FCF_FABRIC_DEVICE
|
2716 fcport
->flags
&= ~FCF_PERSISTENT_BOUND
;
2721 * Port ID changed or device was marked to be updated;
2722 * Log it out if still logged in and mark it for
2725 fcport
->d_id
.b24
= new_fcport
->d_id
.b24
;
2726 fcport
->flags
|= FCF_LOGIN_NEEDED
;
2727 if (fcport
->loop_id
!= FC_NO_LOOP_ID
&&
2728 (fcport
->flags
& FCF_TAPE_PRESENT
) == 0 &&
2729 fcport
->port_type
!= FCT_INITIATOR
&&
2730 fcport
->port_type
!= FCT_BROADCAST
) {
2731 ha
->isp_ops
->fabric_logout(ha
, fcport
->loop_id
,
2732 fcport
->d_id
.b
.domain
, fcport
->d_id
.b
.area
,
2733 fcport
->d_id
.b
.al_pa
);
2734 fcport
->loop_id
= FC_NO_LOOP_ID
;
2743 /* If device was not in our fcports list, then add it. */
2744 list_add_tail(&new_fcport
->list
, new_fcports
);
2746 /* Allocate a new replacement fcport. */
2747 nxt_d_id
.b24
= new_fcport
->d_id
.b24
;
2748 new_fcport
= qla2x00_alloc_fcport(ha
, GFP_KERNEL
);
2749 if (new_fcport
== NULL
) {
2751 return (QLA_MEMORY_ALLOC_FAILED
);
2753 new_fcport
->flags
|= (FCF_FABRIC_DEVICE
| FCF_LOGIN_NEEDED
);
2754 new_fcport
->d_id
.b24
= nxt_d_id
.b24
;
2755 new_fcport
->vp_idx
= ha
->vp_idx
;
2761 if (!list_empty(new_fcports
))
2762 ha
->device_flags
|= DFLG_FABRIC_DEVICES
;
2768 * qla2x00_find_new_loop_id
2769 * Scan through our port list and find a new usable loop ID.
2772 * ha: adapter state pointer.
2773 * dev: port structure pointer.
2776 * qla2x00 local function return status code.
2782 qla2x00_find_new_loop_id(scsi_qla_host_t
*ha
, fc_port_t
*dev
)
2787 uint16_t first_loop_id
;
2788 scsi_qla_host_t
*pha
= to_qla_parent(ha
);
2792 /* Save starting loop ID. */
2793 first_loop_id
= dev
->loop_id
;
2796 /* Skip loop ID if already used by adapter. */
2797 if (dev
->loop_id
== ha
->loop_id
) {
2801 /* Skip reserved loop IDs. */
2802 while (qla2x00_is_reserved_id(ha
, dev
->loop_id
)) {
2806 /* Reset loop ID if passed the end. */
2807 if (dev
->loop_id
> ha
->last_loop_id
) {
2808 /* first loop ID. */
2809 dev
->loop_id
= ha
->min_external_loopid
;
2812 /* Check for loop ID being already in use. */
2815 list_for_each_entry(fcport
, &pha
->fcports
, list
) {
2816 if (fcport
->loop_id
== dev
->loop_id
&& fcport
!= dev
) {
2817 /* ID possibly in use */
2823 /* If not in use then it is free to use. */
2828 /* ID in use. Try next value. */
2831 /* If wrap around. No free ID to use. */
2832 if (dev
->loop_id
== first_loop_id
) {
2833 dev
->loop_id
= FC_NO_LOOP_ID
;
2834 rval
= QLA_FUNCTION_FAILED
;
2843 * qla2x00_device_resync
2844 * Marks devices in the database that needs resynchronization.
2847 * ha = adapter block pointer.
2853 qla2x00_device_resync(scsi_qla_host_t
*ha
)
2858 uint32_t rscn_entry
;
2859 uint8_t rscn_out_iter
;
2862 scsi_qla_host_t
*pha
= to_qla_parent(ha
);
2864 rval
= QLA_RSCNS_HANDLED
;
2866 while (ha
->rscn_out_ptr
!= ha
->rscn_in_ptr
||
2867 ha
->flags
.rscn_queue_overflow
) {
2869 rscn_entry
= ha
->rscn_queue
[ha
->rscn_out_ptr
];
2870 format
= MSB(MSW(rscn_entry
));
2871 d_id
.b
.domain
= LSB(MSW(rscn_entry
));
2872 d_id
.b
.area
= MSB(LSW(rscn_entry
));
2873 d_id
.b
.al_pa
= LSB(LSW(rscn_entry
));
2875 DEBUG(printk("scsi(%ld): RSCN queue entry[%d] = "
2876 "[%02x/%02x%02x%02x].\n",
2877 ha
->host_no
, ha
->rscn_out_ptr
, format
, d_id
.b
.domain
,
2878 d_id
.b
.area
, d_id
.b
.al_pa
));
2881 if (ha
->rscn_out_ptr
== MAX_RSCN_COUNT
)
2882 ha
->rscn_out_ptr
= 0;
2884 /* Skip duplicate entries. */
2885 for (rscn_out_iter
= ha
->rscn_out_ptr
;
2886 !ha
->flags
.rscn_queue_overflow
&&
2887 rscn_out_iter
!= ha
->rscn_in_ptr
;
2888 rscn_out_iter
= (rscn_out_iter
==
2889 (MAX_RSCN_COUNT
- 1)) ? 0: rscn_out_iter
+ 1) {
2891 if (rscn_entry
!= ha
->rscn_queue
[rscn_out_iter
])
2894 DEBUG(printk("scsi(%ld): Skipping duplicate RSCN queue "
2895 "entry found at [%d].\n", ha
->host_no
,
2898 ha
->rscn_out_ptr
= rscn_out_iter
;
2901 /* Queue overflow, set switch default case. */
2902 if (ha
->flags
.rscn_queue_overflow
) {
2903 DEBUG(printk("scsi(%ld): device_resync: rscn "
2904 "overflow.\n", ha
->host_no
));
2907 ha
->flags
.rscn_queue_overflow
= 0;
2923 ha
->rscn_out_ptr
= ha
->rscn_in_ptr
;
2929 list_for_each_entry(fcport
, &pha
->fcports
, list
) {
2930 if (fcport
->vp_idx
!= ha
->vp_idx
)
2933 if ((fcport
->flags
& FCF_FABRIC_DEVICE
) == 0 ||
2934 (fcport
->d_id
.b24
& mask
) != d_id
.b24
||
2935 fcport
->port_type
== FCT_BROADCAST
)
2938 if (atomic_read(&fcport
->state
) == FCS_ONLINE
) {
2940 fcport
->port_type
!= FCT_INITIATOR
) {
2941 qla2x00_mark_device_lost(ha
, fcport
,
2945 fcport
->flags
&= ~FCF_FARP_DONE
;
2952 * qla2x00_fabric_dev_login
2953 * Login fabric target device and update FC port database.
2956 * ha: adapter state pointer.
2957 * fcport: port structure list pointer.
2958 * next_loopid: contains value of a new loop ID that can be used
2959 * by the next login attempt.
2962 * qla2x00 local function return status code.
2968 qla2x00_fabric_dev_login(scsi_qla_host_t
*ha
, fc_port_t
*fcport
,
2969 uint16_t *next_loopid
)
2978 rval
= qla2x00_fabric_login(ha
, fcport
, next_loopid
);
2979 if (rval
== QLA_SUCCESS
) {
2980 /* Send an ADISC to tape devices.*/
2982 if (fcport
->flags
& FCF_TAPE_PRESENT
)
2984 rval
= qla2x00_get_port_database(ha
, fcport
, opts
);
2985 if (rval
!= QLA_SUCCESS
) {
2986 ha
->isp_ops
->fabric_logout(ha
, fcport
->loop_id
,
2987 fcport
->d_id
.b
.domain
, fcport
->d_id
.b
.area
,
2988 fcport
->d_id
.b
.al_pa
);
2989 qla2x00_mark_device_lost(ha
, fcport
, 1, 0);
2991 qla2x00_update_fcport(ha
, fcport
);
2999 * qla2x00_fabric_login
3000 * Issue fabric login command.
3003 * ha = adapter block pointer.
3004 * device = pointer to FC device type structure.
3007 * 0 - Login successfully
3009 * 2 - Initiator device
3013 qla2x00_fabric_login(scsi_qla_host_t
*ha
, fc_port_t
*fcport
,
3014 uint16_t *next_loopid
)
3018 uint16_t tmp_loopid
;
3019 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
3025 DEBUG(printk("scsi(%ld): Trying Fabric Login w/loop id 0x%04x "
3026 "for port %02x%02x%02x.\n",
3027 ha
->host_no
, fcport
->loop_id
, fcport
->d_id
.b
.domain
,
3028 fcport
->d_id
.b
.area
, fcport
->d_id
.b
.al_pa
));
3030 /* Login fcport on switch. */
3031 ha
->isp_ops
->fabric_login(ha
, fcport
->loop_id
,
3032 fcport
->d_id
.b
.domain
, fcport
->d_id
.b
.area
,
3033 fcport
->d_id
.b
.al_pa
, mb
, BIT_0
);
3034 if (mb
[0] == MBS_PORT_ID_USED
) {
3036 * Device has another loop ID. The firmware team
3037 * recommends the driver perform an implicit login with
3038 * the specified ID again. The ID we just used is save
3039 * here so we return with an ID that can be tried by
3043 tmp_loopid
= fcport
->loop_id
;
3044 fcport
->loop_id
= mb
[1];
3046 DEBUG(printk("Fabric Login: port in use - next "
3047 "loop id=0x%04x, port Id=%02x%02x%02x.\n",
3048 fcport
->loop_id
, fcport
->d_id
.b
.domain
,
3049 fcport
->d_id
.b
.area
, fcport
->d_id
.b
.al_pa
));
3051 } else if (mb
[0] == MBS_COMMAND_COMPLETE
) {
3056 /* A retry occurred before. */
3057 *next_loopid
= tmp_loopid
;
3060 * No retry occurred before. Just increment the
3061 * ID value for next login.
3063 *next_loopid
= (fcport
->loop_id
+ 1);
3066 if (mb
[1] & BIT_0
) {
3067 fcport
->port_type
= FCT_INITIATOR
;
3069 fcport
->port_type
= FCT_TARGET
;
3070 if (mb
[1] & BIT_1
) {
3071 fcport
->flags
|= FCF_TAPE_PRESENT
;
3076 fcport
->supported_classes
|= FC_COS_CLASS2
;
3078 fcport
->supported_classes
|= FC_COS_CLASS3
;
3082 } else if (mb
[0] == MBS_LOOP_ID_USED
) {
3084 * Loop ID already used, try next loop ID.
3087 rval
= qla2x00_find_new_loop_id(ha
, fcport
);
3088 if (rval
!= QLA_SUCCESS
) {
3089 /* Ran out of loop IDs to use */
3092 } else if (mb
[0] == MBS_COMMAND_ERROR
) {
3094 * Firmware possibly timed out during login. If NO
3095 * retries are left to do then the device is declared
3098 *next_loopid
= fcport
->loop_id
;
3099 ha
->isp_ops
->fabric_logout(ha
, fcport
->loop_id
,
3100 fcport
->d_id
.b
.domain
, fcport
->d_id
.b
.area
,
3101 fcport
->d_id
.b
.al_pa
);
3102 qla2x00_mark_device_lost(ha
, fcport
, 1, 0);
3108 * unrecoverable / not handled error
3110 DEBUG2(printk("%s(%ld): failed=%x port_id=%02x%02x%02x "
3111 "loop_id=%x jiffies=%lx.\n",
3112 __func__
, ha
->host_no
, mb
[0],
3113 fcport
->d_id
.b
.domain
, fcport
->d_id
.b
.area
,
3114 fcport
->d_id
.b
.al_pa
, fcport
->loop_id
, jiffies
));
3116 *next_loopid
= fcport
->loop_id
;
3117 ha
->isp_ops
->fabric_logout(ha
, fcport
->loop_id
,
3118 fcport
->d_id
.b
.domain
, fcport
->d_id
.b
.area
,
3119 fcport
->d_id
.b
.al_pa
);
3120 fcport
->loop_id
= FC_NO_LOOP_ID
;
3121 fcport
->login_retry
= 0;
3132 * qla2x00_local_device_login
3133 * Issue local device login command.
3136 * ha = adapter block pointer.
3137 * loop_id = loop id of device to login to.
3139 * Returns (Where's the #define!!!!):
3140 * 0 - Login successfully
3145 qla2x00_local_device_login(scsi_qla_host_t
*ha
, fc_port_t
*fcport
)
3148 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
3150 memset(mb
, 0, sizeof(mb
));
3151 rval
= qla2x00_login_local_device(ha
, fcport
, mb
, BIT_0
);
3152 if (rval
== QLA_SUCCESS
) {
3153 /* Interrogate mailbox registers for any errors */
3154 if (mb
[0] == MBS_COMMAND_ERROR
)
3156 else if (mb
[0] == MBS_COMMAND_PARAMETER_ERROR
)
3157 /* device not in PCB table */
3165 * qla2x00_loop_resync
3166 * Resync with fibre channel devices.
3169 * ha = adapter block pointer.
3175 qla2x00_loop_resync(scsi_qla_host_t
*ha
)
3182 atomic_set(&ha
->loop_state
, LOOP_UPDATE
);
3183 clear_bit(ISP_ABORT_RETRY
, &ha
->dpc_flags
);
3184 if (ha
->flags
.online
) {
3185 if (!(rval
= qla2x00_fw_ready(ha
))) {
3186 /* Wait at most MAX_TARGET RSCNs for a stable link. */
3189 atomic_set(&ha
->loop_state
, LOOP_UPDATE
);
3191 /* Issue a marker after FW becomes ready. */
3192 qla2x00_marker(ha
, 0, 0, MK_SYNC_ALL
);
3193 ha
->marker_needed
= 0;
3195 /* Remap devices on Loop. */
3196 clear_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
);
3198 qla2x00_configure_loop(ha
);
3200 } while (!atomic_read(&ha
->loop_down_timer
) &&
3201 !(test_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
)) &&
3203 (test_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
)));
3207 if (test_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
)) {
3208 return (QLA_FUNCTION_FAILED
);
3212 DEBUG2_3(printk("%s(): **** FAILED ****\n", __func__
));
3219 qla2x00_update_fcports(scsi_qla_host_t
*ha
)
3223 /* Go with deferred removal of rport references. */
3224 list_for_each_entry(fcport
, &ha
->fcports
, list
)
3225 if (fcport
->drport
&&
3226 atomic_read(&fcport
->state
) != FCS_UNCONFIGURED
)
3227 qla2x00_rport_del(fcport
);
3232 * Resets ISP and aborts all outstanding commands.
3235 * ha = adapter block pointer.
3241 qla2x00_abort_isp(scsi_qla_host_t
*ha
)
3245 scsi_qla_host_t
*vha
;
3247 if (ha
->flags
.online
) {
3248 ha
->flags
.online
= 0;
3249 clear_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
);
3250 ha
->qla_stats
.total_isp_aborts
++;
3252 qla_printk(KERN_INFO
, ha
,
3253 "Performing ISP error recovery - ha= %p.\n", ha
);
3254 ha
->isp_ops
->reset_chip(ha
);
3256 atomic_set(&ha
->loop_down_timer
, LOOP_DOWN_TIME
);
3257 if (atomic_read(&ha
->loop_state
) != LOOP_DOWN
) {
3258 atomic_set(&ha
->loop_state
, LOOP_DOWN
);
3259 qla2x00_mark_all_devices_lost(ha
, 0);
3260 list_for_each_entry(vha
, &ha
->vp_list
, vp_list
)
3261 qla2x00_mark_all_devices_lost(vha
, 0);
3263 if (!atomic_read(&ha
->loop_down_timer
))
3264 atomic_set(&ha
->loop_down_timer
,
3268 /* Requeue all commands in outstanding command list. */
3269 qla2x00_abort_all_cmds(ha
, DID_RESET
<< 16);
3271 ha
->isp_ops
->get_flash_version(ha
, ha
->request_ring
);
3273 ha
->isp_ops
->nvram_config(ha
);
3275 if (!qla2x00_restart_isp(ha
)) {
3276 clear_bit(RESET_MARKER_NEEDED
, &ha
->dpc_flags
);
3278 if (!atomic_read(&ha
->loop_down_timer
)) {
3280 * Issue marker command only when we are going
3281 * to start the I/O .
3283 ha
->marker_needed
= 1;
3286 ha
->flags
.online
= 1;
3288 ha
->isp_ops
->enable_intrs(ha
);
3290 ha
->isp_abort_cnt
= 0;
3291 clear_bit(ISP_ABORT_RETRY
, &ha
->dpc_flags
);
3294 ha
->flags
.fce_enabled
= 1;
3296 fce_calc_size(ha
->fce_bufs
));
3297 rval
= qla2x00_enable_fce_trace(ha
,
3298 ha
->fce_dma
, ha
->fce_bufs
, ha
->fce_mb
,
3301 qla_printk(KERN_WARNING
, ha
,
3302 "Unable to reinitialize FCE "
3304 ha
->flags
.fce_enabled
= 0;
3309 memset(ha
->eft
, 0, EFT_SIZE
);
3310 rval
= qla2x00_enable_eft_trace(ha
,
3311 ha
->eft_dma
, EFT_NUM_BUFFERS
);
3313 qla_printk(KERN_WARNING
, ha
,
3314 "Unable to reinitialize EFT "
3318 } else { /* failed the ISP abort */
3319 ha
->flags
.online
= 1;
3320 if (test_bit(ISP_ABORT_RETRY
, &ha
->dpc_flags
)) {
3321 if (ha
->isp_abort_cnt
== 0) {
3322 qla_printk(KERN_WARNING
, ha
,
3323 "ISP error recovery failed - "
3324 "board disabled\n");
3326 * The next call disables the board
3329 ha
->isp_ops
->reset_adapter(ha
);
3330 ha
->flags
.online
= 0;
3331 clear_bit(ISP_ABORT_RETRY
,
3334 } else { /* schedule another ISP abort */
3335 ha
->isp_abort_cnt
--;
3336 DEBUG(printk("qla%ld: ISP abort - "
3337 "retry remaining %d\n",
3338 ha
->host_no
, ha
->isp_abort_cnt
));
3342 ha
->isp_abort_cnt
= MAX_RETRIES_OF_ISP_ABORT
;
3343 DEBUG(printk("qla2x00(%ld): ISP error recovery "
3344 "- retrying (%d) more times\n",
3345 ha
->host_no
, ha
->isp_abort_cnt
));
3346 set_bit(ISP_ABORT_RETRY
, &ha
->dpc_flags
);
3354 qla_printk(KERN_INFO
, ha
,
3355 "qla2x00_abort_isp: **** FAILED ****\n");
3357 DEBUG(printk(KERN_INFO
3358 "qla2x00_abort_isp(%ld): exiting.\n",
3366 * qla2x00_restart_isp
3367 * restarts the ISP after a reset
3370 * ha = adapter block pointer.
3376 qla2x00_restart_isp(scsi_qla_host_t
*ha
)
3381 /* If firmware needs to be loaded */
3382 if (qla2x00_isp_firmware(ha
)) {
3383 ha
->flags
.online
= 0;
3384 if (!(status
= ha
->isp_ops
->chip_diag(ha
)))
3385 status
= qla2x00_setup_chip(ha
);
3388 if (!status
&& !(status
= qla2x00_init_rings(ha
))) {
3389 clear_bit(RESET_MARKER_NEEDED
, &ha
->dpc_flags
);
3390 if (!(status
= qla2x00_fw_ready(ha
))) {
3391 DEBUG(printk("%s(): Start configure loop, "
3392 "status = %d\n", __func__
, status
));
3394 /* Issue a marker after FW becomes ready. */
3395 qla2x00_marker(ha
, 0, 0, MK_SYNC_ALL
);
3397 ha
->flags
.online
= 1;
3398 /* Wait at most MAX_TARGET RSCNs for a stable link. */
3401 clear_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
);
3402 qla2x00_configure_loop(ha
);
3404 } while (!atomic_read(&ha
->loop_down_timer
) &&
3405 !(test_bit(ISP_ABORT_NEEDED
, &ha
->dpc_flags
)) &&
3407 (test_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
)));
3410 /* if no cable then assume it's good */
3411 if ((ha
->device_flags
& DFLG_NO_CABLE
))
3414 DEBUG(printk("%s(): Configure loop done, status = 0x%x\n",
3422 * qla2x00_reset_adapter
3426 * ha = adapter block pointer.
3429 qla2x00_reset_adapter(scsi_qla_host_t
*ha
)
3431 unsigned long flags
= 0;
3432 struct device_reg_2xxx __iomem
*reg
= &ha
->iobase
->isp
;
3434 ha
->flags
.online
= 0;
3435 ha
->isp_ops
->disable_intrs(ha
);
3437 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
3438 WRT_REG_WORD(®
->hccr
, HCCR_RESET_RISC
);
3439 RD_REG_WORD(®
->hccr
); /* PCI Posting. */
3440 WRT_REG_WORD(®
->hccr
, HCCR_RELEASE_RISC
);
3441 RD_REG_WORD(®
->hccr
); /* PCI Posting. */
3442 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
3446 qla24xx_reset_adapter(scsi_qla_host_t
*ha
)
3448 unsigned long flags
= 0;
3449 struct device_reg_24xx __iomem
*reg
= &ha
->iobase
->isp24
;
3451 ha
->flags
.online
= 0;
3452 ha
->isp_ops
->disable_intrs(ha
);
3454 spin_lock_irqsave(&ha
->hardware_lock
, flags
);
3455 WRT_REG_DWORD(®
->hccr
, HCCRX_SET_RISC_RESET
);
3456 RD_REG_DWORD(®
->hccr
);
3457 WRT_REG_DWORD(®
->hccr
, HCCRX_REL_RISC_PAUSE
);
3458 RD_REG_DWORD(®
->hccr
);
3459 spin_unlock_irqrestore(&ha
->hardware_lock
, flags
);
3462 /* On sparc systems, obtain port and node WWN from firmware
3465 static void qla24xx_nvram_wwn_from_ofw(scsi_qla_host_t
*ha
, struct nvram_24xx
*nv
)
3468 struct pci_dev
*pdev
= ha
->pdev
;
3469 struct device_node
*dp
= pci_device_to_OF_node(pdev
);
3473 val
= of_get_property(dp
, "port-wwn", &len
);
3474 if (val
&& len
>= WWN_SIZE
)
3475 memcpy(nv
->port_name
, val
, WWN_SIZE
);
3477 val
= of_get_property(dp
, "node-wwn", &len
);
3478 if (val
&& len
>= WWN_SIZE
)
3479 memcpy(nv
->node_name
, val
, WWN_SIZE
);
3484 qla24xx_nvram_config(scsi_qla_host_t
*ha
)
3487 struct init_cb_24xx
*icb
;
3488 struct nvram_24xx
*nv
;
3490 uint8_t *dptr1
, *dptr2
;
3495 icb
= (struct init_cb_24xx
*)ha
->init_cb
;
3498 /* Determine NVRAM starting address. */
3499 ha
->nvram_size
= sizeof(struct nvram_24xx
);
3500 ha
->nvram_base
= FA_NVRAM_FUNC0_ADDR
;
3501 ha
->vpd_size
= FA_NVRAM_VPD_SIZE
;
3502 ha
->vpd_base
= FA_NVRAM_VPD0_ADDR
;
3503 if (PCI_FUNC(ha
->pdev
->devfn
)) {
3504 ha
->nvram_base
= FA_NVRAM_FUNC1_ADDR
;
3505 ha
->vpd_base
= FA_NVRAM_VPD1_ADDR
;
3508 /* Get VPD data into cache */
3509 ha
->vpd
= ha
->nvram
+ VPD_OFFSET
;
3510 ha
->isp_ops
->read_nvram(ha
, (uint8_t *)ha
->vpd
,
3511 ha
->nvram_base
- FA_NVRAM_FUNC0_ADDR
, FA_NVRAM_VPD_SIZE
* 4);
3513 /* Get NVRAM data into cache and calculate checksum. */
3514 dptr
= (uint32_t *)nv
;
3515 ha
->isp_ops
->read_nvram(ha
, (uint8_t *)dptr
, ha
->nvram_base
,
3517 for (cnt
= 0, chksum
= 0; cnt
< ha
->nvram_size
>> 2; cnt
++)
3518 chksum
+= le32_to_cpu(*dptr
++);
3520 DEBUG5(printk("scsi(%ld): Contents of NVRAM\n", ha
->host_no
));
3521 DEBUG5(qla2x00_dump_buffer((uint8_t *)nv
, ha
->nvram_size
));
3523 /* Bad NVRAM data, set defaults parameters. */
3524 if (chksum
|| nv
->id
[0] != 'I' || nv
->id
[1] != 'S' || nv
->id
[2] != 'P'
3525 || nv
->id
[3] != ' ' ||
3526 nv
->nvram_version
< __constant_cpu_to_le16(ICB_VERSION
)) {
3527 /* Reset NVRAM data. */
3528 qla_printk(KERN_WARNING
, ha
, "Inconsistent NVRAM detected: "
3529 "checksum=0x%x id=%c version=0x%x.\n", chksum
, nv
->id
[0],
3530 le16_to_cpu(nv
->nvram_version
));
3531 qla_printk(KERN_WARNING
, ha
, "Falling back to functioning (yet "
3532 "invalid -- WWPN) defaults.\n");
3535 * Set default initialization control block.
3537 memset(nv
, 0, ha
->nvram_size
);
3538 nv
->nvram_version
= __constant_cpu_to_le16(ICB_VERSION
);
3539 nv
->version
= __constant_cpu_to_le16(ICB_VERSION
);
3540 nv
->frame_payload_size
= __constant_cpu_to_le16(2048);
3541 nv
->execution_throttle
= __constant_cpu_to_le16(0xFFFF);
3542 nv
->exchange_count
= __constant_cpu_to_le16(0);
3543 nv
->hard_address
= __constant_cpu_to_le16(124);
3544 nv
->port_name
[0] = 0x21;
3545 nv
->port_name
[1] = 0x00 + PCI_FUNC(ha
->pdev
->devfn
);
3546 nv
->port_name
[2] = 0x00;
3547 nv
->port_name
[3] = 0xe0;
3548 nv
->port_name
[4] = 0x8b;
3549 nv
->port_name
[5] = 0x1c;
3550 nv
->port_name
[6] = 0x55;
3551 nv
->port_name
[7] = 0x86;
3552 nv
->node_name
[0] = 0x20;
3553 nv
->node_name
[1] = 0x00;
3554 nv
->node_name
[2] = 0x00;
3555 nv
->node_name
[3] = 0xe0;
3556 nv
->node_name
[4] = 0x8b;
3557 nv
->node_name
[5] = 0x1c;
3558 nv
->node_name
[6] = 0x55;
3559 nv
->node_name
[7] = 0x86;
3560 qla24xx_nvram_wwn_from_ofw(ha
, nv
);
3561 nv
->login_retry_count
= __constant_cpu_to_le16(8);
3562 nv
->interrupt_delay_timer
= __constant_cpu_to_le16(0);
3563 nv
->login_timeout
= __constant_cpu_to_le16(0);
3564 nv
->firmware_options_1
=
3565 __constant_cpu_to_le32(BIT_14
|BIT_13
|BIT_2
|BIT_1
);
3566 nv
->firmware_options_2
= __constant_cpu_to_le32(2 << 4);
3567 nv
->firmware_options_2
|= __constant_cpu_to_le32(BIT_12
);
3568 nv
->firmware_options_3
= __constant_cpu_to_le32(2 << 13);
3569 nv
->host_p
= __constant_cpu_to_le32(BIT_11
|BIT_10
);
3570 nv
->efi_parameters
= __constant_cpu_to_le32(0);
3571 nv
->reset_delay
= 5;
3572 nv
->max_luns_per_target
= __constant_cpu_to_le16(128);
3573 nv
->port_down_retry_count
= __constant_cpu_to_le16(30);
3574 nv
->link_down_timeout
= __constant_cpu_to_le16(30);
3579 /* Reset Initialization control block */
3580 memset(icb
, 0, sizeof(struct init_cb_24xx
));
3582 /* Copy 1st segment. */
3583 dptr1
= (uint8_t *)icb
;
3584 dptr2
= (uint8_t *)&nv
->version
;
3585 cnt
= (uint8_t *)&icb
->response_q_inpointer
- (uint8_t *)&icb
->version
;
3587 *dptr1
++ = *dptr2
++;
3589 icb
->login_retry_count
= nv
->login_retry_count
;
3590 icb
->link_down_on_nos
= nv
->link_down_on_nos
;
3592 /* Copy 2nd segment. */
3593 dptr1
= (uint8_t *)&icb
->interrupt_delay_timer
;
3594 dptr2
= (uint8_t *)&nv
->interrupt_delay_timer
;
3595 cnt
= (uint8_t *)&icb
->reserved_3
-
3596 (uint8_t *)&icb
->interrupt_delay_timer
;
3598 *dptr1
++ = *dptr2
++;
3601 * Setup driver NVRAM options.
3603 qla2x00_set_model_info(ha
, nv
->model_name
, sizeof(nv
->model_name
),
3606 /* Use alternate WWN? */
3607 if (nv
->host_p
& __constant_cpu_to_le32(BIT_15
)) {
3608 memcpy(icb
->node_name
, nv
->alternate_node_name
, WWN_SIZE
);
3609 memcpy(icb
->port_name
, nv
->alternate_port_name
, WWN_SIZE
);
3612 /* Prepare nodename */
3613 if ((icb
->firmware_options_1
& __constant_cpu_to_le32(BIT_14
)) == 0) {
3615 * Firmware will apply the following mask if the nodename was
3618 memcpy(icb
->node_name
, icb
->port_name
, WWN_SIZE
);
3619 icb
->node_name
[0] &= 0xF0;
3622 /* Set host adapter parameters. */
3623 ha
->flags
.disable_risc_code_load
= 0;
3624 ha
->flags
.enable_lip_reset
= 0;
3625 ha
->flags
.enable_lip_full_login
=
3626 le32_to_cpu(nv
->host_p
) & BIT_10
? 1: 0;
3627 ha
->flags
.enable_target_reset
=
3628 le32_to_cpu(nv
->host_p
) & BIT_11
? 1: 0;
3629 ha
->flags
.enable_led_scheme
= 0;
3630 ha
->flags
.disable_serdes
= le32_to_cpu(nv
->host_p
) & BIT_5
? 1: 0;
3632 ha
->operating_mode
= (le32_to_cpu(icb
->firmware_options_2
) &
3633 (BIT_6
| BIT_5
| BIT_4
)) >> 4;
3635 memcpy(ha
->fw_seriallink_options24
, nv
->seriallink_options
,
3636 sizeof(ha
->fw_seriallink_options24
));
3638 /* save HBA serial number */
3639 ha
->serial0
= icb
->port_name
[5];
3640 ha
->serial1
= icb
->port_name
[6];
3641 ha
->serial2
= icb
->port_name
[7];
3642 ha
->node_name
= icb
->node_name
;
3643 ha
->port_name
= icb
->port_name
;
3645 icb
->execution_throttle
= __constant_cpu_to_le16(0xFFFF);
3647 ha
->retry_count
= le16_to_cpu(nv
->login_retry_count
);
3649 /* Set minimum login_timeout to 4 seconds. */
3650 if (le16_to_cpu(nv
->login_timeout
) < ql2xlogintimeout
)
3651 nv
->login_timeout
= cpu_to_le16(ql2xlogintimeout
);
3652 if (le16_to_cpu(nv
->login_timeout
) < 4)
3653 nv
->login_timeout
= __constant_cpu_to_le16(4);
3654 ha
->login_timeout
= le16_to_cpu(nv
->login_timeout
);
3655 icb
->login_timeout
= nv
->login_timeout
;
3657 /* Set minimum RATOV to 100 tenths of a second. */
3660 ha
->loop_reset_delay
= nv
->reset_delay
;
3662 /* Link Down Timeout = 0:
3664 * When Port Down timer expires we will start returning
3665 * I/O's to OS with "DID_NO_CONNECT".
3667 * Link Down Timeout != 0:
3669 * The driver waits for the link to come up after link down
3670 * before returning I/Os to OS with "DID_NO_CONNECT".
3672 if (le16_to_cpu(nv
->link_down_timeout
) == 0) {
3673 ha
->loop_down_abort_time
=
3674 (LOOP_DOWN_TIME
- LOOP_DOWN_TIMEOUT
);
3676 ha
->link_down_timeout
= le16_to_cpu(nv
->link_down_timeout
);
3677 ha
->loop_down_abort_time
=
3678 (LOOP_DOWN_TIME
- ha
->link_down_timeout
);
3681 /* Need enough time to try and get the port back. */
3682 ha
->port_down_retry_count
= le16_to_cpu(nv
->port_down_retry_count
);
3683 if (qlport_down_retry
)
3684 ha
->port_down_retry_count
= qlport_down_retry
;
3686 /* Set login_retry_count */
3687 ha
->login_retry_count
= le16_to_cpu(nv
->login_retry_count
);
3688 if (ha
->port_down_retry_count
==
3689 le16_to_cpu(nv
->port_down_retry_count
) &&
3690 ha
->port_down_retry_count
> 3)
3691 ha
->login_retry_count
= ha
->port_down_retry_count
;
3692 else if (ha
->port_down_retry_count
> (int)ha
->login_retry_count
)
3693 ha
->login_retry_count
= ha
->port_down_retry_count
;
3694 if (ql2xloginretrycount
)
3695 ha
->login_retry_count
= ql2xloginretrycount
;
3698 if (!ha
->flags
.init_done
) {
3699 ha
->zio_mode
= le32_to_cpu(icb
->firmware_options_2
) &
3700 (BIT_3
| BIT_2
| BIT_1
| BIT_0
);
3701 ha
->zio_timer
= le16_to_cpu(icb
->interrupt_delay_timer
) ?
3702 le16_to_cpu(icb
->interrupt_delay_timer
): 2;
3704 icb
->firmware_options_2
&= __constant_cpu_to_le32(
3705 ~(BIT_3
| BIT_2
| BIT_1
| BIT_0
));
3706 ha
->flags
.process_response_queue
= 0;
3707 if (ha
->zio_mode
!= QLA_ZIO_DISABLED
) {
3708 ha
->zio_mode
= QLA_ZIO_MODE_6
;
3710 DEBUG2(printk("scsi(%ld): ZIO mode %d enabled; timer delay "
3711 "(%d us).\n", ha
->host_no
, ha
->zio_mode
,
3712 ha
->zio_timer
* 100));
3713 qla_printk(KERN_INFO
, ha
,
3714 "ZIO mode %d enabled; timer delay (%d us).\n",
3715 ha
->zio_mode
, ha
->zio_timer
* 100);
3717 icb
->firmware_options_2
|= cpu_to_le32(
3718 (uint32_t)ha
->zio_mode
);
3719 icb
->interrupt_delay_timer
= cpu_to_le16(ha
->zio_timer
);
3720 ha
->flags
.process_response_queue
= 1;
3724 DEBUG2_3(printk(KERN_WARNING
3725 "scsi(%ld): NVRAM configuration failed!\n", ha
->host_no
));
3731 qla24xx_load_risc_flash(scsi_qla_host_t
*ha
, uint32_t *srisc_addr
)
3734 int segments
, fragment
;
3736 uint32_t *dcode
, dlen
;
3743 segments
= FA_RISC_CODE_SEGMENTS
;
3744 faddr
= ha
->flt_region_fw
;
3745 dcode
= (uint32_t *)ha
->request_ring
;
3748 /* Validate firmware image by checking version. */
3749 qla24xx_read_flash_data(ha
, dcode
, faddr
+ 4, 4);
3750 for (i
= 0; i
< 4; i
++)
3751 dcode
[i
] = be32_to_cpu(dcode
[i
]);
3752 if ((dcode
[0] == 0xffffffff && dcode
[1] == 0xffffffff &&
3753 dcode
[2] == 0xffffffff && dcode
[3] == 0xffffffff) ||
3754 (dcode
[0] == 0 && dcode
[1] == 0 && dcode
[2] == 0 &&
3756 qla_printk(KERN_WARNING
, ha
,
3757 "Unable to verify integrity of flash firmware image!\n");
3758 qla_printk(KERN_WARNING
, ha
,
3759 "Firmware data: %08x %08x %08x %08x!\n", dcode
[0],
3760 dcode
[1], dcode
[2], dcode
[3]);
3762 return QLA_FUNCTION_FAILED
;
3765 while (segments
&& rval
== QLA_SUCCESS
) {
3766 /* Read segment's load information. */
3767 qla24xx_read_flash_data(ha
, dcode
, faddr
, 4);
3769 risc_addr
= be32_to_cpu(dcode
[2]);
3770 *srisc_addr
= *srisc_addr
== 0 ? risc_addr
: *srisc_addr
;
3771 risc_size
= be32_to_cpu(dcode
[3]);
3774 while (risc_size
> 0 && rval
== QLA_SUCCESS
) {
3775 dlen
= (uint32_t)(ha
->fw_transfer_size
>> 2);
3776 if (dlen
> risc_size
)
3779 DEBUG7(printk("scsi(%ld): Loading risc segment@ risc "
3780 "addr %x, number of dwords 0x%x, offset 0x%x.\n",
3781 ha
->host_no
, risc_addr
, dlen
, faddr
));
3783 qla24xx_read_flash_data(ha
, dcode
, faddr
, dlen
);
3784 for (i
= 0; i
< dlen
; i
++)
3785 dcode
[i
] = swab32(dcode
[i
]);
3787 rval
= qla2x00_load_ram(ha
, ha
->request_dma
, risc_addr
,
3790 DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
3791 "segment %d of firmware\n", ha
->host_no
,
3793 qla_printk(KERN_WARNING
, ha
,
3794 "[ERROR] Failed to load segment %d of "
3795 "firmware\n", fragment
);
3812 #define QLA_FW_URL "ftp://ftp.qlogic.com/outgoing/linux/firmware/"
3815 qla2x00_load_risc(scsi_qla_host_t
*ha
, uint32_t *srisc_addr
)
3819 uint16_t *wcode
, *fwcode
;
3820 uint32_t risc_addr
, risc_size
, fwclen
, wlen
, *seg
;
3821 struct fw_blob
*blob
;
3823 /* Load firmware blob. */
3824 blob
= qla2x00_request_firmware(ha
);
3826 qla_printk(KERN_ERR
, ha
, "Firmware image unavailable.\n");
3827 qla_printk(KERN_ERR
, ha
, "Firmware images can be retrieved "
3828 "from: " QLA_FW_URL
".\n");
3829 return QLA_FUNCTION_FAILED
;
3834 wcode
= (uint16_t *)ha
->request_ring
;
3836 fwcode
= (uint16_t *)blob
->fw
->data
;
3839 /* Validate firmware image by checking version. */
3840 if (blob
->fw
->size
< 8 * sizeof(uint16_t)) {
3841 qla_printk(KERN_WARNING
, ha
,
3842 "Unable to verify integrity of firmware image (%Zd)!\n",
3844 goto fail_fw_integrity
;
3846 for (i
= 0; i
< 4; i
++)
3847 wcode
[i
] = be16_to_cpu(fwcode
[i
+ 4]);
3848 if ((wcode
[0] == 0xffff && wcode
[1] == 0xffff && wcode
[2] == 0xffff &&
3849 wcode
[3] == 0xffff) || (wcode
[0] == 0 && wcode
[1] == 0 &&
3850 wcode
[2] == 0 && wcode
[3] == 0)) {
3851 qla_printk(KERN_WARNING
, ha
,
3852 "Unable to verify integrity of firmware image!\n");
3853 qla_printk(KERN_WARNING
, ha
,
3854 "Firmware data: %04x %04x %04x %04x!\n", wcode
[0],
3855 wcode
[1], wcode
[2], wcode
[3]);
3856 goto fail_fw_integrity
;
3860 while (*seg
&& rval
== QLA_SUCCESS
) {
3862 *srisc_addr
= *srisc_addr
== 0 ? *seg
: *srisc_addr
;
3863 risc_size
= be16_to_cpu(fwcode
[3]);
3865 /* Validate firmware image size. */
3866 fwclen
+= risc_size
* sizeof(uint16_t);
3867 if (blob
->fw
->size
< fwclen
) {
3868 qla_printk(KERN_WARNING
, ha
,
3869 "Unable to verify integrity of firmware image "
3870 "(%Zd)!\n", blob
->fw
->size
);
3871 goto fail_fw_integrity
;
3875 while (risc_size
> 0 && rval
== QLA_SUCCESS
) {
3876 wlen
= (uint16_t)(ha
->fw_transfer_size
>> 1);
3877 if (wlen
> risc_size
)
3880 DEBUG7(printk("scsi(%ld): Loading risc segment@ risc "
3881 "addr %x, number of words 0x%x.\n", ha
->host_no
,
3884 for (i
= 0; i
< wlen
; i
++)
3885 wcode
[i
] = swab16(fwcode
[i
]);
3887 rval
= qla2x00_load_ram(ha
, ha
->request_dma
, risc_addr
,
3890 DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
3891 "segment %d of firmware\n", ha
->host_no
,
3893 qla_printk(KERN_WARNING
, ha
,
3894 "[ERROR] Failed to load segment %d of "
3895 "firmware\n", fragment
);
3911 return QLA_FUNCTION_FAILED
;
3915 qla24xx_load_risc(scsi_qla_host_t
*ha
, uint32_t *srisc_addr
)
3918 int segments
, fragment
;
3919 uint32_t *dcode
, dlen
;
3923 struct fw_blob
*blob
;
3924 uint32_t *fwcode
, fwclen
;
3926 /* Load firmware blob. */
3927 blob
= qla2x00_request_firmware(ha
);
3929 qla_printk(KERN_ERR
, ha
, "Firmware image unavailable.\n");
3930 qla_printk(KERN_ERR
, ha
, "Firmware images can be retrieved "
3931 "from: " QLA_FW_URL
".\n");
3933 /* Try to load RISC code from flash. */
3934 qla_printk(KERN_ERR
, ha
, "Attempting to load (potentially "
3935 "outdated) firmware from flash.\n");
3936 return qla24xx_load_risc_flash(ha
, srisc_addr
);
3941 segments
= FA_RISC_CODE_SEGMENTS
;
3942 dcode
= (uint32_t *)ha
->request_ring
;
3944 fwcode
= (uint32_t *)blob
->fw
->data
;
3947 /* Validate firmware image by checking version. */
3948 if (blob
->fw
->size
< 8 * sizeof(uint32_t)) {
3949 qla_printk(KERN_WARNING
, ha
,
3950 "Unable to verify integrity of firmware image (%Zd)!\n",
3952 goto fail_fw_integrity
;
3954 for (i
= 0; i
< 4; i
++)
3955 dcode
[i
] = be32_to_cpu(fwcode
[i
+ 4]);
3956 if ((dcode
[0] == 0xffffffff && dcode
[1] == 0xffffffff &&
3957 dcode
[2] == 0xffffffff && dcode
[3] == 0xffffffff) ||
3958 (dcode
[0] == 0 && dcode
[1] == 0 && dcode
[2] == 0 &&
3960 qla_printk(KERN_WARNING
, ha
,
3961 "Unable to verify integrity of firmware image!\n");
3962 qla_printk(KERN_WARNING
, ha
,
3963 "Firmware data: %08x %08x %08x %08x!\n", dcode
[0],
3964 dcode
[1], dcode
[2], dcode
[3]);
3965 goto fail_fw_integrity
;
3968 while (segments
&& rval
== QLA_SUCCESS
) {
3969 risc_addr
= be32_to_cpu(fwcode
[2]);
3970 *srisc_addr
= *srisc_addr
== 0 ? risc_addr
: *srisc_addr
;
3971 risc_size
= be32_to_cpu(fwcode
[3]);
3973 /* Validate firmware image size. */
3974 fwclen
+= risc_size
* sizeof(uint32_t);
3975 if (blob
->fw
->size
< fwclen
) {
3976 qla_printk(KERN_WARNING
, ha
,
3977 "Unable to verify integrity of firmware image "
3978 "(%Zd)!\n", blob
->fw
->size
);
3980 goto fail_fw_integrity
;
3984 while (risc_size
> 0 && rval
== QLA_SUCCESS
) {
3985 dlen
= (uint32_t)(ha
->fw_transfer_size
>> 2);
3986 if (dlen
> risc_size
)
3989 DEBUG7(printk("scsi(%ld): Loading risc segment@ risc "
3990 "addr %x, number of dwords 0x%x.\n", ha
->host_no
,
3993 for (i
= 0; i
< dlen
; i
++)
3994 dcode
[i
] = swab32(fwcode
[i
]);
3996 rval
= qla2x00_load_ram(ha
, ha
->request_dma
, risc_addr
,
3999 DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
4000 "segment %d of firmware\n", ha
->host_no
,
4002 qla_printk(KERN_WARNING
, ha
,
4003 "[ERROR] Failed to load segment %d of "
4004 "firmware\n", fragment
);
4020 return QLA_FUNCTION_FAILED
;
4024 qla2x00_try_to_stop_firmware(scsi_qla_host_t
*ha
)
4028 if (!IS_FWI2_CAPABLE(ha
))
4030 if (!ha
->fw_major_version
)
4033 ret
= qla2x00_stop_firmware(ha
);
4034 for (retries
= 5; ret
!= QLA_SUCCESS
&& ret
!= QLA_FUNCTION_TIMEOUT
&&
4035 retries
; retries
--) {
4036 ha
->isp_ops
->reset_chip(ha
);
4037 if (ha
->isp_ops
->chip_diag(ha
) != QLA_SUCCESS
)
4039 if (qla2x00_setup_chip(ha
) != QLA_SUCCESS
)
4041 qla_printk(KERN_INFO
, ha
,
4042 "Attempting retry of stop-firmware command...\n");
4043 ret
= qla2x00_stop_firmware(ha
);
4048 qla24xx_configure_vhba(scsi_qla_host_t
*ha
)
4050 int rval
= QLA_SUCCESS
;
4051 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
4056 rval
= qla2x00_fw_ready(ha
->parent
);
4057 if (rval
== QLA_SUCCESS
) {
4058 clear_bit(RESET_MARKER_NEEDED
, &ha
->dpc_flags
);
4059 qla2x00_marker(ha
, 0, 0, MK_SYNC_ALL
);
4062 ha
->flags
.management_server_logged_in
= 0;
4064 /* Login to SNS first */
4065 qla24xx_login_fabric(ha
->parent
, NPH_SNS
, 0xff, 0xff, 0xfc,
4067 if (mb
[0] != MBS_COMMAND_COMPLETE
) {
4068 DEBUG15(qla_printk(KERN_INFO
, ha
,
4069 "Failed SNS login: loop_id=%x mb[0]=%x mb[1]=%x "
4070 "mb[2]=%x mb[6]=%x mb[7]=%x\n", NPH_SNS
,
4071 mb
[0], mb
[1], mb
[2], mb
[6], mb
[7]));
4072 return (QLA_FUNCTION_FAILED
);
4075 atomic_set(&ha
->loop_down_timer
, 0);
4076 atomic_set(&ha
->loop_state
, LOOP_UP
);
4077 set_bit(LOOP_RESYNC_NEEDED
, &ha
->dpc_flags
);
4078 set_bit(LOCAL_LOOP_UPDATE
, &ha
->dpc_flags
);
4079 rval
= qla2x00_loop_resync(ha
->parent
);
4084 /* 84XX Support **************************************************************/
4086 static LIST_HEAD(qla_cs84xx_list
);
4087 static DEFINE_MUTEX(qla_cs84xx_mutex
);
4089 static struct qla_chip_state_84xx
*
4090 qla84xx_get_chip(struct scsi_qla_host
*ha
)
4092 struct qla_chip_state_84xx
*cs84xx
;
4094 mutex_lock(&qla_cs84xx_mutex
);
4096 /* Find any shared 84xx chip. */
4097 list_for_each_entry(cs84xx
, &qla_cs84xx_list
, list
) {
4098 if (cs84xx
->bus
== ha
->pdev
->bus
) {
4099 kref_get(&cs84xx
->kref
);
4104 cs84xx
= kzalloc(sizeof(*cs84xx
), GFP_KERNEL
);
4108 kref_init(&cs84xx
->kref
);
4109 spin_lock_init(&cs84xx
->access_lock
);
4110 mutex_init(&cs84xx
->fw_update_mutex
);
4111 cs84xx
->bus
= ha
->pdev
->bus
;
4113 list_add_tail(&cs84xx
->list
, &qla_cs84xx_list
);
4115 mutex_unlock(&qla_cs84xx_mutex
);
4120 __qla84xx_chip_release(struct kref
*kref
)
4122 struct qla_chip_state_84xx
*cs84xx
=
4123 container_of(kref
, struct qla_chip_state_84xx
, kref
);
4125 mutex_lock(&qla_cs84xx_mutex
);
4126 list_del(&cs84xx
->list
);
4127 mutex_unlock(&qla_cs84xx_mutex
);
4132 qla84xx_put_chip(struct scsi_qla_host
*ha
)
4135 kref_put(&ha
->cs84xx
->kref
, __qla84xx_chip_release
);
4139 qla84xx_init_chip(scsi_qla_host_t
*ha
)
4144 mutex_lock(&ha
->cs84xx
->fw_update_mutex
);
4146 rval
= qla84xx_verify_chip(ha
, status
);
4148 mutex_unlock(&ha
->cs84xx
->fw_update_mutex
);
4150 return rval
!= QLA_SUCCESS
|| status
[0] ? QLA_FUNCTION_FAILED
: