patch-2.4.5 linux/drivers/scsi/gdth.c
Next file: linux/drivers/scsi/gdth.h
Previous file: linux/drivers/scsi/fdomain.c
Back to the patch index
Back to the overall index
- Lines: 2877
- Date:
Sat May 19 17:43:06 2001
- Orig file:
v2.4.4/linux/drivers/scsi/gdth.c
- Orig date:
Fri Apr 27 13:59:18 2001
diff -u --recursive --new-file v2.4.4/linux/drivers/scsi/gdth.c linux/drivers/scsi/gdth.c
@@ -2,7 +2,7 @@
* GDT ISA/EISA/PCI Disk Array Controller driver for Linux *
* *
* gdth.c *
- * Copyright (C) 1995-99 ICP vortex Computersysteme GmbH, Achim Leubner *
+ * Copyright (C) 1995-01 ICP vortex Computersysteme GmbH, Achim Leubner *
* *
* <achim@vortex.de> *
* *
@@ -20,9 +20,92 @@
* along with this kernel; if not, write to the Free Software *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
* *
- * Tested with Linux 1.2.13, ..., 2.2.4 *
+ * Tested with Linux 1.2.13, ..., 2.2.18, ..., 2.4.2 *
* *
* $Log: gdth.c,v $
+ * Revision 1.49 2001/03/15 15:07:17 achim
+ * New __setup interface for boot command line options added
+ *
+ * Revision 1.48 2001/02/06 12:36:28 achim
+ * Bugfix Cluster protocol
+ *
+ * Revision 1.47 2001/01/10 14:42:06 achim
+ * New switch shared_access added
+ *
+ * Revision 1.46 2001/01/09 08:11:35 achim
+ * gdth_command() removed
+ * meaning of Scsi_Pointer members changed
+ *
+ * Revision 1.45 2000/11/16 12:02:24 achim
+ * Changes for kernel 2.4
+ *
+ * Revision 1.44 2000/10/11 08:44:10 achim
+ * Clustering changes: New flag media_changed added
+ *
+ * Revision 1.43 2000/09/20 12:59:01 achim
+ * DPMEM remap functions for all PCI controller types implemented
+ * Small changes for ia64 platform
+ *
+ * Revision 1.42 2000/07/20 09:04:50 achim
+ * Small changes for kernel 2.4
+ *
+ * Revision 1.41 2000/07/04 14:11:11 achim
+ * gdth_analyse_hdrive() added to rescan drives after online expansion
+ *
+ * Revision 1.40 2000/06/27 11:24:16 achim
+ * Changes Clustering, Screenservice
+ *
+ * Revision 1.39 2000/06/15 13:09:04 achim
+ * Changes for gdth_do_cmd()
+ *
+ * Revision 1.38 2000/06/15 12:08:43 achim
+ * Bugfix gdth_sync_event(), service SCREENSERVICE
+ * Data direction for command 0xc2 changed to DOU
+ *
+ * Revision 1.37 2000/05/25 13:50:10 achim
+ * New driver parameter virt_ctr added
+ *
+ * Revision 1.36 2000/05/04 08:50:46 achim
+ * Event buffer now in gdth_ha_str
+ *
+ * Revision 1.35 2000/03/03 10:44:08 achim
+ * New event_string only valid for the RP controller family
+ *
+ * Revision 1.34 2000/03/02 14:55:29 achim
+ * New mechanism for async. event handling implemented
+ *
+ * Revision 1.33 2000/02/21 15:37:37 achim
+ * Bugfix Alpha platform + DPMEM above 4GB
+ *
+ * Revision 1.32 2000/02/14 16:17:37 achim
+ * Bugfix sense_buffer[] + raw devices
+ *
+ * Revision 1.31 2000/02/10 10:29:00 achim
+ * Delete sense_buffer[0], if command OK
+ *
+ * Revision 1.30 1999/11/02 13:42:39 achim
+ * ARRAY_DRV_LIST2 implemented
+ * Now 255 log. and 100 host drives supported
+ *
+ * Revision 1.29 1999/10/05 13:28:47 achim
+ * GDT_CLUST_RESET added
+ *
+ * Revision 1.28 1999/08/12 13:44:54 achim
+ * MOUNTALL removed
+ * Cluster drives -> removeable drives
+ *
+ * Revision 1.27 1999/06/22 07:22:38 achim
+ * Small changes
+ *
+ * Revision 1.26 1999/06/10 16:09:12 achim
+ * Cluster Host Drive support: Bugfixes
+ *
+ * Revision 1.25 1999/06/01 16:03:56 achim
+ * gdth_init_pci(): Manipulate config. space to start RP controller
+ *
+ * Revision 1.24 1999/05/26 11:53:06 achim
+ * Cluster Host Drive support added
+ *
* Revision 1.23 1999/03/26 09:12:31 achim
* Default value for hdr_channel set to 0
*
@@ -120,7 +203,7 @@
* Initial revision
*
************************************************************************/
-#ident "$Id: gdth.c,v 1.23 1999/03/26 09:12:31 achim Exp $"
+#ident "$Id: gdth.c,v 1.49 2001/03/15 15:07:17 achim Exp $"
/* All GDT Disk Array Controllers are fully supported by this driver.
* This includes the PCI/EISA/ISA SCSI Disk Array Controllers and the
@@ -147,10 +230,17 @@
* max_ids:x x - target ID count per channel (1..MAXID)
* rescan:Y rescan all channels/IDs
* rescan:N use all devices found until now
+ * virt_ctr:Y map every channel to a virtual controller
+ * virt_ctr:N use multi channel support
* hdr_channel:x x - number of virtual bus for host drives
+ * shared_access:Y disable driver reserve/release protocol to
+ * access a shared resource from several nodes,
+ * appropiate controller firmware required
+ * shared_access:N enable driver reserve/release protocol
*
- * The default value is: "gdth=disable:N,reserve_mode:1,reverse_scan:N,
- * max_ids:127,rescan:N,hdr_channel:0".
+ * The default values are: "gdth=disable:N,reserve_mode:1,reverse_scan:N,
+ * max_ids:127,rescan:N,virt_ctr:N,hdr_channel:0,
+ * shared_access:N".
* Here is another example: "gdth=reserve_list:0,1,2,0,0,1,3,0,rescan:Y".
*
* When loading the gdth driver as a module, the same options are available.
@@ -160,10 +250,22 @@
* '1' in place of 'Y' and '0' in place of 'N'.
*
* Default: "modprobe gdth disable=0 reserve_mode=1 reverse_scan=0
- * max_ids=127 rescan=0 hdr_channel=0"
+ * max_ids=127 rescan=0 virt_ctr=0 hdr_channel=0 shared_access=0"
* The other example: "modprobe gdth reserve_list=0,1,2,0,0,1,3,0 rescan=1".
*/
+/* The meaning of the Scsi_Pointer members in this driver is as follows:
+ * ptr: Chaining
+ * this_residual: Command priority
+ * buffer: Unused
+ * buffers_residual: Timeout value
+ * Status: Command status (gdth_do_cmd())
+ * Message: Additional info (gdth_do_cmd())
+ * have_data_in: Flag for gdth_wait_completion()
+ * sent_command: Opcode special command
+ * phase: Service/parameter/return code special command
+ */
+
#ifdef MODULE
#include <linux/module.h>
#endif
@@ -181,13 +283,32 @@
#include <linux/proc_fs.h>
#include <linux/time.h>
#include <linux/timer.h>
+#ifdef GDTH_RTC
+#include <linux/mc146818rtc.h>
+#endif
+#if LINUX_VERSION_CODE >= 0x020100
#include <linux/reboot.h>
+#else
+#include <linux/bios32.h>
+#endif
+#if LINUX_VERSION_CODE >= 0x020126
+#include <linux/init.h>
+#endif
#include <asm/dma.h>
#include <asm/system.h>
#include <asm/io.h>
+#if LINUX_VERSION_CODE >= 0x020322
#include <linux/spinlock.h>
+#elif LINUX_VERSION_CODE >= 0x02015F
+#include <asm/spinlock.h>
+#endif
+
+#if LINUX_VERSION_CODE >= 0x010300
#include <linux/blk.h>
+#else
+#include "../block/blk.h"
+#endif
#include "scsi.h"
#include "hosts.h"
#include "sd.h"
@@ -196,9 +317,13 @@
static void gdth_delay(int milliseconds);
static void gdth_eval_mapping(ulong32 size, int *cyls, int *heads, int *secs);
+#if LINUX_VERSION_CODE >= 0x010346
static void gdth_interrupt(int irq,void *dev_id,struct pt_regs *regs);
+#else
+static void gdth_interrupt(int irq,struct pt_regs *regs);
+#endif
static int gdth_sync_event(int hanum,int service,unchar index,Scsi_Cmnd *scp);
-static int gdth_async_event(int hanum,int service);
+static int gdth_async_event(int hanum);
static void gdth_log_event(gdth_evt_data *dvr, char *buffer);
static void gdth_putq(int hanum,Scsi_Cmnd *scp,unchar priority);
@@ -233,19 +358,25 @@
static int gdth_internal_cmd(int hanum,unchar service,ushort opcode,ulong32 p1,
ulong32 p2,ulong32 p3);
static int gdth_search_drives(int hanum);
+static int gdth_analyse_hdrive(int hanum, ushort hdrive);
static void *gdth_mmap(ulong paddr, ulong size);
static void gdth_munmap(void *addr);
static const char *gdth_ctr_name(int hanum);
+#if LINUX_VERSION_CODE >= 0x010300
static void gdth_flush(int hanum);
+#if LINUX_VERSION_CODE >= 0x020100
static int gdth_halt(struct notifier_block *nb, ulong event, void *buf);
+#else
+static int halt_called = FALSE;
+void gdth_halt(void);
+#endif
+#endif
#ifdef DEBUG_GDTH
static unchar DebugState = DEBUG_GDTH;
-extern long sys_syslog(int,char*,int);
-#define LOGEN sys_syslog(7,NULL,0)
#ifdef __SERIAL__
#define MAX_SERBUF 160
@@ -314,9 +445,9 @@
#define TRACE3(a) {if (DebugState!=0) {ser_printk a;}}
#else /* !__SERIAL__ */
-#define TRACE(a) {if (DebugState==1) {LOGEN;printk a;}}
-#define TRACE2(a) {if (DebugState==1 || DebugState==2) {LOGEN;printk a;}}
-#define TRACE3(a) {if (DebugState!=0) {LOGEN;printk a;}}
+#define TRACE(a) {if (DebugState==1) {printk a;}}
+#define TRACE2(a) {if (DebugState==1 || DebugState==2) {printk a;}}
+#define TRACE3(a) {if (DebugState!=0) {printk a;}}
#endif
#else /* !DEBUG */
@@ -341,6 +472,64 @@
#define BUS_L2P(a,b) ((b)>(a)->virt_bus ? (b-1):(b))
+#if LINUX_VERSION_CODE < 0x010300
+static void *gdth_mmap(ulong paddr, ulong size)
+{
+ if (paddr >= high_memory)
+ return NULL;
+ else
+ return (void *)paddr;
+}
+static void gdth_munmap(void *addr)
+{
+}
+inline ulong32 virt_to_phys(volatile void *addr)
+{
+ return (ulong32)addr;
+}
+inline void *phys_to_virt(ulong32 addr)
+{
+ return (void *)addr;
+}
+#define virt_to_bus virt_to_phys
+#define bus_to_virt phys_to_virt
+#define gdth_readb(addr) (*(volatile unchar *)(addr))
+#define gdth_readw(addr) (*(volatile ushort *)(addr))
+#define gdth_readl(addr) (*(volatile ulong32 *)(addr))
+#define gdth_writeb(b,addr) (*(volatile unchar *)(addr) = (b))
+#define gdth_writew(b,addr) (*(volatile ushort *)(addr) = (b))
+#define gdth_writel(b,addr) (*(volatile ulong32 *)(addr) = (b))
+#define memset_io(a,b,c) memset((void *)(a),(b),(c))
+#define memcpy_fromio(a,b,c) memcpy((a),(void *)(b),(c))
+#define memcpy_toio(a,b,c) memcpy((void *)(a),(b),(c))
+
+#define PCI_SLOT(devfn) ((devfn >> 3) & 0x1f)
+
+#elif LINUX_VERSION_CODE < 0x020100
+static int remapped = FALSE;
+static void *gdth_mmap(ulong paddr, ulong size)
+{
+ if ( paddr >= high_memory) {
+ remapped = TRUE;
+ return vremap(paddr, size);
+ } else {
+ return (void *)paddr;
+ }
+}
+static void gdth_munmap(void *addr)
+{
+ if (remapped)
+ vfree(addr);
+ remapped = FALSE;
+}
+#define gdth_readb(addr) readb((ulong)(addr))
+#define gdth_readw(addr) readw((ulong)(addr))
+#define gdth_readl(addr) (ulong32)readl((ulong)(addr))
+#define gdth_writeb(b,addr) writeb((b),(ulong)(addr))
+#define gdth_writew(b,addr) writew((b),(ulong)(addr))
+#define gdth_writel(b,addr) writel((ulong32)(b),(ulong)(addr))
+
+#else
static void *gdth_mmap(ulong paddr, ulong size)
{
return ioremap(paddr, size);
@@ -354,7 +543,9 @@
#define gdth_readl(addr) (ulong32)readl((ulong)(addr))
#define gdth_writeb(b,addr) writeb((b),(ulong)(addr))
#define gdth_writew(b,addr) writew((b),(ulong)(addr))
-#define gdth_writel(b,addr) writel((b),(ulong)(addr))
+#define gdth_writel(b,addr) writel((ulong32)(b),(ulong)(addr))
+#endif
+
static unchar gdth_drq_tab[4] = {5,6,7,7}; /* DRQ table */
static unchar gdth_irq_tab[6] = {0,10,11,12,14,0}; /* IRQ table */
@@ -388,15 +579,24 @@
DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,
DUN,DUN,DUN,DUN,DUN,DNO,DNO,DUN,DIN,DNO,DOU,DUN,DNO,DUN,DOU,DOU,
DOU,DOU,DOU,DNO,DUN,DIN,DOU,DIN,DIN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,
- DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,
+ DUN,DUN,DOU,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,
DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,
DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DOU,DUN,DUN,DUN,DUN,DUN,
DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN
};
/* __initfunc, __initdata macros */
-#include <linux/init.h>
+#if LINUX_VERSION_CODE >= 0x020322
+#define GDTH_INITFUNC(type, func) type __init func
+#elif LINUX_VERSION_CODE >= 0x020126
+#define GDTH_INITFUNC(type, func) __initfunc(type func)
+#else
+#define GDTH_INITFUNC(type, func) type func
+#define __initdata
+#define __init
+#endif
+#if LINUX_VERSION_CODE >= 0x02015F
#define GDTH_INIT_LOCK_HA(ha) spin_lock_init(&(ha)->smp_lock)
#define GDTH_LOCK_HA(ha,flags) spin_lock_irqsave(&(ha)->smp_lock,flags)
#define GDTH_UNLOCK_HA(ha,flags) spin_unlock_irqrestore(&(ha)->smp_lock,flags)
@@ -405,6 +605,16 @@
#define GDTH_UNLOCK_SCSI_DONE(flags) spin_unlock_irqrestore(&io_request_lock,flags)
#define GDTH_LOCK_SCSI_DOCMD() spin_lock_irq(&io_request_lock)
#define GDTH_UNLOCK_SCSI_DOCMD() spin_unlock_irq(&io_request_lock)
+#else
+#define GDTH_INIT_LOCK_HA(ha) do {} while (0)
+#define GDTH_LOCK_HA(ha,flags) do {save_flags(flags); cli();} while (0)
+#define GDTH_UNLOCK_HA(ha,flags) do {restore_flags(flags);} while (0)
+
+#define GDTH_LOCK_SCSI_DONE(flags) do {} while (0)
+#define GDTH_UNLOCK_SCSI_DONE(flags) do {} while (0)
+#define GDTH_LOCK_SCSI_DOCMD() do {} while (0)
+#define GDTH_UNLOCK_SCSI_DOCMD() do {} while (0)
+#endif
/* LILO and modprobe/insmod parameters */
/* IRQ list for GDT3000/3020 EISA controllers */
@@ -428,8 +638,13 @@
static int max_ids = MAXID;
/* rescan all IDs */
static int rescan = 0;
+/* map channels to virtual controllers */
+static int virt_ctr = 0;
+/* shared access */
+static int shared_access = 0;
#ifdef MODULE
+#if LINUX_VERSION_CODE >= 0x02011A
/* parameters for modprobe/insmod */
MODULE_PARM(irq, "i");
MODULE_PARM(disable, "i");
@@ -439,25 +654,45 @@
MODULE_PARM(hdr_channel, "i");
MODULE_PARM(max_ids, "i");
MODULE_PARM(rescan, "i");
+MODULE_PARM(virt_ctr, "i");
+MODULE_PARM(shared_access, "i");
MODULE_AUTHOR("Achim Leubner");
#endif
+#endif
/* /proc support */
+#if LINUX_VERSION_CODE >= 0x010300
#include <linux/stat.h>
+#if LINUX_VERSION_CODE < 0x020322
+struct proc_dir_entry proc_scsi_gdth = {
+ PROC_SCSI_GDTH, 4, "gdth",
+ S_IFDIR | S_IRUGO | S_IXUGO, 2
+};
+#endif
#include "gdth_proc.h"
#include "gdth_proc.c"
+#endif
+#if LINUX_VERSION_CODE >= 0x020100
/* notifier block to get a notify on system shutdown/halt/reboot */
static struct notifier_block gdth_notifier = {
gdth_halt, NULL, 0
};
+#endif
+
static void gdth_delay(int milliseconds)
{
if (milliseconds == 0) {
udelay(1);
} else {
+#if LINUX_VERSION_CODE >= 0x020168
mdelay(milliseconds);
+#else
+ int i;
+ for (i = 0; i < milliseconds; ++i)
+ udelay(1000);
+#endif
}
}
@@ -465,24 +700,24 @@
{
*cyls = size /HEADS/SECS;
if (*cyls <= MAXCYLS) {
- *heads = HEADS;
- *secs = SECS;
- } else { /* too high for 64*32 */
- *cyls = size /MEDHEADS/MEDSECS;
- if (*cyls <= MAXCYLS) {
- *heads = MEDHEADS;
- *secs = MEDSECS;
- } else { /* too high for 127*63 */
- *cyls = size /BIGHEADS/BIGSECS;
- *heads = BIGHEADS;
- *secs = BIGSECS;
- }
+ *heads = HEADS;
+ *secs = SECS;
+ } else { /* too high for 64*32 */
+ *cyls = size /MEDHEADS/MEDSECS;
+ if (*cyls <= MAXCYLS) {
+ *heads = MEDHEADS;
+ *secs = MEDSECS;
+ } else { /* too high for 127*63 */
+ *cyls = size /BIGHEADS/BIGSECS;
+ *heads = BIGHEADS;
+ *secs = BIGSECS;
+ }
}
}
/* controller search and initialization functions */
-static int __init gdth_search_eisa(ushort eisa_adr)
+GDTH_INITFUNC(static int, gdth_search_eisa(ushort eisa_adr))
{
ulong32 id;
@@ -500,7 +735,7 @@
}
-static int __init gdth_search_isa(ulong32 bios_adr)
+GDTH_INITFUNC(static int, gdth_search_isa(ulong32 bios_adr))
{
void *addr;
ulong32 id;
@@ -516,11 +751,16 @@
}
-static int __init gdth_search_pci(gdth_pci_str *pcistr)
+GDTH_INITFUNC(static int, gdth_search_pci(gdth_pci_str *pcistr))
{
- ulong32 base0, base1, base2;
+ ulong base0, base1, base2;
ushort device_id, cnt;
+#if LINUX_VERSION_CODE >= 0x2015C
struct pci_dev *pdev;
+#else
+ int error;
+ ushort idx;
+#endif
TRACE(("gdth_search_pci()\n"));
@@ -530,11 +770,46 @@
if (device_id > PCI_DEVICE_ID_VORTEX_GDT6555 &&
device_id < PCI_DEVICE_ID_VORTEX_GDT6x17RP)
continue;
+#if LINUX_VERSION_CODE >= 0x20363
+ pdev = NULL;
+ while ((pdev = pci_find_device(PCI_VENDOR_ID_VORTEX,device_id,pdev))
+ != NULL) {
+ if (pci_enable_device(pdev))
+ continue;
+ if (cnt >= MAXHA)
+ return cnt;
+ /* GDT PCI controller found, resources are already in pdev */
+ pcistr[cnt].pdev = pdev;
+ pcistr[cnt].device_id = device_id;
+ pcistr[cnt].bus = pdev->bus->number;
+ pcistr[cnt].device_fn = pdev->devfn;
+ pcistr[cnt].irq = pdev->irq;
+ base0 = pci_resource_flags(pdev, 0);
+ base1 = pci_resource_flags(pdev, 1);
+ base2 = pci_resource_flags(pdev, 2);
+ if (device_id <= PCI_DEVICE_ID_VORTEX_GDT6000B || /* GDT6000/B */
+ device_id >= PCI_DEVICE_ID_VORTEX_GDT6x17RP) { /* MPR */
+ if (!(base0 & IORESOURCE_MEM))
+ continue;
+ pcistr[cnt].dpmem = pci_resource_start(pdev, 0);
+ } else { /* GDT6110, GDT6120, .. */
+ if (!(base0 & IORESOURCE_MEM) ||
+ !(base2 & IORESOURCE_MEM) ||
+ !(base1 & IORESOURCE_IO))
+ continue;
+ pcistr[cnt].dpmem = pci_resource_start(pdev, 2);
+ pcistr[cnt].io_mm = pci_resource_start(pdev, 0);
+ pcistr[cnt].io = pci_resource_start(pdev, 1);
+ }
+ TRACE2(("Controller found at %d/%d, irq %d, dpmem 0x%lx\n",
+ pcistr[cnt].bus, PCI_SLOT(pcistr[cnt].device_fn),
+ pcistr[cnt].irq, pcistr[cnt].dpmem));
+ cnt++;
+ }
+#elif LINUX_VERSION_CODE >= 0x2015C
pdev = NULL;
while ((pdev = pci_find_device(PCI_VENDOR_ID_VORTEX,device_id,pdev))
!= NULL) {
- if (pci_enable_device(pdev))
- continue;
if (cnt >= MAXHA)
return cnt;
/* GDT PCI controller found, resources are already in pdev */
@@ -543,16 +818,16 @@
pcistr[cnt].bus = pdev->bus->number;
pcistr[cnt].device_fn = pdev->devfn;
pcistr[cnt].irq = pdev->irq;
- base0 = pdev->resource[0].flags;
- base1 = pdev->resource[1].flags;
- base2 = pdev->resource[2].flags;
+ base0 = pdev->base_address[0];
+ base1 = pdev->base_address[1];
+ base2 = pdev->base_address[2];
if (device_id <= PCI_DEVICE_ID_VORTEX_GDT6000B || /* GDT6000/B */
device_id >= PCI_DEVICE_ID_VORTEX_GDT6x17RP) { /* MPR */
if ((base0 & PCI_BASE_ADDRESS_SPACE) !=
PCI_BASE_ADDRESS_SPACE_MEMORY)
continue;
- pcistr[cnt].dpmem = pdev->resource[0].start;
- } else { /* GDT6110, GDT6120, .. */
+ pcistr[cnt].dpmem = base0 & PCI_BASE_ADDRESS_MEM_MASK;
+ } else { /* GDT6110, GDT6120, .. */
if ((base0 & PCI_BASE_ADDRESS_SPACE) !=
PCI_BASE_ADDRESS_SPACE_MEMORY ||
(base2 & PCI_BASE_ADDRESS_SPACE) !=
@@ -560,21 +835,77 @@
(base1 & PCI_BASE_ADDRESS_SPACE) !=
PCI_BASE_ADDRESS_SPACE_IO)
continue;
- pcistr[cnt].dpmem = pdev->resource[2].start;
- pcistr[cnt].io_mm = pdev->resource[0].start;
- pcistr[cnt].io = pdev->resource[1].start;
+ pcistr[cnt].dpmem = base2 & PCI_BASE_ADDRESS_MEM_MASK;
+ pcistr[cnt].io_mm = base0 & PCI_BASE_ADDRESS_MEM_MASK;
+ pcistr[cnt].io = base1 & PCI_BASE_ADDRESS_IO_MASK;
}
- TRACE2(("Controller found at %d/%d, irq %d, dpmem 0x%x\n",
+ TRACE2(("Controller found at %d/%d, irq %d, dpmem 0x%lx\n",
pcistr[cnt].bus, PCI_SLOT(pcistr[cnt].device_fn),
pcistr[cnt].irq, pcistr[cnt].dpmem));
cnt++;
}
+#else
+ idx = 0;
+ while (!pcibios_find_device(PCI_VENDOR_ID_VORTEX,device_id,idx++,
+ &pcistr[cnt].bus,&pcistr[cnt].device_fn)) {
+ if (cnt >= MAXHA)
+ return cnt;
+ /* GDT PCI ctr. found, now read resources from config space */
+#if LINUX_VERSION_CODE >= 0x010300
+#define GDTH_BASEP (int *)
+#else
+#define GDTH_BASEP
+#endif
+ if ((error = pcibios_read_config_dword(pcistr[cnt].bus,
+ pcistr[cnt].device_fn,
+ PCI_BASE_ADDRESS_0,
+ GDTH_BASEP&base0)) ||
+ (error = pcibios_read_config_dword(pcistr[cnt].bus,
+ pcistr[cnt].device_fn,
+ PCI_BASE_ADDRESS_1,
+ GDTH_BASEP&base1)) ||
+ (error = pcibios_read_config_dword(pcistr[cnt].bus,
+ pcistr[cnt].device_fn,
+ PCI_BASE_ADDRESS_2,
+ GDTH_BASEP&base2)) ||
+ (error = pcibios_read_config_byte(pcistr[cnt].bus,
+ pcistr[cnt].device_fn,
+ PCI_INTERRUPT_LINE,
+ &pcistr[cnt].irq))) {
+ printk("GDT-PCI: error %d reading configuration space", error);
+ continue;
+ }
+ pcistr[cnt].device_id = device_id;
+ if (device_id <= PCI_DEVICE_ID_VORTEX_GDT6000B || /* GDT6000/B */
+ device_id >= PCI_DEVICE_ID_VORTEX_GDT6x17RP) { /* MPR */
+ if ((base0 & PCI_BASE_ADDRESS_SPACE) !=
+ PCI_BASE_ADDRESS_SPACE_MEMORY)
+ continue;
+ pcistr[cnt].dpmem = base0 & PCI_BASE_ADDRESS_MEM_MASK;
+ } else { /* GDT6110, GDT6120, .. */
+ if ((base0 & PCI_BASE_ADDRESS_SPACE) !=
+ PCI_BASE_ADDRESS_SPACE_MEMORY ||
+ (base2 & PCI_BASE_ADDRESS_SPACE) !=
+ PCI_BASE_ADDRESS_SPACE_MEMORY ||
+ (base1 & PCI_BASE_ADDRESS_SPACE) !=
+ PCI_BASE_ADDRESS_SPACE_IO)
+ continue;
+ pcistr[cnt].dpmem = base2 & PCI_BASE_ADDRESS_MEM_MASK;
+ pcistr[cnt].io_mm = base0 & PCI_BASE_ADDRESS_MEM_MASK;
+ pcistr[cnt].io = base1 & PCI_BASE_ADDRESS_IO_MASK;
+ }
+ TRACE2(("Controller found at %d/%d, irq %d, dpmem 0x%lx\n",
+ pcistr[cnt].bus, PCI_SLOT(pcistr[cnt].device_fn),
+ pcistr[cnt].irq, pcistr[cnt].dpmem));
+ cnt++;
+ }
+#endif
}
return cnt;
}
-static void __init gdth_sort_pci(gdth_pci_str *pcistr, int cnt)
+GDTH_INITFUNC(static void, gdth_sort_pci(gdth_pci_str *pcistr, int cnt))
{
gdth_pci_str temp;
int i, changed;
@@ -612,7 +943,7 @@
}
-static int __init gdth_init_eisa(ushort eisa_adr,gdth_ha_str *ha)
+GDTH_INITFUNC(static int, gdth_init_eisa(ushort eisa_adr,gdth_ha_str *ha))
{
ulong32 retries,id;
unchar prot_ver,eisacf,i,irq_found;
@@ -701,7 +1032,7 @@
}
-static int __init gdth_init_isa(ulong32 bios_adr,gdth_ha_str *ha)
+GDTH_INITFUNC(static int, gdth_init_isa(ulong32 bios_adr,gdth_ha_str *ha))
{
register gdt2_dpram_str *dp2_ptr;
int i;
@@ -798,14 +1129,18 @@
}
-static int __init gdth_init_pci(gdth_pci_str *pcistr,gdth_ha_str *ha)
+GDTH_INITFUNC(static int, gdth_init_pci(gdth_pci_str *pcistr,gdth_ha_str *ha))
{
register gdt6_dpram_str *dp6_ptr;
register gdt6c_dpram_str *dp6c_ptr;
register gdt6m_dpram_str *dp6m_ptr;
ulong32 retries;
unchar prot_ver;
+ ushort command;
int i, found = FALSE;
+#if LINUX_VERSION_CODE < 0x2015C
+ int rom_addr;
+#endif
TRACE(("gdth_init_pci()\n"));
@@ -820,8 +1155,51 @@
printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
return 0;
}
+ /* check and reset interface area */
dp6_ptr = (gdt6_dpram_str *)ha->brd;
- /* reset interface area */
+ gdth_writel(DPMEM_MAGIC, &dp6_ptr->u);
+ if (gdth_readl(&dp6_ptr->u) != DPMEM_MAGIC) {
+ printk("GDT-PCI: Cannot access DPMEM at 0x%lx (shadowed?)\n",
+ pcistr->dpmem);
+ found = FALSE;
+ for (i = 0xC8000; i < 0xE8000; i += 0x4000) {
+ gdth_munmap(ha->brd);
+ ha->brd = gdth_mmap(i, sizeof(ushort));
+ if (ha->brd == NULL) {
+ printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
+ return 0;
+ }
+ if (gdth_readw(ha->brd) != 0xffff) {
+ TRACE2(("init_pci_old() address 0x%x busy\n", i));
+ continue;
+ }
+ gdth_munmap(ha->brd);
+#if LINUX_VERSION_CODE >= 0x2015C
+ pci_write_config_dword(pcistr->pdev,
+ PCI_BASE_ADDRESS_0, i);
+#else
+ pcibios_write_config_dword(pcistr->bus, pcistr->device_fn,
+ PCI_BASE_ADDRESS_0, i);
+#endif
+ ha->brd = gdth_mmap(i, sizeof(gdt6_dpram_str));
+ if (ha->brd == NULL) {
+ printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
+ return 0;
+ }
+ dp6_ptr = (gdt6_dpram_str *)ha->brd;
+ gdth_writel(DPMEM_MAGIC, &dp6_ptr->u);
+ if (gdth_readl(&dp6_ptr->u) == DPMEM_MAGIC) {
+ printk("GDT-PCI: Use free address at 0x%x\n", i);
+ found = TRUE;
+ break;
+ }
+ }
+ if (!found) {
+ printk("GDT-PCI: No free address found!\n");
+ gdth_munmap(ha->brd);
+ return 0;
+ }
+ }
memset_io((char *)&dp6_ptr->u,0,sizeof(dp6_ptr->u));
if (gdth_readl(&dp6_ptr->u) != 0) {
printk("GDT-PCI: Initialization error (DPMEM write error)\n");
@@ -890,8 +1268,51 @@
gdth_munmap(ha->brd);
return 0;
}
+ /* check and reset interface area */
dp6c_ptr = (gdt6c_dpram_str *)ha->brd;
- /* reset interface area */
+ gdth_writel(DPMEM_MAGIC, &dp6c_ptr->u);
+ if (gdth_readl(&dp6c_ptr->u) != DPMEM_MAGIC) {
+ printk("GDT-PCI: Cannot access DPMEM at 0x%lx (shadowed?)\n",
+ pcistr->dpmem);
+ found = FALSE;
+ for (i = 0xC8000; i < 0xE8000; i += 0x4000) {
+ gdth_munmap(ha->brd);
+ ha->brd = gdth_mmap(i, sizeof(ushort));
+ if (ha->brd == NULL) {
+ printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
+ return 0;
+ }
+ if (gdth_readw(ha->brd) != 0xffff) {
+ TRACE2(("init_pci_plx() address 0x%x busy\n", i));
+ continue;
+ }
+ gdth_munmap(ha->brd);
+#if LINUX_VERSION_CODE >= 0x2015C
+ pci_write_config_dword(pcistr->pdev,
+ PCI_BASE_ADDRESS_2, i);
+#else
+ pcibios_write_config_dword(pcistr->bus, pcistr->device_fn,
+ PCI_BASE_ADDRESS_2, i);
+#endif
+ ha->brd = gdth_mmap(i, sizeof(gdt6c_dpram_str));
+ if (ha->brd == NULL) {
+ printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
+ return 0;
+ }
+ dp6c_ptr = (gdt6c_dpram_str *)ha->brd;
+ gdth_writel(DPMEM_MAGIC, &dp6c_ptr->u);
+ if (gdth_readl(&dp6c_ptr->u) == DPMEM_MAGIC) {
+ printk("GDT-PCI: Use free address at 0x%x\n", i);
+ found = TRUE;
+ break;
+ }
+ }
+ if (!found) {
+ printk("GDT-PCI: No free address found!\n");
+ gdth_munmap(ha->brd);
+ return 0;
+ }
+ }
memset_io((char *)&dp6c_ptr->u,0,sizeof(dp6c_ptr->u));
if (gdth_readl(&dp6c_ptr->u) != 0) {
printk("GDT-PCI: Initialization error (DPMEM write error)\n");
@@ -961,12 +1382,53 @@
return 0;
}
+ /* manipulate config. space to enable DPMEM, start RP controller */
+#if LINUX_VERSION_CODE >= 0x20363
+ pci_read_config_word(pcistr->pdev, PCI_COMMAND, &command);
+ command |= 6;
+ pci_write_config_word(pcistr->pdev, PCI_COMMAND, command);
+ if (pci_resource_start(pcistr->pdev, 8) == 1UL)
+ pci_resource_start(pcistr->pdev, 8) = 0UL;
+ i = 0xFEFF0001UL;
+ pci_write_config_dword(pcistr->pdev, PCI_ROM_ADDRESS, i);
+ gdth_delay(1);
+ pci_write_config_dword(pcistr->pdev, PCI_ROM_ADDRESS,
+ pci_resource_start(pcistr->pdev, 8));
+#elif LINUX_VERSION_CODE >= 0x2015C
+ pci_read_config_word(pcistr->pdev, PCI_COMMAND, &command);
+ command |= 6;
+ pci_write_config_word(pcistr->pdev, PCI_COMMAND, command);
+ if (pcistr->pdev->rom_address == 1UL)
+ pcistr->pdev->rom_address = 0UL;
+ i = 0xFEFF0001UL;
+ pci_write_config_dword(pcistr->pdev, PCI_ROM_ADDRESS, i);
+ gdth_delay(1);
+ pci_write_config_dword(pcistr->pdev, PCI_ROM_ADDRESS,
+ pcistr->pdev->rom_address);
+#else
+ pcibios_read_config_word(pcistr->bus, pcistr->device_fn,
+ PCI_COMMAND, &command);
+ command |= 6;
+ pcibios_write_config_word(pcistr->bus, pcistr->device_fn,
+ PCI_COMMAND, command);
+ pcibios_read_config_dword(pcistr->bus, pcistr->device_fn,
+ PCI_ROM_ADDRESS, &rom_addr);
+ if (rom_addr == 1UL)
+ rom_addr = 0UL;
+ i = 0xFEFF0001UL;
+ pcibios_write_config_dword(pcistr->bus, pcistr->device_fn,
+ PCI_ROM_ADDRESS, i);
+ gdth_delay(1);
+ pcibios_write_config_dword(pcistr->bus, pcistr->device_fn,
+ PCI_ROM_ADDRESS, rom_addr);
+#endif
+
/* check and reset interface area */
dp6m_ptr = (gdt6m_dpram_str *)ha->brd;
gdth_writel(DPMEM_MAGIC, &dp6m_ptr->u);
if (gdth_readl(&dp6m_ptr->u) != DPMEM_MAGIC) {
- printk("GDT-PCI: Cannot access DPMEM at 0x%x (shadowed?)\n",
- (int)pcistr->dpmem);
+ printk("GDT-PCI: Cannot access DPMEM at 0x%lx (shadowed?)\n",
+ pcistr->dpmem);
found = FALSE;
for (i = 0xC8000; i < 0xE8000; i += 0x4000) {
gdth_munmap(ha->brd);
@@ -980,8 +1442,13 @@
continue;
}
gdth_munmap(ha->brd);
+#if LINUX_VERSION_CODE >= 0x2015C
pci_write_config_dword(pcistr->pdev,
PCI_BASE_ADDRESS_0, i);
+#else
+ pcibios_write_config_dword(pcistr->bus, pcistr->device_fn,
+ PCI_BASE_ADDRESS_0, i);
+#endif
ha->brd = gdth_mmap(i, sizeof(gdt6m_dpram_str));
if (ha->brd == NULL) {
printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
@@ -1060,7 +1527,7 @@
/* controller protocol functions */
-static void __init gdth_enable_int(int hanum)
+GDTH_INITFUNC(static void, gdth_enable_int(int hanum))
{
gdth_ha_str *ha;
ulong flags;
@@ -1312,7 +1779,11 @@
gdth_from_wait = TRUE;
do {
+#if LINUX_VERSION_CODE >= 0x010346
gdth_interrupt((int)ha->irq,ha,NULL);
+#else
+ gdth_interrupt((int)ha->irq,NULL);
+#endif
if (wait_hanum==hanum && wait_index==index) {
answer_found = TRUE;
break;
@@ -1367,6 +1838,12 @@
cmd_ptr->u.raw.bus = (unchar)p2;
cmd_ptr->u.raw.target = (unchar)p3;
cmd_ptr->u.raw.lun = (unchar)(p3 >> 8);
+ } else if (service == SCREENSERVICE) {
+ if (opcode == GDT_REALTIME) {
+ *(ulong32 *)&cmd_ptr->u.screen.su.data[0] = p1;
+ *(ulong32 *)&cmd_ptr->u.screen.su.data[4] = p2;
+ *(ulong32 *)&cmd_ptr->u.screen.su.data[8] = p3;
+ }
}
ha->cmd_len = sizeof(gdth_cmd_str);
ha->cmd_offs_dpmem = 0;
@@ -1389,19 +1866,22 @@
/* search for devices */
-static int __init gdth_search_drives(int hanum)
+GDTH_INITFUNC(static int, gdth_search_drives(int hanum))
{
register gdth_ha_str *ha;
ushort cdev_cnt, i;
- int drv_cyls, drv_hds, drv_secs;
- ulong32 bus_no;
- ulong32 drv_cnt, drv_no, j;
+ ulong32 bus_no, drv_cnt, drv_no, j;
gdth_getch_str *chn;
gdth_drlist_str *drl;
gdth_iochan_str *ioc;
gdth_raw_iochan_str *iocr;
- gdth_arraylist_str *alst;
-
+ gdth_arcdl_str *alst;
+ gdth_alist_str *alst2;
+#ifdef GDTH_RTC
+ unchar rtc[12];
+ ulong flags;
+#endif
+
TRACE(("gdth_search_drives() hanum %d\n",hanum));
ha = HADATA(gdth_ctr_tab[hanum]);
@@ -1412,7 +1892,30 @@
return 0;
}
TRACE2(("gdth_search_drives(): SCREENSERVICE initialized\n"));
-
+
+#ifdef GDTH_RTC
+ /* read realtime clock info, send to controller */
+ /* 1. wait for the falling edge of update flag */
+ spin_lock_irqsave(&rtc_lock, flags);
+ for (j = 0; j < 1000000; ++j)
+ if (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP)
+ break;
+ for (j = 0; j < 1000000; ++j)
+ if (!(CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP))
+ break;
+ /* 2. read info */
+ do {
+ for (j = 0; j < 12; ++j)
+ rtc[j] = CMOS_READ(j);
+ } while (rtc[0] != CMOS_READ(0));
+ spin_lock_irqrestore(&rtc_lock, flags);
+ TRACE2(("gdth_search_drives(): RTC: %x/%x/%x\n",*(ulong32 *)&rtc[0],
+ *(ulong32 *)&rtc[4], *(ulong32 *)&rtc[8]));
+ /* 3. send to controller firmware */
+ gdth_internal_cmd(hanum,SCREENSERVICE,GDT_REALTIME, *(ulong32 *)&rtc[0],
+ *(ulong32 *)&rtc[4], *(ulong32 *)&rtc[8]);
+#endif
+
/* initialize cache service */
if (!gdth_internal_cmd(hanum,CACHESERVICE,GDT_INIT,LINUX_OS,0,0)) {
printk("GDT: Initialization error cache service (code %d)\n",
@@ -1421,19 +1924,7 @@
}
TRACE2(("gdth_search_drives(): CACHESERVICE initialized\n"));
cdev_cnt = (ushort)ha->info;
-
- /* mount all cache devices */
- gdth_internal_cmd(hanum,CACHESERVICE,GDT_MOUNT,0xffff,1,0);
- TRACE2(("gdth_search_drives(): mountall CACHESERVICE OK\n"));
-
- /* initialize cache service after mountall */
- if (!gdth_internal_cmd(hanum,CACHESERVICE,GDT_INIT,LINUX_OS,0,0)) {
- printk("GDT: Initialization error cache service (code %d)\n",
- ha->status);
- return 0;
- }
- TRACE2(("gdth_search_drives() CACHES. init. after mountall\n"));
- cdev_cnt = (ushort)ha->info;
+ ha->fw_vers = ha->service;
/* detect number of buses - try new IOCTL */
iocr = (gdth_raw_iochan_str *)ha->pscratch;
@@ -1493,7 +1984,8 @@
ha->more_proc = FALSE;
if (gdth_internal_cmd(hanum,CACHESERVICE,GDT_IOCTL,BOARD_INFO,
INVALID_CHANNEL,sizeof(gdth_binfo_str))) {
- memcpy(&ha->binfo, (gdth_binfo_str *)ha->pscratch, sizeof(gdth_binfo_str));
+ memcpy(&ha->binfo, (gdth_binfo_str *)ha->pscratch,
+ sizeof(gdth_binfo_str));
if (gdth_internal_cmd(hanum,CACHESERVICE,GDT_IOCTL,BOARD_FEATURES,
INVALID_CHANNEL,sizeof(gdth_bfeat_str))) {
TRACE2(("BOARD_INFO/BOARD_FEATURES supported\n"));
@@ -1562,22 +2054,37 @@
INVALID_CHANNEL,drv_cnt * sizeof(ulong32))) {
for (j = 0; j < drv_cnt; ++j) {
drv_no = ((ulong32 *)ha->pscratch)[j];
- if (drv_no < MAX_HDRIVES) {
+ if (drv_no < MAX_LDRIVES) {
ha->hdr[drv_no].is_logdrv = TRUE;
TRACE2(("Drive %d is log. drive\n",drv_no));
}
}
}
+ alst = (gdth_arcdl_str *)ha->pscratch;
+ alst->entries_avail = MAX_LDRIVES;
+ alst->first_entry = 0;
+ alst->list_offset = GDTOFFSOF(gdth_arcdl_str, list[0]);
if (gdth_internal_cmd(hanum,CACHESERVICE,GDT_IOCTL,
- ARRAY_DRV_LIST | LA_CTRL_PATTERN,
- 0, 35 * sizeof(gdth_arraylist_str))) {
+ ARRAY_DRV_LIST2 | LA_CTRL_PATTERN,
+ INVALID_CHANNEL, sizeof(gdth_arcdl_str) +
+ (alst->entries_avail-1) * sizeof(gdth_alist_str))) {
+ for (j = 0; j < alst->entries_init; ++j) {
+ ha->hdr[j].is_arraydrv = alst->list[j].is_arrayd;
+ ha->hdr[j].is_master = alst->list[j].is_master;
+ ha->hdr[j].is_parity = alst->list[j].is_parity;
+ ha->hdr[j].is_hotfix = alst->list[j].is_hotfix;
+ ha->hdr[j].master_no = alst->list[j].cd_handle;
+ }
+ } else if (gdth_internal_cmd(hanum,CACHESERVICE,GDT_IOCTL,
+ ARRAY_DRV_LIST | LA_CTRL_PATTERN,
+ 0, 35 * sizeof(gdth_alist_str))) {
for (j = 0; j < 35; ++j) {
- alst = &((gdth_arraylist_str *)ha->pscratch)[j];
- ha->hdr[j].is_arraydrv = alst->is_arrayd;
- ha->hdr[j].is_master = alst->is_master;
- ha->hdr[j].is_parity = alst->is_parity;
- ha->hdr[j].is_hotfix = alst->is_hotfix;
- ha->hdr[j].master_no = alst->cd_handle;
+ alst2 = &((gdth_alist_str *)ha->pscratch)[j];
+ ha->hdr[j].is_arraydrv = alst2->is_arrayd;
+ ha->hdr[j].is_master = alst2->is_master;
+ ha->hdr[j].is_parity = alst2->is_parity;
+ ha->hdr[j].is_hotfix = alst2->is_hotfix;
+ ha->hdr[j].master_no = alst2->cd_handle;
}
}
}
@@ -1592,7 +2099,6 @@
TRACE2(("gdth_search_drives(): RAWSERVICE initialized\n"));
/* set/get features raw service (scatter/gather) */
- ha->raw_feat = 0;
if (gdth_internal_cmd(hanum,SCSIRAWSERVICE,GDT_SET_FEAT,SCATTER_GATHER,
0,0)) {
TRACE2(("gdth_search_drives(): set features RAWSERVICE OK\n"));
@@ -1636,44 +2142,67 @@
}
}
- /* scanning for cache devices */
- for (i=0; i<cdev_cnt && i<MAX_HDRIVES; ++i) {
- TRACE(("gdth_search_drives() cachedev. %d\n",i));
- if (gdth_internal_cmd(hanum,CACHESERVICE,GDT_INFO,i,0,0)) {
- /* static relation between host drive number and Bus/ID */
- TRACE(("gdth_search_dr() drive %d mapped to bus/id %d/%d\n",
- i,ha->bus_cnt,i));
-
- ha->hdr[i].present = TRUE;
- ha->hdr[i].size = ha->info;
-
- /* evaluate mapping (sectors per head, heads per cylinder) */
- ha->hdr[i].size &= ~SECS32;
- if (ha->info2 == 0) {
- gdth_eval_mapping(ha->hdr[i].size,&drv_cyls,&drv_hds,&drv_secs);
- } else {
- drv_hds = ha->info2 & 0xff;
- drv_secs = (ha->info2 >> 8) & 0xff;
- drv_cyls = ha->hdr[i].size /drv_hds/drv_secs;
- }
- ha->hdr[i].heads = (unchar)drv_hds;
- ha->hdr[i].secs = (unchar)drv_secs;
- /* round size */
- ha->hdr[i].size = drv_cyls * drv_hds * drv_secs;
- TRACE2(("gdth_search_dr() cdr. %d size %d hds %d scs %d\n",
- i,ha->hdr[i].size,drv_hds,drv_secs));
+ /* scanning for host drives */
+ for (i = 0; i < cdev_cnt; ++i)
+ gdth_analyse_hdrive(hanum,i);
+
+ TRACE(("gdth_search_drives() OK\n"));
+ return 1;
+}
+
+static int gdth_analyse_hdrive(int hanum,ushort hdrive)
+{
+ register gdth_ha_str *ha;
+ int drv_cyls, drv_hds, drv_secs;
+
+ TRACE(("gdth_analyse_hdrive() hanum %d drive %d\n",hanum,hdrive));
+ if (hdrive >= MAX_HDRIVES)
+ return 0;
+ ha = HADATA(gdth_ctr_tab[hanum]);
+
+ if (!gdth_internal_cmd(hanum,CACHESERVICE,GDT_INFO,hdrive,0,0))
+ return 0;
+ ha->hdr[hdrive].present = TRUE;
+ ha->hdr[hdrive].size = ha->info;
+
+ /* evaluate mapping (sectors per head, heads per cylinder) */
+ ha->hdr[hdrive].size &= ~SECS32;
+ if (ha->info2 == 0) {
+ gdth_eval_mapping(ha->hdr[hdrive].size,&drv_cyls,&drv_hds,&drv_secs);
+ } else {
+ drv_hds = ha->info2 & 0xff;
+ drv_secs = (ha->info2 >> 8) & 0xff;
+ drv_cyls = ha->hdr[hdrive].size /drv_hds/drv_secs;
+ }
+ ha->hdr[hdrive].heads = (unchar)drv_hds;
+ ha->hdr[hdrive].secs = (unchar)drv_secs;
+ /* round size */
+ ha->hdr[hdrive].size = drv_cyls * drv_hds * drv_secs;
+ TRACE2(("gdth_search_dr() cdr. %d size %d hds %d scs %d\n",
+ hdrive,ha->hdr[hdrive].size,drv_hds,drv_secs));
- /* get informations about device */
- if (gdth_internal_cmd(hanum,CACHESERVICE,GDT_DEVTYPE,i,
- 0,0)) {
- TRACE(("gdth_search_dr() cache drive %d devtype %d\n",
- i,ha->info));
- ha->hdr[i].devtype = (ushort)ha->info;
- }
- }
+ /* get informations about device */
+ if (gdth_internal_cmd(hanum,CACHESERVICE,GDT_DEVTYPE,hdrive,0,0)) {
+ TRACE2(("gdth_search_dr() cache drive %d devtype %d\n",
+ hdrive,ha->info));
+ ha->hdr[hdrive].devtype = (ushort)ha->info;
+ }
+
+ /* cluster info */
+ if (gdth_internal_cmd(hanum,CACHESERVICE,GDT_CLUST_INFO,hdrive,0,0)) {
+ TRACE2(("gdth_search_dr() cache drive %d cluster info %d\n",
+ hdrive,ha->info));
+ if (!shared_access)
+ ha->hdr[hdrive].cluster_type = (unchar)ha->info;
+ }
+
+ /* R/W attributes */
+ if (gdth_internal_cmd(hanum,CACHESERVICE,GDT_RW_ATTRIBS,hdrive,0,0)) {
+ TRACE2(("gdth_search_dr() cache drive %d r/w attrib. %d\n",
+ hdrive,ha->info));
+ ha->hdr[hdrive].rw_attribs = (unchar)ha->info;
}
- TRACE(("gdth_search_drives() OK\n"));
return 1;
}
@@ -1693,8 +2222,9 @@
GDTH_LOCK_HA(ha, flags);
scp->SCp.this_residual = (int)priority;
- b = scp->channel;
+ b = virt_ctr ? NUMDATA(scp->host)->busnum : scp->channel;
t = scp->target;
+#if LINUX_VERSION_CODE >= 0x010300
if (priority >= DEFAULT_PRI) {
if ((b != ha->virt_bus && ha->raw[BUS_L2P(ha,b)].lock) ||
(b == ha->virt_bus && t < MAX_HDRIVES && ha->hdr[t].lock)) {
@@ -1702,6 +2232,7 @@
scp->SCp.buffers_residual = gdth_update_timeout(hanum, scp, 0);
}
}
+#endif
if (ha->req_first==NULL) {
ha->req_first = scp; /* queue was empty */
@@ -1752,7 +2283,7 @@
for (nscp = pscp = ha->req_first; nscp; nscp = (Scsi_Cmnd *)nscp->SCp.ptr) {
if (nscp != pscp && nscp != (Scsi_Cmnd *)pscp->SCp.ptr)
pscp = (Scsi_Cmnd *)pscp->SCp.ptr;
- b = nscp->channel;
+ b = virt_ctr ? NUMDATA(nscp->host)->busnum : nscp->channel;
t = nscp->target;
if (nscp->SCp.this_residual >= DEFAULT_PRI) {
if ((b != ha->virt_bus && ha->raw[BUS_L2P(ha,b)].lock) ||
@@ -1773,10 +2304,12 @@
firsttime = FALSE;
}
- if (nscp->done != gdth_scsi_done)
+#if LINUX_VERSION_CODE >= 0x010300
+ if (nscp->done != gdth_scsi_done || nscp->cmnd[0] != 0xff)
+#endif
{
if (nscp->SCp.phase == -1) {
- nscp->SCp.phase = SCSIRAWSERVICE; /* default: raw svc. */
+ nscp->SCp.phase = CACHESERVICE; /* default: cache svc. */
if (nscp->cmnd[0] == TEST_UNIT_READY) {
TRACE2(("TEST_UNIT_READY Bus %d Id %d LUN %d\n",
b, t, nscp->lun));
@@ -1789,8 +2322,9 @@
} else if ((ha->scan_mode & 0x0f) == 1) {
if (b == 0 && ((t == 0 && nscp->lun == 1) ||
(t == 1 && nscp->lun == 0))) {
- nscp->SCp.Status = GDT_SCAN_START;
- nscp->SCp.phase |= ((ha->scan_mode & 0x10 ? 1:0) << 8);
+ nscp->SCp.sent_command = GDT_SCAN_START;
+ nscp->SCp.phase = ((ha->scan_mode & 0x10 ? 1:0) << 8)
+ | SCSIRAWSERVICE;
ha->scan_mode = 0x12;
TRACE2(("Scan mode: 0x%x (SCAN_START)\n",
ha->scan_mode));
@@ -1800,29 +2334,55 @@
}
} else if (ha->scan_mode == 0x12) {
if (b == ha->bus_cnt && t == ha->tid_cnt-1) {
- nscp->SCp.Status = GDT_SCAN_END;
+ nscp->SCp.phase = SCSIRAWSERVICE;
+ nscp->SCp.sent_command = GDT_SCAN_END;
ha->scan_mode &= 0x10;
TRACE2(("Scan mode: 0x%x (SCAN_END)\n",
ha->scan_mode));
}
}
}
+ if (b == ha->virt_bus && nscp->cmnd[0] != INQUIRY &&
+ nscp->cmnd[0] != READ_CAPACITY && nscp->cmnd[0] != MODE_SENSE &&
+ (ha->hdr[t].cluster_type & CLUSTER_DRIVE)) {
+ /* always GDT_CLUST_INFO! */
+ nscp->SCp.sent_command = GDT_CLUST_INFO;
+ }
}
}
- if (nscp->SCp.Status != -1) {
- if ((nscp->SCp.phase & 0xff) == SCSIRAWSERVICE) {
+ if (nscp->SCp.sent_command != -1) {
+ if ((nscp->SCp.phase & 0xff) == CACHESERVICE) {
+ if (!(cmd_index=gdth_fill_cache_cmd(hanum,nscp,t)))
+ this_cmd = FALSE;
+ next_cmd = FALSE;
+ } else if ((nscp->SCp.phase & 0xff) == SCSIRAWSERVICE) {
if (!(cmd_index=gdth_fill_raw_cmd(hanum,nscp,BUS_L2P(ha,b))))
this_cmd = FALSE;
next_cmd = FALSE;
+ } else {
+ memset((char*)nscp->sense_buffer,0,16);
+ nscp->sense_buffer[0] = 0x70;
+ nscp->sense_buffer[2] = NOT_READY;
+ nscp->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
+ if (!nscp->SCp.have_data_in)
+ nscp->SCp.have_data_in++;
+ else {
+ GDTH_UNLOCK_HA(ha,flags);
+ /* io_request_lock already active ! */
+ nscp->scsi_done(nscp);
+ GDTH_LOCK_HA(ha,flags);
+ }
}
} else
- if (nscp->done == gdth_scsi_done) {
+#if LINUX_VERSION_CODE >= 0x010300
+ if (nscp->done == gdth_scsi_done && nscp->cmnd[0] == 0xff) {
if (!(cmd_index=gdth_special_cmd(hanum,nscp)))
this_cmd = FALSE;
next_cmd = FALSE;
} else
+#endif
if (b != ha->virt_bus) {
if (ha->raw[BUS_L2P(ha,b)].io_cnt[t] >= GDTH_MAX_RAW ||
!(cmd_index=gdth_fill_raw_cmd(hanum,nscp,BUS_L2P(ha,b))))
@@ -1833,10 +2393,14 @@
TRACE2(("Command 0x%x to bus %d id %d lun %d -> IGNORE\n",
nscp->cmnd[0], b, t, nscp->lun));
nscp->result = DID_BAD_TARGET << 16;
- GDTH_UNLOCK_HA(ha,flags);
- /* io_request_lock already active ! */
- nscp->scsi_done(nscp);
- GDTH_LOCK_HA(ha,flags);
+ if (!nscp->SCp.have_data_in)
+ nscp->SCp.have_data_in++;
+ else {
+ GDTH_UNLOCK_HA(ha,flags);
+ /* io_request_lock already active ! */
+ nscp->scsi_done(nscp);
+ GDTH_LOCK_HA(ha,flags);
+ }
} else {
switch (nscp->cmnd[0]) {
case TEST_UNIT_READY:
@@ -1849,7 +2413,24 @@
TRACE(("cache cmd %x/%x/%x/%x/%x/%x\n",nscp->cmnd[0],
nscp->cmnd[1],nscp->cmnd[2],nscp->cmnd[3],
nscp->cmnd[4],nscp->cmnd[5]));
- if (gdth_internal_cache_cmd(hanum,nscp)) {
+ if (ha->hdr[t].media_changed && nscp->cmnd[0] != INQUIRY) {
+ /* return UNIT_ATTENTION */
+ TRACE2(("cmd 0x%x target %d: UNIT_ATTENTION\n",
+ nscp->cmnd[0], t));
+ ha->hdr[t].media_changed = FALSE;
+ memset((char*)nscp->sense_buffer,0,16);
+ nscp->sense_buffer[0] = 0x70;
+ nscp->sense_buffer[2] = UNIT_ATTENTION;
+ nscp->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
+ if (!nscp->SCp.have_data_in)
+ nscp->SCp.have_data_in++;
+ else {
+ GDTH_UNLOCK_HA(ha,flags);
+ /* io_request_lock already active ! */
+ nscp->scsi_done(nscp);
+ GDTH_LOCK_HA(ha,flags);
+ }
+ } else if (gdth_internal_cache_cmd(hanum,nscp)) {
GDTH_UNLOCK_HA(ha,flags);
/* io_request_lock already active ! */
nscp->scsi_done(nscp);
@@ -1864,6 +2445,7 @@
if ( (nscp->cmnd[4]&1) && !(ha->hdr[t].devtype&1) ) {
TRACE(("Prevent r. nonremov. drive->do nothing\n"));
nscp->result = DID_OK << 16;
+ nscp->sense_buffer[0] = 0;
if (!nscp->SCp.have_data_in)
nscp->SCp.have_data_in++;
else {
@@ -1881,11 +2463,36 @@
}
break;
+ case RESERVE:
+ case RELEASE:
+ TRACE2(("cache cmd %s\n",nscp->cmnd[0] == RESERVE ?
+ "RESERVE" : "RELEASE"));
+ if (!(cmd_index=gdth_fill_cache_cmd(hanum,nscp,t)))
+ this_cmd = FALSE;
+ break;
+
case READ_6:
case WRITE_6:
case READ_10:
case WRITE_10:
- if (!(cmd_index=gdth_fill_cache_cmd(hanum,nscp,t)))
+ if (ha->hdr[t].media_changed) {
+ /* return UNIT_ATTENTION */
+ TRACE2(("cmd 0x%x target %d: UNIT_ATTENTION\n",
+ nscp->cmnd[0], t));
+ ha->hdr[t].media_changed = FALSE;
+ memset((char*)nscp->sense_buffer,0,16);
+ nscp->sense_buffer[0] = 0x70;
+ nscp->sense_buffer[2] = UNIT_ATTENTION;
+ nscp->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
+ if (!nscp->SCp.have_data_in)
+ nscp->SCp.have_data_in++;
+ else {
+ GDTH_UNLOCK_HA(ha,flags);
+ /* io_request_lock already active ! */
+ nscp->scsi_done(nscp);
+ GDTH_LOCK_HA(ha,flags);
+ }
+ } else if (!(cmd_index=gdth_fill_cache_cmd(hanum,nscp,t)))
this_cmd = FALSE;
break;
@@ -1985,7 +2592,10 @@
inq.type_qual = (ha->hdr[t].devtype&4) ? TYPE_ROM:TYPE_DISK;
/* you can here set all disks to removable, if you want to do
a flush using the ALLOW_MEDIUM_REMOVAL command */
- inq.modif_rmb = ha->hdr[t].devtype&1 ? 0x80:0x00;
+ inq.modif_rmb = 0x00;
+ if ((ha->hdr[t].devtype & 1) ||
+ (ha->hdr[t].cluster_type & CLUSTER_DRIVE))
+ inq.modif_rmb = 0x80;
inq.version = 2;
inq.resp_aenc = 2;
inq.add_length= 32;
@@ -2028,7 +2638,9 @@
TRACE2(("Internal cache cmd 0x%x unknown\n",scp->cmnd[0]));
break;
}
+
scp->result = DID_OK << 16;
+ scp->sense_buffer[0] = 0;
if (!scp->SCp.have_data_in)
scp->SCp.have_data_in++;
@@ -2043,8 +2655,9 @@
register gdth_ha_str *ha;
register gdth_cmd_str *cmdp;
struct scatterlist *sl;
- ushort i;
- int cmd_index;
+ ushort i, cnt;
+ ulong32 no;
+ int cmd_index, read_write;
ha = HADATA(gdth_ctr_tab[hanum]);
cmdp = ha->pccb;
@@ -2066,37 +2679,46 @@
gdth_set_sema0(hanum);
/* fill command */
- if (scp->cmnd[0]==ALLOW_MEDIUM_REMOVAL) {
+ read_write = FALSE;
+ if (scp->SCp.sent_command != -1)
+ cmdp->OpCode = scp->SCp.sent_command; /* special cache cmd. */
+ else if (scp->cmnd[0] == RESERVE)
+ cmdp->OpCode = GDT_RESERVE_DRV;
+ else if (scp->cmnd[0] == RELEASE)
+ cmdp->OpCode = GDT_RELEASE_DRV;
+ else if (scp->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
if (scp->cmnd[4] & 1) /* prevent ? */
- cmdp->OpCode = GDT_MOUNT;
+ cmdp->OpCode = GDT_MOUNT;
else if (scp->cmnd[3] & 1) /* removable drive ? */
- cmdp->OpCode = GDT_UNMOUNT;
+ cmdp->OpCode = GDT_UNMOUNT;
+ else
+ cmdp->OpCode = GDT_FLUSH;
+ } else if (scp->cmnd[0] == WRITE_6 || scp->cmnd[0] == WRITE_10) {
+ read_write = TRUE;
+ if (gdth_write_through || ((ha->hdr[hdrive].rw_attribs & 1) &&
+ (ha->cache_feat & GDT_WR_THROUGH)))
+ cmdp->OpCode = GDT_WRITE_THR;
else
- cmdp->OpCode = GDT_FLUSH;
+ cmdp->OpCode = GDT_WRITE;
} else {
- if (scp->cmnd[0]==WRITE_6 || scp->cmnd[0]==WRITE_10) {
- if (gdth_write_through)
- cmdp->OpCode = GDT_WRITE_THR;
- else
- cmdp->OpCode = GDT_WRITE;
- } else {
- cmdp->OpCode = GDT_READ;
- }
+ read_write = TRUE;
+ cmdp->OpCode = GDT_READ;
}
+
+ cmdp->BoardNode = LOCALBOARD;
+ cmdp->u.cache.DeviceNo = hdrive;
+ cmdp->u.cache.BlockNo = 1;
+ cmdp->u.cache.sg_canz = 0;
- cmdp->BoardNode = LOCALBOARD;
- cmdp->u.cache.DeviceNo = hdrive;
-
- if (scp->cmnd[0]==ALLOW_MEDIUM_REMOVAL) {
- cmdp->u.cache.BlockNo = 1;
- cmdp->u.cache.sg_canz = 0;
- } else {
+ if (read_write) {
if (scp->cmd_len != 6) {
- cmdp->u.cache.BlockNo = ntohl(*(ulong32*)&scp->cmnd[2]);
- cmdp->u.cache.BlockCnt= (ulong32)ntohs(*(ushort*)&scp->cmnd[7]);
+ memcpy(&no, &scp->cmnd[2], sizeof(ulong32));
+ cmdp->u.cache.BlockNo = ntohl(no);
+ memcpy(&cnt, &scp->cmnd[7], sizeof(ushort));
+ cmdp->u.cache.BlockCnt = (ulong32)ntohs(cnt);
} else {
- cmdp->u.cache.BlockNo =
- ntohl(*(ulong32*)&scp->cmnd[0]) & 0x001fffffUL;
+ memcpy(&no, &scp->cmnd[0], sizeof(ulong32));
+ cmdp->u.cache.BlockNo = ntohl(no) & 0x001fffffUL;
cmdp->u.cache.BlockCnt= scp->cmnd[4]==0 ? 0x100 : scp->cmnd[4];
}
@@ -2189,8 +2811,8 @@
gdth_set_sema0(hanum);
/* fill command */
- if (scp->SCp.Status != -1) {
- cmdp->OpCode = scp->SCp.Status; /* special raw cmd. */
+ if (scp->SCp.sent_command != -1) {
+ cmdp->OpCode = scp->SCp.sent_command; /* special raw cmd. */
cmdp->BoardNode = LOCALBOARD;
cmdp->u.raw.direction = (scp->SCp.phase >> 8);
TRACE2(("special raw cmd 0x%x param 0x%x\n",
@@ -2209,12 +2831,12 @@
cmdp->u.raw.lun = l;
cmdp->u.raw.bus = b;
cmdp->u.raw.priority = 0;
- cmdp->u.raw.link_p = NULL;
+ cmdp->u.raw.link_p = 0;
cmdp->u.raw.sdlen = scp->request_bufflen;
cmdp->u.raw.sense_len = 16;
cmdp->u.raw.sense_data = virt_to_bus(scp->sense_buffer);
cmdp->u.raw.direction =
- gdth_direction_tab[scp->cmnd[0]]==DOU ? DATA_OUT : DATA_IN;
+ gdth_direction_tab[scp->cmnd[0]]==DOU ? GDTH_DATA_OUT:GDTH_DATA_IN;
memcpy(cmdp->u.raw.cmd,scp->cmnd,12);
if (scp->use_sg) {
@@ -2346,8 +2968,12 @@
if (ebuffer[elastidx].event_source == source &&
ebuffer[elastidx].event_idx == idx &&
- !memcmp((char *)&ebuffer[elastidx].event_data.eu,
- (char *)&evt->eu, evt->size)) {
+ ((evt->size != 0 && ebuffer[elastidx].event_data.size != 0 &&
+ !memcmp((char *)&ebuffer[elastidx].event_data.eu,
+ (char *)&evt->eu, evt->size)) ||
+ (evt->size == 0 && ebuffer[elastidx].event_data.size == 0 &&
+ !strcmp((char *)&ebuffer[elastidx].event_data.event_string,
+ (char *)&evt->event_string)))) {
e = &ebuffer[elastidx];
do_gettimeofday(&tv);
e->last_stamp = tv.tv_sec;
@@ -2370,6 +2996,7 @@
e->first_stamp = e->last_stamp = tv.tv_sec;
e->same_count = 1;
e->event_data = *evt;
+ e->application = 0;
}
return e;
}
@@ -2449,18 +3076,20 @@
/* SCSI interface functions */
+#if LINUX_VERSION_CODE >= 0x010346
static void gdth_interrupt(int irq,void *dev_id,struct pt_regs *regs)
+#else
+static void gdth_interrupt(int irq,struct pt_regs *regs)
+#endif
{
register gdth_ha_str *ha;
gdt6m_dpram_str *dp6m_ptr;
gdt6_dpram_str *dp6_ptr;
gdt2_dpram_str *dp2_ptr;
Scsi_Cmnd *scp;
- int hanum, rval;
+ int hanum, rval, i;
unchar IStatus;
- ushort CmdStatus, Service = 0;
- ulong32 InfoBytes, InfoBytes2 = 0;
- gdth_evt_data dvr;
+ ushort Service;
ulong flags = 0;
TRACE(("gdth_interrupt() IRQ %d\n",irq));
@@ -2478,9 +3107,7 @@
/* search controller */
if ((hanum = gdth_get_status(&IStatus,irq)) == -1) {
- /*
- TRACE2(("gdth_interrupt(): Spurious interrupt received\n"));
- */
+ /* spurious interrupt */
if (!gdth_polling)
GDTH_UNLOCK_HA((gdth_ha_str *)dev_id,flags);
return;
@@ -2494,34 +3121,28 @@
if (ha->type == GDT_EISA) {
if (IStatus & 0x80) { /* error flag */
IStatus &= ~0x80;
- CmdStatus = inw(ha->bmic + MAILBOXREG+8);
- TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,CmdStatus));
- if (IStatus == ASYNCINDEX) { /* async. event ? */
- Service = inw(ha->bmic + MAILBOXREG+10);
- InfoBytes2 = inl(ha->bmic + MAILBOXREG+4);
- }
+ ha->status = inw(ha->bmic + MAILBOXREG+8);
+ TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,ha->status));
} else /* no error */
- CmdStatus = S_OK;
- InfoBytes = inl(ha->bmic + MAILBOXREG+12);
- if (gdth_polling) /* init. -> more info */
- InfoBytes2 = inl(ha->bmic + MAILBOXREG+4);
+ ha->status = S_OK;
+ ha->info = inl(ha->bmic + MAILBOXREG+12);
+ ha->service = inw(ha->bmic + MAILBOXREG+10);
+ ha->info2 = inl(ha->bmic + MAILBOXREG+4);
+
outb(0xff, ha->bmic + EDOORREG); /* acknowledge interrupt */
outb(0x00, ha->bmic + SEMA1REG); /* reset status semaphore */
} else if (ha->type == GDT_ISA) {
dp2_ptr = (gdt2_dpram_str *)ha->brd;
if (IStatus & 0x80) { /* error flag */
IStatus &= ~0x80;
- CmdStatus = gdth_readw(&dp2_ptr->u.ic.Status);
- TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,CmdStatus));
- if (IStatus == ASYNCINDEX) { /* async. event ? */
- Service = gdth_readw(&dp2_ptr->u.ic.Service);
- InfoBytes2 = gdth_readl(&dp2_ptr->u.ic.Info[1]);
- }
+ ha->status = gdth_readw(&dp2_ptr->u.ic.Status);
+ TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,ha->status));
} else /* no error */
- CmdStatus = S_OK;
- InfoBytes = gdth_readl(&dp2_ptr->u.ic.Info[0]);
- if (gdth_polling) /* init. -> more info */
- InfoBytes2 = gdth_readl(&dp2_ptr->u.ic.Info[1]);
+ ha->status = S_OK;
+ ha->info = gdth_readl(&dp2_ptr->u.ic.Info[0]);
+ ha->service = gdth_readw(&dp2_ptr->u.ic.Service);
+ ha->info2 = gdth_readl(&dp2_ptr->u.ic.Info[1]);
+
gdth_writeb(0xff, &dp2_ptr->io.irqdel); /* acknowledge interrupt */
gdth_writeb(0, &dp2_ptr->u.ic.Cmd_Index); /* reset command index */
gdth_writeb(0, &dp2_ptr->io.Sema1); /* reset status semaphore */
@@ -2529,52 +3150,56 @@
dp6_ptr = (gdt6_dpram_str *)ha->brd;
if (IStatus & 0x80) { /* error flag */
IStatus &= ~0x80;
- CmdStatus = gdth_readw(&dp6_ptr->u.ic.Status);
- TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,CmdStatus));
- if (IStatus == ASYNCINDEX) { /* async. event ? */
- Service = gdth_readw(&dp6_ptr->u.ic.Service);
- InfoBytes2 = gdth_readl(&dp6_ptr->u.ic.Info[1]);
- }
+ ha->status = gdth_readw(&dp6_ptr->u.ic.Status);
+ TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,ha->status));
} else /* no error */
- CmdStatus = S_OK;
- InfoBytes = gdth_readl(&dp6_ptr->u.ic.Info[0]);
- if (gdth_polling) /* init. -> more info */
- InfoBytes2 = gdth_readl(&dp6_ptr->u.ic.Info[1]);
+ ha->status = S_OK;
+ ha->info = gdth_readl(&dp6_ptr->u.ic.Info[0]);
+ ha->service = gdth_readw(&dp6_ptr->u.ic.Service);
+ ha->info2 = gdth_readl(&dp6_ptr->u.ic.Info[1]);
+
gdth_writeb(0xff, &dp6_ptr->io.irqdel); /* acknowledge interrupt */
gdth_writeb(0, &dp6_ptr->u.ic.Cmd_Index); /* reset command index */
gdth_writeb(0, &dp6_ptr->io.Sema1); /* reset status semaphore */
} else if (ha->type == GDT_PCINEW) {
if (IStatus & 0x80) { /* error flag */
IStatus &= ~0x80;
- CmdStatus = inw(PTR2USHORT(&ha->plx->status));
- TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,CmdStatus));
- if (IStatus == ASYNCINDEX) { /* async. event ? */
- Service = inw(PTR2USHORT(&ha->plx->service));
- InfoBytes2 = inl(PTR2USHORT(&ha->plx->info[1]));
- }
+ ha->status = inw(PTR2USHORT(&ha->plx->status));
+ TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,ha->status));
} else
- CmdStatus = S_OK;
+ ha->status = S_OK;
+ ha->info = inl(PTR2USHORT(&ha->plx->info[0]));
+ ha->service = inw(PTR2USHORT(&ha->plx->service));
+ ha->info2 = inl(PTR2USHORT(&ha->plx->info[1]));
- InfoBytes = inl(PTR2USHORT(&ha->plx->info[0]));
- if (gdth_polling) /* init. -> more info */
- InfoBytes2 = inl(PTR2USHORT(&ha->plx->info[1]));
outb(0xff, PTR2USHORT(&ha->plx->edoor_reg));
outb(0x00, PTR2USHORT(&ha->plx->sema1_reg));
} else if (ha->type == GDT_PCIMPR) {
dp6m_ptr = (gdt6m_dpram_str *)ha->brd;
if (IStatus & 0x80) { /* error flag */
IStatus &= ~0x80;
- CmdStatus = gdth_readw(&dp6m_ptr->i960r.status);
- TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,CmdStatus));
- if (IStatus == ASYNCINDEX) { /* async. event ? */
- Service = gdth_readw(&dp6m_ptr->i960r.service);
- InfoBytes2 = gdth_readl(&dp6m_ptr->i960r.info[1]);
- }
+ ha->status = gdth_readw(&dp6m_ptr->i960r.status);
+ TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,ha->status));
} else /* no error */
- CmdStatus = S_OK;
- InfoBytes = gdth_readl(&dp6m_ptr->i960r.info[0]);
- if (gdth_polling) /* init. -> more info */
- InfoBytes2 = gdth_readl(&dp6m_ptr->i960r.info[1]);
+ ha->status = S_OK;
+ ha->info = gdth_readl(&dp6m_ptr->i960r.info[0]);
+ ha->service = gdth_readw(&dp6m_ptr->i960r.service);
+ ha->info2 = gdth_readl(&dp6m_ptr->i960r.info[1]);
+
+ /* event string */
+ if (IStatus == ASYNCINDEX) {
+ if (ha->service != SCREENSERVICE &&
+ (ha->fw_vers & 0xff) >= 0x1a) {
+ ha->dvr.severity =
+ gdth_readb(&((gdt6m_dpram_str *)ha->brd)->i960r.severity);
+ for (i = 0; i < 256; ++i) {
+ ha->dvr.event_string[i] = gdth_readb
+ (&((gdt6m_dpram_str *)ha->brd)->i960r.evt_str[i]);
+ if (ha->dvr.event_string[i] == 0)
+ break;
+ }
+ }
+ }
gdth_writeb(0xff, &dp6m_ptr->i960r.edoor_reg);
gdth_writeb(0, &dp6m_ptr->i960r.sema1_reg);
} else {
@@ -2585,10 +3210,7 @@
}
TRACE(("gdth_interrupt() index %d stat %d info %d\n",
- IStatus,CmdStatus,InfoBytes));
- ha->status = CmdStatus;
- ha->info = InfoBytes;
- ha->info2 = InfoBytes2;
+ IStatus,ha->status,ha->info));
if (gdth_from_wait) {
wait_hanum = hanum;
@@ -2597,7 +3219,7 @@
if (IStatus == ASYNCINDEX) {
TRACE2(("gdth_interrupt() async. event\n"));
- gdth_async_event(hanum,Service);
+ gdth_async_event(hanum);
if (!gdth_polling)
GDTH_UNLOCK_HA((gdth_ha_str *)dev_id,flags);
gdth_next(hanum);
@@ -2606,9 +3228,9 @@
if (IStatus == SPEZINDEX) {
TRACE2(("Service unknown or not initialized !\n"));
- dvr.size = sizeof(dvr.eu.driver);
- dvr.eu.driver.ionode = hanum;
- gdth_store_event(ha, ES_DRIVER, 4, &dvr);
+ ha->dvr.size = sizeof(ha->dvr.eu.driver);
+ ha->dvr.eu.driver.ionode = hanum;
+ gdth_store_event(ha, ES_DRIVER, 4, &ha->dvr);
if (!gdth_polling)
GDTH_UNLOCK_HA((gdth_ha_str *)dev_id,flags);
return;
@@ -2618,10 +3240,10 @@
ha->cmd_tab[IStatus-2].cmnd = UNUSED_CMND;
if (scp == UNUSED_CMND) {
TRACE2(("gdth_interrupt() index to unused command (%d)\n",IStatus));
- dvr.size = sizeof(dvr.eu.driver);
- dvr.eu.driver.ionode = hanum;
- dvr.eu.driver.index = IStatus;
- gdth_store_event(ha, ES_DRIVER, 1, &dvr);
+ ha->dvr.size = sizeof(ha->dvr.eu.driver);
+ ha->dvr.eu.driver.ionode = hanum;
+ ha->dvr.eu.driver.index = IStatus;
+ gdth_store_event(ha, ES_DRIVER, 1, &ha->dvr);
if (!gdth_polling)
GDTH_UNLOCK_HA((gdth_ha_str *)dev_id,flags);
return;
@@ -2652,9 +3274,7 @@
register gdth_ha_str *ha;
gdth_msg_str *msg;
gdth_cmd_str *cmdp;
- char c='\r';
- ushort i;
- gdth_evt_data dvr;
+ unchar b;
ha = HADATA(gdth_ctr_tab[hanum]);
cmdp = ha->pccb;
@@ -2682,11 +3302,11 @@
cmdp->OpCode = GDT_READ;
cmdp->BoardNode = LOCALBOARD;
cmdp->u.screen.reserved = 0;
- cmdp->u.screen.msg_handle= msg->msg_handle;
- cmdp->u.screen.msg_addr = virt_to_bus(msg);
+ cmdp->u.screen.su.msg.msg_handle= msg->msg_handle;
+ cmdp->u.screen.su.msg.msg_addr = virt_to_bus(msg);
ha->scratch_busy = TRUE;
ha->cmd_offs_dpmem = 0;
- ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.msg_addr)
+ ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.su.msg.msg_addr)
+ sizeof(ulong32);
ha->cmd_cnt = 0;
gdth_copy_command(hanum);
@@ -2695,22 +3315,19 @@
}
if (msg->msg_answer && msg->msg_alen) {
- for (i=0; i<msg->msg_alen && i<MSGLEN; ++i) {
- /* getchar() ?? */
- /* .. */
- if (c == '\r')
- break;
- msg->msg_text[i] = c;
- }
- msg->msg_alen -= i;
- if (c!='\r' && msg->msg_alen!=0) {
- msg->msg_answer = 1;
- msg->msg_ext = 1;
+ /* default answers (getchar() not possible) */
+ if (msg->msg_alen == 1) {
+ msg->msg_alen = 0;
+ msg->msg_len = 1;
+ msg->msg_text[0] = 0;
} else {
- msg->msg_ext = 0;
- msg->msg_answer = 0;
+ msg->msg_alen -= 2;
+ msg->msg_len = 2;
+ msg->msg_text[0] = 1;
+ msg->msg_text[1] = 0;
}
- msg->msg_len = i;
+ msg->msg_ext = 0;
+ msg->msg_answer = 0;
while (gdth_test_busy(hanum))
gdth_delay(0);
cmdp->Service = SCREENSERVICE;
@@ -2720,11 +3337,11 @@
cmdp->OpCode = GDT_WRITE;
cmdp->BoardNode = LOCALBOARD;
cmdp->u.screen.reserved = 0;
- cmdp->u.screen.msg_handle= msg->msg_handle;
- cmdp->u.screen.msg_addr = virt_to_bus(msg);
+ cmdp->u.screen.su.msg.msg_handle= msg->msg_handle;
+ cmdp->u.screen.su.msg.msg_addr = virt_to_bus(msg);
ha->scratch_busy = TRUE;
ha->cmd_offs_dpmem = 0;
- ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.msg_addr)
+ ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.su.msg.msg_addr)
+ sizeof(ulong32);
ha->cmd_cnt = 0;
gdth_copy_command(hanum);
@@ -2734,54 +3351,110 @@
printk("\n");
} else {
- if (scp->SCp.Status == -1 && scp->channel != ha->virt_bus) {
- ha->raw[BUS_L2P(ha,scp->channel)].io_cnt[scp->target]--;
+ b = virt_ctr ? NUMDATA(scp->host)->busnum : scp->channel;
+ if (scp->SCp.sent_command == -1 && b != ha->virt_bus) {
+ ha->raw[BUS_L2P(ha,b)].io_cnt[scp->target]--;
}
/* cache or raw service */
if (ha->status == S_OK) {
- scp->SCp.Message = S_OK;
- if (scp->SCp.Status != -1) {
+ scp->SCp.Status = S_OK;
+ scp->SCp.Message = ha->info;
+ if (scp->SCp.sent_command != -1) {
TRACE2(("gdth_sync_event(): special cmd 0x%x OK\n",
- scp->SCp.Status));
- scp->SCp.Status = -1;
+ scp->SCp.sent_command));
+ /* special commands GDT_CLUST_INFO/GDT_MOUNT ? */
+ if (scp->SCp.sent_command == GDT_CLUST_INFO) {
+ ha->hdr[scp->target].cluster_type = (unchar)ha->info;
+ if (!(ha->hdr[scp->target].cluster_type &
+ CLUSTER_MOUNTED)) {
+ /* NOT MOUNTED -> MOUNT */
+ scp->SCp.sent_command = GDT_MOUNT;
+ if (ha->hdr[scp->target].cluster_type &
+ CLUSTER_RESERVED) {
+ /* cluster drive RESERVED (on the other node) */
+ scp->SCp.phase = -2; /* reservation conflict */
+ }
+ } else {
+ scp->SCp.sent_command = -1;
+ }
+ } else {
+ if (scp->SCp.sent_command == GDT_MOUNT) {
+ ha->hdr[scp->target].cluster_type |= CLUSTER_MOUNTED;
+ ha->hdr[scp->target].media_changed = TRUE;
+ } else if (scp->SCp.sent_command == GDT_UNMOUNT) {
+ ha->hdr[scp->target].cluster_type &= ~CLUSTER_MOUNTED;
+ ha->hdr[scp->target].media_changed = TRUE;
+ }
+ scp->SCp.sent_command = -1;
+ }
+ /* retry */
scp->SCp.this_residual = HIGH_PRI;
return 2;
+ } else {
+ /* RESERVE/RELEASE ? */
+ if (scp->cmnd[0] == RESERVE) {
+ ha->hdr[scp->target].cluster_type |= CLUSTER_RESERVED;
+ } else if (scp->cmnd[0] == RELEASE) {
+ ha->hdr[scp->target].cluster_type &= ~CLUSTER_RESERVED;
+ }
+ scp->result = DID_OK << 16;
+ scp->sense_buffer[0] = 0;
}
- scp->result = DID_OK << 16;
} else if (ha->status == S_BSY) {
TRACE2(("Controller busy -> retry !\n"));
- scp->SCp.Message = S_BSY;
+ scp->SCp.Status = S_BSY;
+ scp->SCp.Message = ha->info;
+ if (scp->SCp.sent_command == GDT_MOUNT)
+ scp->SCp.sent_command = GDT_CLUST_INFO;
+ /* retry */
return 2;
} else {
- scp->SCp.Message = (int)((ha->info<<16)|ha->status);
- if (scp->SCp.Status != -1) {
+ scp->SCp.Status = ha->status;
+ scp->SCp.Message = ha->info;
+
+ if (scp->SCp.sent_command != -1) {
TRACE2(("gdth_sync_event(): special cmd 0x%x error 0x%x\n",
- scp->SCp.Status, ha->status));
- scp->SCp.Status = -1;
- scp->SCp.this_residual = HIGH_PRI;
- return 2;
- }
- if (service == CACHESERVICE) {
+ scp->SCp.sent_command, ha->status));
+ if (scp->SCp.sent_command == GDT_SCAN_START ||
+ scp->SCp.sent_command == GDT_SCAN_END) {
+ scp->SCp.sent_command = -1;
+ /* retry */
+ scp->SCp.this_residual = HIGH_PRI;
+ return 2;
+ }
memset((char*)scp->sense_buffer,0,16);
scp->sense_buffer[0] = 0x70;
scp->sense_buffer[2] = NOT_READY;
scp->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
-
+ } else if (service == CACHESERVICE) {
+ if (ha->status == S_CACHE_UNKNOWN &&
+ (ha->hdr[scp->target].cluster_type &
+ CLUSTER_RESERVE_STATE) == CLUSTER_RESERVE_STATE) {
+ /* bus reset -> force GDT_CLUST_INFO */
+ ha->hdr[scp->target].cluster_type &= ~CLUSTER_RESERVED;
+ }
+ memset((char*)scp->sense_buffer,0,16);
+ scp->sense_buffer[0] = 0x70;
+ scp->sense_buffer[2] = NOT_READY;
+ scp->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
+#if LINUX_VERSION_CODE >= 0x010300
if (scp->done != gdth_scsi_done)
+#endif
{
- dvr.size = sizeof(dvr.eu.sync);
- dvr.eu.sync.ionode = hanum;
- dvr.eu.sync.service = service;
- dvr.eu.sync.status = ha->status;
- dvr.eu.sync.info = ha->info;
- dvr.eu.sync.hostdrive = scp->target;
+ ha->dvr.size = sizeof(ha->dvr.eu.sync);
+ ha->dvr.eu.sync.ionode = hanum;
+ ha->dvr.eu.sync.service = service;
+ ha->dvr.eu.sync.status = ha->status;
+ ha->dvr.eu.sync.info = ha->info;
+ ha->dvr.eu.sync.hostdrive = scp->target;
if (ha->status >= 0x8000)
- gdth_store_event(ha, ES_SYNC, 0, &dvr);
+ gdth_store_event(ha, ES_SYNC, 0, &ha->dvr);
else
- gdth_store_event(ha, ES_SYNC, service, &dvr);
+ gdth_store_event(ha, ES_SYNC, service, &ha->dvr);
}
} else {
- if (ha->status!=S_RAW_SCSI || ha->info>=0x100) {
+ /* sense buffer filled from controller firmware (DMA) */
+ if (ha->status != S_RAW_SCSI || ha->info >= 0x100) {
scp->result = DID_BAD_TARGET << 16;
} else {
scp->result = (DID_OK << 16) | ha->info;
@@ -2944,12 +3617,17 @@
"GDT HA %u, Uncorrectable DRAM error detected with ECC",
/*72*/ "\011\000\002\012\001\013\001\014\001"
"GDT HA %u, SCSI bus %u, ID %u, LUN %u: reassigning block",
+/*73*/ "\005\000\002\006\002"
+ "GDT HA %u, Host drive %u resetted locally",
+/*74*/ "\005\000\002\006\002"
+ "GDT HA %u, Host drive %u resetted remotely",
+/*75*/ "\003\000\002"
+ "GDT HA %u, async. status 75 unknown",
};
-static int gdth_async_event(int hanum,int service)
+static int gdth_async_event(int hanum)
{
- gdth_evt_data dvr;
gdth_ha_str *ha;
gdth_msg_str *msg;
gdth_cmd_str *cmdp;
@@ -2959,9 +3637,9 @@
cmdp= ha->pccb;
msg = (gdth_msg_str *)ha->pscratch;
TRACE2(("gdth_async_event() ha %d serv %d\n",
- hanum,service));
+ hanum,ha->service));
- if (service == SCREENSERVICE) {
+ if (ha->service == SCREENSERVICE) {
if (ha->status == MSG_REQUEST) {
while (gdth_test_busy(hanum))
gdth_delay(0);
@@ -2972,11 +3650,11 @@
cmdp->OpCode = GDT_READ;
cmdp->BoardNode = LOCALBOARD;
cmdp->u.screen.reserved = 0;
- cmdp->u.screen.msg_handle= MSG_INV_HANDLE;
- cmdp->u.screen.msg_addr = virt_to_bus(msg);
+ cmdp->u.screen.su.msg.msg_handle= MSG_INV_HANDLE;
+ cmdp->u.screen.su.msg.msg_addr = virt_to_bus(msg);
ha->scratch_busy = TRUE;
ha->cmd_offs_dpmem = 0;
- ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.msg_addr)
+ ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.su.msg.msg_addr)
+ sizeof(ulong32);
ha->cmd_cnt = 0;
gdth_copy_command(hanum);
@@ -2991,14 +3669,29 @@
}
} else {
- dvr.size = sizeof(dvr.eu.async);
- dvr.eu.async.ionode = hanum;
- dvr.eu.async.service = service;
- dvr.eu.async.status = ha->status;
- dvr.eu.async.info = ha->info;
- *(ulong32 *)dvr.eu.async.scsi_coord = ha->info2;
- gdth_store_event(ha, ES_ASYNC, service, &dvr);
- gdth_log_event( &dvr, NULL );
+ if (ha->type == GDT_PCIMPR &&
+ (ha->fw_vers & 0xff) >= 0x1a) {
+ ha->dvr.size = 0;
+ ha->dvr.eu.async.ionode = hanum;
+ ha->dvr.eu.async.status = ha->status;
+ /* severity and event_string already set! */
+ } else {
+ ha->dvr.size = sizeof(ha->dvr.eu.async);
+ ha->dvr.eu.async.ionode = hanum;
+ ha->dvr.eu.async.service = ha->service;
+ ha->dvr.eu.async.status = ha->status;
+ ha->dvr.eu.async.info = ha->info;
+ *(ulong32 *)ha->dvr.eu.async.scsi_coord = ha->info2;
+ }
+ gdth_store_event( ha, ES_ASYNC, ha->service, &ha->dvr );
+ gdth_log_event( &ha->dvr, NULL );
+
+ /* new host drive from expand? */
+ if (ha->service == CACHESERVICE && ha->status == 56) {
+ TRACE2(("gdth_async_event(): new host drive %d created\n",
+ (ushort)ha->info));
+ gdth_analyse_hdrive(hanum, (ushort)ha->info);
+ }
}
return 1;
}
@@ -3010,7 +3703,14 @@
int i,j;
TRACE2(("gdth_log_event()\n"));
- if (dvr->eu.async.service == CACHESERVICE &&
+ if (dvr->size == 0) {
+ if (buffer == NULL) {
+ printk("Adapter %d: %s\n",dvr->eu.async.ionode,dvr->event_string);
+ } else {
+ sprintf(buffer,"Adapter %d: %s\n",
+ dvr->eu.async.ionode,dvr->event_string);
+ }
+ } else if (dvr->eu.async.service == CACHESERVICE &&
INDEX_OK(dvr->eu.async.status, async_cache_tab)) {
TRACE2(("GDT: Async. event cache service, event no.: %d\n",
dvr->eu.async.status));
@@ -3081,8 +3781,96 @@
}
#endif
+GDTH_INITFUNC(void, internal_setup(char *str,int *ints))
+{
+ int i, argc;
+ char *cur_str, *argv;
-int __init gdth_detect(Scsi_Host_Template *shtp)
+ TRACE2(("internal_setup() str %s ints[0] %d\n",
+ str ? str:"NULL", ints ? ints[0]:0));
+
+ /* read irq[] from ints[] */
+ if (ints) {
+ argc = ints[0];
+ if (argc > 0) {
+ if (argc > MAXHA)
+ argc = MAXHA;
+ for (i = 0; i < argc; ++i)
+ irq[i] = ints[i+1];
+ }
+ }
+
+ /* analyse string */
+ argv = str;
+ while (argv && (cur_str = strchr(argv, ':'))) {
+ int val = 0, c = *++cur_str;
+
+ if (c == 'n' || c == 'N')
+ val = 0;
+ else if (c == 'y' || c == 'Y')
+ val = 1;
+ else
+ val = (int)simple_strtoul(cur_str, NULL, 0);
+
+ if (!strncmp(argv, "disable:", 8))
+ disable = val;
+ else if (!strncmp(argv, "reserve_mode:", 13))
+ reserve_mode = val;
+ else if (!strncmp(argv, "reverse_scan:", 13))
+ reverse_scan = val;
+ else if (!strncmp(argv, "hdr_channel:", 12))
+ hdr_channel = val;
+ else if (!strncmp(argv, "max_ids:", 8))
+ max_ids = val;
+ else if (!strncmp(argv, "rescan:", 7))
+ rescan = val;
+ else if (!strncmp(argv, "virt_ctr:", 9))
+ virt_ctr = val;
+ else if (!strncmp(argv, "shared_access:", 14))
+ shared_access = val;
+ else if (!strncmp(argv, "reserve_list:", 13)) {
+ reserve_list[0] = val;
+ for (i = 1; i < MAX_RES_ARGS; i++) {
+ cur_str = strchr(cur_str, ',');
+ if (!cur_str)
+ break;
+ if (!isdigit((int)*++cur_str)) {
+ --cur_str;
+ break;
+ }
+ reserve_list[i] =
+ (int)simple_strtoul(cur_str, NULL, 0);
+ }
+ if (!cur_str)
+ break;
+ argv = ++cur_str;
+ continue;
+ }
+
+ if ((argv = strchr(argv, ',')))
+ ++argv;
+ }
+}
+
+GDTH_INITFUNC(int, option_setup(char *str))
+{
+ int ints[MAXHA];
+ char *cur = str;
+ int i = 1;
+
+ TRACE2(("option_setup() str %s\n", str ? str:"NULL"));
+
+ while (cur && isdigit(*cur) && i <= MAXHA) {
+ ints[i++] = simple_strtoul(cur, NULL, 0);
+ if ((cur = strchr(cur, ',')) != NULL) cur++;
+ }
+
+ ints[0] = i - 1;
+ internal_setup(cur, ints);
+ return 1;
+}
+
+GDTH_INITFUNC(int, gdth_detect(Scsi_Host_Template *shtp))
{
struct Scsi_Host *shp;
gdth_ha_str *ha;
@@ -3125,18 +3913,23 @@
break;
if (gdth_search_isa(isa_bios)) { /* controller found */
shp = scsi_register(shtp,sizeof(gdth_ext_str));
- if(shp == NULL)
- continue;
ha = HADATA(shp);
if (!gdth_init_isa(isa_bios,ha)) {
scsi_unregister(shp);
continue;
}
+#ifdef __ia64__
+ break;
+#else
/* controller found and initialized */
printk("Configuring GDT-ISA HA at BIOS 0x%05X IRQ %u DRQ %u\n",
isa_bios,ha->irq,ha->drq);
+#if LINUX_VERSION_CODE >= 0x010346
if (request_irq(ha->irq,gdth_interrupt,SA_INTERRUPT,"gdth",ha))
+#else
+ if (request_irq(ha->irq,gdth_interrupt,SA_INTERRUPT,"gdth"))
+#endif
{
printk("GDT-ISA: Unable to allocate IRQ\n");
scsi_unregister(shp);
@@ -3144,7 +3937,11 @@
}
if (request_dma(ha->drq,"gdth")) {
printk("GDT-ISA: Unable to allocate DMA channel\n");
+#if LINUX_VERSION_CODE >= 0x010346
free_irq(ha->irq,NULL);
+#else
+ free_irq(ha->irq);
+#endif
scsi_unregister(shp);
continue;
}
@@ -3161,7 +3958,12 @@
NUMDATA(shp)->busnum= 0;
ha->pccb = CMDDATA(shp);
- ha->pscratch = (void *) __get_free_pages(GFP_ATOMIC | GFP_DMA, GDTH_SCRATCH_ORD);
+#if LINUX_VERSION_CODE >= 0x020322
+ ha->pscratch = (void *) __get_free_pages(GFP_ATOMIC | GFP_DMA,
+ GDTH_SCRATCH_ORD);
+#else
+ ha->pscratch = scsi_init_malloc(GDTH_SCRATCH, GFP_ATOMIC | GFP_DMA);
+#endif
ha->scratch_busy = FALSE;
ha->req_first = NULL;
ha->tid_cnt = MAX_HDRIVES;
@@ -3176,8 +3978,16 @@
--gdth_ctr_count;
--gdth_ctr_vcount;
if (ha->pscratch != NULL)
+#if LINUX_VERSION_CODE >= 0x020322
free_pages((unsigned long)ha->pscratch, GDTH_SCRATCH_ORD);
+#else
+ scsi_init_free((void *)ha->pscratch, GDTH_SCRATCH);
+#endif
+#if LINUX_VERSION_CODE >= 0x010346
free_irq(ha->irq,NULL);
+#else
+ free_irq(ha->irq);
+#endif
scsi_unregister(shp);
continue;
}
@@ -3185,11 +3995,29 @@
hdr_channel = ha->bus_cnt;
ha->virt_bus = hdr_channel;
+#if LINUX_VERSION_CODE >= 0x020000
shp->max_id = ha->tid_cnt;
shp->max_lun = MAXLUN;
- shp->max_channel = ha->bus_cnt;
+ shp->max_channel = virt_ctr ? 0 : ha->bus_cnt;
+ if (virt_ctr)
+#endif
+ {
+ virt_ctr = 1;
+ /* register addit. SCSI channels as virtual controllers */
+ for (b = 1; b < ha->bus_cnt + 1; ++b) {
+ shp = scsi_register(shtp,sizeof(gdth_num_str));
+ shp->unchecked_isa_dma = 1;
+ shp->irq = ha->irq;
+ shp->dma_channel = ha->drq;
+ gdth_ctr_vtab[gdth_ctr_vcount++] = shp;
+ NUMDATA(shp)->hanum = (ushort)hanum;
+ NUMDATA(shp)->busnum = b;
+ }
+ }
+
GDTH_INIT_LOCK_HA(ha);
gdth_enable_int(hanum);
+#endif /* !__ia64__ */
}
}
@@ -3199,8 +4027,6 @@
break;
if (gdth_search_eisa(eisa_slot)) { /* controller found */
shp = scsi_register(shtp,sizeof(gdth_ext_str));
- if(shp == NULL)
- continue;
ha = HADATA(shp);
if (!gdth_init_eisa(eisa_slot,ha)) {
scsi_unregister(shp);
@@ -3210,7 +4036,11 @@
printk("Configuring GDT-EISA HA at Slot %d IRQ %u\n",
eisa_slot>>12,ha->irq);
+#if LINUX_VERSION_CODE >= 0x010346
if (request_irq(ha->irq,gdth_interrupt,SA_INTERRUPT,"gdth",ha))
+#else
+ if (request_irq(ha->irq,gdth_interrupt,SA_INTERRUPT,"gdth"))
+#endif
{
printk("GDT-EISA: Unable to allocate IRQ\n");
scsi_unregister(shp);
@@ -3229,7 +4059,12 @@
NUMDATA(shp)->hanum));
ha->pccb = CMDDATA(shp);
- ha->pscratch = (void *) __get_free_pages(GFP_ATOMIC | GFP_DMA, GDTH_SCRATCH_ORD);
+#if LINUX_VERSION_CODE >= 0x020322
+ ha->pscratch = (void *) __get_free_pages(GFP_ATOMIC | GFP_DMA,
+ GDTH_SCRATCH_ORD);
+#else
+ ha->pscratch = scsi_init_malloc(GDTH_SCRATCH, GFP_ATOMIC | GFP_DMA);
+#endif
ha->scratch_busy = FALSE;
ha->req_first = NULL;
ha->tid_cnt = MAX_HDRIVES;
@@ -3244,8 +4079,16 @@
--gdth_ctr_count;
--gdth_ctr_vcount;
if (ha->pscratch != NULL)
+#if LINUX_VERSION_CODE >= 0x020322
free_pages((unsigned long)ha->pscratch, GDTH_SCRATCH_ORD);
+#else
+ scsi_init_free((void *)ha->pscratch, GDTH_SCRATCH);
+#endif
+#if LINUX_VERSION_CODE >= 0x010346
free_irq(ha->irq,NULL);
+#else
+ free_irq(ha->irq);
+#endif
scsi_unregister(shp);
continue;
}
@@ -3253,16 +4096,37 @@
hdr_channel = ha->bus_cnt;
ha->virt_bus = hdr_channel;
+#if LINUX_VERSION_CODE >= 0x020000
shp->max_id = ha->tid_cnt;
shp->max_lun = MAXLUN;
- shp->max_channel = ha->bus_cnt;
+ shp->max_channel = virt_ctr ? 0 : ha->bus_cnt;
+ if (virt_ctr)
+#endif
+ {
+ virt_ctr = 1;
+ /* register addit. SCSI channels as virtual controllers */
+ for (b = 1; b < ha->bus_cnt + 1; ++b) {
+ shp = scsi_register(shtp,sizeof(gdth_num_str));
+ shp->unchecked_isa_dma = 0;
+ shp->irq = ha->irq;
+ shp->dma_channel = 0xff;
+ gdth_ctr_vtab[gdth_ctr_vcount++] = shp;
+ NUMDATA(shp)->hanum = (ushort)hanum;
+ NUMDATA(shp)->busnum = b;
+ }
+ }
+
GDTH_INIT_LOCK_HA(ha);
gdth_enable_int(hanum);
}
}
/* scanning for PCI controllers */
+#if LINUX_VERSION_CODE >= 0x2015C
if (pci_present())
+#else
+ if (pcibios_present())
+#endif
{
gdth_pci_str pcistr[MAXHA];
@@ -3272,8 +4136,6 @@
if (gdth_ctr_count >= MAXHA)
break;
shp = scsi_register(shtp,sizeof(gdth_ext_str));
- if(shp == NULL)
- continue;
ha = HADATA(shp);
if (!gdth_init_pci(&pcistr[ctr],ha)) {
scsi_unregister(shp);
@@ -3283,14 +4145,18 @@
printk("Configuring GDT-PCI HA at %d/%d IRQ %u\n",
pcistr[ctr].bus,PCI_SLOT(pcistr[ctr].device_fn),ha->irq);
+#if LINUX_VERSION_CODE >= 0x010346
if (request_irq(ha->irq, gdth_interrupt,
SA_INTERRUPT|SA_SHIRQ, "gdth", ha))
+#else
+ if (request_irq(ha->irq, gdth_interrupt,
+ SA_INTERRUPT|SA_SHIRQ, "gdth"))
+#endif
{
printk("GDT-PCI: Unable to allocate IRQ\n");
scsi_unregister(shp);
continue;
}
- scsi_set_pci_device(shp, pcistr[ctr].pdev);
shp->unchecked_isa_dma = 0;
shp->irq = ha->irq;
shp->dma_channel = 0xff;
@@ -3302,7 +4168,12 @@
NUMDATA(shp)->busnum= 0;
ha->pccb = CMDDATA(shp);
- ha->pscratch = (void *) __get_free_pages(GFP_ATOMIC | GFP_DMA, GDTH_SCRATCH_ORD);
+#if LINUX_VERSION_CODE >= 0x020322
+ ha->pscratch = (void *) __get_free_pages(GFP_ATOMIC | GFP_DMA,
+ GDTH_SCRATCH_ORD);
+#else
+ ha->pscratch = scsi_init_malloc(GDTH_SCRATCH, GFP_ATOMIC | GFP_DMA);
+#endif
ha->scratch_busy = FALSE;
ha->req_first = NULL;
ha->tid_cnt = pcistr[ctr].device_id >= 0x200 ? MAXID : MAX_HDRIVES;
@@ -3317,8 +4188,16 @@
--gdth_ctr_count;
--gdth_ctr_vcount;
if (ha->pscratch != NULL)
+#if LINUX_VERSION_CODE >= 0x020322
free_pages((unsigned long)ha->pscratch, GDTH_SCRATCH_ORD);
+#else
+ scsi_init_free((void *)ha->pscratch, GDTH_SCRATCH);
+#endif
+#if LINUX_VERSION_CODE >= 0x010346
free_irq(ha->irq,NULL);
+#else
+ free_irq(ha->irq);
+#endif
scsi_unregister(shp);
continue;
}
@@ -3326,9 +4205,26 @@
hdr_channel = ha->bus_cnt;
ha->virt_bus = hdr_channel;
+#if LINUX_VERSION_CODE >= 0x020000
shp->max_id = ha->tid_cnt;
shp->max_lun = MAXLUN;
- shp->max_channel = ha->bus_cnt;
+ shp->max_channel = virt_ctr ? 0 : ha->bus_cnt;
+ if (virt_ctr)
+#endif
+ {
+ virt_ctr = 1;
+ /* register addit. SCSI channels as virtual controllers */
+ for (b = 1; b < ha->bus_cnt + 1; ++b) {
+ shp = scsi_register(shtp,sizeof(gdth_num_str));
+ shp->unchecked_isa_dma = 0;
+ shp->irq = ha->irq;
+ shp->dma_channel = 0xff;
+ gdth_ctr_vtab[gdth_ctr_vcount++] = shp;
+ NUMDATA(shp)->hanum = (ushort)hanum;
+ NUMDATA(shp)->busnum = b;
+ }
+ }
+
GDTH_INIT_LOCK_HA(ha);
gdth_enable_int(hanum);
}
@@ -3344,7 +4240,9 @@
gdth_timer.function = gdth_timeout;
add_timer(&gdth_timer);
#endif
+#if LINUX_VERSION_CODE >= 0x020100
register_reboot_notifier(&gdth_notifier);
+#endif
}
gdth_polling = FALSE;
return gdth_ctr_vcount;
@@ -3360,15 +4258,27 @@
if (NUMDATA(shp)->busnum == 0) {
hanum = NUMDATA(shp)->hanum;
ha = HADATA(gdth_ctr_tab[hanum]);
+#if LINUX_VERSION_CODE >= 0x010300
gdth_flush(hanum);
+#endif
if (shp->irq) {
+#if LINUX_VERSION_CODE >= 0x010346
free_irq(shp->irq,NULL);
+#else
+ free_irq(shp->irq);
+#endif
}
+#ifndef __ia64__
if (shp->dma_channel != 0xff) {
free_dma(shp->dma_channel);
}
+#endif
+#if LINUX_VERSION_CODE >= 0x020322
free_pages((unsigned long)ha->pscratch, GDTH_SCRATCH_ORD);
+#else
+ scsi_init_free((void *)ha->pscratch, GDTH_SCRATCH);
+#endif
gdth_ctr_released++;
TRACE2(("gdth_release(): HA %d of %d\n",
gdth_ctr_released, gdth_ctr_count));
@@ -3377,7 +4287,9 @@
#ifdef GDTH_STATISTICS
del_timer(&gdth_timer);
#endif
+#if LINUX_VERSION_CODE >= 0x020100
unregister_reboot_notifier(&gdth_notifier);
+#endif
}
}
@@ -3437,12 +4349,17 @@
return SCSI_ABORT_SNOOZE;
}
+#if LINUX_VERSION_CODE >= 0x010346
int gdth_reset(Scsi_Cmnd *scp, unsigned int reset_flags)
+#else
+int gdth_reset(Scsi_Cmnd *scp)
+#endif
{
TRACE2(("gdth_reset()\n"));
return SCSI_RESET_PUNT;
}
+#if LINUX_VERSION_CODE >= 0x02015F
/* new error handling */
int gdth_eh_abort(Scsi_Cmnd *scp)
{
@@ -3462,28 +4379,50 @@
gdth_ha_str *ha;
ulong flags;
Scsi_Cmnd *cmnd;
+ unchar b;
TRACE2(("gdth_eh_bus_reset()\n"));
hanum = NUMDATA(scp->host)->hanum;
+ b = virt_ctr ? NUMDATA(scp->host)->busnum : scp->channel;
ha = HADATA(gdth_ctr_tab[hanum]);
- if (scp->channel == ha->virt_bus)
- return FAILED;
+ /* clear command tab */
GDTH_LOCK_HA(ha, flags);
- for (i = 0; i < MAXID; ++i)
- ha->raw[BUS_L2P(ha,scp->channel)].io_cnt[i] = 0;
for (i = 0; i < GDTH_MAXCMDS; ++i) {
cmnd = ha->cmd_tab[i].cmnd;
- if (!SPECIAL_SCP(cmnd) && cmnd->channel == scp->channel)
+ if (!SPECIAL_SCP(cmnd) && cmnd->channel == b)
ha->cmd_tab[i].cmnd = UNUSED_CMND;
}
- gdth_polling = TRUE;
- while (gdth_test_busy(hanum))
- gdth_delay(0);
- gdth_internal_cmd(hanum, SCSIRAWSERVICE, GDT_RESET_BUS,
- BUS_L2P(ha,scp->channel), 0, 0);
- gdth_polling = FALSE;
GDTH_UNLOCK_HA(ha, flags);
+
+ if (b == ha->virt_bus) {
+ /* host drives */
+ for (i = 0; i < MAX_HDRIVES; ++i) {
+ if (ha->hdr[i].present) {
+ GDTH_LOCK_HA(ha, flags);
+ gdth_polling = TRUE;
+ while (gdth_test_busy(hanum))
+ gdth_delay(0);
+ if (gdth_internal_cmd(hanum, CACHESERVICE,
+ GDT_CLUST_RESET, i, 0, 0))
+ ha->hdr[i].cluster_type &= ~CLUSTER_RESERVED;
+ gdth_polling = FALSE;
+ GDTH_UNLOCK_HA(ha, flags);
+ }
+ }
+ } else {
+ /* raw devices */
+ GDTH_LOCK_HA(ha, flags);
+ for (i = 0; i < MAXID; ++i)
+ ha->raw[BUS_L2P(ha,b)].io_cnt[i] = 0;
+ gdth_polling = TRUE;
+ while (gdth_test_busy(hanum))
+ gdth_delay(0);
+ gdth_internal_cmd(hanum, SCSIRAWSERVICE, GDT_RESET_BUS,
+ BUS_L2P(ha,b), 0, 0);
+ gdth_polling = FALSE;
+ GDTH_UNLOCK_HA(ha, flags);
+ }
return SUCCESS;
}
@@ -3492,27 +4431,32 @@
TRACE2(("gdth_eh_host_reset()\n"));
return FAILED;
}
+#endif
+#if LINUX_VERSION_CODE >= 0x010300
int gdth_bios_param(Disk *disk,kdev_t dev,int *ip)
+#else
+int gdth_bios_param(Disk *disk,int dev,int *ip)
+#endif
{
- unchar t;
+ unchar b, t;
int hanum;
gdth_ha_str *ha;
hanum = NUMDATA(disk->device->host)->hanum;
+ b = virt_ctr ? NUMDATA(disk->device->host)->busnum : disk->device->channel;
t = disk->device->id;
- TRACE2(("gdth_bios_param() ha %d bus %d target %d\n",
- hanum, disk->device->channel, t));
+ TRACE2(("gdth_bios_param() ha %d bus %d target %d\n", hanum, b, t));
ha = HADATA(gdth_ctr_tab[hanum]);
- if (disk->device->channel != ha->virt_bus || ha->hdr[t].heads == 0) {
+ if (b != ha->virt_bus || ha->hdr[t].heads == 0) {
/* raw device or host drive without mapping information */
- TRACE2(("Evaluate mapping\n"));
- gdth_eval_mapping(disk->capacity,&ip[2],&ip[0],&ip[1]);
+ TRACE2(("Evaluate mapping\n"));
+ gdth_eval_mapping(disk->capacity,&ip[2],&ip[0],&ip[1]);
} else {
- ip[0] = ha->hdr[t].heads;
- ip[1] = ha->hdr[t].secs;
- ip[2] = disk->capacity / ip[0] / ip[1];
+ ip[0] = ha->hdr[t].heads;
+ ip[1] = ha->hdr[t].secs;
+ ip[2] = disk->capacity / ip[0] / ip[1];
}
TRACE2(("gdth_bios_param(): %d heads, %d secs, %d cyls\n",
@@ -3521,24 +4465,6 @@
}
-static void internal_done(Scsi_Cmnd *scp)
-{
- scp->SCp.sent_command++;
-}
-
-int gdth_command(Scsi_Cmnd *scp)
-{
- TRACE2(("gdth_command()\n"));
-
- scp->SCp.sent_command = 0;
- gdth_queuecommand(scp,internal_done);
-
- while (!scp->SCp.sent_command)
- barrier();
- return scp->result;
-}
-
-
int gdth_queuecommand(Scsi_Cmnd *scp,void (*done)(Scsi_Cmnd *))
{
int hanum;
@@ -3550,171 +4476,173 @@
scp->scsi_done = (void *)done;
scp->SCp.have_data_in = 1;
scp->SCp.phase = -1;
- scp->SCp.Status = -1;
+ scp->SCp.sent_command = -1;
hanum = NUMDATA(scp->host)->hanum;
#ifdef GDTH_STATISTICS
++act_ios;
#endif
priority = DEFAULT_PRI;
+#if LINUX_VERSION_CODE >= 0x010300
if (scp->done == gdth_scsi_done)
priority = scp->SCp.this_residual;
+#endif
gdth_update_timeout(hanum, scp, scp->timeout_per_command * 6);
gdth_putq( hanum, scp, priority );
gdth_next( hanum );
return 0;
}
+#if LINUX_VERSION_CODE >= 0x010300
/* flush routine */
static void gdth_flush(int hanum)
{
int i;
gdth_ha_str *ha;
- Scsi_Cmnd * scp;
- Scsi_Device * sdev;
gdth_cmd_str gdtcmd;
+#if LINUX_VERSION_CODE >= 0x020322
+ Scsi_Cmnd *scp;
+ Scsi_Device *sdev;
+#else
+ Scsi_Cmnd scp;
+ Scsi_Device sdev;
+#endif
+ char cmnd[MAX_COMMAND_SIZE];
+ memset(cmnd, 0xff, 12);
TRACE2(("gdth_flush() hanum %d\n",hanum));
ha = HADATA(gdth_ctr_tab[hanum]);
+#if LINUX_VERSION_CODE >= 0x020322
sdev = scsi_get_host_dev(gdth_ctr_tab[hanum]);
- if (!sdev)
- return;
-
scp = scsi_allocate_device(sdev, 1, FALSE);
+ scp->cmd_len = 12;
+ scp->use_sg = 0;
+#else
+ memset(&sdev,0,sizeof(Scsi_Device));
+ memset(&scp, 0,sizeof(Scsi_Cmnd));
+ sdev.host = scp.host = gdth_ctr_tab[hanum];
+ sdev.id = scp.target = sdev.host->this_id;
+ scp.device = &sdev;
+#endif
- if (scp) {
- scp->cmd_len = 12;
- scp->use_sg = 0;
-
- for (i = 0; i < MAX_HDRIVES; ++i) {
- if (ha->hdr[i].present) {
- gdtcmd.BoardNode = LOCALBOARD;
- gdtcmd.Service = CACHESERVICE;
- gdtcmd.OpCode = GDT_FLUSH;
- gdtcmd.u.cache.DeviceNo = i;
- gdtcmd.u.cache.BlockNo = 1;
- gdtcmd.u.cache.sg_canz = 0;
- TRACE2(("gdth_flush(): flush ha %d drive %d\n", hanum, i));
- gdth_do_cmd(scp, &gdtcmd, 30);
- }
+ for (i = 0; i < MAX_HDRIVES; ++i) {
+ if (ha->hdr[i].present) {
+ gdtcmd.BoardNode = LOCALBOARD;
+ gdtcmd.Service = CACHESERVICE;
+ gdtcmd.OpCode = GDT_FLUSH;
+ gdtcmd.u.cache.DeviceNo = i;
+ gdtcmd.u.cache.BlockNo = 1;
+ gdtcmd.u.cache.sg_canz = 0;
+ TRACE2(("gdth_flush(): flush ha %d drive %d\n", hanum, i));
+#if LINUX_VERSION_CODE >= 0x020322
+ gdth_do_cmd(scp, &gdtcmd, cmnd, 30);
+#else
+ gdth_do_cmd(&scp, &gdtcmd, cmnd, 30);
+#endif
}
- scsi_release_command(scp);
}
+#if LINUX_VERSION_CODE >= 0x020322
+ scsi_release_command(scp);
scsi_free_host_dev(sdev);
+#endif
}
/* shutdown routine */
+#if LINUX_VERSION_CODE >= 0x020100
static int gdth_halt(struct notifier_block *nb, ulong event, void *buf)
+#else
+void gdth_halt(void)
+#endif
{
int hanum;
#ifndef __alpha__
- Scsi_Cmnd * scp;
- Scsi_Device * sdev;
gdth_cmd_str gdtcmd;
+#if LINUX_VERSION_CODE >= 0x020322
+ Scsi_Cmnd *scp;
+ Scsi_Device *sdev;
+#else
+ Scsi_Cmnd scp;
+ Scsi_Device sdev;
+#endif
+ char cmnd[MAX_COMMAND_SIZE];
#endif
- TRACE2(("gdth_halt() event %d\n",event));
+#if LINUX_VERSION_CODE >= 0x020100
+ TRACE2(("gdth_halt() event %d\n",(int)event));
if (event != SYS_RESTART && event != SYS_HALT && event != SYS_POWER_OFF)
return NOTIFY_DONE;
+#else
+ TRACE2(("gdth_halt()\n"));
+ if (halt_called) {
+ TRACE2(("already called\n"));
+ return;
+ }
+ halt_called = TRUE;
+#endif
printk("GDT: Flushing all host drives .. ");
for (hanum = 0; hanum < gdth_ctr_count; ++hanum) {
gdth_flush(hanum);
#ifndef __alpha__
/* controller reset */
- sdev = scsi_get_host_dev(gdth_ctr_tab[hanum]);
- scp = scsi_allocate_device(sdev, 1, FALSE);
+ memset(cmnd, 0xff, 12);
+#if LINUX_VERSION_CODE >= 0x020322
+ sdev = scsi_get_host_dev(gdth_ctr_tab[hanum]);
+ scp = scsi_allocate_device(sdev, 1, FALSE);
scp->cmd_len = 12;
scp->use_sg = 0;
+#else
+ memset(&sdev,0,sizeof(Scsi_Device));
+ memset(&scp, 0,sizeof(Scsi_Cmnd));
+ sdev.host = scp.host = gdth_ctr_tab[hanum];
+ sdev.id = scp.target = sdev.host->this_id;
+ scp.device = &sdev;
+#endif
gdtcmd.BoardNode = LOCALBOARD;
gdtcmd.Service = CACHESERVICE;
gdtcmd.OpCode = GDT_RESET;
TRACE2(("gdth_halt(): reset controller %d\n", hanum));
- gdth_do_cmd(scp, &gdtcmd, 10);
- scsi_release_command(scp);
- scsi_free_host_dev(sdev);
+#if LINUX_VERSION_CODE >= 0x020322
+ gdth_do_cmd(scp, &gdtcmd, cmnd, 10);
+ scsi_release_command(scp);
+ scsi_free_host_dev(sdev);
+#else
+ gdth_do_cmd(&scp, &gdtcmd, cmnd, 10);
+#endif
#endif
}
-
printk("Done.\n");
#ifdef GDTH_STATISTICS
del_timer(&gdth_timer);
#endif
+#if LINUX_VERSION_CODE >= 0x020100
+#if LINUX_VERSION_CODE < 0x020322
unregister_reboot_notifier(&gdth_notifier);
+#endif
return NOTIFY_OK;
+#endif
}
+#endif
-/* called from init/main.c */
-void __init gdth_setup(char *str,int *ints)
-{
- int i, argc;
- char *cur_str, *argv;
+#if LINUX_VERSION_CODE < 0x020400 && !defined(MODULE)
+
+GDTH_INITFUNC(void, gdth_setup(char *str,int *ints))
+{
TRACE2(("gdth_setup() str %s ints[0] %d\n",
str ? str:"NULL", ints ? ints[0]:0));
-
- /* read irq[] from ints[] */
- if (ints) {
- argc = ints[0];
- if (argc > 0) {
- if (argc > MAXHA)
- argc = MAXHA;
- for (i = 0; i < argc; ++i)
- irq[i] = ints[i+1];
- }
- }
-
- /* analyse string */
- argv = str;
- while (argv && (cur_str = strchr(argv, ':'))) {
- int val = 0, c = *++cur_str;
-
- if (c == 'n' || c == 'N')
- val = 0;
- else if (c == 'y' || c == 'Y')
- val = 1;
- else
- val = (int)simple_strtoul(cur_str, NULL, 0);
-
- if (!strncmp(argv, "disable:", 8))
- disable = val;
- else if (!strncmp(argv, "reserve_mode:", 13))
- reserve_mode = val;
- else if (!strncmp(argv, "reverse_scan:", 13))
- reverse_scan = val;
- else if (!strncmp(argv, "hdr_channel:", 12))
- hdr_channel = val;
- else if (!strncmp(argv, "max_ids:", 8))
- max_ids = val;
- else if (!strncmp(argv, "rescan:", 7))
- rescan = val;
- else if (!strncmp(argv, "reserve_list:", 13)) {
- reserve_list[0] = val;
- for (i = 1; i < MAX_RES_ARGS; i++) {
- cur_str = strchr(cur_str, ',');
- if (!cur_str)
- break;
- if (!isdigit((int)*++cur_str)) {
- --cur_str;
- break;
- }
- reserve_list[i] =
- (int)simple_strtoul(cur_str, NULL, 0);
- }
- if (!cur_str)
- break;
- argv = ++cur_str;
- continue;
- }
-
- if ((argv = strchr(argv, ',')))
- ++argv;
- }
+ internal_setup(str, ints);
}
+#else
-static Scsi_Host_Template driver_template = GDTH;
+Scsi_Host_Template driver_template = GDTH;
#include "scsi_module.c"
+#ifndef MODULE
+__setup("gdth=", option_setup);
+#endif
+
+#endif
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)