source: src/linux/universal/linux-4.9/drivers/scsi/qla2xxx/qla_os.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 2 months ago

update

File size: 166.7 KB
Line 
1/*
2 * QLogic Fibre Channel HBA Driver
3 * Copyright (c)  2003-2014 QLogic Corporation
4 *
5 * See LICENSE.qla2xxx for copyright and licensing details.
6 */
7#include "qla_def.h"
8
9#include <linux/moduleparam.h>
10#include <linux/vmalloc.h>
11#include <linux/delay.h>
12#include <linux/kthread.h>
13#include <linux/mutex.h>
14#include <linux/kobject.h>
15#include <linux/slab.h>
16#include <scsi/scsi_tcq.h>
17#include <scsi/scsicam.h>
18#include <scsi/scsi_transport.h>
19#include <scsi/scsi_transport_fc.h>
20
21#include "qla_target.h"
22
23/*
24 * Driver version
25 */
26char qla2x00_version_str[40];
27
28static int apidev_major;
29
30/*
31 * SRB allocation cache
32 */
33static struct kmem_cache *srb_cachep;
34
35/*
36 * CT6 CTX allocation cache
37 */
38static struct kmem_cache *ctx_cachep;
39/*
40 * error level for logging
41 */
42int ql_errlev = ql_log_all;
43
44static int ql2xenableclass2;
45module_param(ql2xenableclass2, int, S_IRUGO|S_IRUSR);
46MODULE_PARM_DESC(ql2xenableclass2,
47                "Specify if Class 2 operations are supported from the very "
48                "beginning. Default is 0 - class 2 not supported.");
49
50
51int ql2xlogintimeout = 20;
52module_param(ql2xlogintimeout, int, S_IRUGO);
53MODULE_PARM_DESC(ql2xlogintimeout,
54                "Login timeout value in seconds.");
55
56int qlport_down_retry;
57module_param(qlport_down_retry, int, S_IRUGO);
58MODULE_PARM_DESC(qlport_down_retry,
59                "Maximum number of command retries to a port that returns "
60                "a PORT-DOWN status.");
61
62int ql2xplogiabsentdevice;
63module_param(ql2xplogiabsentdevice, int, S_IRUGO|S_IWUSR);
64MODULE_PARM_DESC(ql2xplogiabsentdevice,
65                "Option to enable PLOGI to devices that are not present after "
66                "a Fabric scan.  This is needed for several broken switches. "
67                "Default is 0 - no PLOGI. 1 - perfom PLOGI.");
68
69int ql2xloginretrycount = 0;
70module_param(ql2xloginretrycount, int, S_IRUGO);
71MODULE_PARM_DESC(ql2xloginretrycount,
72                "Specify an alternate value for the NVRAM login retry count.");
73
74int ql2xallocfwdump = 1;
75module_param(ql2xallocfwdump, int, S_IRUGO);
76MODULE_PARM_DESC(ql2xallocfwdump,
77                "Option to enable allocation of memory for a firmware dump "
78                "during HBA initialization.  Memory allocation requirements "
79                "vary by ISP type.  Default is 1 - allocate memory.");
80
81int ql2xextended_error_logging;
82module_param(ql2xextended_error_logging, int, S_IRUGO|S_IWUSR);
83module_param_named(logging, ql2xextended_error_logging, int, S_IRUGO|S_IWUSR);
84MODULE_PARM_DESC(ql2xextended_error_logging,
85                "Option to enable extended error logging,\n"
86                "\t\tDefault is 0 - no logging.  0x40000000 - Module Init & Probe.\n"
87                "\t\t0x20000000 - Mailbox Cmnds. 0x10000000 - Device Discovery.\n"
88                "\t\t0x08000000 - IO tracing.    0x04000000 - DPC Thread.\n"
89                "\t\t0x02000000 - Async events.  0x01000000 - Timer routines.\n"
90                "\t\t0x00800000 - User space.    0x00400000 - Task Management.\n"
91                "\t\t0x00200000 - AER/EEH.       0x00100000 - Multi Q.\n"
92                "\t\t0x00080000 - P3P Specific.  0x00040000 - Virtual Port.\n"
93                "\t\t0x00020000 - Buffer Dump.   0x00010000 - Misc.\n"
94                "\t\t0x00008000 - Verbose.       0x00004000 - Target.\n"
95                "\t\t0x00002000 - Target Mgmt.   0x00001000 - Target TMF.\n"
96                "\t\t0x7fffffff - For enabling all logs, can be too many logs.\n"
97                "\t\t0x1e400000 - Preferred value for capturing essential "
98                "debug information (equivalent to old "
99                "ql2xextended_error_logging=1).\n"
100                "\t\tDo LOGICAL OR of the value to enable more than one level");
101
102int ql2xshiftctondsd = 6;
103module_param(ql2xshiftctondsd, int, S_IRUGO);
104MODULE_PARM_DESC(ql2xshiftctondsd,
105                "Set to control shifting of command type processing "
106                "based on total number of SG elements.");
107
108int ql2xfdmienable=1;
109module_param(ql2xfdmienable, int, S_IRUGO|S_IWUSR);
110module_param_named(fdmi, ql2xfdmienable, int, S_IRUGO|S_IWUSR);
111MODULE_PARM_DESC(ql2xfdmienable,
112                "Enables FDMI registrations. "
113                "0 - no FDMI. Default is 1 - perform FDMI.");
114
115#define MAX_Q_DEPTH     32
116static int ql2xmaxqdepth = MAX_Q_DEPTH;
117module_param(ql2xmaxqdepth, int, S_IRUGO|S_IWUSR);
118MODULE_PARM_DESC(ql2xmaxqdepth,
119                "Maximum queue depth to set for each LUN. "
120                "Default is 32.");
121
122int ql2xenabledif = 2;
123module_param(ql2xenabledif, int, S_IRUGO);
124MODULE_PARM_DESC(ql2xenabledif,
125                " Enable T10-CRC-DIF:\n"
126                " Default is 2.\n"
127                "  0 -- No DIF Support\n"
128                "  1 -- Enable DIF for all types\n"
129                "  2 -- Enable DIF for all types, except Type 0.\n");
130
131int ql2xenablehba_err_chk = 2;
132module_param(ql2xenablehba_err_chk, int, S_IRUGO|S_IWUSR);
133MODULE_PARM_DESC(ql2xenablehba_err_chk,
134                " Enable T10-CRC-DIF Error isolation by HBA:\n"
135                " Default is 2.\n"
136                "  0 -- Error isolation disabled\n"
137                "  1 -- Error isolation enabled only for DIX Type 0\n"
138                "  2 -- Error isolation enabled for all Types\n");
139
140int ql2xiidmaenable=1;
141module_param(ql2xiidmaenable, int, S_IRUGO);
142MODULE_PARM_DESC(ql2xiidmaenable,
143                "Enables iIDMA settings "
144                "Default is 1 - perform iIDMA. 0 - no iIDMA.");
145
146int ql2xmaxqueues = 1;
147module_param(ql2xmaxqueues, int, S_IRUGO);
148MODULE_PARM_DESC(ql2xmaxqueues,
149                "Enables MQ settings "
150                "Default is 1 for single queue. Set it to number "
151                "of queues in MQ mode.");
152
153int ql2xmultique_tag;
154module_param(ql2xmultique_tag, int, S_IRUGO);
155MODULE_PARM_DESC(ql2xmultique_tag,
156                "Enables CPU affinity settings for the driver "
157                "Default is 0 for no affinity of request and response IO. "
158                "Set it to 1 to turn on the cpu affinity.");
159
160int ql2xfwloadbin;
161module_param(ql2xfwloadbin, int, S_IRUGO|S_IWUSR);
162module_param_named(fwload, ql2xfwloadbin, int, S_IRUGO|S_IWUSR);
163MODULE_PARM_DESC(ql2xfwloadbin,
164                "Option to specify location from which to load ISP firmware:.\n"
165                " 2 -- load firmware via the request_firmware() (hotplug).\n"
166                "      interface.\n"
167                " 1 -- load firmware from flash.\n"
168                " 0 -- use default semantics.\n");
169
170int ql2xetsenable;
171module_param(ql2xetsenable, int, S_IRUGO);
172MODULE_PARM_DESC(ql2xetsenable,
173                "Enables firmware ETS burst."
174                "Default is 0 - skip ETS enablement.");
175
176int ql2xdbwr = 1;
177module_param(ql2xdbwr, int, S_IRUGO|S_IWUSR);
178MODULE_PARM_DESC(ql2xdbwr,
179                "Option to specify scheme for request queue posting.\n"
180                " 0 -- Regular doorbell.\n"
181                " 1 -- CAMRAM doorbell (faster).\n");
182
183int ql2xtargetreset = 1;
184module_param(ql2xtargetreset, int, S_IRUGO);
185MODULE_PARM_DESC(ql2xtargetreset,
186                 "Enable target reset."
187                 "Default is 1 - use hw defaults.");
188
189int ql2xgffidenable;
190module_param(ql2xgffidenable, int, S_IRUGO);
191MODULE_PARM_DESC(ql2xgffidenable,
192                "Enables GFF_ID checks of port type. "
193                "Default is 0 - Do not use GFF_ID information.");
194
195int ql2xasynctmfenable;
196module_param(ql2xasynctmfenable, int, S_IRUGO);
197MODULE_PARM_DESC(ql2xasynctmfenable,
198                "Enables issue of TM IOCBs asynchronously via IOCB mechanism"
199                "Default is 0 - Issue TM IOCBs via mailbox mechanism.");
200
201int ql2xdontresethba;
202module_param(ql2xdontresethba, int, S_IRUGO|S_IWUSR);
203MODULE_PARM_DESC(ql2xdontresethba,
204                "Option to specify reset behaviour.\n"
205                " 0 (Default) -- Reset on failure.\n"
206                " 1 -- Do not reset on failure.\n");
207
208uint64_t ql2xmaxlun = MAX_LUNS;
209module_param(ql2xmaxlun, ullong, S_IRUGO);
210MODULE_PARM_DESC(ql2xmaxlun,
211                "Defines the maximum LU number to register with the SCSI "
212                "midlayer. Default is 65535.");
213
214int ql2xmdcapmask = 0x1F;
215module_param(ql2xmdcapmask, int, S_IRUGO);
216MODULE_PARM_DESC(ql2xmdcapmask,
217                "Set the Minidump driver capture mask level. "
218                "Default is 0x1F - Can be set to 0x3, 0x7, 0xF, 0x1F, 0x7F.");
219
220int ql2xmdenable = 1;
221module_param(ql2xmdenable, int, S_IRUGO);
222MODULE_PARM_DESC(ql2xmdenable,
223                "Enable/disable MiniDump. "
224                "0 - MiniDump disabled. "
225                "1 (Default) - MiniDump enabled.");
226
227int ql2xexlogins = 0;
228module_param(ql2xexlogins, uint, S_IRUGO|S_IWUSR);
229MODULE_PARM_DESC(ql2xexlogins,
230                 "Number of extended Logins. "
231                 "0 (Default)- Disabled.");
232
233int ql2xexchoffld = 0;
234module_param(ql2xexchoffld, uint, S_IRUGO|S_IWUSR);
235MODULE_PARM_DESC(ql2xexchoffld,
236                 "Number of exchanges to offload. "
237                 "0 (Default)- Disabled.");
238
239int ql2xfwholdabts = 0;
240module_param(ql2xfwholdabts, int, S_IRUGO);
241MODULE_PARM_DESC(ql2xfwholdabts,
242                "Allow FW to hold status IOCB until ABTS rsp received. "
243                "0 (Default) Do not set fw option. "
244                "1 - Set fw option to hold ABTS.");
245
246/*
247 * SCSI host template entry points
248 */
249static int qla2xxx_slave_configure(struct scsi_device * device);
250static int qla2xxx_slave_alloc(struct scsi_device *);
251static int qla2xxx_scan_finished(struct Scsi_Host *, unsigned long time);
252static void qla2xxx_scan_start(struct Scsi_Host *);
253static void qla2xxx_slave_destroy(struct scsi_device *);
254static int qla2xxx_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *cmd);
255static int qla2xxx_eh_abort(struct scsi_cmnd *);
256static int qla2xxx_eh_device_reset(struct scsi_cmnd *);
257static int qla2xxx_eh_target_reset(struct scsi_cmnd *);
258static int qla2xxx_eh_bus_reset(struct scsi_cmnd *);
259static int qla2xxx_eh_host_reset(struct scsi_cmnd *);
260
261static void qla2x00_clear_drv_active(struct qla_hw_data *);
262static void qla2x00_free_device(scsi_qla_host_t *);
263static void qla83xx_disable_laser(scsi_qla_host_t *vha);
264
265struct scsi_host_template qla2xxx_driver_template = {
266        .module                 = THIS_MODULE,
267        .name                   = QLA2XXX_DRIVER_NAME,
268        .queuecommand           = qla2xxx_queuecommand,
269
270        .eh_abort_handler       = qla2xxx_eh_abort,
271        .eh_device_reset_handler = qla2xxx_eh_device_reset,
272        .eh_target_reset_handler = qla2xxx_eh_target_reset,
273        .eh_bus_reset_handler   = qla2xxx_eh_bus_reset,
274        .eh_host_reset_handler  = qla2xxx_eh_host_reset,
275
276        .slave_configure        = qla2xxx_slave_configure,
277
278        .slave_alloc            = qla2xxx_slave_alloc,
279        .slave_destroy          = qla2xxx_slave_destroy,
280        .scan_finished          = qla2xxx_scan_finished,
281        .scan_start             = qla2xxx_scan_start,
282        .change_queue_depth     = scsi_change_queue_depth,
283        .this_id                = -1,
284        .cmd_per_lun            = 3,
285        .use_clustering         = ENABLE_CLUSTERING,
286        .sg_tablesize           = SG_ALL,
287
288        .max_sectors            = 0xFFFF,
289        .shost_attrs            = qla2x00_host_attrs,
290
291        .supported_mode         = MODE_INITIATOR,
292        .track_queue_depth      = 1,
293};
294
295static struct scsi_transport_template *qla2xxx_transport_template = NULL;
296struct scsi_transport_template *qla2xxx_transport_vport_template = NULL;
297
298/* TODO Convert to inlines
299 *
300 * Timer routines
301 */
302
303__inline__ void
304qla2x00_start_timer(scsi_qla_host_t *vha, void *func, unsigned long interval)
305{
306        init_timer(&vha->timer);
307        vha->timer.expires = jiffies + interval * HZ;
308        vha->timer.data = (unsigned long)vha;
309        vha->timer.function = (void (*)(unsigned long))func;
310        add_timer(&vha->timer);
311        vha->timer_active = 1;
312}
313
314static inline void
315qla2x00_restart_timer(scsi_qla_host_t *vha, unsigned long interval)
316{
317        /* Currently used for 82XX only. */
318        if (vha->device_flags & DFLG_DEV_FAILED) {
319                ql_dbg(ql_dbg_timer, vha, 0x600d,
320                    "Device in a failed state, returning.\n");
321                return;
322        }
323
324        mod_timer(&vha->timer, jiffies + interval * HZ);
325}
326
327static __inline__ void
328qla2x00_stop_timer(scsi_qla_host_t *vha)
329{
330        del_timer_sync(&vha->timer);
331        vha->timer_active = 0;
332}
333
334static int qla2x00_do_dpc(void *data);
335
336static void qla2x00_rst_aen(scsi_qla_host_t *);
337
338static int qla2x00_mem_alloc(struct qla_hw_data *, uint16_t, uint16_t,
339        struct req_que **, struct rsp_que **);
340static void qla2x00_free_fw_dump(struct qla_hw_data *);
341static void qla2x00_mem_free(struct qla_hw_data *);
342
343/* -------------------------------------------------------------------------- */
344static int qla2x00_alloc_queues(struct qla_hw_data *ha, struct req_que *req,
345                                struct rsp_que *rsp)
346{
347        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
348        ha->req_q_map = kzalloc(sizeof(struct req_que *) * ha->max_req_queues,
349                                GFP_KERNEL);
350        if (!ha->req_q_map) {
351                ql_log(ql_log_fatal, vha, 0x003b,
352                    "Unable to allocate memory for request queue ptrs.\n");
353                goto fail_req_map;
354        }
355
356        ha->rsp_q_map = kzalloc(sizeof(struct rsp_que *) * ha->max_rsp_queues,
357                                GFP_KERNEL);
358        if (!ha->rsp_q_map) {
359                ql_log(ql_log_fatal, vha, 0x003c,
360                    "Unable to allocate memory for response queue ptrs.\n");
361                goto fail_rsp_map;
362        }
363        /*
364         * Make sure we record at least the request and response queue zero in
365         * case we need to free them if part of the probe fails.
366         */
367        ha->rsp_q_map[0] = rsp;
368        ha->req_q_map[0] = req;
369        set_bit(0, ha->rsp_qid_map);
370        set_bit(0, ha->req_qid_map);
371        return 1;
372
373fail_rsp_map:
374        kfree(ha->req_q_map);
375        ha->req_q_map = NULL;
376fail_req_map:
377        return -ENOMEM;
378}
379
380static void qla2x00_free_req_que(struct qla_hw_data *ha, struct req_que *req)
381{
382        if (IS_QLAFX00(ha)) {
383                if (req && req->ring_fx00)
384                        dma_free_coherent(&ha->pdev->dev,
385                            (req->length_fx00 + 1) * sizeof(request_t),
386                            req->ring_fx00, req->dma_fx00);
387        } else if (req && req->ring)
388                dma_free_coherent(&ha->pdev->dev,
389                (req->length + 1) * sizeof(request_t),
390                req->ring, req->dma);
391
392        if (req)
393                kfree(req->outstanding_cmds);
394
395        kfree(req);
396        req = NULL;
397}
398
399static void qla2x00_free_rsp_que(struct qla_hw_data *ha, struct rsp_que *rsp)
400{
401        if (IS_QLAFX00(ha)) {
402                if (rsp && rsp->ring)
403                        dma_free_coherent(&ha->pdev->dev,
404                            (rsp->length_fx00 + 1) * sizeof(request_t),
405                            rsp->ring_fx00, rsp->dma_fx00);
406        } else if (rsp && rsp->ring) {
407                dma_free_coherent(&ha->pdev->dev,
408                (rsp->length + 1) * sizeof(response_t),
409                rsp->ring, rsp->dma);
410        }
411        kfree(rsp);
412        rsp = NULL;
413}
414
415static void qla2x00_free_queues(struct qla_hw_data *ha)
416{
417        struct req_que *req;
418        struct rsp_que *rsp;
419        int cnt;
420
421        for (cnt = 0; cnt < ha->max_req_queues; cnt++) {
422                if (!test_bit(cnt, ha->req_qid_map))
423                        continue;
424
425                req = ha->req_q_map[cnt];
426                qla2x00_free_req_que(ha, req);
427        }
428        kfree(ha->req_q_map);
429        ha->req_q_map = NULL;
430
431        for (cnt = 0; cnt < ha->max_rsp_queues; cnt++) {
432                if (!test_bit(cnt, ha->rsp_qid_map))
433                        continue;
434
435                rsp = ha->rsp_q_map[cnt];
436                qla2x00_free_rsp_que(ha, rsp);
437        }
438        kfree(ha->rsp_q_map);
439        ha->rsp_q_map = NULL;
440}
441
442static int qla25xx_setup_mode(struct scsi_qla_host *vha)
443{
444        uint16_t options = 0;
445        int ques, req, ret;
446        struct qla_hw_data *ha = vha->hw;
447
448        if (!(ha->fw_attributes & BIT_6)) {
449                ql_log(ql_log_warn, vha, 0x00d8,
450                    "Firmware is not multi-queue capable.\n");
451                goto fail;
452        }
453        if (ql2xmultique_tag) {
454                /* create a request queue for IO */
455                options |= BIT_7;
456                req = qla25xx_create_req_que(ha, options, 0, 0, -1,
457                        QLA_DEFAULT_QUE_QOS);
458                if (!req) {
459                        ql_log(ql_log_warn, vha, 0x00e0,
460                            "Failed to create request queue.\n");
461                        goto fail;
462                }
463                ha->wq = alloc_workqueue("qla2xxx_wq", WQ_MEM_RECLAIM, 1);
464                vha->req = ha->req_q_map[req];
465                options |= BIT_1;
466                for (ques = 1; ques < ha->max_rsp_queues; ques++) {
467                        ret = qla25xx_create_rsp_que(ha, options, 0, 0, req);
468                        if (!ret) {
469                                ql_log(ql_log_warn, vha, 0x00e8,
470                                    "Failed to create response queue.\n");
471                                goto fail2;
472                        }
473                }
474                ha->flags.cpu_affinity_enabled = 1;
475                ql_dbg(ql_dbg_multiq, vha, 0xc007,
476                    "CPU affinity mode enabled, "
477                    "no. of response queues:%d no. of request queues:%d.\n",
478                    ha->max_rsp_queues, ha->max_req_queues);
479                ql_dbg(ql_dbg_init, vha, 0x00e9,
480                    "CPU affinity mode enabled, "
481                    "no. of response queues:%d no. of request queues:%d.\n",
482                    ha->max_rsp_queues, ha->max_req_queues);
483        }
484        return 0;
485fail2:
486        qla25xx_delete_queues(vha);
487        destroy_workqueue(ha->wq);
488        ha->wq = NULL;
489        vha->req = ha->req_q_map[0];
490fail:
491        ha->mqenable = 0;
492        kfree(ha->req_q_map);
493        kfree(ha->rsp_q_map);
494        ha->max_req_queues = ha->max_rsp_queues = 1;
495        return 1;
496}
497
498static char *
499qla2x00_pci_info_str(struct scsi_qla_host *vha, char *str)
500{
501        struct qla_hw_data *ha = vha->hw;
502        static char *pci_bus_modes[] = {
503                "33", "66", "100", "133",
504        };
505        uint16_t pci_bus;
506
507        strcpy(str, "PCI");
508        pci_bus = (ha->pci_attr & (BIT_9 | BIT_10)) >> 9;
509        if (pci_bus) {
510                strcat(str, "-X (");
511                strcat(str, pci_bus_modes[pci_bus]);
512        } else {
513                pci_bus = (ha->pci_attr & BIT_8) >> 8;
514                strcat(str, " (");
515                strcat(str, pci_bus_modes[pci_bus]);
516        }
517        strcat(str, " MHz)");
518
519        return (str);
520}
521
522static char *
523qla24xx_pci_info_str(struct scsi_qla_host *vha, char *str)
524{
525        static char *pci_bus_modes[] = { "33", "66", "100", "133", };
526        struct qla_hw_data *ha = vha->hw;
527        uint32_t pci_bus;
528
529        if (pci_is_pcie(ha->pdev)) {
530                char lwstr[6];
531                uint32_t lstat, lspeed, lwidth;
532
533                pcie_capability_read_dword(ha->pdev, PCI_EXP_LNKCAP, &lstat);
534                lspeed = lstat & PCI_EXP_LNKCAP_SLS;
535                lwidth = (lstat & PCI_EXP_LNKCAP_MLW) >> 4;
536
537                strcpy(str, "PCIe (");
538                switch (lspeed) {
539                case 1:
540                        strcat(str, "2.5GT/s ");
541                        break;
542                case 2:
543                        strcat(str, "5.0GT/s ");
544                        break;
545                case 3:
546                        strcat(str, "8.0GT/s ");
547                        break;
548                default:
549                        strcat(str, "<unknown> ");
550                        break;
551                }
552                snprintf(lwstr, sizeof(lwstr), "x%d)", lwidth);
553                strcat(str, lwstr);
554
555                return str;
556        }
557
558        strcpy(str, "PCI");
559        pci_bus = (ha->pci_attr & CSRX_PCIX_BUS_MODE_MASK) >> 8;
560        if (pci_bus == 0 || pci_bus == 8) {
561                strcat(str, " (");
562                strcat(str, pci_bus_modes[pci_bus >> 3]);
563        } else {
564                strcat(str, "-X ");
565                if (pci_bus & BIT_2)
566                        strcat(str, "Mode 2");
567                else
568                        strcat(str, "Mode 1");
569                strcat(str, " (");
570                strcat(str, pci_bus_modes[pci_bus & ~BIT_2]);
571        }
572        strcat(str, " MHz)");
573
574        return str;
575}
576
577static char *
578qla2x00_fw_version_str(struct scsi_qla_host *vha, char *str, size_t size)
579{
580        char un_str[10];
581        struct qla_hw_data *ha = vha->hw;
582
583        snprintf(str, size, "%d.%02d.%02d ", ha->fw_major_version,
584            ha->fw_minor_version, ha->fw_subminor_version);
585
586        if (ha->fw_attributes & BIT_9) {
587                strcat(str, "FLX");
588                return (str);
589        }
590
591        switch (ha->fw_attributes & 0xFF) {
592        case 0x7:
593                strcat(str, "EF");
594                break;
595        case 0x17:
596                strcat(str, "TP");
597                break;
598        case 0x37:
599                strcat(str, "IP");
600                break;
601        case 0x77:
602                strcat(str, "VI");
603                break;
604        default:
605                sprintf(un_str, "(%x)", ha->fw_attributes);
606                strcat(str, un_str);
607                break;
608        }
609        if (ha->fw_attributes & 0x100)
610                strcat(str, "X");
611
612        return (str);
613}
614
615static char *
616qla24xx_fw_version_str(struct scsi_qla_host *vha, char *str, size_t size)
617{
618        struct qla_hw_data *ha = vha->hw;
619
620        snprintf(str, size, "%d.%02d.%02d (%x)", ha->fw_major_version,
621            ha->fw_minor_version, ha->fw_subminor_version, ha->fw_attributes);
622        return str;
623}
624
625void
626qla2x00_sp_free_dma(void *vha, void *ptr)
627{
628        srb_t *sp = (srb_t *)ptr;
629        struct scsi_cmnd *cmd = GET_CMD_SP(sp);
630        struct qla_hw_data *ha = sp->fcport->vha->hw;
631        void *ctx = GET_CMD_CTX_SP(sp);
632
633        if (sp->flags & SRB_DMA_VALID) {
634                scsi_dma_unmap(cmd);
635                sp->flags &= ~SRB_DMA_VALID;
636        }
637
638        if (sp->flags & SRB_CRC_PROT_DMA_VALID) {
639                dma_unmap_sg(&ha->pdev->dev, scsi_prot_sglist(cmd),
640                    scsi_prot_sg_count(cmd), cmd->sc_data_direction);
641                sp->flags &= ~SRB_CRC_PROT_DMA_VALID;
642        }
643
644        if (sp->flags & SRB_CRC_CTX_DSD_VALID) {
645                /* List assured to be having elements */
646                qla2x00_clean_dsd_pool(ha, sp, NULL);
647                sp->flags &= ~SRB_CRC_CTX_DSD_VALID;
648        }
649
650        if (sp->flags & SRB_CRC_CTX_DMA_VALID) {
651                dma_pool_free(ha->dl_dma_pool, ctx,
652                    ((struct crc_context *)ctx)->crc_ctx_dma);
653                sp->flags &= ~SRB_CRC_CTX_DMA_VALID;
654        }
655
656        if (sp->flags & SRB_FCP_CMND_DMA_VALID) {
657                struct ct6_dsd *ctx1 = (struct ct6_dsd *)ctx;
658
659                dma_pool_free(ha->fcp_cmnd_dma_pool, ctx1->fcp_cmnd,
660                        ctx1->fcp_cmnd_dma);
661                list_splice(&ctx1->dsd_list, &ha->gbl_dsd_list);
662                ha->gbl_dsd_inuse -= ctx1->dsd_use_cnt;
663                ha->gbl_dsd_avail += ctx1->dsd_use_cnt;
664                mempool_free(ctx1, ha->ctx_mempool);
665                ctx1 = NULL;
666        }
667
668        CMD_SP(cmd) = NULL;
669        qla2x00_rel_sp(sp->fcport->vha, sp);
670}
671
672static void
673qla2x00_sp_compl(void *data, void *ptr, int res)
674{
675        struct qla_hw_data *ha = (struct qla_hw_data *)data;
676        srb_t *sp = (srb_t *)ptr;
677        struct scsi_cmnd *cmd = GET_CMD_SP(sp);
678
679        cmd->result = res;
680
681        if (atomic_read(&sp->ref_count) == 0) {
682                ql_dbg(ql_dbg_io, sp->fcport->vha, 0x3015,
683                    "SP reference-count to ZERO -- sp=%p cmd=%p.\n",
684                    sp, GET_CMD_SP(sp));
685                if (ql2xextended_error_logging & ql_dbg_io)
686                        WARN_ON(atomic_read(&sp->ref_count) == 0);
687                return;
688        }
689        if (!atomic_dec_and_test(&sp->ref_count))
690                return;
691
692        qla2x00_sp_free_dma(ha, sp);
693        cmd->scsi_done(cmd);
694}
695
696/* If we are SP1 here, we need to still take and release the host_lock as SP1
697 * does not have the changes necessary to avoid taking host->host_lock.
698 */
699static int
700qla2xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
701{
702        scsi_qla_host_t *vha = shost_priv(host);
703        fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
704        struct fc_rport *rport = starget_to_rport(scsi_target(cmd->device));
705        struct qla_hw_data *ha = vha->hw;
706        struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
707        srb_t *sp;
708        int rval;
709
710        if (unlikely(test_bit(UNLOADING, &base_vha->dpc_flags))) {
711                cmd->result = DID_NO_CONNECT << 16;
712                goto qc24_fail_command;
713        }
714
715        if (ha->flags.eeh_busy) {
716                if (ha->flags.pci_channel_io_perm_failure) {
717                        ql_dbg(ql_dbg_aer, vha, 0x9010,
718                            "PCI Channel IO permanent failure, exiting "
719                            "cmd=%p.\n", cmd);
720                        cmd->result = DID_NO_CONNECT << 16;
721                } else {
722                        ql_dbg(ql_dbg_aer, vha, 0x9011,
723                            "EEH_Busy, Requeuing the cmd=%p.\n", cmd);
724                        cmd->result = DID_REQUEUE << 16;
725                }
726                goto qc24_fail_command;
727        }
728
729        rval = fc_remote_port_chkready(rport);
730        if (rval) {
731                cmd->result = rval;
732                ql_dbg(ql_dbg_io + ql_dbg_verbose, vha, 0x3003,
733                    "fc_remote_port_chkready failed for cmd=%p, rval=0x%x.\n",
734                    cmd, rval);
735                goto qc24_fail_command;
736        }
737
738        if (!vha->flags.difdix_supported &&
739                scsi_get_prot_op(cmd) != SCSI_PROT_NORMAL) {
740                        ql_dbg(ql_dbg_io, vha, 0x3004,
741                            "DIF Cap not reg, fail DIF capable cmd's:%p.\n",
742                            cmd);
743                        cmd->result = DID_NO_CONNECT << 16;
744                        goto qc24_fail_command;
745        }
746
747        if (!fcport) {
748                cmd->result = DID_NO_CONNECT << 16;
749                goto qc24_fail_command;
750        }
751
752        if (atomic_read(&fcport->state) != FCS_ONLINE) {
753                if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD ||
754                        atomic_read(&base_vha->loop_state) == LOOP_DEAD) {
755                        ql_dbg(ql_dbg_io, vha, 0x3005,
756                            "Returning DNC, fcport_state=%d loop_state=%d.\n",
757                            atomic_read(&fcport->state),
758                            atomic_read(&base_vha->loop_state));
759                        cmd->result = DID_NO_CONNECT << 16;
760                        goto qc24_fail_command;
761                }
762                goto qc24_target_busy;
763        }
764
765        /*
766         * Return target busy if we've received a non-zero retry_delay_timer
767         * in a FCP_RSP.
768         */
769        if (fcport->retry_delay_timestamp == 0) {
770                /* retry delay not set */
771        } else if (time_after(jiffies, fcport->retry_delay_timestamp))
772                fcport->retry_delay_timestamp = 0;
773        else
774                goto qc24_target_busy;
775
776        sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
777        if (!sp)
778                goto qc24_host_busy;
779
780        sp->u.scmd.cmd = cmd;
781        sp->type = SRB_SCSI_CMD;
782        atomic_set(&sp->ref_count, 1);
783        CMD_SP(cmd) = (void *)sp;
784        sp->free = qla2x00_sp_free_dma;
785        sp->done = qla2x00_sp_compl;
786
787        rval = ha->isp_ops->start_scsi(sp);
788        if (rval != QLA_SUCCESS) {
789                ql_dbg(ql_dbg_io + ql_dbg_verbose, vha, 0x3013,
790                    "Start scsi failed rval=%d for cmd=%p.\n", rval, cmd);
791                goto qc24_host_busy_free_sp;
792        }
793
794        return 0;
795
796qc24_host_busy_free_sp:
797        qla2x00_sp_free_dma(ha, sp);
798
799qc24_host_busy:
800        return SCSI_MLQUEUE_HOST_BUSY;
801
802qc24_target_busy:
803        return SCSI_MLQUEUE_TARGET_BUSY;
804
805qc24_fail_command:
806        cmd->scsi_done(cmd);
807
808        return 0;
809}
810
811/*
812 * qla2x00_eh_wait_on_command
813 *    Waits for the command to be returned by the Firmware for some
814 *    max time.
815 *
816 * Input:
817 *    cmd = Scsi Command to wait on.
818 *
819 * Return:
820 *    Not Found : 0
821 *    Found : 1
822 */
823static int
824qla2x00_eh_wait_on_command(struct scsi_cmnd *cmd)
825{
826#define ABORT_POLLING_PERIOD    1000
827#define ABORT_WAIT_ITER         ((2 * 1000) / (ABORT_POLLING_PERIOD))
828        unsigned long wait_iter = ABORT_WAIT_ITER;
829        scsi_qla_host_t *vha = shost_priv(cmd->device->host);
830        struct qla_hw_data *ha = vha->hw;
831        int ret = QLA_SUCCESS;
832
833        if (unlikely(pci_channel_offline(ha->pdev)) || ha->flags.eeh_busy) {
834                ql_dbg(ql_dbg_taskm, vha, 0x8005,
835                    "Return:eh_wait.\n");
836                return ret;
837        }
838
839        while (CMD_SP(cmd) && wait_iter--) {
840                msleep(ABORT_POLLING_PERIOD);
841        }
842        if (CMD_SP(cmd))
843                ret = QLA_FUNCTION_FAILED;
844
845        return ret;
846}
847
848/*
849 * qla2x00_wait_for_hba_online
850 *    Wait till the HBA is online after going through
851 *    <= MAX_RETRIES_OF_ISP_ABORT  or
852 *    finally HBA is disabled ie marked offline
853 *
854 * Input:
855 *     ha - pointer to host adapter structure
856 *
857 * Note:
858 *    Does context switching-Release SPIN_LOCK
859 *    (if any) before calling this routine.
860 *
861 * Return:
862 *    Success (Adapter is online) : 0
863 *    Failed  (Adapter is offline/disabled) : 1
864 */
865int
866qla2x00_wait_for_hba_online(scsi_qla_host_t *vha)
867{
868        int             return_status;
869        unsigned long   wait_online;
870        struct qla_hw_data *ha = vha->hw;
871        scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
872
873        wait_online = jiffies + (MAX_LOOP_TIMEOUT * HZ);
874        while (((test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags)) ||
875            test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) ||
876            test_bit(ISP_ABORT_RETRY, &base_vha->dpc_flags) ||
877            ha->dpc_active) && time_before(jiffies, wait_online)) {
878
879                msleep(1000);
880        }
881        if (base_vha->flags.online)
882                return_status = QLA_SUCCESS;
883        else
884                return_status = QLA_FUNCTION_FAILED;
885
886        return (return_status);
887}
888
889/*
890 * qla2x00_wait_for_hba_ready
891 * Wait till the HBA is ready before doing driver unload
892 *
893 * Input:
894 *     ha - pointer to host adapter structure
895 *
896 * Note:
897 *    Does context switching-Release SPIN_LOCK
898 *    (if any) before calling this routine.
899 *
900 */
901static void
902qla2x00_wait_for_hba_ready(scsi_qla_host_t *vha)
903{
904        struct qla_hw_data *ha = vha->hw;
905        scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
906
907        while ((qla2x00_reset_active(vha) || ha->dpc_active ||
908                ha->flags.mbox_busy) ||
909               test_bit(FX00_RESET_RECOVERY, &vha->dpc_flags) ||
910               test_bit(FX00_TARGET_SCAN, &vha->dpc_flags)) {
911                if (test_bit(UNLOADING, &base_vha->dpc_flags))
912                        break;
913                msleep(1000);
914        }
915}
916
917int
918qla2x00_wait_for_chip_reset(scsi_qla_host_t *vha)
919{
920        int             return_status;
921        unsigned long   wait_reset;
922        struct qla_hw_data *ha = vha->hw;
923        scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
924
925        wait_reset = jiffies + (MAX_LOOP_TIMEOUT * HZ);
926        while (((test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags)) ||
927            test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) ||
928            test_bit(ISP_ABORT_RETRY, &base_vha->dpc_flags) ||
929            ha->dpc_active) && time_before(jiffies, wait_reset)) {
930
931                msleep(1000);
932
933                if (!test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags) &&
934                    ha->flags.chip_reset_done)
935                        break;
936        }
937        if (ha->flags.chip_reset_done)
938                return_status = QLA_SUCCESS;
939        else
940                return_status = QLA_FUNCTION_FAILED;
941
942        return return_status;
943}
944
945static void
946sp_get(struct srb *sp)
947{
948        atomic_inc(&sp->ref_count);
949}
950
951#define ISP_REG_DISCONNECT 0xffffffffU
952/**************************************************************************
953* qla2x00_isp_reg_stat
954*
955* Description:
956*       Read the host status register of ISP before aborting the command.
957*
958* Input:
959*       ha = pointer to host adapter structure.
960*
961*
962* Returns:
963*       Either true or false.
964*
965* Note: Return true if there is register disconnect.
966**************************************************************************/
967static inline
968uint32_t qla2x00_isp_reg_stat(struct qla_hw_data *ha)
969{
970        struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
971        struct device_reg_82xx __iomem *reg82 = &ha->iobase->isp82;
972
973        if (IS_P3P_TYPE(ha))
974                return ((RD_REG_DWORD(&reg82->host_int)) == ISP_REG_DISCONNECT);
975        else
976                return ((RD_REG_DWORD(&reg->host_status)) ==
977                        ISP_REG_DISCONNECT);
978}
979
980/**************************************************************************
981* qla2xxx_eh_abort
982*
983* Description:
984*    The abort function will abort the specified command.
985*
986* Input:
987*    cmd = Linux SCSI command packet to be aborted.
988*
989* Returns:
990*    Either SUCCESS or FAILED.
991*
992* Note:
993*    Only return FAILED if command not returned by firmware.
994**************************************************************************/
995static int
996qla2xxx_eh_abort(struct scsi_cmnd *cmd)
997{
998        scsi_qla_host_t *vha = shost_priv(cmd->device->host);
999        srb_t *sp;
1000        int ret;
1001        unsigned int id;
1002        uint64_t lun;
1003        unsigned long flags;
1004        int rval, wait = 0;
1005        struct qla_hw_data *ha = vha->hw;
1006
1007        if (qla2x00_isp_reg_stat(ha)) {
1008                ql_log(ql_log_info, vha, 0x8042,
1009                    "PCI/Register disconnect, exiting.\n");
1010                return FAILED;
1011        }
1012        if (!CMD_SP(cmd))
1013                return SUCCESS;
1014
1015        ret = fc_block_scsi_eh(cmd);
1016        if (ret != 0)
1017                return ret;
1018        ret = SUCCESS;
1019
1020        id = cmd->device->id;
1021        lun = cmd->device->lun;
1022
1023        spin_lock_irqsave(&ha->hardware_lock, flags);
1024        sp = (srb_t *) CMD_SP(cmd);
1025        if (!sp) {
1026                spin_unlock_irqrestore(&ha->hardware_lock, flags);
1027                return SUCCESS;
1028        }
1029
1030        ql_dbg(ql_dbg_taskm, vha, 0x8002,
1031            "Aborting from RISC nexus=%ld:%d:%llu sp=%p cmd=%p handle=%x\n",
1032            vha->host_no, id, lun, sp, cmd, sp->handle);
1033
1034        /* Get a reference to the sp and drop the lock.*/
1035        sp_get(sp);
1036
1037        spin_unlock_irqrestore(&ha->hardware_lock, flags);
1038        rval = ha->isp_ops->abort_command(sp);
1039        if (rval) {
1040                if (rval == QLA_FUNCTION_PARAMETER_ERROR)
1041                        ret = SUCCESS;
1042                else
1043                        ret = FAILED;
1044
1045                ql_dbg(ql_dbg_taskm, vha, 0x8003,
1046                    "Abort command mbx failed cmd=%p, rval=%x.\n", cmd, rval);
1047        } else {
1048                ql_dbg(ql_dbg_taskm, vha, 0x8004,
1049                    "Abort command mbx success cmd=%p.\n", cmd);
1050                wait = 1;
1051        }
1052
1053        spin_lock_irqsave(&ha->hardware_lock, flags);
1054        sp->done(ha, sp, 0);
1055        spin_unlock_irqrestore(&ha->hardware_lock, flags);
1056
1057        /* Did the command return during mailbox execution? */
1058        if (ret == FAILED && !CMD_SP(cmd))
1059                ret = SUCCESS;
1060
1061        /* Wait for the command to be returned. */
1062        if (wait) {
1063                if (qla2x00_eh_wait_on_command(cmd) != QLA_SUCCESS) {
1064                        ql_log(ql_log_warn, vha, 0x8006,
1065                            "Abort handler timed out cmd=%p.\n", cmd);
1066                        ret = FAILED;
1067                }
1068        }
1069
1070        ql_log(ql_log_info, vha, 0x801c,
1071            "Abort command issued nexus=%ld:%d:%llu --  %d %x.\n",
1072            vha->host_no, id, lun, wait, ret);
1073
1074        return ret;
1075}
1076
1077int
1078qla2x00_eh_wait_for_pending_commands(scsi_qla_host_t *vha, unsigned int t,
1079        uint64_t l, enum nexus_wait_type type)
1080{
1081        int cnt, match, status;
1082        unsigned long flags;
1083        struct qla_hw_data *ha = vha->hw;
1084        struct req_que *req;
1085        srb_t *sp;
1086        struct scsi_cmnd *cmd;
1087
1088        status = QLA_SUCCESS;
1089
1090        spin_lock_irqsave(&ha->hardware_lock, flags);
1091        req = vha->req;
1092        for (cnt = 1; status == QLA_SUCCESS &&
1093                cnt < req->num_outstanding_cmds; cnt++) {
1094                sp = req->outstanding_cmds[cnt];
1095                if (!sp)
1096                        continue;
1097                if (sp->type != SRB_SCSI_CMD)
1098                        continue;
1099                if (vha->vp_idx != sp->fcport->vha->vp_idx)
1100                        continue;
1101                match = 0;
1102                cmd = GET_CMD_SP(sp);
1103                switch (type) {
1104                case WAIT_HOST:
1105                        match = 1;
1106                        break;
1107                case WAIT_TARGET:
1108                        match = cmd->device->id == t;
1109                        break;
1110                case WAIT_LUN:
1111                        match = (cmd->device->id == t &&
1112                                cmd->device->lun == l);
1113                        break;
1114                }
1115                if (!match)
1116                        continue;
1117
1118                spin_unlock_irqrestore(&ha->hardware_lock, flags);
1119                status = qla2x00_eh_wait_on_command(cmd);
1120                spin_lock_irqsave(&ha->hardware_lock, flags);
1121        }
1122        spin_unlock_irqrestore(&ha->hardware_lock, flags);
1123
1124        return status;
1125}
1126
1127static char *reset_errors[] = {
1128        "HBA not online",
1129        "HBA not ready",
1130        "Task management failed",
1131        "Waiting for command completions",
1132};
1133
1134static int
1135__qla2xxx_eh_generic_reset(char *name, enum nexus_wait_type type,
1136    struct scsi_cmnd *cmd, int (*do_reset)(struct fc_port *, uint64_t, int))
1137{
1138        scsi_qla_host_t *vha = shost_priv(cmd->device->host);
1139        fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
1140        int err;
1141
1142        if (!fcport) {
1143                return FAILED;
1144        }
1145
1146        err = fc_block_scsi_eh(cmd);
1147        if (err != 0)
1148                return err;
1149
1150        ql_log(ql_log_info, vha, 0x8009,
1151            "%s RESET ISSUED nexus=%ld:%d:%llu cmd=%p.\n", name, vha->host_no,
1152            cmd->device->id, cmd->device->lun, cmd);
1153
1154        err = 0;
1155        if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
1156                ql_log(ql_log_warn, vha, 0x800a,
1157                    "Wait for hba online failed for cmd=%p.\n", cmd);
1158                goto eh_reset_failed;
1159        }
1160        err = 2;
1161        if (do_reset(fcport, cmd->device->lun, cmd->request->cpu + 1)
1162                != QLA_SUCCESS) {
1163                ql_log(ql_log_warn, vha, 0x800c,
1164                    "do_reset failed for cmd=%p.\n", cmd);
1165                goto eh_reset_failed;
1166        }
1167        err = 3;
1168        if (qla2x00_eh_wait_for_pending_commands(vha, cmd->device->id,
1169            cmd->device->lun, type) != QLA_SUCCESS) {
1170                ql_log(ql_log_warn, vha, 0x800d,
1171                    "wait for pending cmds failed for cmd=%p.\n", cmd);
1172                goto eh_reset_failed;
1173        }
1174
1175        ql_log(ql_log_info, vha, 0x800e,
1176            "%s RESET SUCCEEDED nexus:%ld:%d:%llu cmd=%p.\n", name,
1177            vha->host_no, cmd->device->id, cmd->device->lun, cmd);
1178
1179        return SUCCESS;
1180
1181eh_reset_failed:
1182        ql_log(ql_log_info, vha, 0x800f,
1183            "%s RESET FAILED: %s nexus=%ld:%d:%llu cmd=%p.\n", name,
1184            reset_errors[err], vha->host_no, cmd->device->id, cmd->device->lun,
1185            cmd);
1186        return FAILED;
1187}
1188
1189static int
1190qla2xxx_eh_device_reset(struct scsi_cmnd *cmd)
1191{
1192        scsi_qla_host_t *vha = shost_priv(cmd->device->host);
1193        struct qla_hw_data *ha = vha->hw;
1194
1195        if (qla2x00_isp_reg_stat(ha)) {
1196                ql_log(ql_log_info, vha, 0x803e,
1197                    "PCI/Register disconnect, exiting.\n");
1198                return FAILED;
1199        }
1200
1201        return __qla2xxx_eh_generic_reset("DEVICE", WAIT_LUN, cmd,
1202            ha->isp_ops->lun_reset);
1203}
1204
1205static int
1206qla2xxx_eh_target_reset(struct scsi_cmnd *cmd)
1207{
1208        scsi_qla_host_t *vha = shost_priv(cmd->device->host);
1209        struct qla_hw_data *ha = vha->hw;
1210
1211        if (qla2x00_isp_reg_stat(ha)) {
1212                ql_log(ql_log_info, vha, 0x803f,
1213                    "PCI/Register disconnect, exiting.\n");
1214                return FAILED;
1215        }
1216
1217        return __qla2xxx_eh_generic_reset("TARGET", WAIT_TARGET, cmd,
1218            ha->isp_ops->target_reset);
1219}
1220
1221/**************************************************************************
1222* qla2xxx_eh_bus_reset
1223*
1224* Description:
1225*    The bus reset function will reset the bus and abort any executing
1226*    commands.
1227*
1228* Input:
1229*    cmd = Linux SCSI command packet of the command that cause the
1230*          bus reset.
1231*
1232* Returns:
1233*    SUCCESS/FAILURE (defined as macro in scsi.h).
1234*
1235**************************************************************************/
1236static int
1237qla2xxx_eh_bus_reset(struct scsi_cmnd *cmd)
1238{
1239        scsi_qla_host_t *vha = shost_priv(cmd->device->host);
1240        fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
1241        int ret = FAILED;
1242        unsigned int id;
1243        uint64_t lun;
1244        struct qla_hw_data *ha = vha->hw;
1245
1246        if (qla2x00_isp_reg_stat(ha)) {
1247                ql_log(ql_log_info, vha, 0x8040,
1248                    "PCI/Register disconnect, exiting.\n");
1249                return FAILED;
1250        }
1251
1252        id = cmd->device->id;
1253        lun = cmd->device->lun;
1254
1255        if (!fcport) {
1256                return ret;
1257        }
1258
1259        ret = fc_block_scsi_eh(cmd);
1260        if (ret != 0)
1261                return ret;
1262        ret = FAILED;
1263
1264        ql_log(ql_log_info, vha, 0x8012,
1265            "BUS RESET ISSUED nexus=%ld:%d:%llu.\n", vha->host_no, id, lun);
1266
1267        if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
1268                ql_log(ql_log_fatal, vha, 0x8013,
1269                    "Wait for hba online failed board disabled.\n");
1270                goto eh_bus_reset_done;
1271        }
1272
1273        if (qla2x00_loop_reset(vha) == QLA_SUCCESS)
1274                ret = SUCCESS;
1275
1276        if (ret == FAILED)
1277                goto eh_bus_reset_done;
1278
1279        /* Flush outstanding commands. */
1280        if (qla2x00_eh_wait_for_pending_commands(vha, 0, 0, WAIT_HOST) !=
1281            QLA_SUCCESS) {
1282                ql_log(ql_log_warn, vha, 0x8014,
1283                    "Wait for pending commands failed.\n");
1284                ret = FAILED;
1285        }
1286
1287eh_bus_reset_done:
1288        ql_log(ql_log_warn, vha, 0x802b,
1289            "BUS RESET %s nexus=%ld:%d:%llu.\n",
1290            (ret == FAILED) ? "FAILED" : "SUCCEEDED", vha->host_no, id, lun);
1291
1292        return ret;
1293}
1294
1295/**************************************************************************
1296* qla2xxx_eh_host_reset
1297*
1298* Description:
1299*    The reset function will reset the Adapter.
1300*
1301* Input:
1302*      cmd = Linux SCSI command packet of the command that cause the
1303*            adapter reset.
1304*
1305* Returns:
1306*      Either SUCCESS or FAILED.
1307*
1308* Note:
1309**************************************************************************/
1310static int
1311qla2xxx_eh_host_reset(struct scsi_cmnd *cmd)
1312{
1313        scsi_qla_host_t *vha = shost_priv(cmd->device->host);
1314        struct qla_hw_data *ha = vha->hw;
1315        int ret = FAILED;
1316        unsigned int id;
1317        uint64_t lun;
1318        scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
1319
1320        if (qla2x00_isp_reg_stat(ha)) {
1321                ql_log(ql_log_info, vha, 0x8041,
1322                    "PCI/Register disconnect, exiting.\n");
1323                schedule_work(&ha->board_disable);
1324                return SUCCESS;
1325        }
1326
1327        id = cmd->device->id;
1328        lun = cmd->device->lun;
1329
1330        ql_log(ql_log_info, vha, 0x8018,
1331            "ADAPTER RESET ISSUED nexus=%ld:%d:%llu.\n", vha->host_no, id, lun);
1332
1333        /*
1334         * No point in issuing another reset if one is active.  Also do not
1335         * attempt a reset if we are updating flash.
1336         */
1337        if (qla2x00_reset_active(vha) || ha->optrom_state != QLA_SWAITING)
1338                goto eh_host_reset_lock;
1339
1340        if (vha != base_vha) {
1341                if (qla2x00_vp_abort_isp(vha))
1342                        goto eh_host_reset_lock;
1343        } else {
1344                if (IS_P3P_TYPE(vha->hw)) {
1345                        if (!qla82xx_fcoe_ctx_reset(vha)) {
1346                                /* Ctx reset success */
1347                                ret = SUCCESS;
1348                                goto eh_host_reset_lock;
1349                        }
1350                        /* fall thru if ctx reset failed */
1351                }
1352                if (ha->wq)
1353                        flush_workqueue(ha->wq);
1354
1355                set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
1356                if (ha->isp_ops->abort_isp(base_vha)) {
1357                        clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
1358                        /* failed. schedule dpc to try */
1359                        set_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags);
1360
1361                        if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
1362                                ql_log(ql_log_warn, vha, 0x802a,
1363                                    "wait for hba online failed.\n");
1364                                goto eh_host_reset_lock;
1365                        }
1366                }
1367                clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
1368        }
1369
1370        /* Waiting for command to be returned to OS.*/
1371        if (qla2x00_eh_wait_for_pending_commands(vha, 0, 0, WAIT_HOST) ==
1372                QLA_SUCCESS)
1373                ret = SUCCESS;
1374
1375eh_host_reset_lock:
1376        ql_log(ql_log_info, vha, 0x8017,
1377            "ADAPTER RESET %s nexus=%ld:%d:%llu.\n",
1378            (ret == FAILED) ? "FAILED" : "SUCCEEDED", vha->host_no, id, lun);
1379
1380        return ret;
1381}
1382
1383/*
1384* qla2x00_loop_reset
1385*      Issue loop reset.
1386*
1387* Input:
1388*      ha = adapter block pointer.
1389*
1390* Returns:
1391*      0 = success
1392*/
1393int
1394qla2x00_loop_reset(scsi_qla_host_t *vha)
1395{
1396        int ret;
1397        struct fc_port *fcport;
1398        struct qla_hw_data *ha = vha->hw;
1399
1400        if (IS_QLAFX00(ha)) {
1401                return qlafx00_loop_reset(vha);
1402        }
1403
1404        if (ql2xtargetreset == 1 && ha->flags.enable_target_reset) {
1405                list_for_each_entry(fcport, &vha->vp_fcports, list) {
1406                        if (fcport->port_type != FCT_TARGET)
1407                                continue;
1408
1409                        ret = ha->isp_ops->target_reset(fcport, 0, 0);
1410                        if (ret != QLA_SUCCESS) {
1411                                ql_dbg(ql_dbg_taskm, vha, 0x802c,
1412                                    "Bus Reset failed: Reset=%d "
1413                                    "d_id=%x.\n", ret, fcport->d_id.b24);
1414                        }
1415                }
1416        }
1417
1418
1419        if (ha->flags.enable_lip_full_login && !IS_CNA_CAPABLE(ha)) {
1420                atomic_set(&vha->loop_state, LOOP_DOWN);
1421                atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
1422                qla2x00_mark_all_devices_lost(vha, 0);
1423                ret = qla2x00_full_login_lip(vha);
1424                if (ret != QLA_SUCCESS) {
1425                        ql_dbg(ql_dbg_taskm, vha, 0x802d,
1426                            "full_login_lip=%d.\n", ret);
1427                }
1428        }
1429
1430        if (ha->flags.enable_lip_reset) {
1431                ret = qla2x00_lip_reset(vha);
1432                if (ret != QLA_SUCCESS)
1433                        ql_dbg(ql_dbg_taskm, vha, 0x802e,
1434                            "lip_reset failed (%d).\n", ret);
1435        }
1436
1437        /* Issue marker command only when we are going to start the I/O */
1438        vha->marker_needed = 1;
1439
1440        return QLA_SUCCESS;
1441}
1442
1443void
1444qla2x00_abort_all_cmds(scsi_qla_host_t *vha, int res)
1445{
1446        int que, cnt;
1447        unsigned long flags;
1448        srb_t *sp;
1449        struct qla_hw_data *ha = vha->hw;
1450        struct req_que *req;
1451
1452        qlt_host_reset_handler(ha);
1453
1454        spin_lock_irqsave(&ha->hardware_lock, flags);
1455        for (que = 0; que < ha->max_req_queues; que++) {
1456                req = ha->req_q_map[que];
1457                if (!req)
1458                        continue;
1459                if (!req->outstanding_cmds)
1460                        continue;
1461                for (cnt = 1; cnt < req->num_outstanding_cmds; cnt++) {
1462                        sp = req->outstanding_cmds[cnt];
1463                        if (sp) {
1464                                /* Don't abort commands in adapter during EEH
1465                                 * recovery as it's not accessible/responding.
1466                                 */
1467                                if (GET_CMD_SP(sp) && !ha->flags.eeh_busy) {
1468                                        /* Get a reference to the sp and drop the lock.
1469                                         * The reference ensures this sp->done() call
1470                                         * - and not the call in qla2xxx_eh_abort() -
1471                                         * ends the SCSI command (with result 'res').
1472                                         */
1473                                        sp_get(sp);
1474                                        spin_unlock_irqrestore(&ha->hardware_lock, flags);
1475                                        qla2xxx_eh_abort(GET_CMD_SP(sp));
1476                                        spin_lock_irqsave(&ha->hardware_lock, flags);
1477                                }
1478                                req->outstanding_cmds[cnt] = NULL;
1479                                sp->done(vha, sp, res);
1480                        }
1481                }
1482        }
1483        spin_unlock_irqrestore(&ha->hardware_lock, flags);
1484}
1485
1486static int
1487qla2xxx_slave_alloc(struct scsi_device *sdev)
1488{
1489        struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
1490
1491        if (!rport || fc_remote_port_chkready(rport))
1492                return -ENXIO;
1493
1494        sdev->hostdata = *(fc_port_t **)rport->dd_data;
1495
1496        return 0;
1497}
1498
1499static int
1500qla2xxx_slave_configure(struct scsi_device *sdev)
1501{
1502        scsi_qla_host_t *vha = shost_priv(sdev->host);
1503        struct req_que *req = vha->req;
1504
1505        if (IS_T10_PI_CAPABLE(vha->hw))
1506                blk_queue_update_dma_alignment(sdev->request_queue, 0x7);
1507
1508        scsi_change_queue_depth(sdev, req->max_q_depth);
1509        return 0;
1510}
1511
1512static void
1513qla2xxx_slave_destroy(struct scsi_device *sdev)
1514{
1515        sdev->hostdata = NULL;
1516}
1517
1518/**
1519 * qla2x00_config_dma_addressing() - Configure OS DMA addressing method.
1520 * @ha: HA context
1521 *
1522 * At exit, the @ha's flags.enable_64bit_addressing set to indicated
1523 * supported addressing method.
1524 */
1525static void
1526qla2x00_config_dma_addressing(struct qla_hw_data *ha)
1527{
1528        /* Assume a 32bit DMA mask. */
1529        ha->flags.enable_64bit_addressing = 0;
1530
1531        if (!dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(64))) {
1532                /* Any upper-dword bits set? */
1533                if (MSD(dma_get_required_mask(&ha->pdev->dev)) &&
1534                    !pci_set_consistent_dma_mask(ha->pdev, DMA_BIT_MASK(64))) {
1535                        /* Ok, a 64bit DMA mask is applicable. */
1536                        ha->flags.enable_64bit_addressing = 1;
1537                        ha->isp_ops->calc_req_entries = qla2x00_calc_iocbs_64;
1538                        ha->isp_ops->build_iocbs = qla2x00_build_scsi_iocbs_64;
1539                        return;
1540                }
1541        }
1542
1543        dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32));
1544        pci_set_consistent_dma_mask(ha->pdev, DMA_BIT_MASK(32));
1545}
1546
1547static void
1548qla2x00_enable_intrs(struct qla_hw_data *ha)
1549{
1550        unsigned long flags = 0;
1551        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1552
1553        spin_lock_irqsave(&ha->hardware_lock, flags);
1554        ha->interrupts_on = 1;
1555        /* enable risc and host interrupts */
1556        WRT_REG_WORD(&reg->ictrl, ICR_EN_INT | ICR_EN_RISC);
1557        RD_REG_WORD(&reg->ictrl);
1558        spin_unlock_irqrestore(&ha->hardware_lock, flags);
1559
1560}
1561
1562static void
1563qla2x00_disable_intrs(struct qla_hw_data *ha)
1564{
1565        unsigned long flags = 0;
1566        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1567
1568        spin_lock_irqsave(&ha->hardware_lock, flags);
1569        ha->interrupts_on = 0;
1570        /* disable risc and host interrupts */
1571        WRT_REG_WORD(&reg->ictrl, 0);
1572        RD_REG_WORD(&reg->ictrl);
1573        spin_unlock_irqrestore(&ha->hardware_lock, flags);
1574}
1575
1576static void
1577qla24xx_enable_intrs(struct qla_hw_data *ha)
1578{
1579        unsigned long flags = 0;
1580        struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1581
1582        spin_lock_irqsave(&ha->hardware_lock, flags);
1583        ha->interrupts_on = 1;
1584        WRT_REG_DWORD(&reg->ictrl, ICRX_EN_RISC_INT);
1585        RD_REG_DWORD(&reg->ictrl);
1586        spin_unlock_irqrestore(&ha->hardware_lock, flags);
1587}
1588
1589static void
1590qla24xx_disable_intrs(struct qla_hw_data *ha)
1591{
1592        unsigned long flags = 0;
1593        struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1594
1595        if (IS_NOPOLLING_TYPE(ha))
1596                return;
1597        spin_lock_irqsave(&ha->hardware_lock, flags);
1598        ha->interrupts_on = 0;
1599        WRT_REG_DWORD(&reg->ictrl, 0);
1600        RD_REG_DWORD(&reg->ictrl);
1601        spin_unlock_irqrestore(&ha->hardware_lock, flags);
1602}
1603
1604static int
1605qla2x00_iospace_config(struct qla_hw_data *ha)
1606{
1607        resource_size_t pio;
1608        uint16_t msix;
1609        int cpus;
1610
1611        if (pci_request_selected_regions(ha->pdev, ha->bars,
1612            QLA2XXX_DRIVER_NAME)) {
1613                ql_log_pci(ql_log_fatal, ha->pdev, 0x0011,
1614                    "Failed to reserve PIO/MMIO regions (%s), aborting.\n",
1615                    pci_name(ha->pdev));
1616                goto iospace_error_exit;
1617        }
1618        if (!(ha->bars & 1))
1619                goto skip_pio;
1620
1621        /* We only need PIO for Flash operations on ISP2312 v2 chips. */
1622        pio = pci_resource_start(ha->pdev, 0);
1623        if (pci_resource_flags(ha->pdev, 0) & IORESOURCE_IO) {
1624                if (pci_resource_len(ha->pdev, 0) < MIN_IOBASE_LEN) {
1625                        ql_log_pci(ql_log_warn, ha->pdev, 0x0012,
1626                            "Invalid pci I/O region size (%s).\n",
1627                            pci_name(ha->pdev));
1628                        pio = 0;
1629                }
1630        } else {
1631                ql_log_pci(ql_log_warn, ha->pdev, 0x0013,
1632                    "Region #0 no a PIO resource (%s).\n",
1633                    pci_name(ha->pdev));
1634                pio = 0;
1635        }
1636        ha->pio_address = pio;
1637        ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0014,
1638            "PIO address=%llu.\n",
1639            (unsigned long long)ha->pio_address);
1640
1641skip_pio:
1642        /* Use MMIO operations for all accesses. */
1643        if (!(pci_resource_flags(ha->pdev, 1) & IORESOURCE_MEM)) {
1644                ql_log_pci(ql_log_fatal, ha->pdev, 0x0015,
1645                    "Region #1 not an MMIO resource (%s), aborting.\n",
1646                    pci_name(ha->pdev));
1647                goto iospace_error_exit;
1648        }
1649        if (pci_resource_len(ha->pdev, 1) < MIN_IOBASE_LEN) {
1650                ql_log_pci(ql_log_fatal, ha->pdev, 0x0016,
1651                    "Invalid PCI mem region size (%s), aborting.\n",
1652                    pci_name(ha->pdev));
1653                goto iospace_error_exit;
1654        }
1655
1656        ha->iobase = ioremap(pci_resource_start(ha->pdev, 1), MIN_IOBASE_LEN);
1657        if (!ha->iobase) {
1658                ql_log_pci(ql_log_fatal, ha->pdev, 0x0017,
1659                    "Cannot remap MMIO (%s), aborting.\n",
1660                    pci_name(ha->pdev));
1661                goto iospace_error_exit;
1662        }
1663
1664        /* Determine queue resources */
1665        ha->max_req_queues = ha->max_rsp_queues = 1;
1666        if ((ql2xmaxqueues <= 1 && !ql2xmultique_tag) ||
1667                (ql2xmaxqueues > 1 && ql2xmultique_tag) ||
1668                (!IS_QLA25XX(ha) && !IS_QLA81XX(ha)))
1669                goto mqiobase_exit;
1670
1671        ha->mqiobase = ioremap(pci_resource_start(ha->pdev, 3),
1672                        pci_resource_len(ha->pdev, 3));
1673        if (ha->mqiobase) {
1674                ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0018,
1675                    "MQIO Base=%p.\n", ha->mqiobase);
1676                /* Read MSIX vector size of the board */
1677                pci_read_config_word(ha->pdev, QLA_PCI_MSIX_CONTROL, &msix);
1678                ha->msix_count = msix;
1679                /* Max queues are bounded by available msix vectors */
1680                /* queue 0 uses two msix vectors */
1681                if (ql2xmultique_tag) {
1682                        cpus = num_online_cpus();
1683                        ha->max_rsp_queues = (ha->msix_count - 1 > cpus) ?
1684                                (cpus + 1) : (ha->msix_count - 1);
1685                        ha->max_req_queues = 2;
1686                } else if (ql2xmaxqueues > 1) {
1687                        ha->max_req_queues = ql2xmaxqueues > QLA_MQ_SIZE ?
1688                            QLA_MQ_SIZE : ql2xmaxqueues;
1689                        ql_dbg_pci(ql_dbg_multiq, ha->pdev, 0xc008,
1690                            "QoS mode set, max no of request queues:%d.\n",
1691                            ha->max_req_queues);
1692                        ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0019,
1693                            "QoS mode set, max no of request queues:%d.\n",
1694                            ha->max_req_queues);
1695                }
1696                ql_log_pci(ql_log_info, ha->pdev, 0x001a,
1697                    "MSI-X vector count: %d.\n", msix);
1698        } else
1699                ql_log_pci(ql_log_info, ha->pdev, 0x001b,
1700                    "BAR 3 not enabled.\n");
1701
1702mqiobase_exit:
1703        ha->msix_count = ha->max_rsp_queues + 1;
1704        ql_dbg_pci(ql_dbg_init, ha->pdev, 0x001c,
1705            "MSIX Count:%d.\n", ha->msix_count);
1706        return (0);
1707
1708iospace_error_exit:
1709        return (-ENOMEM);
1710}
1711
1712
1713static int
1714qla83xx_iospace_config(struct qla_hw_data *ha)
1715{
1716        uint16_t msix;
1717        int cpus;
1718
1719        if (pci_request_selected_regions(ha->pdev, ha->bars,
1720            QLA2XXX_DRIVER_NAME)) {
1721                ql_log_pci(ql_log_fatal, ha->pdev, 0x0117,
1722                    "Failed to reserve PIO/MMIO regions (%s), aborting.\n",
1723                    pci_name(ha->pdev));
1724
1725                goto iospace_error_exit;
1726        }
1727
1728        /* Use MMIO operations for all accesses. */
1729        if (!(pci_resource_flags(ha->pdev, 0) & IORESOURCE_MEM)) {
1730                ql_log_pci(ql_log_warn, ha->pdev, 0x0118,
1731                    "Invalid pci I/O region size (%s).\n",
1732                    pci_name(ha->pdev));
1733                goto iospace_error_exit;
1734        }
1735        if (pci_resource_len(ha->pdev, 0) < MIN_IOBASE_LEN) {
1736                ql_log_pci(ql_log_warn, ha->pdev, 0x0119,
1737                    "Invalid PCI mem region size (%s), aborting\n",
1738                        pci_name(ha->pdev));
1739                goto iospace_error_exit;
1740        }
1741
1742        ha->iobase = ioremap(pci_resource_start(ha->pdev, 0), MIN_IOBASE_LEN);
1743        if (!ha->iobase) {
1744                ql_log_pci(ql_log_fatal, ha->pdev, 0x011a,
1745                    "Cannot remap MMIO (%s), aborting.\n",
1746                    pci_name(ha->pdev));
1747                goto iospace_error_exit;
1748        }
1749
1750        /* 64bit PCI BAR - BAR2 will correspoond to region 4 */
1751        /* 83XX 26XX always use MQ type access for queues
1752         * - mbar 2, a.k.a region 4 */
1753        ha->max_req_queues = ha->max_rsp_queues = 1;
1754        ha->mqiobase = ioremap(pci_resource_start(ha->pdev, 4),
1755                        pci_resource_len(ha->pdev, 4));
1756
1757        if (!ha->mqiobase) {
1758                ql_log_pci(ql_log_fatal, ha->pdev, 0x011d,
1759                    "BAR2/region4 not enabled\n");
1760                goto mqiobase_exit;
1761        }
1762
1763        ha->msixbase = ioremap(pci_resource_start(ha->pdev, 2),
1764                        pci_resource_len(ha->pdev, 2));
1765        if (ha->msixbase) {
1766                /* Read MSIX vector size of the board */
1767                pci_read_config_word(ha->pdev,
1768                    QLA_83XX_PCI_MSIX_CONTROL, &msix);
1769                ha->msix_count = msix;
1770                /* Max queues are bounded by available msix vectors */
1771                /* queue 0 uses two msix vectors */
1772                if (ql2xmultique_tag) {
1773                        cpus = num_online_cpus();
1774                        ha->max_rsp_queues = (ha->msix_count - 1 > cpus) ?
1775                                (cpus + 1) : (ha->msix_count - 1);
1776                        ha->max_req_queues = 2;
1777                } else if (ql2xmaxqueues > 1) {
1778                        ha->max_req_queues = ql2xmaxqueues > QLA_MQ_SIZE ?
1779                                                QLA_MQ_SIZE : ql2xmaxqueues;
1780                        ql_dbg_pci(ql_dbg_multiq, ha->pdev, 0xc00c,
1781                            "QoS mode set, max no of request queues:%d.\n",
1782                            ha->max_req_queues);
1783                        ql_dbg_pci(ql_dbg_init, ha->pdev, 0x011b,
1784                            "QoS mode set, max no of request queues:%d.\n",
1785                            ha->max_req_queues);
1786                }
1787                ql_log_pci(ql_log_info, ha->pdev, 0x011c,
1788                    "MSI-X vector count: %d.\n", msix);
1789        } else
1790                ql_log_pci(ql_log_info, ha->pdev, 0x011e,
1791                    "BAR 1 not enabled.\n");
1792
1793mqiobase_exit:
1794        ha->msix_count = ha->max_rsp_queues + 1;
1795
1796        qlt_83xx_iospace_config(ha);
1797
1798        ql_dbg_pci(ql_dbg_init, ha->pdev, 0x011f,
1799            "MSIX Count:%d.\n", ha->msix_count);
1800        return 0;
1801
1802iospace_error_exit:
1803        return -ENOMEM;
1804}
1805
1806static struct isp_operations qla2100_isp_ops = {
1807        .pci_config             = qla2100_pci_config,
1808        .reset_chip             = qla2x00_reset_chip,
1809        .chip_diag              = qla2x00_chip_diag,
1810        .config_rings           = qla2x00_config_rings,
1811        .reset_adapter          = qla2x00_reset_adapter,
1812        .nvram_config           = qla2x00_nvram_config,
1813        .update_fw_options      = qla2x00_update_fw_options,
1814        .load_risc              = qla2x00_load_risc,
1815        .pci_info_str           = qla2x00_pci_info_str,
1816        .fw_version_str         = qla2x00_fw_version_str,
1817        .intr_handler           = qla2100_intr_handler,
1818        .enable_intrs           = qla2x00_enable_intrs,
1819        .disable_intrs          = qla2x00_disable_intrs,
1820        .abort_command          = qla2x00_abort_command,
1821        .target_reset           = qla2x00_abort_target,
1822        .lun_reset              = qla2x00_lun_reset,
1823        .fabric_login           = qla2x00_login_fabric,
1824        .fabric_logout          = qla2x00_fabric_logout,
1825        .calc_req_entries       = qla2x00_calc_iocbs_32,
1826        .build_iocbs            = qla2x00_build_scsi_iocbs_32,
1827        .prep_ms_iocb           = qla2x00_prep_ms_iocb,
1828        .prep_ms_fdmi_iocb      = qla2x00_prep_ms_fdmi_iocb,
1829        .read_nvram             = qla2x00_read_nvram_data,
1830        .write_nvram            = qla2x00_write_nvram_data,
1831        .fw_dump                = qla2100_fw_dump,
1832        .beacon_on              = NULL,
1833        .beacon_off             = NULL,
1834        .beacon_blink           = NULL,
1835        .read_optrom            = qla2x00_read_optrom_data,
1836        .write_optrom           = qla2x00_write_optrom_data,
1837        .get_flash_version      = qla2x00_get_flash_version,
1838        .start_scsi             = qla2x00_start_scsi,
1839        .abort_isp              = qla2x00_abort_isp,
1840        .iospace_config         = qla2x00_iospace_config,
1841        .initialize_adapter     = qla2x00_initialize_adapter,
1842};
1843
1844static struct isp_operations qla2300_isp_ops = {
1845        .pci_config             = qla2300_pci_config,
1846        .reset_chip             = qla2x00_reset_chip,
1847        .chip_diag              = qla2x00_chip_diag,
1848        .config_rings           = qla2x00_config_rings,
1849        .reset_adapter          = qla2x00_reset_adapter,
1850        .nvram_config           = qla2x00_nvram_config,
1851        .update_fw_options      = qla2x00_update_fw_options,
1852        .load_risc              = qla2x00_load_risc,
1853        .pci_info_str           = qla2x00_pci_info_str,
1854        .fw_version_str         = qla2x00_fw_version_str,
1855        .intr_handler           = qla2300_intr_handler,
1856        .enable_intrs           = qla2x00_enable_intrs,
1857        .disable_intrs          = qla2x00_disable_intrs,
1858        .abort_command          = qla2x00_abort_command,
1859        .target_reset           = qla2x00_abort_target,
1860        .lun_reset              = qla2x00_lun_reset,
1861        .fabric_login           = qla2x00_login_fabric,
1862        .fabric_logout          = qla2x00_fabric_logout,
1863        .calc_req_entries       = qla2x00_calc_iocbs_32,
1864        .build_iocbs            = qla2x00_build_scsi_iocbs_32,
1865        .prep_ms_iocb           = qla2x00_prep_ms_iocb,
1866        .prep_ms_fdmi_iocb      = qla2x00_prep_ms_fdmi_iocb,
1867        .read_nvram             = qla2x00_read_nvram_data,
1868        .write_nvram            = qla2x00_write_nvram_data,
1869        .fw_dump                = qla2300_fw_dump,
1870        .beacon_on              = qla2x00_beacon_on,
1871        .beacon_off             = qla2x00_beacon_off,
1872        .beacon_blink           = qla2x00_beacon_blink,
1873        .read_optrom            = qla2x00_read_optrom_data,
1874        .write_optrom           = qla2x00_write_optrom_data,
1875        .get_flash_version      = qla2x00_get_flash_version,
1876        .start_scsi             = qla2x00_start_scsi,
1877        .abort_isp              = qla2x00_abort_isp,
1878        .iospace_config         = qla2x00_iospace_config,
1879        .initialize_adapter     = qla2x00_initialize_adapter,
1880};
1881
1882static struct isp_operations qla24xx_isp_ops = {
1883        .pci_config             = qla24xx_pci_config,
1884        .reset_chip             = qla24xx_reset_chip,
1885        .chip_diag              = qla24xx_chip_diag,
1886        .config_rings           = qla24xx_config_rings,
1887        .reset_adapter          = qla24xx_reset_adapter,
1888        .nvram_config           = qla24xx_nvram_config,
1889        .update_fw_options      = qla24xx_update_fw_options,
1890        .load_risc              = qla24xx_load_risc,
1891        .pci_info_str           = qla24xx_pci_info_str,
1892        .fw_version_str         = qla24xx_fw_version_str,
1893        .intr_handler           = qla24xx_intr_handler,
1894        .enable_intrs           = qla24xx_enable_intrs,
1895        .disable_intrs          = qla24xx_disable_intrs,
1896        .abort_command          = qla24xx_abort_command,
1897        .target_reset           = qla24xx_abort_target,
1898        .lun_reset              = qla24xx_lun_reset,
1899        .fabric_login           = qla24xx_login_fabric,
1900        .fabric_logout          = qla24xx_fabric_logout,
1901        .calc_req_entries       = NULL,
1902        .build_iocbs            = NULL,
1903        .prep_ms_iocb           = qla24xx_prep_ms_iocb,
1904        .prep_ms_fdmi_iocb      = qla24xx_prep_ms_fdmi_iocb,
1905        .read_nvram             = qla24xx_read_nvram_data,
1906        .write_nvram            = qla24xx_write_nvram_data,
1907        .fw_dump                = qla24xx_fw_dump,
1908        .beacon_on              = qla24xx_beacon_on,
1909        .beacon_off             = qla24xx_beacon_off,
1910        .beacon_blink           = qla24xx_beacon_blink,
1911        .read_optrom            = qla24xx_read_optrom_data,
1912        .write_optrom           = qla24xx_write_optrom_data,
1913        .get_flash_version      = qla24xx_get_flash_version,
1914        .start_scsi             = qla24xx_start_scsi,
1915        .abort_isp              = qla2x00_abort_isp,
1916        .iospace_config         = qla2x00_iospace_config,
1917        .initialize_adapter     = qla2x00_initialize_adapter,
1918};
1919
1920static struct isp_operations qla25xx_isp_ops = {
1921        .pci_config             = qla25xx_pci_config,
1922        .reset_chip             = qla24xx_reset_chip,
1923        .chip_diag              = qla24xx_chip_diag,
1924        .config_rings           = qla24xx_config_rings,
1925        .reset_adapter          = qla24xx_reset_adapter,
1926        .nvram_config           = qla24xx_nvram_config,
1927        .update_fw_options      = qla24xx_update_fw_options,
1928        .load_risc              = qla24xx_load_risc,
1929        .pci_info_str           = qla24xx_pci_info_str,
1930        .fw_version_str         = qla24xx_fw_version_str,
1931        .intr_handler           = qla24xx_intr_handler,
1932        .enable_intrs           = qla24xx_enable_intrs,
1933        .disable_intrs          = qla24xx_disable_intrs,
1934        .abort_command          = qla24xx_abort_command,
1935        .target_reset           = qla24xx_abort_target,
1936        .lun_reset              = qla24xx_lun_reset,
1937        .fabric_login           = qla24xx_login_fabric,
1938        .fabric_logout          = qla24xx_fabric_logout,
1939        .calc_req_entries       = NULL,
1940        .build_iocbs            = NULL,
1941        .prep_ms_iocb           = qla24xx_prep_ms_iocb,
1942        .prep_ms_fdmi_iocb      = qla24xx_prep_ms_fdmi_iocb,
1943        .read_nvram             = qla25xx_read_nvram_data,
1944        .write_nvram            = qla25xx_write_nvram_data,
1945        .fw_dump                = qla25xx_fw_dump,
1946        .beacon_on              = qla24xx_beacon_on,
1947        .beacon_off             = qla24xx_beacon_off,
1948        .beacon_blink           = qla24xx_beacon_blink,
1949        .read_optrom            = qla25xx_read_optrom_data,
1950        .write_optrom           = qla24xx_write_optrom_data,
1951        .get_flash_version      = qla24xx_get_flash_version,
1952        .start_scsi             = qla24xx_dif_start_scsi,
1953        .abort_isp              = qla2x00_abort_isp,
1954        .iospace_config         = qla2x00_iospace_config,
1955        .initialize_adapter     = qla2x00_initialize_adapter,
1956};
1957
1958static struct isp_operations qla81xx_isp_ops = {
1959        .pci_config             = qla25xx_pci_config,
1960        .reset_chip             = qla24xx_reset_chip,
1961        .chip_diag              = qla24xx_chip_diag,
1962        .config_rings           = qla24xx_config_rings,
1963        .reset_adapter          = qla24xx_reset_adapter,
1964        .nvram_config           = qla81xx_nvram_config,
1965        .update_fw_options      = qla81xx_update_fw_options,
1966        .load_risc              = qla81xx_load_risc,
1967        .pci_info_str           = qla24xx_pci_info_str,
1968        .fw_version_str         = qla24xx_fw_version_str,
1969        .intr_handler           = qla24xx_intr_handler,
1970        .enable_intrs           = qla24xx_enable_intrs,
1971        .disable_intrs          = qla24xx_disable_intrs,
1972        .abort_command          = qla24xx_abort_command,
1973        .target_reset           = qla24xx_abort_target,
1974        .lun_reset              = qla24xx_lun_reset,
1975        .fabric_login           = qla24xx_login_fabric,
1976        .fabric_logout          = qla24xx_fabric_logout,
1977        .calc_req_entries       = NULL,
1978        .build_iocbs            = NULL,
1979        .prep_ms_iocb           = qla24xx_prep_ms_iocb,
1980        .prep_ms_fdmi_iocb      = qla24xx_prep_ms_fdmi_iocb,
1981        .read_nvram             = NULL,
1982        .write_nvram            = NULL,
1983        .fw_dump                = qla81xx_fw_dump,
1984        .beacon_on              = qla24xx_beacon_on,
1985        .beacon_off             = qla24xx_beacon_off,
1986        .beacon_blink           = qla83xx_beacon_blink,
1987        .read_optrom            = qla25xx_read_optrom_data,
1988        .write_optrom           = qla24xx_write_optrom_data,
1989        .get_flash_version      = qla24xx_get_flash_version,
1990        .start_scsi             = qla24xx_dif_start_scsi,
1991        .abort_isp              = qla2x00_abort_isp,
1992        .iospace_config         = qla2x00_iospace_config,
1993        .initialize_adapter     = qla2x00_initialize_adapter,
1994};
1995
1996static struct isp_operations qla82xx_isp_ops = {
1997        .pci_config             = qla82xx_pci_config,
1998        .reset_chip             = qla82xx_reset_chip,
1999        .chip_diag              = qla24xx_chip_diag,
2000        .config_rings           = qla82xx_config_rings,
2001        .reset_adapter          = qla24xx_reset_adapter,
2002        .nvram_config           = qla81xx_nvram_config,
2003        .update_fw_options      = qla24xx_update_fw_options,
2004        .load_risc              = qla82xx_load_risc,
2005        .pci_info_str           = qla24xx_pci_info_str,
2006        .fw_version_str         = qla24xx_fw_version_str,
2007        .intr_handler           = qla82xx_intr_handler,
2008        .enable_intrs           = qla82xx_enable_intrs,
2009        .disable_intrs          = qla82xx_disable_intrs,
2010        .abort_command          = qla24xx_abort_command,
2011        .target_reset           = qla24xx_abort_target,
2012        .lun_reset              = qla24xx_lun_reset,
2013        .fabric_login           = qla24xx_login_fabric,
2014        .fabric_logout          = qla24xx_fabric_logout,
2015        .calc_req_entries       = NULL,
2016        .build_iocbs            = NULL,
2017        .prep_ms_iocb           = qla24xx_prep_ms_iocb,
2018        .prep_ms_fdmi_iocb      = qla24xx_prep_ms_fdmi_iocb,
2019        .read_nvram             = qla24xx_read_nvram_data,
2020        .write_nvram            = qla24xx_write_nvram_data,
2021        .fw_dump                = qla82xx_fw_dump,
2022        .beacon_on              = qla82xx_beacon_on,
2023        .beacon_off             = qla82xx_beacon_off,
2024        .beacon_blink           = NULL,
2025        .read_optrom            = qla82xx_read_optrom_data,
2026        .write_optrom           = qla82xx_write_optrom_data,
2027        .get_flash_version      = qla82xx_get_flash_version,
2028        .start_scsi             = qla82xx_start_scsi,
2029        .abort_isp              = qla82xx_abort_isp,
2030        .iospace_config         = qla82xx_iospace_config,
2031        .initialize_adapter     = qla2x00_initialize_adapter,
2032};
2033
2034static struct isp_operations qla8044_isp_ops = {
2035        .pci_config             = qla82xx_pci_config,
2036        .reset_chip             = qla82xx_reset_chip,
2037        .chip_diag              = qla24xx_chip_diag,
2038        .config_rings           = qla82xx_config_rings,
2039        .reset_adapter          = qla24xx_reset_adapter,
2040        .nvram_config           = qla81xx_nvram_config,
2041        .update_fw_options      = qla24xx_update_fw_options,
2042        .load_risc              = qla82xx_load_risc,
2043        .pci_info_str           = qla24xx_pci_info_str,
2044        .fw_version_str         = qla24xx_fw_version_str,
2045        .intr_handler           = qla8044_intr_handler,
2046        .enable_intrs           = qla82xx_enable_intrs,
2047        .disable_intrs          = qla82xx_disable_intrs,
2048        .abort_command          = qla24xx_abort_command,
2049        .target_reset           = qla24xx_abort_target,
2050        .lun_reset              = qla24xx_lun_reset,
2051        .fabric_login           = qla24xx_login_fabric,
2052        .fabric_logout          = qla24xx_fabric_logout,
2053        .calc_req_entries       = NULL,
2054        .build_iocbs            = NULL,
2055        .prep_ms_iocb           = qla24xx_prep_ms_iocb,
2056        .prep_ms_fdmi_iocb      = qla24xx_prep_ms_fdmi_iocb,
2057        .read_nvram             = NULL,
2058        .write_nvram            = NULL,
2059        .fw_dump                = qla8044_fw_dump,
2060        .beacon_on              = qla82xx_beacon_on,
2061        .beacon_off             = qla82xx_beacon_off,
2062        .beacon_blink           = NULL,
2063        .read_optrom            = qla8044_read_optrom_data,
2064        .write_optrom           = qla8044_write_optrom_data,
2065        .get_flash_version      = qla82xx_get_flash_version,
2066        .start_scsi             = qla82xx_start_scsi,
2067        .abort_isp              = qla8044_abort_isp,
2068        .iospace_config         = qla82xx_iospace_config,
2069        .initialize_adapter     = qla2x00_initialize_adapter,
2070};
2071
2072static struct isp_operations qla83xx_isp_ops = {
2073        .pci_config             = qla25xx_pci_config,
2074        .reset_chip             = qla24xx_reset_chip,
2075        .chip_diag              = qla24xx_chip_diag,
2076        .config_rings           = qla24xx_config_rings,
2077        .reset_adapter          = qla24xx_reset_adapter,
2078        .nvram_config           = qla81xx_nvram_config,
2079        .update_fw_options      = qla81xx_update_fw_options,
2080        .load_risc              = qla81xx_load_risc,
2081        .pci_info_str           = qla24xx_pci_info_str,
2082        .fw_version_str         = qla24xx_fw_version_str,
2083        .intr_handler           = qla24xx_intr_handler,
2084        .enable_intrs           = qla24xx_enable_intrs,
2085        .disable_intrs          = qla24xx_disable_intrs,
2086        .abort_command          = qla24xx_abort_command,
2087        .target_reset           = qla24xx_abort_target,
2088        .lun_reset              = qla24xx_lun_reset,
2089        .fabric_login           = qla24xx_login_fabric,
2090        .fabric_logout          = qla24xx_fabric_logout,
2091        .calc_req_entries       = NULL,
2092        .build_iocbs            = NULL,
2093        .prep_ms_iocb           = qla24xx_prep_ms_iocb,
2094        .prep_ms_fdmi_iocb      = qla24xx_prep_ms_fdmi_iocb,
2095        .read_nvram             = NULL,
2096        .write_nvram            = NULL,
2097        .fw_dump                = qla83xx_fw_dump,
2098        .beacon_on              = qla24xx_beacon_on,
2099        .beacon_off             = qla24xx_beacon_off,
2100        .beacon_blink           = qla83xx_beacon_blink,
2101        .read_optrom            = qla25xx_read_optrom_data,
2102        .write_optrom           = qla24xx_write_optrom_data,
2103        .get_flash_version      = qla24xx_get_flash_version,
2104        .start_scsi             = qla24xx_dif_start_scsi,
2105        .abort_isp              = qla2x00_abort_isp,
2106        .iospace_config         = qla83xx_iospace_config,
2107        .initialize_adapter     = qla2x00_initialize_adapter,
2108};
2109
2110static struct isp_operations qlafx00_isp_ops = {
2111        .pci_config             = qlafx00_pci_config,
2112        .reset_chip             = qlafx00_soft_reset,
2113        .chip_diag              = qlafx00_chip_diag,
2114        .config_rings           = qlafx00_config_rings,
2115        .reset_adapter          = qlafx00_soft_reset,
2116        .nvram_config           = NULL,
2117        .update_fw_options      = NULL,
2118        .load_risc              = NULL,
2119        .pci_info_str           = qlafx00_pci_info_str,
2120        .fw_version_str         = qlafx00_fw_version_str,
2121        .intr_handler           = qlafx00_intr_handler,
2122        .enable_intrs           = qlafx00_enable_intrs,
2123        .disable_intrs          = qlafx00_disable_intrs,
2124        .abort_command          = qla24xx_async_abort_command,
2125        .target_reset           = qlafx00_abort_target,
2126        .lun_reset              = qlafx00_lun_reset,
2127        .fabric_login           = NULL,
2128        .fabric_logout          = NULL,
2129        .calc_req_entries       = NULL,
2130        .build_iocbs            = NULL,
2131        .prep_ms_iocb           = qla24xx_prep_ms_iocb,
2132        .prep_ms_fdmi_iocb      = qla24xx_prep_ms_fdmi_iocb,
2133        .read_nvram             = qla24xx_read_nvram_data,
2134        .write_nvram            = qla24xx_write_nvram_data,
2135        .fw_dump                = NULL,
2136        .beacon_on              = qla24xx_beacon_on,
2137        .beacon_off             = qla24xx_beacon_off,
2138        .beacon_blink           = NULL,
2139        .read_optrom            = qla24xx_read_optrom_data,
2140        .write_optrom           = qla24xx_write_optrom_data,
2141        .get_flash_version      = qla24xx_get_flash_version,
2142        .start_scsi             = qlafx00_start_scsi,
2143        .abort_isp              = qlafx00_abort_isp,
2144        .iospace_config         = qlafx00_iospace_config,
2145        .initialize_adapter     = qlafx00_initialize_adapter,
2146};
2147
2148static struct isp_operations qla27xx_isp_ops = {
2149        .pci_config             = qla25xx_pci_config,
2150        .reset_chip             = qla24xx_reset_chip,
2151        .chip_diag              = qla24xx_chip_diag,
2152        .config_rings           = qla24xx_config_rings,
2153        .reset_adapter          = qla24xx_reset_adapter,
2154        .nvram_config           = qla81xx_nvram_config,
2155        .update_fw_options      = qla81xx_update_fw_options,
2156        .load_risc              = qla81xx_load_risc,
2157        .pci_info_str           = qla24xx_pci_info_str,
2158        .fw_version_str         = qla24xx_fw_version_str,
2159        .intr_handler           = qla24xx_intr_handler,
2160        .enable_intrs           = qla24xx_enable_intrs,
2161        .disable_intrs          = qla24xx_disable_intrs,
2162        .abort_command          = qla24xx_abort_command,
2163        .target_reset           = qla24xx_abort_target,
2164        .lun_reset              = qla24xx_lun_reset,
2165        .fabric_login           = qla24xx_login_fabric,
2166        .fabric_logout          = qla24xx_fabric_logout,
2167        .calc_req_entries       = NULL,
2168        .build_iocbs            = NULL,
2169        .prep_ms_iocb           = qla24xx_prep_ms_iocb,
2170        .prep_ms_fdmi_iocb      = qla24xx_prep_ms_fdmi_iocb,
2171        .read_nvram             = NULL,
2172        .write_nvram            = NULL,
2173        .fw_dump                = qla27xx_fwdump,
2174        .beacon_on              = qla24xx_beacon_on,
2175        .beacon_off             = qla24xx_beacon_off,
2176        .beacon_blink           = qla83xx_beacon_blink,
2177        .read_optrom            = qla25xx_read_optrom_data,
2178        .write_optrom           = qla24xx_write_optrom_data,
2179        .get_flash_version      = qla24xx_get_flash_version,
2180        .start_scsi             = qla24xx_dif_start_scsi,
2181        .abort_isp              = qla2x00_abort_isp,
2182        .iospace_config         = qla83xx_iospace_config,
2183        .initialize_adapter     = qla2x00_initialize_adapter,
2184};
2185
2186static inline void
2187qla2x00_set_isp_flags(struct qla_hw_data *ha)
2188{
2189        ha->device_type = DT_EXTENDED_IDS;
2190        switch (ha->pdev->device) {
2191        case PCI_DEVICE_ID_QLOGIC_ISP2100:
2192                ha->isp_type |= DT_ISP2100;
2193                ha->device_type &= ~DT_EXTENDED_IDS;
2194                ha->fw_srisc_address = RISC_START_ADDRESS_2100;
2195                break;
2196        case PCI_DEVICE_ID_QLOGIC_ISP2200:
2197                ha->isp_type |= DT_ISP2200;
2198                ha->device_type &= ~DT_EXTENDED_IDS;
2199                ha->fw_srisc_address = RISC_START_ADDRESS_2100;
2200                break;
2201        case PCI_DEVICE_ID_QLOGIC_ISP2300:
2202                ha->isp_type |= DT_ISP2300;
2203                ha->device_type |= DT_ZIO_SUPPORTED;
2204                ha->fw_srisc_address = RISC_START_ADDRESS_2300;
2205                break;
2206        case PCI_DEVICE_ID_QLOGIC_ISP2312:
2207                ha->isp_type |= DT_ISP2312;
2208                ha->device_type |= DT_ZIO_SUPPORTED;
2209                ha->fw_srisc_address = RISC_START_ADDRESS_2300;
2210                break;
2211        case PCI_DEVICE_ID_QLOGIC_ISP2322:
2212                ha->isp_type |= DT_ISP2322;
2213                ha->device_type |= DT_ZIO_SUPPORTED;
2214                if (ha->pdev->subsystem_vendor == 0x1028 &&
2215                    ha->pdev->subsystem_device == 0x0170)
2216                        ha->device_type |= DT_OEM_001;
2217                ha->fw_srisc_address = RISC_START_ADDRESS_2300;
2218                break;
2219        case PCI_DEVICE_ID_QLOGIC_ISP6312:
2220                ha->isp_type |= DT_ISP6312;
2221                ha->fw_srisc_address = RISC_START_ADDRESS_2300;
2222                break;
2223        case PCI_DEVICE_ID_QLOGIC_ISP6322:
2224                ha->isp_type |= DT_ISP6322;
2225                ha->fw_srisc_address = RISC_START_ADDRESS_2300;
2226                break;
2227        case PCI_DEVICE_ID_QLOGIC_ISP2422:
2228                ha->isp_type |= DT_ISP2422;
2229                ha->device_type |= DT_ZIO_SUPPORTED;
2230                ha->device_type |= DT_FWI2;
2231                ha->device_type |= DT_IIDMA;
2232                ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2233                break;
2234        case PCI_DEVICE_ID_QLOGIC_ISP2432:
2235                ha->isp_type |= DT_ISP2432;
2236                ha->device_type |= DT_ZIO_SUPPORTED;
2237                ha->device_type |= DT_FWI2;
2238                ha->device_type |= DT_IIDMA;
2239                ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2240                break;
2241        case PCI_DEVICE_ID_QLOGIC_ISP8432:
2242                ha->isp_type |= DT_ISP8432;
2243                ha->device_type |= DT_ZIO_SUPPORTED;
2244                ha->device_type |= DT_FWI2;
2245                ha->device_type |= DT_IIDMA;
2246                ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2247                break;
2248        case PCI_DEVICE_ID_QLOGIC_ISP5422:
2249                ha->isp_type |= DT_ISP5422;
2250                ha->device_type |= DT_FWI2;
2251                ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2252                break;
2253        case PCI_DEVICE_ID_QLOGIC_ISP5432:
2254                ha->isp_type |= DT_ISP5432;
2255                ha->device_type |= DT_FWI2;
2256                ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2257                break;
2258        case PCI_DEVICE_ID_QLOGIC_ISP2532:
2259                ha->isp_type |= DT_ISP2532;
2260                ha->device_type |= DT_ZIO_SUPPORTED;
2261                ha->device_type |= DT_FWI2;
2262                ha->device_type |= DT_IIDMA;
2263                ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2264                break;
2265        case PCI_DEVICE_ID_QLOGIC_ISP8001:
2266                ha->isp_type |= DT_ISP8001;
2267                ha->device_type |= DT_ZIO_SUPPORTED;
2268                ha->device_type |= DT_FWI2;
2269                ha->device_type |= DT_IIDMA;
2270                ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2271                break;
2272        case PCI_DEVICE_ID_QLOGIC_ISP8021:
2273                ha->isp_type |= DT_ISP8021;
2274                ha->device_type |= DT_ZIO_SUPPORTED;
2275                ha->device_type |= DT_FWI2;
2276                ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2277                /* Initialize 82XX ISP flags */
2278                qla82xx_init_flags(ha);
2279                break;
2280         case PCI_DEVICE_ID_QLOGIC_ISP8044:
2281                ha->isp_type |= DT_ISP8044;
2282                ha->device_type |= DT_ZIO_SUPPORTED;
2283                ha->device_type |= DT_FWI2;
2284                ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2285                /* Initialize 82XX ISP flags */
2286                qla82xx_init_flags(ha);
2287                break;
2288        case PCI_DEVICE_ID_QLOGIC_ISP2031:
2289                ha->isp_type |= DT_ISP2031;
2290                ha->device_type |= DT_ZIO_SUPPORTED;
2291                ha->device_type |= DT_FWI2;
2292                ha->device_type |= DT_IIDMA;
2293                ha->device_type |= DT_T10_PI;
2294                ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2295                break;
2296        case PCI_DEVICE_ID_QLOGIC_ISP8031:
2297                ha->isp_type |= DT_ISP8031;
2298                ha->device_type |= DT_ZIO_SUPPORTED;
2299                ha->device_type |= DT_FWI2;
2300                ha->device_type |= DT_IIDMA;
2301                ha->device_type |= DT_T10_PI;
2302                ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2303                break;
2304        case PCI_DEVICE_ID_QLOGIC_ISPF001:
2305                ha->isp_type |= DT_ISPFX00;
2306                break;
2307        case PCI_DEVICE_ID_QLOGIC_ISP2071:
2308                ha->isp_type |= DT_ISP2071;
2309                ha->device_type |= DT_ZIO_SUPPORTED;
2310                ha->device_type |= DT_FWI2;
2311                ha->device_type |= DT_IIDMA;
2312                ha->device_type |= DT_T10_PI;
2313                ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2314                break;
2315        case PCI_DEVICE_ID_QLOGIC_ISP2271:
2316                ha->isp_type |= DT_ISP2271;
2317                ha->device_type |= DT_ZIO_SUPPORTED;
2318                ha->device_type |= DT_FWI2;
2319                ha->device_type |= DT_IIDMA;
2320                ha->device_type |= DT_T10_PI;
2321                ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2322                break;
2323        case PCI_DEVICE_ID_QLOGIC_ISP2261:
2324                ha->isp_type |= DT_ISP2261;
2325                ha->device_type |= DT_ZIO_SUPPORTED;
2326                ha->device_type |= DT_FWI2;
2327                ha->device_type |= DT_IIDMA;
2328                ha->device_type |= DT_T10_PI;
2329                ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2330                break;
2331        }
2332
2333        if (IS_QLA82XX(ha))
2334                ha->port_no = ha->portnum & 1;
2335        else {
2336                /* Get adapter physical port no from interrupt pin register. */
2337                pci_read_config_byte(ha->pdev, PCI_INTERRUPT_PIN, &ha->port_no);
2338                if (IS_QLA27XX(ha))
2339                        ha->port_no--;
2340                else
2341                        ha->port_no = !(ha->port_no & 1);
2342        }
2343
2344        ql_dbg_pci(ql_dbg_init, ha->pdev, 0x000b,
2345            "device_type=0x%x port=%d fw_srisc_address=0x%x.\n",
2346            ha->device_type, ha->port_no, ha->fw_srisc_address);
2347}
2348
2349static void
2350qla2xxx_scan_start(struct Scsi_Host *shost)
2351{
2352        scsi_qla_host_t *vha = shost_priv(shost);
2353
2354        if (vha->hw->flags.running_gold_fw)
2355                return;
2356
2357        set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
2358        set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
2359        set_bit(RSCN_UPDATE, &vha->dpc_flags);
2360        set_bit(NPIV_CONFIG_NEEDED, &vha->dpc_flags);
2361}
2362
2363static int
2364qla2xxx_scan_finished(struct Scsi_Host *shost, unsigned long time)
2365{
2366        scsi_qla_host_t *vha = shost_priv(shost);
2367
2368        if (test_bit(UNLOADING, &vha->dpc_flags))
2369                return 1;
2370        if (!vha->host)
2371                return 1;
2372        if (time > vha->hw->loop_reset_delay * HZ)
2373                return 1;
2374
2375        return atomic_read(&vha->loop_state) == LOOP_READY;
2376}
2377
2378/*
2379 * PCI driver interface
2380 */
2381static int
2382qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
2383{
2384        int     ret = -ENODEV;
2385        struct Scsi_Host *host;
2386        scsi_qla_host_t *base_vha = NULL;
2387        struct qla_hw_data *ha;
2388        char pci_info[30];
2389        char fw_str[30], wq_name[30];
2390        struct scsi_host_template *sht;
2391        int bars, mem_only = 0;
2392        uint16_t req_length = 0, rsp_length = 0;
2393        struct req_que *req = NULL;
2394        struct rsp_que *rsp = NULL;
2395        bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO);
2396        sht = &qla2xxx_driver_template;
2397        if (pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2422 ||
2398            pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2432 ||
2399            pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8432 ||
2400            pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5422 ||
2401            pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5432 ||
2402            pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2532 ||
2403            pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8001 ||
2404            pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8021 ||
2405            pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2031 ||
2406            pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8031 ||
2407            pdev->device == PCI_DEVICE_ID_QLOGIC_ISPF001 ||
2408            pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8044 ||
2409            pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2071 ||
2410            pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2271 ||
2411            pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2261) {
2412                bars = pci_select_bars(pdev, IORESOURCE_MEM);
2413                mem_only = 1;
2414                ql_dbg_pci(ql_dbg_init, pdev, 0x0007,
2415                    "Mem only adapter.\n");
2416        }
2417        ql_dbg_pci(ql_dbg_init, pdev, 0x0008,
2418            "Bars=%d.\n", bars);
2419
2420        if (mem_only) {
2421                if (pci_enable_device_mem(pdev))
2422                        goto probe_out;
2423        } else {
2424                if (pci_enable_device(pdev))
2425                        goto probe_out;
2426        }
2427
2428        /* This may fail but that's ok */
2429        pci_enable_pcie_error_reporting(pdev);
2430
2431        ha = kzalloc(sizeof(struct qla_hw_data), GFP_KERNEL);
2432        if (!ha) {
2433                ql_log_pci(ql_log_fatal, pdev, 0x0009,
2434                    "Unable to allocate memory for ha.\n");
2435                goto probe_out;
2436        }
2437        ql_dbg_pci(ql_dbg_init, pdev, 0x000a,
2438            "Memory allocated for ha=%p.\n", ha);
2439        ha->pdev = pdev;
2440        ha->tgt.enable_class_2 = ql2xenableclass2;
2441        INIT_LIST_HEAD(&ha->tgt.q_full_list);
2442        spin_lock_init(&ha->tgt.q_full_lock);
2443        spin_lock_init(&ha->tgt.sess_lock);
2444        spin_lock_init(&ha->tgt.atio_lock);
2445
2446
2447        /* Clear our data area */
2448        ha->bars = bars;
2449        ha->mem_only = mem_only;
2450        spin_lock_init(&ha->hardware_lock);
2451        spin_lock_init(&ha->vport_slock);
2452        mutex_init(&ha->selflogin_lock);
2453        mutex_init(&ha->optrom_mutex);
2454
2455        /* Set ISP-type information. */
2456        qla2x00_set_isp_flags(ha);
2457
2458        /* Set EEH reset type to fundamental if required by hba */
2459        if (IS_QLA24XX(ha) || IS_QLA25XX(ha) || IS_QLA81XX(ha) ||
2460            IS_QLA83XX(ha) || IS_QLA27XX(ha))
2461                pdev->needs_freset = 1;
2462
2463        ha->prev_topology = 0;
2464        ha->init_cb_size = sizeof(init_cb_t);
2465        ha->link_data_rate = PORT_SPEED_UNKNOWN;
2466        ha->optrom_size = OPTROM_SIZE_2300;
2467
2468        /* Assign ISP specific operations. */
2469        if (IS_QLA2100(ha)) {
2470                ha->max_fibre_devices = MAX_FIBRE_DEVICES_2100;
2471                ha->mbx_count = MAILBOX_REGISTER_COUNT_2100;
2472                req_length = REQUEST_ENTRY_CNT_2100;
2473                rsp_length = RESPONSE_ENTRY_CNT_2100;
2474                ha->max_loop_id = SNS_LAST_LOOP_ID_2100;
2475                ha->gid_list_info_size = 4;
2476                ha->flash_conf_off = ~0;
2477                ha->flash_data_off = ~0;
2478                ha->nvram_conf_off = ~0;
2479                ha->nvram_data_off = ~0;
2480                ha->isp_ops = &qla2100_isp_ops;
2481        } else if (IS_QLA2200(ha)) {
2482                ha->max_fibre_devices = MAX_FIBRE_DEVICES_2100;
2483                ha->mbx_count = MAILBOX_REGISTER_COUNT_2200;
2484                req_length = REQUEST_ENTRY_CNT_2200;
2485                rsp_length = RESPONSE_ENTRY_CNT_2100;
2486                ha->max_loop_id = SNS_LAST_LOOP_ID_2100;
2487                ha->gid_list_info_size = 4;
2488                ha->flash_conf_off = ~0;
2489                ha->flash_data_off = ~0;
2490                ha->nvram_conf_off = ~0;
2491                ha->nvram_data_off = ~0;
2492                ha->isp_ops = &qla2100_isp_ops;
2493        } else if (IS_QLA23XX(ha)) {
2494                ha->max_fibre_devices = MAX_FIBRE_DEVICES_2100;
2495                ha->mbx_count = MAILBOX_REGISTER_COUNT;
2496                req_length = REQUEST_ENTRY_CNT_2200;
2497                rsp_length = RESPONSE_ENTRY_CNT_2300;
2498                ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
2499                ha->gid_list_info_size = 6;
2500                if (IS_QLA2322(ha) || IS_QLA6322(ha))
2501                        ha->optrom_size = OPTROM_SIZE_2322;
2502                ha->flash_conf_off = ~0;
2503                ha->flash_data_off = ~0;
2504                ha->nvram_conf_off = ~0;
2505                ha->nvram_data_off = ~0;
2506                ha->isp_ops = &qla2300_isp_ops;
2507        } else if (IS_QLA24XX_TYPE(ha)) {
2508                ha->max_fibre_devices = MAX_FIBRE_DEVICES_2400;
2509                ha->mbx_count = MAILBOX_REGISTER_COUNT;
2510                req_length = REQUEST_ENTRY_CNT_24XX;
2511                rsp_length = RESPONSE_ENTRY_CNT_2300;
2512                ha->tgt.atio_q_length = ATIO_ENTRY_CNT_24XX;
2513                ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
2514                ha->init_cb_size = sizeof(struct mid_init_cb_24xx);
2515                ha->gid_list_info_size = 8;
2516                ha->optrom_size = OPTROM_SIZE_24XX;
2517                ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA24XX;
2518                ha->isp_ops = &qla24xx_isp_ops;
2519                ha->flash_conf_off = FARX_ACCESS_FLASH_CONF;
2520                ha->flash_data_off = FARX_ACCESS_FLASH_DATA;
2521                ha->nvram_conf_off = FARX_ACCESS_NVRAM_CONF;
2522                ha->nvram_data_off = FARX_ACCESS_NVRAM_DATA;
2523        } else if (IS_QLA25XX(ha)) {
2524                ha->max_fibre_devices = MAX_FIBRE_DEVICES_2400;
2525                ha->mbx_count = MAILBOX_REGISTER_COUNT;
2526                req_length = REQUEST_ENTRY_CNT_24XX;
2527                rsp_length = RESPONSE_ENTRY_CNT_2300;
2528                ha->tgt.atio_q_length = ATIO_ENTRY_CNT_24XX;
2529                ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
2530                ha->init_cb_size = sizeof(struct mid_init_cb_24xx);
2531                ha->gid_list_info_size = 8;
2532                ha->optrom_size = OPTROM_SIZE_25XX;
2533                ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX;
2534                ha->isp_ops = &qla25xx_isp_ops;
2535                ha->flash_conf_off = FARX_ACCESS_FLASH_CONF;
2536                ha->flash_data_off = FARX_ACCESS_FLASH_DATA;
2537                ha->nvram_conf_off = FARX_ACCESS_NVRAM_CONF;
2538                ha->nvram_data_off = FARX_ACCESS_NVRAM_DATA;
2539        } else if (IS_QLA81XX(ha)) {
2540                ha->max_fibre_devices = MAX_FIBRE_DEVICES_2400;
2541                ha->mbx_count = MAILBOX_REGISTER_COUNT;
2542                req_length = REQUEST_ENTRY_CNT_24XX;
2543                rsp_length = RESPONSE_ENTRY_CNT_2300;
2544                ha->tgt.atio_q_length = ATIO_ENTRY_CNT_24XX;
2545                ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
2546                ha->init_cb_size = sizeof(struct mid_init_cb_81xx);
2547                ha->gid_list_info_size = 8;
2548                ha->optrom_size = OPTROM_SIZE_81XX;
2549                ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX;
2550                ha->isp_ops = &qla81xx_isp_ops;
2551                ha->flash_conf_off = FARX_ACCESS_FLASH_CONF_81XX;
2552                ha->flash_data_off = FARX_ACCESS_FLASH_DATA_81XX;
2553                ha->nvram_conf_off = ~0;
2554                ha->nvram_data_off = ~0;
2555        } else if (IS_QLA82XX(ha)) {
2556                ha->max_fibre_devices = MAX_FIBRE_DEVICES_2400;
2557                ha->mbx_count = MAILBOX_REGISTER_COUNT;
2558                req_length = REQUEST_ENTRY_CNT_82XX;
2559                rsp_length = RESPONSE_ENTRY_CNT_82XX;
2560                ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
2561                ha->init_cb_size = sizeof(struct mid_init_cb_81xx);
2562                ha->gid_list_info_size = 8;
2563                ha->optrom_size = OPTROM_SIZE_82XX;
2564                ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX;
2565                ha->isp_ops = &qla82xx_isp_ops;
2566                ha->flash_conf_off = FARX_ACCESS_FLASH_CONF;
2567                ha->flash_data_off = FARX_ACCESS_FLASH_DATA;
2568                ha->nvram_conf_off = FARX_ACCESS_NVRAM_CONF;
2569                ha->nvram_data_off = FARX_ACCESS_NVRAM_DATA;
2570        } else if (IS_QLA8044(ha)) {
2571                ha->max_fibre_devices = MAX_FIBRE_DEVICES_2400;
2572                ha->mbx_count = MAILBOX_REGISTER_COUNT;
2573                req_length = REQUEST_ENTRY_CNT_82XX;
2574                rsp_length = RESPONSE_ENTRY_CNT_82XX;
2575                ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
2576                ha->init_cb_size = sizeof(struct mid_init_cb_81xx);
2577                ha->gid_list_info_size = 8;
2578                ha->optrom_size = OPTROM_SIZE_83XX;
2579                ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX;
2580                ha->isp_ops = &qla8044_isp_ops;
2581                ha->flash_conf_off = FARX_ACCESS_FLASH_CONF;
2582                ha->flash_data_off = FARX_ACCESS_FLASH_DATA;
2583                ha->nvram_conf_off = FARX_ACCESS_NVRAM_CONF;
2584                ha->nvram_data_off = FARX_ACCESS_NVRAM_DATA;
2585        } else if (IS_QLA83XX(ha)) {
2586                ha->portnum = PCI_FUNC(ha->pdev->devfn);
2587                ha->max_fibre_devices = MAX_FIBRE_DEVICES_2400;
2588                ha->mbx_count = MAILBOX_REGISTER_COUNT;
2589                req_length = REQUEST_ENTRY_CNT_83XX;
2590                rsp_length = RESPONSE_ENTRY_CNT_83XX;
2591                ha->tgt.atio_q_length = ATIO_ENTRY_CNT_24XX;
2592                ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
2593                ha->init_cb_size = sizeof(struct mid_init_cb_81xx);
2594                ha->gid_list_info_size = 8;
2595                ha->optrom_size = OPTROM_SIZE_83XX;
2596                ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX;
2597                ha->isp_ops = &qla83xx_isp_ops;
2598                ha->flash_conf_off = FARX_ACCESS_FLASH_CONF_81XX;
2599                ha->flash_data_off = FARX_ACCESS_FLASH_DATA_81XX;
2600                ha->nvram_conf_off = ~0;
2601                ha->nvram_data_off = ~0;
2602        }  else if (IS_QLAFX00(ha)) {
2603                ha->max_fibre_devices = MAX_FIBRE_DEVICES_FX00;
2604                ha->mbx_count = MAILBOX_REGISTER_COUNT_FX00;
2605                ha->aen_mbx_count = AEN_MAILBOX_REGISTER_COUNT_FX00;
2606                req_length = REQUEST_ENTRY_CNT_FX00;
2607                rsp_length = RESPONSE_ENTRY_CNT_FX00;
2608                ha->isp_ops = &qlafx00_isp_ops;
2609                ha->port_down_retry_count = 30; /* default value */
2610                ha->mr.fw_hbt_cnt = QLAFX00_HEARTBEAT_INTERVAL;
2611                ha->mr.fw_reset_timer_tick = QLAFX00_RESET_INTERVAL;
2612                ha->mr.fw_critemp_timer_tick = QLAFX00_CRITEMP_INTERVAL;
2613                ha->mr.fw_hbt_en = 1;
2614                ha->mr.host_info_resend = false;
2615                ha->mr.hinfo_resend_timer_tick = QLAFX00_HINFO_RESEND_INTERVAL;
2616        } else if (IS_QLA27XX(ha)) {
2617                ha->portnum = PCI_FUNC(ha->pdev->devfn);
2618                ha->max_fibre_devices = MAX_FIBRE_DEVICES_2400;
2619                ha->mbx_count = MAILBOX_REGISTER_COUNT;
2620                req_length = REQUEST_ENTRY_CNT_83XX;
2621                rsp_length = RESPONSE_ENTRY_CNT_83XX;
2622                ha->tgt.atio_q_length = ATIO_ENTRY_CNT_24XX;
2623                ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
2624                ha->init_cb_size = sizeof(struct mid_init_cb_81xx);
2625                ha->gid_list_info_size = 8;
2626                ha->optrom_size = OPTROM_SIZE_83XX;
2627                ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX;
2628                ha->isp_ops = &qla27xx_isp_ops;
2629                ha->flash_conf_off = FARX_ACCESS_FLASH_CONF_81XX;
2630                ha->flash_data_off = FARX_ACCESS_FLASH_DATA_81XX;
2631                ha->nvram_conf_off = ~0;
2632                ha->nvram_data_off = ~0;
2633        }
2634
2635        ql_dbg_pci(ql_dbg_init, pdev, 0x001e,
2636            "mbx_count=%d, req_length=%d, "
2637            "rsp_length=%d, max_loop_id=%d, init_cb_size=%d, "
2638            "gid_list_info_size=%d, optrom_size=%d, nvram_npiv_size=%d, "
2639            "max_fibre_devices=%d.\n",
2640            ha->mbx_count, req_length, rsp_length, ha->max_loop_id,
2641            ha->init_cb_size, ha->gid_list_info_size, ha->optrom_size,
2642            ha->nvram_npiv_size, ha->max_fibre_devices);
2643        ql_dbg_pci(ql_dbg_init, pdev, 0x001f,
2644            "isp_ops=%p, flash_conf_off=%d, "
2645            "flash_data_off=%d, nvram_conf_off=%d, nvram_data_off=%d.\n",
2646            ha->isp_ops, ha->flash_conf_off, ha->flash_data_off,
2647            ha->nvram_conf_off, ha->nvram_data_off);
2648
2649        /* Configure PCI I/O space */
2650        ret = ha->isp_ops->iospace_config(ha);
2651        if (ret)
2652                goto iospace_config_failed;
2653
2654        ql_log_pci(ql_log_info, pdev, 0x001d,
2655            "Found an ISP%04X irq %d iobase 0x%p.\n",
2656            pdev->device, pdev->irq, ha->iobase);
2657        mutex_init(&ha->vport_lock);
2658        init_completion(&ha->mbx_cmd_comp);
2659        complete(&ha->mbx_cmd_comp);
2660        init_completion(&ha->mbx_intr_comp);
2661        init_completion(&ha->dcbx_comp);
2662        init_completion(&ha->lb_portup_comp);
2663
2664        set_bit(0, (unsigned long *) ha->vp_idx_map);
2665
2666        qla2x00_config_dma_addressing(ha);
2667        ql_dbg_pci(ql_dbg_init, pdev, 0x0020,
2668            "64 Bit addressing is %s.\n",
2669            ha->flags.enable_64bit_addressing ? "enable" :
2670            "disable");
2671        ret = qla2x00_mem_alloc(ha, req_length, rsp_length, &req, &rsp);
2672        if (ret) {
2673                ql_log_pci(ql_log_fatal, pdev, 0x0031,
2674                    "Failed to allocate memory for adapter, aborting.\n");
2675
2676                goto probe_hw_failed;
2677        }
2678
2679        req->max_q_depth = MAX_Q_DEPTH;
2680        if (ql2xmaxqdepth != 0 && ql2xmaxqdepth <= 0xffffU)
2681                req->max_q_depth = ql2xmaxqdepth;
2682
2683
2684        base_vha = qla2x00_create_host(sht, ha);
2685        if (!base_vha) {
2686                ret = -ENOMEM;
2687                qla2x00_mem_free(ha);
2688                qla2x00_free_req_que(ha, req);
2689                qla2x00_free_rsp_que(ha, rsp);
2690                goto probe_hw_failed;
2691        }
2692
2693        pci_set_drvdata(pdev, base_vha);
2694        set_bit(PFLG_DRIVER_PROBING, &base_vha->pci_flags);
2695
2696        host = base_vha->host;
2697        base_vha->req = req;
2698        if (IS_QLA2XXX_MIDTYPE(ha))
2699                base_vha->mgmt_svr_loop_id = 10 + base_vha->vp_idx;
2700        else
2701                base_vha->mgmt_svr_loop_id = MANAGEMENT_SERVER +
2702                                                base_vha->vp_idx;
2703
2704        /* Setup fcport template structure. */
2705        ha->mr.fcport.vha = base_vha;
2706        ha->mr.fcport.port_type = FCT_UNKNOWN;
2707        ha->mr.fcport.loop_id = FC_NO_LOOP_ID;
2708        qla2x00_set_fcport_state(&ha->mr.fcport, FCS_UNCONFIGURED);
2709        ha->mr.fcport.supported_classes = FC_COS_UNSPECIFIED;
2710        ha->mr.fcport.scan_state = 1;
2711
2712        /* Set the SG table size based on ISP type */
2713        if (!IS_FWI2_CAPABLE(ha)) {
2714                if (IS_QLA2100(ha))
2715                        host->sg_tablesize = 32;
2716        } else {
2717                if (!IS_QLA82XX(ha))
2718                        host->sg_tablesize = QLA_SG_ALL;
2719        }
2720        host->max_id = ha->max_fibre_devices;
2721        host->cmd_per_lun = 3;
2722        host->unique_id = host->host_no;
2723        if (IS_T10_PI_CAPABLE(ha) && ql2xenabledif)
2724                host->max_cmd_len = 32;
2725        else
2726                host->max_cmd_len = MAX_CMDSZ;
2727        host->max_channel = MAX_BUSES - 1;
2728        /* Older HBAs support only 16-bit LUNs */
2729        if (!IS_QLAFX00(ha) && !IS_FWI2_CAPABLE(ha) &&
2730            ql2xmaxlun > 0xffff)
2731                host->max_lun = 0xffff;
2732        else
2733                host->max_lun = ql2xmaxlun;
2734        host->transportt = qla2xxx_transport_template;
2735        sht->vendor_id = (SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_QLOGIC);
2736
2737        ql_dbg(ql_dbg_init, base_vha, 0x0033,
2738            "max_id=%d this_id=%d "
2739            "cmd_per_len=%d unique_id=%d max_cmd_len=%d max_channel=%d "
2740            "max_lun=%llu transportt=%p, vendor_id=%llu.\n", host->max_id,
2741            host->this_id, host->cmd_per_lun, host->unique_id,
2742            host->max_cmd_len, host->max_channel, host->max_lun,
2743            host->transportt, sht->vendor_id);
2744
2745que_init:
2746        /* Alloc arrays of request and response ring ptrs */
2747        if (!qla2x00_alloc_queues(ha, req, rsp)) {
2748                ql_log(ql_log_fatal, base_vha, 0x003d,
2749                    "Failed to allocate memory for queue pointers..."
2750                    "aborting.\n");
2751                goto probe_init_failed;
2752        }
2753
2754        qlt_probe_one_stage1(base_vha, ha);
2755
2756        /* Set up the irqs */
2757        ret = qla2x00_request_irqs(ha, rsp);
2758        if (ret)
2759                goto probe_init_failed;
2760
2761        pci_save_state(pdev);
2762
2763        /* Assign back pointers */
2764        rsp->req = req;
2765        req->rsp = rsp;
2766
2767        if (IS_QLAFX00(ha)) {
2768                ha->rsp_q_map[0] = rsp;
2769                ha->req_q_map[0] = req;
2770                set_bit(0, ha->req_qid_map);
2771                set_bit(0, ha->rsp_qid_map);
2772        }
2773
2774        /* FWI2-capable only. */
2775        req->req_q_in = &ha->iobase->isp24.req_q_in;
2776        req->req_q_out = &ha->iobase->isp24.req_q_out;
2777        rsp->rsp_q_in = &ha->iobase->isp24.rsp_q_in;
2778        rsp->rsp_q_out = &ha->iobase->isp24.rsp_q_out;
2779        if (ha->mqenable || IS_QLA83XX(ha) || IS_QLA27XX(ha)) {
2780                req->req_q_in = &ha->mqiobase->isp25mq.req_q_in;
2781                req->req_q_out = &ha->mqiobase->isp25mq.req_q_out;
2782                rsp->rsp_q_in = &ha->mqiobase->isp25mq.rsp_q_in;
2783                rsp->rsp_q_out =  &ha->mqiobase->isp25mq.rsp_q_out;
2784        }
2785
2786        if (IS_QLAFX00(ha)) {
2787                req->req_q_in = &ha->iobase->ispfx00.req_q_in;
2788                req->req_q_out = &ha->iobase->ispfx00.req_q_out;
2789                rsp->rsp_q_in = &ha->iobase->ispfx00.rsp_q_in;
2790                rsp->rsp_q_out = &ha->iobase->ispfx00.rsp_q_out;
2791        }
2792
2793        if (IS_P3P_TYPE(ha)) {
2794                req->req_q_out = &ha->iobase->isp82.req_q_out[0];
2795                rsp->rsp_q_in = &ha->iobase->isp82.rsp_q_in[0];
2796                rsp->rsp_q_out = &ha->iobase->isp82.rsp_q_out[0];
2797        }
2798
2799        ql_dbg(ql_dbg_multiq, base_vha, 0xc009,
2800            "rsp_q_map=%p req_q_map=%p rsp->req=%p req->rsp=%p.\n",
2801            ha->rsp_q_map, ha->req_q_map, rsp->req, req->rsp);
2802        ql_dbg(ql_dbg_multiq, base_vha, 0xc00a,
2803            "req->req_q_in=%p req->req_q_out=%p "
2804            "rsp->rsp_q_in=%p rsp->rsp_q_out=%p.\n",
2805            req->req_q_in, req->req_q_out,
2806            rsp->rsp_q_in, rsp->rsp_q_out);
2807        ql_dbg(ql_dbg_init, base_vha, 0x003e,
2808            "rsp_q_map=%p req_q_map=%p rsp->req=%p req->rsp=%p.\n",
2809            ha->rsp_q_map, ha->req_q_map, rsp->req, req->rsp);
2810        ql_dbg(ql_dbg_init, base_vha, 0x003f,
2811            "req->req_q_in=%p req->req_q_out=%p rsp->rsp_q_in=%p rsp->rsp_q_out=%p.\n",
2812            req->req_q_in, req->req_q_out, rsp->rsp_q_in, rsp->rsp_q_out);
2813
2814        if (ha->isp_ops->initialize_adapter(base_vha)) {
2815                ql_log(ql_log_fatal, base_vha, 0x00d6,
2816                    "Failed to initialize adapter - Adapter flags %x.\n",
2817                    base_vha->device_flags);
2818
2819                if (IS_QLA82XX(ha)) {
2820                        qla82xx_idc_lock(ha);
2821                        qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
2822                                QLA8XXX_DEV_FAILED);
2823                        qla82xx_idc_unlock(ha);
2824                        ql_log(ql_log_fatal, base_vha, 0x00d7,
2825                            "HW State: FAILED.\n");
2826                } else if (IS_QLA8044(ha)) {
2827                        qla8044_idc_lock(ha);
2828                        qla8044_wr_direct(base_vha,
2829                                QLA8044_CRB_DEV_STATE_INDEX,
2830                                QLA8XXX_DEV_FAILED);
2831                        qla8044_idc_unlock(ha);
2832                        ql_log(ql_log_fatal, base_vha, 0x0150,
2833                            "HW State: FAILED.\n");
2834                }
2835
2836                ret = -ENODEV;
2837                goto probe_failed;
2838        }
2839
2840        if (IS_QLAFX00(ha))
2841                host->can_queue = QLAFX00_MAX_CANQUEUE;
2842        else
2843                host->can_queue = req->num_outstanding_cmds - 10;
2844
2845        ql_dbg(ql_dbg_init, base_vha, 0x0032,
2846            "can_queue=%d, req=%p, mgmt_svr_loop_id=%d, sg_tablesize=%d.\n",
2847            host->can_queue, base_vha->req,
2848            base_vha->mgmt_svr_loop_id, host->sg_tablesize);
2849
2850        if (ha->mqenable) {
2851                if (qla25xx_setup_mode(base_vha)) {
2852                        ql_log(ql_log_warn, base_vha, 0x00ec,
2853                            "Failed to create queues, falling back to single queue mode.\n");
2854                        goto que_init;
2855                }
2856        }
2857
2858        if (ha->flags.running_gold_fw)
2859                goto skip_dpc;
2860
2861        /*
2862         * Startup the kernel thread for this host adapter
2863         */
2864        ha->dpc_thread = kthread_create(qla2x00_do_dpc, ha,
2865            "%s_dpc", base_vha->host_str);
2866        if (IS_ERR(ha->dpc_thread)) {
2867                ql_log(ql_log_fatal, base_vha, 0x00ed,
2868                    "Failed to start DPC thread.\n");
2869                ret = PTR_ERR(ha->dpc_thread);
2870                goto probe_failed;
2871        }
2872        ql_dbg(ql_dbg_init, base_vha, 0x00ee,
2873            "DPC thread started successfully.\n");
2874
2875        /*
2876         * If we're not coming up in initiator mode, we might sit for
2877         * a while without waking up the dpc thread, which leads to a
2878         * stuck process warning.  So just kick the dpc once here and
2879         * let the kthread start (and go back to sleep in qla2x00_do_dpc).
2880         */
2881        qla2xxx_wake_dpc(base_vha);
2882
2883        INIT_WORK(&ha->board_disable, qla2x00_disable_board_on_pci_error);
2884
2885        if (IS_QLA8031(ha) || IS_MCTP_CAPABLE(ha)) {
2886                sprintf(wq_name, "qla2xxx_%lu_dpc_lp_wq", base_vha->host_no);
2887                ha->dpc_lp_wq = create_singlethread_workqueue(wq_name);
2888                INIT_WORK(&ha->idc_aen, qla83xx_service_idc_aen);
2889
2890                sprintf(wq_name, "qla2xxx_%lu_dpc_hp_wq", base_vha->host_no);
2891                ha->dpc_hp_wq = create_singlethread_workqueue(wq_name);
2892                INIT_WORK(&ha->nic_core_reset, qla83xx_nic_core_reset_work);
2893                INIT_WORK(&ha->idc_state_handler,
2894                    qla83xx_idc_state_handler_work);
2895                INIT_WORK(&ha->nic_core_unrecoverable,
2896                    qla83xx_nic_core_unrecoverable_work);
2897        }
2898
2899skip_dpc:
2900        list_add_tail(&base_vha->list, &ha->vp_list);
2901        base_vha->host->irq = ha->pdev->irq;
2902
2903        /* Initialized the timer */
2904        qla2x00_start_timer(base_vha, qla2x00_timer, WATCH_INTERVAL);
2905        ql_dbg(ql_dbg_init, base_vha, 0x00ef,
2906            "Started qla2x00_timer with "
2907            "interval=%d.\n", WATCH_INTERVAL);
2908        ql_dbg(ql_dbg_init, base_vha, 0x00f0,
2909            "Detected hba at address=%p.\n",
2910            ha);
2911
2912        if (IS_T10_PI_CAPABLE(ha) && ql2xenabledif) {
2913                if (ha->fw_attributes & BIT_4) {
2914                        int prot = 0, guard;
2915                        base_vha->flags.difdix_supported = 1;
2916                        ql_dbg(ql_dbg_init, base_vha, 0x00f1,
2917                            "Registering for DIF/DIX type 1 and 3 protection.\n");
2918                        if (ql2xenabledif == 1)
2919                                prot = SHOST_DIX_TYPE0_PROTECTION;
2920                        scsi_host_set_prot(host,
2921                            prot | SHOST_DIF_TYPE1_PROTECTION
2922                            | SHOST_DIF_TYPE2_PROTECTION
2923                            | SHOST_DIF_TYPE3_PROTECTION
2924                            | SHOST_DIX_TYPE1_PROTECTION
2925                            | SHOST_DIX_TYPE2_PROTECTION
2926                            | SHOST_DIX_TYPE3_PROTECTION);
2927
2928                        guard = SHOST_DIX_GUARD_CRC;
2929
2930                        if (IS_PI_IPGUARD_CAPABLE(ha) &&
2931                            (ql2xenabledif > 1 || IS_PI_DIFB_DIX0_CAPABLE(ha)))
2932                                guard |= SHOST_DIX_GUARD_IP;
2933
2934                        scsi_host_set_guard(host, guard);
2935                } else
2936                        base_vha->flags.difdix_supported = 0;
2937        }
2938
2939        ha->isp_ops->enable_intrs(ha);
2940
2941        if (IS_QLAFX00(ha)) {
2942                ret = qlafx00_fx_disc(base_vha,
2943                        &base_vha->hw->mr.fcport, FXDISC_GET_CONFIG_INFO);
2944                host->sg_tablesize = (ha->mr.extended_io_enabled) ?
2945                    QLA_SG_ALL : 128;
2946        }
2947
2948        ret = scsi_add_host(host, &pdev->dev);
2949        if (ret)
2950                goto probe_failed;
2951
2952        base_vha->flags.init_done = 1;
2953        base_vha->flags.online = 1;
2954        ha->prev_minidump_failed = 0;
2955
2956        ql_dbg(ql_dbg_init, base_vha, 0x00f2,
2957            "Init done and hba is online.\n");
2958
2959        if (qla_ini_mode_enabled(base_vha))
2960                scsi_scan_host(host);
2961        else
2962                ql_dbg(ql_dbg_init, base_vha, 0x0122,
2963                        "skipping scsi_scan_host() for non-initiator port\n");
2964
2965        qla2x00_alloc_sysfs_attr(base_vha);
2966
2967        if (IS_QLAFX00(ha)) {
2968                ret = qlafx00_fx_disc(base_vha,
2969                        &base_vha->hw->mr.fcport, FXDISC_GET_PORT_INFO);
2970
2971                /* Register system information */
2972                ret =  qlafx00_fx_disc(base_vha,
2973                        &base_vha->hw->mr.fcport, FXDISC_REG_HOST_INFO);
2974        }
2975
2976        qla2x00_init_host_attr(base_vha);
2977
2978        qla2x00_dfs_setup(base_vha);
2979
2980        ql_log(ql_log_info, base_vha, 0x00fb,
2981            "QLogic %s - %s.\n", ha->model_number, ha->model_desc);
2982        ql_log(ql_log_info, base_vha, 0x00fc,
2983            "ISP%04X: %s @ %s hdma%c host#=%ld fw=%s.\n",
2984            pdev->device, ha->isp_ops->pci_info_str(base_vha, pci_info),
2985            pci_name(pdev), ha->flags.enable_64bit_addressing ? '+' : '-',
2986            base_vha->host_no,
2987            ha->isp_ops->fw_version_str(base_vha, fw_str, sizeof(fw_str)));
2988
2989        qlt_add_target(ha, base_vha);
2990
2991        clear_bit(PFLG_DRIVER_PROBING, &base_vha->pci_flags);
2992
2993        if (test_bit(UNLOADING, &base_vha->dpc_flags))
2994                return -ENODEV;
2995
2996        return 0;
2997
2998probe_init_failed:
2999        qla2x00_free_req_que(ha, req);
3000        ha->req_q_map[0] = NULL;
3001        clear_bit(0, ha->req_qid_map);
3002        qla2x00_free_rsp_que(ha, rsp);
3003        ha->rsp_q_map[0] = NULL;
3004        clear_bit(0, ha->rsp_qid_map);
3005        ha->max_req_queues = ha->max_rsp_queues = 0;
3006
3007probe_failed:
3008        if (base_vha->timer_active)
3009                qla2x00_stop_timer(base_vha);
3010        base_vha->flags.online = 0;
3011        if (ha->dpc_thread) {
3012                struct task_struct *t = ha->dpc_thread;
3013
3014                ha->dpc_thread = NULL;
3015                kthread_stop(t);
3016        }
3017
3018        qla2x00_free_device(base_vha);
3019
3020        scsi_host_put(base_vha->host);
3021
3022probe_hw_failed:
3023        qla2x00_clear_drv_active(ha);
3024
3025iospace_config_failed:
3026        if (IS_P3P_TYPE(ha)) {
3027                if (!ha->nx_pcibase)
3028                        iounmap((device_reg_t *)ha->nx_pcibase);
3029                if (!ql2xdbwr)
3030                        iounmap((device_reg_t *)ha->nxdb_wr_ptr);
3031        } else {
3032                if (ha->iobase)
3033                        iounmap(ha->iobase);
3034                if (ha->cregbase)
3035                        iounmap(ha->cregbase);
3036        }
3037        pci_release_selected_regions(ha->pdev, ha->bars);
3038        kfree(ha);
3039        ha = NULL;
3040
3041probe_out:
3042        pci_disable_device(pdev);
3043        return ret;
3044}
3045
3046static void
3047qla2x00_shutdown(struct pci_dev *pdev)
3048{
3049        scsi_qla_host_t *vha;
3050        struct qla_hw_data  *ha;
3051
3052        if (!atomic_read(&pdev->enable_cnt))
3053                return;
3054
3055        vha = pci_get_drvdata(pdev);
3056        ha = vha->hw;
3057
3058        /* Notify ISPFX00 firmware */
3059        if (IS_QLAFX00(ha))
3060                qlafx00_driver_shutdown(vha, 20);
3061
3062        /* Turn-off FCE trace */
3063        if (ha->flags.fce_enabled) {
3064                qla2x00_disable_fce_trace(vha, NULL, NULL);
3065                ha->flags.fce_enabled = 0;
3066        }
3067
3068        /* Turn-off EFT trace */
3069        if (ha->eft)
3070                qla2x00_disable_eft_trace(vha);
3071
3072        /* Stop currently executing firmware. */
3073        qla2x00_try_to_stop_firmware(vha);
3074
3075        /* Turn adapter off line */
3076        vha->flags.online = 0;
3077
3078        /* turn-off interrupts on the card */
3079        if (ha->interrupts_on) {
3080                vha->flags.init_done = 0;
3081                ha->isp_ops->disable_intrs(ha);
3082        }
3083
3084        qla2x00_free_irqs(vha);
3085
3086        qla2x00_free_fw_dump(ha);
3087
3088        pci_disable_pcie_error_reporting(pdev);
3089        pci_disable_device(pdev);
3090}
3091
3092/* Deletes all the virtual ports for a given ha */
3093static void
3094qla2x00_delete_all_vps(struct qla_hw_data *ha, scsi_qla_host_t *base_vha)
3095{
3096        scsi_qla_host_t *vha;
3097        unsigned long flags;
3098
3099        mutex_lock(&ha->vport_lock);
3100        while (ha->cur_vport_count) {
3101                spin_lock_irqsave(&ha->vport_slock, flags);
3102
3103                BUG_ON(base_vha->list.next == &ha->vp_list);
3104                /* This assumes first entry in ha->vp_list is always base vha */
3105                vha = list_first_entry(&base_vha->list, scsi_qla_host_t, list);
3106                scsi_host_get(vha->host);
3107
3108                spin_unlock_irqrestore(&ha->vport_slock, flags);
3109                mutex_unlock(&ha->vport_lock);
3110
3111                fc_vport_terminate(vha->fc_vport);
3112                scsi_host_put(vha->host);
3113
3114                mutex_lock(&ha->vport_lock);
3115        }
3116        mutex_unlock(&ha->vport_lock);
3117}
3118
3119/* Stops all deferred work threads */
3120static void
3121qla2x00_destroy_deferred_work(struct qla_hw_data *ha)
3122{
3123        /* Flush the work queue and remove it */
3124        if (ha->wq) {
3125                flush_workqueue(ha->wq);
3126                destroy_workqueue(ha->wq);
3127                ha->wq = NULL;
3128        }
3129
3130        /* Cancel all work and destroy DPC workqueues */
3131        if (ha->dpc_lp_wq) {
3132                cancel_work_sync(&ha->idc_aen);
3133                destroy_workqueue(ha->dpc_lp_wq);
3134                ha->dpc_lp_wq = NULL;
3135        }
3136
3137        if (ha->dpc_hp_wq) {
3138                cancel_work_sync(&ha->nic_core_reset);
3139                cancel_work_sync(&ha->idc_state_handler);
3140                cancel_work_sync(&ha->nic_core_unrecoverable);
3141                destroy_workqueue(ha->dpc_hp_wq);
3142                ha->dpc_hp_wq = NULL;
3143        }
3144
3145        /* Kill the kernel thread for this host */
3146        if (ha->dpc_thread) {
3147                struct task_struct *t = ha->dpc_thread;
3148
3149                /*
3150                 * qla2xxx_wake_dpc checks for ->dpc_thread
3151                 * so we need to zero it out.
3152                 */
3153                ha->dpc_thread = NULL;
3154                kthread_stop(t);
3155        }
3156}
3157
3158static void
3159qla2x00_unmap_iobases(struct qla_hw_data *ha)
3160{
3161        if (IS_QLA82XX(ha)) {
3162
3163                iounmap((device_reg_t *)ha->nx_pcibase);
3164                if (!ql2xdbwr)
3165                        iounmap((device_reg_t *)ha->nxdb_wr_ptr);
3166        } else {
3167                if (ha->iobase)
3168                        iounmap(ha->iobase);
3169
3170                if (ha->cregbase)
3171                        iounmap(ha->cregbase);
3172
3173                if (ha->mqiobase)
3174                        iounmap(ha->mqiobase);
3175
3176                if ((IS_QLA83XX(ha) || IS_QLA27XX(ha)) && ha->msixbase)
3177                        iounmap(ha->msixbase);
3178        }
3179}
3180
3181static void
3182qla2x00_clear_drv_active(struct qla_hw_data *ha)
3183{
3184        if (IS_QLA8044(ha)) {
3185                qla8044_idc_lock(ha);
3186                qla8044_clear_drv_active(ha);
3187                qla8044_idc_unlock(ha);
3188        } else if (IS_QLA82XX(ha)) {
3189                qla82xx_idc_lock(ha);
3190                qla82xx_clear_drv_active(ha);
3191                qla82xx_idc_unlock(ha);
3192        }
3193}
3194
3195static void
3196qla2x00_remove_one(struct pci_dev *pdev)
3197{
3198        scsi_qla_host_t *base_vha;
3199        struct qla_hw_data  *ha;
3200
3201        base_vha = pci_get_drvdata(pdev);
3202        ha = base_vha->hw;
3203
3204        /* Indicate device removal to prevent future board_disable and wait
3205         * until any pending board_disable has completed. */
3206        set_bit(PFLG_DRIVER_REMOVING, &base_vha->pci_flags);
3207        cancel_work_sync(&ha->board_disable);
3208
3209        /*
3210         * If the PCI device is disabled then there was a PCI-disconnect and
3211         * qla2x00_disable_board_on_pci_error has taken care of most of the
3212         * resources.
3213         */
3214        if (!atomic_read(&pdev->enable_cnt)) {
3215                scsi_host_put(base_vha->host);
3216                kfree(ha);
3217                pci_set_drvdata(pdev, NULL);
3218                return;
3219        }
3220
3221        qla2x00_wait_for_hba_ready(base_vha);
3222
3223        /* if UNLOAD flag is already set, then continue unload,
3224         * where it was set first.
3225         */
3226        if (test_bit(UNLOADING, &base_vha->dpc_flags))
3227                return;
3228
3229        set_bit(UNLOADING, &base_vha->dpc_flags);
3230
3231        if (IS_QLAFX00(ha))
3232                qlafx00_driver_shutdown(base_vha, 20);
3233
3234        qla2x00_delete_all_vps(ha, base_vha);
3235
3236        if (IS_QLA8031(ha)) {
3237                ql_dbg(ql_dbg_p3p, base_vha, 0xb07e,
3238                    "Clearing fcoe driver presence.\n");
3239                if (qla83xx_clear_drv_presence(base_vha) != QLA_SUCCESS)
3240                        ql_dbg(ql_dbg_p3p, base_vha, 0xb079,
3241                            "Error while clearing DRV-Presence.\n");
3242        }
3243
3244        qla2x00_abort_all_cmds(base_vha, DID_NO_CONNECT << 16);
3245
3246        qla2x00_dfs_remove(base_vha);
3247
3248        qla84xx_put_chip(base_vha);
3249
3250        /* Laser should be disabled only for ISP2031 */
3251        if (IS_QLA2031(ha))
3252                qla83xx_disable_laser(base_vha);
3253
3254        /* Disable timer */
3255        if (base_vha->timer_active)
3256                qla2x00_stop_timer(base_vha);
3257
3258        base_vha->flags.online = 0;
3259
3260        /* free DMA memory */
3261        if (ha->exlogin_buf)
3262                qla2x00_free_exlogin_buffer(ha);
3263
3264        /* free DMA memory */
3265        if (ha->exchoffld_buf)
3266                qla2x00_free_exchoffld_buffer(ha);
3267
3268        qla2x00_destroy_deferred_work(ha);
3269
3270        qlt_remove_target(ha, base_vha);
3271
3272        qla2x00_free_sysfs_attr(base_vha, true);
3273
3274        fc_remove_host(base_vha->host);
3275
3276        scsi_remove_host(base_vha->host);
3277
3278        qla2x00_free_device(base_vha);
3279
3280        qla2x00_clear_drv_active(ha);
3281
3282        scsi_host_put(base_vha->host);
3283
3284        qla2x00_unmap_iobases(ha);
3285
3286        pci_release_selected_regions(ha->pdev, ha->bars);
3287        kfree(ha);
3288        ha = NULL;
3289
3290        pci_disable_pcie_error_reporting(pdev);
3291
3292        pci_disable_device(pdev);
3293}
3294
3295static void
3296qla2x00_free_device(scsi_qla_host_t *vha)
3297{
3298        struct qla_hw_data *ha = vha->hw;
3299
3300        qla2x00_abort_all_cmds(vha, DID_NO_CONNECT << 16);
3301
3302        /* Disable timer */
3303        if (vha->timer_active)
3304                qla2x00_stop_timer(vha);
3305
3306        qla25xx_delete_queues(vha);
3307
3308        if (ha->flags.fce_enabled)
3309                qla2x00_disable_fce_trace(vha, NULL, NULL);
3310
3311        if (ha->eft)
3312                qla2x00_disable_eft_trace(vha);
3313
3314        /* Stop currently executing firmware. */
3315        qla2x00_try_to_stop_firmware(vha);
3316
3317        vha->flags.online = 0;
3318
3319        /* turn-off interrupts on the card */
3320        if (ha->interrupts_on) {
3321                vha->flags.init_done = 0;
3322                ha->isp_ops->disable_intrs(ha);
3323        }
3324
3325        qla2x00_free_irqs(vha);
3326
3327        qla2x00_free_fcports(vha);
3328
3329        qla2x00_mem_free(ha);
3330
3331        qla82xx_md_free(vha);
3332
3333        qla2x00_free_queues(ha);
3334}
3335
3336void qla2x00_free_fcports(struct scsi_qla_host *vha)
3337{
3338        fc_port_t *fcport, *tfcport;
3339
3340        list_for_each_entry_safe(fcport, tfcport, &vha->vp_fcports, list) {
3341                list_del(&fcport->list);
3342                qla2x00_clear_loop_id(fcport);
3343                kfree(fcport);
3344                fcport = NULL;
3345        }
3346}
3347
3348static inline void
3349qla2x00_schedule_rport_del(struct scsi_qla_host *vha, fc_port_t *fcport,
3350    int defer)
3351{
3352        struct fc_rport *rport;
3353        scsi_qla_host_t *base_vha;
3354        unsigned long flags;
3355
3356        if (!fcport->rport)
3357                return;
3358
3359        rport = fcport->rport;
3360        if (defer) {
3361                base_vha = pci_get_drvdata(vha->hw->pdev);
3362                spin_lock_irqsave(vha->host->host_lock, flags);
3363                fcport->drport = rport;
3364                spin_unlock_irqrestore(vha->host->host_lock, flags);
3365                qlt_do_generation_tick(vha, &base_vha->total_fcport_update_gen);
3366                set_bit(FCPORT_UPDATE_NEEDED, &base_vha->dpc_flags);
3367                qla2xxx_wake_dpc(base_vha);
3368        } else {
3369                int now;
3370                if (rport)
3371                        fc_remote_port_delete(rport);
3372                qlt_do_generation_tick(vha, &now);
3373                qlt_fc_port_deleted(vha, fcport, now);
3374        }
3375}
3376
3377/*
3378 * qla2x00_mark_device_lost Updates fcport state when device goes offline.
3379 *
3380 * Input: ha = adapter block pointer.  fcport = port structure pointer.
3381 *
3382 * Return: None.
3383 *
3384 * Context:
3385 */
3386void qla2x00_mark_device_lost(scsi_qla_host_t *vha, fc_port_t *fcport,
3387    int do_login, int defer)
3388{
3389        if (IS_QLAFX00(vha->hw)) {
3390                qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
3391                qla2x00_schedule_rport_del(vha, fcport, defer);
3392                return;
3393        }
3394
3395        if (atomic_read(&fcport->state) == FCS_ONLINE &&
3396            vha->vp_idx == fcport->vha->vp_idx) {
3397                qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
3398                qla2x00_schedule_rport_del(vha, fcport, defer);
3399        }
3400        /*
3401         * We may need to retry the login, so don't change the state of the
3402         * port but do the retries.
3403         */
3404        if (atomic_read(&fcport->state) != FCS_DEVICE_DEAD)
3405                qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
3406
3407        if (!do_login)
3408                return;
3409
3410        set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
3411
3412        if (fcport->login_retry == 0) {
3413                fcport->login_retry = vha->hw->login_retry_count;
3414
3415                ql_dbg(ql_dbg_disc, vha, 0x2067,
3416                    "Port login retry %8phN, id = 0x%04x retry cnt=%d.\n",
3417                    fcport->port_name, fcport->loop_id, fcport->login_retry);
3418        }
3419}
3420
3421/*
3422 * qla2x00_mark_all_devices_lost
3423 *      Updates fcport state when device goes offline.
3424 *
3425 * Input:
3426 *      ha = adapter block pointer.
3427 *      fcport = port structure pointer.
3428 *
3429 * Return:
3430 *      None.
3431 *
3432 * Context:
3433 */
3434void
3435qla2x00_mark_all_devices_lost(scsi_qla_host_t *vha, int defer)
3436{
3437        fc_port_t *fcport;
3438
3439        list_for_each_entry(fcport, &vha->vp_fcports, list) {
3440                if (vha->vp_idx != 0 && vha->vp_idx != fcport->vha->vp_idx)
3441                        continue;
3442
3443                /*
3444                 * No point in marking the device as lost, if the device is
3445                 * already DEAD.
3446                 */
3447                if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD)
3448                        continue;
3449                if (atomic_read(&fcport->state) == FCS_ONLINE) {
3450                        qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
3451                        if (defer)
3452                                qla2x00_schedule_rport_del(vha, fcport, defer);
3453                        else if (vha->vp_idx == fcport->vha->vp_idx)
3454                                qla2x00_schedule_rport_del(vha, fcport, defer);
3455                }
3456        }
3457}
3458
3459/*
3460* qla2x00_mem_alloc
3461*      Allocates adapter memory.
3462*
3463* Returns:
3464*      0  = success.
3465*      !0  = failure.
3466*/
3467static int
3468qla2x00_mem_alloc(struct qla_hw_data *ha, uint16_t req_len, uint16_t rsp_len,
3469        struct req_que **req, struct rsp_que **rsp)
3470{
3471        char    name[16];
3472
3473        ha->init_cb = dma_alloc_coherent(&ha->pdev->dev, ha->init_cb_size,
3474                &ha->init_cb_dma, GFP_KERNEL);
3475        if (!ha->init_cb)
3476                goto fail;
3477
3478        if (qlt_mem_alloc(ha) < 0)
3479                goto fail_free_init_cb;
3480
3481        ha->gid_list = dma_alloc_coherent(&ha->pdev->dev,
3482                qla2x00_gid_list_size(ha), &ha->gid_list_dma, GFP_KERNEL);
3483        if (!ha->gid_list)
3484                goto fail_free_tgt_mem;
3485
3486        ha->srb_mempool = mempool_create_slab_pool(SRB_MIN_REQ, srb_cachep);
3487        if (!ha->srb_mempool)
3488                goto fail_free_gid_list;
3489
3490        if (IS_P3P_TYPE(ha)) {
3491                /* Allocate cache for CT6 Ctx. */
3492                if (!ctx_cachep) {
3493                        ctx_cachep = kmem_cache_create("qla2xxx_ctx",
3494                                sizeof(struct ct6_dsd), 0,
3495                                SLAB_HWCACHE_ALIGN, NULL);
3496                        if (!ctx_cachep)
3497                                goto fail_free_srb_mempool;
3498                }
3499                ha->ctx_mempool = mempool_create_slab_pool(SRB_MIN_REQ,
3500                        ctx_cachep);
3501                if (!ha->ctx_mempool)
3502                        goto fail_free_srb_mempool;
3503                ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0021,
3504                    "ctx_cachep=%p ctx_mempool=%p.\n",
3505                    ctx_cachep, ha->ctx_mempool);
3506        }
3507
3508        /* Get memory for cached NVRAM */
3509        ha->nvram = kzalloc(MAX_NVRAM_SIZE, GFP_KERNEL);
3510        if (!ha->nvram)
3511                goto fail_free_ctx_mempool;
3512
3513        snprintf(name, sizeof(name), "%s_%d", QLA2XXX_DRIVER_NAME,
3514                ha->pdev->device);
3515        ha->s_dma_pool = dma_pool_create(name, &ha->pdev->dev,
3516                DMA_POOL_SIZE, 8, 0);
3517        if (!ha->s_dma_pool)
3518                goto fail_free_nvram;
3519
3520        ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0022,
3521            "init_cb=%p gid_list=%p, srb_mempool=%p s_dma_pool=%p.\n",
3522            ha->init_cb, ha->gid_list, ha->srb_mempool, ha->s_dma_pool);
3523
3524        if (IS_P3P_TYPE(ha) || ql2xenabledif) {
3525                ha->dl_dma_pool = dma_pool_create(name, &ha->pdev->dev,
3526                        DSD_LIST_DMA_POOL_SIZE, 8, 0);
3527                if (!ha->dl_dma_pool) {
3528                        ql_log_pci(ql_log_fatal, ha->pdev, 0x0023,
3529                            "Failed to allocate memory for dl_dma_pool.\n");
3530                        goto fail_s_dma_pool;
3531                }
3532
3533                ha->fcp_cmnd_dma_pool = dma_pool_create(name, &ha->pdev->dev,
3534                        FCP_CMND_DMA_POOL_SIZE, 8, 0);
3535                if (!ha->fcp_cmnd_dma_pool) {
3536                        ql_log_pci(ql_log_fatal, ha->pdev, 0x0024,
3537                            "Failed to allocate memory for fcp_cmnd_dma_pool.\n");
3538                        goto fail_dl_dma_pool;
3539                }
3540                ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0025,
3541                    "dl_dma_pool=%p fcp_cmnd_dma_pool=%p.\n",
3542                    ha->dl_dma_pool, ha->fcp_cmnd_dma_pool);
3543        }
3544
3545        /* Allocate memory for SNS commands */
3546        if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
3547        /* Get consistent memory allocated for SNS commands */
3548                ha->sns_cmd = dma_alloc_coherent(&ha->pdev->dev,
3549                sizeof(struct sns_cmd_pkt), &ha->sns_cmd_dma, GFP_KERNEL);
3550                if (!ha->sns_cmd)
3551                        goto fail_dma_pool;
3552                ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0026,
3553                    "sns_cmd: %p.\n", ha->sns_cmd);
3554        } else {
3555        /* Get consistent memory allocated for MS IOCB */
3556                ha->ms_iocb = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
3557                        &ha->ms_iocb_dma);
3558                if (!ha->ms_iocb)
3559                        goto fail_dma_pool;
3560        /* Get consistent memory allocated for CT SNS commands */
3561                ha->ct_sns = dma_alloc_coherent(&ha->pdev->dev,
3562                        sizeof(struct ct_sns_pkt), &ha->ct_sns_dma, GFP_KERNEL);
3563                if (!ha->ct_sns)
3564                        goto fail_free_ms_iocb;
3565                ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0027,
3566                    "ms_iocb=%p ct_sns=%p.\n",
3567                    ha->ms_iocb, ha->ct_sns);
3568        }
3569
3570        /* Allocate memory for request ring */
3571        *req = kzalloc(sizeof(struct req_que), GFP_KERNEL);
3572        if (!*req) {
3573                ql_log_pci(ql_log_fatal, ha->pdev, 0x0028,
3574                    "Failed to allocate memory for req.\n");
3575                goto fail_req;
3576        }
3577        (*req)->length = req_len;
3578        (*req)->ring = dma_alloc_coherent(&ha->pdev->dev,
3579                ((*req)->length + 1) * sizeof(request_t),
3580                &(*req)->dma, GFP_KERNEL);
3581        if (!(*req)->ring) {
3582                ql_log_pci(ql_log_fatal, ha->pdev, 0x0029,
3583                    "Failed to allocate memory for req_ring.\n");
3584                goto fail_req_ring;
3585        }
3586        /* Allocate memory for response ring */
3587        *rsp = kzalloc(sizeof(struct rsp_que), GFP_KERNEL);
3588        if (!*rsp) {
3589                ql_log_pci(ql_log_fatal, ha->pdev, 0x002a,
3590                    "Failed to allocate memory for rsp.\n");
3591                goto fail_rsp;
3592        }
3593        (*rsp)->hw = ha;
3594        (*rsp)->length = rsp_len;
3595        (*rsp)->ring = dma_alloc_coherent(&ha->pdev->dev,
3596                ((*rsp)->length + 1) * sizeof(response_t),
3597                &(*rsp)->dma, GFP_KERNEL);
3598        if (!(*rsp)->ring) {
3599                ql_log_pci(ql_log_fatal, ha->pdev, 0x002b,
3600                    "Failed to allocate memory for rsp_ring.\n");
3601                goto fail_rsp_ring;
3602        }
3603        (*req)->rsp = *rsp;
3604        (*rsp)->req = *req;
3605        ql_dbg_pci(ql_dbg_init, ha->pdev, 0x002c,
3606            "req=%p req->length=%d req->ring=%p rsp=%p "
3607            "rsp->length=%d rsp->ring=%p.\n",
3608            *req, (*req)->length, (*req)->ring, *rsp, (*rsp)->length,
3609            (*rsp)->ring);
3610        /* Allocate memory for NVRAM data for vports */
3611        if (ha->nvram_npiv_size) {
3612                ha->npiv_info = kzalloc(sizeof(struct qla_npiv_entry) *
3613                    ha->nvram_npiv_size, GFP_KERNEL);
3614                if (!ha->npiv_info) {
3615                        ql_log_pci(ql_log_fatal, ha->pdev, 0x002d,
3616                            "Failed to allocate memory for npiv_info.\n");
3617                        goto fail_npiv_info;
3618                }
3619        } else
3620                ha->npiv_info = NULL;
3621
3622        /* Get consistent memory allocated for EX-INIT-CB. */
3623        if (IS_CNA_CAPABLE(ha) || IS_QLA2031(ha) || IS_QLA27XX(ha)) {
3624                ha->ex_init_cb = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
3625                    &ha->ex_init_cb_dma);
3626                if (!ha->ex_init_cb)
3627                        goto fail_ex_init_cb;
3628                ql_dbg_pci(ql_dbg_init, ha->pdev, 0x002e,
3629                    "ex_init_cb=%p.\n", ha->ex_init_cb);
3630        }
3631
3632        INIT_LIST_HEAD(&ha->gbl_dsd_list);
3633
3634        /* Get consistent memory allocated for Async Port-Database. */
3635        if (!IS_FWI2_CAPABLE(ha)) {
3636                ha->async_pd = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
3637                        &ha->async_pd_dma);
3638                if (!ha->async_pd)
3639                        goto fail_async_pd;
3640                ql_dbg_pci(ql_dbg_init, ha->pdev, 0x002f,
3641                    "async_pd=%p.\n", ha->async_pd);
3642        }
3643
3644        INIT_LIST_HEAD(&ha->vp_list);
3645
3646        /* Allocate memory for our loop_id bitmap */
3647        ha->loop_id_map = kzalloc(BITS_TO_LONGS(LOOPID_MAP_SIZE) * sizeof(long),
3648            GFP_KERNEL);
3649        if (!ha->loop_id_map)
3650                goto fail_loop_id_map;
3651        else {
3652                qla2x00_set_reserved_loop_ids(ha);
3653                ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0123,
3654                    "loop_id_map=%p.\n", ha->loop_id_map);
3655        }
3656
3657        return 0;
3658
3659fail_loop_id_map:
3660        dma_pool_free(ha->s_dma_pool, ha->async_pd, ha->async_pd_dma);
3661fail_async_pd:
3662        dma_pool_free(ha->s_dma_pool, ha->ex_init_cb, ha->ex_init_cb_dma);
3663fail_ex_init_cb:
3664        kfree(ha->npiv_info);
3665fail_npiv_info:
3666        dma_free_coherent(&ha->pdev->dev, ((*rsp)->length + 1) *
3667                sizeof(response_t), (*rsp)->ring, (*rsp)->dma);
3668        (*rsp)->ring = NULL;
3669        (*rsp)->dma = 0;
3670fail_rsp_ring:
3671        kfree(*rsp);
3672fail_rsp:
3673        dma_free_coherent(&ha->pdev->dev, ((*req)->length + 1) *
3674                sizeof(request_t), (*req)->ring, (*req)->dma);
3675        (*req)->ring = NULL;
3676        (*req)->dma = 0;
3677fail_req_ring:
3678        kfree(*req);
3679fail_req:
3680        dma_free_coherent(&ha->pdev->dev, sizeof(struct ct_sns_pkt),
3681                ha->ct_sns, ha->ct_sns_dma);
3682        ha->ct_sns = NULL;
3683        ha->ct_sns_dma = 0;
3684fail_free_ms_iocb:
3685        dma_pool_free(ha->s_dma_pool, ha->ms_iocb, ha->ms_iocb_dma);
3686        ha->ms_iocb = NULL;
3687        ha->ms_iocb_dma = 0;
3688
3689        if (ha->sns_cmd)
3690                dma_free_coherent(&ha->pdev->dev, sizeof(struct sns_cmd_pkt),
3691                    ha->sns_cmd, ha->sns_cmd_dma);
3692fail_dma_pool:
3693        if (IS_QLA82XX(ha) || ql2xenabledif) {
3694                dma_pool_destroy(ha->fcp_cmnd_dma_pool);
3695                ha->fcp_cmnd_dma_pool = NULL;
3696        }
3697fail_dl_dma_pool:
3698        if (IS_QLA82XX(ha) || ql2xenabledif) {
3699                dma_pool_destroy(ha->dl_dma_pool);
3700                ha->dl_dma_pool = NULL;
3701        }
3702fail_s_dma_pool:
3703        dma_pool_destroy(ha->s_dma_pool);
3704        ha->s_dma_pool = NULL;
3705fail_free_nvram:
3706        kfree(ha->nvram);
3707        ha->nvram = NULL;
3708fail_free_ctx_mempool:
3709        if (ha->ctx_mempool)
3710                mempool_destroy(ha->ctx_mempool);
3711        ha->ctx_mempool = NULL;
3712fail_free_srb_mempool:
3713        if (ha->srb_mempool)
3714                mempool_destroy(ha->srb_mempool);
3715        ha->srb_mempool = NULL;
3716fail_free_gid_list:
3717        dma_free_coherent(&ha->pdev->dev, qla2x00_gid_list_size(ha),
3718        ha->gid_list,
3719        ha->gid_list_dma);
3720        ha->gid_list = NULL;
3721        ha->gid_list_dma = 0;
3722fail_free_tgt_mem:
3723        qlt_mem_free(ha);
3724fail_free_init_cb:
3725        dma_free_coherent(&ha->pdev->dev, ha->init_cb_size, ha->init_cb,
3726        ha->init_cb_dma);
3727        ha->init_cb = NULL;
3728        ha->init_cb_dma = 0;
3729fail:
3730        ql_log(ql_log_fatal, NULL, 0x0030,
3731            "Memory allocation failure.\n");
3732        return -ENOMEM;
3733}
3734
3735int
3736qla2x00_set_exlogins_buffer(scsi_qla_host_t *vha)
3737{
3738        int rval;
3739        uint16_t        size, max_cnt, temp;
3740        struct qla_hw_data *ha = vha->hw;
3741
3742        /* Return if we don't need to alloacate any extended logins */
3743        if (!ql2xexlogins)
3744                return QLA_SUCCESS;
3745
3746        ql_log(ql_log_info, vha, 0xd021, "EXLOGIN count: %d.\n", ql2xexlogins);
3747        max_cnt = 0;
3748        rval = qla_get_exlogin_status(vha, &size, &max_cnt);
3749        if (rval != QLA_SUCCESS) {
3750                ql_log_pci(ql_log_fatal, ha->pdev, 0xd029,
3751                    "Failed to get exlogin status.\n");
3752                return rval;
3753        }
3754
3755        temp = (ql2xexlogins > max_cnt) ? max_cnt : ql2xexlogins;
3756        ha->exlogin_size = (size * temp);
3757        ql_log(ql_log_info, vha, 0xd024,
3758                "EXLOGIN: max_logins=%d, portdb=0x%x, total=%d.\n",
3759                max_cnt, size, temp);
3760
3761        ql_log(ql_log_info, vha, 0xd025, "EXLOGIN: requested size=0x%x\n",
3762                ha->exlogin_size);
3763
3764        /* Get consistent memory for extended logins */
3765        ha->exlogin_buf = dma_alloc_coherent(&ha->pdev->dev,
3766            ha->exlogin_size, &ha->exlogin_buf_dma, GFP_KERNEL);
3767        if (!ha->exlogin_buf) {
3768                ql_log_pci(ql_log_fatal, ha->pdev, 0xd02a,
3769                    "Failed to allocate memory for exlogin_buf_dma.\n");
3770                return -ENOMEM;
3771        }
3772
3773        /* Now configure the dma buffer */
3774        rval = qla_set_exlogin_mem_cfg(vha, ha->exlogin_buf_dma);
3775        if (rval) {
3776                ql_log(ql_log_fatal, vha, 0x00cf,
3777                    "Setup extended login buffer  ****FAILED****.\n");
3778                qla2x00_free_exlogin_buffer(ha);
3779        }
3780
3781        return rval;
3782}
3783
3784/*
3785* qla2x00_free_exlogin_buffer
3786*
3787* Input:
3788*       ha = adapter block pointer
3789*/
3790void
3791qla2x00_free_exlogin_buffer(struct qla_hw_data *ha)
3792{
3793        if (ha->exlogin_buf) {
3794                dma_free_coherent(&ha->pdev->dev, ha->exlogin_size,
3795                    ha->exlogin_buf, ha->exlogin_buf_dma);
3796                ha->exlogin_buf = NULL;
3797                ha->exlogin_size = 0;
3798        }
3799}
3800
3801int
3802qla2x00_set_exchoffld_buffer(scsi_qla_host_t *vha)
3803{
3804        int rval;
3805        uint16_t        size, max_cnt, temp;
3806        struct qla_hw_data *ha = vha->hw;
3807
3808        /* Return if we don't need to alloacate any extended logins */
3809        if (!ql2xexchoffld)
3810                return QLA_SUCCESS;
3811
3812        ql_log(ql_log_info, vha, 0xd014,
3813            "Exchange offload count: %d.\n", ql2xexlogins);
3814
3815        max_cnt = 0;
3816        rval = qla_get_exchoffld_status(vha, &size, &max_cnt);
3817        if (rval != QLA_SUCCESS) {
3818                ql_log_pci(ql_log_fatal, ha->pdev, 0xd012,
3819                    "Failed to get exlogin status.\n");
3820                return rval;
3821        }
3822
3823        temp = (ql2xexchoffld > max_cnt) ? max_cnt : ql2xexchoffld;
3824        ha->exchoffld_size = (size * temp);
3825        ql_log(ql_log_info, vha, 0xd016,
3826                "Exchange offload: max_count=%d, buffers=0x%x, total=%d.\n",
3827                max_cnt, size, temp);
3828
3829        ql_log(ql_log_info, vha, 0xd017,
3830            "Exchange Buffers requested size = 0x%x\n", ha->exchoffld_size);
3831
3832        /* Get consistent memory for extended logins */
3833        ha->exchoffld_buf = dma_alloc_coherent(&ha->pdev->dev,
3834            ha->exchoffld_size, &ha->exchoffld_buf_dma, GFP_KERNEL);
3835        if (!ha->exchoffld_buf) {
3836                ql_log_pci(ql_log_fatal, ha->pdev, 0xd013,
3837                    "Failed to allocate memory for exchoffld_buf_dma.\n");
3838                return -ENOMEM;
3839        }
3840
3841        /* Now configure the dma buffer */
3842        rval = qla_set_exchoffld_mem_cfg(vha, ha->exchoffld_buf_dma);
3843        if (rval) {
3844                ql_log(ql_log_fatal, vha, 0xd02e,
3845                    "Setup exchange offload buffer ****FAILED****.\n");
3846                qla2x00_free_exchoffld_buffer(ha);
3847        }
3848
3849        return rval;
3850}
3851
3852/*
3853* qla2x00_free_exchoffld_buffer
3854*
3855* Input:
3856*       ha = adapter block pointer
3857*/
3858void
3859qla2x00_free_exchoffld_buffer(struct qla_hw_data *ha)
3860{
3861        if (ha->exchoffld_buf) {
3862                dma_free_coherent(&ha->pdev->dev, ha->exchoffld_size,
3863                    ha->exchoffld_buf, ha->exchoffld_buf_dma);
3864                ha->exchoffld_buf = NULL;
3865                ha->exchoffld_size = 0;
3866        }
3867}
3868
3869/*
3870* qla2x00_free_fw_dump
3871*       Frees fw dump stuff.
3872*
3873* Input:
3874*       ha = adapter block pointer
3875*/
3876static void
3877qla2x00_free_fw_dump(struct qla_hw_data *ha)
3878{
3879        if (ha->fce)
3880                dma_free_coherent(&ha->pdev->dev,
3881                    FCE_SIZE, ha->fce, ha->fce_dma);
3882
3883        if (ha->eft)
3884                dma_free_coherent(&ha->pdev->dev,
3885                    EFT_SIZE, ha->eft, ha->eft_dma);
3886
3887        if (ha->fw_dump)
3888                vfree(ha->fw_dump);
3889        if (ha->fw_dump_template)
3890                vfree(ha->fw_dump_template);
3891
3892        ha->fce = NULL;
3893        ha->fce_dma = 0;
3894        ha->eft = NULL;
3895        ha->eft_dma = 0;
3896        ha->fw_dumped = 0;
3897        ha->fw_dump_cap_flags = 0;
3898        ha->fw_dump_reading = 0;
3899        ha->fw_dump = NULL;
3900        ha->fw_dump_len = 0;
3901        ha->fw_dump_template = NULL;
3902        ha->fw_dump_template_len = 0;
3903}
3904
3905/*
3906* qla2x00_mem_free
3907*      Frees all adapter allocated memory.
3908*
3909* Input:
3910*      ha = adapter block pointer.
3911*/
3912static void
3913qla2x00_mem_free(struct qla_hw_data *ha)
3914{
3915        qla2x00_free_fw_dump(ha);
3916
3917        if (ha->mctp_dump)
3918                dma_free_coherent(&ha->pdev->dev, MCTP_DUMP_SIZE, ha->mctp_dump,
3919                    ha->mctp_dump_dma);
3920
3921        if (ha->srb_mempool)
3922                mempool_destroy(ha->srb_mempool);
3923
3924        if (ha->dcbx_tlv)
3925                dma_free_coherent(&ha->pdev->dev, DCBX_TLV_DATA_SIZE,
3926                    ha->dcbx_tlv, ha->dcbx_tlv_dma);
3927
3928        if (ha->xgmac_data)
3929                dma_free_coherent(&ha->pdev->dev, XGMAC_DATA_SIZE,
3930                    ha->xgmac_data, ha->xgmac_data_dma);
3931
3932        if (ha->sns_cmd)
3933                dma_free_coherent(&ha->pdev->dev, sizeof(struct sns_cmd_pkt),
3934                ha->sns_cmd, ha->sns_cmd_dma);
3935
3936        if (ha->ct_sns)
3937                dma_free_coherent(&ha->pdev->dev, sizeof(struct ct_sns_pkt),
3938                ha->ct_sns, ha->ct_sns_dma);
3939
3940        if (ha->sfp_data)
3941                dma_pool_free(ha->s_dma_pool, ha->sfp_data, ha->sfp_data_dma);
3942
3943        if (ha->ms_iocb)
3944                dma_pool_free(ha->s_dma_pool, ha->ms_iocb, ha->ms_iocb_dma);
3945
3946        if (ha->ex_init_cb)
3947                dma_pool_free(ha->s_dma_pool,
3948                        ha->ex_init_cb, ha->ex_init_cb_dma);
3949
3950        if (ha->async_pd)
3951                dma_pool_free(ha->s_dma_pool, ha->async_pd, ha->async_pd_dma);
3952
3953        if (ha->s_dma_pool)
3954                dma_pool_destroy(ha->s_dma_pool);
3955
3956        if (ha->gid_list)
3957                dma_free_coherent(&ha->pdev->dev, qla2x00_gid_list_size(ha),
3958                ha->gid_list, ha->gid_list_dma);
3959
3960        if (IS_QLA82XX(ha)) {
3961                if (!list_empty(&ha->gbl_dsd_list)) {
3962                        struct dsd_dma *dsd_ptr, *tdsd_ptr;
3963
3964                        /* clean up allocated prev pool */
3965                        list_for_each_entry_safe(dsd_ptr,
3966                                tdsd_ptr, &ha->gbl_dsd_list, list) {
3967                                dma_pool_free(ha->dl_dma_pool,
3968                                dsd_ptr->dsd_addr, dsd_ptr->dsd_list_dma);
3969                                list_del(&dsd_ptr->list);
3970                                kfree(dsd_ptr);
3971                        }
3972                }
3973        }
3974
3975        if (ha->dl_dma_pool)
3976                dma_pool_destroy(ha->dl_dma_pool);
3977
3978        if (ha->fcp_cmnd_dma_pool)
3979                dma_pool_destroy(ha->fcp_cmnd_dma_pool);
3980
3981        if (ha->ctx_mempool)
3982                mempool_destroy(ha->ctx_mempool);
3983
3984        qlt_mem_free(ha);
3985
3986        if (ha->init_cb)
3987                dma_free_coherent(&ha->pdev->dev, ha->init_cb_size,
3988                        ha->init_cb, ha->init_cb_dma);
3989        vfree(ha->optrom_buffer);
3990        kfree(ha->nvram);
3991        kfree(ha->npiv_info);
3992        kfree(ha->swl);
3993        kfree(ha->loop_id_map);
3994
3995        ha->srb_mempool = NULL;
3996        ha->ctx_mempool = NULL;
3997        ha->sns_cmd = NULL;
3998        ha->sns_cmd_dma = 0;
3999        ha->ct_sns = NULL;
4000        ha->ct_sns_dma = 0;
4001        ha->ms_iocb = NULL;
4002        ha->ms_iocb_dma = 0;
4003        ha->init_cb = NULL;
4004        ha->init_cb_dma = 0;
4005        ha->ex_init_cb = NULL;
4006        ha->ex_init_cb_dma = 0;
4007        ha->async_pd = NULL;
4008        ha->async_pd_dma = 0;
4009
4010        ha->s_dma_pool = NULL;
4011        ha->dl_dma_pool = NULL;
4012        ha->fcp_cmnd_dma_pool = NULL;
4013
4014        ha->gid_list = NULL;
4015        ha->gid_list_dma = 0;
4016
4017        ha->tgt.atio_ring = NULL;
4018        ha->tgt.atio_dma = 0;
4019        ha->tgt.tgt_vp_map = NULL;
4020}
4021
4022struct scsi_qla_host *qla2x00_create_host(struct scsi_host_template *sht,
4023                                                struct qla_hw_data *ha)
4024{
4025        struct Scsi_Host *host;
4026        struct scsi_qla_host *vha = NULL;
4027
4028        host = scsi_host_alloc(sht, sizeof(scsi_qla_host_t));
4029        if (host == NULL) {
4030                ql_log_pci(ql_log_fatal, ha->pdev, 0x0107,
4031                    "Failed to allocate host from the scsi layer, aborting.\n");
4032                goto fail;
4033        }
4034
4035        /* Clear our data area */
4036        vha = shost_priv(host);
4037        memset(vha, 0, sizeof(scsi_qla_host_t));
4038
4039        vha->host = host;
4040        vha->host_no = host->host_no;
4041        vha->hw = ha;
4042
4043        INIT_LIST_HEAD(&vha->vp_fcports);
4044        INIT_LIST_HEAD(&vha->work_list);
4045        INIT_LIST_HEAD(&vha->list);
4046        INIT_LIST_HEAD(&vha->qla_cmd_list);
4047        INIT_LIST_HEAD(&vha->qla_sess_op_cmd_list);
4048        INIT_LIST_HEAD(&vha->logo_list);
4049        INIT_LIST_HEAD(&vha->plogi_ack_list);
4050
4051        spin_lock_init(&vha->work_lock);
4052        spin_lock_init(&vha->cmd_list_lock);
4053        init_waitqueue_head(&vha->vref_waitq);
4054
4055        sprintf(vha->host_str, "%s_%ld", QLA2XXX_DRIVER_NAME, vha->host_no);
4056        ql_dbg(ql_dbg_init, vha, 0x0041,
4057            "Allocated the host=%p hw=%p vha=%p dev_name=%s",
4058            vha->host, vha->hw, vha,
4059            dev_name(&(ha->pdev->dev)));
4060
4061        return vha;
4062
4063fail:
4064        return vha;
4065}
4066
4067static struct qla_work_evt *
4068qla2x00_alloc_work(struct scsi_qla_host *vha, enum qla_work_type type)
4069{
4070        struct qla_work_evt *e;
4071        uint8_t bail;
4072
4073        QLA_VHA_MARK_BUSY(vha, bail);
4074        if (bail)
4075                return NULL;
4076
4077        e = kzalloc(sizeof(struct qla_work_evt), GFP_ATOMIC);
4078        if (!e) {
4079                QLA_VHA_MARK_NOT_BUSY(vha);
4080                return NULL;
4081        }
4082
4083        INIT_LIST_HEAD(&e->list);
4084        e->type = type;
4085        e->flags = QLA_EVT_FLAG_FREE;
4086        return e;
4087}
4088
4089static int
4090qla2x00_post_work(struct scsi_qla_host *vha, struct qla_work_evt *e)
4091{
4092        unsigned long flags;
4093
4094        spin_lock_irqsave(&vha->work_lock, flags);
4095        list_add_tail(&e->list, &vha->work_list);
4096        spin_unlock_irqrestore(&vha->work_lock, flags);
4097        qla2xxx_wake_dpc(vha);
4098
4099        return QLA_SUCCESS;
4100}
4101
4102int
4103qla2x00_post_aen_work(struct scsi_qla_host *vha, enum fc_host_event_code code,
4104    u32 data)
4105{
4106        struct qla_work_evt *e;
4107
4108        e = qla2x00_alloc_work(vha, QLA_EVT_AEN);
4109        if (!e)
4110                return QLA_FUNCTION_FAILED;
4111
4112        e->u.aen.code = code;
4113        e->u.aen.data = data;
4114        return qla2x00_post_work(vha, e);
4115}
4116
4117int
4118qla2x00_post_idc_ack_work(struct scsi_qla_host *vha, uint16_t *mb)
4119{
4120        struct qla_work_evt *e;
4121
4122        e = qla2x00_alloc_work(vha, QLA_EVT_IDC_ACK);
4123        if (!e)
4124                return QLA_FUNCTION_FAILED;
4125
4126        memcpy(e->u.idc_ack.mb, mb, QLA_IDC_ACK_REGS * sizeof(uint16_t));
4127        return qla2x00_post_work(vha, e);
4128}
4129
4130#define qla2x00_post_async_work(name, type)     \
4131int qla2x00_post_async_##name##_work(           \
4132    struct scsi_qla_host *vha,                  \
4133    fc_port_t *fcport, uint16_t *data)          \
4134{                                               \
4135        struct qla_work_evt *e;                 \
4136                                                \
4137        e = qla2x00_alloc_work(vha, type);      \
4138        if (!e)                                 \
4139                return QLA_FUNCTION_FAILED;     \
4140                                                \
4141        e->u.logio.fcport = fcport;             \
4142        if (data) {                             \
4143                e->u.logio.data[0] = data[0];   \
4144                e->u.logio.data[1] = data[1];   \
4145        }                                       \
4146        return qla2x00_post_work(vha, e);       \
4147}
4148
4149qla2x00_post_async_work(login, QLA_EVT_ASYNC_LOGIN);
4150qla2x00_post_async_work(login_done, QLA_EVT_ASYNC_LOGIN_DONE);
4151qla2x00_post_async_work(logout, QLA_EVT_ASYNC_LOGOUT);
4152qla2x00_post_async_work(logout_done, QLA_EVT_ASYNC_LOGOUT_DONE);
4153qla2x00_post_async_work(adisc, QLA_EVT_ASYNC_ADISC);
4154qla2x00_post_async_work(adisc_done, QLA_EVT_ASYNC_ADISC_DONE);
4155
4156int
4157qla2x00_post_uevent_work(struct scsi_qla_host *vha, u32 code)
4158{
4159        struct qla_work_evt *e;
4160
4161        e = qla2x00_alloc_work(vha, QLA_EVT_UEVENT);
4162        if (!e)
4163                return QLA_FUNCTION_FAILED;
4164
4165        e->u.uevent.code = code;
4166        return qla2x00_post_work(vha, e);
4167}
4168
4169static void
4170qla2x00_uevent_emit(struct scsi_qla_host *vha, u32 code)
4171{
4172        char event_string[40];
4173        char *envp[] = { event_string, NULL };
4174
4175        switch (code) {
4176        case QLA_UEVENT_CODE_FW_DUMP:
4177                snprintf(event_string, sizeof(event_string), "FW_DUMP=%ld",
4178                    vha->host_no);
4179                break;
4180        default:
4181                /* do nothing */
4182                break;
4183        }
4184        kobject_uevent_env(&vha->hw->pdev->dev.kobj, KOBJ_CHANGE, envp);
4185}
4186
4187int
4188qlafx00_post_aenfx_work(struct scsi_qla_host *vha,  uint32_t evtcode,
4189                        uint32_t *data, int cnt)
4190{
4191        struct qla_work_evt *e;
4192
4193        e = qla2x00_alloc_work(vha, QLA_EVT_AENFX);
4194        if (!e)
4195                return QLA_FUNCTION_FAILED;
4196
4197        e->u.aenfx.evtcode = evtcode;
4198        e->u.aenfx.count = cnt;
4199        memcpy(e->u.aenfx.mbx, data, sizeof(*data) * cnt);
4200        return qla2x00_post_work(vha, e);
4201}
4202
4203void
4204qla2x00_do_work(struct scsi_qla_host *vha)
4205{
4206        struct qla_work_evt *e, *tmp;
4207        unsigned long flags;
4208        LIST_HEAD(work);
4209
4210        spin_lock_irqsave(&vha->work_lock, flags);
4211        list_splice_init(&vha->work_list, &work);
4212        spin_unlock_irqrestore(&vha->work_lock, flags);
4213
4214        list_for_each_entry_safe(e, tmp, &work, list) {
4215                list_del_init(&e->list);
4216
4217                switch (e->type) {
4218                case QLA_EVT_AEN:
4219                        fc_host_post_event(vha->host, fc_get_event_number(),
4220                            e->u.aen.code, e->u.aen.data);
4221                        break;
4222                case QLA_EVT_IDC_ACK:
4223                        qla81xx_idc_ack(vha, e->u.idc_ack.mb);
4224                        break;
4225                case QLA_EVT_ASYNC_LOGIN:
4226                        qla2x00_async_login(vha, e->u.logio.fcport,
4227                            e->u.logio.data);
4228                        break;
4229                case QLA_EVT_ASYNC_LOGIN_DONE:
4230                        qla2x00_async_login_done(vha, e->u.logio.fcport,
4231                            e->u.logio.data);
4232                        break;
4233                case QLA_EVT_ASYNC_LOGOUT:
4234                        qla2x00_async_logout(vha, e->u.logio.fcport);
4235                        break;
4236                case QLA_EVT_ASYNC_LOGOUT_DONE:
4237                        qla2x00_async_logout_done(vha, e->u.logio.fcport,
4238                            e->u.logio.data);
4239                        break;
4240                case QLA_EVT_ASYNC_ADISC:
4241                        qla2x00_async_adisc(vha, e->u.logio.fcport,
4242                            e->u.logio.data);
4243                        break;
4244                case QLA_EVT_ASYNC_ADISC_DONE:
4245                        qla2x00_async_adisc_done(vha, e->u.logio.fcport,
4246                            e->u.logio.data);
4247                        break;
4248                case QLA_EVT_UEVENT:
4249                        qla2x00_uevent_emit(vha, e->u.uevent.code);
4250                        break;
4251                case QLA_EVT_AENFX:
4252                        qlafx00_process_aen(vha, e);
4253                        break;
4254                }
4255                if (e->flags & QLA_EVT_FLAG_FREE)
4256                        kfree(e);
4257
4258                /* For each work completed decrement vha ref count */
4259                QLA_VHA_MARK_NOT_BUSY(vha);
4260        }
4261}
4262
4263/* Relogins all the fcports of a vport
4264 * Context: dpc thread
4265 */
4266void qla2x00_relogin(struct scsi_qla_host *vha)
4267{
4268        fc_port_t       *fcport;
4269        int status;
4270        uint16_t        next_loopid = 0;
4271        struct qla_hw_data *ha = vha->hw;
4272        uint16_t data[2];
4273
4274        list_for_each_entry(fcport, &vha->vp_fcports, list) {
4275        /*
4276         * If the port is not ONLINE then try to login
4277         * to it if we haven't run out of retries.
4278         */
4279                if (atomic_read(&fcport->state) != FCS_ONLINE &&
4280                    fcport->login_retry && !(fcport->flags & FCF_ASYNC_SENT)) {
4281                        fcport->login_retry--;
4282                        if (fcport->flags & FCF_FABRIC_DEVICE) {
4283                                if (fcport->flags & FCF_FCP2_DEVICE)
4284                                        ha->isp_ops->fabric_logout(vha,
4285                                                        fcport->loop_id,
4286                                                        fcport->d_id.b.domain,
4287                                                        fcport->d_id.b.area,
4288                                                        fcport->d_id.b.al_pa);
4289
4290                                if (fcport->loop_id == FC_NO_LOOP_ID) {
4291                                        fcport->loop_id = next_loopid =
4292                                            ha->min_external_loopid;
4293                                        status = qla2x00_find_new_loop_id(
4294                                            vha, fcport);
4295                                        if (status != QLA_SUCCESS) {
4296                                                /* Ran out of IDs to use */
4297                                                break;
4298                                        }
4299                                }
4300
4301                                if (IS_ALOGIO_CAPABLE(ha)) {
4302                                        fcport->flags |= FCF_ASYNC_SENT;
4303                                        data[0] = 0;
4304                                        data[1] = QLA_LOGIO_LOGIN_RETRIED;
4305                                        status = qla2x00_post_async_login_work(
4306                                            vha, fcport, data);
4307                                        if (status == QLA_SUCCESS)
4308                                                continue;
4309                                        /* Attempt a retry. */
4310                                        status = 1;
4311                                } else {
4312                                        status = qla2x00_fabric_login(vha,
4313                                            fcport, &next_loopid);
4314                                        if (status ==  QLA_SUCCESS) {
4315                                                int status2;
4316                                                uint8_t opts;
4317
4318                                                opts = 0;
4319                                                if (fcport->flags &
4320                                                    FCF_FCP2_DEVICE)
4321                                                        opts |= BIT_1;
4322                                                status2 =
4323                                                    qla2x00_get_port_database(
4324                                                        vha, fcport, opts);
4325                                                if (status2 != QLA_SUCCESS)
4326                                                        status = 1;
4327                                        }
4328                                }
4329                        } else
4330                                status = qla2x00_local_device_login(vha,
4331                                                                fcport);
4332
4333                        if (status == QLA_SUCCESS) {
4334                                fcport->old_loop_id = fcport->loop_id;
4335
4336                                ql_dbg(ql_dbg_disc, vha, 0x2003,
4337                                    "Port login OK: logged in ID 0x%x.\n",
4338                                    fcport->loop_id);
4339
4340                                qla2x00_update_fcport(vha, fcport);
4341
4342                        } else if (status == 1) {
4343                                set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
4344                                /* retry the login again */
4345                                ql_dbg(ql_dbg_disc, vha, 0x2007,
4346                                    "Retrying %d login again loop_id 0x%x.\n",
4347                                    fcport->login_retry, fcport->loop_id);
4348                        } else {
4349                                fcport->login_retry = 0;
4350                        }
4351
4352                        if (fcport->login_retry == 0 && status != QLA_SUCCESS)
4353                                qla2x00_clear_loop_id(fcport);
4354                }
4355                if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
4356                        break;
4357        }
4358}
4359
4360/* Schedule work on any of the dpc-workqueues */
4361void
4362qla83xx_schedule_work(scsi_qla_host_t *base_vha, int work_code)
4363{
4364        struct qla_hw_data *ha = base_vha->hw;
4365
4366        switch (work_code) {
4367        case MBA_IDC_AEN: /* 0x8200 */
4368                if (ha->dpc_lp_wq)
4369                        queue_work(ha->dpc_lp_wq, &ha->idc_aen);
4370                break;
4371
4372        case QLA83XX_NIC_CORE_RESET: /* 0x1 */
4373                if (!ha->flags.nic_core_reset_hdlr_active) {
4374                        if (ha->dpc_hp_wq)
4375                                queue_work(ha->dpc_hp_wq, &ha->nic_core_reset);
4376                } else
4377                        ql_dbg(ql_dbg_p3p, base_vha, 0xb05e,
4378                            "NIC Core reset is already active. Skip "
4379                            "scheduling it again.\n");
4380                break;
4381        case QLA83XX_IDC_STATE_HANDLER: /* 0x2 */
4382                if (ha->dpc_hp_wq)
4383                        queue_work(ha->dpc_hp_wq, &ha->idc_state_handler);
4384                break;
4385        case QLA83XX_NIC_CORE_UNRECOVERABLE: /* 0x3 */
4386                if (ha->dpc_hp_wq)
4387                        queue_work(ha->dpc_hp_wq, &ha->nic_core_unrecoverable);
4388                break;
4389        default:
4390                ql_log(ql_log_warn, base_vha, 0xb05f,
4391                    "Unknown work-code=0x%x.\n", work_code);
4392        }
4393
4394        return;
4395}
4396
4397/* Work: Perform NIC Core Unrecoverable state handling */
4398void
4399qla83xx_nic_core_unrecoverable_work(struct work_struct *work)
4400{
4401        struct qla_hw_data *ha =
4402                container_of(work, struct qla_hw_data, nic_core_unrecoverable);
4403        scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
4404        uint32_t dev_state = 0;
4405
4406        qla83xx_idc_lock(base_vha, 0);
4407        qla83xx_rd_reg(base_vha, QLA83XX_IDC_DEV_STATE, &dev_state);
4408        qla83xx_reset_ownership(base_vha);
4409        if (ha->flags.nic_core_reset_owner) {
4410                ha->flags.nic_core_reset_owner = 0;
4411                qla83xx_wr_reg(base_vha, QLA83XX_IDC_DEV_STATE,
4412                    QLA8XXX_DEV_FAILED);
4413                ql_log(ql_log_info, base_vha, 0xb060, "HW State: FAILED.\n");
4414                qla83xx_schedule_work(base_vha, QLA83XX_IDC_STATE_HANDLER);
4415        }
4416        qla83xx_idc_unlock(base_vha, 0);
4417}
4418
4419/* Work: Execute IDC state handler */
4420void
4421qla83xx_idc_state_handler_work(struct work_struct *work)
4422{
4423        struct qla_hw_data *ha =
4424                container_of(work, struct qla_hw_data, idc_state_handler);
4425        scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
4426        uint32_t dev_state = 0;
4427
4428        qla83xx_idc_lock(base_vha, 0);
4429        qla83xx_rd_reg(base_vha, QLA83XX_IDC_DEV_STATE, &dev_state);
4430        if (dev_state == QLA8XXX_DEV_FAILED ||
4431                        dev_state == QLA8XXX_DEV_NEED_QUIESCENT)
4432                qla83xx_idc_state_handler(base_vha);
4433        qla83xx_idc_unlock(base_vha, 0);
4434}
4435
4436static int
4437qla83xx_check_nic_core_fw_alive(scsi_qla_host_t *base_vha)
4438{
4439        int rval = QLA_SUCCESS;
4440        unsigned long heart_beat_wait = jiffies + (1 * HZ);
4441        uint32_t heart_beat_counter1, heart_beat_counter2;
4442
4443        do {
4444                if (time_after(jiffies, heart_beat_wait)) {
4445                        ql_dbg(ql_dbg_p3p, base_vha, 0xb07c,
4446                            "Nic Core f/w is not alive.\n");
4447                        rval = QLA_FUNCTION_FAILED;
4448                        break;
4449                }
4450
4451                qla83xx_idc_lock(base_vha, 0);
4452                qla83xx_rd_reg(base_vha, QLA83XX_FW_HEARTBEAT,
4453                    &heart_beat_counter1);
4454                qla83xx_idc_unlock(base_vha, 0);
4455                msleep(100);
4456                qla83xx_idc_lock(base_vha, 0);
4457                qla83xx_rd_reg(base_vha, QLA83XX_FW_HEARTBEAT,
4458                    &heart_beat_counter2);
4459                qla83xx_idc_unlock(base_vha, 0);
4460        } while (heart_beat_counter1 == heart_beat_counter2);
4461
4462        return rval;
4463}
4464
4465/* Work: Perform NIC Core Reset handling */
4466void
4467qla83xx_nic_core_reset_work(struct work_struct *work)
4468{
4469        struct qla_hw_data *ha =
4470                container_of(work, struct qla_hw_data, nic_core_reset);
4471        scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
4472        uint32_t dev_state = 0;
4473
4474        if (IS_QLA2031(ha)) {
4475                if (qla2xxx_mctp_dump(base_vha) != QLA_SUCCESS)
4476                        ql_log(ql_log_warn, base_vha, 0xb081,
4477                            "Failed to dump mctp\n");
4478                return;
4479        }
4480
4481        if (!ha->flags.nic_core_reset_hdlr_active) {
4482                if (qla83xx_check_nic_core_fw_alive(base_vha) == QLA_SUCCESS) {
4483                        qla83xx_idc_lock(base_vha, 0);
4484                        qla83xx_rd_reg(base_vha, QLA83XX_IDC_DEV_STATE,
4485                            &dev_state);
4486                        qla83xx_idc_unlock(base_vha, 0);
4487                        if (dev_state != QLA8XXX_DEV_NEED_RESET) {
4488                                ql_dbg(ql_dbg_p3p, base_vha, 0xb07a,
4489                                    "Nic Core f/w is alive.\n");
4490                                return;
4491                        }
4492                }
4493
4494                ha->flags.nic_core_reset_hdlr_active = 1;
4495                if (qla83xx_nic_core_reset(base_vha)) {
4496                        /* NIC Core reset failed. */
4497                        ql_dbg(ql_dbg_p3p, base_vha, 0xb061,
4498                            "NIC Core reset failed.\n");
4499                }
4500                ha->flags.nic_core_reset_hdlr_active = 0;
4501        }
4502}
4503
4504/* Work: Handle 8200 IDC aens */
4505void
4506qla83xx_service_idc_aen(struct work_struct *work)
4507{
4508        struct qla_hw_data *ha =
4509                container_of(work, struct qla_hw_data, idc_aen);
4510        scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
4511        uint32_t dev_state, idc_control;
4512
4513        qla83xx_idc_lock(base_vha, 0);
4514        qla83xx_rd_reg(base_vha, QLA83XX_IDC_DEV_STATE, &dev_state);
4515        qla83xx_rd_reg(base_vha, QLA83XX_IDC_CONTROL, &idc_control);
4516        qla83xx_idc_unlock(base_vha, 0);
4517        if (dev_state == QLA8XXX_DEV_NEED_RESET) {
4518                if (idc_control & QLA83XX_IDC_GRACEFUL_RESET) {
4519                        ql_dbg(ql_dbg_p3p, base_vha, 0xb062,
4520                            "Application requested NIC Core Reset.\n");
4521                        qla83xx_schedule_work(base_vha, QLA83XX_NIC_CORE_RESET);
4522                } else if (qla83xx_check_nic_core_fw_alive(base_vha) ==
4523                    QLA_SUCCESS) {
4524                        ql_dbg(ql_dbg_p3p, base_vha, 0xb07b,
4525                            "Other protocol driver requested NIC Core Reset.\n");
4526                        qla83xx_schedule_work(base_vha, QLA83XX_NIC_CORE_RESET);
4527                }
4528        } else if (dev_state == QLA8XXX_DEV_FAILED ||
4529                        dev_state == QLA8XXX_DEV_NEED_QUIESCENT) {
4530                qla83xx_schedule_work(base_vha, QLA83XX_IDC_STATE_HANDLER);
4531        }
4532}
4533
4534static void
4535qla83xx_wait_logic(void)
4536{
4537        int i;
4538
4539        /* Yield CPU */
4540        if (!in_interrupt()) {
4541                /*
4542                 * Wait about 200ms before retrying again.
4543                 * This controls the number of retries for single
4544                 * lock operation.
4545                 */
4546                msleep(100);
4547                schedule();
4548        } else {
4549                for (i = 0; i < 20; i++)
4550                        cpu_relax(); /* This a nop instr on i386 */
4551        }
4552}
4553
4554static int
4555qla83xx_force_lock_recovery(scsi_qla_host_t *base_vha)
4556{
4557        int rval;
4558        uint32_t data;
4559        uint32_t idc_lck_rcvry_stage_mask = 0x3;
4560        uint32_t idc_lck_rcvry_owner_mask = 0x3c;
4561        struct qla_hw_data *ha = base_vha->hw;
4562        ql_dbg(ql_dbg_p3p, base_vha, 0xb086,
4563            "Trying force recovery of the IDC lock.\n");
4564
4565        rval = qla83xx_rd_reg(base_vha, QLA83XX_IDC_LOCK_RECOVERY, &data);
4566        if (rval)
4567                return rval;
4568
4569        if ((data & idc_lck_rcvry_stage_mask) > 0) {
4570                return QLA_SUCCESS;
4571        } else {
4572                data = (IDC_LOCK_RECOVERY_STAGE1) | (ha->portnum << 2);
4573                rval = qla83xx_wr_reg(base_vha, QLA83XX_IDC_LOCK_RECOVERY,
4574                    data);
4575                if (rval)
4576                        return rval;
4577
4578                msleep(200);
4579
4580                rval = qla83xx_rd_reg(base_vha, QLA83XX_IDC_LOCK_RECOVERY,
4581                    &data);
4582                if (rval)
4583                        return rval;
4584
4585                if (((data & idc_lck_rcvry_owner_mask) >> 2) == ha->portnum) {
4586                        data &= (IDC_LOCK_RECOVERY_STAGE2 |
4587                                        ~(idc_lck_rcvry_stage_mask));
4588                        rval = qla83xx_wr_reg(base_vha,
4589                            QLA83XX_IDC_LOCK_RECOVERY, data);
4590                        if (rval)
4591                                return rval;
4592
4593                        /* Forcefully perform IDC UnLock */
4594                        rval = qla83xx_rd_reg(base_vha, QLA83XX_DRIVER_UNLOCK,
4595                            &data);
4596                        if (rval)
4597                                return rval;
4598                        /* Clear lock-id by setting 0xff */
4599                        rval = qla83xx_wr_reg(base_vha, QLA83XX_DRIVER_LOCKID,
4600                            0xff);
4601                        if (rval)
4602                                return rval;
4603                        /* Clear lock-recovery by setting 0x0 */
4604                        rval = qla83xx_wr_reg(base_vha,
4605                            QLA83XX_IDC_LOCK_RECOVERY, 0x0);
4606                        if (rval)
4607                                return rval;
4608                } else
4609                        return QLA_SUCCESS;
4610        }
4611
4612        return rval;
4613}
4614
4615static int
4616qla83xx_idc_lock_recovery(scsi_qla_host_t *base_vha)
4617{
4618        int rval = QLA_SUCCESS;
4619        uint32_t o_drv_lockid, n_drv_lockid;
4620        unsigned long lock_recovery_timeout;
4621
4622        lock_recovery_timeout = jiffies + QLA83XX_MAX_LOCK_RECOVERY_WAIT;
4623retry_lockid:
4624        rval = qla83xx_rd_reg(base_vha, QLA83XX_DRIVER_LOCKID, &o_drv_lockid);
4625        if (rval)
4626                goto exit;
4627
4628        /* MAX wait time before forcing IDC Lock recovery = 2 secs */
4629        if (time_after_eq(jiffies, lock_recovery_timeout)) {
4630                if (qla83xx_force_lock_recovery(base_vha) == QLA_SUCCESS)
4631                        return QLA_SUCCESS;
4632                else
4633                        return QLA_FUNCTION_FAILED;
4634        }
4635
4636        rval = qla83xx_rd_reg(base_vha, QLA83XX_DRIVER_LOCKID, &n_drv_lockid);
4637        if (rval)
4638                goto exit;
4639
4640        if (o_drv_lockid == n_drv_lockid) {
4641                qla83xx_wait_logic();
4642                goto retry_lockid;
4643        } else
4644                return QLA_SUCCESS;
4645
4646exit:
4647        return rval;
4648}
4649
4650void
4651qla83xx_idc_lock(scsi_qla_host_t *base_vha, uint16_t requester_id)
4652{
4653        uint16_t options = (requester_id << 15) | BIT_6;
4654        uint32_t data;
4655        uint32_t lock_owner;
4656        struct qla_hw_data *ha = base_vha->hw;
4657
4658        /* IDC-lock implementation using driver-lock/lock-id remote registers */
4659retry_lock:
4660        if (qla83xx_rd_reg(base_vha, QLA83XX_DRIVER_LOCK, &data)
4661            == QLA_SUCCESS) {
4662                if (data) {
4663                        /* Setting lock-id to our function-number */
4664                        qla83xx_wr_reg(base_vha, QLA83XX_DRIVER_LOCKID,
4665                            ha->portnum);
4666                } else {
4667                        qla83xx_rd_reg(base_vha, QLA83XX_DRIVER_LOCKID,
4668                            &lock_owner);
4669                        ql_dbg(ql_dbg_p3p, base_vha, 0xb063,
4670                            "Failed to acquire IDC lock, acquired by %d, "
4671                            "retrying...\n", lock_owner);
4672
4673                        /* Retry/Perform IDC-Lock recovery */
4674                        if (qla83xx_idc_lock_recovery(base_vha)
4675                            == QLA_SUCCESS) {
4676                                qla83xx_wait_logic();
4677                                goto retry_lock;
4678                        } else
4679                                ql_log(ql_log_warn, base_vha, 0xb075,
4680                                    "IDC Lock recovery FAILED.\n");
4681                }
4682
4683        }
4684
4685        return;
4686
4687        /* XXX: IDC-lock implementation using access-control mbx */
4688retry_lock2:
4689        if (qla83xx_access_control(base_vha, options, 0, 0, NULL)) {
4690                ql_dbg(ql_dbg_p3p, base_vha, 0xb072,
4691                    "Failed to acquire IDC lock. retrying...\n");
4692                /* Retry/Perform IDC-Lock recovery */
4693                if (qla83xx_idc_lock_recovery(base_vha) == QLA_SUCCESS) {
4694                        qla83xx_wait_logic();
4695                        goto retry_lock2;
4696                } else
4697                        ql_log(ql_log_warn, base_vha, 0xb076,
4698                            "IDC Lock recovery FAILED.\n");
4699        }
4700
4701        return;
4702}
4703
4704void
4705qla83xx_idc_unlock(scsi_qla_host_t *base_vha, uint16_t requester_id)
4706{
4707#if 0
4708        uint16_t options = (requester_id << 15) | BIT_7;
4709#endif
4710        uint16_t retry;
4711        uint32_t data;
4712        struct qla_hw_data *ha = base_vha->hw;
4713
4714        /* IDC-unlock implementation using driver-unlock/lock-id
4715         * remote registers
4716         */
4717        retry = 0;
4718retry_unlock:
4719        if (qla83xx_rd_reg(base_vha, QLA83XX_DRIVER_LOCKID, &data)
4720            == QLA_SUCCESS) {
4721                if (data == ha->portnum) {
4722                        qla83xx_rd_reg(base_vha, QLA83XX_DRIVER_UNLOCK, &data);
4723                        /* Clearing lock-id by setting 0xff */
4724                        qla83xx_wr_reg(base_vha, QLA83XX_DRIVER_LOCKID, 0xff);
4725                } else if (retry < 10) {
4726                        /* SV: XXX: IDC unlock retrying needed here? */
4727
4728                        /* Retry for IDC-unlock */
4729                        qla83xx_wait_logic();
4730                        retry++;
4731                        ql_dbg(ql_dbg_p3p, base_vha, 0xb064,
4732                            "Failed to release IDC lock, retrying=%d\n", retry);
4733                        goto retry_unlock;
4734                }
4735        } else if (retry < 10) {
4736                /* Retry for IDC-unlock */
4737                qla83xx_wait_logic();
4738                retry++;
4739                ql_dbg(ql_dbg_p3p, base_vha, 0xb065,
4740                    "Failed to read drv-lockid, retrying=%d\n", retry);
4741                goto retry_unlock;
4742        }
4743
4744        return;
4745
4746#if 0
4747        /* XXX: IDC-unlock implementation using access-control mbx */
4748        retry = 0;
4749retry_unlock2:
4750        if (qla83xx_access_control(base_vha, options, 0, 0, NULL)) {
4751                if (retry < 10) {
4752                        /* Retry for IDC-unlock */
4753                        qla83xx_wait_logic();
4754                        retry++;
4755                        ql_dbg(ql_dbg_p3p, base_vha, 0xb066,
4756                            "Failed to release IDC lock, retrying=%d\n", retry);
4757                        goto retry_unlock2;
4758                }
4759        }
4760
4761        return;
4762#endif
4763}
4764
4765int
4766__qla83xx_set_drv_presence(scsi_qla_host_t *vha)
4767{
4768        int rval = QLA_SUCCESS;
4769        struct qla_hw_data *ha = vha->hw;
4770        uint32_t drv_presence;
4771
4772        rval = qla83xx_rd_reg(vha, QLA83XX_IDC_DRV_PRESENCE, &drv_presence);
4773        if (rval == QLA_SUCCESS) {
4774                drv_presence |= (1 << ha->portnum);
4775                rval = qla83xx_wr_reg(vha, QLA83XX_IDC_DRV_PRESENCE,
4776                    drv_presence);
4777        }
4778
4779        return rval;
4780}
4781
4782int
4783qla83xx_set_drv_presence(scsi_qla_host_t *vha)
4784{
4785        int rval = QLA_SUCCESS;
4786
4787        qla83xx_idc_lock(vha, 0);
4788        rval = __qla83xx_set_drv_presence(vha);
4789        qla83xx_idc_unlock(vha, 0);
4790
4791        return rval;
4792}
4793
4794int
4795__qla83xx_clear_drv_presence(scsi_qla_host_t *vha)
4796{
4797        int rval = QLA_SUCCESS;
4798        struct qla_hw_data *ha = vha->hw;
4799        uint32_t drv_presence;
4800
4801        rval = qla83xx_rd_reg(vha, QLA83XX_IDC_DRV_PRESENCE, &drv_presence);
4802        if (rval == QLA_SUCCESS) {
4803                drv_presence &= ~(1 << ha->portnum);
4804                rval = qla83xx_wr_reg(vha, QLA83XX_IDC_DRV_PRESENCE,
4805                    drv_presence);
4806        }
4807
4808        return rval;
4809}
4810
4811int
4812qla83xx_clear_drv_presence(scsi_qla_host_t *vha)
4813{
4814        int rval = QLA_SUCCESS;
4815
4816        qla83xx_idc_lock(vha, 0);
4817        rval = __qla83xx_clear_drv_presence(vha);
4818        qla83xx_idc_unlock(vha, 0);
4819
4820        return rval;
4821}
4822
4823static void
4824qla83xx_need_reset_handler(scsi_qla_host_t *vha)
4825{
4826        struct qla_hw_data *ha = vha->hw;
4827        uint32_t drv_ack, drv_presence;
4828        unsigned long ack_timeout;
4829
4830        /* Wait for IDC ACK from all functions (DRV-ACK == DRV-PRESENCE) */
4831        ack_timeout = jiffies + (ha->fcoe_reset_timeout * HZ);
4832        while (1) {
4833                qla83xx_rd_reg(vha, QLA83XX_IDC_DRIVER_ACK, &drv_ack);
4834                qla83xx_rd_reg(vha, QLA83XX_IDC_DRV_PRESENCE, &drv_presence);
4835                if ((drv_ack & drv_presence) == drv_presence)
4836                        break;
4837
4838                if (time_after_eq(jiffies, ack_timeout)) {
4839                        ql_log(ql_log_warn, vha, 0xb067,
4840                            "RESET ACK TIMEOUT! drv_presence=0x%x "
4841                            "drv_ack=0x%x\n", drv_presence, drv_ack);
4842                        /*
4843                         * The function(s) which did not ack in time are forced
4844                         * to withdraw any further participation in the IDC
4845                         * reset.
4846                         */
4847                        if (drv_ack != drv_presence)
4848                                qla83xx_wr_reg(vha, QLA83XX_IDC_DRV_PRESENCE,
4849                                    drv_ack);
4850                        break;
4851                }
4852
4853                qla83xx_idc_unlock(vha, 0);
4854                msleep(1000);
4855                qla83xx_idc_lock(vha, 0);
4856        }
4857
4858        qla83xx_wr_reg(vha, QLA83XX_IDC_DEV_STATE, QLA8XXX_DEV_COLD);
4859        ql_log(ql_log_info, vha, 0xb068, "HW State: COLD/RE-INIT.\n");
4860}
4861
4862static int
4863qla83xx_device_bootstrap(scsi_qla_host_t *vha)
4864{
4865        int rval = QLA_SUCCESS;
4866        uint32_t idc_control;
4867
4868        qla83xx_wr_reg(vha, QLA83XX_IDC_DEV_STATE, QLA8XXX_DEV_INITIALIZING);
4869        ql_log(ql_log_info, vha, 0xb069, "HW State: INITIALIZING.\n");
4870
4871        /* Clearing IDC-Control Graceful-Reset Bit before resetting f/w */
4872        __qla83xx_get_idc_control(vha, &idc_control);
4873        idc_control &= ~QLA83XX_IDC_GRACEFUL_RESET;
4874        __qla83xx_set_idc_control(vha, 0);
4875
4876        qla83xx_idc_unlock(vha, 0);
4877        rval = qla83xx_restart_nic_firmware(vha);
4878        qla83xx_idc_lock(vha, 0);
4879
4880        if (rval != QLA_SUCCESS) {
4881                ql_log(ql_log_fatal, vha, 0xb06a,
4882                    "Failed to restart NIC f/w.\n");
4883                qla83xx_wr_reg(vha, QLA83XX_IDC_DEV_STATE, QLA8XXX_DEV_FAILED);
4884                ql_log(ql_log_info, vha, 0xb06b, "HW State: FAILED.\n");
4885        } else {
4886                ql_dbg(ql_dbg_p3p, vha, 0xb06c,
4887                    "Success in restarting nic f/w.\n");
4888                qla83xx_wr_reg(vha, QLA83XX_IDC_DEV_STATE, QLA8XXX_DEV_READY);
4889                ql_log(ql_log_info, vha, 0xb06d, "HW State: READY.\n");
4890        }
4891
4892        return rval;
4893}
4894
4895/* Assumes idc_lock always held on entry */
4896int
4897qla83xx_idc_state_handler(scsi_qla_host_t *base_vha)
4898{
4899        struct qla_hw_data *ha = base_vha->hw;
4900        int rval = QLA_SUCCESS;
4901        unsigned long dev_init_timeout;
4902        uint32_t dev_state;
4903
4904        /* Wait for MAX-INIT-TIMEOUT for the device to go ready */
4905        dev_init_timeout = jiffies + (ha->fcoe_dev_init_timeout * HZ);
4906
4907        while (1) {
4908
4909                if (time_after_eq(jiffies, dev_init_timeout)) {
4910                        ql_log(ql_log_warn, base_vha, 0xb06e,
4911                            "Initialization TIMEOUT!\n");
4912                        /* Init timeout. Disable further NIC Core
4913                         * communication.
4914                         */
4915                        qla83xx_wr_reg(base_vha, QLA83XX_IDC_DEV_STATE,
4916                                QLA8XXX_DEV_FAILED);
4917                        ql_log(ql_log_info, base_vha, 0xb06f,
4918                            "HW State: FAILED.\n");
4919                }
4920
4921                qla83xx_rd_reg(base_vha, QLA83XX_IDC_DEV_STATE, &dev_state);
4922                switch (dev_state) {
4923                case QLA8XXX_DEV_READY:
4924                        if (ha->flags.nic_core_reset_owner)
4925                                qla83xx_idc_audit(base_vha,
4926                                    IDC_AUDIT_COMPLETION);
4927                        ha->flags.nic_core_reset_owner = 0;
4928                        ql_dbg(ql_dbg_p3p, base_vha, 0xb070,
4929                            "Reset_owner reset by 0x%x.\n",
4930                            ha->portnum);
4931                        goto exit;
4932                case QLA8XXX_DEV_COLD:
4933                        if (ha->flags.nic_core_reset_owner)
4934                                rval = qla83xx_device_bootstrap(base_vha);
4935                        else {
4936                        /* Wait for AEN to change device-state */
4937                                qla83xx_idc_unlock(base_vha, 0);
4938                                msleep(1000);
4939                                qla83xx_idc_lock(base_vha, 0);
4940                        }
4941                        break;
4942                case QLA8XXX_DEV_INITIALIZING:
4943                        /* Wait for AEN to change device-state */
4944                        qla83xx_idc_unlock(base_vha, 0);
4945                        msleep(1000);
4946                        qla83xx_idc_lock(base_vha, 0);
4947                        break;
4948                case QLA8XXX_DEV_NEED_RESET:
4949                        if (!ql2xdontresethba && ha->flags.nic_core_reset_owner)
4950                                qla83xx_need_reset_handler(base_vha);
4951                        else {
4952                                /* Wait for AEN to change device-state */
4953                                qla83xx_idc_unlock(base_vha, 0);
4954                                msleep(1000);
4955                                qla83xx_idc_lock(base_vha, 0);
4956                        }
4957                        /* reset timeout value after need reset handler */
4958                        dev_init_timeout = jiffies +
4959                            (ha->fcoe_dev_init_timeout * HZ);
4960                        break;
4961                case QLA8XXX_DEV_NEED_QUIESCENT:
4962                        /* XXX: DEBUG for now */
4963                        qla83xx_idc_unlock(base_vha, 0);
4964                        msleep(1000);
4965                        qla83xx_idc_lock(base_vha, 0);
4966                        break;
4967                case QLA8XXX_DEV_QUIESCENT:
4968                        /* XXX: DEBUG for now */
4969                        if (ha->flags.quiesce_owner)
4970                                goto exit;
4971
4972                        qla83xx_idc_unlock(base_vha, 0);
4973                        msleep(1000);
4974                        qla83xx_idc_lock(base_vha, 0);
4975                        dev_init_timeout = jiffies +
4976                            (ha->fcoe_dev_init_timeout * HZ);
4977                        break;
4978                case QLA8XXX_DEV_FAILED:
4979                        if (ha->flags.nic_core_reset_owner)
4980                                qla83xx_idc_audit(base_vha,
4981                                    IDC_AUDIT_COMPLETION);
4982                        ha->flags.nic_core_reset_owner = 0;
4983                        __qla83xx_clear_drv_presence(base_vha);
4984                        qla83xx_idc_unlock(base_vha, 0);
4985                        qla8xxx_dev_failed_handler(base_vha);
4986                        rval = QLA_FUNCTION_FAILED;
4987                        qla83xx_idc_lock(base_vha, 0);
4988                        goto exit;
4989                case QLA8XXX_BAD_VALUE:
4990                        qla83xx_idc_unlock(base_vha, 0);
4991                        msleep(1000);
4992                        qla83xx_idc_lock(base_vha, 0);
4993                        break;
4994                default:
4995                        ql_log(ql_log_warn, base_vha, 0xb071,
4996                            "Unknown Device State: %x.\n", dev_state);
4997                        qla83xx_idc_unlock(base_vha, 0);
4998                        qla8xxx_dev_failed_handler(base_vha);
4999                        rval = QLA_FUNCTION_FAILED;
5000                        qla83xx_idc_lock(base_vha, 0);
5001                        goto exit;
5002                }
5003        }
5004
5005exit:
5006        return rval;
5007}
5008
5009void
5010qla2x00_disable_board_on_pci_error(struct work_struct *work)
5011{
5012        struct qla_hw_data *ha = container_of(work, struct qla_hw_data,
5013            board_disable);
5014        struct pci_dev *pdev = ha->pdev;
5015        scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
5016
5017        /* if UNLOAD flag is already set, then continue unload,
5018         * where it was set first.
5019         */
5020        if (test_bit(UNLOADING, &base_vha->dpc_flags))
5021                return;
5022
5023        ql_log(ql_log_warn, base_vha, 0x015b,
5024            "Disabling adapter.\n");
5025
5026        set_bit(UNLOADING, &base_vha->dpc_flags);
5027
5028        qla2x00_delete_all_vps(ha, base_vha);
5029
5030        qla2x00_abort_all_cmds(base_vha, DID_NO_CONNECT << 16);
5031
5032        qla2x00_dfs_remove(base_vha);
5033
5034        qla84xx_put_chip(base_vha);
5035
5036        if (base_vha->timer_active)
5037                qla2x00_stop_timer(base_vha);
5038
5039        base_vha->flags.online = 0;
5040
5041        qla2x00_destroy_deferred_work(ha);
5042
5043        /*
5044         * Do not try to stop beacon blink as it will issue a mailbox
5045         * command.
5046         */
5047        qla2x00_free_sysfs_attr(base_vha, false);
5048
5049        fc_remove_host(base_vha->host);
5050
5051        scsi_remove_host(base_vha->host);
5052
5053        base_vha->flags.init_done = 0;
5054        qla25xx_delete_queues(base_vha);
5055        qla2x00_free_irqs(base_vha);
5056        qla2x00_free_fcports(base_vha);
5057        qla2x00_mem_free(ha);
5058        qla82xx_md_free(base_vha);
5059        qla2x00_free_queues(ha);
5060
5061        qla2x00_unmap_iobases(ha);
5062
5063        pci_release_selected_regions(ha->pdev, ha->bars);
5064        pci_disable_pcie_error_reporting(pdev);
5065        pci_disable_device(pdev);
5066
5067        /*
5068         * Let qla2x00_remove_one cleanup qla_hw_data on device removal.
5069         */
5070}
5071
5072/**************************************************************************
5073* qla2x00_do_dpc
5074*   This kernel thread is a task that is schedule by the interrupt handler
5075*   to perform the background processing for interrupts.
5076*
5077* Notes:
5078* This task always run in the context of a kernel thread.  It
5079* is kick-off by the driver's detect code and starts up
5080* up one per adapter. It immediately goes to sleep and waits for
5081* some fibre event.  When either the interrupt handler or
5082* the timer routine detects a event it will one of the task
5083* bits then wake us up.
5084**************************************************************************/
5085static int
5086qla2x00_do_dpc(void *data)
5087{
5088        scsi_qla_host_t *base_vha;
5089        struct qla_hw_data *ha;
5090
5091        ha = (struct qla_hw_data *)data;
5092        base_vha = pci_get_drvdata(ha->pdev);
5093
5094        set_user_nice(current, MIN_NICE);
5095
5096        set_current_state(TASK_INTERRUPTIBLE);
5097        while (!kthread_should_stop()) {
5098                ql_dbg(ql_dbg_dpc, base_vha, 0x4000,
5099                    "DPC handler sleeping.\n");
5100
5101                schedule();
5102
5103                if (!base_vha->flags.init_done || ha->flags.mbox_busy)
5104                        goto end_loop;
5105
5106                if (ha->flags.eeh_busy) {
5107                        ql_dbg(ql_dbg_dpc, base_vha, 0x4003,
5108                            "eeh_busy=%d.\n", ha->flags.eeh_busy);
5109                        goto end_loop;
5110                }
5111
5112                ha->dpc_active = 1;
5113
5114                ql_dbg(ql_dbg_dpc + ql_dbg_verbose, base_vha, 0x4001,
5115                    "DPC handler waking up, dpc_flags=0x%lx.\n",
5116                    base_vha->dpc_flags);
5117
5118                if (test_bit(UNLOADING, &base_vha->dpc_flags))
5119                        break;
5120
5121                qla2x00_do_work(base_vha);
5122
5123                if (IS_P3P_TYPE(ha)) {
5124                        if (IS_QLA8044(ha)) {
5125                                if (test_and_clear_bit(ISP_UNRECOVERABLE,
5126                                        &base_vha->dpc_flags)) {
5127                                        qla8044_idc_lock(ha);
5128                                        qla8044_wr_direct(base_vha,
5129                                                QLA8044_CRB_DEV_STATE_INDEX,
5130                                                QLA8XXX_DEV_FAILED);
5131                                        qla8044_idc_unlock(ha);
5132                                        ql_log(ql_log_info, base_vha, 0x4004,
5133                                                "HW State: FAILED.\n");
5134                                        qla8044_device_state_handler(base_vha);
5135                                        continue;
5136                                }
5137
5138                        } else {
5139                                if (test_and_clear_bit(ISP_UNRECOVERABLE,
5140                                        &base_vha->dpc_flags)) {
5141                                        qla82xx_idc_lock(ha);
5142                                        qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
5143                                                QLA8XXX_DEV_FAILED);
5144                                        qla82xx_idc_unlock(ha);
5145                                        ql_log(ql_log_info, base_vha, 0x0151,
5146                                                "HW State: FAILED.\n");
5147                                        qla82xx_device_state_handler(base_vha);
5148                                        continue;
5149                                }
5150                        }
5151
5152                        if (test_and_clear_bit(FCOE_CTX_RESET_NEEDED,
5153                                &base_vha->dpc_flags)) {
5154
5155                                ql_dbg(ql_dbg_dpc, base_vha, 0x4005,
5156                                    "FCoE context reset scheduled.\n");
5157                                if (!(test_and_set_bit(ABORT_ISP_ACTIVE,
5158                                        &base_vha->dpc_flags))) {
5159                                        if (qla82xx_fcoe_ctx_reset(base_vha)) {
5160                                                /* FCoE-ctx reset failed.
5161                                                 * Escalate to chip-reset
5162                                                 */
5163                                                set_bit(ISP_ABORT_NEEDED,
5164                                                        &base_vha->dpc_flags);
5165                                        }
5166                                        clear_bit(ABORT_ISP_ACTIVE,
5167                                                &base_vha->dpc_flags);
5168                                }
5169
5170                                ql_dbg(ql_dbg_dpc, base_vha, 0x4006,
5171                                    "FCoE context reset end.\n");
5172                        }
5173                } else if (IS_QLAFX00(ha)) {
5174                        if (test_and_clear_bit(ISP_UNRECOVERABLE,
5175                                &base_vha->dpc_flags)) {
5176                                ql_dbg(ql_dbg_dpc, base_vha, 0x4020,
5177                                    "Firmware Reset Recovery\n");
5178                                if (qlafx00_reset_initialize(base_vha)) {
5179                                        /* Failed. Abort isp later. */
5180                                        if (!test_bit(UNLOADING,
5181                                            &base_vha->dpc_flags)) {
5182                                                set_bit(ISP_UNRECOVERABLE,
5183                                                    &base_vha->dpc_flags);
5184                                                ql_dbg(ql_dbg_dpc, base_vha,
5185                                                    0x4021,
5186                                                    "Reset Recovery Failed\n");
5187                                        }
5188                                }
5189                        }
5190
5191                        if (test_and_clear_bit(FX00_TARGET_SCAN,
5192                                &base_vha->dpc_flags)) {
5193                                ql_dbg(ql_dbg_dpc, base_vha, 0x4022,
5194                                    "ISPFx00 Target Scan scheduled\n");
5195                                if (qlafx00_rescan_isp(base_vha)) {
5196                                        if (!test_bit(UNLOADING,
5197                                            &base_vha->dpc_flags))
5198                                                set_bit(ISP_UNRECOVERABLE,
5199                                                    &base_vha->dpc_flags);
5200                                        ql_dbg(ql_dbg_dpc, base_vha, 0x401e,
5201                                            "ISPFx00 Target Scan Failed\n");
5202                                }
5203                                ql_dbg(ql_dbg_dpc, base_vha, 0x401f,
5204                                    "ISPFx00 Target Scan End\n");
5205                        }
5206                        if (test_and_clear_bit(FX00_HOST_INFO_RESEND,
5207                                &base_vha->dpc_flags)) {
5208                                ql_dbg(ql_dbg_dpc, base_vha, 0x4023,
5209                                    "ISPFx00 Host Info resend scheduled\n");
5210                                qlafx00_fx_disc(base_vha,
5211                                    &base_vha->hw->mr.fcport,
5212                                    FXDISC_REG_HOST_INFO);
5213                        }
5214                }
5215
5216                if (test_and_clear_bit(ISP_ABORT_NEEDED,
5217                                                &base_vha->dpc_flags)) {
5218
5219                        ql_dbg(ql_dbg_dpc, base_vha, 0x4007,
5220                            "ISP abort scheduled.\n");
5221                        if (!(test_and_set_bit(ABORT_ISP_ACTIVE,
5222                            &base_vha->dpc_flags))) {
5223
5224                                if (ha->isp_ops->abort_isp(base_vha)) {
5225                                        /* failed. retry later */
5226                                        set_bit(ISP_ABORT_NEEDED,
5227                                            &base_vha->dpc_flags);
5228                                }
5229                                clear_bit(ABORT_ISP_ACTIVE,
5230                                                &base_vha->dpc_flags);
5231                        }
5232
5233                        ql_dbg(ql_dbg_dpc, base_vha, 0x4008,
5234                            "ISP abort end.\n");
5235                }
5236
5237                if (test_and_clear_bit(FCPORT_UPDATE_NEEDED,
5238                    &base_vha->dpc_flags)) {
5239                        qla2x00_update_fcports(base_vha);
5240                }
5241
5242                if (test_bit(SCR_PENDING, &base_vha->dpc_flags)) {
5243                        int ret;
5244                        ret = qla2x00_send_change_request(base_vha, 0x3, 0);
5245                        if (ret != QLA_SUCCESS)
5246                                ql_log(ql_log_warn, base_vha, 0x121,
5247                                    "Failed to enable receiving of RSCN "
5248                                    "requests: 0x%x.\n", ret);
5249                        clear_bit(SCR_PENDING, &base_vha->dpc_flags);
5250                }
5251
5252                if (IS_QLAFX00(ha))
5253                        goto loop_resync_check;
5254
5255                if (test_bit(ISP_QUIESCE_NEEDED, &base_vha->dpc_flags)) {
5256                        ql_dbg(ql_dbg_dpc, base_vha, 0x4009,
5257                            "Quiescence mode scheduled.\n");
5258                        if (IS_P3P_TYPE(ha)) {
5259                                if (IS_QLA82XX(ha))
5260                                        qla82xx_device_state_handler(base_vha);
5261                                if (IS_QLA8044(ha))
5262                                        qla8044_device_state_handler(base_vha);
5263                                clear_bit(ISP_QUIESCE_NEEDED,
5264                                    &base_vha->dpc_flags);
5265                                if (!ha->flags.quiesce_owner) {
5266                                        qla2x00_perform_loop_resync(base_vha);
5267                                        if (IS_QLA82XX(ha)) {
5268                                                qla82xx_idc_lock(ha);
5269                                                qla82xx_clear_qsnt_ready(
5270                                                    base_vha);
5271                                                qla82xx_idc_unlock(ha);
5272                                        } else if (IS_QLA8044(ha)) {
5273                                                qla8044_idc_lock(ha);
5274                                                qla8044_clear_qsnt_ready(
5275                                                    base_vha);
5276                                                qla8044_idc_unlock(ha);
5277                                        }
5278                                }
5279                        } else {
5280                                clear_bit(ISP_QUIESCE_NEEDED,
5281                                    &base_vha->dpc_flags);
5282                                qla2x00_quiesce_io(base_vha);
5283                        }
5284                        ql_dbg(ql_dbg_dpc, base_vha, 0x400a,
5285                            "Quiescence mode end.\n");
5286                }
5287
5288                if (test_and_clear_bit(RESET_MARKER_NEEDED,
5289                                &base_vha->dpc_flags) &&
5290                    (!(test_and_set_bit(RESET_ACTIVE, &base_vha->dpc_flags)))) {
5291
5292                        ql_dbg(ql_dbg_dpc, base_vha, 0x400b,
5293                            "Reset marker scheduled.\n");
5294                        qla2x00_rst_aen(base_vha);
5295                        clear_bit(RESET_ACTIVE, &base_vha->dpc_flags);
5296                        ql_dbg(ql_dbg_dpc, base_vha, 0x400c,
5297                            "Reset marker end.\n");
5298                }
5299
5300                /* Retry each device up to login retry count */
5301                if ((test_and_clear_bit(RELOGIN_NEEDED,
5302                                                &base_vha->dpc_flags)) &&
5303                    !test_bit(LOOP_RESYNC_NEEDED, &base_vha->dpc_flags) &&
5304                    atomic_read(&base_vha->loop_state) != LOOP_DOWN) {
5305
5306                        ql_dbg(ql_dbg_dpc, base_vha, 0x400d,
5307                            "Relogin scheduled.\n");
5308                        qla2x00_relogin(base_vha);
5309                        ql_dbg(ql_dbg_dpc, base_vha, 0x400e,
5310                            "Relogin end.\n");
5311                }
5312loop_resync_check:
5313                if (test_and_clear_bit(LOOP_RESYNC_NEEDED,
5314                    &base_vha->dpc_flags)) {
5315
5316                        ql_dbg(ql_dbg_dpc, base_vha, 0x400f,
5317                            "Loop resync scheduled.\n");
5318
5319                        if (!(test_and_set_bit(LOOP_RESYNC_ACTIVE,
5320                            &base_vha->dpc_flags))) {
5321
5322                                qla2x00_loop_resync(base_vha);
5323
5324                                clear_bit(LOOP_RESYNC_ACTIVE,
5325                                                &base_vha->dpc_flags);
5326                        }
5327
5328                        ql_dbg(ql_dbg_dpc, base_vha, 0x4010,
5329                            "Loop resync end.\n");
5330                }
5331
5332                if (IS_QLAFX00(ha))
5333                        goto intr_on_check;
5334
5335                if (test_bit(NPIV_CONFIG_NEEDED, &base_vha->dpc_flags) &&
5336                    atomic_read(&base_vha->loop_state) == LOOP_READY) {
5337                        clear_bit(NPIV_CONFIG_NEEDED, &base_vha->dpc_flags);
5338                        qla2xxx_flash_npiv_conf(base_vha);
5339                }
5340
5341intr_on_check:
5342                if (!ha->interrupts_on)
5343                        ha->isp_ops->enable_intrs(ha);
5344
5345                if (test_and_clear_bit(BEACON_BLINK_NEEDED,
5346                                        &base_vha->dpc_flags)) {
5347                        if (ha->beacon_blink_led == 1)
5348                                ha->isp_ops->beacon_blink(base_vha);
5349                }
5350
5351                if (!IS_QLAFX00(ha))
5352                        qla2x00_do_dpc_all_vps(base_vha);
5353
5354                ha->dpc_active = 0;
5355end_loop:
5356                set_current_state(TASK_INTERRUPTIBLE);
5357        } /* End of while(1) */
5358        __set_current_state(TASK_RUNNING);
5359
5360        ql_dbg(ql_dbg_dpc, base_vha, 0x4011,
5361            "DPC handler exiting.\n");
5362
5363        /*
5364         * Make sure that nobody tries to wake us up again.
5365         */
5366        ha->dpc_active = 0;
5367
5368        /* Cleanup any residual CTX SRBs. */
5369        qla2x00_abort_all_cmds(base_vha, DID_NO_CONNECT << 16);
5370
5371        return 0;
5372}
5373
5374void
5375qla2xxx_wake_dpc(struct scsi_qla_host *vha)
5376{
5377        struct qla_hw_data *ha = vha->hw;
5378        struct task_struct *t = ha->dpc_thread;
5379
5380        if (!test_bit(UNLOADING, &vha->dpc_flags) && t)
5381                wake_up_process(t);
5382}
5383
5384/*
5385*  qla2x00_rst_aen
5386*      Processes asynchronous reset.
5387*
5388* Input:
5389*      ha  = adapter block pointer.
5390*/
5391static void
5392qla2x00_rst_aen(scsi_qla_host_t *vha)
5393{
5394        if (vha->flags.online && !vha->flags.reset_active &&
5395            !atomic_read(&vha->loop_down_timer) &&
5396            !(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))) {
5397                do {
5398                        clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
5399
5400                        /*
5401                         * Issue marker command only when we are going to start
5402                         * the I/O.
5403                         */
5404                        vha->marker_needed = 1;
5405                } while (!atomic_read(&vha->loop_down_timer) &&
5406                    (test_bit(RESET_MARKER_NEEDED, &vha->dpc_flags)));
5407        }
5408}
5409
5410/**************************************************************************
5411*   qla2x00_timer
5412*
5413* Description:
5414*   One second timer
5415*
5416* Context: Interrupt
5417***************************************************************************/
5418void
5419qla2x00_timer(scsi_qla_host_t *vha)
5420{
5421        unsigned long   cpu_flags = 0;
5422        int             start_dpc = 0;
5423        int             index;
5424        srb_t           *sp;
5425        uint16_t        w;
5426        struct qla_hw_data *ha = vha->hw;
5427        struct req_que *req;
5428
5429        if (ha->flags.eeh_busy) {
5430                ql_dbg(ql_dbg_timer, vha, 0x6000,
5431                    "EEH = %d, restarting timer.\n",
5432                    ha->flags.eeh_busy);
5433                qla2x00_restart_timer(vha, WATCH_INTERVAL);
5434                return;
5435        }
5436
5437        /*
5438         * Hardware read to raise pending EEH errors during mailbox waits. If
5439         * the read returns -1 then disable the board.
5440         */
5441        if (!pci_channel_offline(ha->pdev)) {
5442                pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w);
5443                qla2x00_check_reg16_for_disconnect(vha, w);
5444        }
5445
5446        /* Make sure qla82xx_watchdog is run only for physical port */
5447        if (!vha->vp_idx && IS_P3P_TYPE(ha)) {
5448                if (test_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags))
5449                        start_dpc++;
5450                if (IS_QLA82XX(ha))
5451                        qla82xx_watchdog(vha);
5452                else if (IS_QLA8044(ha))
5453                        qla8044_watchdog(vha);
5454        }
5455
5456        if (!vha->vp_idx && IS_QLAFX00(ha))
5457                qlafx00_timer_routine(vha);
5458
5459        /* Loop down handler. */
5460        if (atomic_read(&vha->loop_down_timer) > 0 &&
5461            !(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) &&
5462            !(test_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags))
5463                && vha->flags.online) {
5464
5465                if (atomic_read(&vha->loop_down_timer) ==
5466                    vha->loop_down_abort_time) {
5467
5468                        ql_log(ql_log_info, vha, 0x6008,
5469                            "Loop down - aborting the queues before time expires.\n");
5470
5471                        if (!IS_QLA2100(ha) && vha->link_down_timeout)
5472                                atomic_set(&vha->loop_state, LOOP_DEAD);
5473
5474                        /*
5475                         * Schedule an ISP abort to return any FCP2-device
5476                         * commands.
5477                         */
5478                        /* NPIV - scan physical port only */
5479                        if (!vha->vp_idx) {
5480                                spin_lock_irqsave(&ha->hardware_lock,
5481                                    cpu_flags);
5482                                req = ha->req_q_map[0];
5483                                for (index = 1;
5484                                    index < req->num_outstanding_cmds;
5485                                    index++) {
5486                                        fc_port_t *sfcp;
5487
5488                                        sp = req->outstanding_cmds[index];
5489                                        if (!sp)
5490                                                continue;
5491                                        if (sp->type != SRB_SCSI_CMD)
5492                                                continue;
5493                                        sfcp = sp->fcport;
5494                                        if (!(sfcp->flags & FCF_FCP2_DEVICE))
5495                                                continue;
5496
5497                                        if (IS_QLA82XX(ha))
5498                                                set_bit(FCOE_CTX_RESET_NEEDED,
5499                                                        &vha->dpc_flags);
5500                                        else
5501                                                set_bit(ISP_ABORT_NEEDED,
5502                                                        &vha->dpc_flags);
5503                                        break;
5504                                }
5505                                spin_unlock_irqrestore(&ha->hardware_lock,
5506                                                                cpu_flags);
5507                        }
5508                        start_dpc++;
5509                }
5510
5511                /* if the loop has been down for 4 minutes, reinit adapter */
5512                if (atomic_dec_and_test(&vha->loop_down_timer) != 0) {
5513                        if (!(vha->device_flags & DFLG_NO_CABLE)) {
5514                                ql_log(ql_log_warn, vha, 0x6009,
5515                                    "Loop down - aborting ISP.\n");
5516
5517                                if (IS_QLA82XX(ha))
5518                                        set_bit(FCOE_CTX_RESET_NEEDED,
5519                                                &vha->dpc_flags);
5520                                else
5521                                        set_bit(ISP_ABORT_NEEDED,
5522                                                &vha->dpc_flags);
5523                        }
5524                }
5525                ql_dbg(ql_dbg_timer, vha, 0x600a,
5526                    "Loop down - seconds remaining %d.\n",
5527                    atomic_read(&vha->loop_down_timer));
5528        }
5529        /* Check if beacon LED needs to be blinked for physical host only */
5530        if (!vha->vp_idx && (ha->beacon_blink_led == 1)) {
5531                /* There is no beacon_blink function for ISP82xx */
5532                if (!IS_P3P_TYPE(ha)) {
5533                        set_bit(BEACON_BLINK_NEEDED, &vha->dpc_flags);
5534                        start_dpc++;
5535                }
5536        }
5537
5538        /* Process any deferred work. */
5539        if (!list_empty(&vha->work_list))
5540                start_dpc++;
5541
5542        /* Schedule the DPC routine if needed */
5543        if ((test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) ||
5544            test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags) ||
5545            test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags) ||
5546            start_dpc ||
5547            test_bit(RESET_MARKER_NEEDED, &vha->dpc_flags) ||
5548            test_bit(BEACON_BLINK_NEEDED, &vha->dpc_flags) ||
5549            test_bit(ISP_UNRECOVERABLE, &vha->dpc_flags) ||
5550            test_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags) ||
5551            test_bit(VP_DPC_NEEDED, &vha->dpc_flags) ||
5552            test_bit(RELOGIN_NEEDED, &vha->dpc_flags))) {
5553                ql_dbg(ql_dbg_timer, vha, 0x600b,
5554                    "isp_abort_needed=%d loop_resync_needed=%d "
5555                    "fcport_update_needed=%d start_dpc=%d "
5556                    "reset_marker_needed=%d",
5557                    test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags),
5558                    test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags),
5559                    test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags),
5560                    start_dpc,
5561                    test_bit(RESET_MARKER_NEEDED, &vha->dpc_flags));
5562                ql_dbg(ql_dbg_timer, vha, 0x600c,
5563                    "beacon_blink_needed=%d isp_unrecoverable=%d "
5564                    "fcoe_ctx_reset_needed=%d vp_dpc_needed=%d "
5565                    "relogin_needed=%d.\n",
5566                    test_bit(BEACON_BLINK_NEEDED, &vha->dpc_flags),
5567                    test_bit(ISP_UNRECOVERABLE, &vha->dpc_flags),
5568                    test_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags),
5569                    test_bit(VP_DPC_NEEDED, &vha->dpc_flags),
5570                    test_bit(RELOGIN_NEEDED, &vha->dpc_flags));
5571                qla2xxx_wake_dpc(vha);
5572        }
5573
5574        qla2x00_restart_timer(vha, WATCH_INTERVAL);
5575}
5576
5577/* Firmware interface routines. */
5578
5579#define FW_BLOBS        11
5580#define FW_ISP21XX      0
5581#define FW_ISP22XX      1
5582#define FW_ISP2300      2
5583#define FW_ISP2322      3
5584#define FW_ISP24XX      4
5585#define FW_ISP25XX      5
5586#define FW_ISP81XX      6
5587#define FW_ISP82XX      7
5588#define FW_ISP2031      8
5589#define FW_ISP8031      9
5590#define FW_ISP27XX      10
5591
5592#define FW_FILE_ISP21XX "ql2100_fw.bin"
5593#define FW_FILE_ISP22XX "ql2200_fw.bin"
5594#define FW_FILE_ISP2300 "ql2300_fw.bin"
5595#define FW_FILE_ISP2322 "ql2322_fw.bin"
5596#define FW_FILE_ISP24XX "ql2400_fw.bin"
5597#define FW_FILE_ISP25XX "ql2500_fw.bin"
5598#define FW_FILE_ISP81XX "ql8100_fw.bin"
5599#define FW_FILE_ISP82XX "ql8200_fw.bin"
5600#define FW_FILE_ISP2031 "ql2600_fw.bin"
5601#define FW_FILE_ISP8031 "ql8300_fw.bin"
5602#define FW_FILE_ISP27XX "ql2700_fw.bin"
5603
5604
5605static DEFINE_MUTEX(qla_fw_lock);
5606
5607static struct fw_blob qla_fw_blobs[FW_BLOBS] = {
5608        { .name = FW_FILE_ISP21XX, .segs = { 0x1000, 0 }, },
5609        { .name = FW_FILE_ISP22XX, .segs = { 0x1000, 0 }, },
5610        { .name = FW_FILE_ISP2300, .segs = { 0x800, 0 }, },
5611        { .name = FW_FILE_ISP2322, .segs = { 0x800, 0x1c000, 0x1e000, 0 }, },
5612        { .name = FW_FILE_ISP24XX, },
5613        { .name = FW_FILE_ISP25XX, },
5614        { .name = FW_FILE_ISP81XX, },
5615        { .name = FW_FILE_ISP82XX, },
5616        { .name = FW_FILE_ISP2031, },
5617        { .name = FW_FILE_ISP8031, },
5618        { .name = FW_FILE_ISP27XX, },
5619};
5620
5621struct fw_blob *
5622qla2x00_request_firmware(scsi_qla_host_t *vha)
5623{
5624        struct qla_hw_data *ha = vha->hw;
5625        struct fw_blob *blob;
5626
5627        if (IS_QLA2100(ha)) {
5628                blob = &qla_fw_blobs[FW_ISP21XX];
5629        } else if (IS_QLA2200(ha)) {
5630                blob = &qla_fw_blobs[FW_ISP22XX];
5631        } else if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
5632                blob = &qla_fw_blobs[FW_ISP2300];
5633        } else if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
5634                blob = &qla_fw_blobs[FW_ISP2322];
5635        } else if (IS_QLA24XX_TYPE(ha)) {
5636                blob = &qla_fw_blobs[FW_ISP24XX];
5637        } else if (IS_QLA25XX(ha)) {
5638                blob = &qla_fw_blobs[FW_ISP25XX];
5639        } else if (IS_QLA81XX(ha)) {
5640                blob = &qla_fw_blobs[FW_ISP81XX];
5641        } else if (IS_QLA82XX(ha)) {
5642                blob = &qla_fw_blobs[FW_ISP82XX];
5643        } else if (IS_QLA2031(ha)) {
5644                blob = &qla_fw_blobs[FW_ISP2031];
5645        } else if (IS_QLA8031(ha)) {
5646                blob = &qla_fw_blobs[FW_ISP8031];
5647        } else if (IS_QLA27XX(ha)) {
5648                blob = &qla_fw_blobs[FW_ISP27XX];
5649        } else {
5650                return NULL;
5651        }
5652
5653        mutex_lock(&qla_fw_lock);
5654        if (blob->fw)
5655                goto out;
5656
5657        if (request_firmware(&blob->fw, blob->name, &ha->pdev->dev)) {
5658                ql_log(ql_log_warn, vha, 0x0063,
5659                    "Failed to load firmware image (%s).\n", blob->name);
5660                blob->fw = NULL;
5661                blob = NULL;
5662                goto out;
5663        }
5664
5665out:
5666        mutex_unlock(&qla_fw_lock);
5667        return blob;
5668}
5669
5670static void
5671qla2x00_release_firmware(void)
5672{
5673        int idx;
5674
5675        mutex_lock(&qla_fw_lock);
5676        for (idx = 0; idx < FW_BLOBS; idx++)
5677                release_firmware(qla_fw_blobs[idx].fw);
5678        mutex_unlock(&qla_fw_lock);
5679}
5680
5681static pci_ers_result_t
5682qla2xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
5683{
5684        scsi_qla_host_t *vha = pci_get_drvdata(pdev);
5685        struct qla_hw_data *ha = vha->hw;
5686
5687        ql_dbg(ql_dbg_aer, vha, 0x9000,
5688            "PCI error detected, state %x.\n", state);
5689
5690        switch (state) {
5691        case pci_channel_io_normal:
5692                ha->flags.eeh_busy = 0;
5693                return PCI_ERS_RESULT_CAN_RECOVER;
5694        case pci_channel_io_frozen:
5695                ha->flags.eeh_busy = 1;
5696                /* For ISP82XX complete any pending mailbox cmd */
5697                if (IS_QLA82XX(ha)) {
5698                        ha->flags.isp82xx_fw_hung = 1;
5699                        ql_dbg(ql_dbg_aer, vha, 0x9001, "Pci channel io frozen\n");
5700                        qla82xx_clear_pending_mbx(vha);
5701                }
5702                qla2x00_free_irqs(vha);
5703                pci_disable_device(pdev);
5704                /* Return back all IOs */
5705                qla2x00_abort_all_cmds(vha, DID_RESET << 16);
5706                return PCI_ERS_RESULT_NEED_RESET;
5707        case pci_channel_io_perm_failure:
5708                ha->flags.pci_channel_io_perm_failure = 1;
5709                qla2x00_abort_all_cmds(vha, DID_NO_CONNECT << 16);
5710                return PCI_ERS_RESULT_DISCONNECT;
5711        }
5712        return PCI_ERS_RESULT_NEED_RESET;
5713}
5714
5715static pci_ers_result_t
5716qla2xxx_pci_mmio_enabled(struct pci_dev *pdev)
5717{
5718        int risc_paused = 0;
5719        uint32_t stat;
5720        unsigned long flags;
5721        scsi_qla_host_t *base_vha = pci_get_drvdata(pdev);
5722        struct qla_hw_data *ha = base_vha->hw;
5723        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
5724        struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
5725
5726        if (IS_QLA82XX(ha))
5727                return PCI_ERS_RESULT_RECOVERED;
5728
5729        spin_lock_irqsave(&ha->hardware_lock, flags);
5730        if (IS_QLA2100(ha) || IS_QLA2200(ha)){
5731                stat = RD_REG_DWORD(&reg->hccr);
5732                if (stat & HCCR_RISC_PAUSE)
5733                        risc_paused = 1;
5734        } else if (IS_QLA23XX(ha)) {
5735                stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
5736                if (stat & HSR_RISC_PAUSED)
5737                        risc_paused = 1;
5738        } else if (IS_FWI2_CAPABLE(ha)) {
5739                stat = RD_REG_DWORD(&reg24->host_status);
5740                if (stat & HSRX_RISC_PAUSED)
5741                        risc_paused = 1;
5742        }
5743        spin_unlock_irqrestore(&ha->hardware_lock, flags);
5744
5745        if (risc_paused) {
5746                ql_log(ql_log_info, base_vha, 0x9003,
5747                    "RISC paused -- mmio_enabled, Dumping firmware.\n");
5748                ha->isp_ops->fw_dump(base_vha, 0);
5749
5750                return PCI_ERS_RESULT_NEED_RESET;
5751        } else
5752                return PCI_ERS_RESULT_RECOVERED;
5753}
5754
5755static uint32_t
5756qla82xx_error_recovery(scsi_qla_host_t *base_vha)
5757{
5758        uint32_t rval = QLA_FUNCTION_FAILED;
5759        uint32_t drv_active = 0;
5760        struct qla_hw_data *ha = base_vha->hw;
5761        int fn;
5762        struct pci_dev *other_pdev = NULL;
5763
5764        ql_dbg(ql_dbg_aer, base_vha, 0x9006,
5765            "Entered %s.\n", __func__);
5766
5767        set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
5768
5769        if (base_vha->flags.online) {
5770                /* Abort all outstanding commands,
5771                 * so as to be requeued later */
5772                qla2x00_abort_isp_cleanup(base_vha);
5773        }
5774
5775
5776        fn = PCI_FUNC(ha->pdev->devfn);
5777        while (fn > 0) {
5778                fn--;
5779                ql_dbg(ql_dbg_aer, base_vha, 0x9007,
5780                    "Finding pci device at function = 0x%x.\n", fn);
5781                other_pdev =
5782                    pci_get_domain_bus_and_slot(pci_domain_nr(ha->pdev->bus),
5783                    ha->pdev->bus->number, PCI_DEVFN(PCI_SLOT(ha->pdev->devfn),
5784                    fn));
5785
5786                if (!other_pdev)
5787                        continue;
5788                if (atomic_read(&other_pdev->enable_cnt)) {
5789                        ql_dbg(ql_dbg_aer, base_vha, 0x9008,
5790                            "Found PCI func available and enable at 0x%x.\n",
5791                            fn);
5792                        pci_dev_put(other_pdev);
5793                        break;
5794                }
5795                pci_dev_put(other_pdev);
5796        }
5797
5798        if (!fn) {
5799                /* Reset owner */
5800                ql_dbg(ql_dbg_aer, base_vha, 0x9009,
5801                    "This devfn is reset owner = 0x%x.\n",
5802                    ha->pdev->devfn);
5803                qla82xx_idc_lock(ha);
5804
5805                qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
5806                    QLA8XXX_DEV_INITIALIZING);
5807
5808                qla82xx_wr_32(ha, QLA82XX_CRB_DRV_IDC_VERSION,
5809                    QLA82XX_IDC_VERSION);
5810
5811                drv_active = qla82xx_rd_32(ha, QLA82XX_CRB_DRV_ACTIVE);
5812                ql_dbg(ql_dbg_aer, base_vha, 0x900a,
5813                    "drv_active = 0x%x.\n", drv_active);
5814
5815                qla82xx_idc_unlock(ha);
5816                /* Reset if device is not already reset
5817                 * drv_active would be 0 if a reset has already been done
5818                 */
5819                if (drv_active)
5820                        rval = qla82xx_start_firmware(base_vha);
5821                else
5822                        rval = QLA_SUCCESS;
5823                qla82xx_idc_lock(ha);
5824
5825                if (rval != QLA_SUCCESS) {
5826                        ql_log(ql_log_info, base_vha, 0x900b,
5827                            "HW State: FAILED.\n");
5828                        qla82xx_clear_drv_active(ha);
5829                        qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
5830                            QLA8XXX_DEV_FAILED);
5831                } else {
5832                        ql_log(ql_log_info, base_vha, 0x900c,
5833                            "HW State: READY.\n");
5834                        qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
5835                            QLA8XXX_DEV_READY);
5836                        qla82xx_idc_unlock(ha);
5837                        ha->flags.isp82xx_fw_hung = 0;
5838                        rval = qla82xx_restart_isp(base_vha);
5839                        qla82xx_idc_lock(ha);
5840                        /* Clear driver state register */
5841                        qla82xx_wr_32(ha, QLA82XX_CRB_DRV_STATE, 0);
5842                        qla82xx_set_drv_active(base_vha);
5843                }
5844                qla82xx_idc_unlock(ha);
5845        } else {
5846                ql_dbg(ql_dbg_aer, base_vha, 0x900d,
5847                    "This devfn is not reset owner = 0x%x.\n",
5848                    ha->pdev->devfn);
5849                if ((qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE) ==
5850                    QLA8XXX_DEV_READY)) {
5851                        ha->flags.isp82xx_fw_hung = 0;
5852                        rval = qla82xx_restart_isp(base_vha);
5853                        qla82xx_idc_lock(ha);
5854                        qla82xx_set_drv_active(base_vha);
5855                        qla82xx_idc_unlock(ha);
5856                }
5857        }
5858        clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
5859
5860        return rval;
5861}
5862
5863static pci_ers_result_t
5864qla2xxx_pci_slot_reset(struct pci_dev *pdev)
5865{
5866        pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT;
5867        scsi_qla_host_t *base_vha = pci_get_drvdata(pdev);
5868        struct qla_hw_data *ha = base_vha->hw;
5869        struct rsp_que *rsp;
5870        int rc, retries = 10;
5871
5872        ql_dbg(ql_dbg_aer, base_vha, 0x9004,
5873            "Slot Reset.\n");
5874
5875        /* Workaround: qla2xxx driver which access hardware earlier
5876         * needs error state to be pci_channel_io_online.
5877         * Otherwise mailbox command timesout.
5878         */
5879        pdev->error_state = pci_channel_io_normal;
5880
5881        pci_restore_state(pdev);
5882
5883        /* pci_restore_state() clears the saved_state flag of the device
5884         * save restored state which resets saved_state flag
5885         */
5886        pci_save_state(pdev);
5887
5888        if (ha->mem_only)
5889                rc = pci_enable_device_mem(pdev);
5890        else
5891                rc = pci_enable_device(pdev);
5892
5893        if (rc) {
5894                ql_log(ql_log_warn, base_vha, 0x9005,
5895                    "Can't re-enable PCI device after reset.\n");
5896                goto exit_slot_reset;
5897        }
5898
5899        rsp = ha->rsp_q_map[0];
5900        if (qla2x00_request_irqs(ha, rsp))
5901                goto exit_slot_reset;
5902
5903        if (ha->isp_ops->pci_config(base_vha))
5904                goto exit_slot_reset;
5905
5906        if (IS_QLA82XX(ha)) {
5907                if (qla82xx_error_recovery(base_vha) == QLA_SUCCESS) {
5908                        ret = PCI_ERS_RESULT_RECOVERED;
5909                        goto exit_slot_reset;
5910                } else
5911                        goto exit_slot_reset;
5912        }
5913
5914        while (ha->flags.mbox_busy && retries--)
5915                msleep(1000);
5916
5917        set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
5918        if (ha->isp_ops->abort_isp(base_vha) == QLA_SUCCESS)
5919                ret =  PCI_ERS_RESULT_RECOVERED;
5920        clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
5921
5922
5923exit_slot_reset:
5924        ql_dbg(ql_dbg_aer, base_vha, 0x900e,
5925            "slot_reset return %x.\n", ret);
5926
5927        return ret;
5928}
5929
5930static void
5931qla2xxx_pci_resume(struct pci_dev *pdev)
5932{
5933        scsi_qla_host_t *base_vha = pci_get_drvdata(pdev);
5934        struct qla_hw_data *ha = base_vha->hw;
5935        int ret;
5936
5937        ql_dbg(ql_dbg_aer, base_vha, 0x900f,
5938            "pci_resume.\n");
5939
5940        ret = qla2x00_wait_for_hba_online(base_vha);
5941        if (ret != QLA_SUCCESS) {
5942                ql_log(ql_log_fatal, base_vha, 0x9002,
5943                    "The device failed to resume I/O from slot/link_reset.\n");
5944        }
5945
5946        pci_cleanup_aer_uncorrect_error_status(pdev);
5947
5948        ha->flags.eeh_busy = 0;
5949}
5950
5951static void
5952qla83xx_disable_laser(scsi_qla_host_t *vha)
5953{
5954        uint32_t reg, data, fn;
5955        struct qla_hw_data *ha = vha->hw;
5956        struct device_reg_24xx __iomem *isp_reg = &ha->iobase->isp24;
5957
5958        /* pci func #/port # */
5959        ql_dbg(ql_dbg_init, vha, 0x004b,
5960            "Disabling Laser for hba: %p\n", vha);
5961
5962        fn = (RD_REG_DWORD(&isp_reg->ctrl_status) &
5963                (BIT_15|BIT_14|BIT_13|BIT_12));
5964
5965        fn = (fn >> 12);
5966
5967        if (fn & 1)
5968                reg = PORT_1_2031;
5969        else
5970                reg = PORT_0_2031;
5971
5972        data = LASER_OFF_2031;
5973
5974        qla83xx_wr_reg(vha, reg, data);
5975}
5976
5977static const struct pci_error_handlers qla2xxx_err_handler = {
5978        .error_detected = qla2xxx_pci_error_detected,
5979        .mmio_enabled = qla2xxx_pci_mmio_enabled,
5980        .slot_reset = qla2xxx_pci_slot_reset,
5981        .resume = qla2xxx_pci_resume,
5982};
5983
5984static struct pci_device_id qla2xxx_pci_tbl[] = {
5985        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2100) },
5986        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2200) },
5987        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2300) },
5988        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2312) },
5989        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2322) },
5990        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6312) },
5991        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6322) },
5992        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2422) },
5993        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2432) },
5994        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP8432) },
5995        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP5422) },
5996        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP5432) },
5997        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2532) },
5998        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2031) },
5999        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP8001) },
6000        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP8021) },
6001        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP8031) },
6002        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISPF001) },
6003        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP8044) },
6004        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2071) },
6005        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2271) },
6006        { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2261) },
6007        { 0 },
6008};
6009MODULE_DEVICE_TABLE(pci, qla2xxx_pci_tbl);
6010
6011static struct pci_driver qla2xxx_pci_driver = {
6012        .name           = QLA2XXX_DRIVER_NAME,
6013        .driver         = {
6014                .owner          = THIS_MODULE,
6015        },
6016        .id_table       = qla2xxx_pci_tbl,
6017        .probe          = qla2x00_probe_one,
6018        .remove         = qla2x00_remove_one,
6019        .shutdown       = qla2x00_shutdown,
6020        .err_handler    = &qla2xxx_err_handler,
6021};
6022
6023static const struct file_operations apidev_fops = {
6024        .owner = THIS_MODULE,
6025        .llseek = noop_llseek,
6026};
6027
6028/**
6029 * qla2x00_module_init - Module initialization.
6030 **/
6031static int __init
6032qla2x00_module_init(void)
6033{
6034        int ret = 0;
6035
6036        /* Allocate cache for SRBs. */
6037        srb_cachep = kmem_cache_create("qla2xxx_srbs", sizeof(srb_t), 0,
6038            SLAB_HWCACHE_ALIGN, NULL);
6039        if (srb_cachep == NULL) {
6040                ql_log(ql_log_fatal, NULL, 0x0001,
6041                    "Unable to allocate SRB cache...Failing load!.\n");
6042                return -ENOMEM;
6043        }
6044
6045        /* Initialize target kmem_cache and mem_pools */
6046        ret = qlt_init();
6047        if (ret < 0) {
6048                kmem_cache_destroy(srb_cachep);
6049                return ret;
6050        } else if (ret > 0) {
6051                /*
6052                 * If initiator mode is explictly disabled by qlt_init(),
6053                 * prevent scsi_transport_fc.c:fc_scsi_scan_rport() from
6054                 * performing scsi_scan_target() during LOOP UP event.
6055                 */
6056                qla2xxx_transport_functions.disable_target_scan = 1;
6057                qla2xxx_transport_vport_functions.disable_target_scan = 1;
6058        }
6059
6060        /* Derive version string. */
6061        strcpy(qla2x00_version_str, QLA2XXX_VERSION);
6062        if (ql2xextended_error_logging)
6063                strcat(qla2x00_version_str, "-debug");
6064
6065        qla2xxx_transport_template =
6066            fc_attach_transport(&qla2xxx_transport_functions);
6067        if (!qla2xxx_transport_template) {
6068                kmem_cache_destroy(srb_cachep);
6069                ql_log(ql_log_fatal, NULL, 0x0002,
6070                    "fc_attach_transport failed...Failing load!.\n");
6071                qlt_exit();
6072                return -ENODEV;
6073        }
6074
6075        apidev_major = register_chrdev(0, QLA2XXX_APIDEV, &apidev_fops);
6076        if (apidev_major < 0) {
6077                ql_log(ql_log_fatal, NULL, 0x0003,
6078                    "Unable to register char device %s.\n", QLA2XXX_APIDEV);
6079        }
6080
6081        qla2xxx_transport_vport_template =
6082            fc_attach_transport(&qla2xxx_transport_vport_functions);
6083        if (!qla2xxx_transport_vport_template) {
6084                kmem_cache_destroy(srb_cachep);
6085                qlt_exit();
6086                fc_release_transport(qla2xxx_transport_template);
6087                ql_log(ql_log_fatal, NULL, 0x0004,
6088                    "fc_attach_transport vport failed...Failing load!.\n");
6089                return -ENODEV;
6090        }
6091        ql_log(ql_log_info, NULL, 0x0005,
6092            "QLogic Fibre Channel HBA Driver: %s.\n",
6093            qla2x00_version_str);
6094        ret = pci_register_driver(&qla2xxx_pci_driver);
6095        if (ret) {
6096                kmem_cache_destroy(srb_cachep);
6097                qlt_exit();
6098                fc_release_transport(qla2xxx_transport_template);
6099                fc_release_transport(qla2xxx_transport_vport_template);
6100                ql_log(ql_log_fatal, NULL, 0x0006,
6101                    "pci_register_driver failed...ret=%d Failing load!.\n",
6102                    ret);
6103        }
6104        return ret;
6105}
6106
6107/**
6108 * qla2x00_module_exit - Module cleanup.
6109 **/
6110static void __exit
6111qla2x00_module_exit(void)
6112{
6113        unregister_chrdev(apidev_major, QLA2XXX_APIDEV);
6114        pci_unregister_driver(&qla2xxx_pci_driver);
6115        qla2x00_release_firmware();
6116        kmem_cache_destroy(srb_cachep);
6117        qlt_exit();
6118        if (ctx_cachep)
6119                kmem_cache_destroy(ctx_cachep);
6120        fc_release_transport(qla2xxx_transport_template);
6121        fc_release_transport(qla2xxx_transport_vport_template);
6122}
6123
6124module_init(qla2x00_module_init);
6125module_exit(qla2x00_module_exit);
6126
6127MODULE_AUTHOR("QLogic Corporation");
6128MODULE_DESCRIPTION("QLogic Fibre Channel HBA Driver");
6129MODULE_LICENSE("GPL");
6130MODULE_VERSION(QLA2XXX_VERSION);
6131MODULE_FIRMWARE(FW_FILE_ISP21XX);
6132MODULE_FIRMWARE(FW_FILE_ISP22XX);
6133MODULE_FIRMWARE(FW_FILE_ISP2300);
6134MODULE_FIRMWARE(FW_FILE_ISP2322);
6135MODULE_FIRMWARE(FW_FILE_ISP24XX);
6136MODULE_FIRMWARE(FW_FILE_ISP25XX);
Note: See TracBrowser for help on using the repository browser.