2 * Device driver for the SYMBIOS/LSILOGIC 53C8XX and 53C1010 family
3 * of PCI-SCSI IO processors.
5 * Copyright (C) 1999-2001 Gerard Roudier <groudier@free.fr>
6 * Copyright (c) 2003-2005 Matthew Wilcox <matthew@wil.cx>
8 * This driver is derived from the Linux sym53c8xx driver.
9 * Copyright (C) 1998-2000 Gerard Roudier
11 * The sym53c8xx driver is derived from the ncr53c8xx driver that had been
12 * a port of the FreeBSD ncr driver to Linux-1.2.13.
14 * The original ncr driver has been written for 386bsd and FreeBSD by
15 * Wolfgang Stanglmeier <wolf@cologne.de>
16 * Stefan Esser <se@mi.Uni-Koeln.de>
17 * Copyright (C) 1994 Wolfgang Stanglmeier
19 * Other major contributions:
21 * NVRAM detection and reading.
22 * Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk>
24 *-----------------------------------------------------------------------------
26 * This program is free software; you can redistribute it and/or modify
27 * it under the terms of the GNU General Public License as published by
28 * the Free Software Foundation; either version 2 of the License, or
29 * (at your option) any later version.
31 * This program is distributed in the hope that it will be useful,
32 * but WITHOUT ANY WARRANTY; without even the implied warranty of
33 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
34 * GNU General Public License for more details.
36 * You should have received a copy of the GNU General Public License
37 * along with this program; if not, write to the Free Software
38 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
40 #include <linux/ctype.h>
41 #include <linux/init.h>
42 #include <linux/interrupt.h>
43 #include <linux/module.h>
44 #include <linux/moduleparam.h>
45 #include <linux/spinlock.h>
46 #include <scsi/scsi.h>
47 #include <scsi/scsi_tcq.h>
48 #include <scsi/scsi_device.h>
49 #include <scsi/scsi_transport.h>
52 #include "sym_nvram.h"
54 #define NAME53C "sym53c"
55 #define NAME53C8XX "sym53c8xx"
57 /* SPARC just has to be different ... */
60 #define IRQ_PRM(x) __irq_itoa(x)
63 #define IRQ_PRM(x) (x)
66 struct sym_driver_setup sym_driver_setup
= SYM_LINUX_DRIVER_SETUP
;
67 unsigned int sym_debug_flags
= 0;
69 static char *excl_string
;
70 static char *safe_string
;
71 module_param_named(cmd_per_lun
, sym_driver_setup
.max_tag
, ushort
, 0);
72 module_param_string(tag_ctrl
, sym_driver_setup
.tag_ctrl
, 100, 0);
73 module_param_named(burst
, sym_driver_setup
.burst_order
, byte
, 0);
74 module_param_named(led
, sym_driver_setup
.scsi_led
, byte
, 0);
75 module_param_named(diff
, sym_driver_setup
.scsi_diff
, byte
, 0);
76 module_param_named(irqm
, sym_driver_setup
.irq_mode
, byte
, 0);
77 module_param_named(buschk
, sym_driver_setup
.scsi_bus_check
, byte
, 0);
78 module_param_named(hostid
, sym_driver_setup
.host_id
, byte
, 0);
79 module_param_named(verb
, sym_driver_setup
.verbose
, byte
, 0);
80 module_param_named(debug
, sym_debug_flags
, uint
, 0);
81 module_param_named(settle
, sym_driver_setup
.settle_delay
, byte
, 0);
82 module_param_named(nvram
, sym_driver_setup
.use_nvram
, byte
, 0);
83 module_param_named(excl
, excl_string
, charp
, 0);
84 module_param_named(safe
, safe_string
, charp
, 0);
86 MODULE_PARM_DESC(cmd_per_lun
, "The maximum number of tags to use by default");
87 MODULE_PARM_DESC(tag_ctrl
, "More detailed control over tags per LUN");
88 MODULE_PARM_DESC(burst
, "Maximum burst. 0 to disable, 255 to read from registers");
89 MODULE_PARM_DESC(led
, "Set to 1 to enable LED support");
90 MODULE_PARM_DESC(diff
, "0 for no differential mode, 1 for BIOS, 2 for always, 3 for not GPIO3");
91 MODULE_PARM_DESC(irqm
, "0 for open drain, 1 to leave alone, 2 for totem pole");
92 MODULE_PARM_DESC(buschk
, "0 to not check, 1 for detach on error, 2 for warn on error");
93 MODULE_PARM_DESC(hostid
, "The SCSI ID to use for the host adapters");
94 MODULE_PARM_DESC(verb
, "0 for minimal verbosity, 1 for normal, 2 for excessive");
95 MODULE_PARM_DESC(debug
, "Set bits to enable debugging");
96 MODULE_PARM_DESC(settle
, "Settle delay in seconds. Default 3");
97 MODULE_PARM_DESC(nvram
, "Option currently not used");
98 MODULE_PARM_DESC(excl
, "List ioport addresses here to prevent controllers from being attached");
99 MODULE_PARM_DESC(safe
, "Set other settings to a \"safe mode\"");
101 MODULE_LICENSE("GPL");
102 MODULE_VERSION(SYM_VERSION
);
103 MODULE_AUTHOR("Matthew Wilcox <matthew@wil.cx>");
104 MODULE_DESCRIPTION("NCR, Symbios and LSI 8xx and 1010 PCI SCSI adapters");
106 static void sym2_setup_params(void)
108 char *p
= excl_string
;
111 while (p
&& (xi
< 8)) {
113 int val
= (int) simple_strtoul(p
, &next_p
, 0);
114 sym_driver_setup
.excludes
[xi
++] = val
;
119 if (*safe_string
== 'y') {
120 sym_driver_setup
.max_tag
= 0;
121 sym_driver_setup
.burst_order
= 0;
122 sym_driver_setup
.scsi_led
= 0;
123 sym_driver_setup
.scsi_diff
= 1;
124 sym_driver_setup
.irq_mode
= 0;
125 sym_driver_setup
.scsi_bus_check
= 2;
126 sym_driver_setup
.host_id
= 7;
127 sym_driver_setup
.verbose
= 2;
128 sym_driver_setup
.settle_delay
= 10;
129 sym_driver_setup
.use_nvram
= 1;
130 } else if (*safe_string
!= 'n') {
131 printk(KERN_WARNING NAME53C8XX
"Ignoring parameter %s"
132 " passed to safe option", safe_string
);
138 * We used to try to deal with 64-bit BARs here, but don't any more.
139 * There are many parts of this driver which would need to be modified
140 * to handle a 64-bit base address, including scripts. I'm uncomfortable
141 * with making those changes when I have no way of testing it, so I'm
142 * just going to disable it.
144 * Note that some machines (eg HP rx8620 and Superdome) have bus addresses
145 * below 4GB and physical addresses above 4GB. These will continue to work.
148 pci_get_base_address(struct pci_dev
*pdev
, int index
, unsigned long *basep
)
152 #define PCI_BAR_OFFSET(index) (PCI_BASE_ADDRESS_0 + (index<<2))
154 pci_read_config_dword(pdev
, PCI_BAR_OFFSET(index
++), &tmp
);
156 if ((tmp
& 0x7) == PCI_BASE_ADDRESS_MEM_TYPE_64
) {
157 pci_read_config_dword(pdev
, PCI_BAR_OFFSET(index
++), &tmp
);
160 "BAR %d is 64-bit, disabling\n", index
- 1);
164 if ((base
& PCI_BASE_ADDRESS_SPACE
) == PCI_BASE_ADDRESS_SPACE_IO
) {
165 base
&= PCI_BASE_ADDRESS_IO_MASK
;
167 base
&= PCI_BASE_ADDRESS_MEM_MASK
;
172 #undef PCI_BAR_OFFSET
175 static struct scsi_transport_template
*sym2_transport_template
= NULL
;
178 * Used by the eh thread to wait for command completion.
179 * It is allocated on the eh thread stack.
182 struct completion done
;
183 struct timer_list timer
;
184 void (*old_done
)(struct scsi_cmnd
*);
190 * Driver private area in the SCSI command structure.
192 struct sym_ucmd
{ /* Override the SCSI pointer structure */
193 dma_addr_t data_mapping
;
195 struct sym_eh_wait
*eh_wait
;
198 #define SYM_UCMD_PTR(cmd) ((struct sym_ucmd *)(&(cmd)->SCp))
199 #define SYM_SOFTC_PTR(cmd) sym_get_hcb(cmd->device->host)
201 static void __unmap_scsi_data(struct pci_dev
*pdev
, struct scsi_cmnd
*cmd
)
203 int dma_dir
= cmd
->sc_data_direction
;
205 switch(SYM_UCMD_PTR(cmd
)->data_mapped
) {
207 pci_unmap_sg(pdev
, cmd
->buffer
, cmd
->use_sg
, dma_dir
);
210 pci_unmap_single(pdev
, SYM_UCMD_PTR(cmd
)->data_mapping
,
211 cmd
->request_bufflen
, dma_dir
);
214 SYM_UCMD_PTR(cmd
)->data_mapped
= 0;
217 static dma_addr_t
__map_scsi_single_data(struct pci_dev
*pdev
, struct scsi_cmnd
*cmd
)
220 int dma_dir
= cmd
->sc_data_direction
;
222 mapping
= pci_map_single(pdev
, cmd
->request_buffer
,
223 cmd
->request_bufflen
, dma_dir
);
225 SYM_UCMD_PTR(cmd
)->data_mapped
= 1;
226 SYM_UCMD_PTR(cmd
)->data_mapping
= mapping
;
232 static int __map_scsi_sg_data(struct pci_dev
*pdev
, struct scsi_cmnd
*cmd
)
235 int dma_dir
= cmd
->sc_data_direction
;
237 use_sg
= pci_map_sg(pdev
, cmd
->buffer
, cmd
->use_sg
, dma_dir
);
239 SYM_UCMD_PTR(cmd
)->data_mapped
= 2;
240 SYM_UCMD_PTR(cmd
)->data_mapping
= use_sg
;
246 #define unmap_scsi_data(np, cmd) \
247 __unmap_scsi_data(np->s.device, cmd)
248 #define map_scsi_single_data(np, cmd) \
249 __map_scsi_single_data(np->s.device, cmd)
250 #define map_scsi_sg_data(np, cmd) \
251 __map_scsi_sg_data(np->s.device, cmd)
253 * Complete a pending CAM CCB.
255 void sym_xpt_done(struct sym_hcb
*np
, struct scsi_cmnd
*cmd
)
257 unmap_scsi_data(np
, cmd
);
261 static void sym_xpt_done2(struct sym_hcb
*np
, struct scsi_cmnd
*cmd
, int cam_status
)
263 sym_set_cam_status(cmd
, cam_status
);
264 sym_xpt_done(np
, cmd
);
269 * Tell the SCSI layer about a BUS RESET.
271 void sym_xpt_async_bus_reset(struct sym_hcb
*np
)
273 printf_notice("%s: SCSI BUS has been reset.\n", sym_name(np
));
274 np
->s
.settle_time
= jiffies
+ sym_driver_setup
.settle_delay
* HZ
;
275 np
->s
.settle_time_valid
= 1;
276 if (sym_verbose
>= 2)
277 printf_info("%s: command processing suspended for %d seconds\n",
278 sym_name(np
), sym_driver_setup
.settle_delay
);
282 * Tell the SCSI layer about a BUS DEVICE RESET message sent.
284 void sym_xpt_async_sent_bdr(struct sym_hcb
*np
, int target
)
286 printf_notice("%s: TARGET %d has been reset.\n", sym_name(np
), target
);
290 * Choose the more appropriate CAM status if
291 * the IO encountered an extended error.
293 static int sym_xerr_cam_status(int cam_status
, int x_status
)
296 if (x_status
& XE_PARITY_ERR
)
297 cam_status
= DID_PARITY
;
298 else if (x_status
&(XE_EXTRA_DATA
|XE_SODL_UNRUN
|XE_SWIDE_OVRUN
))
299 cam_status
= DID_ERROR
;
300 else if (x_status
& XE_BAD_PHASE
)
301 cam_status
= DID_ERROR
;
303 cam_status
= DID_ERROR
;
309 * Build CAM result for a failed or auto-sensed IO.
311 void sym_set_cam_result_error(struct sym_hcb
*np
, struct sym_ccb
*cp
, int resid
)
313 struct scsi_cmnd
*cmd
= cp
->cmd
;
314 u_int cam_status
, scsi_status
, drv_status
;
318 scsi_status
= cp
->ssss_status
;
320 if (cp
->host_flags
& HF_SENSE
) {
321 scsi_status
= cp
->sv_scsi_status
;
322 resid
= cp
->sv_resid
;
323 if (sym_verbose
&& cp
->sv_xerr_status
)
324 sym_print_xerr(cmd
, cp
->sv_xerr_status
);
325 if (cp
->host_status
== HS_COMPLETE
&&
326 cp
->ssss_status
== S_GOOD
&&
327 cp
->xerr_status
== 0) {
328 cam_status
= sym_xerr_cam_status(DID_OK
,
330 drv_status
= DRIVER_SENSE
;
332 * Bounce back the sense data to user.
334 memset(&cmd
->sense_buffer
, 0, sizeof(cmd
->sense_buffer
));
335 memcpy(cmd
->sense_buffer
, cp
->sns_bbuf
,
336 min(sizeof(cmd
->sense_buffer
),
337 (size_t)SYM_SNS_BBUF_LEN
));
340 * If the device reports a UNIT ATTENTION condition
341 * due to a RESET condition, we should consider all
342 * disconnect CCBs for this unit as aborted.
346 p
= (u_char
*) cmd
->sense_data
;
347 if (p
[0]==0x70 && p
[2]==0x6 && p
[12]==0x29)
348 sym_clear_tasks(np
, DID_ABORT
,
349 cp
->target
,cp
->lun
, -1);
354 * Error return from our internal request sense. This
355 * is bad: we must clear the contingent allegiance
356 * condition otherwise the device will always return
357 * BUSY. Use a big stick.
359 sym_reset_scsi_target(np
, cmd
->device
->id
);
360 cam_status
= DID_ERROR
;
362 } else if (cp
->host_status
== HS_COMPLETE
) /* Bad SCSI status */
364 else if (cp
->host_status
== HS_SEL_TIMEOUT
) /* Selection timeout */
365 cam_status
= DID_NO_CONNECT
;
366 else if (cp
->host_status
== HS_UNEXPECTED
) /* Unexpected BUS FREE*/
367 cam_status
= DID_ERROR
;
368 else { /* Extended error */
370 sym_print_addr(cmd
, "COMMAND FAILED (%x %x %x).\n",
371 cp
->host_status
, cp
->ssss_status
,
375 * Set the most appropriate value for CAM status.
377 cam_status
= sym_xerr_cam_status(DID_ERROR
, cp
->xerr_status
);
380 cmd
->result
= (drv_status
<< 24) + (cam_status
<< 16) + scsi_status
;
385 * Build the scatter/gather array for an I/O.
388 static int sym_scatter_no_sglist(struct sym_hcb
*np
, struct sym_ccb
*cp
, struct scsi_cmnd
*cmd
)
390 struct sym_tblmove
*data
= &cp
->phys
.data
[SYM_CONF_MAX_SG
-1];
393 cp
->data_len
= cmd
->request_bufflen
;
395 if (cmd
->request_bufflen
) {
396 dma_addr_t baddr
= map_scsi_single_data(np
, cmd
);
398 sym_build_sge(np
, data
, baddr
, cmd
->request_bufflen
);
410 static int sym_scatter(struct sym_hcb
*np
, struct sym_ccb
*cp
, struct scsi_cmnd
*cmd
)
413 int use_sg
= (int) cmd
->use_sg
;
418 segment
= sym_scatter_no_sglist(np
, cp
, cmd
);
419 else if ((use_sg
= map_scsi_sg_data(np
, cmd
)) > 0) {
420 struct scatterlist
*scatter
= (struct scatterlist
*)cmd
->buffer
;
421 struct sym_tblmove
*data
;
423 if (use_sg
> SYM_CONF_MAX_SG
) {
424 unmap_scsi_data(np
, cmd
);
428 data
= &cp
->phys
.data
[SYM_CONF_MAX_SG
- use_sg
];
430 for (segment
= 0; segment
< use_sg
; segment
++) {
431 dma_addr_t baddr
= sg_dma_address(&scatter
[segment
]);
432 unsigned int len
= sg_dma_len(&scatter
[segment
]);
434 sym_build_sge(np
, &data
[segment
], baddr
, len
);
445 * Queue a SCSI command.
447 static int sym_queue_command(struct sym_hcb
*np
, struct scsi_cmnd
*cmd
)
449 struct scsi_device
*sdev
= cmd
->device
;
456 * Minimal checkings, so that we will not
457 * go outside our tables.
459 if (sdev
->id
== np
->myaddr
||
460 sdev
->id
>= SYM_CONF_MAX_TARGET
||
461 sdev
->lun
>= SYM_CONF_MAX_LUN
) {
462 sym_xpt_done2(np
, cmd
, CAM_DEV_NOT_THERE
);
467 * Retrieve the target descriptor.
469 tp
= &np
->target
[sdev
->id
];
472 * Complete the 1st INQUIRY command with error
473 * condition if the device is flagged NOSCAN
474 * at BOOT in the NVRAM. This may speed up
475 * the boot and maintain coherency with BIOS
476 * device numbering. Clearing the flag allows
477 * user to rescan skipped devices later.
478 * We also return error for devices not flagged
479 * for SCAN LUNS in the NVRAM since some mono-lun
480 * devices behave badly when asked for some non
481 * zero LUN. Btw, this is an absolute hack.:-)
483 if (cmd
->cmnd
[0] == 0x12 || cmd
->cmnd
[0] == 0x0) {
484 if ((tp
->usrflags
& SYM_SCAN_BOOT_DISABLED
) ||
485 ((tp
->usrflags
& SYM_SCAN_LUNS_DISABLED
) &&
487 tp
->usrflags
&= ~SYM_SCAN_BOOT_DISABLED
;
488 sym_xpt_done2(np
, cmd
, CAM_DEV_NOT_THERE
);
494 * Select tagged/untagged.
496 lp
= sym_lp(tp
, sdev
->lun
);
497 order
= (lp
&& lp
->s
.reqtags
) ? M_SIMPLE_TAG
: 0;
502 cp
= sym_get_ccb(np
, cmd
, order
);
504 return 1; /* Means resource shortage */
505 sym_queue_scsiio(np
, cmd
, cp
);
510 * Setup buffers and pointers that address the CDB.
512 static inline int sym_setup_cdb(struct sym_hcb
*np
, struct scsi_cmnd
*cmd
, struct sym_ccb
*cp
)
518 * CDB is 16 bytes max.
520 if (cmd
->cmd_len
> sizeof(cp
->cdb_buf
)) {
521 sym_set_cam_status(cp
->cmd
, CAM_REQ_INVALID
);
525 memcpy(cp
->cdb_buf
, cmd
->cmnd
, cmd
->cmd_len
);
526 cmd_ba
= CCB_BA (cp
, cdb_buf
[0]);
527 cmd_len
= cmd
->cmd_len
;
529 cp
->phys
.cmd
.addr
= cpu_to_scr(cmd_ba
);
530 cp
->phys
.cmd
.size
= cpu_to_scr(cmd_len
);
536 * Setup pointers that address the data and start the I/O.
538 int sym_setup_data_and_start(struct sym_hcb
*np
, struct scsi_cmnd
*cmd
, struct sym_ccb
*cp
)
541 struct sym_tcb
*tp
= &np
->target
[cp
->target
];
542 struct sym_lcb
*lp
= sym_lp(tp
, cp
->lun
);
547 if (sym_setup_cdb(np
, cmd
, cp
))
551 * No direction means no data.
553 dir
= cmd
->sc_data_direction
;
554 if (dir
!= DMA_NONE
) {
555 cp
->segments
= sym_scatter(np
, cp
, cmd
);
556 if (cp
->segments
< 0) {
557 if (cp
->segments
== -2)
558 sym_set_cam_status(cmd
, CAM_RESRC_UNAVAIL
);
560 sym_set_cam_status(cmd
, CAM_REQ_TOO_BIG
);
571 sym_setup_data_pointers(np
, cp
, dir
);
574 * When `#ifed 1', the code below makes the driver
575 * panic on the first attempt to write to a SCSI device.
576 * It is the first test we want to do after a driver
577 * change that does not seem obviously safe. :)
580 switch (cp
->cdb_buf
[0]) {
581 case 0x0A: case 0x2A: case 0xAA:
582 panic("XXXXXXXXXXXXX WRITE NOT YET ALLOWED XXXXXXXXXXXXXX\n");
593 sym_start_next_ccbs(np
, lp
, 2);
595 sym_put_start_queue(np
, cp
);
599 sym_free_ccb(np
, cp
);
600 sym_xpt_done(np
, cmd
);
608 * Misused to keep the driver running when
609 * interrupts are not configured correctly.
611 static void sym_timer(struct sym_hcb
*np
)
613 unsigned long thistime
= jiffies
;
618 np
->s
.timer
.expires
= thistime
+ SYM_CONF_TIMER_INTERVAL
;
619 add_timer(&np
->s
.timer
);
622 * If we are resetting the ncr, wait for settle_time before
623 * clearing it. Then command processing will be resumed.
625 if (np
->s
.settle_time_valid
) {
626 if (time_before_eq(np
->s
.settle_time
, thistime
)) {
627 if (sym_verbose
>= 2 )
628 printk("%s: command processing resumed\n",
630 np
->s
.settle_time_valid
= 0;
636 * Nothing to do for now, but that may come.
638 if (np
->s
.lasttime
+ 4*HZ
< thistime
) {
639 np
->s
.lasttime
= thistime
;
642 #ifdef SYM_CONF_PCIQ_MAY_MISS_COMPLETIONS
644 * Some way-broken PCI bridges may lead to
645 * completions being lost when the clearing
646 * of the INTFLY flag by the CPU occurs
647 * concurrently with the chip raising this flag.
648 * If this ever happen, lost completions will
657 * PCI BUS error handler.
659 void sym_log_bus_error(struct sym_hcb
*np
)
662 pci_read_config_word(np
->s
.device
, PCI_STATUS
, &pci_sts
);
663 if (pci_sts
& 0xf900) {
664 pci_write_config_word(np
->s
.device
, PCI_STATUS
, pci_sts
);
665 printf("%s: PCI STATUS = 0x%04x\n",
666 sym_name(np
), pci_sts
& 0xf900);
671 * queuecommand method. Entered with the host adapter lock held and
672 * interrupts disabled.
674 static int sym53c8xx_queue_command(struct scsi_cmnd
*cmd
,
675 void (*done
)(struct scsi_cmnd
*))
677 struct sym_hcb
*np
= SYM_SOFTC_PTR(cmd
);
678 struct sym_ucmd
*ucp
= SYM_UCMD_PTR(cmd
);
681 cmd
->scsi_done
= done
;
682 memset(ucp
, 0, sizeof(*ucp
));
685 * Shorten our settle_time if needed for
686 * this command not to time out.
688 if (np
->s
.settle_time_valid
&& cmd
->timeout_per_command
) {
689 unsigned long tlimit
= jiffies
+ cmd
->timeout_per_command
;
690 tlimit
-= SYM_CONF_TIMER_INTERVAL
*2;
691 if (time_after(np
->s
.settle_time
, tlimit
)) {
692 np
->s
.settle_time
= tlimit
;
696 if (np
->s
.settle_time_valid
)
697 return SCSI_MLQUEUE_HOST_BUSY
;
699 sts
= sym_queue_command(np
, cmd
);
701 return SCSI_MLQUEUE_HOST_BUSY
;
706 * Linux entry point of the interrupt handler.
708 static irqreturn_t
sym53c8xx_intr(int irq
, void *dev_id
, struct pt_regs
* regs
)
711 struct sym_hcb
*np
= (struct sym_hcb
*)dev_id
;
713 if (DEBUG_FLAGS
& DEBUG_TINY
) printf_debug ("[");
715 spin_lock_irqsave(np
->s
.host
->host_lock
, flags
);
717 spin_unlock_irqrestore(np
->s
.host
->host_lock
, flags
);
719 if (DEBUG_FLAGS
& DEBUG_TINY
) printf_debug ("]\n");
725 * Linux entry point of the timer handler
727 static void sym53c8xx_timer(unsigned long npref
)
729 struct sym_hcb
*np
= (struct sym_hcb
*)npref
;
732 spin_lock_irqsave(np
->s
.host
->host_lock
, flags
);
734 spin_unlock_irqrestore(np
->s
.host
->host_lock
, flags
);
739 * What the eh thread wants us to perform.
741 #define SYM_EH_ABORT 0
742 #define SYM_EH_DEVICE_RESET 1
743 #define SYM_EH_BUS_RESET 2
744 #define SYM_EH_HOST_RESET 3
747 * What we will do regarding the involved SCSI command.
749 #define SYM_EH_DO_IGNORE 0
750 #define SYM_EH_DO_COMPLETE 1
751 #define SYM_EH_DO_WAIT 2
754 * Our general completion handler.
756 static void __sym_eh_done(struct scsi_cmnd
*cmd
, int timed_out
)
758 struct sym_eh_wait
*ep
= SYM_UCMD_PTR(cmd
)->eh_wait
;
762 /* Try to avoid a race here (not 100% safe) */
765 if (ep
->to_do
== SYM_EH_DO_WAIT
&& !del_timer(&ep
->timer
))
769 /* Revert everything */
770 SYM_UCMD_PTR(cmd
)->eh_wait
= NULL
;
771 cmd
->scsi_done
= ep
->old_done
;
773 /* Wake up the eh thread if it wants to sleep */
774 if (ep
->to_do
== SYM_EH_DO_WAIT
)
779 * scsi_done() alias when error recovery is in progress.
781 static void sym_eh_done(struct scsi_cmnd
*cmd
) { __sym_eh_done(cmd
, 0); }
784 * Some timeout handler to avoid waiting too long.
786 static void sym_eh_timeout(u_long p
) { __sym_eh_done((struct scsi_cmnd
*)p
, 1); }
789 * Generic method for our eh processing.
790 * The 'op' argument tells what we have to do.
792 static int sym_eh_handler(int op
, char *opname
, struct scsi_cmnd
*cmd
)
794 struct sym_hcb
*np
= SYM_SOFTC_PTR(cmd
);
796 int to_do
= SYM_EH_DO_IGNORE
;
798 struct sym_eh_wait eh
, *ep
= &eh
;
800 dev_warn(&cmd
->device
->sdev_gendev
, "%s operation started.\n", opname
);
803 /* This one should be the result of some race, thus to ignore */
804 if (cmd
->serial_number
!= cmd
->serial_number_at_timeout
)
808 /* This one is queued in some place -> to wait for completion */
809 FOR_EACH_QUEUED_ELEMENT(&np
->busy_ccbq
, qp
) {
810 struct sym_ccb
*cp
= sym_que_entry(qp
, struct sym_ccb
, link_ccbq
);
811 if (cp
->cmd
== cmd
) {
812 to_do
= SYM_EH_DO_WAIT
;
818 /* Prepare stuff to either ignore, complete or wait for completion */
821 case SYM_EH_DO_IGNORE
:
824 init_completion(&ep
->done
);
826 case SYM_EH_DO_COMPLETE
:
827 ep
->old_done
= cmd
->scsi_done
;
828 cmd
->scsi_done
= sym_eh_done
;
829 SYM_UCMD_PTR(cmd
)->eh_wait
= ep
;
832 /* Try to proceed the operation we have been asked for */
836 sts
= sym_abort_scsiio(np
, cmd
, 1);
838 case SYM_EH_DEVICE_RESET
:
839 sts
= sym_reset_scsi_target(np
, cmd
->device
->id
);
841 case SYM_EH_BUS_RESET
:
842 sym_reset_scsi_bus(np
, 1);
845 case SYM_EH_HOST_RESET
:
846 sym_reset_scsi_bus(np
, 0);
847 sym_start_up (np
, 1);
854 /* On error, restore everything and cross fingers :) */
856 SYM_UCMD_PTR(cmd
)->eh_wait
= NULL
;
857 cmd
->scsi_done
= ep
->old_done
;
858 to_do
= SYM_EH_DO_IGNORE
;
862 /* Complete the command with locks held as required by the driver */
863 if (to_do
== SYM_EH_DO_COMPLETE
)
864 sym_xpt_done2(np
, cmd
, CAM_REQ_ABORTED
);
866 /* Wait for completion with locks released, as required by kernel */
867 if (to_do
== SYM_EH_DO_WAIT
) {
868 init_timer(&ep
->timer
);
869 ep
->timer
.expires
= jiffies
+ (5*HZ
);
870 ep
->timer
.function
= sym_eh_timeout
;
871 ep
->timer
.data
= (u_long
)cmd
;
872 ep
->timed_out
= 1; /* Be pessimistic for once :) */
873 add_timer(&ep
->timer
);
874 spin_unlock_irq(np
->s
.host
->host_lock
);
875 wait_for_completion(&ep
->done
);
876 spin_lock_irq(np
->s
.host
->host_lock
);
880 dev_warn(&cmd
->device
->sdev_gendev
, "%s operation %s.\n", opname
,
881 sts
==0 ? "complete" :sts
==-2 ? "timed-out" : "failed");
882 return sts
? SCSI_FAILED
: SCSI_SUCCESS
;
887 * Error handlers called from the eh thread (one thread per HBA).
889 static int sym53c8xx_eh_abort_handler(struct scsi_cmnd
*cmd
)
891 return sym_eh_handler(SYM_EH_ABORT
, "ABORT", cmd
);
894 static int sym53c8xx_eh_device_reset_handler(struct scsi_cmnd
*cmd
)
896 return sym_eh_handler(SYM_EH_DEVICE_RESET
, "DEVICE RESET", cmd
);
899 static int sym53c8xx_eh_bus_reset_handler(struct scsi_cmnd
*cmd
)
901 return sym_eh_handler(SYM_EH_BUS_RESET
, "BUS RESET", cmd
);
904 static int sym53c8xx_eh_host_reset_handler(struct scsi_cmnd
*cmd
)
906 return sym_eh_handler(SYM_EH_HOST_RESET
, "HOST RESET", cmd
);
910 * Tune device queuing depth, according to various limits.
912 static void sym_tune_dev_queuing(struct sym_tcb
*tp
, int lun
, u_short reqtags
)
914 struct sym_lcb
*lp
= sym_lp(tp
, lun
);
920 oldtags
= lp
->s
.reqtags
;
922 if (reqtags
> lp
->s
.scdev_depth
)
923 reqtags
= lp
->s
.scdev_depth
;
925 lp
->started_limit
= reqtags
? reqtags
: 2;
927 lp
->s
.reqtags
= reqtags
;
929 if (reqtags
!= oldtags
) {
930 dev_info(&tp
->sdev
->sdev_target
->dev
,
931 "tagged command queuing %s, command queue depth %d.\n",
932 lp
->s
.reqtags
? "enabled" : "disabled",
938 * Linux select queue depths function
940 #define DEF_DEPTH (sym_driver_setup.max_tag)
941 #define ALL_TARGETS -2
946 static int device_queue_depth(struct sym_hcb
*np
, int target
, int lun
)
949 char *p
= sym_driver_setup
.tag_ctrl
;
955 while ((c
= *p
++) != 0) {
956 v
= simple_strtoul(p
, &ep
, 0);
965 t
= (target
== v
) ? v
: NO_TARGET
;
970 u
= (lun
== v
) ? v
: NO_LUN
;
973 if (h
== np
->s
.unit
&&
974 (t
== ALL_TARGETS
|| t
== target
) &&
975 (u
== ALL_LUNS
|| u
== lun
))
990 static int sym53c8xx_slave_alloc(struct scsi_device
*device
)
992 struct sym_hcb
*np
= sym_get_hcb(device
->host
);
993 struct sym_tcb
*tp
= &np
->target
[device
->id
];
1000 static void sym53c8xx_slave_destroy(struct scsi_device
*device
)
1002 struct sym_hcb
*np
= sym_get_hcb(device
->host
);
1003 struct sym_tcb
*tp
= &np
->target
[device
->id
];
1004 if (tp
->sdev
== device
)
1009 * Linux entry point for device queue sizing.
1011 static int sym53c8xx_slave_configure(struct scsi_device
*device
)
1013 struct sym_hcb
*np
= sym_get_hcb(device
->host
);
1014 struct sym_tcb
*tp
= &np
->target
[device
->id
];
1016 int reqtags
, depth_to_use
;
1019 * Allocate the LCB if not yet.
1020 * If it fail, we may well be in the sh*t. :)
1022 lp
= sym_alloc_lcb(np
, device
->id
, device
->lun
);
1029 lp
->curr_flags
= lp
->user_flags
;
1032 * Select queue depth from driver setup.
1033 * Donnot use more than configured by user.
1035 * Donnot use more than our maximum.
1037 reqtags
= device_queue_depth(np
, device
->id
, device
->lun
);
1038 if (reqtags
> tp
->usrtags
)
1039 reqtags
= tp
->usrtags
;
1040 if (!device
->tagged_supported
)
1042 #if 1 /* Avoid to locally queue commands for no good reasons */
1043 if (reqtags
> SYM_CONF_MAX_TAG
)
1044 reqtags
= SYM_CONF_MAX_TAG
;
1045 depth_to_use
= (reqtags
? reqtags
: 2);
1047 depth_to_use
= (reqtags
? SYM_CONF_MAX_TAG
: 2);
1049 scsi_adjust_queue_depth(device
,
1050 (device
->tagged_supported
?
1051 MSG_SIMPLE_TAG
: 0),
1053 lp
->s
.scdev_depth
= depth_to_use
;
1054 sym_tune_dev_queuing(tp
, device
->lun
, reqtags
);
1056 if (!spi_initial_dv(device
->sdev_target
))
1057 spi_dv_device(device
);
1063 * Linux entry point for info() function
1065 static const char *sym53c8xx_info (struct Scsi_Host
*host
)
1067 return SYM_DRIVER_NAME
;
1071 #ifdef SYM_LINUX_PROC_INFO_SUPPORT
1073 * Proc file system stuff
1075 * A read operation returns adapter information.
1076 * A write operation is a control command.
1077 * The string is parsed in the driver code and the command is passed
1078 * to the sym_usercmd() function.
1081 #ifdef SYM_LINUX_USER_COMMAND_SUPPORT
1090 #define UC_SETSYNC 10
1091 #define UC_SETTAGS 11
1092 #define UC_SETDEBUG 12
1093 #define UC_SETWIDE 14
1094 #define UC_SETFLAG 15
1095 #define UC_SETVERBOSE 17
1096 #define UC_RESETDEV 18
1097 #define UC_CLEARDEV 19
1099 static void sym_exec_user_command (struct sym_hcb
*np
, struct sym_usrcmd
*uc
)
1107 #ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT
1109 sym_debug_flags
= uc
->data
;
1113 np
->verbose
= uc
->data
;
1117 * We assume that other commands apply to targets.
1118 * This should always be the case and avoid the below
1119 * 4 lines to be repeated 6 times.
1121 for (t
= 0; t
< SYM_CONF_MAX_TARGET
; t
++) {
1122 if (!((uc
->target
>> t
) & 1))
1124 tp
= &np
->target
[t
];
1129 if (!uc
->data
|| uc
->data
>= 255) {
1130 tp
->tgoal
.iu
= tp
->tgoal
.dt
=
1132 tp
->tgoal
.offset
= 0;
1133 } else if (uc
->data
<= 9 && np
->minsync_dt
) {
1134 if (uc
->data
< np
->minsync_dt
)
1135 uc
->data
= np
->minsync_dt
;
1136 tp
->tgoal
.iu
= tp
->tgoal
.dt
=
1138 tp
->tgoal
.width
= 1;
1139 tp
->tgoal
.period
= uc
->data
;
1140 tp
->tgoal
.offset
= np
->maxoffs_dt
;
1142 if (uc
->data
< np
->minsync
)
1143 uc
->data
= np
->minsync
;
1144 tp
->tgoal
.iu
= tp
->tgoal
.dt
=
1146 tp
->tgoal
.period
= uc
->data
;
1147 tp
->tgoal
.offset
= np
->maxoffs
;
1149 tp
->tgoal
.check_nego
= 1;
1152 tp
->tgoal
.width
= uc
->data
? 1 : 0;
1153 tp
->tgoal
.check_nego
= 1;
1156 for (l
= 0; l
< SYM_CONF_MAX_LUN
; l
++)
1157 sym_tune_dev_queuing(tp
, l
, uc
->data
);
1161 np
->istat_sem
= SEM
;
1162 OUTB(np
, nc_istat
, SIGP
|SEM
);
1165 for (l
= 0; l
< SYM_CONF_MAX_LUN
; l
++) {
1166 struct sym_lcb
*lp
= sym_lp(tp
, l
);
1167 if (lp
) lp
->to_clear
= 1;
1169 np
->istat_sem
= SEM
;
1170 OUTB(np
, nc_istat
, SIGP
|SEM
);
1173 tp
->usrflags
= uc
->data
;
1181 static int skip_spaces(char *ptr
, int len
)
1185 for (cnt
= len
; cnt
> 0 && (c
= *ptr
++) && isspace(c
); cnt
--);
1190 static int get_int_arg(char *ptr
, int len
, u_long
*pv
)
1194 *pv
= simple_strtoul(ptr
, &end
, 10);
1198 static int is_keyword(char *ptr
, int len
, char *verb
)
1200 int verb_len
= strlen(verb
);
1202 if (len
>= verb_len
&& !memcmp(verb
, ptr
, verb_len
))
1208 #define SKIP_SPACES(ptr, len) \
1209 if ((arg_len = skip_spaces(ptr, len)) < 1) \
1211 ptr += arg_len; len -= arg_len;
1213 #define GET_INT_ARG(ptr, len, v) \
1214 if (!(arg_len = get_int_arg(ptr, len, &(v)))) \
1216 ptr += arg_len; len -= arg_len;
1220 * Parse a control command
1223 static int sym_user_command(struct sym_hcb
*np
, char *buffer
, int length
)
1227 struct sym_usrcmd cmd
, *uc
= &cmd
;
1231 memset(uc
, 0, sizeof(*uc
));
1233 if (len
> 0 && ptr
[len
-1] == '\n')
1236 if ((arg_len
= is_keyword(ptr
, len
, "setsync")) != 0)
1237 uc
->cmd
= UC_SETSYNC
;
1238 else if ((arg_len
= is_keyword(ptr
, len
, "settags")) != 0)
1239 uc
->cmd
= UC_SETTAGS
;
1240 else if ((arg_len
= is_keyword(ptr
, len
, "setverbose")) != 0)
1241 uc
->cmd
= UC_SETVERBOSE
;
1242 else if ((arg_len
= is_keyword(ptr
, len
, "setwide")) != 0)
1243 uc
->cmd
= UC_SETWIDE
;
1244 #ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT
1245 else if ((arg_len
= is_keyword(ptr
, len
, "setdebug")) != 0)
1246 uc
->cmd
= UC_SETDEBUG
;
1248 else if ((arg_len
= is_keyword(ptr
, len
, "setflag")) != 0)
1249 uc
->cmd
= UC_SETFLAG
;
1250 else if ((arg_len
= is_keyword(ptr
, len
, "resetdev")) != 0)
1251 uc
->cmd
= UC_RESETDEV
;
1252 else if ((arg_len
= is_keyword(ptr
, len
, "cleardev")) != 0)
1253 uc
->cmd
= UC_CLEARDEV
;
1257 #ifdef DEBUG_PROC_INFO
1258 printk("sym_user_command: arg_len=%d, cmd=%ld\n", arg_len
, uc
->cmd
);
1263 ptr
+= arg_len
; len
-= arg_len
;
1272 SKIP_SPACES(ptr
, len
);
1273 if ((arg_len
= is_keyword(ptr
, len
, "all")) != 0) {
1274 ptr
+= arg_len
; len
-= arg_len
;
1277 GET_INT_ARG(ptr
, len
, target
);
1278 uc
->target
= (1<<target
);
1279 #ifdef DEBUG_PROC_INFO
1280 printk("sym_user_command: target=%ld\n", target
);
1291 SKIP_SPACES(ptr
, len
);
1292 GET_INT_ARG(ptr
, len
, uc
->data
);
1293 #ifdef DEBUG_PROC_INFO
1294 printk("sym_user_command: data=%ld\n", uc
->data
);
1297 #ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT
1300 SKIP_SPACES(ptr
, len
);
1301 if ((arg_len
= is_keyword(ptr
, len
, "alloc")))
1302 uc
->data
|= DEBUG_ALLOC
;
1303 else if ((arg_len
= is_keyword(ptr
, len
, "phase")))
1304 uc
->data
|= DEBUG_PHASE
;
1305 else if ((arg_len
= is_keyword(ptr
, len
, "queue")))
1306 uc
->data
|= DEBUG_QUEUE
;
1307 else if ((arg_len
= is_keyword(ptr
, len
, "result")))
1308 uc
->data
|= DEBUG_RESULT
;
1309 else if ((arg_len
= is_keyword(ptr
, len
, "scatter")))
1310 uc
->data
|= DEBUG_SCATTER
;
1311 else if ((arg_len
= is_keyword(ptr
, len
, "script")))
1312 uc
->data
|= DEBUG_SCRIPT
;
1313 else if ((arg_len
= is_keyword(ptr
, len
, "tiny")))
1314 uc
->data
|= DEBUG_TINY
;
1315 else if ((arg_len
= is_keyword(ptr
, len
, "timing")))
1316 uc
->data
|= DEBUG_TIMING
;
1317 else if ((arg_len
= is_keyword(ptr
, len
, "nego")))
1318 uc
->data
|= DEBUG_NEGO
;
1319 else if ((arg_len
= is_keyword(ptr
, len
, "tags")))
1320 uc
->data
|= DEBUG_TAGS
;
1321 else if ((arg_len
= is_keyword(ptr
, len
, "pointer")))
1322 uc
->data
|= DEBUG_POINTER
;
1325 ptr
+= arg_len
; len
-= arg_len
;
1327 #ifdef DEBUG_PROC_INFO
1328 printk("sym_user_command: data=%ld\n", uc
->data
);
1331 #endif /* SYM_LINUX_DEBUG_CONTROL_SUPPORT */
1334 SKIP_SPACES(ptr
, len
);
1335 if ((arg_len
= is_keyword(ptr
, len
, "no_disc")))
1336 uc
->data
&= ~SYM_DISC_ENABLED
;
1339 ptr
+= arg_len
; len
-= arg_len
;
1349 unsigned long flags
;
1351 spin_lock_irqsave(np
->s
.host
->host_lock
, flags
);
1352 sym_exec_user_command (np
, uc
);
1353 spin_unlock_irqrestore(np
->s
.host
->host_lock
, flags
);
1358 #endif /* SYM_LINUX_USER_COMMAND_SUPPORT */
1361 #ifdef SYM_LINUX_USER_INFO_SUPPORT
1363 * Informations through the proc file system.
1372 static void copy_mem_info(struct info_str
*info
, char *data
, int len
)
1374 if (info
->pos
+ len
> info
->length
)
1375 len
= info
->length
- info
->pos
;
1377 if (info
->pos
+ len
< info
->offset
) {
1381 if (info
->pos
< info
->offset
) {
1382 data
+= (info
->offset
- info
->pos
);
1383 len
-= (info
->offset
- info
->pos
);
1387 memcpy(info
->buffer
+ info
->pos
, data
, len
);
1392 static int copy_info(struct info_str
*info
, char *fmt
, ...)
1398 va_start(args
, fmt
);
1399 len
= vsprintf(buf
, fmt
, args
);
1402 copy_mem_info(info
, buf
, len
);
1407 * Copy formatted information into the input buffer.
1409 static int sym_host_info(struct sym_hcb
*np
, char *ptr
, off_t offset
, int len
)
1411 struct info_str info
;
1415 info
.offset
= offset
;
1418 copy_info(&info
, "Chip " NAME53C
"%s, device id 0x%x, "
1419 "revision id 0x%x\n",
1420 np
->s
.chip_name
, np
->device_id
, np
->revision_id
);
1421 copy_info(&info
, "At PCI address %s, IRQ " IRQ_FMT
"\n",
1422 pci_name(np
->s
.device
), IRQ_PRM(np
->s
.irq
));
1423 copy_info(&info
, "Min. period factor %d, %s SCSI BUS%s\n",
1424 (int) (np
->minsync_dt
? np
->minsync_dt
: np
->minsync
),
1425 np
->maxwide
? "Wide" : "Narrow",
1426 np
->minsync_dt
? ", DT capable" : "");
1428 copy_info(&info
, "Max. started commands %d, "
1429 "max. commands per LUN %d\n",
1430 SYM_CONF_MAX_START
, SYM_CONF_MAX_TAG
);
1432 return info
.pos
> info
.offset
? info
.pos
- info
.offset
: 0;
1434 #endif /* SYM_LINUX_USER_INFO_SUPPORT */
1437 * Entry point of the scsi proc fs of the driver.
1438 * - func = 0 means read (returns adapter infos)
1439 * - func = 1 means write (not yet merget from sym53c8xx)
1441 static int sym53c8xx_proc_info(struct Scsi_Host
*host
, char *buffer
,
1442 char **start
, off_t offset
, int length
, int func
)
1444 struct sym_hcb
*np
= sym_get_hcb(host
);
1448 #ifdef SYM_LINUX_USER_COMMAND_SUPPORT
1449 retv
= sym_user_command(np
, buffer
, length
);
1456 #ifdef SYM_LINUX_USER_INFO_SUPPORT
1457 retv
= sym_host_info(np
, buffer
, offset
, length
);
1465 #endif /* SYM_LINUX_PROC_INFO_SUPPORT */
1468 * Free controller resources.
1470 static void sym_free_resources(struct sym_hcb
*np
, struct pci_dev
*pdev
)
1473 * Free O/S specific resources.
1476 free_irq(np
->s
.irq
, np
);
1478 pci_iounmap(pdev
, np
->s
.ioaddr
);
1480 pci_iounmap(pdev
, np
->s
.ramaddr
);
1482 * Free O/S independent resources.
1486 sym_mfree_dma(np
, sizeof(*np
), "HCB");
1490 * Ask/tell the system about DMA addressing.
1492 static int sym_setup_bus_dma_mask(struct sym_hcb
*np
)
1494 #if SYM_CONF_DMA_ADDRESSING_MODE > 0
1495 #if SYM_CONF_DMA_ADDRESSING_MODE == 1
1496 #define DMA_DAC_MASK 0x000000ffffffffffULL /* 40-bit */
1497 #elif SYM_CONF_DMA_ADDRESSING_MODE == 2
1498 #define DMA_DAC_MASK DMA_64BIT_MASK
1500 if ((np
->features
& FE_DAC
) &&
1501 !pci_set_dma_mask(np
->s
.device
, DMA_DAC_MASK
)) {
1507 if (!pci_set_dma_mask(np
->s
.device
, DMA_32BIT_MASK
))
1510 printf_warning("%s: No suitable DMA available\n", sym_name(np
));
1515 * Host attach and initialisations.
1517 * Allocate host data and ncb structure.
1518 * Remap MMIO region.
1519 * Do chip initialization.
1520 * If all is OK, install interrupt handling and
1521 * start the timer daemon.
1523 static struct Scsi_Host
* __devinit
sym_attach(struct scsi_host_template
*tpnt
,
1524 int unit
, struct sym_device
*dev
)
1526 struct host_data
*host_data
;
1527 struct sym_hcb
*np
= NULL
;
1528 struct Scsi_Host
*instance
= NULL
;
1529 struct pci_dev
*pdev
= dev
->pdev
;
1530 unsigned long flags
;
1534 "sym%d: <%s> rev 0x%x at pci %s irq " IRQ_FMT
"\n",
1535 unit
, dev
->chip
.name
, dev
->chip
.revision_id
,
1536 pci_name(pdev
), IRQ_PRM(pdev
->irq
));
1539 * Get the firmware for this chip.
1541 fw
= sym_find_firmware(&dev
->chip
);
1546 * Allocate host_data structure
1548 instance
= scsi_host_alloc(tpnt
, sizeof(*host_data
));
1551 host_data
= (struct host_data
*) instance
->hostdata
;
1554 * Allocate immediately the host control block,
1555 * since we are only expecting to succeed. :)
1556 * We keep track in the HCB of all the resources that
1557 * are to be released on error.
1559 np
= __sym_calloc_dma(&pdev
->dev
, sizeof(*np
), "HCB");
1562 np
->s
.device
= pdev
;
1563 np
->bus_dmat
= &pdev
->dev
; /* Result in 1 DMA pool per HBA */
1564 host_data
->ncb
= np
;
1565 np
->s
.host
= instance
;
1567 pci_set_drvdata(pdev
, np
);
1570 * Copy some useful infos to the HCB.
1572 np
->hcb_ba
= vtobus(np
);
1573 np
->verbose
= sym_driver_setup
.verbose
;
1574 np
->s
.device
= pdev
;
1576 np
->device_id
= dev
->chip
.device_id
;
1577 np
->revision_id
= dev
->chip
.revision_id
;
1578 np
->features
= dev
->chip
.features
;
1579 np
->clock_divn
= dev
->chip
.nr_divisor
;
1580 np
->maxoffs
= dev
->chip
.offset_max
;
1581 np
->maxburst
= dev
->chip
.burst_max
;
1582 np
->myaddr
= dev
->host_id
;
1587 strlcpy(np
->s
.chip_name
, dev
->chip
.name
, sizeof(np
->s
.chip_name
));
1588 sprintf(np
->s
.inst_name
, "sym%d", np
->s
.unit
);
1590 if (sym_setup_bus_dma_mask(np
))
1594 * Try to map the controller chip to
1595 * virtual and physical memory.
1597 np
->mmio_ba
= (u32
)dev
->mmio_base
;
1598 np
->s
.ioaddr
= dev
->s
.ioaddr
;
1599 np
->s
.ramaddr
= dev
->s
.ramaddr
;
1600 np
->s
.io_ws
= (np
->features
& FE_IO256
) ? 256 : 128;
1603 * Map on-chip RAM if present and supported.
1605 if (!(np
->features
& FE_RAM
))
1607 if (dev
->ram_base
) {
1608 np
->ram_ba
= (u32
)dev
->ram_base
;
1609 np
->ram_ws
= (np
->features
& FE_RAM8K
) ? 8192 : 4096;
1612 if (sym_hcb_attach(instance
, fw
, dev
->nvram
))
1616 * Install the interrupt handler.
1617 * If we synchonize the C code with SCRIPTS on interrupt,
1618 * we do not want to share the INTR line at all.
1620 if (request_irq(pdev
->irq
, sym53c8xx_intr
, SA_SHIRQ
, NAME53C8XX
, np
)) {
1621 printf_err("%s: request irq %d failure\n",
1622 sym_name(np
), pdev
->irq
);
1625 np
->s
.irq
= pdev
->irq
;
1628 * After SCSI devices have been opened, we cannot
1629 * reset the bus safely, so we do it here.
1631 spin_lock_irqsave(instance
->host_lock
, flags
);
1632 if (sym_reset_scsi_bus(np
, 0))
1636 * Start the SCRIPTS.
1638 sym_start_up (np
, 1);
1641 * Start the timer daemon
1643 init_timer(&np
->s
.timer
);
1644 np
->s
.timer
.data
= (unsigned long) np
;
1645 np
->s
.timer
.function
= sym53c8xx_timer
;
1650 * Fill Linux host instance structure
1651 * and return success.
1653 instance
->max_channel
= 0;
1654 instance
->this_id
= np
->myaddr
;
1655 instance
->max_id
= np
->maxwide
? 16 : 8;
1656 instance
->max_lun
= SYM_CONF_MAX_LUN
;
1657 instance
->unique_id
= pci_resource_start(pdev
, 0);
1658 instance
->cmd_per_lun
= SYM_CONF_MAX_TAG
;
1659 instance
->can_queue
= (SYM_CONF_MAX_START
-2);
1660 instance
->sg_tablesize
= SYM_CONF_MAX_SG
;
1661 instance
->max_cmd_len
= 16;
1662 BUG_ON(sym2_transport_template
== NULL
);
1663 instance
->transportt
= sym2_transport_template
;
1665 spin_unlock_irqrestore(instance
->host_lock
, flags
);
1670 printf_err("%s: FATAL ERROR: CHECK SCSI BUS - CABLES, "
1671 "TERMINATION, DEVICE POWER etc.!\n", sym_name(np
));
1672 spin_unlock_irqrestore(instance
->host_lock
, flags
);
1676 printf_info("%s: giving up ...\n", sym_name(np
));
1678 sym_free_resources(np
, pdev
);
1679 scsi_host_put(instance
);
1686 * Detect and try to read SYMBIOS and TEKRAM NVRAM.
1688 #if SYM_CONF_NVRAM_SUPPORT
1689 static void __devinit
sym_get_nvram(struct sym_device
*devp
, struct sym_nvram
*nvp
)
1692 devp
->device_id
= devp
->chip
.device_id
;
1695 sym_read_nvram(devp
, nvp
);
1698 static inline void sym_get_nvram(struct sym_device
*devp
, struct sym_nvram
*nvp
)
1701 #endif /* SYM_CONF_NVRAM_SUPPORT */
1703 static int __devinit
sym_check_supported(struct sym_device
*device
)
1705 struct sym_chip
*chip
;
1706 struct pci_dev
*pdev
= device
->pdev
;
1708 unsigned long io_port
= pci_resource_start(pdev
, 0);
1712 * If user excluded this chip, do not initialize it.
1713 * I hate this code so much. Must kill it.
1716 for (i
= 0 ; i
< 8 ; i
++) {
1717 if (sym_driver_setup
.excludes
[i
] == io_port
)
1723 * Check if the chip is supported. Then copy the chip description
1724 * to our device structure so we can make it match the actual device
1727 pci_read_config_byte(pdev
, PCI_CLASS_REVISION
, &revision
);
1728 chip
= sym_lookup_chip_table(pdev
->device
, revision
);
1730 dev_info(&pdev
->dev
, "device not supported\n");
1733 memcpy(&device
->chip
, chip
, sizeof(device
->chip
));
1734 device
->chip
.revision_id
= revision
;
1740 * Ignore Symbios chips controlled by various RAID controllers.
1741 * These controllers set value 0x52414944 at RAM end - 16.
1743 static int __devinit
sym_check_raid(struct sym_device
*device
)
1745 unsigned int ram_size
, ram_val
;
1747 if (!device
->s
.ramaddr
)
1750 if (device
->chip
.features
& FE_RAM8K
)
1755 ram_val
= readl(device
->s
.ramaddr
+ ram_size
- 16);
1756 if (ram_val
!= 0x52414944)
1759 dev_info(&device
->pdev
->dev
,
1760 "not initializing, driven by RAID controller.\n");
1764 static int __devinit
sym_set_workarounds(struct sym_device
*device
)
1766 struct sym_chip
*chip
= &device
->chip
;
1767 struct pci_dev
*pdev
= device
->pdev
;
1771 * (ITEM 12 of a DEL about the 896 I haven't yet).
1772 * We must ensure the chip will use WRITE AND INVALIDATE.
1773 * The revision number limit is for now arbitrary.
1775 if (pdev
->device
== PCI_DEVICE_ID_NCR_53C896
&& chip
->revision_id
< 0x4) {
1776 chip
->features
|= (FE_WRIE
| FE_CLSE
);
1779 /* If the chip can do Memory Write Invalidate, enable it */
1780 if (chip
->features
& FE_WRIE
) {
1781 if (pci_set_mwi(pdev
))
1786 * Work around for errant bit in 895A. The 66Mhz
1787 * capable bit is set erroneously. Clear this bit.
1790 * Make sure Config space and Features agree.
1792 * Recall: writes are not normal to status register -
1793 * write a 1 to clear and a 0 to leave unchanged.
1794 * Can only reset bits.
1796 pci_read_config_word(pdev
, PCI_STATUS
, &status_reg
);
1797 if (chip
->features
& FE_66MHZ
) {
1798 if (!(status_reg
& PCI_STATUS_66MHZ
))
1799 chip
->features
&= ~FE_66MHZ
;
1801 if (status_reg
& PCI_STATUS_66MHZ
) {
1802 status_reg
= PCI_STATUS_66MHZ
;
1803 pci_write_config_word(pdev
, PCI_STATUS
, status_reg
);
1804 pci_read_config_word(pdev
, PCI_STATUS
, &status_reg
);
1812 * Read and check the PCI configuration for any detected NCR
1813 * boards and save data for attaching after all boards have
1816 static void __devinit
1817 sym_init_device(struct pci_dev
*pdev
, struct sym_device
*device
)
1821 device
->host_id
= SYM_SETUP_HOST_ID
;
1822 device
->pdev
= pdev
;
1824 i
= pci_get_base_address(pdev
, 1, &device
->mmio_base
);
1825 pci_get_base_address(pdev
, i
, &device
->ram_base
);
1827 #ifndef CONFIG_SCSI_SYM53C8XX_IOMAPPED
1828 if (device
->mmio_base
)
1829 device
->s
.ioaddr
= pci_iomap(pdev
, 1,
1830 pci_resource_len(pdev
, 1));
1832 if (!device
->s
.ioaddr
)
1833 device
->s
.ioaddr
= pci_iomap(pdev
, 0,
1834 pci_resource_len(pdev
, 0));
1835 if (device
->ram_base
)
1836 device
->s
.ramaddr
= pci_iomap(pdev
, i
,
1837 pci_resource_len(pdev
, i
));
1841 * The NCR PQS and PDS cards are constructed as a DEC bridge
1842 * behind which sits a proprietary NCR memory controller and
1843 * either four or two 53c875s as separate devices. We can tell
1844 * if an 875 is part of a PQS/PDS or not since if it is, it will
1845 * be on the same bus as the memory controller. In its usual
1846 * mode of operation, the 875s are slaved to the memory
1847 * controller for all transfers. To operate with the Linux
1848 * driver, the memory controller is disabled and the 875s
1849 * freed to function independently. The only wrinkle is that
1850 * the preset SCSI ID (which may be zero) must be read in from
1851 * a special configuration space register of the 875.
1853 static void sym_config_pqs(struct pci_dev
*pdev
, struct sym_device
*sym_dev
)
1858 for (slot
= 0; slot
< 256; slot
++) {
1859 struct pci_dev
*memc
= pci_get_slot(pdev
->bus
, slot
);
1861 if (!memc
|| memc
->vendor
!= 0x101a || memc
->device
== 0x0009) {
1866 /* bit 1: allow individual 875 configuration */
1867 pci_read_config_byte(memc
, 0x44, &tmp
);
1868 if ((tmp
& 0x2) == 0) {
1870 pci_write_config_byte(memc
, 0x44, tmp
);
1873 /* bit 2: drive individual 875 interrupts to the bus */
1874 pci_read_config_byte(memc
, 0x45, &tmp
);
1875 if ((tmp
& 0x4) == 0) {
1877 pci_write_config_byte(memc
, 0x45, tmp
);
1884 pci_read_config_byte(pdev
, 0x84, &tmp
);
1885 sym_dev
->host_id
= tmp
;
1889 * Called before unloading the module.
1891 * We have to free resources and halt the NCR chip.
1893 static int sym_detach(struct sym_hcb
*np
, struct pci_dev
*pdev
)
1895 printk("%s: detaching ...\n", sym_name(np
));
1897 del_timer_sync(&np
->s
.timer
);
1901 * We should use sym_soft_reset(), but we don't want to do
1902 * so, since we may not be safe if interrupts occur.
1904 printk("%s: resetting chip\n", sym_name(np
));
1905 OUTB(np
, nc_istat
, SRST
);
1907 OUTB(np
, nc_istat
, 0);
1909 sym_free_resources(np
, pdev
);
1915 * Driver host template.
1917 static struct scsi_host_template sym2_template
= {
1918 .module
= THIS_MODULE
,
1919 .name
= "sym53c8xx",
1920 .info
= sym53c8xx_info
,
1921 .queuecommand
= sym53c8xx_queue_command
,
1922 .slave_alloc
= sym53c8xx_slave_alloc
,
1923 .slave_configure
= sym53c8xx_slave_configure
,
1924 .slave_destroy
= sym53c8xx_slave_destroy
,
1925 .eh_abort_handler
= sym53c8xx_eh_abort_handler
,
1926 .eh_device_reset_handler
= sym53c8xx_eh_device_reset_handler
,
1927 .eh_bus_reset_handler
= sym53c8xx_eh_bus_reset_handler
,
1928 .eh_host_reset_handler
= sym53c8xx_eh_host_reset_handler
,
1930 .use_clustering
= DISABLE_CLUSTERING
,
1931 #ifdef SYM_LINUX_PROC_INFO_SUPPORT
1932 .proc_info
= sym53c8xx_proc_info
,
1933 .proc_name
= NAME53C8XX
,
1937 static int attach_count
;
1939 static int __devinit
sym2_probe(struct pci_dev
*pdev
,
1940 const struct pci_device_id
*ent
)
1942 struct sym_device sym_dev
;
1943 struct sym_nvram nvram
;
1944 struct Scsi_Host
*instance
;
1946 memset(&sym_dev
, 0, sizeof(sym_dev
));
1947 memset(&nvram
, 0, sizeof(nvram
));
1949 if (pci_enable_device(pdev
))
1952 pci_set_master(pdev
);
1954 if (pci_request_regions(pdev
, NAME53C8XX
))
1957 sym_init_device(pdev
, &sym_dev
);
1958 if (sym_check_supported(&sym_dev
))
1961 if (sym_check_raid(&sym_dev
))
1962 goto leave
; /* Don't disable the device */
1964 if (sym_set_workarounds(&sym_dev
))
1967 sym_config_pqs(pdev
, &sym_dev
);
1969 sym_get_nvram(&sym_dev
, &nvram
);
1971 instance
= sym_attach(&sym2_template
, attach_count
, &sym_dev
);
1975 if (scsi_add_host(instance
, &pdev
->dev
))
1977 scsi_scan_host(instance
);
1984 sym_detach(pci_get_drvdata(pdev
), pdev
);
1986 pci_release_regions(pdev
);
1988 pci_disable_device(pdev
);
1993 static void __devexit
sym2_remove(struct pci_dev
*pdev
)
1995 struct sym_hcb
*np
= pci_get_drvdata(pdev
);
1996 struct Scsi_Host
*host
= np
->s
.host
;
1998 scsi_remove_host(host
);
1999 scsi_host_put(host
);
2001 sym_detach(np
, pdev
);
2003 pci_release_regions(pdev
);
2004 pci_disable_device(pdev
);
2009 static void sym2_get_signalling(struct Scsi_Host
*shost
)
2011 struct sym_hcb
*np
= sym_get_hcb(shost
);
2012 enum spi_signal_type type
;
2014 switch (np
->scsi_mode
) {
2016 type
= SPI_SIGNAL_SE
;
2019 type
= SPI_SIGNAL_LVD
;
2022 type
= SPI_SIGNAL_HVD
;
2025 type
= SPI_SIGNAL_UNKNOWN
;
2028 spi_signalling(shost
) = type
;
2031 static void sym2_set_offset(struct scsi_target
*starget
, int offset
)
2033 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
2034 struct sym_hcb
*np
= sym_get_hcb(shost
);
2035 struct sym_tcb
*tp
= &np
->target
[starget
->id
];
2037 tp
->tgoal
.offset
= offset
;
2038 tp
->tgoal
.check_nego
= 1;
2041 static void sym2_set_period(struct scsi_target
*starget
, int period
)
2043 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
2044 struct sym_hcb
*np
= sym_get_hcb(shost
);
2045 struct sym_tcb
*tp
= &np
->target
[starget
->id
];
2047 /* have to have DT for these transfers */
2048 if (period
<= np
->minsync
)
2051 tp
->tgoal
.period
= period
;
2052 tp
->tgoal
.check_nego
= 1;
2055 static void sym2_set_width(struct scsi_target
*starget
, int width
)
2057 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
2058 struct sym_hcb
*np
= sym_get_hcb(shost
);
2059 struct sym_tcb
*tp
= &np
->target
[starget
->id
];
2061 /* It is illegal to have DT set on narrow transfers. If DT is
2062 * clear, we must also clear IU and QAS. */
2064 tp
->tgoal
.iu
= tp
->tgoal
.dt
= tp
->tgoal
.qas
= 0;
2066 tp
->tgoal
.width
= width
;
2067 tp
->tgoal
.check_nego
= 1;
2070 static void sym2_set_dt(struct scsi_target
*starget
, int dt
)
2072 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
2073 struct sym_hcb
*np
= sym_get_hcb(shost
);
2074 struct sym_tcb
*tp
= &np
->target
[starget
->id
];
2076 /* We must clear QAS and IU if DT is clear */
2080 tp
->tgoal
.iu
= tp
->tgoal
.dt
= tp
->tgoal
.qas
= 0;
2081 tp
->tgoal
.check_nego
= 1;
2084 static void sym2_set_iu(struct scsi_target
*starget
, int iu
)
2086 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
2087 struct sym_hcb
*np
= sym_get_hcb(shost
);
2088 struct sym_tcb
*tp
= &np
->target
[starget
->id
];
2091 tp
->tgoal
.iu
= tp
->tgoal
.dt
= 1;
2094 tp
->tgoal
.check_nego
= 1;
2097 static void sym2_set_qas(struct scsi_target
*starget
, int qas
)
2099 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
2100 struct sym_hcb
*np
= sym_get_hcb(shost
);
2101 struct sym_tcb
*tp
= &np
->target
[starget
->id
];
2104 tp
->tgoal
.dt
= tp
->tgoal
.qas
= 1;
2107 tp
->tgoal
.check_nego
= 1;
2111 static struct spi_function_template sym2_transport_functions
= {
2112 .set_offset
= sym2_set_offset
,
2114 .set_period
= sym2_set_period
,
2116 .set_width
= sym2_set_width
,
2118 .set_dt
= sym2_set_dt
,
2120 .set_iu
= sym2_set_iu
,
2122 .set_qas
= sym2_set_qas
,
2124 .get_signalling
= sym2_get_signalling
,
2127 static struct pci_device_id sym2_id_table
[] __devinitdata
= {
2128 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_NCR_53C810
,
2129 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL },
2130 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_NCR_53C820
,
2131 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL }, /* new */
2132 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_NCR_53C825
,
2133 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL },
2134 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_NCR_53C815
,
2135 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL },
2136 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_53C810AP
,
2137 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL }, /* new */
2138 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_NCR_53C860
,
2139 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL },
2140 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_53C1510
,
2141 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL },
2142 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_NCR_53C896
,
2143 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL },
2144 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_NCR_53C895
,
2145 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL },
2146 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_NCR_53C885
,
2147 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL },
2148 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_NCR_53C875
,
2149 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL },
2150 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_NCR_53C1510
,
2151 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL }, /* new */
2152 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_53C895A
,
2153 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL },
2154 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_53C875A
,
2155 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL },
2156 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_53C1010_33
,
2157 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL },
2158 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_53C1010_66
,
2159 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL },
2160 { PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_NCR_53C875J
,
2161 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0UL },
2165 MODULE_DEVICE_TABLE(pci
, sym2_id_table
);
2167 static struct pci_driver sym2_driver
= {
2169 .id_table
= sym2_id_table
,
2170 .probe
= sym2_probe
,
2171 .remove
= __devexit_p(sym2_remove
),
2174 static int __init
sym2_init(void)
2178 sym2_setup_params();
2179 sym2_transport_template
= spi_attach_transport(&sym2_transport_functions
);
2180 if (!sym2_transport_template
)
2183 error
= pci_register_driver(&sym2_driver
);
2185 spi_release_transport(sym2_transport_template
);
2189 static void __exit
sym2_exit(void)
2191 pci_unregister_driver(&sym2_driver
);
2192 spi_release_transport(sym2_transport_template
);
2195 module_init(sym2_init
);
2196 module_exit(sym2_exit
);