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