projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] qla2xxx: Simplify interrupt handler locking.
[linux-2.6-block.git] / drivers / scsi / qla2xxx / qla_os.c
CommitLineData
1da177e4 1/*
fa90c54f 2 * QLogic Fibre Channel HBA Driver
01e58d8e 3 * Copyright (c) 2003-2008 QLogic Corporation
1da177e4 4 *
fa90c54f 5 * See LICENSE.qla2xxx for copyright and licensing details.
1da177e4
LT		 6 */
7#include "qla_def.h"
8
9#include <linux/moduleparam.h>
10#include <linux/vmalloc.h>
1da177e4 11#include <linux/delay.h>
39a11240 12#include <linux/kthread.h>
1da177e4
LT		 13
14#include <scsi/scsi_tcq.h>
15#include <scsi/scsicam.h>
16#include <scsi/scsi_transport.h>
17#include <scsi/scsi_transport_fc.h>
18
19/*
20 * Driver version
21 */
22char qla2x00_version_str[40];
23
24/*
25 * SRB allocation cache
26 */
e18b890b 27static struct kmem_cache *srb_cachep;
1da177e4
LT		 28
29/*
30 * Ioctl related information.
31 */
2c3dfe3f 32int num_hosts;
1da177e4
LT		 33int ql2xlogintimeout = 20;
34module_param(ql2xlogintimeout, int, S_IRUGO|S_IRUSR);
35MODULE_PARM_DESC(ql2xlogintimeout,
36 "Login timeout value in seconds.");
37
a7b61842 38int qlport_down_retry;
1da177e4
LT		 39module_param(qlport_down_retry, int, S_IRUGO|S_IRUSR);
40MODULE_PARM_DESC(qlport_down_retry,
900d9f98 41 "Maximum number of command retries to a port that returns "
1da177e4
LT		 42 "a PORT-DOWN status.");
43
1da177e4
LT		 44int ql2xplogiabsentdevice;
45module_param(ql2xplogiabsentdevice, int, S_IRUGO|S_IWUSR);
46MODULE_PARM_DESC(ql2xplogiabsentdevice,
47 "Option to enable PLOGI to devices that are not present after "
900d9f98 48 "a Fabric scan. This is needed for several broken switches. "
1da177e4
LT		 49 "Default is 0 - no PLOGI. 1 - perfom PLOGI.");
50
1da177e4
LT		 51int ql2xloginretrycount = 0;
52module_param(ql2xloginretrycount, int, S_IRUGO|S_IRUSR);
53MODULE_PARM_DESC(ql2xloginretrycount,
54 "Specify an alternate value for the NVRAM login retry count.");
55
a7a167bf
AV		 56int ql2xallocfwdump = 1;
57module_param(ql2xallocfwdump, int, S_IRUGO|S_IRUSR);
58MODULE_PARM_DESC(ql2xallocfwdump,
59 "Option to enable allocation of memory for a firmware dump "
60 "during HBA initialization. Memory allocation requirements "
61 "vary by ISP type. Default is 1 - allocate memory.");
62
11010fec 63int ql2xextended_error_logging;
27d94035 64module_param(ql2xextended_error_logging, int, S_IRUGO|S_IWUSR);
11010fec 65MODULE_PARM_DESC(ql2xextended_error_logging,
0181944f
AV		 66 "Option to enable extended error logging, "
67 "Default is 0 - no logging. 1 - log errors.");
68
1da177e4
LT		 69static void qla2x00_free_device(scsi_qla_host_t *);
70
71static void qla2x00_config_dma_addressing(scsi_qla_host_t *ha);
72
cca5335c
AV		 73int ql2xfdmienable;
74module_param(ql2xfdmienable, int, S_IRUGO|S_IRUSR);
75MODULE_PARM_DESC(ql2xfdmienable,
76 "Enables FDMI registratons "
77 "Default is 0 - no FDMI. 1 - perfom FDMI.");
78
df7baa50
AV		 79#define MAX_Q_DEPTH 32
80static int ql2xmaxqdepth = MAX_Q_DEPTH;
81module_param(ql2xmaxqdepth, int, S_IRUGO|S_IWUSR);
82MODULE_PARM_DESC(ql2xmaxqdepth,
83 "Maximum queue depth to report for target devices.");
84
85int ql2xqfullrampup = 120;
86module_param(ql2xqfullrampup, int, S_IRUGO|S_IWUSR);
87MODULE_PARM_DESC(ql2xqfullrampup,
88 "Number of seconds to wait to begin to ramp-up the queue "
89 "depth for a device after a queue-full condition has been "
90 "detected. Default is 120 seconds.");
91
1da177e4 92/*
fa2a1ce5 93 * SCSI host template entry points
1da177e4
LT		 94 */
95static int qla2xxx_slave_configure(struct scsi_device * device);
f4f051eb 96static int qla2xxx_slave_alloc(struct scsi_device *);
1e99e33a
AV		 97static int qla2xxx_scan_finished(struct Scsi_Host *, unsigned long time);
98static void qla2xxx_scan_start(struct Scsi_Host *);
f4f051eb 99static void qla2xxx_slave_destroy(struct scsi_device *);
1da177e4
LT		 100static int qla2x00_queuecommand(struct scsi_cmnd *cmd,
101 void (*fn)(struct scsi_cmnd *));
fca29703
AV		 102static int qla24xx_queuecommand(struct scsi_cmnd *cmd,
103 void (*fn)(struct scsi_cmnd *));
1da177e4
LT		 104static int qla2xxx_eh_abort(struct scsi_cmnd *);
105static int qla2xxx_eh_device_reset(struct scsi_cmnd *);
106static int qla2xxx_eh_bus_reset(struct scsi_cmnd *);
107static int qla2xxx_eh_host_reset(struct scsi_cmnd *);
1da177e4
LT		 108static int qla2x00_device_reset(scsi_qla_host_t *, fc_port_t *);
109
ce7e4af7
AV		 110static int qla2x00_change_queue_depth(struct scsi_device *, int);
111static int qla2x00_change_queue_type(struct scsi_device *, int);
112
a824ebb3 113static struct scsi_host_template qla2x00_driver_template = {
1da177e4 114 .module = THIS_MODULE,
cb63067a 115 .name = QLA2XXX_DRIVER_NAME,
1da177e4
LT		 116 .queuecommand = qla2x00_queuecommand,
117
118 .eh_abort_handler = qla2xxx_eh_abort,
119 .eh_device_reset_handler = qla2xxx_eh_device_reset,
120 .eh_bus_reset_handler = qla2xxx_eh_bus_reset,
121 .eh_host_reset_handler = qla2xxx_eh_host_reset,
122
123 .slave_configure = qla2xxx_slave_configure,
124
f4f051eb 125 .slave_alloc = qla2xxx_slave_alloc,
126 .slave_destroy = qla2xxx_slave_destroy,
1e99e33a
AV		 127 .scan_finished = qla2xxx_scan_finished,
128 .scan_start = qla2xxx_scan_start,
ce7e4af7
AV		 129 .change_queue_depth = qla2x00_change_queue_depth,
130 .change_queue_type = qla2x00_change_queue_type,
1da177e4
LT		 131 .this_id = -1,
132 .cmd_per_lun = 3,
133 .use_clustering = ENABLE_CLUSTERING,
134 .sg_tablesize = SG_ALL,
135
136 /*
137 * The RISC allows for each command to transfer (2^32-1) bytes of data,
138 * which equates to 0x800000 sectors.
139 */
140 .max_sectors = 0xFFFF,
afb046e2 141 .shost_attrs = qla2x00_host_attrs,
1da177e4
LT		 142};
143
2c3dfe3f 144struct scsi_host_template qla24xx_driver_template = {
fca29703 145 .module = THIS_MODULE,
cb63067a 146 .name = QLA2XXX_DRIVER_NAME,
fca29703
AV		 147 .queuecommand = qla24xx_queuecommand,
148
149 .eh_abort_handler = qla2xxx_eh_abort,
150 .eh_device_reset_handler = qla2xxx_eh_device_reset,
151 .eh_bus_reset_handler = qla2xxx_eh_bus_reset,
152 .eh_host_reset_handler = qla2xxx_eh_host_reset,
153
154 .slave_configure = qla2xxx_slave_configure,
155
156 .slave_alloc = qla2xxx_slave_alloc,
157 .slave_destroy = qla2xxx_slave_destroy,
ed677086
AV		 158 .scan_finished = qla2xxx_scan_finished,
159 .scan_start = qla2xxx_scan_start,
ce7e4af7
AV		 160 .change_queue_depth = qla2x00_change_queue_depth,
161 .change_queue_type = qla2x00_change_queue_type,
fca29703
AV		 162 .this_id = -1,
163 .cmd_per_lun = 3,
164 .use_clustering = ENABLE_CLUSTERING,
165 .sg_tablesize = SG_ALL,
166
167 .max_sectors = 0xFFFF,
afb046e2 168 .shost_attrs = qla2x00_host_attrs,
fca29703
AV		 169};
170
1da177e4 171static struct scsi_transport_template *qla2xxx_transport_template = NULL;
2c3dfe3f 172struct scsi_transport_template *qla2xxx_transport_vport_template = NULL;
1da177e4 173
1da177e4
LT		 174/* TODO Convert to inlines
175 *
176 * Timer routines
177 */
1da177e4 178
2c3dfe3f 179__inline__ void
1da177e4
LT		 180qla2x00_start_timer(scsi_qla_host_t *ha, void *func, unsigned long interval)
181{
182 init_timer(&ha->timer);
183 ha->timer.expires = jiffies + interval * HZ;
184 ha->timer.data = (unsigned long)ha;
185 ha->timer.function = (void (*)(unsigned long))func;
186 add_timer(&ha->timer);
187 ha->timer_active = 1;
188}
189
190static inline void
191qla2x00_restart_timer(scsi_qla_host_t *ha, unsigned long interval)
192{
193 mod_timer(&ha->timer, jiffies + interval * HZ);
194}
195
a824ebb3 196static __inline__ void
1da177e4
LT		 197qla2x00_stop_timer(scsi_qla_host_t *ha)
198{
199 del_timer_sync(&ha->timer);
200 ha->timer_active = 0;
201}
202
1da177e4
LT		 203static int qla2x00_do_dpc(void *data);
204
205static void qla2x00_rst_aen(scsi_qla_host_t *);
206
e8711085 207static int qla2x00_mem_alloc(scsi_qla_host_t *);
a824ebb3 208static void qla2x00_mem_free(scsi_qla_host_t *ha);
f4f051eb 209static void qla2x00_sp_free_dma(scsi_qla_host_t *, srb_t *);
1da177e4 210
1da177e4
LT		 211/* -------------------------------------------------------------------------- */
212
1da177e4 213static char *
abbd8870 214qla2x00_pci_info_str(struct scsi_qla_host *ha, char *str)
1da177e4
LT		 215{
216 static char *pci_bus_modes[] = {
217 "33", "66", "100", "133",
218 };
219 uint16_t pci_bus;
220
221 strcpy(str, "PCI");
222 pci_bus = (ha->pci_attr & (BIT_9 | BIT_10)) >> 9;
223 if (pci_bus) {
224 strcat(str, "-X (");
225 strcat(str, pci_bus_modes[pci_bus]);
226 } else {
227 pci_bus = (ha->pci_attr & BIT_8) >> 8;
228 strcat(str, " (");
229 strcat(str, pci_bus_modes[pci_bus]);
230 }
231 strcat(str, " MHz)");
232
233 return (str);
234}
235
fca29703
AV		 236static char *
237qla24xx_pci_info_str(struct scsi_qla_host *ha, char *str)
238{
239 static char *pci_bus_modes[] = { "33", "66", "100", "133", };
240 uint32_t pci_bus;
241 int pcie_reg;
242
243 pcie_reg = pci_find_capability(ha->pdev, PCI_CAP_ID_EXP);
244 if (pcie_reg) {
245 char lwstr[6];
246 uint16_t pcie_lstat, lspeed, lwidth;
247
248 pcie_reg += 0x12;
249 pci_read_config_word(ha->pdev, pcie_reg, &pcie_lstat);
250 lspeed = pcie_lstat & (BIT_0 | BIT_1 | BIT_2 | BIT_3);
251 lwidth = (pcie_lstat &
252 (BIT_4 | BIT_5 | BIT_6 | BIT_7 | BIT_8 | BIT_9)) >> 4;
253
254 strcpy(str, "PCIe (");
255 if (lspeed == 1)
256 strcat(str, "2.5Gb/s ");
c3a2f0df
AV		 257 else if (lspeed == 2)
258 strcat(str, "5.0Gb/s ");
fca29703
AV		 259 else
260 strcat(str, "<unknown> ");
261 snprintf(lwstr, sizeof(lwstr), "x%d)", lwidth);
262 strcat(str, lwstr);
263
264 return str;
265 }
266
267 strcpy(str, "PCI");
268 pci_bus = (ha->pci_attr & CSRX_PCIX_BUS_MODE_MASK) >> 8;
269 if (pci_bus == 0 || pci_bus == 8) {
270 strcat(str, " (");
271 strcat(str, pci_bus_modes[pci_bus >> 3]);
272 } else {
273 strcat(str, "-X ");
274 if (pci_bus & BIT_2)
275 strcat(str, "Mode 2");
276 else
277 strcat(str, "Mode 1");
278 strcat(str, " (");
279 strcat(str, pci_bus_modes[pci_bus & ~BIT_2]);
280 }
281 strcat(str, " MHz)");
282
283 return str;
284}
285
e5f82ab8 286static char *
abbd8870 287qla2x00_fw_version_str(struct scsi_qla_host *ha, char *str)
1da177e4
LT		 288{
289 char un_str[10];
fa2a1ce5 290
1da177e4
LT		 291 sprintf(str, "%d.%02d.%02d ", ha->fw_major_version,
292 ha->fw_minor_version,
293 ha->fw_subminor_version);
294
295 if (ha->fw_attributes & BIT_9) {
296 strcat(str, "FLX");
297 return (str);
298 }
299
300 switch (ha->fw_attributes & 0xFF) {
301 case 0x7:
302 strcat(str, "EF");
303 break;
304 case 0x17:
305 strcat(str, "TP");
306 break;
307 case 0x37:
308 strcat(str, "IP");
309 break;
310 case 0x77:
311 strcat(str, "VI");
312 break;
313 default:
314 sprintf(un_str, "(%x)", ha->fw_attributes);
315 strcat(str, un_str);
316 break;
317 }
318 if (ha->fw_attributes & 0x100)
319 strcat(str, "X");
320
321 return (str);
322}
323
e5f82ab8 324static char *
fca29703
AV		 325qla24xx_fw_version_str(struct scsi_qla_host *ha, char *str)
326{
f0883ac6
AV		 327 sprintf(str, "%d.%02d.%02d ", ha->fw_major_version,
328 ha->fw_minor_version,
329 ha->fw_subminor_version);
330
fca29703
AV		 331 if (ha->fw_attributes & BIT_0)
332 strcat(str, "[Class 2] ");
333 if (ha->fw_attributes & BIT_1)
334 strcat(str, "[IP] ");
335 if (ha->fw_attributes & BIT_2)
336 strcat(str, "[Multi-ID] ");
c3a2f0df
AV		 337 if (ha->fw_attributes & BIT_3)
338 strcat(str, "[SB-2] ");
339 if (ha->fw_attributes & BIT_4)
340 strcat(str, "[T10 CRC] ");
341 if (ha->fw_attributes & BIT_5)
342 strcat(str, "[VI] ");
fca29703
AV		 343 if (ha->fw_attributes & BIT_13)
344 strcat(str, "[Experimental]");
345 return str;
fca29703
AV		 346}
347
348static inline srb_t *
349qla2x00_get_new_sp(scsi_qla_host_t *ha, fc_port_t *fcport,
350 struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
351{
352 srb_t *sp;
353
354 sp = mempool_alloc(ha->srb_mempool, GFP_ATOMIC);
355 if (!sp)
356 return sp;
357
fca29703
AV		 358 sp->ha = ha;
359 sp->fcport = fcport;
360 sp->cmd = cmd;
361 sp->flags = 0;
362 CMD_SP(cmd) = (void *)sp;
363 cmd->scsi_done = done;
364
365 return sp;
366}
367
1da177e4 368static int
f4f051eb 369qla2x00_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1da177e4 370{
f363b943 371 scsi_qla_host_t *ha = shost_priv(cmd->device->host);
bdf79621 372 fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
19a7b4ae 373 struct fc_rport *rport = starget_to_rport(scsi_target(cmd->device));
f4f051eb 374 srb_t *sp;
375 int rval;
1da177e4 376
14e660e6
SJ		 377 if (unlikely(pci_channel_offline(ha->pdev))) {
378 cmd->result = DID_REQUEUE << 16;
379 goto qc_fail_command;
380 }
381
19a7b4ae
JSEC		 382 rval = fc_remote_port_chkready(rport);
383 if (rval) {
384 cmd->result = rval;
f4f051eb 385 goto qc_fail_command;
386 }
1da177e4 387
387f96b4 388 /* Close window on fcport/rport state-transitioning. */
389 if (!*(fc_port_t **)rport->dd_data) {
390 cmd->result = DID_IMM_RETRY << 16;
391 goto qc_fail_command;
392 }
393
f4f051eb 394 if (atomic_read(&fcport->state) != FCS_ONLINE) {
395 if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD ||
396 atomic_read(&ha->loop_state) == LOOP_DEAD) {
397 cmd->result = DID_NO_CONNECT << 16;
398 goto qc_fail_command;
399 }
400 goto qc_host_busy;
401 }
1da177e4
LT		 402
403 spin_unlock_irq(ha->host->host_lock);
404
fca29703
AV		 405 sp = qla2x00_get_new_sp(ha, fcport, cmd, done);
406 if (!sp)
f4f051eb 407 goto qc_host_busy_lock;
1da177e4 408
f4f051eb 409 rval = qla2x00_start_scsi(sp);
410 if (rval != QLA_SUCCESS)
411 goto qc_host_busy_free_sp;
1da177e4 412
f4f051eb 413 spin_lock_irq(ha->host->host_lock);
1da177e4 414
f4f051eb 415 return 0;
1da177e4 416
f4f051eb 417qc_host_busy_free_sp:
418 qla2x00_sp_free_dma(ha, sp);
f4f051eb 419 mempool_free(sp, ha->srb_mempool);
1da177e4 420
f4f051eb 421qc_host_busy_lock:
422 spin_lock_irq(ha->host->host_lock);
1da177e4 423
f4f051eb 424qc_host_busy:
425 return SCSI_MLQUEUE_HOST_BUSY;
1da177e4 426
f4f051eb 427qc_fail_command:
428 done(cmd);
1da177e4 429
f4f051eb 430 return 0;
1da177e4
LT		 431}
432
fca29703
AV		 433
434static int
435qla24xx_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
436{
f363b943 437 scsi_qla_host_t *ha = shost_priv(cmd->device->host);
fca29703 438 fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
19a7b4ae 439 struct fc_rport *rport = starget_to_rport(scsi_target(cmd->device));
fca29703
AV		 440 srb_t *sp;
441 int rval;
2c3dfe3f 442 scsi_qla_host_t *pha = to_qla_parent(ha);
fca29703 443
14e660e6
SJ		 444 if (unlikely(pci_channel_offline(ha->pdev))) {
445 cmd->result = DID_REQUEUE << 16;
446 goto qc24_fail_command;
447 }
448
19a7b4ae
JSEC		 449 rval = fc_remote_port_chkready(rport);
450 if (rval) {
451 cmd->result = rval;
fca29703
AV		 452 goto qc24_fail_command;
453 }
454
387f96b4 455 /* Close window on fcport/rport state-transitioning. */
456 if (!*(fc_port_t **)rport->dd_data) {
457 cmd->result = DID_IMM_RETRY << 16;
458 goto qc24_fail_command;
459 }
460
fca29703
AV		 461 if (atomic_read(&fcport->state) != FCS_ONLINE) {
462 if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD ||
2c3dfe3f 463 atomic_read(&pha->loop_state) == LOOP_DEAD) {
fca29703
AV		 464 cmd->result = DID_NO_CONNECT << 16;
465 goto qc24_fail_command;
466 }
467 goto qc24_host_busy;
468 }
469
470 spin_unlock_irq(ha->host->host_lock);
471
2c3dfe3f 472 sp = qla2x00_get_new_sp(pha, fcport, cmd, done);
fca29703
AV		 473 if (!sp)
474 goto qc24_host_busy_lock;
475
476 rval = qla24xx_start_scsi(sp);
477 if (rval != QLA_SUCCESS)
478 goto qc24_host_busy_free_sp;
479
480 spin_lock_irq(ha->host->host_lock);
481
482 return 0;
483
484qc24_host_busy_free_sp:
2c3dfe3f
SJ		 485 qla2x00_sp_free_dma(pha, sp);
486 mempool_free(sp, pha->srb_mempool);
fca29703
AV		 487
488qc24_host_busy_lock:
489 spin_lock_irq(ha->host->host_lock);
490
491qc24_host_busy:
492 return SCSI_MLQUEUE_HOST_BUSY;
493
494qc24_fail_command:
495 done(cmd);
496
497 return 0;
498}
499
500
1da177e4
LT		 501/*
502 * qla2x00_eh_wait_on_command
503 * Waits for the command to be returned by the Firmware for some
504 * max time.
505 *
506 * Input:
507 * ha = actual ha whose done queue will contain the command
508 * returned by firmware.
509 * cmd = Scsi Command to wait on.
510 * flag = Abort/Reset(Bus or Device Reset)
511 *
512 * Return:
513 * Not Found : 0
514 * Found : 1
515 */
516static int
517qla2x00_eh_wait_on_command(scsi_qla_host_t *ha, struct scsi_cmnd *cmd)
518{
fe74c71f
AV		 519#define ABORT_POLLING_PERIOD 1000
520#define ABORT_WAIT_ITER ((10 * 1000) / (ABORT_POLLING_PERIOD))
f4f051eb 521 unsigned long wait_iter = ABORT_WAIT_ITER;
522 int ret = QLA_SUCCESS;
1da177e4 523
f4f051eb 524 while (CMD_SP(cmd)) {
fe74c71f 525 msleep(ABORT_POLLING_PERIOD);
1da177e4 526
f4f051eb 527 if (--wait_iter)
528 break;
529 }
530 if (CMD_SP(cmd))
531 ret = QLA_FUNCTION_FAILED;
1da177e4 532
f4f051eb 533 return ret;
1da177e4
LT		 534}
535
536/*
537 * qla2x00_wait_for_hba_online
fa2a1ce5 538 * Wait till the HBA is online after going through
1da177e4
LT		 539 * <= MAX_RETRIES_OF_ISP_ABORT or
540 * finally HBA is disabled ie marked offline
541 *
542 * Input:
543 * ha - pointer to host adapter structure
fa2a1ce5
AV		 544 *
545 * Note:
1da177e4
LT		 546 * Does context switching-Release SPIN_LOCK
547 * (if any) before calling this routine.
548 *
549 * Return:
550 * Success (Adapter is online) : 0
551 * Failed (Adapter is offline/disabled) : 1
552 */
854165f4 553int
1da177e4
LT		 554qla2x00_wait_for_hba_online(scsi_qla_host_t *ha)
555{
fca29703
AV		 556 int return_status;
557 unsigned long wait_online;
2c3dfe3f 558 scsi_qla_host_t *pha = to_qla_parent(ha);
1da177e4 559
fa2a1ce5 560 wait_online = jiffies + (MAX_LOOP_TIMEOUT * HZ);
2c3dfe3f
SJ		 561 while (((test_bit(ISP_ABORT_NEEDED, &pha->dpc_flags)) ||
562 test_bit(ABORT_ISP_ACTIVE, &pha->dpc_flags) ||
563 test_bit(ISP_ABORT_RETRY, &pha->dpc_flags) ||
564 pha->dpc_active) && time_before(jiffies, wait_online)) {
1da177e4
LT		 565
566 msleep(1000);
567 }
2c3dfe3f 568 if (pha->flags.online)
fa2a1ce5 569 return_status = QLA_SUCCESS;
1da177e4
LT		 570 else
571 return_status = QLA_FUNCTION_FAILED;
572
573 DEBUG2(printk("%s return_status=%d\n",__func__,return_status));
574
575 return (return_status);
576}
577
578/*
579 * qla2x00_wait_for_loop_ready
580 * Wait for MAX_LOOP_TIMEOUT(5 min) value for loop
fa2a1ce5 581 * to be in LOOP_READY state.
1da177e4
LT		 582 * Input:
583 * ha - pointer to host adapter structure
fa2a1ce5
AV		 584 *
585 * Note:
1da177e4
LT		 586 * Does context switching-Release SPIN_LOCK
587 * (if any) before calling this routine.
fa2a1ce5 588 *
1da177e4
LT		 589 *
590 * Return:
591 * Success (LOOP_READY) : 0
592 * Failed (LOOP_NOT_READY) : 1
593 */
fa2a1ce5 594static inline int
1da177e4
LT		 595qla2x00_wait_for_loop_ready(scsi_qla_host_t *ha)
596{
597 int return_status = QLA_SUCCESS;
598 unsigned long loop_timeout ;
2c3dfe3f 599 scsi_qla_host_t *pha = to_qla_parent(ha);
1da177e4
LT		 600
601 /* wait for 5 min at the max for loop to be ready */
fa2a1ce5 602 loop_timeout = jiffies + (MAX_LOOP_TIMEOUT * HZ);
1da177e4 603
2c3dfe3f
SJ		 604 while ((!atomic_read(&pha->loop_down_timer) &&
605 atomic_read(&pha->loop_state) == LOOP_DOWN) ||
606 atomic_read(&pha->loop_state) != LOOP_READY) {
607 if (atomic_read(&pha->loop_state) == LOOP_DEAD) {
57680080
RA		 608 return_status = QLA_FUNCTION_FAILED;
609 break;
610 }
1da177e4
LT		 611 msleep(1000);
612 if (time_after_eq(jiffies, loop_timeout)) {
613 return_status = QLA_FUNCTION_FAILED;
614 break;
615 }
616 }
fa2a1ce5 617 return (return_status);
1da177e4
LT		 618}
619
07db5183
AV		 620static void
621qla2x00_block_error_handler(struct scsi_cmnd *cmnd)
622{
623 struct Scsi_Host *shost = cmnd->device->host;
624 struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
625 unsigned long flags;
626
627 spin_lock_irqsave(shost->host_lock, flags);
628 while (rport->port_state == FC_PORTSTATE_BLOCKED) {
629 spin_unlock_irqrestore(shost->host_lock, flags);
630 msleep(1000);
631 spin_lock_irqsave(shost->host_lock, flags);
632 }
633 spin_unlock_irqrestore(shost->host_lock, flags);
634 return;
635}
636
1da177e4
LT		 637/**************************************************************************
638* qla2xxx_eh_abort
639*
640* Description:
641* The abort function will abort the specified command.
642*
643* Input:
644* cmd = Linux SCSI command packet to be aborted.
645*
646* Returns:
647* Either SUCCESS or FAILED.
648*
649* Note:
2ea00202 650* Only return FAILED if command not returned by firmware.
1da177e4 651**************************************************************************/
e5f82ab8 652static int
1da177e4
LT		 653qla2xxx_eh_abort(struct scsi_cmnd *cmd)
654{
f363b943 655 scsi_qla_host_t *ha = shost_priv(cmd->device->host);
f4f051eb 656 srb_t *sp;
657 int ret, i;
658 unsigned int id, lun;
659 unsigned long serial;
18e144d3 660 unsigned long flags;
2ea00202 661 int wait = 0;
2c3dfe3f 662 scsi_qla_host_t *pha = to_qla_parent(ha);
1da177e4 663
07db5183
AV		 664 qla2x00_block_error_handler(cmd);
665
f4f051eb 666 if (!CMD_SP(cmd))
2ea00202 667 return SUCCESS;
1da177e4 668
2ea00202 669 ret = SUCCESS;
1da177e4 670
f4f051eb 671 id = cmd->device->id;
672 lun = cmd->device->lun;
673 serial = cmd->serial_number;
1da177e4 674
f4f051eb 675 /* Check active list for command command. */
2c3dfe3f 676 spin_lock_irqsave(&pha->hardware_lock, flags);
f4f051eb 677 for (i = 1; i < MAX_OUTSTANDING_COMMANDS; i++) {
2c3dfe3f 678 sp = pha->outstanding_cmds[i];
1da177e4 679
f4f051eb 680 if (sp == NULL)
681 continue;
1da177e4 682
f4f051eb 683 if (sp->cmd != cmd)
684 continue;
1da177e4 685
75bc4190
AV		 686 DEBUG2(printk("%s(%ld): aborting sp %p from RISC. pid=%ld.\n",
687 __func__, ha->host_no, sp, serial));
744f11fd 688 DEBUG3(qla2x00_print_scsi_cmd(cmd));
1da177e4 689
2c3dfe3f 690 spin_unlock_irqrestore(&pha->hardware_lock, flags);
fd34f556 691 if (ha->isp_ops->abort_command(ha, sp)) {
f4f051eb 692 DEBUG2(printk("%s(%ld): abort_command "
693 "mbx failed.\n", __func__, ha->host_no));
694 } else {
695 DEBUG3(printk("%s(%ld): abort_command "
696 "mbx success.\n", __func__, ha->host_no));
2ea00202 697 wait = 1;
f4f051eb 698 }
2c3dfe3f 699 spin_lock_irqsave(&pha->hardware_lock, flags);
1da177e4 700
f4f051eb 701 break;
702 }
2c3dfe3f 703 spin_unlock_irqrestore(&pha->hardware_lock, flags);
1da177e4 704
f4f051eb 705 /* Wait for the command to be returned. */
2ea00202 706 if (wait) {
f4f051eb 707 if (qla2x00_eh_wait_on_command(ha, cmd) != QLA_SUCCESS) {
fa2a1ce5 708 qla_printk(KERN_ERR, ha,
f4f051eb 709 "scsi(%ld:%d:%d): Abort handler timed out -- %lx "
710 "%x.\n", ha->host_no, id, lun, serial, ret);
2ea00202 711 ret = FAILED;
f4f051eb 712 }
1da177e4 713 }
1da177e4 714
fa2a1ce5 715 qla_printk(KERN_INFO, ha,
2ea00202
MR		 716 "scsi(%ld:%d:%d): Abort command issued -- %d %lx %x.\n",
717 ha->host_no, id, lun, wait, serial, ret);
1da177e4 718
f4f051eb 719 return ret;
720}
1da177e4 721
f4f051eb 722/**************************************************************************
723* qla2x00_eh_wait_for_pending_target_commands
724*
725* Description:
726* Waits for all the commands to come back from the specified target.
727*
728* Input:
729* ha - pointer to scsi_qla_host structure.
fa2a1ce5 730* t - target
f4f051eb 731* Returns:
732* Either SUCCESS or FAILED.
733*
734* Note:
735**************************************************************************/
736static int
737qla2x00_eh_wait_for_pending_target_commands(scsi_qla_host_t *ha, unsigned int t)
738{
739 int cnt;
740 int status;
741 srb_t *sp;
742 struct scsi_cmnd *cmd;
18e144d3 743 unsigned long flags;
2c3dfe3f 744 scsi_qla_host_t *pha = to_qla_parent(ha);
1da177e4 745
f4f051eb 746 status = 0;
1da177e4
LT		 747
748 /*
f4f051eb 749 * Waiting for all commands for the designated target in the active
750 * array
1da177e4
LT		 751 */
752 for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
2c3dfe3f
SJ		 753 spin_lock_irqsave(&pha->hardware_lock, flags);
754 sp = pha->outstanding_cmds[cnt];
1da177e4
LT		 755 if (sp) {
756 cmd = sp->cmd;
2c3dfe3f
SJ		 757 spin_unlock_irqrestore(&pha->hardware_lock, flags);
758 if (cmd->device->id == t &&
759 ha->vp_idx == sp->ha->vp_idx) {
1da177e4
LT		 760 if (!qla2x00_eh_wait_on_command(ha, cmd)) {
761 status = 1;
762 break;
763 }
764 }
f4f051eb 765 } else {
2c3dfe3f 766 spin_unlock_irqrestore(&pha->hardware_lock, flags);
1da177e4
LT		 767 }
768 }
769 return (status);
770}
771
772
773/**************************************************************************
774* qla2xxx_eh_device_reset
775*
776* Description:
777* The device reset function will reset the target and abort any
778* executing commands.
779*
780* NOTE: The use of SP is undefined within this context. Do *NOT*
fa2a1ce5 781* attempt to use this value, even if you determine it is
1da177e4
LT		 782* non-null.
783*
784* Input:
785* cmd = Linux SCSI command packet of the command that cause the
786* bus device reset.
787*
788* Returns:
789* SUCCESS/FAILURE (defined as macro in scsi.h).
790*
791**************************************************************************/
e5f82ab8 792static int
1da177e4
LT		 793qla2xxx_eh_device_reset(struct scsi_cmnd *cmd)
794{
f363b943 795 scsi_qla_host_t *ha = shost_priv(cmd->device->host);
bdf79621 796 fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
2c3dfe3f 797 int ret = FAILED;
f4f051eb 798 unsigned int id, lun;
799 unsigned long serial;
1da177e4 800
07db5183
AV		 801 qla2x00_block_error_handler(cmd);
802
f4f051eb 803 id = cmd->device->id;
804 lun = cmd->device->lun;
805 serial = cmd->serial_number;
1da177e4 806
b0328bee 807 if (!fcport)
f4f051eb 808 return ret;
1da177e4
LT		 809
810 qla_printk(KERN_INFO, ha,
f4f051eb 811 "scsi(%ld:%d:%d): DEVICE RESET ISSUED.\n", ha->host_no, id, lun);
1da177e4 812
94d0e7b8 813 if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS)
1da177e4 814 goto eh_dev_reset_done;
1da177e4
LT		 815
816 if (qla2x00_wait_for_loop_ready(ha) == QLA_SUCCESS) {
f4f051eb 817 if (qla2x00_device_reset(ha, fcport) == 0)
818 ret = SUCCESS;
1da177e4
LT		 819 } else {
820 DEBUG2(printk(KERN_INFO
744f11fd 821 "%s failed: loop not ready\n",__func__));
1da177e4
LT		 822 }
823
f4f051eb 824 if (ret == FAILED) {
1da177e4
LT		 825 DEBUG3(printk("%s(%ld): device reset failed\n",
826 __func__, ha->host_no));
827 qla_printk(KERN_INFO, ha, "%s: device reset failed\n",
828 __func__);
829
830 goto eh_dev_reset_done;
831 }
832
9a41a62b
AV		 833 /* Flush outstanding commands. */
834 if (qla2x00_eh_wait_for_pending_target_commands(ha, id))
835 ret = FAILED;
836 if (ret == FAILED) {
837 DEBUG3(printk("%s(%ld): failed while waiting for commands\n",
838 __func__, ha->host_no));
839 qla_printk(KERN_INFO, ha,
840 "%s: failed while waiting for commands\n", __func__);
841 } else
842 qla_printk(KERN_INFO, ha,
843 "scsi(%ld:%d:%d): DEVICE RESET SUCCEEDED.\n", ha->host_no,
844 id, lun);
28f22b03 845 eh_dev_reset_done:
f4f051eb 846 return ret;
1da177e4
LT		 847}
848
849/**************************************************************************
850* qla2x00_eh_wait_for_pending_commands
851*
852* Description:
853* Waits for all the commands to come back from the specified host.
854*
855* Input:
856* ha - pointer to scsi_qla_host structure.
857*
858* Returns:
859* 1 : SUCCESS
860* 0 : FAILED
861*
862* Note:
863**************************************************************************/
864static int
865qla2x00_eh_wait_for_pending_commands(scsi_qla_host_t *ha)
866{
867 int cnt;
868 int status;
869 srb_t *sp;
870 struct scsi_cmnd *cmd;
18e144d3 871 unsigned long flags;
1da177e4
LT		 872
873 status = 1;
874
875 /*
876 * Waiting for all commands for the designated target in the active
877 * array
878 */
879 for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
18e144d3 880 spin_lock_irqsave(&ha->hardware_lock, flags);
1da177e4
LT		 881 sp = ha->outstanding_cmds[cnt];
882 if (sp) {
883 cmd = sp->cmd;
18e144d3 884 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1da177e4
LT		 885 status = qla2x00_eh_wait_on_command(ha, cmd);
886 if (status == 0)
887 break;
888 }
889 else {
18e144d3 890 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1da177e4
LT		 891 }
892 }
893 return (status);
894}
895
896
897/**************************************************************************
898* qla2xxx_eh_bus_reset
899*
900* Description:
901* The bus reset function will reset the bus and abort any executing
902* commands.
903*
904* Input:
905* cmd = Linux SCSI command packet of the command that cause the
906* bus reset.
907*
908* Returns:
909* SUCCESS/FAILURE (defined as macro in scsi.h).
910*
911**************************************************************************/
e5f82ab8 912static int
1da177e4
LT		 913qla2xxx_eh_bus_reset(struct scsi_cmnd *cmd)
914{
f363b943 915 scsi_qla_host_t *ha = shost_priv(cmd->device->host);
2c3dfe3f 916 scsi_qla_host_t *pha = to_qla_parent(ha);
bdf79621 917 fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
2c3dfe3f 918 int ret = FAILED;
f4f051eb 919 unsigned int id, lun;
920 unsigned long serial;
921
07db5183
AV		 922 qla2x00_block_error_handler(cmd);
923
f4f051eb 924 id = cmd->device->id;
925 lun = cmd->device->lun;
926 serial = cmd->serial_number;
1da177e4 927
b0328bee 928 if (!fcport)
f4f051eb 929 return ret;
1da177e4
LT		 930
931 qla_printk(KERN_INFO, ha,
f4f051eb 932 "scsi(%ld:%d:%d): LOOP RESET ISSUED.\n", ha->host_no, id, lun);
1da177e4 933
1da177e4
LT		 934 if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) {
935 DEBUG2(printk("%s failed:board disabled\n",__func__));
f4f051eb 936 goto eh_bus_reset_done;
1da177e4
LT		 937 }
938
939 if (qla2x00_wait_for_loop_ready(ha) == QLA_SUCCESS) {
f4f051eb 940 if (qla2x00_loop_reset(ha) == QLA_SUCCESS)
941 ret = SUCCESS;
1da177e4 942 }
f4f051eb 943 if (ret == FAILED)
944 goto eh_bus_reset_done;
1da177e4 945
9a41a62b 946 /* Flush outstanding commands. */
2c3dfe3f 947 if (!qla2x00_eh_wait_for_pending_commands(pha))
9a41a62b 948 ret = FAILED;
1da177e4 949
f4f051eb 950eh_bus_reset_done:
1da177e4 951 qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__,
f4f051eb 952 (ret == FAILED) ? "failed" : "succeded");
1da177e4 953
f4f051eb 954 return ret;
1da177e4
LT		 955}
956
957/**************************************************************************
958* qla2xxx_eh_host_reset
959*
960* Description:
961* The reset function will reset the Adapter.
962*
963* Input:
964* cmd = Linux SCSI command packet of the command that cause the
965* adapter reset.
966*
967* Returns:
968* Either SUCCESS or FAILED.
969*
970* Note:
971**************************************************************************/
e5f82ab8 972static int
1da177e4
LT		 973qla2xxx_eh_host_reset(struct scsi_cmnd *cmd)
974{
f363b943 975 scsi_qla_host_t *ha = shost_priv(cmd->device->host);
bdf79621 976 fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
2c3dfe3f 977 int ret = FAILED;
f4f051eb 978 unsigned int id, lun;
979 unsigned long serial;
2c3dfe3f 980 scsi_qla_host_t *pha = to_qla_parent(ha);
1da177e4 981
07db5183
AV		 982 qla2x00_block_error_handler(cmd);
983
f4f051eb 984 id = cmd->device->id;
985 lun = cmd->device->lun;
986 serial = cmd->serial_number;
987
b0328bee 988 if (!fcport)
f4f051eb 989 return ret;
1da177e4 990
1da177e4 991 qla_printk(KERN_INFO, ha,
f4f051eb 992 "scsi(%ld:%d:%d): ADAPTER RESET ISSUED.\n", ha->host_no, id, lun);
1da177e4 993
1da177e4 994 if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS)
f4f051eb 995 goto eh_host_reset_lock;
1da177e4
LT		 996
997 /*
998 * Fixme-may be dpc thread is active and processing
fa2a1ce5 999 * loop_resync,so wait a while for it to
1da177e4
LT		 1000 * be completed and then issue big hammer.Otherwise
1001 * it may cause I/O failure as big hammer marks the
1002 * devices as lost kicking of the port_down_timer
1003 * while dpc is stuck for the mailbox to complete.
1004 */
1da177e4 1005 qla2x00_wait_for_loop_ready(ha);
2c3dfe3f
SJ		 1006 set_bit(ABORT_ISP_ACTIVE, &pha->dpc_flags);
1007 if (qla2x00_abort_isp(pha)) {
1008 clear_bit(ABORT_ISP_ACTIVE, &pha->dpc_flags);
1da177e4 1009 /* failed. schedule dpc to try */
2c3dfe3f 1010 set_bit(ISP_ABORT_NEEDED, &pha->dpc_flags);
1da177e4
LT		 1011
1012 if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS)
f4f051eb 1013 goto eh_host_reset_lock;
fa2a1ce5 1014 }
2c3dfe3f 1015 clear_bit(ABORT_ISP_ACTIVE, &pha->dpc_flags);
1da177e4 1016
1da177e4 1017 /* Waiting for our command in done_queue to be returned to OS.*/
2c3dfe3f 1018 if (qla2x00_eh_wait_for_pending_commands(pha))
f4f051eb 1019 ret = SUCCESS;
1da177e4 1020
2c3dfe3f
SJ		 1021 if (ha->parent)
1022 qla2x00_vp_abort_isp(ha);
1023
f4f051eb 1024eh_host_reset_lock:
f4f051eb 1025 qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__,
1026 (ret == FAILED) ? "failed" : "succeded");
1da177e4 1027
f4f051eb 1028 return ret;
1029}
1da177e4
LT		 1030
1031/*
1032* qla2x00_loop_reset
1033* Issue loop reset.
1034*
1035* Input:
1036* ha = adapter block pointer.
1037*
1038* Returns:
1039* 0 = success
1040*/
a4722cf2 1041int
1da177e4
LT		 1042qla2x00_loop_reset(scsi_qla_host_t *ha)
1043{
0c8c39af 1044 int ret;
bdf79621 1045 struct fc_port *fcport;
1da177e4 1046
0c8c39af
AV		 1047 if (ha->flags.enable_lip_full_login) {
1048 ret = qla2x00_full_login_lip(ha);
1049 if (ret != QLA_SUCCESS) {
1050 DEBUG2_3(printk("%s(%ld): bus_reset failed: "
1051 "full_login_lip=%d.\n", __func__, ha->host_no,
1052 ret));
1053 }
1054 atomic_set(&ha->loop_state, LOOP_DOWN);
1055 atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
1056 qla2x00_mark_all_devices_lost(ha, 0);
1057 qla2x00_wait_for_loop_ready(ha);
1058 }
1059
1da177e4 1060 if (ha->flags.enable_lip_reset) {
0c8c39af
AV		 1061 ret = qla2x00_lip_reset(ha);
1062 if (ret != QLA_SUCCESS) {
1063 DEBUG2_3(printk("%s(%ld): bus_reset failed: "
1064 "lip_reset=%d.\n", __func__, ha->host_no, ret));
1065 }
1066 qla2x00_wait_for_loop_ready(ha);
1da177e4
LT		 1067 }
1068
0c8c39af 1069 if (ha->flags.enable_target_reset) {
bdf79621 1070 list_for_each_entry(fcport, &ha->fcports, list) {
1071 if (fcport->port_type != FCT_TARGET)
1da177e4
LT		 1072 continue;
1073
0c8c39af
AV		 1074 ret = qla2x00_device_reset(ha, fcport);
1075 if (ret != QLA_SUCCESS) {
1076 DEBUG2_3(printk("%s(%ld): bus_reset failed: "
1077 "target_reset=%d d_id=%x.\n", __func__,
1078 ha->host_no, ret, fcport->d_id.b24));
1079 }
1da177e4
LT		 1080 }
1081 }
1082
1da177e4
LT		 1083 /* Issue marker command only when we are going to start the I/O */
1084 ha->marker_needed = 1;
1085
0c8c39af 1086 return QLA_SUCCESS;
1da177e4
LT		 1087}
1088
1089/*
1090 * qla2x00_device_reset
1091 * Issue bus device reset message to the target.
1092 *
1093 * Input:
1094 * ha = adapter block pointer.
1095 * t = SCSI ID.
1096 * TARGET_QUEUE_LOCK must be released.
1097 * ADAPTER_STATE_LOCK must be released.
1098 *
1099 * Context:
1100 * Kernel context.
1101 */
1102static int
1103qla2x00_device_reset(scsi_qla_host_t *ha, fc_port_t *reset_fcport)
1104{
1105 /* Abort Target command will clear Reservation */
fd34f556 1106 return ha->isp_ops->abort_target(reset_fcport);
1da177e4
LT		 1107}
1108
df4bf0bb
AV		 1109void
1110qla2x00_abort_all_cmds(scsi_qla_host_t *ha, int res)
1111{
1112 int cnt;
1113 unsigned long flags;
1114 srb_t *sp;
1115
1116 spin_lock_irqsave(&ha->hardware_lock, flags);
1117 for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
1118 sp = ha->outstanding_cmds[cnt];
1119 if (sp) {
1120 ha->outstanding_cmds[cnt] = NULL;
1121 sp->flags = 0;
1122 sp->cmd->result = res;
1123 sp->cmd->host_scribble = (unsigned char *)NULL;
1124 qla2x00_sp_compl(ha, sp);
1125 }
1126 }
1127 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1128}
1129
f4f051eb 1130static int
1131qla2xxx_slave_alloc(struct scsi_device *sdev)
1da177e4 1132{
bdf79621 1133 struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
1da177e4 1134
19a7b4ae 1135 if (!rport || fc_remote_port_chkready(rport))
f4f051eb 1136 return -ENXIO;
bdf79621 1137
19a7b4ae 1138 sdev->hostdata = *(fc_port_t **)rport->dd_data;
1da177e4 1139
f4f051eb 1140 return 0;
1141}
1da177e4 1142
f4f051eb 1143static int
1144qla2xxx_slave_configure(struct scsi_device *sdev)
1145{
f363b943 1146 scsi_qla_host_t *ha = shost_priv(sdev->host);
8482e118 1147 struct fc_rport *rport = starget_to_rport(sdev->sdev_target);
1148
f4f051eb 1149 if (sdev->tagged_supported)
df7baa50 1150 scsi_activate_tcq(sdev, ha->max_q_depth);
f4f051eb 1151 else
df7baa50 1152 scsi_deactivate_tcq(sdev, ha->max_q_depth);
1da177e4 1153
8482e118 1154 rport->dev_loss_tmo = ha->port_down_retry_count + 5;
1155
f4f051eb 1156 return 0;
1157}
1da177e4 1158
f4f051eb 1159static void
1160qla2xxx_slave_destroy(struct scsi_device *sdev)
1161{
1162 sdev->hostdata = NULL;
1da177e4
LT		 1163}
1164
ce7e4af7
AV		 1165static int
1166qla2x00_change_queue_depth(struct scsi_device *sdev, int qdepth)
1167{
1168 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
1169 return sdev->queue_depth;
1170}
1171
1172static int
1173qla2x00_change_queue_type(struct scsi_device *sdev, int tag_type)
1174{
1175 if (sdev->tagged_supported) {
1176 scsi_set_tag_type(sdev, tag_type);
1177 if (tag_type)
1178 scsi_activate_tcq(sdev, sdev->queue_depth);
1179 else
1180 scsi_deactivate_tcq(sdev, sdev->queue_depth);
1181 } else
1182 tag_type = 0;
1183
1184 return tag_type;
1185}
1186
1da177e4
LT		 1187/**
1188 * qla2x00_config_dma_addressing() - Configure OS DMA addressing method.
1189 * @ha: HA context
1190 *
1191 * At exit, the @ha's flags.enable_64bit_addressing set to indicated
1192 * supported addressing method.
1193 */
1194static void
1195qla2x00_config_dma_addressing(scsi_qla_host_t *ha)
1196{
7524f9b9 1197 /* Assume a 32bit DMA mask. */
1da177e4 1198 ha->flags.enable_64bit_addressing = 0;
1da177e4 1199
7524f9b9
AV		 1200 if (!dma_set_mask(&ha->pdev->dev, DMA_64BIT_MASK)) {
1201 /* Any upper-dword bits set? */
1202 if (MSD(dma_get_required_mask(&ha->pdev->dev)) &&
1203 !pci_set_consistent_dma_mask(ha->pdev, DMA_64BIT_MASK)) {
1204 /* Ok, a 64bit DMA mask is applicable. */
1da177e4 1205 ha->flags.enable_64bit_addressing = 1;
fd34f556
AV		 1206 ha->isp_ops->calc_req_entries = qla2x00_calc_iocbs_64;
1207 ha->isp_ops->build_iocbs = qla2x00_build_scsi_iocbs_64;
7524f9b9 1208 return;
1da177e4 1209 }
1da177e4 1210 }
7524f9b9
AV		 1211
1212 dma_set_mask(&ha->pdev->dev, DMA_32BIT_MASK);
1213 pci_set_consistent_dma_mask(ha->pdev, DMA_32BIT_MASK);
1da177e4
LT		 1214}
1215
fd34f556
AV		 1216static void
1217qla2x00_enable_intrs(scsi_qla_host_t *ha)
1218{
1219 unsigned long flags = 0;
1220 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1221
1222 spin_lock_irqsave(&ha->hardware_lock, flags);
1223 ha->interrupts_on = 1;
1224 /* enable risc and host interrupts */
1225 WRT_REG_WORD(&reg->ictrl, ICR_EN_INT | ICR_EN_RISC);
1226 RD_REG_WORD(&reg->ictrl);
1227 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1228
1229}
1230
1231static void
1232qla2x00_disable_intrs(scsi_qla_host_t *ha)
1233{
1234 unsigned long flags = 0;
1235 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1236
1237 spin_lock_irqsave(&ha->hardware_lock, flags);
1238 ha->interrupts_on = 0;
1239 /* disable risc and host interrupts */
1240 WRT_REG_WORD(&reg->ictrl, 0);
1241 RD_REG_WORD(&reg->ictrl);
1242 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1243}
1244
1245static void
1246qla24xx_enable_intrs(scsi_qla_host_t *ha)
1247{
1248 unsigned long flags = 0;
1249 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1250
1251 spin_lock_irqsave(&ha->hardware_lock, flags);
1252 ha->interrupts_on = 1;
1253 WRT_REG_DWORD(&reg->ictrl, ICRX_EN_RISC_INT);
1254 RD_REG_DWORD(&reg->ictrl);
1255 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1256}
1257
1258static void
1259qla24xx_disable_intrs(scsi_qla_host_t *ha)
1260{
1261 unsigned long flags = 0;
1262 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1263
1264 spin_lock_irqsave(&ha->hardware_lock, flags);
1265 ha->interrupts_on = 0;
1266 WRT_REG_DWORD(&reg->ictrl, 0);
1267 RD_REG_DWORD(&reg->ictrl);
1268 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1269}
1270
1271static struct isp_operations qla2100_isp_ops = {
1272 .pci_config = qla2100_pci_config,
1273 .reset_chip = qla2x00_reset_chip,
1274 .chip_diag = qla2x00_chip_diag,
1275 .config_rings = qla2x00_config_rings,
1276 .reset_adapter = qla2x00_reset_adapter,
1277 .nvram_config = qla2x00_nvram_config,
1278 .update_fw_options = qla2x00_update_fw_options,
1279 .load_risc = qla2x00_load_risc,
1280 .pci_info_str = qla2x00_pci_info_str,
1281 .fw_version_str = qla2x00_fw_version_str,
1282 .intr_handler = qla2100_intr_handler,
1283 .enable_intrs = qla2x00_enable_intrs,
1284 .disable_intrs = qla2x00_disable_intrs,
1285 .abort_command = qla2x00_abort_command,
1286 .abort_target = qla2x00_abort_target,
1287 .fabric_login = qla2x00_login_fabric,
1288 .fabric_logout = qla2x00_fabric_logout,
1289 .calc_req_entries = qla2x00_calc_iocbs_32,
1290 .build_iocbs = qla2x00_build_scsi_iocbs_32,
1291 .prep_ms_iocb = qla2x00_prep_ms_iocb,
1292 .prep_ms_fdmi_iocb = qla2x00_prep_ms_fdmi_iocb,
1293 .read_nvram = qla2x00_read_nvram_data,
1294 .write_nvram = qla2x00_write_nvram_data,
1295 .fw_dump = qla2100_fw_dump,
1296 .beacon_on = NULL,
1297 .beacon_off = NULL,
1298 .beacon_blink = NULL,
1299 .read_optrom = qla2x00_read_optrom_data,
1300 .write_optrom = qla2x00_write_optrom_data,
1301 .get_flash_version = qla2x00_get_flash_version,
1302};
1303
1304static struct isp_operations qla2300_isp_ops = {
1305 .pci_config = qla2300_pci_config,
1306 .reset_chip = qla2x00_reset_chip,
1307 .chip_diag = qla2x00_chip_diag,
1308 .config_rings = qla2x00_config_rings,
1309 .reset_adapter = qla2x00_reset_adapter,
1310 .nvram_config = qla2x00_nvram_config,
1311 .update_fw_options = qla2x00_update_fw_options,
1312 .load_risc = qla2x00_load_risc,
1313 .pci_info_str = qla2x00_pci_info_str,
1314 .fw_version_str = qla2x00_fw_version_str,
1315 .intr_handler = qla2300_intr_handler,
1316 .enable_intrs = qla2x00_enable_intrs,
1317 .disable_intrs = qla2x00_disable_intrs,
1318 .abort_command = qla2x00_abort_command,
1319 .abort_target = qla2x00_abort_target,
1320 .fabric_login = qla2x00_login_fabric,
1321 .fabric_logout = qla2x00_fabric_logout,
1322 .calc_req_entries = qla2x00_calc_iocbs_32,
1323 .build_iocbs = qla2x00_build_scsi_iocbs_32,
1324 .prep_ms_iocb = qla2x00_prep_ms_iocb,
1325 .prep_ms_fdmi_iocb = qla2x00_prep_ms_fdmi_iocb,
1326 .read_nvram = qla2x00_read_nvram_data,
1327 .write_nvram = qla2x00_write_nvram_data,
1328 .fw_dump = qla2300_fw_dump,
1329 .beacon_on = qla2x00_beacon_on,
1330 .beacon_off = qla2x00_beacon_off,
1331 .beacon_blink = qla2x00_beacon_blink,
1332 .read_optrom = qla2x00_read_optrom_data,
1333 .write_optrom = qla2x00_write_optrom_data,
1334 .get_flash_version = qla2x00_get_flash_version,
1335};
1336
1337static struct isp_operations qla24xx_isp_ops = {
1338 .pci_config = qla24xx_pci_config,
1339 .reset_chip = qla24xx_reset_chip,
1340 .chip_diag = qla24xx_chip_diag,
1341 .config_rings = qla24xx_config_rings,
1342 .reset_adapter = qla24xx_reset_adapter,
1343 .nvram_config = qla24xx_nvram_config,
1344 .update_fw_options = qla24xx_update_fw_options,
1345 .load_risc = qla24xx_load_risc,
1346 .pci_info_str = qla24xx_pci_info_str,
1347 .fw_version_str = qla24xx_fw_version_str,
1348 .intr_handler = qla24xx_intr_handler,
1349 .enable_intrs = qla24xx_enable_intrs,
1350 .disable_intrs = qla24xx_disable_intrs,
1351 .abort_command = qla24xx_abort_command,
1352 .abort_target = qla24xx_abort_target,
1353 .fabric_login = qla24xx_login_fabric,
1354 .fabric_logout = qla24xx_fabric_logout,
1355 .calc_req_entries = NULL,
1356 .build_iocbs = NULL,
1357 .prep_ms_iocb = qla24xx_prep_ms_iocb,
1358 .prep_ms_fdmi_iocb = qla24xx_prep_ms_fdmi_iocb,
1359 .read_nvram = qla24xx_read_nvram_data,
1360 .write_nvram = qla24xx_write_nvram_data,
1361 .fw_dump = qla24xx_fw_dump,
1362 .beacon_on = qla24xx_beacon_on,
1363 .beacon_off = qla24xx_beacon_off,
1364 .beacon_blink = qla24xx_beacon_blink,
1365 .read_optrom = qla24xx_read_optrom_data,
1366 .write_optrom = qla24xx_write_optrom_data,
1367 .get_flash_version = qla24xx_get_flash_version,
1368};
1369
c3a2f0df
AV		 1370static struct isp_operations qla25xx_isp_ops = {
1371 .pci_config = qla25xx_pci_config,
1372 .reset_chip = qla24xx_reset_chip,
1373 .chip_diag = qla24xx_chip_diag,
1374 .config_rings = qla24xx_config_rings,
1375 .reset_adapter = qla24xx_reset_adapter,
1376 .nvram_config = qla24xx_nvram_config,
1377 .update_fw_options = qla24xx_update_fw_options,
1378 .load_risc = qla24xx_load_risc,
1379 .pci_info_str = qla24xx_pci_info_str,
1380 .fw_version_str = qla24xx_fw_version_str,
1381 .intr_handler = qla24xx_intr_handler,
1382 .enable_intrs = qla24xx_enable_intrs,
1383 .disable_intrs = qla24xx_disable_intrs,
1384 .abort_command = qla24xx_abort_command,
1385 .abort_target = qla24xx_abort_target,
1386 .fabric_login = qla24xx_login_fabric,
1387 .fabric_logout = qla24xx_fabric_logout,
1388 .calc_req_entries = NULL,
1389 .build_iocbs = NULL,
1390 .prep_ms_iocb = qla24xx_prep_ms_iocb,
1391 .prep_ms_fdmi_iocb = qla24xx_prep_ms_fdmi_iocb,
1392 .read_nvram = qla25xx_read_nvram_data,
1393 .write_nvram = qla25xx_write_nvram_data,
1394 .fw_dump = qla25xx_fw_dump,
1395 .beacon_on = qla24xx_beacon_on,
1396 .beacon_off = qla24xx_beacon_off,
1397 .beacon_blink = qla24xx_beacon_blink,
338c9161 1398 .read_optrom = qla25xx_read_optrom_data,
c3a2f0df
AV		 1399 .write_optrom = qla24xx_write_optrom_data,
1400 .get_flash_version = qla24xx_get_flash_version,
1401};
1402
ea5b6382 1403static inline void
1404qla2x00_set_isp_flags(scsi_qla_host_t *ha)
1405{
1406 ha->device_type = DT_EXTENDED_IDS;
1407 switch (ha->pdev->device) {
1408 case PCI_DEVICE_ID_QLOGIC_ISP2100:
1409 ha->device_type |= DT_ISP2100;
1410 ha->device_type &= ~DT_EXTENDED_IDS;
441d1072 1411 ha->fw_srisc_address = RISC_START_ADDRESS_2100;
ea5b6382 1412 break;
1413 case PCI_DEVICE_ID_QLOGIC_ISP2200:
1414 ha->device_type |= DT_ISP2200;
1415 ha->device_type &= ~DT_EXTENDED_IDS;
441d1072 1416 ha->fw_srisc_address = RISC_START_ADDRESS_2100;
ea5b6382 1417 break;
1418 case PCI_DEVICE_ID_QLOGIC_ISP2300:
1419 ha->device_type |= DT_ISP2300;
4a59f71d 1420 ha->device_type |= DT_ZIO_SUPPORTED;
441d1072 1421 ha->fw_srisc_address = RISC_START_ADDRESS_2300;
ea5b6382 1422 break;
1423 case PCI_DEVICE_ID_QLOGIC_ISP2312:
1424 ha->device_type |= DT_ISP2312;
4a59f71d 1425 ha->device_type |= DT_ZIO_SUPPORTED;
441d1072 1426 ha->fw_srisc_address = RISC_START_ADDRESS_2300;
ea5b6382 1427 break;
1428 case PCI_DEVICE_ID_QLOGIC_ISP2322:
1429 ha->device_type |= DT_ISP2322;
4a59f71d 1430 ha->device_type |= DT_ZIO_SUPPORTED;
ea5b6382 1431 if (ha->pdev->subsystem_vendor == 0x1028 &&
1432 ha->pdev->subsystem_device == 0x0170)
1433 ha->device_type |= DT_OEM_001;
441d1072 1434 ha->fw_srisc_address = RISC_START_ADDRESS_2300;
ea5b6382 1435 break;
1436 case PCI_DEVICE_ID_QLOGIC_ISP6312:
1437 ha->device_type |= DT_ISP6312;
441d1072 1438 ha->fw_srisc_address = RISC_START_ADDRESS_2300;
ea5b6382 1439 break;
1440 case PCI_DEVICE_ID_QLOGIC_ISP6322:
1441 ha->device_type |= DT_ISP6322;
441d1072 1442 ha->fw_srisc_address = RISC_START_ADDRESS_2300;
ea5b6382 1443 break;
1444 case PCI_DEVICE_ID_QLOGIC_ISP2422:
1445 ha->device_type |= DT_ISP2422;
4a59f71d 1446 ha->device_type |= DT_ZIO_SUPPORTED;
e428924c 1447 ha->device_type |= DT_FWI2;
c76f2c01 1448 ha->device_type |= DT_IIDMA;
441d1072 1449 ha->fw_srisc_address = RISC_START_ADDRESS_2400;
ea5b6382 1450 break;
1451 case PCI_DEVICE_ID_QLOGIC_ISP2432:
1452 ha->device_type |= DT_ISP2432;
4a59f71d 1453 ha->device_type |= DT_ZIO_SUPPORTED;
e428924c 1454 ha->device_type |= DT_FWI2;
c76f2c01 1455 ha->device_type |= DT_IIDMA;
441d1072 1456 ha->fw_srisc_address = RISC_START_ADDRESS_2400;
ea5b6382 1457 break;
044cc6c8 1458 case PCI_DEVICE_ID_QLOGIC_ISP5422:
1459 ha->device_type |= DT_ISP5422;
e428924c 1460 ha->device_type |= DT_FWI2;
441d1072 1461 ha->fw_srisc_address = RISC_START_ADDRESS_2400;
ea5b6382 1462 break;
044cc6c8 1463 case PCI_DEVICE_ID_QLOGIC_ISP5432:
1464 ha->device_type |= DT_ISP5432;
e428924c 1465 ha->device_type |= DT_FWI2;
441d1072 1466 ha->fw_srisc_address = RISC_START_ADDRESS_2400;
ea5b6382 1467 break;
c3a2f0df
AV		 1468 case PCI_DEVICE_ID_QLOGIC_ISP2532:
1469 ha->device_type |= DT_ISP2532;
1470 ha->device_type |= DT_ZIO_SUPPORTED;
1471 ha->device_type |= DT_FWI2;
1472 ha->device_type |= DT_IIDMA;
441d1072 1473 ha->fw_srisc_address = RISC_START_ADDRESS_2400;
ea5b6382 1474 break;
1475 }
1476}
1477
1da177e4
LT		 1478static int
1479qla2x00_iospace_config(scsi_qla_host_t *ha)
1480{
3776541d 1481 resource_size_t pio;
1da177e4 1482
285d0321
AV		 1483 if (pci_request_selected_regions(ha->pdev, ha->bars,
1484 QLA2XXX_DRIVER_NAME)) {
1485 qla_printk(KERN_WARNING, ha,
1486 "Failed to reserve PIO/MMIO regions (%s)\n",
1487 pci_name(ha->pdev));
1488
1489 goto iospace_error_exit;
1490 }
1491 if (!(ha->bars & 1))
1492 goto skip_pio;
1493
1da177e4
LT		 1494 /* We only need PIO for Flash operations on ISP2312 v2 chips. */
1495 pio = pci_resource_start(ha->pdev, 0);
3776541d
AV		 1496 if (pci_resource_flags(ha->pdev, 0) & IORESOURCE_IO) {
1497 if (pci_resource_len(ha->pdev, 0) < MIN_IOBASE_LEN) {
1da177e4
LT		 1498 qla_printk(KERN_WARNING, ha,
1499 "Invalid PCI I/O region size (%s)...\n",
1500 pci_name(ha->pdev));
1501 pio = 0;
1502 }
1503 } else {
1504 qla_printk(KERN_WARNING, ha,
1505 "region #0 not a PIO resource (%s)...\n",
1506 pci_name(ha->pdev));
1507 pio = 0;
1508 }
285d0321 1509 ha->pio_address = pio;
1da177e4 1510
285d0321 1511skip_pio:
1da177e4 1512 /* Use MMIO operations for all accesses. */
3776541d 1513 if (!(pci_resource_flags(ha->pdev, 1) & IORESOURCE_MEM)) {
1da177e4 1514 qla_printk(KERN_ERR, ha,
3776541d 1515 "region #1 not an MMIO resource (%s), aborting\n",
1da177e4
LT		 1516 pci_name(ha->pdev));
1517 goto iospace_error_exit;
1518 }
3776541d 1519 if (pci_resource_len(ha->pdev, 1) < MIN_IOBASE_LEN) {
1da177e4
LT		 1520 qla_printk(KERN_ERR, ha,
1521 "Invalid PCI mem region size (%s), aborting\n",
1522 pci_name(ha->pdev));
1523 goto iospace_error_exit;
1524 }
1525
3776541d 1526 ha->iobase = ioremap(pci_resource_start(ha->pdev, 1), MIN_IOBASE_LEN);
1da177e4
LT		 1527 if (!ha->iobase) {
1528 qla_printk(KERN_ERR, ha,
1529 "cannot remap MMIO (%s), aborting\n", pci_name(ha->pdev));
1530
1531 goto iospace_error_exit;
1532 }
1533
1534 return (0);
1535
1536iospace_error_exit:
1537 return (-ENOMEM);
1538}
1539
1e99e33a
AV		 1540static void
1541qla2xxx_scan_start(struct Scsi_Host *shost)
1542{
f363b943 1543 scsi_qla_host_t *ha = shost_priv(shost);
1e99e33a
AV		 1544
1545 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
1546 set_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags);
1547 set_bit(RSCN_UPDATE, &ha->dpc_flags);
1548}
1549
1550static int
1551qla2xxx_scan_finished(struct Scsi_Host *shost, unsigned long time)
1552{
f363b943 1553 scsi_qla_host_t *ha = shost_priv(shost);
1e99e33a
AV		 1554
1555 if (!ha->host)
1556 return 1;
1557 if (time > ha->loop_reset_delay * HZ)
1558 return 1;
1559
1560 return atomic_read(&ha->loop_state) == LOOP_READY;
1561}
1562
1da177e4
LT		 1563/*
1564 * PCI driver interface
1565 */
7ee61397
AV		 1566static int __devinit
1567qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
1da177e4 1568{
a1541d5a 1569 int ret = -ENODEV;
1da177e4
LT		 1570 struct Scsi_Host *host;
1571 scsi_qla_host_t *ha;
29856e28 1572 char pci_info[30];
1da177e4 1573 char fw_str[30];
5433383e 1574 struct scsi_host_template *sht;
09483916 1575 int bars, mem_only = 0;
1da177e4 1576
285d0321 1577 bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO);
5433383e
AV		 1578 sht = &qla2x00_driver_template;
1579 if (pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2422 ||
8bc69e7d
AV		 1580 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2432 ||
1581 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5422 ||
c3a2f0df 1582 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5432 ||
285d0321
AV		 1583 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2532) {
1584 bars = pci_select_bars(pdev, IORESOURCE_MEM);
5433383e 1585 sht = &qla24xx_driver_template;
09483916 1586 mem_only = 1;
285d0321
AV		 1587 }
1588
09483916
BH		 1589 if (mem_only) {
1590 if (pci_enable_device_mem(pdev))
1591 goto probe_out;
1592 } else {
1593 if (pci_enable_device(pdev))
1594 goto probe_out;
1595 }
285d0321
AV		 1596
1597 if (pci_find_aer_capability(pdev))
1598 if (pci_enable_pcie_error_reporting(pdev))
1599 goto probe_out;
1600
5433383e 1601 host = scsi_host_alloc(sht, sizeof(scsi_qla_host_t));
1da177e4
LT		 1602 if (host == NULL) {
1603 printk(KERN_WARNING
1604 "qla2xxx: Couldn't allocate host from scsi layer!\n");
1605 goto probe_disable_device;
1606 }
1607
1608 /* Clear our data area */
f363b943 1609 ha = shost_priv(host);
1da177e4
LT		 1610 memset(ha, 0, sizeof(scsi_qla_host_t));
1611
1612 ha->pdev = pdev;
1613 ha->host = host;
1614 ha->host_no = host->host_no;
cb63067a 1615 sprintf(ha->host_str, "%s_%ld", QLA2XXX_DRIVER_NAME, ha->host_no);
2c3dfe3f 1616 ha->parent = NULL;
285d0321 1617 ha->bars = bars;
09483916 1618 ha->mem_only = mem_only;
df4bf0bb 1619 spin_lock_init(&ha->hardware_lock);
1da177e4 1620
ea5b6382 1621 /* Set ISP-type information. */
1622 qla2x00_set_isp_flags(ha);
1623
1da177e4
LT		 1624 /* Configure PCI I/O space */
1625 ret = qla2x00_iospace_config(ha);
a1541d5a
AV		 1626 if (ret)
1627 goto probe_failed;
1da177e4 1628
1da177e4 1629 qla_printk(KERN_INFO, ha,
5433383e
AV		 1630 "Found an ISP%04X, irq %d, iobase 0x%p\n", pdev->device, pdev->irq,
1631 ha->iobase);
1da177e4 1632
1da177e4 1633 ha->prev_topology = 0;
fca29703 1634 ha->init_cb_size = sizeof(init_cb_t);
2c3dfe3f 1635 ha->mgmt_svr_loop_id = MANAGEMENT_SERVER + ha->vp_idx;
d8b45213 1636 ha->link_data_rate = PORT_SPEED_UNKNOWN;
854165f4 1637 ha->optrom_size = OPTROM_SIZE_2300;
1da177e4 1638
df7baa50
AV		 1639 ha->max_q_depth = MAX_Q_DEPTH;
1640 if (ql2xmaxqdepth != 0 && ql2xmaxqdepth <= 0xffffU)
1641 ha->max_q_depth = ql2xmaxqdepth;
1642
abbd8870 1643 /* Assign ISP specific operations. */
1da177e4 1644 if (IS_QLA2100(ha)) {
354d6b21 1645 host->max_id = MAX_TARGETS_2100;
1da177e4
LT		 1646 ha->mbx_count = MAILBOX_REGISTER_COUNT_2100;
1647 ha->request_q_length = REQUEST_ENTRY_CNT_2100;
1648 ha->response_q_length = RESPONSE_ENTRY_CNT_2100;
1649 ha->last_loop_id = SNS_LAST_LOOP_ID_2100;
1650 host->sg_tablesize = 32;
abbd8870 1651 ha->gid_list_info_size = 4;
fd34f556 1652 ha->isp_ops = &qla2100_isp_ops;
1da177e4 1653 } else if (IS_QLA2200(ha)) {
354d6b21 1654 host->max_id = MAX_TARGETS_2200;
1da177e4
LT		 1655 ha->mbx_count = MAILBOX_REGISTER_COUNT;
1656 ha->request_q_length = REQUEST_ENTRY_CNT_2200;
1657 ha->response_q_length = RESPONSE_ENTRY_CNT_2100;
1658 ha->last_loop_id = SNS_LAST_LOOP_ID_2100;
abbd8870 1659 ha->gid_list_info_size = 4;
fd34f556 1660 ha->isp_ops = &qla2100_isp_ops;
fca29703 1661 } else if (IS_QLA23XX(ha)) {
354d6b21 1662 host->max_id = MAX_TARGETS_2200;
1da177e4
LT		 1663 ha->mbx_count = MAILBOX_REGISTER_COUNT;
1664 ha->request_q_length = REQUEST_ENTRY_CNT_2200;
1665 ha->response_q_length = RESPONSE_ENTRY_CNT_2300;
1666 ha->last_loop_id = SNS_LAST_LOOP_ID_2300;
abbd8870 1667 ha->gid_list_info_size = 6;
854165f4 1668 if (IS_QLA2322(ha) || IS_QLA6322(ha))
1669 ha->optrom_size = OPTROM_SIZE_2322;
fd34f556 1670 ha->isp_ops = &qla2300_isp_ops;
044cc6c8 1671 } else if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
fca29703
AV		 1672 host->max_id = MAX_TARGETS_2200;
1673 ha->mbx_count = MAILBOX_REGISTER_COUNT;
1674 ha->request_q_length = REQUEST_ENTRY_CNT_24XX;
1675 ha->response_q_length = RESPONSE_ENTRY_CNT_2300;
1676 ha->last_loop_id = SNS_LAST_LOOP_ID_2300;
2c3dfe3f
SJ		 1677 ha->init_cb_size = sizeof(struct mid_init_cb_24xx);
1678 ha->mgmt_svr_loop_id = 10 + ha->vp_idx;
fca29703 1679 ha->gid_list_info_size = 8;
854165f4 1680 ha->optrom_size = OPTROM_SIZE_24XX;
fd34f556 1681 ha->isp_ops = &qla24xx_isp_ops;
c3a2f0df
AV		 1682 } else if (IS_QLA25XX(ha)) {
1683 host->max_id = MAX_TARGETS_2200;
1684 ha->mbx_count = MAILBOX_REGISTER_COUNT;
1685 ha->request_q_length = REQUEST_ENTRY_CNT_24XX;
1686 ha->response_q_length = RESPONSE_ENTRY_CNT_2300;
1687 ha->last_loop_id = SNS_LAST_LOOP_ID_2300;
1688 ha->init_cb_size = sizeof(struct mid_init_cb_24xx);
1689 ha->mgmt_svr_loop_id = 10 + ha->vp_idx;
1690 ha->gid_list_info_size = 8;
1691 ha->optrom_size = OPTROM_SIZE_25XX;
1692 ha->isp_ops = &qla25xx_isp_ops;
1da177e4
LT		 1693 }
1694 host->can_queue = ha->request_q_length + 128;
1695
1696 /* load the F/W, read paramaters, and init the H/W */
1697 ha->instance = num_hosts;
1698
2c3dfe3f 1699 init_MUTEX(&ha->vport_sem);
0b05a1f0
MB		 1700 init_completion(&ha->mbx_cmd_comp);
1701 complete(&ha->mbx_cmd_comp);
1702 init_completion(&ha->mbx_intr_comp);
1da177e4
LT		 1703
1704 INIT_LIST_HEAD(&ha->list);
1705 INIT_LIST_HEAD(&ha->fcports);
2c3dfe3f
SJ		 1706 INIT_LIST_HEAD(&ha->vp_list);
1707
1708 set_bit(0, (unsigned long *) ha->vp_idx_map);
1da177e4 1709
1da177e4
LT		 1710 qla2x00_config_dma_addressing(ha);
1711 if (qla2x00_mem_alloc(ha)) {
1712 qla_printk(KERN_WARNING, ha,
1713 "[ERROR] Failed to allocate memory for adapter\n");
1714
a1541d5a
AV		 1715 ret = -ENOMEM;
1716 goto probe_failed;
1da177e4
LT		 1717 }
1718
765140bf 1719 if (qla2x00_initialize_adapter(ha)) {
1da177e4
LT		 1720 qla_printk(KERN_WARNING, ha,
1721 "Failed to initialize adapter\n");
1722
1723 DEBUG2(printk("scsi(%ld): Failed to initialize adapter - "
1724 "Adapter flags %x.\n",
1725 ha->host_no, ha->device_flags));
1726
a1541d5a 1727 ret = -ENODEV;
1da177e4
LT		 1728 goto probe_failed;
1729 }
1730
1731 /*
1732 * Startup the kernel thread for this host adapter
1733 */
39a11240
CH		 1734 ha->dpc_thread = kthread_create(qla2x00_do_dpc, ha,
1735 "%s_dpc", ha->host_str);
1736 if (IS_ERR(ha->dpc_thread)) {
1da177e4
LT		 1737 qla_printk(KERN_WARNING, ha,
1738 "Unable to start DPC thread!\n");
39a11240 1739 ret = PTR_ERR(ha->dpc_thread);
1da177e4
LT		 1740 goto probe_failed;
1741 }
1da177e4 1742
a1541d5a
AV		 1743 host->this_id = 255;
1744 host->cmd_per_lun = 3;
1745 host->unique_id = ha->instance;
1746 host->max_cmd_len = MAX_CMDSZ;
75bc4190 1747 host->max_channel = MAX_BUSES - 1;
a1541d5a
AV		 1748 host->max_lun = MAX_LUNS;
1749 host->transportt = qla2xxx_transport_template;
1750
a8488abe
AV		 1751 ret = qla2x00_request_irqs(ha);
1752 if (ret)
1da177e4 1753 goto probe_failed;
1da177e4
LT		 1754
1755 /* Initialized the timer */
1756 qla2x00_start_timer(ha, qla2x00_timer, WATCH_INTERVAL);
1757
1758 DEBUG2(printk("DEBUG: detect hba %ld at address = %p\n",
1759 ha->host_no, ha));
1760
a1541d5a 1761 pci_set_drvdata(pdev, ha);
d19044c3 1762
1da177e4 1763 ha->flags.init_done = 1;
d19044c3
AV		 1764 ha->flags.online = 1;
1765
1da177e4
LT		 1766 num_hosts++;
1767
a1541d5a
AV		 1768 ret = scsi_add_host(host, &pdev->dev);
1769 if (ret)
1770 goto probe_failed;
1771
1e99e33a
AV		 1772 scsi_scan_host(host);
1773
a1541d5a
AV		 1774 qla2x00_alloc_sysfs_attr(ha);
1775
1776 qla2x00_init_host_attr(ha);
1777
df613b96
AV		 1778 qla2x00_dfs_setup(ha);
1779
1da177e4
LT		 1780 qla_printk(KERN_INFO, ha, "\n"
1781 " QLogic Fibre Channel HBA Driver: %s\n"
1782 " QLogic %s - %s\n"
5433383e
AV		 1783 " ISP%04X: %s @ %s hdma%c, host#=%ld, fw=%s\n",
1784 qla2x00_version_str, ha->model_number,
1785 ha->model_desc ? ha->model_desc: "", pdev->device,
fd34f556 1786 ha->isp_ops->pci_info_str(ha, pci_info), pci_name(pdev),
5433383e 1787 ha->flags.enable_64bit_addressing ? '+': '-', ha->host_no,
fd34f556 1788 ha->isp_ops->fw_version_str(ha, fw_str));
1da177e4 1789
1da177e4
LT		 1790 return 0;
1791
1792probe_failed:
1793 qla2x00_free_device(ha);
1794
1795 scsi_host_put(host);
1796
1797probe_disable_device:
1798 pci_disable_device(pdev);
1799
a1541d5a
AV		 1800probe_out:
1801 return ret;
1da177e4 1802}
1da177e4 1803
4c993f76 1804static void
7ee61397 1805qla2x00_remove_one(struct pci_dev *pdev)
1da177e4
LT		 1806{
1807 scsi_qla_host_t *ha;
1808
1809 ha = pci_get_drvdata(pdev);
1810
df613b96
AV		 1811 qla2x00_dfs_remove(ha);
1812
8482e118 1813 qla2x00_free_sysfs_attr(ha);
1da177e4 1814
bdf79621 1815 fc_remove_host(ha->host);
1816
1da177e4
LT		 1817 scsi_remove_host(ha->host);
1818
1819 qla2x00_free_device(ha);
1820
1821 scsi_host_put(ha->host);
1822
665db93b 1823 pci_disable_device(pdev);
1da177e4
LT		 1824 pci_set_drvdata(pdev, NULL);
1825}
1da177e4
LT		 1826
1827static void
1828qla2x00_free_device(scsi_qla_host_t *ha)
1829{
df4bf0bb
AV		 1830 qla2x00_abort_all_cmds(ha, DID_NO_CONNECT << 16);
1831
1da177e4
LT		 1832 /* Disable timer */
1833 if (ha->timer_active)
1834 qla2x00_stop_timer(ha);
1835
df4bf0bb
AV		 1836 ha->flags.online = 0;
1837
1da177e4 1838 /* Kill the kernel thread for this host */
39a11240
CH		 1839 if (ha->dpc_thread) {
1840 struct task_struct *t = ha->dpc_thread;
1da177e4 1841
39a11240
CH		 1842 /*
1843 * qla2xxx_wake_dpc checks for ->dpc_thread
1844 * so we need to zero it out.
1845 */
1846 ha->dpc_thread = NULL;
1847 kthread_stop(t);
1da177e4
LT		 1848 }
1849
df613b96
AV		 1850 if (ha->flags.fce_enabled)
1851 qla2x00_disable_fce_trace(ha, NULL, NULL);
1852
a7a167bf 1853 if (ha->eft)
00b6bd25 1854 qla2x00_disable_eft_trace(ha);
a7a167bf 1855
f6ef3b18 1856 /* Stop currently executing firmware. */
18c6c127 1857 qla2x00_try_to_stop_firmware(ha);
1da177e4 1858
f6ef3b18
AV		 1859 /* turn-off interrupts on the card */
1860 if (ha->interrupts_on)
fd34f556 1861 ha->isp_ops->disable_intrs(ha);
f6ef3b18
AV		 1862
1863 qla2x00_mem_free(ha);
1da177e4 1864
a8488abe 1865 qla2x00_free_irqs(ha);
1da177e4
LT		 1866
1867 /* release io space registers */
1868 if (ha->iobase)
1869 iounmap(ha->iobase);
285d0321 1870 pci_release_selected_regions(ha->pdev, ha->bars);
1da177e4
LT		 1871}
1872
d97994dc 1873static inline void
1874qla2x00_schedule_rport_del(struct scsi_qla_host *ha, fc_port_t *fcport,
1875 int defer)
1876{
1877 unsigned long flags;
1878 struct fc_rport *rport;
1879
1880 if (!fcport->rport)
1881 return;
1882
1883 rport = fcport->rport;
1884 if (defer) {
1885 spin_lock_irqsave(&fcport->rport_lock, flags);
1886 fcport->drport = rport;
1887 fcport->rport = NULL;
387f96b4 1888 *(fc_port_t **)rport->dd_data = NULL;
d97994dc 1889 spin_unlock_irqrestore(&fcport->rport_lock, flags);
1890 set_bit(FCPORT_UPDATE_NEEDED, &ha->dpc_flags);
1891 } else {
1892 spin_lock_irqsave(&fcport->rport_lock, flags);
1893 fcport->rport = NULL;
387f96b4 1894 *(fc_port_t **)rport->dd_data = NULL;
d97994dc 1895 spin_unlock_irqrestore(&fcport->rport_lock, flags);
1896 fc_remote_port_delete(rport);
1897 }
1898}
1899
1da177e4
LT		 1900/*
1901 * qla2x00_mark_device_lost Updates fcport state when device goes offline.
1902 *
1903 * Input: ha = adapter block pointer. fcport = port structure pointer.
1904 *
1905 * Return: None.
1906 *
1907 * Context:
1908 */
1909void qla2x00_mark_device_lost(scsi_qla_host_t *ha, fc_port_t *fcport,
d97994dc 1910 int do_login, int defer)
1da177e4 1911{
2c3dfe3f
SJ		 1912 if (atomic_read(&fcport->state) == FCS_ONLINE &&
1913 ha->vp_idx == fcport->vp_idx)
d97994dc 1914 qla2x00_schedule_rport_del(ha, fcport, defer);
19a7b4ae 1915
fa2a1ce5 1916 /*
1da177e4
LT		 1917 * We may need to retry the login, so don't change the state of the
1918 * port but do the retries.
1919 */
1920 if (atomic_read(&fcport->state) != FCS_DEVICE_DEAD)
1921 atomic_set(&fcport->state, FCS_DEVICE_LOST);
1922
1923 if (!do_login)
1924 return;
1925
1926 if (fcport->login_retry == 0) {
1927 fcport->login_retry = ha->login_retry_count;
1928 set_bit(RELOGIN_NEEDED, &ha->dpc_flags);
1929
1930 DEBUG(printk("scsi(%ld): Port login retry: "
1931 "%02x%02x%02x%02x%02x%02x%02x%02x, "
1932 "id = 0x%04x retry cnt=%d\n",
1933 ha->host_no,
1934 fcport->port_name[0],
1935 fcport->port_name[1],
1936 fcport->port_name[2],
1937 fcport->port_name[3],
1938 fcport->port_name[4],
1939 fcport->port_name[5],
1940 fcport->port_name[6],
1941 fcport->port_name[7],
1942 fcport->loop_id,
1943 fcport->login_retry));
1944 }
1945}
1946
1947/*
1948 * qla2x00_mark_all_devices_lost
1949 * Updates fcport state when device goes offline.
1950 *
1951 * Input:
1952 * ha = adapter block pointer.
1953 * fcport = port structure pointer.
1954 *
1955 * Return:
1956 * None.
1957 *
1958 * Context:
1959 */
1960void
d97994dc 1961qla2x00_mark_all_devices_lost(scsi_qla_host_t *ha, int defer)
1da177e4
LT		 1962{
1963 fc_port_t *fcport;
2c3dfe3f 1964 scsi_qla_host_t *pha = to_qla_parent(ha);
1da177e4 1965
2c3dfe3f
SJ		 1966 list_for_each_entry(fcport, &pha->fcports, list) {
1967 if (ha->vp_idx != 0 && ha->vp_idx != fcport->vp_idx)
1da177e4 1968 continue;
1da177e4
LT		 1969 /*
1970 * No point in marking the device as lost, if the device is
1971 * already DEAD.
1972 */
1973 if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD)
1974 continue;
2c3dfe3f
SJ		 1975 if (atomic_read(&fcport->state) == FCS_ONLINE) {
1976 if (defer)
1977 qla2x00_schedule_rport_del(ha, fcport, defer);
1978 else if (ha->vp_idx == fcport->vp_idx)
1979 qla2x00_schedule_rport_del(ha, fcport, defer);
1980 }
1da177e4
LT		 1981 atomic_set(&fcport->state, FCS_DEVICE_LOST);
1982 }
d97994dc 1983
39a11240
CH		 1984 if (defer)
1985 qla2xxx_wake_dpc(ha);
1da177e4
LT		 1986}
1987
1988/*
1989* qla2x00_mem_alloc
1990* Allocates adapter memory.
1991*
1992* Returns:
1993* 0 = success.
e8711085 1994* !0 = failure.
1da177e4 1995*/
e8711085 1996static int
1da177e4
LT		 1997qla2x00_mem_alloc(scsi_qla_host_t *ha)
1998{
1999 char name[16];
1da177e4 2000
e8711085
AV		 2001 ha->request_ring = dma_alloc_coherent(&ha->pdev->dev,
2002 (ha->request_q_length + 1) * sizeof(request_t), &ha->request_dma,
2003 GFP_KERNEL);
2004 if (!ha->request_ring)
2005 goto fail;
2006
2007 ha->response_ring = dma_alloc_coherent(&ha->pdev->dev,
2008 (ha->response_q_length + 1) * sizeof(response_t),
2009 &ha->response_dma, GFP_KERNEL);
2010 if (!ha->response_ring)
2011 goto fail_free_request_ring;
2012
2013 ha->gid_list = dma_alloc_coherent(&ha->pdev->dev, GID_LIST_SIZE,
2014 &ha->gid_list_dma, GFP_KERNEL);
2015 if (!ha->gid_list)
2016 goto fail_free_response_ring;
2017
2018 ha->init_cb = dma_alloc_coherent(&ha->pdev->dev, ha->init_cb_size,
2019 &ha->init_cb_dma, GFP_KERNEL);
2020 if (!ha->init_cb)
2021 goto fail_free_gid_list;
2022
2023 snprintf(name, sizeof(name), "%s_%ld", QLA2XXX_DRIVER_NAME,
2024 ha->host_no);
2025 ha->s_dma_pool = dma_pool_create(name, &ha->pdev->dev,
2026 DMA_POOL_SIZE, 8, 0);
2027 if (!ha->s_dma_pool)
2028 goto fail_free_init_cb;
1da177e4 2029
e8711085
AV		 2030 ha->srb_mempool = mempool_create_slab_pool(SRB_MIN_REQ, srb_cachep);
2031 if (!ha->srb_mempool)
2032 goto fail_free_s_dma_pool;
2033
2034 /* Get memory for cached NVRAM */
2035 ha->nvram = kzalloc(MAX_NVRAM_SIZE, GFP_KERNEL);
2036 if (!ha->nvram)
2037 goto fail_free_srb_mempool;
2038
2039 /* Allocate memory for SNS commands */
2040 if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
2041 /* Get consistent memory allocated for SNS commands */
2042 ha->sns_cmd = dma_alloc_coherent(&ha->pdev->dev,
2043 sizeof(struct sns_cmd_pkt), &ha->sns_cmd_dma, GFP_KERNEL);
2044 if (!ha->sns_cmd)
2045 goto fail_free_nvram;
2046 } else {
2047 /* Get consistent memory allocated for MS IOCB */
2048 ha->ms_iocb = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
2049 &ha->ms_iocb_dma);
2050 if (!ha->ms_iocb)
2051 goto fail_free_nvram;
2052
2053 /* Get consistent memory allocated for CT SNS commands */
2054 ha->ct_sns = dma_alloc_coherent(&ha->pdev->dev,
2055 sizeof(struct ct_sns_pkt), &ha->ct_sns_dma, GFP_KERNEL);
2056 if (!ha->ct_sns)
2057 goto fail_free_ms_iocb;
1da177e4
LT		 2058 }
2059
e8711085
AV		 2060 return 0;
2061
2062fail_free_ms_iocb:
2063 dma_pool_free(ha->s_dma_pool, ha->ms_iocb, ha->ms_iocb_dma);
2064 ha->ms_iocb = NULL;
2065 ha->ms_iocb_dma = 0;
2066fail_free_nvram:
2067 kfree(ha->nvram);
2068 ha->nvram = NULL;
2069fail_free_srb_mempool:
2070 mempool_destroy(ha->srb_mempool);
2071 ha->srb_mempool = NULL;
2072fail_free_s_dma_pool:
2073 dma_pool_destroy(ha->s_dma_pool);
2074 ha->s_dma_pool = NULL;
2075fail_free_init_cb:
2076 dma_free_coherent(&ha->pdev->dev, ha->init_cb_size, ha->init_cb,
2077 ha->init_cb_dma);
2078 ha->init_cb = NULL;
2079 ha->init_cb_dma = 0;
2080fail_free_gid_list:
2081 dma_free_coherent(&ha->pdev->dev, GID_LIST_SIZE, ha->gid_list,
2082 ha->gid_list_dma);
2083 ha->gid_list = NULL;
2084 ha->gid_list_dma = 0;
2085fail_free_response_ring:
2086 dma_free_coherent(&ha->pdev->dev, (ha->response_q_length + 1) *
2087 sizeof(response_t), ha->response_ring, ha->response_dma);
2088 ha->response_ring = NULL;
2089 ha->response_dma = 0;
2090fail_free_request_ring:
2091 dma_free_coherent(&ha->pdev->dev, (ha->request_q_length + 1) *
2092 sizeof(request_t), ha->request_ring, ha->request_dma);
2093 ha->request_ring = NULL;
2094 ha->request_dma = 0;
2095fail:
2096 return -ENOMEM;
1da177e4
LT		 2097}
2098
2099/*
2100* qla2x00_mem_free
2101* Frees all adapter allocated memory.
2102*
2103* Input:
2104* ha = adapter block pointer.
2105*/
a824ebb3 2106static void
1da177e4
LT		 2107qla2x00_mem_free(scsi_qla_host_t *ha)
2108{
1da177e4
LT		 2109 struct list_head *fcpl, *fcptemp;
2110 fc_port_t *fcport;
1da177e4 2111
e8711085
AV		 2112 if (ha->srb_mempool)
2113 mempool_destroy(ha->srb_mempool);
1da177e4 2114
df613b96
AV		 2115 if (ha->fce)
2116 dma_free_coherent(&ha->pdev->dev, FCE_SIZE, ha->fce,
2117 ha->fce_dma);
2118
a7a167bf
AV		 2119 if (ha->fw_dump) {
2120 if (ha->eft)
2121 dma_free_coherent(&ha->pdev->dev,
2122 ntohl(ha->fw_dump->eft_size), ha->eft, ha->eft_dma);
2123 vfree(ha->fw_dump);
2124 }
2125
1da177e4
LT		 2126 if (ha->sns_cmd)
2127 dma_free_coherent(&ha->pdev->dev, sizeof(struct sns_cmd_pkt),
2128 ha->sns_cmd, ha->sns_cmd_dma);
2129
2130 if (ha->ct_sns)
2131 dma_free_coherent(&ha->pdev->dev, sizeof(struct ct_sns_pkt),
2132 ha->ct_sns, ha->ct_sns_dma);
2133
88729e53
AV		 2134 if (ha->sfp_data)
2135 dma_pool_free(ha->s_dma_pool, ha->sfp_data, ha->sfp_data_dma);
2136
1da177e4
LT		 2137 if (ha->ms_iocb)
2138 dma_pool_free(ha->s_dma_pool, ha->ms_iocb, ha->ms_iocb_dma);
2139
1da177e4
LT		 2140 if (ha->s_dma_pool)
2141 dma_pool_destroy(ha->s_dma_pool);
2142
2c3dfe3f
SJ		 2143 if (ha->init_cb)
2144 dma_free_coherent(&ha->pdev->dev, ha->init_cb_size,
2145 ha->init_cb, ha->init_cb_dma);
2146
1da177e4
LT		 2147 if (ha->gid_list)
2148 dma_free_coherent(&ha->pdev->dev, GID_LIST_SIZE, ha->gid_list,
2149 ha->gid_list_dma);
2150
2151 if (ha->response_ring)
2152 dma_free_coherent(&ha->pdev->dev,
2153 (ha->response_q_length + 1) * sizeof(response_t),
2154 ha->response_ring, ha->response_dma);
2155
2156 if (ha->request_ring)
2157 dma_free_coherent(&ha->pdev->dev,
2158 (ha->request_q_length + 1) * sizeof(request_t),
2159 ha->request_ring, ha->request_dma);
2160
e8711085 2161 ha->srb_mempool = NULL;
a7a167bf
AV		 2162 ha->eft = NULL;
2163 ha->eft_dma = 0;
1da177e4
LT		 2164 ha->sns_cmd = NULL;
2165 ha->sns_cmd_dma = 0;
2166 ha->ct_sns = NULL;
2167 ha->ct_sns_dma = 0;
2168 ha->ms_iocb = NULL;
2169 ha->ms_iocb_dma = 0;
1da177e4
LT		 2170 ha->init_cb = NULL;
2171 ha->init_cb_dma = 0;
2172
2173 ha->s_dma_pool = NULL;
2174
1da177e4
LT		 2175 ha->gid_list = NULL;
2176 ha->gid_list_dma = 0;
2177
2178 ha->response_ring = NULL;
2179 ha->response_dma = 0;
2180 ha->request_ring = NULL;
2181 ha->request_dma = 0;
2182
2183 list_for_each_safe(fcpl, fcptemp, &ha->fcports) {
2184 fcport = list_entry(fcpl, fc_port_t, list);
2185
1da177e4
LT		 2186 /* fc ports */
2187 list_del_init(&fcport->list);
2188 kfree(fcport);
2189 }
2190 INIT_LIST_HEAD(&ha->fcports);
2191
1da177e4 2192 ha->fw_dump = NULL;
fca29703 2193 ha->fw_dumped = 0;
1da177e4 2194 ha->fw_dump_reading = 0;
854165f4 2195
2196 vfree(ha->optrom_buffer);
53772a2c 2197 kfree(ha->nvram);
1da177e4
LT		 2198}
2199
1da177e4
LT		 2200/**************************************************************************
2201* qla2x00_do_dpc
2202* This kernel thread is a task that is schedule by the interrupt handler
2203* to perform the background processing for interrupts.
2204*
2205* Notes:
2206* This task always run in the context of a kernel thread. It
2207* is kick-off by the driver's detect code and starts up
2208* up one per adapter. It immediately goes to sleep and waits for
2209* some fibre event. When either the interrupt handler or
2210* the timer routine detects a event it will one of the task
2211* bits then wake us up.
2212**************************************************************************/
2213static int
2214qla2x00_do_dpc(void *data)
2215{
2c3dfe3f 2216 int rval;
1da177e4
LT		 2217 scsi_qla_host_t *ha;
2218 fc_port_t *fcport;
1da177e4 2219 uint8_t status;
1da177e4 2220 uint16_t next_loopid;
99363ef8
SJ		 2221 struct scsi_qla_host *vha;
2222 int i;
2223
1da177e4
LT		 2224
2225 ha = (scsi_qla_host_t *)data;
2226
1da177e4
LT		 2227 set_user_nice(current, -20);
2228
39a11240 2229 while (!kthread_should_stop()) {
1da177e4
LT		 2230 DEBUG3(printk("qla2x00: DPC handler sleeping\n"));
2231
39a11240
CH		 2232 set_current_state(TASK_INTERRUPTIBLE);
2233 schedule();
2234 __set_current_state(TASK_RUNNING);
1da177e4
LT		 2235
2236 DEBUG3(printk("qla2x00: DPC handler waking up\n"));
2237
2238 /* Initialization not yet finished. Don't do anything yet. */
39a11240 2239 if (!ha->flags.init_done)
1da177e4
LT		 2240 continue;
2241
2242 DEBUG3(printk("scsi(%ld): DPC handler\n", ha->host_no));
2243
2244 ha->dpc_active = 1;
2245
1da177e4 2246 if (ha->flags.mbox_busy) {
1da177e4
LT		 2247 ha->dpc_active = 0;
2248 continue;
2249 }
2250
2251 if (test_and_clear_bit(ISP_ABORT_NEEDED, &ha->dpc_flags)) {
2252
2253 DEBUG(printk("scsi(%ld): dpc: sched "
2254 "qla2x00_abort_isp ha = %p\n",
2255 ha->host_no, ha));
2256 if (!(test_and_set_bit(ABORT_ISP_ACTIVE,
2257 &ha->dpc_flags))) {
2258
2259 if (qla2x00_abort_isp(ha)) {
2260 /* failed. retry later */
2261 set_bit(ISP_ABORT_NEEDED,
2262 &ha->dpc_flags);
2263 }
2264 clear_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
2265 }
99363ef8
SJ		 2266
2267 for_each_mapped_vp_idx(ha, i) {
2268 list_for_each_entry(vha, &ha->vp_list,
2269 vp_list) {
2270 if (i == vha->vp_idx) {
2271 set_bit(ISP_ABORT_NEEDED,
2272 &vha->dpc_flags);
2273 break;
2274 }
2275 }
2276 }
2277
1da177e4
LT		 2278 DEBUG(printk("scsi(%ld): dpc: qla2x00_abort_isp end\n",
2279 ha->host_no));
2280 }
2281
d97994dc 2282 if (test_and_clear_bit(FCPORT_UPDATE_NEEDED, &ha->dpc_flags))
2283 qla2x00_update_fcports(ha);
2284
91ca7b01
AV		 2285 if (test_and_clear_bit(LOOP_RESET_NEEDED, &ha->dpc_flags)) {
2286 DEBUG(printk("scsi(%ld): dpc: sched loop_reset()\n",
2287 ha->host_no));
2288 qla2x00_loop_reset(ha);
2289 }
2290
1da177e4
LT		 2291 if (test_and_clear_bit(RESET_MARKER_NEEDED, &ha->dpc_flags) &&
2292 (!(test_and_set_bit(RESET_ACTIVE, &ha->dpc_flags)))) {
2293
2294 DEBUG(printk("scsi(%ld): qla2x00_reset_marker()\n",
2295 ha->host_no));
2296
2297 qla2x00_rst_aen(ha);
2298 clear_bit(RESET_ACTIVE, &ha->dpc_flags);
2299 }
2300
2301 /* Retry each device up to login retry count */
2302 if ((test_and_clear_bit(RELOGIN_NEEDED, &ha->dpc_flags)) &&
2303 !test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags) &&
2304 atomic_read(&ha->loop_state) != LOOP_DOWN) {
2305
2306 DEBUG(printk("scsi(%ld): qla2x00_port_login()\n",
2307 ha->host_no));
2308
2309 next_loopid = 0;
2310 list_for_each_entry(fcport, &ha->fcports, list) {
1da177e4
LT		 2311 /*
2312 * If the port is not ONLINE then try to login
2313 * to it if we haven't run out of retries.
2314 */
2315 if (atomic_read(&fcport->state) != FCS_ONLINE &&
2316 fcport->login_retry) {
2317
1da177e4
LT		 2318 if (fcport->flags & FCF_FABRIC_DEVICE) {
2319 if (fcport->flags &
2320 FCF_TAPE_PRESENT)
fd34f556 2321 ha->isp_ops->fabric_logout(
1c7c6357
AV		 2322 ha, fcport->loop_id,
2323 fcport->d_id.b.domain,
2324 fcport->d_id.b.area,
2325 fcport->d_id.b.al_pa);
1da177e4
LT		 2326 status = qla2x00_fabric_login(
2327 ha, fcport, &next_loopid);
2328 } else
2329 status =
2330 qla2x00_local_device_login(
9a52a57c 2331 ha, fcport);
1da177e4 2332
63a8651f 2333 fcport->login_retry--;
1da177e4
LT		 2334 if (status == QLA_SUCCESS) {
2335 fcport->old_loop_id = fcport->loop_id;
2336
2337 DEBUG(printk("scsi(%ld): port login OK: logged in ID 0x%x\n",
2338 ha->host_no, fcport->loop_id));
fa2a1ce5 2339
052c40c8 2340 qla2x00_update_fcport(ha,
2341 fcport);
1da177e4
LT		 2342 } else if (status == 1) {
2343 set_bit(RELOGIN_NEEDED, &ha->dpc_flags);
2344 /* retry the login again */
2345 DEBUG(printk("scsi(%ld): Retrying %d login again loop_id 0x%x\n",
2346 ha->host_no,
2347 fcport->login_retry, fcport->loop_id));
2348 } else {
2349 fcport->login_retry = 0;
2350 }
63a8651f
RA		 2351 if (fcport->login_retry == 0)
2352 fcport->loop_id = FC_NO_LOOP_ID;
1da177e4
LT		 2353 }
2354 if (test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags))
2355 break;
2356 }
2357 DEBUG(printk("scsi(%ld): qla2x00_port_login - end\n",
2358 ha->host_no));
2359 }
2360
2361 if ((test_bit(LOGIN_RETRY_NEEDED, &ha->dpc_flags)) &&
2362 atomic_read(&ha->loop_state) != LOOP_DOWN) {
2363
2364 clear_bit(LOGIN_RETRY_NEEDED, &ha->dpc_flags);
2365 DEBUG(printk("scsi(%ld): qla2x00_login_retry()\n",
2366 ha->host_no));
fa2a1ce5 2367
1da177e4
LT		 2368 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
2369
2370 DEBUG(printk("scsi(%ld): qla2x00_login_retry - end\n",
2371 ha->host_no));
2372 }
2373
2374 if (test_and_clear_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags)) {
2375
2376 DEBUG(printk("scsi(%ld): qla2x00_loop_resync()\n",
2377 ha->host_no));
2378
2379 if (!(test_and_set_bit(LOOP_RESYNC_ACTIVE,
2380 &ha->dpc_flags))) {
2381
2c3dfe3f 2382 rval = qla2x00_loop_resync(ha);
1da177e4
LT		 2383
2384 clear_bit(LOOP_RESYNC_ACTIVE, &ha->dpc_flags);
2385 }
2386
2387 DEBUG(printk("scsi(%ld): qla2x00_loop_resync - end\n",
2388 ha->host_no));
2389 }
2390
1da177e4
LT		 2391 if (test_and_clear_bit(FCPORT_RESCAN_NEEDED, &ha->dpc_flags)) {
2392
2393 DEBUG(printk("scsi(%ld): Rescan flagged fcports...\n",
2394 ha->host_no));
2395
2396 qla2x00_rescan_fcports(ha);
2397
2398 DEBUG(printk("scsi(%ld): Rescan flagged fcports..."
2399 "end.\n",
2400 ha->host_no));
2401 }
2402
1da177e4 2403 if (!ha->interrupts_on)
fd34f556 2404 ha->isp_ops->enable_intrs(ha);
1da177e4 2405
f6df144c 2406 if (test_and_clear_bit(BEACON_BLINK_NEEDED, &ha->dpc_flags))
fd34f556 2407 ha->isp_ops->beacon_blink(ha);
f6df144c 2408
2c3dfe3f
SJ		 2409 qla2x00_do_dpc_all_vps(ha);
2410
1da177e4
LT		 2411 ha->dpc_active = 0;
2412 } /* End of while(1) */
2413
2414 DEBUG(printk("scsi(%ld): DPC handler exiting\n", ha->host_no));
2415
2416 /*
2417 * Make sure that nobody tries to wake us up again.
2418 */
1da177e4
LT		 2419 ha->dpc_active = 0;
2420
39a11240
CH		 2421 return 0;
2422}
2423
2424void
2425qla2xxx_wake_dpc(scsi_qla_host_t *ha)
2426{
2427 if (ha->dpc_thread)
2428 wake_up_process(ha->dpc_thread);
1da177e4
LT		 2429}
2430
1da177e4
LT		 2431/*
2432* qla2x00_rst_aen
2433* Processes asynchronous reset.
2434*
2435* Input:
2436* ha = adapter block pointer.
2437*/
2438static void
fa2a1ce5 2439qla2x00_rst_aen(scsi_qla_host_t *ha)
1da177e4
LT		 2440{
2441 if (ha->flags.online && !ha->flags.reset_active &&
2442 !atomic_read(&ha->loop_down_timer) &&
2443 !(test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags))) {
2444 do {
2445 clear_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
2446
2447 /*
2448 * Issue marker command only when we are going to start
2449 * the I/O.
2450 */
2451 ha->marker_needed = 1;
2452 } while (!atomic_read(&ha->loop_down_timer) &&
2453 (test_bit(RESET_MARKER_NEEDED, &ha->dpc_flags)));
2454 }
2455}
2456
f4f051eb 2457static void
2458qla2x00_sp_free_dma(scsi_qla_host_t *ha, srb_t *sp)
2459{
2460 struct scsi_cmnd *cmd = sp->cmd;
2461
2462 if (sp->flags & SRB_DMA_VALID) {
385d70b4 2463 scsi_dma_unmap(cmd);
f4f051eb 2464 sp->flags &= ~SRB_DMA_VALID;
2465 }
fca29703 2466 CMD_SP(cmd) = NULL;
f4f051eb 2467}
2468
2469void
2470qla2x00_sp_compl(scsi_qla_host_t *ha, srb_t *sp)
2471{
2472 struct scsi_cmnd *cmd = sp->cmd;
2473
2474 qla2x00_sp_free_dma(ha, sp);
2475
f4f051eb 2476 mempool_free(sp, ha->srb_mempool);
2477
2478 cmd->scsi_done(cmd);
2479}
bdf79621 2480
1da177e4
LT		 2481/**************************************************************************
2482* qla2x00_timer
2483*
2484* Description:
2485* One second timer
2486*
2487* Context: Interrupt
2488***************************************************************************/
2c3dfe3f 2489void
1da177e4
LT		 2490qla2x00_timer(scsi_qla_host_t *ha)
2491{
1da177e4
LT		 2492 unsigned long cpu_flags = 0;
2493 fc_port_t *fcport;
1da177e4
LT		 2494 int start_dpc = 0;
2495 int index;
2496 srb_t *sp;
f4f051eb 2497 int t;
2c3dfe3f 2498 scsi_qla_host_t *pha = to_qla_parent(ha);
1da177e4
LT		 2499
2500 /*
2501 * Ports - Port down timer.
2502 *
2503 * Whenever, a port is in the LOST state we start decrementing its port
2504 * down timer every second until it reaches zero. Once it reaches zero
fa2a1ce5 2505 * the port it marked DEAD.
1da177e4
LT		 2506 */
2507 t = 0;
2508 list_for_each_entry(fcport, &ha->fcports, list) {
2509 if (fcport->port_type != FCT_TARGET)
2510 continue;
2511
2512 if (atomic_read(&fcport->state) == FCS_DEVICE_LOST) {
2513
2514 if (atomic_read(&fcport->port_down_timer) == 0)
2515 continue;
2516
fa2a1ce5 2517 if (atomic_dec_and_test(&fcport->port_down_timer) != 0)
1da177e4 2518 atomic_set(&fcport->state, FCS_DEVICE_DEAD);
fa2a1ce5 2519
1da177e4 2520 DEBUG(printk("scsi(%ld): fcport-%d - port retry count: "
fca29703 2521 "%d remaining\n",
1da177e4
LT		 2522 ha->host_no,
2523 t, atomic_read(&fcport->port_down_timer)));
2524 }
2525 t++;
2526 } /* End of for fcport */
2527
1da177e4
LT		 2528
2529 /* Loop down handler. */
2530 if (atomic_read(&ha->loop_down_timer) > 0 &&
2531 !(test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags)) && ha->flags.online) {
2532
2533 if (atomic_read(&ha->loop_down_timer) ==
2534 ha->loop_down_abort_time) {
2535
2536 DEBUG(printk("scsi(%ld): Loop Down - aborting the "
2537 "queues before time expire\n",
2538 ha->host_no));
2539
2540 if (!IS_QLA2100(ha) && ha->link_down_timeout)
fa2a1ce5 2541 atomic_set(&ha->loop_state, LOOP_DEAD);
1da177e4
LT		 2542
2543 /* Schedule an ISP abort to return any tape commands. */
2c3dfe3f
SJ		 2544 /* NPIV - scan physical port only */
2545 if (!ha->parent) {
2546 spin_lock_irqsave(&ha->hardware_lock,
2547 cpu_flags);
2548 for (index = 1;
2549 index < MAX_OUTSTANDING_COMMANDS;
2550 index++) {
2551 fc_port_t *sfcp;
2552
2553 sp = ha->outstanding_cmds[index];
2554 if (!sp)
2555 continue;
2556 sfcp = sp->fcport;
2557 if (!(sfcp->flags & FCF_TAPE_PRESENT))
2558 continue;
bdf79621 2559
2c3dfe3f
SJ		 2560 set_bit(ISP_ABORT_NEEDED,
2561 &ha->dpc_flags);
2562 break;
2563 }
2564 spin_unlock_irqrestore(&ha->hardware_lock,
2565 cpu_flags);
1da177e4 2566 }
1da177e4
LT		 2567 set_bit(ABORT_QUEUES_NEEDED, &ha->dpc_flags);
2568 start_dpc++;
2569 }
2570
2571 /* if the loop has been down for 4 minutes, reinit adapter */
2572 if (atomic_dec_and_test(&ha->loop_down_timer) != 0) {
2573 DEBUG(printk("scsi(%ld): Loop down exceed 4 mins - "
2574 "restarting queues.\n",
2575 ha->host_no));
2576
2577 set_bit(RESTART_QUEUES_NEEDED, &ha->dpc_flags);
2578 start_dpc++;
2579
2580 if (!(ha->device_flags & DFLG_NO_CABLE)) {
2581 DEBUG(printk("scsi(%ld): Loop down - "
2582 "aborting ISP.\n",
2583 ha->host_no));
2584 qla_printk(KERN_WARNING, ha,
2585 "Loop down - aborting ISP.\n");
2586
2587 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
2588 }
2589 }
fca29703 2590 DEBUG3(printk("scsi(%ld): Loop Down - seconds remaining %d\n",
1da177e4
LT		 2591 ha->host_no,
2592 atomic_read(&ha->loop_down_timer)));
2593 }
2594
f6df144c 2595 /* Check if beacon LED needs to be blinked */
2596 if (ha->beacon_blink_led == 1) {
2597 set_bit(BEACON_BLINK_NEEDED, &ha->dpc_flags);
2598 start_dpc++;
2599 }
2600
1da177e4
LT		 2601 /* Schedule the DPC routine if needed */
2602 if ((test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags) ||
2603 test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags) ||
91ca7b01 2604 test_bit(LOOP_RESET_NEEDED, &ha->dpc_flags) ||
d97994dc 2605 test_bit(FCPORT_UPDATE_NEEDED, &ha->dpc_flags) ||
1da177e4
LT		 2606 start_dpc ||
2607 test_bit(LOGIN_RETRY_NEEDED, &ha->dpc_flags) ||
f4f051eb 2608 test_bit(RESET_MARKER_NEEDED, &ha->dpc_flags) ||
f6df144c 2609 test_bit(BEACON_BLINK_NEEDED, &ha->dpc_flags) ||
2c3dfe3f 2610 test_bit(VP_DPC_NEEDED, &ha->dpc_flags) ||
39a11240 2611 test_bit(RELOGIN_NEEDED, &ha->dpc_flags)))
2c3dfe3f 2612 qla2xxx_wake_dpc(pha);
1da177e4
LT		 2613
2614 qla2x00_restart_timer(ha, WATCH_INTERVAL);
2615}
2616
5433383e
AV		 2617/* Firmware interface routines. */
2618
c3a2f0df 2619#define FW_BLOBS 6
5433383e
AV		 2620#define FW_ISP21XX 0
2621#define FW_ISP22XX 1
2622#define FW_ISP2300 2
2623#define FW_ISP2322 3
48c02fde 2624#define FW_ISP24XX 4
c3a2f0df 2625#define FW_ISP25XX 5
5433383e 2626
bb8ee499
AV		 2627#define FW_FILE_ISP21XX "ql2100_fw.bin"
2628#define FW_FILE_ISP22XX "ql2200_fw.bin"
2629#define FW_FILE_ISP2300 "ql2300_fw.bin"
2630#define FW_FILE_ISP2322 "ql2322_fw.bin"
2631#define FW_FILE_ISP24XX "ql2400_fw.bin"
c3a2f0df 2632#define FW_FILE_ISP25XX "ql2500_fw.bin"
bb8ee499 2633
5433383e
AV		 2634static DECLARE_MUTEX(qla_fw_lock);
2635
2636static struct fw_blob qla_fw_blobs[FW_BLOBS] = {
bb8ee499
AV		 2637 { .name = FW_FILE_ISP21XX, .segs = { 0x1000, 0 }, },
2638 { .name = FW_FILE_ISP22XX, .segs = { 0x1000, 0 }, },
2639 { .name = FW_FILE_ISP2300, .segs = { 0x800, 0 }, },
2640 { .name = FW_FILE_ISP2322, .segs = { 0x800, 0x1c000, 0x1e000, 0 }, },
2641 { .name = FW_FILE_ISP24XX, },
c3a2f0df 2642 { .name = FW_FILE_ISP25XX, },
5433383e
AV		 2643};
2644
2645struct fw_blob *
2646qla2x00_request_firmware(scsi_qla_host_t *ha)
2647{
2648 struct fw_blob *blob;
2649
2650 blob = NULL;
2651 if (IS_QLA2100(ha)) {
2652 blob = &qla_fw_blobs[FW_ISP21XX];
2653 } else if (IS_QLA2200(ha)) {
2654 blob = &qla_fw_blobs[FW_ISP22XX];
48c02fde 2655 } else if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
5433383e 2656 blob = &qla_fw_blobs[FW_ISP2300];
48c02fde 2657 } else if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
5433383e 2658 blob = &qla_fw_blobs[FW_ISP2322];
044cc6c8 2659 } else if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) {
5433383e 2660 blob = &qla_fw_blobs[FW_ISP24XX];
c3a2f0df
AV		 2661 } else if (IS_QLA25XX(ha)) {
2662 blob = &qla_fw_blobs[FW_ISP25XX];
5433383e
AV		 2663 }
2664
2665 down(&qla_fw_lock);
2666 if (blob->fw)
2667 goto out;
2668
2669 if (request_firmware(&blob->fw, blob->name, &ha->pdev->dev)) {
2670 DEBUG2(printk("scsi(%ld): Failed to load firmware image "
2671 "(%s).\n", ha->host_no, blob->name));
2672 blob->fw = NULL;
2673 blob = NULL;
2674 goto out;
2675 }
2676
2677out:
2678 up(&qla_fw_lock);
2679 return blob;
2680}
2681
2682static void
2683qla2x00_release_firmware(void)
2684{
2685 int idx;
2686
2687 down(&qla_fw_lock);
2688 for (idx = 0; idx < FW_BLOBS; idx++)
2689 if (qla_fw_blobs[idx].fw)
2690 release_firmware(qla_fw_blobs[idx].fw);
2691 up(&qla_fw_lock);
2692}
2693
14e660e6
SJ		 2694static pci_ers_result_t
2695qla2xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
2696{
2697 switch (state) {
2698 case pci_channel_io_normal:
2699 return PCI_ERS_RESULT_CAN_RECOVER;
2700 case pci_channel_io_frozen:
2701 pci_disable_device(pdev);
2702 return PCI_ERS_RESULT_NEED_RESET;
2703 case pci_channel_io_perm_failure:
2704 qla2x00_remove_one(pdev);
2705 return PCI_ERS_RESULT_DISCONNECT;
2706 }
2707 return PCI_ERS_RESULT_NEED_RESET;
2708}
2709
2710static pci_ers_result_t
2711qla2xxx_pci_mmio_enabled(struct pci_dev *pdev)
2712{
2713 int risc_paused = 0;
2714 uint32_t stat;
2715 unsigned long flags;
2716 scsi_qla_host_t *ha = pci_get_drvdata(pdev);
2717 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
2718 struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
2719
2720 spin_lock_irqsave(&ha->hardware_lock, flags);
2721 if (IS_QLA2100(ha) || IS_QLA2200(ha)){
2722 stat = RD_REG_DWORD(&reg->hccr);
2723 if (stat & HCCR_RISC_PAUSE)
2724 risc_paused = 1;
2725 } else if (IS_QLA23XX(ha)) {
2726 stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
2727 if (stat & HSR_RISC_PAUSED)
2728 risc_paused = 1;
2729 } else if (IS_FWI2_CAPABLE(ha)) {
2730 stat = RD_REG_DWORD(&reg24->host_status);
2731 if (stat & HSRX_RISC_PAUSED)
2732 risc_paused = 1;
2733 }
2734 spin_unlock_irqrestore(&ha->hardware_lock, flags);
2735
2736 if (risc_paused) {
2737 qla_printk(KERN_INFO, ha, "RISC paused -- mmio_enabled, "
2738 "Dumping firmware!\n");
2739 ha->isp_ops->fw_dump(ha, 0);
2740
2741 return PCI_ERS_RESULT_NEED_RESET;
2742 } else
2743 return PCI_ERS_RESULT_RECOVERED;
2744}
2745
2746static pci_ers_result_t
2747qla2xxx_pci_slot_reset(struct pci_dev *pdev)
2748{
2749 pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT;
2750 scsi_qla_host_t *ha = pci_get_drvdata(pdev);
09483916
BH		 2751 int rc;
2752
2753 if (ha->mem_only)
2754 rc = pci_enable_device_mem(pdev);
2755 else
2756 rc = pci_enable_device(pdev);
14e660e6 2757
09483916 2758 if (rc) {
14e660e6
SJ		 2759 qla_printk(KERN_WARNING, ha,
2760 "Can't re-enable PCI device after reset.\n");
2761
2762 return ret;
2763 }
2764 pci_set_master(pdev);
2765
2766 if (ha->isp_ops->pci_config(ha))
2767 return ret;
2768
2769 set_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
2770 if (qla2x00_abort_isp(ha)== QLA_SUCCESS)
2771 ret = PCI_ERS_RESULT_RECOVERED;
2772 clear_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
2773
2774 return ret;
2775}
2776
2777static void
2778qla2xxx_pci_resume(struct pci_dev *pdev)
2779{
2780 scsi_qla_host_t *ha = pci_get_drvdata(pdev);
2781 int ret;
2782
2783 ret = qla2x00_wait_for_hba_online(ha);
2784 if (ret != QLA_SUCCESS) {
2785 qla_printk(KERN_ERR, ha,
2786 "the device failed to resume I/O "
2787 "from slot/link_reset");
2788 }
2789 pci_cleanup_aer_uncorrect_error_status(pdev);
2790}
2791
2792static struct pci_error_handlers qla2xxx_err_handler = {
2793 .error_detected = qla2xxx_pci_error_detected,
2794 .mmio_enabled = qla2xxx_pci_mmio_enabled,
2795 .slot_reset = qla2xxx_pci_slot_reset,
2796 .resume = qla2xxx_pci_resume,
2797};
2798
5433383e 2799static struct pci_device_id qla2xxx_pci_tbl[] = {
47f5e069
AV		 2800 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2100) },
2801 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2200) },
2802 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2300) },
2803 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2312) },
2804 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2322) },
2805 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6312) },
2806 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6322) },
2807 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2422) },
2808 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2432) },
2809 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP5422) },
2810 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP5432) },
c3a2f0df 2811 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2532) },
5433383e
AV		 2812 { 0 },
2813};
2814MODULE_DEVICE_TABLE(pci, qla2xxx_pci_tbl);
2815
fca29703 2816static struct pci_driver qla2xxx_pci_driver = {
cb63067a 2817 .name = QLA2XXX_DRIVER_NAME,
0a21ef1e
JB		 2818 .driver = {
2819 .owner = THIS_MODULE,
2820 },
fca29703 2821 .id_table = qla2xxx_pci_tbl,
7ee61397 2822 .probe = qla2x00_probe_one,
4c993f76 2823 .remove = qla2x00_remove_one,
14e660e6 2824 .err_handler = &qla2xxx_err_handler,
fca29703
AV		 2825};
2826
1da177e4
LT		 2827/**
2828 * qla2x00_module_init - Module initialization.
2829 **/
2830static int __init
2831qla2x00_module_init(void)
2832{
fca29703
AV		 2833 int ret = 0;
2834
1da177e4 2835 /* Allocate cache for SRBs. */
354d6b21 2836 srb_cachep = kmem_cache_create("qla2xxx_srbs", sizeof(srb_t), 0,
20c2df83 2837 SLAB_HWCACHE_ALIGN, NULL);
1da177e4
LT		 2838 if (srb_cachep == NULL) {
2839 printk(KERN_ERR
2840 "qla2xxx: Unable to allocate SRB cache...Failing load!\n");
2841 return -ENOMEM;
2842 }
2843
2844 /* Derive version string. */
2845 strcpy(qla2x00_version_str, QLA2XXX_VERSION);
11010fec 2846 if (ql2xextended_error_logging)
0181944f
AV		 2847 strcat(qla2x00_version_str, "-debug");
2848
1c97a12a
AV		 2849 qla2xxx_transport_template =
2850 fc_attach_transport(&qla2xxx_transport_functions);
2c3dfe3f
SJ		 2851 if (!qla2xxx_transport_template) {
2852 kmem_cache_destroy(srb_cachep);
1da177e4 2853 return -ENODEV;
2c3dfe3f
SJ		 2854 }
2855 qla2xxx_transport_vport_template =
2856 fc_attach_transport(&qla2xxx_transport_vport_functions);
2857 if (!qla2xxx_transport_vport_template) {
2858 kmem_cache_destroy(srb_cachep);
2859 fc_release_transport(qla2xxx_transport_template);
1da177e4 2860 return -ENODEV;
2c3dfe3f 2861 }
1da177e4
LT		 2862
2863 printk(KERN_INFO "QLogic Fibre Channel HBA Driver\n");
7ee61397 2864 ret = pci_register_driver(&qla2xxx_pci_driver);
fca29703
AV		 2865 if (ret) {
2866 kmem_cache_destroy(srb_cachep);
2867 fc_release_transport(qla2xxx_transport_template);
2c3dfe3f 2868 fc_release_transport(qla2xxx_transport_vport_template);
fca29703
AV		 2869 }
2870 return ret;
1da177e4
LT		 2871}
2872
2873/**
2874 * qla2x00_module_exit - Module cleanup.
2875 **/
2876static void __exit
2877qla2x00_module_exit(void)
2878{
7ee61397 2879 pci_unregister_driver(&qla2xxx_pci_driver);
5433383e 2880 qla2x00_release_firmware();
354d6b21 2881 kmem_cache_destroy(srb_cachep);
1da177e4 2882 fc_release_transport(qla2xxx_transport_template);
2c3dfe3f 2883 fc_release_transport(qla2xxx_transport_vport_template);
1da177e4
LT		 2884}
2885
2886module_init(qla2x00_module_init);
2887module_exit(qla2x00_module_exit);
2888
2889MODULE_AUTHOR("QLogic Corporation");
2890MODULE_DESCRIPTION("QLogic Fibre Channel HBA Driver");
2891MODULE_LICENSE("GPL");
2892MODULE_VERSION(QLA2XXX_VERSION);
bb8ee499
AV		 2893MODULE_FIRMWARE(FW_FILE_ISP21XX);
2894MODULE_FIRMWARE(FW_FILE_ISP22XX);
2895MODULE_FIRMWARE(FW_FILE_ISP2300);
2896MODULE_FIRMWARE(FW_FILE_ISP2322);
2897MODULE_FIRMWARE(FW_FILE_ISP24XX);
61623fc3 2898MODULE_FIRMWARE(FW_FILE_ISP25XX);
Linux 6.x block layer and io_uring tree(s)