1e3976af5SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
2afaf5a2dSDavid Somayajulu /*
3afaf5a2dSDavid Somayajulu * QLogic iSCSI HBA Driver
44a4f51e9SVikas Chaudhary * Copyright (c) 2003-2013 QLogic Corporation
5afaf5a2dSDavid Somayajulu */
6afaf5a2dSDavid Somayajulu
726974789SMike Christie #include <scsi/iscsi_if.h>
8afaf5a2dSDavid Somayajulu #include "ql4_def.h"
992b72736SDavid C Somayajulu #include "ql4_glbl.h"
1092b72736SDavid C Somayajulu #include "ql4_dbg.h"
1192b72736SDavid C Somayajulu #include "ql4_inline.h"
12afaf5a2dSDavid Somayajulu
ql4xxx_set_mac_number(struct scsi_qla_host * ha)13afaf5a2dSDavid Somayajulu static void ql4xxx_set_mac_number(struct scsi_qla_host *ha)
14afaf5a2dSDavid Somayajulu {
15afaf5a2dSDavid Somayajulu uint32_t value;
16afaf5a2dSDavid Somayajulu unsigned long flags;
17afaf5a2dSDavid Somayajulu
18afaf5a2dSDavid Somayajulu /* Get the function number */
19afaf5a2dSDavid Somayajulu spin_lock_irqsave(&ha->hardware_lock, flags);
20afaf5a2dSDavid Somayajulu value = readw(&ha->reg->ctrl_status);
21afaf5a2dSDavid Somayajulu spin_unlock_irqrestore(&ha->hardware_lock, flags);
22afaf5a2dSDavid Somayajulu
23afaf5a2dSDavid Somayajulu switch (value & ISP_CONTROL_FN_MASK) {
24afaf5a2dSDavid Somayajulu case ISP_CONTROL_FN0_SCSI:
25afaf5a2dSDavid Somayajulu ha->mac_index = 1;
26afaf5a2dSDavid Somayajulu break;
27afaf5a2dSDavid Somayajulu case ISP_CONTROL_FN1_SCSI:
28afaf5a2dSDavid Somayajulu ha->mac_index = 3;
29afaf5a2dSDavid Somayajulu break;
30afaf5a2dSDavid Somayajulu default:
31afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: Invalid function number, "
32afaf5a2dSDavid Somayajulu "ispControlStatus = 0x%x\n", ha->host_no,
33afaf5a2dSDavid Somayajulu __func__, value));
34afaf5a2dSDavid Somayajulu break;
35afaf5a2dSDavid Somayajulu }
36afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: mac_index %d.\n", ha->host_no, __func__,
37afaf5a2dSDavid Somayajulu ha->mac_index));
38afaf5a2dSDavid Somayajulu }
39afaf5a2dSDavid Somayajulu
40afaf5a2dSDavid Somayajulu /**
41afaf5a2dSDavid Somayajulu * qla4xxx_free_ddb - deallocate ddb
42afaf5a2dSDavid Somayajulu * @ha: pointer to host adapter structure.
43afaf5a2dSDavid Somayajulu * @ddb_entry: pointer to device database entry
44afaf5a2dSDavid Somayajulu *
45b3a271a9SManish Rangankar * This routine marks a DDB entry INVALID
46afaf5a2dSDavid Somayajulu **/
qla4xxx_free_ddb(struct scsi_qla_host * ha,struct ddb_entry * ddb_entry)47f4f5df23SVikas Chaudhary void qla4xxx_free_ddb(struct scsi_qla_host *ha,
4847975477SAdrian Bunk struct ddb_entry *ddb_entry)
49afaf5a2dSDavid Somayajulu {
50afaf5a2dSDavid Somayajulu /* Remove device pointer from index mapping arrays */
51afaf5a2dSDavid Somayajulu ha->fw_ddb_index_map[ddb_entry->fw_ddb_index] =
52afaf5a2dSDavid Somayajulu (struct ddb_entry *) INVALID_ENTRY;
53afaf5a2dSDavid Somayajulu ha->tot_ddbs--;
54afaf5a2dSDavid Somayajulu }
55afaf5a2dSDavid Somayajulu
56afaf5a2dSDavid Somayajulu /**
57f4f5df23SVikas Chaudhary * qla4xxx_init_response_q_entries() - Initializes response queue entries.
58f4f5df23SVikas Chaudhary * @ha: HA context
59f4f5df23SVikas Chaudhary *
60f4f5df23SVikas Chaudhary * Beginning of request ring has initialization control block already built
61f4f5df23SVikas Chaudhary * by nvram config routine.
62f4f5df23SVikas Chaudhary **/
qla4xxx_init_response_q_entries(struct scsi_qla_host * ha)63f4f5df23SVikas Chaudhary static void qla4xxx_init_response_q_entries(struct scsi_qla_host *ha)
64f4f5df23SVikas Chaudhary {
65f4f5df23SVikas Chaudhary uint16_t cnt;
66f4f5df23SVikas Chaudhary struct response *pkt;
67f4f5df23SVikas Chaudhary
68f4f5df23SVikas Chaudhary pkt = (struct response *)ha->response_ptr;
69f4f5df23SVikas Chaudhary for (cnt = 0; cnt < RESPONSE_QUEUE_DEPTH; cnt++) {
70f4f5df23SVikas Chaudhary pkt->signature = RESPONSE_PROCESSED;
71f4f5df23SVikas Chaudhary pkt++;
72f4f5df23SVikas Chaudhary }
73f4f5df23SVikas Chaudhary }
74f4f5df23SVikas Chaudhary
75f4f5df23SVikas Chaudhary /**
76afaf5a2dSDavid Somayajulu * qla4xxx_init_rings - initialize hw queues
77afaf5a2dSDavid Somayajulu * @ha: pointer to host adapter structure.
78afaf5a2dSDavid Somayajulu *
79afaf5a2dSDavid Somayajulu * This routine initializes the internal queues for the specified adapter.
80afaf5a2dSDavid Somayajulu * The QLA4010 requires us to restart the queues at index 0.
81afaf5a2dSDavid Somayajulu * The QLA4000 doesn't care, so just default to QLA4010's requirement.
82afaf5a2dSDavid Somayajulu **/
qla4xxx_init_rings(struct scsi_qla_host * ha)83afaf5a2dSDavid Somayajulu int qla4xxx_init_rings(struct scsi_qla_host *ha)
84afaf5a2dSDavid Somayajulu {
85afaf5a2dSDavid Somayajulu unsigned long flags = 0;
86c0b9d3f7SVikas Chaudhary int i;
87afaf5a2dSDavid Somayajulu
88afaf5a2dSDavid Somayajulu /* Initialize request queue. */
89afaf5a2dSDavid Somayajulu spin_lock_irqsave(&ha->hardware_lock, flags);
90afaf5a2dSDavid Somayajulu ha->request_out = 0;
91afaf5a2dSDavid Somayajulu ha->request_in = 0;
92afaf5a2dSDavid Somayajulu ha->request_ptr = &ha->request_ring[ha->request_in];
93afaf5a2dSDavid Somayajulu ha->req_q_count = REQUEST_QUEUE_DEPTH;
94afaf5a2dSDavid Somayajulu
95afaf5a2dSDavid Somayajulu /* Initialize response queue. */
96afaf5a2dSDavid Somayajulu ha->response_in = 0;
97afaf5a2dSDavid Somayajulu ha->response_out = 0;
98afaf5a2dSDavid Somayajulu ha->response_ptr = &ha->response_ring[ha->response_out];
99afaf5a2dSDavid Somayajulu
100f4f5df23SVikas Chaudhary if (is_qla8022(ha)) {
101f4f5df23SVikas Chaudhary writel(0,
1027664a1fdSVikas Chaudhary (unsigned long __iomem *)&ha->qla4_82xx_reg->req_q_out);
103f4f5df23SVikas Chaudhary writel(0,
1047664a1fdSVikas Chaudhary (unsigned long __iomem *)&ha->qla4_82xx_reg->rsp_q_in);
105f4f5df23SVikas Chaudhary writel(0,
1067664a1fdSVikas Chaudhary (unsigned long __iomem *)&ha->qla4_82xx_reg->rsp_q_out);
107b37ca418SVikas Chaudhary } else if (is_qla8032(ha) || is_qla8042(ha)) {
1086e7b4292SVikas Chaudhary writel(0,
1096e7b4292SVikas Chaudhary (unsigned long __iomem *)&ha->qla4_83xx_reg->req_q_in);
1106e7b4292SVikas Chaudhary writel(0,
1116e7b4292SVikas Chaudhary (unsigned long __iomem *)&ha->qla4_83xx_reg->rsp_q_in);
1126e7b4292SVikas Chaudhary writel(0,
1136e7b4292SVikas Chaudhary (unsigned long __iomem *)&ha->qla4_83xx_reg->rsp_q_out);
114f4f5df23SVikas Chaudhary } else {
115afaf5a2dSDavid Somayajulu /*
116f4f5df23SVikas Chaudhary * Initialize DMA Shadow registers. The firmware is really
117f4f5df23SVikas Chaudhary * supposed to take care of this, but on some uniprocessor
118f4f5df23SVikas Chaudhary * systems, the shadow registers aren't cleared-- causing
119f4f5df23SVikas Chaudhary * the interrupt_handler to think there are responses to be
120f4f5df23SVikas Chaudhary * processed when there aren't.
121afaf5a2dSDavid Somayajulu */
122*33529018SDwaipayan Ray ha->shadow_regs->req_q_out = cpu_to_le32(0);
123*33529018SDwaipayan Ray ha->shadow_regs->rsp_q_in = cpu_to_le32(0);
124afaf5a2dSDavid Somayajulu wmb();
125afaf5a2dSDavid Somayajulu
126afaf5a2dSDavid Somayajulu writel(0, &ha->reg->req_q_in);
127afaf5a2dSDavid Somayajulu writel(0, &ha->reg->rsp_q_out);
128afaf5a2dSDavid Somayajulu readl(&ha->reg->rsp_q_out);
129f4f5df23SVikas Chaudhary }
130f4f5df23SVikas Chaudhary
131f4f5df23SVikas Chaudhary qla4xxx_init_response_q_entries(ha);
132afaf5a2dSDavid Somayajulu
13318e2df93SVikas Chaudhary /* Initialize mailbox active array */
134c0b9d3f7SVikas Chaudhary for (i = 0; i < MAX_MRB; i++)
135c0b9d3f7SVikas Chaudhary ha->active_mrb_array[i] = NULL;
136c0b9d3f7SVikas Chaudhary
137afaf5a2dSDavid Somayajulu spin_unlock_irqrestore(&ha->hardware_lock, flags);
138afaf5a2dSDavid Somayajulu
139afaf5a2dSDavid Somayajulu return QLA_SUCCESS;
140afaf5a2dSDavid Somayajulu }
141afaf5a2dSDavid Somayajulu
142afaf5a2dSDavid Somayajulu /**
143f4f5df23SVikas Chaudhary * qla4xxx_get_sys_info - validate adapter MAC address(es)
144afaf5a2dSDavid Somayajulu * @ha: pointer to host adapter structure.
145afaf5a2dSDavid Somayajulu *
146afaf5a2dSDavid Somayajulu **/
qla4xxx_get_sys_info(struct scsi_qla_host * ha)147f4f5df23SVikas Chaudhary int qla4xxx_get_sys_info(struct scsi_qla_host *ha)
148afaf5a2dSDavid Somayajulu {
149afaf5a2dSDavid Somayajulu struct flash_sys_info *sys_info;
150afaf5a2dSDavid Somayajulu dma_addr_t sys_info_dma;
151afaf5a2dSDavid Somayajulu int status = QLA_ERROR;
152afaf5a2dSDavid Somayajulu
153750afb08SLuis Chamberlain sys_info = dma_alloc_coherent(&ha->pdev->dev, sizeof(*sys_info),
154afaf5a2dSDavid Somayajulu &sys_info_dma, GFP_KERNEL);
155afaf5a2dSDavid Somayajulu if (sys_info == NULL) {
156afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: Unable to allocate dma buffer.\n",
157afaf5a2dSDavid Somayajulu ha->host_no, __func__));
158afaf5a2dSDavid Somayajulu
159f4f5df23SVikas Chaudhary goto exit_get_sys_info_no_free;
160afaf5a2dSDavid Somayajulu }
161afaf5a2dSDavid Somayajulu
162afaf5a2dSDavid Somayajulu /* Get flash sys info */
163afaf5a2dSDavid Somayajulu if (qla4xxx_get_flash(ha, sys_info_dma, FLASH_OFFSET_SYS_INFO,
164afaf5a2dSDavid Somayajulu sizeof(*sys_info)) != QLA_SUCCESS) {
165afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: get_flash FLASH_OFFSET_SYS_INFO "
166afaf5a2dSDavid Somayajulu "failed\n", ha->host_no, __func__));
167afaf5a2dSDavid Somayajulu
168f4f5df23SVikas Chaudhary goto exit_get_sys_info;
169afaf5a2dSDavid Somayajulu }
170afaf5a2dSDavid Somayajulu
171afaf5a2dSDavid Somayajulu /* Save M.A.C. address & serial_number */
172afaf5a2dSDavid Somayajulu memcpy(ha->my_mac, &sys_info->physAddr[0].address[0],
173afaf5a2dSDavid Somayajulu min(sizeof(ha->my_mac),
174afaf5a2dSDavid Somayajulu sizeof(sys_info->physAddr[0].address)));
175afaf5a2dSDavid Somayajulu memcpy(ha->serial_number, &sys_info->acSerialNumber,
176afaf5a2dSDavid Somayajulu min(sizeof(ha->serial_number),
177afaf5a2dSDavid Somayajulu sizeof(sys_info->acSerialNumber)));
178afaf5a2dSDavid Somayajulu
179afaf5a2dSDavid Somayajulu status = QLA_SUCCESS;
180afaf5a2dSDavid Somayajulu
181f4f5df23SVikas Chaudhary exit_get_sys_info:
182afaf5a2dSDavid Somayajulu dma_free_coherent(&ha->pdev->dev, sizeof(*sys_info), sys_info,
183afaf5a2dSDavid Somayajulu sys_info_dma);
184afaf5a2dSDavid Somayajulu
185f4f5df23SVikas Chaudhary exit_get_sys_info_no_free:
186afaf5a2dSDavid Somayajulu return status;
187afaf5a2dSDavid Somayajulu }
188afaf5a2dSDavid Somayajulu
189afaf5a2dSDavid Somayajulu /**
190afaf5a2dSDavid Somayajulu * qla4xxx_init_local_data - initialize adapter specific local data
191afaf5a2dSDavid Somayajulu * @ha: pointer to host adapter structure.
192afaf5a2dSDavid Somayajulu *
193afaf5a2dSDavid Somayajulu **/
qla4xxx_init_local_data(struct scsi_qla_host * ha)194ff4108dcSKaren Higgins static void qla4xxx_init_local_data(struct scsi_qla_host *ha)
195afaf5a2dSDavid Somayajulu {
196421f91d2SUwe Kleine-König /* Initialize aen queue */
197afaf5a2dSDavid Somayajulu ha->aen_q_count = MAX_AEN_ENTRIES;
198afaf5a2dSDavid Somayajulu }
199afaf5a2dSDavid Somayajulu
2002a49a78eSVikas Chaudhary static uint8_t
qla4xxx_wait_for_ip_config(struct scsi_qla_host * ha)2012a49a78eSVikas Chaudhary qla4xxx_wait_for_ip_config(struct scsi_qla_host *ha)
2022a49a78eSVikas Chaudhary {
2032a49a78eSVikas Chaudhary uint8_t ipv4_wait = 0;
2042a49a78eSVikas Chaudhary uint8_t ipv6_wait = 0;
2052a49a78eSVikas Chaudhary int8_t ip_address[IPv6_ADDR_LEN] = {0} ;
2062a49a78eSVikas Chaudhary
2072a49a78eSVikas Chaudhary /* If both IPv4 & IPv6 are enabled, possibly only one
2082a49a78eSVikas Chaudhary * IP address may be acquired, so check to see if we
2092a49a78eSVikas Chaudhary * need to wait for another */
2102a49a78eSVikas Chaudhary if (is_ipv4_enabled(ha) && is_ipv6_enabled(ha)) {
2112a49a78eSVikas Chaudhary if (((ha->addl_fw_state & FW_ADDSTATE_DHCPv4_ENABLED) != 0) &&
2122a49a78eSVikas Chaudhary ((ha->addl_fw_state &
2132a49a78eSVikas Chaudhary FW_ADDSTATE_DHCPv4_LEASE_ACQUIRED) == 0)) {
2142a49a78eSVikas Chaudhary ipv4_wait = 1;
2152a49a78eSVikas Chaudhary }
2162bab08fcSVikas Chaudhary if (((ha->ip_config.ipv6_addl_options &
2172a49a78eSVikas Chaudhary IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE) != 0) &&
2182bab08fcSVikas Chaudhary ((ha->ip_config.ipv6_link_local_state ==
2192bab08fcSVikas Chaudhary IP_ADDRSTATE_ACQUIRING) ||
2202bab08fcSVikas Chaudhary (ha->ip_config.ipv6_addr0_state ==
2212bab08fcSVikas Chaudhary IP_ADDRSTATE_ACQUIRING) ||
2222bab08fcSVikas Chaudhary (ha->ip_config.ipv6_addr1_state ==
2232bab08fcSVikas Chaudhary IP_ADDRSTATE_ACQUIRING))) {
2242a49a78eSVikas Chaudhary
2252a49a78eSVikas Chaudhary ipv6_wait = 1;
2262a49a78eSVikas Chaudhary
2272bab08fcSVikas Chaudhary if ((ha->ip_config.ipv6_link_local_state ==
2282a49a78eSVikas Chaudhary IP_ADDRSTATE_PREFERRED) ||
2292bab08fcSVikas Chaudhary (ha->ip_config.ipv6_addr0_state ==
2302bab08fcSVikas Chaudhary IP_ADDRSTATE_PREFERRED) ||
2312bab08fcSVikas Chaudhary (ha->ip_config.ipv6_addr1_state ==
2322bab08fcSVikas Chaudhary IP_ADDRSTATE_PREFERRED)) {
2332a49a78eSVikas Chaudhary DEBUG2(printk(KERN_INFO "scsi%ld: %s: "
2342a49a78eSVikas Chaudhary "Preferred IP configured."
2352a49a78eSVikas Chaudhary " Don't wait!\n", ha->host_no,
2362a49a78eSVikas Chaudhary __func__));
2372a49a78eSVikas Chaudhary ipv6_wait = 0;
2382a49a78eSVikas Chaudhary }
2392bab08fcSVikas Chaudhary if (memcmp(&ha->ip_config.ipv6_default_router_addr,
2402bab08fcSVikas Chaudhary ip_address, IPv6_ADDR_LEN) == 0) {
2412a49a78eSVikas Chaudhary DEBUG2(printk(KERN_INFO "scsi%ld: %s: "
2422a49a78eSVikas Chaudhary "No Router configured. "
2432a49a78eSVikas Chaudhary "Don't wait!\n", ha->host_no,
2442a49a78eSVikas Chaudhary __func__));
2452a49a78eSVikas Chaudhary ipv6_wait = 0;
2462a49a78eSVikas Chaudhary }
2472bab08fcSVikas Chaudhary if ((ha->ip_config.ipv6_default_router_state ==
2482a49a78eSVikas Chaudhary IPV6_RTRSTATE_MANUAL) &&
2492bab08fcSVikas Chaudhary (ha->ip_config.ipv6_link_local_state ==
2502a49a78eSVikas Chaudhary IP_ADDRSTATE_TENTATIVE) &&
2512bab08fcSVikas Chaudhary (memcmp(&ha->ip_config.ipv6_link_local_addr,
2522bab08fcSVikas Chaudhary &ha->ip_config.ipv6_default_router_addr, 4) ==
2532bab08fcSVikas Chaudhary 0)) {
2542a49a78eSVikas Chaudhary DEBUG2(printk("scsi%ld: %s: LinkLocal Router & "
2552a49a78eSVikas Chaudhary "IP configured. Don't wait!\n",
2562a49a78eSVikas Chaudhary ha->host_no, __func__));
2572a49a78eSVikas Chaudhary ipv6_wait = 0;
2582a49a78eSVikas Chaudhary }
2592a49a78eSVikas Chaudhary }
2602a49a78eSVikas Chaudhary if (ipv4_wait || ipv6_wait) {
2612a49a78eSVikas Chaudhary DEBUG2(printk("scsi%ld: %s: Wait for additional "
2622a49a78eSVikas Chaudhary "IP(s) \"", ha->host_no, __func__));
2632a49a78eSVikas Chaudhary if (ipv4_wait)
2642a49a78eSVikas Chaudhary DEBUG2(printk("IPv4 "));
2652bab08fcSVikas Chaudhary if (ha->ip_config.ipv6_link_local_state ==
2662bab08fcSVikas Chaudhary IP_ADDRSTATE_ACQUIRING)
2672a49a78eSVikas Chaudhary DEBUG2(printk("IPv6LinkLocal "));
2682bab08fcSVikas Chaudhary if (ha->ip_config.ipv6_addr0_state ==
2692bab08fcSVikas Chaudhary IP_ADDRSTATE_ACQUIRING)
2702a49a78eSVikas Chaudhary DEBUG2(printk("IPv6Addr0 "));
2712bab08fcSVikas Chaudhary if (ha->ip_config.ipv6_addr1_state ==
2722bab08fcSVikas Chaudhary IP_ADDRSTATE_ACQUIRING)
2732a49a78eSVikas Chaudhary DEBUG2(printk("IPv6Addr1 "));
2742a49a78eSVikas Chaudhary DEBUG2(printk("\"\n"));
2752a49a78eSVikas Chaudhary }
2762a49a78eSVikas Chaudhary }
2772a49a78eSVikas Chaudhary
2782a49a78eSVikas Chaudhary return ipv4_wait|ipv6_wait;
2792a49a78eSVikas Chaudhary }
2802a49a78eSVikas Chaudhary
qla4_80xx_is_minidump_dma_capable(struct scsi_qla_host * ha,struct qla4_8xxx_minidump_template_hdr * md_hdr)281b410982cSTej Parkash static int qla4_80xx_is_minidump_dma_capable(struct scsi_qla_host *ha,
282b410982cSTej Parkash struct qla4_8xxx_minidump_template_hdr *md_hdr)
283b410982cSTej Parkash {
284b410982cSTej Parkash int offset = (is_qla8022(ha)) ? QLA8022_TEMPLATE_CAP_OFFSET :
285b410982cSTej Parkash QLA83XX_TEMPLATE_CAP_OFFSET;
286b410982cSTej Parkash int rval = 1;
287b410982cSTej Parkash uint32_t *cap_offset;
288b410982cSTej Parkash
289b410982cSTej Parkash cap_offset = (uint32_t *)((char *)md_hdr + offset);
290b410982cSTej Parkash
291b410982cSTej Parkash if (!(le32_to_cpu(*cap_offset) & BIT_0)) {
292b410982cSTej Parkash ql4_printk(KERN_INFO, ha, "PEX DMA Not supported %d\n",
293b410982cSTej Parkash *cap_offset);
294b410982cSTej Parkash rval = 0;
295b410982cSTej Parkash }
296b410982cSTej Parkash
297b410982cSTej Parkash return rval;
298b410982cSTej Parkash }
299b410982cSTej Parkash
300068237c8STej Parkash /**
301068237c8STej Parkash * qla4xxx_alloc_fw_dump - Allocate memory for minidump data.
302068237c8STej Parkash * @ha: pointer to host adapter structure.
303068237c8STej Parkash **/
qla4xxx_alloc_fw_dump(struct scsi_qla_host * ha)304068237c8STej Parkash void qla4xxx_alloc_fw_dump(struct scsi_qla_host *ha)
305068237c8STej Parkash {
306068237c8STej Parkash int status;
307068237c8STej Parkash uint32_t capture_debug_level;
308068237c8STej Parkash int hdr_entry_bit, k;
309068237c8STej Parkash void *md_tmp;
310068237c8STej Parkash dma_addr_t md_tmp_dma;
311068237c8STej Parkash struct qla4_8xxx_minidump_template_hdr *md_hdr;
312b410982cSTej Parkash int dma_capable;
313068237c8STej Parkash
314068237c8STej Parkash if (ha->fw_dump) {
315068237c8STej Parkash ql4_printk(KERN_WARNING, ha,
316068237c8STej Parkash "Firmware dump previously allocated.\n");
317068237c8STej Parkash return;
318068237c8STej Parkash }
319068237c8STej Parkash
320068237c8STej Parkash status = qla4xxx_req_template_size(ha);
321068237c8STej Parkash if (status != QLA_SUCCESS) {
322068237c8STej Parkash ql4_printk(KERN_INFO, ha,
323068237c8STej Parkash "scsi%ld: Failed to get template size\n",
324068237c8STej Parkash ha->host_no);
325068237c8STej Parkash return;
326068237c8STej Parkash }
327068237c8STej Parkash
328068237c8STej Parkash clear_bit(AF_82XX_FW_DUMPED, &ha->flags);
329068237c8STej Parkash
330068237c8STej Parkash /* Allocate memory for saving the template */
331068237c8STej Parkash md_tmp = dma_alloc_coherent(&ha->pdev->dev, ha->fw_dump_tmplt_size,
332068237c8STej Parkash &md_tmp_dma, GFP_KERNEL);
333a5c277ecSMaurizio Lombardi if (!md_tmp) {
334a5c277ecSMaurizio Lombardi ql4_printk(KERN_INFO, ha,
335a5c277ecSMaurizio Lombardi "scsi%ld: Failed to allocate DMA memory\n",
336a5c277ecSMaurizio Lombardi ha->host_no);
337a5c277ecSMaurizio Lombardi return;
338a5c277ecSMaurizio Lombardi }
339068237c8STej Parkash
340068237c8STej Parkash /* Request template */
341068237c8STej Parkash status = qla4xxx_get_minidump_template(ha, md_tmp_dma);
342068237c8STej Parkash if (status != QLA_SUCCESS) {
343068237c8STej Parkash ql4_printk(KERN_INFO, ha,
344068237c8STej Parkash "scsi%ld: Failed to get minidump template\n",
345068237c8STej Parkash ha->host_no);
346068237c8STej Parkash goto alloc_cleanup;
347068237c8STej Parkash }
348068237c8STej Parkash
349068237c8STej Parkash md_hdr = (struct qla4_8xxx_minidump_template_hdr *)md_tmp;
350068237c8STej Parkash
351b410982cSTej Parkash dma_capable = qla4_80xx_is_minidump_dma_capable(ha, md_hdr);
352b410982cSTej Parkash
353068237c8STej Parkash capture_debug_level = md_hdr->capture_debug_level;
354068237c8STej Parkash
355068237c8STej Parkash /* Get capture mask based on module loadtime setting. */
356b410982cSTej Parkash if ((ql4xmdcapmask >= 0x3 && ql4xmdcapmask <= 0x7F) ||
357b410982cSTej Parkash (ql4xmdcapmask == 0xFF && dma_capable)) {
358068237c8STej Parkash ha->fw_dump_capture_mask = ql4xmdcapmask;
359b410982cSTej Parkash } else {
360b410982cSTej Parkash if (ql4xmdcapmask == 0xFF)
361b410982cSTej Parkash ql4_printk(KERN_INFO, ha, "Falling back to default capture mask, as PEX DMA is not supported\n");
362068237c8STej Parkash ha->fw_dump_capture_mask = capture_debug_level;
363b410982cSTej Parkash }
364068237c8STej Parkash
365068237c8STej Parkash md_hdr->driver_capture_mask = ha->fw_dump_capture_mask;
366068237c8STej Parkash
367068237c8STej Parkash DEBUG2(ql4_printk(KERN_INFO, ha, "Minimum num of entries = %d\n",
368068237c8STej Parkash md_hdr->num_of_entries));
369068237c8STej Parkash DEBUG2(ql4_printk(KERN_INFO, ha, "Dump template size = %d\n",
370068237c8STej Parkash ha->fw_dump_tmplt_size));
371068237c8STej Parkash DEBUG2(ql4_printk(KERN_INFO, ha, "Selected Capture mask =0x%x\n",
372068237c8STej Parkash ha->fw_dump_capture_mask));
373068237c8STej Parkash
374068237c8STej Parkash /* Calculate fw_dump_size */
375068237c8STej Parkash for (hdr_entry_bit = 0x2, k = 1; (hdr_entry_bit & 0xFF);
376068237c8STej Parkash hdr_entry_bit <<= 1, k++) {
377068237c8STej Parkash if (hdr_entry_bit & ha->fw_dump_capture_mask)
378068237c8STej Parkash ha->fw_dump_size += md_hdr->capture_size_array[k];
379068237c8STej Parkash }
380068237c8STej Parkash
381068237c8STej Parkash /* Total firmware dump size including command header */
382068237c8STej Parkash ha->fw_dump_size += ha->fw_dump_tmplt_size;
383068237c8STej Parkash ha->fw_dump = vmalloc(ha->fw_dump_size);
384068237c8STej Parkash if (!ha->fw_dump)
385068237c8STej Parkash goto alloc_cleanup;
386068237c8STej Parkash
387068237c8STej Parkash DEBUG2(ql4_printk(KERN_INFO, ha,
388e7731da3SColin Ian King "Minidump Template Size = 0x%x KB\n",
389068237c8STej Parkash ha->fw_dump_tmplt_size));
390068237c8STej Parkash DEBUG2(ql4_printk(KERN_INFO, ha,
391068237c8STej Parkash "Total Minidump size = 0x%x KB\n", ha->fw_dump_size));
392068237c8STej Parkash
393068237c8STej Parkash memcpy(ha->fw_dump, md_tmp, ha->fw_dump_tmplt_size);
394068237c8STej Parkash ha->fw_dump_tmplt_hdr = ha->fw_dump;
395068237c8STej Parkash
396068237c8STej Parkash alloc_cleanup:
397068237c8STej Parkash dma_free_coherent(&ha->pdev->dev, ha->fw_dump_tmplt_size,
398068237c8STej Parkash md_tmp, md_tmp_dma);
399068237c8STej Parkash }
400068237c8STej Parkash
qla4xxx_fw_ready(struct scsi_qla_host * ha)401afaf5a2dSDavid Somayajulu static int qla4xxx_fw_ready(struct scsi_qla_host *ha)
402afaf5a2dSDavid Somayajulu {
403afaf5a2dSDavid Somayajulu uint32_t timeout_count;
404afaf5a2dSDavid Somayajulu int ready = 0;
405afaf5a2dSDavid Somayajulu
406c2660df3SVikas Chaudhary DEBUG2(ql4_printk(KERN_INFO, ha, "Waiting for Firmware Ready..\n"));
407afaf5a2dSDavid Somayajulu for (timeout_count = ADAPTER_INIT_TOV; timeout_count > 0;
408afaf5a2dSDavid Somayajulu timeout_count--) {
409afaf5a2dSDavid Somayajulu if (test_and_clear_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags))
410afaf5a2dSDavid Somayajulu qla4xxx_get_dhcp_ip_address(ha);
411afaf5a2dSDavid Somayajulu
412afaf5a2dSDavid Somayajulu /* Get firmware state. */
413afaf5a2dSDavid Somayajulu if (qla4xxx_get_firmware_state(ha) != QLA_SUCCESS) {
414afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: unable to get firmware "
415afaf5a2dSDavid Somayajulu "state\n", ha->host_no, __func__));
416afaf5a2dSDavid Somayajulu break;
417afaf5a2dSDavid Somayajulu }
418afaf5a2dSDavid Somayajulu
419afaf5a2dSDavid Somayajulu if (ha->firmware_state & FW_STATE_ERROR) {
420afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: an unrecoverable error has"
421afaf5a2dSDavid Somayajulu " occurred\n", ha->host_no, __func__));
422afaf5a2dSDavid Somayajulu break;
423afaf5a2dSDavid Somayajulu
424afaf5a2dSDavid Somayajulu }
425afaf5a2dSDavid Somayajulu if (ha->firmware_state & FW_STATE_CONFIG_WAIT) {
426afaf5a2dSDavid Somayajulu /*
427afaf5a2dSDavid Somayajulu * The firmware has not yet been issued an Initialize
428afaf5a2dSDavid Somayajulu * Firmware command, so issue it now.
429afaf5a2dSDavid Somayajulu */
430afaf5a2dSDavid Somayajulu if (qla4xxx_initialize_fw_cb(ha) == QLA_ERROR)
431afaf5a2dSDavid Somayajulu break;
432afaf5a2dSDavid Somayajulu
433afaf5a2dSDavid Somayajulu /* Go back and test for ready state - no wait. */
434afaf5a2dSDavid Somayajulu continue;
435afaf5a2dSDavid Somayajulu }
436afaf5a2dSDavid Somayajulu
4372a49a78eSVikas Chaudhary if (ha->firmware_state & FW_STATE_WAIT_AUTOCONNECT) {
4382a49a78eSVikas Chaudhary DEBUG2(printk(KERN_INFO "scsi%ld: %s: fwstate:"
4392a49a78eSVikas Chaudhary "AUTOCONNECT in progress\n",
4402a49a78eSVikas Chaudhary ha->host_no, __func__));
4412a49a78eSVikas Chaudhary }
4422a49a78eSVikas Chaudhary
4432a49a78eSVikas Chaudhary if (ha->firmware_state & FW_STATE_CONFIGURING_IP) {
4442a49a78eSVikas Chaudhary DEBUG2(printk(KERN_INFO "scsi%ld: %s: fwstate:"
4452a49a78eSVikas Chaudhary " CONFIGURING IP\n",
4462a49a78eSVikas Chaudhary ha->host_no, __func__));
4472a49a78eSVikas Chaudhary /*
4482a49a78eSVikas Chaudhary * Check for link state after 15 secs and if link is
4492a49a78eSVikas Chaudhary * still DOWN then, cable is unplugged. Ignore "DHCP
4502a49a78eSVikas Chaudhary * in Progress/CONFIGURING IP" bit to check if firmware
4512a49a78eSVikas Chaudhary * is in ready state or not after 15 secs.
4522a49a78eSVikas Chaudhary * This is applicable for both 2.x & 3.x firmware
4532a49a78eSVikas Chaudhary */
4542a49a78eSVikas Chaudhary if (timeout_count <= (ADAPTER_INIT_TOV - 15)) {
4552a49a78eSVikas Chaudhary if (ha->addl_fw_state & FW_ADDSTATE_LINK_UP) {
4562a49a78eSVikas Chaudhary DEBUG2(printk(KERN_INFO "scsi%ld: %s:"
4572a49a78eSVikas Chaudhary " LINK UP (Cable plugged)\n",
4582a49a78eSVikas Chaudhary ha->host_no, __func__));
4592a49a78eSVikas Chaudhary } else if (ha->firmware_state &
4602a49a78eSVikas Chaudhary (FW_STATE_CONFIGURING_IP |
4612a49a78eSVikas Chaudhary FW_STATE_READY)) {
4622a49a78eSVikas Chaudhary DEBUG2(printk(KERN_INFO "scsi%ld: %s: "
4632a49a78eSVikas Chaudhary "LINK DOWN (Cable unplugged)\n",
4642a49a78eSVikas Chaudhary ha->host_no, __func__));
4652a49a78eSVikas Chaudhary ha->firmware_state = FW_STATE_READY;
4662a49a78eSVikas Chaudhary }
4672a49a78eSVikas Chaudhary }
4682a49a78eSVikas Chaudhary }
4692a49a78eSVikas Chaudhary
470afaf5a2dSDavid Somayajulu if (ha->firmware_state == FW_STATE_READY) {
4712a49a78eSVikas Chaudhary /* If DHCP IP Addr is available, retrieve it now. */
4722a49a78eSVikas Chaudhary if (test_and_clear_bit(DPC_GET_DHCP_IP_ADDR,
4732a49a78eSVikas Chaudhary &ha->dpc_flags))
4742a49a78eSVikas Chaudhary qla4xxx_get_dhcp_ip_address(ha);
4752a49a78eSVikas Chaudhary
4762a49a78eSVikas Chaudhary if (!qla4xxx_wait_for_ip_config(ha) ||
4772a49a78eSVikas Chaudhary timeout_count == 1) {
478c2660df3SVikas Chaudhary DEBUG2(ql4_printk(KERN_INFO, ha,
4792a49a78eSVikas Chaudhary "Firmware Ready..\n"));
4802a49a78eSVikas Chaudhary /* The firmware is ready to process SCSI
4812a49a78eSVikas Chaudhary commands. */
482c2660df3SVikas Chaudhary DEBUG2(ql4_printk(KERN_INFO, ha,
4832a49a78eSVikas Chaudhary "scsi%ld: %s: MEDIA TYPE"
4842a49a78eSVikas Chaudhary " - %s\n", ha->host_no,
485afaf5a2dSDavid Somayajulu __func__, (ha->addl_fw_state &
486afaf5a2dSDavid Somayajulu FW_ADDSTATE_OPTICAL_MEDIA)
487afaf5a2dSDavid Somayajulu != 0 ? "OPTICAL" : "COPPER"));
488c2660df3SVikas Chaudhary DEBUG2(ql4_printk(KERN_INFO, ha,
4892a49a78eSVikas Chaudhary "scsi%ld: %s: DHCPv4 STATE"
4902a49a78eSVikas Chaudhary " Enabled %s\n", ha->host_no,
4912a49a78eSVikas Chaudhary __func__, (ha->addl_fw_state &
4922a49a78eSVikas Chaudhary FW_ADDSTATE_DHCPv4_ENABLED) != 0 ?
493afaf5a2dSDavid Somayajulu "YES" : "NO"));
494c2660df3SVikas Chaudhary DEBUG2(ql4_printk(KERN_INFO, ha,
495afaf5a2dSDavid Somayajulu "scsi%ld: %s: LINK %s\n",
496afaf5a2dSDavid Somayajulu ha->host_no, __func__,
497afaf5a2dSDavid Somayajulu (ha->addl_fw_state &
498afaf5a2dSDavid Somayajulu FW_ADDSTATE_LINK_UP) != 0 ?
499afaf5a2dSDavid Somayajulu "UP" : "DOWN"));
500c2660df3SVikas Chaudhary DEBUG2(ql4_printk(KERN_INFO, ha,
501afaf5a2dSDavid Somayajulu "scsi%ld: %s: iSNS Service "
502afaf5a2dSDavid Somayajulu "Started %s\n",
503afaf5a2dSDavid Somayajulu ha->host_no, __func__,
504afaf5a2dSDavid Somayajulu (ha->addl_fw_state &
505afaf5a2dSDavid Somayajulu FW_ADDSTATE_ISNS_SVC_ENABLED) != 0 ?
506afaf5a2dSDavid Somayajulu "YES" : "NO"));
507afaf5a2dSDavid Somayajulu
508afaf5a2dSDavid Somayajulu ready = 1;
509afaf5a2dSDavid Somayajulu break;
510afaf5a2dSDavid Somayajulu }
5112a49a78eSVikas Chaudhary }
512afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: waiting on fw, state=%x:%x - "
513afaf5a2dSDavid Somayajulu "seconds expired= %d\n", ha->host_no, __func__,
514afaf5a2dSDavid Somayajulu ha->firmware_state, ha->addl_fw_state,
515afaf5a2dSDavid Somayajulu timeout_count));
516d915058fSDavid C Somayajulu if (is_qla4032(ha) &&
517d915058fSDavid C Somayajulu !(ha->addl_fw_state & FW_ADDSTATE_LINK_UP) &&
518d915058fSDavid C Somayajulu (timeout_count < ADAPTER_INIT_TOV - 5)) {
519d915058fSDavid C Somayajulu break;
520d915058fSDavid C Somayajulu }
521d915058fSDavid C Somayajulu
522afaf5a2dSDavid Somayajulu msleep(1000);
523afaf5a2dSDavid Somayajulu } /* end of for */
524afaf5a2dSDavid Somayajulu
5252a49a78eSVikas Chaudhary if (timeout_count <= 0)
526afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: FW Initialization timed out!\n",
527afaf5a2dSDavid Somayajulu ha->host_no, __func__));
528afaf5a2dSDavid Somayajulu
5292a49a78eSVikas Chaudhary if (ha->firmware_state & FW_STATE_CONFIGURING_IP) {
5302a49a78eSVikas Chaudhary DEBUG2(printk("scsi%ld: %s: FW initialized, but is reporting "
5312a49a78eSVikas Chaudhary "it's waiting to configure an IP address\n",
532afaf5a2dSDavid Somayajulu ha->host_no, __func__));
533afaf5a2dSDavid Somayajulu ready = 1;
5342a49a78eSVikas Chaudhary } else if (ha->firmware_state & FW_STATE_WAIT_AUTOCONNECT) {
5352a49a78eSVikas Chaudhary DEBUG2(printk("scsi%ld: %s: FW initialized, but "
5362a49a78eSVikas Chaudhary "auto-discovery still in process\n",
5372a49a78eSVikas Chaudhary ha->host_no, __func__));
538b966346cSVikas Chaudhary ready = 1;
539afaf5a2dSDavid Somayajulu }
540afaf5a2dSDavid Somayajulu
541afaf5a2dSDavid Somayajulu return ready;
542afaf5a2dSDavid Somayajulu }
543afaf5a2dSDavid Somayajulu
544afaf5a2dSDavid Somayajulu /**
545afaf5a2dSDavid Somayajulu * qla4xxx_init_firmware - initializes the firmware.
546afaf5a2dSDavid Somayajulu * @ha: pointer to host adapter structure.
547afaf5a2dSDavid Somayajulu *
548afaf5a2dSDavid Somayajulu **/
qla4xxx_init_firmware(struct scsi_qla_host * ha)549afaf5a2dSDavid Somayajulu static int qla4xxx_init_firmware(struct scsi_qla_host *ha)
550afaf5a2dSDavid Somayajulu {
551afaf5a2dSDavid Somayajulu int status = QLA_ERROR;
552afaf5a2dSDavid Somayajulu
5532232be0dSLalit Chandivade if (is_aer_supported(ha) &&
5542232be0dSLalit Chandivade test_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags))
5552232be0dSLalit Chandivade return status;
5562232be0dSLalit Chandivade
5579d4946f8SLalit Chandivade /* For 82xx, stop firmware before initializing because if BIOS
5589d4946f8SLalit Chandivade * has previously initialized firmware, then driver's initialize
5599d4946f8SLalit Chandivade * firmware will fail. */
5606e7b4292SVikas Chaudhary if (is_qla80XX(ha))
5619d4946f8SLalit Chandivade qla4_8xxx_stop_firmware(ha);
5629d4946f8SLalit Chandivade
563c2660df3SVikas Chaudhary ql4_printk(KERN_INFO, ha, "Initializing firmware..\n");
564afaf5a2dSDavid Somayajulu if (qla4xxx_initialize_fw_cb(ha) == QLA_ERROR) {
565afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: Failed to initialize firmware "
566afaf5a2dSDavid Somayajulu "control block\n", ha->host_no, __func__));
567afaf5a2dSDavid Somayajulu return status;
568afaf5a2dSDavid Somayajulu }
569068237c8STej Parkash
570afaf5a2dSDavid Somayajulu if (!qla4xxx_fw_ready(ha))
571afaf5a2dSDavid Somayajulu return status;
572afaf5a2dSDavid Somayajulu
5736e7b4292SVikas Chaudhary if (is_qla80XX(ha) && !test_bit(AF_INIT_DONE, &ha->flags))
574068237c8STej Parkash qla4xxx_alloc_fw_dump(ha);
575068237c8STej Parkash
576afaf5a2dSDavid Somayajulu return qla4xxx_get_firmware_status(ha);
577afaf5a2dSDavid Somayajulu }
578afaf5a2dSDavid Somayajulu
qla4xxx_set_model_info(struct scsi_qla_host * ha)57991ec7cecSVikas Chaudhary static void qla4xxx_set_model_info(struct scsi_qla_host *ha)
58091ec7cecSVikas Chaudhary {
58191ec7cecSVikas Chaudhary uint16_t board_id_string[8];
58291ec7cecSVikas Chaudhary int i;
58391ec7cecSVikas Chaudhary int size = sizeof(ha->nvram->isp4022.boardIdStr);
58491ec7cecSVikas Chaudhary int offset = offsetof(struct eeprom_data, isp4022.boardIdStr) / 2;
58591ec7cecSVikas Chaudhary
58691ec7cecSVikas Chaudhary for (i = 0; i < (size / 2) ; i++) {
58791ec7cecSVikas Chaudhary board_id_string[i] = rd_nvram_word(ha, offset);
58891ec7cecSVikas Chaudhary offset += 1;
58991ec7cecSVikas Chaudhary }
59091ec7cecSVikas Chaudhary
59191ec7cecSVikas Chaudhary memcpy(ha->model_name, board_id_string, size);
59291ec7cecSVikas Chaudhary }
59391ec7cecSVikas Chaudhary
qla4xxx_config_nvram(struct scsi_qla_host * ha)594afaf5a2dSDavid Somayajulu static int qla4xxx_config_nvram(struct scsi_qla_host *ha)
595afaf5a2dSDavid Somayajulu {
596afaf5a2dSDavid Somayajulu unsigned long flags;
597afaf5a2dSDavid Somayajulu union external_hw_config_reg extHwConfig;
598afaf5a2dSDavid Somayajulu
599afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: Get EEProm parameters \n", ha->host_no,
600afaf5a2dSDavid Somayajulu __func__));
601afaf5a2dSDavid Somayajulu if (ql4xxx_lock_flash(ha) != QLA_SUCCESS)
602b3925514SMike Christie return QLA_ERROR;
603afaf5a2dSDavid Somayajulu if (ql4xxx_lock_nvram(ha) != QLA_SUCCESS) {
604afaf5a2dSDavid Somayajulu ql4xxx_unlock_flash(ha);
605b3925514SMike Christie return QLA_ERROR;
606afaf5a2dSDavid Somayajulu }
607afaf5a2dSDavid Somayajulu
608afaf5a2dSDavid Somayajulu /* Get EEPRom Parameters from NVRAM and validate */
609c2660df3SVikas Chaudhary ql4_printk(KERN_INFO, ha, "Configuring NVRAM ...\n");
610afaf5a2dSDavid Somayajulu if (qla4xxx_is_nvram_configuration_valid(ha) == QLA_SUCCESS) {
611afaf5a2dSDavid Somayajulu spin_lock_irqsave(&ha->hardware_lock, flags);
612afaf5a2dSDavid Somayajulu extHwConfig.Asuint32_t =
613afaf5a2dSDavid Somayajulu rd_nvram_word(ha, eeprom_ext_hw_conf_offset(ha));
614afaf5a2dSDavid Somayajulu spin_unlock_irqrestore(&ha->hardware_lock, flags);
615afaf5a2dSDavid Somayajulu } else {
616c2660df3SVikas Chaudhary ql4_printk(KERN_WARNING, ha,
617afaf5a2dSDavid Somayajulu "scsi%ld: %s: EEProm checksum invalid. "
618afaf5a2dSDavid Somayajulu "Please update your EEPROM\n", ha->host_no,
619afaf5a2dSDavid Somayajulu __func__);
620afaf5a2dSDavid Somayajulu
621b3925514SMike Christie /* Attempt to set defaults */
622afaf5a2dSDavid Somayajulu if (is_qla4010(ha))
623afaf5a2dSDavid Somayajulu extHwConfig.Asuint32_t = 0x1912;
624d915058fSDavid C Somayajulu else if (is_qla4022(ha) | is_qla4032(ha))
625afaf5a2dSDavid Somayajulu extHwConfig.Asuint32_t = 0x0023;
626b3925514SMike Christie else
627b3925514SMike Christie return QLA_ERROR;
628afaf5a2dSDavid Somayajulu }
62991ec7cecSVikas Chaudhary
63091ec7cecSVikas Chaudhary if (is_qla4022(ha) || is_qla4032(ha))
63191ec7cecSVikas Chaudhary qla4xxx_set_model_info(ha);
63291ec7cecSVikas Chaudhary else
63391ec7cecSVikas Chaudhary strcpy(ha->model_name, "QLA4010");
63491ec7cecSVikas Chaudhary
635afaf5a2dSDavid Somayajulu DEBUG(printk("scsi%ld: %s: Setting extHwConfig to 0xFFFF%04x\n",
636afaf5a2dSDavid Somayajulu ha->host_no, __func__, extHwConfig.Asuint32_t));
637afaf5a2dSDavid Somayajulu
638afaf5a2dSDavid Somayajulu spin_lock_irqsave(&ha->hardware_lock, flags);
639afaf5a2dSDavid Somayajulu writel((0xFFFF << 16) | extHwConfig.Asuint32_t, isp_ext_hw_conf(ha));
640afaf5a2dSDavid Somayajulu readl(isp_ext_hw_conf(ha));
641afaf5a2dSDavid Somayajulu spin_unlock_irqrestore(&ha->hardware_lock, flags);
642afaf5a2dSDavid Somayajulu
643afaf5a2dSDavid Somayajulu ql4xxx_unlock_nvram(ha);
644afaf5a2dSDavid Somayajulu ql4xxx_unlock_flash(ha);
645afaf5a2dSDavid Somayajulu
646b3925514SMike Christie return QLA_SUCCESS;
647afaf5a2dSDavid Somayajulu }
648afaf5a2dSDavid Somayajulu
649f4f5df23SVikas Chaudhary /**
650f4f5df23SVikas Chaudhary * qla4_8xxx_pci_config() - Setup ISP82xx PCI configuration registers.
651f4f5df23SVikas Chaudhary * @ha: HA context
652f4f5df23SVikas Chaudhary */
qla4_8xxx_pci_config(struct scsi_qla_host * ha)653f4f5df23SVikas Chaudhary void qla4_8xxx_pci_config(struct scsi_qla_host *ha)
654f4f5df23SVikas Chaudhary {
655f4f5df23SVikas Chaudhary pci_set_master(ha->pdev);
656f4f5df23SVikas Chaudhary }
657f4f5df23SVikas Chaudhary
qla4xxx_pci_config(struct scsi_qla_host * ha)658f4f5df23SVikas Chaudhary void qla4xxx_pci_config(struct scsi_qla_host *ha)
659afaf5a2dSDavid Somayajulu {
66092b72736SDavid C Somayajulu uint16_t w;
66146235e60SDavid C Somayajulu int status;
662afaf5a2dSDavid Somayajulu
663c2660df3SVikas Chaudhary ql4_printk(KERN_INFO, ha, "Configuring PCI space...\n");
664afaf5a2dSDavid Somayajulu
665afaf5a2dSDavid Somayajulu pci_set_master(ha->pdev);
66646235e60SDavid C Somayajulu status = pci_set_mwi(ha->pdev);
667b8544600SLee Jones if (status)
668b8544600SLee Jones ql4_printk(KERN_WARNING, ha, "Failed to set MWI\n");
669b8544600SLee Jones
670afaf5a2dSDavid Somayajulu /*
671afaf5a2dSDavid Somayajulu * We want to respect framework's setting of PCI configuration space
672afaf5a2dSDavid Somayajulu * command register and also want to make sure that all bits of
673afaf5a2dSDavid Somayajulu * interest to us are properly set in command register.
674afaf5a2dSDavid Somayajulu */
675afaf5a2dSDavid Somayajulu pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
67692b72736SDavid C Somayajulu w |= PCI_COMMAND_PARITY | PCI_COMMAND_SERR;
677afaf5a2dSDavid Somayajulu w &= ~PCI_COMMAND_INTX_DISABLE;
678afaf5a2dSDavid Somayajulu pci_write_config_word(ha->pdev, PCI_COMMAND, w);
679afaf5a2dSDavid Somayajulu }
680afaf5a2dSDavid Somayajulu
qla4xxx_start_firmware_from_flash(struct scsi_qla_host * ha)681afaf5a2dSDavid Somayajulu static int qla4xxx_start_firmware_from_flash(struct scsi_qla_host *ha)
682afaf5a2dSDavid Somayajulu {
683afaf5a2dSDavid Somayajulu int status = QLA_ERROR;
684c301b026SVikas Chaudhary unsigned long max_wait_time;
685afaf5a2dSDavid Somayajulu unsigned long flags;
686afaf5a2dSDavid Somayajulu uint32_t mbox_status;
687afaf5a2dSDavid Somayajulu
688c2660df3SVikas Chaudhary ql4_printk(KERN_INFO, ha, "Starting firmware ...\n");
689afaf5a2dSDavid Somayajulu
690afaf5a2dSDavid Somayajulu /*
691afaf5a2dSDavid Somayajulu * Start firmware from flash ROM
692afaf5a2dSDavid Somayajulu *
693afaf5a2dSDavid Somayajulu * WORKAROUND: Stuff a non-constant value that the firmware can
694afaf5a2dSDavid Somayajulu * use as a seed for a random number generator in MB7 prior to
695afaf5a2dSDavid Somayajulu * setting BOOT_ENABLE. Fixes problem where the TCP
696afaf5a2dSDavid Somayajulu * connections use the same TCP ports after each reboot,
697afaf5a2dSDavid Somayajulu * causing some connections to not get re-established.
698afaf5a2dSDavid Somayajulu */
699afaf5a2dSDavid Somayajulu DEBUG(printk("scsi%d: %s: Start firmware from flash ROM\n",
700afaf5a2dSDavid Somayajulu ha->host_no, __func__));
701afaf5a2dSDavid Somayajulu
702afaf5a2dSDavid Somayajulu spin_lock_irqsave(&ha->hardware_lock, flags);
703afaf5a2dSDavid Somayajulu writel(jiffies, &ha->reg->mailbox[7]);
704d915058fSDavid C Somayajulu if (is_qla4022(ha) | is_qla4032(ha))
705afaf5a2dSDavid Somayajulu writel(set_rmask(NVR_WRITE_ENABLE),
706afaf5a2dSDavid Somayajulu &ha->reg->u1.isp4022.nvram);
707afaf5a2dSDavid Somayajulu
70892b72736SDavid C Somayajulu writel(2, &ha->reg->mailbox[6]);
70992b72736SDavid C Somayajulu readl(&ha->reg->mailbox[6]);
71092b72736SDavid C Somayajulu
711afaf5a2dSDavid Somayajulu writel(set_rmask(CSR_BOOT_ENABLE), &ha->reg->ctrl_status);
712afaf5a2dSDavid Somayajulu readl(&ha->reg->ctrl_status);
713afaf5a2dSDavid Somayajulu spin_unlock_irqrestore(&ha->hardware_lock, flags);
714afaf5a2dSDavid Somayajulu
715afaf5a2dSDavid Somayajulu /* Wait for firmware to come UP. */
716c301b026SVikas Chaudhary DEBUG2(printk(KERN_INFO "scsi%ld: %s: Wait up to %d seconds for "
717c301b026SVikas Chaudhary "boot firmware to complete...\n",
718c301b026SVikas Chaudhary ha->host_no, __func__, FIRMWARE_UP_TOV));
719c301b026SVikas Chaudhary max_wait_time = jiffies + (FIRMWARE_UP_TOV * HZ);
720afaf5a2dSDavid Somayajulu do {
721afaf5a2dSDavid Somayajulu uint32_t ctrl_status;
722afaf5a2dSDavid Somayajulu
723afaf5a2dSDavid Somayajulu spin_lock_irqsave(&ha->hardware_lock, flags);
724afaf5a2dSDavid Somayajulu ctrl_status = readw(&ha->reg->ctrl_status);
725afaf5a2dSDavid Somayajulu mbox_status = readw(&ha->reg->mailbox[0]);
726afaf5a2dSDavid Somayajulu spin_unlock_irqrestore(&ha->hardware_lock, flags);
727afaf5a2dSDavid Somayajulu
728afaf5a2dSDavid Somayajulu if (ctrl_status & set_rmask(CSR_SCSI_PROCESSOR_INTR))
729afaf5a2dSDavid Somayajulu break;
730afaf5a2dSDavid Somayajulu if (mbox_status == MBOX_STS_COMMAND_COMPLETE)
731afaf5a2dSDavid Somayajulu break;
732afaf5a2dSDavid Somayajulu
733c301b026SVikas Chaudhary DEBUG2(printk(KERN_INFO "scsi%ld: %s: Waiting for boot "
734f581a3f7SVikas Chaudhary "firmware to complete... ctrl_sts=0x%x, remaining=%ld\n",
735f581a3f7SVikas Chaudhary ha->host_no, __func__, ctrl_status, max_wait_time));
736afaf5a2dSDavid Somayajulu
737c301b026SVikas Chaudhary msleep_interruptible(250);
738c301b026SVikas Chaudhary } while (!time_after_eq(jiffies, max_wait_time));
739afaf5a2dSDavid Somayajulu
740afaf5a2dSDavid Somayajulu if (mbox_status == MBOX_STS_COMMAND_COMPLETE) {
741c301b026SVikas Chaudhary DEBUG(printk(KERN_INFO "scsi%ld: %s: Firmware has started\n",
742afaf5a2dSDavid Somayajulu ha->host_no, __func__));
743afaf5a2dSDavid Somayajulu
744afaf5a2dSDavid Somayajulu spin_lock_irqsave(&ha->hardware_lock, flags);
745afaf5a2dSDavid Somayajulu writel(set_rmask(CSR_SCSI_PROCESSOR_INTR),
746afaf5a2dSDavid Somayajulu &ha->reg->ctrl_status);
747afaf5a2dSDavid Somayajulu readl(&ha->reg->ctrl_status);
748afaf5a2dSDavid Somayajulu spin_unlock_irqrestore(&ha->hardware_lock, flags);
749afaf5a2dSDavid Somayajulu
750afaf5a2dSDavid Somayajulu status = QLA_SUCCESS;
751afaf5a2dSDavid Somayajulu } else {
752afaf5a2dSDavid Somayajulu printk(KERN_INFO "scsi%ld: %s: Boot firmware failed "
753afaf5a2dSDavid Somayajulu "- mbox status 0x%x\n", ha->host_no, __func__,
754afaf5a2dSDavid Somayajulu mbox_status);
755afaf5a2dSDavid Somayajulu status = QLA_ERROR;
756afaf5a2dSDavid Somayajulu }
757afaf5a2dSDavid Somayajulu return status;
758afaf5a2dSDavid Somayajulu }
759afaf5a2dSDavid Somayajulu
ql4xxx_lock_drvr_wait(struct scsi_qla_host * a)76092b72736SDavid C Somayajulu int ql4xxx_lock_drvr_wait(struct scsi_qla_host *a)
761afaf5a2dSDavid Somayajulu {
76292b72736SDavid C Somayajulu #define QL4_LOCK_DRVR_WAIT 60
763477ffb9dSDavid C Somayajulu #define QL4_LOCK_DRVR_SLEEP 1
764afaf5a2dSDavid Somayajulu
765afaf5a2dSDavid Somayajulu int drvr_wait = QL4_LOCK_DRVR_WAIT;
766afaf5a2dSDavid Somayajulu while (drvr_wait) {
76792b72736SDavid C Somayajulu if (ql4xxx_lock_drvr(a) == 0) {
768477ffb9dSDavid C Somayajulu ssleep(QL4_LOCK_DRVR_SLEEP);
769afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: Waiting for "
77092b72736SDavid C Somayajulu "Global Init Semaphore(%d)...\n",
77192b72736SDavid C Somayajulu a->host_no,
772477ffb9dSDavid C Somayajulu __func__, drvr_wait));
773afaf5a2dSDavid Somayajulu drvr_wait -= QL4_LOCK_DRVR_SLEEP;
774afaf5a2dSDavid Somayajulu } else {
775afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: Global Init Semaphore "
77692b72736SDavid C Somayajulu "acquired\n", a->host_no, __func__));
777afaf5a2dSDavid Somayajulu return QLA_SUCCESS;
778afaf5a2dSDavid Somayajulu }
779afaf5a2dSDavid Somayajulu }
780afaf5a2dSDavid Somayajulu return QLA_ERROR;
781afaf5a2dSDavid Somayajulu }
782afaf5a2dSDavid Somayajulu
783afaf5a2dSDavid Somayajulu /**
784afaf5a2dSDavid Somayajulu * qla4xxx_start_firmware - starts qla4xxx firmware
785afaf5a2dSDavid Somayajulu * @ha: Pointer to host adapter structure.
786afaf5a2dSDavid Somayajulu *
7873a4fa0a2SRobert P. J. Day * This routine performs the necessary steps to start the firmware for
788afaf5a2dSDavid Somayajulu * the QLA4010 adapter.
789afaf5a2dSDavid Somayajulu **/
qla4xxx_start_firmware(struct scsi_qla_host * ha)790f4f5df23SVikas Chaudhary int qla4xxx_start_firmware(struct scsi_qla_host *ha)
791afaf5a2dSDavid Somayajulu {
792afaf5a2dSDavid Somayajulu unsigned long flags = 0;
793afaf5a2dSDavid Somayajulu uint32_t mbox_status;
794afaf5a2dSDavid Somayajulu int status = QLA_ERROR;
795afaf5a2dSDavid Somayajulu int soft_reset = 1;
796afaf5a2dSDavid Somayajulu int config_chip = 0;
797afaf5a2dSDavid Somayajulu
798d915058fSDavid C Somayajulu if (is_qla4022(ha) | is_qla4032(ha))
799afaf5a2dSDavid Somayajulu ql4xxx_set_mac_number(ha);
800afaf5a2dSDavid Somayajulu
801afaf5a2dSDavid Somayajulu if (ql4xxx_lock_drvr_wait(ha) != QLA_SUCCESS)
802afaf5a2dSDavid Somayajulu return QLA_ERROR;
803afaf5a2dSDavid Somayajulu
804afaf5a2dSDavid Somayajulu spin_lock_irqsave(&ha->hardware_lock, flags);
805afaf5a2dSDavid Somayajulu
806afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: port_ctrl = 0x%08X\n", ha->host_no,
807afaf5a2dSDavid Somayajulu __func__, readw(isp_port_ctrl(ha))));
808afaf5a2dSDavid Somayajulu DEBUG(printk("scsi%ld: %s: port_status = 0x%08X\n", ha->host_no,
809afaf5a2dSDavid Somayajulu __func__, readw(isp_port_status(ha))));
810afaf5a2dSDavid Somayajulu
811afaf5a2dSDavid Somayajulu /* Is Hardware already initialized? */
812afaf5a2dSDavid Somayajulu if ((readw(isp_port_ctrl(ha)) & 0x8000) != 0) {
813afaf5a2dSDavid Somayajulu DEBUG(printk("scsi%ld: %s: Hardware has already been "
814afaf5a2dSDavid Somayajulu "initialized\n", ha->host_no, __func__));
815afaf5a2dSDavid Somayajulu
816afaf5a2dSDavid Somayajulu /* Receive firmware boot acknowledgement */
817afaf5a2dSDavid Somayajulu mbox_status = readw(&ha->reg->mailbox[0]);
818afaf5a2dSDavid Somayajulu
819afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: H/W Config complete - mbox[0]= "
820afaf5a2dSDavid Somayajulu "0x%x\n", ha->host_no, __func__, mbox_status));
821afaf5a2dSDavid Somayajulu
822afaf5a2dSDavid Somayajulu /* Is firmware already booted? */
823afaf5a2dSDavid Somayajulu if (mbox_status == 0) {
824afaf5a2dSDavid Somayajulu /* F/W not running, must be config by net driver */
825afaf5a2dSDavid Somayajulu config_chip = 1;
826afaf5a2dSDavid Somayajulu soft_reset = 0;
827afaf5a2dSDavid Somayajulu } else {
828afaf5a2dSDavid Somayajulu writel(set_rmask(CSR_SCSI_PROCESSOR_INTR),
829afaf5a2dSDavid Somayajulu &ha->reg->ctrl_status);
830afaf5a2dSDavid Somayajulu readl(&ha->reg->ctrl_status);
83178764999SSarang Radke writel(set_rmask(CSR_SCSI_COMPLETION_INTR),
83278764999SSarang Radke &ha->reg->ctrl_status);
83378764999SSarang Radke readl(&ha->reg->ctrl_status);
834afaf5a2dSDavid Somayajulu spin_unlock_irqrestore(&ha->hardware_lock, flags);
835afaf5a2dSDavid Somayajulu if (qla4xxx_get_firmware_state(ha) == QLA_SUCCESS) {
836afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: Get firmware "
837afaf5a2dSDavid Somayajulu "state -- state = 0x%x\n",
838afaf5a2dSDavid Somayajulu ha->host_no,
839afaf5a2dSDavid Somayajulu __func__, ha->firmware_state));
840afaf5a2dSDavid Somayajulu /* F/W is running */
841afaf5a2dSDavid Somayajulu if (ha->firmware_state &
842afaf5a2dSDavid Somayajulu FW_STATE_CONFIG_WAIT) {
843afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: Firmware "
844afaf5a2dSDavid Somayajulu "in known state -- "
845afaf5a2dSDavid Somayajulu "config and "
846afaf5a2dSDavid Somayajulu "boot, state = 0x%x\n",
847afaf5a2dSDavid Somayajulu ha->host_no, __func__,
848afaf5a2dSDavid Somayajulu ha->firmware_state));
849afaf5a2dSDavid Somayajulu config_chip = 1;
850afaf5a2dSDavid Somayajulu soft_reset = 0;
851afaf5a2dSDavid Somayajulu }
852afaf5a2dSDavid Somayajulu } else {
853afaf5a2dSDavid Somayajulu DEBUG2(printk("scsi%ld: %s: Firmware in "
854afaf5a2dSDavid Somayajulu "unknown state -- resetting,"
855afaf5a2dSDavid Somayajulu " state = "
856afaf5a2dSDavid Somayajulu "0x%x\n", ha->host_no, __func__,
857afaf5a2dSDavid Somayajulu ha->firmware_state));
858afaf5a2dSDavid Somayajulu }
859afaf5a2dSDavid Somayajulu spin_lock_irqsave(&ha->hardware_lock, flags);
860afaf5a2dSDavid Somayajulu }
861afaf5a2dSDavid Somayajulu } else {
862afaf5a2dSDavid Somayajulu DEBUG(printk("scsi%ld: %s: H/W initialization hasn't been "
863afaf5a2dSDavid Somayajulu "started - resetting\n", ha->host_no, __func__));
864afaf5a2dSDavid Somayajulu }
865afaf5a2dSDavid Somayajulu spin_unlock_irqrestore(&ha->hardware_lock, flags);
866afaf5a2dSDavid Somayajulu
867afaf5a2dSDavid Somayajulu DEBUG(printk("scsi%ld: %s: Flags soft_rest=%d, config= %d\n ",
868afaf5a2dSDavid Somayajulu ha->host_no, __func__, soft_reset, config_chip));
869afaf5a2dSDavid Somayajulu if (soft_reset) {
870afaf5a2dSDavid Somayajulu DEBUG(printk("scsi%ld: %s: Issue Soft Reset\n", ha->host_no,
871afaf5a2dSDavid Somayajulu __func__));
872f4f5df23SVikas Chaudhary status = qla4xxx_soft_reset(ha); /* NOTE: acquires drvr
873f4f5df23SVikas Chaudhary * lock again, but ok */
874afaf5a2dSDavid Somayajulu if (status == QLA_ERROR) {
875afaf5a2dSDavid Somayajulu DEBUG(printk("scsi%d: %s: Soft Reset failed!\n",
876afaf5a2dSDavid Somayajulu ha->host_no, __func__));
877afaf5a2dSDavid Somayajulu ql4xxx_unlock_drvr(ha);
878afaf5a2dSDavid Somayajulu return QLA_ERROR;
879afaf5a2dSDavid Somayajulu }
880afaf5a2dSDavid Somayajulu config_chip = 1;
881afaf5a2dSDavid Somayajulu
882b1c11812SJoe Perches /* Reset clears the semaphore, so acquire again */
883afaf5a2dSDavid Somayajulu if (ql4xxx_lock_drvr_wait(ha) != QLA_SUCCESS)
884afaf5a2dSDavid Somayajulu return QLA_ERROR;
885afaf5a2dSDavid Somayajulu }
886afaf5a2dSDavid Somayajulu
887afaf5a2dSDavid Somayajulu if (config_chip) {
888afaf5a2dSDavid Somayajulu if ((status = qla4xxx_config_nvram(ha)) == QLA_SUCCESS)
889afaf5a2dSDavid Somayajulu status = qla4xxx_start_firmware_from_flash(ha);
890afaf5a2dSDavid Somayajulu }
891afaf5a2dSDavid Somayajulu
892afaf5a2dSDavid Somayajulu ql4xxx_unlock_drvr(ha);
893afaf5a2dSDavid Somayajulu if (status == QLA_SUCCESS) {
894afaf5a2dSDavid Somayajulu if (test_and_clear_bit(AF_GET_CRASH_RECORD, &ha->flags))
895afaf5a2dSDavid Somayajulu qla4xxx_get_crash_record(ha);
896aa6db9b9SVikas Chaudhary
897aa6db9b9SVikas Chaudhary qla4xxx_init_rings(ha);
898afaf5a2dSDavid Somayajulu } else {
899afaf5a2dSDavid Somayajulu DEBUG(printk("scsi%ld: %s: Firmware has NOT started\n",
900afaf5a2dSDavid Somayajulu ha->host_no, __func__));
901afaf5a2dSDavid Somayajulu }
902afaf5a2dSDavid Somayajulu return status;
903afaf5a2dSDavid Somayajulu }
904166dd20dSLalit Chandivade /**
905166dd20dSLalit Chandivade * qla4xxx_free_ddb_index - Free DDBs reserved by firmware
906166dd20dSLalit Chandivade * @ha: pointer to adapter structure
907166dd20dSLalit Chandivade *
908166dd20dSLalit Chandivade * Since firmware is not running in autoconnect mode the DDB indices should
909166dd20dSLalit Chandivade * be freed so that when login happens from user space there are free DDB
910166dd20dSLalit Chandivade * indices available.
911166dd20dSLalit Chandivade **/
qla4xxx_free_ddb_index(struct scsi_qla_host * ha)91213483730SMike Christie void qla4xxx_free_ddb_index(struct scsi_qla_host *ha)
913166dd20dSLalit Chandivade {
914166dd20dSLalit Chandivade int max_ddbs;
915166dd20dSLalit Chandivade int ret;
916166dd20dSLalit Chandivade uint32_t idx = 0, next_idx = 0;
917166dd20dSLalit Chandivade uint32_t state = 0, conn_err = 0;
918166dd20dSLalit Chandivade
91913483730SMike Christie max_ddbs = is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
920166dd20dSLalit Chandivade MAX_DEV_DB_ENTRIES;
921166dd20dSLalit Chandivade
922166dd20dSLalit Chandivade for (idx = 0; idx < max_ddbs; idx = next_idx) {
923166dd20dSLalit Chandivade ret = qla4xxx_get_fwddb_entry(ha, idx, NULL, 0, NULL,
924166dd20dSLalit Chandivade &next_idx, &state, &conn_err,
925166dd20dSLalit Chandivade NULL, NULL);
926e1cd89c5STomas Henzl if (ret == QLA_ERROR) {
927e1cd89c5STomas Henzl next_idx++;
928166dd20dSLalit Chandivade continue;
929e1cd89c5STomas Henzl }
930166dd20dSLalit Chandivade if (state == DDB_DS_NO_CONNECTION_ACTIVE ||
931166dd20dSLalit Chandivade state == DDB_DS_SESSION_FAILED) {
932166dd20dSLalit Chandivade DEBUG2(ql4_printk(KERN_INFO, ha,
933166dd20dSLalit Chandivade "Freeing DDB index = 0x%x\n", idx));
934166dd20dSLalit Chandivade ret = qla4xxx_clear_ddb_entry(ha, idx);
935166dd20dSLalit Chandivade if (ret == QLA_ERROR)
936166dd20dSLalit Chandivade ql4_printk(KERN_ERR, ha,
937166dd20dSLalit Chandivade "Unable to clear DDB index = "
938166dd20dSLalit Chandivade "0x%x\n", idx);
939166dd20dSLalit Chandivade }
940166dd20dSLalit Chandivade if (next_idx == 0)
941166dd20dSLalit Chandivade break;
942166dd20dSLalit Chandivade }
943166dd20dSLalit Chandivade }
944afaf5a2dSDavid Somayajulu
945afaf5a2dSDavid Somayajulu /**
946afaf5a2dSDavid Somayajulu * qla4xxx_initialize_adapter - initiailizes hba
947afaf5a2dSDavid Somayajulu * @ha: Pointer to host adapter structure.
9487ec772d0SLee Jones * @is_reset: Is this init path or reset path
949afaf5a2dSDavid Somayajulu *
950afaf5a2dSDavid Somayajulu * This routine parforms all of the steps necessary to initialize the adapter.
951afaf5a2dSDavid Somayajulu *
952afaf5a2dSDavid Somayajulu **/
qla4xxx_initialize_adapter(struct scsi_qla_host * ha,int is_reset)95313483730SMike Christie int qla4xxx_initialize_adapter(struct scsi_qla_host *ha, int is_reset)
954afaf5a2dSDavid Somayajulu {
955afaf5a2dSDavid Somayajulu int status = QLA_ERROR;
956afaf5a2dSDavid Somayajulu
957afaf5a2dSDavid Somayajulu ha->eeprom_cmd_data = 0;
958afaf5a2dSDavid Somayajulu
959f4f5df23SVikas Chaudhary ql4_printk(KERN_INFO, ha, "Configuring PCI space...\n");
960f4f5df23SVikas Chaudhary ha->isp_ops->pci_config(ha);
961afaf5a2dSDavid Somayajulu
962f4f5df23SVikas Chaudhary ha->isp_ops->disable_intrs(ha);
963afaf5a2dSDavid Somayajulu
964afaf5a2dSDavid Somayajulu /* Initialize the Host adapter request/response queues and firmware */
965f4f5df23SVikas Chaudhary if (ha->isp_ops->start_firmware(ha) == QLA_ERROR)
96646235e60SDavid C Somayajulu goto exit_init_hba;
967afaf5a2dSDavid Somayajulu
9685c19b92aSVikas Chaudhary /*
9695c19b92aSVikas Chaudhary * For ISP83XX, mailbox and IOCB interrupts are enabled separately.
9705c19b92aSVikas Chaudhary * Mailbox interrupts must be enabled prior to issuing any mailbox
9715c19b92aSVikas Chaudhary * command in order to prevent the possibility of losing interrupts
9725c19b92aSVikas Chaudhary * while switching from polling to interrupt mode. IOCB interrupts are
9735c19b92aSVikas Chaudhary * enabled via isp_ops->enable_intrs.
9745c19b92aSVikas Chaudhary */
975b37ca418SVikas Chaudhary if (is_qla8032(ha) || is_qla8042(ha))
9765c19b92aSVikas Chaudhary qla4_83xx_enable_mbox_intrs(ha);
9775c19b92aSVikas Chaudhary
9787ad633c0SHarish Zunjarrao if (qla4xxx_about_firmware(ha) == QLA_ERROR)
979f4f5df23SVikas Chaudhary goto exit_init_hba;
980f4f5df23SVikas Chaudhary
981f4f5df23SVikas Chaudhary if (ha->isp_ops->get_sys_info(ha) == QLA_ERROR)
98246235e60SDavid C Somayajulu goto exit_init_hba;
983afaf5a2dSDavid Somayajulu
984ff4108dcSKaren Higgins qla4xxx_init_local_data(ha);
985afaf5a2dSDavid Somayajulu
986afaf5a2dSDavid Somayajulu status = qla4xxx_init_firmware(ha);
987afaf5a2dSDavid Somayajulu if (status == QLA_ERROR)
98846235e60SDavid C Somayajulu goto exit_init_hba;
989afaf5a2dSDavid Somayajulu
99013483730SMike Christie if (is_reset == RESET_ADAPTER)
99113483730SMike Christie qla4xxx_build_ddb_list(ha, is_reset);
992166dd20dSLalit Chandivade
99392b72736SDavid C Somayajulu set_bit(AF_ONLINE, &ha->flags);
9943710c60cSVikas Chaudhary
99537418cc6SNilesh Javali exit_init_hba:
996f4f5df23SVikas Chaudhary DEBUG2(printk("scsi%ld: initialize adapter: %s\n", ha->host_no,
99725985edcSLucas De Marchi status == QLA_ERROR ? "FAILED" : "SUCCEEDED"));
998afaf5a2dSDavid Somayajulu return status;
999afaf5a2dSDavid Somayajulu }
1000afaf5a2dSDavid Somayajulu
qla4xxx_ddb_change(struct scsi_qla_host * ha,uint32_t fw_ddb_index,struct ddb_entry * ddb_entry,uint32_t state)100113483730SMike Christie int qla4xxx_ddb_change(struct scsi_qla_host *ha, uint32_t fw_ddb_index,
100213483730SMike Christie struct ddb_entry *ddb_entry, uint32_t state)
1003afaf5a2dSDavid Somayajulu {
1004b3a271a9SManish Rangankar uint32_t old_fw_ddb_device_state;
1005b3a271a9SManish Rangankar int status = QLA_ERROR;
1006afaf5a2dSDavid Somayajulu
1007b3a271a9SManish Rangankar old_fw_ddb_device_state = ddb_entry->fw_ddb_device_state;
1008b3a271a9SManish Rangankar DEBUG2(ql4_printk(KERN_INFO, ha,
1009b3a271a9SManish Rangankar "%s: DDB - old state = 0x%x, new state = 0x%x for "
1010b3a271a9SManish Rangankar "index [%d]\n", __func__,
1011afaf5a2dSDavid Somayajulu ddb_entry->fw_ddb_device_state, state, fw_ddb_index));
1012afaf5a2dSDavid Somayajulu
1013afaf5a2dSDavid Somayajulu ddb_entry->fw_ddb_device_state = state;
1014b3a271a9SManish Rangankar
1015b3a271a9SManish Rangankar switch (old_fw_ddb_device_state) {
1016b3a271a9SManish Rangankar case DDB_DS_LOGIN_IN_PROCESS:
1017b3a271a9SManish Rangankar switch (state) {
1018b3a271a9SManish Rangankar case DDB_DS_SESSION_ACTIVE:
1019b3a271a9SManish Rangankar case DDB_DS_DISCOVERY:
1020b3a271a9SManish Rangankar qla4xxx_update_session_conn_param(ha, ddb_entry);
10213d948e2aSManish Rangankar ddb_entry->unblock_sess(ddb_entry->sess);
1022b3a271a9SManish Rangankar status = QLA_SUCCESS;
1023b3a271a9SManish Rangankar break;
1024b3a271a9SManish Rangankar case DDB_DS_SESSION_FAILED:
1025b3a271a9SManish Rangankar case DDB_DS_NO_CONNECTION_ACTIVE:
1026b3a271a9SManish Rangankar iscsi_conn_login_event(ddb_entry->conn,
1027b3a271a9SManish Rangankar ISCSI_CONN_STATE_FREE);
1028b3a271a9SManish Rangankar status = QLA_SUCCESS;
1029b3a271a9SManish Rangankar break;
1030b3a271a9SManish Rangankar }
1031b3a271a9SManish Rangankar break;
1032b3a271a9SManish Rangankar case DDB_DS_SESSION_ACTIVE:
10333d948e2aSManish Rangankar case DDB_DS_DISCOVERY:
1034736cf369SManish Rangankar switch (state) {
1035736cf369SManish Rangankar case DDB_DS_SESSION_FAILED:
1036afaf5a2dSDavid Somayajulu /*
1037b3a271a9SManish Rangankar * iscsi_session failure will cause userspace to
1038b3a271a9SManish Rangankar * stop the connection which in turn would block the
1039b3a271a9SManish Rangankar * iscsi_session and start relogin
1040afaf5a2dSDavid Somayajulu */
1041b3a271a9SManish Rangankar iscsi_session_failure(ddb_entry->sess->dd_data,
1042b3a271a9SManish Rangankar ISCSI_ERR_CONN_FAILED);
1043b3a271a9SManish Rangankar status = QLA_SUCCESS;
1044736cf369SManish Rangankar break;
1045736cf369SManish Rangankar case DDB_DS_NO_CONNECTION_ACTIVE:
1046736cf369SManish Rangankar clear_bit(fw_ddb_index, ha->ddb_idx_map);
1047736cf369SManish Rangankar status = QLA_SUCCESS;
1048736cf369SManish Rangankar break;
1049b3a271a9SManish Rangankar }
1050b3a271a9SManish Rangankar break;
105198270ab4SManish Rangankar case DDB_DS_SESSION_FAILED:
105298270ab4SManish Rangankar switch (state) {
105398270ab4SManish Rangankar case DDB_DS_SESSION_ACTIVE:
105498270ab4SManish Rangankar case DDB_DS_DISCOVERY:
105513483730SMike Christie ddb_entry->unblock_sess(ddb_entry->sess);
105698270ab4SManish Rangankar qla4xxx_update_session_conn_param(ha, ddb_entry);
105798270ab4SManish Rangankar status = QLA_SUCCESS;
105898270ab4SManish Rangankar break;
105998270ab4SManish Rangankar case DDB_DS_SESSION_FAILED:
106098270ab4SManish Rangankar iscsi_session_failure(ddb_entry->sess->dd_data,
106198270ab4SManish Rangankar ISCSI_ERR_CONN_FAILED);
106298270ab4SManish Rangankar status = QLA_SUCCESS;
106398270ab4SManish Rangankar break;
106498270ab4SManish Rangankar }
106598270ab4SManish Rangankar break;
1066b3a271a9SManish Rangankar default:
1067b3a271a9SManish Rangankar DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Unknown Event\n",
1068b3a271a9SManish Rangankar __func__));
1069b3a271a9SManish Rangankar break;
1070065aa1b4SVikas Chaudhary }
107113483730SMike Christie return status;
107213483730SMike Christie }
107313483730SMike Christie
qla4xxx_arm_relogin_timer(struct ddb_entry * ddb_entry)107413483730SMike Christie void qla4xxx_arm_relogin_timer(struct ddb_entry *ddb_entry)
107513483730SMike Christie {
107613483730SMike Christie /*
107713483730SMike Christie * This triggers a relogin. After the relogin_timer
107813483730SMike Christie * expires, the relogin gets scheduled. We must wait a
107913483730SMike Christie * minimum amount of time since receiving an 0x8014 AEN
108013483730SMike Christie * with failed device_state or a logout response before
108113483730SMike Christie * we can issue another relogin.
108213483730SMike Christie *
108313483730SMike Christie * Firmware pads this timeout: (time2wait +1).
108413483730SMike Christie * Driver retry to login should be longer than F/W.
108513483730SMike Christie * Otherwise F/W will fail
108613483730SMike Christie * set_ddb() mbx cmd with 0x4005 since it still
108713483730SMike Christie * counting down its time2wait.
108813483730SMike Christie */
108913483730SMike Christie atomic_set(&ddb_entry->relogin_timer, 0);
109013483730SMike Christie atomic_set(&ddb_entry->retry_relogin_timer,
109113483730SMike Christie ddb_entry->default_time2wait + 4);
109213483730SMike Christie
109313483730SMike Christie }
109413483730SMike Christie
qla4xxx_flash_ddb_change(struct scsi_qla_host * ha,uint32_t fw_ddb_index,struct ddb_entry * ddb_entry,uint32_t state)109513483730SMike Christie int qla4xxx_flash_ddb_change(struct scsi_qla_host *ha, uint32_t fw_ddb_index,
109613483730SMike Christie struct ddb_entry *ddb_entry, uint32_t state)
109713483730SMike Christie {
109813483730SMike Christie uint32_t old_fw_ddb_device_state;
109913483730SMike Christie int status = QLA_ERROR;
110013483730SMike Christie
110113483730SMike Christie old_fw_ddb_device_state = ddb_entry->fw_ddb_device_state;
110213483730SMike Christie DEBUG2(ql4_printk(KERN_INFO, ha,
110313483730SMike Christie "%s: DDB - old state = 0x%x, new state = 0x%x for "
110413483730SMike Christie "index [%d]\n", __func__,
110513483730SMike Christie ddb_entry->fw_ddb_device_state, state, fw_ddb_index));
110613483730SMike Christie
110713483730SMike Christie ddb_entry->fw_ddb_device_state = state;
110813483730SMike Christie
110913483730SMike Christie switch (old_fw_ddb_device_state) {
111013483730SMike Christie case DDB_DS_LOGIN_IN_PROCESS:
111113483730SMike Christie case DDB_DS_NO_CONNECTION_ACTIVE:
111213483730SMike Christie switch (state) {
111313483730SMike Christie case DDB_DS_SESSION_ACTIVE:
111413483730SMike Christie ddb_entry->unblock_sess(ddb_entry->sess);
111513483730SMike Christie qla4xxx_update_session_conn_fwddb_param(ha, ddb_entry);
111613483730SMike Christie status = QLA_SUCCESS;
111713483730SMike Christie break;
111813483730SMike Christie case DDB_DS_SESSION_FAILED:
111913483730SMike Christie iscsi_block_session(ddb_entry->sess);
112013483730SMike Christie if (!test_bit(DF_RELOGIN, &ddb_entry->flags))
112113483730SMike Christie qla4xxx_arm_relogin_timer(ddb_entry);
112213483730SMike Christie status = QLA_SUCCESS;
112313483730SMike Christie break;
112413483730SMike Christie }
112513483730SMike Christie break;
112613483730SMike Christie case DDB_DS_SESSION_ACTIVE:
112713483730SMike Christie switch (state) {
112813483730SMike Christie case DDB_DS_SESSION_FAILED:
112913483730SMike Christie iscsi_block_session(ddb_entry->sess);
113013483730SMike Christie if (!test_bit(DF_RELOGIN, &ddb_entry->flags))
113113483730SMike Christie qla4xxx_arm_relogin_timer(ddb_entry);
113213483730SMike Christie status = QLA_SUCCESS;
113313483730SMike Christie break;
113413483730SMike Christie }
113513483730SMike Christie break;
113613483730SMike Christie case DDB_DS_SESSION_FAILED:
113713483730SMike Christie switch (state) {
113813483730SMike Christie case DDB_DS_SESSION_ACTIVE:
113913483730SMike Christie ddb_entry->unblock_sess(ddb_entry->sess);
114013483730SMike Christie qla4xxx_update_session_conn_fwddb_param(ha, ddb_entry);
114113483730SMike Christie status = QLA_SUCCESS;
114213483730SMike Christie break;
114313483730SMike Christie case DDB_DS_SESSION_FAILED:
114413483730SMike Christie if (!test_bit(DF_RELOGIN, &ddb_entry->flags))
114513483730SMike Christie qla4xxx_arm_relogin_timer(ddb_entry);
114613483730SMike Christie status = QLA_SUCCESS;
114713483730SMike Christie break;
114813483730SMike Christie }
114913483730SMike Christie break;
115013483730SMike Christie default:
115113483730SMike Christie DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Unknown Event\n",
115213483730SMike Christie __func__));
115313483730SMike Christie break;
115413483730SMike Christie }
115513483730SMike Christie return status;
115613483730SMike Christie }
115713483730SMike Christie
115813483730SMike Christie /**
115913483730SMike Christie * qla4xxx_process_ddb_changed - process ddb state change
11607ec772d0SLee Jones * @ha: Pointer to host adapter structure.
11617ec772d0SLee Jones * @fw_ddb_index: Firmware's device database index
11627ec772d0SLee Jones * @state: Device state
1163c0ad04b4SLee Jones * @conn_err: Unused
116413483730SMike Christie *
116513483730SMike Christie * This routine processes a Decive Database Changed AEN Event.
116613483730SMike Christie **/
qla4xxx_process_ddb_changed(struct scsi_qla_host * ha,uint32_t fw_ddb_index,uint32_t state,uint32_t conn_err)116713483730SMike Christie int qla4xxx_process_ddb_changed(struct scsi_qla_host *ha,
116813483730SMike Christie uint32_t fw_ddb_index,
116913483730SMike Christie uint32_t state, uint32_t conn_err)
117013483730SMike Christie {
117113483730SMike Christie struct ddb_entry *ddb_entry;
117213483730SMike Christie
117313483730SMike Christie /* check for out of range index */
117413483730SMike Christie if (fw_ddb_index >= MAX_DDB_ENTRIES)
117513483730SMike Christie goto exit_ddb_event;
117613483730SMike Christie
117713483730SMike Christie /* Get the corresponging ddb entry */
117813483730SMike Christie ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, fw_ddb_index);
117913483730SMike Christie /* Device does not currently exist in our database. */
118013483730SMike Christie if (ddb_entry == NULL) {
118113483730SMike Christie ql4_printk(KERN_ERR, ha, "%s: No ddb_entry at FW index [%d]\n",
118213483730SMike Christie __func__, fw_ddb_index);
118313483730SMike Christie
118413483730SMike Christie if (state == DDB_DS_NO_CONNECTION_ACTIVE)
118513483730SMike Christie clear_bit(fw_ddb_index, ha->ddb_idx_map);
118613483730SMike Christie
118713483730SMike Christie goto exit_ddb_event;
118813483730SMike Christie }
118913483730SMike Christie
119013483730SMike Christie ddb_entry->ddb_change(ha, fw_ddb_index, ddb_entry, state);
1191065aa1b4SVikas Chaudhary
1192b3a271a9SManish Rangankar exit_ddb_event:
1193121432e8SYe Bin return QLA_ERROR;
1194afaf5a2dSDavid Somayajulu }
119513483730SMike Christie
119613483730SMike Christie /**
119713483730SMike Christie * qla4xxx_login_flash_ddb - Login to target (DDB)
119813483730SMike Christie * @cls_session: Pointer to the session to login
119913483730SMike Christie *
120013483730SMike Christie * This routine logins to the target.
120113483730SMike Christie * Issues setddb and conn open mbx
120213483730SMike Christie **/
qla4xxx_login_flash_ddb(struct iscsi_cls_session * cls_session)120313483730SMike Christie void qla4xxx_login_flash_ddb(struct iscsi_cls_session *cls_session)
120413483730SMike Christie {
120513483730SMike Christie struct iscsi_session *sess;
120613483730SMike Christie struct ddb_entry *ddb_entry;
120713483730SMike Christie struct scsi_qla_host *ha;
120813483730SMike Christie struct dev_db_entry *fw_ddb_entry = NULL;
120913483730SMike Christie dma_addr_t fw_ddb_dma;
121013483730SMike Christie uint32_t mbx_sts = 0;
121113483730SMike Christie int ret;
121213483730SMike Christie
121313483730SMike Christie sess = cls_session->dd_data;
121413483730SMike Christie ddb_entry = sess->dd_data;
121513483730SMike Christie ha = ddb_entry->ha;
121613483730SMike Christie
121713483730SMike Christie if (!test_bit(AF_LINK_UP, &ha->flags))
121813483730SMike Christie return;
121913483730SMike Christie
122013483730SMike Christie if (ddb_entry->ddb_type != FLASH_DDB) {
122113483730SMike Christie DEBUG2(ql4_printk(KERN_INFO, ha,
122213483730SMike Christie "Skipping login to non FLASH DB"));
122313483730SMike Christie goto exit_login;
122413483730SMike Christie }
122513483730SMike Christie
122613483730SMike Christie fw_ddb_entry = dma_pool_alloc(ha->fw_ddb_dma_pool, GFP_KERNEL,
122713483730SMike Christie &fw_ddb_dma);
122813483730SMike Christie if (fw_ddb_entry == NULL) {
122913483730SMike Christie DEBUG2(ql4_printk(KERN_ERR, ha, "Out of memory\n"));
123013483730SMike Christie goto exit_login;
123113483730SMike Christie }
123213483730SMike Christie
123313483730SMike Christie if (ddb_entry->fw_ddb_index == INVALID_ENTRY) {
123413483730SMike Christie ret = qla4xxx_get_ddb_index(ha, &ddb_entry->fw_ddb_index);
123513483730SMike Christie if (ret == QLA_ERROR)
123613483730SMike Christie goto exit_login;
123713483730SMike Christie
123813483730SMike Christie ha->fw_ddb_index_map[ddb_entry->fw_ddb_index] = ddb_entry;
123913483730SMike Christie ha->tot_ddbs++;
124013483730SMike Christie }
124113483730SMike Christie
124213483730SMike Christie memcpy(fw_ddb_entry, &ddb_entry->fw_ddb_entry,
124313483730SMike Christie sizeof(struct dev_db_entry));
124413483730SMike Christie ddb_entry->sess->target_id = ddb_entry->fw_ddb_index;
124513483730SMike Christie
124613483730SMike Christie ret = qla4xxx_set_ddb_entry(ha, ddb_entry->fw_ddb_index,
124713483730SMike Christie fw_ddb_dma, &mbx_sts);
124813483730SMike Christie if (ret == QLA_ERROR) {
124913483730SMike Christie DEBUG2(ql4_printk(KERN_ERR, ha, "Set DDB failed\n"));
125013483730SMike Christie goto exit_login;
125113483730SMike Christie }
125213483730SMike Christie
125313483730SMike Christie ddb_entry->fw_ddb_device_state = DDB_DS_LOGIN_IN_PROCESS;
125413483730SMike Christie ret = qla4xxx_conn_open(ha, ddb_entry->fw_ddb_index);
125513483730SMike Christie if (ret == QLA_ERROR) {
125613483730SMike Christie ql4_printk(KERN_ERR, ha, "%s: Login failed: %s\n", __func__,
125713483730SMike Christie sess->targetname);
125813483730SMike Christie goto exit_login;
125913483730SMike Christie }
126013483730SMike Christie
126113483730SMike Christie exit_login:
126213483730SMike Christie if (fw_ddb_entry)
126313483730SMike Christie dma_pool_free(ha->fw_ddb_dma_pool, fw_ddb_entry, fw_ddb_dma);
126413483730SMike Christie }
126513483730SMike Christie
1266