aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/qla2xxx/qla_os.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/scsi/qla2xxx/qla_os.c')
-rw-r--r--drivers/scsi/qla2xxx/qla_os.c4456
1 files changed, 4456 insertions, 0 deletions
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
new file mode 100644
index 000000000000..b5863d8769e0
--- /dev/null
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -0,0 +1,4456 @@
1/*
2 * QLOGIC LINUX SOFTWARE
3 *
4 * QLogic ISP2x00 device driver for Linux 2.6.x
5 * Copyright (C) 2003-2004 QLogic Corporation
6 * (www.qlogic.com)
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2, or (at your option) any
11 * later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 */
19#include "qla_def.h"
20
21#include <linux/moduleparam.h>
22#include <linux/vmalloc.h>
23#include <linux/smp_lock.h>
24#include <linux/delay.h>
25
26#include <scsi/scsi_tcq.h>
27#include <scsi/scsicam.h>
28#include <scsi/scsi_transport.h>
29#include <scsi/scsi_transport_fc.h>
30
31/*
32 * Driver version
33 */
34char qla2x00_version_str[40];
35
36/*
37 * SRB allocation cache
38 */
39char srb_cachep_name[16];
40kmem_cache_t *srb_cachep;
41
42/*
43 * Stats for all adpaters.
44 */
45struct _qla2x00stats qla2x00_stats;
46
47/*
48 * Ioctl related information.
49 */
50int num_hosts;
51int apiHBAInstance;
52
53/*
54 * Module parameter information and variables
55 */
56int ql2xmaxqdepth;
57module_param(ql2xmaxqdepth, int, S_IRUGO|S_IWUSR);
58MODULE_PARM_DESC(ql2xmaxqdepth,
59 "Maximum queue depth to report for target devices.");
60
61int ql2xlogintimeout = 20;
62module_param(ql2xlogintimeout, int, S_IRUGO|S_IRUSR);
63MODULE_PARM_DESC(ql2xlogintimeout,
64 "Login timeout value in seconds.");
65
66int qlport_down_retry;
67module_param(qlport_down_retry, int, S_IRUGO|S_IRUSR);
68MODULE_PARM_DESC(qlport_down_retry,
69 "Maximum number of command retries to a port that returns"
70 "a PORT-DOWN status.");
71
72int ql2xretrycount = 20;
73module_param(ql2xretrycount, int, S_IRUGO|S_IWUSR);
74MODULE_PARM_DESC(ql2xretrycount,
75 "Maximum number of mid-layer retries allowed for a command. "
76 "Default value is 20, ");
77
78int displayConfig;
79module_param(displayConfig, int, S_IRUGO|S_IWUSR);
80MODULE_PARM_DESC(displayConfig,
81 "If 1 then display the configuration used in /etc/modprobe.conf.");
82
83int ql2xplogiabsentdevice;
84module_param(ql2xplogiabsentdevice, int, S_IRUGO|S_IWUSR);
85MODULE_PARM_DESC(ql2xplogiabsentdevice,
86 "Option to enable PLOGI to devices that are not present after "
87 "a Fabric scan. This is needed for several broken switches."
88 "Default is 0 - no PLOGI. 1 - perfom PLOGI.");
89
90int ql2xenablezio = 0;
91module_param(ql2xenablezio, int, S_IRUGO|S_IRUSR);
92MODULE_PARM_DESC(ql2xenablezio,
93 "Option to enable ZIO:If 1 then enable it otherwise"
94 " use the default set in the NVRAM."
95 " Default is 0 : disabled");
96
97int ql2xintrdelaytimer = 10;
98module_param(ql2xintrdelaytimer, int, S_IRUGO|S_IRUSR);
99MODULE_PARM_DESC(ql2xintrdelaytimer,
100 "ZIO: Waiting time for Firmware before it generates an "
101 "interrupt to the host to notify completion of request.");
102
103int ConfigRequired;
104module_param(ConfigRequired, int, S_IRUGO|S_IRUSR);
105MODULE_PARM_DESC(ConfigRequired,
106 "If 1, then only configured devices passed in through the"
107 "ql2xopts parameter will be presented to the OS");
108
109int Bind = BIND_BY_PORT_NAME;
110module_param(Bind, int, S_IRUGO|S_IRUSR);
111MODULE_PARM_DESC(Bind,
112 "Target persistent binding method: "
113 "0 by Portname (default); 1 by PortID; 2 by Nodename. ");
114
115int ql2xsuspendcount = SUSPEND_COUNT;
116module_param(ql2xsuspendcount, int, S_IRUGO|S_IWUSR);
117MODULE_PARM_DESC(ql2xsuspendcount,
118 "Number of 6-second suspend iterations to perform while a "
119 "target returns a <NOT READY> status. Default is 10 "
120 "iterations.");
121
122int ql2xdoinitscan = 1;
123module_param(ql2xdoinitscan, int, S_IRUGO|S_IWUSR);
124MODULE_PARM_DESC(ql2xdoinitscan,
125 "Signal mid-layer to perform scan after driver load: 0 -- no "
126 "signal sent to mid-layer.");
127
128int ql2xloginretrycount = 0;
129module_param(ql2xloginretrycount, int, S_IRUGO|S_IRUSR);
130MODULE_PARM_DESC(ql2xloginretrycount,
131 "Specify an alternate value for the NVRAM login retry count.");
132
133/*
134 * Proc structures and functions
135 */
136struct info_str {
137 char *buffer;
138 int length;
139 off_t offset;
140 int pos;
141};
142
143static void copy_mem_info(struct info_str *, char *, int);
144static int copy_info(struct info_str *, char *, ...);
145
146static void qla2x00_free_device(scsi_qla_host_t *);
147
148static void qla2x00_config_dma_addressing(scsi_qla_host_t *ha);
149
150/*
151 * SCSI host template entry points
152 */
153static int qla2xxx_slave_configure(struct scsi_device * device);
154static int qla2x00_queuecommand(struct scsi_cmnd *cmd,
155 void (*fn)(struct scsi_cmnd *));
156static int qla2xxx_eh_abort(struct scsi_cmnd *);
157static int qla2xxx_eh_device_reset(struct scsi_cmnd *);
158static int qla2xxx_eh_bus_reset(struct scsi_cmnd *);
159static int qla2xxx_eh_host_reset(struct scsi_cmnd *);
160static int qla2x00_loop_reset(scsi_qla_host_t *ha);
161static int qla2x00_device_reset(scsi_qla_host_t *, fc_port_t *);
162
163static int qla2x00_proc_info(struct Scsi_Host *, char *, char **,
164 off_t, int, int);
165
166static struct scsi_host_template qla2x00_driver_template = {
167 .module = THIS_MODULE,
168 .name = "qla2xxx",
169 .proc_name = "qla2xxx",
170 .proc_info = qla2x00_proc_info,
171 .queuecommand = qla2x00_queuecommand,
172
173 .eh_abort_handler = qla2xxx_eh_abort,
174 .eh_device_reset_handler = qla2xxx_eh_device_reset,
175 .eh_bus_reset_handler = qla2xxx_eh_bus_reset,
176 .eh_host_reset_handler = qla2xxx_eh_host_reset,
177
178 .slave_configure = qla2xxx_slave_configure,
179
180 .this_id = -1,
181 .cmd_per_lun = 3,
182 .use_clustering = ENABLE_CLUSTERING,
183 .sg_tablesize = SG_ALL,
184
185 /*
186 * The RISC allows for each command to transfer (2^32-1) bytes of data,
187 * which equates to 0x800000 sectors.
188 */
189 .max_sectors = 0xFFFF,
190};
191
192static struct scsi_transport_template *qla2xxx_transport_template = NULL;
193
194static void qla2x00_display_fc_names(scsi_qla_host_t *);
195
196/* TODO Convert to inlines
197 *
198 * Timer routines
199 */
200#define WATCH_INTERVAL 1 /* number of seconds */
201
202static void qla2x00_timer(scsi_qla_host_t *);
203
204static __inline__ void qla2x00_start_timer(scsi_qla_host_t *,
205 void *, unsigned long);
206static __inline__ void qla2x00_restart_timer(scsi_qla_host_t *, unsigned long);
207static __inline__ void qla2x00_stop_timer(scsi_qla_host_t *);
208
209static inline void
210qla2x00_start_timer(scsi_qla_host_t *ha, void *func, unsigned long interval)
211{
212 init_timer(&ha->timer);
213 ha->timer.expires = jiffies + interval * HZ;
214 ha->timer.data = (unsigned long)ha;
215 ha->timer.function = (void (*)(unsigned long))func;
216 add_timer(&ha->timer);
217 ha->timer_active = 1;
218}
219
220static inline void
221qla2x00_restart_timer(scsi_qla_host_t *ha, unsigned long interval)
222{
223 mod_timer(&ha->timer, jiffies + interval * HZ);
224}
225
226static __inline__ void
227qla2x00_stop_timer(scsi_qla_host_t *ha)
228{
229 del_timer_sync(&ha->timer);
230 ha->timer_active = 0;
231}
232
233void qla2x00_cmd_timeout(srb_t *);
234
235static __inline__ void qla2x00_callback(scsi_qla_host_t *, struct scsi_cmnd *);
236static __inline__ void sp_put(struct scsi_qla_host * ha, srb_t *sp);
237static __inline__ void sp_get(struct scsi_qla_host * ha, srb_t *sp);
238static __inline__ void
239qla2x00_delete_from_done_queue(scsi_qla_host_t *, srb_t *);
240
241/*
242* qla2x00_callback
243* Returns the completed SCSI command to LINUX.
244*
245* Input:
246* ha -- Host adapter structure
247* cmd -- SCSI mid-level command structure.
248* Returns:
249* None
250* Note:From failover point of view we always get the sp
251* from vis_ha pool in queuecommand.So when we put it
252* back to the pool it has to be the vis_ha.
253* So rely on struct scsi_cmnd to get the vis_ha and not on sp.
254*/
255static inline void
256qla2x00_callback(scsi_qla_host_t *ha, struct scsi_cmnd *cmd)
257{
258 srb_t *sp = (srb_t *) CMD_SP(cmd);
259 scsi_qla_host_t *vis_ha;
260 os_lun_t *lq;
261 int got_sense;
262 unsigned long cpu_flags = 0;
263
264 cmd->host_scribble = (unsigned char *) NULL;
265 vis_ha = (scsi_qla_host_t *) cmd->device->host->hostdata;
266
267 if (sp == NULL) {
268 qla_printk(KERN_INFO, ha,
269 "%s(): **** CMD derives a NULL SP\n",
270 __func__);
271 DEBUG2(BUG();)
272 return;
273 }
274
275 /*
276 * If command status is not DID_BUS_BUSY then go ahead and freed sp.
277 */
278 /*
279 * Cancel command timeout
280 */
281 qla2x00_delete_timer_from_cmd(sp);
282
283 /*
284 * Put SP back in the free queue
285 */
286 sp->cmd = NULL;
287 CMD_SP(cmd) = NULL;
288 lq = sp->lun_queue;
289 got_sense = (sp->flags & SRB_GOT_SENSE)? 1: 0;
290 add_to_free_queue(vis_ha, sp);
291
292 if (host_byte(cmd->result) == DID_OK) {
293 /* device ok */
294 ha->total_bytes += cmd->bufflen;
295 if (!got_sense) {
296 /* If lun was suspended then clear retry count */
297 spin_lock_irqsave(&lq->q_lock, cpu_flags);
298 if (!test_bit(LUN_EXEC_DELAYED, &lq->q_flag))
299 lq->q_state = LUN_STATE_READY;
300 spin_unlock_irqrestore(&lq->q_lock, cpu_flags);
301 }
302 } else if (host_byte(cmd->result) == DID_ERROR) {
303 /* device error */
304 ha->total_dev_errs++;
305 }
306
307 /* Call the mid-level driver interrupt handler */
308 (*(cmd)->scsi_done)(cmd);
309}
310
311/**************************************************************************
312* sp_put
313*
314* Description:
315* Decrement reference count and call the callback if we're the last
316* owner of the specified sp. Will get the host_lock before calling
317* the callback.
318*
319* Input:
320* ha - pointer to the scsi_qla_host_t where the callback is to occur.
321* sp - pointer to srb_t structure to use.
322*
323* Returns:
324*
325**************************************************************************/
326static inline void
327sp_put(struct scsi_qla_host * ha, srb_t *sp)
328{
329 if (atomic_read(&sp->ref_count) == 0) {
330 qla_printk(KERN_INFO, ha,
331 "%s(): **** SP->ref_count not zero\n",
332 __func__);
333 DEBUG2(BUG();)
334
335 return;
336 }
337
338 if (!atomic_dec_and_test(&sp->ref_count)) {
339 return;
340 }
341
342 qla2x00_callback(ha, sp->cmd);
343}
344
345/**************************************************************************
346* sp_get
347*
348* Description:
349* Increment reference count of the specified sp.
350*
351* Input:
352* sp - pointer to srb_t structure to use.
353*
354* Returns:
355*
356**************************************************************************/
357static inline void
358sp_get(struct scsi_qla_host * ha, srb_t *sp)
359{
360 atomic_inc(&sp->ref_count);
361
362 if (atomic_read(&sp->ref_count) > 2) {
363 qla_printk(KERN_INFO, ha,
364 "%s(): **** SP->ref_count greater than two\n",
365 __func__);
366 DEBUG2(BUG();)
367
368 return;
369 }
370}
371
372static inline void
373qla2x00_delete_from_done_queue(scsi_qla_host_t *dest_ha, srb_t *sp)
374{
375 /* remove command from done list */
376 list_del_init(&sp->list);
377 dest_ha->done_q_cnt--;
378 sp->state = SRB_NO_QUEUE_STATE;
379
380 if (sp->flags & SRB_DMA_VALID) {
381 sp->flags &= ~SRB_DMA_VALID;
382
383 /* Release memory used for this I/O */
384 if (sp->cmd->use_sg) {
385 pci_unmap_sg(dest_ha->pdev, sp->cmd->request_buffer,
386 sp->cmd->use_sg, sp->cmd->sc_data_direction);
387 } else if (sp->cmd->request_bufflen) {
388 pci_unmap_page(dest_ha->pdev, sp->dma_handle,
389 sp->cmd->request_bufflen,
390 sp->cmd->sc_data_direction);
391 }
392 }
393}
394
395static int qla2x00_do_dpc(void *data);
396
397static void qla2x00_rst_aen(scsi_qla_host_t *);
398
399static uint8_t qla2x00_mem_alloc(scsi_qla_host_t *);
400static void qla2x00_mem_free(scsi_qla_host_t *ha);
401static int qla2x00_allocate_sp_pool( scsi_qla_host_t *ha);
402static void qla2x00_free_sp_pool(scsi_qla_host_t *ha);
403static srb_t *qla2x00_get_new_sp(scsi_qla_host_t *ha);
404
405static ssize_t qla2x00_sysfs_read_fw_dump(struct kobject *, char *, loff_t,
406 size_t);
407static ssize_t qla2x00_sysfs_write_fw_dump(struct kobject *, char *, loff_t,
408 size_t);
409static struct bin_attribute sysfs_fw_dump_attr = {
410 .attr = {
411 .name = "fw_dump",
412 .mode = S_IRUSR | S_IWUSR,
413 .owner = THIS_MODULE,
414 },
415 .size = 0,
416 .read = qla2x00_sysfs_read_fw_dump,
417 .write = qla2x00_sysfs_write_fw_dump,
418};
419static ssize_t qla2x00_sysfs_read_nvram(struct kobject *, char *, loff_t,
420 size_t);
421static ssize_t qla2x00_sysfs_write_nvram(struct kobject *, char *, loff_t,
422 size_t);
423static struct bin_attribute sysfs_nvram_attr = {
424 .attr = {
425 .name = "nvram",
426 .mode = S_IRUSR | S_IWUSR,
427 .owner = THIS_MODULE,
428 },
429 .size = sizeof(nvram_t),
430 .read = qla2x00_sysfs_read_nvram,
431 .write = qla2x00_sysfs_write_nvram,
432};
433
434/* -------------------------------------------------------------------------- */
435
436
437/* SysFS attributes. */
438static ssize_t qla2x00_sysfs_read_fw_dump(struct kobject *kobj, char *buf,
439 loff_t off, size_t count)
440{
441 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
442 struct device, kobj)));
443
444 if (ha->fw_dump_reading == 0)
445 return 0;
446 if (off > ha->fw_dump_buffer_len)
447 return 0;
448 if (off + count > ha->fw_dump_buffer_len)
449 count = ha->fw_dump_buffer_len - off;
450
451 memcpy(buf, &ha->fw_dump_buffer[off], count);
452
453 return (count);
454}
455
456static ssize_t qla2x00_sysfs_write_fw_dump(struct kobject *kobj, char *buf,
457 loff_t off, size_t count)
458{
459 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
460 struct device, kobj)));
461 int reading;
462 uint32_t dump_size;
463
464 if (off != 0)
465 return (0);
466
467 reading = simple_strtol(buf, NULL, 10);
468 switch (reading) {
469 case 0:
470 if (ha->fw_dump_reading == 1) {
471 qla_printk(KERN_INFO, ha,
472 "Firmware dump cleared on (%ld).\n",
473 ha->host_no);
474
475 vfree(ha->fw_dump_buffer);
476 free_pages((unsigned long)ha->fw_dump,
477 ha->fw_dump_order);
478
479 ha->fw_dump_reading = 0;
480 ha->fw_dump_buffer = NULL;
481 ha->fw_dump = NULL;
482 }
483 break;
484 case 1:
485 if (ha->fw_dump != NULL && !ha->fw_dump_reading) {
486 ha->fw_dump_reading = 1;
487
488 dump_size = FW_DUMP_SIZE_1M;
489 if (ha->fw_memory_size < 0x20000)
490 dump_size = FW_DUMP_SIZE_128K;
491 else if (ha->fw_memory_size < 0x80000)
492 dump_size = FW_DUMP_SIZE_512K;
493 ha->fw_dump_buffer = (char *)vmalloc(dump_size);
494 if (ha->fw_dump_buffer == NULL) {
495 qla_printk(KERN_WARNING, ha,
496 "Unable to allocate memory for firmware "
497 "dump buffer (%d).\n", dump_size);
498
499 ha->fw_dump_reading = 0;
500 return (count);
501 }
502 qla_printk(KERN_INFO, ha,
503 "Firmware dump ready for read on (%ld).\n",
504 ha->host_no);
505 memset(ha->fw_dump_buffer, 0, dump_size);
506 if (IS_QLA2100(ha) || IS_QLA2200(ha))
507 qla2100_ascii_fw_dump(ha);
508 else
509 qla2300_ascii_fw_dump(ha);
510 ha->fw_dump_buffer_len = strlen(ha->fw_dump_buffer);
511 }
512 break;
513 }
514 return (count);
515}
516
517static ssize_t qla2x00_sysfs_read_nvram(struct kobject *kobj, char *buf,
518 loff_t off, size_t count)
519{
520 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
521 struct device, kobj)));
522 uint16_t *witer;
523 unsigned long flags;
524 uint16_t cnt;
525
526 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != sizeof(nvram_t))
527 return 0;
528
529 /* Read NVRAM. */
530 spin_lock_irqsave(&ha->hardware_lock, flags);
531 qla2x00_lock_nvram_access(ha);
532 witer = (uint16_t *)buf;
533 for (cnt = 0; cnt < count / 2; cnt++) {
534 *witer = cpu_to_le16(qla2x00_get_nvram_word(ha,
535 cnt+ha->nvram_base));
536 witer++;
537 }
538 qla2x00_unlock_nvram_access(ha);
539 spin_unlock_irqrestore(&ha->hardware_lock, flags);
540
541 return (count);
542}
543
544static ssize_t qla2x00_sysfs_write_nvram(struct kobject *kobj, char *buf,
545 loff_t off, size_t count)
546{
547 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
548 struct device, kobj)));
549 uint8_t *iter;
550 uint16_t *witer;
551 unsigned long flags;
552 uint16_t cnt;
553 uint8_t chksum;
554
555 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != sizeof(nvram_t))
556 return 0;
557
558 /* Checksum NVRAM. */
559 iter = (uint8_t *)buf;
560 chksum = 0;
561 for (cnt = 0; cnt < count - 1; cnt++)
562 chksum += *iter++;
563 chksum = ~chksum + 1;
564 *iter = chksum;
565
566 /* Write NVRAM. */
567 spin_lock_irqsave(&ha->hardware_lock, flags);
568 qla2x00_lock_nvram_access(ha);
569 qla2x00_release_nvram_protection(ha);
570 witer = (uint16_t *)buf;
571 for (cnt = 0; cnt < count / 2; cnt++) {
572 qla2x00_write_nvram_word(ha, cnt+ha->nvram_base,
573 cpu_to_le16(*witer));
574 witer++;
575 }
576 qla2x00_unlock_nvram_access(ha);
577 spin_unlock_irqrestore(&ha->hardware_lock, flags);
578
579 return (count);
580}
581
582/* -------------------------------------------------------------------------- */
583static char *
584qla2x00_get_pci_info_str(struct scsi_qla_host *ha, char *str)
585{
586 static char *pci_bus_modes[] = {
587 "33", "66", "100", "133",
588 };
589 uint16_t pci_bus;
590
591 strcpy(str, "PCI");
592 pci_bus = (ha->pci_attr & (BIT_9 | BIT_10)) >> 9;
593 if (pci_bus) {
594 strcat(str, "-X (");
595 strcat(str, pci_bus_modes[pci_bus]);
596 } else {
597 pci_bus = (ha->pci_attr & BIT_8) >> 8;
598 strcat(str, " (");
599 strcat(str, pci_bus_modes[pci_bus]);
600 }
601 strcat(str, " MHz)");
602
603 return (str);
604}
605
606char *
607qla2x00_get_fw_version_str(struct scsi_qla_host *ha, char *str)
608{
609 char un_str[10];
610
611 sprintf(str, "%d.%02d.%02d ", ha->fw_major_version,
612 ha->fw_minor_version,
613 ha->fw_subminor_version);
614
615 if (ha->fw_attributes & BIT_9) {
616 strcat(str, "FLX");
617 return (str);
618 }
619
620 switch (ha->fw_attributes & 0xFF) {
621 case 0x7:
622 strcat(str, "EF");
623 break;
624 case 0x17:
625 strcat(str, "TP");
626 break;
627 case 0x37:
628 strcat(str, "IP");
629 break;
630 case 0x77:
631 strcat(str, "VI");
632 break;
633 default:
634 sprintf(un_str, "(%x)", ha->fw_attributes);
635 strcat(str, un_str);
636 break;
637 }
638 if (ha->fw_attributes & 0x100)
639 strcat(str, "X");
640
641 return (str);
642}
643
644/**************************************************************************
645* qla2x00_queuecommand
646*
647* Description:
648* Queue a command to the controller.
649*
650* Input:
651* cmd - pointer to Scsi cmd structure
652* fn - pointer to Scsi done function
653*
654* Returns:
655* 0 - Always
656*
657* Note:
658* The mid-level driver tries to ensures that queuecommand never gets invoked
659* concurrently with itself or the interrupt handler (although the
660* interrupt handler may call this routine as part of request-completion
661* handling).
662**************************************************************************/
663static int
664qla2x00_queuecommand(struct scsi_cmnd *cmd, void (*fn)(struct scsi_cmnd *))
665{
666 fc_port_t *fcport;
667 os_lun_t *lq;
668 os_tgt_t *tq;
669 scsi_qla_host_t *ha, *ha2;
670 srb_t *sp;
671 struct Scsi_Host *host;
672 unsigned int b, t, l;
673 unsigned long handle;
674 int was_empty;
675
676
677 host = cmd->device->host;
678 ha = (scsi_qla_host_t *) host->hostdata;
679 was_empty = 1;
680
681 cmd->scsi_done = fn;
682
683 spin_unlock_irq(ha->host->host_lock);
684
685 /*
686 * Allocate a command packet from the "sp" pool. If we cant get back
687 * one then let scsi layer come back later.
688 */
689 if ((sp = qla2x00_get_new_sp(ha)) == NULL) {
690 qla_printk(KERN_WARNING, ha,
691 "Couldn't allocate memory for sp - retried.\n");
692
693 spin_lock_irq(ha->host->host_lock);
694
695 return (1);
696 }
697
698 sp->cmd = cmd;
699 CMD_SP(cmd) = (void *)sp;
700
701 sp->flags = 0;
702 if (CMD_RESID_LEN(cmd) & SRB_IOCTL) {
703 /* Need to set sp->flags */
704 sp->flags |= SRB_IOCTL;
705 CMD_RESID_LEN(cmd) = 0; /* Clear it since no more use. */
706 }
707
708 sp->fo_retry_cnt = 0;
709 sp->err_id = 0;
710
711 /* Generate LU queue on bus, target, LUN */
712 b = cmd->device->channel;
713 t = cmd->device->id;
714 l = cmd->device->lun;
715
716 /*
717 * Start Command Timer. Typically it will be 2 seconds less than what
718 * is requested by the Host such that we can return the IO before
719 * aborts are called.
720 */
721 if ((cmd->timeout_per_command / HZ) > QLA_CMD_TIMER_DELTA)
722 qla2x00_add_timer_to_cmd(sp,
723 (cmd->timeout_per_command / HZ) - QLA_CMD_TIMER_DELTA);
724 else
725 qla2x00_add_timer_to_cmd(sp, cmd->timeout_per_command / HZ);
726
727 if (l >= ha->max_luns) {
728 cmd->result = DID_NO_CONNECT << 16;
729 sp->err_id = SRB_ERR_PORT;
730
731 spin_lock_irq(ha->host->host_lock);
732
733 sp_put(ha, sp);
734
735 return (0);
736 }
737
738 if ((tq = (os_tgt_t *) TGT_Q(ha, t)) != NULL &&
739 (lq = (os_lun_t *) LUN_Q(ha, t, l)) != NULL) {
740 fcport = lq->fclun->fcport;
741 ha2 = fcport->ha;
742 } else {
743 lq = NULL;
744 fcport = NULL;
745 ha2 = ha;
746 }
747
748 /* Set an invalid handle until we issue the command to ISP */
749 /* then we will set the real handle value. */
750 handle = INVALID_HANDLE;
751 cmd->host_scribble = (unsigned char *)handle;
752
753 /* Bookkeeping information */
754 sp->r_start = jiffies; /* Time the request was recieved. */
755 sp->u_start = 0;
756
757 /* Setup device queue pointers. */
758 sp->tgt_queue = tq;
759 sp->lun_queue = lq;
760
761 /*
762 * NOTE : q is NULL
763 *
764 * 1. When device is added from persistent binding but has not been
765 * discovered yet.The state of loopid == PORT_AVAIL.
766 * 2. When device is never found on the bus.(loopid == UNUSED)
767 *
768 * IF Device Queue is not created, or device is not in a valid state
769 * and link down error reporting is enabled, reject IO.
770 */
771 if (fcport == NULL) {
772 DEBUG3(printk("scsi(%ld:%2d:%2d): port unavailable\n",
773 ha->host_no,t,l));
774
775 cmd->result = DID_NO_CONNECT << 16;
776 sp->err_id = SRB_ERR_PORT;
777
778 spin_lock_irq(ha->host->host_lock);
779
780 sp_put(ha, sp);
781
782 return (0);
783 }
784
785 /* Only modify the allowed count if the target is a *non* tape device */
786 if ((fcport->flags & FCF_TAPE_PRESENT) == 0) {
787 sp->flags &= ~SRB_TAPE;
788 if (cmd->allowed < ql2xretrycount) {
789 cmd->allowed = ql2xretrycount;
790 }
791 } else
792 sp->flags |= SRB_TAPE;
793
794 DEBUG5(printk("scsi(%ld:%2d:%2d): (queuecmd) queue sp = %p, "
795 "flags=0x%x fo retry=%d, pid=%ld\n",
796 ha->host_no, t, l, sp, sp->flags, sp->fo_retry_cnt,
797 cmd->serial_number));
798 DEBUG5(qla2x00_print_scsi_cmd(cmd));
799
800 sp->fclun = lq->fclun;
801 sp->ha = ha2;
802
803 if (cmd->sc_data_direction == DMA_BIDIRECTIONAL &&
804 cmd->request_bufflen != 0) {
805
806 DEBUG2(printk(KERN_WARNING
807 "scsi(%ld): Incorrect data direction - transfer "
808 "length=%d, direction=%d, pid=%ld, opcode=%x\n",
809 ha->host_no, cmd->request_bufflen, cmd->sc_data_direction,
810 cmd->serial_number, cmd->cmnd[0]));
811 }
812
813 /* Final pre-check :
814 *
815 * Either PORT_DOWN_TIMER OR LINK_DOWN_TIMER Expired.
816 */
817 if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD ||
818 atomic_read(&ha2->loop_state) == LOOP_DEAD) {
819 /*
820 * Add the command to the done-queue for later failover
821 * processing.
822 */
823 cmd->result = DID_NO_CONNECT << 16;
824 if (atomic_read(&ha2->loop_state) == LOOP_DOWN)
825 sp->err_id = SRB_ERR_LOOP;
826 else
827 sp->err_id = SRB_ERR_PORT;
828
829 add_to_done_queue(ha, sp);
830 qla2x00_done(ha);
831
832 spin_lock_irq(ha->host->host_lock);
833 return (0);
834 }
835
836 if (tq && test_bit(TQF_SUSPENDED, &tq->flags) &&
837 (sp->flags & SRB_TAPE) == 0) {
838 /* If target suspended put incoming I/O in retry_q. */
839 qla2x00_extend_timeout(sp->cmd, 10);
840 add_to_scsi_retry_queue(ha, sp);
841 } else
842 was_empty = add_to_pending_queue(ha, sp);
843
844 if ((IS_QLA2100(ha) || IS_QLA2200(ha)) && ha->flags.online) {
845 if (ha->response_ring_ptr->signature != RESPONSE_PROCESSED) {
846 unsigned long flags;
847
848 spin_lock_irqsave(&ha->hardware_lock, flags);
849 qla2x00_process_response_queue(ha);
850 spin_unlock_irqrestore(&ha->hardware_lock, flags);
851 }
852 }
853
854 /* We submit to the hardware if:
855 *
856 * 1) we're on the cpu the irq's arrive on or
857 * 2) there are very few io's outstanding.
858 *
859 * In all other cases we'll let an irq pick up our IO and submit it
860 * to the controller to improve affinity.
861 */
862 if (_smp_processor_id() == ha->last_irq_cpu || was_empty)
863 qla2x00_next(ha);
864
865 spin_lock_irq(ha->host->host_lock);
866
867 return (0);
868}
869
870/*
871 * qla2x00_eh_wait_on_command
872 * Waits for the command to be returned by the Firmware for some
873 * max time.
874 *
875 * Input:
876 * ha = actual ha whose done queue will contain the command
877 * returned by firmware.
878 * cmd = Scsi Command to wait on.
879 * flag = Abort/Reset(Bus or Device Reset)
880 *
881 * Return:
882 * Not Found : 0
883 * Found : 1
884 */
885static int
886qla2x00_eh_wait_on_command(scsi_qla_host_t *ha, struct scsi_cmnd *cmd)
887{
888#define ABORT_POLLING_PERIOD HZ
889#define ABORT_WAIT_TIME ((10 * HZ) / (ABORT_POLLING_PERIOD))
890
891 int found = 0;
892 int done = 0;
893 srb_t *rp = NULL;
894 struct list_head *list, *temp;
895 u_long max_wait_time = ABORT_WAIT_TIME;
896
897 do {
898 /* Check on done queue */
899 spin_lock(&ha->list_lock);
900 list_for_each_safe(list, temp, &ha->done_queue) {
901 rp = list_entry(list, srb_t, list);
902
903 /*
904 * Found command. Just exit and wait for the cmd sent
905 * to OS.
906 */
907 if (cmd == rp->cmd) {
908 found++;
909 DEBUG3(printk("%s: found in done queue.\n",
910 __func__);)
911 break;
912 }
913 }
914 spin_unlock(&ha->list_lock);
915
916 /* Complete the cmd right away. */
917 if (found) {
918 qla2x00_delete_from_done_queue(ha, rp);
919 sp_put(ha, rp);
920 done++;
921 break;
922 }
923
924 spin_unlock_irq(ha->host->host_lock);
925
926 set_current_state(TASK_UNINTERRUPTIBLE);
927 schedule_timeout(ABORT_POLLING_PERIOD);
928
929 spin_lock_irq(ha->host->host_lock);
930
931 } while ((max_wait_time--));
932
933 if (done)
934 DEBUG2(printk(KERN_INFO "%s: found cmd=%p.\n", __func__, cmd));
935
936 return (done);
937}
938
939/*
940 * qla2x00_wait_for_hba_online
941 * Wait till the HBA is online after going through
942 * <= MAX_RETRIES_OF_ISP_ABORT or
943 * finally HBA is disabled ie marked offline
944 *
945 * Input:
946 * ha - pointer to host adapter structure
947 *
948 * Note:
949 * Does context switching-Release SPIN_LOCK
950 * (if any) before calling this routine.
951 *
952 * Return:
953 * Success (Adapter is online) : 0
954 * Failed (Adapter is offline/disabled) : 1
955 */
956static int
957qla2x00_wait_for_hba_online(scsi_qla_host_t *ha)
958{
959 int return_status;
960 unsigned long wait_online;
961
962 wait_online = jiffies + (MAX_LOOP_TIMEOUT * HZ);
963 while (((test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags)) ||
964 test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags) ||
965 test_bit(ISP_ABORT_RETRY, &ha->dpc_flags) ||
966 ha->dpc_active) && time_before(jiffies, wait_online)) {
967
968 msleep(1000);
969 }
970 if (ha->flags.online)
971 return_status = QLA_SUCCESS;
972 else
973 return_status = QLA_FUNCTION_FAILED;
974
975 DEBUG2(printk("%s return_status=%d\n",__func__,return_status));
976
977 return (return_status);
978}
979
980/*
981 * qla2x00_wait_for_loop_ready
982 * Wait for MAX_LOOP_TIMEOUT(5 min) value for loop
983 * to be in LOOP_READY state.
984 * Input:
985 * ha - pointer to host adapter structure
986 *
987 * Note:
988 * Does context switching-Release SPIN_LOCK
989 * (if any) before calling this routine.
990 *
991 *
992 * Return:
993 * Success (LOOP_READY) : 0
994 * Failed (LOOP_NOT_READY) : 1
995 */
996static inline int
997qla2x00_wait_for_loop_ready(scsi_qla_host_t *ha)
998{
999 int return_status = QLA_SUCCESS;
1000 unsigned long loop_timeout ;
1001
1002 /* wait for 5 min at the max for loop to be ready */
1003 loop_timeout = jiffies + (MAX_LOOP_TIMEOUT * HZ);
1004
1005 while ((!atomic_read(&ha->loop_down_timer) &&
1006 atomic_read(&ha->loop_state) == LOOP_DOWN) ||
1007 test_bit(CFG_ACTIVE, &ha->cfg_flags) ||
1008 atomic_read(&ha->loop_state) != LOOP_READY) {
1009 msleep(1000);
1010 if (time_after_eq(jiffies, loop_timeout)) {
1011 return_status = QLA_FUNCTION_FAILED;
1012 break;
1013 }
1014 }
1015 return (return_status);
1016}
1017
1018/**************************************************************************
1019* qla2xxx_eh_abort
1020*
1021* Description:
1022* The abort function will abort the specified command.
1023*
1024* Input:
1025* cmd = Linux SCSI command packet to be aborted.
1026*
1027* Returns:
1028* Either SUCCESS or FAILED.
1029*
1030* Note:
1031**************************************************************************/
1032int
1033qla2xxx_eh_abort(struct scsi_cmnd *cmd)
1034{
1035 int i;
1036 int return_status = FAILED;
1037 os_lun_t *q;
1038 scsi_qla_host_t *ha;
1039 scsi_qla_host_t *vis_ha;
1040 srb_t *sp;
1041 srb_t *rp;
1042 struct list_head *list, *temp;
1043 struct Scsi_Host *host;
1044 uint8_t found = 0;
1045 unsigned int b, t, l;
1046
1047 /* Get the SCSI request ptr */
1048 sp = (srb_t *) CMD_SP(cmd);
1049
1050 /*
1051 * If sp is NULL, command is already returned.
1052 * sp is NULLED just before we call back scsi_done
1053 *
1054 */
1055 if ((sp == NULL)) {
1056 /* no action - we don't have command */
1057 qla_printk(KERN_INFO, to_qla_host(cmd->device->host),
1058 "qla2xxx_eh_abort: cmd already done sp=%p\n", sp);
1059 DEBUG(printk("qla2xxx_eh_abort: cmd already done sp=%p\n", sp);)
1060 return SUCCESS;
1061 }
1062 if (sp) {
1063 DEBUG(printk("qla2xxx_eh_abort: refcount %i \n",
1064 atomic_read(&sp->ref_count));)
1065 }
1066
1067 vis_ha = (scsi_qla_host_t *) cmd->device->host->hostdata;
1068 ha = (scsi_qla_host_t *)cmd->device->host->hostdata;
1069
1070 host = ha->host;
1071
1072 /* Generate LU queue on bus, target, LUN */
1073 b = cmd->device->channel;
1074 t = cmd->device->id;
1075 l = cmd->device->lun;
1076 q = GET_LU_Q(vis_ha, t, l);
1077
1078 qla_printk(KERN_INFO, ha,
1079 "%s scsi(%ld:%d:%d:%d): cmd_timeout_in_sec=0x%x.\n", __func__,
1080 ha->host_no, (int)b, (int)t, (int)l,
1081 cmd->timeout_per_command / HZ);
1082
1083 /*
1084 * if no LUN queue then something is very wrong!!!
1085 */
1086 if (q == NULL) {
1087 qla_printk(KERN_WARNING, ha,
1088 "qla2x00: (%x:%x:%x) No LUN queue.\n", b, t, l);
1089
1090 /* no action - we don't have command */
1091 return FAILED;
1092 }
1093
1094 DEBUG2(printk("scsi(%ld): ABORTing cmd=%p sp=%p jiffies = 0x%lx, "
1095 "timeout=%x, dpc_flags=%lx, vis_ha->dpc_flags=%lx q->flag=%lx\n",
1096 ha->host_no, cmd, sp, jiffies, cmd->timeout_per_command / HZ,
1097 ha->dpc_flags, vis_ha->dpc_flags, q->q_flag));
1098 DEBUG2(qla2x00_print_scsi_cmd(cmd));
1099
1100 spin_unlock_irq(ha->host->host_lock);
1101 if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) {
1102 DEBUG2(printk("%s failed:board disabled\n", __func__);)
1103 spin_lock_irq(ha->host->host_lock);
1104 return FAILED;
1105 }
1106 spin_lock_irq(ha->host->host_lock);
1107
1108 /* Search done queue */
1109 spin_lock(&ha->list_lock);
1110 list_for_each_safe(list, temp, &ha->done_queue) {
1111 rp = list_entry(list, srb_t, list);
1112
1113 if (cmd != rp->cmd)
1114 continue;
1115
1116 /*
1117 * Found command.Remove it from done list.
1118 * And proceed to post completion to scsi mid layer.
1119 */
1120 return_status = SUCCESS;
1121 found++;
1122 qla2x00_delete_from_done_queue(ha, sp);
1123
1124 break;
1125 } /* list_for_each_safe() */
1126 spin_unlock(&ha->list_lock);
1127
1128 /*
1129 * Return immediately if the aborted command was already in the done
1130 * queue
1131 */
1132 if (found) {
1133 qla_printk(KERN_INFO, ha,
1134 "qla2xxx_eh_abort: Returning completed command=%p sp=%p\n",
1135 cmd, sp);
1136 sp_put(ha, sp);
1137 return (return_status);
1138 }
1139
1140
1141 /*
1142 * See if this command is in the retry queue
1143 */
1144 DEBUG3(printk("qla2xxx_eh_abort: searching sp %p in retry "
1145 "queue.\n", sp);)
1146
1147 spin_lock(&ha->list_lock);
1148 list_for_each_safe(list, temp, &ha->retry_queue) {
1149 rp = list_entry(list, srb_t, list);
1150
1151 if (cmd != rp->cmd)
1152 continue;
1153
1154
1155 DEBUG2(printk("qla2xxx_eh_abort: found "
1156 "in retry queue. SP=%p\n", sp);)
1157
1158 __del_from_retry_queue(ha, rp);
1159 cmd->result = DID_ABORT << 16;
1160 __add_to_done_queue(ha, rp);
1161
1162 return_status = SUCCESS;
1163 found++;
1164
1165 break;
1166
1167 }
1168 spin_unlock(&ha->list_lock);
1169
1170
1171 /*
1172 * Our SP pointer points at the command we want to remove from the
1173 * pending queue providing we haven't already sent it to the adapter.
1174 */
1175 if (!found) {
1176 DEBUG3(printk("qla2xxx_eh_abort: searching sp %p "
1177 "in pending queue.\n", sp);)
1178
1179 spin_lock(&vis_ha->list_lock);
1180 list_for_each_safe(list, temp, &vis_ha->pending_queue) {
1181 rp = list_entry(list, srb_t, list);
1182
1183 if (rp->cmd != cmd)
1184 continue;
1185
1186 /* Remove srb from LUN queue. */
1187 rp->flags |= SRB_ABORTED;
1188
1189 DEBUG2(printk("qla2xxx_eh_abort: Cmd in pending queue."
1190 " serial_number %ld.\n",
1191 sp->cmd->serial_number);)
1192
1193 __del_from_pending_queue(vis_ha, rp);
1194 cmd->result = DID_ABORT << 16;
1195
1196 __add_to_done_queue(vis_ha, rp);
1197
1198 return_status = SUCCESS;
1199
1200 found++;
1201 break;
1202 } /* list_for_each_safe() */
1203 spin_unlock(&vis_ha->list_lock);
1204 } /*End of if !found */
1205
1206 if (!found) { /* find the command in our active list */
1207 DEBUG3(printk("qla2xxx_eh_abort: searching sp %p "
1208 "in outstanding queue.\n", sp);)
1209
1210 spin_lock(&ha->hardware_lock);
1211 for (i = 1; i < MAX_OUTSTANDING_COMMANDS; i++) {
1212 sp = ha->outstanding_cmds[i];
1213
1214 if (sp == NULL)
1215 continue;
1216
1217 if (sp->cmd != cmd)
1218 continue;
1219
1220 DEBUG2(printk("qla2xxx_eh_abort(%ld): aborting sp %p "
1221 "from RISC. pid=%ld sp->state=%x q->q_flag=%lx\n",
1222 ha->host_no, sp, sp->cmd->serial_number,
1223 sp->state, q->q_flag);)
1224 DEBUG(qla2x00_print_scsi_cmd(cmd);)
1225
1226 /* Get a reference to the sp and drop the lock.*/
1227 sp_get(ha, sp);
1228
1229 spin_unlock(&ha->hardware_lock);
1230 spin_unlock_irq(ha->host->host_lock);
1231
1232 if (qla2x00_abort_command(ha, sp)) {
1233 DEBUG2(printk("qla2xxx_eh_abort: abort_command "
1234 "mbx failed.\n");)
1235 return_status = FAILED;
1236 } else {
1237 DEBUG3(printk("qla2xxx_eh_abort: abort_command "
1238 " mbx success.\n");)
1239 return_status = SUCCESS;
1240 }
1241
1242 sp_put(ha,sp);
1243
1244 spin_lock_irq(ha->host->host_lock);
1245 spin_lock(&ha->hardware_lock);
1246
1247 /*
1248 * Regardless of mailbox command status, go check on
1249 * done queue just in case the sp is already done.
1250 */
1251 break;
1252
1253 }/*End of for loop */
1254 spin_unlock(&ha->hardware_lock);
1255
1256 } /*End of if !found */
1257
1258 /* Waiting for our command in done_queue to be returned to OS.*/
1259 if (qla2x00_eh_wait_on_command(ha, cmd) != 0) {
1260 DEBUG2(printk("qla2xxx_eh_abort: cmd returned back to OS.\n");)
1261 return_status = SUCCESS;
1262 }
1263
1264 if (return_status == FAILED) {
1265 qla_printk(KERN_INFO, ha,
1266 "qla2xxx_eh_abort Exiting: status=Failed\n");
1267 return FAILED;
1268 }
1269
1270 DEBUG2(printk("qla2xxx_eh_abort: Exiting. return_status=0x%x.\n",
1271 return_status));
1272
1273 return return_status;
1274}
1275
1276/**************************************************************************
1277* qla2x00_eh_wait_for_pending_target_commands
1278*
1279* Description:
1280* Waits for all the commands to come back from the specified target.
1281*
1282* Input:
1283* ha - pointer to scsi_qla_host structure.
1284* t - target
1285* Returns:
1286* Either SUCCESS or FAILED.
1287*
1288* Note:
1289**************************************************************************/
1290static int
1291qla2x00_eh_wait_for_pending_target_commands(scsi_qla_host_t *ha, unsigned int t)
1292{
1293 int cnt;
1294 int status;
1295 srb_t *sp;
1296 struct scsi_cmnd *cmd;
1297
1298 status = 0;
1299
1300 /*
1301 * Waiting for all commands for the designated target in the active
1302 * array
1303 */
1304 for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
1305 spin_lock(&ha->hardware_lock);
1306 sp = ha->outstanding_cmds[cnt];
1307 if (sp) {
1308 cmd = sp->cmd;
1309 spin_unlock(&ha->hardware_lock);
1310 if (cmd->device->id == t) {
1311 if (!qla2x00_eh_wait_on_command(ha, cmd)) {
1312 status = 1;
1313 break;
1314 }
1315 }
1316 }
1317 else {
1318 spin_unlock(&ha->hardware_lock);
1319 }
1320 }
1321 return (status);
1322}
1323
1324
1325/**************************************************************************
1326* qla2xxx_eh_device_reset
1327*
1328* Description:
1329* The device reset function will reset the target and abort any
1330* executing commands.
1331*
1332* NOTE: The use of SP is undefined within this context. Do *NOT*
1333* attempt to use this value, even if you determine it is
1334* non-null.
1335*
1336* Input:
1337* cmd = Linux SCSI command packet of the command that cause the
1338* bus device reset.
1339*
1340* Returns:
1341* SUCCESS/FAILURE (defined as macro in scsi.h).
1342*
1343**************************************************************************/
1344int
1345qla2xxx_eh_device_reset(struct scsi_cmnd *cmd)
1346{
1347 int return_status;
1348 unsigned int b, t, l;
1349 scsi_qla_host_t *ha;
1350 os_tgt_t *tq;
1351 os_lun_t *lq;
1352 fc_port_t *fcport_to_reset;
1353 srb_t *rp;
1354 struct list_head *list, *temp;
1355
1356 return_status = FAILED;
1357 if (cmd == NULL) {
1358 printk(KERN_INFO
1359 "%s(): **** SCSI mid-layer passing in NULL cmd\n",
1360 __func__);
1361
1362 return (return_status);
1363 }
1364
1365 b = cmd->device->channel;
1366 t = cmd->device->id;
1367 l = cmd->device->lun;
1368 ha = (scsi_qla_host_t *)cmd->device->host->hostdata;
1369
1370 tq = TGT_Q(ha, t);
1371 if (tq == NULL) {
1372 qla_printk(KERN_INFO, ha,
1373 "%s(): **** CMD derives a NULL TGT_Q\n", __func__);
1374
1375 return (return_status);
1376 }
1377 lq = (os_lun_t *)LUN_Q(ha, t, l);
1378 if (lq == NULL) {
1379 printk(KERN_INFO
1380 "%s(): **** CMD derives a NULL LUN_Q\n", __func__);
1381
1382 return (return_status);
1383 }
1384 fcport_to_reset = lq->fclun->fcport;
1385
1386 /* If we are coming in from the back-door, stall I/O until complete. */
1387 if (!cmd->device->host->eh_active)
1388 set_bit(TQF_SUSPENDED, &tq->flags);
1389
1390 qla_printk(KERN_INFO, ha,
1391 "scsi(%ld:%d:%d:%d): DEVICE RESET ISSUED.\n", ha->host_no, b, t, l);
1392
1393 DEBUG2(printk(KERN_INFO
1394 "scsi(%ld): DEVICE_RESET cmd=%p jiffies = 0x%lx, timeout=%x, "
1395 "dpc_flags=%lx, status=%x allowed=%d cmd.state=%x\n",
1396 ha->host_no, cmd, jiffies, cmd->timeout_per_command / HZ,
1397 ha->dpc_flags, cmd->result, cmd->allowed, cmd->state));
1398
1399 /* Clear commands from the retry queue. */
1400 spin_lock(&ha->list_lock);
1401 list_for_each_safe(list, temp, &ha->retry_queue) {
1402 rp = list_entry(list, srb_t, list);
1403
1404 if (t != rp->cmd->device->id)
1405 continue;
1406
1407 DEBUG2(printk(KERN_INFO
1408 "qla2xxx_eh_reset: found in retry queue. SP=%p\n", rp));
1409
1410 __del_from_retry_queue(ha, rp);
1411 rp->cmd->result = DID_RESET << 16;
1412 __add_to_done_queue(ha, rp);
1413 }
1414 spin_unlock(&ha->list_lock);
1415
1416 spin_unlock_irq(ha->host->host_lock);
1417
1418 if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) {
1419 DEBUG2(printk(KERN_INFO
1420 "%s failed:board disabled\n",__func__));
1421
1422 spin_lock_irq(ha->host->host_lock);
1423 goto eh_dev_reset_done;
1424 }
1425
1426 if (qla2x00_wait_for_loop_ready(ha) == QLA_SUCCESS) {
1427 if (qla2x00_device_reset(ha, fcport_to_reset) == 0) {
1428 return_status = SUCCESS;
1429 }
1430
1431#if defined(LOGOUT_AFTER_DEVICE_RESET)
1432 if (return_status == SUCCESS) {
1433 if (fcport_to_reset->flags & FC_FABRIC_DEVICE) {
1434 qla2x00_fabric_logout(ha,
1435 fcport_to_reset->loop_id);
1436 qla2x00_mark_device_lost(ha, fcport_to_reset);
1437 }
1438 }
1439#endif
1440 } else {
1441 DEBUG2(printk(KERN_INFO
1442 "%s failed: loop not ready\n",__func__);)
1443 }
1444
1445 spin_lock_irq(ha->host->host_lock);
1446
1447 if (return_status == FAILED) {
1448 DEBUG3(printk("%s(%ld): device reset failed\n",
1449 __func__, ha->host_no));
1450 qla_printk(KERN_INFO, ha, "%s: device reset failed\n",
1451 __func__);
1452
1453 goto eh_dev_reset_done;
1454 }
1455
1456 /*
1457 * If we are coming down the EH path, wait for all commands to
1458 * complete for the device.
1459 */
1460 if (cmd->device->host->eh_active) {
1461 if (qla2x00_eh_wait_for_pending_target_commands(ha, t))
1462 return_status = FAILED;
1463
1464 if (return_status == FAILED) {
1465 DEBUG3(printk("%s(%ld): failed while waiting for "
1466 "commands\n", __func__, ha->host_no));
1467 qla_printk(KERN_INFO, ha,
1468 "%s: failed while waiting for commands\n",
1469 __func__);
1470
1471 goto eh_dev_reset_done;
1472 }
1473 }
1474
1475 qla_printk(KERN_INFO, ha,
1476 "scsi(%ld:%d:%d:%d): DEVICE RESET SUCCEEDED.\n",
1477 ha->host_no, b, t, l);
1478
1479eh_dev_reset_done:
1480
1481 if (!cmd->device->host->eh_active)
1482 clear_bit(TQF_SUSPENDED, &tq->flags);
1483
1484 return (return_status);
1485}
1486
1487/**************************************************************************
1488* qla2x00_eh_wait_for_pending_commands
1489*
1490* Description:
1491* Waits for all the commands to come back from the specified host.
1492*
1493* Input:
1494* ha - pointer to scsi_qla_host structure.
1495*
1496* Returns:
1497* 1 : SUCCESS
1498* 0 : FAILED
1499*
1500* Note:
1501**************************************************************************/
1502static int
1503qla2x00_eh_wait_for_pending_commands(scsi_qla_host_t *ha)
1504{
1505 int cnt;
1506 int status;
1507 srb_t *sp;
1508 struct scsi_cmnd *cmd;
1509
1510 status = 1;
1511
1512 /*
1513 * Waiting for all commands for the designated target in the active
1514 * array
1515 */
1516 for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
1517 spin_lock(&ha->hardware_lock);
1518 sp = ha->outstanding_cmds[cnt];
1519 if (sp) {
1520 cmd = sp->cmd;
1521 spin_unlock(&ha->hardware_lock);
1522 status = qla2x00_eh_wait_on_command(ha, cmd);
1523 if (status == 0)
1524 break;
1525 }
1526 else {
1527 spin_unlock(&ha->hardware_lock);
1528 }
1529 }
1530 return (status);
1531}
1532
1533
1534/**************************************************************************
1535* qla2xxx_eh_bus_reset
1536*
1537* Description:
1538* The bus reset function will reset the bus and abort any executing
1539* commands.
1540*
1541* Input:
1542* cmd = Linux SCSI command packet of the command that cause the
1543* bus reset.
1544*
1545* Returns:
1546* SUCCESS/FAILURE (defined as macro in scsi.h).
1547*
1548**************************************************************************/
1549int
1550qla2xxx_eh_bus_reset(struct scsi_cmnd *cmd)
1551{
1552 scsi_qla_host_t *ha;
1553 srb_t *sp;
1554 int rval = FAILED;
1555
1556 ha = (scsi_qla_host_t *) cmd->device->host->hostdata;
1557 sp = (srb_t *) CMD_SP(cmd);
1558
1559 qla_printk(KERN_INFO, ha,
1560 "scsi(%ld:%d:%d:%d): LOOP RESET ISSUED.\n", ha->host_no,
1561 cmd->device->channel, cmd->device->id, cmd->device->lun);
1562
1563 spin_unlock_irq(ha->host->host_lock);
1564
1565 if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS) {
1566 DEBUG2(printk("%s failed:board disabled\n",__func__));
1567 spin_lock_irq(ha->host->host_lock);
1568 return FAILED;
1569 }
1570
1571 if (qla2x00_wait_for_loop_ready(ha) == QLA_SUCCESS) {
1572 if (qla2x00_loop_reset(ha) == QLA_SUCCESS)
1573 rval = SUCCESS;
1574 }
1575
1576 spin_lock_irq(ha->host->host_lock);
1577 if (rval == FAILED)
1578 goto out;
1579
1580 /* Waiting for our command in done_queue to be returned to OS.*/
1581 if (cmd->device->host->eh_active)
1582 if (!qla2x00_eh_wait_for_pending_commands(ha))
1583 rval = FAILED;
1584
1585 out:
1586 qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__,
1587 (rval == FAILED) ? "failed" : "succeded");
1588
1589 return rval;
1590}
1591
1592/**************************************************************************
1593* qla2xxx_eh_host_reset
1594*
1595* Description:
1596* The reset function will reset the Adapter.
1597*
1598* Input:
1599* cmd = Linux SCSI command packet of the command that cause the
1600* adapter reset.
1601*
1602* Returns:
1603* Either SUCCESS or FAILED.
1604*
1605* Note:
1606**************************************************************************/
1607int
1608qla2xxx_eh_host_reset(struct scsi_cmnd *cmd)
1609{
1610 scsi_qla_host_t *ha = (scsi_qla_host_t *)cmd->device->host->hostdata;
1611 int rval = SUCCESS;
1612
1613 /* Display which one we're actually resetting for debug. */
1614 DEBUG(printk("qla2xxx_eh_host_reset:Resetting scsi(%ld).\n",
1615 ha->host_no));
1616
1617 /*
1618 * Now issue reset.
1619 */
1620 qla_printk(KERN_INFO, ha,
1621 "scsi(%ld:%d:%d:%d): ADAPTER RESET issued.\n", ha->host_no,
1622 cmd->device->channel, cmd->device->id, cmd->device->lun);
1623
1624 spin_unlock_irq(ha->host->host_lock);
1625
1626 if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS)
1627 goto board_disabled;
1628
1629 /*
1630 * Fixme-may be dpc thread is active and processing
1631 * loop_resync,so wait a while for it to
1632 * be completed and then issue big hammer.Otherwise
1633 * it may cause I/O failure as big hammer marks the
1634 * devices as lost kicking of the port_down_timer
1635 * while dpc is stuck for the mailbox to complete.
1636 */
1637 /* Blocking call-Does context switching if loop is Not Ready */
1638 qla2x00_wait_for_loop_ready(ha);
1639 set_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
1640 if (qla2x00_abort_isp(ha)) {
1641 clear_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
1642 /* failed. schedule dpc to try */
1643 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
1644
1645 if (qla2x00_wait_for_hba_online(ha) != QLA_SUCCESS)
1646 goto board_disabled;
1647 }
1648
1649 clear_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
1650
1651 spin_lock_irq(ha->host->host_lock);
1652 if (rval == FAILED)
1653 goto out;
1654
1655 /* Waiting for our command in done_queue to be returned to OS.*/
1656 if (!qla2x00_eh_wait_for_pending_commands(ha))
1657 rval = FAILED;
1658
1659 out:
1660 qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__,
1661 (rval == FAILED) ? "failed" : "succeded");
1662
1663 return rval;
1664
1665 board_disabled:
1666 spin_lock_irq(ha->host->host_lock);
1667
1668 qla_printk(KERN_INFO, ha, "%s: failed:board disabled\n", __func__);
1669 return FAILED;
1670}
1671
1672
1673/*
1674* qla2x00_loop_reset
1675* Issue loop reset.
1676*
1677* Input:
1678* ha = adapter block pointer.
1679*
1680* Returns:
1681* 0 = success
1682*/
1683static int
1684qla2x00_loop_reset(scsi_qla_host_t *ha)
1685{
1686 int status = QLA_SUCCESS;
1687 uint16_t t;
1688 os_tgt_t *tq;
1689
1690 if (ha->flags.enable_lip_reset) {
1691 status = qla2x00_lip_reset(ha);
1692 }
1693
1694 if (status == QLA_SUCCESS && ha->flags.enable_target_reset) {
1695 for (t = 0; t < MAX_FIBRE_DEVICES; t++) {
1696 if ((tq = TGT_Q(ha, t)) == NULL)
1697 continue;
1698
1699 if (tq->fcport == NULL)
1700 continue;
1701
1702 status = qla2x00_target_reset(ha, 0, t);
1703 if (status != QLA_SUCCESS) {
1704 break;
1705 }
1706 }
1707 }
1708
1709 if (status == QLA_SUCCESS &&
1710 ((!ha->flags.enable_target_reset &&
1711 !ha->flags.enable_lip_reset) ||
1712 ha->flags.enable_lip_full_login)) {
1713
1714 status = qla2x00_full_login_lip(ha);
1715 }
1716
1717 /* Issue marker command only when we are going to start the I/O */
1718 ha->marker_needed = 1;
1719
1720 if (status) {
1721 /* Empty */
1722 DEBUG2_3(printk("%s(%ld): **** FAILED ****\n",
1723 __func__,
1724 ha->host_no);)
1725 } else {
1726 /* Empty */
1727 DEBUG3(printk("%s(%ld): exiting normally.\n",
1728 __func__,
1729 ha->host_no);)
1730 }
1731
1732 return(status);
1733}
1734
1735/*
1736 * qla2x00_device_reset
1737 * Issue bus device reset message to the target.
1738 *
1739 * Input:
1740 * ha = adapter block pointer.
1741 * t = SCSI ID.
1742 * TARGET_QUEUE_LOCK must be released.
1743 * ADAPTER_STATE_LOCK must be released.
1744 *
1745 * Context:
1746 * Kernel context.
1747 */
1748static int
1749qla2x00_device_reset(scsi_qla_host_t *ha, fc_port_t *reset_fcport)
1750{
1751 /* Abort Target command will clear Reservation */
1752 return qla2x00_abort_target(reset_fcport);
1753}
1754
1755/**************************************************************************
1756* qla2xxx_slave_configure
1757*
1758* Description:
1759**************************************************************************/
1760int
1761qla2xxx_slave_configure(struct scsi_device *sdev)
1762{
1763 scsi_qla_host_t *ha = to_qla_host(sdev->host);
1764 int queue_depth;
1765
1766 if (IS_QLA2100(ha) || IS_QLA2200(ha))
1767 queue_depth = 16;
1768 else
1769 queue_depth = 32;
1770
1771 if (sdev->tagged_supported) {
1772 if (ql2xmaxqdepth != 0 && ql2xmaxqdepth <= 0xffffU)
1773 queue_depth = ql2xmaxqdepth;
1774
1775 ql2xmaxqdepth = queue_depth;
1776
1777 scsi_activate_tcq(sdev, queue_depth);
1778
1779 qla_printk(KERN_INFO, ha,
1780 "scsi(%d:%d:%d:%d): Enabled tagged queuing, queue "
1781 "depth %d.\n",
1782 sdev->host->host_no, sdev->channel, sdev->id, sdev->lun,
1783 sdev->queue_depth);
1784 } else {
1785 scsi_adjust_queue_depth(sdev, 0 /* TCQ off */,
1786 sdev->host->hostt->cmd_per_lun /* 3 */);
1787 }
1788
1789 return (0);
1790}
1791
1792/**
1793 * qla2x00_config_dma_addressing() - Configure OS DMA addressing method.
1794 * @ha: HA context
1795 *
1796 * At exit, the @ha's flags.enable_64bit_addressing set to indicated
1797 * supported addressing method.
1798 */
1799static void
1800qla2x00_config_dma_addressing(scsi_qla_host_t *ha)
1801{
1802 /* Assume 32bit DMA address */
1803 ha->flags.enable_64bit_addressing = 0;
1804 ha->calc_request_entries = qla2x00_calc_iocbs_32;
1805 ha->build_scsi_iocbs = qla2x00_build_scsi_iocbs_32;
1806
1807 /*
1808 * Given the two variants pci_set_dma_mask(), allow the compiler to
1809 * assist in setting the proper dma mask.
1810 */
1811 if (sizeof(dma_addr_t) > 4) {
1812 if (pci_set_dma_mask(ha->pdev, DMA_64BIT_MASK) == 0) {
1813 ha->flags.enable_64bit_addressing = 1;
1814 ha->calc_request_entries = qla2x00_calc_iocbs_64;
1815 ha->build_scsi_iocbs = qla2x00_build_scsi_iocbs_64;
1816
1817 if (pci_set_consistent_dma_mask(ha->pdev,
1818 DMA_64BIT_MASK)) {
1819 qla_printk(KERN_DEBUG, ha,
1820 "Failed to set 64 bit PCI consistent mask; "
1821 "using 32 bit.\n");
1822 pci_set_consistent_dma_mask(ha->pdev,
1823 DMA_32BIT_MASK);
1824 }
1825 } else {
1826 qla_printk(KERN_DEBUG, ha,
1827 "Failed to set 64 bit PCI DMA mask, falling back "
1828 "to 32 bit MASK.\n");
1829 pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK);
1830 }
1831 } else {
1832 pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK);
1833 }
1834}
1835
1836static int
1837qla2x00_iospace_config(scsi_qla_host_t *ha)
1838{
1839 unsigned long pio, pio_len, pio_flags;
1840 unsigned long mmio, mmio_len, mmio_flags;
1841
1842 /* We only need PIO for Flash operations on ISP2312 v2 chips. */
1843 pio = pci_resource_start(ha->pdev, 0);
1844 pio_len = pci_resource_len(ha->pdev, 0);
1845 pio_flags = pci_resource_flags(ha->pdev, 0);
1846 if (pio_flags & IORESOURCE_IO) {
1847 if (pio_len < MIN_IOBASE_LEN) {
1848 qla_printk(KERN_WARNING, ha,
1849 "Invalid PCI I/O region size (%s)...\n",
1850 pci_name(ha->pdev));
1851 pio = 0;
1852 }
1853 } else {
1854 qla_printk(KERN_WARNING, ha,
1855 "region #0 not a PIO resource (%s)...\n",
1856 pci_name(ha->pdev));
1857 pio = 0;
1858 }
1859
1860 /* Use MMIO operations for all accesses. */
1861 mmio = pci_resource_start(ha->pdev, 1);
1862 mmio_len = pci_resource_len(ha->pdev, 1);
1863 mmio_flags = pci_resource_flags(ha->pdev, 1);
1864
1865 if (!(mmio_flags & IORESOURCE_MEM)) {
1866 qla_printk(KERN_ERR, ha,
1867 "region #0 not an MMIO resource (%s), aborting\n",
1868 pci_name(ha->pdev));
1869 goto iospace_error_exit;
1870 }
1871 if (mmio_len < MIN_IOBASE_LEN) {
1872 qla_printk(KERN_ERR, ha,
1873 "Invalid PCI mem region size (%s), aborting\n",
1874 pci_name(ha->pdev));
1875 goto iospace_error_exit;
1876 }
1877
1878 if (pci_request_regions(ha->pdev, ha->brd_info->drv_name)) {
1879 qla_printk(KERN_WARNING, ha,
1880 "Failed to reserve PIO/MMIO regions (%s)\n",
1881 pci_name(ha->pdev));
1882
1883 goto iospace_error_exit;
1884 }
1885
1886 ha->pio_address = pio;
1887 ha->pio_length = pio_len;
1888 ha->iobase = ioremap(mmio, MIN_IOBASE_LEN);
1889 if (!ha->iobase) {
1890 qla_printk(KERN_ERR, ha,
1891 "cannot remap MMIO (%s), aborting\n", pci_name(ha->pdev));
1892
1893 goto iospace_error_exit;
1894 }
1895
1896 return (0);
1897
1898iospace_error_exit:
1899 return (-ENOMEM);
1900}
1901
1902/*
1903 * PCI driver interface
1904 */
1905int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info)
1906{
1907 int ret;
1908 device_reg_t __iomem *reg;
1909 struct Scsi_Host *host;
1910 scsi_qla_host_t *ha;
1911 unsigned long flags = 0;
1912 unsigned long wait_switch = 0;
1913 char pci_info[20];
1914 char fw_str[30];
1915
1916 if (pci_enable_device(pdev))
1917 return -1;
1918
1919 host = scsi_host_alloc(&qla2x00_driver_template,
1920 sizeof(scsi_qla_host_t));
1921 if (host == NULL) {
1922 printk(KERN_WARNING
1923 "qla2xxx: Couldn't allocate host from scsi layer!\n");
1924 goto probe_disable_device;
1925 }
1926
1927 /* Clear our data area */
1928 ha = (scsi_qla_host_t *)host->hostdata;
1929 memset(ha, 0, sizeof(scsi_qla_host_t));
1930
1931 ha->pdev = pdev;
1932 ha->host = host;
1933 ha->host_no = host->host_no;
1934 ha->brd_info = brd_info;
1935 sprintf(ha->host_str, "%s_%ld", ha->brd_info->drv_name, ha->host_no);
1936
1937 /* Configure PCI I/O space */
1938 ret = qla2x00_iospace_config(ha);
1939 if (ret != 0) {
1940 goto probe_failed;
1941 }
1942
1943 /* Sanitize the information from PCI BIOS. */
1944 host->irq = pdev->irq;
1945
1946 qla_printk(KERN_INFO, ha,
1947 "Found an %s, irq %d, iobase 0x%p\n", ha->brd_info->isp_name,
1948 host->irq, ha->iobase);
1949
1950 spin_lock_init(&ha->hardware_lock);
1951
1952 /* 4.23 Initialize /proc/scsi/qla2x00 counters */
1953 ha->actthreads = 0;
1954 ha->qthreads = 0;
1955 ha->total_isr_cnt = 0;
1956 ha->total_isp_aborts = 0;
1957 ha->total_lip_cnt = 0;
1958 ha->total_dev_errs = 0;
1959 ha->total_ios = 0;
1960 ha->total_bytes = 0;
1961
1962 ha->prev_topology = 0;
1963 ha->ports = MAX_BUSES;
1964
1965 if (IS_QLA2100(ha)) {
1966 ha->max_targets = MAX_TARGETS_2100;
1967 ha->mbx_count = MAILBOX_REGISTER_COUNT_2100;
1968 ha->request_q_length = REQUEST_ENTRY_CNT_2100;
1969 ha->response_q_length = RESPONSE_ENTRY_CNT_2100;
1970 ha->last_loop_id = SNS_LAST_LOOP_ID_2100;
1971 host->sg_tablesize = 32;
1972 } else if (IS_QLA2200(ha)) {
1973 ha->max_targets = MAX_TARGETS_2200;
1974 ha->mbx_count = MAILBOX_REGISTER_COUNT;
1975 ha->request_q_length = REQUEST_ENTRY_CNT_2200;
1976 ha->response_q_length = RESPONSE_ENTRY_CNT_2100;
1977 ha->last_loop_id = SNS_LAST_LOOP_ID_2100;
1978 } else /*if (IS_QLA2300(ha))*/ {
1979 ha->max_targets = MAX_TARGETS_2200;
1980 ha->mbx_count = MAILBOX_REGISTER_COUNT;
1981 ha->request_q_length = REQUEST_ENTRY_CNT_2200;
1982 ha->response_q_length = RESPONSE_ENTRY_CNT_2300;
1983 ha->last_loop_id = SNS_LAST_LOOP_ID_2300;
1984 }
1985 host->can_queue = ha->request_q_length + 128;
1986
1987 /* load the F/W, read paramaters, and init the H/W */
1988 ha->instance = num_hosts;
1989
1990 init_MUTEX(&ha->mbx_cmd_sem);
1991 init_MUTEX_LOCKED(&ha->mbx_intr_sem);
1992
1993 INIT_LIST_HEAD(&ha->list);
1994 INIT_LIST_HEAD(&ha->fcports);
1995 INIT_LIST_HEAD(&ha->rscn_fcports);
1996 INIT_LIST_HEAD(&ha->done_queue);
1997 INIT_LIST_HEAD(&ha->retry_queue);
1998 INIT_LIST_HEAD(&ha->scsi_retry_queue);
1999 INIT_LIST_HEAD(&ha->pending_queue);
2000
2001 /*
2002 * These locks are used to prevent more than one CPU
2003 * from modifying the queue at the same time. The
2004 * higher level "host_lock" will reduce most
2005 * contention for these locks.
2006 */
2007 spin_lock_init(&ha->mbx_reg_lock);
2008 spin_lock_init(&ha->list_lock);
2009
2010 ha->dpc_pid = -1;
2011 init_completion(&ha->dpc_inited);
2012 init_completion(&ha->dpc_exited);
2013
2014 qla2x00_config_dma_addressing(ha);
2015 if (qla2x00_mem_alloc(ha)) {
2016 qla_printk(KERN_WARNING, ha,
2017 "[ERROR] Failed to allocate memory for adapter\n");
2018
2019 goto probe_failed;
2020 }
2021
2022 if (qla2x00_initialize_adapter(ha) &&
2023 !(ha->device_flags & DFLG_NO_CABLE)) {
2024
2025 qla_printk(KERN_WARNING, ha,
2026 "Failed to initialize adapter\n");
2027
2028 DEBUG2(printk("scsi(%ld): Failed to initialize adapter - "
2029 "Adapter flags %x.\n",
2030 ha->host_no, ha->device_flags));
2031
2032 goto probe_failed;
2033 }
2034
2035 /*
2036 * Startup the kernel thread for this host adapter
2037 */
2038 ha->dpc_should_die = 0;
2039 ha->dpc_pid = kernel_thread(qla2x00_do_dpc, ha, 0);
2040 if (ha->dpc_pid < 0) {
2041 qla_printk(KERN_WARNING, ha,
2042 "Unable to start DPC thread!\n");
2043
2044 goto probe_failed;
2045 }
2046 wait_for_completion(&ha->dpc_inited);
2047
2048 host->this_id = 255;
2049 host->cmd_per_lun = 3;
2050 host->max_cmd_len = MAX_CMDSZ;
2051 host->max_channel = ha->ports - 1;
2052 host->max_lun = ha->max_luns;
2053 BUG_ON(qla2xxx_transport_template == NULL);
2054 host->transportt = qla2xxx_transport_template;
2055 host->unique_id = ha->instance;
2056 host->max_id = ha->max_targets;
2057
2058 if (IS_QLA2100(ha) || IS_QLA2200(ha))
2059 ret = request_irq(host->irq, qla2100_intr_handler,
2060 SA_INTERRUPT|SA_SHIRQ, ha->brd_info->drv_name, ha);
2061 else
2062 ret = request_irq(host->irq, qla2300_intr_handler,
2063 SA_INTERRUPT|SA_SHIRQ, ha->brd_info->drv_name, ha);
2064 if (ret != 0) {
2065 qla_printk(KERN_WARNING, ha,
2066 "Failed to reserve interrupt %d already in use.\n",
2067 host->irq);
2068 goto probe_failed;
2069 }
2070
2071 /* Initialized the timer */
2072 qla2x00_start_timer(ha, qla2x00_timer, WATCH_INTERVAL);
2073
2074 DEBUG2(printk("DEBUG: detect hba %ld at address = %p\n",
2075 ha->host_no, ha));
2076
2077 reg = ha->iobase;
2078
2079 /* Disable ISP interrupts. */
2080 qla2x00_disable_intrs(ha);
2081
2082 /* Ensure mailbox registers are free. */
2083 spin_lock_irqsave(&ha->hardware_lock, flags);
2084 WRT_REG_WORD(&reg->semaphore, 0);
2085 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
2086 WRT_REG_WORD(&reg->hccr, HCCR_CLR_HOST_INT);
2087
2088 /* Enable proper parity */
2089 if (!IS_QLA2100(ha) && !IS_QLA2200(ha)) {
2090 if (IS_QLA2300(ha))
2091 /* SRAM parity */
2092 WRT_REG_WORD(&reg->hccr, (HCCR_ENABLE_PARITY + 0x1));
2093 else
2094 /* SRAM, Instruction RAM and GP RAM parity */
2095 WRT_REG_WORD(&reg->hccr, (HCCR_ENABLE_PARITY + 0x7));
2096 }
2097 spin_unlock_irqrestore(&ha->hardware_lock, flags);
2098
2099 /* Enable chip interrupts. */
2100 qla2x00_enable_intrs(ha);
2101
2102 /* v2.19.5b6 */
2103 /*
2104 * Wait around max loop_reset_delay secs for the devices to come
2105 * on-line. We don't want Linux scanning before we are ready.
2106 *
2107 */
2108 for (wait_switch = jiffies + (ha->loop_reset_delay * HZ);
2109 time_before(jiffies,wait_switch) &&
2110 !(ha->device_flags & (DFLG_NO_CABLE | DFLG_FABRIC_DEVICES))
2111 && (ha->device_flags & SWITCH_FOUND) ;) {
2112
2113 qla2x00_check_fabric_devices(ha);
2114
2115 msleep(10);
2116 }
2117
2118 pci_set_drvdata(pdev, ha);
2119 ha->flags.init_done = 1;
2120 num_hosts++;
2121
2122 /* List the target we have found */
2123 if (displayConfig) {
2124 qla2x00_display_fc_names(ha);
2125 }
2126
2127 if (scsi_add_host(host, &pdev->dev))
2128 goto probe_failed;
2129
2130 sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_fw_dump_attr);
2131 sysfs_create_bin_file(&host->shost_gendev.kobj, &sysfs_nvram_attr);
2132
2133 qla_printk(KERN_INFO, ha, "\n"
2134 " QLogic Fibre Channel HBA Driver: %s\n"
2135 " QLogic %s - %s\n"
2136 " %s: %s @ %s hdma%c, host#=%ld, fw=%s\n", qla2x00_version_str,
2137 ha->model_number, ha->model_desc ? ha->model_desc: "",
2138 ha->brd_info->isp_name, qla2x00_get_pci_info_str(ha, pci_info),
2139 pci_name(ha->pdev), ha->flags.enable_64bit_addressing ? '+': '-',
2140 ha->host_no, qla2x00_get_fw_version_str(ha, fw_str));
2141
2142 if (ql2xdoinitscan)
2143 scsi_scan_host(host);
2144
2145 return 0;
2146
2147probe_failed:
2148 qla2x00_free_device(ha);
2149
2150 scsi_host_put(host);
2151
2152probe_disable_device:
2153 pci_disable_device(pdev);
2154
2155 return -1;
2156}
2157EXPORT_SYMBOL_GPL(qla2x00_probe_one);
2158
2159void qla2x00_remove_one(struct pci_dev *pdev)
2160{
2161 scsi_qla_host_t *ha;
2162
2163 ha = pci_get_drvdata(pdev);
2164
2165 sysfs_remove_bin_file(&ha->host->shost_gendev.kobj,
2166 &sysfs_fw_dump_attr);
2167 sysfs_remove_bin_file(&ha->host->shost_gendev.kobj, &sysfs_nvram_attr);
2168
2169 scsi_remove_host(ha->host);
2170
2171 qla2x00_free_device(ha);
2172
2173 scsi_host_put(ha->host);
2174
2175 pci_set_drvdata(pdev, NULL);
2176}
2177EXPORT_SYMBOL_GPL(qla2x00_remove_one);
2178
2179static void
2180qla2x00_free_device(scsi_qla_host_t *ha)
2181{
2182 int ret;
2183
2184 /* Abort any outstanding IO descriptors. */
2185 if (!IS_QLA2100(ha) && !IS_QLA2200(ha))
2186 qla2x00_cancel_io_descriptors(ha);
2187
2188 /* turn-off interrupts on the card */
2189 if (ha->interrupts_on)
2190 qla2x00_disable_intrs(ha);
2191
2192 /* Disable timer */
2193 if (ha->timer_active)
2194 qla2x00_stop_timer(ha);
2195
2196 /* Kill the kernel thread for this host */
2197 if (ha->dpc_pid >= 0) {
2198 ha->dpc_should_die = 1;
2199 wmb();
2200 ret = kill_proc(ha->dpc_pid, SIGHUP, 1);
2201 if (ret) {
2202 qla_printk(KERN_ERR, ha,
2203 "Unable to signal DPC thread -- (%d)\n", ret);
2204
2205 /* TODO: SOMETHING MORE??? */
2206 } else {
2207 wait_for_completion(&ha->dpc_exited);
2208 }
2209 }
2210
2211 qla2x00_mem_free(ha);
2212
2213
2214 ha->flags.online = 0;
2215
2216 /* Detach interrupts */
2217 if (ha->pdev->irq)
2218 free_irq(ha->pdev->irq, ha);
2219
2220 /* release io space registers */
2221 if (ha->iobase)
2222 iounmap(ha->iobase);
2223 pci_release_regions(ha->pdev);
2224
2225 pci_disable_device(ha->pdev);
2226}
2227
2228
2229/*
2230 * The following support functions are adopted to handle
2231 * the re-entrant qla2x00_proc_info correctly.
2232 */
2233static void
2234copy_mem_info(struct info_str *info, char *data, int len)
2235{
2236 if (info->pos + len > info->offset + info->length)
2237 len = info->offset + info->length - info->pos;
2238
2239 if (info->pos + len < info->offset) {
2240 info->pos += len;
2241 return;
2242 }
2243
2244 if (info->pos < info->offset) {
2245 off_t partial;
2246
2247 partial = info->offset - info->pos;
2248 data += partial;
2249 info->pos += partial;
2250 len -= partial;
2251 }
2252
2253 if (len > 0) {
2254 memcpy(info->buffer, data, len);
2255 info->pos += len;
2256 info->buffer += len;
2257 }
2258}
2259
2260static int
2261copy_info(struct info_str *info, char *fmt, ...)
2262{
2263 va_list args;
2264 char buf[256];
2265 int len;
2266
2267 va_start(args, fmt);
2268 len = vsprintf(buf, fmt, args);
2269 va_end(args);
2270
2271 copy_mem_info(info, buf, len);
2272
2273 return (len);
2274}
2275
2276/*************************************************************************
2277* qla2x00_proc_info
2278*
2279* Description:
2280* Return information to handle /proc support for the driver.
2281*
2282* inout : decides the direction of the dataflow and the meaning of the
2283* variables
2284* buffer: If inout==0 data is being written to it else read from it
2285* (ptr to a page buffer)
2286* *start: If inout==0 start of the valid data in the buffer
2287* offset: If inout==0 starting offset from the beginning of all
2288* possible data to return.
2289* length: If inout==0 max number of bytes to be written into the buffer
2290* else number of bytes in "buffer"
2291* Returns:
2292* < 0: error. errno value.
2293* >= 0: sizeof data returned.
2294*************************************************************************/
2295int
2296qla2x00_proc_info(struct Scsi_Host *shost, char *buffer,
2297 char **start, off_t offset, int length, int inout)
2298{
2299 struct info_str info;
2300 int retval = -EINVAL;
2301 os_lun_t *up;
2302 os_tgt_t *tq;
2303 unsigned int t, l;
2304 uint32_t tmp_sn;
2305 uint32_t *flags;
2306 uint8_t *loop_state;
2307 scsi_qla_host_t *ha;
2308 char fw_info[30];
2309
2310 DEBUG3(printk(KERN_INFO
2311 "Entering proc_info buff_in=%p, offset=0x%lx, length=0x%x\n",
2312 buffer, offset, length);)
2313
2314 ha = (scsi_qla_host_t *) shost->hostdata;
2315
2316 if (inout) {
2317 /* Has data been written to the file? */
2318 DEBUG3(printk(
2319 "%s: has data been written to the file. \n",
2320 __func__);)
2321
2322 return -ENOSYS;
2323 }
2324
2325 if (start) {
2326 *start = buffer;
2327 }
2328
2329 info.buffer = buffer;
2330 info.length = length;
2331 info.offset = offset;
2332 info.pos = 0;
2333
2334 /* start building the print buffer */
2335 copy_info(&info,
2336 "QLogic PCI to Fibre Channel Host Adapter for %s:\n"
2337 " Firmware version %s, ",
2338 ha->model_number, qla2x00_get_fw_version_str(ha, fw_info));
2339
2340 copy_info(&info, "Driver version %s\n", qla2x00_version_str);
2341
2342 tmp_sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) |
2343 ha->serial1;
2344 copy_info(&info, "ISP: %s, Serial# %c%05d\n",
2345 ha->brd_info->isp_name, ('A' + tmp_sn/100000), (tmp_sn%100000));
2346
2347 copy_info(&info,
2348 "Request Queue = 0x%llx, Response Queue = 0x%llx\n",
2349 (unsigned long long)ha->request_dma,
2350 (unsigned long long)ha->response_dma);
2351
2352 copy_info(&info,
2353 "Request Queue count = %d, Response Queue count = %d\n",
2354 ha->request_q_length, ha->response_q_length);
2355
2356 copy_info(&info,
2357 "Total number of active commands = %ld\n",
2358 ha->actthreads);
2359
2360 copy_info(&info,
2361 "Total number of interrupts = %ld\n",
2362 (long)ha->total_isr_cnt);
2363
2364 copy_info(&info,
2365 " Device queue depth = 0x%x\n",
2366 (ql2xmaxqdepth == 0) ? 16 : ql2xmaxqdepth);
2367
2368 copy_info(&info,
2369 "Number of free request entries = %d\n", ha->req_q_cnt);
2370
2371 copy_info(&info,
2372 "Number of mailbox timeouts = %ld\n", ha->total_mbx_timeout);
2373
2374 copy_info(&info,
2375 "Number of ISP aborts = %ld\n", ha->total_isp_aborts);
2376
2377 copy_info(&info,
2378 "Number of loop resyncs = %ld\n", ha->total_loop_resync);
2379
2380 copy_info(&info,
2381 "Number of retries for empty slots = %ld\n",
2382 qla2x00_stats.outarray_full);
2383
2384 copy_info(&info,
2385 "Number of reqs in pending_q= %ld, retry_q= %d, "
2386 "done_q= %ld, scsi_retry_q= %d\n",
2387 ha->qthreads, ha->retry_q_cnt,
2388 ha->done_q_cnt, ha->scsi_retry_q_cnt);
2389
2390
2391 flags = (uint32_t *) &ha->flags;
2392
2393 if (atomic_read(&ha->loop_state) == LOOP_DOWN) {
2394 loop_state = "DOWN";
2395 } else if (atomic_read(&ha->loop_state) == LOOP_UP) {
2396 loop_state = "UP";
2397 } else if (atomic_read(&ha->loop_state) == LOOP_READY) {
2398 loop_state = "READY";
2399 } else if (atomic_read(&ha->loop_state) == LOOP_TIMEOUT) {
2400 loop_state = "TIMEOUT";
2401 } else if (atomic_read(&ha->loop_state) == LOOP_UPDATE) {
2402 loop_state = "UPDATE";
2403 } else {
2404 loop_state = "UNKNOWN";
2405 }
2406
2407 copy_info(&info,
2408 "Host adapter:loop state = <%s>, flags = 0x%lx\n",
2409 loop_state , *flags);
2410
2411 copy_info(&info, "Dpc flags = 0x%lx\n", ha->dpc_flags);
2412
2413 copy_info(&info, "MBX flags = 0x%x\n", ha->mbx_flags);
2414
2415 copy_info(&info, "Link down Timeout = %3.3d\n",
2416 ha->link_down_timeout);
2417
2418 copy_info(&info, "Port down retry = %3.3d\n",
2419 ha->port_down_retry_count);
2420
2421 copy_info(&info, "Login retry count = %3.3d\n",
2422 ha->login_retry_count);
2423
2424 copy_info(&info,
2425 "Commands retried with dropped frame(s) = %d\n",
2426 ha->dropped_frame_error_cnt);
2427
2428 copy_info(&info,
2429 "Product ID = %04x %04x %04x %04x\n", ha->product_id[0],
2430 ha->product_id[1], ha->product_id[2], ha->product_id[3]);
2431
2432 copy_info(&info, "\n");
2433
2434 /* 2.25 node/port display to proc */
2435 /* Display the node name for adapter */
2436 copy_info(&info, "\nSCSI Device Information:\n");
2437 copy_info(&info,
2438 "scsi-qla%d-adapter-node="
2439 "%02x%02x%02x%02x%02x%02x%02x%02x;\n",
2440 (int)ha->instance,
2441 ha->init_cb->node_name[0],
2442 ha->init_cb->node_name[1],
2443 ha->init_cb->node_name[2],
2444 ha->init_cb->node_name[3],
2445 ha->init_cb->node_name[4],
2446 ha->init_cb->node_name[5],
2447 ha->init_cb->node_name[6],
2448 ha->init_cb->node_name[7]);
2449
2450 /* display the port name for adapter */
2451 copy_info(&info,
2452 "scsi-qla%d-adapter-port="
2453 "%02x%02x%02x%02x%02x%02x%02x%02x;\n",
2454 (int)ha->instance,
2455 ha->init_cb->port_name[0],
2456 ha->init_cb->port_name[1],
2457 ha->init_cb->port_name[2],
2458 ha->init_cb->port_name[3],
2459 ha->init_cb->port_name[4],
2460 ha->init_cb->port_name[5],
2461 ha->init_cb->port_name[6],
2462 ha->init_cb->port_name[7]);
2463
2464 /* Print out device port names */
2465 for (t = 0; t < MAX_FIBRE_DEVICES; t++) {
2466 if ((tq = TGT_Q(ha, t)) == NULL)
2467 continue;
2468
2469 copy_info(&info,
2470 "scsi-qla%d-target-%d="
2471 "%02x%02x%02x%02x%02x%02x%02x%02x;\n",
2472 (int)ha->instance, t,
2473 tq->port_name[0], tq->port_name[1],
2474 tq->port_name[2], tq->port_name[3],
2475 tq->port_name[4], tq->port_name[5],
2476 tq->port_name[6], tq->port_name[7]);
2477 }
2478
2479 copy_info(&info, "\nSCSI LUN Information:\n");
2480 copy_info(&info,
2481 "(Id:Lun) * - indicates lun is not registered with the OS.\n");
2482
2483 /* scan for all equipment stats */
2484 for (t = 0; t < MAX_FIBRE_DEVICES; t++) {
2485 /* scan all luns */
2486 for (l = 0; l < ha->max_luns; l++) {
2487 up = (os_lun_t *) GET_LU_Q(ha, t, l);
2488
2489 if (up == NULL) {
2490 continue;
2491 }
2492 if (up->fclun == NULL) {
2493 continue;
2494 }
2495
2496 copy_info(&info,
2497 "(%2d:%2d): Total reqs %ld,",
2498 t,l,up->io_cnt);
2499
2500 copy_info(&info,
2501 " Pending reqs %ld,",
2502 up->out_cnt);
2503
2504 if (up->io_cnt < 4) {
2505 copy_info(&info,
2506 " flags 0x%x*,",
2507 (int)up->q_flag);
2508 } else {
2509 copy_info(&info,
2510 " flags 0x%x,",
2511 (int)up->q_flag);
2512 }
2513
2514 copy_info(&info,
2515 " %ld:%d:%02x %02x",
2516 up->fclun->fcport->ha->instance,
2517 up->fclun->fcport->cur_path,
2518 up->fclun->fcport->loop_id,
2519 up->fclun->device_type);
2520
2521 copy_info(&info, "\n");
2522
2523 if (info.pos >= info.offset + info.length) {
2524 /* No need to continue */
2525 goto profile_stop;
2526 }
2527 }
2528
2529 if (info.pos >= info.offset + info.length) {
2530 /* No need to continue */
2531 break;
2532 }
2533 }
2534
2535profile_stop:
2536
2537 retval = info.pos > info.offset ? info.pos - info.offset : 0;
2538
2539 DEBUG3(printk(KERN_INFO
2540 "Exiting proc_info: info.pos=%d, offset=0x%lx, "
2541 "length=0x%x\n", info.pos, offset, length);)
2542
2543 return (retval);
2544}
2545
2546/*
2547* qla2x00_display_fc_names
2548* This routine will the node names of the different devices found
2549* after port inquiry.
2550*
2551* Input:
2552* cmd = SCSI command structure
2553*
2554* Returns:
2555* None.
2556*/
2557static void
2558qla2x00_display_fc_names(scsi_qla_host_t *ha)
2559{
2560 uint16_t tgt;
2561 os_tgt_t *tq;
2562
2563 /* Display the node name for adapter */
2564 qla_printk(KERN_INFO, ha,
2565 "scsi-qla%d-adapter-node=%02x%02x%02x%02x%02x%02x%02x%02x\\;\n",
2566 (int)ha->instance,
2567 ha->init_cb->node_name[0],
2568 ha->init_cb->node_name[1],
2569 ha->init_cb->node_name[2],
2570 ha->init_cb->node_name[3],
2571 ha->init_cb->node_name[4],
2572 ha->init_cb->node_name[5],
2573 ha->init_cb->node_name[6],
2574 ha->init_cb->node_name[7]);
2575
2576 /* display the port name for adapter */
2577 qla_printk(KERN_INFO, ha,
2578 "scsi-qla%d-adapter-port=%02x%02x%02x%02x%02x%02x%02x%02x\\;\n",
2579 (int)ha->instance,
2580 ha->init_cb->port_name[0],
2581 ha->init_cb->port_name[1],
2582 ha->init_cb->port_name[2],
2583 ha->init_cb->port_name[3],
2584 ha->init_cb->port_name[4],
2585 ha->init_cb->port_name[5],
2586 ha->init_cb->port_name[6],
2587 ha->init_cb->port_name[7]);
2588
2589 /* Print out device port names */
2590 for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
2591 if ((tq = ha->otgt[tgt]) == NULL)
2592 continue;
2593
2594 if (tq->fcport == NULL)
2595 continue;
2596
2597 switch (ha->binding_type) {
2598 case BIND_BY_PORT_NAME:
2599 qla_printk(KERN_INFO, ha,
2600 "scsi-qla%d-tgt-%d-di-0-port="
2601 "%02x%02x%02x%02x%02x%02x%02x%02x\\;\n",
2602 (int)ha->instance,
2603 tgt,
2604 tq->port_name[0],
2605 tq->port_name[1],
2606 tq->port_name[2],
2607 tq->port_name[3],
2608 tq->port_name[4],
2609 tq->port_name[5],
2610 tq->port_name[6],
2611 tq->port_name[7]);
2612
2613 break;
2614
2615 case BIND_BY_PORT_ID:
2616 qla_printk(KERN_INFO, ha,
2617 "scsi-qla%d-tgt-%d-di-0-pid="
2618 "%02x%02x%02x\\;\n",
2619 (int)ha->instance,
2620 tgt,
2621 tq->d_id.b.domain,
2622 tq->d_id.b.area,
2623 tq->d_id.b.al_pa);
2624 break;
2625 }
2626
2627#if VSA
2628 qla_printk(KERN_INFO, ha,
2629 "scsi-qla%d-target-%d-vsa=01;\n", (int)ha->instance, tgt);
2630#endif
2631 }
2632}
2633
2634/*
2635 * qla2x00_suspend_lun
2636 * Suspend lun and start port down timer
2637 *
2638 * Input:
2639 * ha = visable adapter block pointer.
2640 * lq = lun queue
2641 * cp = Scsi command pointer
2642 * time = time in seconds
2643 * count = number of times to let time expire
2644 * delay_lun = non-zero, if lun should be delayed rather than suspended
2645 *
2646 * Return:
2647 * QLA_SUCCESS -- suspended lun
2648 * QLA_FUNCTION_FAILED -- Didn't suspend lun
2649 *
2650 * Context:
2651 * Interrupt context.
2652 */
2653int
2654__qla2x00_suspend_lun(scsi_qla_host_t *ha,
2655 os_lun_t *lq, int time, int count, int delay_lun)
2656{
2657 int rval;
2658 srb_t *sp;
2659 struct list_head *list, *temp;
2660 unsigned long flags;
2661
2662 rval = QLA_SUCCESS;
2663
2664 /* if the lun_q is already suspended then don't do it again */
2665 if (lq->q_state == LUN_STATE_READY ||lq->q_state == LUN_STATE_RUN) {
2666
2667 spin_lock_irqsave(&lq->q_lock, flags);
2668 if (lq->q_state == LUN_STATE_READY) {
2669 lq->q_max = count;
2670 lq->q_count = 0;
2671 }
2672 /* Set the suspend time usually 6 secs */
2673 atomic_set(&lq->q_timer, time);
2674
2675 /* now suspend the lun */
2676 lq->q_state = LUN_STATE_WAIT;
2677
2678 if (delay_lun) {
2679 set_bit(LUN_EXEC_DELAYED, &lq->q_flag);
2680 DEBUG(printk(KERN_INFO
2681 "scsi(%ld): Delay lun execution for %d secs, "
2682 "count=%d, max count=%d, state=%d\n",
2683 ha->host_no,
2684 time,
2685 lq->q_count, lq->q_max, lq->q_state));
2686 } else {
2687 DEBUG(printk(KERN_INFO
2688 "scsi(%ld): Suspend lun for %d secs, count=%d, "
2689 "max count=%d, state=%d\n",
2690 ha->host_no,
2691 time,
2692 lq->q_count, lq->q_max, lq->q_state));
2693 }
2694 spin_unlock_irqrestore(&lq->q_lock, flags);
2695
2696 /*
2697 * Remove all pending commands from request queue and put them
2698 * in the scsi_retry queue.
2699 */
2700 spin_lock_irqsave(&ha->list_lock, flags);
2701 list_for_each_safe(list, temp, &ha->pending_queue) {
2702 sp = list_entry(list, srb_t, list);
2703 if (sp->lun_queue != lq)
2704 continue;
2705
2706 __del_from_pending_queue(ha, sp);
2707
2708 if (sp->cmd->allowed < count)
2709 sp->cmd->allowed = count;
2710 __add_to_scsi_retry_queue(ha, sp);
2711
2712 } /* list_for_each_safe */
2713 spin_unlock_irqrestore(&ha->list_lock, flags);
2714 rval = QLA_SUCCESS;
2715 } else {
2716 rval = QLA_FUNCTION_FAILED;
2717 }
2718
2719 return (rval);
2720}
2721
2722/*
2723 * qla2x00_mark_device_lost Updates fcport state when device goes offline.
2724 *
2725 * Input: ha = adapter block pointer. fcport = port structure pointer.
2726 *
2727 * Return: None.
2728 *
2729 * Context:
2730 */
2731void qla2x00_mark_device_lost(scsi_qla_host_t *ha, fc_port_t *fcport,
2732 int do_login)
2733{
2734 /*
2735 * We may need to retry the login, so don't change the state of the
2736 * port but do the retries.
2737 */
2738 if (atomic_read(&fcport->state) != FCS_DEVICE_DEAD)
2739 atomic_set(&fcport->state, FCS_DEVICE_LOST);
2740
2741 if (!do_login)
2742 return;
2743
2744 if (fcport->login_retry == 0) {
2745 fcport->login_retry = ha->login_retry_count;
2746 set_bit(RELOGIN_NEEDED, &ha->dpc_flags);
2747
2748 DEBUG(printk("scsi(%ld): Port login retry: "
2749 "%02x%02x%02x%02x%02x%02x%02x%02x, "
2750 "id = 0x%04x retry cnt=%d\n",
2751 ha->host_no,
2752 fcport->port_name[0],
2753 fcport->port_name[1],
2754 fcport->port_name[2],
2755 fcport->port_name[3],
2756 fcport->port_name[4],
2757 fcport->port_name[5],
2758 fcport->port_name[6],
2759 fcport->port_name[7],
2760 fcport->loop_id,
2761 fcport->login_retry));
2762 }
2763}
2764
2765/*
2766 * qla2x00_mark_all_devices_lost
2767 * Updates fcport state when device goes offline.
2768 *
2769 * Input:
2770 * ha = adapter block pointer.
2771 * fcport = port structure pointer.
2772 *
2773 * Return:
2774 * None.
2775 *
2776 * Context:
2777 */
2778void
2779qla2x00_mark_all_devices_lost(scsi_qla_host_t *ha)
2780{
2781 fc_port_t *fcport;
2782
2783 list_for_each_entry(fcport, &ha->fcports, list) {
2784 if (fcport->port_type != FCT_TARGET)
2785 continue;
2786
2787 /*
2788 * No point in marking the device as lost, if the device is
2789 * already DEAD.
2790 */
2791 if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD)
2792 continue;
2793
2794 atomic_set(&fcport->state, FCS_DEVICE_LOST);
2795 }
2796}
2797
2798/*
2799* qla2x00_mem_alloc
2800* Allocates adapter memory.
2801*
2802* Returns:
2803* 0 = success.
2804* 1 = failure.
2805*/
2806static uint8_t
2807qla2x00_mem_alloc(scsi_qla_host_t *ha)
2808{
2809 char name[16];
2810 uint8_t status = 1;
2811 int retry= 10;
2812
2813 do {
2814 /*
2815 * This will loop only once if everything goes well, else some
2816 * number of retries will be performed to get around a kernel
2817 * bug where available mem is not allocated until after a
2818 * little delay and a retry.
2819 */
2820 ha->request_ring = dma_alloc_coherent(&ha->pdev->dev,
2821 (ha->request_q_length + 1) * sizeof(request_t),
2822 &ha->request_dma, GFP_KERNEL);
2823 if (ha->request_ring == NULL) {
2824 qla_printk(KERN_WARNING, ha,
2825 "Memory Allocation failed - request_ring\n");
2826
2827 qla2x00_mem_free(ha);
2828 msleep(100);
2829
2830 continue;
2831 }
2832
2833 ha->response_ring = dma_alloc_coherent(&ha->pdev->dev,
2834 (ha->response_q_length + 1) * sizeof(response_t),
2835 &ha->response_dma, GFP_KERNEL);
2836 if (ha->response_ring == NULL) {
2837 qla_printk(KERN_WARNING, ha,
2838 "Memory Allocation failed - response_ring\n");
2839
2840 qla2x00_mem_free(ha);
2841 msleep(100);
2842
2843 continue;
2844 }
2845
2846 ha->gid_list = dma_alloc_coherent(&ha->pdev->dev, GID_LIST_SIZE,
2847 &ha->gid_list_dma, GFP_KERNEL);
2848 if (ha->gid_list == NULL) {
2849 qla_printk(KERN_WARNING, ha,
2850 "Memory Allocation failed - gid_list\n");
2851
2852 qla2x00_mem_free(ha);
2853 msleep(100);
2854
2855 continue;
2856 }
2857
2858 ha->rlc_rsp = dma_alloc_coherent(&ha->pdev->dev,
2859 sizeof(rpt_lun_cmd_rsp_t), &ha->rlc_rsp_dma, GFP_KERNEL);
2860 if (ha->rlc_rsp == NULL) {
2861 qla_printk(KERN_WARNING, ha,
2862 "Memory Allocation failed - rlc");
2863
2864 qla2x00_mem_free(ha);
2865 msleep(100);
2866
2867 continue;
2868 }
2869
2870 snprintf(name, sizeof(name), "qla2xxx_%ld", ha->host_no);
2871 ha->s_dma_pool = dma_pool_create(name, &ha->pdev->dev,
2872 DMA_POOL_SIZE, 8, 0);
2873 if (ha->s_dma_pool == NULL) {
2874 qla_printk(KERN_WARNING, ha,
2875 "Memory Allocation failed - s_dma_pool\n");
2876
2877 qla2x00_mem_free(ha);
2878 msleep(100);
2879
2880 continue;
2881 }
2882
2883 /* get consistent memory allocated for init control block */
2884 ha->init_cb = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
2885 &ha->init_cb_dma);
2886 if (ha->init_cb == NULL) {
2887 qla_printk(KERN_WARNING, ha,
2888 "Memory Allocation failed - init_cb\n");
2889
2890 qla2x00_mem_free(ha);
2891 msleep(100);
2892
2893 continue;
2894 }
2895 memset(ha->init_cb, 0, sizeof(init_cb_t));
2896
2897 /* Get consistent memory allocated for Get Port Database cmd */
2898 ha->iodesc_pd = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
2899 &ha->iodesc_pd_dma);
2900 if (ha->iodesc_pd == NULL) {
2901 /* error */
2902 qla_printk(KERN_WARNING, ha,
2903 "Memory Allocation failed - iodesc_pd\n");
2904
2905 qla2x00_mem_free(ha);
2906 msleep(100);
2907
2908 continue;
2909 }
2910 memset(ha->iodesc_pd, 0, PORT_DATABASE_SIZE);
2911
2912 /* Allocate ioctl related memory. */
2913 if (qla2x00_alloc_ioctl_mem(ha)) {
2914 qla_printk(KERN_WARNING, ha,
2915 "Memory Allocation failed - ioctl_mem\n");
2916
2917 qla2x00_mem_free(ha);
2918 msleep(100);
2919
2920 continue;
2921 }
2922
2923 if (qla2x00_allocate_sp_pool(ha)) {
2924 qla_printk(KERN_WARNING, ha,
2925 "Memory Allocation failed - "
2926 "qla2x00_allocate_sp_pool()\n");
2927
2928 qla2x00_mem_free(ha);
2929 msleep(100);
2930
2931 continue;
2932 }
2933
2934 /* Allocate memory for SNS commands */
2935 if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
2936 /* Get consistent memory allocated for SNS commands */
2937 ha->sns_cmd = dma_alloc_coherent(&ha->pdev->dev,
2938 sizeof(struct sns_cmd_pkt), &ha->sns_cmd_dma,
2939 GFP_KERNEL);
2940 if (ha->sns_cmd == NULL) {
2941 /* error */
2942 qla_printk(KERN_WARNING, ha,
2943 "Memory Allocation failed - sns_cmd\n");
2944
2945 qla2x00_mem_free(ha);
2946 msleep(100);
2947
2948 continue;
2949 }
2950 memset(ha->sns_cmd, 0, sizeof(struct sns_cmd_pkt));
2951 } else {
2952 /* Get consistent memory allocated for MS IOCB */
2953 ha->ms_iocb = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
2954 &ha->ms_iocb_dma);
2955 if (ha->ms_iocb == NULL) {
2956 /* error */
2957 qla_printk(KERN_WARNING, ha,
2958 "Memory Allocation failed - ms_iocb\n");
2959
2960 qla2x00_mem_free(ha);
2961 msleep(100);
2962
2963 continue;
2964 }
2965 memset(ha->ms_iocb, 0, sizeof(ms_iocb_entry_t));
2966
2967 /*
2968 * Get consistent memory allocated for CT SNS
2969 * commands
2970 */
2971 ha->ct_sns = dma_alloc_coherent(&ha->pdev->dev,
2972 sizeof(struct ct_sns_pkt), &ha->ct_sns_dma,
2973 GFP_KERNEL);
2974 if (ha->ct_sns == NULL) {
2975 /* error */
2976 qla_printk(KERN_WARNING, ha,
2977 "Memory Allocation failed - ct_sns\n");
2978
2979 qla2x00_mem_free(ha);
2980 msleep(100);
2981
2982 continue;
2983 }
2984 memset(ha->ct_sns, 0, sizeof(struct ct_sns_pkt));
2985 }
2986
2987 /* Done all allocations without any error. */
2988 status = 0;
2989
2990 } while (retry-- && status != 0);
2991
2992 if (status) {
2993 printk(KERN_WARNING
2994 "%s(): **** FAILED ****\n", __func__);
2995 }
2996
2997 return(status);
2998}
2999
3000/*
3001* qla2x00_mem_free
3002* Frees all adapter allocated memory.
3003*
3004* Input:
3005* ha = adapter block pointer.
3006*/
3007static void
3008qla2x00_mem_free(scsi_qla_host_t *ha)
3009{
3010 uint32_t t;
3011 struct list_head *fcpl, *fcptemp;
3012 fc_port_t *fcport;
3013 struct list_head *fcll, *fcltemp;
3014 fc_lun_t *fclun;
3015 unsigned long wtime;/* max wait time if mbx cmd is busy. */
3016
3017 if (ha == NULL) {
3018 /* error */
3019 DEBUG2(printk("%s(): ERROR invalid ha pointer.\n", __func__));
3020 return;
3021 }
3022
3023 /* Free the target queues */
3024 for (t = 0; t < MAX_TARGETS; t++) {
3025 qla2x00_tgt_free(ha, t);
3026 }
3027
3028 /* Make sure all other threads are stopped. */
3029 wtime = 60 * HZ;
3030 while (ha->dpc_wait && wtime) {
3031 set_current_state(TASK_INTERRUPTIBLE);
3032 wtime = schedule_timeout(wtime);
3033 }
3034
3035 /* free ioctl memory */
3036 qla2x00_free_ioctl_mem(ha);
3037
3038 /* free sp pool */
3039 qla2x00_free_sp_pool(ha);
3040
3041 if (ha->sns_cmd)
3042 dma_free_coherent(&ha->pdev->dev, sizeof(struct sns_cmd_pkt),
3043 ha->sns_cmd, ha->sns_cmd_dma);
3044
3045 if (ha->ct_sns)
3046 dma_free_coherent(&ha->pdev->dev, sizeof(struct ct_sns_pkt),
3047 ha->ct_sns, ha->ct_sns_dma);
3048
3049 if (ha->ms_iocb)
3050 dma_pool_free(ha->s_dma_pool, ha->ms_iocb, ha->ms_iocb_dma);
3051
3052 if (ha->iodesc_pd)
3053 dma_pool_free(ha->s_dma_pool, ha->iodesc_pd, ha->iodesc_pd_dma);
3054
3055 if (ha->init_cb)
3056 dma_pool_free(ha->s_dma_pool, ha->init_cb, ha->init_cb_dma);
3057
3058 if (ha->s_dma_pool)
3059 dma_pool_destroy(ha->s_dma_pool);
3060
3061 if (ha->rlc_rsp)
3062 dma_free_coherent(&ha->pdev->dev,
3063 sizeof(rpt_lun_cmd_rsp_t), ha->rlc_rsp,
3064 ha->rlc_rsp_dma);
3065
3066 if (ha->gid_list)
3067 dma_free_coherent(&ha->pdev->dev, GID_LIST_SIZE, ha->gid_list,
3068 ha->gid_list_dma);
3069
3070 if (ha->response_ring)
3071 dma_free_coherent(&ha->pdev->dev,
3072 (ha->response_q_length + 1) * sizeof(response_t),
3073 ha->response_ring, ha->response_dma);
3074
3075 if (ha->request_ring)
3076 dma_free_coherent(&ha->pdev->dev,
3077 (ha->request_q_length + 1) * sizeof(request_t),
3078 ha->request_ring, ha->request_dma);
3079
3080 ha->sns_cmd = NULL;
3081 ha->sns_cmd_dma = 0;
3082 ha->ct_sns = NULL;
3083 ha->ct_sns_dma = 0;
3084 ha->ms_iocb = NULL;
3085 ha->ms_iocb_dma = 0;
3086 ha->iodesc_pd = NULL;
3087 ha->iodesc_pd_dma = 0;
3088 ha->init_cb = NULL;
3089 ha->init_cb_dma = 0;
3090
3091 ha->s_dma_pool = NULL;
3092
3093 ha->rlc_rsp = NULL;
3094 ha->rlc_rsp_dma = 0;
3095 ha->gid_list = NULL;
3096 ha->gid_list_dma = 0;
3097
3098 ha->response_ring = NULL;
3099 ha->response_dma = 0;
3100 ha->request_ring = NULL;
3101 ha->request_dma = 0;
3102
3103 list_for_each_safe(fcpl, fcptemp, &ha->fcports) {
3104 fcport = list_entry(fcpl, fc_port_t, list);
3105
3106 /* fc luns */
3107 list_for_each_safe(fcll, fcltemp, &fcport->fcluns) {
3108 fclun = list_entry(fcll, fc_lun_t, list);
3109
3110 list_del_init(&fclun->list);
3111 kfree(fclun);
3112 }
3113
3114 /* fc ports */
3115 list_del_init(&fcport->list);
3116 kfree(fcport);
3117 }
3118 INIT_LIST_HEAD(&ha->fcports);
3119
3120 if (ha->fw_dump)
3121 free_pages((unsigned long)ha->fw_dump, ha->fw_dump_order);
3122
3123 if (ha->fw_dump_buffer)
3124 vfree(ha->fw_dump_buffer);
3125
3126 ha->fw_dump = NULL;
3127 ha->fw_dump_reading = 0;
3128 ha->fw_dump_buffer = NULL;
3129}
3130
3131/*
3132 * qla2x00_allocate_sp_pool
3133 * This routine is called during initialization to allocate
3134 * memory for local srb_t.
3135 *
3136 * Input:
3137 * ha = adapter block pointer.
3138 *
3139 * Context:
3140 * Kernel context.
3141 *
3142 * Note: Sets the ref_count for non Null sp to one.
3143 */
3144static int
3145qla2x00_allocate_sp_pool(scsi_qla_host_t *ha)
3146{
3147 int rval;
3148
3149 rval = QLA_SUCCESS;
3150 ha->srb_mempool = mempool_create(SRB_MIN_REQ, mempool_alloc_slab,
3151 mempool_free_slab, srb_cachep);
3152 if (ha->srb_mempool == NULL) {
3153 qla_printk(KERN_INFO, ha, "Unable to allocate SRB mempool.\n");
3154 rval = QLA_FUNCTION_FAILED;
3155 }
3156 return (rval);
3157}
3158
3159/*
3160 * This routine frees all adapter allocated memory.
3161 *
3162 */
3163static void
3164qla2x00_free_sp_pool( scsi_qla_host_t *ha)
3165{
3166 if (ha->srb_mempool) {
3167 mempool_destroy(ha->srb_mempool);
3168 ha->srb_mempool = NULL;
3169 }
3170}
3171
3172/**************************************************************************
3173* qla2x00_do_dpc
3174* This kernel thread is a task that is schedule by the interrupt handler
3175* to perform the background processing for interrupts.
3176*
3177* Notes:
3178* This task always run in the context of a kernel thread. It
3179* is kick-off by the driver's detect code and starts up
3180* up one per adapter. It immediately goes to sleep and waits for
3181* some fibre event. When either the interrupt handler or
3182* the timer routine detects a event it will one of the task
3183* bits then wake us up.
3184**************************************************************************/
3185static int
3186qla2x00_do_dpc(void *data)
3187{
3188 DECLARE_MUTEX_LOCKED(sem);
3189 scsi_qla_host_t *ha;
3190 fc_port_t *fcport;
3191 os_lun_t *q;
3192 srb_t *sp;
3193 uint8_t status;
3194 unsigned long flags = 0;
3195 struct list_head *list, *templist;
3196 int dead_cnt, online_cnt;
3197 int retry_cmds = 0;
3198 uint16_t next_loopid;
3199 int t;
3200 os_tgt_t *tq;
3201
3202 ha = (scsi_qla_host_t *)data;
3203
3204 lock_kernel();
3205
3206 daemonize("%s_dpc", ha->host_str);
3207 allow_signal(SIGHUP);
3208
3209 ha->dpc_wait = &sem;
3210
3211 set_user_nice(current, -20);
3212
3213 unlock_kernel();
3214
3215 complete(&ha->dpc_inited);
3216
3217 while (1) {
3218 DEBUG3(printk("qla2x00: DPC handler sleeping\n"));
3219
3220 if (down_interruptible(&sem))
3221 break;
3222
3223 if (ha->dpc_should_die)
3224 break;
3225
3226 DEBUG3(printk("qla2x00: DPC handler waking up\n"));
3227
3228 /* Initialization not yet finished. Don't do anything yet. */
3229 if (!ha->flags.init_done || ha->dpc_active)
3230 continue;
3231
3232 DEBUG3(printk("scsi(%ld): DPC handler\n", ha->host_no));
3233
3234 ha->dpc_active = 1;
3235
3236 if (!list_empty(&ha->done_queue))
3237 qla2x00_done(ha);
3238
3239 /* Process commands in retry queue */
3240 if (test_and_clear_bit(PORT_RESTART_NEEDED, &ha->dpc_flags)) {
3241 DEBUG(printk("scsi(%ld): DPC checking retry_q. "
3242 "total=%d\n",
3243 ha->host_no, ha->retry_q_cnt));
3244
3245 spin_lock_irqsave(&ha->list_lock, flags);
3246 dead_cnt = online_cnt = 0;
3247 list_for_each_safe(list, templist, &ha->retry_queue) {
3248 sp = list_entry(list, srb_t, list);
3249 q = sp->lun_queue;
3250 DEBUG3(printk("scsi(%ld): pid=%ld sp=%p, "
3251 "spflags=0x%x, q_flag= 0x%lx\n",
3252 ha->host_no, sp->cmd->serial_number, sp,
3253 sp->flags, q->q_flag));
3254
3255 if (q == NULL)
3256 continue;
3257 fcport = q->fclun->fcport;
3258
3259 if (atomic_read(&fcport->state) ==
3260 FCS_DEVICE_DEAD ||
3261 atomic_read(&fcport->ha->loop_state) == LOOP_DEAD) {
3262
3263 __del_from_retry_queue(ha, sp);
3264 sp->cmd->result = DID_NO_CONNECT << 16;
3265 if (atomic_read(&fcport->ha->loop_state) ==
3266 LOOP_DOWN)
3267 sp->err_id = SRB_ERR_LOOP;
3268 else
3269 sp->err_id = SRB_ERR_PORT;
3270 sp->cmd->host_scribble =
3271 (unsigned char *) NULL;
3272 __add_to_done_queue(ha, sp);
3273 dead_cnt++;
3274 } else if (atomic_read(&fcport->state) !=
3275 FCS_DEVICE_LOST) {
3276
3277 __del_from_retry_queue(ha, sp);
3278 sp->cmd->result = DID_BUS_BUSY << 16;
3279 sp->cmd->host_scribble =
3280 (unsigned char *) NULL;
3281 __add_to_done_queue(ha, sp);
3282 online_cnt++;
3283 }
3284 } /* list_for_each_safe() */
3285 spin_unlock_irqrestore(&ha->list_lock, flags);
3286
3287 DEBUG(printk("scsi(%ld): done processing retry queue "
3288 "- dead=%d, online=%d\n ",
3289 ha->host_no, dead_cnt, online_cnt));
3290 }
3291
3292 /* Process commands in scsi retry queue */
3293 if (test_and_clear_bit(SCSI_RESTART_NEEDED, &ha->dpc_flags)) {
3294 /*
3295 * Any requests we want to delay for some period is put
3296 * in the scsi retry queue with a delay added. The
3297 * timer will schedule a "scsi_restart_needed" every
3298 * second as long as there are requests in the scsi
3299 * queue.
3300 */
3301 DEBUG(printk("scsi(%ld): DPC checking scsi "
3302 "retry_q.total=%d\n",
3303 ha->host_no, ha->scsi_retry_q_cnt));
3304
3305 online_cnt = 0;
3306 spin_lock_irqsave(&ha->list_lock, flags);
3307 list_for_each_safe(list, templist,
3308 &ha->scsi_retry_queue) {
3309
3310 sp = list_entry(list, srb_t, list);
3311 q = sp->lun_queue;
3312 tq = sp->tgt_queue;
3313
3314 DEBUG3(printk("scsi(%ld): scsi_retry_q: "
3315 "pid=%ld sp=%p, spflags=0x%x, "
3316 "q_flag= 0x%lx,q_state=%d\n",
3317 ha->host_no, sp->cmd->serial_number,
3318 sp, sp->flags, q->q_flag, q->q_state));
3319
3320 /* Was this lun suspended */
3321 if (q->q_state != LUN_STATE_WAIT) {
3322 online_cnt++;
3323 __del_from_scsi_retry_queue(ha, sp);
3324
3325 if (test_bit(TQF_RETRY_CMDS,
3326 &tq->flags)) {
3327 qla2x00_extend_timeout(sp->cmd,
3328 (sp->cmd->timeout_per_command / HZ) - QLA_CMD_TIMER_DELTA);
3329 __add_to_pending_queue(ha, sp);
3330 retry_cmds++;
3331 } else
3332 __add_to_retry_queue(ha, sp);
3333 }
3334
3335 /* Was this command suspended for N secs */
3336 if (sp->delay != 0) {
3337 sp->delay--;
3338 if (sp->delay == 0) {
3339 online_cnt++;
3340 __del_from_scsi_retry_queue(
3341 ha, sp);
3342 __add_to_retry_queue(ha,sp);
3343 }
3344 }
3345 }
3346 spin_unlock_irqrestore(&ha->list_lock, flags);
3347
3348 /* Clear all Target Unsuspended bits */
3349 for (t = 0; t < ha->max_targets; t++) {
3350 if ((tq = ha->otgt[t]) == NULL)
3351 continue;
3352
3353 if (test_bit(TQF_RETRY_CMDS, &tq->flags))
3354 clear_bit(TQF_RETRY_CMDS, &tq->flags);
3355 }
3356 if (retry_cmds)
3357 qla2x00_next(ha);
3358
3359 DEBUG(if (online_cnt > 0))
3360 DEBUG(printk("scsi(%ld): dpc() found scsi reqs to "
3361 "restart= %d\n",
3362 ha->host_no, online_cnt));
3363 }
3364
3365 if (ha->flags.mbox_busy) {
3366 if (!list_empty(&ha->done_queue))
3367 qla2x00_done(ha);
3368
3369 ha->dpc_active = 0;
3370 continue;
3371 }
3372
3373 if (test_and_clear_bit(ISP_ABORT_NEEDED, &ha->dpc_flags)) {
3374
3375 DEBUG(printk("scsi(%ld): dpc: sched "
3376 "qla2x00_abort_isp ha = %p\n",
3377 ha->host_no, ha));
3378 if (!(test_and_set_bit(ABORT_ISP_ACTIVE,
3379 &ha->dpc_flags))) {
3380
3381 if (qla2x00_abort_isp(ha)) {
3382 /* failed. retry later */
3383 set_bit(ISP_ABORT_NEEDED,
3384 &ha->dpc_flags);
3385 }
3386 clear_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
3387 }
3388 DEBUG(printk("scsi(%ld): dpc: qla2x00_abort_isp end\n",
3389 ha->host_no));
3390 }
3391
3392 if (test_and_clear_bit(RESET_MARKER_NEEDED, &ha->dpc_flags) &&
3393 (!(test_and_set_bit(RESET_ACTIVE, &ha->dpc_flags)))) {
3394
3395 DEBUG(printk("scsi(%ld): qla2x00_reset_marker()\n",
3396 ha->host_no));
3397
3398 qla2x00_rst_aen(ha);
3399 clear_bit(RESET_ACTIVE, &ha->dpc_flags);
3400 }
3401
3402 /* Retry each device up to login retry count */
3403 if ((test_and_clear_bit(RELOGIN_NEEDED, &ha->dpc_flags)) &&
3404 !test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags) &&
3405 atomic_read(&ha->loop_state) != LOOP_DOWN) {
3406
3407 DEBUG(printk("scsi(%ld): qla2x00_port_login()\n",
3408 ha->host_no));
3409
3410 next_loopid = 0;
3411 list_for_each_entry(fcport, &ha->fcports, list) {
3412 if (fcport->port_type != FCT_TARGET)
3413 continue;
3414
3415 /*
3416 * If the port is not ONLINE then try to login
3417 * to it if we haven't run out of retries.
3418 */
3419 if (atomic_read(&fcport->state) != FCS_ONLINE &&
3420 fcport->login_retry) {
3421
3422 fcport->login_retry--;
3423 if (fcport->flags & FCF_FABRIC_DEVICE) {
3424 if (fcport->flags &
3425 FCF_TAPE_PRESENT)
3426 qla2x00_fabric_logout(
3427 ha,
3428 fcport->loop_id);
3429 status = qla2x00_fabric_login(
3430 ha, fcport, &next_loopid);
3431 } else
3432 status =
3433 qla2x00_local_device_login(
3434 ha, fcport->loop_id);
3435
3436 if (status == QLA_SUCCESS) {
3437 fcport->old_loop_id = fcport->loop_id;
3438
3439 DEBUG(printk("scsi(%ld): port login OK: logged in ID 0x%x\n",
3440 ha->host_no, fcport->loop_id));
3441
3442 fcport->port_login_retry_count =
3443 ha->port_down_retry_count * PORT_RETRY_TIME;
3444 atomic_set(&fcport->state, FCS_ONLINE);
3445 atomic_set(&fcport->port_down_timer,
3446 ha->port_down_retry_count * PORT_RETRY_TIME);
3447
3448 fcport->login_retry = 0;
3449 } else if (status == 1) {
3450 set_bit(RELOGIN_NEEDED, &ha->dpc_flags);
3451 /* retry the login again */
3452 DEBUG(printk("scsi(%ld): Retrying %d login again loop_id 0x%x\n",
3453 ha->host_no,
3454 fcport->login_retry, fcport->loop_id));
3455 } else {
3456 fcport->login_retry = 0;
3457 }
3458 }
3459 if (test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags))
3460 break;
3461 }
3462 DEBUG(printk("scsi(%ld): qla2x00_port_login - end\n",
3463 ha->host_no));
3464 }
3465
3466 if ((test_bit(LOGIN_RETRY_NEEDED, &ha->dpc_flags)) &&
3467 atomic_read(&ha->loop_state) != LOOP_DOWN) {
3468
3469 clear_bit(LOGIN_RETRY_NEEDED, &ha->dpc_flags);
3470 DEBUG(printk("scsi(%ld): qla2x00_login_retry()\n",
3471 ha->host_no));
3472
3473 set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);
3474
3475 DEBUG(printk("scsi(%ld): qla2x00_login_retry - end\n",
3476 ha->host_no));
3477 }
3478
3479 if (test_and_clear_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags)) {
3480
3481 DEBUG(printk("scsi(%ld): qla2x00_loop_resync()\n",
3482 ha->host_no));
3483
3484 if (!(test_and_set_bit(LOOP_RESYNC_ACTIVE,
3485 &ha->dpc_flags))) {
3486
3487 qla2x00_loop_resync(ha);
3488
3489 clear_bit(LOOP_RESYNC_ACTIVE, &ha->dpc_flags);
3490 }
3491
3492 DEBUG(printk("scsi(%ld): qla2x00_loop_resync - end\n",
3493 ha->host_no));
3494 }
3495
3496
3497 if (test_bit(RESTART_QUEUES_NEEDED, &ha->dpc_flags)) {
3498 DEBUG(printk("scsi(%ld): qla2x00_restart_queues()\n",
3499 ha->host_no));
3500
3501 qla2x00_restart_queues(ha, 0);
3502
3503 DEBUG(printk("scsi(%ld): qla2x00_restart_queues - end\n",
3504 ha->host_no));
3505 }
3506
3507 if (test_bit(ABORT_QUEUES_NEEDED, &ha->dpc_flags)) {
3508
3509 DEBUG(printk("scsi(%ld): qla2x00_abort_queues()\n",
3510 ha->host_no));
3511
3512 qla2x00_abort_queues(ha, 0);
3513
3514 DEBUG(printk("scsi(%ld): qla2x00_abort_queues - end\n",
3515 ha->host_no));
3516 }
3517
3518 if (test_and_clear_bit(FCPORT_RESCAN_NEEDED, &ha->dpc_flags)) {
3519
3520 DEBUG(printk("scsi(%ld): Rescan flagged fcports...\n",
3521 ha->host_no));
3522
3523 qla2x00_rescan_fcports(ha);
3524
3525 DEBUG(printk("scsi(%ld): Rescan flagged fcports..."
3526 "end.\n",
3527 ha->host_no));
3528 }
3529
3530
3531 if (!ha->interrupts_on)
3532 qla2x00_enable_intrs(ha);
3533
3534 if (!list_empty(&ha->done_queue))
3535 qla2x00_done(ha);
3536
3537 ha->dpc_active = 0;
3538 } /* End of while(1) */
3539
3540 DEBUG(printk("scsi(%ld): DPC handler exiting\n", ha->host_no));
3541
3542 /*
3543 * Make sure that nobody tries to wake us up again.
3544 */
3545 ha->dpc_wait = NULL;
3546 ha->dpc_active = 0;
3547
3548 complete_and_exit(&ha->dpc_exited, 0);
3549}
3550
3551/*
3552 * qla2x00_abort_queues
3553 * Abort all commands on queues on device
3554 *
3555 * Input:
3556 * ha = adapter block pointer.
3557 *
3558 * Context:
3559 * Interrupt context.
3560 */
3561void
3562qla2x00_abort_queues(scsi_qla_host_t *ha, uint8_t doneqflg)
3563{
3564
3565 srb_t *sp;
3566 struct list_head *list, *temp;
3567 unsigned long flags;
3568
3569 clear_bit(ABORT_QUEUES_NEEDED, &ha->dpc_flags);
3570
3571 /* Return all commands device queues. */
3572 spin_lock_irqsave(&ha->list_lock,flags);
3573 list_for_each_safe(list, temp, &ha->pending_queue) {
3574 sp = list_entry(list, srb_t, list);
3575
3576 if (sp->flags & SRB_ABORTED)
3577 continue;
3578
3579 /* Remove srb from LUN queue. */
3580 __del_from_pending_queue(ha, sp);
3581
3582 /* Set ending status. */
3583 sp->cmd->result = DID_BUS_BUSY << 16;
3584
3585 __add_to_done_queue(ha, sp);
3586 }
3587 spin_unlock_irqrestore(&ha->list_lock, flags);
3588}
3589
3590/*
3591* qla2x00_rst_aen
3592* Processes asynchronous reset.
3593*
3594* Input:
3595* ha = adapter block pointer.
3596*/
3597static void
3598qla2x00_rst_aen(scsi_qla_host_t *ha)
3599{
3600 if (ha->flags.online && !ha->flags.reset_active &&
3601 !atomic_read(&ha->loop_down_timer) &&
3602 !(test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags))) {
3603 do {
3604 clear_bit(RESET_MARKER_NEEDED, &ha->dpc_flags);
3605
3606 /*
3607 * Issue marker command only when we are going to start
3608 * the I/O.
3609 */
3610 ha->marker_needed = 1;
3611 } while (!atomic_read(&ha->loop_down_timer) &&
3612 (test_bit(RESET_MARKER_NEEDED, &ha->dpc_flags)));
3613 }
3614}
3615
3616
3617/*
3618 * This routine will allocate SP from the free queue
3619 * input:
3620 * scsi_qla_host_t *
3621 * output:
3622 * srb_t * or NULL
3623 */
3624static srb_t *
3625qla2x00_get_new_sp(scsi_qla_host_t *ha)
3626{
3627 srb_t *sp;
3628
3629 sp = mempool_alloc(ha->srb_mempool, GFP_ATOMIC);
3630 if (sp)
3631 atomic_set(&sp->ref_count, 1);
3632 return (sp);
3633}
3634
3635/**************************************************************************
3636* qla2x00_timer
3637*
3638* Description:
3639* One second timer
3640*
3641* Context: Interrupt
3642***************************************************************************/
3643static void
3644qla2x00_timer(scsi_qla_host_t *ha)
3645{
3646 int t,l;
3647 unsigned long cpu_flags = 0;
3648 fc_port_t *fcport;
3649 os_lun_t *lq;
3650 os_tgt_t *tq;
3651 int start_dpc = 0;
3652 int index;
3653 srb_t *sp;
3654
3655 /*
3656 * We try and restart any request in the retry queue every second.
3657 */
3658 if (!list_empty(&ha->retry_queue)) {
3659 set_bit(PORT_RESTART_NEEDED, &ha->dpc_flags);
3660 start_dpc++;
3661 }
3662
3663 /*
3664 * We try and restart any request in the scsi_retry queue every second.
3665 */
3666 if (!list_empty(&ha->scsi_retry_queue)) {
3667 set_bit(SCSI_RESTART_NEEDED, &ha->dpc_flags);
3668 start_dpc++;
3669 }
3670
3671 /*
3672 * Ports - Port down timer.
3673 *
3674 * Whenever, a port is in the LOST state we start decrementing its port
3675 * down timer every second until it reaches zero. Once it reaches zero
3676 * the port it marked DEAD.
3677 */
3678 t = 0;
3679 list_for_each_entry(fcport, &ha->fcports, list) {
3680 if (fcport->port_type != FCT_TARGET)
3681 continue;
3682
3683 if (atomic_read(&fcport->state) == FCS_DEVICE_LOST) {
3684
3685 if (atomic_read(&fcport->port_down_timer) == 0)
3686 continue;
3687
3688 if (atomic_dec_and_test(&fcport->port_down_timer) != 0)
3689 atomic_set(&fcport->state, FCS_DEVICE_DEAD);
3690
3691 DEBUG(printk("scsi(%ld): fcport-%d - port retry count: "
3692 "%d remainning\n",
3693 ha->host_no,
3694 t, atomic_read(&fcport->port_down_timer)));
3695 }
3696 t++;
3697 } /* End of for fcport */
3698
3699 /*
3700 * LUNS - lun suspend timer.
3701 *
3702 * Whenever, a lun is suspended the timer starts decrementing its
3703 * suspend timer every second until it reaches zero. Once it reaches
3704 * zero the lun retry count is decremented.
3705 */
3706
3707 /*
3708 * FIXME(dg) - Need to convert this linear search of luns into a search
3709 * of a list of suspended luns.
3710 */
3711 for (t = 0; t < ha->max_targets; t++) {
3712 if ((tq = ha->otgt[t]) == NULL)
3713 continue;
3714
3715 for (l = 0; l < ha->max_luns; l++) {
3716 if ((lq = (os_lun_t *) tq->olun[l]) == NULL)
3717 continue;
3718
3719 spin_lock_irqsave(&lq->q_lock, cpu_flags);
3720 if (lq->q_state == LUN_STATE_WAIT &&
3721 atomic_read(&lq->q_timer) != 0) {
3722
3723 if (atomic_dec_and_test(&lq->q_timer) != 0) {
3724 /*
3725 * A delay should immediately
3726 * transition to a READY state
3727 */
3728 if (test_and_clear_bit(LUN_EXEC_DELAYED,
3729 &lq->q_flag)) {
3730 lq->q_state = LUN_STATE_READY;
3731 }
3732 else {
3733 lq->q_count++;
3734 if (lq->q_count == lq->q_max)
3735 lq->q_state =
3736 LUN_STATE_TIMEOUT;
3737 else
3738 lq->q_state =
3739 LUN_STATE_RUN;
3740 }
3741 }
3742 DEBUG3(printk("scsi(%ld): lun%d - timer %d, "
3743 "count=%d, max=%d, state=%d\n",
3744 ha->host_no,
3745 l,
3746 atomic_read(&lq->q_timer),
3747 lq->q_count, lq->q_max, lq->q_state));
3748 }
3749 spin_unlock_irqrestore(&lq->q_lock, cpu_flags);
3750 } /* End of for luns */
3751 } /* End of for targets */
3752
3753 /* Loop down handler. */
3754 if (atomic_read(&ha->loop_down_timer) > 0 &&
3755 !(test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags)) && ha->flags.online) {
3756
3757 if (atomic_read(&ha->loop_down_timer) ==
3758 ha->loop_down_abort_time) {
3759
3760 DEBUG(printk("scsi(%ld): Loop Down - aborting the "
3761 "queues before time expire\n",
3762 ha->host_no));
3763
3764 if (!IS_QLA2100(ha) && ha->link_down_timeout)
3765 atomic_set(&ha->loop_state, LOOP_DEAD);
3766
3767 /* Schedule an ISP abort to return any tape commands. */
3768 spin_lock_irqsave(&ha->hardware_lock, cpu_flags);
3769 for (index = 1; index < MAX_OUTSTANDING_COMMANDS;
3770 index++) {
3771 sp = ha->outstanding_cmds[index];
3772 if (!sp)
3773 continue;
3774 if (!(sp->fclun->fcport->flags &
3775 FCF_TAPE_PRESENT))
3776 continue;
3777
3778 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
3779 break;
3780 }
3781 spin_unlock_irqrestore(&ha->hardware_lock, cpu_flags);
3782
3783 set_bit(ABORT_QUEUES_NEEDED, &ha->dpc_flags);
3784 start_dpc++;
3785 }
3786
3787 /* if the loop has been down for 4 minutes, reinit adapter */
3788 if (atomic_dec_and_test(&ha->loop_down_timer) != 0) {
3789 DEBUG(printk("scsi(%ld): Loop down exceed 4 mins - "
3790 "restarting queues.\n",
3791 ha->host_no));
3792
3793 set_bit(RESTART_QUEUES_NEEDED, &ha->dpc_flags);
3794 start_dpc++;
3795
3796 if (!(ha->device_flags & DFLG_NO_CABLE)) {
3797 DEBUG(printk("scsi(%ld): Loop down - "
3798 "aborting ISP.\n",
3799 ha->host_no));
3800 qla_printk(KERN_WARNING, ha,
3801 "Loop down - aborting ISP.\n");
3802
3803 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
3804 }
3805 }
3806 DEBUG3(printk("scsi(%ld): Loop Down - seconds remainning %d\n",
3807 ha->host_no,
3808 atomic_read(&ha->loop_down_timer)));
3809 }
3810
3811 /*
3812 * Done Q Handler -- dgFIXME This handler will kick off doneq if we
3813 * haven't process it in 2 seconds.
3814 */
3815 if (!list_empty(&ha->done_queue))
3816 qla2x00_done(ha);
3817
3818
3819 /* Schedule the DPC routine if needed */
3820 if ((test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags) ||
3821 test_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags) ||
3822 start_dpc ||
3823 test_bit(LOGIN_RETRY_NEEDED, &ha->dpc_flags) ||
3824 test_bit(RELOGIN_NEEDED, &ha->dpc_flags)) &&
3825 ha->dpc_wait && !ha->dpc_active) {
3826
3827 up(ha->dpc_wait);
3828 }
3829
3830 qla2x00_restart_timer(ha, WATCH_INTERVAL);
3831}
3832
3833/*
3834 * qla2x00_extend_timeout
3835 * This routine will extend the timeout to the specified value.
3836 *
3837 * Input:
3838 * cmd = SCSI command structure
3839 *
3840 * Returns:
3841 * None.
3842 */
3843void
3844qla2x00_extend_timeout(struct scsi_cmnd *cmd, int timeout)
3845{
3846 srb_t *sp = (srb_t *) CMD_SP(cmd);
3847 u_long our_jiffies = (timeout * HZ) + jiffies;
3848
3849 sp->ext_history= 0;
3850 sp->e_start = jiffies;
3851 if (cmd->eh_timeout.function) {
3852 mod_timer(&cmd->eh_timeout,our_jiffies);
3853 sp->ext_history |= 1;
3854 }
3855 if (sp->timer.function != NULL) {
3856 /*
3857 * Our internal timer should timeout before the midlayer has a
3858 * chance begin the abort process
3859 */
3860 mod_timer(&sp->timer,our_jiffies - (QLA_CMD_TIMER_DELTA * HZ));
3861
3862 sp->ext_history |= 2;
3863 }
3864}
3865
3866/**************************************************************************
3867* qla2x00_cmd_timeout
3868*
3869* Description:
3870* Handles the command if it times out in any state.
3871*
3872* Input:
3873* sp - pointer to validate
3874*
3875* Returns:
3876* None.
3877* Note:Need to add the support for if( sp->state == SRB_FAILOVER_STATE).
3878**************************************************************************/
3879void
3880qla2x00_cmd_timeout(srb_t *sp)
3881{
3882 int t, l;
3883 int processed;
3884 scsi_qla_host_t *vis_ha, *dest_ha;
3885 struct scsi_cmnd *cmd;
3886 unsigned long flags, cpu_flags;
3887 fc_port_t *fcport;
3888
3889 cmd = sp->cmd;
3890 vis_ha = (scsi_qla_host_t *)cmd->device->host->hostdata;
3891
3892 DEBUG3(printk("cmd_timeout: Entering sp->state = %x\n", sp->state));
3893
3894 t = cmd->device->id;
3895 l = cmd->device->lun;
3896 fcport = sp->fclun->fcport;
3897 dest_ha = sp->ha;
3898
3899 /*
3900 * If IO is found either in retry Queue
3901 * OR in Lun Queue
3902 * Return this IO back to host
3903 */
3904 spin_lock_irqsave(&vis_ha->list_lock, flags);
3905 processed = 0;
3906 if (sp->state == SRB_PENDING_STATE) {
3907 __del_from_pending_queue(vis_ha, sp);
3908 DEBUG2(printk("scsi(%ld): Found in Pending queue pid %ld, "
3909 "State = %x., fcport state=%d sjiffs=%lx njiffs=%lx\n",
3910 vis_ha->host_no, cmd->serial_number, sp->state,
3911 atomic_read(&fcport->state), sp->r_start, jiffies));
3912
3913 /*
3914 * If FC_DEVICE is marked as dead return the cmd with
3915 * DID_NO_CONNECT status. Otherwise set the host_byte to
3916 * DID_BUS_BUSY to let the OS retry this cmd.
3917 */
3918 if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD ||
3919 atomic_read(&fcport->ha->loop_state) == LOOP_DEAD) {
3920 cmd->result = DID_NO_CONNECT << 16;
3921 if (atomic_read(&fcport->ha->loop_state) == LOOP_DOWN)
3922 sp->err_id = SRB_ERR_LOOP;
3923 else
3924 sp->err_id = SRB_ERR_PORT;
3925 } else {
3926 cmd->result = DID_BUS_BUSY << 16;
3927 }
3928 __add_to_done_queue(vis_ha, sp);
3929 processed++;
3930 }
3931 spin_unlock_irqrestore(&vis_ha->list_lock, flags);
3932
3933 if (processed) {
3934 qla2x00_done(vis_ha);
3935 return;
3936 }
3937
3938 spin_lock_irqsave(&dest_ha->list_lock, flags);
3939 if ((sp->state == SRB_RETRY_STATE) ||
3940 (sp->state == SRB_SCSI_RETRY_STATE)) {
3941
3942 DEBUG2(printk("scsi(%ld): Found in (Scsi) Retry queue or "
3943 "failover Q pid %ld, State = %x., fcport state=%d "
3944 "jiffies=%lx retried=%d\n",
3945 dest_ha->host_no, cmd->serial_number, sp->state,
3946 atomic_read(&fcport->state), jiffies, cmd->retries));
3947
3948 if ((sp->state == SRB_RETRY_STATE)) {
3949 __del_from_retry_queue(dest_ha, sp);
3950 } else if ((sp->state == SRB_SCSI_RETRY_STATE)) {
3951 __del_from_scsi_retry_queue(dest_ha, sp);
3952 }
3953
3954 /*
3955 * If FC_DEVICE is marked as dead return the cmd with
3956 * DID_NO_CONNECT status. Otherwise set the host_byte to
3957 * DID_BUS_BUSY to let the OS retry this cmd.
3958 */
3959 if ((atomic_read(&fcport->state) == FCS_DEVICE_DEAD) ||
3960 atomic_read(&dest_ha->loop_state) == LOOP_DEAD) {
3961 qla2x00_extend_timeout(cmd, EXTEND_CMD_TIMEOUT);
3962 cmd->result = DID_NO_CONNECT << 16;
3963 if (atomic_read(&dest_ha->loop_state) == LOOP_DOWN)
3964 sp->err_id = SRB_ERR_LOOP;
3965 else
3966 sp->err_id = SRB_ERR_PORT;
3967 } else {
3968 cmd->result = DID_BUS_BUSY << 16;
3969 }
3970
3971 __add_to_done_queue(dest_ha, sp);
3972 processed++;
3973 }
3974 spin_unlock_irqrestore(&dest_ha->list_lock, flags);
3975
3976 if (processed) {
3977 qla2x00_done(dest_ha);
3978 return;
3979 }
3980
3981 spin_lock_irqsave(&dest_ha->list_lock, cpu_flags);
3982 if (sp->state == SRB_DONE_STATE) {
3983 /* IO in done_q -- leave it */
3984 DEBUG(printk("scsi(%ld): Found in Done queue pid %ld sp=%p.\n",
3985 dest_ha->host_no, cmd->serial_number, sp));
3986 } else if (sp->state == SRB_SUSPENDED_STATE) {
3987 DEBUG(printk("scsi(%ld): Found SP %p in suspended state "
3988 "- pid %ld:\n",
3989 dest_ha->host_no, sp, cmd->serial_number));
3990 DEBUG(qla2x00_dump_buffer((uint8_t *)sp, sizeof(srb_t));)
3991 } else if (sp->state == SRB_ACTIVE_STATE) {
3992 /*
3993 * IO is with ISP find the command in our active list.
3994 */
3995 spin_unlock_irqrestore(&dest_ha->list_lock, cpu_flags);
3996 spin_lock_irqsave(&dest_ha->hardware_lock, flags);
3997 if (sp == dest_ha->outstanding_cmds[
3998 (unsigned long)sp->cmd->host_scribble]) {
3999
4000 DEBUG(printk("cmd_timeout: Found in ISP \n"));
4001
4002 if (sp->flags & SRB_TAPE) {
4003 /*
4004 * We cannot allow the midlayer error handler
4005 * to wakeup and begin the abort process.
4006 * Extend the timer so that the firmware can
4007 * properly return the IOCB.
4008 */
4009 DEBUG(printk("cmd_timeout: Extending timeout "
4010 "of FCP2 tape command!\n"));
4011 qla2x00_extend_timeout(sp->cmd,
4012 EXTEND_CMD_TIMEOUT);
4013 }
4014 sp->state = SRB_ACTIVE_TIMEOUT_STATE;
4015 spin_unlock_irqrestore(&dest_ha->hardware_lock, flags);
4016 } else {
4017 spin_unlock_irqrestore(&dest_ha->hardware_lock, flags);
4018 printk(KERN_INFO
4019 "qla_cmd_timeout: State indicates it is with "
4020 "ISP, But not in active array\n");
4021 }
4022 spin_lock_irqsave(&dest_ha->list_lock, cpu_flags);
4023 } else if (sp->state == SRB_ACTIVE_TIMEOUT_STATE) {
4024 DEBUG(printk("qla2100%ld: Found in Active timeout state"
4025 "pid %ld, State = %x., \n",
4026 dest_ha->host_no,
4027 sp->cmd->serial_number, sp->state);)
4028 } else {
4029 /* EMPTY */
4030 DEBUG2(printk("cmd_timeout%ld: LOST command state = "
4031 "0x%x, sp=%p\n",
4032 vis_ha->host_no, sp->state,sp);)
4033
4034 qla_printk(KERN_INFO, vis_ha,
4035 "cmd_timeout: LOST command state = 0x%x\n", sp->state);
4036 }
4037 spin_unlock_irqrestore(&dest_ha->list_lock, cpu_flags);
4038
4039 DEBUG3(printk("cmd_timeout: Leaving\n");)
4040}
4041
4042/**************************************************************************
4043* qla2x00_done
4044* Process completed commands.
4045*
4046* Input:
4047* old_ha = adapter block pointer.
4048*
4049**************************************************************************/
4050void
4051qla2x00_done(scsi_qla_host_t *old_ha)
4052{
4053 os_lun_t *lq;
4054 struct scsi_cmnd *cmd;
4055 unsigned long flags = 0;
4056 scsi_qla_host_t *ha;
4057 scsi_qla_host_t *vis_ha;
4058 int send_marker_once = 0;
4059 srb_t *sp, *sptemp;
4060 LIST_HEAD(local_sp_list);
4061
4062 /*
4063 * Get into local queue such that we do not wind up calling done queue
4064 * tasklet for the same IOs from DPC or any other place.
4065 */
4066 spin_lock_irqsave(&old_ha->list_lock, flags);
4067 list_splice_init(&old_ha->done_queue, &local_sp_list);
4068 spin_unlock_irqrestore(&old_ha->list_lock, flags);
4069
4070 /*
4071 * All done commands are in the local queue, now do the call back.
4072 */
4073 list_for_each_entry_safe(sp, sptemp, &local_sp_list, list) {
4074 old_ha->done_q_cnt--;
4075 sp->state = SRB_NO_QUEUE_STATE;
4076
4077 /* remove command from local list */
4078 list_del_init(&sp->list);
4079
4080 cmd = sp->cmd;
4081 if (cmd == NULL)
4082 continue;
4083
4084 vis_ha = (scsi_qla_host_t *)cmd->device->host->hostdata;
4085 lq = sp->lun_queue;
4086 ha = sp->ha;
4087
4088 if (sp->flags & SRB_DMA_VALID) {
4089 sp->flags &= ~SRB_DMA_VALID;
4090
4091 /* Release memory used for this I/O */
4092 if (cmd->use_sg) {
4093 pci_unmap_sg(ha->pdev, cmd->request_buffer,
4094 cmd->use_sg, cmd->sc_data_direction);
4095 } else if (cmd->request_bufflen) {
4096 pci_unmap_page(ha->pdev, sp->dma_handle,
4097 cmd->request_bufflen,
4098 cmd->sc_data_direction);
4099 }
4100 }
4101
4102
4103 switch (host_byte(cmd->result)) {
4104 case DID_OK:
4105 case DID_ERROR:
4106 break;
4107
4108 case DID_RESET:
4109 /*
4110 * Set marker needed, so we don't have to
4111 * send multiple markers
4112 */
4113 if (!send_marker_once) {
4114 ha->marker_needed = 1;
4115 send_marker_once++;
4116 }
4117
4118 /*
4119 * WORKAROUND
4120 *
4121 * A backdoor device-reset requires different
4122 * error handling. This code differentiates
4123 * between normal error handling and the
4124 * backdoor method.
4125 *
4126 */
4127 if (ha->host->eh_active != EH_ACTIVE)
4128 cmd->result = DID_BUS_BUSY << 16;
4129 break;
4130
4131
4132 case DID_ABORT:
4133 sp->flags &= ~SRB_ABORT_PENDING;
4134 sp->flags |= SRB_ABORTED;
4135
4136 if (sp->flags & SRB_TIMEOUT)
4137 cmd->result = DID_TIME_OUT << 16;
4138
4139 break;
4140
4141 default:
4142 DEBUG2(printk("scsi(%ld:%d:%d) %s: did_error "
4143 "= %d, comp-scsi= 0x%x-0x%x pid=%ld.\n",
4144 vis_ha->host_no,
4145 cmd->device->id, cmd->device->lun,
4146 __func__,
4147 host_byte(cmd->result),
4148 CMD_COMPL_STATUS(cmd),
4149 CMD_SCSI_STATUS(cmd), cmd->serial_number));
4150 break;
4151 }
4152
4153 /*
4154 * Call the mid-level driver interrupt handler -- via sp_put()
4155 */
4156 sp_put(ha, sp);
4157 } /* end of while */
4158}
4159
4160/*
4161 * qla2x00_process_response_queue_in_zio_mode
4162 * Process response queue completion as fast as possible
4163 * to achieve Zero Interrupt Opertions-ZIO
4164 *
4165 * Input:
4166 * ha = adapter block pointer.
4167 *
4168 * Context:
4169 * Kernel context.
4170 */
4171static inline void
4172qla2x00_process_response_queue_in_zio_mode(scsi_qla_host_t *ha)
4173{
4174 unsigned long flags;
4175
4176 /* Check for unprocessed commands in response queue. */
4177 if (!ha->flags.process_response_queue)
4178 return;
4179 if (!ha->flags.online)
4180 return;
4181 if (ha->response_ring_ptr->signature == RESPONSE_PROCESSED)
4182 return;
4183
4184 spin_lock_irqsave(&ha->hardware_lock,flags);
4185 qla2x00_process_response_queue(ha);
4186 spin_unlock_irqrestore(&ha->hardware_lock, flags);
4187}
4188
4189/*
4190 * qla2x00_next
4191 * Retrieve and process next job in the LUN queue.
4192 *
4193 * Input:
4194 * tq = SCSI target queue pointer.
4195 * lq = SCSI LUN queue pointer.
4196 * TGT_LOCK must be already obtained.
4197 *
4198 * Output:
4199 * Releases TGT_LOCK upon exit.
4200 *
4201 * Context:
4202 * Kernel/Interrupt context.
4203 *
4204 * Note: This routine will always try to start I/O from visible HBA.
4205 */
4206void
4207qla2x00_next(scsi_qla_host_t *vis_ha)
4208{
4209 int rval;
4210 unsigned long flags;
4211 scsi_qla_host_t *dest_ha;
4212 fc_port_t *fcport;
4213 srb_t *sp, *sptemp;
4214 LIST_HEAD(local_sp_list);
4215
4216 dest_ha = NULL;
4217
4218 spin_lock_irqsave(&vis_ha->list_lock, flags);
4219 list_splice_init(&vis_ha->pending_queue, &local_sp_list);
4220 vis_ha->qthreads = 0;
4221 spin_unlock_irqrestore(&vis_ha->list_lock, flags);
4222
4223 list_for_each_entry_safe(sp, sptemp, &local_sp_list, list) {
4224 list_del_init(&sp->list);
4225 sp->state = SRB_NO_QUEUE_STATE;
4226
4227 fcport = sp->fclun->fcport;
4228 dest_ha = fcport->ha;
4229
4230 /* If device is dead then send request back to OS */
4231 if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD) {
4232 sp->cmd->result = DID_NO_CONNECT << 16;
4233 if (atomic_read(&dest_ha->loop_state) == LOOP_DOWN)
4234 sp->err_id = SRB_ERR_LOOP;
4235 else
4236 sp->err_id = SRB_ERR_PORT;
4237
4238 DEBUG3(printk("scsi(%ld): loop/port is down - pid=%ld, "
4239 "sp=%p err_id=%d loopid=0x%x queued to dest HBA "
4240 "scsi%ld.\n", dest_ha->host_no,
4241 sp->cmd->serial_number, sp, sp->err_id,
4242 fcport->loop_id, dest_ha->host_no));
4243 /*
4244 * Initiate a failover - done routine will initiate.
4245 */
4246 add_to_done_queue(vis_ha, sp);
4247
4248 continue;
4249 }
4250
4251 /*
4252 * SCSI Kluge: Whenever, we need to wait for an event such as
4253 * loop down (i.e. loop_down_timer ) or port down (i.e. LUN
4254 * request qeueue is suspended) then we will recycle new
4255 * commands back to the SCSI layer. We do this because this is
4256 * normally a temporary condition and we don't want the
4257 * mid-level scsi.c driver to get upset and start aborting
4258 * commands. The timeout value is extracted from the command
4259 * minus 1-second and put on a retry queue (watchdog). Once the
4260 * command timeout it is returned to the mid-level with a BUSY
4261 * status, so the mid-level will retry it. This process
4262 * continues until the LOOP DOWN time expires or the condition
4263 * goes away.
4264 */
4265 if (!(sp->flags & (SRB_IOCTL | SRB_TAPE)) &&
4266 (atomic_read(&fcport->state) != FCS_ONLINE ||
4267 test_bit(ABORT_ISP_ACTIVE, &dest_ha->dpc_flags) ||
4268 atomic_read(&dest_ha->loop_state) != LOOP_READY)) {
4269
4270 DEBUG3(printk("scsi(%ld): pid=%ld port=0x%x state=%d "
4271 "loop state=%d, loop counter=0x%x "
4272 "dpc_flags=0x%lx\n", sp->cmd->serial_number,
4273 dest_ha->host_no, fcport->loop_id,
4274 atomic_read(&fcport->state),
4275 atomic_read(&dest_ha->loop_state),
4276 atomic_read(&dest_ha->loop_down_timer),
4277 dest_ha->dpc_flags));
4278
4279 qla2x00_extend_timeout(sp->cmd, EXTEND_CMD_TIMEOUT);
4280 add_to_retry_queue(vis_ha, sp);
4281
4282 continue;
4283 }
4284
4285 /*
4286 * If this request's lun is suspended then put the request on
4287 * the scsi_retry queue.
4288 */
4289 if (!(sp->flags & (SRB_IOCTL | SRB_TAPE)) &&
4290 sp->lun_queue->q_state == LUN_STATE_WAIT) {
4291 DEBUG3(printk("scsi(%ld): lun wait state - pid=%ld, "
4292 "opcode=%d, allowed=%d, retries=%d\n",
4293 dest_ha->host_no,
4294 sp->cmd->serial_number,
4295 sp->cmd->cmnd[0],
4296 sp->cmd->allowed,
4297 sp->cmd->retries));
4298
4299 add_to_scsi_retry_queue(vis_ha, sp);
4300
4301 continue;
4302 }
4303
4304 sp->lun_queue->io_cnt++;
4305
4306 rval = qla2x00_start_scsi(sp);
4307 if (rval != QLA_SUCCESS) {
4308 /* Place request back on top of device queue */
4309 /* add to the top of queue */
4310 add_to_pending_queue_head(vis_ha, sp);
4311
4312 sp->lun_queue->io_cnt--;
4313 }
4314 }
4315
4316 if (!IS_QLA2100(vis_ha) && !IS_QLA2200(vis_ha)) {
4317 /* Process response_queue if ZIO support is enabled*/
4318 qla2x00_process_response_queue_in_zio_mode(vis_ha);
4319
4320 }
4321}
4322
4323/* XXX(hch): crude hack to emulate a down_timeout() */
4324int
4325qla2x00_down_timeout(struct semaphore *sema, unsigned long timeout)
4326{
4327 const unsigned int step = HZ/10;
4328
4329 do {
4330 if (!down_trylock(sema))
4331 return 0;
4332 set_current_state(TASK_INTERRUPTIBLE);
4333 if (schedule_timeout(step))
4334 break;
4335 } while ((timeout -= step) > 0);
4336
4337 return -ETIMEDOUT;
4338}
4339
4340static void
4341qla2xxx_get_port_id(struct scsi_target *starget)
4342{
4343 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
4344 scsi_qla_host_t *ha = to_qla_host(shost);
4345 struct fc_port *fc;
4346
4347 list_for_each_entry(fc, &ha->fcports, list) {
4348 if (fc->os_target_id == starget->id) {
4349 fc_starget_port_id(starget) = fc->d_id.b.domain << 16 |
4350 fc->d_id.b.area << 8 |
4351 fc->d_id.b.al_pa;
4352 return;
4353 }
4354 }
4355 fc_starget_port_id(starget) = -1;
4356}
4357
4358static void
4359qla2xxx_get_port_name(struct scsi_target *starget)
4360{
4361 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
4362 scsi_qla_host_t *ha = to_qla_host(shost);
4363 struct fc_port *fc;
4364
4365 list_for_each_entry(fc, &ha->fcports, list) {
4366 if (fc->os_target_id == starget->id) {
4367 fc_starget_port_name(starget) =
4368 __be64_to_cpu(*(uint64_t *)fc->port_name);
4369 return;
4370 }
4371 }
4372 fc_starget_port_name(starget) = -1;
4373}
4374
4375static void
4376qla2xxx_get_node_name(struct scsi_target *starget)
4377{
4378 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
4379 scsi_qla_host_t *ha = to_qla_host(shost);
4380 struct fc_port *fc;
4381
4382 list_for_each_entry(fc, &ha->fcports, list) {
4383 if (fc->os_target_id == starget->id) {
4384 fc_starget_node_name(starget) =
4385 __be64_to_cpu(*(uint64_t *)fc->node_name);
4386 return;
4387 }
4388 }
4389 fc_starget_node_name(starget) = -1;
4390}
4391
4392static struct fc_function_template qla2xxx_transport_functions = {
4393 .get_starget_port_id = qla2xxx_get_port_id,
4394 .show_starget_port_id = 1,
4395 .get_starget_port_name = qla2xxx_get_port_name,
4396 .show_starget_port_name = 1,
4397 .get_starget_node_name = qla2xxx_get_node_name,
4398 .show_starget_node_name = 1,
4399};
4400
4401/**
4402 * qla2x00_module_init - Module initialization.
4403 **/
4404static int __init
4405qla2x00_module_init(void)
4406{
4407 /* Allocate cache for SRBs. */
4408 sprintf(srb_cachep_name, "qla2xxx_srbs");
4409 srb_cachep = kmem_cache_create(srb_cachep_name, sizeof(srb_t), 0,
4410 SLAB_HWCACHE_ALIGN, NULL, NULL);
4411 if (srb_cachep == NULL) {
4412 printk(KERN_ERR
4413 "qla2xxx: Unable to allocate SRB cache...Failing load!\n");
4414 return -ENOMEM;
4415 }
4416
4417 /* Derive version string. */
4418 strcpy(qla2x00_version_str, QLA2XXX_VERSION);
4419#if DEBUG_QLA2100
4420 strcat(qla2x00_version_str, "-debug");
4421#endif
4422
4423 qla2xxx_transport_template = fc_attach_transport(&qla2xxx_transport_functions);
4424 if (!qla2xxx_transport_template)
4425 return -ENODEV;
4426
4427 printk(KERN_INFO "QLogic Fibre Channel HBA Driver\n");
4428 return 0;
4429}
4430
4431/**
4432 * qla2x00_module_exit - Module cleanup.
4433 **/
4434static void __exit
4435qla2x00_module_exit(void)
4436{
4437 /* Free SRBs cache. */
4438 if (srb_cachep != NULL) {
4439 if (kmem_cache_destroy(srb_cachep) != 0) {
4440 printk(KERN_ERR
4441 "qla2xxx: Unable to free SRB cache...Memory pools "
4442 "still active?\n");
4443 }
4444 srb_cachep = NULL;
4445 }
4446
4447 fc_release_transport(qla2xxx_transport_template);
4448}
4449
4450module_init(qla2x00_module_init);
4451module_exit(qla2x00_module_exit);
4452
4453MODULE_AUTHOR("QLogic Corporation");
4454MODULE_DESCRIPTION("QLogic Fibre Channel HBA Driver");
4455MODULE_LICENSE("GPL");
4456MODULE_VERSION(QLA2XXX_VERSION);
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-07 20:04:15 -0500