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