qla_os.c 179.9 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
A
Andrew Vasquez 已提交
2
 * QLogic Fibre Channel HBA Driver
3
 * Copyright (c)  2003-2014 QLogic Corporation
L
Linus Torvalds 已提交
4
 *
A
Andrew Vasquez 已提交
5
 * See LICENSE.qla2xxx for copyright and licensing details.
L
Linus Torvalds 已提交
6 7 8 9 10 11
 */
#include "qla_def.h"

#include <linux/moduleparam.h>
#include <linux/vmalloc.h>
#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 <linux/blk-mq-pci.h>
L
Linus Torvalds 已提交
17 18 19 20 21
#include <scsi/scsi_tcq.h>
#include <scsi/scsicam.h>
#include <scsi/scsi_transport.h>
#include <scsi/scsi_transport_fc.h>

22 23
#include "qla_target.h"

L
Linus Torvalds 已提交
24 25 26 27 28
/*
 * Driver version
 */
char qla2x00_version_str[40];

29 30
static int apidev_major;

L
Linus Torvalds 已提交
31 32 33
/*
 * SRB allocation cache
 */
34
struct kmem_cache *srb_cachep;
L
Linus Torvalds 已提交
35

36 37 38 39
/*
 * CT6 CTX allocation cache
 */
static struct kmem_cache *ctx_cachep;
40 41 42 43
/*
 * error level for logging
 */
int ql_errlev = ql_log_all;
44

45
static int ql2xenableclass2;
46 47 48 49 50
module_param(ql2xenableclass2, int, S_IRUGO|S_IRUSR);
MODULE_PARM_DESC(ql2xenableclass2,
		"Specify if Class 2 operations are supported from the very "
		"beginning. Default is 0 - class 2 not supported.");

51

L
Linus Torvalds 已提交
52
int ql2xlogintimeout = 20;
53
module_param(ql2xlogintimeout, int, S_IRUGO);
L
Linus Torvalds 已提交
54 55 56
MODULE_PARM_DESC(ql2xlogintimeout,
		"Login timeout value in seconds.");

57
int qlport_down_retry;
58
module_param(qlport_down_retry, int, S_IRUGO);
L
Linus Torvalds 已提交
59
MODULE_PARM_DESC(qlport_down_retry,
60
		"Maximum number of command retries to a port that returns "
L
Linus Torvalds 已提交
61 62 63 64 65 66
		"a PORT-DOWN status.");

int ql2xplogiabsentdevice;
module_param(ql2xplogiabsentdevice, int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(ql2xplogiabsentdevice,
		"Option to enable PLOGI to devices that are not present after "
67
		"a Fabric scan.  This is needed for several broken switches. "
L
Linus Torvalds 已提交
68 69 70
		"Default is 0 - no PLOGI. 1 - perfom PLOGI.");

int ql2xloginretrycount = 0;
71
module_param(ql2xloginretrycount, int, S_IRUGO);
L
Linus Torvalds 已提交
72 73 74
MODULE_PARM_DESC(ql2xloginretrycount,
		"Specify an alternate value for the NVRAM login retry count.");

75
int ql2xallocfwdump = 1;
76
module_param(ql2xallocfwdump, int, S_IRUGO);
77 78 79 80 81
MODULE_PARM_DESC(ql2xallocfwdump,
		"Option to enable allocation of memory for a firmware dump "
		"during HBA initialization.  Memory allocation requirements "
		"vary by ISP type.  Default is 1 - allocate memory.");

82
int ql2xextended_error_logging;
83
module_param(ql2xextended_error_logging, int, S_IRUGO|S_IWUSR);
84
module_param_named(logging, ql2xextended_error_logging, int, S_IRUGO|S_IWUSR);
85
MODULE_PARM_DESC(ql2xextended_error_logging,
86 87 88 89 90 91 92 93 94
		"Option to enable extended error logging,\n"
		"\t\tDefault is 0 - no logging.  0x40000000 - Module Init & Probe.\n"
		"\t\t0x20000000 - Mailbox Cmnds. 0x10000000 - Device Discovery.\n"
		"\t\t0x08000000 - IO tracing.    0x04000000 - DPC Thread.\n"
		"\t\t0x02000000 - Async events.  0x01000000 - Timer routines.\n"
		"\t\t0x00800000 - User space.    0x00400000 - Task Management.\n"
		"\t\t0x00200000 - AER/EEH.       0x00100000 - Multi Q.\n"
		"\t\t0x00080000 - P3P Specific.  0x00040000 - Virtual Port.\n"
		"\t\t0x00020000 - Buffer Dump.   0x00010000 - Misc.\n"
95 96
		"\t\t0x00008000 - Verbose.       0x00004000 - Target.\n"
		"\t\t0x00002000 - Target Mgmt.   0x00001000 - Target TMF.\n"
97
		"\t\t0x7fffffff - For enabling all logs, can be too many logs.\n"
98 99 100
		"\t\t0x1e400000 - Preferred value for capturing essential "
		"debug information (equivalent to old "
		"ql2xextended_error_logging=1).\n"
101
		"\t\tDo LOGICAL OR of the value to enable more than one level");
102

103
int ql2xshiftctondsd = 6;
104
module_param(ql2xshiftctondsd, int, S_IRUGO);
105 106 107 108
MODULE_PARM_DESC(ql2xshiftctondsd,
		"Set to control shifting of command type processing "
		"based on total number of SG elements.");

109
int ql2xfdmienable=1;
110
module_param(ql2xfdmienable, int, S_IRUGO|S_IWUSR);
111
module_param_named(fdmi, ql2xfdmienable, int, S_IRUGO|S_IWUSR);
112
MODULE_PARM_DESC(ql2xfdmienable,
113 114
		"Enables FDMI registrations. "
		"0 - no FDMI. Default is 1 - perform FDMI.");
115

116 117
#define MAX_Q_DEPTH	32
static int ql2xmaxqdepth = MAX_Q_DEPTH;
118 119
module_param(ql2xmaxqdepth, int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(ql2xmaxqdepth,
120 121
		"Maximum queue depth to set for each LUN. "
		"Default is 32.");
122

123 124 125
#if (IS_ENABLED(CONFIG_NVME_FC))
int ql2xenabledif;
#else
126
int ql2xenabledif = 2;
127
#endif
128
module_param(ql2xenabledif, int, S_IRUGO);
129
MODULE_PARM_DESC(ql2xenabledif,
130 131 132 133 134
		" Enable T10-CRC-DIF:\n"
		" Default is 2.\n"
		"  0 -- No DIF Support\n"
		"  1 -- Enable DIF for all types\n"
		"  2 -- Enable DIF for all types, except Type 0.\n");
135

136 137 138 139 140 141 142 143 144 145
#if (IS_ENABLED(CONFIG_NVME_FC))
int ql2xnvmeenable = 1;
#else
int ql2xnvmeenable;
#endif
module_param(ql2xnvmeenable, int, 0644);
MODULE_PARM_DESC(ql2xnvmeenable,
    "Enables NVME support. "
    "0 - no NVMe.  Default is Y");

146
int ql2xenablehba_err_chk = 2;
147 148
module_param(ql2xenablehba_err_chk, int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(ql2xenablehba_err_chk,
149
		" Enable T10-CRC-DIF Error isolation by HBA:\n"
150
		" Default is 2.\n"
151 152 153
		"  0 -- Error isolation disabled\n"
		"  1 -- Error isolation enabled only for DIX Type 0\n"
		"  2 -- Error isolation enabled for all Types\n");
154

155
int ql2xiidmaenable=1;
156
module_param(ql2xiidmaenable, int, S_IRUGO);
157 158 159 160
MODULE_PARM_DESC(ql2xiidmaenable,
		"Enables iIDMA settings "
		"Default is 1 - perform iIDMA. 0 - no iIDMA.");

161 162 163 164 165 166
int ql2xmqsupport = 1;
module_param(ql2xmqsupport, int, S_IRUGO);
MODULE_PARM_DESC(ql2xmqsupport,
		"Enable on demand multiple queue pairs support "
		"Default is 1 for supported. "
		"Set it to 0 to turn off mq qpair support.");
167 168

int ql2xfwloadbin;
169
module_param(ql2xfwloadbin, int, S_IRUGO|S_IWUSR);
170
module_param_named(fwload, ql2xfwloadbin, int, S_IRUGO|S_IWUSR);
171
MODULE_PARM_DESC(ql2xfwloadbin,
172 173
		"Option to specify location from which to load ISP firmware:.\n"
		" 2 -- load firmware via the request_firmware() (hotplug).\n"
174 175 176 177
		"      interface.\n"
		" 1 -- load firmware from flash.\n"
		" 0 -- use default semantics.\n");

178
int ql2xetsenable;
179
module_param(ql2xetsenable, int, S_IRUGO);
180 181 182 183
MODULE_PARM_DESC(ql2xetsenable,
		"Enables firmware ETS burst."
		"Default is 0 - skip ETS enablement.");

184
int ql2xdbwr = 1;
185
module_param(ql2xdbwr, int, S_IRUGO|S_IWUSR);
186
MODULE_PARM_DESC(ql2xdbwr,
187 188 189
		"Option to specify scheme for request queue posting.\n"
		" 0 -- Regular doorbell.\n"
		" 1 -- CAMRAM doorbell (faster).\n");
190

191
int ql2xtargetreset = 1;
192
module_param(ql2xtargetreset, int, S_IRUGO);
193 194 195 196
MODULE_PARM_DESC(ql2xtargetreset,
		 "Enable target reset."
		 "Default is 1 - use hw defaults.");

197
int ql2xgffidenable;
198
module_param(ql2xgffidenable, int, S_IRUGO);
199 200 201
MODULE_PARM_DESC(ql2xgffidenable,
		"Enables GFF_ID checks of port type. "
		"Default is 0 - Do not use GFF_ID information.");
202

203
int ql2xasynctmfenable;
204
module_param(ql2xasynctmfenable, int, S_IRUGO);
205 206 207
MODULE_PARM_DESC(ql2xasynctmfenable,
		"Enables issue of TM IOCBs asynchronously via IOCB mechanism"
		"Default is 0 - Issue TM IOCBs via mailbox mechanism.");
208 209

int ql2xdontresethba;
210
module_param(ql2xdontresethba, int, S_IRUGO|S_IWUSR);
211
MODULE_PARM_DESC(ql2xdontresethba,
212 213 214
		"Option to specify reset behaviour.\n"
		" 0 (Default) -- Reset on failure.\n"
		" 1 -- Do not reset on failure.\n");
215

216 217
uint64_t ql2xmaxlun = MAX_LUNS;
module_param(ql2xmaxlun, ullong, S_IRUGO);
218 219 220 221
MODULE_PARM_DESC(ql2xmaxlun,
		"Defines the maximum LU number to register with the SCSI "
		"midlayer. Default is 65535.");

222 223 224 225
int ql2xmdcapmask = 0x1F;
module_param(ql2xmdcapmask, int, S_IRUGO);
MODULE_PARM_DESC(ql2xmdcapmask,
		"Set the Minidump driver capture mask level. "
226
		"Default is 0x1F - Can be set to 0x3, 0x7, 0xF, 0x1F, 0x7F.");
227

228
int ql2xmdenable = 1;
229 230 231
module_param(ql2xmdenable, int, S_IRUGO);
MODULE_PARM_DESC(ql2xmdenable,
		"Enable/disable MiniDump. "
232 233
		"0 - MiniDump disabled. "
		"1 (Default) - MiniDump enabled.");
234

235 236 237 238 239 240
int ql2xexlogins = 0;
module_param(ql2xexlogins, uint, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(ql2xexlogins,
		 "Number of extended Logins. "
		 "0 (Default)- Disabled.");

241 242
int ql2xexchoffld = 1024;
module_param(ql2xexchoffld, uint, 0644);
243
MODULE_PARM_DESC(ql2xexchoffld,
244 245 246 247 248 249
	"Number of target exchanges.");

int ql2xiniexchg = 1024;
module_param(ql2xiniexchg, uint, 0644);
MODULE_PARM_DESC(ql2xiniexchg,
	"Number of initiator exchanges.");
250

251 252 253 254 255 256 257
int ql2xfwholdabts = 0;
module_param(ql2xfwholdabts, int, S_IRUGO);
MODULE_PARM_DESC(ql2xfwholdabts,
		"Allow FW to hold status IOCB until ABTS rsp received. "
		"0 (Default) Do not set fw option. "
		"1 - Set fw option to hold ABTS.");

258 259 260 261 262 263 264
int ql2xmvasynctoatio = 1;
module_param(ql2xmvasynctoatio, int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(ql2xmvasynctoatio,
		"Move PUREX, ABTS RX and RIDA IOCBs to ATIOQ"
		"0 (Default). Do not move IOCBs"
		"1 - Move IOCBs.");

L
Linus Torvalds 已提交
265
/*
A
Andrew Vasquez 已提交
266
 * SCSI host template entry points
L
Linus Torvalds 已提交
267 268
 */
static int qla2xxx_slave_configure(struct scsi_device * device);
已提交
269
static int qla2xxx_slave_alloc(struct scsi_device *);
270 271
static int qla2xxx_scan_finished(struct Scsi_Host *, unsigned long time);
static void qla2xxx_scan_start(struct Scsi_Host *);
已提交
272
static void qla2xxx_slave_destroy(struct scsi_device *);
J
Jeff Garzik 已提交
273
static int qla2xxx_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *cmd);
L
Linus Torvalds 已提交
274 275
static int qla2xxx_eh_abort(struct scsi_cmnd *);
static int qla2xxx_eh_device_reset(struct scsi_cmnd *);
276
static int qla2xxx_eh_target_reset(struct scsi_cmnd *);
L
Linus Torvalds 已提交
277 278 279
static int qla2xxx_eh_bus_reset(struct scsi_cmnd *);
static int qla2xxx_eh_host_reset(struct scsi_cmnd *);

280
static void qla2x00_clear_drv_active(struct qla_hw_data *);
281
static void qla2x00_free_device(scsi_qla_host_t *);
282
static void qla83xx_disable_laser(scsi_qla_host_t *vha);
283
static int qla2xxx_map_queues(struct Scsi_Host *shost);
284
static void qla2x00_destroy_deferred_work(struct qla_hw_data *);
285

286
struct scsi_host_template qla2xxx_driver_template = {
L
Linus Torvalds 已提交
287
	.module			= THIS_MODULE,
288
	.name			= QLA2XXX_DRIVER_NAME,
289
	.queuecommand		= qla2xxx_queuecommand,
290

291
	.eh_timed_out		= fc_eh_timed_out,
292 293
	.eh_abort_handler	= qla2xxx_eh_abort,
	.eh_device_reset_handler = qla2xxx_eh_device_reset,
294
	.eh_target_reset_handler = qla2xxx_eh_target_reset,
295 296 297 298 299 300 301
	.eh_bus_reset_handler	= qla2xxx_eh_bus_reset,
	.eh_host_reset_handler	= qla2xxx_eh_host_reset,

	.slave_configure	= qla2xxx_slave_configure,

	.slave_alloc		= qla2xxx_slave_alloc,
	.slave_destroy		= qla2xxx_slave_destroy,
302 303
	.scan_finished		= qla2xxx_scan_finished,
	.scan_start		= qla2xxx_scan_start,
304
	.change_queue_depth	= scsi_change_queue_depth,
305
	.map_queues             = qla2xxx_map_queues,
306 307 308 309 310 311
	.this_id		= -1,
	.cmd_per_lun		= 3,
	.use_clustering		= ENABLE_CLUSTERING,
	.sg_tablesize		= SG_ALL,

	.max_sectors		= 0xFFFF,
312
	.shost_attrs		= qla2x00_host_attrs,
313 314

	.supported_mode		= MODE_INITIATOR,
315
	.track_queue_depth	= 1,
316 317
};

L
Linus Torvalds 已提交
318
static struct scsi_transport_template *qla2xxx_transport_template = NULL;
319
struct scsi_transport_template *qla2xxx_transport_vport_template = NULL;
L
Linus Torvalds 已提交
320 321 322 323 324 325

/* TODO Convert to inlines
 *
 * Timer routines
 */

326
__inline__ void
327
qla2x00_start_timer(scsi_qla_host_t *vha, void *func, unsigned long interval)
L
Linus Torvalds 已提交
328
{
329 330 331 332 333 334
	init_timer(&vha->timer);
	vha->timer.expires = jiffies + interval * HZ;
	vha->timer.data = (unsigned long)vha;
	vha->timer.function = (void (*)(unsigned long))func;
	add_timer(&vha->timer);
	vha->timer_active = 1;
L
Linus Torvalds 已提交
335 336 337
}

static inline void
338
qla2x00_restart_timer(scsi_qla_host_t *vha, unsigned long interval)
L
Linus Torvalds 已提交
339
{
340
	/* Currently used for 82XX only. */
341 342 343
	if (vha->device_flags & DFLG_DEV_FAILED) {
		ql_dbg(ql_dbg_timer, vha, 0x600d,
		    "Device in a failed state, returning.\n");
344
		return;
345
	}
346

347
	mod_timer(&vha->timer, jiffies + interval * HZ);
L
Linus Torvalds 已提交
348 349
}

A
Adrian Bunk 已提交
350
static __inline__ void
351
qla2x00_stop_timer(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
352
{
353 354
	del_timer_sync(&vha->timer);
	vha->timer_active = 0;
L
Linus Torvalds 已提交
355 356 357 358 359 360
}

static int qla2x00_do_dpc(void *data);

static void qla2x00_rst_aen(scsi_qla_host_t *);

361 362
static int qla2x00_mem_alloc(struct qla_hw_data *, uint16_t, uint16_t,
	struct req_que **, struct rsp_que **);
363
static void qla2x00_free_fw_dump(struct qla_hw_data *);
364
static void qla2x00_mem_free(struct qla_hw_data *);
365 366
int qla2xxx_mqueuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd,
	struct qla_qpair *qpair);
L
Linus Torvalds 已提交
367 368

/* -------------------------------------------------------------------------- */
369 370 371 372 373 374 375 376 377 378 379 380 381
static void qla_init_base_qpair(struct scsi_qla_host *vha, struct req_que *req,
    struct rsp_que *rsp)
{
	struct qla_hw_data *ha = vha->hw;
	rsp->qpair = ha->base_qpair;
	rsp->req = req;
	ha->base_qpair->req = req;
	ha->base_qpair->rsp = rsp;
	ha->base_qpair->vha = vha;
	ha->base_qpair->qp_lock_ptr = &ha->hardware_lock;
	ha->base_qpair->use_shadow_reg = IS_SHADOW_REG_CAPABLE(ha) ? 1 : 0;
	ha->base_qpair->msix = &ha->msix_entries[QLA_MSIX_RSP_Q];
	INIT_LIST_HEAD(&ha->base_qpair->hints_list);
382
	INIT_LIST_HEAD(&ha->base_qpair->nvme_done_list);
383 384 385 386 387 388 389 390 391
	ha->base_qpair->enable_class_2 = ql2xenableclass2;
	/* init qpair to this cpu. Will adjust at run time. */
	qla_cpu_update(rsp->qpair, smp_processor_id());
	ha->base_qpair->pdev = ha->pdev;

	if (IS_QLA27XX(ha) || IS_QLA83XX(ha))
		ha->base_qpair->reqq_start_iocbs = qla_83xx_start_iocbs;
}

392 393
static int qla2x00_alloc_queues(struct qla_hw_data *ha, struct req_que *req,
				struct rsp_que *rsp)
394
{
395
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
396
	ha->req_q_map = kzalloc(sizeof(struct req_que *) * ha->max_req_queues,
397 398
				GFP_KERNEL);
	if (!ha->req_q_map) {
399 400
		ql_log(ql_log_fatal, vha, 0x003b,
		    "Unable to allocate memory for request queue ptrs.\n");
401 402 403
		goto fail_req_map;
	}

404
	ha->rsp_q_map = kzalloc(sizeof(struct rsp_que *) * ha->max_rsp_queues,
405 406
				GFP_KERNEL);
	if (!ha->rsp_q_map) {
407 408
		ql_log(ql_log_fatal, vha, 0x003c,
		    "Unable to allocate memory for response queue ptrs.\n");
409 410
		goto fail_rsp_map;
	}
411

412 413 414 415 416 417 418
	ha->base_qpair = kzalloc(sizeof(struct qla_qpair), GFP_KERNEL);
	if (ha->base_qpair == NULL) {
		ql_log(ql_log_warn, vha, 0x00e0,
		    "Failed to allocate base queue pair memory.\n");
		goto fail_base_qpair;
	}

419
	qla_init_base_qpair(vha, req, rsp);
420

421 422 423 424 425 426 427 428 429 430
	if (ql2xmqsupport && ha->max_qpairs) {
		ha->queue_pair_map = kcalloc(ha->max_qpairs, sizeof(struct qla_qpair *),
			GFP_KERNEL);
		if (!ha->queue_pair_map) {
			ql_log(ql_log_fatal, vha, 0x0180,
			    "Unable to allocate memory for queue pair ptrs.\n");
			goto fail_qpair_map;
		}
	}

431 432 433 434 435 436
	/*
	 * Make sure we record at least the request and response queue zero in
	 * case we need to free them if part of the probe fails.
	 */
	ha->rsp_q_map[0] = rsp;
	ha->req_q_map[0] = req;
437 438 439 440
	set_bit(0, ha->rsp_qid_map);
	set_bit(0, ha->req_qid_map);
	return 1;

441
fail_qpair_map:
442 443 444
	kfree(ha->base_qpair);
	ha->base_qpair = NULL;
fail_base_qpair:
445 446
	kfree(ha->rsp_q_map);
	ha->rsp_q_map = NULL;
447 448 449 450 451 452 453
fail_rsp_map:
	kfree(ha->req_q_map);
	ha->req_q_map = NULL;
fail_req_map:
	return -ENOMEM;
}

454
static void qla2x00_free_req_que(struct qla_hw_data *ha, struct req_que *req)
455
{
456 457 458 459 460 461
	if (IS_QLAFX00(ha)) {
		if (req && req->ring_fx00)
			dma_free_coherent(&ha->pdev->dev,
			    (req->length_fx00 + 1) * sizeof(request_t),
			    req->ring_fx00, req->dma_fx00);
	} else if (req && req->ring)
462 463 464 465
		dma_free_coherent(&ha->pdev->dev,
		(req->length + 1) * sizeof(request_t),
		req->ring, req->dma);

466 467 468
	if (req)
		kfree(req->outstanding_cmds);

469 470 471
	kfree(req);
}

472 473
static void qla2x00_free_rsp_que(struct qla_hw_data *ha, struct rsp_que *rsp)
{
474 475 476 477 478 479
	if (IS_QLAFX00(ha)) {
		if (rsp && rsp->ring)
			dma_free_coherent(&ha->pdev->dev,
			    (rsp->length_fx00 + 1) * sizeof(request_t),
			    rsp->ring_fx00, rsp->dma_fx00);
	} else if (rsp && rsp->ring) {
480 481 482
		dma_free_coherent(&ha->pdev->dev,
		(rsp->length + 1) * sizeof(response_t),
		rsp->ring, rsp->dma);
483
	}
484 485 486
	kfree(rsp);
}

487 488 489 490 491
static void qla2x00_free_queues(struct qla_hw_data *ha)
{
	struct req_que *req;
	struct rsp_que *rsp;
	int cnt;
492
	unsigned long flags;
493

494 495 496 497 498 499 500 501 502
	if (ha->queue_pair_map) {
		kfree(ha->queue_pair_map);
		ha->queue_pair_map = NULL;
	}
	if (ha->base_qpair) {
		kfree(ha->base_qpair);
		ha->base_qpair = NULL;
	}

503
	spin_lock_irqsave(&ha->hardware_lock, flags);
504
	for (cnt = 0; cnt < ha->max_req_queues; cnt++) {
Q
Quinn Tran 已提交
505 506 507
		if (!test_bit(cnt, ha->req_qid_map))
			continue;

508
		req = ha->req_q_map[cnt];
509 510 511 512
		clear_bit(cnt, ha->req_qid_map);
		ha->req_q_map[cnt] = NULL;

		spin_unlock_irqrestore(&ha->hardware_lock, flags);
513
		qla2x00_free_req_que(ha, req);
514
		spin_lock_irqsave(&ha->hardware_lock, flags);
515
	}
516 517
	spin_unlock_irqrestore(&ha->hardware_lock, flags);

518 519
	kfree(ha->req_q_map);
	ha->req_q_map = NULL;
520

521 522

	spin_lock_irqsave(&ha->hardware_lock, flags);
523
	for (cnt = 0; cnt < ha->max_rsp_queues; cnt++) {
Q
Quinn Tran 已提交
524 525 526
		if (!test_bit(cnt, ha->rsp_qid_map))
			continue;

527
		rsp = ha->rsp_q_map[cnt];
528
		clear_bit(cnt, ha->rsp_qid_map);
529 530
		ha->rsp_q_map[cnt] =  NULL;
		spin_unlock_irqrestore(&ha->hardware_lock, flags);
531
		qla2x00_free_rsp_que(ha, rsp);
532
		spin_lock_irqsave(&ha->hardware_lock, flags);
533
	}
534 535
	spin_unlock_irqrestore(&ha->hardware_lock, flags);

536 537
	kfree(ha->rsp_q_map);
	ha->rsp_q_map = NULL;
538 539
}

L
Linus Torvalds 已提交
540
static char *
541
qla2x00_pci_info_str(struct scsi_qla_host *vha, char *str)
L
Linus Torvalds 已提交
542
{
543
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
	static char *pci_bus_modes[] = {
		"33", "66", "100", "133",
	};
	uint16_t pci_bus;

	strcpy(str, "PCI");
	pci_bus = (ha->pci_attr & (BIT_9 | BIT_10)) >> 9;
	if (pci_bus) {
		strcat(str, "-X (");
		strcat(str, pci_bus_modes[pci_bus]);
	} else {
		pci_bus = (ha->pci_attr & BIT_8) >> 8;
		strcat(str, " (");
		strcat(str, pci_bus_modes[pci_bus]);
	}
	strcat(str, " MHz)");

	return (str);
}

564
static char *
565
qla24xx_pci_info_str(struct scsi_qla_host *vha, char *str)
566 567
{
	static char *pci_bus_modes[] = { "33", "66", "100", "133", };
568
	struct qla_hw_data *ha = vha->hw;
569 570
	uint32_t pci_bus;

571
	if (pci_is_pcie(ha->pdev)) {
572
		char lwstr[6];
573
		uint32_t lstat, lspeed, lwidth;
574

575 576 577
		pcie_capability_read_dword(ha->pdev, PCI_EXP_LNKCAP, &lstat);
		lspeed = lstat & PCI_EXP_LNKCAP_SLS;
		lwidth = (lstat & PCI_EXP_LNKCAP_MLW) >> 4;
578 579

		strcpy(str, "PCIe (");
580 581
		switch (lspeed) {
		case 1:
582
			strcat(str, "2.5GT/s ");
583 584
			break;
		case 2:
585
			strcat(str, "5.0GT/s ");
586 587 588 589 590
			break;
		case 3:
			strcat(str, "8.0GT/s ");
			break;
		default:
591
			strcat(str, "<unknown> ");
592 593
			break;
		}
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618
		snprintf(lwstr, sizeof(lwstr), "x%d)", lwidth);
		strcat(str, lwstr);

		return str;
	}

	strcpy(str, "PCI");
	pci_bus = (ha->pci_attr & CSRX_PCIX_BUS_MODE_MASK) >> 8;
	if (pci_bus == 0 || pci_bus == 8) {
		strcat(str, " (");
		strcat(str, pci_bus_modes[pci_bus >> 3]);
	} else {
		strcat(str, "-X ");
		if (pci_bus & BIT_2)
			strcat(str, "Mode 2");
		else
			strcat(str, "Mode 1");
		strcat(str, " (");
		strcat(str, pci_bus_modes[pci_bus & ~BIT_2]);
	}
	strcat(str, " MHz)");

	return str;
}

619
static char *
620
qla2x00_fw_version_str(struct scsi_qla_host *vha, char *str, size_t size)
L
Linus Torvalds 已提交
621 622
{
	char un_str[10];
623
	struct qla_hw_data *ha = vha->hw;
A
Andrew Vasquez 已提交
624

625 626
	snprintf(str, size, "%d.%02d.%02d ", ha->fw_major_version,
	    ha->fw_minor_version, ha->fw_subminor_version);
L
Linus Torvalds 已提交
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656

	if (ha->fw_attributes & BIT_9) {
		strcat(str, "FLX");
		return (str);
	}

	switch (ha->fw_attributes & 0xFF) {
	case 0x7:
		strcat(str, "EF");
		break;
	case 0x17:
		strcat(str, "TP");
		break;
	case 0x37:
		strcat(str, "IP");
		break;
	case 0x77:
		strcat(str, "VI");
		break;
	default:
		sprintf(un_str, "(%x)", ha->fw_attributes);
		strcat(str, un_str);
		break;
	}
	if (ha->fw_attributes & 0x100)
		strcat(str, "X");

	return (str);
}

657
static char *
658
qla24xx_fw_version_str(struct scsi_qla_host *vha, char *str, size_t size)
659
{
660
	struct qla_hw_data *ha = vha->hw;
661

662
	snprintf(str, size, "%d.%02d.%02d (%x)", ha->fw_major_version,
663
	    ha->fw_minor_version, ha->fw_subminor_version, ha->fw_attributes);
664 665 666
	return str;
}

667
void
668
qla2x00_sp_free_dma(void *ptr)
669
{
670 671
	srb_t *sp = ptr;
	struct qla_hw_data *ha = sp->vha->hw;
672 673
	struct scsi_cmnd *cmd = GET_CMD_SP(sp);
	void *ctx = GET_CMD_CTX_SP(sp);
674

675 676 677
	if (sp->flags & SRB_DMA_VALID) {
		scsi_dma_unmap(cmd);
		sp->flags &= ~SRB_DMA_VALID;
678
	}
679

680 681 682 683 684 685
	if (sp->flags & SRB_CRC_PROT_DMA_VALID) {
		dma_unmap_sg(&ha->pdev->dev, scsi_prot_sglist(cmd),
		    scsi_prot_sg_count(cmd), cmd->sc_data_direction);
		sp->flags &= ~SRB_CRC_PROT_DMA_VALID;
	}

686 687 688
	if (!ctx)
		goto end;

689 690
	if (sp->flags & SRB_CRC_CTX_DSD_VALID) {
		/* List assured to be having elements */
691
		qla2x00_clean_dsd_pool(ha, ctx);
692 693 694 695
		sp->flags &= ~SRB_CRC_CTX_DSD_VALID;
	}

	if (sp->flags & SRB_CRC_CTX_DMA_VALID) {
696 697 698
		struct crc_context *ctx0 = ctx;

		dma_pool_free(ha->dl_dma_pool, ctx0, ctx0->crc_ctx_dma);
699 700 701 702
		sp->flags &= ~SRB_CRC_CTX_DMA_VALID;
	}

	if (sp->flags & SRB_FCP_CMND_DMA_VALID) {
703
		struct ct6_dsd *ctx1 = ctx;
704

705
		dma_pool_free(ha->fcp_cmnd_dma_pool, ctx1->fcp_cmnd,
706
		    ctx1->fcp_cmnd_dma);
707 708 709 710 711 712
		list_splice(&ctx1->dsd_list, &ha->gbl_dsd_list);
		ha->gbl_dsd_inuse -= ctx1->dsd_use_cnt;
		ha->gbl_dsd_avail += ctx1->dsd_use_cnt;
		mempool_free(ctx1, ha->ctx_mempool);
	}

713
end:
714
	if (sp->type != SRB_NVME_CMD && sp->type != SRB_NVME_LS) {
715 716 717
		CMD_SP(cmd) = NULL;
		qla2x00_rel_sp(sp);
	}
718 719
}

720
void
721
qla2x00_sp_compl(void *ptr, int res)
722
{
723
	srb_t *sp = ptr;
724 725 726 727 728
	struct scsi_cmnd *cmd = GET_CMD_SP(sp);

	cmd->result = res;

	if (atomic_read(&sp->ref_count) == 0) {
729
		ql_dbg(ql_dbg_io, sp->vha, 0x3015,
730 731 732
		    "SP reference-count to ZERO -- sp=%p cmd=%p.\n",
		    sp, GET_CMD_SP(sp));
		if (ql2xextended_error_logging & ql_dbg_io)
733
			WARN_ON(atomic_read(&sp->ref_count) == 0);
734 735 736 737 738
		return;
	}
	if (!atomic_dec_and_test(&sp->ref_count))
		return;

739
	qla2x00_sp_free_dma(sp);
740
	cmd->scsi_done(cmd);
741 742
}

743
void
744
qla2xxx_qpair_sp_free_dma(void *ptr)
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
{
	srb_t *sp = (srb_t *)ptr;
	struct scsi_cmnd *cmd = GET_CMD_SP(sp);
	struct qla_hw_data *ha = sp->fcport->vha->hw;
	void *ctx = GET_CMD_CTX_SP(sp);

	if (sp->flags & SRB_DMA_VALID) {
		scsi_dma_unmap(cmd);
		sp->flags &= ~SRB_DMA_VALID;
	}

	if (sp->flags & SRB_CRC_PROT_DMA_VALID) {
		dma_unmap_sg(&ha->pdev->dev, scsi_prot_sglist(cmd),
		    scsi_prot_sg_count(cmd), cmd->sc_data_direction);
		sp->flags &= ~SRB_CRC_PROT_DMA_VALID;
	}

762 763 764
	if (!ctx)
		goto end;

765 766
	if (sp->flags & SRB_CRC_CTX_DSD_VALID) {
		/* List assured to be having elements */
767
		qla2x00_clean_dsd_pool(ha, ctx);
768 769 770 771
		sp->flags &= ~SRB_CRC_CTX_DSD_VALID;
	}

	if (sp->flags & SRB_CRC_CTX_DMA_VALID) {
772 773 774
		struct crc_context *ctx0 = ctx;

		dma_pool_free(ha->dl_dma_pool, ctx, ctx0->crc_ctx_dma);
775 776 777 778
		sp->flags &= ~SRB_CRC_CTX_DMA_VALID;
	}

	if (sp->flags & SRB_FCP_CMND_DMA_VALID) {
779
		struct ct6_dsd *ctx1 = ctx;
780 781 782 783 784 785 786
		dma_pool_free(ha->fcp_cmnd_dma_pool, ctx1->fcp_cmnd,
		    ctx1->fcp_cmnd_dma);
		list_splice(&ctx1->dsd_list, &ha->gbl_dsd_list);
		ha->gbl_dsd_inuse -= ctx1->dsd_use_cnt;
		ha->gbl_dsd_avail += ctx1->dsd_use_cnt;
		mempool_free(ctx1, ha->ctx_mempool);
	}
787
end:
788 789 790 791 792
	CMD_SP(cmd) = NULL;
	qla2xxx_rel_qpair_sp(sp->qpair, sp);
}

void
793
qla2xxx_qpair_sp_compl(void *ptr, int res)
794
{
795
	srb_t *sp = ptr;
796 797 798 799 800 801 802 803 804 805 806 807 808 809 810
	struct scsi_cmnd *cmd = GET_CMD_SP(sp);

	cmd->result = res;

	if (atomic_read(&sp->ref_count) == 0) {
		ql_dbg(ql_dbg_io, sp->fcport->vha, 0x3079,
		    "SP reference-count to ZERO -- sp=%p cmd=%p.\n",
		    sp, GET_CMD_SP(sp));
		if (ql2xextended_error_logging & ql_dbg_io)
			WARN_ON(atomic_read(&sp->ref_count) == 0);
		return;
	}
	if (!atomic_dec_and_test(&sp->ref_count))
		return;

811
	qla2xxx_qpair_sp_free_dma(sp);
812 813 814
	cmd->scsi_done(cmd);
}

815 816 817
/* If we are SP1 here, we need to still take and release the host_lock as SP1
 * does not have the changes necessary to avoid taking host->host_lock.
 */
L
Linus Torvalds 已提交
818
static int
819
qla2xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
820
{
821
	scsi_qla_host_t *vha = shost_priv(host);
822
	fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
823
	struct fc_rport *rport = starget_to_rport(scsi_target(cmd->device));
824 825
	struct qla_hw_data *ha = vha->hw;
	struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
826 827
	srb_t *sp;
	int rval;
828 829 830
	struct qla_qpair *qpair = NULL;
	uint32_t tag;
	uint16_t hwq;
831

832 833 834 835 836
	if (unlikely(test_bit(UNLOADING, &base_vha->dpc_flags))) {
		cmd->result = DID_NO_CONNECT << 16;
		goto qc24_fail_command;
	}

837 838 839 840 841 842 843 844 845 846 847
	if (ha->mqenable) {
		if (shost_use_blk_mq(vha->host)) {
			tag = blk_mq_unique_tag(cmd->request);
			hwq = blk_mq_unique_tag_to_hwq(tag);
			qpair = ha->queue_pair_map[hwq];
		} else if (vha->vp_idx && vha->qpair) {
			qpair = vha->qpair;
		}

		if (qpair)
			return qla2xxx_mqueuecommand(host, cmd, qpair);
848 849
	}

850
	if (ha->flags.eeh_busy) {
851
		if (ha->flags.pci_channel_io_perm_failure) {
852
			ql_dbg(ql_dbg_aer, vha, 0x9010,
853 854
			    "PCI Channel IO permanent failure, exiting "
			    "cmd=%p.\n", cmd);
855
			cmd->result = DID_NO_CONNECT << 16;
856
		} else {
857
			ql_dbg(ql_dbg_aer, vha, 0x9011,
858
			    "EEH_Busy, Requeuing the cmd=%p.\n", cmd);
859
			cmd->result = DID_REQUEUE << 16;
860
		}
861 862 863
		goto qc24_fail_command;
	}

864 865 866
	rval = fc_remote_port_chkready(rport);
	if (rval) {
		cmd->result = rval;
867
		ql_dbg(ql_dbg_io + ql_dbg_verbose, vha, 0x3003,
868 869
		    "fc_remote_port_chkready failed for cmd=%p, rval=0x%x.\n",
		    cmd, rval);
870 871 872
		goto qc24_fail_command;
	}

873 874
	if (!vha->flags.difdix_supported &&
		scsi_get_prot_op(cmd) != SCSI_PROT_NORMAL) {
875 876 877
			ql_dbg(ql_dbg_io, vha, 0x3004,
			    "DIF Cap not reg, fail DIF capable cmd's:%p.\n",
			    cmd);
878 879 880
			cmd->result = DID_NO_CONNECT << 16;
			goto qc24_fail_command;
	}
881 882 883 884 885 886

	if (!fcport) {
		cmd->result = DID_NO_CONNECT << 16;
		goto qc24_fail_command;
	}

887 888
	if (atomic_read(&fcport->state) != FCS_ONLINE) {
		if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD ||
889
			atomic_read(&base_vha->loop_state) == LOOP_DEAD) {
890 891 892 893
			ql_dbg(ql_dbg_io, vha, 0x3005,
			    "Returning DNC, fcport_state=%d loop_state=%d.\n",
			    atomic_read(&fcport->state),
			    atomic_read(&base_vha->loop_state));
894 895 896
			cmd->result = DID_NO_CONNECT << 16;
			goto qc24_fail_command;
		}
897
		goto qc24_target_busy;
898 899
	}

900 901 902 903
	/*
	 * Return target busy if we've received a non-zero retry_delay_timer
	 * in a FCP_RSP.
	 */
904 905 906
	if (fcport->retry_delay_timestamp == 0) {
		/* retry delay not set */
	} else if (time_after(jiffies, fcport->retry_delay_timestamp))
907 908 909 910
		fcport->retry_delay_timestamp = 0;
	else
		goto qc24_target_busy;

911
	sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
912
	if (!sp)
913
		goto qc24_host_busy;
914

915 916 917 918 919 920 921
	sp->u.scmd.cmd = cmd;
	sp->type = SRB_SCSI_CMD;
	atomic_set(&sp->ref_count, 1);
	CMD_SP(cmd) = (void *)sp;
	sp->free = qla2x00_sp_free_dma;
	sp->done = qla2x00_sp_compl;

922
	rval = ha->isp_ops->start_scsi(sp);
923
	if (rval != QLA_SUCCESS) {
924
		ql_dbg(ql_dbg_io + ql_dbg_verbose, vha, 0x3013,
925
		    "Start scsi failed rval=%d for cmd=%p.\n", rval, cmd);
926
		goto qc24_host_busy_free_sp;
927
	}
928 929 930 931

	return 0;

qc24_host_busy_free_sp:
932
	qla2x00_sp_free_dma(sp);
933

934
qc24_host_busy:
935 936
	return SCSI_MLQUEUE_HOST_BUSY;

937 938 939
qc24_target_busy:
	return SCSI_MLQUEUE_TARGET_BUSY;

940
qc24_fail_command:
941
	cmd->scsi_done(cmd);
942 943 944 945

	return 0;
}

946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020
/* For MQ supported I/O */
int
qla2xxx_mqueuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd,
    struct qla_qpair *qpair)
{
	scsi_qla_host_t *vha = shost_priv(host);
	fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
	struct fc_rport *rport = starget_to_rport(scsi_target(cmd->device));
	struct qla_hw_data *ha = vha->hw;
	struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
	srb_t *sp;
	int rval;

	rval = fc_remote_port_chkready(rport);
	if (rval) {
		cmd->result = rval;
		ql_dbg(ql_dbg_io + ql_dbg_verbose, vha, 0x3076,
		    "fc_remote_port_chkready failed for cmd=%p, rval=0x%x.\n",
		    cmd, rval);
		goto qc24_fail_command;
	}

	if (!fcport) {
		cmd->result = DID_NO_CONNECT << 16;
		goto qc24_fail_command;
	}

	if (atomic_read(&fcport->state) != FCS_ONLINE) {
		if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD ||
			atomic_read(&base_vha->loop_state) == LOOP_DEAD) {
			ql_dbg(ql_dbg_io, vha, 0x3077,
			    "Returning DNC, fcport_state=%d loop_state=%d.\n",
			    atomic_read(&fcport->state),
			    atomic_read(&base_vha->loop_state));
			cmd->result = DID_NO_CONNECT << 16;
			goto qc24_fail_command;
		}
		goto qc24_target_busy;
	}

	/*
	 * Return target busy if we've received a non-zero retry_delay_timer
	 * in a FCP_RSP.
	 */
	if (fcport->retry_delay_timestamp == 0) {
		/* retry delay not set */
	} else if (time_after(jiffies, fcport->retry_delay_timestamp))
		fcport->retry_delay_timestamp = 0;
	else
		goto qc24_target_busy;

	sp = qla2xxx_get_qpair_sp(qpair, fcport, GFP_ATOMIC);
	if (!sp)
		goto qc24_host_busy;

	sp->u.scmd.cmd = cmd;
	sp->type = SRB_SCSI_CMD;
	atomic_set(&sp->ref_count, 1);
	CMD_SP(cmd) = (void *)sp;
	sp->free = qla2xxx_qpair_sp_free_dma;
	sp->done = qla2xxx_qpair_sp_compl;
	sp->qpair = qpair;

	rval = ha->isp_ops->start_scsi_mq(sp);
	if (rval != QLA_SUCCESS) {
		ql_dbg(ql_dbg_io + ql_dbg_verbose, vha, 0x3078,
		    "Start scsi failed rval=%d for cmd=%p.\n", rval, cmd);
		if (rval == QLA_INTERFACE_ERROR)
			goto qc24_fail_command;
		goto qc24_host_busy_free_sp;
	}

	return 0;

qc24_host_busy_free_sp:
1021
	qla2xxx_qpair_sp_free_dma(sp);
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034

qc24_host_busy:
	return SCSI_MLQUEUE_HOST_BUSY;

qc24_target_busy:
	return SCSI_MLQUEUE_TARGET_BUSY;

qc24_fail_command:
	cmd->scsi_done(cmd);

	return 0;
}

L
Linus Torvalds 已提交
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
/*
 * qla2x00_eh_wait_on_command
 *    Waits for the command to be returned by the Firmware for some
 *    max time.
 *
 * Input:
 *    cmd = Scsi Command to wait on.
 *
 * Return:
 *    Not Found : 0
 *    Found : 1
 */
static int
1048
qla2x00_eh_wait_on_command(struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
1049
{
1050
#define ABORT_POLLING_PERIOD	1000
1051
#define ABORT_WAIT_ITER		((2 * 1000) / (ABORT_POLLING_PERIOD))
已提交
1052
	unsigned long wait_iter = ABORT_WAIT_ITER;
1053 1054
	scsi_qla_host_t *vha = shost_priv(cmd->device->host);
	struct qla_hw_data *ha = vha->hw;
已提交
1055
	int ret = QLA_SUCCESS;
L
Linus Torvalds 已提交
1056

1057
	if (unlikely(pci_channel_offline(ha->pdev)) || ha->flags.eeh_busy) {
1058 1059
		ql_dbg(ql_dbg_taskm, vha, 0x8005,
		    "Return:eh_wait.\n");
1060 1061 1062
		return ret;
	}

1063
	while (CMD_SP(cmd) && wait_iter--) {
1064
		msleep(ABORT_POLLING_PERIOD);
已提交
1065 1066 1067
	}
	if (CMD_SP(cmd))
		ret = QLA_FUNCTION_FAILED;
L
Linus Torvalds 已提交
1068

已提交
1069
	return ret;
L
Linus Torvalds 已提交
1070 1071 1072 1073
}

/*
 * qla2x00_wait_for_hba_online
A
Andrew Vasquez 已提交
1074
 *    Wait till the HBA is online after going through
L
Linus Torvalds 已提交
1075 1076 1077 1078 1079
 *    <= MAX_RETRIES_OF_ISP_ABORT  or
 *    finally HBA is disabled ie marked offline
 *
 * Input:
 *     ha - pointer to host adapter structure
A
Andrew Vasquez 已提交
1080 1081
 *
 * Note:
L
Linus Torvalds 已提交
1082 1083 1084 1085 1086 1087 1088
 *    Does context switching-Release SPIN_LOCK
 *    (if any) before calling this routine.
 *
 * Return:
 *    Success (Adapter is online) : 0
 *    Failed  (Adapter is offline/disabled) : 1
 */
1089
int
1090
qla2x00_wait_for_hba_online(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
1091
{
1092 1093
	int		return_status;
	unsigned long	wait_online;
1094 1095
	struct qla_hw_data *ha = vha->hw;
	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
L
Linus Torvalds 已提交
1096

A
Andrew Vasquez 已提交
1097
	wait_online = jiffies + (MAX_LOOP_TIMEOUT * HZ);
1098 1099 1100 1101
	while (((test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags)) ||
	    test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) ||
	    test_bit(ISP_ABORT_RETRY, &base_vha->dpc_flags) ||
	    ha->dpc_active) && time_before(jiffies, wait_online)) {
L
Linus Torvalds 已提交
1102 1103 1104

		msleep(1000);
	}
1105
	if (base_vha->flags.online)
A
Andrew Vasquez 已提交
1106
		return_status = QLA_SUCCESS;
L
Linus Torvalds 已提交
1107 1108 1109 1110 1111 1112
	else
		return_status = QLA_FUNCTION_FAILED;

	return (return_status);
}

1113 1114 1115 1116 1117 1118 1119
static inline int test_fcport_count(scsi_qla_host_t *vha)
{
	struct qla_hw_data *ha = vha->hw;
	unsigned long flags;
	int res;

	spin_lock_irqsave(&ha->tgt.sess_lock, flags);
1120 1121 1122
	ql_dbg(ql_dbg_init, vha, 0x00ec,
	    "tgt %p, fcport_count=%d\n",
	    vha, vha->fcport_count);
1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140
	res = (vha->fcport_count == 0);
	spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);

	return res;
}

/*
 * qla2x00_wait_for_sess_deletion can only be called from remove_one.
 * it has dependency on UNLOADING flag to stop device discovery
 */
static void
qla2x00_wait_for_sess_deletion(scsi_qla_host_t *vha)
{
	qla2x00_mark_all_devices_lost(vha, 0);

	wait_event(vha->fcport_waitQ, test_fcport_count(vha));
}

1141
/*
1142 1143
 * qla2x00_wait_for_hba_ready
 * Wait till the HBA is ready before doing driver unload
1144 1145 1146 1147 1148 1149 1150 1151 1152
 *
 * Input:
 *     ha - pointer to host adapter structure
 *
 * Note:
 *    Does context switching-Release SPIN_LOCK
 *    (if any) before calling this routine.
 *
 */
1153 1154
static void
qla2x00_wait_for_hba_ready(scsi_qla_host_t *vha)
1155 1156
{
	struct qla_hw_data *ha = vha->hw;
1157
	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
1158

1159 1160 1161 1162 1163 1164
	while ((qla2x00_reset_active(vha) || ha->dpc_active ||
		ha->flags.mbox_busy) ||
	       test_bit(FX00_RESET_RECOVERY, &vha->dpc_flags) ||
	       test_bit(FX00_TARGET_SCAN, &vha->dpc_flags)) {
		if (test_bit(UNLOADING, &base_vha->dpc_flags))
			break;
1165
		msleep(1000);
1166
	}
1167 1168
}

1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
int
qla2x00_wait_for_chip_reset(scsi_qla_host_t *vha)
{
	int		return_status;
	unsigned long	wait_reset;
	struct qla_hw_data *ha = vha->hw;
	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);

	wait_reset = jiffies + (MAX_LOOP_TIMEOUT * HZ);
	while (((test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags)) ||
	    test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) ||
	    test_bit(ISP_ABORT_RETRY, &base_vha->dpc_flags) ||
	    ha->dpc_active) && time_before(jiffies, wait_reset)) {

		msleep(1000);

		if (!test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags) &&
		    ha->flags.chip_reset_done)
			break;
	}
	if (ha->flags.chip_reset_done)
		return_status = QLA_SUCCESS;
	else
		return_status = QLA_FUNCTION_FAILED;

	return return_status;
}

1197 1198 1199 1200 1201 1202
static void
sp_get(struct srb *sp)
{
	atomic_inc(&sp->ref_count);
}

1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222
#define ISP_REG_DISCONNECT 0xffffffffU
/**************************************************************************
* qla2x00_isp_reg_stat
*
* Description:
*	Read the host status register of ISP before aborting the command.
*
* Input:
*	ha = pointer to host adapter structure.
*
*
* Returns:
*	Either true or false.
*
* Note:	Return true if there is register disconnect.
**************************************************************************/
static inline
uint32_t qla2x00_isp_reg_stat(struct qla_hw_data *ha)
{
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1223
	struct device_reg_82xx __iomem *reg82 = &ha->iobase->isp82;
1224

1225 1226 1227 1228 1229
	if (IS_P3P_TYPE(ha))
		return ((RD_REG_DWORD(&reg82->host_int)) == ISP_REG_DISCONNECT);
	else
		return ((RD_REG_DWORD(&reg->host_status)) ==
			ISP_REG_DISCONNECT);
1230 1231
}

L
Linus Torvalds 已提交
1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244
/**************************************************************************
* qla2xxx_eh_abort
*
* Description:
*    The abort function will abort the specified command.
*
* Input:
*    cmd = Linux SCSI command packet to be aborted.
*
* Returns:
*    Either SUCCESS or FAILED.
*
* Note:
1245
*    Only return FAILED if command not returned by firmware.
L
Linus Torvalds 已提交
1246
**************************************************************************/
1247
static int
L
Linus Torvalds 已提交
1248 1249
qla2xxx_eh_abort(struct scsi_cmnd *cmd)
{
1250
	scsi_qla_host_t *vha = shost_priv(cmd->device->host);
已提交
1251
	srb_t *sp;
1252
	int ret;
H
Hannes Reinecke 已提交
1253 1254
	unsigned int id;
	uint64_t lun;
1255
	unsigned long flags;
1256
	int rval, wait = 0;
1257
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
1258

1259 1260 1261 1262 1263
	if (qla2x00_isp_reg_stat(ha)) {
		ql_log(ql_log_info, vha, 0x8042,
		    "PCI/Register disconnect, exiting.\n");
		return FAILED;
	}
已提交
1264
	if (!CMD_SP(cmd))
1265
		return SUCCESS;
L
Linus Torvalds 已提交
1266

1267 1268 1269 1270 1271
	ret = fc_block_scsi_eh(cmd);
	if (ret != 0)
		return ret;
	ret = SUCCESS;

已提交
1272 1273
	id = cmd->device->id;
	lun = cmd->device->lun;
L
Linus Torvalds 已提交
1274

1275
	spin_lock_irqsave(&ha->hardware_lock, flags);
1276 1277 1278 1279 1280
	sp = (srb_t *) CMD_SP(cmd);
	if (!sp) {
		spin_unlock_irqrestore(&ha->hardware_lock, flags);
		return SUCCESS;
	}
L
Linus Torvalds 已提交
1281

1282
	ql_dbg(ql_dbg_taskm, vha, 0x8002,
1283 1284
	    "Aborting from RISC nexus=%ld:%d:%llu sp=%p cmd=%p handle=%x\n",
	    vha->host_no, id, lun, sp, cmd, sp->handle);
1285

1286 1287
	/* Get a reference to the sp and drop the lock.*/
	sp_get(sp);
1288

1289
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
1290 1291
	rval = ha->isp_ops->abort_command(sp);
	if (rval) {
1292
		if (rval == QLA_FUNCTION_PARAMETER_ERROR)
1293
			ret = SUCCESS;
1294
		else
1295 1296
			ret = FAILED;

1297
		ql_dbg(ql_dbg_taskm, vha, 0x8003,
1298
		    "Abort command mbx failed cmd=%p, rval=%x.\n", cmd, rval);
1299
	} else {
1300
		ql_dbg(ql_dbg_taskm, vha, 0x8004,
1301
		    "Abort command mbx success cmd=%p.\n", cmd);
1302 1303
		wait = 1;
	}
1304 1305

	spin_lock_irqsave(&ha->hardware_lock, flags);
1306
	sp->done(sp, 0);
1307
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
L
Linus Torvalds 已提交
1308

1309 1310 1311 1312
	/* Did the command return during mailbox execution? */
	if (ret == FAILED && !CMD_SP(cmd))
		ret = SUCCESS;

已提交
1313
	/* Wait for the command to be returned. */
1314
	if (wait) {
1315
		if (qla2x00_eh_wait_on_command(cmd) != QLA_SUCCESS) {
1316
			ql_log(ql_log_warn, vha, 0x8006,
1317
			    "Abort handler timed out cmd=%p.\n", cmd);
1318
			ret = FAILED;
已提交
1319
		}
L
Linus Torvalds 已提交
1320 1321
	}

1322
	ql_log(ql_log_info, vha, 0x801c,
H
Hannes Reinecke 已提交
1323
	    "Abort command issued nexus=%ld:%d:%llu --  %d %x.\n",
1324
	    vha->host_no, id, lun, wait, ret);
L
Linus Torvalds 已提交
1325

已提交
1326 1327
	return ret;
}
L
Linus Torvalds 已提交
1328

1329
int
1330
qla2x00_eh_wait_for_pending_commands(scsi_qla_host_t *vha, unsigned int t,
H
Hannes Reinecke 已提交
1331
	uint64_t l, enum nexus_wait_type type)
已提交
1332
{
1333
	int cnt, match, status;
1334
	unsigned long flags;
1335
	struct qla_hw_data *ha = vha->hw;
1336
	struct req_que *req;
1337
	srb_t *sp;
1338
	struct scsi_cmnd *cmd;
L
Linus Torvalds 已提交
1339

1340
	status = QLA_SUCCESS;
1341

1342
	spin_lock_irqsave(&ha->hardware_lock, flags);
1343
	req = vha->req;
1344
	for (cnt = 1; status == QLA_SUCCESS &&
1345
		cnt < req->num_outstanding_cmds; cnt++) {
1346 1347
		sp = req->outstanding_cmds[cnt];
		if (!sp)
1348
			continue;
1349
		if (sp->type != SRB_SCSI_CMD)
1350
			continue;
1351
		if (vha->vp_idx != sp->vha->vp_idx)
1352 1353
			continue;
		match = 0;
1354
		cmd = GET_CMD_SP(sp);
1355 1356 1357 1358 1359
		switch (type) {
		case WAIT_HOST:
			match = 1;
			break;
		case WAIT_TARGET:
1360
			match = cmd->device->id == t;
1361 1362
			break;
		case WAIT_LUN:
1363 1364
			match = (cmd->device->id == t &&
				cmd->device->lun == l);
1365
			break;
1366
		}
1367 1368 1369 1370
		if (!match)
			continue;

		spin_unlock_irqrestore(&ha->hardware_lock, flags);
1371
		status = qla2x00_eh_wait_on_command(cmd);
1372
		spin_lock_irqsave(&ha->hardware_lock, flags);
L
Linus Torvalds 已提交
1373
	}
1374
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
1375 1376

	return status;
L
Linus Torvalds 已提交
1377 1378
}

1379 1380 1381 1382 1383 1384
static char *reset_errors[] = {
	"HBA not online",
	"HBA not ready",
	"Task management failed",
	"Waiting for command completions",
};
L
Linus Torvalds 已提交
1385

1386
static int
1387
__qla2xxx_eh_generic_reset(char *name, enum nexus_wait_type type,
H
Hannes Reinecke 已提交
1388
    struct scsi_cmnd *cmd, int (*do_reset)(struct fc_port *, uint64_t, int))
L
Linus Torvalds 已提交
1389
{
1390
	scsi_qla_host_t *vha = shost_priv(cmd->device->host);
1391
	fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
1392
	int err;
L
Linus Torvalds 已提交
1393

1394
	if (!fcport) {
1395
		return FAILED;
1396
	}
L
Linus Torvalds 已提交
1397

1398 1399 1400 1401
	err = fc_block_scsi_eh(cmd);
	if (err != 0)
		return err;

1402
	ql_log(ql_log_info, vha, 0x8009,
H
Hannes Reinecke 已提交
1403
	    "%s RESET ISSUED nexus=%ld:%d:%llu cmd=%p.\n", name, vha->host_no,
1404
	    cmd->device->id, cmd->device->lun, cmd);
L
Linus Torvalds 已提交
1405

1406
	err = 0;
1407 1408 1409
	if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
		ql_log(ql_log_warn, vha, 0x800a,
		    "Wait for hba online failed for cmd=%p.\n", cmd);
1410
		goto eh_reset_failed;
1411
	}
1412
	err = 2;
1413
	if (do_reset(fcport, cmd->device->lun, cmd->request->cpu + 1)
1414 1415 1416
		!= QLA_SUCCESS) {
		ql_log(ql_log_warn, vha, 0x800c,
		    "do_reset failed for cmd=%p.\n", cmd);
1417
		goto eh_reset_failed;
1418
	}
1419
	err = 3;
1420
	if (qla2x00_eh_wait_for_pending_commands(vha, cmd->device->id,
1421 1422
	    cmd->device->lun, type) != QLA_SUCCESS) {
		ql_log(ql_log_warn, vha, 0x800d,
1423
		    "wait for pending cmds failed for cmd=%p.\n", cmd);
1424
		goto eh_reset_failed;
1425
	}
1426

1427
	ql_log(ql_log_info, vha, 0x800e,
H
Hannes Reinecke 已提交
1428
	    "%s RESET SUCCEEDED nexus:%ld:%d:%llu cmd=%p.\n", name,
1429
	    vha->host_no, cmd->device->id, cmd->device->lun, cmd);
1430 1431 1432

	return SUCCESS;

1433
eh_reset_failed:
1434
	ql_log(ql_log_info, vha, 0x800f,
H
Hannes Reinecke 已提交
1435
	    "%s RESET FAILED: %s nexus=%ld:%d:%llu cmd=%p.\n", name,
1436 1437
	    reset_errors[err], vha->host_no, cmd->device->id, cmd->device->lun,
	    cmd);
1438 1439
	return FAILED;
}
L
Linus Torvalds 已提交
1440

1441 1442 1443
static int
qla2xxx_eh_device_reset(struct scsi_cmnd *cmd)
{
1444 1445
	scsi_qla_host_t *vha = shost_priv(cmd->device->host);
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
1446

1447 1448 1449 1450 1451 1452
	if (qla2x00_isp_reg_stat(ha)) {
		ql_log(ql_log_info, vha, 0x803e,
		    "PCI/Register disconnect, exiting.\n");
		return FAILED;
	}

1453 1454
	return __qla2xxx_eh_generic_reset("DEVICE", WAIT_LUN, cmd,
	    ha->isp_ops->lun_reset);
L
Linus Torvalds 已提交
1455 1456 1457
}

static int
1458
qla2xxx_eh_target_reset(struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
1459
{
1460 1461
	scsi_qla_host_t *vha = shost_priv(cmd->device->host);
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
1462

1463 1464 1465 1466 1467 1468
	if (qla2x00_isp_reg_stat(ha)) {
		ql_log(ql_log_info, vha, 0x803f,
		    "PCI/Register disconnect, exiting.\n");
		return FAILED;
	}

1469 1470
	return __qla2xxx_eh_generic_reset("TARGET", WAIT_TARGET, cmd,
	    ha->isp_ops->target_reset);
L
Linus Torvalds 已提交
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487
}

/**************************************************************************
* qla2xxx_eh_bus_reset
*
* Description:
*    The bus reset function will reset the bus and abort any executing
*    commands.
*
* Input:
*    cmd = Linux SCSI command packet of the command that cause the
*          bus reset.
*
* Returns:
*    SUCCESS/FAILURE (defined as macro in scsi.h).
*
**************************************************************************/
1488
static int
L
Linus Torvalds 已提交
1489 1490
qla2xxx_eh_bus_reset(struct scsi_cmnd *cmd)
{
1491
	scsi_qla_host_t *vha = shost_priv(cmd->device->host);
1492
	fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
1493
	int ret = FAILED;
H
Hannes Reinecke 已提交
1494 1495
	unsigned int id;
	uint64_t lun;
1496 1497 1498 1499 1500 1501 1502
	struct qla_hw_data *ha = vha->hw;

	if (qla2x00_isp_reg_stat(ha)) {
		ql_log(ql_log_info, vha, 0x8040,
		    "PCI/Register disconnect, exiting.\n");
		return FAILED;
	}
已提交
1503 1504 1505

	id = cmd->device->id;
	lun = cmd->device->lun;
L
Linus Torvalds 已提交
1506

1507
	if (!fcport) {
已提交
1508
		return ret;
1509
	}
L
Linus Torvalds 已提交
1510

1511 1512 1513 1514 1515
	ret = fc_block_scsi_eh(cmd);
	if (ret != 0)
		return ret;
	ret = FAILED;

1516
	ql_log(ql_log_info, vha, 0x8012,
H
Hannes Reinecke 已提交
1517
	    "BUS RESET ISSUED nexus=%ld:%d:%llu.\n", vha->host_no, id, lun);
L
Linus Torvalds 已提交
1518

1519
	if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
1520 1521
		ql_log(ql_log_fatal, vha, 0x8013,
		    "Wait for hba online failed board disabled.\n");
已提交
1522
		goto eh_bus_reset_done;
L
Linus Torvalds 已提交
1523 1524
	}

1525 1526 1527
	if (qla2x00_loop_reset(vha) == QLA_SUCCESS)
		ret = SUCCESS;

已提交
1528 1529
	if (ret == FAILED)
		goto eh_bus_reset_done;
L
Linus Torvalds 已提交
1530

1531
	/* Flush outstanding commands. */
1532
	if (qla2x00_eh_wait_for_pending_commands(vha, 0, 0, WAIT_HOST) !=
1533 1534 1535
	    QLA_SUCCESS) {
		ql_log(ql_log_warn, vha, 0x8014,
		    "Wait for pending commands failed.\n");
1536
		ret = FAILED;
1537
	}
L
Linus Torvalds 已提交
1538

已提交
1539
eh_bus_reset_done:
1540
	ql_log(ql_log_warn, vha, 0x802b,
H
Hannes Reinecke 已提交
1541
	    "BUS RESET %s nexus=%ld:%d:%llu.\n",
1542
	    (ret == FAILED) ? "FAILED" : "SUCCEEDED", vha->host_no, id, lun);
L
Linus Torvalds 已提交
1543

已提交
1544
	return ret;
L
Linus Torvalds 已提交
1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561
}

/**************************************************************************
* qla2xxx_eh_host_reset
*
* Description:
*    The reset function will reset the Adapter.
*
* Input:
*      cmd = Linux SCSI command packet of the command that cause the
*            adapter reset.
*
* Returns:
*      Either SUCCESS or FAILED.
*
* Note:
**************************************************************************/
1562
static int
L
Linus Torvalds 已提交
1563 1564
qla2xxx_eh_host_reset(struct scsi_cmnd *cmd)
{
1565 1566
	scsi_qla_host_t *vha = shost_priv(cmd->device->host);
	struct qla_hw_data *ha = vha->hw;
1567
	int ret = FAILED;
H
Hannes Reinecke 已提交
1568 1569
	unsigned int id;
	uint64_t lun;
1570
	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
L
Linus Torvalds 已提交
1571

1572 1573 1574 1575 1576 1577 1578
	if (qla2x00_isp_reg_stat(ha)) {
		ql_log(ql_log_info, vha, 0x8041,
		    "PCI/Register disconnect, exiting.\n");
		schedule_work(&ha->board_disable);
		return SUCCESS;
	}

已提交
1579 1580 1581
	id = cmd->device->id;
	lun = cmd->device->lun;

1582
	ql_log(ql_log_info, vha, 0x8018,
H
Hannes Reinecke 已提交
1583
	    "ADAPTER RESET ISSUED nexus=%ld:%d:%llu.\n", vha->host_no, id, lun);
L
Linus Torvalds 已提交
1584

1585 1586 1587 1588 1589
	/*
	 * No point in issuing another reset if one is active.  Also do not
	 * attempt a reset if we are updating flash.
	 */
	if (qla2x00_reset_active(vha) || ha->optrom_state != QLA_SWAITING)
已提交
1590
		goto eh_host_reset_lock;
L
Linus Torvalds 已提交
1591

1592 1593
	if (vha != base_vha) {
		if (qla2x00_vp_abort_isp(vha))
已提交
1594
			goto eh_host_reset_lock;
1595
	} else {
1596
		if (IS_P3P_TYPE(vha->hw)) {
1597 1598 1599 1600 1601 1602 1603
			if (!qla82xx_fcoe_ctx_reset(vha)) {
				/* Ctx reset success */
				ret = SUCCESS;
				goto eh_host_reset_lock;
			}
			/* fall thru if ctx reset failed */
		}
1604 1605 1606
		if (ha->wq)
			flush_workqueue(ha->wq);

1607
		set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
1608
		if (ha->isp_ops->abort_isp(base_vha)) {
1609 1610 1611 1612
			clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
			/* failed. schedule dpc to try */
			set_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags);

1613 1614 1615
			if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
				ql_log(ql_log_warn, vha, 0x802a,
				    "wait for hba online failed.\n");
1616
				goto eh_host_reset_lock;
1617
			}
1618 1619
		}
		clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
A
Andrew Vasquez 已提交
1620
	}
L
Linus Torvalds 已提交
1621

1622
	/* Waiting for command to be returned to OS.*/
1623
	if (qla2x00_eh_wait_for_pending_commands(vha, 0, 0, WAIT_HOST) ==
1624
		QLA_SUCCESS)
已提交
1625
		ret = SUCCESS;
L
Linus Torvalds 已提交
1626

已提交
1627
eh_host_reset_lock:
1628
	ql_log(ql_log_info, vha, 0x8017,
H
Hannes Reinecke 已提交
1629
	    "ADAPTER RESET %s nexus=%ld:%d:%llu.\n",
1630
	    (ret == FAILED) ? "FAILED" : "SUCCEEDED", vha->host_no, id, lun);
L
Linus Torvalds 已提交
1631

已提交
1632 1633
	return ret;
}
L
Linus Torvalds 已提交
1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644

/*
* qla2x00_loop_reset
*      Issue loop reset.
*
* Input:
*      ha = adapter block pointer.
*
* Returns:
*      0 = success
*/
1645
int
1646
qla2x00_loop_reset(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
1647
{
1648
	int ret;
1649
	struct fc_port *fcport;
1650
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
1651

1652 1653 1654 1655
	if (IS_QLAFX00(ha)) {
		return qlafx00_loop_reset(vha);
	}

1656
	if (ql2xtargetreset == 1 && ha->flags.enable_target_reset) {
1657 1658 1659 1660 1661 1662
		list_for_each_entry(fcport, &vha->vp_fcports, list) {
			if (fcport->port_type != FCT_TARGET)
				continue;

			ret = ha->isp_ops->target_reset(fcport, 0, 0);
			if (ret != QLA_SUCCESS) {
1663
				ql_dbg(ql_dbg_taskm, vha, 0x802c,
1664
				    "Bus Reset failed: Reset=%d "
1665
				    "d_id=%x.\n", ret, fcport->d_id.b24);
1666 1667 1668 1669
			}
		}
	}

1670

1671
	if (ha->flags.enable_lip_full_login && !IS_CNA_CAPABLE(ha)) {
1672 1673 1674
		atomic_set(&vha->loop_state, LOOP_DOWN);
		atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
		qla2x00_mark_all_devices_lost(vha, 0);
1675
		ret = qla2x00_full_login_lip(vha);
1676
		if (ret != QLA_SUCCESS) {
1677 1678
			ql_dbg(ql_dbg_taskm, vha, 0x802d,
			    "full_login_lip=%d.\n", ret);
1679
		}
1680 1681
	}

1682
	if (ha->flags.enable_lip_reset) {
1683
		ret = qla2x00_lip_reset(vha);
1684
		if (ret != QLA_SUCCESS)
1685 1686
			ql_dbg(ql_dbg_taskm, vha, 0x802e,
			    "lip_reset failed (%d).\n", ret);
L
Linus Torvalds 已提交
1687 1688 1689
	}

	/* Issue marker command only when we are going to start the I/O */
1690
	vha->marker_needed = 1;
L
Linus Torvalds 已提交
1691

1692
	return QLA_SUCCESS;
L
Linus Torvalds 已提交
1693 1694
}

1695
void
1696
qla2x00_abort_all_cmds(scsi_qla_host_t *vha, int res)
1697
{
1698
	int que, cnt, status;
1699 1700
	unsigned long flags;
	srb_t *sp;
1701
	struct qla_hw_data *ha = vha->hw;
1702
	struct req_que *req;
1703 1704 1705
	struct qla_tgt *tgt = vha->vha_tgt.qla_tgt;
	struct qla_tgt_cmd *cmd;
	uint8_t trace = 0;
1706

1707
	spin_lock_irqsave(&ha->hardware_lock, flags);
1708
	for (que = 0; que < ha->max_req_queues; que++) {
1709
		req = ha->req_q_map[que];
1710 1711
		if (!req)
			continue;
1712 1713 1714
		if (!req->outstanding_cmds)
			continue;
		for (cnt = 1; cnt < req->num_outstanding_cmds; cnt++) {
1715
			sp = req->outstanding_cmds[cnt];
1716
			if (sp) {
1717 1718
				req->outstanding_cmds[cnt] = NULL;
				if (sp->cmd_type == TYPE_SRB) {
1719 1720
					if (sp->type == SRB_NVME_CMD ||
					    sp->type == SRB_NVME_LS) {
1721 1722 1723 1724 1725 1726 1727
						sp_get(sp);
						spin_unlock_irqrestore(
						    &ha->hardware_lock, flags);
						qla_nvme_abort(ha, sp);
						spin_lock_irqsave(
						    &ha->hardware_lock, flags);
					} else if (GET_CMD_SP(sp) &&
1728 1729 1730
					    !ha->flags.eeh_busy &&
					    (sp->type == SRB_SCSI_CMD)) {
						/*
1731 1732 1733 1734 1735
						 * Don't abort commands in
						 * adapter during EEH
						 * recovery as it's not
						 * accessible/responding.
						 *
1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774
						 * Get a reference to the sp
						 * and drop the lock. The
						 * reference ensures this
						 * sp->done() call and not the
						 * call in qla2xxx_eh_abort()
						 * ends the SCSI command (with
						 * result 'res').
						 */
						sp_get(sp);
						spin_unlock_irqrestore(
						    &ha->hardware_lock, flags);
						status = qla2xxx_eh_abort(
						    GET_CMD_SP(sp));
						spin_lock_irqsave(
						    &ha->hardware_lock, flags);
						/*
						 * Get rid of extra reference
						 * if immediate exit from
						 * ql2xxx_eh_abort
						 */
						if (status == FAILED &&
						    (qla2x00_isp_reg_stat(ha)))
							atomic_dec(
							    &sp->ref_count);
					}
					sp->done(sp, res);
				} else {
					if (!vha->hw->tgt.tgt_ops || !tgt ||
					    qla_ini_mode_enabled(vha)) {
						if (!trace)
							ql_dbg(ql_dbg_tgt_mgt,
							    vha, 0xf003,
							    "HOST-ABORT-HNDLR: dpc_flags=%lx. Target mode disabled\n",
							    vha->dpc_flags);
						continue;
					}
					cmd = (struct qla_tgt_cmd *)sp;
					qlt_abort_cmd_on_host_reset(cmd->vha,
					    cmd);
1775
				}
1776
			}
1777 1778 1779 1780 1781
		}
	}
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
}

已提交
1782 1783
static int
qla2xxx_slave_alloc(struct scsi_device *sdev)
L
Linus Torvalds 已提交
1784
{
1785
	struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
L
Linus Torvalds 已提交
1786

1787
	if (!rport || fc_remote_port_chkready(rport))
已提交
1788
		return -ENXIO;
1789

1790
	sdev->hostdata = *(fc_port_t **)rport->dd_data;
L
Linus Torvalds 已提交
1791

已提交
1792 1793
	return 0;
}
L
Linus Torvalds 已提交
1794

已提交
1795 1796 1797
static int
qla2xxx_slave_configure(struct scsi_device *sdev)
{
1798
	scsi_qla_host_t *vha = shost_priv(sdev->host);
1799
	struct req_que *req = vha->req;
已提交
1800

1801 1802 1803
	if (IS_T10_PI_CAPABLE(vha->hw))
		blk_queue_update_dma_alignment(sdev->request_queue, 0x7);

1804
	scsi_change_queue_depth(sdev, req->max_q_depth);
已提交
1805 1806
	return 0;
}
L
Linus Torvalds 已提交
1807

已提交
1808 1809 1810 1811
static void
qla2xxx_slave_destroy(struct scsi_device *sdev)
{
	sdev->hostdata = NULL;
L
Linus Torvalds 已提交
1812 1813 1814 1815 1816 1817 1818 1819 1820 1821
}

/**
 * qla2x00_config_dma_addressing() - Configure OS DMA addressing method.
 * @ha: HA context
 *
 * At exit, the @ha's flags.enable_64bit_addressing set to indicated
 * supported addressing method.
 */
static void
1822
qla2x00_config_dma_addressing(struct qla_hw_data *ha)
L
Linus Torvalds 已提交
1823
{
1824
	/* Assume a 32bit DMA mask. */
L
Linus Torvalds 已提交
1825 1826
	ha->flags.enable_64bit_addressing = 0;

1827
	if (!dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(64))) {
1828 1829
		/* Any upper-dword bits set? */
		if (MSD(dma_get_required_mask(&ha->pdev->dev)) &&
1830
		    !pci_set_consistent_dma_mask(ha->pdev, DMA_BIT_MASK(64))) {
1831
			/* Ok, a 64bit DMA mask is applicable. */
L
Linus Torvalds 已提交
1832
			ha->flags.enable_64bit_addressing = 1;
1833 1834
			ha->isp_ops->calc_req_entries = qla2x00_calc_iocbs_64;
			ha->isp_ops->build_iocbs = qla2x00_build_scsi_iocbs_64;
1835
			return;
L
Linus Torvalds 已提交
1836 1837
		}
	}
1838

1839 1840
	dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32));
	pci_set_consistent_dma_mask(ha->pdev, DMA_BIT_MASK(32));
L
Linus Torvalds 已提交
1841 1842
}

1843
static void
1844
qla2x00_enable_intrs(struct qla_hw_data *ha)
1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858
{
	unsigned long flags = 0;
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;

	spin_lock_irqsave(&ha->hardware_lock, flags);
	ha->interrupts_on = 1;
	/* enable risc and host interrupts */
	WRT_REG_WORD(&reg->ictrl, ICR_EN_INT | ICR_EN_RISC);
	RD_REG_WORD(&reg->ictrl);
	spin_unlock_irqrestore(&ha->hardware_lock, flags);

}

static void
1859
qla2x00_disable_intrs(struct qla_hw_data *ha)
1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872
{
	unsigned long flags = 0;
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;

	spin_lock_irqsave(&ha->hardware_lock, flags);
	ha->interrupts_on = 0;
	/* disable risc and host interrupts */
	WRT_REG_WORD(&reg->ictrl, 0);
	RD_REG_WORD(&reg->ictrl);
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
}

static void
1873
qla24xx_enable_intrs(struct qla_hw_data *ha)
1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885
{
	unsigned long flags = 0;
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

	spin_lock_irqsave(&ha->hardware_lock, flags);
	ha->interrupts_on = 1;
	WRT_REG_DWORD(&reg->ictrl, ICRX_EN_RISC_INT);
	RD_REG_DWORD(&reg->ictrl);
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
}

static void
1886
qla24xx_disable_intrs(struct qla_hw_data *ha)
1887 1888 1889 1890
{
	unsigned long flags = 0;
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

1891 1892
	if (IS_NOPOLLING_TYPE(ha))
		return;
1893 1894 1895 1896 1897 1898 1899
	spin_lock_irqsave(&ha->hardware_lock, flags);
	ha->interrupts_on = 0;
	WRT_REG_DWORD(&reg->ictrl, 0);
	RD_REG_DWORD(&reg->ictrl);
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
}

1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960
static int
qla2x00_iospace_config(struct qla_hw_data *ha)
{
	resource_size_t pio;
	uint16_t msix;

	if (pci_request_selected_regions(ha->pdev, ha->bars,
	    QLA2XXX_DRIVER_NAME)) {
		ql_log_pci(ql_log_fatal, ha->pdev, 0x0011,
		    "Failed to reserve PIO/MMIO regions (%s), aborting.\n",
		    pci_name(ha->pdev));
		goto iospace_error_exit;
	}
	if (!(ha->bars & 1))
		goto skip_pio;

	/* We only need PIO for Flash operations on ISP2312 v2 chips. */
	pio = pci_resource_start(ha->pdev, 0);
	if (pci_resource_flags(ha->pdev, 0) & IORESOURCE_IO) {
		if (pci_resource_len(ha->pdev, 0) < MIN_IOBASE_LEN) {
			ql_log_pci(ql_log_warn, ha->pdev, 0x0012,
			    "Invalid pci I/O region size (%s).\n",
			    pci_name(ha->pdev));
			pio = 0;
		}
	} else {
		ql_log_pci(ql_log_warn, ha->pdev, 0x0013,
		    "Region #0 no a PIO resource (%s).\n",
		    pci_name(ha->pdev));
		pio = 0;
	}
	ha->pio_address = pio;
	ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0014,
	    "PIO address=%llu.\n",
	    (unsigned long long)ha->pio_address);

skip_pio:
	/* Use MMIO operations for all accesses. */
	if (!(pci_resource_flags(ha->pdev, 1) & IORESOURCE_MEM)) {
		ql_log_pci(ql_log_fatal, ha->pdev, 0x0015,
		    "Region #1 not an MMIO resource (%s), aborting.\n",
		    pci_name(ha->pdev));
		goto iospace_error_exit;
	}
	if (pci_resource_len(ha->pdev, 1) < MIN_IOBASE_LEN) {
		ql_log_pci(ql_log_fatal, ha->pdev, 0x0016,
		    "Invalid PCI mem region size (%s), aborting.\n",
		    pci_name(ha->pdev));
		goto iospace_error_exit;
	}

	ha->iobase = ioremap(pci_resource_start(ha->pdev, 1), MIN_IOBASE_LEN);
	if (!ha->iobase) {
		ql_log_pci(ql_log_fatal, ha->pdev, 0x0017,
		    "Cannot remap MMIO (%s), aborting.\n",
		    pci_name(ha->pdev));
		goto iospace_error_exit;
	}

	/* Determine queue resources */
	ha->max_req_queues = ha->max_rsp_queues = 1;
1961
	ha->msix_count = QLA_BASE_VECTORS;
1962
	if (!ql2xmqsupport || (!IS_QLA25XX(ha) && !IS_QLA81XX(ha)))
1963 1964 1965 1966 1967 1968 1969 1970 1971
		goto mqiobase_exit;

	ha->mqiobase = ioremap(pci_resource_start(ha->pdev, 3),
			pci_resource_len(ha->pdev, 3));
	if (ha->mqiobase) {
		ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0018,
		    "MQIO Base=%p.\n", ha->mqiobase);
		/* Read MSIX vector size of the board */
		pci_read_config_word(ha->pdev, QLA_PCI_MSIX_CONTROL, &msix);
1972
		ha->msix_count = msix + 1;
1973
		/* Max queues are bounded by available msix vectors */
1974 1975 1976 1977 1978 1979 1980 1981
		/* MB interrupt uses 1 vector */
		ha->max_req_queues = ha->msix_count - 1;
		ha->max_rsp_queues = ha->max_req_queues;
		/* Queue pairs is the max value minus the base queue pair */
		ha->max_qpairs = ha->max_rsp_queues - 1;
		ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0188,
		    "Max no of queues pairs: %d.\n", ha->max_qpairs);

1982
		ql_log_pci(ql_log_info, ha->pdev, 0x001a,
1983
		    "MSI-X vector count: %d.\n", ha->msix_count);
1984 1985 1986 1987 1988 1989
	} else
		ql_log_pci(ql_log_info, ha->pdev, 0x001b,
		    "BAR 3 not enabled.\n");

mqiobase_exit:
	ql_dbg_pci(ql_dbg_init, ha->pdev, 0x001c,
1990
	    "MSIX Count: %d.\n", ha->msix_count);
1991 1992 1993 1994 1995 1996 1997
	return (0);

iospace_error_exit:
	return (-ENOMEM);
}


1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037
static int
qla83xx_iospace_config(struct qla_hw_data *ha)
{
	uint16_t msix;

	if (pci_request_selected_regions(ha->pdev, ha->bars,
	    QLA2XXX_DRIVER_NAME)) {
		ql_log_pci(ql_log_fatal, ha->pdev, 0x0117,
		    "Failed to reserve PIO/MMIO regions (%s), aborting.\n",
		    pci_name(ha->pdev));

		goto iospace_error_exit;
	}

	/* Use MMIO operations for all accesses. */
	if (!(pci_resource_flags(ha->pdev, 0) & IORESOURCE_MEM)) {
		ql_log_pci(ql_log_warn, ha->pdev, 0x0118,
		    "Invalid pci I/O region size (%s).\n",
		    pci_name(ha->pdev));
		goto iospace_error_exit;
	}
	if (pci_resource_len(ha->pdev, 0) < MIN_IOBASE_LEN) {
		ql_log_pci(ql_log_warn, ha->pdev, 0x0119,
		    "Invalid PCI mem region size (%s), aborting\n",
			pci_name(ha->pdev));
		goto iospace_error_exit;
	}

	ha->iobase = ioremap(pci_resource_start(ha->pdev, 0), MIN_IOBASE_LEN);
	if (!ha->iobase) {
		ql_log_pci(ql_log_fatal, ha->pdev, 0x011a,
		    "Cannot remap MMIO (%s), aborting.\n",
		    pci_name(ha->pdev));
		goto iospace_error_exit;
	}

	/* 64bit PCI BAR - BAR2 will correspoond to region 4 */
	/* 83XX 26XX always use MQ type access for queues
	 * - mbar 2, a.k.a region 4 */
	ha->max_req_queues = ha->max_rsp_queues = 1;
2038
	ha->msix_count = QLA_BASE_VECTORS;
2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053
	ha->mqiobase = ioremap(pci_resource_start(ha->pdev, 4),
			pci_resource_len(ha->pdev, 4));

	if (!ha->mqiobase) {
		ql_log_pci(ql_log_fatal, ha->pdev, 0x011d,
		    "BAR2/region4 not enabled\n");
		goto mqiobase_exit;
	}

	ha->msixbase = ioremap(pci_resource_start(ha->pdev, 2),
			pci_resource_len(ha->pdev, 2));
	if (ha->msixbase) {
		/* Read MSIX vector size of the board */
		pci_read_config_word(ha->pdev,
		    QLA_83XX_PCI_MSIX_CONTROL, &msix);
2054
		ha->msix_count = (msix & PCI_MSIX_FLAGS_QSIZE)  + 1;
2055 2056 2057 2058
		/*
		 * By default, driver uses at least two msix vectors
		 * (default & rspq)
		 */
2059 2060 2061
		if (ql2xmqsupport) {
			/* MB interrupt uses 1 vector */
			ha->max_req_queues = ha->msix_count - 1;
2062 2063 2064 2065 2066

			/* ATIOQ needs 1 vector. That's 1 less QPair */
			if (QLA_TGT_MODE_ENABLED())
				ha->max_req_queues--;

2067 2068
			ha->max_rsp_queues = ha->max_req_queues;

2069 2070 2071
			/* Queue pairs is the max value minus
			 * the base queue pair */
			ha->max_qpairs = ha->max_req_queues - 1;
2072
			ql_dbg_pci(ql_dbg_init, ha->pdev, 0x00e3,
2073
			    "Max no of queues pairs: %d.\n", ha->max_qpairs);
2074 2075
		}
		ql_log_pci(ql_log_info, ha->pdev, 0x011c,
2076
		    "MSI-X vector count: %d.\n", ha->msix_count);
2077 2078 2079 2080 2081 2082
	} else
		ql_log_pci(ql_log_info, ha->pdev, 0x011e,
		    "BAR 1 not enabled.\n");

mqiobase_exit:
	ql_dbg_pci(ql_dbg_init, ha->pdev, 0x011f,
2083
	    "MSIX Count: %d.\n", ha->msix_count);
2084 2085 2086 2087 2088 2089
	return 0;

iospace_error_exit:
	return -ENOMEM;
}

2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104
static struct isp_operations qla2100_isp_ops = {
	.pci_config		= qla2100_pci_config,
	.reset_chip		= qla2x00_reset_chip,
	.chip_diag		= qla2x00_chip_diag,
	.config_rings		= qla2x00_config_rings,
	.reset_adapter		= qla2x00_reset_adapter,
	.nvram_config		= qla2x00_nvram_config,
	.update_fw_options	= qla2x00_update_fw_options,
	.load_risc		= qla2x00_load_risc,
	.pci_info_str		= qla2x00_pci_info_str,
	.fw_version_str		= qla2x00_fw_version_str,
	.intr_handler		= qla2100_intr_handler,
	.enable_intrs		= qla2x00_enable_intrs,
	.disable_intrs		= qla2x00_disable_intrs,
	.abort_command		= qla2x00_abort_command,
2105 2106
	.target_reset		= qla2x00_abort_target,
	.lun_reset		= qla2x00_lun_reset,
2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121
	.fabric_login		= qla2x00_login_fabric,
	.fabric_logout		= qla2x00_fabric_logout,
	.calc_req_entries	= qla2x00_calc_iocbs_32,
	.build_iocbs		= qla2x00_build_scsi_iocbs_32,
	.prep_ms_iocb		= qla2x00_prep_ms_iocb,
	.prep_ms_fdmi_iocb	= qla2x00_prep_ms_fdmi_iocb,
	.read_nvram		= qla2x00_read_nvram_data,
	.write_nvram		= qla2x00_write_nvram_data,
	.fw_dump		= qla2100_fw_dump,
	.beacon_on		= NULL,
	.beacon_off		= NULL,
	.beacon_blink		= NULL,
	.read_optrom		= qla2x00_read_optrom_data,
	.write_optrom		= qla2x00_write_optrom_data,
	.get_flash_version	= qla2x00_get_flash_version,
2122
	.start_scsi		= qla2x00_start_scsi,
2123
	.start_scsi_mq          = NULL,
2124
	.abort_isp		= qla2x00_abort_isp,
2125
	.iospace_config     	= qla2x00_iospace_config,
2126
	.initialize_adapter	= qla2x00_initialize_adapter,
2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143
};

static struct isp_operations qla2300_isp_ops = {
	.pci_config		= qla2300_pci_config,
	.reset_chip		= qla2x00_reset_chip,
	.chip_diag		= qla2x00_chip_diag,
	.config_rings		= qla2x00_config_rings,
	.reset_adapter		= qla2x00_reset_adapter,
	.nvram_config		= qla2x00_nvram_config,
	.update_fw_options	= qla2x00_update_fw_options,
	.load_risc		= qla2x00_load_risc,
	.pci_info_str		= qla2x00_pci_info_str,
	.fw_version_str		= qla2x00_fw_version_str,
	.intr_handler		= qla2300_intr_handler,
	.enable_intrs		= qla2x00_enable_intrs,
	.disable_intrs		= qla2x00_disable_intrs,
	.abort_command		= qla2x00_abort_command,
2144 2145
	.target_reset		= qla2x00_abort_target,
	.lun_reset		= qla2x00_lun_reset,
2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160
	.fabric_login		= qla2x00_login_fabric,
	.fabric_logout		= qla2x00_fabric_logout,
	.calc_req_entries	= qla2x00_calc_iocbs_32,
	.build_iocbs		= qla2x00_build_scsi_iocbs_32,
	.prep_ms_iocb		= qla2x00_prep_ms_iocb,
	.prep_ms_fdmi_iocb	= qla2x00_prep_ms_fdmi_iocb,
	.read_nvram		= qla2x00_read_nvram_data,
	.write_nvram		= qla2x00_write_nvram_data,
	.fw_dump		= qla2300_fw_dump,
	.beacon_on		= qla2x00_beacon_on,
	.beacon_off		= qla2x00_beacon_off,
	.beacon_blink		= qla2x00_beacon_blink,
	.read_optrom		= qla2x00_read_optrom_data,
	.write_optrom		= qla2x00_write_optrom_data,
	.get_flash_version	= qla2x00_get_flash_version,
2161
	.start_scsi		= qla2x00_start_scsi,
2162
	.start_scsi_mq          = NULL,
2163
	.abort_isp		= qla2x00_abort_isp,
2164
	.iospace_config		= qla2x00_iospace_config,
2165
	.initialize_adapter	= qla2x00_initialize_adapter,
2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182
};

static struct isp_operations qla24xx_isp_ops = {
	.pci_config		= qla24xx_pci_config,
	.reset_chip		= qla24xx_reset_chip,
	.chip_diag		= qla24xx_chip_diag,
	.config_rings		= qla24xx_config_rings,
	.reset_adapter		= qla24xx_reset_adapter,
	.nvram_config		= qla24xx_nvram_config,
	.update_fw_options	= qla24xx_update_fw_options,
	.load_risc		= qla24xx_load_risc,
	.pci_info_str		= qla24xx_pci_info_str,
	.fw_version_str		= qla24xx_fw_version_str,
	.intr_handler		= qla24xx_intr_handler,
	.enable_intrs		= qla24xx_enable_intrs,
	.disable_intrs		= qla24xx_disable_intrs,
	.abort_command		= qla24xx_abort_command,
2183 2184
	.target_reset		= qla24xx_abort_target,
	.lun_reset		= qla24xx_lun_reset,
2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199
	.fabric_login		= qla24xx_login_fabric,
	.fabric_logout		= qla24xx_fabric_logout,
	.calc_req_entries	= NULL,
	.build_iocbs		= NULL,
	.prep_ms_iocb		= qla24xx_prep_ms_iocb,
	.prep_ms_fdmi_iocb	= qla24xx_prep_ms_fdmi_iocb,
	.read_nvram		= qla24xx_read_nvram_data,
	.write_nvram		= qla24xx_write_nvram_data,
	.fw_dump		= qla24xx_fw_dump,
	.beacon_on		= qla24xx_beacon_on,
	.beacon_off		= qla24xx_beacon_off,
	.beacon_blink		= qla24xx_beacon_blink,
	.read_optrom		= qla24xx_read_optrom_data,
	.write_optrom		= qla24xx_write_optrom_data,
	.get_flash_version	= qla24xx_get_flash_version,
2200
	.start_scsi		= qla24xx_start_scsi,
2201
	.start_scsi_mq          = NULL,
2202
	.abort_isp		= qla2x00_abort_isp,
2203
	.iospace_config		= qla2x00_iospace_config,
2204
	.initialize_adapter	= qla2x00_initialize_adapter,
2205 2206
};

2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221
static struct isp_operations qla25xx_isp_ops = {
	.pci_config		= qla25xx_pci_config,
	.reset_chip		= qla24xx_reset_chip,
	.chip_diag		= qla24xx_chip_diag,
	.config_rings		= qla24xx_config_rings,
	.reset_adapter		= qla24xx_reset_adapter,
	.nvram_config		= qla24xx_nvram_config,
	.update_fw_options	= qla24xx_update_fw_options,
	.load_risc		= qla24xx_load_risc,
	.pci_info_str		= qla24xx_pci_info_str,
	.fw_version_str		= qla24xx_fw_version_str,
	.intr_handler		= qla24xx_intr_handler,
	.enable_intrs		= qla24xx_enable_intrs,
	.disable_intrs		= qla24xx_disable_intrs,
	.abort_command		= qla24xx_abort_command,
2222 2223
	.target_reset		= qla24xx_abort_target,
	.lun_reset		= qla24xx_lun_reset,
2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235
	.fabric_login		= qla24xx_login_fabric,
	.fabric_logout		= qla24xx_fabric_logout,
	.calc_req_entries	= NULL,
	.build_iocbs		= NULL,
	.prep_ms_iocb		= qla24xx_prep_ms_iocb,
	.prep_ms_fdmi_iocb	= qla24xx_prep_ms_fdmi_iocb,
	.read_nvram		= qla25xx_read_nvram_data,
	.write_nvram		= qla25xx_write_nvram_data,
	.fw_dump		= qla25xx_fw_dump,
	.beacon_on		= qla24xx_beacon_on,
	.beacon_off		= qla24xx_beacon_off,
	.beacon_blink		= qla24xx_beacon_blink,
2236
	.read_optrom		= qla25xx_read_optrom_data,
2237 2238
	.write_optrom		= qla24xx_write_optrom_data,
	.get_flash_version	= qla24xx_get_flash_version,
2239
	.start_scsi		= qla24xx_dif_start_scsi,
2240
	.start_scsi_mq          = qla2xxx_dif_start_scsi_mq,
2241
	.abort_isp		= qla2x00_abort_isp,
2242
	.iospace_config		= qla2x00_iospace_config,
2243
	.initialize_adapter	= qla2x00_initialize_adapter,
2244 2245
};

2246 2247 2248 2249 2250 2251 2252 2253
static struct isp_operations qla81xx_isp_ops = {
	.pci_config		= qla25xx_pci_config,
	.reset_chip		= qla24xx_reset_chip,
	.chip_diag		= qla24xx_chip_diag,
	.config_rings		= qla24xx_config_rings,
	.reset_adapter		= qla24xx_reset_adapter,
	.nvram_config		= qla81xx_nvram_config,
	.update_fw_options	= qla81xx_update_fw_options,
2254
	.load_risc		= qla81xx_load_risc,
2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268
	.pci_info_str		= qla24xx_pci_info_str,
	.fw_version_str		= qla24xx_fw_version_str,
	.intr_handler		= qla24xx_intr_handler,
	.enable_intrs		= qla24xx_enable_intrs,
	.disable_intrs		= qla24xx_disable_intrs,
	.abort_command		= qla24xx_abort_command,
	.target_reset		= qla24xx_abort_target,
	.lun_reset		= qla24xx_lun_reset,
	.fabric_login		= qla24xx_login_fabric,
	.fabric_logout		= qla24xx_fabric_logout,
	.calc_req_entries	= NULL,
	.build_iocbs		= NULL,
	.prep_ms_iocb		= qla24xx_prep_ms_iocb,
	.prep_ms_fdmi_iocb	= qla24xx_prep_ms_fdmi_iocb,
2269 2270
	.read_nvram		= NULL,
	.write_nvram		= NULL,
2271 2272 2273
	.fw_dump		= qla81xx_fw_dump,
	.beacon_on		= qla24xx_beacon_on,
	.beacon_off		= qla24xx_beacon_off,
2274
	.beacon_blink		= qla83xx_beacon_blink,
2275 2276 2277
	.read_optrom		= qla25xx_read_optrom_data,
	.write_optrom		= qla24xx_write_optrom_data,
	.get_flash_version	= qla24xx_get_flash_version,
2278
	.start_scsi		= qla24xx_dif_start_scsi,
2279
	.start_scsi_mq          = qla2xxx_dif_start_scsi_mq,
2280
	.abort_isp		= qla2x00_abort_isp,
2281
	.iospace_config		= qla2x00_iospace_config,
2282
	.initialize_adapter	= qla2x00_initialize_adapter,
2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293
};

static struct isp_operations qla82xx_isp_ops = {
	.pci_config		= qla82xx_pci_config,
	.reset_chip		= qla82xx_reset_chip,
	.chip_diag		= qla24xx_chip_diag,
	.config_rings		= qla82xx_config_rings,
	.reset_adapter		= qla24xx_reset_adapter,
	.nvram_config		= qla81xx_nvram_config,
	.update_fw_options	= qla24xx_update_fw_options,
	.load_risc		= qla82xx_load_risc,
2294
	.pci_info_str		= qla24xx_pci_info_str,
2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309
	.fw_version_str		= qla24xx_fw_version_str,
	.intr_handler		= qla82xx_intr_handler,
	.enable_intrs		= qla82xx_enable_intrs,
	.disable_intrs		= qla82xx_disable_intrs,
	.abort_command		= qla24xx_abort_command,
	.target_reset		= qla24xx_abort_target,
	.lun_reset		= qla24xx_lun_reset,
	.fabric_login		= qla24xx_login_fabric,
	.fabric_logout		= qla24xx_fabric_logout,
	.calc_req_entries	= NULL,
	.build_iocbs		= NULL,
	.prep_ms_iocb		= qla24xx_prep_ms_iocb,
	.prep_ms_fdmi_iocb	= qla24xx_prep_ms_fdmi_iocb,
	.read_nvram		= qla24xx_read_nvram_data,
	.write_nvram		= qla24xx_write_nvram_data,
2310
	.fw_dump		= qla82xx_fw_dump,
2311 2312 2313
	.beacon_on		= qla82xx_beacon_on,
	.beacon_off		= qla82xx_beacon_off,
	.beacon_blink		= NULL,
2314 2315
	.read_optrom		= qla82xx_read_optrom_data,
	.write_optrom		= qla82xx_write_optrom_data,
2316
	.get_flash_version	= qla82xx_get_flash_version,
2317
	.start_scsi             = qla82xx_start_scsi,
2318
	.start_scsi_mq          = NULL,
2319
	.abort_isp		= qla82xx_abort_isp,
2320
	.iospace_config     	= qla82xx_iospace_config,
2321
	.initialize_adapter	= qla2x00_initialize_adapter,
2322 2323
};

2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348
static struct isp_operations qla8044_isp_ops = {
	.pci_config		= qla82xx_pci_config,
	.reset_chip		= qla82xx_reset_chip,
	.chip_diag		= qla24xx_chip_diag,
	.config_rings		= qla82xx_config_rings,
	.reset_adapter		= qla24xx_reset_adapter,
	.nvram_config		= qla81xx_nvram_config,
	.update_fw_options	= qla24xx_update_fw_options,
	.load_risc		= qla82xx_load_risc,
	.pci_info_str		= qla24xx_pci_info_str,
	.fw_version_str		= qla24xx_fw_version_str,
	.intr_handler		= qla8044_intr_handler,
	.enable_intrs		= qla82xx_enable_intrs,
	.disable_intrs		= qla82xx_disable_intrs,
	.abort_command		= qla24xx_abort_command,
	.target_reset		= qla24xx_abort_target,
	.lun_reset		= qla24xx_lun_reset,
	.fabric_login		= qla24xx_login_fabric,
	.fabric_logout		= qla24xx_fabric_logout,
	.calc_req_entries	= NULL,
	.build_iocbs		= NULL,
	.prep_ms_iocb		= qla24xx_prep_ms_iocb,
	.prep_ms_fdmi_iocb	= qla24xx_prep_ms_fdmi_iocb,
	.read_nvram		= NULL,
	.write_nvram		= NULL,
2349
	.fw_dump		= qla8044_fw_dump,
2350 2351 2352
	.beacon_on		= qla82xx_beacon_on,
	.beacon_off		= qla82xx_beacon_off,
	.beacon_blink		= NULL,
2353
	.read_optrom		= qla8044_read_optrom_data,
2354 2355 2356
	.write_optrom		= qla8044_write_optrom_data,
	.get_flash_version	= qla82xx_get_flash_version,
	.start_scsi             = qla82xx_start_scsi,
2357
	.start_scsi_mq          = NULL,
2358 2359 2360 2361 2362
	.abort_isp		= qla8044_abort_isp,
	.iospace_config		= qla82xx_iospace_config,
	.initialize_adapter	= qla2x00_initialize_adapter,
};

2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395
static struct isp_operations qla83xx_isp_ops = {
	.pci_config		= qla25xx_pci_config,
	.reset_chip		= qla24xx_reset_chip,
	.chip_diag		= qla24xx_chip_diag,
	.config_rings		= qla24xx_config_rings,
	.reset_adapter		= qla24xx_reset_adapter,
	.nvram_config		= qla81xx_nvram_config,
	.update_fw_options	= qla81xx_update_fw_options,
	.load_risc		= qla81xx_load_risc,
	.pci_info_str		= qla24xx_pci_info_str,
	.fw_version_str		= qla24xx_fw_version_str,
	.intr_handler		= qla24xx_intr_handler,
	.enable_intrs		= qla24xx_enable_intrs,
	.disable_intrs		= qla24xx_disable_intrs,
	.abort_command		= qla24xx_abort_command,
	.target_reset		= qla24xx_abort_target,
	.lun_reset		= qla24xx_lun_reset,
	.fabric_login		= qla24xx_login_fabric,
	.fabric_logout		= qla24xx_fabric_logout,
	.calc_req_entries	= NULL,
	.build_iocbs		= NULL,
	.prep_ms_iocb		= qla24xx_prep_ms_iocb,
	.prep_ms_fdmi_iocb	= qla24xx_prep_ms_fdmi_iocb,
	.read_nvram		= NULL,
	.write_nvram		= NULL,
	.fw_dump		= qla83xx_fw_dump,
	.beacon_on		= qla24xx_beacon_on,
	.beacon_off		= qla24xx_beacon_off,
	.beacon_blink		= qla83xx_beacon_blink,
	.read_optrom		= qla25xx_read_optrom_data,
	.write_optrom		= qla24xx_write_optrom_data,
	.get_flash_version	= qla24xx_get_flash_version,
	.start_scsi		= qla24xx_dif_start_scsi,
2396
	.start_scsi_mq          = qla2xxx_dif_start_scsi_mq,
2397 2398
	.abort_isp		= qla2x00_abort_isp,
	.iospace_config		= qla83xx_iospace_config,
2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415
	.initialize_adapter	= qla2x00_initialize_adapter,
};

static struct isp_operations qlafx00_isp_ops = {
	.pci_config		= qlafx00_pci_config,
	.reset_chip		= qlafx00_soft_reset,
	.chip_diag		= qlafx00_chip_diag,
	.config_rings		= qlafx00_config_rings,
	.reset_adapter		= qlafx00_soft_reset,
	.nvram_config		= NULL,
	.update_fw_options	= NULL,
	.load_risc		= NULL,
	.pci_info_str		= qlafx00_pci_info_str,
	.fw_version_str		= qlafx00_fw_version_str,
	.intr_handler		= qlafx00_intr_handler,
	.enable_intrs		= qlafx00_enable_intrs,
	.disable_intrs		= qlafx00_disable_intrs,
2416
	.abort_command		= qla24xx_async_abort_command,
2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434
	.target_reset		= qlafx00_abort_target,
	.lun_reset		= qlafx00_lun_reset,
	.fabric_login		= NULL,
	.fabric_logout		= NULL,
	.calc_req_entries	= NULL,
	.build_iocbs		= NULL,
	.prep_ms_iocb		= qla24xx_prep_ms_iocb,
	.prep_ms_fdmi_iocb	= qla24xx_prep_ms_fdmi_iocb,
	.read_nvram		= qla24xx_read_nvram_data,
	.write_nvram		= qla24xx_write_nvram_data,
	.fw_dump		= NULL,
	.beacon_on		= qla24xx_beacon_on,
	.beacon_off		= qla24xx_beacon_off,
	.beacon_blink		= NULL,
	.read_optrom		= qla24xx_read_optrom_data,
	.write_optrom		= qla24xx_write_optrom_data,
	.get_flash_version	= qla24xx_get_flash_version,
	.start_scsi		= qlafx00_start_scsi,
2435
	.start_scsi_mq          = NULL,
2436 2437 2438
	.abort_isp		= qlafx00_abort_isp,
	.iospace_config		= qlafx00_iospace_config,
	.initialize_adapter	= qlafx00_initialize_adapter,
2439 2440
};

2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473
static struct isp_operations qla27xx_isp_ops = {
	.pci_config		= qla25xx_pci_config,
	.reset_chip		= qla24xx_reset_chip,
	.chip_diag		= qla24xx_chip_diag,
	.config_rings		= qla24xx_config_rings,
	.reset_adapter		= qla24xx_reset_adapter,
	.nvram_config		= qla81xx_nvram_config,
	.update_fw_options	= qla81xx_update_fw_options,
	.load_risc		= qla81xx_load_risc,
	.pci_info_str		= qla24xx_pci_info_str,
	.fw_version_str		= qla24xx_fw_version_str,
	.intr_handler		= qla24xx_intr_handler,
	.enable_intrs		= qla24xx_enable_intrs,
	.disable_intrs		= qla24xx_disable_intrs,
	.abort_command		= qla24xx_abort_command,
	.target_reset		= qla24xx_abort_target,
	.lun_reset		= qla24xx_lun_reset,
	.fabric_login		= qla24xx_login_fabric,
	.fabric_logout		= qla24xx_fabric_logout,
	.calc_req_entries	= NULL,
	.build_iocbs		= NULL,
	.prep_ms_iocb		= qla24xx_prep_ms_iocb,
	.prep_ms_fdmi_iocb	= qla24xx_prep_ms_fdmi_iocb,
	.read_nvram		= NULL,
	.write_nvram		= NULL,
	.fw_dump		= qla27xx_fwdump,
	.beacon_on		= qla24xx_beacon_on,
	.beacon_off		= qla24xx_beacon_off,
	.beacon_blink		= qla83xx_beacon_blink,
	.read_optrom		= qla25xx_read_optrom_data,
	.write_optrom		= qla24xx_write_optrom_data,
	.get_flash_version	= qla24xx_get_flash_version,
	.start_scsi		= qla24xx_dif_start_scsi,
2474
	.start_scsi_mq          = qla2xxx_dif_start_scsi_mq,
2475 2476 2477 2478 2479
	.abort_isp		= qla2x00_abort_isp,
	.iospace_config		= qla83xx_iospace_config,
	.initialize_adapter	= qla2x00_initialize_adapter,
};

2480
static inline void
2481
qla2x00_set_isp_flags(struct qla_hw_data *ha)
2482 2483 2484 2485
{
	ha->device_type = DT_EXTENDED_IDS;
	switch (ha->pdev->device) {
	case PCI_DEVICE_ID_QLOGIC_ISP2100:
2486
		ha->isp_type |= DT_ISP2100;
2487
		ha->device_type &= ~DT_EXTENDED_IDS;
2488
		ha->fw_srisc_address = RISC_START_ADDRESS_2100;
2489 2490
		break;
	case PCI_DEVICE_ID_QLOGIC_ISP2200:
2491
		ha->isp_type |= DT_ISP2200;
2492
		ha->device_type &= ~DT_EXTENDED_IDS;
2493
		ha->fw_srisc_address = RISC_START_ADDRESS_2100;
2494 2495
		break;
	case PCI_DEVICE_ID_QLOGIC_ISP2300:
2496
		ha->isp_type |= DT_ISP2300;
2497
		ha->device_type |= DT_ZIO_SUPPORTED;
2498
		ha->fw_srisc_address = RISC_START_ADDRESS_2300;
2499 2500
		break;
	case PCI_DEVICE_ID_QLOGIC_ISP2312:
2501
		ha->isp_type |= DT_ISP2312;
2502
		ha->device_type |= DT_ZIO_SUPPORTED;
2503
		ha->fw_srisc_address = RISC_START_ADDRESS_2300;
2504 2505
		break;
	case PCI_DEVICE_ID_QLOGIC_ISP2322:
2506
		ha->isp_type |= DT_ISP2322;
2507
		ha->device_type |= DT_ZIO_SUPPORTED;
2508 2509 2510
		if (ha->pdev->subsystem_vendor == 0x1028 &&
		    ha->pdev->subsystem_device == 0x0170)
			ha->device_type |= DT_OEM_001;
2511
		ha->fw_srisc_address = RISC_START_ADDRESS_2300;
2512 2513
		break;
	case PCI_DEVICE_ID_QLOGIC_ISP6312:
2514
		ha->isp_type |= DT_ISP6312;
2515
		ha->fw_srisc_address = RISC_START_ADDRESS_2300;
2516 2517
		break;
	case PCI_DEVICE_ID_QLOGIC_ISP6322:
2518
		ha->isp_type |= DT_ISP6322;
2519
		ha->fw_srisc_address = RISC_START_ADDRESS_2300;
2520 2521
		break;
	case PCI_DEVICE_ID_QLOGIC_ISP2422:
2522
		ha->isp_type |= DT_ISP2422;
2523
		ha->device_type |= DT_ZIO_SUPPORTED;
2524
		ha->device_type |= DT_FWI2;
2525
		ha->device_type |= DT_IIDMA;
2526
		ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2527 2528
		break;
	case PCI_DEVICE_ID_QLOGIC_ISP2432:
2529
		ha->isp_type |= DT_ISP2432;
2530
		ha->device_type |= DT_ZIO_SUPPORTED;
2531
		ha->device_type |= DT_FWI2;
2532
		ha->device_type |= DT_IIDMA;
2533
		ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2534
		break;
2535
	case PCI_DEVICE_ID_QLOGIC_ISP8432:
2536
		ha->isp_type |= DT_ISP8432;
2537 2538 2539 2540 2541
		ha->device_type |= DT_ZIO_SUPPORTED;
		ha->device_type |= DT_FWI2;
		ha->device_type |= DT_IIDMA;
		ha->fw_srisc_address = RISC_START_ADDRESS_2400;
		break;
2542
	case PCI_DEVICE_ID_QLOGIC_ISP5422:
2543
		ha->isp_type |= DT_ISP5422;
2544
		ha->device_type |= DT_FWI2;
2545
		ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2546
		break;
2547
	case PCI_DEVICE_ID_QLOGIC_ISP5432:
2548
		ha->isp_type |= DT_ISP5432;
2549
		ha->device_type |= DT_FWI2;
2550
		ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2551
		break;
2552
	case PCI_DEVICE_ID_QLOGIC_ISP2532:
2553
		ha->isp_type |= DT_ISP2532;
2554 2555 2556
		ha->device_type |= DT_ZIO_SUPPORTED;
		ha->device_type |= DT_FWI2;
		ha->device_type |= DT_IIDMA;
2557
		ha->fw_srisc_address = RISC_START_ADDRESS_2400;
2558
		break;
2559
	case PCI_DEVICE_ID_QLOGIC_ISP8001:
2560
		ha->isp_type |= DT_ISP8001;
2561 2562 2563 2564 2565
		ha->device_type |= DT_ZIO_SUPPORTED;
		ha->device_type |= DT_FWI2;
		ha->device_type |= DT_IIDMA;
		ha->fw_srisc_address = RISC_START_ADDRESS_2400;
		break;
2566
	case PCI_DEVICE_ID_QLOGIC_ISP8021:
2567
		ha->isp_type |= DT_ISP8021;
2568 2569 2570 2571 2572 2573
		ha->device_type |= DT_ZIO_SUPPORTED;
		ha->device_type |= DT_FWI2;
		ha->fw_srisc_address = RISC_START_ADDRESS_2400;
		/* Initialize 82XX ISP flags */
		qla82xx_init_flags(ha);
		break;
2574
	 case PCI_DEVICE_ID_QLOGIC_ISP8044:
2575
		ha->isp_type |= DT_ISP8044;
2576 2577 2578 2579 2580 2581
		ha->device_type |= DT_ZIO_SUPPORTED;
		ha->device_type |= DT_FWI2;
		ha->fw_srisc_address = RISC_START_ADDRESS_2400;
		/* Initialize 82XX ISP flags */
		qla82xx_init_flags(ha);
		break;
2582
	case PCI_DEVICE_ID_QLOGIC_ISP2031:
2583
		ha->isp_type |= DT_ISP2031;
2584 2585 2586 2587 2588 2589 2590
		ha->device_type |= DT_ZIO_SUPPORTED;
		ha->device_type |= DT_FWI2;
		ha->device_type |= DT_IIDMA;
		ha->device_type |= DT_T10_PI;
		ha->fw_srisc_address = RISC_START_ADDRESS_2400;
		break;
	case PCI_DEVICE_ID_QLOGIC_ISP8031:
2591
		ha->isp_type |= DT_ISP8031;
2592 2593 2594 2595 2596 2597
		ha->device_type |= DT_ZIO_SUPPORTED;
		ha->device_type |= DT_FWI2;
		ha->device_type |= DT_IIDMA;
		ha->device_type |= DT_T10_PI;
		ha->fw_srisc_address = RISC_START_ADDRESS_2400;
		break;
2598
	case PCI_DEVICE_ID_QLOGIC_ISPF001:
2599
		ha->isp_type |= DT_ISPFX00;
2600
		break;
2601
	case PCI_DEVICE_ID_QLOGIC_ISP2071:
2602
		ha->isp_type |= DT_ISP2071;
2603 2604 2605
		ha->device_type |= DT_ZIO_SUPPORTED;
		ha->device_type |= DT_FWI2;
		ha->device_type |= DT_IIDMA;
2606
		ha->device_type |= DT_T10_PI;
2607 2608
		ha->fw_srisc_address = RISC_START_ADDRESS_2400;
		break;
2609
	case PCI_DEVICE_ID_QLOGIC_ISP2271:
2610
		ha->isp_type |= DT_ISP2271;
2611 2612 2613
		ha->device_type |= DT_ZIO_SUPPORTED;
		ha->device_type |= DT_FWI2;
		ha->device_type |= DT_IIDMA;
2614
		ha->device_type |= DT_T10_PI;
2615 2616
		ha->fw_srisc_address = RISC_START_ADDRESS_2400;
		break;
2617
	case PCI_DEVICE_ID_QLOGIC_ISP2261:
2618
		ha->isp_type |= DT_ISP2261;
2619 2620 2621
		ha->device_type |= DT_ZIO_SUPPORTED;
		ha->device_type |= DT_FWI2;
		ha->device_type |= DT_IIDMA;
2622
		ha->device_type |= DT_T10_PI;
2623 2624
		ha->fw_srisc_address = RISC_START_ADDRESS_2400;
		break;
2625
	}
2626

2627
	if (IS_QLA82XX(ha))
2628
		ha->port_no = ha->portnum & 1;
2629
	else {
2630 2631
		/* Get adapter physical port no from interrupt pin register. */
		pci_read_config_byte(ha->pdev, PCI_INTERRUPT_PIN, &ha->port_no);
2632 2633 2634 2635 2636
		if (IS_QLA27XX(ha))
			ha->port_no--;
		else
			ha->port_no = !(ha->port_no & 1);
	}
2637

2638
	ql_dbg_pci(ql_dbg_init, ha->pdev, 0x000b,
2639
	    "device_type=0x%x port=%d fw_srisc_address=0x%x.\n",
2640
	    ha->device_type, ha->port_no, ha->fw_srisc_address);
2641 2642
}

2643 2644 2645
static void
qla2xxx_scan_start(struct Scsi_Host *shost)
{
2646
	scsi_qla_host_t *vha = shost_priv(shost);
2647

2648 2649 2650
	if (vha->hw->flags.running_gold_fw)
		return;

2651 2652 2653 2654
	set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
	set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
	set_bit(RSCN_UPDATE, &vha->dpc_flags);
	set_bit(NPIV_CONFIG_NEEDED, &vha->dpc_flags);
2655 2656 2657 2658 2659
}

static int
qla2xxx_scan_finished(struct Scsi_Host *shost, unsigned long time)
{
2660
	scsi_qla_host_t *vha = shost_priv(shost);
2661

2662 2663
	if (test_bit(UNLOADING, &vha->dpc_flags))
		return 1;
2664
	if (!vha->host)
2665
		return 1;
2666
	if (time > vha->hw->loop_reset_delay * HZ)
2667 2668
		return 1;

2669
	return atomic_read(&vha->loop_state) == LOOP_READY;
2670 2671
}

2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685
static void qla2x00_iocb_work_fn(struct work_struct *work)
{
	struct scsi_qla_host *vha = container_of(work,
		struct scsi_qla_host, iocb_work);
	int cnt = 0;

	while (!list_empty(&vha->work_list)) {
		qla2x00_do_work(vha);
		cnt++;
		if (cnt > 10)
			break;
	}
}

L
Linus Torvalds 已提交
2686 2687 2688
/*
 * PCI driver interface
 */
2689
static int
2690
qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
L
Linus Torvalds 已提交
2691
{
2692
	int	ret = -ENODEV;
L
Linus Torvalds 已提交
2693
	struct Scsi_Host *host;
2694 2695
	scsi_qla_host_t *base_vha = NULL;
	struct qla_hw_data *ha;
2696
	char pci_info[30];
2697
	char fw_str[30], wq_name[30];
2698
	struct scsi_host_template *sht;
2699
	int bars, mem_only = 0;
2700
	uint16_t req_length = 0, rsp_length = 0;
2701 2702
	struct req_que *req = NULL;
	struct rsp_que *rsp = NULL;
2703
	int i;
2704

2705
	bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO);
2706
	sht = &qla2xxx_driver_template;
2707
	if (pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2422 ||
2708
	    pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2432 ||
2709
	    pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8432 ||
2710
	    pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5422 ||
2711
	    pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5432 ||
2712
	    pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2532 ||
2713
	    pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8001 ||
2714 2715
	    pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8021 ||
	    pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2031 ||
2716
	    pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8031 ||
2717
	    pdev->device == PCI_DEVICE_ID_QLOGIC_ISPF001 ||
2718
	    pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8044 ||
2719
	    pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2071 ||
2720 2721
	    pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2271 ||
	    pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2261) {
2722
		bars = pci_select_bars(pdev, IORESOURCE_MEM);
2723
		mem_only = 1;
2724 2725
		ql_dbg_pci(ql_dbg_init, pdev, 0x0007,
		    "Mem only adapter.\n");
2726
	}
2727 2728
	ql_dbg_pci(ql_dbg_init, pdev, 0x0008,
	    "Bars=%d.\n", bars);
2729

2730 2731
	if (mem_only) {
		if (pci_enable_device_mem(pdev))
2732
			return ret;
2733 2734
	} else {
		if (pci_enable_device(pdev))
2735
			return ret;
2736
	}
2737

2738 2739
	/* This may fail but that's ok */
	pci_enable_pcie_error_reporting(pdev);
2740

2741 2742
	ha = kzalloc(sizeof(struct qla_hw_data), GFP_KERNEL);
	if (!ha) {
2743 2744
		ql_log_pci(ql_log_fatal, pdev, 0x0009,
		    "Unable to allocate memory for ha.\n");
2745
		goto disable_device;
L
Linus Torvalds 已提交
2746
	}
2747 2748
	ql_dbg_pci(ql_dbg_init, pdev, 0x000a,
	    "Memory allocated for ha=%p.\n", ha);
2749
	ha->pdev = pdev;
2750 2751
	INIT_LIST_HEAD(&ha->tgt.q_full_list);
	spin_lock_init(&ha->tgt.q_full_lock);
2752
	spin_lock_init(&ha->tgt.sess_lock);
2753 2754
	spin_lock_init(&ha->tgt.atio_lock);

2755
	atomic_set(&ha->nvme_active_aen_cnt, 0);
L
Linus Torvalds 已提交
2756 2757

	/* Clear our data area */
2758
	ha->bars = bars;
2759
	ha->mem_only = mem_only;
2760
	spin_lock_init(&ha->hardware_lock);
2761
	spin_lock_init(&ha->vport_slock);
2762
	mutex_init(&ha->selflogin_lock);
2763
	mutex_init(&ha->optrom_mutex);
L
Linus Torvalds 已提交
2764

2765 2766
	/* Set ISP-type information. */
	qla2x00_set_isp_flags(ha);
2767 2768

	/* Set EEH reset type to fundamental if required by hba */
2769
	if (IS_QLA24XX(ha) || IS_QLA25XX(ha) || IS_QLA81XX(ha) ||
2770
	    IS_QLA83XX(ha) || IS_QLA27XX(ha))
2771 2772
		pdev->needs_freset = 1;

2773 2774 2775 2776 2777
	ha->prev_topology = 0;
	ha->init_cb_size = sizeof(init_cb_t);
	ha->link_data_rate = PORT_SPEED_UNKNOWN;
	ha->optrom_size = OPTROM_SIZE_2300;

2778
	/* Assign ISP specific operations. */
L
Linus Torvalds 已提交
2779
	if (IS_QLA2100(ha)) {
2780
		ha->max_fibre_devices = MAX_FIBRE_DEVICES_2100;
L
Linus Torvalds 已提交
2781
		ha->mbx_count = MAILBOX_REGISTER_COUNT_2100;
2782 2783 2784
		req_length = REQUEST_ENTRY_CNT_2100;
		rsp_length = RESPONSE_ENTRY_CNT_2100;
		ha->max_loop_id = SNS_LAST_LOOP_ID_2100;
2785
		ha->gid_list_info_size = 4;
2786 2787 2788 2789
		ha->flash_conf_off = ~0;
		ha->flash_data_off = ~0;
		ha->nvram_conf_off = ~0;
		ha->nvram_data_off = ~0;
2790
		ha->isp_ops = &qla2100_isp_ops;
L
Linus Torvalds 已提交
2791
	} else if (IS_QLA2200(ha)) {
2792
		ha->max_fibre_devices = MAX_FIBRE_DEVICES_2100;
2793
		ha->mbx_count = MAILBOX_REGISTER_COUNT_2200;
2794 2795 2796
		req_length = REQUEST_ENTRY_CNT_2200;
		rsp_length = RESPONSE_ENTRY_CNT_2100;
		ha->max_loop_id = SNS_LAST_LOOP_ID_2100;
2797
		ha->gid_list_info_size = 4;
2798 2799 2800 2801
		ha->flash_conf_off = ~0;
		ha->flash_data_off = ~0;
		ha->nvram_conf_off = ~0;
		ha->nvram_data_off = ~0;
2802
		ha->isp_ops = &qla2100_isp_ops;
2803
	} else if (IS_QLA23XX(ha)) {
2804
		ha->max_fibre_devices = MAX_FIBRE_DEVICES_2100;
L
Linus Torvalds 已提交
2805
		ha->mbx_count = MAILBOX_REGISTER_COUNT;
2806 2807 2808
		req_length = REQUEST_ENTRY_CNT_2200;
		rsp_length = RESPONSE_ENTRY_CNT_2300;
		ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
2809
		ha->gid_list_info_size = 6;
2810 2811
		if (IS_QLA2322(ha) || IS_QLA6322(ha))
			ha->optrom_size = OPTROM_SIZE_2322;
2812 2813 2814 2815
		ha->flash_conf_off = ~0;
		ha->flash_data_off = ~0;
		ha->nvram_conf_off = ~0;
		ha->nvram_data_off = ~0;
2816
		ha->isp_ops = &qla2300_isp_ops;
2817
	} else if (IS_QLA24XX_TYPE(ha)) {
2818
		ha->max_fibre_devices = MAX_FIBRE_DEVICES_2400;
2819
		ha->mbx_count = MAILBOX_REGISTER_COUNT;
2820 2821
		req_length = REQUEST_ENTRY_CNT_24XX;
		rsp_length = RESPONSE_ENTRY_CNT_2300;
2822
		ha->tgt.atio_q_length = ATIO_ENTRY_CNT_24XX;
2823
		ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
2824
		ha->init_cb_size = sizeof(struct mid_init_cb_24xx);
2825
		ha->gid_list_info_size = 8;
2826
		ha->optrom_size = OPTROM_SIZE_24XX;
2827
		ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA24XX;
2828
		ha->isp_ops = &qla24xx_isp_ops;
2829 2830 2831 2832
		ha->flash_conf_off = FARX_ACCESS_FLASH_CONF;
		ha->flash_data_off = FARX_ACCESS_FLASH_DATA;
		ha->nvram_conf_off = FARX_ACCESS_NVRAM_CONF;
		ha->nvram_data_off = FARX_ACCESS_NVRAM_DATA;
2833
	} else if (IS_QLA25XX(ha)) {
2834
		ha->max_fibre_devices = MAX_FIBRE_DEVICES_2400;
2835
		ha->mbx_count = MAILBOX_REGISTER_COUNT;
2836 2837
		req_length = REQUEST_ENTRY_CNT_24XX;
		rsp_length = RESPONSE_ENTRY_CNT_2300;
2838
		ha->tgt.atio_q_length = ATIO_ENTRY_CNT_24XX;
2839
		ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
2840 2841 2842
		ha->init_cb_size = sizeof(struct mid_init_cb_24xx);
		ha->gid_list_info_size = 8;
		ha->optrom_size = OPTROM_SIZE_25XX;
2843
		ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX;
2844
		ha->isp_ops = &qla25xx_isp_ops;
2845 2846 2847 2848 2849
		ha->flash_conf_off = FARX_ACCESS_FLASH_CONF;
		ha->flash_data_off = FARX_ACCESS_FLASH_DATA;
		ha->nvram_conf_off = FARX_ACCESS_NVRAM_CONF;
		ha->nvram_data_off = FARX_ACCESS_NVRAM_DATA;
	} else if (IS_QLA81XX(ha)) {
2850
		ha->max_fibre_devices = MAX_FIBRE_DEVICES_2400;
2851 2852 2853
		ha->mbx_count = MAILBOX_REGISTER_COUNT;
		req_length = REQUEST_ENTRY_CNT_24XX;
		rsp_length = RESPONSE_ENTRY_CNT_2300;
2854
		ha->tgt.atio_q_length = ATIO_ENTRY_CNT_24XX;
2855 2856 2857 2858
		ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
		ha->init_cb_size = sizeof(struct mid_init_cb_81xx);
		ha->gid_list_info_size = 8;
		ha->optrom_size = OPTROM_SIZE_81XX;
2859
		ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX;
2860 2861 2862 2863 2864
		ha->isp_ops = &qla81xx_isp_ops;
		ha->flash_conf_off = FARX_ACCESS_FLASH_CONF_81XX;
		ha->flash_data_off = FARX_ACCESS_FLASH_DATA_81XX;
		ha->nvram_conf_off = ~0;
		ha->nvram_data_off = ~0;
2865
	} else if (IS_QLA82XX(ha)) {
2866
		ha->max_fibre_devices = MAX_FIBRE_DEVICES_2400;
2867 2868 2869 2870 2871 2872 2873
		ha->mbx_count = MAILBOX_REGISTER_COUNT;
		req_length = REQUEST_ENTRY_CNT_82XX;
		rsp_length = RESPONSE_ENTRY_CNT_82XX;
		ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
		ha->init_cb_size = sizeof(struct mid_init_cb_81xx);
		ha->gid_list_info_size = 8;
		ha->optrom_size = OPTROM_SIZE_82XX;
2874
		ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX;
2875 2876 2877 2878 2879
		ha->isp_ops = &qla82xx_isp_ops;
		ha->flash_conf_off = FARX_ACCESS_FLASH_CONF;
		ha->flash_data_off = FARX_ACCESS_FLASH_DATA;
		ha->nvram_conf_off = FARX_ACCESS_NVRAM_CONF;
		ha->nvram_data_off = FARX_ACCESS_NVRAM_DATA;
2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894
	} else if (IS_QLA8044(ha)) {
		ha->max_fibre_devices = MAX_FIBRE_DEVICES_2400;
		ha->mbx_count = MAILBOX_REGISTER_COUNT;
		req_length = REQUEST_ENTRY_CNT_82XX;
		rsp_length = RESPONSE_ENTRY_CNT_82XX;
		ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
		ha->init_cb_size = sizeof(struct mid_init_cb_81xx);
		ha->gid_list_info_size = 8;
		ha->optrom_size = OPTROM_SIZE_83XX;
		ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX;
		ha->isp_ops = &qla8044_isp_ops;
		ha->flash_conf_off = FARX_ACCESS_FLASH_CONF;
		ha->flash_data_off = FARX_ACCESS_FLASH_DATA;
		ha->nvram_conf_off = FARX_ACCESS_NVRAM_CONF;
		ha->nvram_data_off = FARX_ACCESS_NVRAM_DATA;
2895
	} else if (IS_QLA83XX(ha)) {
2896
		ha->portnum = PCI_FUNC(ha->pdev->devfn);
2897
		ha->max_fibre_devices = MAX_FIBRE_DEVICES_2400;
2898
		ha->mbx_count = MAILBOX_REGISTER_COUNT;
2899
		req_length = REQUEST_ENTRY_CNT_83XX;
Q
Quinn Tran 已提交
2900
		rsp_length = RESPONSE_ENTRY_CNT_83XX;
2901
		ha->tgt.atio_q_length = ATIO_ENTRY_CNT_24XX;
2902 2903 2904 2905 2906 2907 2908 2909 2910 2911
		ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
		ha->init_cb_size = sizeof(struct mid_init_cb_81xx);
		ha->gid_list_info_size = 8;
		ha->optrom_size = OPTROM_SIZE_83XX;
		ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX;
		ha->isp_ops = &qla83xx_isp_ops;
		ha->flash_conf_off = FARX_ACCESS_FLASH_CONF_81XX;
		ha->flash_data_off = FARX_ACCESS_FLASH_DATA_81XX;
		ha->nvram_conf_off = ~0;
		ha->nvram_data_off = ~0;
2912 2913 2914 2915 2916 2917 2918 2919 2920 2921
	}  else if (IS_QLAFX00(ha)) {
		ha->max_fibre_devices = MAX_FIBRE_DEVICES_FX00;
		ha->mbx_count = MAILBOX_REGISTER_COUNT_FX00;
		ha->aen_mbx_count = AEN_MAILBOX_REGISTER_COUNT_FX00;
		req_length = REQUEST_ENTRY_CNT_FX00;
		rsp_length = RESPONSE_ENTRY_CNT_FX00;
		ha->isp_ops = &qlafx00_isp_ops;
		ha->port_down_retry_count = 30; /* default value */
		ha->mr.fw_hbt_cnt = QLAFX00_HEARTBEAT_INTERVAL;
		ha->mr.fw_reset_timer_tick = QLAFX00_RESET_INTERVAL;
2922
		ha->mr.fw_critemp_timer_tick = QLAFX00_CRITEMP_INTERVAL;
2923
		ha->mr.fw_hbt_en = 1;
2924 2925
		ha->mr.host_info_resend = false;
		ha->mr.hinfo_resend_timer_tick = QLAFX00_HINFO_RESEND_INTERVAL;
2926 2927 2928 2929
	} else if (IS_QLA27XX(ha)) {
		ha->portnum = PCI_FUNC(ha->pdev->devfn);
		ha->max_fibre_devices = MAX_FIBRE_DEVICES_2400;
		ha->mbx_count = MAILBOX_REGISTER_COUNT;
Q
Quinn Tran 已提交
2930 2931
		req_length = REQUEST_ENTRY_CNT_83XX;
		rsp_length = RESPONSE_ENTRY_CNT_83XX;
2932
		ha->tgt.atio_q_length = ATIO_ENTRY_CNT_24XX;
2933 2934 2935 2936 2937 2938 2939 2940 2941 2942
		ha->max_loop_id = SNS_LAST_LOOP_ID_2300;
		ha->init_cb_size = sizeof(struct mid_init_cb_81xx);
		ha->gid_list_info_size = 8;
		ha->optrom_size = OPTROM_SIZE_83XX;
		ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX;
		ha->isp_ops = &qla27xx_isp_ops;
		ha->flash_conf_off = FARX_ACCESS_FLASH_CONF_81XX;
		ha->flash_data_off = FARX_ACCESS_FLASH_DATA_81XX;
		ha->nvram_conf_off = ~0;
		ha->nvram_data_off = ~0;
L
Linus Torvalds 已提交
2943
	}
2944

2945 2946 2947
	ql_dbg_pci(ql_dbg_init, pdev, 0x001e,
	    "mbx_count=%d, req_length=%d, "
	    "rsp_length=%d, max_loop_id=%d, init_cb_size=%d, "
2948 2949
	    "gid_list_info_size=%d, optrom_size=%d, nvram_npiv_size=%d, "
	    "max_fibre_devices=%d.\n",
2950 2951
	    ha->mbx_count, req_length, rsp_length, ha->max_loop_id,
	    ha->init_cb_size, ha->gid_list_info_size, ha->optrom_size,
2952
	    ha->nvram_npiv_size, ha->max_fibre_devices);
2953 2954 2955 2956 2957
	ql_dbg_pci(ql_dbg_init, pdev, 0x001f,
	    "isp_ops=%p, flash_conf_off=%d, "
	    "flash_data_off=%d, nvram_conf_off=%d, nvram_data_off=%d.\n",
	    ha->isp_ops, ha->flash_conf_off, ha->flash_data_off,
	    ha->nvram_conf_off, ha->nvram_data_off);
2958 2959 2960 2961

	/* Configure PCI I/O space */
	ret = ha->isp_ops->iospace_config(ha);
	if (ret)
2962
		goto iospace_config_failed;
2963 2964 2965 2966

	ql_log_pci(ql_log_info, pdev, 0x001d,
	    "Found an ISP%04X irq %d iobase 0x%p.\n",
	    pdev->device, pdev->irq, ha->iobase);
2967
	mutex_init(&ha->vport_lock);
2968
	mutex_init(&ha->mq_lock);
2969 2970 2971
	init_completion(&ha->mbx_cmd_comp);
	complete(&ha->mbx_cmd_comp);
	init_completion(&ha->mbx_intr_comp);
2972
	init_completion(&ha->dcbx_comp);
2973
	init_completion(&ha->lb_portup_comp);
L
Linus Torvalds 已提交
2974

2975
	set_bit(0, (unsigned long *) ha->vp_idx_map);
L
Linus Torvalds 已提交
2976

2977
	qla2x00_config_dma_addressing(ha);
2978 2979 2980 2981
	ql_dbg_pci(ql_dbg_init, pdev, 0x0020,
	    "64 Bit addressing is %s.\n",
	    ha->flags.enable_64bit_addressing ? "enable" :
	    "disable");
2982
	ret = qla2x00_mem_alloc(ha, req_length, rsp_length, &req, &rsp);
2983
	if (ret) {
2984 2985
		ql_log_pci(ql_log_fatal, pdev, 0x0031,
		    "Failed to allocate memory for adapter, aborting.\n");
L
Linus Torvalds 已提交
2986

2987 2988 2989
		goto probe_hw_failed;
	}

2990
	req->max_q_depth = MAX_Q_DEPTH;
2991
	if (ql2xmaxqdepth != 0 && ql2xmaxqdepth <= 0xffffU)
2992 2993
		req->max_q_depth = ql2xmaxqdepth;

2994 2995 2996

	base_vha = qla2x00_create_host(sht, ha);
	if (!base_vha) {
2997
		ret = -ENOMEM;
2998
		qla2x00_mem_free(ha);
2999 3000
		qla2x00_free_req_que(ha, req);
		qla2x00_free_rsp_que(ha, rsp);
3001
		goto probe_hw_failed;
L
Linus Torvalds 已提交
3002 3003
	}

3004
	pci_set_drvdata(pdev, base_vha);
3005
	set_bit(PFLG_DRIVER_PROBING, &base_vha->pci_flags);
3006 3007

	host = base_vha->host;
3008
	base_vha->req = req;
3009
	if (IS_QLA2XXX_MIDTYPE(ha))
3010
		base_vha->mgmt_svr_loop_id = 10 + base_vha->vp_idx;
3011
	else
3012 3013
		base_vha->mgmt_svr_loop_id = MANAGEMENT_SERVER +
						base_vha->vp_idx;
3014

3015 3016 3017 3018 3019 3020 3021 3022
	/* Setup fcport template structure. */
	ha->mr.fcport.vha = base_vha;
	ha->mr.fcport.port_type = FCT_UNKNOWN;
	ha->mr.fcport.loop_id = FC_NO_LOOP_ID;
	qla2x00_set_fcport_state(&ha->mr.fcport, FCS_UNCONFIGURED);
	ha->mr.fcport.supported_classes = FC_COS_UNSPECIFIED;
	ha->mr.fcport.scan_state = 1;

3023 3024 3025 3026 3027 3028 3029 3030
	/* Set the SG table size based on ISP type */
	if (!IS_FWI2_CAPABLE(ha)) {
		if (IS_QLA2100(ha))
			host->sg_tablesize = 32;
	} else {
		if (!IS_QLA82XX(ha))
			host->sg_tablesize = QLA_SG_ALL;
	}
3031
	host->max_id = ha->max_fibre_devices;
3032 3033
	host->cmd_per_lun = 3;
	host->unique_id = host->host_no;
3034
	if (IS_T10_PI_CAPABLE(ha) && ql2xenabledif)
3035 3036 3037
		host->max_cmd_len = 32;
	else
		host->max_cmd_len = MAX_CMDSZ;
3038
	host->max_channel = MAX_BUSES - 1;
3039 3040 3041 3042 3043 3044
	/* Older HBAs support only 16-bit LUNs */
	if (!IS_QLAFX00(ha) && !IS_FWI2_CAPABLE(ha) &&
	    ql2xmaxlun > 0xffff)
		host->max_lun = 0xffff;
	else
		host->max_lun = ql2xmaxlun;
3045
	host->transportt = qla2xxx_transport_template;
3046
	sht->vendor_id = (SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_QLOGIC);
3047

3048 3049 3050
	ql_dbg(ql_dbg_init, base_vha, 0x0033,
	    "max_id=%d this_id=%d "
	    "cmd_per_len=%d unique_id=%d max_cmd_len=%d max_channel=%d "
3051
	    "max_lun=%llu transportt=%p, vendor_id=%llu.\n", host->max_id,
3052 3053 3054 3055
	    host->this_id, host->cmd_per_lun, host->unique_id,
	    host->max_cmd_len, host->max_channel, host->max_lun,
	    host->transportt, sht->vendor_id);

3056 3057 3058 3059 3060
	/* Set up the irqs */
	ret = qla2x00_request_irqs(ha, rsp);
	if (ret)
		goto probe_init_failed;

3061 3062 3063 3064 3065 3066 3067 3068
	/* Alloc arrays of request and response ring ptrs */
	if (!qla2x00_alloc_queues(ha, req, rsp)) {
		ql_log(ql_log_fatal, base_vha, 0x003d,
		    "Failed to allocate memory for queue pointers..."
		    "aborting.\n");
		goto probe_init_failed;
	}

3069 3070 3071 3072 3073 3074 3075 3076 3077 3078
	if (ha->mqenable && shost_use_blk_mq(host)) {
		/* number of hardware queues supported by blk/scsi-mq*/
		host->nr_hw_queues = ha->max_qpairs;

		ql_dbg(ql_dbg_init, base_vha, 0x0192,
			"blk/scsi-mq enabled, HW queues = %d.\n", host->nr_hw_queues);
	} else
		ql_dbg(ql_dbg_init, base_vha, 0x0193,
			"blk/scsi-mq disabled.\n");

3079
	qlt_probe_one_stage1(base_vha, ha);
3080

3081 3082
	pci_save_state(pdev);

3083
	/* Assign back pointers */
3084 3085
	rsp->req = req;
	req->rsp = rsp;
3086

3087 3088 3089 3090 3091 3092 3093
	if (IS_QLAFX00(ha)) {
		ha->rsp_q_map[0] = rsp;
		ha->req_q_map[0] = req;
		set_bit(0, ha->req_qid_map);
		set_bit(0, ha->rsp_qid_map);
	}

3094 3095 3096 3097 3098
	/* FWI2-capable only. */
	req->req_q_in = &ha->iobase->isp24.req_q_in;
	req->req_q_out = &ha->iobase->isp24.req_q_out;
	rsp->rsp_q_in = &ha->iobase->isp24.rsp_q_in;
	rsp->rsp_q_out = &ha->iobase->isp24.rsp_q_out;
3099
	if (ha->mqenable || IS_QLA83XX(ha) || IS_QLA27XX(ha)) {
3100 3101 3102 3103
		req->req_q_in = &ha->mqiobase->isp25mq.req_q_in;
		req->req_q_out = &ha->mqiobase->isp25mq.req_q_out;
		rsp->rsp_q_in = &ha->mqiobase->isp25mq.rsp_q_in;
		rsp->rsp_q_out =  &ha->mqiobase->isp25mq.rsp_q_out;
3104 3105
	}

3106 3107 3108 3109 3110 3111 3112
	if (IS_QLAFX00(ha)) {
		req->req_q_in = &ha->iobase->ispfx00.req_q_in;
		req->req_q_out = &ha->iobase->ispfx00.req_q_out;
		rsp->rsp_q_in = &ha->iobase->ispfx00.rsp_q_in;
		rsp->rsp_q_out = &ha->iobase->ispfx00.rsp_q_out;
	}

3113
	if (IS_P3P_TYPE(ha)) {
3114 3115 3116 3117 3118
		req->req_q_out = &ha->iobase->isp82.req_q_out[0];
		rsp->rsp_q_in = &ha->iobase->isp82.rsp_q_in[0];
		rsp->rsp_q_out = &ha->iobase->isp82.rsp_q_out[0];
	}

3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132
	ql_dbg(ql_dbg_multiq, base_vha, 0xc009,
	    "rsp_q_map=%p req_q_map=%p rsp->req=%p req->rsp=%p.\n",
	    ha->rsp_q_map, ha->req_q_map, rsp->req, req->rsp);
	ql_dbg(ql_dbg_multiq, base_vha, 0xc00a,
	    "req->req_q_in=%p req->req_q_out=%p "
	    "rsp->rsp_q_in=%p rsp->rsp_q_out=%p.\n",
	    req->req_q_in, req->req_q_out,
	    rsp->rsp_q_in, rsp->rsp_q_out);
	ql_dbg(ql_dbg_init, base_vha, 0x003e,
	    "rsp_q_map=%p req_q_map=%p rsp->req=%p req->rsp=%p.\n",
	    ha->rsp_q_map, ha->req_q_map, rsp->req, req->rsp);
	ql_dbg(ql_dbg_init, base_vha, 0x003f,
	    "req->req_q_in=%p req->req_q_out=%p rsp->rsp_q_in=%p rsp->rsp_q_out=%p.\n",
	    req->req_q_in, req->req_q_out, rsp->rsp_q_in, rsp->rsp_q_out);
L
Linus Torvalds 已提交
3133

3134
	if (ha->isp_ops->initialize_adapter(base_vha)) {
3135 3136 3137
		ql_log(ql_log_fatal, base_vha, 0x00d6,
		    "Failed to initialize adapter - Adapter flags %x.\n",
		    base_vha->device_flags);
L
Linus Torvalds 已提交
3138

3139 3140 3141
		if (IS_QLA82XX(ha)) {
			qla82xx_idc_lock(ha);
			qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
3142
				QLA8XXX_DEV_FAILED);
3143
			qla82xx_idc_unlock(ha);
3144 3145
			ql_log(ql_log_fatal, base_vha, 0x00d7,
			    "HW State: FAILED.\n");
3146 3147 3148 3149 3150 3151 3152 3153
		} else if (IS_QLA8044(ha)) {
			qla8044_idc_lock(ha);
			qla8044_wr_direct(base_vha,
				QLA8044_CRB_DEV_STATE_INDEX,
				QLA8XXX_DEV_FAILED);
			qla8044_idc_unlock(ha);
			ql_log(ql_log_fatal, base_vha, 0x0150,
			    "HW State: FAILED.\n");
3154 3155
		}

3156
		ret = -ENODEV;
L
Linus Torvalds 已提交
3157 3158 3159
		goto probe_failed;
	}

3160 3161 3162 3163 3164 3165 3166 3167 3168 3169
	if (IS_QLAFX00(ha))
		host->can_queue = QLAFX00_MAX_CANQUEUE;
	else
		host->can_queue = req->num_outstanding_cmds - 10;

	ql_dbg(ql_dbg_init, base_vha, 0x0032,
	    "can_queue=%d, req=%p, mgmt_svr_loop_id=%d, sg_tablesize=%d.\n",
	    host->can_queue, base_vha->req,
	    base_vha->mgmt_svr_loop_id, host->sg_tablesize);

3170 3171 3172
	if (ha->mqenable) {
		bool mq = false;
		bool startit = false;
3173
		ha->wq = alloc_workqueue("qla2xxx_wq", WQ_MEM_RECLAIM, 1);
3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187

		if (QLA_TGT_MODE_ENABLED()) {
			mq = true;
			startit = false;
		}

		if ((ql2x_ini_mode == QLA2XXX_INI_MODE_ENABLED) &&
		    shost_use_blk_mq(host)) {
			mq = true;
			startit = true;
		}

		if (mq) {
			/* Create start of day qpairs for Block MQ */
3188
			for (i = 0; i < ha->max_qpairs; i++)
3189
				qla2xxx_create_qpair(base_vha, 5, 0, startit);
3190 3191
		}
	}
3192

3193 3194 3195
	if (ha->flags.running_gold_fw)
		goto skip_dpc;

L
Linus Torvalds 已提交
3196 3197 3198
	/*
	 * Startup the kernel thread for this host adapter
	 */
3199
	ha->dpc_thread = kthread_create(qla2x00_do_dpc, ha,
3200
	    "%s_dpc", base_vha->host_str);
3201
	if (IS_ERR(ha->dpc_thread)) {
3202 3203
		ql_log(ql_log_fatal, base_vha, 0x00ed,
		    "Failed to start DPC thread.\n");
3204
		ret = PTR_ERR(ha->dpc_thread);
L
Linus Torvalds 已提交
3205 3206
		goto probe_failed;
	}
3207 3208
	ql_dbg(ql_dbg_init, base_vha, 0x00ee,
	    "DPC thread started successfully.\n");
L
Linus Torvalds 已提交
3209

3210 3211 3212 3213 3214 3215 3216 3217
	/*
	 * If we're not coming up in initiator mode, we might sit for
	 * a while without waking up the dpc thread, which leads to a
	 * stuck process warning.  So just kick the dpc once here and
	 * let the kthread start (and go back to sleep in qla2x00_do_dpc).
	 */
	qla2xxx_wake_dpc(base_vha);

3218
	INIT_WORK(&base_vha->iocb_work, qla2x00_iocb_work_fn);
3219 3220
	INIT_WORK(&ha->board_disable, qla2x00_disable_board_on_pci_error);

3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234
	if (IS_QLA8031(ha) || IS_MCTP_CAPABLE(ha)) {
		sprintf(wq_name, "qla2xxx_%lu_dpc_lp_wq", base_vha->host_no);
		ha->dpc_lp_wq = create_singlethread_workqueue(wq_name);
		INIT_WORK(&ha->idc_aen, qla83xx_service_idc_aen);

		sprintf(wq_name, "qla2xxx_%lu_dpc_hp_wq", base_vha->host_no);
		ha->dpc_hp_wq = create_singlethread_workqueue(wq_name);
		INIT_WORK(&ha->nic_core_reset, qla83xx_nic_core_reset_work);
		INIT_WORK(&ha->idc_state_handler,
		    qla83xx_idc_state_handler_work);
		INIT_WORK(&ha->nic_core_unrecoverable,
		    qla83xx_nic_core_unrecoverable_work);
	}

3235
skip_dpc:
3236 3237
	list_add_tail(&base_vha->list, &ha->vp_list);
	base_vha->host->irq = ha->pdev->irq;
L
Linus Torvalds 已提交
3238 3239

	/* Initialized the timer */
3240
	qla2x00_start_timer(base_vha, qla2x00_timer, WATCH_INTERVAL);
3241 3242 3243 3244 3245 3246
	ql_dbg(ql_dbg_init, base_vha, 0x00ef,
	    "Started qla2x00_timer with "
	    "interval=%d.\n", WATCH_INTERVAL);
	ql_dbg(ql_dbg_init, base_vha, 0x00f0,
	    "Detected hba at address=%p.\n",
	    ha);
3247

3248
	if (IS_T10_PI_CAPABLE(ha) && ql2xenabledif) {
3249
		if (ha->fw_attributes & BIT_4) {
3250
			int prot = 0, guard;
3251
			base_vha->flags.difdix_supported = 1;
3252 3253
			ql_dbg(ql_dbg_init, base_vha, 0x00f1,
			    "Registering for DIF/DIX type 1 and 3 protection.\n");
3254 3255
			if (ql2xenabledif == 1)
				prot = SHOST_DIX_TYPE0_PROTECTION;
3256
			scsi_host_set_prot(host,
3257
			    prot | SHOST_DIF_TYPE1_PROTECTION
3258
			    | SHOST_DIF_TYPE2_PROTECTION
3259 3260
			    | SHOST_DIF_TYPE3_PROTECTION
			    | SHOST_DIX_TYPE1_PROTECTION
3261
			    | SHOST_DIX_TYPE2_PROTECTION
3262
			    | SHOST_DIX_TYPE3_PROTECTION);
3263 3264 3265 3266 3267 3268 3269 3270

			guard = SHOST_DIX_GUARD_CRC;

			if (IS_PI_IPGUARD_CAPABLE(ha) &&
			    (ql2xenabledif > 1 || IS_PI_DIFB_DIX0_CAPABLE(ha)))
				guard |= SHOST_DIX_GUARD_IP;

			scsi_host_set_guard(host, guard);
3271 3272 3273 3274
		} else
			base_vha->flags.difdix_supported = 0;
	}

3275 3276
	ha->isp_ops->enable_intrs(ha);

3277 3278 3279 3280 3281 3282 3283
	if (IS_QLAFX00(ha)) {
		ret = qlafx00_fx_disc(base_vha,
			&base_vha->hw->mr.fcport, FXDISC_GET_CONFIG_INFO);
		host->sg_tablesize = (ha->mr.extended_io_enabled) ?
		    QLA_SG_ALL : 128;
	}

3284 3285 3286 3287
	ret = scsi_add_host(host, &pdev->dev);
	if (ret)
		goto probe_failed;

3288 3289
	base_vha->flags.init_done = 1;
	base_vha->flags.online = 1;
3290
	ha->prev_minidump_failed = 0;
3291

3292 3293 3294
	ql_dbg(ql_dbg_init, base_vha, 0x00f2,
	    "Init done and hba is online.\n");

3295 3296
	if (qla_ini_mode_enabled(base_vha) ||
		qla_dual_mode_enabled(base_vha))
3297 3298 3299 3300
		scsi_scan_host(host);
	else
		ql_dbg(ql_dbg_init, base_vha, 0x0122,
			"skipping scsi_scan_host() for non-initiator port\n");
3301

3302
	qla2x00_alloc_sysfs_attr(base_vha);
3303

3304 3305 3306 3307 3308 3309 3310 3311 3312
	if (IS_QLAFX00(ha)) {
		ret = qlafx00_fx_disc(base_vha,
			&base_vha->hw->mr.fcport, FXDISC_GET_PORT_INFO);

		/* Register system information */
		ret =  qlafx00_fx_disc(base_vha,
			&base_vha->hw->mr.fcport, FXDISC_REG_HOST_INFO);
	}

3313
	qla2x00_init_host_attr(base_vha);
3314

3315
	qla2x00_dfs_setup(base_vha);
3316

3317 3318
	ql_log(ql_log_info, base_vha, 0x00fb,
	    "QLogic %s - %s.\n", ha->model_number, ha->model_desc);
3319 3320 3321 3322 3323
	ql_log(ql_log_info, base_vha, 0x00fc,
	    "ISP%04X: %s @ %s hdma%c host#=%ld fw=%s.\n",
	    pdev->device, ha->isp_ops->pci_info_str(base_vha, pci_info),
	    pci_name(pdev), ha->flags.enable_64bit_addressing ? '+' : '-',
	    base_vha->host_no,
3324
	    ha->isp_ops->fw_version_str(base_vha, fw_str, sizeof(fw_str)));
L
Linus Torvalds 已提交
3325

3326 3327
	qlt_add_target(ha, base_vha);

3328
	clear_bit(PFLG_DRIVER_PROBING, &base_vha->pci_flags);
3329 3330 3331 3332

	if (test_bit(UNLOADING, &base_vha->dpc_flags))
		return -ENODEV;

L
Linus Torvalds 已提交
3333 3334
	return 0;

3335
probe_init_failed:
3336
	qla2x00_free_req_que(ha, req);
3337 3338
	ha->req_q_map[0] = NULL;
	clear_bit(0, ha->req_qid_map);
3339
	qla2x00_free_rsp_que(ha, rsp);
3340 3341
	ha->rsp_q_map[0] = NULL;
	clear_bit(0, ha->rsp_qid_map);
3342
	ha->max_req_queues = ha->max_rsp_queues = 0;
3343

L
Linus Torvalds 已提交
3344
probe_failed:
3345 3346 3347 3348 3349 3350 3351 3352 3353 3354
	if (base_vha->timer_active)
		qla2x00_stop_timer(base_vha);
	base_vha->flags.online = 0;
	if (ha->dpc_thread) {
		struct task_struct *t = ha->dpc_thread;

		ha->dpc_thread = NULL;
		kthread_stop(t);
	}

3355
	qla2x00_free_device(base_vha);
L
Linus Torvalds 已提交
3356

3357
	scsi_host_put(base_vha->host);
L
Linus Torvalds 已提交
3358

3359
probe_hw_failed:
3360 3361
	qla2x00_clear_drv_active(ha);

3362
iospace_config_failed:
3363
	if (IS_P3P_TYPE(ha)) {
3364
		if (!ha->nx_pcibase)
3365
			iounmap((device_reg_t *)ha->nx_pcibase);
3366
		if (!ql2xdbwr)
3367
			iounmap((device_reg_t *)ha->nxdb_wr_ptr);
3368 3369 3370
	} else {
		if (ha->iobase)
			iounmap(ha->iobase);
3371 3372
		if (ha->cregbase)
			iounmap(ha->cregbase);
3373
	}
3374 3375
	pci_release_selected_regions(ha->pdev, ha->bars);
	kfree(ha);
L
Linus Torvalds 已提交
3376

3377
disable_device:
3378
	pci_disable_device(pdev);
3379
	return ret;
L
Linus Torvalds 已提交
3380 3381
}

3382 3383 3384 3385 3386 3387
static void
qla2x00_shutdown(struct pci_dev *pdev)
{
	scsi_qla_host_t *vha;
	struct qla_hw_data  *ha;

3388 3389 3390
	if (!atomic_read(&pdev->enable_cnt))
		return;

3391 3392 3393
	vha = pci_get_drvdata(pdev);
	ha = vha->hw;

3394 3395 3396 3397
	/* Notify ISPFX00 firmware */
	if (IS_QLAFX00(ha))
		qlafx00_driver_shutdown(vha, 20);

3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422
	/* Turn-off FCE trace */
	if (ha->flags.fce_enabled) {
		qla2x00_disable_fce_trace(vha, NULL, NULL);
		ha->flags.fce_enabled = 0;
	}

	/* Turn-off EFT trace */
	if (ha->eft)
		qla2x00_disable_eft_trace(vha);

	/* Stop currently executing firmware. */
	qla2x00_try_to_stop_firmware(vha);

	/* Turn adapter off line */
	vha->flags.online = 0;

	/* turn-off interrupts on the card */
	if (ha->interrupts_on) {
		vha->flags.init_done = 0;
		ha->isp_ops->disable_intrs(ha);
	}

	qla2x00_free_irqs(vha);

	qla2x00_free_fw_dump(ha);
3423 3424 3425

	pci_disable_pcie_error_reporting(pdev);
	pci_disable_device(pdev);
3426 3427
}

3428
/* Deletes all the virtual ports for a given ha */
A
Adrian Bunk 已提交
3429
static void
3430
qla2x00_delete_all_vps(struct qla_hw_data *ha, scsi_qla_host_t *base_vha)
L
Linus Torvalds 已提交
3431
{
3432
	scsi_qla_host_t *vha;
3433
	unsigned long flags;
3434

3435 3436 3437
	mutex_lock(&ha->vport_lock);
	while (ha->cur_vport_count) {
		spin_lock_irqsave(&ha->vport_slock, flags);
3438

3439 3440 3441
		BUG_ON(base_vha->list.next == &ha->vp_list);
		/* This assumes first entry in ha->vp_list is always base vha */
		vha = list_first_entry(&base_vha->list, scsi_qla_host_t, list);
3442
		scsi_host_get(vha->host);
3443

3444 3445 3446 3447 3448
		spin_unlock_irqrestore(&ha->vport_slock, flags);
		mutex_unlock(&ha->vport_lock);

		fc_vport_terminate(vha->fc_vport);
		scsi_host_put(vha->host);
3449

3450
		mutex_lock(&ha->vport_lock);
3451
	}
3452
	mutex_unlock(&ha->vport_lock);
3453
}
L
Linus Torvalds 已提交
3454

3455 3456 3457 3458
/* Stops all deferred work threads */
static void
qla2x00_destroy_deferred_work(struct qla_hw_data *ha)
{
3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473
	/* Cancel all work and destroy DPC workqueues */
	if (ha->dpc_lp_wq) {
		cancel_work_sync(&ha->idc_aen);
		destroy_workqueue(ha->dpc_lp_wq);
		ha->dpc_lp_wq = NULL;
	}

	if (ha->dpc_hp_wq) {
		cancel_work_sync(&ha->nic_core_reset);
		cancel_work_sync(&ha->idc_state_handler);
		cancel_work_sync(&ha->nic_core_unrecoverable);
		destroy_workqueue(ha->dpc_hp_wq);
		ha->dpc_hp_wq = NULL;
	}

3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484
	/* Kill the kernel thread for this host */
	if (ha->dpc_thread) {
		struct task_struct *t = ha->dpc_thread;

		/*
		 * qla2xxx_wake_dpc checks for ->dpc_thread
		 * so we need to zero it out.
		 */
		ha->dpc_thread = NULL;
		kthread_stop(t);
	}
3485
}
L
Linus Torvalds 已提交
3486

3487 3488 3489
static void
qla2x00_unmap_iobases(struct qla_hw_data *ha)
{
3490
	if (IS_QLA82XX(ha)) {
3491

3492
		iounmap((device_reg_t *)ha->nx_pcibase);
3493
		if (!ql2xdbwr)
3494
			iounmap((device_reg_t *)ha->nxdb_wr_ptr);
3495 3496 3497
	} else {
		if (ha->iobase)
			iounmap(ha->iobase);
L
Linus Torvalds 已提交
3498

3499 3500 3501
		if (ha->cregbase)
			iounmap(ha->cregbase);

3502 3503
		if (ha->mqiobase)
			iounmap(ha->mqiobase);
3504

3505
		if ((IS_QLA83XX(ha) || IS_QLA27XX(ha)) && ha->msixbase)
3506
			iounmap(ha->msixbase);
3507
	}
3508 3509 3510
}

static void
3511
qla2x00_clear_drv_active(struct qla_hw_data *ha)
3512 3513 3514
{
	if (IS_QLA8044(ha)) {
		qla8044_idc_lock(ha);
3515
		qla8044_clear_drv_active(ha);
3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529
		qla8044_idc_unlock(ha);
	} else if (IS_QLA82XX(ha)) {
		qla82xx_idc_lock(ha);
		qla82xx_clear_drv_active(ha);
		qla82xx_idc_unlock(ha);
	}
}

static void
qla2x00_remove_one(struct pci_dev *pdev)
{
	scsi_qla_host_t *base_vha;
	struct qla_hw_data  *ha;

3530 3531 3532 3533 3534 3535 3536 3537
	base_vha = pci_get_drvdata(pdev);
	ha = base_vha->hw;

	/* Indicate device removal to prevent future board_disable and wait
	 * until any pending board_disable has completed. */
	set_bit(PFLG_DRIVER_REMOVING, &base_vha->pci_flags);
	cancel_work_sync(&ha->board_disable);

3538
	/*
3539 3540 3541
	 * If the PCI device is disabled then there was a PCI-disconnect and
	 * qla2x00_disable_board_on_pci_error has taken care of most of the
	 * resources.
3542
	 */
3543
	if (!atomic_read(&pdev->enable_cnt)) {
3544 3545 3546
		dma_free_coherent(&ha->pdev->dev, base_vha->gnl.size,
		    base_vha->gnl.l, base_vha->gnl.ldma);

3547 3548 3549
		scsi_host_put(base_vha->host);
		kfree(ha);
		pci_set_drvdata(pdev, NULL);
3550
		return;
3551
	}
3552 3553
	qla2x00_wait_for_hba_ready(base_vha);

3554 3555
	/*
	 * if UNLOAD flag is already set, then continue unload,
3556 3557 3558 3559 3560
	 * where it was set first.
	 */
	if (test_bit(UNLOADING, &base_vha->dpc_flags))
		return;

3561
	set_bit(UNLOADING, &base_vha->dpc_flags);
3562 3563 3564

	qla_nvme_delete(base_vha);

3565 3566
	dma_free_coherent(&ha->pdev->dev,
		base_vha->gnl.size, base_vha->gnl.l, base_vha->gnl.ldma);
3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586

	if (IS_QLAFX00(ha))
		qlafx00_driver_shutdown(base_vha, 20);

	qla2x00_delete_all_vps(ha, base_vha);

	if (IS_QLA8031(ha)) {
		ql_dbg(ql_dbg_p3p, base_vha, 0xb07e,
		    "Clearing fcoe driver presence.\n");
		if (qla83xx_clear_drv_presence(base_vha) != QLA_SUCCESS)
			ql_dbg(ql_dbg_p3p, base_vha, 0xb079,
			    "Error while clearing DRV-Presence.\n");
	}

	qla2x00_abort_all_cmds(base_vha, DID_NO_CONNECT << 16);

	qla2x00_dfs_remove(base_vha);

	qla84xx_put_chip(base_vha);

3587 3588 3589 3590
	/* Laser should be disabled only for ISP2031 */
	if (IS_QLA2031(ha))
		qla83xx_disable_laser(base_vha);

3591 3592 3593 3594 3595 3596
	/* Disable timer */
	if (base_vha->timer_active)
		qla2x00_stop_timer(base_vha);

	base_vha->flags.online = 0;

3597 3598 3599 3600
	/* free DMA memory */
	if (ha->exlogin_buf)
		qla2x00_free_exlogin_buffer(ha);

3601 3602 3603 3604
	/* free DMA memory */
	if (ha->exchoffld_buf)
		qla2x00_free_exchoffld_buffer(ha);

3605 3606 3607 3608 3609 3610 3611
	qla2x00_destroy_deferred_work(ha);

	qlt_remove_target(ha, base_vha);

	qla2x00_free_sysfs_attr(base_vha, true);

	fc_remove_host(base_vha->host);
3612
	qlt_remove_target_resources(ha);
3613 3614 3615 3616 3617

	scsi_remove_host(base_vha->host);

	qla2x00_free_device(base_vha);

3618
	qla2x00_clear_drv_active(ha);
3619

3620 3621
	scsi_host_put(base_vha->host);

3622
	qla2x00_unmap_iobases(ha);
3623

3624 3625
	pci_release_selected_regions(ha->pdev, ha->bars);
	kfree(ha);
L
Linus Torvalds 已提交
3626

3627 3628
	pci_disable_pcie_error_reporting(pdev);

3629
	pci_disable_device(pdev);
L
Linus Torvalds 已提交
3630 3631 3632
}

static void
3633
qla2x00_free_device(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
3634
{
3635
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
3636

3637 3638 3639 3640 3641 3642
	qla2x00_abort_all_cmds(vha, DID_NO_CONNECT << 16);

	/* Disable timer */
	if (vha->timer_active)
		qla2x00_stop_timer(vha);

3643
	qla25xx_delete_queues(vha);
3644

3645
	if (ha->flags.fce_enabled)
3646
		qla2x00_disable_fce_trace(vha, NULL, NULL);
3647

3648
	if (ha->eft)
3649
		qla2x00_disable_eft_trace(vha);
3650

3651
	/* Stop currently executing firmware. */
3652
	qla2x00_try_to_stop_firmware(vha);
L
Linus Torvalds 已提交
3653

3654 3655
	vha->flags.online = 0;

3656
	/* turn-off interrupts on the card */
3657 3658
	if (ha->interrupts_on) {
		vha->flags.init_done = 0;
3659
		ha->isp_ops->disable_intrs(ha);
3660
	}
3661

3662 3663
	qla2x00_free_fcports(vha);

3664
	qla2x00_free_irqs(vha);
L
Linus Torvalds 已提交
3665

3666 3667 3668 3669 3670 3671 3672
	/* Flush the work queue and remove it */
	if (ha->wq) {
		flush_workqueue(ha->wq);
		destroy_workqueue(ha->wq);
		ha->wq = NULL;
	}

3673

3674
	qla2x00_mem_free(ha);
3675

3676 3677
	qla82xx_md_free(vha);

3678
	qla2x00_free_queues(ha);
L
Linus Torvalds 已提交
3679 3680
}

3681 3682 3683 3684 3685 3686
void qla2x00_free_fcports(struct scsi_qla_host *vha)
{
	fc_port_t *fcport, *tfcport;

	list_for_each_entry_safe(fcport, tfcport, &vha->vp_fcports, list) {
		list_del(&fcport->list);
3687
		qla2x00_clear_loop_id(fcport);
3688 3689 3690 3691
		kfree(fcport);
	}
}

3692
static inline void
3693
qla2x00_schedule_rport_del(struct scsi_qla_host *vha, fc_port_t *fcport,
3694 3695 3696
    int defer)
{
	struct fc_rport *rport;
3697
	scsi_qla_host_t *base_vha;
3698
	unsigned long flags;
3699 3700 3701 3702 3703 3704

	if (!fcport->rport)
		return;

	rport = fcport->rport;
	if (defer) {
3705
		base_vha = pci_get_drvdata(vha->hw->pdev);
3706
		spin_lock_irqsave(vha->host->host_lock, flags);
3707
		fcport->drport = rport;
3708
		spin_unlock_irqrestore(vha->host->host_lock, flags);
3709
		qlt_do_generation_tick(vha, &base_vha->total_fcport_update_gen);
3710 3711
		set_bit(FCPORT_UPDATE_NEEDED, &base_vha->dpc_flags);
		qla2xxx_wake_dpc(base_vha);
3712
	} else {
3713
		int now;
3714
		if (rport) {
3715 3716 3717 3718
			ql_dbg(ql_dbg_disc, fcport->vha, 0x2109,
			    "%s %8phN. rport %p roles %x\n",
			    __func__, fcport->port_name, rport,
			    rport->roles);
3719
			fc_remote_port_delete(rport);
3720
		}
3721
		qlt_do_generation_tick(vha, &now);
3722
	}
3723 3724
}

L
Linus Torvalds 已提交
3725 3726 3727 3728 3729 3730 3731 3732 3733
/*
 * qla2x00_mark_device_lost Updates fcport state when device goes offline.
 *
 * Input: ha = adapter block pointer.  fcport = port structure pointer.
 *
 * Return: None.
 *
 * Context:
 */
3734
void qla2x00_mark_device_lost(scsi_qla_host_t *vha, fc_port_t *fcport,
3735
    int do_login, int defer)
L
Linus Torvalds 已提交
3736
{
3737 3738 3739 3740 3741 3742
	if (IS_QLAFX00(vha->hw)) {
		qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
		qla2x00_schedule_rport_del(vha, fcport, defer);
		return;
	}

3743
	if (atomic_read(&fcport->state) == FCS_ONLINE &&
3744
	    vha->vp_idx == fcport->vha->vp_idx) {
3745
		qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
3746 3747
		qla2x00_schedule_rport_del(vha, fcport, defer);
	}
A
Andrew Vasquez 已提交
3748
	/*
L
Linus Torvalds 已提交
3749 3750 3751 3752
	 * We may need to retry the login, so don't change the state of the
	 * port but do the retries.
	 */
	if (atomic_read(&fcport->state) != FCS_DEVICE_DEAD)
3753
		qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
L
Linus Torvalds 已提交
3754 3755 3756 3757

	if (!do_login)
		return;

3758 3759
	set_bit(RELOGIN_NEEDED, &vha->dpc_flags);

L
Linus Torvalds 已提交
3760
	if (fcport->login_retry == 0) {
3761
		fcport->login_retry = vha->hw->login_retry_count;
L
Linus Torvalds 已提交
3762

3763
		ql_dbg(ql_dbg_disc, vha, 0x20a3,
3764
		    "Port login retry %8phN, lid 0x%04x retry cnt=%d.\n",
3765
		    fcport->port_name, fcport->loop_id, fcport->login_retry);
L
Linus Torvalds 已提交
3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782
	}
}

/*
 * qla2x00_mark_all_devices_lost
 *	Updates fcport state when device goes offline.
 *
 * Input:
 *	ha = adapter block pointer.
 *	fcport = port structure pointer.
 *
 * Return:
 *	None.
 *
 * Context:
 */
void
3783
qla2x00_mark_all_devices_lost(scsi_qla_host_t *vha, int defer)
L
Linus Torvalds 已提交
3784 3785 3786
{
	fc_port_t *fcport;

3787 3788
	ql_dbg(ql_dbg_disc, vha, 0x20f1,
	    "Mark all dev lost\n");
3789

3790
	list_for_each_entry(fcport, &vha->vp_fcports, list) {
3791 3792 3793
		fcport->scan_state = 0;
		qlt_schedule_sess_for_deletion_lock(fcport);

3794
		if (vha->vp_idx != 0 && vha->vp_idx != fcport->vha->vp_idx)
L
Linus Torvalds 已提交
3795
			continue;
3796

L
Linus Torvalds 已提交
3797 3798 3799 3800 3801 3802
		/*
		 * No point in marking the device as lost, if the device is
		 * already DEAD.
		 */
		if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD)
			continue;
3803
		if (atomic_read(&fcport->state) == FCS_ONLINE) {
3804
			qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
3805 3806
			if (defer)
				qla2x00_schedule_rport_del(vha, fcport, defer);
3807
			else if (vha->vp_idx == fcport->vha->vp_idx)
3808 3809
				qla2x00_schedule_rport_del(vha, fcport, defer);
		}
L
Linus Torvalds 已提交
3810 3811 3812 3813 3814 3815 3816 3817 3818
	}
}

/*
* qla2x00_mem_alloc
*      Allocates adapter memory.
*
* Returns:
*      0  = success.
3819
*      !0  = failure.
L
Linus Torvalds 已提交
3820
*/
3821
static int
3822 3823
qla2x00_mem_alloc(struct qla_hw_data *ha, uint16_t req_len, uint16_t rsp_len,
	struct req_que **req, struct rsp_que **rsp)
L
Linus Torvalds 已提交
3824 3825 3826
{
	char	name[16];

3827
	ha->init_cb = dma_alloc_coherent(&ha->pdev->dev, ha->init_cb_size,
3828
		&ha->init_cb_dma, GFP_KERNEL);
3829
	if (!ha->init_cb)
3830
		goto fail;
3831

3832 3833 3834
	if (qlt_mem_alloc(ha) < 0)
		goto fail_free_init_cb;

3835 3836
	ha->gid_list = dma_alloc_coherent(&ha->pdev->dev,
		qla2x00_gid_list_size(ha), &ha->gid_list_dma, GFP_KERNEL);
3837
	if (!ha->gid_list)
3838
		goto fail_free_tgt_mem;
L
Linus Torvalds 已提交
3839

3840 3841
	ha->srb_mempool = mempool_create_slab_pool(SRB_MIN_REQ, srb_cachep);
	if (!ha->srb_mempool)
3842
		goto fail_free_gid_list;
3843

3844
	if (IS_P3P_TYPE(ha)) {
3845 3846 3847 3848 3849 3850
		/* Allocate cache for CT6 Ctx. */
		if (!ctx_cachep) {
			ctx_cachep = kmem_cache_create("qla2xxx_ctx",
				sizeof(struct ct6_dsd), 0,
				SLAB_HWCACHE_ALIGN, NULL);
			if (!ctx_cachep)
3851
				goto fail_free_srb_mempool;
3852 3853 3854 3855 3856
		}
		ha->ctx_mempool = mempool_create_slab_pool(SRB_MIN_REQ,
			ctx_cachep);
		if (!ha->ctx_mempool)
			goto fail_free_srb_mempool;
3857 3858 3859
		ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0021,
		    "ctx_cachep=%p ctx_mempool=%p.\n",
		    ctx_cachep, ha->ctx_mempool);
3860 3861
	}

3862 3863 3864
	/* Get memory for cached NVRAM */
	ha->nvram = kzalloc(MAX_NVRAM_SIZE, GFP_KERNEL);
	if (!ha->nvram)
3865
		goto fail_free_ctx_mempool;
3866

3867 3868 3869 3870 3871 3872 3873
	snprintf(name, sizeof(name), "%s_%d", QLA2XXX_DRIVER_NAME,
		ha->pdev->device);
	ha->s_dma_pool = dma_pool_create(name, &ha->pdev->dev,
		DMA_POOL_SIZE, 8, 0);
	if (!ha->s_dma_pool)
		goto fail_free_nvram;

3874 3875 3876 3877
	ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0022,
	    "init_cb=%p gid_list=%p, srb_mempool=%p s_dma_pool=%p.\n",
	    ha->init_cb, ha->gid_list, ha->srb_mempool, ha->s_dma_pool);

3878
	if (IS_P3P_TYPE(ha) || ql2xenabledif) {
3879 3880 3881
		ha->dl_dma_pool = dma_pool_create(name, &ha->pdev->dev,
			DSD_LIST_DMA_POOL_SIZE, 8, 0);
		if (!ha->dl_dma_pool) {
3882 3883
			ql_log_pci(ql_log_fatal, ha->pdev, 0x0023,
			    "Failed to allocate memory for dl_dma_pool.\n");
3884 3885 3886 3887 3888 3889
			goto fail_s_dma_pool;
		}

		ha->fcp_cmnd_dma_pool = dma_pool_create(name, &ha->pdev->dev,
			FCP_CMND_DMA_POOL_SIZE, 8, 0);
		if (!ha->fcp_cmnd_dma_pool) {
3890 3891
			ql_log_pci(ql_log_fatal, ha->pdev, 0x0024,
			    "Failed to allocate memory for fcp_cmnd_dma_pool.\n");
3892 3893
			goto fail_dl_dma_pool;
		}
3894 3895 3896
		ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0025,
		    "dl_dma_pool=%p fcp_cmnd_dma_pool=%p.\n",
		    ha->dl_dma_pool, ha->fcp_cmnd_dma_pool);
3897 3898
	}

3899 3900
	/* Allocate memory for SNS commands */
	if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
3901
	/* Get consistent memory allocated for SNS commands */
3902
		ha->sns_cmd = dma_alloc_coherent(&ha->pdev->dev,
3903
		sizeof(struct sns_cmd_pkt), &ha->sns_cmd_dma, GFP_KERNEL);
3904
		if (!ha->sns_cmd)
3905
			goto fail_dma_pool;
3906
		ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0026,
3907
		    "sns_cmd: %p.\n", ha->sns_cmd);
3908
	} else {
3909
	/* Get consistent memory allocated for MS IOCB */
3910
		ha->ms_iocb = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
3911
			&ha->ms_iocb_dma);
3912
		if (!ha->ms_iocb)
3913 3914
			goto fail_dma_pool;
	/* Get consistent memory allocated for CT SNS commands */
3915
		ha->ct_sns = dma_alloc_coherent(&ha->pdev->dev,
3916
			sizeof(struct ct_sns_pkt), &ha->ct_sns_dma, GFP_KERNEL);
3917 3918
		if (!ha->ct_sns)
			goto fail_free_ms_iocb;
3919 3920 3921
		ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0027,
		    "ms_iocb=%p ct_sns=%p.\n",
		    ha->ms_iocb, ha->ct_sns);
L
Linus Torvalds 已提交
3922 3923
	}

3924
	/* Allocate memory for request ring */
3925 3926
	*req = kzalloc(sizeof(struct req_que), GFP_KERNEL);
	if (!*req) {
3927 3928
		ql_log_pci(ql_log_fatal, ha->pdev, 0x0028,
		    "Failed to allocate memory for req.\n");
3929 3930
		goto fail_req;
	}
3931 3932 3933 3934 3935
	(*req)->length = req_len;
	(*req)->ring = dma_alloc_coherent(&ha->pdev->dev,
		((*req)->length + 1) * sizeof(request_t),
		&(*req)->dma, GFP_KERNEL);
	if (!(*req)->ring) {
3936 3937
		ql_log_pci(ql_log_fatal, ha->pdev, 0x0029,
		    "Failed to allocate memory for req_ring.\n");
3938 3939 3940
		goto fail_req_ring;
	}
	/* Allocate memory for response ring */
3941 3942
	*rsp = kzalloc(sizeof(struct rsp_que), GFP_KERNEL);
	if (!*rsp) {
3943 3944
		ql_log_pci(ql_log_fatal, ha->pdev, 0x002a,
		    "Failed to allocate memory for rsp.\n");
3945 3946
		goto fail_rsp;
	}
3947 3948 3949 3950 3951 3952
	(*rsp)->hw = ha;
	(*rsp)->length = rsp_len;
	(*rsp)->ring = dma_alloc_coherent(&ha->pdev->dev,
		((*rsp)->length + 1) * sizeof(response_t),
		&(*rsp)->dma, GFP_KERNEL);
	if (!(*rsp)->ring) {
3953 3954
		ql_log_pci(ql_log_fatal, ha->pdev, 0x002b,
		    "Failed to allocate memory for rsp_ring.\n");
3955 3956
		goto fail_rsp_ring;
	}
3957 3958
	(*req)->rsp = *rsp;
	(*rsp)->req = *req;
3959 3960 3961 3962 3963
	ql_dbg_pci(ql_dbg_init, ha->pdev, 0x002c,
	    "req=%p req->length=%d req->ring=%p rsp=%p "
	    "rsp->length=%d rsp->ring=%p.\n",
	    *req, (*req)->length, (*req)->ring, *rsp, (*rsp)->length,
	    (*rsp)->ring);
3964 3965 3966
	/* Allocate memory for NVRAM data for vports */
	if (ha->nvram_npiv_size) {
		ha->npiv_info = kzalloc(sizeof(struct qla_npiv_entry) *
3967
		    ha->nvram_npiv_size, GFP_KERNEL);
3968
		if (!ha->npiv_info) {
3969 3970
			ql_log_pci(ql_log_fatal, ha->pdev, 0x002d,
			    "Failed to allocate memory for npiv_info.\n");
3971 3972 3973 3974
			goto fail_npiv_info;
		}
	} else
		ha->npiv_info = NULL;
3975

3976
	/* Get consistent memory allocated for EX-INIT-CB. */
3977
	if (IS_CNA_CAPABLE(ha) || IS_QLA2031(ha) || IS_QLA27XX(ha)) {
3978 3979 3980 3981
		ha->ex_init_cb = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
		    &ha->ex_init_cb_dma);
		if (!ha->ex_init_cb)
			goto fail_ex_init_cb;
3982 3983
		ql_dbg_pci(ql_dbg_init, ha->pdev, 0x002e,
		    "ex_init_cb=%p.\n", ha->ex_init_cb);
3984 3985
	}

3986 3987
	INIT_LIST_HEAD(&ha->gbl_dsd_list);

3988 3989 3990 3991 3992 3993
	/* Get consistent memory allocated for Async Port-Database. */
	if (!IS_FWI2_CAPABLE(ha)) {
		ha->async_pd = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
			&ha->async_pd_dma);
		if (!ha->async_pd)
			goto fail_async_pd;
3994 3995
		ql_dbg_pci(ql_dbg_init, ha->pdev, 0x002f,
		    "async_pd=%p.\n", ha->async_pd);
3996 3997
	}

3998
	INIT_LIST_HEAD(&ha->vp_list);
3999 4000 4001 4002 4003

	/* Allocate memory for our loop_id bitmap */
	ha->loop_id_map = kzalloc(BITS_TO_LONGS(LOOPID_MAP_SIZE) * sizeof(long),
	    GFP_KERNEL);
	if (!ha->loop_id_map)
4004
		goto fail_loop_id_map;
4005 4006 4007
	else {
		qla2x00_set_reserved_loop_ids(ha);
		ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0123,
4008
		    "loop_id_map=%p.\n", ha->loop_id_map);
4009 4010
	}

4011
	return 0;
4012

4013 4014
fail_loop_id_map:
	dma_pool_free(ha->s_dma_pool, ha->async_pd, ha->async_pd_dma);
4015 4016
fail_async_pd:
	dma_pool_free(ha->s_dma_pool, ha->ex_init_cb, ha->ex_init_cb_dma);
4017 4018
fail_ex_init_cb:
	kfree(ha->npiv_info);
4019 4020 4021 4022 4023
fail_npiv_info:
	dma_free_coherent(&ha->pdev->dev, ((*rsp)->length + 1) *
		sizeof(response_t), (*rsp)->ring, (*rsp)->dma);
	(*rsp)->ring = NULL;
	(*rsp)->dma = 0;
4024
fail_rsp_ring:
4025
	kfree(*rsp);
4026
fail_rsp:
4027 4028 4029 4030
	dma_free_coherent(&ha->pdev->dev, ((*req)->length + 1) *
		sizeof(request_t), (*req)->ring, (*req)->dma);
	(*req)->ring = NULL;
	(*req)->dma = 0;
4031
fail_req_ring:
4032
	kfree(*req);
4033 4034 4035 4036 4037
fail_req:
	dma_free_coherent(&ha->pdev->dev, sizeof(struct ct_sns_pkt),
		ha->ct_sns, ha->ct_sns_dma);
	ha->ct_sns = NULL;
	ha->ct_sns_dma = 0;
4038 4039 4040 4041
fail_free_ms_iocb:
	dma_pool_free(ha->s_dma_pool, ha->ms_iocb, ha->ms_iocb_dma);
	ha->ms_iocb = NULL;
	ha->ms_iocb_dma = 0;
4042 4043 4044 4045

	if (ha->sns_cmd)
		dma_free_coherent(&ha->pdev->dev, sizeof(struct sns_cmd_pkt),
		    ha->sns_cmd, ha->sns_cmd_dma);
4046
fail_dma_pool:
4047
	if (IS_QLA82XX(ha) || ql2xenabledif) {
4048 4049 4050 4051
		dma_pool_destroy(ha->fcp_cmnd_dma_pool);
		ha->fcp_cmnd_dma_pool = NULL;
	}
fail_dl_dma_pool:
4052
	if (IS_QLA82XX(ha) || ql2xenabledif) {
4053 4054 4055 4056
		dma_pool_destroy(ha->dl_dma_pool);
		ha->dl_dma_pool = NULL;
	}
fail_s_dma_pool:
4057 4058
	dma_pool_destroy(ha->s_dma_pool);
	ha->s_dma_pool = NULL;
4059 4060 4061
fail_free_nvram:
	kfree(ha->nvram);
	ha->nvram = NULL;
4062
fail_free_ctx_mempool:
4063 4064
	if (ha->ctx_mempool)
		mempool_destroy(ha->ctx_mempool);
4065
	ha->ctx_mempool = NULL;
4066
fail_free_srb_mempool:
4067 4068
	if (ha->srb_mempool)
		mempool_destroy(ha->srb_mempool);
4069 4070
	ha->srb_mempool = NULL;
fail_free_gid_list:
4071 4072
	dma_free_coherent(&ha->pdev->dev, qla2x00_gid_list_size(ha),
	ha->gid_list,
4073
	ha->gid_list_dma);
4074 4075
	ha->gid_list = NULL;
	ha->gid_list_dma = 0;
4076 4077
fail_free_tgt_mem:
	qlt_mem_free(ha);
4078 4079 4080 4081 4082
fail_free_init_cb:
	dma_free_coherent(&ha->pdev->dev, ha->init_cb_size, ha->init_cb,
	ha->init_cb_dma);
	ha->init_cb = NULL;
	ha->init_cb_dma = 0;
4083
fail:
4084 4085
	ql_log(ql_log_fatal, NULL, 0x0030,
	    "Memory allocation failure.\n");
4086
	return -ENOMEM;
L
Linus Torvalds 已提交
4087 4088
}

4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099
int
qla2x00_set_exlogins_buffer(scsi_qla_host_t *vha)
{
	int rval;
	uint16_t	size, max_cnt, temp;
	struct qla_hw_data *ha = vha->hw;

	/* Return if we don't need to alloacate any extended logins */
	if (!ql2xexlogins)
		return QLA_SUCCESS;

4100 4101 4102
	if (!IS_EXLOGIN_OFFLD_CAPABLE(ha))
		return QLA_SUCCESS;

4103 4104 4105 4106 4107 4108 4109 4110 4111 4112
	ql_log(ql_log_info, vha, 0xd021, "EXLOGIN count: %d.\n", ql2xexlogins);
	max_cnt = 0;
	rval = qla_get_exlogin_status(vha, &size, &max_cnt);
	if (rval != QLA_SUCCESS) {
		ql_log_pci(ql_log_fatal, ha->pdev, 0xd029,
		    "Failed to get exlogin status.\n");
		return rval;
	}

	temp = (ql2xexlogins > max_cnt) ? max_cnt : ql2xexlogins;
4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130
	temp *= size;

	if (temp != ha->exlogin_size) {
		qla2x00_free_exlogin_buffer(ha);
		ha->exlogin_size = temp;

		ql_log(ql_log_info, vha, 0xd024,
		    "EXLOGIN: max_logins=%d, portdb=0x%x, total=%d.\n",
		    max_cnt, size, temp);

		ql_log(ql_log_info, vha, 0xd025,
		    "EXLOGIN: requested size=0x%x\n", ha->exlogin_size);

		/* Get consistent memory for extended logins */
		ha->exlogin_buf = dma_alloc_coherent(&ha->pdev->dev,
			ha->exlogin_size, &ha->exlogin_buf_dma, GFP_KERNEL);
		if (!ha->exlogin_buf) {
			ql_log_pci(ql_log_fatal, ha->pdev, 0xd02a,
4131
		    "Failed to allocate memory for exlogin_buf_dma.\n");
4132 4133
			return -ENOMEM;
		}
4134 4135 4136 4137 4138
	}

	/* Now configure the dma buffer */
	rval = qla_set_exlogin_mem_cfg(vha, ha->exlogin_buf_dma);
	if (rval) {
4139
		ql_log(ql_log_fatal, vha, 0xd033,
4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163
		    "Setup extended login buffer  ****FAILED****.\n");
		qla2x00_free_exlogin_buffer(ha);
	}

	return rval;
}

/*
* qla2x00_free_exlogin_buffer
*
* Input:
*	ha = adapter block pointer
*/
void
qla2x00_free_exlogin_buffer(struct qla_hw_data *ha)
{
	if (ha->exlogin_buf) {
		dma_free_coherent(&ha->pdev->dev, ha->exlogin_size,
		    ha->exlogin_buf, ha->exlogin_buf_dma);
		ha->exlogin_buf = NULL;
		ha->exlogin_size = 0;
	}
}

4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194
static void
qla2x00_number_of_exch(scsi_qla_host_t *vha, u32 *ret_cnt, u16 max_cnt)
{
	u32 temp;
	*ret_cnt = FW_DEF_EXCHANGES_CNT;

	if (qla_ini_mode_enabled(vha)) {
		if (ql2xiniexchg > max_cnt)
			ql2xiniexchg = max_cnt;

		if (ql2xiniexchg > FW_DEF_EXCHANGES_CNT)
			*ret_cnt = ql2xiniexchg;
	} else if (qla_tgt_mode_enabled(vha)) {
		if (ql2xexchoffld > max_cnt)
			ql2xexchoffld = max_cnt;

		if (ql2xexchoffld > FW_DEF_EXCHANGES_CNT)
			*ret_cnt = ql2xexchoffld;
	} else if (qla_dual_mode_enabled(vha)) {
		temp = ql2xiniexchg + ql2xexchoffld;
		if (temp > max_cnt) {
			ql2xiniexchg -= (temp - max_cnt)/2;
			ql2xexchoffld -= (((temp - max_cnt)/2) + 1);
			temp = max_cnt;
		}

		if (temp > FW_DEF_EXCHANGES_CNT)
			*ret_cnt = temp;
	}
}

4195 4196 4197 4198
int
qla2x00_set_exchoffld_buffer(scsi_qla_host_t *vha)
{
	int rval;
4199 4200
	u16 size, max_cnt;
	u32 temp;
4201 4202
	struct qla_hw_data *ha = vha->hw;

4203 4204 4205 4206
	if (!ha->flags.exchoffld_enabled)
		return QLA_SUCCESS;

	if (!IS_EXCHG_OFFLD_CAPABLE(ha))
4207 4208 4209 4210 4211 4212 4213 4214 4215 4216
		return QLA_SUCCESS;

	max_cnt = 0;
	rval = qla_get_exchoffld_status(vha, &size, &max_cnt);
	if (rval != QLA_SUCCESS) {
		ql_log_pci(ql_log_fatal, ha->pdev, 0xd012,
		    "Failed to get exlogin status.\n");
		return rval;
	}

4217 4218
	qla2x00_number_of_exch(vha, &temp, max_cnt);
	temp *= size;
4219

4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239
	if (temp != ha->exchoffld_size) {
		qla2x00_free_exchoffld_buffer(ha);
		ha->exchoffld_size = temp;

		ql_log(ql_log_info, vha, 0xd016,
		    "Exchange offload: max_count=%d, buffers=0x%x, total=%d.\n",
		    max_cnt, size, temp);

		ql_log(ql_log_info, vha, 0xd017,
		    "Exchange Buffers requested size = 0x%x\n",
		    ha->exchoffld_size);

		/* Get consistent memory for extended logins */
		ha->exchoffld_buf = dma_alloc_coherent(&ha->pdev->dev,
			ha->exchoffld_size, &ha->exchoffld_buf_dma, GFP_KERNEL);
		if (!ha->exchoffld_buf) {
			ql_log_pci(ql_log_fatal, ha->pdev, 0xd013,
			"Failed to allocate memory for exchoffld_buf_dma.\n");
			return -ENOMEM;
		}
4240 4241 4242
	}

	/* Now configure the dma buffer */
4243
	rval = qla_set_exchoffld_mem_cfg(vha);
4244 4245 4246 4247
	if (rval) {
		ql_log(ql_log_fatal, vha, 0xd02e,
		    "Setup exchange offload buffer ****FAILED****.\n");
		qla2x00_free_exchoffld_buffer(ha);
4248 4249 4250 4251 4252 4253 4254 4255
	} else {
		/* re-adjust number of target exchange */
		struct init_cb_81xx *icb = (struct init_cb_81xx *)ha->init_cb;

		if (qla_ini_mode_enabled(vha))
			icb->exchange_count = 0;
		else
			icb->exchange_count = cpu_to_le16(ql2xexchoffld);
4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277
	}

	return rval;
}

/*
* qla2x00_free_exchoffld_buffer
*
* Input:
*	ha = adapter block pointer
*/
void
qla2x00_free_exchoffld_buffer(struct qla_hw_data *ha)
{
	if (ha->exchoffld_buf) {
		dma_free_coherent(&ha->pdev->dev, ha->exchoffld_size,
		    ha->exchoffld_buf, ha->exchoffld_buf_dma);
		ha->exchoffld_buf = NULL;
		ha->exchoffld_size = 0;
	}
}

L
Linus Torvalds 已提交
4278
/*
4279 4280
* qla2x00_free_fw_dump
*	Frees fw dump stuff.
L
Linus Torvalds 已提交
4281 4282
*
* Input:
4283
*	ha = adapter block pointer
L
Linus Torvalds 已提交
4284
*/
A
Adrian Bunk 已提交
4285
static void
4286
qla2x00_free_fw_dump(struct qla_hw_data *ha)
L
Linus Torvalds 已提交
4287
{
4288
	if (ha->fce)
4289 4290
		dma_free_coherent(&ha->pdev->dev,
		    FCE_SIZE, ha->fce, ha->fce_dma);
4291

4292 4293 4294 4295 4296
	if (ha->eft)
		dma_free_coherent(&ha->pdev->dev,
		    EFT_SIZE, ha->eft, ha->eft_dma);

	if (ha->fw_dump)
4297
		vfree(ha->fw_dump);
4298 4299 4300
	if (ha->fw_dump_template)
		vfree(ha->fw_dump_template);

4301 4302 4303 4304 4305
	ha->fce = NULL;
	ha->fce_dma = 0;
	ha->eft = NULL;
	ha->eft_dma = 0;
	ha->fw_dumped = 0;
4306
	ha->fw_dump_cap_flags = 0;
4307
	ha->fw_dump_reading = 0;
4308 4309 4310 4311
	ha->fw_dump = NULL;
	ha->fw_dump_len = 0;
	ha->fw_dump_template = NULL;
	ha->fw_dump_template_len = 0;
4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325
}

/*
* qla2x00_mem_free
*      Frees all adapter allocated memory.
*
* Input:
*      ha = adapter block pointer.
*/
static void
qla2x00_mem_free(struct qla_hw_data *ha)
{
	qla2x00_free_fw_dump(ha);

4326 4327 4328 4329
	if (ha->mctp_dump)
		dma_free_coherent(&ha->pdev->dev, MCTP_DUMP_SIZE, ha->mctp_dump,
		    ha->mctp_dump_dma);

4330 4331
	if (ha->srb_mempool)
		mempool_destroy(ha->srb_mempool);
4332

4333 4334 4335 4336
	if (ha->dcbx_tlv)
		dma_free_coherent(&ha->pdev->dev, DCBX_TLV_DATA_SIZE,
		    ha->dcbx_tlv, ha->dcbx_tlv_dma);

4337 4338 4339 4340
	if (ha->xgmac_data)
		dma_free_coherent(&ha->pdev->dev, XGMAC_DATA_SIZE,
		    ha->xgmac_data, ha->xgmac_data_dma);

L
Linus Torvalds 已提交
4341 4342
	if (ha->sns_cmd)
		dma_free_coherent(&ha->pdev->dev, sizeof(struct sns_cmd_pkt),
4343
		ha->sns_cmd, ha->sns_cmd_dma);
L
Linus Torvalds 已提交
4344 4345 4346

	if (ha->ct_sns)
		dma_free_coherent(&ha->pdev->dev, sizeof(struct ct_sns_pkt),
4347
		ha->ct_sns, ha->ct_sns_dma);
L
Linus Torvalds 已提交
4348

4349 4350 4351
	if (ha->sfp_data)
		dma_pool_free(ha->s_dma_pool, ha->sfp_data, ha->sfp_data_dma);

L
Linus Torvalds 已提交
4352 4353 4354
	if (ha->ms_iocb)
		dma_pool_free(ha->s_dma_pool, ha->ms_iocb, ha->ms_iocb_dma);

4355
	if (ha->ex_init_cb)
4356 4357
		dma_pool_free(ha->s_dma_pool,
			ha->ex_init_cb, ha->ex_init_cb_dma);
4358

4359 4360 4361
	if (ha->async_pd)
		dma_pool_free(ha->s_dma_pool, ha->async_pd, ha->async_pd_dma);

L
Linus Torvalds 已提交
4362 4363 4364 4365
	if (ha->s_dma_pool)
		dma_pool_destroy(ha->s_dma_pool);

	if (ha->gid_list)
4366 4367
		dma_free_coherent(&ha->pdev->dev, qla2x00_gid_list_size(ha),
		ha->gid_list, ha->gid_list_dma);
L
Linus Torvalds 已提交
4368

4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392
	if (IS_QLA82XX(ha)) {
		if (!list_empty(&ha->gbl_dsd_list)) {
			struct dsd_dma *dsd_ptr, *tdsd_ptr;

			/* clean up allocated prev pool */
			list_for_each_entry_safe(dsd_ptr,
				tdsd_ptr, &ha->gbl_dsd_list, list) {
				dma_pool_free(ha->dl_dma_pool,
				dsd_ptr->dsd_addr, dsd_ptr->dsd_list_dma);
				list_del(&dsd_ptr->list);
				kfree(dsd_ptr);
			}
		}
	}

	if (ha->dl_dma_pool)
		dma_pool_destroy(ha->dl_dma_pool);

	if (ha->fcp_cmnd_dma_pool)
		dma_pool_destroy(ha->fcp_cmnd_dma_pool);

	if (ha->ctx_mempool)
		mempool_destroy(ha->ctx_mempool);

4393 4394
	qlt_mem_free(ha);

4395 4396
	if (ha->init_cb)
		dma_free_coherent(&ha->pdev->dev, ha->init_cb_size,
4397
			ha->init_cb, ha->init_cb_dma);
4398 4399
	vfree(ha->optrom_buffer);
	kfree(ha->nvram);
4400
	kfree(ha->npiv_info);
4401
	kfree(ha->swl);
4402
	kfree(ha->loop_id_map);
L
Linus Torvalds 已提交
4403

4404
	ha->srb_mempool = NULL;
4405
	ha->ctx_mempool = NULL;
L
Linus Torvalds 已提交
4406 4407 4408 4409 4410 4411 4412 4413
	ha->sns_cmd = NULL;
	ha->sns_cmd_dma = 0;
	ha->ct_sns = NULL;
	ha->ct_sns_dma = 0;
	ha->ms_iocb = NULL;
	ha->ms_iocb_dma = 0;
	ha->init_cb = NULL;
	ha->init_cb_dma = 0;
4414 4415
	ha->ex_init_cb = NULL;
	ha->ex_init_cb_dma = 0;
4416 4417
	ha->async_pd = NULL;
	ha->async_pd_dma = 0;
L
Linus Torvalds 已提交
4418 4419

	ha->s_dma_pool = NULL;
4420 4421
	ha->dl_dma_pool = NULL;
	ha->fcp_cmnd_dma_pool = NULL;
L
Linus Torvalds 已提交
4422 4423 4424

	ha->gid_list = NULL;
	ha->gid_list_dma = 0;
4425 4426 4427 4428

	ha->tgt.atio_ring = NULL;
	ha->tgt.atio_dma = 0;
	ha->tgt.tgt_vp_map = NULL;
4429
}
L
Linus Torvalds 已提交
4430

4431 4432 4433 4434 4435
struct scsi_qla_host *qla2x00_create_host(struct scsi_host_template *sht,
						struct qla_hw_data *ha)
{
	struct Scsi_Host *host;
	struct scsi_qla_host *vha = NULL;
4436

4437
	host = scsi_host_alloc(sht, sizeof(scsi_qla_host_t));
4438
	if (!host) {
4439 4440
		ql_log_pci(ql_log_fatal, ha->pdev, 0x0107,
		    "Failed to allocate host from the scsi layer, aborting.\n");
4441
		return NULL;
4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454
	}

	/* Clear our data area */
	vha = shost_priv(host);
	memset(vha, 0, sizeof(scsi_qla_host_t));

	vha->host = host;
	vha->host_no = host->host_no;
	vha->hw = ha;

	INIT_LIST_HEAD(&vha->vp_fcports);
	INIT_LIST_HEAD(&vha->work_list);
	INIT_LIST_HEAD(&vha->list);
4455 4456
	INIT_LIST_HEAD(&vha->qla_cmd_list);
	INIT_LIST_HEAD(&vha->qla_sess_op_cmd_list);
4457
	INIT_LIST_HEAD(&vha->logo_list);
4458
	INIT_LIST_HEAD(&vha->plogi_ack_list);
4459
	INIT_LIST_HEAD(&vha->qp_list);
4460
	INIT_LIST_HEAD(&vha->gnl.fcports);
4461
	INIT_LIST_HEAD(&vha->nvme_rport_list);
4462

4463
	spin_lock_init(&vha->work_lock);
4464
	spin_lock_init(&vha->cmd_list_lock);
4465
	init_waitqueue_head(&vha->fcport_waitQ);
4466
	init_waitqueue_head(&vha->vref_waitq);
4467

4468 4469
	vha->gnl.size = sizeof(struct get_name_list_extended) *
			(ha->max_loop_id + 1);
4470 4471 4472
	vha->gnl.l = dma_alloc_coherent(&ha->pdev->dev,
	    vha->gnl.size, &vha->gnl.ldma, GFP_KERNEL);
	if (!vha->gnl.l) {
4473
		ql_log(ql_log_fatal, vha, 0xd04a,
4474 4475 4476 4477
		    "Alloc failed for name list.\n");
		scsi_remove_host(vha->host);
		return NULL;
	}
4478

4479
	sprintf(vha->host_str, "%s_%ld", QLA2XXX_DRIVER_NAME, vha->host_no);
4480 4481 4482 4483 4484
	ql_dbg(ql_dbg_init, vha, 0x0041,
	    "Allocated the host=%p hw=%p vha=%p dev_name=%s",
	    vha->host, vha->hw, vha,
	    dev_name(&(ha->pdev->dev)));

4485
	return vha;
L
Linus Torvalds 已提交
4486 4487
}

4488
struct qla_work_evt *
4489
qla2x00_alloc_work(struct scsi_qla_host *vha, enum qla_work_type type)
4490 4491
{
	struct qla_work_evt *e;
4492 4493 4494 4495 4496
	uint8_t bail;

	QLA_VHA_MARK_BUSY(vha, bail);
	if (bail)
		return NULL;
4497

4498
	e = kzalloc(sizeof(struct qla_work_evt), GFP_ATOMIC);
4499 4500
	if (!e) {
		QLA_VHA_MARK_NOT_BUSY(vha);
4501
		return NULL;
4502
	}
4503 4504 4505 4506 4507 4508 4509

	INIT_LIST_HEAD(&e->list);
	e->type = type;
	e->flags = QLA_EVT_FLAG_FREE;
	return e;
}

4510
int
4511
qla2x00_post_work(struct scsi_qla_host *vha, struct qla_work_evt *e)
4512
{
4513
	unsigned long flags;
4514

4515
	spin_lock_irqsave(&vha->work_lock, flags);
4516
	list_add_tail(&e->list, &vha->work_list);
4517
	spin_unlock_irqrestore(&vha->work_lock, flags);
4518 4519 4520 4521 4522

	if (QLA_EARLY_LINKUP(vha->hw))
		schedule_work(&vha->iocb_work);
	else
		qla2xxx_wake_dpc(vha);
4523

4524 4525 4526 4527
	return QLA_SUCCESS;
}

int
4528
qla2x00_post_aen_work(struct scsi_qla_host *vha, enum fc_host_event_code code,
4529 4530 4531 4532
    u32 data)
{
	struct qla_work_evt *e;

4533
	e = qla2x00_alloc_work(vha, QLA_EVT_AEN);
4534 4535 4536 4537 4538
	if (!e)
		return QLA_FUNCTION_FAILED;

	e->u.aen.code = code;
	e->u.aen.data = data;
4539
	return qla2x00_post_work(vha, e);
4540 4541
}

4542 4543 4544 4545 4546
int
qla2x00_post_idc_ack_work(struct scsi_qla_host *vha, uint16_t *mb)
{
	struct qla_work_evt *e;

4547
	e = qla2x00_alloc_work(vha, QLA_EVT_IDC_ACK);
4548 4549 4550 4551
	if (!e)
		return QLA_FUNCTION_FAILED;

	memcpy(e->u.idc_ack.mb, mb, QLA_IDC_ACK_REGS * sizeof(uint16_t));
4552
	return qla2x00_post_work(vha, e);
4553 4554
}

4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576
#define qla2x00_post_async_work(name, type)	\
int qla2x00_post_async_##name##_work(		\
    struct scsi_qla_host *vha,			\
    fc_port_t *fcport, uint16_t *data)		\
{						\
	struct qla_work_evt *e;			\
						\
	e = qla2x00_alloc_work(vha, type);	\
	if (!e)					\
		return QLA_FUNCTION_FAILED;	\
						\
	e->u.logio.fcport = fcport;		\
	if (data) {				\
		e->u.logio.data[0] = data[0];	\
		e->u.logio.data[1] = data[1];	\
	}					\
	return qla2x00_post_work(vha, e);	\
}

qla2x00_post_async_work(login, QLA_EVT_ASYNC_LOGIN);
qla2x00_post_async_work(logout, QLA_EVT_ASYNC_LOGOUT);
qla2x00_post_async_work(logout_done, QLA_EVT_ASYNC_LOGOUT_DONE);
4577 4578
qla2x00_post_async_work(adisc, QLA_EVT_ASYNC_ADISC);
qla2x00_post_async_work(adisc_done, QLA_EVT_ASYNC_ADISC_DONE);
4579

4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610
int
qla2x00_post_uevent_work(struct scsi_qla_host *vha, u32 code)
{
	struct qla_work_evt *e;

	e = qla2x00_alloc_work(vha, QLA_EVT_UEVENT);
	if (!e)
		return QLA_FUNCTION_FAILED;

	e->u.uevent.code = code;
	return qla2x00_post_work(vha, e);
}

static void
qla2x00_uevent_emit(struct scsi_qla_host *vha, u32 code)
{
	char event_string[40];
	char *envp[] = { event_string, NULL };

	switch (code) {
	case QLA_UEVENT_CODE_FW_DUMP:
		snprintf(event_string, sizeof(event_string), "FW_DUMP=%ld",
		    vha->host_no);
		break;
	default:
		/* do nothing */
		break;
	}
	kobject_uevent_env(&vha->hw->pdev->dev.kobj, KOBJ_CHANGE, envp);
}

4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626
int
qlafx00_post_aenfx_work(struct scsi_qla_host *vha,  uint32_t evtcode,
			uint32_t *data, int cnt)
{
	struct qla_work_evt *e;

	e = qla2x00_alloc_work(vha, QLA_EVT_AENFX);
	if (!e)
		return QLA_FUNCTION_FAILED;

	e->u.aenfx.evtcode = evtcode;
	e->u.aenfx.count = cnt;
	memcpy(e->u.aenfx.mbx, data, sizeof(*data) * cnt);
	return qla2x00_post_work(vha, e);
}

4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687
int qla24xx_post_upd_fcport_work(struct scsi_qla_host *vha, fc_port_t *fcport)
{
	struct qla_work_evt *e;

	e = qla2x00_alloc_work(vha, QLA_EVT_UPD_FCPORT);
	if (!e)
		return QLA_FUNCTION_FAILED;

	e->u.fcport.fcport = fcport;
	return qla2x00_post_work(vha, e);
}

static
void qla24xx_create_new_sess(struct scsi_qla_host *vha, struct qla_work_evt *e)
{
	unsigned long flags;
	fc_port_t *fcport =  NULL;
	struct qlt_plogi_ack_t *pla =
	    (struct qlt_plogi_ack_t *)e->u.new_sess.pla;

	spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
	fcport = qla2x00_find_fcport_by_wwpn(vha, e->u.new_sess.port_name, 1);
	if (fcport) {
		fcport->d_id = e->u.new_sess.id;
		if (pla) {
			fcport->fw_login_state = DSC_LS_PLOGI_PEND;
			qlt_plogi_ack_link(vha, pla, fcport, QLT_PLOGI_LINK_SAME_WWN);
			/* we took an extra ref_count to prevent PLOGI ACK when
			 * fcport/sess has not been created.
			 */
			pla->ref_count--;
		}
	} else {
		fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
		if (fcport) {
			fcport->d_id = e->u.new_sess.id;
			fcport->scan_state = QLA_FCPORT_FOUND;
			fcport->flags |= FCF_FABRIC_DEVICE;
			fcport->fw_login_state = DSC_LS_PLOGI_PEND;

			memcpy(fcport->port_name, e->u.new_sess.port_name,
			    WWN_SIZE);
			list_add_tail(&fcport->list, &vha->vp_fcports);

			if (pla) {
				qlt_plogi_ack_link(vha, pla, fcport,
				    QLT_PLOGI_LINK_SAME_WWN);
				pla->ref_count--;
			}
		}
	}
	spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);

	if (fcport) {
		if (pla)
			qlt_plogi_ack_unref(vha, pla);
		else
			qla24xx_async_gnl(vha, fcport);
	}
}

4688
void
4689
qla2x00_do_work(struct scsi_qla_host *vha)
4690
{
4691 4692 4693
	struct qla_work_evt *e, *tmp;
	unsigned long flags;
	LIST_HEAD(work);
4694

4695 4696 4697 4698 4699
	spin_lock_irqsave(&vha->work_lock, flags);
	list_splice_init(&vha->work_list, &work);
	spin_unlock_irqrestore(&vha->work_lock, flags);

	list_for_each_entry_safe(e, tmp, &work, list) {
4700 4701 4702 4703
		list_del_init(&e->list);

		switch (e->type) {
		case QLA_EVT_AEN:
4704
			fc_host_post_event(vha->host, fc_get_event_number(),
4705 4706
			    e->u.aen.code, e->u.aen.data);
			break;
4707 4708 4709
		case QLA_EVT_IDC_ACK:
			qla81xx_idc_ack(vha, e->u.idc_ack.mb);
			break;
4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720
		case QLA_EVT_ASYNC_LOGIN:
			qla2x00_async_login(vha, e->u.logio.fcport,
			    e->u.logio.data);
			break;
		case QLA_EVT_ASYNC_LOGOUT:
			qla2x00_async_logout(vha, e->u.logio.fcport);
			break;
		case QLA_EVT_ASYNC_LOGOUT_DONE:
			qla2x00_async_logout_done(vha, e->u.logio.fcport,
			    e->u.logio.data);
			break;
4721 4722 4723 4724 4725 4726 4727 4728
		case QLA_EVT_ASYNC_ADISC:
			qla2x00_async_adisc(vha, e->u.logio.fcport,
			    e->u.logio.data);
			break;
		case QLA_EVT_ASYNC_ADISC_DONE:
			qla2x00_async_adisc_done(vha, e->u.logio.fcport,
			    e->u.logio.data);
			break;
4729 4730 4731
		case QLA_EVT_UEVENT:
			qla2x00_uevent_emit(vha, e->u.uevent.code);
			break;
4732 4733 4734
		case QLA_EVT_AENFX:
			qlafx00_process_aen(vha, e);
			break;
4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750
		case QLA_EVT_GIDPN:
			qla24xx_async_gidpn(vha, e->u.fcport.fcport);
			break;
		case QLA_EVT_GPNID:
			qla24xx_async_gpnid(vha, &e->u.gpnid.id);
			break;
		case QLA_EVT_GPNID_DONE:
			qla24xx_async_gpnid_done(vha, e->u.iosb.sp);
			break;
		case QLA_EVT_NEW_SESS:
			qla24xx_create_new_sess(vha, e);
			break;
		case QLA_EVT_GPDB:
			qla24xx_async_gpdb(vha, e->u.fcport.fcport,
			    e->u.fcport.opt);
			break;
4751 4752 4753
		case QLA_EVT_PRLI:
			qla24xx_async_prli(vha, e->u.fcport.fcport);
			break;
4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765
		case QLA_EVT_GPSC:
			qla24xx_async_gpsc(vha, e->u.fcport.fcport);
			break;
		case QLA_EVT_UPD_FCPORT:
			qla2x00_update_fcport(vha, e->u.fcport.fcport);
			break;
		case QLA_EVT_GNL:
			qla24xx_async_gnl(vha, e->u.fcport.fcport);
			break;
		case QLA_EVT_NACK:
			qla24xx_do_nack_work(vha, e);
			break;
4766 4767 4768
		}
		if (e->flags & QLA_EVT_FLAG_FREE)
			kfree(e);
4769 4770 4771

		/* For each work completed decrement vha ref count */
		QLA_VHA_MARK_NOT_BUSY(vha);
4772 4773
	}
}
4774

4775 4776 4777 4778 4779 4780
/* Relogins all the fcports of a vport
 * Context: dpc thread
 */
void qla2x00_relogin(struct scsi_qla_host *vha)
{
	fc_port_t       *fcport;
4781
	int status;
4782
	struct event_arg ea;
4783 4784 4785 4786 4787 4788

	list_for_each_entry(fcport, &vha->vp_fcports, list) {
	/*
	 * If the port is not ONLINE then try to login
	 * to it if we haven't run out of retries.
	 */
4789 4790
		if (atomic_read(&fcport->state) != FCS_ONLINE &&
		    fcport->login_retry && !(fcport->flags & FCF_ASYNC_SENT)) {
4791
			fcport->login_retry--;
4792
			if (fcport->flags & FCF_FABRIC_DEVICE) {
4793
				ql_dbg(ql_dbg_disc, fcport->vha, 0x2108,
4794 4795 4796 4797 4798 4799 4800 4801
				    "%s %8phC DS %d LS %d\n", __func__,
				    fcport->port_name, fcport->disc_state,
				    fcport->fw_login_state);
				memset(&ea, 0, sizeof(ea));
				ea.event = FCME_RELOGIN;
				ea.fcport = fcport;
				qla2x00_fcport_event_handler(vha, &ea);
			} else {
4802 4803
				status = qla2x00_local_device_login(vha,
								fcport);
4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819
				if (status == QLA_SUCCESS) {
					fcport->old_loop_id = fcport->loop_id;
					ql_dbg(ql_dbg_disc, vha, 0x2003,
					    "Port login OK: logged in ID 0x%x.\n",
					    fcport->loop_id);
					qla2x00_update_fcport(vha, fcport);
				} else if (status == 1) {
					set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
					/* retry the login again */
					ql_dbg(ql_dbg_disc, vha, 0x2007,
					    "Retrying %d login again loop_id 0x%x.\n",
					    fcport->login_retry,
					    fcport->loop_id);
				} else {
					fcport->login_retry = 0;
				}
4820

4821 4822 4823
				if (fcport->login_retry == 0 &&
				    status != QLA_SUCCESS)
					qla2x00_clear_loop_id(fcport);
4824 4825 4826 4827
			}
		}
		if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
			break;
4828 4829 4830
	}
}

4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861
/* Schedule work on any of the dpc-workqueues */
void
qla83xx_schedule_work(scsi_qla_host_t *base_vha, int work_code)
{
	struct qla_hw_data *ha = base_vha->hw;

	switch (work_code) {
	case MBA_IDC_AEN: /* 0x8200 */
		if (ha->dpc_lp_wq)
			queue_work(ha->dpc_lp_wq, &ha->idc_aen);
		break;

	case QLA83XX_NIC_CORE_RESET: /* 0x1 */
		if (!ha->flags.nic_core_reset_hdlr_active) {
			if (ha->dpc_hp_wq)
				queue_work(ha->dpc_hp_wq, &ha->nic_core_reset);
		} else
			ql_dbg(ql_dbg_p3p, base_vha, 0xb05e,
			    "NIC Core reset is already active. Skip "
			    "scheduling it again.\n");
		break;
	case QLA83XX_IDC_STATE_HANDLER: /* 0x2 */
		if (ha->dpc_hp_wq)
			queue_work(ha->dpc_hp_wq, &ha->idc_state_handler);
		break;
	case QLA83XX_NIC_CORE_UNRECOVERABLE: /* 0x3 */
		if (ha->dpc_hp_wq)
			queue_work(ha->dpc_hp_wq, &ha->nic_core_unrecoverable);
		break;
	default:
		ql_log(ql_log_warn, base_vha, 0xb05f,
4862
		    "Unknown work-code=0x%x.\n", work_code);
4863 4864 4865 4866 4867 4868 4869 4870 4871 4872
	}

	return;
}

/* Work: Perform NIC Core Unrecoverable state handling */
void
qla83xx_nic_core_unrecoverable_work(struct work_struct *work)
{
	struct qla_hw_data *ha =
4873
		container_of(work, struct qla_hw_data, nic_core_unrecoverable);
4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894
	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
	uint32_t dev_state = 0;

	qla83xx_idc_lock(base_vha, 0);
	qla83xx_rd_reg(base_vha, QLA83XX_IDC_DEV_STATE, &dev_state);
	qla83xx_reset_ownership(base_vha);
	if (ha->flags.nic_core_reset_owner) {
		ha->flags.nic_core_reset_owner = 0;
		qla83xx_wr_reg(base_vha, QLA83XX_IDC_DEV_STATE,
		    QLA8XXX_DEV_FAILED);
		ql_log(ql_log_info, base_vha, 0xb060, "HW State: FAILED.\n");
		qla83xx_schedule_work(base_vha, QLA83XX_IDC_STATE_HANDLER);
	}
	qla83xx_idc_unlock(base_vha, 0);
}

/* Work: Execute IDC state handler */
void
qla83xx_idc_state_handler_work(struct work_struct *work)
{
	struct qla_hw_data *ha =
4895
		container_of(work, struct qla_hw_data, idc_state_handler);
4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906
	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
	uint32_t dev_state = 0;

	qla83xx_idc_lock(base_vha, 0);
	qla83xx_rd_reg(base_vha, QLA83XX_IDC_DEV_STATE, &dev_state);
	if (dev_state == QLA8XXX_DEV_FAILED ||
			dev_state == QLA8XXX_DEV_NEED_QUIESCENT)
		qla83xx_idc_state_handler(base_vha);
	qla83xx_idc_unlock(base_vha, 0);
}

4907
static int
4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944
qla83xx_check_nic_core_fw_alive(scsi_qla_host_t *base_vha)
{
	int rval = QLA_SUCCESS;
	unsigned long heart_beat_wait = jiffies + (1 * HZ);
	uint32_t heart_beat_counter1, heart_beat_counter2;

	do {
		if (time_after(jiffies, heart_beat_wait)) {
			ql_dbg(ql_dbg_p3p, base_vha, 0xb07c,
			    "Nic Core f/w is not alive.\n");
			rval = QLA_FUNCTION_FAILED;
			break;
		}

		qla83xx_idc_lock(base_vha, 0);
		qla83xx_rd_reg(base_vha, QLA83XX_FW_HEARTBEAT,
		    &heart_beat_counter1);
		qla83xx_idc_unlock(base_vha, 0);
		msleep(100);
		qla83xx_idc_lock(base_vha, 0);
		qla83xx_rd_reg(base_vha, QLA83XX_FW_HEARTBEAT,
		    &heart_beat_counter2);
		qla83xx_idc_unlock(base_vha, 0);
	} while (heart_beat_counter1 == heart_beat_counter2);

	return rval;
}

/* Work: Perform NIC Core Reset handling */
void
qla83xx_nic_core_reset_work(struct work_struct *work)
{
	struct qla_hw_data *ha =
		container_of(work, struct qla_hw_data, nic_core_reset);
	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
	uint32_t dev_state = 0;

4945 4946 4947 4948 4949 4950 4951
	if (IS_QLA2031(ha)) {
		if (qla2xxx_mctp_dump(base_vha) != QLA_SUCCESS)
			ql_log(ql_log_warn, base_vha, 0xb081,
			    "Failed to dump mctp\n");
		return;
	}

4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024
	if (!ha->flags.nic_core_reset_hdlr_active) {
		if (qla83xx_check_nic_core_fw_alive(base_vha) == QLA_SUCCESS) {
			qla83xx_idc_lock(base_vha, 0);
			qla83xx_rd_reg(base_vha, QLA83XX_IDC_DEV_STATE,
			    &dev_state);
			qla83xx_idc_unlock(base_vha, 0);
			if (dev_state != QLA8XXX_DEV_NEED_RESET) {
				ql_dbg(ql_dbg_p3p, base_vha, 0xb07a,
				    "Nic Core f/w is alive.\n");
				return;
			}
		}

		ha->flags.nic_core_reset_hdlr_active = 1;
		if (qla83xx_nic_core_reset(base_vha)) {
			/* NIC Core reset failed. */
			ql_dbg(ql_dbg_p3p, base_vha, 0xb061,
			    "NIC Core reset failed.\n");
		}
		ha->flags.nic_core_reset_hdlr_active = 0;
	}
}

/* Work: Handle 8200 IDC aens */
void
qla83xx_service_idc_aen(struct work_struct *work)
{
	struct qla_hw_data *ha =
		container_of(work, struct qla_hw_data, idc_aen);
	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
	uint32_t dev_state, idc_control;

	qla83xx_idc_lock(base_vha, 0);
	qla83xx_rd_reg(base_vha, QLA83XX_IDC_DEV_STATE, &dev_state);
	qla83xx_rd_reg(base_vha, QLA83XX_IDC_CONTROL, &idc_control);
	qla83xx_idc_unlock(base_vha, 0);
	if (dev_state == QLA8XXX_DEV_NEED_RESET) {
		if (idc_control & QLA83XX_IDC_GRACEFUL_RESET) {
			ql_dbg(ql_dbg_p3p, base_vha, 0xb062,
			    "Application requested NIC Core Reset.\n");
			qla83xx_schedule_work(base_vha, QLA83XX_NIC_CORE_RESET);
		} else if (qla83xx_check_nic_core_fw_alive(base_vha) ==
		    QLA_SUCCESS) {
			ql_dbg(ql_dbg_p3p, base_vha, 0xb07b,
			    "Other protocol driver requested NIC Core Reset.\n");
			qla83xx_schedule_work(base_vha, QLA83XX_NIC_CORE_RESET);
		}
	} else if (dev_state == QLA8XXX_DEV_FAILED ||
			dev_state == QLA8XXX_DEV_NEED_QUIESCENT) {
		qla83xx_schedule_work(base_vha, QLA83XX_IDC_STATE_HANDLER);
	}
}

static void
qla83xx_wait_logic(void)
{
	int i;

	/* Yield CPU */
	if (!in_interrupt()) {
		/*
		 * Wait about 200ms before retrying again.
		 * This controls the number of retries for single
		 * lock operation.
		 */
		msleep(100);
		schedule();
	} else {
		for (i = 0; i < 20; i++)
			cpu_relax(); /* This a nop instr on i386 */
	}
}

5025
static int
5026 5027 5028 5029 5030 5031 5032
qla83xx_force_lock_recovery(scsi_qla_host_t *base_vha)
{
	int rval;
	uint32_t data;
	uint32_t idc_lck_rcvry_stage_mask = 0x3;
	uint32_t idc_lck_rcvry_owner_mask = 0x3c;
	struct qla_hw_data *ha = base_vha->hw;
5033 5034
	ql_dbg(ql_dbg_p3p, base_vha, 0xb086,
	    "Trying force recovery of the IDC lock.\n");
5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085

	rval = qla83xx_rd_reg(base_vha, QLA83XX_IDC_LOCK_RECOVERY, &data);
	if (rval)
		return rval;

	if ((data & idc_lck_rcvry_stage_mask) > 0) {
		return QLA_SUCCESS;
	} else {
		data = (IDC_LOCK_RECOVERY_STAGE1) | (ha->portnum << 2);
		rval = qla83xx_wr_reg(base_vha, QLA83XX_IDC_LOCK_RECOVERY,
		    data);
		if (rval)
			return rval;

		msleep(200);

		rval = qla83xx_rd_reg(base_vha, QLA83XX_IDC_LOCK_RECOVERY,
		    &data);
		if (rval)
			return rval;

		if (((data & idc_lck_rcvry_owner_mask) >> 2) == ha->portnum) {
			data &= (IDC_LOCK_RECOVERY_STAGE2 |
					~(idc_lck_rcvry_stage_mask));
			rval = qla83xx_wr_reg(base_vha,
			    QLA83XX_IDC_LOCK_RECOVERY, data);
			if (rval)
				return rval;

			/* Forcefully perform IDC UnLock */
			rval = qla83xx_rd_reg(base_vha, QLA83XX_DRIVER_UNLOCK,
			    &data);
			if (rval)
				return rval;
			/* Clear lock-id by setting 0xff */
			rval = qla83xx_wr_reg(base_vha, QLA83XX_DRIVER_LOCKID,
			    0xff);
			if (rval)
				return rval;
			/* Clear lock-recovery by setting 0x0 */
			rval = qla83xx_wr_reg(base_vha,
			    QLA83XX_IDC_LOCK_RECOVERY, 0x0);
			if (rval)
				return rval;
		} else
			return QLA_SUCCESS;
	}

	return rval;
}

5086
static int
5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125
qla83xx_idc_lock_recovery(scsi_qla_host_t *base_vha)
{
	int rval = QLA_SUCCESS;
	uint32_t o_drv_lockid, n_drv_lockid;
	unsigned long lock_recovery_timeout;

	lock_recovery_timeout = jiffies + QLA83XX_MAX_LOCK_RECOVERY_WAIT;
retry_lockid:
	rval = qla83xx_rd_reg(base_vha, QLA83XX_DRIVER_LOCKID, &o_drv_lockid);
	if (rval)
		goto exit;

	/* MAX wait time before forcing IDC Lock recovery = 2 secs */
	if (time_after_eq(jiffies, lock_recovery_timeout)) {
		if (qla83xx_force_lock_recovery(base_vha) == QLA_SUCCESS)
			return QLA_SUCCESS;
		else
			return QLA_FUNCTION_FAILED;
	}

	rval = qla83xx_rd_reg(base_vha, QLA83XX_DRIVER_LOCKID, &n_drv_lockid);
	if (rval)
		goto exit;

	if (o_drv_lockid == n_drv_lockid) {
		qla83xx_wait_logic();
		goto retry_lockid;
	} else
		return QLA_SUCCESS;

exit:
	return rval;
}

void
qla83xx_idc_lock(scsi_qla_host_t *base_vha, uint16_t requester_id)
{
	uint16_t options = (requester_id << 15) | BIT_6;
	uint32_t data;
5126
	uint32_t lock_owner;
5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137
	struct qla_hw_data *ha = base_vha->hw;

	/* IDC-lock implementation using driver-lock/lock-id remote registers */
retry_lock:
	if (qla83xx_rd_reg(base_vha, QLA83XX_DRIVER_LOCK, &data)
	    == QLA_SUCCESS) {
		if (data) {
			/* Setting lock-id to our function-number */
			qla83xx_wr_reg(base_vha, QLA83XX_DRIVER_LOCKID,
			    ha->portnum);
		} else {
5138 5139
			qla83xx_rd_reg(base_vha, QLA83XX_DRIVER_LOCKID,
			    &lock_owner);
5140
			ql_dbg(ql_dbg_p3p, base_vha, 0xb063,
5141 5142
			    "Failed to acquire IDC lock, acquired by %d, "
			    "retrying...\n", lock_owner);
5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177

			/* Retry/Perform IDC-Lock recovery */
			if (qla83xx_idc_lock_recovery(base_vha)
			    == QLA_SUCCESS) {
				qla83xx_wait_logic();
				goto retry_lock;
			} else
				ql_log(ql_log_warn, base_vha, 0xb075,
				    "IDC Lock recovery FAILED.\n");
		}

	}

	return;

	/* XXX: IDC-lock implementation using access-control mbx */
retry_lock2:
	if (qla83xx_access_control(base_vha, options, 0, 0, NULL)) {
		ql_dbg(ql_dbg_p3p, base_vha, 0xb072,
		    "Failed to acquire IDC lock. retrying...\n");
		/* Retry/Perform IDC-Lock recovery */
		if (qla83xx_idc_lock_recovery(base_vha) == QLA_SUCCESS) {
			qla83xx_wait_logic();
			goto retry_lock2;
		} else
			ql_log(ql_log_warn, base_vha, 0xb076,
			    "IDC Lock recovery FAILED.\n");
	}

	return;
}

void
qla83xx_idc_unlock(scsi_qla_host_t *base_vha, uint16_t requester_id)
{
5178 5179 5180 5181
#if 0
	uint16_t options = (requester_id << 15) | BIT_7;
#endif
	uint16_t retry;
5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202
	uint32_t data;
	struct qla_hw_data *ha = base_vha->hw;

	/* IDC-unlock implementation using driver-unlock/lock-id
	 * remote registers
	 */
	retry = 0;
retry_unlock:
	if (qla83xx_rd_reg(base_vha, QLA83XX_DRIVER_LOCKID, &data)
	    == QLA_SUCCESS) {
		if (data == ha->portnum) {
			qla83xx_rd_reg(base_vha, QLA83XX_DRIVER_UNLOCK, &data);
			/* Clearing lock-id by setting 0xff */
			qla83xx_wr_reg(base_vha, QLA83XX_DRIVER_LOCKID, 0xff);
		} else if (retry < 10) {
			/* SV: XXX: IDC unlock retrying needed here? */

			/* Retry for IDC-unlock */
			qla83xx_wait_logic();
			retry++;
			ql_dbg(ql_dbg_p3p, base_vha, 0xb064,
5203
			    "Failed to release IDC lock, retrying=%d\n", retry);
5204 5205 5206 5207 5208 5209 5210
			goto retry_unlock;
		}
	} else if (retry < 10) {
		/* Retry for IDC-unlock */
		qla83xx_wait_logic();
		retry++;
		ql_dbg(ql_dbg_p3p, base_vha, 0xb065,
5211
		    "Failed to read drv-lockid, retrying=%d\n", retry);
5212 5213 5214 5215 5216
		goto retry_unlock;
	}

	return;

5217
#if 0
5218 5219 5220 5221 5222 5223 5224 5225 5226
	/* XXX: IDC-unlock implementation using access-control mbx */
	retry = 0;
retry_unlock2:
	if (qla83xx_access_control(base_vha, options, 0, 0, NULL)) {
		if (retry < 10) {
			/* Retry for IDC-unlock */
			qla83xx_wait_logic();
			retry++;
			ql_dbg(ql_dbg_p3p, base_vha, 0xb066,
5227
			    "Failed to release IDC lock, retrying=%d\n", retry);
5228 5229 5230 5231 5232
			goto retry_unlock2;
		}
	}

	return;
5233
#endif
5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293
}

int
__qla83xx_set_drv_presence(scsi_qla_host_t *vha)
{
	int rval = QLA_SUCCESS;
	struct qla_hw_data *ha = vha->hw;
	uint32_t drv_presence;

	rval = qla83xx_rd_reg(vha, QLA83XX_IDC_DRV_PRESENCE, &drv_presence);
	if (rval == QLA_SUCCESS) {
		drv_presence |= (1 << ha->portnum);
		rval = qla83xx_wr_reg(vha, QLA83XX_IDC_DRV_PRESENCE,
		    drv_presence);
	}

	return rval;
}

int
qla83xx_set_drv_presence(scsi_qla_host_t *vha)
{
	int rval = QLA_SUCCESS;

	qla83xx_idc_lock(vha, 0);
	rval = __qla83xx_set_drv_presence(vha);
	qla83xx_idc_unlock(vha, 0);

	return rval;
}

int
__qla83xx_clear_drv_presence(scsi_qla_host_t *vha)
{
	int rval = QLA_SUCCESS;
	struct qla_hw_data *ha = vha->hw;
	uint32_t drv_presence;

	rval = qla83xx_rd_reg(vha, QLA83XX_IDC_DRV_PRESENCE, &drv_presence);
	if (rval == QLA_SUCCESS) {
		drv_presence &= ~(1 << ha->portnum);
		rval = qla83xx_wr_reg(vha, QLA83XX_IDC_DRV_PRESENCE,
		    drv_presence);
	}

	return rval;
}

int
qla83xx_clear_drv_presence(scsi_qla_host_t *vha)
{
	int rval = QLA_SUCCESS;

	qla83xx_idc_lock(vha, 0);
	rval = __qla83xx_clear_drv_presence(vha);
	qla83xx_idc_unlock(vha, 0);

	return rval;
}

5294
static void
5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305
qla83xx_need_reset_handler(scsi_qla_host_t *vha)
{
	struct qla_hw_data *ha = vha->hw;
	uint32_t drv_ack, drv_presence;
	unsigned long ack_timeout;

	/* Wait for IDC ACK from all functions (DRV-ACK == DRV-PRESENCE) */
	ack_timeout = jiffies + (ha->fcoe_reset_timeout * HZ);
	while (1) {
		qla83xx_rd_reg(vha, QLA83XX_IDC_DRIVER_ACK, &drv_ack);
		qla83xx_rd_reg(vha, QLA83XX_IDC_DRV_PRESENCE, &drv_presence);
5306
		if ((drv_ack & drv_presence) == drv_presence)
5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332
			break;

		if (time_after_eq(jiffies, ack_timeout)) {
			ql_log(ql_log_warn, vha, 0xb067,
			    "RESET ACK TIMEOUT! drv_presence=0x%x "
			    "drv_ack=0x%x\n", drv_presence, drv_ack);
			/*
			 * The function(s) which did not ack in time are forced
			 * to withdraw any further participation in the IDC
			 * reset.
			 */
			if (drv_ack != drv_presence)
				qla83xx_wr_reg(vha, QLA83XX_IDC_DRV_PRESENCE,
				    drv_ack);
			break;
		}

		qla83xx_idc_unlock(vha, 0);
		msleep(1000);
		qla83xx_idc_lock(vha, 0);
	}

	qla83xx_wr_reg(vha, QLA83XX_IDC_DEV_STATE, QLA8XXX_DEV_COLD);
	ql_log(ql_log_info, vha, 0xb068, "HW State: COLD/RE-INIT.\n");
}

5333
static int
5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466
qla83xx_device_bootstrap(scsi_qla_host_t *vha)
{
	int rval = QLA_SUCCESS;
	uint32_t idc_control;

	qla83xx_wr_reg(vha, QLA83XX_IDC_DEV_STATE, QLA8XXX_DEV_INITIALIZING);
	ql_log(ql_log_info, vha, 0xb069, "HW State: INITIALIZING.\n");

	/* Clearing IDC-Control Graceful-Reset Bit before resetting f/w */
	__qla83xx_get_idc_control(vha, &idc_control);
	idc_control &= ~QLA83XX_IDC_GRACEFUL_RESET;
	__qla83xx_set_idc_control(vha, 0);

	qla83xx_idc_unlock(vha, 0);
	rval = qla83xx_restart_nic_firmware(vha);
	qla83xx_idc_lock(vha, 0);

	if (rval != QLA_SUCCESS) {
		ql_log(ql_log_fatal, vha, 0xb06a,
		    "Failed to restart NIC f/w.\n");
		qla83xx_wr_reg(vha, QLA83XX_IDC_DEV_STATE, QLA8XXX_DEV_FAILED);
		ql_log(ql_log_info, vha, 0xb06b, "HW State: FAILED.\n");
	} else {
		ql_dbg(ql_dbg_p3p, vha, 0xb06c,
		    "Success in restarting nic f/w.\n");
		qla83xx_wr_reg(vha, QLA83XX_IDC_DEV_STATE, QLA8XXX_DEV_READY);
		ql_log(ql_log_info, vha, 0xb06d, "HW State: READY.\n");
	}

	return rval;
}

/* Assumes idc_lock always held on entry */
int
qla83xx_idc_state_handler(scsi_qla_host_t *base_vha)
{
	struct qla_hw_data *ha = base_vha->hw;
	int rval = QLA_SUCCESS;
	unsigned long dev_init_timeout;
	uint32_t dev_state;

	/* Wait for MAX-INIT-TIMEOUT for the device to go ready */
	dev_init_timeout = jiffies + (ha->fcoe_dev_init_timeout * HZ);

	while (1) {

		if (time_after_eq(jiffies, dev_init_timeout)) {
			ql_log(ql_log_warn, base_vha, 0xb06e,
			    "Initialization TIMEOUT!\n");
			/* Init timeout. Disable further NIC Core
			 * communication.
			 */
			qla83xx_wr_reg(base_vha, QLA83XX_IDC_DEV_STATE,
				QLA8XXX_DEV_FAILED);
			ql_log(ql_log_info, base_vha, 0xb06f,
			    "HW State: FAILED.\n");
		}

		qla83xx_rd_reg(base_vha, QLA83XX_IDC_DEV_STATE, &dev_state);
		switch (dev_state) {
		case QLA8XXX_DEV_READY:
			if (ha->flags.nic_core_reset_owner)
				qla83xx_idc_audit(base_vha,
				    IDC_AUDIT_COMPLETION);
			ha->flags.nic_core_reset_owner = 0;
			ql_dbg(ql_dbg_p3p, base_vha, 0xb070,
			    "Reset_owner reset by 0x%x.\n",
			    ha->portnum);
			goto exit;
		case QLA8XXX_DEV_COLD:
			if (ha->flags.nic_core_reset_owner)
				rval = qla83xx_device_bootstrap(base_vha);
			else {
			/* Wait for AEN to change device-state */
				qla83xx_idc_unlock(base_vha, 0);
				msleep(1000);
				qla83xx_idc_lock(base_vha, 0);
			}
			break;
		case QLA8XXX_DEV_INITIALIZING:
			/* Wait for AEN to change device-state */
			qla83xx_idc_unlock(base_vha, 0);
			msleep(1000);
			qla83xx_idc_lock(base_vha, 0);
			break;
		case QLA8XXX_DEV_NEED_RESET:
			if (!ql2xdontresethba && ha->flags.nic_core_reset_owner)
				qla83xx_need_reset_handler(base_vha);
			else {
				/* Wait for AEN to change device-state */
				qla83xx_idc_unlock(base_vha, 0);
				msleep(1000);
				qla83xx_idc_lock(base_vha, 0);
			}
			/* reset timeout value after need reset handler */
			dev_init_timeout = jiffies +
			    (ha->fcoe_dev_init_timeout * HZ);
			break;
		case QLA8XXX_DEV_NEED_QUIESCENT:
			/* XXX: DEBUG for now */
			qla83xx_idc_unlock(base_vha, 0);
			msleep(1000);
			qla83xx_idc_lock(base_vha, 0);
			break;
		case QLA8XXX_DEV_QUIESCENT:
			/* XXX: DEBUG for now */
			if (ha->flags.quiesce_owner)
				goto exit;

			qla83xx_idc_unlock(base_vha, 0);
			msleep(1000);
			qla83xx_idc_lock(base_vha, 0);
			dev_init_timeout = jiffies +
			    (ha->fcoe_dev_init_timeout * HZ);
			break;
		case QLA8XXX_DEV_FAILED:
			if (ha->flags.nic_core_reset_owner)
				qla83xx_idc_audit(base_vha,
				    IDC_AUDIT_COMPLETION);
			ha->flags.nic_core_reset_owner = 0;
			__qla83xx_clear_drv_presence(base_vha);
			qla83xx_idc_unlock(base_vha, 0);
			qla8xxx_dev_failed_handler(base_vha);
			rval = QLA_FUNCTION_FAILED;
			qla83xx_idc_lock(base_vha, 0);
			goto exit;
		case QLA8XXX_BAD_VALUE:
			qla83xx_idc_unlock(base_vha, 0);
			msleep(1000);
			qla83xx_idc_lock(base_vha, 0);
			break;
		default:
			ql_log(ql_log_warn, base_vha, 0xb071,
5467
			    "Unknown Device State: %x.\n", dev_state);
5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479
			qla83xx_idc_unlock(base_vha, 0);
			qla8xxx_dev_failed_handler(base_vha);
			rval = QLA_FUNCTION_FAILED;
			qla83xx_idc_lock(base_vha, 0);
			goto exit;
		}
	}

exit:
	return rval;
}

5480 5481 5482 5483 5484 5485 5486 5487
void
qla2x00_disable_board_on_pci_error(struct work_struct *work)
{
	struct qla_hw_data *ha = container_of(work, struct qla_hw_data,
	    board_disable);
	struct pci_dev *pdev = ha->pdev;
	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);

5488 5489
	/*
	 * if UNLOAD flag is already set, then continue unload,
5490 5491 5492 5493 5494
	 * where it was set first.
	 */
	if (test_bit(UNLOADING, &base_vha->dpc_flags))
		return;

5495 5496 5497
	ql_log(ql_log_warn, base_vha, 0x015b,
	    "Disabling adapter.\n");

5498 5499
	qla2x00_wait_for_sess_deletion(base_vha);

5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529
	set_bit(UNLOADING, &base_vha->dpc_flags);

	qla2x00_delete_all_vps(ha, base_vha);

	qla2x00_abort_all_cmds(base_vha, DID_NO_CONNECT << 16);

	qla2x00_dfs_remove(base_vha);

	qla84xx_put_chip(base_vha);

	if (base_vha->timer_active)
		qla2x00_stop_timer(base_vha);

	base_vha->flags.online = 0;

	qla2x00_destroy_deferred_work(ha);

	/*
	 * Do not try to stop beacon blink as it will issue a mailbox
	 * command.
	 */
	qla2x00_free_sysfs_attr(base_vha, false);

	fc_remove_host(base_vha->host);

	scsi_remove_host(base_vha->host);

	base_vha->flags.init_done = 0;
	qla25xx_delete_queues(base_vha);
	qla2x00_free_fcports(base_vha);
5530
	qla2x00_free_irqs(base_vha);
5531 5532 5533 5534 5535 5536 5537 5538 5539 5540
	qla2x00_mem_free(ha);
	qla82xx_md_free(base_vha);
	qla2x00_free_queues(ha);

	qla2x00_unmap_iobases(ha);

	pci_release_selected_regions(ha->pdev, ha->bars);
	pci_disable_pcie_error_reporting(pdev);
	pci_disable_device(pdev);

5541 5542 5543
	/*
	 * Let qla2x00_remove_one cleanup qla_hw_data on device removal.
	 */
5544 5545
}

L
Linus Torvalds 已提交
5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561
/**************************************************************************
* qla2x00_do_dpc
*   This kernel thread is a task that is schedule by the interrupt handler
*   to perform the background processing for interrupts.
*
* Notes:
* This task always run in the context of a kernel thread.  It
* is kick-off by the driver's detect code and starts up
* up one per adapter. It immediately goes to sleep and waits for
* some fibre event.  When either the interrupt handler or
* the timer routine detects a event it will one of the task
* bits then wake us up.
**************************************************************************/
static int
qla2x00_do_dpc(void *data)
{
5562 5563
	scsi_qla_host_t *base_vha;
	struct qla_hw_data *ha;
5564 5565
	uint32_t online;
	struct qla_qpair *qpair;
L
Linus Torvalds 已提交
5566

5567 5568
	ha = (struct qla_hw_data *)data;
	base_vha = pci_get_drvdata(ha->pdev);
L
Linus Torvalds 已提交
5569

5570
	set_user_nice(current, MIN_NICE);
L
Linus Torvalds 已提交
5571

5572
	set_current_state(TASK_INTERRUPTIBLE);
5573
	while (!kthread_should_stop()) {
5574 5575
		ql_dbg(ql_dbg_dpc, base_vha, 0x4000,
		    "DPC handler sleeping.\n");
L
Linus Torvalds 已提交
5576

5577
		schedule();
L
Linus Torvalds 已提交
5578

5579 5580
		if (!base_vha->flags.init_done || ha->flags.mbox_busy)
			goto end_loop;
L
Linus Torvalds 已提交
5581

5582
		if (ha->flags.eeh_busy) {
5583 5584
			ql_dbg(ql_dbg_dpc, base_vha, 0x4003,
			    "eeh_busy=%d.\n", ha->flags.eeh_busy);
5585
			goto end_loop;
5586 5587
		}

L
Linus Torvalds 已提交
5588 5589
		ha->dpc_active = 1;

5590 5591 5592
		ql_dbg(ql_dbg_dpc + ql_dbg_verbose, base_vha, 0x4001,
		    "DPC handler waking up, dpc_flags=0x%lx.\n",
		    base_vha->dpc_flags);
L
Linus Torvalds 已提交
5593

5594 5595 5596
		if (test_bit(UNLOADING, &base_vha->dpc_flags))
			break;

5597
		qla2x00_do_work(base_vha);
5598

5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625
		if (IS_P3P_TYPE(ha)) {
			if (IS_QLA8044(ha)) {
				if (test_and_clear_bit(ISP_UNRECOVERABLE,
					&base_vha->dpc_flags)) {
					qla8044_idc_lock(ha);
					qla8044_wr_direct(base_vha,
						QLA8044_CRB_DEV_STATE_INDEX,
						QLA8XXX_DEV_FAILED);
					qla8044_idc_unlock(ha);
					ql_log(ql_log_info, base_vha, 0x4004,
						"HW State: FAILED.\n");
					qla8044_device_state_handler(base_vha);
					continue;
				}

			} else {
				if (test_and_clear_bit(ISP_UNRECOVERABLE,
					&base_vha->dpc_flags)) {
					qla82xx_idc_lock(ha);
					qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
						QLA8XXX_DEV_FAILED);
					qla82xx_idc_unlock(ha);
					ql_log(ql_log_info, base_vha, 0x0151,
						"HW State: FAILED.\n");
					qla82xx_device_state_handler(base_vha);
					continue;
				}
5626 5627 5628 5629 5630
			}

			if (test_and_clear_bit(FCOE_CTX_RESET_NEEDED,
				&base_vha->dpc_flags)) {

5631 5632
				ql_dbg(ql_dbg_dpc, base_vha, 0x4005,
				    "FCoE context reset scheduled.\n");
5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645
				if (!(test_and_set_bit(ABORT_ISP_ACTIVE,
					&base_vha->dpc_flags))) {
					if (qla82xx_fcoe_ctx_reset(base_vha)) {
						/* FCoE-ctx reset failed.
						 * Escalate to chip-reset
						 */
						set_bit(ISP_ABORT_NEEDED,
							&base_vha->dpc_flags);
					}
					clear_bit(ABORT_ISP_ACTIVE,
						&base_vha->dpc_flags);
				}

5646 5647
				ql_dbg(ql_dbg_dpc, base_vha, 0x4006,
				    "FCoE context reset end.\n");
5648
			}
5649 5650 5651 5652 5653 5654 5655 5656
		} else if (IS_QLAFX00(ha)) {
			if (test_and_clear_bit(ISP_UNRECOVERABLE,
				&base_vha->dpc_flags)) {
				ql_dbg(ql_dbg_dpc, base_vha, 0x4020,
				    "Firmware Reset Recovery\n");
				if (qlafx00_reset_initialize(base_vha)) {
					/* Failed. Abort isp later. */
					if (!test_bit(UNLOADING,
5657
					    &base_vha->dpc_flags)) {
5658 5659 5660 5661 5662
						set_bit(ISP_UNRECOVERABLE,
						    &base_vha->dpc_flags);
						ql_dbg(ql_dbg_dpc, base_vha,
						    0x4021,
						    "Reset Recovery Failed\n");
5663
					}
5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681
				}
			}

			if (test_and_clear_bit(FX00_TARGET_SCAN,
				&base_vha->dpc_flags)) {
				ql_dbg(ql_dbg_dpc, base_vha, 0x4022,
				    "ISPFx00 Target Scan scheduled\n");
				if (qlafx00_rescan_isp(base_vha)) {
					if (!test_bit(UNLOADING,
					    &base_vha->dpc_flags))
						set_bit(ISP_UNRECOVERABLE,
						    &base_vha->dpc_flags);
					ql_dbg(ql_dbg_dpc, base_vha, 0x401e,
					    "ISPFx00 Target Scan Failed\n");
				}
				ql_dbg(ql_dbg_dpc, base_vha, 0x401f,
				    "ISPFx00 Target Scan End\n");
			}
5682 5683 5684 5685 5686 5687 5688 5689
			if (test_and_clear_bit(FX00_HOST_INFO_RESEND,
				&base_vha->dpc_flags)) {
				ql_dbg(ql_dbg_dpc, base_vha, 0x4023,
				    "ISPFx00 Host Info resend scheduled\n");
				qlafx00_fx_disc(base_vha,
				    &base_vha->hw->mr.fcport,
				    FXDISC_REG_HOST_INFO);
			}
5690 5691
		}

5692 5693
		if (test_and_clear_bit(ISP_ABORT_NEEDED,
						&base_vha->dpc_flags)) {
L
Linus Torvalds 已提交
5694

5695 5696
			ql_dbg(ql_dbg_dpc, base_vha, 0x4007,
			    "ISP abort scheduled.\n");
L
Linus Torvalds 已提交
5697
			if (!(test_and_set_bit(ABORT_ISP_ACTIVE,
5698
			    &base_vha->dpc_flags))) {
L
Linus Torvalds 已提交
5699

5700
				if (ha->isp_ops->abort_isp(base_vha)) {
L
Linus Torvalds 已提交
5701 5702
					/* failed. retry later */
					set_bit(ISP_ABORT_NEEDED,
5703
					    &base_vha->dpc_flags);
5704
				}
5705 5706
				clear_bit(ABORT_ISP_ACTIVE,
						&base_vha->dpc_flags);
5707 5708
			}

5709 5710
			ql_dbg(ql_dbg_dpc, base_vha, 0x4008,
			    "ISP abort end.\n");
L
Linus Torvalds 已提交
5711 5712
		}

5713 5714
		if (test_and_clear_bit(FCPORT_UPDATE_NEEDED,
		    &base_vha->dpc_flags)) {
5715
			qla2x00_update_fcports(base_vha);
5716
		}
5717

5718 5719 5720
		if (IS_QLAFX00(ha))
			goto loop_resync_check;

5721
		if (test_bit(ISP_QUIESCE_NEEDED, &base_vha->dpc_flags)) {
5722 5723
			ql_dbg(ql_dbg_dpc, base_vha, 0x4009,
			    "Quiescence mode scheduled.\n");
5724 5725 5726 5727 5728
			if (IS_P3P_TYPE(ha)) {
				if (IS_QLA82XX(ha))
					qla82xx_device_state_handler(base_vha);
				if (IS_QLA8044(ha))
					qla8044_device_state_handler(base_vha);
5729 5730 5731 5732
				clear_bit(ISP_QUIESCE_NEEDED,
				    &base_vha->dpc_flags);
				if (!ha->flags.quiesce_owner) {
					qla2x00_perform_loop_resync(base_vha);
5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743
					if (IS_QLA82XX(ha)) {
						qla82xx_idc_lock(ha);
						qla82xx_clear_qsnt_ready(
						    base_vha);
						qla82xx_idc_unlock(ha);
					} else if (IS_QLA8044(ha)) {
						qla8044_idc_lock(ha);
						qla8044_clear_qsnt_ready(
						    base_vha);
						qla8044_idc_unlock(ha);
					}
5744 5745 5746 5747 5748
				}
			} else {
				clear_bit(ISP_QUIESCE_NEEDED,
				    &base_vha->dpc_flags);
				qla2x00_quiesce_io(base_vha);
5749
			}
5750 5751
			ql_dbg(ql_dbg_dpc, base_vha, 0x400a,
			    "Quiescence mode end.\n");
5752 5753
		}

5754
		if (test_and_clear_bit(RESET_MARKER_NEEDED,
5755
				&base_vha->dpc_flags) &&
5756
		    (!(test_and_set_bit(RESET_ACTIVE, &base_vha->dpc_flags)))) {
L
Linus Torvalds 已提交
5757

5758 5759
			ql_dbg(ql_dbg_dpc, base_vha, 0x400b,
			    "Reset marker scheduled.\n");
5760 5761
			qla2x00_rst_aen(base_vha);
			clear_bit(RESET_ACTIVE, &base_vha->dpc_flags);
5762 5763
			ql_dbg(ql_dbg_dpc, base_vha, 0x400c,
			    "Reset marker end.\n");
L
Linus Torvalds 已提交
5764 5765 5766
		}

		/* Retry each device up to login retry count */
5767 5768 5769 5770
		if ((test_and_clear_bit(RELOGIN_NEEDED,
						&base_vha->dpc_flags)) &&
		    !test_bit(LOOP_RESYNC_NEEDED, &base_vha->dpc_flags) &&
		    atomic_read(&base_vha->loop_state) != LOOP_DOWN) {
L
Linus Torvalds 已提交
5771

5772 5773
			ql_dbg(ql_dbg_dpc, base_vha, 0x400d,
			    "Relogin scheduled.\n");
5774
			qla2x00_relogin(base_vha);
5775 5776
			ql_dbg(ql_dbg_dpc, base_vha, 0x400e,
			    "Relogin end.\n");
L
Linus Torvalds 已提交
5777
		}
5778
loop_resync_check:
5779
		if (test_and_clear_bit(LOOP_RESYNC_NEEDED,
5780
		    &base_vha->dpc_flags)) {
L
Linus Torvalds 已提交
5781

5782 5783
			ql_dbg(ql_dbg_dpc, base_vha, 0x400f,
			    "Loop resync scheduled.\n");
L
Linus Torvalds 已提交
5784 5785

			if (!(test_and_set_bit(LOOP_RESYNC_ACTIVE,
5786
			    &base_vha->dpc_flags))) {
L
Linus Torvalds 已提交
5787

5788
				qla2x00_loop_resync(base_vha);
L
Linus Torvalds 已提交
5789

5790 5791
				clear_bit(LOOP_RESYNC_ACTIVE,
						&base_vha->dpc_flags);
L
Linus Torvalds 已提交
5792 5793
			}

5794 5795
			ql_dbg(ql_dbg_dpc, base_vha, 0x4010,
			    "Loop resync end.\n");
L
Linus Torvalds 已提交
5796 5797
		}

5798 5799 5800
		if (IS_QLAFX00(ha))
			goto intr_on_check;

5801 5802 5803 5804
		if (test_bit(NPIV_CONFIG_NEEDED, &base_vha->dpc_flags) &&
		    atomic_read(&base_vha->loop_state) == LOOP_READY) {
			clear_bit(NPIV_CONFIG_NEEDED, &base_vha->dpc_flags);
			qla2xxx_flash_npiv_conf(base_vha);
5805 5806
		}

5807
intr_on_check:
L
Linus Torvalds 已提交
5808
		if (!ha->interrupts_on)
5809
			ha->isp_ops->enable_intrs(ha);
L
Linus Torvalds 已提交
5810

5811
		if (test_and_clear_bit(BEACON_BLINK_NEEDED,
5812 5813 5814 5815
					&base_vha->dpc_flags)) {
			if (ha->beacon_blink_led == 1)
				ha->isp_ops->beacon_blink(base_vha);
		}
5816

5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832
		/* qpair online check */
		if (test_and_clear_bit(QPAIR_ONLINE_CHECK_NEEDED,
		    &base_vha->dpc_flags)) {
			if (ha->flags.eeh_busy ||
			    ha->flags.pci_channel_io_perm_failure)
				online = 0;
			else
				online = 1;

			mutex_lock(&ha->mq_lock);
			list_for_each_entry(qpair, &base_vha->qp_list,
			    qp_list_elem)
			qpair->online = online;
			mutex_unlock(&ha->mq_lock);
		}

5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843
		if (test_and_clear_bit(SET_ZIO_THRESHOLD_NEEDED, &base_vha->dpc_flags)) {
			ql_log(ql_log_info, base_vha, 0xffffff,
				"nvme: SET ZIO Activity exchange threshold to %d.\n",
						ha->nvme_last_rptd_aen);
			if (qla27xx_set_zio_threshold(base_vha, ha->nvme_last_rptd_aen)) {
				ql_log(ql_log_info, base_vha, 0xffffff,
					"nvme: Unable to SET ZIO Activity exchange threshold to %d.\n",
						ha->nvme_last_rptd_aen);
			}
		}

5844 5845
		if (!IS_QLAFX00(ha))
			qla2x00_do_dpc_all_vps(base_vha);
5846

L
Linus Torvalds 已提交
5847
		ha->dpc_active = 0;
5848
end_loop:
5849
		set_current_state(TASK_INTERRUPTIBLE);
L
Linus Torvalds 已提交
5850
	} /* End of while(1) */
5851
	__set_current_state(TASK_RUNNING);
L
Linus Torvalds 已提交
5852

5853 5854
	ql_dbg(ql_dbg_dpc, base_vha, 0x4011,
	    "DPC handler exiting.\n");
L
Linus Torvalds 已提交
5855 5856 5857 5858 5859 5860

	/*
	 * Make sure that nobody tries to wake us up again.
	 */
	ha->dpc_active = 0;

5861 5862 5863
	/* Cleanup any residual CTX SRBs. */
	qla2x00_abort_all_cmds(base_vha, DID_NO_CONNECT << 16);

5864 5865 5866 5867
	return 0;
}

void
5868
qla2xxx_wake_dpc(struct scsi_qla_host *vha)
5869
{
5870
	struct qla_hw_data *ha = vha->hw;
5871 5872
	struct task_struct *t = ha->dpc_thread;

5873
	if (!test_bit(UNLOADING, &vha->dpc_flags) && t)
5874
		wake_up_process(t);
L
Linus Torvalds 已提交
5875 5876 5877 5878 5879 5880 5881 5882 5883 5884
}

/*
*  qla2x00_rst_aen
*      Processes asynchronous reset.
*
* Input:
*      ha  = adapter block pointer.
*/
static void
5885
qla2x00_rst_aen(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
5886
{
5887 5888 5889
	if (vha->flags.online && !vha->flags.reset_active &&
	    !atomic_read(&vha->loop_down_timer) &&
	    !(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))) {
L
Linus Torvalds 已提交
5890
		do {
5891
			clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
5892 5893 5894 5895 5896

			/*
			 * Issue marker command only when we are going to start
			 * the I/O.
			 */
5897 5898 5899
			vha->marker_needed = 1;
		} while (!atomic_read(&vha->loop_down_timer) &&
		    (test_bit(RESET_MARKER_NEEDED, &vha->dpc_flags)));
L
Linus Torvalds 已提交
5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910
	}
}

/**************************************************************************
*   qla2x00_timer
*
* Description:
*   One second timer
*
* Context: Interrupt
***************************************************************************/
5911
void
5912
qla2x00_timer(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
5913 5914 5915 5916 5917
{
	unsigned long	cpu_flags = 0;
	int		start_dpc = 0;
	int		index;
	srb_t		*sp;
5918
	uint16_t        w;
5919
	struct qla_hw_data *ha = vha->hw;
5920
	struct req_que *req;
5921

5922
	if (ha->flags.eeh_busy) {
5923 5924 5925
		ql_dbg(ql_dbg_timer, vha, 0x6000,
		    "EEH = %d, restarting timer.\n",
		    ha->flags.eeh_busy);
5926 5927 5928 5929
		qla2x00_restart_timer(vha, WATCH_INTERVAL);
		return;
	}

5930 5931 5932 5933 5934
	/*
	 * Hardware read to raise pending EEH errors during mailbox waits. If
	 * the read returns -1 then disable the board.
	 */
	if (!pci_channel_offline(ha->pdev)) {
5935
		pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w);
5936
		qla2x00_check_reg16_for_disconnect(vha, w);
5937
	}
L
Linus Torvalds 已提交
5938

5939
	/* Make sure qla82xx_watchdog is run only for physical port */
5940
	if (!vha->vp_idx && IS_P3P_TYPE(ha)) {
5941 5942
		if (test_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags))
			start_dpc++;
5943 5944 5945 5946
		if (IS_QLA82XX(ha))
			qla82xx_watchdog(vha);
		else if (IS_QLA8044(ha))
			qla8044_watchdog(vha);
5947 5948
	}

5949 5950 5951
	if (!vha->vp_idx && IS_QLAFX00(ha))
		qlafx00_timer_routine(vha);

L
Linus Torvalds 已提交
5952
	/* Loop down handler. */
5953
	if (atomic_read(&vha->loop_down_timer) > 0 &&
5954 5955
	    !(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) &&
	    !(test_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags))
5956
		&& vha->flags.online) {
L
Linus Torvalds 已提交
5957

5958 5959
		if (atomic_read(&vha->loop_down_timer) ==
		    vha->loop_down_abort_time) {
L
Linus Torvalds 已提交
5960

5961 5962
			ql_log(ql_log_info, vha, 0x6008,
			    "Loop down - aborting the queues before time expires.\n");
L
Linus Torvalds 已提交
5963

5964 5965
			if (!IS_QLA2100(ha) && vha->link_down_timeout)
				atomic_set(&vha->loop_state, LOOP_DEAD);
L
Linus Torvalds 已提交
5966

5967 5968 5969 5970
			/*
			 * Schedule an ISP abort to return any FCP2-device
			 * commands.
			 */
5971
			/* NPIV - scan physical port only */
5972
			if (!vha->vp_idx) {
5973 5974
				spin_lock_irqsave(&ha->hardware_lock,
				    cpu_flags);
5975
				req = ha->req_q_map[0];
5976
				for (index = 1;
5977
				    index < req->num_outstanding_cmds;
5978 5979 5980
				    index++) {
					fc_port_t *sfcp;

5981
					sp = req->outstanding_cmds[index];
5982 5983
					if (!sp)
						continue;
5984 5985
					if (sp->cmd_type != TYPE_SRB)
						continue;
5986
					if (sp->type != SRB_SCSI_CMD)
5987
						continue;
5988
					sfcp = sp->fcport;
5989
					if (!(sfcp->flags & FCF_FCP2_DEVICE))
5990
						continue;
5991

5992 5993 5994 5995 5996
					if (IS_QLA82XX(ha))
						set_bit(FCOE_CTX_RESET_NEEDED,
							&vha->dpc_flags);
					else
						set_bit(ISP_ABORT_NEEDED,
5997
							&vha->dpc_flags);
5998 5999 6000
					break;
				}
				spin_unlock_irqrestore(&ha->hardware_lock,
6001
								cpu_flags);
L
Linus Torvalds 已提交
6002 6003 6004 6005 6006
			}
			start_dpc++;
		}

		/* if the loop has been down for 4 minutes, reinit adapter */
6007
		if (atomic_dec_and_test(&vha->loop_down_timer) != 0) {
6008
			if (!(vha->device_flags & DFLG_NO_CABLE)) {
6009
				ql_log(ql_log_warn, vha, 0x6009,
L
Linus Torvalds 已提交
6010 6011
				    "Loop down - aborting ISP.\n");

6012 6013 6014 6015 6016 6017
				if (IS_QLA82XX(ha))
					set_bit(FCOE_CTX_RESET_NEEDED,
						&vha->dpc_flags);
				else
					set_bit(ISP_ABORT_NEEDED,
						&vha->dpc_flags);
L
Linus Torvalds 已提交
6018 6019
			}
		}
6020 6021 6022
		ql_dbg(ql_dbg_timer, vha, 0x600a,
		    "Loop down - seconds remaining %d.\n",
		    atomic_read(&vha->loop_down_timer));
L
Linus Torvalds 已提交
6023
	}
6024 6025
	/* Check if beacon LED needs to be blinked for physical host only */
	if (!vha->vp_idx && (ha->beacon_blink_led == 1)) {
6026
		/* There is no beacon_blink function for ISP82xx */
6027
		if (!IS_P3P_TYPE(ha)) {
6028 6029 6030
			set_bit(BEACON_BLINK_NEEDED, &vha->dpc_flags);
			start_dpc++;
		}
6031 6032
	}

6033
	/* Process any deferred work. */
6034
	if (!list_empty(&vha->work_list))
6035 6036
		start_dpc++;

6037 6038 6039 6040
	/*
	 * FC-NVME
	 * see if the active AEN count has changed from what was last reported.
	 */
6041 6042 6043
	if (!vha->vp_idx &&
		atomic_read(&ha->nvme_active_aen_cnt) != ha->nvme_last_rptd_aen &&
		ha->zio_mode == QLA_ZIO_MODE_6) {
6044
		ql_log(ql_log_info, vha, 0x3002,
6045 6046 6047 6048 6049
			"nvme: Sched: Set ZIO exchange threshold to %d.\n",
			ha->nvme_last_rptd_aen);
		ha->nvme_last_rptd_aen = atomic_read(&ha->nvme_active_aen_cnt);
		set_bit(SET_ZIO_THRESHOLD_NEEDED, &vha->dpc_flags);
		start_dpc++;
6050 6051
	}

L
Linus Torvalds 已提交
6052
	/* Schedule the DPC routine if needed */
6053 6054 6055
	if ((test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) ||
	    test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags) ||
	    test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags) ||
L
Linus Torvalds 已提交
6056
	    start_dpc ||
6057 6058
	    test_bit(RESET_MARKER_NEEDED, &vha->dpc_flags) ||
	    test_bit(BEACON_BLINK_NEEDED, &vha->dpc_flags) ||
6059 6060
	    test_bit(ISP_UNRECOVERABLE, &vha->dpc_flags) ||
	    test_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags) ||
6061
	    test_bit(VP_DPC_NEEDED, &vha->dpc_flags) ||
6062
	    test_bit(RELOGIN_NEEDED, &vha->dpc_flags))) {
6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074
		ql_dbg(ql_dbg_timer, vha, 0x600b,
		    "isp_abort_needed=%d loop_resync_needed=%d "
		    "fcport_update_needed=%d start_dpc=%d "
		    "reset_marker_needed=%d",
		    test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags),
		    test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags),
		    test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags),
		    start_dpc,
		    test_bit(RESET_MARKER_NEEDED, &vha->dpc_flags));
		ql_dbg(ql_dbg_timer, vha, 0x600c,
		    "beacon_blink_needed=%d isp_unrecoverable=%d "
		    "fcoe_ctx_reset_needed=%d vp_dpc_needed=%d "
6075
		    "relogin_needed=%d.\n",
6076 6077 6078 6079
		    test_bit(BEACON_BLINK_NEEDED, &vha->dpc_flags),
		    test_bit(ISP_UNRECOVERABLE, &vha->dpc_flags),
		    test_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags),
		    test_bit(VP_DPC_NEEDED, &vha->dpc_flags),
6080
		    test_bit(RELOGIN_NEEDED, &vha->dpc_flags));
6081
		qla2xxx_wake_dpc(vha);
6082
	}
L
Linus Torvalds 已提交
6083

6084
	qla2x00_restart_timer(vha, WATCH_INTERVAL);
L
Linus Torvalds 已提交
6085 6086
}

6087 6088
/* Firmware interface routines. */

6089
#define FW_BLOBS	11
6090 6091 6092 6093
#define FW_ISP21XX	0
#define FW_ISP22XX	1
#define FW_ISP2300	2
#define FW_ISP2322	3
6094
#define FW_ISP24XX	4
6095
#define FW_ISP25XX	5
6096
#define FW_ISP81XX	6
6097
#define FW_ISP82XX	7
6098 6099
#define FW_ISP2031	8
#define FW_ISP8031	9
6100
#define FW_ISP27XX	10
6101

6102 6103 6104 6105 6106
#define FW_FILE_ISP21XX	"ql2100_fw.bin"
#define FW_FILE_ISP22XX	"ql2200_fw.bin"
#define FW_FILE_ISP2300	"ql2300_fw.bin"
#define FW_FILE_ISP2322	"ql2322_fw.bin"
#define FW_FILE_ISP24XX	"ql2400_fw.bin"
6107
#define FW_FILE_ISP25XX	"ql2500_fw.bin"
6108
#define FW_FILE_ISP81XX	"ql8100_fw.bin"
6109
#define FW_FILE_ISP82XX	"ql8200_fw.bin"
6110 6111
#define FW_FILE_ISP2031	"ql2600_fw.bin"
#define FW_FILE_ISP8031	"ql8300_fw.bin"
6112
#define FW_FILE_ISP27XX	"ql2700_fw.bin"
6113

6114

6115
static DEFINE_MUTEX(qla_fw_lock);
6116 6117

static struct fw_blob qla_fw_blobs[FW_BLOBS] = {
6118 6119 6120 6121 6122
	{ .name = FW_FILE_ISP21XX, .segs = { 0x1000, 0 }, },
	{ .name = FW_FILE_ISP22XX, .segs = { 0x1000, 0 }, },
	{ .name = FW_FILE_ISP2300, .segs = { 0x800, 0 }, },
	{ .name = FW_FILE_ISP2322, .segs = { 0x800, 0x1c000, 0x1e000, 0 }, },
	{ .name = FW_FILE_ISP24XX, },
6123
	{ .name = FW_FILE_ISP25XX, },
6124
	{ .name = FW_FILE_ISP81XX, },
6125
	{ .name = FW_FILE_ISP82XX, },
6126 6127
	{ .name = FW_FILE_ISP2031, },
	{ .name = FW_FILE_ISP8031, },
6128
	{ .name = FW_FILE_ISP27XX, },
6129 6130 6131
};

struct fw_blob *
6132
qla2x00_request_firmware(scsi_qla_host_t *vha)
6133
{
6134
	struct qla_hw_data *ha = vha->hw;
6135 6136 6137 6138 6139 6140
	struct fw_blob *blob;

	if (IS_QLA2100(ha)) {
		blob = &qla_fw_blobs[FW_ISP21XX];
	} else if (IS_QLA2200(ha)) {
		blob = &qla_fw_blobs[FW_ISP22XX];
6141
	} else if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
6142
		blob = &qla_fw_blobs[FW_ISP2300];
6143
	} else if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
6144
		blob = &qla_fw_blobs[FW_ISP2322];
6145
	} else if (IS_QLA24XX_TYPE(ha)) {
6146
		blob = &qla_fw_blobs[FW_ISP24XX];
6147 6148
	} else if (IS_QLA25XX(ha)) {
		blob = &qla_fw_blobs[FW_ISP25XX];
6149 6150
	} else if (IS_QLA81XX(ha)) {
		blob = &qla_fw_blobs[FW_ISP81XX];
6151 6152
	} else if (IS_QLA82XX(ha)) {
		blob = &qla_fw_blobs[FW_ISP82XX];
6153 6154 6155 6156
	} else if (IS_QLA2031(ha)) {
		blob = &qla_fw_blobs[FW_ISP2031];
	} else if (IS_QLA8031(ha)) {
		blob = &qla_fw_blobs[FW_ISP8031];
6157 6158
	} else if (IS_QLA27XX(ha)) {
		blob = &qla_fw_blobs[FW_ISP27XX];
6159 6160
	} else {
		return NULL;
6161 6162
	}

6163
	mutex_lock(&qla_fw_lock);
6164 6165 6166 6167
	if (blob->fw)
		goto out;

	if (request_firmware(&blob->fw, blob->name, &ha->pdev->dev)) {
6168 6169
		ql_log(ql_log_warn, vha, 0x0063,
		    "Failed to load firmware image (%s).\n", blob->name);
6170 6171 6172 6173 6174 6175
		blob->fw = NULL;
		blob = NULL;
		goto out;
	}

out:
6176
	mutex_unlock(&qla_fw_lock);
6177 6178 6179 6180 6181 6182 6183 6184
	return blob;
}

static void
qla2x00_release_firmware(void)
{
	int idx;

6185
	mutex_lock(&qla_fw_lock);
6186
	for (idx = 0; idx < FW_BLOBS; idx++)
6187
		release_firmware(qla_fw_blobs[idx].fw);
6188
	mutex_unlock(&qla_fw_lock);
6189 6190
}

6191 6192 6193
static pci_ers_result_t
qla2xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
{
6194 6195 6196
	scsi_qla_host_t *vha = pci_get_drvdata(pdev);
	struct qla_hw_data *ha = vha->hw;

6197 6198
	ql_dbg(ql_dbg_aer, vha, 0x9000,
	    "PCI error detected, state %x.\n", state);
6199

6200 6201
	switch (state) {
	case pci_channel_io_normal:
6202
		ha->flags.eeh_busy = 0;
6203 6204 6205 6206
		if (ql2xmqsupport) {
			set_bit(QPAIR_ONLINE_CHECK_NEEDED, &vha->dpc_flags);
			qla2xxx_wake_dpc(vha);
		}
6207 6208
		return PCI_ERS_RESULT_CAN_RECOVER;
	case pci_channel_io_frozen:
6209
		ha->flags.eeh_busy = 1;
6210 6211
		/* For ISP82XX complete any pending mailbox cmd */
		if (IS_QLA82XX(ha)) {
6212
			ha->flags.isp82xx_fw_hung = 1;
6213 6214
			ql_dbg(ql_dbg_aer, vha, 0x9001, "Pci channel io frozen\n");
			qla82xx_clear_pending_mbx(vha);
6215
		}
6216
		qla2x00_free_irqs(vha);
6217
		pci_disable_device(pdev);
6218 6219
		/* Return back all IOs */
		qla2x00_abort_all_cmds(vha, DID_RESET << 16);
6220 6221 6222 6223
		if (ql2xmqsupport) {
			set_bit(QPAIR_ONLINE_CHECK_NEEDED, &vha->dpc_flags);
			qla2xxx_wake_dpc(vha);
		}
6224 6225
		return PCI_ERS_RESULT_NEED_RESET;
	case pci_channel_io_perm_failure:
6226 6227
		ha->flags.pci_channel_io_perm_failure = 1;
		qla2x00_abort_all_cmds(vha, DID_NO_CONNECT << 16);
6228 6229 6230 6231
		if (ql2xmqsupport) {
			set_bit(QPAIR_ONLINE_CHECK_NEEDED, &vha->dpc_flags);
			qla2xxx_wake_dpc(vha);
		}
6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242
		return PCI_ERS_RESULT_DISCONNECT;
	}
	return PCI_ERS_RESULT_NEED_RESET;
}

static pci_ers_result_t
qla2xxx_pci_mmio_enabled(struct pci_dev *pdev)
{
	int risc_paused = 0;
	uint32_t stat;
	unsigned long flags;
6243 6244
	scsi_qla_host_t *base_vha = pci_get_drvdata(pdev);
	struct qla_hw_data *ha = base_vha->hw;
6245 6246 6247
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
	struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;

6248 6249 6250
	if (IS_QLA82XX(ha))
		return PCI_ERS_RESULT_RECOVERED;

6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267
	spin_lock_irqsave(&ha->hardware_lock, flags);
	if (IS_QLA2100(ha) || IS_QLA2200(ha)){
		stat = RD_REG_DWORD(&reg->hccr);
		if (stat & HCCR_RISC_PAUSE)
			risc_paused = 1;
	} else if (IS_QLA23XX(ha)) {
		stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
		if (stat & HSR_RISC_PAUSED)
			risc_paused = 1;
	} else if (IS_FWI2_CAPABLE(ha)) {
		stat = RD_REG_DWORD(&reg24->host_status);
		if (stat & HSRX_RISC_PAUSED)
			risc_paused = 1;
	}
	spin_unlock_irqrestore(&ha->hardware_lock, flags);

	if (risc_paused) {
6268 6269
		ql_log(ql_log_info, base_vha, 0x9003,
		    "RISC paused -- mmio_enabled, Dumping firmware.\n");
6270
		ha->isp_ops->fw_dump(base_vha, 0);
6271 6272 6273 6274 6275 6276

		return PCI_ERS_RESULT_NEED_RESET;
	} else
		return PCI_ERS_RESULT_RECOVERED;
}

6277 6278
static uint32_t
qla82xx_error_recovery(scsi_qla_host_t *base_vha)
6279 6280 6281 6282 6283 6284 6285
{
	uint32_t rval = QLA_FUNCTION_FAILED;
	uint32_t drv_active = 0;
	struct qla_hw_data *ha = base_vha->hw;
	int fn;
	struct pci_dev *other_pdev = NULL;

6286 6287
	ql_dbg(ql_dbg_aer, base_vha, 0x9006,
	    "Entered %s.\n", __func__);
6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300

	set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);

	if (base_vha->flags.online) {
		/* Abort all outstanding commands,
		 * so as to be requeued later */
		qla2x00_abort_isp_cleanup(base_vha);
	}


	fn = PCI_FUNC(ha->pdev->devfn);
	while (fn > 0) {
		fn--;
6301 6302
		ql_dbg(ql_dbg_aer, base_vha, 0x9007,
		    "Finding pci device at function = 0x%x.\n", fn);
6303 6304 6305 6306 6307 6308 6309 6310
		other_pdev =
		    pci_get_domain_bus_and_slot(pci_domain_nr(ha->pdev->bus),
		    ha->pdev->bus->number, PCI_DEVFN(PCI_SLOT(ha->pdev->devfn),
		    fn));

		if (!other_pdev)
			continue;
		if (atomic_read(&other_pdev->enable_cnt)) {
6311 6312 6313
			ql_dbg(ql_dbg_aer, base_vha, 0x9008,
			    "Found PCI func available and enable at 0x%x.\n",
			    fn);
6314 6315 6316 6317 6318 6319 6320 6321
			pci_dev_put(other_pdev);
			break;
		}
		pci_dev_put(other_pdev);
	}

	if (!fn) {
		/* Reset owner */
6322 6323 6324
		ql_dbg(ql_dbg_aer, base_vha, 0x9009,
		    "This devfn is reset owner = 0x%x.\n",
		    ha->pdev->devfn);
6325 6326 6327
		qla82xx_idc_lock(ha);

		qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
6328
		    QLA8XXX_DEV_INITIALIZING);
6329 6330 6331 6332 6333

		qla82xx_wr_32(ha, QLA82XX_CRB_DRV_IDC_VERSION,
		    QLA82XX_IDC_VERSION);

		drv_active = qla82xx_rd_32(ha, QLA82XX_CRB_DRV_ACTIVE);
6334 6335
		ql_dbg(ql_dbg_aer, base_vha, 0x900a,
		    "drv_active = 0x%x.\n", drv_active);
6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347

		qla82xx_idc_unlock(ha);
		/* Reset if device is not already reset
		 * drv_active would be 0 if a reset has already been done
		 */
		if (drv_active)
			rval = qla82xx_start_firmware(base_vha);
		else
			rval = QLA_SUCCESS;
		qla82xx_idc_lock(ha);

		if (rval != QLA_SUCCESS) {
6348 6349
			ql_log(ql_log_info, base_vha, 0x900b,
			    "HW State: FAILED.\n");
6350 6351
			qla82xx_clear_drv_active(ha);
			qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
6352
			    QLA8XXX_DEV_FAILED);
6353
		} else {
6354 6355
			ql_log(ql_log_info, base_vha, 0x900c,
			    "HW State: READY.\n");
6356
			qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
6357
			    QLA8XXX_DEV_READY);
6358
			qla82xx_idc_unlock(ha);
6359
			ha->flags.isp82xx_fw_hung = 0;
6360 6361 6362 6363 6364 6365 6366 6367
			rval = qla82xx_restart_isp(base_vha);
			qla82xx_idc_lock(ha);
			/* Clear driver state register */
			qla82xx_wr_32(ha, QLA82XX_CRB_DRV_STATE, 0);
			qla82xx_set_drv_active(base_vha);
		}
		qla82xx_idc_unlock(ha);
	} else {
6368 6369 6370
		ql_dbg(ql_dbg_aer, base_vha, 0x900d,
		    "This devfn is not reset owner = 0x%x.\n",
		    ha->pdev->devfn);
6371
		if ((qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE) ==
6372
		    QLA8XXX_DEV_READY)) {
6373
			ha->flags.isp82xx_fw_hung = 0;
6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384
			rval = qla82xx_restart_isp(base_vha);
			qla82xx_idc_lock(ha);
			qla82xx_set_drv_active(base_vha);
			qla82xx_idc_unlock(ha);
		}
	}
	clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);

	return rval;
}

6385 6386 6387 6388
static pci_ers_result_t
qla2xxx_pci_slot_reset(struct pci_dev *pdev)
{
	pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT;
6389 6390
	scsi_qla_host_t *base_vha = pci_get_drvdata(pdev);
	struct qla_hw_data *ha = base_vha->hw;
6391 6392
	struct rsp_que *rsp;
	int rc, retries = 10;
6393

6394 6395
	ql_dbg(ql_dbg_aer, base_vha, 0x9004,
	    "Slot Reset.\n");
6396

6397 6398 6399 6400 6401 6402 6403 6404
	/* Workaround: qla2xxx driver which access hardware earlier
	 * needs error state to be pci_channel_io_online.
	 * Otherwise mailbox command timesout.
	 */
	pdev->error_state = pci_channel_io_normal;

	pci_restore_state(pdev);

6405 6406 6407 6408 6409
	/* pci_restore_state() clears the saved_state flag of the device
	 * save restored state which resets saved_state flag
	 */
	pci_save_state(pdev);

6410 6411 6412 6413
	if (ha->mem_only)
		rc = pci_enable_device_mem(pdev);
	else
		rc = pci_enable_device(pdev);
6414

6415
	if (rc) {
6416
		ql_log(ql_log_warn, base_vha, 0x9005,
6417
		    "Can't re-enable PCI device after reset.\n");
6418
		goto exit_slot_reset;
6419 6420
	}

6421 6422
	rsp = ha->rsp_q_map[0];
	if (qla2x00_request_irqs(ha, rsp))
6423
		goto exit_slot_reset;
6424

6425
	if (ha->isp_ops->pci_config(base_vha))
6426 6427 6428 6429 6430 6431 6432 6433 6434
		goto exit_slot_reset;

	if (IS_QLA82XX(ha)) {
		if (qla82xx_error_recovery(base_vha) == QLA_SUCCESS) {
			ret = PCI_ERS_RESULT_RECOVERED;
			goto exit_slot_reset;
		} else
			goto exit_slot_reset;
	}
6435

6436 6437
	while (ha->flags.mbox_busy && retries--)
		msleep(1000);
6438

6439
	set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
6440
	if (ha->isp_ops->abort_isp(base_vha) == QLA_SUCCESS)
6441
		ret =  PCI_ERS_RESULT_RECOVERED;
6442
	clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
6443

6444

6445
exit_slot_reset:
6446 6447
	ql_dbg(ql_dbg_aer, base_vha, 0x900e,
	    "slot_reset return %x.\n", ret);
6448

6449 6450 6451 6452 6453 6454
	return ret;
}

static void
qla2xxx_pci_resume(struct pci_dev *pdev)
{
6455 6456
	scsi_qla_host_t *base_vha = pci_get_drvdata(pdev);
	struct qla_hw_data *ha = base_vha->hw;
6457 6458
	int ret;

6459 6460
	ql_dbg(ql_dbg_aer, base_vha, 0x900f,
	    "pci_resume.\n");
6461

6462
	ret = qla2x00_wait_for_hba_online(base_vha);
6463
	if (ret != QLA_SUCCESS) {
6464 6465
		ql_log(ql_log_fatal, base_vha, 0x9002,
		    "The device failed to resume I/O from slot/link_reset.\n");
6466
	}
6467

6468 6469
	pci_cleanup_aer_uncorrect_error_status(pdev);

6470
	ha->flags.eeh_busy = 0;
6471 6472
}

6473 6474 6475 6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492 6493 6494 6495 6496 6497 6498
static void
qla83xx_disable_laser(scsi_qla_host_t *vha)
{
	uint32_t reg, data, fn;
	struct qla_hw_data *ha = vha->hw;
	struct device_reg_24xx __iomem *isp_reg = &ha->iobase->isp24;

	/* pci func #/port # */
	ql_dbg(ql_dbg_init, vha, 0x004b,
	    "Disabling Laser for hba: %p\n", vha);

	fn = (RD_REG_DWORD(&isp_reg->ctrl_status) &
		(BIT_15|BIT_14|BIT_13|BIT_12));

	fn = (fn >> 12);

	if (fn & 1)
		reg = PORT_1_2031;
	else
		reg = PORT_0_2031;

	data = LASER_OFF_2031;

	qla83xx_wr_reg(vha, reg, data);
}

6499 6500 6501 6502 6503 6504 6505
static int qla2xxx_map_queues(struct Scsi_Host *shost)
{
	scsi_qla_host_t *vha = (scsi_qla_host_t *)shost->hostdata;

	return blk_mq_pci_map_queues(&shost->tag_set, vha->hw->pdev);
}

6506
static const struct pci_error_handlers qla2xxx_err_handler = {
6507 6508 6509 6510 6511 6512
	.error_detected = qla2xxx_pci_error_detected,
	.mmio_enabled = qla2xxx_pci_mmio_enabled,
	.slot_reset = qla2xxx_pci_slot_reset,
	.resume = qla2xxx_pci_resume,
};

6513
static struct pci_device_id qla2xxx_pci_tbl[] = {
6514 6515 6516 6517 6518 6519 6520 6521 6522
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2100) },
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2200) },
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2300) },
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2312) },
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2322) },
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6312) },
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6322) },
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2422) },
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2432) },
6523
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP8432) },
6524 6525
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP5422) },
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP5432) },
6526
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2532) },
6527
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2031) },
6528
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP8001) },
6529
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP8021) },
6530
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP8031) },
6531
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISPF001) },
6532
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP8044) },
6533
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2071) },
6534
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2271) },
6535
	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2261) },
6536 6537 6538 6539
	{ 0 },
};
MODULE_DEVICE_TABLE(pci, qla2xxx_pci_tbl);

6540
static struct pci_driver qla2xxx_pci_driver = {
6541
	.name		= QLA2XXX_DRIVER_NAME,
6542 6543 6544
	.driver		= {
		.owner		= THIS_MODULE,
	},
6545
	.id_table	= qla2xxx_pci_tbl,
6546
	.probe		= qla2x00_probe_one,
A
Adrian Bunk 已提交
6547
	.remove		= qla2x00_remove_one,
6548
	.shutdown	= qla2x00_shutdown,
6549
	.err_handler	= &qla2xxx_err_handler,
6550 6551
};

6552
static const struct file_operations apidev_fops = {
6553
	.owner = THIS_MODULE,
6554
	.llseek = noop_llseek,
6555 6556
};

L
Linus Torvalds 已提交
6557 6558 6559 6560 6561 6562
/**
 * qla2x00_module_init - Module initialization.
 **/
static int __init
qla2x00_module_init(void)
{
6563 6564
	int ret = 0;

L
Linus Torvalds 已提交
6565
	/* Allocate cache for SRBs. */
6566
	srb_cachep = kmem_cache_create("qla2xxx_srbs", sizeof(srb_t), 0,
6567
	    SLAB_HWCACHE_ALIGN, NULL);
L
Linus Torvalds 已提交
6568
	if (srb_cachep == NULL) {
6569 6570
		ql_log(ql_log_fatal, NULL, 0x0001,
		    "Unable to allocate SRB cache...Failing load!.\n");
L
Linus Torvalds 已提交
6571 6572 6573
		return -ENOMEM;
	}

6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588
	/* Initialize target kmem_cache and mem_pools */
	ret = qlt_init();
	if (ret < 0) {
		kmem_cache_destroy(srb_cachep);
		return ret;
	} else if (ret > 0) {
		/*
		 * If initiator mode is explictly disabled by qlt_init(),
		 * prevent scsi_transport_fc.c:fc_scsi_scan_rport() from
		 * performing scsi_scan_target() during LOOP UP event.
		 */
		qla2xxx_transport_functions.disable_target_scan = 1;
		qla2xxx_transport_vport_functions.disable_target_scan = 1;
	}

L
Linus Torvalds 已提交
6589 6590
	/* Derive version string. */
	strcpy(qla2x00_version_str, QLA2XXX_VERSION);
6591
	if (ql2xextended_error_logging)
6592 6593
		strcat(qla2x00_version_str, "-debug");

6594 6595
	qla2xxx_transport_template =
	    fc_attach_transport(&qla2xxx_transport_functions);
6596 6597
	if (!qla2xxx_transport_template) {
		kmem_cache_destroy(srb_cachep);
6598 6599
		ql_log(ql_log_fatal, NULL, 0x0002,
		    "fc_attach_transport failed...Failing load!.\n");
6600
		qlt_exit();
L
Linus Torvalds 已提交
6601
		return -ENODEV;
6602
	}
6603 6604 6605

	apidev_major = register_chrdev(0, QLA2XXX_APIDEV, &apidev_fops);
	if (apidev_major < 0) {
6606 6607
		ql_log(ql_log_fatal, NULL, 0x0003,
		    "Unable to register char device %s.\n", QLA2XXX_APIDEV);
6608 6609
	}

6610 6611 6612 6613
	qla2xxx_transport_vport_template =
	    fc_attach_transport(&qla2xxx_transport_vport_functions);
	if (!qla2xxx_transport_vport_template) {
		kmem_cache_destroy(srb_cachep);
6614
		qlt_exit();
6615
		fc_release_transport(qla2xxx_transport_template);
6616 6617
		ql_log(ql_log_fatal, NULL, 0x0004,
		    "fc_attach_transport vport failed...Failing load!.\n");
L
Linus Torvalds 已提交
6618
		return -ENODEV;
6619
	}
6620 6621
	ql_log(ql_log_info, NULL, 0x0005,
	    "QLogic Fibre Channel HBA Driver: %s.\n",
6622
	    qla2x00_version_str);
6623
	ret = pci_register_driver(&qla2xxx_pci_driver);
6624 6625
	if (ret) {
		kmem_cache_destroy(srb_cachep);
6626
		qlt_exit();
6627
		fc_release_transport(qla2xxx_transport_template);
6628
		fc_release_transport(qla2xxx_transport_vport_template);
6629 6630 6631
		ql_log(ql_log_fatal, NULL, 0x0006,
		    "pci_register_driver failed...ret=%d Failing load!.\n",
		    ret);
6632 6633
	}
	return ret;
L
Linus Torvalds 已提交
6634 6635 6636 6637 6638 6639 6640 6641
}

/**
 * qla2x00_module_exit - Module cleanup.
 **/
static void __exit
qla2x00_module_exit(void)
{
6642
	unregister_chrdev(apidev_major, QLA2XXX_APIDEV);
6643
	pci_unregister_driver(&qla2xxx_pci_driver);
6644
	qla2x00_release_firmware();
6645
	kmem_cache_destroy(srb_cachep);
6646
	qlt_exit();
6647 6648
	if (ctx_cachep)
		kmem_cache_destroy(ctx_cachep);
L
Linus Torvalds 已提交
6649
	fc_release_transport(qla2xxx_transport_template);
6650
	fc_release_transport(qla2xxx_transport_vport_template);
L
Linus Torvalds 已提交
6651 6652 6653 6654 6655 6656 6657 6658 6659
}

module_init(qla2x00_module_init);
module_exit(qla2x00_module_exit);

MODULE_AUTHOR("QLogic Corporation");
MODULE_DESCRIPTION("QLogic Fibre Channel HBA Driver");
MODULE_LICENSE("GPL");
MODULE_VERSION(QLA2XXX_VERSION);
6660 6661 6662 6663 6664
MODULE_FIRMWARE(FW_FILE_ISP21XX);
MODULE_FIRMWARE(FW_FILE_ISP22XX);
MODULE_FIRMWARE(FW_FILE_ISP2300);
MODULE_FIRMWARE(FW_FILE_ISP2322);
MODULE_FIRMWARE(FW_FILE_ISP24XX);
6665
MODULE_FIRMWARE(FW_FILE_ISP25XX);