diff -urN linux-2.0.31/drivers/scsi/gdth.c linux-2.0.31-gdth/drivers/scsi/gdth.c
--- linux-2.0.31/drivers/scsi/gdth.c	Fri Oct 31 13:20:11 1997
+++ linux-2.0.31-gdth/drivers/scsi/gdth.c	Fri Oct 31 13:36:36 1997
@@ -20,9 +20,16 @@
  * 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.0.29                                *
+ * Tested with Linux 1.2.13, ..., 2.1.61                                *
  *                                                                      *
  * $Log: gdth.c,v $
+ * Revision 1.10  1997/10/31 12:29:57  achim
+ * Read heads/sectors from host drive
+ *
+ * Revision 1.9  1997/09/04 10:07:25  achim
+ * IO-mapping with virt_to_bus(), readb(), writeb(), ...
+ * register_reboot_notifier() to get a notify on shutdown used
+ *
  * Revision 1.8  1997/04/02 12:14:30  achim
  * Version 1.00 (see gdth.h), tested with kernel 2.0.29
  *
@@ -53,7 +60,7 @@
  * Initial revision
  *
  *
- * $Id: gdth.c,v 1.8 1997/04/02 12:14:30 achim Exp $ 
+ * $Id: gdth.c,v 1.10 1997/10/31 12:29:57 achim Exp $ 
  ************************************************************************/
 
 #ifdef MODULE
@@ -74,6 +81,9 @@
 #include <linux/proc_fs.h>
 #include <linux/time.h>
 #include <linux/timer.h>
+#if LINUX_VERSION_CODE >= 0x020100
+#include <linux/reboot.h>
+#endif
 
 #include <asm/dma.h>
 #include <asm/system.h>
@@ -116,9 +126,9 @@
 static int gdth_search_eisa(ushort eisa_adr);
 static int gdth_search_isa(ulong bios_adr);
 static int gdth_search_pci(ushort device_id,ushort index,gdth_pci_str *pcistr);
-static int gdth_init_eisa(ushort eisa_adr,gdth_ha_str *ha,int firsttime);
-static int gdth_init_isa(ulong bios_adr,gdth_ha_str *ha,int firsttime);
-static int gdth_init_pci(gdth_pci_str *pcistr,gdth_ha_str *ha,int firsttime);
+static int gdth_init_eisa(ushort eisa_adr,gdth_ha_str *ha);
+static int gdth_init_isa(ulong bios_adr,gdth_ha_str *ha);
+static int gdth_init_pci(gdth_pci_str *pcistr,gdth_ha_str *ha);
 
 static void gdth_enable_int(int hanum);
 static int gdth_get_status(unchar *pIStatus,int irq);
@@ -128,10 +138,17 @@
 static int gdth_wait(int hanum,int index,ulong time);
 static int gdth_internal_cmd(int hanum,unchar service,ushort opcode,ulong p1,
                              ulong p2,ulong p3);
-static int gdth_search_drives(int hanum,int firsttime);
+static int gdth_search_drives(int hanum);
+
+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 >= 0x020100
+static int gdth_halt(struct notifier_block *nb, ulong event, void *buf);
+#else
 void gdth_halt(void);
+#endif
 
 #ifdef DEBUG_GDTH
 static unchar   DebugState = DEBUG_GDTH;
@@ -229,7 +246,6 @@
 #define TRACE3(a)
 #endif
 
-
 #ifdef GDTH_STATISTICS
 static ulong max_rq=0, max_index=0, max_sg=0;
 static ulong act_ints=0, act_ios=0, act_stats=0, act_rq=0;
@@ -246,6 +262,67 @@
 #define CMDDATA(a)      (&((gdth_ext_str *)((a)->hostdata))->cmdext)
 #define DMADATA(a)      (&((gdth_ext_str *)((a)->hostdata))->dmaext)
 
+
+#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 ulong virt_to_phys(volatile void *addr)
+{
+    return (ulong)addr;
+}
+inline void *phys_to_virt(ulong addr)
+{
+    return (void *)addr;
+}
+#define virt_to_bus		virt_to_phys
+#define bus_to_virt		phys_to_virt
+#define readb(addr)		(*(volatile unchar *)(addr))
+#define readw(addr)		(*(volatile ushort *)(addr))
+#define readl(addr)		(*(volatile ulong *)(addr))
+#define writeb(b,addr)		(*(volatile unchar *)(addr) = (b))
+#define writew(b,addr)		(*(volatile ushort *)(addr) = (b))
+#define writel(b,addr)		(*(volatile ulong *)(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))
+
+#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;
+}
+#else
+static void *gdth_mmap(ulong paddr, ulong size) 
+{ 
+    return ioremap(paddr, size); 
+}
+static void gdth_munmap(void *addr) 
+{
+    return iounmap(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 */
 static unchar   gdth_polling;                           /* polling if TRUE */
@@ -312,6 +389,12 @@
 #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
 
 /* controller search and initialization functions */
 
@@ -335,12 +418,16 @@
 
 static int gdth_search_isa(ulong bios_adr)
 {
+    void *addr;
     ulong id;
 
     TRACE(("gdth_search_isa() bios adr. %lx\n",bios_adr));
-    id = *(ulong *)(bios_adr+BIOS_ID_OFFS);
-    if (id == GDT2_ID)                          /* GDT2000 */
-        return 1;
+    if ((addr = gdth_mmap(bios_adr+BIOS_ID_OFFS, sizeof(ulong))) != NULL) {
+	id = readl(addr);
+	gdth_munmap(addr);
+	if (id == GDT2_ID)                          /* GDT2000 */
+	    return 1;
+    }
     return 0;
 }
 
@@ -404,7 +491,7 @@
 }
 
 
-static int gdth_init_eisa(ushort eisa_adr,gdth_ha_str *ha,int firsttime)
+static int gdth_init_eisa(ushort eisa_adr,gdth_ha_str *ha)
 {
     ulong retries,id;
     unchar prot_ver,eisacf,i,irq_found;
@@ -433,7 +520,7 @@
         printk("GDT-EISA: Illegal protocol version\n");
         return 0;
     }
-    ha->brd = (ulong)eisa_adr;
+    ha->bmic = eisa_adr;
     ha->brd_phys = (ulong)eisa_adr >> 12;
 
     outl(0,eisa_adr+MAILBOXREG);
@@ -456,33 +543,30 @@
             }
             udelay(1000);
         }
-        if (firsttime)
-            ha->irq = inb(eisa_adr+MAILBOXREG);
+        ha->irq = inb(eisa_adr+MAILBOXREG);
         outb(0xff,eisa_adr+EDOORREG);
         TRACE2(("GDT3000/3020: IRQ=%d\n",ha->irq));
-        if (firsttime) {
-            /* check the result */
-            if (ha->irq == 0) {
-                TRACE2(("Unknown IRQ, check IRQ table from cmd line !\n"));
-                for (i=0,irq_found=FALSE; i<MAXHA && irqs[i]!=0xff; ++i) {
-                    if (irqs[i]!=0) {
-                        irq_found=TRUE;
-                        break;
-                    }
-                }
-                if (irq_found) {
-                    ha->irq = irqs[i];
-                    irqs[i] = 0;
-                    printk("GDT-EISA: Can not detect controller IRQ,\n");
-                    printk("Use IRQ setting from command line (IRQ = %d)\n",
-                           ha->irq);
-                } else {
-                    printk("GDT-EISA: Initialization error (unknown IRQ), Enable\n");
-                    printk("the controller BIOS or use command line parameters\n");
-                    return 0;
-                }
-            }
-        }
+	/* check the result */
+	if (ha->irq == 0) {
+	    TRACE2(("Unknown IRQ, check IRQ table from cmd line !\n"));
+	    for (i=0,irq_found=FALSE; i<MAXHA && irqs[i]!=0xff; ++i) {
+		if (irqs[i]!=0) {
+		    irq_found=TRUE;
+		    break;
+		}
+	    }
+	    if (irq_found) {
+		ha->irq = irqs[i];
+		irqs[i] = 0;
+		printk("GDT-EISA: Can not detect controller IRQ,\n");
+		printk("Use IRQ setting from command line (IRQ = %d)\n",
+		       ha->irq);
+	    } else {
+		printk("GDT-EISA: Initialization error (unknown IRQ), Enable\n");
+		printk("the controller BIOS or use command line parameters\n");
+		return 0;
+	    }
+	}
     } else {
         eisacf = inb(eisa_adr+EISAREG) & 7;
         if (eisacf > 4)                         /* level triggered */
@@ -495,7 +579,7 @@
 }
 
        
-static int gdth_init_isa(ulong bios_adr,gdth_ha_str *ha,int firsttime)
+static int gdth_init_isa(ulong bios_adr,gdth_ha_str *ha)
 {
     register gdt2_dpram_str *dp2_ptr;
     int i;
@@ -504,19 +588,23 @@
 
     TRACE(("gdth_init_isa() bios adr. %lx\n",bios_adr));
 
-    ha->brd = bios_adr;
+    ha->brd = gdth_mmap(bios_adr, sizeof(gdt2_dpram_str));
+    if (ha->brd == NULL) {
+	printk("GDT-ISA: Initialization error (DPMEM remap error)\n");
+	return 0;
+    }
     dp2_ptr = (gdt2_dpram_str *)ha->brd;
-    dp2_ptr->io.memlock = 1;            /* switch off write protection */
+    writeb(1, &dp2_ptr->io.memlock);			/* switch off write protection */
     /* reset interface area */
-    memset((char *)&dp2_ptr->u,0,sizeof(dp2_ptr->u));
+    memset_io((char *)&dp2_ptr->u,0,sizeof(dp2_ptr->u));
 
     /* disable board interrupts, read DRQ and IRQ */
-    dp2_ptr->io.irqdel     = 0xff;
-    dp2_ptr->io.irqen      = 0x00;
-    dp2_ptr->u.ic.S_Status = 0x00;
-    dp2_ptr->u.ic.Cmd_Index= 0x00;
+    writeb(0xff, &dp2_ptr->io.irqdel);
+    writeb(0x00, &dp2_ptr->io.irqen);
+    writeb(0x00, &dp2_ptr->u.ic.S_Status);
+    writeb(0x00, &dp2_ptr->u.ic.Cmd_Index);
 
-    irq_drq = dp2_ptr->io.rq;
+    irq_drq = readb(&dp2_ptr->io.rq);
     for (i=0; i<3; ++i) {
         if ((irq_drq & 1)==0)
             break;
@@ -524,7 +612,7 @@
     }
     ha->drq = gdth_drq_tab[i];
 
-    irq_drq = dp2_ptr->io.rq >> 3;
+    irq_drq = readb(&dp2_ptr->io.rq) >> 3;
     for (i=1; i<5; ++i) {
         if ((irq_drq & 1)==0)
             break;
@@ -533,23 +621,25 @@
     ha->irq = gdth_irq_tab[i];
 
     /* deinitialize services */
-    dp2_ptr->u.ic.S_Info[0] = bios_adr;
-    dp2_ptr->u.ic.S_Cmd_Indx= 0xff;
-    dp2_ptr->io.event = 0;
+    writel(bios_adr, &dp2_ptr->u.ic.S_Info[0]);
+    writeb(0xff, &dp2_ptr->u.ic.S_Cmd_Indx);
+    writeb(0, &dp2_ptr->io.event);
     retries = INIT_RETRIES;
     JIFFYWAIT(2);
-    while (dp2_ptr->u.ic.S_Status != 0xff) {
+    while (readb(&dp2_ptr->u.ic.S_Status) != 0xff) {
         if (--retries == 0) {
             printk("GDT-ISA: Initialization error (DEINIT failed)\n");
+	    gdth_munmap(ha->brd);
             return 0;
         }
         udelay(1000);
     }
-    prot_ver = (unchar)dp2_ptr->u.ic.S_Info[0];
-    dp2_ptr->u.ic.Status = 0;
-    dp2_ptr->io.irqdel = 0xff;
+    prot_ver = (unchar)readl(&dp2_ptr->u.ic.S_Info[0]);
+    writeb(0, &dp2_ptr->u.ic.Status);
+    writeb(0xff, &dp2_ptr->io.irqdel);
     if (prot_ver != PROTOCOL_VERSION) {
         printk("GDT-ISA: Illegal protocol version\n");
+	gdth_munmap(ha->brd);
         return 0;
     }
 
@@ -559,78 +649,83 @@
     ha->brd_phys = bios_adr >> 4;
 
     /* special request to controller BIOS */
-    dp2_ptr->u.ic.S_Info[0] = 0x00;
-    dp2_ptr->u.ic.S_Info[1] = 0x00;
-    dp2_ptr->u.ic.S_Info[2] = 0x01;
-    dp2_ptr->u.ic.S_Info[3] = 0x00;
-    dp2_ptr->u.ic.S_Cmd_Indx= 0xfe;
-    dp2_ptr->io.event = 0;
+    writel(0x00, &dp2_ptr->u.ic.S_Info[0]);
+    writel(0x00, &dp2_ptr->u.ic.S_Info[1]);
+    writel(0x01, &dp2_ptr->u.ic.S_Info[2]);
+    writel(0x00, &dp2_ptr->u.ic.S_Info[3]);
+    writeb(0xfe, &dp2_ptr->u.ic.S_Cmd_Indx);
+    writeb(0, &dp2_ptr->io.event);
     retries = INIT_RETRIES;
     JIFFYWAIT(2);
-    while (dp2_ptr->u.ic.S_Status != 0xfe) {
+    while (readb(&dp2_ptr->u.ic.S_Status) != 0xfe) {
         if (--retries == 0) {
             printk("GDT-ISA: Initialization error\n");
+	    gdth_munmap(ha->brd);
             return 0;
         }
         udelay(1000);
     }
-    dp2_ptr->u.ic.Status = 0;
-    dp2_ptr->io.irqdel = 0xff;
+    writeb(0, &dp2_ptr->u.ic.Status);
+    writeb(0xff, &dp2_ptr->io.irqdel);
     return 1;
 }
 
 
-static int gdth_init_pci(gdth_pci_str *pcistr,gdth_ha_str *ha,int firsttime)
+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;
     ulong retries;
     unchar prot_ver;
-    unchar remapped = FALSE;
 
     TRACE(("gdth_init_pci()\n"));
 
-    if (firsttime) {
-        ha->brd      = pcistr->dpmem;
-        ha->brd_phys = (pcistr->bus << 8) | (pcistr->device_fn & 0xf8);
-        ha->stype    = (ulong)pcistr->device_id;
-        ha->irq      = pcistr->irq;
-    }
-
+    ha->brd_phys = (pcistr->bus << 8) | (pcistr->device_fn & 0xf8);
+    ha->stype    = (ulong)pcistr->device_id;
+    ha->irq      = pcistr->irq;
+    
     if (ha->stype <= PCI_DEVICE_ID_VORTEX_GDT6000B) {   /* GDT6000 or GDT6000B */
-        TRACE2(("init_pci() dpmem %lx irq %d\n",ha->brd,ha->irq));
+        TRACE2(("init_pci() dpmem %lx irq %d\n",pcistr->dpmem,ha->irq));
+	ha->brd = gdth_mmap(pcistr->dpmem, 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;
         /* reset interface area */
-        memset((char *)&dp6_ptr->u,0,sizeof(dp6_ptr->u));
-        if (*(ulong *)&dp6_ptr->u != 0) {
+        memset_io((char *)&dp6_ptr->u,0,sizeof(dp6_ptr->u));
+        if (readl(&dp6_ptr->u) != 0) {
             printk("GDT-PCI: Initialization error (DPMEM write error)\n");
+	    gdth_munmap(ha->brd);
             return 0;
         }
         
         /* disable board interrupts, deinit services */
-        dp6_ptr->io.irqdel     = 0xff;
-        dp6_ptr->io.irqen      = 0x00;
-        dp6_ptr->u.ic.S_Status = 0x00;
-        dp6_ptr->u.ic.Cmd_Index= 0x00;
-
-        dp6_ptr->u.ic.S_Info[0] = ha->brd;
-        dp6_ptr->u.ic.S_Cmd_Indx= 0xff;
-        dp6_ptr->io.event = 0;
+        writeb(0xff, &dp6_ptr->io.irqdel);
+        writeb(0x00, &dp6_ptr->io.irqen);;
+        writeb(0x00, &dp6_ptr->u.ic.S_Status);
+        writeb(0x00, &dp6_ptr->u.ic.Cmd_Index);
+
+        writel(pcistr->dpmem, &dp6_ptr->u.ic.S_Info[0]);
+        writeb(0xff, &dp6_ptr->u.ic.S_Cmd_Indx);
+        writeb(0, &dp6_ptr->io.event);
         retries = INIT_RETRIES;
         JIFFYWAIT(2);
-        while (dp6_ptr->u.ic.S_Status != 0xff) {
+        while (readb(&dp6_ptr->u.ic.S_Status) != 0xff) {
             if (--retries == 0) {
                 printk("GDT-PCI: Initialization error (DEINIT failed)\n");
+		gdth_munmap(ha->brd);
                 return 0;
             }
             udelay(1000);
         }
-        prot_ver = (unchar)dp6_ptr->u.ic.S_Info[0];
-        dp6_ptr->u.ic.S_Status = 0;
-        dp6_ptr->io.irqdel = 0xff;
+        prot_ver = (unchar)readl(&dp6_ptr->u.ic.S_Info[0]);
+        writeb(0, &dp6_ptr->u.ic.S_Status);
+        writeb(0xff, &dp6_ptr->io.irqdel);
         if (prot_ver != PROTOCOL_VERSION) {
             printk("GDT-PCI: Illegal protocol version\n");
+	    gdth_munmap(ha->brd);
             return 0;
         }
 
@@ -638,35 +733,41 @@
         ha->ic_all_size = sizeof(dp6_ptr->u);
         
         /* special command to controller BIOS */
-        dp6_ptr->u.ic.S_Info[0] = 0x00;
-        dp6_ptr->u.ic.S_Info[1] = 0x00;
-        dp6_ptr->u.ic.S_Info[2] = 0x01;
-        dp6_ptr->u.ic.S_Info[3] = 0x00;
-        dp6_ptr->u.ic.S_Cmd_Indx= 0xfe;
-        dp6_ptr->io.event = 0;
+        writel(0x00, &dp6_ptr->u.ic.S_Info[0]);
+        writel(0x00, &dp6_ptr->u.ic.S_Info[1]);
+        writel(0x01, &dp6_ptr->u.ic.S_Info[2]);
+        writel(0x00, &dp6_ptr->u.ic.S_Info[3]);
+        writeb(0xfe, &dp6_ptr->u.ic.S_Cmd_Indx);
+        writeb(0, &dp6_ptr->io.event);
         retries = INIT_RETRIES;
         JIFFYWAIT(2);
-        while (dp6_ptr->u.ic.S_Status != 0xfe) {
+        while (readb(&dp6_ptr->u.ic.S_Status) != 0xfe) {
             if (--retries == 0) {
                 printk("GDT-PCI: Initialization error\n");
+		gdth_munmap(ha->brd);
                 return 0;
             }
             udelay(1000);
         }
-        dp6_ptr->u.ic.S_Status = 0;
-        dp6_ptr->io.irqdel = 0xff;
+        writeb(0, &dp6_ptr->u.ic.S_Status);
+        writeb(0xff, &dp6_ptr->io.irqdel);
 
     } else if (ha->stype <= PCI_DEVICE_ID_VORTEX_GDT6555) { /* GDT6110, GDT6120, .. */
-        if (firsttime) {
-            ha->plx = (gdt6c_plx_regs *)pcistr->io;
-        }
-        TRACE2(("init_pci_new() dpmem %lx io %lx irq %d\n",
-                      ha->brd,(ulong)ha->plx,ha->irq));
+	ha->plx = (gdt6c_plx_regs *)pcistr->io;
+	TRACE2(("init_pci_new() dpmem %lx io %lx irq %d\n",
+		pcistr->dpmem,(ulong)ha->plx,ha->irq));
+	ha->brd = gdth_mmap(pcistr->dpmem, sizeof(gdt6c_dpram_str));
+	if (ha->brd == NULL) {
+	    printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
+	    gdth_munmap(ha->brd);
+	    return 0;
+	}
         dp6c_ptr = (gdt6c_dpram_str *)ha->brd;
         /* reset interface area */
-        memset((char *)&dp6c_ptr->u,0,sizeof(dp6c_ptr->u));
-        if (*(ulong *)&dp6c_ptr->u != 0) {
+        memset_io((char *)&dp6c_ptr->u,0,sizeof(dp6c_ptr->u));
+        if (readl(&dp6c_ptr->u) != 0) {
             printk("GDT-PCI: Initialization error (DPMEM write error)\n");
+	    gdth_munmap(ha->brd);
             return 0;
         }
         
@@ -674,27 +775,29 @@
         outb(0x00,PTR2USHORT(&ha->plx->control1));
         outb(0xff,PTR2USHORT(&ha->plx->edoor_reg));
         
-        dp6c_ptr->u.ic.S_Status = 0x00;
-        dp6c_ptr->u.ic.Cmd_Index= 0x00;
+        writeb(0x00, &dp6c_ptr->u.ic.S_Status);
+        writeb(0x00, &dp6c_ptr->u.ic.Cmd_Index);
 
-        dp6c_ptr->u.ic.S_Info[0] = ha->brd;
-        dp6c_ptr->u.ic.S_Cmd_Indx= 0xff;
+        writel(pcistr->dpmem, &dp6c_ptr->u.ic.S_Info[0]);
+        writeb(0xff, &dp6c_ptr->u.ic.S_Cmd_Indx);
 
         outb(1,PTR2USHORT(&ha->plx->ldoor_reg));
 
         retries = INIT_RETRIES;
         JIFFYWAIT(2);
-        while (dp6c_ptr->u.ic.S_Status != 0xff) {
+        while (readb(&dp6c_ptr->u.ic.S_Status) != 0xff) {
             if (--retries == 0) {
                 printk("GDT-PCI: Initialization error (DEINIT failed)\n");
+		gdth_munmap(ha->brd);
                 return 0;
             }
             udelay(1000);
         }
-        prot_ver = (unchar)dp6c_ptr->u.ic.S_Info[0];
-        dp6c_ptr->u.ic.Status = 0;
+        prot_ver = (unchar)readl(&dp6c_ptr->u.ic.S_Info[0]);
+        writeb(0, &dp6c_ptr->u.ic.Status);
         if (prot_ver != PROTOCOL_VERSION) {
             printk("GDT-PCI: Illegal protocol version\n");
+	    gdth_munmap(ha->brd);
             return 0;
         }
 
@@ -702,87 +805,68 @@
         ha->ic_all_size = sizeof(dp6c_ptr->u);
 
         /* special command to controller BIOS */
-        dp6c_ptr->u.ic.S_Info[0] = 0x00;
-        dp6c_ptr->u.ic.S_Info[1] = 0x00;
-        dp6c_ptr->u.ic.S_Info[2] = 0x01;
-        dp6c_ptr->u.ic.S_Info[3] = 0x00;
-        dp6c_ptr->u.ic.S_Cmd_Indx= 0xfe;
+        writel(0x00, &dp6c_ptr->u.ic.S_Info[0]);
+        writel(0x00, &dp6c_ptr->u.ic.S_Info[1]);
+        writel(0x01, &dp6c_ptr->u.ic.S_Info[2]);
+        writel(0x00, &dp6c_ptr->u.ic.S_Info[3]);
+        writeb(0xfe, &dp6c_ptr->u.ic.S_Cmd_Indx);
         
         outb(1,PTR2USHORT(&ha->plx->ldoor_reg));
 
         retries = INIT_RETRIES;
         JIFFYWAIT(2);
-        while (dp6c_ptr->u.ic.S_Status != 0xfe) {
+        while (readb(&dp6c_ptr->u.ic.S_Status) != 0xfe) {
             if (--retries == 0) {
                 printk("GDT-PCI: Initialization error\n");
+		gdth_munmap(ha->brd);
                 return 0;
             }
             udelay(1000);
         }
-        dp6c_ptr->u.ic.S_Status = 0;
+        writeb(0, &dp6c_ptr->u.ic.S_Status);
 
     } else {                                            /* MPR */
-        if (ha->brd > 0xfffff) {                        /* NOT below 1MB */
-#if LINUX_VERSION_CODE >= 0x010300
-            /* Linux 1.3.X allow to remap physical pages adresses greater
-               than the highest physical memory address to kernel virtual
-               pages using vremap()/vfree(), Linux 1.2.X doesn't */
-            TRACE2(("init_pci_mpr() dpmem %lx irq %d\n",ha->brd,ha->irq));
-            ha->brd = (ulong)vremap(ha->brd, sizeof(gdt6m_dpram_str));
-            if (ha->brd == 0L) {
-                printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
-                return 0;
-            }
-            TRACE2(("init_pci_mpr() remapped dpmem %lx\n",ha->brd));
-            remapped = TRUE;
-#else
-            printk("GDT-PCI: Initialization error (DPMEM not below 1MB)\n");
-            return 0;
-#endif
-        }
+	TRACE2(("init_pci_mpr() dpmem %lx irq %d\n",pcistr->dpmem,ha->irq));
+	ha->brd = gdth_mmap(pcistr->dpmem, sizeof(gdt6m_dpram_str));
+	if (ha->brd == NULL) {
+	    printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
+	    return 0;
+	}
 
         dp6m_ptr = (gdt6m_dpram_str *)ha->brd;
         /* reset interface area */
-        memset((char *)&dp6m_ptr->u,0,sizeof(dp6m_ptr->u));
-        if (*(ulong *)&dp6m_ptr->u != 0) {
+        memset_io((char *)&dp6m_ptr->u,0,sizeof(dp6m_ptr->u));
+        if (readl(&dp6m_ptr->u) != 0) {
             printk("GDT-PCI: Initialization error (DPMEM write error)\n");
-#if LINUX_VERSION_CODE >= 0x010300
-            if (remapped)
-                vfree((void *)ha->brd);
-#endif
+	    gdth_munmap(ha->brd);
             return 0;
         }
         
         /* disable board interrupts, deinit services */
-        dp6m_ptr->i960r.edoor_en_reg |= 4;
-        dp6m_ptr->i960r.edoor_reg = 0xff;
-        dp6m_ptr->u.ic.S_Status   = 0x00;
-        dp6m_ptr->u.ic.Cmd_Index  = 0x00;
-
-        dp6m_ptr->u.ic.S_Info[0]  = ha->brd;
-        dp6m_ptr->u.ic.S_Cmd_Indx = 0xff;
-        dp6m_ptr->i960r.ldoor_reg = 1;
+        writeb(readb(&dp6m_ptr->i960r.edoor_en_reg) | 4,
+	       &dp6m_ptr->i960r.edoor_en_reg);
+        writeb(0xff, &dp6m_ptr->i960r.edoor_reg);
+        writeb(0x00, &dp6m_ptr->u.ic.S_Status);
+        writeb(0x00, &dp6m_ptr->u.ic.Cmd_Index);
+
+        writel(pcistr->dpmem, &dp6m_ptr->u.ic.S_Info[0]);
+        writeb(0xff, &dp6m_ptr->u.ic.S_Cmd_Indx);
+        writeb(1, &dp6m_ptr->i960r.ldoor_reg);
         retries = INIT_RETRIES;
         JIFFYWAIT(2);
-        while (dp6m_ptr->u.ic.S_Status != 0xff) {
+        while (readb(&dp6m_ptr->u.ic.S_Status) != 0xff) {
             if (--retries == 0) {
                 printk("GDT-PCI: Initialization error (DEINIT failed)\n");
-#if LINUX_VERSION_CODE >= 0x010300
-                if (remapped)
-                    vfree((void *)ha->brd);
-#endif
+		gdth_munmap(ha->brd);
                 return 0;
             }
             udelay(1000);
         }
-        prot_ver = (unchar)dp6m_ptr->u.ic.S_Info[0];
-        dp6m_ptr->u.ic.S_Status = 0;
+        prot_ver = (unchar)readl(&dp6m_ptr->u.ic.S_Info[0]);
+        writeb(0, &dp6m_ptr->u.ic.S_Status);
         if (prot_ver != PROTOCOL_VERSION) {
             printk("GDT-PCI: Illegal protocol version\n");
-#if LINUX_VERSION_CODE >= 0x010300
-            if (remapped)
-                vfree((void *)ha->brd);
-#endif
+	    gdth_munmap(ha->brd);
             return 0;
         }
 
@@ -790,26 +874,23 @@
         ha->ic_all_size = sizeof(dp6m_ptr->u);
         
         /* special command to controller BIOS */
-        dp6m_ptr->u.ic.S_Info[0]  = 0x00;
-        dp6m_ptr->u.ic.S_Info[1]  = 0x00;
-        dp6m_ptr->u.ic.S_Info[2]  = 0x01;
-        dp6m_ptr->u.ic.S_Info[3]  = 0x00;
-        dp6m_ptr->u.ic.S_Cmd_Indx = 0xfe;
-        dp6m_ptr->i960r.ldoor_reg = 1;
+        writel(0x00, &dp6m_ptr->u.ic.S_Info[0]);
+        writel(0x00, &dp6m_ptr->u.ic.S_Info[1]);
+        writel(0x01, &dp6m_ptr->u.ic.S_Info[2]);
+        writel(0x00, &dp6m_ptr->u.ic.S_Info[3]);
+        writeb(0xfe, &dp6m_ptr->u.ic.S_Cmd_Indx);
+        writeb(1, &dp6m_ptr->i960r.ldoor_reg);
         retries = INIT_RETRIES;
         JIFFYWAIT(2);
-        while (dp6m_ptr->u.ic.S_Status != 0xfe) {
+        while (readb(&dp6m_ptr->u.ic.S_Status) != 0xfe) {
             if (--retries == 0) {
                 printk("GDT-PCI: Initialization error\n");
-#if LINUX_VERSION_CODE >= 0x010300
-                if (remapped)
-                    vfree((void *)ha->brd);
-#endif
+		gdth_munmap(ha->brd);
                 return 0;
             }
             udelay(1000);
         }
-        dp6m_ptr->u.ic.S_Status = 0;
+        writeb(0, &dp6m_ptr->u.ic.S_Status);
     }
 
     return 1;
@@ -822,7 +903,6 @@
 {
     gdth_ha_str *ha;
     ulong flags;
-    ushort addr;
     gdt2_dpram_str *dp2_ptr;
     gdt6_dpram_str *dp6_ptr;
     gdt6m_dpram_str *dp6m_ptr;
@@ -834,27 +914,27 @@
     cli();
 
     if (ha->type == GDT_EISA) {
-        addr = (ushort)ha->brd;
-        outb(0xff,addr+EDOORREG);
-        outb(0xff,addr+EDENABREG);
-        outb(0x01,addr+EINTENABREG);
+        outb(0xff, ha->bmic + EDOORREG);
+        outb(0xff, ha->bmic + EDENABREG);
+        outb(0x01, ha->bmic + EINTENABREG);
     } else if (ha->type == GDT_ISA) {
         dp2_ptr = (gdt2_dpram_str *)ha->brd;
-        dp2_ptr->io.irqdel = 1;
-        dp2_ptr->u.ic.Cmd_Index = 0;
-        dp2_ptr->io.irqen = 1;
+        writeb(1, &dp2_ptr->io.irqdel);
+        writeb(0, &dp2_ptr->u.ic.Cmd_Index);
+        writeb(1, &dp2_ptr->io.irqen);
     } else if (ha->type == GDT_PCI) {
         dp6_ptr = (gdt6_dpram_str *)ha->brd;
-        dp6_ptr->io.irqdel = 1;
-        dp6_ptr->u.ic.Cmd_Index = 0;
-        dp6_ptr->io.irqen = 1;
+        writeb(1, &dp6_ptr->io.irqdel);
+        writeb(0, &dp6_ptr->u.ic.Cmd_Index);
+        writeb(1, &dp6_ptr->io.irqen);
     } else if (ha->type == GDT_PCINEW) {
-        outb(0xff,PTR2USHORT(&ha->plx->edoor_reg));
-        outb(0x03,PTR2USHORT(&ha->plx->control1));
+        outb(0xff, PTR2USHORT(&ha->plx->edoor_reg));
+        outb(0x03, PTR2USHORT(&ha->plx->control1));
     } else if (ha->type == GDT_PCIMPR) {
         dp6m_ptr = (gdt6m_dpram_str *)ha->brd;
-        dp6m_ptr->i960r.edoor_reg = 0xff;
-        dp6m_ptr->i960r.edoor_en_reg &= ~4;
+        writeb(0xff, &dp6m_ptr->i960r.edoor_reg);
+        writeb(readb(&dp6m_ptr->i960r.edoor_en_reg) & ~4,
+	       &dp6m_ptr->i960r.edoor_en_reg);
     }
     restore_flags(flags);
 }
@@ -874,15 +954,15 @@
         if (ha->irq != (unchar)irq)             /* check IRQ */
             continue;
         if (ha->type == GDT_EISA)
-            *pIStatus = inb((ushort)ha->brd+EDOORREG);
+            *pIStatus = inb((ushort)ha->bmic + EDOORREG);
         else if (ha->type == GDT_ISA)
-            *pIStatus = ((gdt2_dpram_str *)ha->brd)->u.ic.Cmd_Index;
+            *pIStatus = readb(&((gdt2_dpram_str *)ha->brd)->u.ic.Cmd_Index);
         else if (ha->type == GDT_PCI)
-            *pIStatus = ((gdt6_dpram_str *)ha->brd)->u.ic.Cmd_Index;
+            *pIStatus = readb(&((gdt6_dpram_str *)ha->brd)->u.ic.Cmd_Index);
         else if (ha->type == GDT_PCINEW) 
             *pIStatus = inb(PTR2USHORT(&ha->plx->edoor_reg));
         else if (ha->type == GDT_PCIMPR)
-            *pIStatus = ((gdt6m_dpram_str *)ha->brd)->i960r.edoor_reg;
+            *pIStatus = readb(&((gdt6m_dpram_str *)ha->brd)->i960r.edoor_reg);
    
         if (*pIStatus)                                  
             return i;                           /* board found */
@@ -900,15 +980,15 @@
     
     ha = HADATA(gdth_ctr_tab[hanum]);
     if (ha->type == GDT_EISA)
-        gdtsema0 = (int)inb((ushort)ha->brd+SEMA0REG);
+        gdtsema0 = (int)inb(ha->bmic + SEMA0REG);
     else if (ha->type == GDT_ISA)
-        gdtsema0 = (int)((gdt2_dpram_str *)ha->brd)->u.ic.Sema0;
+        gdtsema0 = (int)readb(&((gdt2_dpram_str *)ha->brd)->u.ic.Sema0);
     else if (ha->type == GDT_PCI)
-        gdtsema0 = (int)((gdt6_dpram_str *)ha->brd)->u.ic.Sema0;
+        gdtsema0 = (int)readb(&((gdt6_dpram_str *)ha->brd)->u.ic.Sema0);
     else if (ha->type == GDT_PCINEW) 
         gdtsema0 = (int)inb(PTR2USHORT(&ha->plx->sema0_reg));
     else if (ha->type == GDT_PCIMPR)
-        gdtsema0 = (int)((gdt6m_dpram_str *)ha->brd)->i960r.sema0_reg;
+        gdtsema0 = (int)readb(&((gdt6m_dpram_str *)ha->brd)->i960r.sema0_reg);
 
     return (gdtsema0 & 1);
 }
@@ -942,15 +1022,15 @@
 
     ha = HADATA(gdth_ctr_tab[hanum]);
     if (ha->type == GDT_EISA)
-        outb(1,(ushort)ha->brd+SEMA0REG);
+        outb(1, ha->bmic + SEMA0REG);
     else if (ha->type == GDT_ISA)
-        ((gdt2_dpram_str *)ha->brd)->u.ic.Sema0 = 1;
+        writeb(1, &((gdt2_dpram_str *)ha->brd)->u.ic.Sema0);
     else if (ha->type == GDT_PCI)
-        ((gdt6_dpram_str *)ha->brd)->u.ic.Sema0 = 1;
+        writeb(1, &((gdt6_dpram_str *)ha->brd)->u.ic.Sema0);
     else if (ha->type == GDT_PCINEW)  
-        outb(1,PTR2USHORT(&ha->plx->sema0_reg));
+        outb(1, PTR2USHORT(&ha->plx->sema0_reg));
     else if (ha->type == GDT_PCIMPR)
-        ((gdt6m_dpram_str *)ha->brd)->i960r.sema0_reg = 1;
+        writeb(1, &((gdt6m_dpram_str *)ha->brd)->i960r.sema0_reg);
     
 }
 
@@ -986,32 +1066,32 @@
     /* set offset and service, copy command to DPMEM */
     if (ha->type == GDT_ISA) {
         dp2_ptr = (gdt2_dpram_str *)ha->brd;
-        dp2_ptr->u.ic.comm_queue[cmd_no].offset =
-            dp_offset + DPMEM_COMMAND_OFFSET;
-        dp2_ptr->u.ic.comm_queue[cmd_no].serv_id =
-            (ushort)cmd_ptr->Service;
-        memcpy(&dp2_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
+        writew(dp_offset + DPMEM_COMMAND_OFFSET, 
+	       &dp2_ptr->u.ic.comm_queue[cmd_no].offset);
+        writew((ushort)cmd_ptr->Service, 
+	       &dp2_ptr->u.ic.comm_queue[cmd_no].serv_id);
+	memcpy_toio(&dp2_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
     } else if (ha->type == GDT_PCI) {
         dp6_ptr = (gdt6_dpram_str *)ha->brd;
-        dp6_ptr->u.ic.comm_queue[cmd_no].offset =
-            dp_offset + DPMEM_COMMAND_OFFSET;
-        dp6_ptr->u.ic.comm_queue[cmd_no].serv_id =
-            (ushort)cmd_ptr->Service;
-        memcpy(&dp6_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
+        writew(dp_offset + DPMEM_COMMAND_OFFSET, 
+	       &dp6_ptr->u.ic.comm_queue[cmd_no].offset);
+        writew((ushort)cmd_ptr->Service, 
+	       &dp6_ptr->u.ic.comm_queue[cmd_no].serv_id);
+        memcpy_toio(&dp6_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
     } else if (ha->type == GDT_PCINEW) {
         dp6c_ptr = (gdt6c_dpram_str *)ha->brd;
-        dp6c_ptr->u.ic.comm_queue[cmd_no].offset =
-            dp_offset + DPMEM_COMMAND_OFFSET;
-        dp6c_ptr->u.ic.comm_queue[cmd_no].serv_id =
-            (ushort)cmd_ptr->Service;
-        memcpy(&dp6c_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
+        writew(dp_offset + DPMEM_COMMAND_OFFSET, 
+	       &dp6c_ptr->u.ic.comm_queue[cmd_no].offset);
+	writew((ushort)cmd_ptr->Service, 
+	       &dp6c_ptr->u.ic.comm_queue[cmd_no].serv_id);
+	memcpy_toio(&dp6c_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
     } else if (ha->type == GDT_PCIMPR) {
         dp6m_ptr = (gdt6m_dpram_str *)ha->brd;
-        dp6m_ptr->u.ic.comm_queue[cmd_no].offset =
-            dp_offset + DPMEM_COMMAND_OFFSET;
-        dp6m_ptr->u.ic.comm_queue[cmd_no].serv_id =
-            (ushort)cmd_ptr->Service;
-        memcpy(&dp6m_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
+        writew(dp_offset + DPMEM_COMMAND_OFFSET, 
+	       &dp6m_ptr->u.ic.comm_queue[cmd_no].offset);
+        writew((ushort)cmd_ptr->Service, 
+	       &dp6m_ptr->u.ic.comm_queue[cmd_no].serv_id);
+        memcpy_toio(&dp6m_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
     }
 }
 
@@ -1039,17 +1119,17 @@
         ha->pccb->Service |= 0x80;
 
     if (ha->type == GDT_EISA) {
-        outb(ha->pccb->Service,(ushort)ha->brd+LDOORREG);
+        outb(ha->pccb->Service, ha->bmic + LDOORREG);
         if (ha->pccb->OpCode == GDT_INIT)               /* store DMA buffer */
-            outl((ulong)ha->pccb,(ushort)ha->brd+MAILBOXREG);
+            outl((ulong)ha->pccb, ha->bmic + MAILBOXREG);
     } else if (ha->type == GDT_ISA)
-        ((gdt2_dpram_str *)ha->brd)->io.event = 0;
+        writeb(0, &((gdt2_dpram_str *)ha->brd)->io.event);
     else if (ha->type == GDT_PCI)
-        ((gdt6_dpram_str *)ha->brd)->io.event = 0;
+        writeb(0, &((gdt6_dpram_str *)ha->brd)->io.event);
     else if (ha->type == GDT_PCINEW) 
-        outb(1,PTR2USHORT(&ha->plx->ldoor_reg));
+        outb(1, PTR2USHORT(&ha->plx->ldoor_reg));
     else if (ha->type == GDT_PCIMPR)
-        ((gdt6m_dpram_str *)ha->brd)->i960r.ldoor_reg = 1;
+        writeb(1, &((gdt6m_dpram_str *)ha->brd)->i960r.ldoor_reg);
 }
 
     
@@ -1115,7 +1195,7 @@
                 cmd_ptr->u.ioctl.subfunc = p1;
                 cmd_ptr->u.ioctl.channel = p2;
                 cmd_ptr->u.ioctl.param_size = (ushort)p3;
-                cmd_ptr->u.ioctl.p_param = (ulong)ha->pscratch;
+                cmd_ptr->u.ioctl.p_param = virt_to_bus(ha->pscratch);
             } else {
                 cmd_ptr->u.cache.DeviceNo = (ushort)p1;
                 cmd_ptr->u.cache.BlockNo  = p2;
@@ -1147,7 +1227,7 @@
 
 /* search for devices */
 
-static int gdth_search_drives(int hanum,int firsttime)
+static int gdth_search_drives(int hanum)
 {
     register gdth_ha_str *ha;
     ushort cdev_cnt,i;
@@ -1156,7 +1236,7 @@
     ulong bus_no;
     gdth_getch_str *chn;
     
-    TRACE(("gdth_search_drives() hanum %d flag %d\n",hanum,firsttime));
+    TRACE(("gdth_search_drives() hanum %d\n",hanum));
     ha = HADATA(gdth_ctr_tab[hanum]);
 
     /* initialize controller services, at first: screen service */
@@ -1176,57 +1256,51 @@
     TRACE2(("gdth_search_drives(): CACHESERVICE initialized\n"));
     cdev_cnt = (ushort)ha->info;
 
-    if (firsttime) {
-        /* mount all cache devices */
-        if (!gdth_internal_cmd(hanum,CACHESERVICE,GDT_MOUNT,0xffff,1,0)) {
-            printk("GDT: Initialization error cache service (code %d)\n",
-                   ha->status);
-            return 0;
-        }
-        TRACE2(("gdth_search_drives(): mountall CACHESERVICE OK\n"));
+    /* 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;
-
-        /* detect number of SCSI buses */
-        chn = (gdth_getch_str *)DMADATA(gdth_ctr_tab[hanum]);
-        for (bus_no=0; bus_no<MAXBUS; ++bus_no) {
-            chn->channel_no = bus_no;
-            if (!gdth_internal_cmd(hanum,CACHESERVICE,GDT_IOCTL,
-                                   SCSI_CHAN_CNT | L_CTRL_PATTERN,
-                                   IO_CHANNEL | INVALID_CHANNEL,
-                                   sizeof(gdth_getch_str))) {
-                if (bus_no == 0) {
-                    printk("GDT: Error detecting SCSI channel count (0x%x)\n",
-                           ha->status);
-                    return 0;
-                }
-                break;
-            }
-            if (chn->siop_id < MAXID)
-                ha->id[bus_no][chn->siop_id].type = SIOP_DTYP;
-        }       
-        ha->bus_cnt = (unchar)bus_no;
-        TRACE2(("gdth_search_drives() %d SCSI channels\n",ha->bus_cnt));
-
-        /* read cache configuration */
-        if (!gdth_internal_cmd(hanum,CACHESERVICE,GDT_IOCTL,CACHE_INFO,
-                               INVALID_CHANNEL,sizeof(gdth_cinfo_str))) {
-            printk("GDT: Initialization error cache service (code %d)\n",
-                   ha->status);
-            return 0;
-        }
-        ha->cpar = ((gdth_cinfo_str *)DMADATA(gdth_ctr_tab[hanum]))->cpar;
-        TRACE2(("gdth_search_drives() cinfo: vs %lx sta %d str %d dw %d b %d\n",
-                ha->cpar.version,ha->cpar.state,ha->cpar.strategy,
-                ha->cpar.write_back,ha->cpar.block_size));
+    /* 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;
+
+    /* detect number of SCSI buses */
+    chn = (gdth_getch_str *)DMADATA(gdth_ctr_tab[hanum]);
+    for (bus_no=0; bus_no<MAXBUS; ++bus_no) {
+	chn->channel_no = bus_no;
+	if (!gdth_internal_cmd(hanum,CACHESERVICE,GDT_IOCTL,
+			       SCSI_CHAN_CNT | L_CTRL_PATTERN,
+			       IO_CHANNEL | INVALID_CHANNEL,
+			       sizeof(gdth_getch_str))) {
+	    if (bus_no == 0) {
+		printk("GDT: Error detecting SCSI channel count (0x%x)\n",
+		       ha->status);
+		return 0;
+	    }
+	    break;
+	}
+	if (chn->siop_id < MAXID)
+	    ha->id[bus_no][chn->siop_id].type = SIOP_DTYP;
+    }       
+    ha->bus_cnt = (unchar)bus_no;
+    TRACE2(("gdth_search_drives() %d SCSI channels\n",ha->bus_cnt));
+
+    /* read cache configuration */
+    if (!gdth_internal_cmd(hanum,CACHESERVICE,GDT_IOCTL,CACHE_INFO,
+			   INVALID_CHANNEL,sizeof(gdth_cinfo_str))) {
+	printk("GDT: Initialization error cache service (code %d)\n",
+	       ha->status);
+	return 0;
+    }
+    ha->cpar = ((gdth_cinfo_str *)DMADATA(gdth_ctr_tab[hanum]))->cpar;
+    TRACE2(("gdth_search_drives() cinfo: vs %lx sta %d str %d dw %d b %d\n",
+	    ha->cpar.version,ha->cpar.state,ha->cpar.strategy,
+	    ha->cpar.write_back,ha->cpar.block_size));
 
     /* initialize raw service */
     if (!gdth_internal_cmd(hanum,SCSIRAWSERVICE,GDT_INIT,0,0,0)) {
@@ -1260,10 +1334,6 @@
         }
     }
 
-    /* if it is not the first scan, we are ready */
-    if (!firsttime)
-        return 1;
-
     /* scanning for raw devices */
     for (b=0; b<ha->bus_cnt; ++b) {
         for (t=0; t<MAXID; ++t) {
@@ -1301,27 +1371,33 @@
             ha->id[b][t].hostdrive = i;
 
             /* evaluate mapping (sectors per head, heads per cylinder) */
-            ha->id[b][t].size &= ~SECS32;
-            drv_cyls = ha->id[b][t].size /HEADS/SECS;
-            if (drv_cyls <= MAXCYLS) {
-                drv_hds = HEADS;
-                drv_secs= SECS;
-            } else {                            /* too high for 64*32 */
-                drv_cyls = ha->id[b][t].size /MEDHEADS/MEDSECS;
-                if (drv_cyls <= MAXCYLS) {
-                    drv_hds = MEDHEADS;
-                    drv_secs= MEDSECS;
-                } else {                        /* too high for 127*63 */
-                    drv_cyls = ha->id[b][t].size /BIGHEADS/BIGSECS;
-                    drv_hds = BIGHEADS;
-                    drv_secs= BIGSECS;
-                }
-            }
+	    ha->id[b][t].size &= ~SECS32;
+	    if (ha->info2 == 0) {
+		drv_cyls = ha->id[b][t].size /HEADS/SECS;
+		if (drv_cyls <= MAXCYLS) {
+		    drv_hds = HEADS;
+		    drv_secs= SECS;
+		} else {                            /* too high for 64*32 */
+		    drv_cyls = ha->id[b][t].size /MEDHEADS/MEDSECS;
+		    if (drv_cyls <= MAXCYLS) {
+			drv_hds = MEDHEADS;
+			drv_secs= MEDSECS;
+		    } else {                        /* too high for 127*63 */
+			drv_cyls = ha->id[b][t].size /BIGHEADS/BIGSECS;
+			drv_hds = BIGHEADS;
+			drv_secs= BIGSECS;
+		    }
+		}
+            } else {
+		drv_hds = ha->info2 & 0xff;
+		drv_secs = (ha->info2 >> 8) & 0xff;
+		drv_cyls = ha->id[b][t].size /drv_hds/drv_secs;
+	    }
             ha->id[b][t].heads = (unchar)drv_hds;
             ha->id[b][t].secs  = (unchar)drv_secs;
             /* round size */
             ha->id[b][t].size  = drv_cyls * drv_hds * drv_secs;
-            TRACE(("gdth_search_dr() cdr. %d size %ld hds %ld scs %ld\n",
+            TRACE2(("gdth_search_dr() cdr. %d size %ld hds %ld scs %ld\n",
                    i,ha->id[b][t].size,drv_hds,drv_secs));
             
             /* get informations about device */
@@ -1356,7 +1432,7 @@
     ha = HADATA(gdth_ctr_tab[hanum]);
     scp->SCp.this_residual = (int)priority;
     gdth_update_timeout(scp, scp->timeout * 6);
-#if LINUX_VERSION_CODE >= 0x010400
+#if LINUX_VERSION_CODE >= 0x020000
     b = scp->channel;
 #else
     b = NUMDATA(nscp->host)->busnum;
@@ -1418,7 +1494,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;
-#if LINUX_VERSION_CODE >= 0x010400
+#if LINUX_VERSION_CODE >= 0x020000
         b = nscp->channel;
 #else
         b = NUMDATA(nscp->host)->busnum;
@@ -1709,7 +1785,7 @@
             cmdp->u.cache.DestAddr= -1UL;
             sl = (struct scatterlist *)scp->request_buffer;
             for (i=0; i<scp->use_sg; ++i,++sl) {
-                cmdp->u.cache.sg_lst[i].sg_ptr = (ulong)sl->address;
+                cmdp->u.cache.sg_lst[i].sg_ptr = virt_to_bus(sl->address);
                 cmdp->u.cache.sg_lst[i].sg_len = (ulong)sl->length;
             }
             cmdp->u.cache.sg_canz = (ulong)i;
@@ -1726,11 +1802,11 @@
             if (ha->cache_feat & SCATTER_GATHER) {
                 cmdp->u.cache.DestAddr = -1UL;
                 cmdp->u.cache.sg_canz = 1;
-                cmdp->u.cache.sg_lst[0].sg_ptr = (ulong)scp->request_buffer;
+                cmdp->u.cache.sg_lst[0].sg_ptr = virt_to_bus(scp->request_buffer);
                 cmdp->u.cache.sg_lst[0].sg_len = scp->request_bufflen;
                 cmdp->u.cache.sg_lst[1].sg_len = 0;
             } else {
-                cmdp->u.cache.DestAddr  = (ulong)scp->request_buffer;
+                cmdp->u.cache.DestAddr  = virt_to_bus(scp->request_buffer);
                 cmdp->u.cache.sg_canz= 0;
             }
         }
@@ -1806,7 +1882,7 @@
     cmdp->u.raw.link_p     = NULL;
     cmdp->u.raw.sdlen      = scp->request_bufflen;
     cmdp->u.raw.sense_len  = 16;
-    cmdp->u.raw.sense_data = (ulong)scp->sense_buffer;
+    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;
     memcpy(cmdp->u.raw.cmd,scp->cmnd,12);
@@ -1815,7 +1891,7 @@
         cmdp->u.raw.sdata  = -1UL;
         sl = (struct scatterlist *)scp->request_buffer;
         for (i=0; i<scp->use_sg; ++i,++sl) {
-            cmdp->u.raw.sg_lst[i].sg_ptr = (ulong)sl->address;
+            cmdp->u.raw.sg_lst[i].sg_ptr = virt_to_bus(sl->address);
             cmdp->u.raw.sg_lst[i].sg_len = (ulong)sl->length;
         }
         cmdp->u.raw.sg_ranz = (ulong)i;
@@ -1832,11 +1908,11 @@
         if (ha->raw_feat & SCATTER_GATHER) {
             cmdp->u.raw.sdata  = -1UL;
             cmdp->u.raw.sg_ranz= 1;
-            cmdp->u.raw.sg_lst[0].sg_ptr = (ulong)scp->request_buffer;
+            cmdp->u.raw.sg_lst[0].sg_ptr = virt_to_bus(scp->request_buffer);
             cmdp->u.raw.sg_lst[0].sg_len = scp->request_bufflen;
             cmdp->u.raw.sg_lst[1].sg_len = 0;
         } else {
-            cmdp->u.raw.sdata  = (ulong)scp->request_buffer;
+            cmdp->u.raw.sdata  = virt_to_bus(scp->request_buffer);
             cmdp->u.raw.sg_ranz= 0;
         }
     }
@@ -2091,49 +2167,55 @@
     if (ha->type == GDT_EISA) {
         if (IStatus & 0x80) {                   /* error flag */
             IStatus &= ~0x80;
-            CmdStatus = inw((ushort)ha->brd+MAILBOXREG+8);
+            CmdStatus = inw(ha->bmic + MAILBOXREG+8);
             TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,CmdStatus));
             if (IStatus == ASYNCINDEX) {        /* async. event ? */
-                Service = inw((ushort)ha->brd+MAILBOXREG+10);
-                InfoBytes2 = inl((ushort)ha->brd+MAILBOXREG+4);
+                Service = inw(ha->bmic + MAILBOXREG+10);
+                InfoBytes2 = inl(ha->bmic + MAILBOXREG+4);
             }
         } else                                  /* no error */
             CmdStatus = S_OK;
-        InfoBytes = inl((ushort)ha->brd+MAILBOXREG+12);
-        outb(0xff,(ushort)ha->brd+EDOORREG);    /* acknowledge interrupt */
-        outb(0x00,(ushort)ha->brd+SEMA1REG);    /* reset status semaphore */
+        InfoBytes = inl(ha->bmic + MAILBOXREG+12);
+	if (gdth_polling)			/* init. -> more info */
+	    InfoBytes2 = 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 = dp2_ptr->u.ic.Status;
+            CmdStatus = readw(&dp2_ptr->u.ic.Status);
             TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,CmdStatus));
             if (IStatus == ASYNCINDEX) {        /* async. event ? */
-                Service = dp2_ptr->u.ic.Service;
-                InfoBytes2 = dp2_ptr->u.ic.Info[1];
+                Service = readw(&dp2_ptr->u.ic.Service);
+                InfoBytes2 = readl(&dp2_ptr->u.ic.Info[1]);
             }
         } else                                  /* no error */
             CmdStatus = S_OK;
-        InfoBytes = dp2_ptr->u.ic.Info[0];
-        dp2_ptr->io.irqdel = 0xff;              /* acknowledge interrupt */
-        dp2_ptr->u.ic.Cmd_Index = 0;            /* reset command index */
-        dp2_ptr->io.Sema1  = 0;                 /* reset status semaphore */
+        InfoBytes = readl(&dp2_ptr->u.ic.Info[0]);
+	if (gdth_polling)			/* init. -> more info */
+	    InfoBytes2 = readl(&dp2_ptr->u.ic.Info[1]);
+        writeb(0xff, &dp2_ptr->io.irqdel);              /* acknowledge interrupt */
+        writeb(0, &dp2_ptr->u.ic.Cmd_Index);            /* reset command index */
+        writeb(0, &dp2_ptr->io.Sema1);                 /* reset status semaphore */
     } else if (ha->type == GDT_PCI) {
         dp6_ptr = (gdt6_dpram_str *)ha->brd;
         if (IStatus & 0x80) {                   /* error flag */
             IStatus &= ~0x80;
-            CmdStatus = dp6_ptr->u.ic.Status;
+            CmdStatus = readw(&dp6_ptr->u.ic.Status);
             TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,CmdStatus));
             if (IStatus == ASYNCINDEX) {        /* async. event ? */
-                Service = dp6_ptr->u.ic.Service;
-                InfoBytes2 = dp6_ptr->u.ic.Info[1];
+                Service = readw(&dp6_ptr->u.ic.Service);
+                InfoBytes2 = readl(&dp6_ptr->u.ic.Info[1]);
             }
         } else                                  /* no error */
             CmdStatus = S_OK;
-        InfoBytes = dp6_ptr->u.ic.Info[0];
-        dp6_ptr->io.irqdel = 0xff;              /* acknowledge interrupt */
-        dp6_ptr->u.ic.Cmd_Index = 0;            /* reset command index */
-        dp6_ptr->io.Sema1  = 0;                 /* reset status semaphore */
+        InfoBytes = readl(&dp6_ptr->u.ic.Info[0]);
+	if (gdth_polling)			/* init. -> more info */
+	    InfoBytes2 = readl(&dp6_ptr->u.ic.Info[1]);
+        writeb(0xff, &dp6_ptr->io.irqdel);              /* acknowledge interrupt */
+        writeb(0, &dp6_ptr->u.ic.Cmd_Index);            /* reset command index */
+        writeb(0, &dp6_ptr->io.Sema1);                 /* reset status semaphore */
     } else if (ha->type == GDT_PCINEW) {
         if (IStatus & 0x80) {                   /* error flag */
             IStatus &= ~0x80;
@@ -2147,23 +2229,27 @@
             CmdStatus = S_OK;
 
         InfoBytes = inl(PTR2USHORT(&ha->plx->info[0]));
-        outb(0xff,PTR2USHORT(&ha->plx->edoor_reg)); 
-        outb(0x00,PTR2USHORT(&ha->plx->sema1_reg)); 
+	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 = dp6m_ptr->i960r.status;
+            CmdStatus = readw(&dp6m_ptr->i960r.status);
             TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,CmdStatus));
             if (IStatus == ASYNCINDEX) {        /* async. event ? */
-                Service = dp6m_ptr->i960r.service;
-                InfoBytes2 = dp6m_ptr->i960r.info[1];
+                Service = readw(&dp6m_ptr->i960r.service);
+                InfoBytes2 = readl(&dp6m_ptr->i960r.info[1]);
             }
         } else                                  /* no error */
             CmdStatus = S_OK;
-        InfoBytes = dp6m_ptr->i960r.info[0];
-        dp6m_ptr->i960r.edoor_reg = 0xff;
-        dp6m_ptr->i960r.sema1_reg = 0;
+        InfoBytes = readl(&dp6m_ptr->i960r.info[0]);
+	if (gdth_polling)			/* init. -> more info */
+	    InfoBytes2 = readl(&dp6m_ptr->i960r.info[1]);
+        writeb(0xff, &dp6m_ptr->i960r.edoor_reg);
+        writeb(0, &dp6m_ptr->i960r.sema1_reg);
     } else {
         TRACE2(("gdth_interrupt() unknown controller type\n"));
         return;
@@ -2318,7 +2404,7 @@
                     dvr.eu.sync.status  = ha->status;
                     dvr.eu.sync.info    = ha->info;
                     dvr.eu.sync.hostdrive =
-#if LINUX_VERSION_CODE >= 0x010400
+#if LINUX_VERSION_CODE >= 0x020000
                         ha->id[scp->channel][scp->target].hostdrive;
 #else
                         ha->id[NUMDATA(scp->host)->busnum][scp->target].hostdrive;
@@ -2456,6 +2542,12 @@
         "GDT HA %u, CPU temperature critical",
 /*55*/  "\003\000\002"
         "GDT HA %u, CPU temperature OK",
+/*56*/  "\005\000\002\006\004"
+        "GDT HA %u, Host drive %lu created",
+/*57*/  "\005\000\002\006\002"
+        "GDT HA %u, Array Drive %u: expand restarted",
+/*58*/  "\005\000\002\006\002"
+        "GDT HA %u, Array Drive %u: expand stopped",
 };
 
 
@@ -2625,7 +2717,7 @@
         if (gdth_search_isa(isa_bios)) {        /* controller found */
             shp = scsi_register(shtp,sizeof(gdth_ext_str));
             ha = HADATA(shp);
-            if (!gdth_init_isa(isa_bios,ha,TRUE)) {
+            if (!gdth_init_isa(isa_bios,ha)) {
                 scsi_unregister(shp);
                 continue;
             }
@@ -2686,9 +2778,10 @@
             }
             restore_flags(flags);
 
-            if (!gdth_search_drives(hanum,TRUE)) {
+            if (!gdth_search_drives(hanum)) {
                 printk("GDT-ISA: Error during device scan\n");
                 --gdth_ctr_count;
+		--gdth_ctr_vcount;
                 save_flags(flags);
                 cli();
 #if LINUX_VERSION_CODE >= 0x010346 
@@ -2701,7 +2794,7 @@
                 continue;
             }
 
-#if LINUX_VERSION_CODE >= 0x010400
+#if LINUX_VERSION_CODE >= 0x020000
             shp->max_id      = 8;
             shp->max_lun     = 8;
             shp->max_channel = ha->bus_cnt - 1;
@@ -2733,7 +2826,7 @@
         if (gdth_search_eisa(eisa_slot)) {      /* controller found */
             shp = scsi_register(shtp,sizeof(gdth_ext_str));
             ha = HADATA(shp);
-            if (!gdth_init_eisa(eisa_slot,ha,TRUE)) {
+            if (!gdth_init_eisa(eisa_slot,ha)) {
                 scsi_unregister(shp);
                 continue;
             }
@@ -2783,9 +2876,10 @@
             }
             restore_flags(flags);
 
-            if (!gdth_search_drives(hanum,TRUE)) {
+            if (!gdth_search_drives(hanum)) {
                 printk("GDT-EISA: Error during device scan\n");
                 --gdth_ctr_count;
+		--gdth_ctr_vcount;
                 save_flags(flags);
                 cli();
 #if LINUX_VERSION_CODE >= 0x010346 
@@ -2798,7 +2892,7 @@
                 continue;
             }
 
-#if LINUX_VERSION_CODE >= 0x010400
+#if LINUX_VERSION_CODE >= 0x020000
             shp->max_id      = 8;
             shp->max_lun     = 8;
             shp->max_channel = ha->bus_cnt - 1;
@@ -2838,7 +2932,7 @@
                 break;                          /* next device_id */
             shp = scsi_register(shtp,sizeof(gdth_ext_str));
             ha = HADATA(shp);
-            if (!gdth_init_pci(&pcistr,ha,TRUE)) {
+            if (!gdth_init_pci(&pcistr,ha)) {
                 scsi_unregister(shp);
                 continue;
             }
@@ -2886,9 +2980,10 @@
             }
             restore_flags(flags);
 
-            if (!gdth_search_drives(hanum,TRUE)) {
+            if (!gdth_search_drives(hanum)) {
                 printk("GDT-PCI: Error during device scan\n");
                 --gdth_ctr_count;
+		--gdth_ctr_vcount;
                 save_flags(flags);
                 cli();
 #if LINUX_VERSION_CODE >= 0x010346 
@@ -2901,7 +2996,7 @@
                 continue;
             }
 
-#if LINUX_VERSION_CODE >= 0x010400
+#if LINUX_VERSION_CODE >= 0x020000
             shp->max_id      = 8;
             shp->max_lun     = 8;
             shp->max_channel = ha->bus_cnt - 1;
@@ -2929,14 +3024,17 @@
     }
 
     TRACE2(("gdth_detect() %d controller detected\n",gdth_ctr_count));
-
+    if (gdth_ctr_count > 0) {
 #ifdef GDTH_STATISTICS
-    TRACE2(("gdth_detect(): Initializing timer !\n"));
-    timer_table[GDTH_TIMER].fn = gdth_timeout;
-    timer_table[GDTH_TIMER].expires = jiffies + HZ;
-    timer_active |= 1<<GDTH_TIMER;
+	TRACE2(("gdth_detect(): Initializing timer !\n"));
+	timer_table[GDTH_TIMER].fn = gdth_timeout;
+	timer_table[GDTH_TIMER].expires = jiffies + HZ;
+	timer_active |= 1<<GDTH_TIMER;
 #endif
-
+#if LINUX_VERSION_CODE >= 0x020100
+	register_reboot_notifier(&gdth_notifier);
+#endif
+    }
     gdth_polling = FALSE;
     return gdth_ctr_vcount;
 }
@@ -3099,23 +3197,20 @@
 int gdth_bios_param(Disk *disk,int dev,int *ip)
 #endif
 {
-    TRACE2(("gdth_bios_param()\n"));
+    unchar b, t;
+    int hanum;
+    gdth_ha_str *ha;
+
+    hanum = NUMDATA(disk->device->host)->hanum;
+    b = disk->device->channel;
+    t = disk->device->id;
+    TRACE2(("gdth_bios_param() ha %d bus %d target %d\n", hanum, b, t));
+    ha = HADATA(gdth_ctr_tab[hanum]);
+
+    ip[0] = ha->id[b][t].heads;
+    ip[1] = ha->id[b][t].secs;
+    ip[2] = disk->capacity / ip[0] / ip[1];
 
-    ip[2] = disk->capacity / HEADS / SECS;
-    if (ip[2] <= MAXCYLS) {
-        ip[0] = HEADS;
-        ip[1] = SECS;
-    } else {
-        ip[2] = disk->capacity / MEDHEADS / MEDSECS;
-        if (ip[2] <= MAXCYLS) {
-            ip[0] = MEDHEADS;
-            ip[1] = MEDSECS;
-        } else {
-            ip[2] = disk->capacity / BIGHEADS / BIGSECS;
-            ip[0] = BIGHEADS;
-            ip[1] = BIGSECS;
-        }
-    }
     TRACE2(("gdth_bios_param(): %d heads, %d secs, %d cyls\n",
             ip[0],ip[1],ip[2]));
     return 0;
@@ -3167,7 +3262,11 @@
 
 
 /* shutdown routine */
-void gdth_halt()
+#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, i, j;
     gdth_ha_str     *ha;
@@ -3176,9 +3275,14 @@
     gdth_cmd_str    gdtcmd;
     char            cmnd[12];
 
+#if LINUX_VERSION_CODE >= 0x020100
+    TRACE2(("gdth_halt() event %d\n",event));
+    if (event != SYS_RESTART && event != SYS_HALT && event != SYS_POWER_OFF)
+	return NOTIFY_DONE;
+#else
     TRACE2(("gdth_halt()\n"));
+#endif
     printk("GDT: Flushing all host drives .. ");
-
     for (hanum = 0; hanum < gdth_ctr_count; ++hanum) {
         ha = HADATA(gdth_ctr_tab[hanum]);
         memset(&sdev,0,sizeof(Scsi_Device));
@@ -3232,6 +3336,14 @@
         }
     }
     printk("Done.\n");
+
+#ifdef GDTH_STATISTICS
+    timer_active &= ~(1<<GDTH_TIMER);
+#endif
+#if LINUX_VERSION_CODE >= 0x020100
+    unregister_reboot_notifier(&gdth_notifier);
+    return NOTIFY_OK;
+#endif
 }
 
 
diff -urN linux-2.0.31/drivers/scsi/gdth.h linux-2.0.31-gdth/drivers/scsi/gdth.h
--- linux-2.0.31/drivers/scsi/gdth.h	Fri Oct 31 13:20:12 1997
+++ linux-2.0.31-gdth/drivers/scsi/gdth.h	Fri Oct 31 13:36:36 1997
@@ -10,7 +10,7 @@
  *
  * <achim@vortex.de>
  *
- * $Id: gdth.h,v 1.7 1997/03/20 16:01:59 achim Exp $
+ * $Id: gdth.h,v 1.9 1997/10/31 10:48:56 achim Exp $
  */
 
 #include <linux/version.h>
@@ -29,9 +29,9 @@
 /* defines, macros */
 
 /* driver version */
-#define GDTH_VERSION_STR        "1.00"
+#define GDTH_VERSION_STR        "1.02"
 #define GDTH_VERSION            1
-#define GDTH_SUBVERSION         0
+#define GDTH_SUBVERSION         1
 
 /* protocol version */
 #define PROTOCOL_VERSION        1
@@ -550,9 +550,10 @@
     unchar              bus_cnt;                /* SCSI bus count */
     unchar              type;                   /* controller class */
     ushort              raw_feat;               /* feat. raw service (s/g,..) */
-    ushort              cache_feat;             /* feat. cache serv. (s/g,..) */
     ulong               stype;                  /* controller subtype */
-    ulong               brd;                    /* BMIC/DPRAM address */
+    ushort              cache_feat;             /* feat. cache serv. (s/g,..) */
+    ushort		bmic;			/* BMIC address (EISA) */
+    void               	*brd;	                /* DPRAM address */
     ulong               brd_phys;               /* slot number/BIOS address */
     gdt6c_plx_regs      *plx;                   /* PLX regs (new PCI contr.) */
     gdth_cmd_str        *pccb;                  /* address command structure */
diff -urN linux-2.0.31/drivers/scsi/gdth_proc.c linux-2.0.31-gdth/drivers/scsi/gdth_proc.c
--- linux-2.0.31/drivers/scsi/gdth_proc.c	Fri Oct 31 13:20:12 1997
+++ linux-2.0.31-gdth/drivers/scsi/gdth_proc.c	Fri Oct 31 13:36:36 1997
@@ -1,5 +1,5 @@
 /* gdth_proc.c 
- * $Id: gdth_proc.c,v 1.4 1997/02/25 13:33:47 achim Exp $
+ * $Id: gdth_proc.c,v 1.6 1997/10/31 10:36:24 achim Exp $
  */
 
 #include "gdth_ioctl.h"
@@ -170,7 +170,7 @@
         gdtcmd.BoardNode = LOCALBOARD;
         gdtcmd.Service = CACHESERVICE;
         gdtcmd.OpCode = GDT_IOCTL;
-        gdtcmd.u.ioctl.p_param = (ulong)pcpar;
+        gdtcmd.u.ioctl.p_param = virt_to_bus(pcpar);
         gdtcmd.u.ioctl.param_size = sizeof(gdth_cpar_str);
         gdtcmd.u.ioctl.subfunc = CACHE_CONFIG;
         gdtcmd.u.ioctl.channel = INVALID_CHANNEL;
@@ -257,7 +257,7 @@
         piord->size = sizeof(gdth_iord_str) + add_size;
         if (add_size > 0) {
             memcpy(piord->iu.general.data, piowr->iu.general.data, add_size);
-            *ppadd = (ulong)piord->iu.general.data;
+            *ppadd = virt_to_bus(piord->iu.general.data);
         }
         /* do IOCTL */
         {
@@ -433,7 +433,7 @@
 
     /* look for buffer ID in length */
     if (id > 4) {
-#if LINUX_VERSION_CODE >= 0x010400
+#if LINUX_VERSION_CODE >= 0x020000
         size = sprintf(buffer+len,
                        "%s SCSI Disk Array Controller\n",
                        gdth_ctr_name(hanum));
@@ -543,7 +543,7 @@
     for (i = 0; i < GDTH_MAXCMDS; ++i) {
         scp = gdth_cmd_tab[i][hanum].cmnd;
         if (!SPECIAL_SCP(scp) && scp->target == (unchar)id &&
-#if LINUX_VERSION_CODE >= 0x010400
+#if LINUX_VERSION_CODE >= 0x020000
             scp->channel == (unchar)busnum)
 #else
             NUMDATA(scp->host)->busnum == (unchar)busnum)
@@ -571,7 +571,7 @@
 
     for (scp = ha->req_first; scp; scp = (Scsi_Cmnd *)scp->SCp.ptr) {
         if (scp->target == (unchar)id &&
-#if LINUX_VERSION_CODE >= 0x010400
+#if LINUX_VERSION_CODE >= 0x020000
             scp->channel == (unchar)busnum)
 #else
             NUMDATA(scp->host)->busnum == (unchar)busnum)
@@ -596,7 +596,7 @@
 
     for (scp = ha->req_first; scp; scp = (Scsi_Cmnd *)scp->SCp.ptr) {
         if (scp->target == (unchar)id &&
-#if LINUX_VERSION_CODE >= 0x010400
+#if LINUX_VERSION_CODE >= 0x020000
             scp->channel == (unchar)busnum)
 #else
             NUMDATA(scp->host)->busnum == (unchar)busnum)
