xref: /linux/drivers/scsi/qla2xxx/qla_init.c (revision f3d9478b2ce468c3115b02ecae7e975990697f15)
1 /*
2  * QLogic Fibre Channel HBA Driver
3  * Copyright (c)  2003-2005 QLogic Corporation
4  *
5  * See LICENSE.qla2xxx for copyright and licensing details.
6  */
7 #include "qla_def.h"
8 
9 #include <linux/delay.h>
10 #include <linux/vmalloc.h>
11 
12 #include "qla_devtbl.h"
13 
14 /* XXX(hch): this is ugly, but we don't want to pull in exioctl.h */
15 #ifndef EXT_IS_LUN_BIT_SET
16 #define EXT_IS_LUN_BIT_SET(P,L) \
17     (((P)->mask[L/8] & (0x80 >> (L%8)))?1:0)
18 #define EXT_SET_LUN_BIT(P,L) \
19     ((P)->mask[L/8] |= (0x80 >> (L%8)))
20 #endif
21 
22 /*
23 *  QLogic ISP2x00 Hardware Support Function Prototypes.
24 */
25 static int qla2x00_isp_firmware(scsi_qla_host_t *);
26 static void qla2x00_resize_request_q(scsi_qla_host_t *);
27 static int qla2x00_setup_chip(scsi_qla_host_t *);
28 static void qla2x00_init_response_q_entries(scsi_qla_host_t *);
29 static int qla2x00_init_rings(scsi_qla_host_t *);
30 static int qla2x00_fw_ready(scsi_qla_host_t *);
31 static int qla2x00_configure_hba(scsi_qla_host_t *);
32 static int qla2x00_configure_loop(scsi_qla_host_t *);
33 static int qla2x00_configure_local_loop(scsi_qla_host_t *);
34 static int qla2x00_configure_fabric(scsi_qla_host_t *);
35 static int qla2x00_find_all_fabric_devs(scsi_qla_host_t *, struct list_head *);
36 static int qla2x00_device_resync(scsi_qla_host_t *);
37 static int qla2x00_fabric_dev_login(scsi_qla_host_t *, fc_port_t *,
38     uint16_t *);
39 
40 static int qla2x00_restart_isp(scsi_qla_host_t *);
41 
42 /****************************************************************************/
43 /*                QLogic ISP2x00 Hardware Support Functions.                */
44 /****************************************************************************/
45 
46 /*
47 * qla2x00_initialize_adapter
48 *      Initialize board.
49 *
50 * Input:
51 *      ha = adapter block pointer.
52 *
53 * Returns:
54 *      0 = success
55 */
56 int
57 qla2x00_initialize_adapter(scsi_qla_host_t *ha)
58 {
59 	int	rval;
60 	uint8_t	restart_risc = 0;
61 	uint8_t	retry;
62 	uint32_t wait_time;
63 
64 	/* Clear adapter flags. */
65 	ha->flags.online = 0;
66 	ha->flags.reset_active = 0;
67 	atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
68 	atomic_set(&ha->loop_state, LOOP_DOWN);
69 	ha->device_flags = 0;
70 	ha->dpc_flags = 0;
71 	ha->flags.management_server_logged_in = 0;
72 	ha->marker_needed = 0;
73 	ha->mbx_flags = 0;
74 	ha->isp_abort_cnt = 0;
75 	ha->beacon_blink_led = 0;
76 	set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags);
77 
78 	qla_printk(KERN_INFO, ha, "Configuring PCI space...\n");
79 	rval = ha->isp_ops.pci_config(ha);
80 	if (rval) {
81 		DEBUG2(printk("scsi(%ld): Unable to configure PCI space=n",
82 		    ha->host_no));
83 		return (rval);
84 	}
85 
86 	ha->isp_ops.reset_chip(ha);
87 
88 	qla_printk(KERN_INFO, ha, "Configure NVRAM parameters...\n");
89 
90 	ha->isp_ops.nvram_config(ha);
91 
92 	qla_printk(KERN_INFO, ha, "Verifying loaded RISC code...\n");
93 
94 	retry = 10;
95 	/*
96 	 * Try to configure the loop.
97 	 */
98 	do {
99 		restart_risc = 0;
100 
101 		/* If firmware needs to be loaded */
102 		if (qla2x00_isp_firmware(ha) != QLA_SUCCESS) {
103 			if ((rval = ha->isp_ops.chip_diag(ha)) == QLA_SUCCESS) {
104 				rval = qla2x00_setup_chip(ha);
105 			}
106 		}
107 
108 		if (rval == QLA_SUCCESS &&
109 		    (rval = qla2x00_init_rings(ha)) == QLA_SUCCESS) {
110 check_fw_ready_again:
111 			/*
112 			 * Wait for a successful LIP up to a maximum
113 			 * of (in seconds): RISC login timeout value,
114 			 * RISC retry count value, and port down retry
115 			 * value OR a minimum of 4 seconds OR If no
116 			 * cable, only 5 seconds.
117 			 */
118 			rval = qla2x00_fw_ready(ha);
119 			if (rval == QLA_SUCCESS) {
120 				clear_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
121 
122 				/* Issue a marker after FW becomes ready. */
123 				qla2x00_marker(ha, 0, 0, MK_SYNC_ALL);
124 
125 				/*
126 				 * Wait at most MAX_TARGET RSCNs for a stable
127 				 * link.
128 				 */
129 				wait_time = 256;
130 				do {
131 					clear_bit(LOOP_RESYNC_NEEDED,
132 					    &ha->dpc_flags);
133 					rval = qla2x00_configure_loop(ha);
134 
135 					if (test_and_clear_bit(ISP_ABORT_NEEDED,
136 					    &ha->dpc_flags)) {
137 						restart_risc = 1;
138 						break;
139 					}
140 
141 					/*
142 					 * If loop state change while we were
143 					 * discoverying devices then wait for
144 					 * LIP to complete
145 					 */
146 
147 					if (atomic_read(&ha->loop_state) !=
148 					    LOOP_READY && retry--) {
149 						goto check_fw_ready_again;
150 					}
151 					wait_time--;
152 				} while (!atomic_read(&ha->loop_down_timer) &&
153 				    retry &&
154 				    wait_time &&
155 				    (test_bit(LOOP_RESYNC_NEEDED,
156 					&ha->dpc_flags)));
157 
158 				if (wait_time == 0)
159 					rval = QLA_FUNCTION_FAILED;
160 			} else if (ha->device_flags & DFLG_NO_CABLE)
161 				/* If no cable, then all is good. */
162 				rval = QLA_SUCCESS;
163 		}
164 	} while (restart_risc && retry--);
165 
166 	if (rval == QLA_SUCCESS) {
167 		clear_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
168 		qla2x00_marker(ha, 0, 0, MK_SYNC_ALL);
169 		ha->marker_needed = 0;
170 
171 		ha->flags.online = 1;
172 	} else {
173 		DEBUG2_3(printk("%s(): **** FAILED ****\n", __func__));
174 	}
175 
176 	return (rval);
177 }
178 
179 /**
180  * qla2100_pci_config() - Setup ISP21xx PCI configuration registers.
181  * @ha: HA context
182  *
183  * Returns 0 on success.
184  */
185 int
186 qla2100_pci_config(scsi_qla_host_t *ha)
187 {
188 	uint16_t w, mwi;
189 	uint32_t d;
190 	unsigned long flags;
191 	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
192 
193 	pci_set_master(ha->pdev);
194 	mwi = 0;
195 	if (pci_set_mwi(ha->pdev))
196 		mwi = PCI_COMMAND_INVALIDATE;
197 
198 	pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
199 	w |= mwi | (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
200 	pci_write_config_word(ha->pdev, PCI_COMMAND, w);
201 
202 	/* Reset expansion ROM address decode enable */
203 	pci_read_config_dword(ha->pdev, PCI_ROM_ADDRESS, &d);
204 	d &= ~PCI_ROM_ADDRESS_ENABLE;
205 	pci_write_config_dword(ha->pdev, PCI_ROM_ADDRESS, d);
206 
207 	/* Get PCI bus information. */
208 	spin_lock_irqsave(&ha->hardware_lock, flags);
209 	ha->pci_attr = RD_REG_WORD(&reg->ctrl_status);
210 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
211 
212 	return QLA_SUCCESS;
213 }
214 
215 /**
216  * qla2300_pci_config() - Setup ISP23xx PCI configuration registers.
217  * @ha: HA context
218  *
219  * Returns 0 on success.
220  */
221 int
222 qla2300_pci_config(scsi_qla_host_t *ha)
223 {
224 	uint16_t	w, mwi;
225 	uint32_t	d;
226 	unsigned long   flags = 0;
227 	uint32_t	cnt;
228 	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
229 
230 	pci_set_master(ha->pdev);
231 	mwi = 0;
232 	if (pci_set_mwi(ha->pdev))
233 		mwi = PCI_COMMAND_INVALIDATE;
234 
235 	pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
236 	w |= mwi | (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
237 
238 	if (IS_QLA2322(ha) || IS_QLA6322(ha))
239 		w &= ~PCI_COMMAND_INTX_DISABLE;
240 
241 	/*
242 	 * If this is a 2300 card and not 2312, reset the
243 	 * COMMAND_INVALIDATE due to a bug in the 2300. Unfortunately,
244 	 * the 2310 also reports itself as a 2300 so we need to get the
245 	 * fb revision level -- a 6 indicates it really is a 2300 and
246 	 * not a 2310.
247 	 */
248 	if (IS_QLA2300(ha)) {
249 		spin_lock_irqsave(&ha->hardware_lock, flags);
250 
251 		/* Pause RISC. */
252 		WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
253 		for (cnt = 0; cnt < 30000; cnt++) {
254 			if ((RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) != 0)
255 				break;
256 
257 			udelay(10);
258 		}
259 
260 		/* Select FPM registers. */
261 		WRT_REG_WORD(&reg->ctrl_status, 0x20);
262 		RD_REG_WORD(&reg->ctrl_status);
263 
264 		/* Get the fb rev level */
265 		ha->fb_rev = RD_FB_CMD_REG(ha, reg);
266 
267 		if (ha->fb_rev == FPM_2300)
268 			w &= ~PCI_COMMAND_INVALIDATE;
269 
270 		/* Deselect FPM registers. */
271 		WRT_REG_WORD(&reg->ctrl_status, 0x0);
272 		RD_REG_WORD(&reg->ctrl_status);
273 
274 		/* Release RISC module. */
275 		WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
276 		for (cnt = 0; cnt < 30000; cnt++) {
277 			if ((RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) == 0)
278 				break;
279 
280 			udelay(10);
281 		}
282 
283 		spin_unlock_irqrestore(&ha->hardware_lock, flags);
284 	}
285 	pci_write_config_word(ha->pdev, PCI_COMMAND, w);
286 
287 	pci_write_config_byte(ha->pdev, PCI_LATENCY_TIMER, 0x80);
288 
289 	/* Reset expansion ROM address decode enable */
290 	pci_read_config_dword(ha->pdev, PCI_ROM_ADDRESS, &d);
291 	d &= ~PCI_ROM_ADDRESS_ENABLE;
292 	pci_write_config_dword(ha->pdev, PCI_ROM_ADDRESS, d);
293 
294 	/* Get PCI bus information. */
295 	spin_lock_irqsave(&ha->hardware_lock, flags);
296 	ha->pci_attr = RD_REG_WORD(&reg->ctrl_status);
297 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
298 
299 	return QLA_SUCCESS;
300 }
301 
302 /**
303  * qla24xx_pci_config() - Setup ISP24xx PCI configuration registers.
304  * @ha: HA context
305  *
306  * Returns 0 on success.
307  */
308 int
309 qla24xx_pci_config(scsi_qla_host_t *ha)
310 {
311 	uint16_t w, mwi;
312 	uint32_t d;
313 	unsigned long flags = 0;
314 	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
315 	int pcix_cmd_reg, pcie_dctl_reg;
316 
317 	pci_set_master(ha->pdev);
318 	mwi = 0;
319 	if (pci_set_mwi(ha->pdev))
320 		mwi = PCI_COMMAND_INVALIDATE;
321 
322 	pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
323 	w |= mwi | (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
324 	w &= ~PCI_COMMAND_INTX_DISABLE;
325 	pci_write_config_word(ha->pdev, PCI_COMMAND, w);
326 
327 	pci_write_config_byte(ha->pdev, PCI_LATENCY_TIMER, 0x80);
328 
329 	/* PCI-X -- adjust Maximum Memory Read Byte Count (2048). */
330 	pcix_cmd_reg = pci_find_capability(ha->pdev, PCI_CAP_ID_PCIX);
331 	if (pcix_cmd_reg) {
332 		uint16_t pcix_cmd;
333 
334 		pcix_cmd_reg += PCI_X_CMD;
335 		pci_read_config_word(ha->pdev, pcix_cmd_reg, &pcix_cmd);
336 		pcix_cmd &= ~PCI_X_CMD_MAX_READ;
337 		pcix_cmd |= 0x0008;
338 		pci_write_config_word(ha->pdev, pcix_cmd_reg, pcix_cmd);
339 	}
340 
341 	/* PCIe -- adjust Maximum Read Request Size (2048). */
342 	pcie_dctl_reg = pci_find_capability(ha->pdev, PCI_CAP_ID_EXP);
343 	if (pcie_dctl_reg) {
344 		uint16_t pcie_dctl;
345 
346 		pcie_dctl_reg += PCI_EXP_DEVCTL;
347 		pci_read_config_word(ha->pdev, pcie_dctl_reg, &pcie_dctl);
348 		pcie_dctl &= ~PCI_EXP_DEVCTL_READRQ;
349 		pcie_dctl |= 0x4000;
350 		pci_write_config_word(ha->pdev, pcie_dctl_reg, pcie_dctl);
351 	}
352 
353 	/* Reset expansion ROM address decode enable */
354 	pci_read_config_dword(ha->pdev, PCI_ROM_ADDRESS, &d);
355 	d &= ~PCI_ROM_ADDRESS_ENABLE;
356 	pci_write_config_dword(ha->pdev, PCI_ROM_ADDRESS, d);
357 
358 	/* Get PCI bus information. */
359 	spin_lock_irqsave(&ha->hardware_lock, flags);
360 	ha->pci_attr = RD_REG_DWORD(&reg->ctrl_status);
361 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
362 
363 	return QLA_SUCCESS;
364 }
365 
366 /**
367  * qla2x00_isp_firmware() - Choose firmware image.
368  * @ha: HA context
369  *
370  * Returns 0 on success.
371  */
372 static int
373 qla2x00_isp_firmware(scsi_qla_host_t *ha)
374 {
375 	int  rval;
376 
377 	/* Assume loading risc code */
378 	rval = QLA_FUNCTION_FAILED;
379 
380 	if (ha->flags.disable_risc_code_load) {
381 		DEBUG2(printk("scsi(%ld): RISC CODE NOT loaded\n",
382 		    ha->host_no));
383 		qla_printk(KERN_INFO, ha, "RISC CODE NOT loaded\n");
384 
385 		/* Verify checksum of loaded RISC code. */
386 		rval = qla2x00_verify_checksum(ha, ha->fw_srisc_address);
387 	}
388 
389 	if (rval) {
390 		DEBUG2_3(printk("scsi(%ld): **** Load RISC code ****\n",
391 		    ha->host_no));
392 	}
393 
394 	return (rval);
395 }
396 
397 /**
398  * qla2x00_reset_chip() - Reset ISP chip.
399  * @ha: HA context
400  *
401  * Returns 0 on success.
402  */
403 void
404 qla2x00_reset_chip(scsi_qla_host_t *ha)
405 {
406 	unsigned long   flags = 0;
407 	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
408 	uint32_t	cnt;
409 	uint16_t	cmd;
410 
411 	ha->isp_ops.disable_intrs(ha);
412 
413 	spin_lock_irqsave(&ha->hardware_lock, flags);
414 
415 	/* Turn off master enable */
416 	cmd = 0;
417 	pci_read_config_word(ha->pdev, PCI_COMMAND, &cmd);
418 	cmd &= ~PCI_COMMAND_MASTER;
419 	pci_write_config_word(ha->pdev, PCI_COMMAND, cmd);
420 
421 	if (!IS_QLA2100(ha)) {
422 		/* Pause RISC. */
423 		WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
424 		if (IS_QLA2200(ha) || IS_QLA2300(ha)) {
425 			for (cnt = 0; cnt < 30000; cnt++) {
426 				if ((RD_REG_WORD(&reg->hccr) &
427 				    HCCR_RISC_PAUSE) != 0)
428 					break;
429 				udelay(100);
430 			}
431 		} else {
432 			RD_REG_WORD(&reg->hccr);	/* PCI Posting. */
433 			udelay(10);
434 		}
435 
436 		/* Select FPM registers. */
437 		WRT_REG_WORD(&reg->ctrl_status, 0x20);
438 		RD_REG_WORD(&reg->ctrl_status);		/* PCI Posting. */
439 
440 		/* FPM Soft Reset. */
441 		WRT_REG_WORD(&reg->fpm_diag_config, 0x100);
442 		RD_REG_WORD(&reg->fpm_diag_config);	/* PCI Posting. */
443 
444 		/* Toggle Fpm Reset. */
445 		if (!IS_QLA2200(ha)) {
446 			WRT_REG_WORD(&reg->fpm_diag_config, 0x0);
447 			RD_REG_WORD(&reg->fpm_diag_config); /* PCI Posting. */
448 		}
449 
450 		/* Select frame buffer registers. */
451 		WRT_REG_WORD(&reg->ctrl_status, 0x10);
452 		RD_REG_WORD(&reg->ctrl_status);		/* PCI Posting. */
453 
454 		/* Reset frame buffer FIFOs. */
455 		if (IS_QLA2200(ha)) {
456 			WRT_FB_CMD_REG(ha, reg, 0xa000);
457 			RD_FB_CMD_REG(ha, reg);		/* PCI Posting. */
458 		} else {
459 			WRT_FB_CMD_REG(ha, reg, 0x00fc);
460 
461 			/* Read back fb_cmd until zero or 3 seconds max */
462 			for (cnt = 0; cnt < 3000; cnt++) {
463 				if ((RD_FB_CMD_REG(ha, reg) & 0xff) == 0)
464 					break;
465 				udelay(100);
466 			}
467 		}
468 
469 		/* Select RISC module registers. */
470 		WRT_REG_WORD(&reg->ctrl_status, 0);
471 		RD_REG_WORD(&reg->ctrl_status);		/* PCI Posting. */
472 
473 		/* Reset RISC processor. */
474 		WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
475 		RD_REG_WORD(&reg->hccr);		/* PCI Posting. */
476 
477 		/* Release RISC processor. */
478 		WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
479 		RD_REG_WORD(&reg->hccr);		/* PCI Posting. */
480 	}
481 
482 	WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
483 	WRT_REG_WORD(&reg->hccr, HCCR_CLR_HOST_INT);
484 
485 	/* Reset ISP chip. */
486 	WRT_REG_WORD(&reg->ctrl_status, CSR_ISP_SOFT_RESET);
487 
488 	/* Wait for RISC to recover from reset. */
489 	if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
490 		/*
491 		 * It is necessary to for a delay here since the card doesn't
492 		 * respond to PCI reads during a reset. On some architectures
493 		 * this will result in an MCA.
494 		 */
495 		udelay(20);
496 		for (cnt = 30000; cnt; cnt--) {
497 			if ((RD_REG_WORD(&reg->ctrl_status) &
498 			    CSR_ISP_SOFT_RESET) == 0)
499 				break;
500 			udelay(100);
501 		}
502 	} else
503 		udelay(10);
504 
505 	/* Reset RISC processor. */
506 	WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
507 
508 	WRT_REG_WORD(&reg->semaphore, 0);
509 
510 	/* Release RISC processor. */
511 	WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
512 	RD_REG_WORD(&reg->hccr);			/* PCI Posting. */
513 
514 	if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
515 		for (cnt = 0; cnt < 30000; cnt++) {
516 			if (RD_MAILBOX_REG(ha, reg, 0) != MBS_BUSY)
517 				break;
518 
519 			udelay(100);
520 		}
521 	} else
522 		udelay(100);
523 
524 	/* Turn on master enable */
525 	cmd |= PCI_COMMAND_MASTER;
526 	pci_write_config_word(ha->pdev, PCI_COMMAND, cmd);
527 
528 	/* Disable RISC pause on FPM parity error. */
529 	if (!IS_QLA2100(ha)) {
530 		WRT_REG_WORD(&reg->hccr, HCCR_DISABLE_PARITY_PAUSE);
531 		RD_REG_WORD(&reg->hccr);		/* PCI Posting. */
532 	}
533 
534 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
535 }
536 
537 /**
538  * qla24xx_reset_risc() - Perform full reset of ISP24xx RISC.
539  * @ha: HA context
540  *
541  * Returns 0 on success.
542  */
543 static inline void
544 qla24xx_reset_risc(scsi_qla_host_t *ha)
545 {
546 	unsigned long flags = 0;
547 	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
548 	uint32_t cnt, d2;
549 	uint16_t wd;
550 
551 	spin_lock_irqsave(&ha->hardware_lock, flags);
552 
553 	/* Reset RISC. */
554 	WRT_REG_DWORD(&reg->ctrl_status, CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
555 	for (cnt = 0; cnt < 30000; cnt++) {
556 		if ((RD_REG_DWORD(&reg->ctrl_status) & CSRX_DMA_ACTIVE) == 0)
557 			break;
558 
559 		udelay(10);
560 	}
561 
562 	WRT_REG_DWORD(&reg->ctrl_status,
563 	    CSRX_ISP_SOFT_RESET|CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
564 	pci_read_config_word(ha->pdev, PCI_COMMAND, &wd);
565 
566 	udelay(100);
567 	/* Wait for firmware to complete NVRAM accesses. */
568 	d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
569 	for (cnt = 10000 ; cnt && d2; cnt--) {
570 		udelay(5);
571 		d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
572 		barrier();
573 	}
574 
575 	/* Wait for soft-reset to complete. */
576 	d2 = RD_REG_DWORD(&reg->ctrl_status);
577 	for (cnt = 6000000 ; cnt && (d2 & CSRX_ISP_SOFT_RESET); cnt--) {
578 		udelay(5);
579 		d2 = RD_REG_DWORD(&reg->ctrl_status);
580 		barrier();
581 	}
582 
583 	WRT_REG_DWORD(&reg->hccr, HCCRX_SET_RISC_RESET);
584 	RD_REG_DWORD(&reg->hccr);
585 
586 	WRT_REG_DWORD(&reg->hccr, HCCRX_REL_RISC_PAUSE);
587 	RD_REG_DWORD(&reg->hccr);
588 
589 	WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_RESET);
590 	RD_REG_DWORD(&reg->hccr);
591 
592 	d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
593 	for (cnt = 6000000 ; cnt && d2; cnt--) {
594 		udelay(5);
595 		d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
596 		barrier();
597 	}
598 
599 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
600 }
601 
602 /**
603  * qla24xx_reset_chip() - Reset ISP24xx chip.
604  * @ha: HA context
605  *
606  * Returns 0 on success.
607  */
608 void
609 qla24xx_reset_chip(scsi_qla_host_t *ha)
610 {
611 	ha->isp_ops.disable_intrs(ha);
612 
613 	/* Perform RISC reset. */
614 	qla24xx_reset_risc(ha);
615 }
616 
617 /**
618  * qla2x00_chip_diag() - Test chip for proper operation.
619  * @ha: HA context
620  *
621  * Returns 0 on success.
622  */
623 int
624 qla2x00_chip_diag(scsi_qla_host_t *ha)
625 {
626 	int		rval;
627 	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
628 	unsigned long	flags = 0;
629 	uint16_t	data;
630 	uint32_t	cnt;
631 	uint16_t	mb[5];
632 
633 	/* Assume a failed state */
634 	rval = QLA_FUNCTION_FAILED;
635 
636 	DEBUG3(printk("scsi(%ld): Testing device at %lx.\n",
637 	    ha->host_no, (u_long)&reg->flash_address));
638 
639 	spin_lock_irqsave(&ha->hardware_lock, flags);
640 
641 	/* Reset ISP chip. */
642 	WRT_REG_WORD(&reg->ctrl_status, CSR_ISP_SOFT_RESET);
643 
644 	/*
645 	 * We need to have a delay here since the card will not respond while
646 	 * in reset causing an MCA on some architectures.
647 	 */
648 	udelay(20);
649 	data = qla2x00_debounce_register(&reg->ctrl_status);
650 	for (cnt = 6000000 ; cnt && (data & CSR_ISP_SOFT_RESET); cnt--) {
651 		udelay(5);
652 		data = RD_REG_WORD(&reg->ctrl_status);
653 		barrier();
654 	}
655 
656 	if (!cnt)
657 		goto chip_diag_failed;
658 
659 	DEBUG3(printk("scsi(%ld): Reset register cleared by chip reset\n",
660 	    ha->host_no));
661 
662 	/* Reset RISC processor. */
663 	WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
664 	WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
665 
666 	/* Workaround for QLA2312 PCI parity error */
667 	if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
668 		data = qla2x00_debounce_register(MAILBOX_REG(ha, reg, 0));
669 		for (cnt = 6000000; cnt && (data == MBS_BUSY); cnt--) {
670 			udelay(5);
671 			data = RD_MAILBOX_REG(ha, reg, 0);
672 			barrier();
673 		}
674 	} else
675 		udelay(10);
676 
677 	if (!cnt)
678 		goto chip_diag_failed;
679 
680 	/* Check product ID of chip */
681 	DEBUG3(printk("scsi(%ld): Checking product ID of chip\n", ha->host_no));
682 
683 	mb[1] = RD_MAILBOX_REG(ha, reg, 1);
684 	mb[2] = RD_MAILBOX_REG(ha, reg, 2);
685 	mb[3] = RD_MAILBOX_REG(ha, reg, 3);
686 	mb[4] = qla2x00_debounce_register(MAILBOX_REG(ha, reg, 4));
687 	if (mb[1] != PROD_ID_1 || (mb[2] != PROD_ID_2 && mb[2] != PROD_ID_2a) ||
688 	    mb[3] != PROD_ID_3) {
689 		qla_printk(KERN_WARNING, ha,
690 		    "Wrong product ID = 0x%x,0x%x,0x%x\n", mb[1], mb[2], mb[3]);
691 
692 		goto chip_diag_failed;
693 	}
694 	ha->product_id[0] = mb[1];
695 	ha->product_id[1] = mb[2];
696 	ha->product_id[2] = mb[3];
697 	ha->product_id[3] = mb[4];
698 
699 	/* Adjust fw RISC transfer size */
700 	if (ha->request_q_length > 1024)
701 		ha->fw_transfer_size = REQUEST_ENTRY_SIZE * 1024;
702 	else
703 		ha->fw_transfer_size = REQUEST_ENTRY_SIZE *
704 		    ha->request_q_length;
705 
706 	if (IS_QLA2200(ha) &&
707 	    RD_MAILBOX_REG(ha, reg, 7) == QLA2200A_RISC_ROM_VER) {
708 		/* Limit firmware transfer size with a 2200A */
709 		DEBUG3(printk("scsi(%ld): Found QLA2200A chip.\n",
710 		    ha->host_no));
711 
712 		ha->device_type |= DT_ISP2200A;
713 		ha->fw_transfer_size = 128;
714 	}
715 
716 	/* Wrap Incoming Mailboxes Test. */
717 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
718 
719 	DEBUG3(printk("scsi(%ld): Checking mailboxes.\n", ha->host_no));
720 	rval = qla2x00_mbx_reg_test(ha);
721 	if (rval) {
722 		DEBUG(printk("scsi(%ld): Failed mailbox send register test\n",
723 		    ha->host_no));
724 		qla_printk(KERN_WARNING, ha,
725 		    "Failed mailbox send register test\n");
726 	}
727 	else {
728 		/* Flag a successful rval */
729 		rval = QLA_SUCCESS;
730 	}
731 	spin_lock_irqsave(&ha->hardware_lock, flags);
732 
733 chip_diag_failed:
734 	if (rval)
735 		DEBUG2_3(printk("scsi(%ld): Chip diagnostics **** FAILED "
736 		    "****\n", ha->host_no));
737 
738 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
739 
740 	return (rval);
741 }
742 
743 /**
744  * qla24xx_chip_diag() - Test ISP24xx for proper operation.
745  * @ha: HA context
746  *
747  * Returns 0 on success.
748  */
749 int
750 qla24xx_chip_diag(scsi_qla_host_t *ha)
751 {
752 	int rval;
753 
754 	/* Perform RISC reset. */
755 	qla24xx_reset_risc(ha);
756 
757 	ha->fw_transfer_size = REQUEST_ENTRY_SIZE * 1024;
758 
759 	rval = qla2x00_mbx_reg_test(ha);
760 	if (rval) {
761 		DEBUG(printk("scsi(%ld): Failed mailbox send register test\n",
762 		    ha->host_no));
763 		qla_printk(KERN_WARNING, ha,
764 		    "Failed mailbox send register test\n");
765 	} else {
766 		/* Flag a successful rval */
767 		rval = QLA_SUCCESS;
768 	}
769 
770 	return rval;
771 }
772 
773 static void
774 qla2x00_alloc_fw_dump(scsi_qla_host_t *ha)
775 {
776 	uint32_t dump_size = 0;
777 
778 	ha->fw_dumped = 0;
779 	if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
780 		dump_size = sizeof(struct qla2100_fw_dump);
781 	} else if (IS_QLA23XX(ha)) {
782 		dump_size = sizeof(struct qla2300_fw_dump);
783 		dump_size += (ha->fw_memory_size - 0x11000) * sizeof(uint16_t);
784         } else if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
785 		dump_size = sizeof(struct qla24xx_fw_dump);
786 		dump_size += (ha->fw_memory_size - 0x100000) * sizeof(uint32_t);
787 	}
788 
789 	ha->fw_dump = vmalloc(dump_size);
790 	if (ha->fw_dump)
791 		qla_printk(KERN_INFO, ha, "Allocated (%d KB) for firmware "
792 		    "dump...\n", dump_size / 1024);
793 	else
794 		qla_printk(KERN_WARNING, ha, "Unable to allocate (%d KB) for "
795 		    "firmware dump!!!\n", dump_size / 1024);
796 }
797 
798 /**
799  * qla2x00_resize_request_q() - Resize request queue given available ISP memory.
800  * @ha: HA context
801  *
802  * Returns 0 on success.
803  */
804 static void
805 qla2x00_resize_request_q(scsi_qla_host_t *ha)
806 {
807 	int rval;
808 	uint16_t fw_iocb_cnt = 0;
809 	uint16_t request_q_length = REQUEST_ENTRY_CNT_2XXX_EXT_MEM;
810 	dma_addr_t request_dma;
811 	request_t *request_ring;
812 
813 	qla2x00_alloc_fw_dump(ha);
814 
815 	/* Valid only on recent ISPs. */
816 	if (IS_QLA2100(ha) || IS_QLA2200(ha))
817 		return;
818 
819 	/* Retrieve IOCB counts available to the firmware. */
820 	rval = qla2x00_get_resource_cnts(ha, NULL, NULL, NULL, &fw_iocb_cnt);
821 	if (rval)
822 		return;
823 	/* No point in continuing if current settings are sufficient. */
824 	if (fw_iocb_cnt < 1024)
825 		return;
826 	if (ha->request_q_length >= request_q_length)
827 		return;
828 
829 	/* Attempt to claim larger area for request queue. */
830 	request_ring = dma_alloc_coherent(&ha->pdev->dev,
831 	    (request_q_length + 1) * sizeof(request_t), &request_dma,
832 	    GFP_KERNEL);
833 	if (request_ring == NULL)
834 		return;
835 
836 	/* Resize successful, report extensions. */
837 	qla_printk(KERN_INFO, ha, "Extended memory detected (%d KB)...\n",
838 	    (ha->fw_memory_size + 1) / 1024);
839 	qla_printk(KERN_INFO, ha, "Resizing request queue depth "
840 	    "(%d -> %d)...\n", ha->request_q_length, request_q_length);
841 
842 	/* Clear old allocations. */
843 	dma_free_coherent(&ha->pdev->dev,
844 	    (ha->request_q_length + 1) * sizeof(request_t), ha->request_ring,
845 	    ha->request_dma);
846 
847 	/* Begin using larger queue. */
848 	ha->request_q_length = request_q_length;
849 	ha->request_ring = request_ring;
850 	ha->request_dma = request_dma;
851 }
852 
853 /**
854  * qla2x00_setup_chip() - Load and start RISC firmware.
855  * @ha: HA context
856  *
857  * Returns 0 on success.
858  */
859 static int
860 qla2x00_setup_chip(scsi_qla_host_t *ha)
861 {
862 	int rval;
863 	uint32_t srisc_address = 0;
864 
865 	/* Load firmware sequences */
866 	rval = ha->isp_ops.load_risc(ha, &srisc_address);
867 	if (rval == QLA_SUCCESS) {
868 		DEBUG(printk("scsi(%ld): Verifying Checksum of loaded RISC "
869 		    "code.\n", ha->host_no));
870 
871 		rval = qla2x00_verify_checksum(ha, srisc_address);
872 		if (rval == QLA_SUCCESS) {
873 			/* Start firmware execution. */
874 			DEBUG(printk("scsi(%ld): Checksum OK, start "
875 			    "firmware.\n", ha->host_no));
876 
877 			rval = qla2x00_execute_fw(ha, srisc_address);
878 			/* Retrieve firmware information. */
879 			if (rval == QLA_SUCCESS && ha->fw_major_version == 0) {
880 				qla2x00_get_fw_version(ha,
881 				    &ha->fw_major_version,
882 				    &ha->fw_minor_version,
883 				    &ha->fw_subminor_version,
884 				    &ha->fw_attributes, &ha->fw_memory_size);
885 				qla2x00_resize_request_q(ha);
886 			}
887 		} else {
888 			DEBUG2(printk(KERN_INFO
889 			    "scsi(%ld): ISP Firmware failed checksum.\n",
890 			    ha->host_no));
891 		}
892 	}
893 
894 	if (rval) {
895 		DEBUG2_3(printk("scsi(%ld): Setup chip **** FAILED ****.\n",
896 		    ha->host_no));
897 	}
898 
899 	return (rval);
900 }
901 
902 /**
903  * qla2x00_init_response_q_entries() - Initializes response queue entries.
904  * @ha: HA context
905  *
906  * Beginning of request ring has initialization control block already built
907  * by nvram config routine.
908  *
909  * Returns 0 on success.
910  */
911 static void
912 qla2x00_init_response_q_entries(scsi_qla_host_t *ha)
913 {
914 	uint16_t cnt;
915 	response_t *pkt;
916 
917 	pkt = ha->response_ring_ptr;
918 	for (cnt = 0; cnt < ha->response_q_length; cnt++) {
919 		pkt->signature = RESPONSE_PROCESSED;
920 		pkt++;
921 	}
922 
923 }
924 
925 /**
926  * qla2x00_update_fw_options() - Read and process firmware options.
927  * @ha: HA context
928  *
929  * Returns 0 on success.
930  */
931 void
932 qla2x00_update_fw_options(scsi_qla_host_t *ha)
933 {
934 	uint16_t swing, emphasis, tx_sens, rx_sens;
935 
936 	memset(ha->fw_options, 0, sizeof(ha->fw_options));
937 	qla2x00_get_fw_options(ha, ha->fw_options);
938 
939 	if (IS_QLA2100(ha) || IS_QLA2200(ha))
940 		return;
941 
942 	/* Serial Link options. */
943 	DEBUG3(printk("scsi(%ld): Serial link options:\n",
944 	    ha->host_no));
945 	DEBUG3(qla2x00_dump_buffer((uint8_t *)&ha->fw_seriallink_options,
946 	    sizeof(ha->fw_seriallink_options)));
947 
948 	ha->fw_options[1] &= ~FO1_SET_EMPHASIS_SWING;
949 	if (ha->fw_seriallink_options[3] & BIT_2) {
950 		ha->fw_options[1] |= FO1_SET_EMPHASIS_SWING;
951 
952 		/*  1G settings */
953 		swing = ha->fw_seriallink_options[2] & (BIT_2 | BIT_1 | BIT_0);
954 		emphasis = (ha->fw_seriallink_options[2] &
955 		    (BIT_4 | BIT_3)) >> 3;
956 		tx_sens = ha->fw_seriallink_options[0] &
957 		    (BIT_3 | BIT_2 | BIT_1 | BIT_0);
958 		rx_sens = (ha->fw_seriallink_options[0] &
959 		    (BIT_7 | BIT_6 | BIT_5 | BIT_4)) >> 4;
960 		ha->fw_options[10] = (emphasis << 14) | (swing << 8);
961 		if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
962 			if (rx_sens == 0x0)
963 				rx_sens = 0x3;
964 			ha->fw_options[10] |= (tx_sens << 4) | rx_sens;
965 		} else if (IS_QLA2322(ha) || IS_QLA6322(ha))
966 			ha->fw_options[10] |= BIT_5 |
967 			    ((rx_sens & (BIT_1 | BIT_0)) << 2) |
968 			    (tx_sens & (BIT_1 | BIT_0));
969 
970 		/*  2G settings */
971 		swing = (ha->fw_seriallink_options[2] &
972 		    (BIT_7 | BIT_6 | BIT_5)) >> 5;
973 		emphasis = ha->fw_seriallink_options[3] & (BIT_1 | BIT_0);
974 		tx_sens = ha->fw_seriallink_options[1] &
975 		    (BIT_3 | BIT_2 | BIT_1 | BIT_0);
976 		rx_sens = (ha->fw_seriallink_options[1] &
977 		    (BIT_7 | BIT_6 | BIT_5 | BIT_4)) >> 4;
978 		ha->fw_options[11] = (emphasis << 14) | (swing << 8);
979 		if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
980 			if (rx_sens == 0x0)
981 				rx_sens = 0x3;
982 			ha->fw_options[11] |= (tx_sens << 4) | rx_sens;
983 		} else if (IS_QLA2322(ha) || IS_QLA6322(ha))
984 			ha->fw_options[11] |= BIT_5 |
985 			    ((rx_sens & (BIT_1 | BIT_0)) << 2) |
986 			    (tx_sens & (BIT_1 | BIT_0));
987 	}
988 
989 	/* FCP2 options. */
990 	/*  Return command IOCBs without waiting for an ABTS to complete. */
991 	ha->fw_options[3] |= BIT_13;
992 
993 	/* LED scheme. */
994 	if (ha->flags.enable_led_scheme)
995 		ha->fw_options[2] |= BIT_12;
996 
997 	/* Detect ISP6312. */
998 	if (IS_QLA6312(ha))
999 		ha->fw_options[2] |= BIT_13;
1000 
1001 	/* Update firmware options. */
1002 	qla2x00_set_fw_options(ha, ha->fw_options);
1003 }
1004 
1005 void
1006 qla24xx_update_fw_options(scsi_qla_host_t *ha)
1007 {
1008 	int rval;
1009 
1010 	/* Update Serial Link options. */
1011 	if ((le16_to_cpu(ha->fw_seriallink_options24[0]) & BIT_0) == 0)
1012 		return;
1013 
1014 	rval = qla2x00_set_serdes_params(ha,
1015 	    le16_to_cpu(ha->fw_seriallink_options24[1]),
1016 	    le16_to_cpu(ha->fw_seriallink_options24[2]),
1017 	    le16_to_cpu(ha->fw_seriallink_options24[3]));
1018 	if (rval != QLA_SUCCESS) {
1019 		qla_printk(KERN_WARNING, ha,
1020 		    "Unable to update Serial Link options (%x).\n", rval);
1021 	}
1022 }
1023 
1024 void
1025 qla2x00_config_rings(struct scsi_qla_host *ha)
1026 {
1027 	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1028 
1029 	/* Setup ring parameters in initialization control block. */
1030 	ha->init_cb->request_q_outpointer = __constant_cpu_to_le16(0);
1031 	ha->init_cb->response_q_inpointer = __constant_cpu_to_le16(0);
1032 	ha->init_cb->request_q_length = cpu_to_le16(ha->request_q_length);
1033 	ha->init_cb->response_q_length = cpu_to_le16(ha->response_q_length);
1034 	ha->init_cb->request_q_address[0] = cpu_to_le32(LSD(ha->request_dma));
1035 	ha->init_cb->request_q_address[1] = cpu_to_le32(MSD(ha->request_dma));
1036 	ha->init_cb->response_q_address[0] = cpu_to_le32(LSD(ha->response_dma));
1037 	ha->init_cb->response_q_address[1] = cpu_to_le32(MSD(ha->response_dma));
1038 
1039 	WRT_REG_WORD(ISP_REQ_Q_IN(ha, reg), 0);
1040 	WRT_REG_WORD(ISP_REQ_Q_OUT(ha, reg), 0);
1041 	WRT_REG_WORD(ISP_RSP_Q_IN(ha, reg), 0);
1042 	WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), 0);
1043 	RD_REG_WORD(ISP_RSP_Q_OUT(ha, reg));		/* PCI Posting. */
1044 }
1045 
1046 void
1047 qla24xx_config_rings(struct scsi_qla_host *ha)
1048 {
1049 	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1050 	struct init_cb_24xx *icb;
1051 
1052 	/* Setup ring parameters in initialization control block. */
1053 	icb = (struct init_cb_24xx *)ha->init_cb;
1054 	icb->request_q_outpointer = __constant_cpu_to_le16(0);
1055 	icb->response_q_inpointer = __constant_cpu_to_le16(0);
1056 	icb->request_q_length = cpu_to_le16(ha->request_q_length);
1057 	icb->response_q_length = cpu_to_le16(ha->response_q_length);
1058 	icb->request_q_address[0] = cpu_to_le32(LSD(ha->request_dma));
1059 	icb->request_q_address[1] = cpu_to_le32(MSD(ha->request_dma));
1060 	icb->response_q_address[0] = cpu_to_le32(LSD(ha->response_dma));
1061 	icb->response_q_address[1] = cpu_to_le32(MSD(ha->response_dma));
1062 
1063 	WRT_REG_DWORD(&reg->req_q_in, 0);
1064 	WRT_REG_DWORD(&reg->req_q_out, 0);
1065 	WRT_REG_DWORD(&reg->rsp_q_in, 0);
1066 	WRT_REG_DWORD(&reg->rsp_q_out, 0);
1067 	RD_REG_DWORD(&reg->rsp_q_out);
1068 }
1069 
1070 /**
1071  * qla2x00_init_rings() - Initializes firmware.
1072  * @ha: HA context
1073  *
1074  * Beginning of request ring has initialization control block already built
1075  * by nvram config routine.
1076  *
1077  * Returns 0 on success.
1078  */
1079 static int
1080 qla2x00_init_rings(scsi_qla_host_t *ha)
1081 {
1082 	int	rval;
1083 	unsigned long flags = 0;
1084 	int cnt;
1085 
1086 	spin_lock_irqsave(&ha->hardware_lock, flags);
1087 
1088 	/* Clear outstanding commands array. */
1089 	for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++)
1090 		ha->outstanding_cmds[cnt] = NULL;
1091 
1092 	ha->current_outstanding_cmd = 0;
1093 
1094 	/* Clear RSCN queue. */
1095 	ha->rscn_in_ptr = 0;
1096 	ha->rscn_out_ptr = 0;
1097 
1098 	/* Initialize firmware. */
1099 	ha->request_ring_ptr  = ha->request_ring;
1100 	ha->req_ring_index    = 0;
1101 	ha->req_q_cnt         = ha->request_q_length;
1102 	ha->response_ring_ptr = ha->response_ring;
1103 	ha->rsp_ring_index    = 0;
1104 
1105 	/* Initialize response queue entries */
1106 	qla2x00_init_response_q_entries(ha);
1107 
1108 	ha->isp_ops.config_rings(ha);
1109 
1110 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
1111 
1112 	/* Update any ISP specific firmware options before initialization. */
1113 	ha->isp_ops.update_fw_options(ha);
1114 
1115 	DEBUG(printk("scsi(%ld): Issue init firmware.\n", ha->host_no));
1116 	rval = qla2x00_init_firmware(ha, ha->init_cb_size);
1117 	if (rval) {
1118 		DEBUG2_3(printk("scsi(%ld): Init firmware **** FAILED ****.\n",
1119 		    ha->host_no));
1120 	} else {
1121 		DEBUG3(printk("scsi(%ld): Init firmware -- success.\n",
1122 		    ha->host_no));
1123 	}
1124 
1125 	return (rval);
1126 }
1127 
1128 /**
1129  * qla2x00_fw_ready() - Waits for firmware ready.
1130  * @ha: HA context
1131  *
1132  * Returns 0 on success.
1133  */
1134 static int
1135 qla2x00_fw_ready(scsi_qla_host_t *ha)
1136 {
1137 	int		rval;
1138 	unsigned long	wtime, mtime;
1139 	uint16_t	min_wait;	/* Minimum wait time if loop is down */
1140 	uint16_t	wait_time;	/* Wait time if loop is coming ready */
1141 	uint16_t	fw_state;
1142 
1143 	rval = QLA_SUCCESS;
1144 
1145 	/* 20 seconds for loop down. */
1146 	min_wait = 20;
1147 
1148 	/*
1149 	 * Firmware should take at most one RATOV to login, plus 5 seconds for
1150 	 * our own processing.
1151 	 */
1152 	if ((wait_time = (ha->retry_count*ha->login_timeout) + 5) < min_wait) {
1153 		wait_time = min_wait;
1154 	}
1155 
1156 	/* Min wait time if loop down */
1157 	mtime = jiffies + (min_wait * HZ);
1158 
1159 	/* wait time before firmware ready */
1160 	wtime = jiffies + (wait_time * HZ);
1161 
1162 	/* Wait for ISP to finish LIP */
1163 	if (!ha->flags.init_done)
1164  		qla_printk(KERN_INFO, ha, "Waiting for LIP to complete...\n");
1165 
1166 	DEBUG3(printk("scsi(%ld): Waiting for LIP to complete...\n",
1167 	    ha->host_no));
1168 
1169 	do {
1170 		rval = qla2x00_get_firmware_state(ha, &fw_state);
1171 		if (rval == QLA_SUCCESS) {
1172 			if (fw_state < FSTATE_LOSS_OF_SYNC) {
1173 				ha->device_flags &= ~DFLG_NO_CABLE;
1174 			}
1175 			if (fw_state == FSTATE_READY) {
1176 				DEBUG(printk("scsi(%ld): F/W Ready - OK \n",
1177 				    ha->host_no));
1178 
1179 				qla2x00_get_retry_cnt(ha, &ha->retry_count,
1180 				    &ha->login_timeout, &ha->r_a_tov);
1181 
1182 				rval = QLA_SUCCESS;
1183 				break;
1184 			}
1185 
1186 			rval = QLA_FUNCTION_FAILED;
1187 
1188 			if (atomic_read(&ha->loop_down_timer) &&
1189 			    (fw_state >= FSTATE_LOSS_OF_SYNC ||
1190 				fw_state == FSTATE_WAIT_AL_PA)) {
1191 				/* Loop down. Timeout on min_wait for states
1192 				 * other than Wait for Login.
1193 				 */
1194 				if (time_after_eq(jiffies, mtime)) {
1195 					qla_printk(KERN_INFO, ha,
1196 					    "Cable is unplugged...\n");
1197 
1198 					ha->device_flags |= DFLG_NO_CABLE;
1199 					break;
1200 				}
1201 			}
1202 		} else {
1203 			/* Mailbox cmd failed. Timeout on min_wait. */
1204 			if (time_after_eq(jiffies, mtime))
1205 				break;
1206 		}
1207 
1208 		if (time_after_eq(jiffies, wtime))
1209 			break;
1210 
1211 		/* Delay for a while */
1212 		msleep(500);
1213 
1214 		DEBUG3(printk("scsi(%ld): fw_state=%x curr time=%lx.\n",
1215 		    ha->host_no, fw_state, jiffies));
1216 	} while (1);
1217 
1218 	DEBUG(printk("scsi(%ld): fw_state=%x curr time=%lx.\n",
1219 	    ha->host_no, fw_state, jiffies));
1220 
1221 	if (rval) {
1222 		DEBUG2_3(printk("scsi(%ld): Firmware ready **** FAILED ****.\n",
1223 		    ha->host_no));
1224 	}
1225 
1226 	return (rval);
1227 }
1228 
1229 /*
1230 *  qla2x00_configure_hba
1231 *      Setup adapter context.
1232 *
1233 * Input:
1234 *      ha = adapter state pointer.
1235 *
1236 * Returns:
1237 *      0 = success
1238 *
1239 * Context:
1240 *      Kernel context.
1241 */
1242 static int
1243 qla2x00_configure_hba(scsi_qla_host_t *ha)
1244 {
1245 	int       rval;
1246 	uint16_t      loop_id;
1247 	uint16_t      topo;
1248 	uint8_t       al_pa;
1249 	uint8_t       area;
1250 	uint8_t       domain;
1251 	char		connect_type[22];
1252 
1253 	/* Get host addresses. */
1254 	rval = qla2x00_get_adapter_id(ha,
1255 	    &loop_id, &al_pa, &area, &domain, &topo);
1256 	if (rval != QLA_SUCCESS) {
1257 		if (LOOP_TRANSITION(ha) || atomic_read(&ha->loop_down_timer) ||
1258 		    (rval == QLA_COMMAND_ERROR && loop_id == 0x7)) {
1259 			DEBUG2(printk("%s(%ld) Loop is in a transition state\n",
1260 			    __func__, ha->host_no));
1261 		} else {
1262 			qla_printk(KERN_WARNING, ha,
1263 			    "ERROR -- Unable to get host loop ID.\n");
1264 			set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1265 		}
1266 		return (rval);
1267 	}
1268 
1269 	if (topo == 4) {
1270 		qla_printk(KERN_INFO, ha,
1271 			"Cannot get topology - retrying.\n");
1272 		return (QLA_FUNCTION_FAILED);
1273 	}
1274 
1275 	ha->loop_id = loop_id;
1276 
1277 	/* initialize */
1278 	ha->min_external_loopid = SNS_FIRST_LOOP_ID;
1279 	ha->operating_mode = LOOP;
1280 
1281 	switch (topo) {
1282 	case 0:
1283 		DEBUG3(printk("scsi(%ld): HBA in NL topology.\n",
1284 		    ha->host_no));
1285 		ha->current_topology = ISP_CFG_NL;
1286 		strcpy(connect_type, "(Loop)");
1287 		break;
1288 
1289 	case 1:
1290 		DEBUG3(printk("scsi(%ld): HBA in FL topology.\n",
1291 		    ha->host_no));
1292 		ha->current_topology = ISP_CFG_FL;
1293 		strcpy(connect_type, "(FL_Port)");
1294 		break;
1295 
1296 	case 2:
1297 		DEBUG3(printk("scsi(%ld): HBA in N P2P topology.\n",
1298 		    ha->host_no));
1299 		ha->operating_mode = P2P;
1300 		ha->current_topology = ISP_CFG_N;
1301 		strcpy(connect_type, "(N_Port-to-N_Port)");
1302 		break;
1303 
1304 	case 3:
1305 		DEBUG3(printk("scsi(%ld): HBA in F P2P topology.\n",
1306 		    ha->host_no));
1307 		ha->operating_mode = P2P;
1308 		ha->current_topology = ISP_CFG_F;
1309 		strcpy(connect_type, "(F_Port)");
1310 		break;
1311 
1312 	default:
1313 		DEBUG3(printk("scsi(%ld): HBA in unknown topology %x. "
1314 		    "Using NL.\n",
1315 		    ha->host_no, topo));
1316 		ha->current_topology = ISP_CFG_NL;
1317 		strcpy(connect_type, "(Loop)");
1318 		break;
1319 	}
1320 
1321 	/* Save Host port and loop ID. */
1322 	/* byte order - Big Endian */
1323 	ha->d_id.b.domain = domain;
1324 	ha->d_id.b.area = area;
1325 	ha->d_id.b.al_pa = al_pa;
1326 
1327 	if (!ha->flags.init_done)
1328  		qla_printk(KERN_INFO, ha,
1329 		    "Topology - %s, Host Loop address 0x%x\n",
1330  		    connect_type, ha->loop_id);
1331 
1332 	if (rval) {
1333 		DEBUG2_3(printk("scsi(%ld): FAILED.\n", ha->host_no));
1334 	} else {
1335 		DEBUG3(printk("scsi(%ld): exiting normally.\n", ha->host_no));
1336 	}
1337 
1338 	return(rval);
1339 }
1340 
1341 /*
1342 * NVRAM configuration for ISP 2xxx
1343 *
1344 * Input:
1345 *      ha                = adapter block pointer.
1346 *
1347 * Output:
1348 *      initialization control block in response_ring
1349 *      host adapters parameters in host adapter block
1350 *
1351 * Returns:
1352 *      0 = success.
1353 */
1354 int
1355 qla2x00_nvram_config(scsi_qla_host_t *ha)
1356 {
1357 	int             rval;
1358 	uint8_t         chksum = 0;
1359 	uint16_t        cnt;
1360 	uint8_t         *dptr1, *dptr2;
1361 	init_cb_t       *icb = ha->init_cb;
1362 	nvram_t         *nv = (nvram_t *)ha->request_ring;
1363 	uint8_t         *ptr = (uint8_t *)ha->request_ring;
1364 	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1365 
1366 	rval = QLA_SUCCESS;
1367 
1368 	/* Determine NVRAM starting address. */
1369 	ha->nvram_size = sizeof(nvram_t);
1370 	ha->nvram_base = 0;
1371 	if (!IS_QLA2100(ha) && !IS_QLA2200(ha) && !IS_QLA2300(ha))
1372 		if ((RD_REG_WORD(&reg->ctrl_status) >> 14) == 1)
1373 			ha->nvram_base = 0x80;
1374 
1375 	/* Get NVRAM data and calculate checksum. */
1376 	ha->isp_ops.read_nvram(ha, ptr, ha->nvram_base, ha->nvram_size);
1377 	for (cnt = 0, chksum = 0; cnt < ha->nvram_size; cnt++)
1378 		chksum += *ptr++;
1379 
1380 	DEBUG5(printk("scsi(%ld): Contents of NVRAM\n", ha->host_no));
1381 	DEBUG5(qla2x00_dump_buffer((uint8_t *)ha->request_ring,
1382 	    ha->nvram_size));
1383 
1384 	/* Bad NVRAM data, set defaults parameters. */
1385 	if (chksum || nv->id[0] != 'I' || nv->id[1] != 'S' ||
1386 	    nv->id[2] != 'P' || nv->id[3] != ' ' || nv->nvram_version < 1) {
1387 		/* Reset NVRAM data. */
1388 		qla_printk(KERN_WARNING, ha, "Inconsistent NVRAM detected: "
1389 		    "checksum=0x%x id=%c version=0x%x.\n", chksum, nv->id[0],
1390 		    nv->nvram_version);
1391 		qla_printk(KERN_WARNING, ha, "Falling back to functioning (yet "
1392 		    "invalid -- WWPN) defaults.\n");
1393 
1394 		/*
1395 		 * Set default initialization control block.
1396 		 */
1397 		memset(nv, 0, ha->nvram_size);
1398 		nv->parameter_block_version = ICB_VERSION;
1399 
1400 		if (IS_QLA23XX(ha)) {
1401 			nv->firmware_options[0] = BIT_2 | BIT_1;
1402 			nv->firmware_options[1] = BIT_7 | BIT_5;
1403 			nv->add_firmware_options[0] = BIT_5;
1404 			nv->add_firmware_options[1] = BIT_5 | BIT_4;
1405 			nv->frame_payload_size = __constant_cpu_to_le16(2048);
1406 			nv->special_options[1] = BIT_7;
1407 		} else if (IS_QLA2200(ha)) {
1408 			nv->firmware_options[0] = BIT_2 | BIT_1;
1409 			nv->firmware_options[1] = BIT_7 | BIT_5;
1410 			nv->add_firmware_options[0] = BIT_5;
1411 			nv->add_firmware_options[1] = BIT_5 | BIT_4;
1412 			nv->frame_payload_size = __constant_cpu_to_le16(1024);
1413 		} else if (IS_QLA2100(ha)) {
1414 			nv->firmware_options[0] = BIT_3 | BIT_1;
1415 			nv->firmware_options[1] = BIT_5;
1416 			nv->frame_payload_size = __constant_cpu_to_le16(1024);
1417 		}
1418 
1419 		nv->max_iocb_allocation = __constant_cpu_to_le16(256);
1420 		nv->execution_throttle = __constant_cpu_to_le16(16);
1421 		nv->retry_count = 8;
1422 		nv->retry_delay = 1;
1423 
1424 		nv->port_name[0] = 33;
1425 		nv->port_name[3] = 224;
1426 		nv->port_name[4] = 139;
1427 
1428 		nv->login_timeout = 4;
1429 
1430 		/*
1431 		 * Set default host adapter parameters
1432 		 */
1433 		nv->host_p[1] = BIT_2;
1434 		nv->reset_delay = 5;
1435 		nv->port_down_retry_count = 8;
1436 		nv->max_luns_per_target = __constant_cpu_to_le16(8);
1437 		nv->link_down_timeout = 60;
1438 
1439 		rval = 1;
1440 	}
1441 
1442 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
1443 	/*
1444 	 * The SN2 does not provide BIOS emulation which means you can't change
1445 	 * potentially bogus BIOS settings. Force the use of default settings
1446 	 * for link rate and frame size.  Hope that the rest of the settings
1447 	 * are valid.
1448 	 */
1449 	if (ia64_platform_is("sn2")) {
1450 		nv->frame_payload_size = __constant_cpu_to_le16(2048);
1451 		if (IS_QLA23XX(ha))
1452 			nv->special_options[1] = BIT_7;
1453 	}
1454 #endif
1455 
1456 	/* Reset Initialization control block */
1457 	memset(icb, 0, ha->init_cb_size);
1458 
1459 	/*
1460 	 * Setup driver NVRAM options.
1461 	 */
1462 	nv->firmware_options[0] |= (BIT_6 | BIT_1);
1463 	nv->firmware_options[0] &= ~(BIT_5 | BIT_4);
1464 	nv->firmware_options[1] |= (BIT_5 | BIT_0);
1465 	nv->firmware_options[1] &= ~BIT_4;
1466 
1467 	if (IS_QLA23XX(ha)) {
1468 		nv->firmware_options[0] |= BIT_2;
1469 		nv->firmware_options[0] &= ~BIT_3;
1470 		nv->add_firmware_options[1] |= BIT_5 | BIT_4;
1471 
1472 		if (IS_QLA2300(ha)) {
1473 			if (ha->fb_rev == FPM_2310) {
1474 				strcpy(ha->model_number, "QLA2310");
1475 			} else {
1476 				strcpy(ha->model_number, "QLA2300");
1477 			}
1478 		} else {
1479 			if (rval == 0 &&
1480 			    memcmp(nv->model_number, BINZERO,
1481 				    sizeof(nv->model_number)) != 0) {
1482 				char *st, *en;
1483 
1484 				strncpy(ha->model_number, nv->model_number,
1485 				    sizeof(nv->model_number));
1486 				st = en = ha->model_number;
1487 				en += sizeof(nv->model_number) - 1;
1488 				while (en > st) {
1489 					if (*en != 0x20 && *en != 0x00)
1490 						break;
1491 					*en-- = '\0';
1492 				}
1493 			} else {
1494 				uint16_t        index;
1495 
1496 				index = (ha->pdev->subsystem_device & 0xff);
1497 				if (index < QLA_MODEL_NAMES) {
1498 					strcpy(ha->model_number,
1499 					    qla2x00_model_name[index * 2]);
1500 					ha->model_desc =
1501 					    qla2x00_model_name[index * 2 + 1];
1502 				} else {
1503 					strcpy(ha->model_number, "QLA23xx");
1504 				}
1505 			}
1506 		}
1507 	} else if (IS_QLA2200(ha)) {
1508 		nv->firmware_options[0] |= BIT_2;
1509 		/*
1510 		 * 'Point-to-point preferred, else loop' is not a safe
1511 		 * connection mode setting.
1512 		 */
1513 		if ((nv->add_firmware_options[0] & (BIT_6 | BIT_5 | BIT_4)) ==
1514 		    (BIT_5 | BIT_4)) {
1515 			/* Force 'loop preferred, else point-to-point'. */
1516 			nv->add_firmware_options[0] &= ~(BIT_6 | BIT_5 | BIT_4);
1517 			nv->add_firmware_options[0] |= BIT_5;
1518 		}
1519 		strcpy(ha->model_number, "QLA22xx");
1520 	} else /*if (IS_QLA2100(ha))*/ {
1521 		strcpy(ha->model_number, "QLA2100");
1522 	}
1523 
1524 	/*
1525 	 * Copy over NVRAM RISC parameter block to initialization control block.
1526 	 */
1527 	dptr1 = (uint8_t *)icb;
1528 	dptr2 = (uint8_t *)&nv->parameter_block_version;
1529 	cnt = (uint8_t *)&icb->request_q_outpointer - (uint8_t *)&icb->version;
1530 	while (cnt--)
1531 		*dptr1++ = *dptr2++;
1532 
1533 	/* Copy 2nd half. */
1534 	dptr1 = (uint8_t *)icb->add_firmware_options;
1535 	cnt = (uint8_t *)icb->reserved_3 - (uint8_t *)icb->add_firmware_options;
1536 	while (cnt--)
1537 		*dptr1++ = *dptr2++;
1538 
1539 	/* Use alternate WWN? */
1540 	if (nv->host_p[1] & BIT_7) {
1541 		memcpy(icb->node_name, nv->alternate_node_name, WWN_SIZE);
1542 		memcpy(icb->port_name, nv->alternate_port_name, WWN_SIZE);
1543 	}
1544 
1545 	/* Prepare nodename */
1546 	if ((icb->firmware_options[1] & BIT_6) == 0) {
1547 		/*
1548 		 * Firmware will apply the following mask if the nodename was
1549 		 * not provided.
1550 		 */
1551 		memcpy(icb->node_name, icb->port_name, WWN_SIZE);
1552 		icb->node_name[0] &= 0xF0;
1553 	}
1554 
1555 	/*
1556 	 * Set host adapter parameters.
1557 	 */
1558 	ha->flags.disable_risc_code_load = ((nv->host_p[0] & BIT_4) ? 1 : 0);
1559 	/* Always load RISC code on non ISP2[12]00 chips. */
1560 	if (!IS_QLA2100(ha) && !IS_QLA2200(ha))
1561 		ha->flags.disable_risc_code_load = 0;
1562 	ha->flags.enable_lip_reset = ((nv->host_p[1] & BIT_1) ? 1 : 0);
1563 	ha->flags.enable_lip_full_login = ((nv->host_p[1] & BIT_2) ? 1 : 0);
1564 	ha->flags.enable_target_reset = ((nv->host_p[1] & BIT_3) ? 1 : 0);
1565 	ha->flags.enable_led_scheme = (nv->special_options[1] & BIT_4) ? 1 : 0;
1566 
1567 	ha->operating_mode =
1568 	    (icb->add_firmware_options[0] & (BIT_6 | BIT_5 | BIT_4)) >> 4;
1569 
1570 	memcpy(ha->fw_seriallink_options, nv->seriallink_options,
1571 	    sizeof(ha->fw_seriallink_options));
1572 
1573 	/* save HBA serial number */
1574 	ha->serial0 = icb->port_name[5];
1575 	ha->serial1 = icb->port_name[6];
1576 	ha->serial2 = icb->port_name[7];
1577 	ha->node_name = icb->node_name;
1578 	ha->port_name = icb->port_name;
1579 
1580 	icb->execution_throttle = __constant_cpu_to_le16(0xFFFF);
1581 
1582 	ha->retry_count = nv->retry_count;
1583 
1584 	/* Set minimum login_timeout to 4 seconds. */
1585 	if (nv->login_timeout < ql2xlogintimeout)
1586 		nv->login_timeout = ql2xlogintimeout;
1587 	if (nv->login_timeout < 4)
1588 		nv->login_timeout = 4;
1589 	ha->login_timeout = nv->login_timeout;
1590 	icb->login_timeout = nv->login_timeout;
1591 
1592 	/* Set minimum RATOV to 200 tenths of a second. */
1593 	ha->r_a_tov = 200;
1594 
1595 	ha->loop_reset_delay = nv->reset_delay;
1596 
1597 	/* Link Down Timeout = 0:
1598 	 *
1599 	 * 	When Port Down timer expires we will start returning
1600 	 *	I/O's to OS with "DID_NO_CONNECT".
1601 	 *
1602 	 * Link Down Timeout != 0:
1603 	 *
1604 	 *	 The driver waits for the link to come up after link down
1605 	 *	 before returning I/Os to OS with "DID_NO_CONNECT".
1606 	 */
1607 	if (nv->link_down_timeout == 0) {
1608 		ha->loop_down_abort_time =
1609 		    (LOOP_DOWN_TIME - LOOP_DOWN_TIMEOUT);
1610 	} else {
1611 		ha->link_down_timeout =	 nv->link_down_timeout;
1612 		ha->loop_down_abort_time =
1613 		    (LOOP_DOWN_TIME - ha->link_down_timeout);
1614 	}
1615 
1616 	/*
1617 	 * Need enough time to try and get the port back.
1618 	 */
1619 	ha->port_down_retry_count = nv->port_down_retry_count;
1620 	if (qlport_down_retry)
1621 		ha->port_down_retry_count = qlport_down_retry;
1622 	/* Set login_retry_count */
1623 	ha->login_retry_count  = nv->retry_count;
1624 	if (ha->port_down_retry_count == nv->port_down_retry_count &&
1625 	    ha->port_down_retry_count > 3)
1626 		ha->login_retry_count = ha->port_down_retry_count;
1627 	else if (ha->port_down_retry_count > (int)ha->login_retry_count)
1628 		ha->login_retry_count = ha->port_down_retry_count;
1629 	if (ql2xloginretrycount)
1630 		ha->login_retry_count = ql2xloginretrycount;
1631 
1632 	icb->lun_enables = __constant_cpu_to_le16(0);
1633 	icb->command_resource_count = 0;
1634 	icb->immediate_notify_resource_count = 0;
1635 	icb->timeout = __constant_cpu_to_le16(0);
1636 
1637 	if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
1638 		/* Enable RIO */
1639 		icb->firmware_options[0] &= ~BIT_3;
1640 		icb->add_firmware_options[0] &=
1641 		    ~(BIT_3 | BIT_2 | BIT_1 | BIT_0);
1642 		icb->add_firmware_options[0] |= BIT_2;
1643 		icb->response_accumulation_timer = 3;
1644 		icb->interrupt_delay_timer = 5;
1645 
1646 		ha->flags.process_response_queue = 1;
1647 	} else {
1648 		/* Enable ZIO. */
1649 		if (!ha->flags.init_done) {
1650 			ha->zio_mode = icb->add_firmware_options[0] &
1651 			    (BIT_3 | BIT_2 | BIT_1 | BIT_0);
1652 			ha->zio_timer = icb->interrupt_delay_timer ?
1653 			    icb->interrupt_delay_timer: 2;
1654 		}
1655 		icb->add_firmware_options[0] &=
1656 		    ~(BIT_3 | BIT_2 | BIT_1 | BIT_0);
1657 		ha->flags.process_response_queue = 0;
1658 		if (ha->zio_mode != QLA_ZIO_DISABLED) {
1659 			ha->zio_mode = QLA_ZIO_MODE_6;
1660 
1661 			DEBUG2(printk("scsi(%ld): ZIO mode %d enabled; timer "
1662 			    "delay (%d us).\n", ha->host_no, ha->zio_mode,
1663 			    ha->zio_timer * 100));
1664 			qla_printk(KERN_INFO, ha,
1665 			    "ZIO mode %d enabled; timer delay (%d us).\n",
1666 			    ha->zio_mode, ha->zio_timer * 100);
1667 
1668 			icb->add_firmware_options[0] |= (uint8_t)ha->zio_mode;
1669 			icb->interrupt_delay_timer = (uint8_t)ha->zio_timer;
1670 			ha->flags.process_response_queue = 1;
1671 		}
1672 	}
1673 
1674 	if (rval) {
1675 		DEBUG2_3(printk(KERN_WARNING
1676 		    "scsi(%ld): NVRAM configuration failed!\n", ha->host_no));
1677 	}
1678 	return (rval);
1679 }
1680 
1681 static void
1682 qla2x00_rport_del(void *data)
1683 {
1684 	fc_port_t *fcport = data;
1685 	struct fc_rport *rport;
1686 	unsigned long flags;
1687 
1688 	spin_lock_irqsave(&fcport->rport_lock, flags);
1689 	rport = fcport->drport;
1690 	fcport->drport = NULL;
1691 	spin_unlock_irqrestore(&fcport->rport_lock, flags);
1692 	if (rport)
1693 		fc_remote_port_delete(rport);
1694 
1695 }
1696 
1697 /**
1698  * qla2x00_alloc_fcport() - Allocate a generic fcport.
1699  * @ha: HA context
1700  * @flags: allocation flags
1701  *
1702  * Returns a pointer to the allocated fcport, or NULL, if none available.
1703  */
1704 fc_port_t *
1705 qla2x00_alloc_fcport(scsi_qla_host_t *ha, gfp_t flags)
1706 {
1707 	fc_port_t *fcport;
1708 
1709 	fcport = kmalloc(sizeof(fc_port_t), flags);
1710 	if (fcport == NULL)
1711 		return (fcport);
1712 
1713 	/* Setup fcport template structure. */
1714 	memset(fcport, 0, sizeof (fc_port_t));
1715 	fcport->ha = ha;
1716 	fcport->port_type = FCT_UNKNOWN;
1717 	fcport->loop_id = FC_NO_LOOP_ID;
1718 	atomic_set(&fcport->state, FCS_UNCONFIGURED);
1719 	fcport->flags = FCF_RLC_SUPPORT;
1720 	fcport->supported_classes = FC_COS_UNSPECIFIED;
1721 	spin_lock_init(&fcport->rport_lock);
1722 
1723 	return (fcport);
1724 }
1725 
1726 /*
1727  * qla2x00_configure_loop
1728  *      Updates Fibre Channel Device Database with what is actually on loop.
1729  *
1730  * Input:
1731  *      ha                = adapter block pointer.
1732  *
1733  * Returns:
1734  *      0 = success.
1735  *      1 = error.
1736  *      2 = database was full and device was not configured.
1737  */
1738 static int
1739 qla2x00_configure_loop(scsi_qla_host_t *ha)
1740 {
1741 	int  rval;
1742 	unsigned long flags, save_flags;
1743 
1744 	rval = QLA_SUCCESS;
1745 
1746 	/* Get Initiator ID */
1747 	if (test_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags)) {
1748 		rval = qla2x00_configure_hba(ha);
1749 		if (rval != QLA_SUCCESS) {
1750 			DEBUG(printk("scsi(%ld): Unable to configure HBA.\n",
1751 			    ha->host_no));
1752 			return (rval);
1753 		}
1754 	}
1755 
1756 	save_flags = flags = ha->dpc_flags;
1757 	DEBUG(printk("scsi(%ld): Configure loop -- dpc flags =0x%lx\n",
1758 	    ha->host_no, flags));
1759 
1760 	/*
1761 	 * If we have both an RSCN and PORT UPDATE pending then handle them
1762 	 * both at the same time.
1763 	 */
1764 	clear_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags);
1765 	clear_bit(RSCN_UPDATE, &ha->dpc_flags);
1766 
1767 	/* Determine what we need to do */
1768 	if (ha->current_topology == ISP_CFG_FL &&
1769 	    (test_bit(LOCAL_LOOP_UPDATE, &flags))) {
1770 
1771 		ha->flags.rscn_queue_overflow = 1;
1772 		set_bit(RSCN_UPDATE, &flags);
1773 
1774 	} else if (ha->current_topology == ISP_CFG_F &&
1775 	    (test_bit(LOCAL_LOOP_UPDATE, &flags))) {
1776 
1777 		ha->flags.rscn_queue_overflow = 1;
1778 		set_bit(RSCN_UPDATE, &flags);
1779 		clear_bit(LOCAL_LOOP_UPDATE, &flags);
1780 
1781 	} else if (ha->current_topology == ISP_CFG_N) {
1782 		clear_bit(RSCN_UPDATE, &flags);
1783 
1784 	} else if (!ha->flags.online ||
1785 	    (test_bit(ABORT_ISP_ACTIVE, &flags))) {
1786 
1787 		ha->flags.rscn_queue_overflow = 1;
1788 		set_bit(RSCN_UPDATE, &flags);
1789 		set_bit(LOCAL_LOOP_UPDATE, &flags);
1790 	}
1791 
1792 	if (test_bit(LOCAL_LOOP_UPDATE, &flags)) {
1793 		if (test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags)) {
1794 			rval = QLA_FUNCTION_FAILED;
1795 		} else {
1796 			rval = qla2x00_configure_local_loop(ha);
1797 		}
1798 	}
1799 
1800 	if (rval == QLA_SUCCESS && test_bit(RSCN_UPDATE, &flags)) {
1801 		if (LOOP_TRANSITION(ha)) {
1802 			rval = QLA_FUNCTION_FAILED;
1803 		} else {
1804 			rval = qla2x00_configure_fabric(ha);
1805 		}
1806 	}
1807 
1808 	if (rval == QLA_SUCCESS) {
1809 		if (atomic_read(&ha->loop_down_timer) ||
1810 		    test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags)) {
1811 			rval = QLA_FUNCTION_FAILED;
1812 		} else {
1813 			atomic_set(&ha->loop_state, LOOP_READY);
1814 
1815 			DEBUG(printk("scsi(%ld): LOOP READY\n", ha->host_no));
1816 		}
1817 	}
1818 
1819 	if (rval) {
1820 		DEBUG2_3(printk("%s(%ld): *** FAILED ***\n",
1821 		    __func__, ha->host_no));
1822 	} else {
1823 		DEBUG3(printk("%s: exiting normally\n", __func__));
1824 	}
1825 
1826 	/* Restore state if a resync event occured during processing */
1827 	if (test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags)) {
1828 		if (test_bit(LOCAL_LOOP_UPDATE, &save_flags))
1829 			set_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags);
1830 		if (test_bit(RSCN_UPDATE, &save_flags))
1831 			set_bit(RSCN_UPDATE, &ha->dpc_flags);
1832 	}
1833 
1834 	return (rval);
1835 }
1836 
1837 
1838 
1839 /*
1840  * qla2x00_configure_local_loop
1841  *	Updates Fibre Channel Device Database with local loop devices.
1842  *
1843  * Input:
1844  *	ha = adapter block pointer.
1845  *
1846  * Returns:
1847  *	0 = success.
1848  */
1849 static int
1850 qla2x00_configure_local_loop(scsi_qla_host_t *ha)
1851 {
1852 	int		rval, rval2;
1853 	int		found_devs;
1854 	int		found;
1855 	fc_port_t	*fcport, *new_fcport;
1856 
1857 	uint16_t	index;
1858 	uint16_t	entries;
1859 	char		*id_iter;
1860 	uint16_t	loop_id;
1861 	uint8_t		domain, area, al_pa;
1862 
1863 	found_devs = 0;
1864 	new_fcport = NULL;
1865 	entries = MAX_FIBRE_DEVICES;
1866 
1867 	DEBUG3(printk("scsi(%ld): Getting FCAL position map\n", ha->host_no));
1868 	DEBUG3(qla2x00_get_fcal_position_map(ha, NULL));
1869 
1870 	/* Get list of logged in devices. */
1871 	memset(ha->gid_list, 0, GID_LIST_SIZE);
1872 	rval = qla2x00_get_id_list(ha, ha->gid_list, ha->gid_list_dma,
1873 	    &entries);
1874 	if (rval != QLA_SUCCESS)
1875 		goto cleanup_allocation;
1876 
1877 	DEBUG3(printk("scsi(%ld): Entries in ID list (%d)\n",
1878 	    ha->host_no, entries));
1879 	DEBUG3(qla2x00_dump_buffer((uint8_t *)ha->gid_list,
1880 	    entries * sizeof(struct gid_list_info)));
1881 
1882 	/* Allocate temporary fcport for any new fcports discovered. */
1883 	new_fcport = qla2x00_alloc_fcport(ha, GFP_KERNEL);
1884 	if (new_fcport == NULL) {
1885 		rval = QLA_MEMORY_ALLOC_FAILED;
1886 		goto cleanup_allocation;
1887 	}
1888 	new_fcport->flags &= ~FCF_FABRIC_DEVICE;
1889 
1890 	/*
1891 	 * Mark local devices that were present with FCF_DEVICE_LOST for now.
1892 	 */
1893 	list_for_each_entry(fcport, &ha->fcports, list) {
1894 		if (atomic_read(&fcport->state) == FCS_ONLINE &&
1895 		    fcport->port_type != FCT_BROADCAST &&
1896 		    (fcport->flags & FCF_FABRIC_DEVICE) == 0) {
1897 
1898 			DEBUG(printk("scsi(%ld): Marking port lost, "
1899 			    "loop_id=0x%04x\n",
1900 			    ha->host_no, fcport->loop_id));
1901 
1902 			atomic_set(&fcport->state, FCS_DEVICE_LOST);
1903 			fcport->flags &= ~FCF_FARP_DONE;
1904 		}
1905 	}
1906 
1907 	/* Add devices to port list. */
1908 	id_iter = (char *)ha->gid_list;
1909 	for (index = 0; index < entries; index++) {
1910 		domain = ((struct gid_list_info *)id_iter)->domain;
1911 		area = ((struct gid_list_info *)id_iter)->area;
1912 		al_pa = ((struct gid_list_info *)id_iter)->al_pa;
1913 		if (IS_QLA2100(ha) || IS_QLA2200(ha))
1914 			loop_id = (uint16_t)
1915 			    ((struct gid_list_info *)id_iter)->loop_id_2100;
1916 		else
1917 			loop_id = le16_to_cpu(
1918 			    ((struct gid_list_info *)id_iter)->loop_id);
1919 		id_iter += ha->gid_list_info_size;
1920 
1921 		/* Bypass reserved domain fields. */
1922 		if ((domain & 0xf0) == 0xf0)
1923 			continue;
1924 
1925 		/* Bypass if not same domain and area of adapter. */
1926 		if (area && domain &&
1927 		    (area != ha->d_id.b.area || domain != ha->d_id.b.domain))
1928 			continue;
1929 
1930 		/* Bypass invalid local loop ID. */
1931 		if (loop_id > LAST_LOCAL_LOOP_ID)
1932 			continue;
1933 
1934 		/* Fill in member data. */
1935 		new_fcport->d_id.b.domain = domain;
1936 		new_fcport->d_id.b.area = area;
1937 		new_fcport->d_id.b.al_pa = al_pa;
1938 		new_fcport->loop_id = loop_id;
1939 		rval2 = qla2x00_get_port_database(ha, new_fcport, 0);
1940 		if (rval2 != QLA_SUCCESS) {
1941 			DEBUG2(printk("scsi(%ld): Failed to retrieve fcport "
1942 			    "information -- get_port_database=%x, "
1943 			    "loop_id=0x%04x\n",
1944 			    ha->host_no, rval2, new_fcport->loop_id));
1945 			DEBUG2(printk("scsi(%ld): Scheduling resync...\n",
1946 			    ha->host_no));
1947 			set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
1948 			continue;
1949 		}
1950 
1951 		/* Check for matching device in port list. */
1952 		found = 0;
1953 		fcport = NULL;
1954 		list_for_each_entry(fcport, &ha->fcports, list) {
1955 			if (memcmp(new_fcport->port_name, fcport->port_name,
1956 			    WWN_SIZE))
1957 				continue;
1958 
1959 			fcport->flags &= ~(FCF_FABRIC_DEVICE |
1960 			    FCF_PERSISTENT_BOUND);
1961 			fcport->loop_id = new_fcport->loop_id;
1962 			fcport->port_type = new_fcport->port_type;
1963 			fcport->d_id.b24 = new_fcport->d_id.b24;
1964 			memcpy(fcport->node_name, new_fcport->node_name,
1965 			    WWN_SIZE);
1966 
1967 			found++;
1968 			break;
1969 		}
1970 
1971 		if (!found) {
1972 			/* New device, add to fcports list. */
1973 			new_fcport->flags &= ~FCF_PERSISTENT_BOUND;
1974 			list_add_tail(&new_fcport->list, &ha->fcports);
1975 
1976 			/* Allocate a new replacement fcport. */
1977 			fcport = new_fcport;
1978 			new_fcport = qla2x00_alloc_fcport(ha, GFP_KERNEL);
1979 			if (new_fcport == NULL) {
1980 				rval = QLA_MEMORY_ALLOC_FAILED;
1981 				goto cleanup_allocation;
1982 			}
1983 			new_fcport->flags &= ~FCF_FABRIC_DEVICE;
1984 		}
1985 
1986 		qla2x00_update_fcport(ha, fcport);
1987 
1988 		found_devs++;
1989 	}
1990 
1991 cleanup_allocation:
1992 	kfree(new_fcport);
1993 
1994 	if (rval != QLA_SUCCESS) {
1995 		DEBUG2(printk("scsi(%ld): Configure local loop error exit: "
1996 		    "rval=%x\n", ha->host_no, rval));
1997 	}
1998 
1999 	if (found_devs) {
2000 		ha->device_flags |= DFLG_LOCAL_DEVICES;
2001 		ha->device_flags &= ~DFLG_RETRY_LOCAL_DEVICES;
2002 	}
2003 
2004 	return (rval);
2005 }
2006 
2007 static void
2008 qla2x00_probe_for_all_luns(scsi_qla_host_t *ha)
2009 {
2010 	fc_port_t	*fcport;
2011 
2012 	qla2x00_mark_all_devices_lost(ha, 0);
2013  	list_for_each_entry(fcport, &ha->fcports, list) {
2014 		if (fcport->port_type != FCT_TARGET)
2015 			continue;
2016 
2017 		qla2x00_update_fcport(ha, fcport);
2018 	}
2019 }
2020 
2021 /*
2022  * qla2x00_update_fcport
2023  *	Updates device on list.
2024  *
2025  * Input:
2026  *	ha = adapter block pointer.
2027  *	fcport = port structure pointer.
2028  *
2029  * Return:
2030  *	0  - Success
2031  *  BIT_0 - error
2032  *
2033  * Context:
2034  *	Kernel context.
2035  */
2036 void
2037 qla2x00_update_fcport(scsi_qla_host_t *ha, fc_port_t *fcport)
2038 {
2039 	fcport->ha = ha;
2040 	fcport->login_retry = 0;
2041 	fcport->port_login_retry_count = ha->port_down_retry_count *
2042 	    PORT_RETRY_TIME;
2043 	atomic_set(&fcport->port_down_timer, ha->port_down_retry_count *
2044 	    PORT_RETRY_TIME);
2045 	fcport->flags &= ~FCF_LOGIN_NEEDED;
2046 
2047 	atomic_set(&fcport->state, FCS_ONLINE);
2048 
2049 	if (ha->flags.init_done)
2050 		qla2x00_reg_remote_port(ha, fcport);
2051 }
2052 
2053 void
2054 qla2x00_reg_remote_port(scsi_qla_host_t *ha, fc_port_t *fcport)
2055 {
2056 	struct fc_rport_identifiers rport_ids;
2057 	struct fc_rport *rport;
2058 	unsigned long flags;
2059 
2060 	if (fcport->drport)
2061 		qla2x00_rport_del(fcport);
2062 	if (fcport->rport)
2063 		return;
2064 
2065 	rport_ids.node_name = wwn_to_u64(fcport->node_name);
2066 	rport_ids.port_name = wwn_to_u64(fcport->port_name);
2067 	rport_ids.port_id = fcport->d_id.b.domain << 16 |
2068 	    fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
2069 	rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
2070 	rport = fc_remote_port_add(ha->host, 0, &rport_ids);
2071 	if (!rport) {
2072 		qla_printk(KERN_WARNING, ha,
2073 		    "Unable to allocate fc remote port!\n");
2074 		return;
2075 	}
2076 	spin_lock_irqsave(&fcport->rport_lock, flags);
2077 	fcport->rport = rport;
2078 	*((fc_port_t **)rport->dd_data) = fcport;
2079 	spin_unlock_irqrestore(&fcport->rport_lock, flags);
2080 
2081 	rport->supported_classes = fcport->supported_classes;
2082 
2083 	rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
2084 	if (fcport->port_type == FCT_INITIATOR)
2085 		rport_ids.roles |= FC_RPORT_ROLE_FCP_INITIATOR;
2086 	if (fcport->port_type == FCT_TARGET)
2087 		rport_ids.roles |= FC_RPORT_ROLE_FCP_TARGET;
2088 	fc_remote_port_rolechg(rport, rport_ids.roles);
2089 
2090 	if (rport->scsi_target_id != -1 &&
2091 	    rport->scsi_target_id < ha->host->max_id)
2092 		fcport->os_target_id = rport->scsi_target_id;
2093 }
2094 
2095 /*
2096  * qla2x00_configure_fabric
2097  *      Setup SNS devices with loop ID's.
2098  *
2099  * Input:
2100  *      ha = adapter block pointer.
2101  *
2102  * Returns:
2103  *      0 = success.
2104  *      BIT_0 = error
2105  */
2106 static int
2107 qla2x00_configure_fabric(scsi_qla_host_t *ha)
2108 {
2109 	int	rval, rval2;
2110 	fc_port_t	*fcport, *fcptemp;
2111 	uint16_t	next_loopid;
2112 	uint16_t	mb[MAILBOX_REGISTER_COUNT];
2113 	uint16_t	loop_id;
2114 	LIST_HEAD(new_fcports);
2115 
2116 	/* If FL port exists, then SNS is present */
2117 	if (IS_QLA24XX(ha) || IS_QLA54XX(ha))
2118 		loop_id = NPH_F_PORT;
2119 	else
2120 		loop_id = SNS_FL_PORT;
2121 	rval = qla2x00_get_port_name(ha, loop_id, NULL, 0);
2122 	if (rval != QLA_SUCCESS) {
2123 		DEBUG2(printk("scsi(%ld): MBC_GET_PORT_NAME Failed, No FL "
2124 		    "Port\n", ha->host_no));
2125 
2126 		ha->device_flags &= ~SWITCH_FOUND;
2127 		return (QLA_SUCCESS);
2128 	}
2129 
2130 	/* Mark devices that need re-synchronization. */
2131 	rval2 = qla2x00_device_resync(ha);
2132 	if (rval2 == QLA_RSCNS_HANDLED) {
2133 		/* No point doing the scan, just continue. */
2134 		return (QLA_SUCCESS);
2135 	}
2136 	do {
2137 		/* FDMI support. */
2138 		if (ql2xfdmienable &&
2139 		    test_and_clear_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags))
2140 			qla2x00_fdmi_register(ha);
2141 
2142 		/* Ensure we are logged into the SNS. */
2143 		if (IS_QLA24XX(ha) || IS_QLA54XX(ha))
2144 			loop_id = NPH_SNS;
2145 		else
2146 			loop_id = SIMPLE_NAME_SERVER;
2147 		ha->isp_ops.fabric_login(ha, loop_id, 0xff, 0xff,
2148 		    0xfc, mb, BIT_1 | BIT_0);
2149 		if (mb[0] != MBS_COMMAND_COMPLETE) {
2150 			DEBUG2(qla_printk(KERN_INFO, ha,
2151 			    "Failed SNS login: loop_id=%x mb[0]=%x mb[1]=%x "
2152 			    "mb[2]=%x mb[6]=%x mb[7]=%x\n", loop_id,
2153 			    mb[0], mb[1], mb[2], mb[6], mb[7]));
2154 			return (QLA_SUCCESS);
2155 		}
2156 
2157 		if (test_and_clear_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags)) {
2158 			if (qla2x00_rft_id(ha)) {
2159 				/* EMPTY */
2160 				DEBUG2(printk("scsi(%ld): Register FC-4 "
2161 				    "TYPE failed.\n", ha->host_no));
2162 			}
2163 			if (qla2x00_rff_id(ha)) {
2164 				/* EMPTY */
2165 				DEBUG2(printk("scsi(%ld): Register FC-4 "
2166 				    "Features failed.\n", ha->host_no));
2167 			}
2168 			if (qla2x00_rnn_id(ha)) {
2169 				/* EMPTY */
2170 				DEBUG2(printk("scsi(%ld): Register Node Name "
2171 				    "failed.\n", ha->host_no));
2172 			} else if (qla2x00_rsnn_nn(ha)) {
2173 				/* EMPTY */
2174 				DEBUG2(printk("scsi(%ld): Register Symbolic "
2175 				    "Node Name failed.\n", ha->host_no));
2176 			}
2177 		}
2178 
2179 		rval = qla2x00_find_all_fabric_devs(ha, &new_fcports);
2180 		if (rval != QLA_SUCCESS)
2181 			break;
2182 
2183 		/*
2184 		 * Logout all previous fabric devices marked lost, except
2185 		 * tape devices.
2186 		 */
2187 		list_for_each_entry(fcport, &ha->fcports, list) {
2188 			if (test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags))
2189 				break;
2190 
2191 			if ((fcport->flags & FCF_FABRIC_DEVICE) == 0)
2192 				continue;
2193 
2194 			if (atomic_read(&fcport->state) == FCS_DEVICE_LOST) {
2195 				qla2x00_mark_device_lost(ha, fcport,
2196 				    ql2xplogiabsentdevice, 0);
2197 				if (fcport->loop_id != FC_NO_LOOP_ID &&
2198 				    (fcport->flags & FCF_TAPE_PRESENT) == 0 &&
2199 				    fcport->port_type != FCT_INITIATOR &&
2200 				    fcport->port_type != FCT_BROADCAST) {
2201 					ha->isp_ops.fabric_logout(ha,
2202 					    fcport->loop_id,
2203 					    fcport->d_id.b.domain,
2204 					    fcport->d_id.b.area,
2205 					    fcport->d_id.b.al_pa);
2206 					fcport->loop_id = FC_NO_LOOP_ID;
2207 				}
2208 			}
2209 		}
2210 
2211 		/* Starting free loop ID. */
2212 		next_loopid = ha->min_external_loopid;
2213 
2214 		/*
2215 		 * Scan through our port list and login entries that need to be
2216 		 * logged in.
2217 		 */
2218 		list_for_each_entry(fcport, &ha->fcports, list) {
2219 			if (atomic_read(&ha->loop_down_timer) ||
2220 			    test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags))
2221 				break;
2222 
2223 			if ((fcport->flags & FCF_FABRIC_DEVICE) == 0 ||
2224 			    (fcport->flags & FCF_LOGIN_NEEDED) == 0)
2225 				continue;
2226 
2227 			if (fcport->loop_id == FC_NO_LOOP_ID) {
2228 				fcport->loop_id = next_loopid;
2229 				rval = qla2x00_find_new_loop_id(ha, fcport);
2230 				if (rval != QLA_SUCCESS) {
2231 					/* Ran out of IDs to use */
2232 					break;
2233 				}
2234 			}
2235 			/* Login and update database */
2236 			qla2x00_fabric_dev_login(ha, fcport, &next_loopid);
2237 		}
2238 
2239 		/* Exit if out of loop IDs. */
2240 		if (rval != QLA_SUCCESS) {
2241 			break;
2242 		}
2243 
2244 		/*
2245 		 * Login and add the new devices to our port list.
2246 		 */
2247 		list_for_each_entry_safe(fcport, fcptemp, &new_fcports, list) {
2248 			if (atomic_read(&ha->loop_down_timer) ||
2249 			    test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags))
2250 				break;
2251 
2252 			/* Find a new loop ID to use. */
2253 			fcport->loop_id = next_loopid;
2254 			rval = qla2x00_find_new_loop_id(ha, fcport);
2255 			if (rval != QLA_SUCCESS) {
2256 				/* Ran out of IDs to use */
2257 				break;
2258 			}
2259 
2260 			/* Remove device from the new list and add it to DB */
2261 			list_del(&fcport->list);
2262 			list_add_tail(&fcport->list, &ha->fcports);
2263 
2264 			/* Login and update database */
2265 			qla2x00_fabric_dev_login(ha, fcport, &next_loopid);
2266 		}
2267 	} while (0);
2268 
2269 	/* Free all new device structures not processed. */
2270 	list_for_each_entry_safe(fcport, fcptemp, &new_fcports, list) {
2271 		list_del(&fcport->list);
2272 		kfree(fcport);
2273 	}
2274 
2275 	if (rval) {
2276 		DEBUG2(printk("scsi(%ld): Configure fabric error exit: "
2277 		    "rval=%d\n", ha->host_no, rval));
2278 	}
2279 
2280 	return (rval);
2281 }
2282 
2283 
2284 /*
2285  * qla2x00_find_all_fabric_devs
2286  *
2287  * Input:
2288  *	ha = adapter block pointer.
2289  *	dev = database device entry pointer.
2290  *
2291  * Returns:
2292  *	0 = success.
2293  *
2294  * Context:
2295  *	Kernel context.
2296  */
2297 static int
2298 qla2x00_find_all_fabric_devs(scsi_qla_host_t *ha, struct list_head *new_fcports)
2299 {
2300 	int		rval;
2301 	uint16_t	loop_id;
2302 	fc_port_t	*fcport, *new_fcport, *fcptemp;
2303 	int		found;
2304 
2305 	sw_info_t	*swl;
2306 	int		swl_idx;
2307 	int		first_dev, last_dev;
2308 	port_id_t	wrap, nxt_d_id;
2309 
2310 	rval = QLA_SUCCESS;
2311 
2312 	/* Try GID_PT to get device list, else GAN. */
2313 	swl = kmalloc(sizeof(sw_info_t) * MAX_FIBRE_DEVICES, GFP_ATOMIC);
2314 	if (swl == NULL) {
2315 		/*EMPTY*/
2316 		DEBUG2(printk("scsi(%ld): GID_PT allocations failed, fallback "
2317 		    "on GA_NXT\n", ha->host_no));
2318 	} else {
2319 		memset(swl, 0, sizeof(sw_info_t) * MAX_FIBRE_DEVICES);
2320 		if (qla2x00_gid_pt(ha, swl) != QLA_SUCCESS) {
2321 			kfree(swl);
2322 			swl = NULL;
2323 		} else if (qla2x00_gpn_id(ha, swl) != QLA_SUCCESS) {
2324 			kfree(swl);
2325 			swl = NULL;
2326 		} else if (qla2x00_gnn_id(ha, swl) != QLA_SUCCESS) {
2327 			kfree(swl);
2328 			swl = NULL;
2329 		}
2330 	}
2331 	swl_idx = 0;
2332 
2333 	/* Allocate temporary fcport for any new fcports discovered. */
2334 	new_fcport = qla2x00_alloc_fcport(ha, GFP_KERNEL);
2335 	if (new_fcport == NULL) {
2336 		kfree(swl);
2337 		return (QLA_MEMORY_ALLOC_FAILED);
2338 	}
2339 	new_fcport->flags |= (FCF_FABRIC_DEVICE | FCF_LOGIN_NEEDED);
2340 
2341 	/* Set start port ID scan at adapter ID. */
2342 	first_dev = 1;
2343 	last_dev = 0;
2344 
2345 	/* Starting free loop ID. */
2346 	loop_id = ha->min_external_loopid;
2347 	for (; loop_id <= ha->last_loop_id; loop_id++) {
2348 		if (qla2x00_is_reserved_id(ha, loop_id))
2349 			continue;
2350 
2351 		if (atomic_read(&ha->loop_down_timer) || LOOP_TRANSITION(ha))
2352 			break;
2353 
2354 		if (swl != NULL) {
2355 			if (last_dev) {
2356 				wrap.b24 = new_fcport->d_id.b24;
2357 			} else {
2358 				new_fcport->d_id.b24 = swl[swl_idx].d_id.b24;
2359 				memcpy(new_fcport->node_name,
2360 				    swl[swl_idx].node_name, WWN_SIZE);
2361 				memcpy(new_fcport->port_name,
2362 				    swl[swl_idx].port_name, WWN_SIZE);
2363 
2364 				if (swl[swl_idx].d_id.b.rsvd_1 != 0) {
2365 					last_dev = 1;
2366 				}
2367 				swl_idx++;
2368 			}
2369 		} else {
2370 			/* Send GA_NXT to the switch */
2371 			rval = qla2x00_ga_nxt(ha, new_fcport);
2372 			if (rval != QLA_SUCCESS) {
2373 				qla_printk(KERN_WARNING, ha,
2374 				    "SNS scan failed -- assuming zero-entry "
2375 				    "result...\n");
2376 				list_for_each_entry_safe(fcport, fcptemp,
2377 				    new_fcports, list) {
2378 					list_del(&fcport->list);
2379 					kfree(fcport);
2380 				}
2381 				rval = QLA_SUCCESS;
2382 				break;
2383 			}
2384 		}
2385 
2386 		/* If wrap on switch device list, exit. */
2387 		if (first_dev) {
2388 			wrap.b24 = new_fcport->d_id.b24;
2389 			first_dev = 0;
2390 		} else if (new_fcport->d_id.b24 == wrap.b24) {
2391 			DEBUG2(printk("scsi(%ld): device wrap (%02x%02x%02x)\n",
2392 			    ha->host_no, new_fcport->d_id.b.domain,
2393 			    new_fcport->d_id.b.area, new_fcport->d_id.b.al_pa));
2394 			break;
2395 		}
2396 
2397 		/* Bypass if host adapter. */
2398 		if (new_fcport->d_id.b24 == ha->d_id.b24)
2399 			continue;
2400 
2401 		/* Bypass if same domain and area of adapter. */
2402 		if (((new_fcport->d_id.b24 & 0xffff00) ==
2403 		    (ha->d_id.b24 & 0xffff00)) && ha->current_topology ==
2404 			ISP_CFG_FL)
2405 			    continue;
2406 
2407 		/* Bypass reserved domain fields. */
2408 		if ((new_fcport->d_id.b.domain & 0xf0) == 0xf0)
2409 			continue;
2410 
2411 		/* Locate matching device in database. */
2412 		found = 0;
2413 		list_for_each_entry(fcport, &ha->fcports, list) {
2414 			if (memcmp(new_fcport->port_name, fcport->port_name,
2415 			    WWN_SIZE))
2416 				continue;
2417 
2418 			found++;
2419 
2420 			/*
2421 			 * If address the same and state FCS_ONLINE, nothing
2422 			 * changed.
2423 			 */
2424 			if (fcport->d_id.b24 == new_fcport->d_id.b24 &&
2425 			    atomic_read(&fcport->state) == FCS_ONLINE) {
2426 				break;
2427 			}
2428 
2429 			/*
2430 			 * If device was not a fabric device before.
2431 			 */
2432 			if ((fcport->flags & FCF_FABRIC_DEVICE) == 0) {
2433 				fcport->d_id.b24 = new_fcport->d_id.b24;
2434 				fcport->loop_id = FC_NO_LOOP_ID;
2435 				fcport->flags |= (FCF_FABRIC_DEVICE |
2436 				    FCF_LOGIN_NEEDED);
2437 				fcport->flags &= ~FCF_PERSISTENT_BOUND;
2438 				break;
2439 			}
2440 
2441 			/*
2442 			 * Port ID changed or device was marked to be updated;
2443 			 * Log it out if still logged in and mark it for
2444 			 * relogin later.
2445 			 */
2446 			fcport->d_id.b24 = new_fcport->d_id.b24;
2447 			fcport->flags |= FCF_LOGIN_NEEDED;
2448 			if (fcport->loop_id != FC_NO_LOOP_ID &&
2449 			    (fcport->flags & FCF_TAPE_PRESENT) == 0 &&
2450 			    fcport->port_type != FCT_INITIATOR &&
2451 			    fcport->port_type != FCT_BROADCAST) {
2452 				ha->isp_ops.fabric_logout(ha, fcport->loop_id,
2453 				    fcport->d_id.b.domain, fcport->d_id.b.area,
2454 				    fcport->d_id.b.al_pa);
2455 				fcport->loop_id = FC_NO_LOOP_ID;
2456 			}
2457 
2458 			break;
2459 		}
2460 
2461 		if (found)
2462 			continue;
2463 
2464 		/* If device was not in our fcports list, then add it. */
2465 		list_add_tail(&new_fcport->list, new_fcports);
2466 
2467 		/* Allocate a new replacement fcport. */
2468 		nxt_d_id.b24 = new_fcport->d_id.b24;
2469 		new_fcport = qla2x00_alloc_fcport(ha, GFP_KERNEL);
2470 		if (new_fcport == NULL) {
2471 			kfree(swl);
2472 			return (QLA_MEMORY_ALLOC_FAILED);
2473 		}
2474 		new_fcport->flags |= (FCF_FABRIC_DEVICE | FCF_LOGIN_NEEDED);
2475 		new_fcport->d_id.b24 = nxt_d_id.b24;
2476 	}
2477 
2478 	kfree(swl);
2479 	kfree(new_fcport);
2480 
2481 	if (!list_empty(new_fcports))
2482 		ha->device_flags |= DFLG_FABRIC_DEVICES;
2483 
2484 	return (rval);
2485 }
2486 
2487 /*
2488  * qla2x00_find_new_loop_id
2489  *	Scan through our port list and find a new usable loop ID.
2490  *
2491  * Input:
2492  *	ha:	adapter state pointer.
2493  *	dev:	port structure pointer.
2494  *
2495  * Returns:
2496  *	qla2x00 local function return status code.
2497  *
2498  * Context:
2499  *	Kernel context.
2500  */
2501 int
2502 qla2x00_find_new_loop_id(scsi_qla_host_t *ha, fc_port_t *dev)
2503 {
2504 	int	rval;
2505 	int	found;
2506 	fc_port_t *fcport;
2507 	uint16_t first_loop_id;
2508 
2509 	rval = QLA_SUCCESS;
2510 
2511 	/* Save starting loop ID. */
2512 	first_loop_id = dev->loop_id;
2513 
2514 	for (;;) {
2515 		/* Skip loop ID if already used by adapter. */
2516 		if (dev->loop_id == ha->loop_id) {
2517 			dev->loop_id++;
2518 		}
2519 
2520 		/* Skip reserved loop IDs. */
2521 		while (qla2x00_is_reserved_id(ha, dev->loop_id)) {
2522 			dev->loop_id++;
2523 		}
2524 
2525 		/* Reset loop ID if passed the end. */
2526 		if (dev->loop_id > ha->last_loop_id) {
2527 			/* first loop ID. */
2528 			dev->loop_id = ha->min_external_loopid;
2529 		}
2530 
2531 		/* Check for loop ID being already in use. */
2532 		found = 0;
2533 		fcport = NULL;
2534 		list_for_each_entry(fcport, &ha->fcports, list) {
2535 			if (fcport->loop_id == dev->loop_id && fcport != dev) {
2536 				/* ID possibly in use */
2537 				found++;
2538 				break;
2539 			}
2540 		}
2541 
2542 		/* If not in use then it is free to use. */
2543 		if (!found) {
2544 			break;
2545 		}
2546 
2547 		/* ID in use. Try next value. */
2548 		dev->loop_id++;
2549 
2550 		/* If wrap around. No free ID to use. */
2551 		if (dev->loop_id == first_loop_id) {
2552 			dev->loop_id = FC_NO_LOOP_ID;
2553 			rval = QLA_FUNCTION_FAILED;
2554 			break;
2555 		}
2556 	}
2557 
2558 	return (rval);
2559 }
2560 
2561 /*
2562  * qla2x00_device_resync
2563  *	Marks devices in the database that needs resynchronization.
2564  *
2565  * Input:
2566  *	ha = adapter block pointer.
2567  *
2568  * Context:
2569  *	Kernel context.
2570  */
2571 static int
2572 qla2x00_device_resync(scsi_qla_host_t *ha)
2573 {
2574 	int	rval;
2575 	uint32_t mask;
2576 	fc_port_t *fcport;
2577 	uint32_t rscn_entry;
2578 	uint8_t rscn_out_iter;
2579 	uint8_t format;
2580 	port_id_t d_id;
2581 
2582 	rval = QLA_RSCNS_HANDLED;
2583 
2584 	while (ha->rscn_out_ptr != ha->rscn_in_ptr ||
2585 	    ha->flags.rscn_queue_overflow) {
2586 
2587 		rscn_entry = ha->rscn_queue[ha->rscn_out_ptr];
2588 		format = MSB(MSW(rscn_entry));
2589 		d_id.b.domain = LSB(MSW(rscn_entry));
2590 		d_id.b.area = MSB(LSW(rscn_entry));
2591 		d_id.b.al_pa = LSB(LSW(rscn_entry));
2592 
2593 		DEBUG(printk("scsi(%ld): RSCN queue entry[%d] = "
2594 		    "[%02x/%02x%02x%02x].\n",
2595 		    ha->host_no, ha->rscn_out_ptr, format, d_id.b.domain,
2596 		    d_id.b.area, d_id.b.al_pa));
2597 
2598 		ha->rscn_out_ptr++;
2599 		if (ha->rscn_out_ptr == MAX_RSCN_COUNT)
2600 			ha->rscn_out_ptr = 0;
2601 
2602 		/* Skip duplicate entries. */
2603 		for (rscn_out_iter = ha->rscn_out_ptr;
2604 		    !ha->flags.rscn_queue_overflow &&
2605 		    rscn_out_iter != ha->rscn_in_ptr;
2606 		    rscn_out_iter = (rscn_out_iter ==
2607 			(MAX_RSCN_COUNT - 1)) ? 0: rscn_out_iter + 1) {
2608 
2609 			if (rscn_entry != ha->rscn_queue[rscn_out_iter])
2610 				break;
2611 
2612 			DEBUG(printk("scsi(%ld): Skipping duplicate RSCN queue "
2613 			    "entry found at [%d].\n", ha->host_no,
2614 			    rscn_out_iter));
2615 
2616 			ha->rscn_out_ptr = rscn_out_iter;
2617 		}
2618 
2619 		/* Queue overflow, set switch default case. */
2620 		if (ha->flags.rscn_queue_overflow) {
2621 			DEBUG(printk("scsi(%ld): device_resync: rscn "
2622 			    "overflow.\n", ha->host_no));
2623 
2624 			format = 3;
2625 			ha->flags.rscn_queue_overflow = 0;
2626 		}
2627 
2628 		switch (format) {
2629 		case 0:
2630 			mask = 0xffffff;
2631 			break;
2632 		case 1:
2633 			mask = 0xffff00;
2634 			break;
2635 		case 2:
2636 			mask = 0xff0000;
2637 			break;
2638 		default:
2639 			mask = 0x0;
2640 			d_id.b24 = 0;
2641 			ha->rscn_out_ptr = ha->rscn_in_ptr;
2642 			break;
2643 		}
2644 
2645 		rval = QLA_SUCCESS;
2646 
2647 		list_for_each_entry(fcport, &ha->fcports, list) {
2648 			if ((fcport->flags & FCF_FABRIC_DEVICE) == 0 ||
2649 			    (fcport->d_id.b24 & mask) != d_id.b24 ||
2650 			    fcport->port_type == FCT_BROADCAST)
2651 				continue;
2652 
2653 			if (atomic_read(&fcport->state) == FCS_ONLINE) {
2654 				if (format != 3 ||
2655 				    fcport->port_type != FCT_INITIATOR) {
2656 					qla2x00_mark_device_lost(ha, fcport,
2657 					    0, 0);
2658 				}
2659 			}
2660 			fcport->flags &= ~FCF_FARP_DONE;
2661 		}
2662 	}
2663 	return (rval);
2664 }
2665 
2666 /*
2667  * qla2x00_fabric_dev_login
2668  *	Login fabric target device and update FC port database.
2669  *
2670  * Input:
2671  *	ha:		adapter state pointer.
2672  *	fcport:		port structure list pointer.
2673  *	next_loopid:	contains value of a new loop ID that can be used
2674  *			by the next login attempt.
2675  *
2676  * Returns:
2677  *	qla2x00 local function return status code.
2678  *
2679  * Context:
2680  *	Kernel context.
2681  */
2682 static int
2683 qla2x00_fabric_dev_login(scsi_qla_host_t *ha, fc_port_t *fcport,
2684     uint16_t *next_loopid)
2685 {
2686 	int	rval;
2687 	int	retry;
2688 	uint8_t opts;
2689 
2690 	rval = QLA_SUCCESS;
2691 	retry = 0;
2692 
2693 	rval = qla2x00_fabric_login(ha, fcport, next_loopid);
2694 	if (rval == QLA_SUCCESS) {
2695 		/* Send an ADISC to tape devices.*/
2696 		opts = 0;
2697 		if (fcport->flags & FCF_TAPE_PRESENT)
2698 			opts |= BIT_1;
2699 		rval = qla2x00_get_port_database(ha, fcport, opts);
2700 		if (rval != QLA_SUCCESS) {
2701 			ha->isp_ops.fabric_logout(ha, fcport->loop_id,
2702 			    fcport->d_id.b.domain, fcport->d_id.b.area,
2703 			    fcport->d_id.b.al_pa);
2704 			qla2x00_mark_device_lost(ha, fcport, 1, 0);
2705 		} else {
2706 			qla2x00_update_fcport(ha, fcport);
2707 		}
2708 	}
2709 
2710 	return (rval);
2711 }
2712 
2713 /*
2714  * qla2x00_fabric_login
2715  *	Issue fabric login command.
2716  *
2717  * Input:
2718  *	ha = adapter block pointer.
2719  *	device = pointer to FC device type structure.
2720  *
2721  * Returns:
2722  *      0 - Login successfully
2723  *      1 - Login failed
2724  *      2 - Initiator device
2725  *      3 - Fatal error
2726  */
2727 int
2728 qla2x00_fabric_login(scsi_qla_host_t *ha, fc_port_t *fcport,
2729     uint16_t *next_loopid)
2730 {
2731 	int	rval;
2732 	int	retry;
2733 	uint16_t tmp_loopid;
2734 	uint16_t mb[MAILBOX_REGISTER_COUNT];
2735 
2736 	retry = 0;
2737 	tmp_loopid = 0;
2738 
2739 	for (;;) {
2740 		DEBUG(printk("scsi(%ld): Trying Fabric Login w/loop id 0x%04x "
2741  		    "for port %02x%02x%02x.\n",
2742  		    ha->host_no, fcport->loop_id, fcport->d_id.b.domain,
2743 		    fcport->d_id.b.area, fcport->d_id.b.al_pa));
2744 
2745 		/* Login fcport on switch. */
2746 		ha->isp_ops.fabric_login(ha, fcport->loop_id,
2747 		    fcport->d_id.b.domain, fcport->d_id.b.area,
2748 		    fcport->d_id.b.al_pa, mb, BIT_0);
2749 		if (mb[0] == MBS_PORT_ID_USED) {
2750 			/*
2751 			 * Device has another loop ID.  The firmware team
2752 			 * recommends the driver perform an implicit login with
2753 			 * the specified ID again. The ID we just used is save
2754 			 * here so we return with an ID that can be tried by
2755 			 * the next login.
2756 			 */
2757 			retry++;
2758 			tmp_loopid = fcport->loop_id;
2759 			fcport->loop_id = mb[1];
2760 
2761 			DEBUG(printk("Fabric Login: port in use - next "
2762  			    "loop id=0x%04x, port Id=%02x%02x%02x.\n",
2763 			    fcport->loop_id, fcport->d_id.b.domain,
2764 			    fcport->d_id.b.area, fcport->d_id.b.al_pa));
2765 
2766 		} else if (mb[0] == MBS_COMMAND_COMPLETE) {
2767 			/*
2768 			 * Login succeeded.
2769 			 */
2770 			if (retry) {
2771 				/* A retry occurred before. */
2772 				*next_loopid = tmp_loopid;
2773 			} else {
2774 				/*
2775 				 * No retry occurred before. Just increment the
2776 				 * ID value for next login.
2777 				 */
2778 				*next_loopid = (fcport->loop_id + 1);
2779 			}
2780 
2781 			if (mb[1] & BIT_0) {
2782 				fcport->port_type = FCT_INITIATOR;
2783 			} else {
2784 				fcport->port_type = FCT_TARGET;
2785 				if (mb[1] & BIT_1) {
2786 					fcport->flags |= FCF_TAPE_PRESENT;
2787 				}
2788 			}
2789 
2790 			if (mb[10] & BIT_0)
2791 				fcport->supported_classes |= FC_COS_CLASS2;
2792 			if (mb[10] & BIT_1)
2793 				fcport->supported_classes |= FC_COS_CLASS3;
2794 
2795 			rval = QLA_SUCCESS;
2796 			break;
2797 		} else if (mb[0] == MBS_LOOP_ID_USED) {
2798 			/*
2799 			 * Loop ID already used, try next loop ID.
2800 			 */
2801 			fcport->loop_id++;
2802 			rval = qla2x00_find_new_loop_id(ha, fcport);
2803 			if (rval != QLA_SUCCESS) {
2804 				/* Ran out of loop IDs to use */
2805 				break;
2806 			}
2807 		} else if (mb[0] == MBS_COMMAND_ERROR) {
2808 			/*
2809 			 * Firmware possibly timed out during login. If NO
2810 			 * retries are left to do then the device is declared
2811 			 * dead.
2812 			 */
2813 			*next_loopid = fcport->loop_id;
2814 			ha->isp_ops.fabric_logout(ha, fcport->loop_id,
2815 			    fcport->d_id.b.domain, fcport->d_id.b.area,
2816 			    fcport->d_id.b.al_pa);
2817 			qla2x00_mark_device_lost(ha, fcport, 1, 0);
2818 
2819 			rval = 1;
2820 			break;
2821 		} else {
2822 			/*
2823 			 * unrecoverable / not handled error
2824 			 */
2825 			DEBUG2(printk("%s(%ld): failed=%x port_id=%02x%02x%02x "
2826  			    "loop_id=%x jiffies=%lx.\n",
2827  			    __func__, ha->host_no, mb[0],
2828 			    fcport->d_id.b.domain, fcport->d_id.b.area,
2829 			    fcport->d_id.b.al_pa, fcport->loop_id, jiffies));
2830 
2831 			*next_loopid = fcport->loop_id;
2832 			ha->isp_ops.fabric_logout(ha, fcport->loop_id,
2833 			    fcport->d_id.b.domain, fcport->d_id.b.area,
2834 			    fcport->d_id.b.al_pa);
2835 			fcport->loop_id = FC_NO_LOOP_ID;
2836 			fcport->login_retry = 0;
2837 
2838 			rval = 3;
2839 			break;
2840 		}
2841 	}
2842 
2843 	return (rval);
2844 }
2845 
2846 /*
2847  * qla2x00_local_device_login
2848  *	Issue local device login command.
2849  *
2850  * Input:
2851  *	ha = adapter block pointer.
2852  *	loop_id = loop id of device to login to.
2853  *
2854  * Returns (Where's the #define!!!!):
2855  *      0 - Login successfully
2856  *      1 - Login failed
2857  *      3 - Fatal error
2858  */
2859 int
2860 qla2x00_local_device_login(scsi_qla_host_t *ha, fc_port_t *fcport)
2861 {
2862 	int		rval;
2863 	uint16_t	mb[MAILBOX_REGISTER_COUNT];
2864 
2865 	memset(mb, 0, sizeof(mb));
2866 	rval = qla2x00_login_local_device(ha, fcport, mb, BIT_0);
2867 	if (rval == QLA_SUCCESS) {
2868 		/* Interrogate mailbox registers for any errors */
2869 		if (mb[0] == MBS_COMMAND_ERROR)
2870 			rval = 1;
2871 		else if (mb[0] == MBS_COMMAND_PARAMETER_ERROR)
2872 			/* device not in PCB table */
2873 			rval = 3;
2874 	}
2875 
2876 	return (rval);
2877 }
2878 
2879 /*
2880  *  qla2x00_loop_resync
2881  *      Resync with fibre channel devices.
2882  *
2883  * Input:
2884  *      ha = adapter block pointer.
2885  *
2886  * Returns:
2887  *      0 = success
2888  */
2889 int
2890 qla2x00_loop_resync(scsi_qla_host_t *ha)
2891 {
2892 	int   rval;
2893 	uint32_t wait_time;
2894 
2895 	rval = QLA_SUCCESS;
2896 
2897 	atomic_set(&ha->loop_state, LOOP_UPDATE);
2898 	clear_bit(ISP_ABORT_RETRY, &ha->dpc_flags);
2899 	if (ha->flags.online) {
2900 		if (!(rval = qla2x00_fw_ready(ha))) {
2901 			/* Wait at most MAX_TARGET RSCNs for a stable link. */
2902 			wait_time = 256;
2903 			do {
2904 				atomic_set(&ha->loop_state, LOOP_UPDATE);
2905 
2906 				/* Issue a marker after FW becomes ready. */
2907 				qla2x00_marker(ha, 0, 0, MK_SYNC_ALL);
2908 				ha->marker_needed = 0;
2909 
2910 				/* Remap devices on Loop. */
2911 				clear_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
2912 
2913 				qla2x00_configure_loop(ha);
2914 				wait_time--;
2915 			} while (!atomic_read(&ha->loop_down_timer) &&
2916 				!(test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags)) &&
2917 				wait_time &&
2918 				(test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags)));
2919 		}
2920 	}
2921 
2922 	if (test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags)) {
2923 		return (QLA_FUNCTION_FAILED);
2924 	}
2925 
2926 	if (rval) {
2927 		DEBUG2_3(printk("%s(): **** FAILED ****\n", __func__));
2928 	}
2929 
2930 	return (rval);
2931 }
2932 
2933 void
2934 qla2x00_rescan_fcports(scsi_qla_host_t *ha)
2935 {
2936 	int rescan_done;
2937 	fc_port_t *fcport;
2938 
2939 	rescan_done = 0;
2940 	list_for_each_entry(fcport, &ha->fcports, list) {
2941 		if ((fcport->flags & FCF_RESCAN_NEEDED) == 0)
2942 			continue;
2943 
2944 		qla2x00_update_fcport(ha, fcport);
2945 		fcport->flags &= ~FCF_RESCAN_NEEDED;
2946 
2947 		rescan_done = 1;
2948 	}
2949 	qla2x00_probe_for_all_luns(ha);
2950 }
2951 
2952 void
2953 qla2x00_update_fcports(scsi_qla_host_t *ha)
2954 {
2955 	fc_port_t *fcport;
2956 
2957 	/* Go with deferred removal of rport references. */
2958 	list_for_each_entry(fcport, &ha->fcports, list)
2959 		if (fcport->drport)
2960 			qla2x00_rport_del(fcport);
2961 }
2962 
2963 /*
2964 *  qla2x00_abort_isp
2965 *      Resets ISP and aborts all outstanding commands.
2966 *
2967 * Input:
2968 *      ha           = adapter block pointer.
2969 *
2970 * Returns:
2971 *      0 = success
2972 */
2973 int
2974 qla2x00_abort_isp(scsi_qla_host_t *ha)
2975 {
2976 	unsigned long flags = 0;
2977 	uint16_t       cnt;
2978 	srb_t          *sp;
2979 	uint8_t        status = 0;
2980 
2981 	if (ha->flags.online) {
2982 		ha->flags.online = 0;
2983 		clear_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
2984 
2985 		qla_printk(KERN_INFO, ha,
2986 		    "Performing ISP error recovery - ha= %p.\n", ha);
2987 		ha->isp_ops.reset_chip(ha);
2988 
2989 		atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
2990 		if (atomic_read(&ha->loop_state) != LOOP_DOWN) {
2991 			atomic_set(&ha->loop_state, LOOP_DOWN);
2992 			qla2x00_mark_all_devices_lost(ha, 0);
2993 		} else {
2994 			if (!atomic_read(&ha->loop_down_timer))
2995 				atomic_set(&ha->loop_down_timer,
2996 				    LOOP_DOWN_TIME);
2997 		}
2998 
2999 		spin_lock_irqsave(&ha->hardware_lock, flags);
3000 		/* Requeue all commands in outstanding command list. */
3001 		for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
3002 			sp = ha->outstanding_cmds[cnt];
3003 			if (sp) {
3004 				ha->outstanding_cmds[cnt] = NULL;
3005 				sp->flags = 0;
3006 				sp->cmd->result = DID_RESET << 16;
3007 				sp->cmd->host_scribble = (unsigned char *)NULL;
3008 				qla2x00_sp_compl(ha, sp);
3009 			}
3010 		}
3011 		spin_unlock_irqrestore(&ha->hardware_lock, flags);
3012 
3013 		ha->isp_ops.nvram_config(ha);
3014 
3015 		if (!qla2x00_restart_isp(ha)) {
3016 			clear_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
3017 
3018 			if (!atomic_read(&ha->loop_down_timer)) {
3019 				/*
3020 				 * Issue marker command only when we are going
3021 				 * to start the I/O .
3022 				 */
3023 				ha->marker_needed = 1;
3024 			}
3025 
3026 			ha->flags.online = 1;
3027 
3028 			ha->isp_ops.enable_intrs(ha);
3029 
3030 			ha->isp_abort_cnt = 0;
3031 			clear_bit(ISP_ABORT_RETRY, &ha->dpc_flags);
3032 		} else {	/* failed the ISP abort */
3033 			ha->flags.online = 1;
3034 			if (test_bit(ISP_ABORT_RETRY, &ha->dpc_flags)) {
3035 				if (ha->isp_abort_cnt == 0) {
3036  					qla_printk(KERN_WARNING, ha,
3037 					    "ISP error recovery failed - "
3038 					    "board disabled\n");
3039 					/*
3040 					 * The next call disables the board
3041 					 * completely.
3042 					 */
3043 					ha->isp_ops.reset_adapter(ha);
3044 					ha->flags.online = 0;
3045 					clear_bit(ISP_ABORT_RETRY,
3046 					    &ha->dpc_flags);
3047 					status = 0;
3048 				} else { /* schedule another ISP abort */
3049 					ha->isp_abort_cnt--;
3050 					DEBUG(printk("qla%ld: ISP abort - "
3051 					    "retry remaining %d\n",
3052 					    ha->host_no, ha->isp_abort_cnt);)
3053 					status = 1;
3054 				}
3055 			} else {
3056 				ha->isp_abort_cnt = MAX_RETRIES_OF_ISP_ABORT;
3057 				DEBUG(printk("qla2x00(%ld): ISP error recovery "
3058 				    "- retrying (%d) more times\n",
3059 				    ha->host_no, ha->isp_abort_cnt);)
3060 				set_bit(ISP_ABORT_RETRY, &ha->dpc_flags);
3061 				status = 1;
3062 			}
3063 		}
3064 
3065 	}
3066 
3067 	if (status) {
3068 		qla_printk(KERN_INFO, ha,
3069 			"qla2x00_abort_isp: **** FAILED ****\n");
3070 	} else {
3071 		DEBUG(printk(KERN_INFO
3072 				"qla2x00_abort_isp(%ld): exiting.\n",
3073 				ha->host_no);)
3074 	}
3075 
3076 	return(status);
3077 }
3078 
3079 /*
3080 *  qla2x00_restart_isp
3081 *      restarts the ISP after a reset
3082 *
3083 * Input:
3084 *      ha = adapter block pointer.
3085 *
3086 * Returns:
3087 *      0 = success
3088 */
3089 static int
3090 qla2x00_restart_isp(scsi_qla_host_t *ha)
3091 {
3092 	uint8_t		status = 0;
3093 	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
3094 	unsigned long	flags = 0;
3095 	uint32_t wait_time;
3096 
3097 	/* If firmware needs to be loaded */
3098 	if (qla2x00_isp_firmware(ha)) {
3099 		ha->flags.online = 0;
3100 		if (!(status = ha->isp_ops.chip_diag(ha))) {
3101 			if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
3102 				status = qla2x00_setup_chip(ha);
3103 				goto done;
3104 			}
3105 
3106 			spin_lock_irqsave(&ha->hardware_lock, flags);
3107 
3108 			if (!IS_QLA24XX(ha) && !IS_QLA54XX(ha)) {
3109 				/*
3110 				 * Disable SRAM, Instruction RAM and GP RAM
3111 				 * parity.
3112 				 */
3113 				WRT_REG_WORD(&reg->hccr,
3114 				    (HCCR_ENABLE_PARITY + 0x0));
3115 				RD_REG_WORD(&reg->hccr);
3116 			}
3117 
3118 			spin_unlock_irqrestore(&ha->hardware_lock, flags);
3119 
3120 			status = qla2x00_setup_chip(ha);
3121 
3122 			spin_lock_irqsave(&ha->hardware_lock, flags);
3123 
3124 			if (!IS_QLA24XX(ha) && !IS_QLA54XX(ha)) {
3125 				/* Enable proper parity */
3126 				if (IS_QLA2300(ha))
3127 					/* SRAM parity */
3128 					WRT_REG_WORD(&reg->hccr,
3129 					    (HCCR_ENABLE_PARITY + 0x1));
3130 				else
3131 					/*
3132 					 * SRAM, Instruction RAM and GP RAM
3133 					 * parity.
3134 					 */
3135 					WRT_REG_WORD(&reg->hccr,
3136 					    (HCCR_ENABLE_PARITY + 0x7));
3137 				RD_REG_WORD(&reg->hccr);
3138 			}
3139 
3140 			spin_unlock_irqrestore(&ha->hardware_lock, flags);
3141 		}
3142 	}
3143 
3144  done:
3145 	if (!status && !(status = qla2x00_init_rings(ha))) {
3146 		clear_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
3147 		if (!(status = qla2x00_fw_ready(ha))) {
3148 			DEBUG(printk("%s(): Start configure loop, "
3149 			    "status = %d\n", __func__, status);)
3150 
3151 			/* Issue a marker after FW becomes ready. */
3152 			qla2x00_marker(ha, 0, 0, MK_SYNC_ALL);
3153 
3154 			ha->flags.online = 1;
3155 			/* Wait at most MAX_TARGET RSCNs for a stable link. */
3156 			wait_time = 256;
3157 			do {
3158 				clear_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
3159 				qla2x00_configure_loop(ha);
3160 				wait_time--;
3161 			} while (!atomic_read(&ha->loop_down_timer) &&
3162 				!(test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags)) &&
3163 				wait_time &&
3164 				(test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags)));
3165 		}
3166 
3167 		/* if no cable then assume it's good */
3168 		if ((ha->device_flags & DFLG_NO_CABLE))
3169 			status = 0;
3170 
3171 		DEBUG(printk("%s(): Configure loop done, status = 0x%x\n",
3172 				__func__,
3173 				status);)
3174 	}
3175 	return (status);
3176 }
3177 
3178 /*
3179 * qla2x00_reset_adapter
3180 *      Reset adapter.
3181 *
3182 * Input:
3183 *      ha = adapter block pointer.
3184 */
3185 void
3186 qla2x00_reset_adapter(scsi_qla_host_t *ha)
3187 {
3188 	unsigned long flags = 0;
3189 	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
3190 
3191 	ha->flags.online = 0;
3192 	ha->isp_ops.disable_intrs(ha);
3193 
3194 	spin_lock_irqsave(&ha->hardware_lock, flags);
3195 	WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
3196 	RD_REG_WORD(&reg->hccr);			/* PCI Posting. */
3197 	WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
3198 	RD_REG_WORD(&reg->hccr);			/* PCI Posting. */
3199 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
3200 }
3201 
3202 void
3203 qla24xx_reset_adapter(scsi_qla_host_t *ha)
3204 {
3205 	unsigned long flags = 0;
3206 	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
3207 
3208 	ha->flags.online = 0;
3209 	ha->isp_ops.disable_intrs(ha);
3210 
3211 	spin_lock_irqsave(&ha->hardware_lock, flags);
3212 	WRT_REG_DWORD(&reg->hccr, HCCRX_SET_RISC_RESET);
3213 	RD_REG_DWORD(&reg->hccr);
3214 	WRT_REG_DWORD(&reg->hccr, HCCRX_REL_RISC_PAUSE);
3215 	RD_REG_DWORD(&reg->hccr);
3216 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
3217 }
3218 
3219 int
3220 qla24xx_nvram_config(scsi_qla_host_t *ha)
3221 {
3222 	int   rval;
3223 	struct init_cb_24xx *icb;
3224 	struct nvram_24xx *nv;
3225 	uint32_t *dptr;
3226 	uint8_t  *dptr1, *dptr2;
3227 	uint32_t chksum;
3228 	uint16_t cnt;
3229 
3230 	rval = QLA_SUCCESS;
3231 	icb = (struct init_cb_24xx *)ha->init_cb;
3232 	nv = (struct nvram_24xx *)ha->request_ring;
3233 
3234 	/* Determine NVRAM starting address. */
3235 	ha->nvram_size = sizeof(struct nvram_24xx);
3236 	ha->nvram_base = FA_NVRAM_FUNC0_ADDR;
3237 	ha->vpd_size = FA_NVRAM_VPD_SIZE;
3238 	ha->vpd_base = FA_NVRAM_VPD0_ADDR;
3239 	if (PCI_FUNC(ha->pdev->devfn)) {
3240 		ha->nvram_base = FA_NVRAM_FUNC1_ADDR;
3241 		ha->vpd_base = FA_NVRAM_VPD1_ADDR;
3242 	}
3243 
3244 	/* Get NVRAM data and calculate checksum. */
3245 	dptr = (uint32_t *)nv;
3246 	ha->isp_ops.read_nvram(ha, (uint8_t *)dptr, ha->nvram_base,
3247 	    ha->nvram_size);
3248 	for (cnt = 0, chksum = 0; cnt < ha->nvram_size >> 2; cnt++)
3249 		chksum += le32_to_cpu(*dptr++);
3250 
3251 	DEBUG5(printk("scsi(%ld): Contents of NVRAM\n", ha->host_no));
3252 	DEBUG5(qla2x00_dump_buffer((uint8_t *)ha->request_ring,
3253 	    ha->nvram_size));
3254 
3255 	/* Bad NVRAM data, set defaults parameters. */
3256 	if (chksum || nv->id[0] != 'I' || nv->id[1] != 'S' || nv->id[2] != 'P'
3257 	    || nv->id[3] != ' ' ||
3258 	    nv->nvram_version < __constant_cpu_to_le16(ICB_VERSION)) {
3259 		/* Reset NVRAM data. */
3260 		qla_printk(KERN_WARNING, ha, "Inconsistent NVRAM detected: "
3261 		    "checksum=0x%x id=%c version=0x%x.\n", chksum, nv->id[0],
3262 		    le16_to_cpu(nv->nvram_version));
3263 		qla_printk(KERN_WARNING, ha, "Falling back to functioning (yet "
3264 		    "invalid -- WWPN) defaults.\n");
3265 
3266 		/*
3267 		 * Set default initialization control block.
3268 		 */
3269 		memset(nv, 0, ha->nvram_size);
3270 		nv->nvram_version = __constant_cpu_to_le16(ICB_VERSION);
3271 		nv->version = __constant_cpu_to_le16(ICB_VERSION);
3272 		nv->frame_payload_size = __constant_cpu_to_le16(2048);
3273 		nv->execution_throttle = __constant_cpu_to_le16(0xFFFF);
3274 		nv->exchange_count = __constant_cpu_to_le16(0);
3275 		nv->hard_address = __constant_cpu_to_le16(124);
3276 		nv->port_name[0] = 0x21;
3277 		nv->port_name[1] = 0x00 + PCI_FUNC(ha->pdev->devfn);
3278 		nv->port_name[2] = 0x00;
3279 		nv->port_name[3] = 0xe0;
3280 		nv->port_name[4] = 0x8b;
3281 		nv->port_name[5] = 0x1c;
3282 		nv->port_name[6] = 0x55;
3283 		nv->port_name[7] = 0x86;
3284 		nv->node_name[0] = 0x20;
3285 		nv->node_name[1] = 0x00;
3286 		nv->node_name[2] = 0x00;
3287 		nv->node_name[3] = 0xe0;
3288 		nv->node_name[4] = 0x8b;
3289 		nv->node_name[5] = 0x1c;
3290 		nv->node_name[6] = 0x55;
3291 		nv->node_name[7] = 0x86;
3292 		nv->login_retry_count = __constant_cpu_to_le16(8);
3293 		nv->link_down_timeout = __constant_cpu_to_le16(200);
3294 		nv->interrupt_delay_timer = __constant_cpu_to_le16(0);
3295 		nv->login_timeout = __constant_cpu_to_le16(0);
3296 		nv->firmware_options_1 =
3297 		    __constant_cpu_to_le32(BIT_14|BIT_13|BIT_2|BIT_1);
3298 		nv->firmware_options_2 = __constant_cpu_to_le32(2 << 4);
3299 		nv->firmware_options_2 |= __constant_cpu_to_le32(BIT_12);
3300 		nv->firmware_options_3 = __constant_cpu_to_le32(2 << 13);
3301 		nv->host_p = __constant_cpu_to_le32(BIT_11|BIT_10);
3302 		nv->efi_parameters = __constant_cpu_to_le32(0);
3303 		nv->reset_delay = 5;
3304 		nv->max_luns_per_target = __constant_cpu_to_le16(128);
3305 		nv->port_down_retry_count = __constant_cpu_to_le16(30);
3306 		nv->link_down_timeout = __constant_cpu_to_le16(30);
3307 
3308 		rval = 1;
3309 	}
3310 
3311 	/* Reset Initialization control block */
3312 	memset(icb, 0, sizeof(struct init_cb_24xx));
3313 
3314 	/* Copy 1st segment. */
3315 	dptr1 = (uint8_t *)icb;
3316 	dptr2 = (uint8_t *)&nv->version;
3317 	cnt = (uint8_t *)&icb->response_q_inpointer - (uint8_t *)&icb->version;
3318 	while (cnt--)
3319 		*dptr1++ = *dptr2++;
3320 
3321 	icb->login_retry_count = nv->login_retry_count;
3322 	icb->link_down_timeout = nv->link_down_timeout;
3323 
3324 	/* Copy 2nd segment. */
3325 	dptr1 = (uint8_t *)&icb->interrupt_delay_timer;
3326 	dptr2 = (uint8_t *)&nv->interrupt_delay_timer;
3327 	cnt = (uint8_t *)&icb->reserved_3 -
3328 	    (uint8_t *)&icb->interrupt_delay_timer;
3329 	while (cnt--)
3330 		*dptr1++ = *dptr2++;
3331 
3332 	/*
3333 	 * Setup driver NVRAM options.
3334 	 */
3335 	if (memcmp(nv->model_name, BINZERO, sizeof(nv->model_name)) != 0) {
3336 		char *st, *en;
3337 		uint16_t index;
3338 
3339 		strncpy(ha->model_number, nv->model_name,
3340 		    sizeof(nv->model_name));
3341 		st = en = ha->model_number;
3342 		en += sizeof(nv->model_name) - 1;
3343 		while (en > st) {
3344 			if (*en != 0x20 && *en != 0x00)
3345 				break;
3346 			*en-- = '\0';
3347 		}
3348 
3349 		index = (ha->pdev->subsystem_device & 0xff);
3350 		if (index < QLA_MODEL_NAMES)
3351 			ha->model_desc = qla2x00_model_name[index * 2 + 1];
3352 	} else
3353 		strcpy(ha->model_number, "QLA2462");
3354 
3355 	/* Use alternate WWN? */
3356 	if (nv->host_p & __constant_cpu_to_le32(BIT_15)) {
3357 		memcpy(icb->node_name, nv->alternate_node_name, WWN_SIZE);
3358 		memcpy(icb->port_name, nv->alternate_port_name, WWN_SIZE);
3359 	}
3360 
3361 	/* Prepare nodename */
3362 	if ((icb->firmware_options_1 & __constant_cpu_to_le32(BIT_14)) == 0) {
3363 		/*
3364 		 * Firmware will apply the following mask if the nodename was
3365 		 * not provided.
3366 		 */
3367 		memcpy(icb->node_name, icb->port_name, WWN_SIZE);
3368 		icb->node_name[0] &= 0xF0;
3369 	}
3370 
3371 	/* Set host adapter parameters. */
3372 	ha->flags.disable_risc_code_load = 0;
3373 	ha->flags.enable_lip_reset = 1;
3374 	ha->flags.enable_lip_full_login = 1;
3375 	ha->flags.enable_target_reset = 1;
3376 	ha->flags.enable_led_scheme = 0;
3377 
3378 	ha->operating_mode = (le32_to_cpu(icb->firmware_options_2) &
3379 	    (BIT_6 | BIT_5 | BIT_4)) >> 4;
3380 
3381 	memcpy(ha->fw_seriallink_options24, nv->seriallink_options,
3382 	    sizeof(ha->fw_seriallink_options24));
3383 
3384 	/* save HBA serial number */
3385 	ha->serial0 = icb->port_name[5];
3386 	ha->serial1 = icb->port_name[6];
3387 	ha->serial2 = icb->port_name[7];
3388 	ha->node_name = icb->node_name;
3389 	ha->port_name = icb->port_name;
3390 
3391 	icb->execution_throttle = __constant_cpu_to_le16(0xFFFF);
3392 
3393 	ha->retry_count = le16_to_cpu(nv->login_retry_count);
3394 
3395 	/* Set minimum login_timeout to 4 seconds. */
3396 	if (le16_to_cpu(nv->login_timeout) < ql2xlogintimeout)
3397 		nv->login_timeout = cpu_to_le16(ql2xlogintimeout);
3398 	if (le16_to_cpu(nv->login_timeout) < 4)
3399 		nv->login_timeout = __constant_cpu_to_le16(4);
3400 	ha->login_timeout = le16_to_cpu(nv->login_timeout);
3401 	icb->login_timeout = cpu_to_le16(nv->login_timeout);
3402 
3403 	/* Set minimum RATOV to 200 tenths of a second. */
3404 	ha->r_a_tov = 200;
3405 
3406 	ha->loop_reset_delay = nv->reset_delay;
3407 
3408 	/* Link Down Timeout = 0:
3409 	 *
3410 	 * 	When Port Down timer expires we will start returning
3411 	 *	I/O's to OS with "DID_NO_CONNECT".
3412 	 *
3413 	 * Link Down Timeout != 0:
3414 	 *
3415 	 *	 The driver waits for the link to come up after link down
3416 	 *	 before returning I/Os to OS with "DID_NO_CONNECT".
3417 	 */
3418 	if (le16_to_cpu(nv->link_down_timeout) == 0) {
3419 		ha->loop_down_abort_time =
3420 		    (LOOP_DOWN_TIME - LOOP_DOWN_TIMEOUT);
3421 	} else {
3422 		ha->link_down_timeout =	le16_to_cpu(nv->link_down_timeout);
3423 		ha->loop_down_abort_time =
3424 		    (LOOP_DOWN_TIME - ha->link_down_timeout);
3425 	}
3426 
3427 	/* Need enough time to try and get the port back. */
3428 	ha->port_down_retry_count = le16_to_cpu(nv->port_down_retry_count);
3429 	if (qlport_down_retry)
3430 		ha->port_down_retry_count = qlport_down_retry;
3431 
3432 	/* Set login_retry_count */
3433 	ha->login_retry_count  = le16_to_cpu(nv->login_retry_count);
3434 	if (ha->port_down_retry_count ==
3435 	    le16_to_cpu(nv->port_down_retry_count) &&
3436 	    ha->port_down_retry_count > 3)
3437 		ha->login_retry_count = ha->port_down_retry_count;
3438 	else if (ha->port_down_retry_count > (int)ha->login_retry_count)
3439 		ha->login_retry_count = ha->port_down_retry_count;
3440 	if (ql2xloginretrycount)
3441 		ha->login_retry_count = ql2xloginretrycount;
3442 
3443 	/* Enable ZIO. */
3444 	if (!ha->flags.init_done) {
3445 		ha->zio_mode = le32_to_cpu(icb->firmware_options_2) &
3446 		    (BIT_3 | BIT_2 | BIT_1 | BIT_0);
3447 		ha->zio_timer = le16_to_cpu(icb->interrupt_delay_timer) ?
3448 		    le16_to_cpu(icb->interrupt_delay_timer): 2;
3449 	}
3450 	icb->firmware_options_2 &= __constant_cpu_to_le32(
3451 	    ~(BIT_3 | BIT_2 | BIT_1 | BIT_0));
3452 	ha->flags.process_response_queue = 0;
3453 	if (ha->zio_mode != QLA_ZIO_DISABLED) {
3454 		ha->zio_mode = QLA_ZIO_MODE_6;
3455 
3456 		DEBUG2(printk("scsi(%ld): ZIO mode %d enabled; timer delay "
3457 		    "(%d us).\n", ha->host_no, ha->zio_mode,
3458 		    ha->zio_timer * 100));
3459 		qla_printk(KERN_INFO, ha,
3460 		    "ZIO mode %d enabled; timer delay (%d us).\n",
3461 		    ha->zio_mode, ha->zio_timer * 100);
3462 
3463 		icb->firmware_options_2 |= cpu_to_le32(
3464 		    (uint32_t)ha->zio_mode);
3465 		icb->interrupt_delay_timer = cpu_to_le16(ha->zio_timer);
3466 		ha->flags.process_response_queue = 1;
3467 	}
3468 
3469 	if (rval) {
3470 		DEBUG2_3(printk(KERN_WARNING
3471 		    "scsi(%ld): NVRAM configuration failed!\n", ha->host_no));
3472 	}
3473 	return (rval);
3474 }
3475 
3476 int
3477 qla24xx_load_risc_flash(scsi_qla_host_t *ha, uint32_t *srisc_addr)
3478 {
3479 	int	rval;
3480 	int	segments, fragment;
3481 	uint32_t faddr;
3482 	uint32_t *dcode, dlen;
3483 	uint32_t risc_addr;
3484 	uint32_t risc_size;
3485 	uint32_t i;
3486 
3487 	rval = QLA_SUCCESS;
3488 
3489 	segments = FA_RISC_CODE_SEGMENTS;
3490 	faddr = FA_RISC_CODE_ADDR;
3491 	dcode = (uint32_t *)ha->request_ring;
3492 	*srisc_addr = 0;
3493 
3494 	/* Validate firmware image by checking version. */
3495 	qla24xx_read_flash_data(ha, dcode, faddr + 4, 4);
3496 	for (i = 0; i < 4; i++)
3497 		dcode[i] = be32_to_cpu(dcode[i]);
3498 	if ((dcode[0] == 0xffffffff && dcode[1] == 0xffffffff &&
3499 	    dcode[2] == 0xffffffff && dcode[3] == 0xffffffff) ||
3500 	    (dcode[0] == 0 && dcode[1] == 0 && dcode[2] == 0 &&
3501 		dcode[3] == 0)) {
3502 		qla_printk(KERN_WARNING, ha,
3503 		    "Unable to verify integrity of flash firmware image!\n");
3504 		qla_printk(KERN_WARNING, ha,
3505 		    "Firmware data: %08x %08x %08x %08x!\n", dcode[0],
3506 		    dcode[1], dcode[2], dcode[3]);
3507 
3508 		return QLA_FUNCTION_FAILED;
3509 	}
3510 
3511 	while (segments && rval == QLA_SUCCESS) {
3512 		/* Read segment's load information. */
3513 		qla24xx_read_flash_data(ha, dcode, faddr, 4);
3514 
3515 		risc_addr = be32_to_cpu(dcode[2]);
3516 		*srisc_addr = *srisc_addr == 0 ? risc_addr : *srisc_addr;
3517 		risc_size = be32_to_cpu(dcode[3]);
3518 
3519 		fragment = 0;
3520 		while (risc_size > 0 && rval == QLA_SUCCESS) {
3521 			dlen = (uint32_t)(ha->fw_transfer_size >> 2);
3522 			if (dlen > risc_size)
3523 				dlen = risc_size;
3524 
3525 			DEBUG7(printk("scsi(%ld): Loading risc segment@ risc "
3526 			    "addr %x, number of dwords 0x%x, offset 0x%x.\n",
3527 			    ha->host_no, risc_addr, dlen, faddr));
3528 
3529 			qla24xx_read_flash_data(ha, dcode, faddr, dlen);
3530 			for (i = 0; i < dlen; i++)
3531 				dcode[i] = swab32(dcode[i]);
3532 
3533 			rval = qla2x00_load_ram(ha, ha->request_dma, risc_addr,
3534 			    dlen);
3535 			if (rval) {
3536 				DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
3537 				    "segment %d of firmware\n", ha->host_no,
3538 				    fragment));
3539 				qla_printk(KERN_WARNING, ha,
3540 				    "[ERROR] Failed to load segment %d of "
3541 				    "firmware\n", fragment);
3542 				break;
3543 			}
3544 
3545 			faddr += dlen;
3546 			risc_addr += dlen;
3547 			risc_size -= dlen;
3548 			fragment++;
3549 		}
3550 
3551 		/* Next segment. */
3552 		segments--;
3553 	}
3554 
3555 	return rval;
3556 }
3557 
3558 #define QLA_FW_URL "ftp://ftp.qlogic.com/outgoing/linux/firmware/"
3559 
3560 int
3561 qla2x00_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr)
3562 {
3563 	int	rval;
3564 	int	i, fragment;
3565 	uint16_t *wcode, *fwcode;
3566 	uint32_t risc_addr, risc_size, fwclen, wlen, *seg;
3567 	struct fw_blob *blob;
3568 
3569 	/* Load firmware blob. */
3570 	blob = qla2x00_request_firmware(ha);
3571 	if (!blob) {
3572 		qla_printk(KERN_ERR, ha, "Firmware image unavailable.\n");
3573 		qla_printk(KERN_ERR, ha, "Firmware images can be retrieved "
3574 		    "from: " QLA_FW_URL ".\n");
3575 		return QLA_FUNCTION_FAILED;
3576 	}
3577 
3578 	rval = QLA_SUCCESS;
3579 
3580 	wcode = (uint16_t *)ha->request_ring;
3581 	*srisc_addr = 0;
3582 	fwcode = (uint16_t *)blob->fw->data;
3583 	fwclen = 0;
3584 
3585 	/* Validate firmware image by checking version. */
3586 	if (blob->fw->size < 8 * sizeof(uint16_t)) {
3587 		qla_printk(KERN_WARNING, ha,
3588 		    "Unable to verify integrity of firmware image (%Zd)!\n",
3589 		    blob->fw->size);
3590 		goto fail_fw_integrity;
3591 	}
3592 	for (i = 0; i < 4; i++)
3593 		wcode[i] = be16_to_cpu(fwcode[i + 4]);
3594 	if ((wcode[0] == 0xffff && wcode[1] == 0xffff && wcode[2] == 0xffff &&
3595 	    wcode[3] == 0xffff) || (wcode[0] == 0 && wcode[1] == 0 &&
3596 		wcode[2] == 0 && wcode[3] == 0)) {
3597 		qla_printk(KERN_WARNING, ha,
3598 		    "Unable to verify integrity of firmware image!\n");
3599 		qla_printk(KERN_WARNING, ha,
3600 		    "Firmware data: %04x %04x %04x %04x!\n", wcode[0],
3601 		    wcode[1], wcode[2], wcode[3]);
3602 		goto fail_fw_integrity;
3603 	}
3604 
3605 	seg = blob->segs;
3606 	while (*seg && rval == QLA_SUCCESS) {
3607 		risc_addr = *seg;
3608 		*srisc_addr = *srisc_addr == 0 ? *seg : *srisc_addr;
3609 		risc_size = be16_to_cpu(fwcode[3]);
3610 
3611 		/* Validate firmware image size. */
3612 		fwclen += risc_size * sizeof(uint16_t);
3613 		if (blob->fw->size < fwclen) {
3614 			qla_printk(KERN_WARNING, ha,
3615 			    "Unable to verify integrity of firmware image "
3616 			    "(%Zd)!\n", blob->fw->size);
3617 			goto fail_fw_integrity;
3618 		}
3619 
3620 		fragment = 0;
3621 		while (risc_size > 0 && rval == QLA_SUCCESS) {
3622 			wlen = (uint16_t)(ha->fw_transfer_size >> 1);
3623 			if (wlen > risc_size)
3624 				wlen = risc_size;
3625 
3626 			DEBUG7(printk("scsi(%ld): Loading risc segment@ risc "
3627 			    "addr %x, number of words 0x%x.\n", ha->host_no,
3628 			    risc_addr, wlen));
3629 
3630 			for (i = 0; i < wlen; i++)
3631 				wcode[i] = swab16(fwcode[i]);
3632 
3633 			rval = qla2x00_load_ram(ha, ha->request_dma, risc_addr,
3634 			    wlen);
3635 			if (rval) {
3636 				DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
3637 				    "segment %d of firmware\n", ha->host_no,
3638 				    fragment));
3639 				qla_printk(KERN_WARNING, ha,
3640 				    "[ERROR] Failed to load segment %d of "
3641 				    "firmware\n", fragment);
3642 				break;
3643 			}
3644 
3645 			fwcode += wlen;
3646 			risc_addr += wlen;
3647 			risc_size -= wlen;
3648 			fragment++;
3649 		}
3650 
3651 		/* Next segment. */
3652 		seg++;
3653 	}
3654 	return rval;
3655 
3656 fail_fw_integrity:
3657 	return QLA_FUNCTION_FAILED;
3658 }
3659 
3660 int
3661 qla24xx_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr)
3662 {
3663 	int	rval;
3664 	int	segments, fragment;
3665 	uint32_t *dcode, dlen;
3666 	uint32_t risc_addr;
3667 	uint32_t risc_size;
3668 	uint32_t i;
3669 	struct fw_blob *blob;
3670 	uint32_t *fwcode, fwclen;
3671 
3672 	/* Load firmware blob. */
3673 	blob = qla2x00_request_firmware(ha);
3674 	if (!blob) {
3675 		qla_printk(KERN_ERR, ha, "Firmware image unavailable.\n");
3676 		qla_printk(KERN_ERR, ha, "Firmware images can be retrieved "
3677 		    "from: " QLA_FW_URL ".\n");
3678 
3679 		/* Try to load RISC code from flash. */
3680 		qla_printk(KERN_ERR, ha, "Attempting to load (potentially "
3681 		    "outdated) firmware from flash.\n");
3682 		return qla24xx_load_risc_flash(ha, srisc_addr);
3683 	}
3684 
3685 	rval = QLA_SUCCESS;
3686 
3687 	segments = FA_RISC_CODE_SEGMENTS;
3688 	dcode = (uint32_t *)ha->request_ring;
3689 	*srisc_addr = 0;
3690 	fwcode = (uint32_t *)blob->fw->data;
3691 	fwclen = 0;
3692 
3693 	/* Validate firmware image by checking version. */
3694 	if (blob->fw->size < 8 * sizeof(uint32_t)) {
3695 		qla_printk(KERN_WARNING, ha,
3696 		    "Unable to verify integrity of firmware image (%Zd)!\n",
3697 		    blob->fw->size);
3698 		goto fail_fw_integrity;
3699 	}
3700 	for (i = 0; i < 4; i++)
3701 		dcode[i] = be32_to_cpu(fwcode[i + 4]);
3702 	if ((dcode[0] == 0xffffffff && dcode[1] == 0xffffffff &&
3703 	    dcode[2] == 0xffffffff && dcode[3] == 0xffffffff) ||
3704 	    (dcode[0] == 0 && dcode[1] == 0 && dcode[2] == 0 &&
3705 		dcode[3] == 0)) {
3706 		qla_printk(KERN_WARNING, ha,
3707 		    "Unable to verify integrity of firmware image!\n");
3708 		qla_printk(KERN_WARNING, ha,
3709 		    "Firmware data: %08x %08x %08x %08x!\n", dcode[0],
3710 		    dcode[1], dcode[2], dcode[3]);
3711 		goto fail_fw_integrity;
3712 	}
3713 
3714 	while (segments && rval == QLA_SUCCESS) {
3715 		risc_addr = be32_to_cpu(fwcode[2]);
3716 		*srisc_addr = *srisc_addr == 0 ? risc_addr : *srisc_addr;
3717 		risc_size = be32_to_cpu(fwcode[3]);
3718 
3719 		/* Validate firmware image size. */
3720 		fwclen += risc_size * sizeof(uint32_t);
3721 		if (blob->fw->size < fwclen) {
3722 			qla_printk(KERN_WARNING, ha,
3723 			    "Unable to verify integrity of firmware image "
3724 			    "(%Zd)!\n", blob->fw->size);
3725 
3726 			goto fail_fw_integrity;
3727 		}
3728 
3729 		fragment = 0;
3730 		while (risc_size > 0 && rval == QLA_SUCCESS) {
3731 			dlen = (uint32_t)(ha->fw_transfer_size >> 2);
3732 			if (dlen > risc_size)
3733 				dlen = risc_size;
3734 
3735 			DEBUG7(printk("scsi(%ld): Loading risc segment@ risc "
3736 			    "addr %x, number of dwords 0x%x.\n", ha->host_no,
3737 			    risc_addr, dlen));
3738 
3739 			for (i = 0; i < dlen; i++)
3740 				dcode[i] = swab32(fwcode[i]);
3741 
3742 			rval = qla2x00_load_ram(ha, ha->request_dma, risc_addr,
3743 			    dlen);
3744 			if (rval) {
3745 				DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
3746 				    "segment %d of firmware\n", ha->host_no,
3747 				    fragment));
3748 				qla_printk(KERN_WARNING, ha,
3749 				    "[ERROR] Failed to load segment %d of "
3750 				    "firmware\n", fragment);
3751 				break;
3752 			}
3753 
3754 			fwcode += dlen;
3755 			risc_addr += dlen;
3756 			risc_size -= dlen;
3757 			fragment++;
3758 		}
3759 
3760 		/* Next segment. */
3761 		segments--;
3762 	}
3763 	return rval;
3764 
3765 fail_fw_integrity:
3766 	return QLA_FUNCTION_FAILED;
3767 }
3768