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>
7 * This driver is derived from the Linux sym53c8xx driver.
8 * Copyright (C) 1998-2000 Gerard Roudier
10 * The sym53c8xx driver is derived from the ncr53c8xx driver that had been
11 * a port of the FreeBSD ncr driver to Linux-1.2.13.
13 * The original ncr driver has been written for 386bsd and FreeBSD by
14 * Wolfgang Stanglmeier <wolf@cologne.de>
15 * Stefan Esser <se@mi.Uni-Koeln.de>
16 * Copyright (C) 1994 Wolfgang Stanglmeier
18 * Other major contributions:
20 * NVRAM detection and reading.
21 * Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk>
23 *-----------------------------------------------------------------------------
25 * Redistribution and use in source and binary forms, with or without
26 * modification, are permitted provided that the following conditions
28 * 1. Redistributions of source code must retain the above copyright
29 * notice, this list of conditions and the following disclaimer.
30 * 2. The name of the author may not be used to endorse or promote products
31 * derived from this software without specific prior written permission.
33 * Where this Software is combined with software released under the terms of
34 * the GNU Public License ("GPL") and the terms of the GPL would require the
35 * combined work to also be released under the terms of the GPL, the terms
36 * and conditions of this License will apply in addition to those of the
37 * GPL with the exception of any terms or conditions of this License that
38 * conflict with, or are expressly prohibited by, the GPL.
40 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
44 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
54 #include <linux/module.h>
57 #define NAME53C "sym53c"
58 #define NAME53C8XX "sym53c8xx"
61 * Simple Wrapper to kernel PCI bus interface.
64 typedef struct pci_dev
*pcidev_t
;
65 #define PCIDEV_NULL (0)
66 #define PciBusNumber(d) (d)->bus->number
67 #define PciDeviceFn(d) (d)->devfn
68 #define PciVendorId(d) (d)->vendor
69 #define PciDeviceId(d) (d)->device
70 #define PciIrqLine(d) (d)->irq
73 pci_get_base_cookie(struct pci_dev
*pdev
, int index
)
77 #if LINUX_VERSION_CODE > LinuxVersionCode(2,3,12)
78 base
= pdev
->resource
[index
].start
;
80 base
= pdev
->base_address
[index
];
81 #if BITS_PER_LONG > 32
82 if ((base
& 0x7) == 0x4)
83 base
|= (((u_long
)pdev
->base_address
[++index
]) << 32);
86 return (base
& ~0x7ul
);
90 pci_get_base_address(struct pci_dev
*pdev
, int index
, u_long
*base
)
93 #define PCI_BAR_OFFSET(index) (PCI_BASE_ADDRESS_0 + (index<<2))
95 pci_read_config_dword(pdev
, PCI_BAR_OFFSET(index
), &tmp
);
98 if ((tmp
& 0x7) == 0x4) {
99 #if BITS_PER_LONG > 32
100 pci_read_config_dword(pdev
, PCI_BAR_OFFSET(index
), &tmp
);
101 *base
|= (((u_long
)tmp
) << 32);
106 #undef PCI_BAR_OFFSET
109 #if LINUX_VERSION_CODE < LinuxVersionCode(2,4,0)
110 #define pci_enable_device(pdev) (0)
113 #if LINUX_VERSION_CODE < LinuxVersionCode(2,4,4)
114 #define scsi_set_pci_device(inst, pdev) do { ;} while (0)
118 * Insert a delay in micro-seconds and milli-seconds.
120 void sym_udelay(int us
) { udelay(us
); }
121 void sym_mdelay(int ms
) { mdelay(ms
); }
126 * The whole SCSI sub-system under Linux is basically single-threaded.
127 * Everything, including low-level driver interrupt routine, happens
128 * with the `io_request_lock' held.
129 * The sym53c8xx-1.x drivers series ran their interrupt code using a
130 * spin mutex per controller. This added complexity without improving
131 * scalability significantly. the sym-2 driver still use a spinlock
132 * per controller for safety, but basically runs with the damned
133 * io_request_lock held.
136 spinlock_t sym53c8xx_lock
= SPIN_LOCK_UNLOCKED
;
138 #define SYM_LOCK_DRIVER(flags) spin_lock_irqsave(&sym53c8xx_lock, flags)
139 #define SYM_UNLOCK_DRIVER(flags) spin_unlock_irqrestore(&sym53c8xx_lock,flags)
141 #define SYM_INIT_LOCK_HCB(np) spin_lock_init((np)->s.host->host_lock);
142 #define SYM_LOCK_HCB(np, flags) \
143 spin_lock_irqsave((np)->s.host->host_lock, flags)
144 #define SYM_UNLOCK_HCB(np, flags) \
145 spin_unlock_irqrestore((np)->s.host->host_lock, flags)
148 * These simple macros limit expression involving
149 * kernel time values (jiffies) to some that have
150 * chance not to be too much incorrect. :-)
152 #define ktime_get(o) (jiffies + (u_long) o)
153 #define ktime_exp(b) ((long)(jiffies) - (long)(b) >= 0)
154 #define ktime_dif(a, b) ((long)(a) - (long)(b))
155 #define ktime_add(a, o) ((a) + (u_long)(o))
156 #define ktime_sub(a, o) ((a) - (u_long)(o))
159 * Wrappers to the generic memory allocator.
161 void *sym_calloc(int size
, char *name
)
165 SYM_LOCK_DRIVER(flags
);
166 m
= sym_calloc_unlocked(size
, name
);
167 SYM_UNLOCK_DRIVER(flags
);
171 void sym_mfree(void *m
, int size
, char *name
)
174 SYM_LOCK_DRIVER(flags
);
175 sym_mfree_unlocked(m
, size
, name
);
176 SYM_UNLOCK_DRIVER(flags
);
179 #ifdef SYM_LINUX_DYNAMIC_DMA_MAPPING
181 void *__sym_calloc_dma(m_pool_ident_t dev_dmat
, int size
, char *name
)
185 SYM_LOCK_DRIVER(flags
);
186 m
= __sym_calloc_dma_unlocked(dev_dmat
, size
, name
);
187 SYM_UNLOCK_DRIVER(flags
);
191 void __sym_mfree_dma(m_pool_ident_t dev_dmat
, void *m
, int size
, char *name
)
194 SYM_LOCK_DRIVER(flags
);
195 __sym_mfree_dma_unlocked(dev_dmat
, m
, size
, name
);
196 SYM_UNLOCK_DRIVER(flags
);
199 m_addr_t
__vtobus(m_pool_ident_t dev_dmat
, void *m
)
203 SYM_LOCK_DRIVER(flags
);
204 b
= __vtobus_unlocked(dev_dmat
, m
);
205 SYM_UNLOCK_DRIVER(flags
);
209 #endif /* SYM_LINUX_DYNAMIC_DMA_MAPPING */
213 * Map/unmap a PCI memory window.
215 #ifndef SYM_OPT_NO_BUS_MEMORY_MAPPING
216 static u_long __init
pci_map_mem(u_long base
, u_long size
)
218 u_long page_base
= ((u_long
) base
) & PAGE_MASK
;
219 u_long page_offs
= ((u_long
) base
) - page_base
;
220 u_long page_remapped
= (u_long
) ioremap(page_base
, page_offs
+size
);
222 return page_remapped
? (page_remapped
+ page_offs
) : 0UL;
225 static void __init
pci_unmap_mem(u_long vaddr
, u_long size
)
228 iounmap((void *) (vaddr
& PAGE_MASK
));
233 * Used to retrieve the host structure when the
234 * driver is called from the proc FS.
236 static struct Scsi_Host
*first_host
= NULL
;
239 * /proc directory entry and proc_info.
241 #if LINUX_VERSION_CODE < LinuxVersionCode(2,3,27)
242 static struct proc_dir_entry proc_scsi_sym53c8xx
= {
243 PROC_SCSI_SYM53C8XX
, 9, NAME53C8XX
,
244 S_IFDIR
| S_IRUGO
| S_IXUGO
, 2
251 * Until some linux kernel version near 2.3.40, low-level scsi
252 * drivers were not told about data transfer direction.
254 #if LINUX_VERSION_CODE > LinuxVersionCode(2, 3, 40)
256 #define scsi_data_direction(cmd) (cmd->sc_data_direction)
260 static __inline__
int scsi_data_direction(Scsi_Cmnd
*cmd
)
264 switch((int) cmd
->cmnd
[0]) {
265 case 0x08: /* READ(6) 08 */
266 case 0x28: /* READ(10) 28 */
267 case 0xA8: /* READ(12) A8 */
268 direction
= SCSI_DATA_READ
;
270 case 0x0A: /* WRITE(6) 0A */
271 case 0x2A: /* WRITE(10) 2A */
272 case 0xAA: /* WRITE(12) AA */
273 direction
= SCSI_DATA_WRITE
;
276 direction
= SCSI_DATA_UNKNOWN
;
286 * Driver host data structure.
293 * Some type that fit DMA addresses as seen from BUS.
295 #ifndef SYM_LINUX_DYNAMIC_DMA_MAPPING
296 typedef u_long bus_addr_t
;
298 typedef dma_addr_t bus_addr_t
;
302 * Used by the eh thread to wait for command completion.
303 * It is allocated on the eh thread stack.
306 struct semaphore sem
;
307 struct timer_list timer
;
308 void (*old_done
)(Scsi_Cmnd
*);
314 * Driver private area in the SCSI command structure.
316 struct sym_ucmd
{ /* Override the SCSI pointer structure */
317 SYM_QUEHEAD link_cmdq
; /* Must stay at offset ZERO */
318 #ifdef SYM_LINUX_DYNAMIC_DMA_MAPPING
319 bus_addr_t data_mapping
;
322 struct sym_eh_wait
*eh_wait
;
325 typedef struct sym_ucmd
*ucmd_p
;
327 #define SYM_UCMD_PTR(cmd) ((ucmd_p)(&(cmd)->SCp))
328 #define SYM_SCMD_PTR(ucmd) sym_que_entry(ucmd, Scsi_Cmnd, SCp)
329 #define SYM_SOFTC_PTR(cmd) (((struct host_data *)cmd->device->host->hostdata)->ncb)
332 * Deal with DMA mapping/unmapping.
335 #ifndef SYM_LINUX_DYNAMIC_DMA_MAPPING
337 /* Linux versions prior to pci bus iommu kernel interface */
339 #define __unmap_scsi_data(pdev, cmd) do {; } while (0)
340 #define __map_scsi_single_data(pdev, cmd) (__vtobus(pdev,(cmd)->request_buffer))
341 #define __map_scsi_sg_data(pdev, cmd) ((cmd)->use_sg)
342 #define __sync_scsi_data(pdev, cmd) do {; } while (0)
344 #define bus_sg_dma_address(sc) vtobus((sc)->address)
345 #define bus_sg_dma_len(sc) ((sc)->length)
347 #else /* Linux version with pci bus iommu kernel interface */
349 #define bus_unmap_sg(pdev, sgptr, sgcnt, dir) \
350 pci_unmap_sg(pdev, sgptr, sgcnt, dir)
352 #define bus_unmap_single(pdev, mapping, bufptr, dir) \
353 pci_unmap_single(pdev, mapping, bufptr, dir)
355 #define bus_map_single(pdev, bufptr, bufsiz, dir) \
356 pci_map_single(pdev, bufptr, bufsiz, dir)
358 #define bus_map_sg(pdev, sgptr, sgcnt, dir) \
359 pci_map_sg(pdev, sgptr, sgcnt, dir)
361 #define bus_dma_sync_sg(pdev, sgptr, sgcnt, dir) \
362 pci_dma_sync_sg(pdev, sgptr, sgcnt, dir)
364 #define bus_dma_sync_single(pdev, mapping, bufsiz, dir) \
365 pci_dma_sync_single(pdev, mapping, bufsiz, dir)
367 #define bus_sg_dma_address(sc) sg_dma_address(sc)
368 #define bus_sg_dma_len(sc) sg_dma_len(sc)
370 static void __unmap_scsi_data(pcidev_t pdev
, Scsi_Cmnd
*cmd
)
372 int dma_dir
= scsi_to_pci_dma_dir(cmd
->sc_data_direction
);
374 switch(SYM_UCMD_PTR(cmd
)->data_mapped
) {
376 bus_unmap_sg(pdev
, cmd
->buffer
, cmd
->use_sg
, dma_dir
);
379 bus_unmap_single(pdev
, SYM_UCMD_PTR(cmd
)->data_mapping
,
380 cmd
->request_bufflen
, dma_dir
);
383 SYM_UCMD_PTR(cmd
)->data_mapped
= 0;
386 static bus_addr_t
__map_scsi_single_data(pcidev_t pdev
, Scsi_Cmnd
*cmd
)
389 int dma_dir
= scsi_to_pci_dma_dir(cmd
->sc_data_direction
);
391 mapping
= bus_map_single(pdev
, cmd
->request_buffer
,
392 cmd
->request_bufflen
, dma_dir
);
394 SYM_UCMD_PTR(cmd
)->data_mapped
= 1;
395 SYM_UCMD_PTR(cmd
)->data_mapping
= mapping
;
401 static int __map_scsi_sg_data(pcidev_t pdev
, Scsi_Cmnd
*cmd
)
404 int dma_dir
= scsi_to_pci_dma_dir(cmd
->sc_data_direction
);
406 use_sg
= bus_map_sg(pdev
, cmd
->buffer
, cmd
->use_sg
, dma_dir
);
408 SYM_UCMD_PTR(cmd
)->data_mapped
= 2;
409 SYM_UCMD_PTR(cmd
)->data_mapping
= use_sg
;
415 static void __sync_scsi_data(pcidev_t pdev
, Scsi_Cmnd
*cmd
)
417 int dma_dir
= scsi_to_pci_dma_dir(cmd
->sc_data_direction
);
419 switch(SYM_UCMD_PTR(cmd
)->data_mapped
) {
421 bus_dma_sync_sg(pdev
, cmd
->buffer
, cmd
->use_sg
, dma_dir
);
424 bus_dma_sync_single(pdev
, SYM_UCMD_PTR(cmd
)->data_mapping
,
425 cmd
->request_bufflen
, dma_dir
);
430 #endif /* SYM_LINUX_DYNAMIC_DMA_MAPPING */
432 #define unmap_scsi_data(np, cmd) \
433 __unmap_scsi_data(np->s.device, cmd)
434 #define map_scsi_single_data(np, cmd) \
435 __map_scsi_single_data(np->s.device, cmd)
436 #define map_scsi_sg_data(np, cmd) \
437 __map_scsi_sg_data(np->s.device, cmd)
438 #define sync_scsi_data(np, cmd) \
439 __sync_scsi_data(np->s.device, cmd)
442 * Complete a pending CAM CCB.
444 void sym_xpt_done(hcb_p np
, Scsi_Cmnd
*ccb
)
446 sym_remque(&SYM_UCMD_PTR(ccb
)->link_cmdq
);
447 unmap_scsi_data(np
, ccb
);
451 void sym_xpt_done2(hcb_p np
, Scsi_Cmnd
*ccb
, int cam_status
)
453 sym_set_cam_status(ccb
, cam_status
);
454 sym_xpt_done(np
, ccb
);
459 * Print something that identifies the IO.
461 void sym_print_addr (ccb_p cp
)
463 Scsi_Cmnd
*cmd
= cp
->cam_ccb
;
465 printf("%s:%d:%d:", sym_name(SYM_SOFTC_PTR(cmd
)),
466 cmd
->device
->id
,cmd
->device
->lun
);
470 * Tell the SCSI layer about a BUS RESET.
472 void sym_xpt_async_bus_reset(hcb_p np
)
474 printf_notice("%s: SCSI BUS has been reset.\n", sym_name(np
));
475 np
->s
.settle_time
= ktime_get(sym_driver_setup
.settle_delay
* HZ
);
476 np
->s
.settle_time_valid
= 1;
477 if (sym_verbose
>= 2)
478 printf_info("%s: command processing suspended for %d seconds\n",
479 sym_name(np
), sym_driver_setup
.settle_delay
);
483 * Tell the SCSI layer about a BUS DEVICE RESET message sent.
485 void sym_xpt_async_sent_bdr(hcb_p np
, int target
)
487 printf_notice("%s: TARGET %d has been reset.\n", sym_name(np
), target
);
491 * Tell the SCSI layer about the new transfer parameters.
493 void sym_xpt_async_nego_wide(hcb_p np
, int target
)
497 sym_announce_transfer_rate(np
, target
);
501 * Choose the more appropriate CAM status if
502 * the IO encountered an extended error.
504 static int sym_xerr_cam_status(int cam_status
, int x_status
)
507 if (x_status
& XE_PARITY_ERR
)
508 cam_status
= DID_PARITY
;
509 else if (x_status
&(XE_EXTRA_DATA
|XE_SODL_UNRUN
|XE_SWIDE_OVRUN
))
510 cam_status
= DID_ERROR
;
511 else if (x_status
& XE_BAD_PHASE
)
512 cam_status
= DID_ERROR
;
514 cam_status
= DID_ERROR
;
520 * Build CAM result for a failed or auto-sensed IO.
522 void sym_set_cam_result_error(hcb_p np
, ccb_p cp
, int resid
)
524 Scsi_Cmnd
*csio
= cp
->cam_ccb
;
525 u_int cam_status
, scsi_status
, drv_status
;
529 scsi_status
= cp
->ssss_status
;
531 if (cp
->host_flags
& HF_SENSE
) {
532 scsi_status
= cp
->sv_scsi_status
;
533 resid
= cp
->sv_resid
;
534 if (sym_verbose
&& cp
->sv_xerr_status
)
535 sym_print_xerr(cp
, cp
->sv_xerr_status
);
536 if (cp
->host_status
== HS_COMPLETE
&&
537 cp
->ssss_status
== S_GOOD
&&
538 cp
->xerr_status
== 0) {
539 cam_status
= sym_xerr_cam_status(DID_OK
,
541 drv_status
= DRIVER_SENSE
;
543 * Bounce back the sense data to user.
545 bzero(&csio
->sense_buffer
, sizeof(csio
->sense_buffer
));
546 bcopy(cp
->sns_bbuf
, csio
->sense_buffer
,
547 MIN(sizeof(csio
->sense_buffer
),SYM_SNS_BBUF_LEN
));
550 * If the device reports a UNIT ATTENTION condition
551 * due to a RESET condition, we should consider all
552 * disconnect CCBs for this unit as aborted.
556 p
= (u_char
*) csio
->sense_data
;
557 if (p
[0]==0x70 && p
[2]==0x6 && p
[12]==0x29)
558 sym_clear_tasks(np
, DID_ABORT
,
559 cp
->target
,cp
->lun
, -1);
564 cam_status
= DID_ERROR
;
566 else if (cp
->host_status
== HS_COMPLETE
) /* Bad SCSI status */
568 else if (cp
->host_status
== HS_SEL_TIMEOUT
) /* Selection timeout */
569 cam_status
= DID_NO_CONNECT
;
570 else if (cp
->host_status
== HS_UNEXPECTED
) /* Unexpected BUS FREE*/
571 cam_status
= DID_ERROR
;
572 else { /* Extended error */
575 printf ("COMMAND FAILED (%x %x %x).\n",
576 cp
->host_status
, cp
->ssss_status
,
580 * Set the most appropriate value for CAM status.
582 cam_status
= sym_xerr_cam_status(DID_ERROR
, cp
->xerr_status
);
584 #if LINUX_VERSION_CODE >= LinuxVersionCode(2,3,99)
587 csio
->result
= (drv_status
<< 24) + (cam_status
<< 16) + scsi_status
;
592 * Called on successfull INQUIRY response.
594 void sym_sniff_inquiry(hcb_p np
, Scsi_Cmnd
*cmd
, int resid
)
598 if (!cmd
|| cmd
->use_sg
)
601 sync_scsi_data(np
, cmd
);
602 retv
= __sym_sniff_inquiry(np
, cmd
->device
->id
, cmd
->device
->lun
,
603 (u_char
*) cmd
->request_buffer
,
604 cmd
->request_bufflen
- resid
);
608 sym_update_trans_settings(np
, &np
->target
[cmd
->device
->id
]);
612 * Build the scatter/gather array for an I/O.
615 static int sym_scatter_no_sglist(hcb_p np
, ccb_p cp
, Scsi_Cmnd
*cmd
)
617 struct sym_tblmove
*data
= &cp
->phys
.data
[SYM_CONF_MAX_SG
-1];
620 cp
->data_len
= cmd
->request_bufflen
;
622 if (cmd
->request_bufflen
) {
623 bus_addr_t baddr
= map_scsi_single_data(np
, cmd
);
625 sym_build_sge(np
, data
, baddr
, cmd
->request_bufflen
);
637 static int sym_scatter(hcb_p np
, ccb_p cp
, Scsi_Cmnd
*cmd
)
640 int use_sg
= (int) cmd
->use_sg
;
645 segment
= sym_scatter_no_sglist(np
, cp
, cmd
);
646 else if ((use_sg
= map_scsi_sg_data(np
, cmd
)) > 0) {
647 struct scatterlist
*scatter
= (struct scatterlist
*)cmd
->buffer
;
648 struct sym_tblmove
*data
;
650 if (use_sg
> SYM_CONF_MAX_SG
) {
651 unmap_scsi_data(np
, cmd
);
655 data
= &cp
->phys
.data
[SYM_CONF_MAX_SG
- use_sg
];
657 for (segment
= 0; segment
< use_sg
; segment
++) {
658 bus_addr_t baddr
= bus_sg_dma_address(&scatter
[segment
]);
659 unsigned int len
= bus_sg_dma_len(&scatter
[segment
]);
661 sym_build_sge(np
, &data
[segment
], baddr
, len
);
672 * Queue a SCSI command.
674 static int sym_queue_command(hcb_p np
, Scsi_Cmnd
*ccb
)
676 /* Scsi_Device *device = ccb->device; */
683 * Minimal checkings, so that we will not
684 * go outside our tables.
686 if (ccb
->device
->id
== np
->myaddr
||
687 ccb
->device
->id
>= SYM_CONF_MAX_TARGET
||
688 ccb
->device
->lun
>= SYM_CONF_MAX_LUN
) {
689 sym_xpt_done2(np
, ccb
, CAM_DEV_NOT_THERE
);
694 * Retreive the target descriptor.
696 tp
= &np
->target
[ccb
->device
->id
];
699 * Complete the 1st INQUIRY command with error
700 * condition if the device is flagged NOSCAN
701 * at BOOT in the NVRAM. This may speed up
702 * the boot and maintain coherency with BIOS
703 * device numbering. Clearing the flag allows
704 * user to rescan skipped devices later.
705 * We also return error for devices not flagged
706 * for SCAN LUNS in the NVRAM since some mono-lun
707 * devices behave badly when asked for some non
708 * zero LUN. Btw, this is an absolute hack.:-)
710 if (ccb
->cmnd
[0] == 0x12 || ccb
->cmnd
[0] == 0x0) {
711 if ((tp
->usrflags
& SYM_SCAN_BOOT_DISABLED
) ||
712 ((tp
->usrflags
& SYM_SCAN_LUNS_DISABLED
) &&
713 ccb
->device
->lun
!= 0)) {
714 tp
->usrflags
&= ~SYM_SCAN_BOOT_DISABLED
;
715 sym_xpt_done2(np
, ccb
, CAM_DEV_NOT_THERE
);
721 * Select tagged/untagged.
723 lp
= sym_lp(np
, tp
, ccb
->device
->lun
);
724 order
= (lp
&& lp
->s
.reqtags
) ? M_SIMPLE_TAG
: 0;
729 cp
= sym_get_ccb(np
, ccb
->device
->id
, ccb
->device
->lun
, order
);
731 return 1; /* Means resource shortage */
732 (void) sym_queue_scsiio(np
, ccb
, cp
);
737 * Setup buffers and pointers that address the CDB.
739 static int __inline
sym_setup_cdb(hcb_p np
, Scsi_Cmnd
*ccb
, ccb_p cp
)
745 * CDB is 16 bytes max.
747 if (ccb
->cmd_len
> sizeof(cp
->cdb_buf
)) {
748 sym_set_cam_status(cp
->cam_ccb
, CAM_REQ_INVALID
);
752 bcopy(ccb
->cmnd
, cp
->cdb_buf
, ccb
->cmd_len
);
753 cmd_ba
= CCB_BA (cp
, cdb_buf
[0]);
754 cmd_len
= ccb
->cmd_len
;
756 cp
->phys
.cmd
.addr
= cpu_to_scr(cmd_ba
);
757 cp
->phys
.cmd
.size
= cpu_to_scr(cmd_len
);
763 * Setup pointers that address the data and start the I/O.
765 int sym_setup_data_and_start(hcb_p np
, Scsi_Cmnd
*csio
, ccb_p cp
)
768 tcb_p tp
= &np
->target
[cp
->target
];
769 lcb_p lp
= sym_lp(np
, tp
, cp
->lun
);
774 if (sym_setup_cdb(np
, csio
, cp
))
778 * No direction means no data.
780 dir
= scsi_data_direction(csio
);
781 if (dir
!= SCSI_DATA_NONE
) {
782 cp
->segments
= sym_scatter (np
, cp
, csio
);
783 if (cp
->segments
< 0) {
784 if (cp
->segments
== -2)
785 sym_set_cam_status(csio
, CAM_RESRC_UNAVAIL
);
787 sym_set_cam_status(csio
, CAM_REQ_TOO_BIG
);
799 sym_setup_data_pointers(np
, cp
, dir
);
802 * When `#ifed 1', the code below makes the driver
803 * panic on the first attempt to write to a SCSI device.
804 * It is the first test we want to do after a driver
805 * change that does not seem obviously safe. :)
808 switch (cp
->cdb_buf
[0]) {
809 case 0x0A: case 0x2A: case 0xAA:
810 panic("XXXXXXXXXXXXX WRITE NOT YET ALLOWED XXXXXXXXXXXXXX\n");
822 sym_start_next_ccbs(np
, lp
, 2);
824 sym_put_start_queue(np
, cp
);
828 sym_free_ccb(np
, cp
);
829 sym_xpt_done(np
, csio
);
837 * Misused to keep the driver running when
838 * interrupts are not configured correctly.
840 static void sym_timer (hcb_p np
)
842 u_long thistime
= ktime_get(0);
844 #if LINUX_VERSION_CODE < LinuxVersionCode(2, 4, 0)
846 * If release process in progress, let's go
847 * Set the release stage from 1 to 2 to synchronize
848 * with the release process.
851 if (np
->s
.release_stage
) {
852 if (np
->s
.release_stage
== 1)
853 np
->s
.release_stage
= 2;
861 #ifdef SYM_CONF_PCIQ_BROKEN_INTR
862 np
->s
.timer
.expires
= ktime_get((HZ
+99)/100);
864 np
->s
.timer
.expires
= ktime_get(SYM_CONF_TIMER_INTERVAL
);
866 add_timer(&np
->s
.timer
);
869 * If we are resetting the ncr, wait for settle_time before
870 * clearing it. Then command processing will be resumed.
872 if (np
->s
.settle_time_valid
) {
873 if (ktime_dif(np
->s
.settle_time
, thistime
) <= 0){
874 if (sym_verbose
>= 2 )
875 printk("%s: command processing resumed\n",
877 np
->s
.settle_time_valid
= 0;
883 * Nothing to do for now, but that may come.
885 if (np
->s
.lasttime
+ 4*HZ
< thistime
) {
886 np
->s
.lasttime
= thistime
;
889 #ifdef SYM_CONF_PCIQ_MAY_MISS_COMPLETIONS
891 * Some way-broken PCI bridges may lead to
892 * completions being lost when the clearing
893 * of the INTFLY flag by the CPU occurs
894 * concurrently with the chip raising this flag.
895 * If this ever happen, lost completions will
901 #ifdef SYM_CONF_PCIQ_BROKEN_INTR
902 if (INB(nc_istat
) & (INTF
|SIP
|DIP
)) {
905 ** Process pending interrupts.
907 if (DEBUG_FLAGS
& DEBUG_TINY
) printk ("{");
909 if (DEBUG_FLAGS
& DEBUG_TINY
) printk ("}");
911 #endif /* SYM_CONF_PCIQ_BROKEN_INTR */
916 * PCI BUS error handler.
918 void sym_log_bus_error(hcb_p np
)
921 pci_read_config_word(np
->s
.device
, PCI_STATUS
, &pci_sts
);
922 if (pci_sts
& 0xf900) {
923 pci_write_config_word(np
->s
.device
, PCI_STATUS
,
925 printf("%s: PCI STATUS = 0x%04x\n",
926 sym_name(np
), pci_sts
& 0xf900);
932 * Requeue awaiting commands.
934 static void sym_requeue_awaiting_cmds(hcb_p np
)
937 ucmd_p ucp
= SYM_UCMD_PTR(cmd
);
938 SYM_QUEHEAD tmp_cmdq
;
941 sym_que_move(&np
->s
.wait_cmdq
, &tmp_cmdq
);
943 while ((ucp
= (ucmd_p
) sym_remque_head(&tmp_cmdq
)) != 0) {
944 sym_insque_tail(&ucp
->link_cmdq
, &np
->s
.busy_cmdq
);
945 cmd
= SYM_SCMD_PTR(ucp
);
946 sts
= sym_queue_command(np
, cmd
);
948 sym_remque(&ucp
->link_cmdq
);
949 sym_insque_head(&ucp
->link_cmdq
, &np
->s
.wait_cmdq
);
955 * Linux entry point of the queuecommand() function
957 int sym53c8xx_queue_command (Scsi_Cmnd
*cmd
, void (*done
)(Scsi_Cmnd
*))
959 hcb_p np
= SYM_SOFTC_PTR(cmd
);
960 ucmd_p ucp
= SYM_UCMD_PTR(cmd
);
966 cmd
->scsi_done
= done
;
967 cmd
->host_scribble
= NULL
;
968 memset(ucp
, 0, sizeof(*ucp
));
971 SYM_LOCK_HCB(np
, flags
);
975 * Shorten our settle_time if needed for
976 * this command not to time out.
978 if (np
->s
.settle_time_valid
&& cmd
->timeout_per_command
) {
979 u_long tlimit
= ktime_get(cmd
->timeout_per_command
);
980 tlimit
= ktime_sub(tlimit
, SYM_CONF_TIMER_INTERVAL
*2);
981 if (ktime_dif(np
->s
.settle_time
, tlimit
) > 0) {
982 np
->s
.settle_time
= tlimit
;
986 if (np
->s
.settle_time_valid
|| !sym_que_empty(&np
->s
.wait_cmdq
)) {
987 sym_insque_tail(&ucp
->link_cmdq
, &np
->s
.wait_cmdq
);
991 sym_insque_tail(&ucp
->link_cmdq
, &np
->s
.busy_cmdq
);
992 sts
= sym_queue_command(np
, cmd
);
994 sym_remque(&ucp
->link_cmdq
);
995 sym_insque_tail(&ucp
->link_cmdq
, &np
->s
.wait_cmdq
);
999 SYM_UNLOCK_HCB(np
, flags
);
1006 * Linux entry point of the interrupt handler.
1008 static irqreturn_t
sym53c8xx_intr(int irq
, void *dev_id
, struct pt_regs
* regs
)
1010 unsigned long flags
;
1011 hcb_p np
= (hcb_p
) dev_id
;
1013 if (DEBUG_FLAGS
& DEBUG_TINY
) printf_debug ("[");
1015 SYM_LOCK_HCB(np
, flags
);
1020 * push queue walk-through to tasklet
1022 if (!sym_que_empty(&np
->s
.wait_cmdq
) && !np
->s
.settle_time_valid
)
1023 sym_requeue_awaiting_cmds(np
);
1025 SYM_UNLOCK_HCB(np
, flags
);
1027 if (DEBUG_FLAGS
& DEBUG_TINY
) printf_debug ("]\n");
1033 * Linux entry point of the timer handler
1035 static void sym53c8xx_timer(unsigned long npref
)
1037 hcb_p np
= (hcb_p
) npref
;
1038 unsigned long flags
;
1040 SYM_LOCK_HCB(np
, flags
);
1044 if (!sym_que_empty(&np
->s
.wait_cmdq
) && !np
->s
.settle_time_valid
)
1045 sym_requeue_awaiting_cmds(np
);
1047 SYM_UNLOCK_HCB(np
, flags
);
1052 * What the eh thread wants us to perform.
1054 #define SYM_EH_ABORT 0
1055 #define SYM_EH_DEVICE_RESET 1
1056 #define SYM_EH_BUS_RESET 2
1057 #define SYM_EH_HOST_RESET 3
1060 * What we will do regarding the involved SCSI command.
1062 #define SYM_EH_DO_IGNORE 0
1063 #define SYM_EH_DO_COMPLETE 1
1064 #define SYM_EH_DO_WAIT 2
1067 * Our general completion handler.
1069 static void __sym_eh_done(Scsi_Cmnd
*cmd
, int timed_out
)
1071 struct sym_eh_wait
*ep
= SYM_UCMD_PTR(cmd
)->eh_wait
;
1075 /* Try to avoid a race here (not 100% safe) */
1078 if (ep
->to_do
== SYM_EH_DO_WAIT
&& !del_timer(&ep
->timer
))
1082 /* Revert everything */
1083 SYM_UCMD_PTR(cmd
)->eh_wait
= 0;
1084 cmd
->scsi_done
= ep
->old_done
;
1086 /* Wake up the eh thread if it wants to sleep */
1087 if (ep
->to_do
== SYM_EH_DO_WAIT
)
1092 * scsi_done() alias when error recovery is in progress.
1094 static void sym_eh_done(Scsi_Cmnd
*cmd
) { __sym_eh_done(cmd
, 0); }
1097 * Some timeout handler to avoid waiting too long.
1099 static void sym_eh_timeout(u_long p
) { __sym_eh_done((Scsi_Cmnd
*)p
, 1); }
1102 * Generic method for our eh processing.
1103 * The 'op' argument tells what we have to do.
1105 static int sym_eh_handler(int op
, char *opname
, Scsi_Cmnd
*cmd
)
1107 hcb_p np
= SYM_SOFTC_PTR(cmd
);
1109 int to_do
= SYM_EH_DO_IGNORE
;
1111 struct sym_eh_wait eh
, *ep
= &eh
;
1114 sprintf(devname
, "%s:%d:%d", sym_name(np
), cmd
->device
->id
, cmd
->device
->lun
);
1116 printf_warning("%s: %s operation started.\n", devname
, opname
);
1119 /* This one should be the result of some race, thus to ignore */
1120 if (cmd
->serial_number
!= cmd
->serial_number_at_timeout
)
1124 /* This one is not queued to the core driver -> to complete here */
1125 FOR_EACH_QUEUED_ELEMENT(&np
->s
.wait_cmdq
, qp
) {
1126 if (SYM_SCMD_PTR(qp
) == cmd
) {
1127 to_do
= SYM_EH_DO_COMPLETE
;
1132 /* This one is queued in some place -> to wait for completion */
1133 FOR_EACH_QUEUED_ELEMENT(&np
->busy_ccbq
, qp
) {
1134 ccb_p cp
= sym_que_entry(qp
, struct sym_ccb
, link_ccbq
);
1135 if (cp
->cam_ccb
== cmd
) {
1136 to_do
= SYM_EH_DO_WAIT
;
1142 /* Prepare stuff to either ignore, complete or wait for completion */
1145 case SYM_EH_DO_IGNORE
:
1148 case SYM_EH_DO_WAIT
:
1149 #if LINUX_VERSION_CODE > LinuxVersionCode(2,3,0)
1150 init_MUTEX_LOCKED(&ep
->sem
);
1152 ep
->sem
= MUTEX_LOCKED
;
1155 case SYM_EH_DO_COMPLETE
:
1156 ep
->old_done
= cmd
->scsi_done
;
1157 cmd
->scsi_done
= sym_eh_done
;
1158 SYM_UCMD_PTR(cmd
)->eh_wait
= ep
;
1161 /* Try to proceed the operation we have been asked for */
1165 sts
= sym_abort_scsiio(np
, cmd
, 1);
1167 case SYM_EH_DEVICE_RESET
:
1168 sts
= sym_reset_scsi_target(np
, cmd
->device
->id
);
1170 case SYM_EH_BUS_RESET
:
1171 sym_reset_scsi_bus(np
, 1);
1174 case SYM_EH_HOST_RESET
:
1175 sym_reset_scsi_bus(np
, 0);
1176 sym_start_up (np
, 1);
1183 /* On error, restore everything and cross fingers :) */
1185 SYM_UCMD_PTR(cmd
)->eh_wait
= 0;
1186 cmd
->scsi_done
= ep
->old_done
;
1187 to_do
= SYM_EH_DO_IGNORE
;
1192 /* Complete the command with locks held as required by the driver */
1193 if (to_do
== SYM_EH_DO_COMPLETE
)
1194 sym_xpt_done2(np
, cmd
, CAM_REQ_ABORTED
);
1196 /* Wait for completion with locks released, as required by kernel */
1197 if (to_do
== SYM_EH_DO_WAIT
) {
1198 init_timer(&ep
->timer
);
1199 ep
->timer
.expires
= jiffies
+ (5*HZ
);
1200 ep
->timer
.function
= sym_eh_timeout
;
1201 ep
->timer
.data
= (u_long
)cmd
;
1202 ep
->timed_out
= 1; /* Be pessimistic for once :) */
1203 add_timer(&ep
->timer
);
1208 printf_warning("%s: %s operation %s.\n", devname
, opname
,
1209 sts
==0?"complete":sts
==-2?"timed-out":"failed");
1210 return sts
? SCSI_FAILED
: SCSI_SUCCESS
;
1215 * Error handlers called from the eh thread (one thread per HBA).
1217 int sym53c8xx_eh_abort_handler(Scsi_Cmnd
*cmd
)
1219 return sym_eh_handler(SYM_EH_ABORT
, "ABORT", cmd
);
1222 int sym53c8xx_eh_device_reset_handler(Scsi_Cmnd
*cmd
)
1224 return sym_eh_handler(SYM_EH_DEVICE_RESET
, "DEVICE RESET", cmd
);
1227 int sym53c8xx_eh_bus_reset_handler(Scsi_Cmnd
*cmd
)
1229 return sym_eh_handler(SYM_EH_BUS_RESET
, "BUS RESET", cmd
);
1232 int sym53c8xx_eh_host_reset_handler(Scsi_Cmnd
*cmd
)
1234 return sym_eh_handler(SYM_EH_HOST_RESET
, "HOST RESET", cmd
);
1238 * Tune device queuing depth, according to various limits.
1241 sym_tune_dev_queuing(hcb_p np
, int target
, int lun
, u_short reqtags
)
1243 tcb_p tp
= &np
->target
[target
];
1244 lcb_p lp
= sym_lp(np
, tp
, lun
);
1250 oldtags
= lp
->s
.reqtags
;
1252 if (reqtags
> lp
->s
.scdev_depth
)
1253 reqtags
= lp
->s
.scdev_depth
;
1255 lp
->started_limit
= reqtags
? reqtags
: 2;
1256 lp
->started_max
= 1;
1257 lp
->s
.reqtags
= reqtags
;
1259 if (reqtags
!= oldtags
) {
1260 printf_info("%s:%d:%d: "
1261 "tagged command queuing %s, command queue depth %d.\n",
1262 sym_name(np
), target
, lun
,
1263 lp
->s
.reqtags
? "enabled" : "disabled",
1268 #ifdef SYM_LINUX_BOOT_COMMAND_LINE_SUPPORT
1270 * Linux select queue depths function
1272 #define DEF_DEPTH (sym_driver_setup.max_tag)
1273 #define ALL_TARGETS -2
1274 #define NO_TARGET -1
1278 static int device_queue_depth(hcb_p np
, int target
, int lun
)
1281 char *p
= sym_driver_setup
.tag_ctrl
;
1287 while ((c
= *p
++) != 0) {
1288 v
= simple_strtoul(p
, &ep
, 0);
1297 t
= (target
== v
) ? v
: NO_TARGET
;
1302 u
= (lun
== v
) ? v
: NO_LUN
;
1305 if (h
== np
->s
.unit
&&
1306 (t
== ALL_TARGETS
|| t
== target
) &&
1307 (u
== ALL_LUNS
|| u
== lun
))
1322 #define device_queue_depth(np, t, l) (sym_driver_setup.max_tag)
1323 #endif /* SYM_LINUX_BOOT_COMMAND_LINE_SUPPORT */
1326 * Linux entry point for device queue sizing.
1329 sym53c8xx_slave_configure(Scsi_Device
*device
)
1331 struct Scsi_Host
*host
= device
->host
;
1335 int reqtags
, depth_to_use
;
1337 np
= ((struct host_data
*) host
->hostdata
)->ncb
;
1338 tp
= &np
->target
[device
->id
];
1341 * Get user settings for transfer parameters.
1343 tp
->inq_byte7_valid
= (INQ7_SYNC
|INQ7_WIDE16
);
1344 sym_update_trans_settings(np
, tp
);
1347 * Allocate the LCB if not yet.
1348 * If it fail, we may well be in the sh*t. :)
1350 lp
= sym_alloc_lcb(np
, device
->id
, device
->lun
);
1357 lp
->curr_flags
= lp
->user_flags
;
1360 * Select queue depth from driver setup.
1361 * Donnot use more than configured by user.
1363 * Donnot use more than our maximum.
1365 reqtags
= device_queue_depth(np
, device
->id
, device
->lun
);
1366 if (reqtags
> tp
->usrtags
)
1367 reqtags
= tp
->usrtags
;
1368 if (!device
->tagged_supported
)
1370 #if 1 /* Avoid to locally queue commands for no good reasons */
1371 if (reqtags
> SYM_CONF_MAX_TAG
)
1372 reqtags
= SYM_CONF_MAX_TAG
;
1373 depth_to_use
= (reqtags
? reqtags
: 2);
1375 depth_to_use
= (reqtags
? SYM_CONF_MAX_TAG
: 2);
1377 scsi_adjust_queue_depth(device
,
1378 (device
->tagged_supported
?
1379 MSG_SIMPLE_TAG
: 0),
1381 lp
->s
.scdev_depth
= depth_to_use
;
1382 sym_tune_dev_queuing(np
, device
->id
, device
->lun
, reqtags
);
1388 * Linux entry point for info() function
1390 const char *sym53c8xx_info (struct Scsi_Host
*host
)
1392 return sym_driver_name();
1396 #ifdef SYM_LINUX_PROC_INFO_SUPPORT
1398 * Proc file system stuff
1400 * A read operation returns adapter information.
1401 * A write operation is a control command.
1402 * The string is parsed in the driver code and the command is passed
1403 * to the sym_usercmd() function.
1406 #ifdef SYM_LINUX_USER_COMMAND_SUPPORT
1415 #define UC_SETSYNC 10
1416 #define UC_SETTAGS 11
1417 #define UC_SETDEBUG 12
1418 #define UC_SETWIDE 14
1419 #define UC_SETFLAG 15
1420 #define UC_SETVERBOSE 17
1421 #define UC_RESETDEV 18
1422 #define UC_CLEARDEV 19
1424 static void sym_exec_user_command (hcb_p np
, struct sym_usrcmd
*uc
)
1432 #ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT
1434 sym_debug_flags
= uc
->data
;
1438 np
->verbose
= uc
->data
;
1442 * We assume that other commands apply to targets.
1443 * This should always be the case and avoid the below
1444 * 4 lines to be repeated 6 times.
1446 for (t
= 0; t
< SYM_CONF_MAX_TARGET
; t
++) {
1447 if (!((uc
->target
>> t
) & 1))
1449 tp
= &np
->target
[t
];
1454 if (!uc
->data
|| uc
->data
>= 255) {
1455 tp
->tinfo
.goal
.options
= 0;
1456 tp
->tinfo
.goal
.offset
= 0;
1459 if (uc
->data
<= 9 && np
->minsync_dt
) {
1460 if (uc
->data
< np
->minsync_dt
)
1461 uc
->data
= np
->minsync_dt
;
1462 tp
->tinfo
.goal
.options
= PPR_OPT_DT
;
1463 tp
->tinfo
.goal
.width
= 1;
1464 tp
->tinfo
.goal
.period
= uc
->data
;
1465 tp
->tinfo
.goal
.offset
= np
->maxoffs_dt
;
1468 if (uc
->data
< np
->minsync
)
1469 uc
->data
= np
->minsync
;
1470 tp
->tinfo
.goal
.options
= 0;
1471 tp
->tinfo
.goal
.period
= uc
->data
;
1472 tp
->tinfo
.goal
.offset
= np
->maxoffs
;
1476 tp
->tinfo
.goal
.width
= uc
->data
? 1 : 0;
1479 for (l
= 0; l
< SYM_CONF_MAX_LUN
; l
++)
1480 sym_tune_dev_queuing(np
, t
,l
, uc
->data
);
1484 np
->istat_sem
= SEM
;
1485 OUTB (nc_istat
, SIGP
|SEM
);
1488 for (l
= 0; l
< SYM_CONF_MAX_LUN
; l
++) {
1489 lcb_p lp
= sym_lp(np
, tp
, l
);
1490 if (lp
) lp
->to_clear
= 1;
1492 np
->istat_sem
= SEM
;
1493 OUTB (nc_istat
, SIGP
|SEM
);
1496 tp
->usrflags
= uc
->data
;
1504 #define is_digit(c) ((c) >= '0' && (c) <= '9')
1505 #define digit_to_bin(c) ((c) - '0')
1506 #define is_space(c) ((c) == ' ' || (c) == '\t')
1508 static int skip_spaces(char *ptr
, int len
)
1512 for (cnt
= len
; cnt
> 0 && (c
= *ptr
++) && is_space(c
); cnt
--);
1517 static int get_int_arg(char *ptr
, int len
, u_long
*pv
)
1522 for (v
= 0, cnt
= len
; cnt
> 0 && (c
= *ptr
++) && is_digit(c
); cnt
--) {
1523 v
= (v
* 10) + digit_to_bin(c
);
1532 static int is_keyword(char *ptr
, int len
, char *verb
)
1534 int verb_len
= strlen(verb
);
1536 if (len
>= strlen(verb
) && !memcmp(verb
, ptr
, verb_len
))
1543 #define SKIP_SPACES(min_spaces) \
1544 if ((arg_len = skip_spaces(ptr, len)) < (min_spaces)) \
1546 ptr += arg_len; len -= arg_len;
1548 #define GET_INT_ARG(v) \
1549 if (!(arg_len = get_int_arg(ptr, len, &(v)))) \
1551 ptr += arg_len; len -= arg_len;
1555 * Parse a control command
1558 static int sym_user_command(hcb_p np
, char *buffer
, int length
)
1562 struct sym_usrcmd cmd
, *uc
= &cmd
;
1566 bzero(uc
, sizeof(*uc
));
1568 if (len
> 0 && ptr
[len
-1] == '\n')
1571 if ((arg_len
= is_keyword(ptr
, len
, "setsync")) != 0)
1572 uc
->cmd
= UC_SETSYNC
;
1573 else if ((arg_len
= is_keyword(ptr
, len
, "settags")) != 0)
1574 uc
->cmd
= UC_SETTAGS
;
1575 else if ((arg_len
= is_keyword(ptr
, len
, "setverbose")) != 0)
1576 uc
->cmd
= UC_SETVERBOSE
;
1577 else if ((arg_len
= is_keyword(ptr
, len
, "setwide")) != 0)
1578 uc
->cmd
= UC_SETWIDE
;
1579 #ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT
1580 else if ((arg_len
= is_keyword(ptr
, len
, "setdebug")) != 0)
1581 uc
->cmd
= UC_SETDEBUG
;
1583 else if ((arg_len
= is_keyword(ptr
, len
, "setflag")) != 0)
1584 uc
->cmd
= UC_SETFLAG
;
1585 else if ((arg_len
= is_keyword(ptr
, len
, "resetdev")) != 0)
1586 uc
->cmd
= UC_RESETDEV
;
1587 else if ((arg_len
= is_keyword(ptr
, len
, "cleardev")) != 0)
1588 uc
->cmd
= UC_CLEARDEV
;
1592 #ifdef DEBUG_PROC_INFO
1593 printk("sym_user_command: arg_len=%d, cmd=%ld\n", arg_len
, uc
->cmd
);
1598 ptr
+= arg_len
; len
-= arg_len
;
1608 if ((arg_len
= is_keyword(ptr
, len
, "all")) != 0) {
1609 ptr
+= arg_len
; len
-= arg_len
;
1612 GET_INT_ARG(target
);
1613 uc
->target
= (1<<target
);
1614 #ifdef DEBUG_PROC_INFO
1615 printk("sym_user_command: target=%ld\n", target
);
1627 GET_INT_ARG(uc
->data
);
1628 #ifdef DEBUG_PROC_INFO
1629 printk("sym_user_command: data=%ld\n", uc
->data
);
1632 #ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT
1636 if ((arg_len
= is_keyword(ptr
, len
, "alloc")))
1637 uc
->data
|= DEBUG_ALLOC
;
1638 else if ((arg_len
= is_keyword(ptr
, len
, "phase")))
1639 uc
->data
|= DEBUG_PHASE
;
1640 else if ((arg_len
= is_keyword(ptr
, len
, "queue")))
1641 uc
->data
|= DEBUG_QUEUE
;
1642 else if ((arg_len
= is_keyword(ptr
, len
, "result")))
1643 uc
->data
|= DEBUG_RESULT
;
1644 else if ((arg_len
= is_keyword(ptr
, len
, "scatter")))
1645 uc
->data
|= DEBUG_SCATTER
;
1646 else if ((arg_len
= is_keyword(ptr
, len
, "script")))
1647 uc
->data
|= DEBUG_SCRIPT
;
1648 else if ((arg_len
= is_keyword(ptr
, len
, "tiny")))
1649 uc
->data
|= DEBUG_TINY
;
1650 else if ((arg_len
= is_keyword(ptr
, len
, "timing")))
1651 uc
->data
|= DEBUG_TIMING
;
1652 else if ((arg_len
= is_keyword(ptr
, len
, "nego")))
1653 uc
->data
|= DEBUG_NEGO
;
1654 else if ((arg_len
= is_keyword(ptr
, len
, "tags")))
1655 uc
->data
|= DEBUG_TAGS
;
1656 else if ((arg_len
= is_keyword(ptr
, len
, "pointer")))
1657 uc
->data
|= DEBUG_POINTER
;
1660 ptr
+= arg_len
; len
-= arg_len
;
1662 #ifdef DEBUG_PROC_INFO
1663 printk("sym_user_command: data=%ld\n", uc
->data
);
1666 #endif /* SYM_LINUX_DEBUG_CONTROL_SUPPORT */
1670 if ((arg_len
= is_keyword(ptr
, len
, "no_disc")))
1671 uc
->data
&= ~SYM_DISC_ENABLED
;
1674 ptr
+= arg_len
; len
-= arg_len
;
1684 unsigned long flags
;
1686 SYM_LOCK_HCB(np
, flags
);
1687 sym_exec_user_command (np
, uc
);
1688 SYM_UNLOCK_HCB(np
, flags
);
1693 #endif /* SYM_LINUX_USER_COMMAND_SUPPORT */
1696 #ifdef SYM_LINUX_USER_INFO_SUPPORT
1698 * Informations through the proc file system.
1707 static void copy_mem_info(struct info_str
*info
, char *data
, int len
)
1709 if (info
->pos
+ len
> info
->length
)
1710 len
= info
->length
- info
->pos
;
1712 if (info
->pos
+ len
< info
->offset
) {
1716 if (info
->pos
< info
->offset
) {
1717 data
+= (info
->offset
- info
->pos
);
1718 len
-= (info
->offset
- info
->pos
);
1722 memcpy(info
->buffer
+ info
->pos
, data
, len
);
1727 static int copy_info(struct info_str
*info
, char *fmt
, ...)
1733 va_start(args
, fmt
);
1734 len
= vsprintf(buf
, fmt
, args
);
1737 copy_mem_info(info
, buf
, len
);
1742 * Copy formatted information into the input buffer.
1744 static int sym_host_info(hcb_p np
, char *ptr
, off_t offset
, int len
)
1746 struct info_str info
;
1750 info
.offset
= offset
;
1753 copy_info(&info
, "Chip " NAME53C
"%s, device id 0x%x, "
1754 "revision id 0x%x\n",
1755 np
->s
.chip_name
, np
->device_id
, np
->revision_id
);
1756 copy_info(&info
, "On PCI bus %d, device %d, function %d, "
1762 np
->s
.bus
, (np
->s
.device_fn
& 0xf8) >> 3, np
->s
.device_fn
& 7,
1764 __irq_itoa(np
->s
.irq
));
1768 copy_info(&info
, "Min. period factor %d, %s SCSI BUS%s\n",
1769 (int) (np
->minsync_dt
? np
->minsync_dt
: np
->minsync
),
1770 np
->maxwide
? "Wide" : "Narrow",
1771 np
->minsync_dt
? ", DT capable" : "");
1773 copy_info(&info
, "Max. started commands %d, "
1774 "max. commands per LUN %d\n",
1775 SYM_CONF_MAX_START
, SYM_CONF_MAX_TAG
);
1777 return info
.pos
> info
.offset
? info
.pos
- info
.offset
: 0;
1779 #endif /* SYM_LINUX_USER_INFO_SUPPORT */
1782 * Entry point of the scsi proc fs of the driver.
1783 * - func = 0 means read (returns adapter infos)
1784 * - func = 1 means write (not yet merget from sym53c8xx)
1786 static int sym53c8xx_proc_info(struct Scsi_Host
*host
, char *buffer
, char **start
, off_t offset
,
1787 int length
, int func
)
1789 struct host_data
*host_data
;
1793 host_data
= (struct host_data
*) host
->hostdata
;
1794 np
= host_data
->ncb
;
1799 #ifdef SYM_LINUX_USER_COMMAND_SUPPORT
1800 retv
= sym_user_command(np
, buffer
, length
);
1808 #ifdef SYM_LINUX_USER_INFO_SUPPORT
1809 retv
= sym_host_info(np
, buffer
, offset
, length
);
1817 #endif /* SYM_LINUX_PROC_INFO_SUPPORT */
1820 * Free controller resources.
1822 static void sym_free_resources(hcb_p np
)
1825 * Free O/S specific resources.
1828 free_irq(np
->s
.irq
, np
);
1830 release_region(np
->s
.io_port
, np
->s
.io_ws
);
1831 #ifndef SYM_OPT_NO_BUS_MEMORY_MAPPING
1833 pci_unmap_mem(np
->s
.mmio_va
, np
->s
.io_ws
);
1835 pci_unmap_mem(np
->s
.ram_va
, np
->ram_ws
);
1838 * Free O/S independent resources.
1842 sym_mfree_dma(np
, sizeof(*np
), "HCB");
1846 * Ask/tell the system about DMA addressing.
1848 #ifdef SYM_LINUX_DYNAMIC_DMA_MAPPING
1849 static int sym_setup_bus_dma_mask(hcb_p np
)
1851 #if LINUX_VERSION_CODE < LinuxVersionCode(2,4,3)
1852 if (!pci_dma_supported(np
->s
.device
, 0xffffffffUL
))
1855 #if SYM_CONF_DMA_ADDRESSING_MODE == 0
1856 if (pci_set_dma_mask(np
->s
.device
, 0xffffffffUL
))
1859 #if SYM_CONF_DMA_ADDRESSING_MODE == 1
1860 #define PciDmaMask 0xffffffffff
1861 #elif SYM_CONF_DMA_ADDRESSING_MODE == 2
1862 #define PciDmaMask 0xffffffffffffffffULL
1864 if (np
->features
& FE_DAC
) {
1865 if (!pci_set_dma_mask(np
->s
.device
, PciDmaMask
)) {
1867 printf_info("%s: using 64 bit DMA addressing\n",
1871 if (pci_set_dma_mask(np
->s
.device
, 0xffffffffUL
))
1881 printf_warning("%s: 32 BIT DMA ADDRESSING NOT SUPPORTED\n",
1885 #endif /* SYM_LINUX_DYNAMIC_DMA_MAPPING */
1888 * Host attach and initialisations.
1890 * Allocate host data and ncb structure.
1891 * Request IO region and remap MMIO region.
1892 * Do chip initialization.
1893 * If all is OK, install interrupt handling and
1894 * start the timer daemon.
1897 sym_attach (Scsi_Host_Template
*tpnt
, int unit
, sym_device
*dev
)
1899 struct host_data
*host_data
;
1901 struct Scsi_Host
*instance
= 0;
1903 sym_nvram
*nvram
= dev
->nvram
;
1907 "sym%d: <%s> rev 0x%x on pci bus %d device %d function %d "
1913 unit
, dev
->chip
.name
, dev
->chip
.revision_id
,
1914 dev
->s
.bus
, (dev
->s
.device_fn
& 0xf8) >> 3,
1915 dev
->s
.device_fn
& 7,
1917 __irq_itoa(dev
->s
.irq
));
1923 * Get the firmware for this chip.
1925 fw
= sym_find_firmware(&dev
->chip
);
1930 * Allocate host_data structure
1932 if (!(instance
= scsi_register(tpnt
, sizeof(*host_data
))))
1934 host_data
= (struct host_data
*) instance
->hostdata
;
1937 * Allocate immediately the host control block,
1938 * since we are only expecting to succeed. :)
1939 * We keep track in the HCB of all the resources that
1940 * are to be released on error.
1942 #ifdef SYM_LINUX_DYNAMIC_DMA_MAPPING
1943 np
= __sym_calloc_dma(dev
->pdev
, sizeof(*np
), "HCB");
1945 np
->s
.device
= dev
->pdev
;
1946 np
->bus_dmat
= dev
->pdev
; /* Result in 1 DMA pool per HBA */
1951 np
= sym_calloc_dma(sizeof(*np
), "HCB");
1955 host_data
->ncb
= np
;
1956 np
->s
.host
= instance
;
1958 SYM_INIT_LOCK_HCB(np
);
1961 * Copy some useful infos to the HCB.
1963 np
->hcb_ba
= vtobus(np
);
1964 np
->verbose
= sym_driver_setup
.verbose
;
1965 np
->s
.device
= dev
->pdev
;
1967 np
->device_id
= dev
->chip
.device_id
;
1968 np
->revision_id
= dev
->chip
.revision_id
;
1969 np
->s
.bus
= dev
->s
.bus
;
1970 np
->s
.device_fn
= dev
->s
.device_fn
;
1971 np
->features
= dev
->chip
.features
;
1972 np
->clock_divn
= dev
->chip
.nr_divisor
;
1973 np
->maxoffs
= dev
->chip
.offset_max
;
1974 np
->maxburst
= dev
->chip
.burst_max
;
1975 np
->myaddr
= dev
->host_id
;
1980 strlcpy(np
->s
.chip_name
, dev
->chip
.name
, sizeof(np
->s
.chip_name
));
1981 sprintf(np
->s
.inst_name
, "sym%d", np
->s
.unit
);
1984 * Ask/tell the system about DMA addressing.
1986 #ifdef SYM_LINUX_DYNAMIC_DMA_MAPPING
1987 if (sym_setup_bus_dma_mask(np
))
1992 * Try to map the controller chip to
1993 * virtual and physical memory.
1995 np
->mmio_ba
= (u32
)dev
->s
.base
;
1996 np
->s
.io_ws
= (np
->features
& FE_IO256
)? 256 : 128;
1998 #ifndef SYM_CONF_IOMAPPED
1999 np
->s
.mmio_va
= pci_map_mem(dev
->s
.base_c
, np
->s
.io_ws
);
2000 if (!np
->s
.mmio_va
) {
2001 printf_err("%s: can't map PCI MMIO region\n", sym_name(np
));
2004 else if (sym_verbose
> 1)
2005 printf_info("%s: using memory mapped IO\n", sym_name(np
));
2006 #endif /* !defined SYM_CONF_IOMAPPED */
2009 * Try to map the controller chip into iospace.
2011 if (dev
->s
.io_port
) {
2012 request_region(dev
->s
.io_port
, np
->s
.io_ws
, NAME53C8XX
);
2013 np
->s
.io_port
= dev
->s
.io_port
;
2017 * Map on-chip RAM if present and supported.
2019 if (!(np
->features
& FE_RAM
))
2021 if (dev
->s
.base_2
) {
2022 np
->ram_ba
= (u32
)dev
->s
.base_2
;
2023 if (np
->features
& FE_RAM8K
)
2027 #ifndef SYM_OPT_NO_BUS_MEMORY_MAPPING
2028 np
->s
.ram_va
= pci_map_mem(dev
->s
.base_2_c
, np
->ram_ws
);
2029 if (!np
->s
.ram_va
) {
2030 printf_err("%s: can't map PCI MEMORY region\n",
2038 * Perform O/S independent stuff.
2040 if (sym_hcb_attach(np
, fw
, nvram
))
2045 * Install the interrupt handler.
2046 * If we synchonize the C code with SCRIPTS on interrupt,
2047 * we donnot want to share the INTR line at all.
2049 if (request_irq(dev
->s
.irq
, sym53c8xx_intr
, SA_SHIRQ
,
2051 printf_err("%s: request irq %d failure\n",
2052 sym_name(np
), dev
->s
.irq
);
2055 np
->s
.irq
= dev
->s
.irq
;
2058 * After SCSI devices have been opened, we cannot
2059 * reset the bus safely, so we do it here.
2061 SYM_LOCK_HCB(np
, flags
);
2062 if (sym_reset_scsi_bus(np
, 0)) {
2063 printf_err("%s: FATAL ERROR: CHECK SCSI BUS - CABLES, "
2064 "TERMINATION, DEVICE POWER etc.!\n", sym_name(np
));
2065 SYM_UNLOCK_HCB(np
, flags
);
2070 * Initialize some queue headers.
2072 sym_que_init(&np
->s
.wait_cmdq
);
2073 sym_que_init(&np
->s
.busy_cmdq
);
2076 * Start the SCRIPTS.
2078 sym_start_up (np
, 1);
2081 * Start the timer daemon
2083 init_timer(&np
->s
.timer
);
2084 np
->s
.timer
.data
= (unsigned long) np
;
2085 np
->s
.timer
.function
= sym53c8xx_timer
;
2093 first_host
= instance
;
2096 * Fill Linux host instance structure
2097 * and return success.
2099 instance
->max_channel
= 0;
2100 instance
->this_id
= np
->myaddr
;
2101 instance
->max_id
= np
->maxwide
? 16 : 8;
2102 instance
->max_lun
= SYM_CONF_MAX_LUN
;
2103 #ifndef SYM_CONF_IOMAPPED
2104 #if LINUX_VERSION_CODE >= LinuxVersionCode(2,3,29)
2105 instance
->base
= (unsigned long) np
->s
.mmio_va
;
2107 instance
->base
= (char *) np
->s
.mmio_va
;
2110 instance
->irq
= np
->s
.irq
;
2111 instance
->unique_id
= np
->s
.io_port
;
2112 instance
->io_port
= np
->s
.io_port
;
2113 instance
->n_io_port
= np
->s
.io_ws
;
2114 instance
->dma_channel
= 0;
2115 instance
->cmd_per_lun
= SYM_CONF_MAX_TAG
;
2116 instance
->can_queue
= (SYM_CONF_MAX_START
-2);
2117 instance
->sg_tablesize
= SYM_CONF_MAX_SG
;
2118 #if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
2119 instance
->max_cmd_len
= 16;
2121 instance
->highmem_io
= 1;
2123 SYM_UNLOCK_HCB(np
, flags
);
2125 scsi_set_device(instance
, &dev
->pdev
->dev
);
2128 * Now let the generic SCSI driver
2129 * look for the SCSI devices on the bus ..
2134 if (!instance
) return -1;
2135 printf_info("%s: giving up ...\n", sym_name(np
));
2137 sym_free_resources(np
);
2138 scsi_unregister(instance
);
2145 * Detect and try to read SYMBIOS and TEKRAM NVRAM.
2147 #if SYM_CONF_NVRAM_SUPPORT
2148 static void __init
sym_get_nvram(sym_device
*devp
, sym_nvram
*nvp
)
2154 devp
->device_id
= devp
->chip
.device_id
;
2158 * Get access to chip IO registers
2160 #ifdef SYM_CONF_IOMAPPED
2161 request_region(devp
->s
.io_port
, 128, NAME53C8XX
);
2163 devp
->s
.mmio_va
= pci_map_mem(devp
->s
.base_c
, 128);
2164 if (!devp
->s
.mmio_va
)
2169 * Try to read SYMBIOS|TEKRAM nvram.
2171 (void) sym_read_nvram(devp
, nvp
);
2174 * Release access to chip IO registers
2176 #ifdef SYM_CONF_IOMAPPED
2177 release_region(devp
->s
.io_port
, 128);
2179 pci_unmap_mem((u_long
) devp
->s
.mmio_va
, 128ul);
2182 #endif /* SYM_CONF_NVRAM_SUPPORT */
2185 * Driver setup from the boot command line
2187 #ifdef SYM_LINUX_BOOT_COMMAND_LINE_SUPPORT
2189 static struct sym_driver_setup
2190 sym_driver_safe_setup __initdata
= SYM_LINUX_DRIVER_SAFE_SETUP
;
2192 char *sym53c8xx
= 0; /* command line passed by insmod */
2193 MODULE_PARM(sym53c8xx
, "s");
2196 static void __init
sym53c8xx_print_driver_setup(void)
2198 printf_info (NAME53C8XX
": setup="
2199 "mpar:%d,spar:%d,tags:%d,sync:%d,burst:%d,"
2200 "led:%d,wide:%d,diff:%d,irqm:%d, buschk:%d\n",
2201 sym_driver_setup
.pci_parity
,
2202 sym_driver_setup
.scsi_parity
,
2203 sym_driver_setup
.max_tag
,
2204 sym_driver_setup
.min_sync
,
2205 sym_driver_setup
.burst_order
,
2206 sym_driver_setup
.scsi_led
,
2207 sym_driver_setup
.max_wide
,
2208 sym_driver_setup
.scsi_diff
,
2209 sym_driver_setup
.irq_mode
,
2210 sym_driver_setup
.scsi_bus_check
);
2211 printf_info (NAME53C8XX
": setup="
2212 "hostid:%d,offs:%d,luns:%d,pcifix:%d,revprob:%d,"
2213 "verb:%d,debug:0x%x,setlle_delay:%d\n",
2214 sym_driver_setup
.host_id
,
2215 sym_driver_setup
.max_offs
,
2216 sym_driver_setup
.max_lun
,
2217 sym_driver_setup
.pci_fix_up
,
2218 sym_driver_setup
.reverse_probe
,
2219 sym_driver_setup
.verbose
,
2220 sym_driver_setup
.debug
,
2221 sym_driver_setup
.settle_delay
);
2227 #define OPT_PCI_PARITY 1
2228 #define OPT_SCSI_PARITY 2
2229 #define OPT_MAX_TAG 3
2230 #define OPT_MIN_SYNC 4
2231 #define OPT_BURST_ORDER 5
2232 #define OPT_SCSI_LED 6
2233 #define OPT_MAX_WIDE 7
2234 #define OPT_SCSI_DIFF 8
2235 #define OPT_IRQ_MODE 9
2236 #define OPT_SCSI_BUS_CHECK 10
2237 #define OPT_HOST_ID 11
2238 #define OPT_MAX_OFFS 12
2239 #define OPT_MAX_LUN 13
2240 #define OPT_PCI_FIX_UP 14
2242 #define OPT_REVERSE_PROBE 15
2243 #define OPT_VERBOSE 16
2244 #define OPT_DEBUG 17
2245 #define OPT_SETTLE_DELAY 18
2246 #define OPT_USE_NVRAM 19
2247 #define OPT_EXCLUDE 20
2248 #define OPT_SAFE_SETUP 21
2250 static char setup_token
[] __initdata
=
2270 static int __init
get_setup_token(char *p
)
2272 char *cur
= setup_token
;
2276 while (cur
!= NULL
&& (pc
= strchr(cur
, ':')) != NULL
) {
2279 if (!strncmp(p
, cur
, pc
- cur
))
2285 #endif /* SYM_LINUX_BOOT_COMMAND_LINE_SUPPORT */
2287 int __init
sym53c8xx_setup(char *str
)
2289 #ifdef SYM_LINUX_BOOT_COMMAND_LINE_SUPPORT
2296 while (cur
!= NULL
&& (pc
= strchr(cur
, ':')) != NULL
) {
2308 val
= (int) simple_strtoul(pv
, &pe
, 0);
2310 switch (get_setup_token(cur
)) {
2312 sym_driver_setup
.max_tag
= val
;
2313 if (!(pe
&& *pe
== '/'))
2316 while (*pe
&& *pe
!= ARG_SEP
&&
2317 i
< sizeof(sym_driver_setup
.tag_ctrl
)-1) {
2318 sym_driver_setup
.tag_ctrl
[i
++] = *pe
++;
2320 sym_driver_setup
.tag_ctrl
[i
] = '\0';
2322 case OPT_SAFE_SETUP
:
2323 memcpy(&sym_driver_setup
, &sym_driver_safe_setup
,
2324 sizeof(sym_driver_setup
));
2328 sym_driver_setup
.excludes
[xi
++] = val
;
2331 #define __SIMPLE_OPTION(NAME, name) \
2332 case OPT_ ## NAME : \
2333 sym_driver_setup.name = val;\
2336 __SIMPLE_OPTION(PCI_PARITY
, pci_parity
)
2337 __SIMPLE_OPTION(SCSI_PARITY
, scsi_parity
)
2338 __SIMPLE_OPTION(MIN_SYNC
, min_sync
)
2339 __SIMPLE_OPTION(BURST_ORDER
, burst_order
)
2340 __SIMPLE_OPTION(SCSI_LED
, scsi_led
)
2341 __SIMPLE_OPTION(MAX_WIDE
, max_wide
)
2342 __SIMPLE_OPTION(SCSI_DIFF
, scsi_diff
)
2343 __SIMPLE_OPTION(IRQ_MODE
, irq_mode
)
2344 __SIMPLE_OPTION(SCSI_BUS_CHECK
, scsi_bus_check
)
2345 __SIMPLE_OPTION(HOST_ID
, host_id
)
2346 __SIMPLE_OPTION(MAX_OFFS
, max_offs
)
2347 __SIMPLE_OPTION(MAX_LUN
, max_lun
)
2348 __SIMPLE_OPTION(PCI_FIX_UP
, pci_fix_up
)
2349 __SIMPLE_OPTION(REVERSE_PROBE
, reverse_probe
)
2350 __SIMPLE_OPTION(VERBOSE
, verbose
)
2351 __SIMPLE_OPTION(DEBUG
, debug
)
2352 __SIMPLE_OPTION(SETTLE_DELAY
, settle_delay
)
2353 __SIMPLE_OPTION(USE_NVRAM
, use_nvram
)
2355 #undef __SIMPLE_OPTION
2358 printk("sym53c8xx_setup: unexpected boot option '%.*s' ignored\n", (int)(pc
-cur
+1), cur
);
2362 if ((cur
= strchr(cur
, ARG_SEP
)) != NULL
)
2365 #endif /* SYM_LINUX_BOOT_COMMAND_LINE_SUPPORT */
2369 #if LINUX_VERSION_CODE >= LinuxVersionCode(2,3,13)
2371 __setup("sym53c8xx=", sym53c8xx_setup
);
2375 #ifdef SYM_CONF_PQS_PDS_SUPPORT
2377 * Detect all NCR PQS/PDS boards and keep track of their bus nr.
2379 * The NCR PQS or PDS card is constructed as a DEC bridge
2380 * behind which sit a proprietary NCR memory controller and
2381 * four or two 53c875s as separate devices. In its usual mode
2382 * of operation, the 875s are slaved to the memory controller
2383 * for all transfers. We can tell if an 875 is part of a
2384 * PQS/PDS or not since if it is, it will be on the same bus
2385 * as the memory controller. To operate with the Linux
2386 * driver, the memory controller is disabled and the 875s
2387 * freed to function independently. The only wrinkle is that
2388 * the preset SCSI ID (which may be zero) must be read in from
2389 * a special configuration space register of the 875
2391 #ifndef SYM_CONF_MAX_PQS_BUS
2392 #define SYM_CONF_MAX_PQS_BUS 16
2394 static int pqs_bus
[SYM_CONF_MAX_PQS_BUS
] __initdata
= { 0 };
2396 static void __init
sym_detect_pqs_pds(void)
2399 pcidev_t dev
= PCIDEV_NULL
;
2401 for(index
=0; index
< SYM_CONF_MAX_PQS_BUS
; index
++) {
2404 dev
= pci_find_device(0x101a, 0x0009, dev
);
2405 if (dev
== PCIDEV_NULL
) {
2406 pqs_bus
[index
] = -1;
2409 printf_info(NAME53C8XX
": NCR PQS/PDS memory controller detected on bus %d\n", PciBusNumber(dev
));
2410 pci_read_config_byte(dev
, 0x44, &tmp
);
2411 /* bit 1: allow individual 875 configuration */
2413 pci_write_config_byte(dev
, 0x44, tmp
);
2414 pci_read_config_byte(dev
, 0x45, &tmp
);
2415 /* bit 2: drive individual 875 interrupts to the bus */
2417 pci_write_config_byte(dev
, 0x45, tmp
);
2419 pqs_bus
[index
] = PciBusNumber(dev
);
2422 #endif /* SYM_CONF_PQS_PDS_SUPPORT */
2425 * Read and check the PCI configuration for any detected NCR
2426 * boards and save data for attaching after all boards have
2430 sym53c8xx_pci_init(Scsi_Host_Template
*tpnt
, pcidev_t pdev
, sym_device
*device
)
2432 u_short vendor_id
, device_id
, command
, status_reg
;
2433 u_char cache_line_size
;
2434 u_char suggested_cache_line_size
= 0;
2435 u_char pci_fix_up
= SYM_SETUP_PCI_FIX_UP
;
2438 u_long base
, base_2
, base_io
;
2439 u_long base_c
, base_2_c
, io_port
;
2443 /* Choose some short name for this device */
2444 sprintf(device
->s
.inst_name
, "sym.%d.%d.%d",
2446 (int) (PciDeviceFn(pdev
) & 0xf8) >> 3,
2447 (int) (PciDeviceFn(pdev
) & 7));
2450 * Read needed minimal info from the PCI config space.
2452 vendor_id
= PciVendorId(pdev
);
2453 device_id
= PciDeviceId(pdev
);
2454 irq
= PciIrqLine(pdev
);
2456 i
= pci_get_base_address(pdev
, 0, &base_io
);
2457 io_port
= pci_get_base_cookie(pdev
, 0);
2459 base_c
= pci_get_base_cookie(pdev
, i
);
2460 i
= pci_get_base_address(pdev
, i
, &base
);
2462 base_2_c
= pci_get_base_cookie(pdev
, i
);
2463 (void) pci_get_base_address(pdev
, i
, &base_2
);
2465 io_port
&= PCI_BASE_ADDRESS_IO_MASK
;
2466 base
&= PCI_BASE_ADDRESS_MEM_MASK
;
2467 base_2
&= PCI_BASE_ADDRESS_MEM_MASK
;
2469 pci_read_config_byte(pdev
, PCI_CLASS_REVISION
, &revision
);
2472 * If user excluded this chip, donnot initialize it.
2475 for (i
= 0 ; i
< 8 ; i
++) {
2476 if (sym_driver_setup
.excludes
[i
] == base_io
)
2482 * Leave here if another driver attached the chip.
2484 if (io_port
&& check_region (io_port
, 128)) {
2485 printf_info("%s: IO region 0x%lx[0..127] is in use\n",
2486 sym_name(device
), (long) io_port
);
2491 * Check if the chip is supported.
2493 chip
= sym_lookup_pci_chip_table(device_id
, revision
);
2495 printf_info("%s: device not supported\n", sym_name(device
));
2500 * Check if the chip has been assigned resources we need.
2502 #ifdef SYM_CONF_IOMAPPED
2504 printf_info("%s: IO base address disabled.\n",
2510 printf_info("%s: MMIO base address disabled.\n",
2517 * Ignore Symbios chips controlled by various RAID controllers.
2518 * These controllers set value 0x52414944 at RAM end - 16.
2520 #if defined(__i386__) && !defined(SYM_OPT_NO_BUS_MEMORY_MAPPING)
2522 unsigned int ram_size
, ram_val
;
2525 if (chip
->features
& FE_RAM8K
)
2530 ram_ptr
= pci_map_mem(base_2_c
, ram_size
);
2532 ram_val
= readl_raw(ram_ptr
+ ram_size
- 16);
2533 pci_unmap_mem(ram_ptr
, ram_size
);
2534 if (ram_val
== 0x52414944) {
2535 printf_info("%s: not initializing, "
2536 "driven by RAID controller.\n",
2542 #endif /* i386 and PCI MEMORY accessible */
2545 * Copy the chip description to our device structure,
2546 * so we can make it match the actual device and options.
2548 bcopy(chip
, &device
->chip
, sizeof(device
->chip
));
2549 device
->chip
.revision_id
= revision
;
2551 if (pci_enable_device(pdev
))
2554 pci_set_master(pdev
);
2557 * Read additionnal info from the configuration space.
2559 pci_read_config_byte(pdev
, PCI_CACHE_LINE_SIZE
, &cache_line_size
);
2562 * If cache line size is not configured, suggest
2563 * a value for well known CPUs.
2565 #if defined(__i386__) && !defined(MODULE)
2566 if (!cache_line_size
&& boot_cpu_data
.x86_vendor
== X86_VENDOR_INTEL
) {
2567 switch(boot_cpu_data
.x86
) {
2568 case 4: suggested_cache_line_size
= 4; break;
2569 case 6: if (boot_cpu_data
.x86_model
> 8) break;
2570 case 5: suggested_cache_line_size
= 8; break;
2573 #endif /* __i386__ */
2576 * Some features are required to be enabled in order to
2577 * work around some chip problems. :) ;)
2578 * (ITEM 12 of a DEL about the 896 I haven't yet).
2579 * We must ensure the chip will use WRITE AND INVALIDATE.
2580 * The revision number limit is for now arbitrary.
2582 if (device_id
== PCI_DEVICE_ID_NCR_53C896
&& revision
< 0x4) {
2583 chip
->features
|= (FE_WRIE
| FE_CLSE
);
2584 pci_fix_up
|= 3; /* Force appropriate PCI fix-up */
2587 #ifdef SYM_CONF_PCI_FIX_UP
2589 * Try to fix up PCI config according to wished features.
2591 if ((pci_fix_up
& 1) && (chip
->features
& FE_CLSE
) &&
2592 !cache_line_size
&& suggested_cache_line_size
) {
2593 cache_line_size
= suggested_cache_line_size
;
2594 pci_write_config_byte(pdev
,
2595 PCI_CACHE_LINE_SIZE
, cache_line_size
);
2596 printf_info("%s: PCI_CACHE_LINE_SIZE set to %d.\n",
2597 sym_name(device
), cache_line_size
);
2600 pci_read_config_word(pdev
, PCI_COMMAND
, &command
);
2601 if ((pci_fix_up
& 2) && cache_line_size
&&
2602 (chip
->features
& FE_WRIE
) && !(command
& PCI_COMMAND_INVALIDATE
)) {
2603 printf_info("%s: setting PCI_COMMAND_INVALIDATE.\n",
2605 command
|= PCI_COMMAND_INVALIDATE
;
2606 pci_write_config_word(pdev
, PCI_COMMAND
, command
);
2608 #endif /* SYM_CONF_PCI_FIX_UP */
2611 * Work around for errant bit in 895A. The 66Mhz
2612 * capable bit is set erroneously. Clear this bit.
2615 * Make sure Config space and Features agree.
2617 * Recall: writes are not normal to status register -
2618 * write a 1 to clear and a 0 to leave unchanged.
2619 * Can only reset bits.
2621 pci_read_config_word(pdev
, PCI_STATUS
, &status_reg
);
2622 if (chip
->features
& FE_66MHZ
) {
2623 if (!(status_reg
& PCI_STATUS_66MHZ
))
2624 chip
->features
&= ~FE_66MHZ
;
2627 if (status_reg
& PCI_STATUS_66MHZ
) {
2628 status_reg
= PCI_STATUS_66MHZ
;
2629 pci_write_config_word(pdev
, PCI_STATUS
, status_reg
);
2630 pci_read_config_word(pdev
, PCI_STATUS
, &status_reg
);
2635 * Initialise device structure with items required by sym_attach.
2637 device
->pdev
= pdev
;
2638 device
->s
.bus
= PciBusNumber(pdev
);
2639 device
->s
.device_fn
= PciDeviceFn(pdev
);
2640 device
->s
.base
= base
;
2641 device
->s
.base_2
= base_2
;
2642 device
->s
.base_c
= base_c
;
2643 device
->s
.base_2_c
= base_2_c
;
2644 device
->s
.io_port
= io_port
;
2645 device
->s
.irq
= irq
;
2646 device
->attach_done
= 0;
2652 * List of supported NCR chip ids
2654 static u_short sym_chip_ids
[] __initdata
= {
2672 * Detect all 53c8xx hosts and then attach them.
2674 * If we are using NVRAM, once all hosts are detected, we need to
2675 * check any NVRAM for boot order in case detect and boot order
2676 * differ and attach them using the order in the NVRAM.
2678 * If no NVRAM is found or data appears invalid attach boards in
2679 * the order they are detected.
2681 int __init
sym53c8xx_detect(Scsi_Host_Template
*tpnt
)
2684 int i
, j
, chips
, hosts
, count
;
2685 int attach_count
= 0;
2686 sym_device
*devtbl
, *devp
;
2688 #if SYM_CONF_NVRAM_SUPPORT
2689 sym_nvram nvram0
, *nvp
;
2693 * Initialize driver general stuff.
2695 #ifdef SYM_LINUX_BOOT_COMMAND_LINE_SUPPORT
2698 sym53c8xx_setup(sym53c8xx
);
2700 #ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT
2701 sym_debug_flags
= sym_driver_setup
.debug
;
2703 if (boot_verbose
>= 2)
2704 sym53c8xx_print_driver_setup();
2705 #endif /* SYM_LINUX_BOOT_COMMAND_LINE_SUPPORT */
2708 * Allocate the device table since we donnot want to
2709 * overflow the kernel stack.
2710 * 1 x 4K PAGE is enough for more than 40 devices for i386.
2712 devtbl
= sym_calloc(PAGE_SIZE
, "DEVTBL");
2717 * Detect all NCR PQS/PDS memory controllers.
2719 #ifdef SYM_CONF_PQS_PDS_SUPPORT
2720 sym_detect_pqs_pds();
2724 * Detect all 53c8xx hosts.
2725 * Save the first Symbios NVRAM content if any
2726 * for the boot order.
2728 chips
= sizeof(sym_chip_ids
) / sizeof(sym_chip_ids
[0]);
2729 hosts
= PAGE_SIZE
/ sizeof(*devtbl
);
2730 #if SYM_CONF_NVRAM_SUPPORT
2731 nvp
= (sym_driver_setup
.use_nvram
& 0x1) ? &nvram0
: 0;
2735 pcidev
= PCIDEV_NULL
;
2742 i
= sym_driver_setup
.reverse_probe
? chips
- 1 - j
: j
;
2743 pcidev
= pci_find_device(PCI_VENDOR_ID_NCR
, sym_chip_ids
[i
],
2745 if (pcidev
== PCIDEV_NULL
) {
2749 /* This one is guaranteed by AC to do nothing :-) */
2750 if (pci_enable_device(pcidev
))
2752 devp
= &devtbl
[count
];
2753 devp
->host_id
= SYM_SETUP_HOST_ID
;
2754 devp
->attach_done
= 0;
2755 if (sym53c8xx_pci_init(tpnt
, pcidev
, devp
)) {
2759 #if SYM_CONF_NVRAM_SUPPORT
2761 sym_get_nvram(devp
, nvp
);
2763 case SYM_SYMBIOS_NVRAM
:
2765 * Switch to the other nvram buffer, so that
2766 * nvram0 will contain the first Symbios
2767 * format NVRAM content with boot order.
2770 msg
= "with Symbios NVRAM";
2772 case SYM_TEKRAM_NVRAM
:
2773 msg
= "with Tekram NVRAM";
2778 #ifdef SYM_CONF_PQS_PDS_SUPPORT
2780 * Match the BUS number for PQS/PDS devices.
2781 * Read the SCSI ID from a special register mapped
2782 * into the configuration space of the individual
2783 * 875s. This register is set up by the PQS bios
2785 for(i
= 0; i
< SYM_CONF_MAX_PQS_BUS
&& pqs_bus
[i
] != -1; i
++) {
2787 if (pqs_bus
[i
] == PciBusNumber(pcidev
)) {
2788 pci_read_config_byte(pcidev
, 0x84, &tmp
);
2790 devp
->host_id
= tmp
;
2795 msg
= "(NCR PQS/PDS)";
2798 printf_info("%s: 53c%s detected %s\n",
2799 sym_name(devp
), devp
->chip
.name
, msg
);
2803 * If we have found a SYMBIOS NVRAM, use first the NVRAM boot
2804 * sequence as device boot order.
2805 * check devices in the boot record against devices detected.
2806 * attach devices if we find a match. boot table records that
2807 * do not match any detected devices will be ignored.
2808 * devices that do not match any boot table will not be attached
2809 * here but will attempt to be attached during the device table
2812 #if SYM_CONF_NVRAM_SUPPORT
2813 if (!nvp
|| nvram0
.type
!= SYM_SYMBIOS_NVRAM
)
2815 for (i
= 0; i
< 4; i
++) {
2816 Symbios_host
*h
= &nvram0
.data
.Symbios
.host
[i
];
2817 for (j
= 0 ; j
< count
; j
++) {
2819 if (h
->device_fn
!= devp
->s
.device_fn
||
2820 h
->bus_nr
!= devp
->s
.bus
||
2821 h
->device_id
!= devp
->chip
.device_id
)
2823 if (devp
->attach_done
)
2825 if (h
->flags
& SYMBIOS_INIT_SCAN_AT_BOOT
) {
2826 sym_get_nvram(devp
, nvp
);
2827 if (!sym_attach (tpnt
, attach_count
, devp
))
2830 else if (!(sym_driver_setup
.use_nvram
& 0x80))
2832 "%s: 53c%s state OFF thus not attached\n",
2833 sym_name(devp
), devp
->chip
.name
);
2837 devp
->attach_done
= 1;
2845 * Rescan device list to make sure all boards attached.
2846 * Devices without boot records will not be attached yet
2847 * so try to attach them here.
2849 for (i
= 0; i
< count
; i
++) {
2851 if (!devp
->attach_done
) {
2852 devp
->nvram
= &nvram
;
2854 #if SYM_CONF_NVRAM_SUPPORT
2855 sym_get_nvram(devp
, nvp
);
2857 if (!sym_attach (tpnt
, attach_count
, devp
))
2862 sym_mfree(devtbl
, PAGE_SIZE
, "DEVTBL");
2864 return attach_count
;
2870 * Linux release module stuff.
2872 * Called before unloading the module.
2874 * We have to free resources and halt the NCR chip.
2877 static int sym_detach(hcb_p np
)
2879 printk("%s: detaching ...\n", sym_name(np
));
2882 * Try to delete the timer.
2883 * In the unlikely situation where this failed,
2884 * try to synchronize with the timer handler.
2886 #if LINUX_VERSION_CODE < LinuxVersionCode(2, 4, 0)
2887 np
->s
.release_stage
= 1;
2888 if (!del_timer(&np
->s
.timer
)) {
2893 SYM_LOCK_HCB(np
, flags
);
2894 k
= np
->s
.release_stage
;
2895 SYM_UNLOCK_HCB(np
, flags
);
2901 printk("%s: failed to kill timer!\n", sym_name(np
));
2903 np
->s
.release_stage
= 2;
2905 (void)del_timer_sync(&np
->s
.timer
);
2910 * We should use sym_soft_reset(), but we donnot want to do
2911 * so, since we may not be safe if interrupts occur.
2913 printk("%s: resetting chip\n", sym_name(np
));
2914 OUTB (nc_istat
, SRST
);
2919 * Free host resources
2921 sym_free_resources(np
);
2926 int sym53c8xx_release(struct Scsi_Host
*host
)
2928 sym_detach(((struct host_data
*) host
->hostdata
)->ncb
);
2934 * For bigots to keep silent. :)
2936 #ifdef MODULE_LICENSE
2937 MODULE_LICENSE("Dual BSD/GPL");
2941 * Driver host template.
2943 static Scsi_Host_Template driver_template
= {
2944 .name
= "sym53c8xx",
2945 .detect
= sym53c8xx_detect
,
2946 .release
= sym53c8xx_release
,
2947 .info
= sym53c8xx_info
,
2948 .queuecommand
= sym53c8xx_queue_command
,
2949 .slave_configure
= sym53c8xx_slave_configure
,
2950 .eh_abort_handler
= sym53c8xx_eh_abort_handler
,
2951 .eh_device_reset_handler
= sym53c8xx_eh_device_reset_handler
,
2952 .eh_bus_reset_handler
= sym53c8xx_eh_bus_reset_handler
,
2953 .eh_host_reset_handler
= sym53c8xx_eh_host_reset_handler
,
2955 .use_clustering
= DISABLE_CLUSTERING
,
2957 #ifdef SYM_LINUX_PROC_INFO_SUPPORT
2958 .proc_info
= sym53c8xx_proc_info
,
2959 #if LINUX_VERSION_CODE < LinuxVersionCode(2,3,27)
2960 .proc_dir
= &proc_scsi_sym53c8xx
,
2962 .proc_name
= NAME53C8XX
,
2966 #include "../scsi_module.c"