![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gdth.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / scsi|
Return to gdth.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / scsi |
1.1 ! root 1: /************************************************************************ ! 2: * GDT ISA/EISA/PCI Disk Array Controller driver for Linux * ! 3: * * ! 4: * gdth.c * ! 5: * Copyright (C) 1995-98 ICP vortex Computersysteme GmbH, Achim Leubner * ! 6: * * ! 7: * <[email protected]> * ! 8: * * ! 9: * This program is free software; you can redistribute it and/or modify * ! 10: * it under the terms of the GNU General Public License as published * ! 11: * by the Free Software Foundation; either version 2 of the License, * ! 12: * or (at your option) any later version. * ! 13: * * ! 14: * This program is distributed in the hope that it will be useful, * ! 15: * but WITHOUT ANY WARRANTY; without even the implied warranty of * ! 16: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * ! 17: * GNU General Public License for more details. * ! 18: * * ! 19: * You should have received a copy of the GNU General Public License * ! 20: * along with this kernel; if not, write to the Free Software * ! 21: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * ! 22: * * ! 23: * Tested with Linux 1.2.13, ..., 2.1.103 * ! 24: * * ! 25: * $Log: gdth.c,v $ ! 26: * Revision 1.1 1999/04/26 05:54:35 tb ! 27: * 1998-11-30 OKUJI Yoshinori <[email protected]> ! 28: * ! 29: * Clean up linux emulation code to make it architecture-independent ! 30: * as much as possible. ! 31: * ! 32: * * linux: Renamed from linuxdev. ! 33: * * Makefile.in (objfiles): Add linux.o instead of linuxdev.o. ! 34: * (MAKE): New variable. Used for the linux.o target. ! 35: * * configure.in: Add AC_CHECK_TOOL(MAKE, make). ! 36: * * i386/i386/spl.h: Include <i386/ipl.h>, for compatibility with ! 37: * OSF Mach 3.0. Suggested by Elgin Lee <[email protected]>. ! 38: * * linux/src: Renamed from linux/linux. ! 39: * * linux/dev: Renamed from linux/mach. ! 40: * * linux/Drivers.in (AC_INIT): Use dev/include/linux/autoconf.h, ! 41: * instead of mach/include/linux/autoconf.h. ! 42: * * Makefile.in (all): Target ../linux.o instead of ../linuxdev.o. ! 43: * * linux/dev/drivers/block/genhd.c: Include <machine/spl.h> instead ! 44: * of <i386/ipl.h>. ! 45: * * linux/dev/drivers/net/auto_irq.c: Remove unneeded header files, ! 46: * <i386/ipl.h> and <i386/pic.h>. ! 47: * * linux/dev/init/main.c: Many i386-dependent codes moved to ... ! 48: * * linux/dev/arch/i386/irq.c: ... here. ! 49: * * linux/dev/arch/i386/setup.c: New file. ! 50: * * linux/dev/arch/i386/linux_emul.h: Likewise. ! 51: * * linux/dev/arch/i386/glue/timer.c: Merged into sched.c. ! 52: * * linux/dev/arch/i386/glue/sched.c: Include <machine/spl.h> instead ! 53: * of <i386/ipl.h>, and moved to ... ! 54: * * linux/dev/kernel/sched.c: ... here. ! 55: * * linux/dev/arch/i386/glue/block.c: Include <machine/spl.h> and ! 56: * <linux_emul.h>, instead of i386-dependent header files, and ! 57: * moved to ... ! 58: * * linux/dev/glue/blocl.c: ... here. ! 59: * * linux/dev/arch/i386/glue/net.c: Include <machine/spl.h> and ! 60: * <linux_emul.h>, instead of i386-dependent header files, and ! 61: * moved to ... ! 62: * * linux/dev/glue/net.c: ... here. ! 63: * * linux/dev/arch/i386/glue/misc.c: Remove `x86' and moved to ... ! 64: * * linux/dev/glue/misc.c: ... here. ! 65: * * linux/dev/arch/i386/glue/kmem.c: Moved to ... ! 66: * * linux/dev/glue/kmem.c: ... here. ! 67: * ! 68: * Revision 1.16 1998/09/28 16:08:46 achim ! 69: * GDT_PCIMPR: DPMEM remapping, if required ! 70: * mdelay() added ! 71: * ! 72: * Revision 1.15 1998/06/03 14:54:06 achim ! 73: * gdth_delay(), gdth_flush() implemented ! 74: * Bugfix: gdth_release() changed ! 75: * ! 76: * Revision 1.14 1998/05/22 10:01:17 achim ! 77: * mj: pcibios_strerror() removed ! 78: * Improved SMP support (if version >= 2.1.95) ! 79: * gdth_halt(): halt_called flag added (if version < 2.1) ! 80: * ! 81: * Revision 1.13 1998/04/16 09:14:57 achim ! 82: * Reserve drives (for raw service) implemented ! 83: * New error handling code enabled ! 84: * Get controller name from board_info() IOCTL ! 85: * Final round of PCI device driver patches by Martin Mares ! 86: * ! 87: * Revision 1.12 1998/03/03 09:32:37 achim ! 88: * Fibre channel controller support added ! 89: * ! 90: * Revision 1.11 1998/01/27 16:19:14 achim ! 91: * SA_SHIRQ added ! 92: * add_timer()/del_timer() instead of GDTH_TIMER ! 93: * scsi_add_timer()/scsi_del_timer() instead of SCSI_TIMER ! 94: * New error handling included ! 95: * ! 96: * Revision 1.10 1997/10/31 12:29:57 achim ! 97: * Read heads/sectors from host drive ! 98: * ! 99: * Revision 1.9 1997/09/04 10:07:25 achim ! 100: * IO-mapping with virt_to_bus(), readb(), writeb(), ... ! 101: * register_reboot_notifier() to get a notify on shutdown used ! 102: * ! 103: * Revision 1.8 1997/04/02 12:14:30 achim ! 104: * Version 1.00 (see gdth.h), tested with kernel 2.0.29 ! 105: * ! 106: * Revision 1.7 1997/03/12 13:33:37 achim ! 107: * gdth_reset() changed, new async. events ! 108: * ! 109: * Revision 1.6 1997/03/04 14:01:11 achim ! 110: * Shutdown routine gdth_halt() implemented ! 111: * ! 112: * Revision 1.5 1997/02/21 09:08:36 achim ! 113: * New controller included (RP, RP1, RP2 series) ! 114: * IOCTL interface implemented ! 115: * ! 116: * Revision 1.4 1996/07/05 12:48:55 achim ! 117: * Function gdth_bios_param() implemented ! 118: * New constant GDTH_MAXC_P_L inserted ! 119: * GDT_WRITE_THR, GDT_EXT_INFO implemented ! 120: * Function gdth_reset() changed ! 121: * ! 122: * Revision 1.3 1996/05/10 09:04:41 achim ! 123: * Small changes for Linux 1.2.13 ! 124: * ! 125: * Revision 1.2 1996/05/09 12:45:27 achim ! 126: * Loadable module support implemented ! 127: * /proc support corrections made ! 128: * ! 129: * Revision 1.1 1996/04/11 07:35:57 achim ! 130: * Initial revision ! 131: * ! 132: * ! 133: * $Id: gdth.c,v 1.1 1999/04/26 05:54:35 tb Exp $ ! 134: ************************************************************************/ ! 135: ! 136: #ifdef MODULE ! 137: #include <linux/module.h> ! 138: #endif ! 139: ! 140: #include <linux/version.h> ! 141: #include <linux/kernel.h> ! 142: #include <linux/head.h> ! 143: #include <linux/types.h> ! 144: #include <linux/pci.h> ! 145: #include <linux/string.h> ! 146: #include <linux/ioport.h> ! 147: #include <linux/delay.h> ! 148: #include <linux/sched.h> ! 149: #include <linux/in.h> ! 150: #include <linux/proc_fs.h> ! 151: #include <linux/time.h> ! 152: #include <linux/timer.h> ! 153: #if LINUX_VERSION_CODE >= 0x020100 ! 154: #include <linux/reboot.h> ! 155: #else ! 156: #include <linux/bios32.h> ! 157: #endif ! 158: ! 159: #include <asm/dma.h> ! 160: #include <asm/system.h> ! 161: #include <asm/io.h> ! 162: #if LINUX_VERSION_CODE >= 0x02015F ! 163: #include <asm/spinlock.h> ! 164: #endif ! 165: ! 166: #if LINUX_VERSION_CODE >= 0x010300 ! 167: #include <linux/blk.h> ! 168: #else ! 169: #include "../block/blk.h" ! 170: #endif ! 171: #include "scsi.h" ! 172: #include "hosts.h" ! 173: #include "sd.h" ! 174: ! 175: #include "gdth.h" ! 176: ! 177: /****************************************************************************/ ! 178: ! 179: /* LILO params: gdth=<IRQ> ! 180: * ! 181: * Where: <IRQ> is any of the valid IRQs for EISA controllers (10,11,12,14) ! 182: * Sets the IRQ of the GDT3000/3020 EISA controller to this value, ! 183: * if the IRQ can not automat. detect (controller BIOS disabled) ! 184: * See gdth_init_eisa() ! 185: * ! 186: * You can use the command line gdth=0 to disable the driver ! 187: */ ! 188: static unchar irqs[MAXHA] = {0xff}; ! 189: static unchar disable_gdth_scan = FALSE; ! 190: ! 191: /* Reserve drives for raw service: Fill the following structure with the ! 192: * appropriate values: Controller number, Channel, Target ID ! 193: */ ! 194: static gdth_reserve_str reserve_list[] = { ! 195: /* { 0, 1, 4 }, Example: Controller 0, Channel B, ID 4 */ ! 196: { 0xff, 0xff, 0xff } /* end of list */ ! 197: }; ! 198: ! 199: /****************************************************************************/ ! 200: ! 201: #if LINUX_VERSION_CODE >= 0x02015F ! 202: static void gdth_interrupt(int irq,void *dev_id,struct pt_regs *regs); ! 203: static void do_gdth_interrupt(int irq,void *dev_id,struct pt_regs *regs); ! 204: #elif LINUX_VERSION_CODE >= 0x010346 ! 205: static void gdth_interrupt(int irq,void *dev_id,struct pt_regs *regs); ! 206: #else ! 207: static void gdth_interrupt(int irq,struct pt_regs *regs); ! 208: #endif ! 209: static int gdth_sync_event(int hanum,int service,unchar index,Scsi_Cmnd *scp); ! 210: static int gdth_async_event(int hanum,int service); ! 211: ! 212: static void gdth_putq(int hanum,Scsi_Cmnd *scp,unchar priority); ! 213: static void gdth_next(int hanum); ! 214: static int gdth_fill_raw_cmd(int hanum,Scsi_Cmnd *scp,unchar b); ! 215: static int gdth_special_cmd(int hanum,Scsi_Cmnd *scp,unchar b); ! 216: static gdth_evt_str *gdth_store_event(ushort source, ushort idx, ! 217: gdth_evt_data *evt); ! 218: static int gdth_read_event(int handle, gdth_evt_str *estr); ! 219: static void gdth_readapp_event(unchar application, gdth_evt_str *estr); ! 220: static void gdth_clear_events(void); ! 221: ! 222: static void gdth_copy_internal_data(Scsi_Cmnd *scp,char *buffer,ushort count); ! 223: static int gdth_internal_cache_cmd(int hanum,Scsi_Cmnd *scp, ! 224: unchar b,ulong *flags); ! 225: static int gdth_fill_cache_cmd(int hanum,Scsi_Cmnd *scp,ushort hdrive); ! 226: ! 227: static int gdth_search_eisa(ushort eisa_adr); ! 228: static int gdth_search_isa(ulong bios_adr); ! 229: static int gdth_search_pci(ushort device_id,ushort index,gdth_pci_str *pcistr); ! 230: static int gdth_init_eisa(ushort eisa_adr,gdth_ha_str *ha); ! 231: static int gdth_init_isa(ulong bios_adr,gdth_ha_str *ha); ! 232: static int gdth_init_pci(gdth_pci_str *pcistr,gdth_ha_str *ha); ! 233: ! 234: static void gdth_enable_int(int hanum); ! 235: static int gdth_get_status(unchar *pIStatus,int irq); ! 236: static int gdth_test_busy(int hanum); ! 237: static int gdth_get_cmd_index(int hanum); ! 238: static void gdth_release_event(int hanum); ! 239: static int gdth_wait(int hanum,int index,ulong time); ! 240: static int gdth_internal_cmd(int hanum,unchar service,ushort opcode,ulong p1, ! 241: ulong p2,ulong p3); ! 242: static int gdth_search_drives(int hanum); ! 243: ! 244: static void *gdth_mmap(ulong paddr, ulong size); ! 245: static void gdth_munmap(void *addr); ! 246: ! 247: static const char *gdth_ctr_name(int hanum); ! 248: ! 249: static void gdth_flush(int hanum); ! 250: #if LINUX_VERSION_CODE >= 0x020100 ! 251: static int gdth_halt(struct notifier_block *nb, ulong event, void *buf); ! 252: #else ! 253: static int halt_called = FALSE; ! 254: void gdth_halt(void); ! 255: #endif ! 256: ! 257: #ifdef DEBUG_GDTH ! 258: static unchar DebugState = DEBUG_GDTH; ! 259: extern int sys_syslog(int,char*,int); ! 260: #define LOGEN sys_syslog(7,NULL,0) ! 261: ! 262: #ifdef __SERIAL__ ! 263: #define MAX_SERBUF 160 ! 264: static void ser_init(void); ! 265: static void ser_puts(char *str); ! 266: static void ser_putc(char c); ! 267: static int ser_printk(const char *fmt, ...); ! 268: static char strbuf[MAX_SERBUF+1]; ! 269: #ifdef __COM2__ ! 270: #define COM_BASE 0x2f8 ! 271: #else ! 272: #define COM_BASE 0x3f8 ! 273: #endif ! 274: static void ser_init() ! 275: { ! 276: unsigned port=COM_BASE; ! 277: ! 278: outb(0x80,port+3); ! 279: outb(0,port+1); ! 280: /* 19200 Baud, if 9600: outb(12,port) */ ! 281: outb(6, port); ! 282: outb(3,port+3); ! 283: outb(0,port+1); ! 284: /* ! 285: ser_putc('I'); ! 286: ser_putc(' '); ! 287: */ ! 288: } ! 289: ! 290: static void ser_puts(char *str) ! 291: { ! 292: char *ptr; ! 293: ! 294: ser_init(); ! 295: for (ptr=str;*ptr;++ptr) ! 296: ser_putc(*ptr); ! 297: } ! 298: ! 299: static void ser_putc(char c) ! 300: { ! 301: unsigned port=COM_BASE; ! 302: ! 303: while ((inb(port+5) & 0x20)==0); ! 304: outb(c,port); ! 305: if (c==0x0a) ! 306: { ! 307: while ((inb(port+5) & 0x20)==0); ! 308: outb(0x0d,port); ! 309: } ! 310: } ! 311: ! 312: static int ser_printk(const char *fmt, ...) ! 313: { ! 314: va_list args; ! 315: int i; ! 316: ! 317: va_start(args,fmt); ! 318: i = vsprintf(strbuf,fmt,args); ! 319: ser_puts(strbuf); ! 320: va_end(args); ! 321: return i; ! 322: } ! 323: ! 324: #define TRACE(a) {if (DebugState==1) {ser_printk a;}} ! 325: #define TRACE2(a) {if (DebugState==1 || DebugState==2) {ser_printk a;}} ! 326: #define TRACE3(a) {if (DebugState!=0) {ser_printk a;}} ! 327: ! 328: #else /* !__SERIAL__ */ ! 329: #define TRACE(a) {if (DebugState==1) {LOGEN;printk a;}} ! 330: #define TRACE2(a) {if (DebugState==1 || DebugState==2) {LOGEN;printk a;}} ! 331: #define TRACE3(a) {if (DebugState!=0) {LOGEN;printk a;}} ! 332: #endif ! 333: ! 334: #else /* !DEBUG */ ! 335: #define TRACE(a) ! 336: #define TRACE2(a) ! 337: #define TRACE3(a) ! 338: #endif ! 339: ! 340: #ifdef GDTH_STATISTICS ! 341: static ulong max_rq=0, max_index=0, max_sg=0; ! 342: static ulong act_ints=0, act_ios=0, act_stats=0, act_rq=0; ! 343: static struct timer_list gdth_timer; ! 344: #endif ! 345: ! 346: #define PTR2USHORT(a) (ushort)(ulong)(a) ! 347: #define GDTOFFSOF(a,b) (size_t)&(((a*)0)->b) ! 348: #define INDEX_OK(i,t) ((i)<sizeof(t)/sizeof((t)[0])) ! 349: ! 350: #define NUMDATA(a) ( (gdth_num_str *)((a)->hostdata)) ! 351: #define HADATA(a) (&((gdth_ext_str *)((a)->hostdata))->haext) ! 352: #define CMDDATA(a) (&((gdth_ext_str *)((a)->hostdata))->cmdext) ! 353: #define DMADATA(a) (&((gdth_ext_str *)((a)->hostdata))->dmaext) ! 354: ! 355: ! 356: #if LINUX_VERSION_CODE < 0x010300 ! 357: static void *gdth_mmap(ulong paddr, ulong size) ! 358: { ! 359: if (paddr >= high_memory) ! 360: return NULL; ! 361: else ! 362: return (void *)paddr; ! 363: } ! 364: static void gdth_munmap(void *addr) ! 365: { ! 366: } ! 367: inline ulong virt_to_phys(volatile void *addr) ! 368: { ! 369: return (ulong)addr; ! 370: } ! 371: inline void *phys_to_virt(ulong addr) ! 372: { ! 373: return (void *)addr; ! 374: } ! 375: #define virt_to_bus virt_to_phys ! 376: #define bus_to_virt phys_to_virt ! 377: #define readb(addr) (*(volatile unchar *)(addr)) ! 378: #define readw(addr) (*(volatile ushort *)(addr)) ! 379: #define readl(addr) (*(volatile ulong *)(addr)) ! 380: #define writeb(b,addr) (*(volatile unchar *)(addr) = (b)) ! 381: #define writew(b,addr) (*(volatile ushort *)(addr) = (b)) ! 382: #define writel(b,addr) (*(volatile ulong *)(addr) = (b)) ! 383: #define memset_io(a,b,c) memset((void *)(a),(b),(c)) ! 384: #define memcpy_fromio(a,b,c) memcpy((a),(void *)(b),(c)) ! 385: #define memcpy_toio(a,b,c) memcpy((void *)(a),(b),(c)) ! 386: ! 387: #elif LINUX_VERSION_CODE < 0x020100 ! 388: static int remapped = FALSE; ! 389: static void *gdth_mmap(ulong paddr, ulong size) ! 390: { ! 391: if ( paddr >= high_memory) { ! 392: remapped = TRUE; ! 393: return vremap(paddr, size); ! 394: } else { ! 395: return (void *)paddr; ! 396: } ! 397: } ! 398: static void gdth_munmap(void *addr) ! 399: { ! 400: if (remapped) ! 401: vfree(addr); ! 402: remapped = FALSE; ! 403: } ! 404: #else ! 405: static void *gdth_mmap(ulong paddr, ulong size) ! 406: { ! 407: return ioremap(paddr, size); ! 408: } ! 409: static void gdth_munmap(void *addr) ! 410: { ! 411: return iounmap(addr); ! 412: } ! 413: #endif ! 414: ! 415: ! 416: static unchar gdth_drq_tab[4] = {5,6,7,7}; /* DRQ table */ ! 417: static unchar gdth_irq_tab[6] = {0,10,11,12,14,0}; /* IRQ table */ ! 418: static unchar gdth_polling; /* polling if TRUE */ ! 419: static unchar gdth_from_wait = FALSE; /* gdth_wait() */ ! 420: static int wait_index,wait_hanum; /* gdth_wait() */ ! 421: static int gdth_ctr_count = 0; /* controller count */ ! 422: static int gdth_ctr_vcount = 0; /* virt. ctr. count */ ! 423: static int gdth_ctr_released = 0; /* gdth_release() */ ! 424: static struct Scsi_Host *gdth_ctr_tab[MAXHA]; /* controller table */ ! 425: static struct Scsi_Host *gdth_ctr_vtab[MAXHA*MAXBUS]; /* virt. ctr. table */ ! 426: static unchar gdth_write_through = FALSE; /* write through */ ! 427: static char *gdth_ioctl_tab[4][MAXHA]; /* ioctl buffer */ ! 428: static gdth_evt_str ebuffer[MAX_EVENTS]; /* event buffer */ ! 429: static int elastidx; ! 430: static int eoldidx; ! 431: ! 432: static struct { ! 433: Scsi_Cmnd *cmnd; /* pending request */ ! 434: ushort service; /* service */ ! 435: } gdth_cmd_tab[GDTH_MAXCMDS][MAXHA]; /* table of pend. requests */ ! 436: ! 437: #define DIN 1 /* IN data direction */ ! 438: #define DOU 2 /* OUT data direction */ ! 439: #define DNO DIN /* no data transfer */ ! 440: #define DUN DIN /* unknown data direction */ ! 441: static unchar gdth_direction_tab[0x100] = { ! 442: DNO,DNO,DIN,DIN,DOU,DIN,DIN,DOU,DIN,DUN,DOU,DOU,DUN,DUN,DUN,DIN, ! 443: DNO,DIN,DIN,DOU,DIN,DOU,DNO,DNO,DOU,DNO,DIN,DNO,DIN,DOU,DNO,DUN, ! 444: DIN,DUN,DIN,DUN,DOU,DIN,DUN,DUN,DIN,DIN,DIN,DUN,DUN,DIN,DIN,DIN, ! 445: DIN,DIN,DIN,DNO,DIN,DNO,DNO,DIN,DIN,DIN,DIN,DIN,DIN,DIN,DIN,DIN, ! 446: DIN,DIN,DIN,DIN,DIN,DNO,DUN,DNO,DNO,DNO,DUN,DNO,DIN,DIN,DUN,DUN, ! 447: DUN,DUN,DUN,DUN,DUN,DIN,DUN,DUN,DUN,DUN,DIN,DUN,DUN,DUN,DUN,DUN, ! 448: DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN, ! 449: DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN, ! 450: DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN, ! 451: DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN, ! 452: DUN,DUN,DUN,DUN,DUN,DNO,DNO,DUN,DIN,DNO,DIN,DUN,DNO,DUN,DIN,DIN, ! 453: DIN,DIN,DIN,DNO,DUN,DIN,DIN,DIN,DIN,DUN,DUN,DUN,DUN,DUN,DUN,DUN, ! 454: DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN, ! 455: DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN, ! 456: DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DOU,DUN,DUN,DUN,DUN,DUN, ! 457: DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN ! 458: }; ! 459: ! 460: /* __initfunc, __initdata macros */ ! 461: #if LINUX_VERSION_CODE >= 0x020126 ! 462: #include <linux/init.h> ! 463: #else ! 464: #define __initfunc(A) A ! 465: #define __initdata ! 466: #define __init ! 467: #endif ! 468: ! 469: /* /proc support */ ! 470: #if LINUX_VERSION_CODE >= 0x010300 ! 471: #include <linux/stat.h> ! 472: struct proc_dir_entry proc_scsi_gdth = { ! 473: PROC_SCSI_GDTH, 4, "gdth", ! 474: S_IFDIR | S_IRUGO | S_IXUGO, 2 ! 475: }; ! 476: #include "gdth_proc.h" ! 477: #include "gdth_proc.c" ! 478: #endif ! 479: ! 480: #if LINUX_VERSION_CODE >= 0x020100 ! 481: /* notifier block to get a notify on system shutdown/halt/reboot */ ! 482: static struct notifier_block gdth_notifier = { ! 483: gdth_halt, NULL, 0 ! 484: }; ! 485: #endif ! 486: ! 487: static void gdth_delay(int milliseconds) ! 488: { ! 489: if (milliseconds == 0) { ! 490: udelay(1); ! 491: } else { ! 492: #if LINUX_VERSION_CODE >= 0x020168 ! 493: mdelay(milliseconds); ! 494: #else ! 495: int i; ! 496: for (i = 0; i < milliseconds; ++i) ! 497: udelay(1000); ! 498: #endif ! 499: } ! 500: } ! 501: ! 502: /* controller search and initialization functions */ ! 503: ! 504: __initfunc (static int gdth_search_eisa(ushort eisa_adr)) ! 505: { ! 506: ulong id; ! 507: ! 508: TRACE(("gdth_search_eisa() adr. %x\n",eisa_adr)); ! 509: id = inl(eisa_adr+ID0REG); ! 510: if (id == GDT3A_ID || id == GDT3B_ID) { /* GDT3000A or GDT3000B */ ! 511: if ((inb(eisa_adr+EISAREG) & 8) == 0) ! 512: return 0; /* not EISA configured */ ! 513: return 1; ! 514: } ! 515: if (id == GDT3_ID) /* GDT3000 */ ! 516: return 1; ! 517: ! 518: return 0; ! 519: } ! 520: ! 521: ! 522: __initfunc (static int gdth_search_isa(ulong bios_adr)) ! 523: { ! 524: void *addr; ! 525: ulong id; ! 526: ! 527: TRACE(("gdth_search_isa() bios adr. %lx\n",bios_adr)); ! 528: if ((addr = gdth_mmap(bios_adr+BIOS_ID_OFFS, sizeof(ulong))) != NULL) { ! 529: id = readl(addr); ! 530: gdth_munmap(addr); ! 531: if (id == GDT2_ID) /* GDT2000 */ ! 532: return 1; ! 533: } ! 534: return 0; ! 535: } ! 536: ! 537: ! 538: __initfunc (static int gdth_search_pci(ushort device_id,ushort index,gdth_pci_str *pcistr)) ! 539: { ! 540: int error; ! 541: ulong base0,base1,base2; ! 542: ! 543: TRACE(("gdth_search_pci() device_id %d, index %d\n", ! 544: device_id,index)); ! 545: ! 546: #if LINUX_VERSION_CODE >= 0x20155 ! 547: if (!pci_present()) ! 548: return 0; ! 549: #else ! 550: if (!pcibios_present()) ! 551: return 0; ! 552: #endif ! 553: ! 554: if (pcibios_find_device(PCI_VENDOR_ID_VORTEX,device_id,index, ! 555: &pcistr->bus,&pcistr->device_fn)) ! 556: return 0; ! 557: ! 558: /* GDT PCI controller found, now read resources from config space */ ! 559: #if LINUX_VERSION_CODE >= 0x20155 ! 560: { ! 561: struct pci_dev *pdev = pci_find_slot(pcistr->bus, pcistr->device_fn); ! 562: base0 = pdev->base_address[0]; ! 563: base1 = pdev->base_address[1]; ! 564: base2 = pdev->base_address[2]; ! 565: if ((error = pcibios_read_config_dword(pcistr->bus,pcistr->device_fn, ! 566: PCI_ROM_ADDRESS, ! 567: (int *) &pcistr->bios))) { ! 568: printk("GDT-PCI: error %d reading configuration space", error); ! 569: return -1; ! 570: } ! 571: pcistr->irq = pdev->irq; ! 572: } ! 573: #else ! 574: #if LINUX_VERSION_CODE >= 0x010300 ! 575: #define GDTH_BASEP (int *) ! 576: #else ! 577: #define GDTH_BASEP ! 578: #endif ! 579: if ((error = pcibios_read_config_dword(pcistr->bus,pcistr->device_fn, ! 580: PCI_BASE_ADDRESS_0, ! 581: GDTH_BASEP&base0)) || ! 582: (error = pcibios_read_config_dword(pcistr->bus,pcistr->device_fn, ! 583: PCI_BASE_ADDRESS_1, ! 584: GDTH_BASEP&base1)) || ! 585: (error = pcibios_read_config_dword(pcistr->bus,pcistr->device_fn, ! 586: PCI_BASE_ADDRESS_2, ! 587: GDTH_BASEP&base2)) || ! 588: (error = pcibios_read_config_dword(pcistr->bus,pcistr->device_fn, ! 589: PCI_ROM_ADDRESS, ! 590: GDTH_BASEP&pcistr->bios)) || ! 591: (error = pcibios_read_config_byte(pcistr->bus,pcistr->device_fn, ! 592: PCI_INTERRUPT_LINE,&pcistr->irq))) { ! 593: printk("GDT-PCI: error %d reading configuration space", error); ! 594: return -1; ! 595: } ! 596: #endif ! 597: ! 598: pcistr->device_id = device_id; ! 599: if (device_id <= PCI_DEVICE_ID_VORTEX_GDT6000B || /* GDT6000 or GDT6000B */ ! 600: device_id >= PCI_DEVICE_ID_VORTEX_GDT6x17RP) { /* MPR */ ! 601: if ((base0 & PCI_BASE_ADDRESS_SPACE)!=PCI_BASE_ADDRESS_SPACE_MEMORY) ! 602: return -1; ! 603: pcistr->dpmem = base0 & PCI_BASE_ADDRESS_MEM_MASK; ! 604: } else { /* GDT6110, GDT6120, .. */ ! 605: if ((base0 & PCI_BASE_ADDRESS_SPACE)!=PCI_BASE_ADDRESS_SPACE_MEMORY || ! 606: (base2 & PCI_BASE_ADDRESS_SPACE)!=PCI_BASE_ADDRESS_SPACE_MEMORY || ! 607: (base1 & PCI_BASE_ADDRESS_SPACE)!=PCI_BASE_ADDRESS_SPACE_IO) ! 608: return -1; ! 609: pcistr->dpmem = base2 & PCI_BASE_ADDRESS_MEM_MASK; ! 610: pcistr->io_mm = base0 & PCI_BASE_ADDRESS_MEM_MASK; ! 611: pcistr->io = base1 & PCI_BASE_ADDRESS_IO_MASK; ! 612: } ! 613: return 1; ! 614: } ! 615: ! 616: ! 617: __initfunc (static int gdth_init_eisa(ushort eisa_adr,gdth_ha_str *ha)) ! 618: { ! 619: ulong retries,id; ! 620: unchar prot_ver,eisacf,i,irq_found; ! 621: ! 622: TRACE(("gdth_init_eisa() adr. %x\n",eisa_adr)); ! 623: ! 624: /* disable board interrupts, deinitialize services */ ! 625: outb(0xff,eisa_adr+EDOORREG); ! 626: outb(0x00,eisa_adr+EDENABREG); ! 627: outb(0x00,eisa_adr+EINTENABREG); ! 628: ! 629: outb(0xff,eisa_adr+LDOORREG); ! 630: retries = INIT_RETRIES; ! 631: gdth_delay(20); ! 632: while (inb(eisa_adr+EDOORREG) != 0xff) { ! 633: if (--retries == 0) { ! 634: printk("GDT-EISA: Initialization error (DEINIT failed)\n"); ! 635: return 0; ! 636: } ! 637: gdth_delay(1); ! 638: TRACE2(("wait for DEINIT: retries=%ld\n",retries)); ! 639: } ! 640: prot_ver = inb(eisa_adr+MAILBOXREG); ! 641: outb(0xff,eisa_adr+EDOORREG); ! 642: if (prot_ver != PROTOCOL_VERSION) { ! 643: printk("GDT-EISA: Illegal protocol version\n"); ! 644: return 0; ! 645: } ! 646: ha->bmic = eisa_adr; ! 647: ha->brd_phys = (ulong)eisa_adr >> 12; ! 648: ! 649: outl(0,eisa_adr+MAILBOXREG); ! 650: outl(0,eisa_adr+MAILBOXREG+4); ! 651: outl(0,eisa_adr+MAILBOXREG+8); ! 652: outl(0,eisa_adr+MAILBOXREG+12); ! 653: ! 654: /* detect IRQ */ ! 655: if ((id = inl(eisa_adr+ID0REG)) == GDT3_ID) { ! 656: ha->type = GDT_EISA; ! 657: ha->stype = id; ! 658: outl(1,eisa_adr+MAILBOXREG+8); ! 659: outb(0xfe,eisa_adr+LDOORREG); ! 660: retries = INIT_RETRIES; ! 661: gdth_delay(20); ! 662: while (inb(eisa_adr+EDOORREG) != 0xfe) { ! 663: if (--retries == 0) { ! 664: printk("GDT-EISA: Initialization error (get IRQ failed)\n"); ! 665: return 0; ! 666: } ! 667: gdth_delay(1); ! 668: } ! 669: ha->irq = inb(eisa_adr+MAILBOXREG); ! 670: outb(0xff,eisa_adr+EDOORREG); ! 671: TRACE2(("GDT3000/3020: IRQ=%d\n",ha->irq)); ! 672: /* check the result */ ! 673: if (ha->irq == 0) { ! 674: TRACE2(("Unknown IRQ, check IRQ table from cmd line !\n")); ! 675: for (i=0,irq_found=FALSE; i<MAXHA && irqs[i]!=0xff; ++i) { ! 676: if (irqs[i]!=0) { ! 677: irq_found=TRUE; ! 678: break; ! 679: } ! 680: } ! 681: if (irq_found) { ! 682: ha->irq = irqs[i]; ! 683: irqs[i] = 0; ! 684: printk("GDT-EISA: Can not detect controller IRQ,\n"); ! 685: printk("Use IRQ setting from command line (IRQ = %d)\n", ! 686: ha->irq); ! 687: } else { ! 688: printk("GDT-EISA: Initialization error (unknown IRQ), Enable\n"); ! 689: printk("the controller BIOS or use command line parameters\n"); ! 690: return 0; ! 691: } ! 692: } ! 693: } else { ! 694: eisacf = inb(eisa_adr+EISAREG) & 7; ! 695: if (eisacf > 4) /* level triggered */ ! 696: eisacf -= 4; ! 697: ha->irq = gdth_irq_tab[eisacf]; ! 698: ha->type = GDT_EISA; ! 699: ha->stype= id; ! 700: } ! 701: return 1; ! 702: } ! 703: ! 704: ! 705: __initfunc (static int gdth_init_isa(ulong bios_adr,gdth_ha_str *ha)) ! 706: { ! 707: register gdt2_dpram_str *dp2_ptr; ! 708: int i; ! 709: unchar irq_drq,prot_ver; ! 710: ulong retries; ! 711: ! 712: TRACE(("gdth_init_isa() bios adr. %lx\n",bios_adr)); ! 713: ! 714: ha->brd = gdth_mmap(bios_adr, sizeof(gdt2_dpram_str)); ! 715: if (ha->brd == NULL) { ! 716: printk("GDT-ISA: Initialization error (DPMEM remap error)\n"); ! 717: return 0; ! 718: } ! 719: dp2_ptr = (gdt2_dpram_str *)ha->brd; ! 720: writeb(1, &dp2_ptr->io.memlock); /* switch off write protection */ ! 721: /* reset interface area */ ! 722: memset_io((char *)&dp2_ptr->u,0,sizeof(dp2_ptr->u)); ! 723: if (readl(&dp2_ptr->u) != 0) { ! 724: printk("GDT-PCI: Initialization error (DPMEM write error)\n"); ! 725: gdth_munmap(ha->brd); ! 726: return 0; ! 727: } ! 728: ! 729: /* disable board interrupts, read DRQ and IRQ */ ! 730: writeb(0xff, &dp2_ptr->io.irqdel); ! 731: writeb(0x00, &dp2_ptr->io.irqen); ! 732: writeb(0x00, &dp2_ptr->u.ic.S_Status); ! 733: writeb(0x00, &dp2_ptr->u.ic.Cmd_Index); ! 734: ! 735: irq_drq = readb(&dp2_ptr->io.rq); ! 736: for (i=0; i<3; ++i) { ! 737: if ((irq_drq & 1)==0) ! 738: break; ! 739: irq_drq >>= 1; ! 740: } ! 741: ha->drq = gdth_drq_tab[i]; ! 742: ! 743: irq_drq = readb(&dp2_ptr->io.rq) >> 3; ! 744: for (i=1; i<5; ++i) { ! 745: if ((irq_drq & 1)==0) ! 746: break; ! 747: irq_drq >>= 1; ! 748: } ! 749: ha->irq = gdth_irq_tab[i]; ! 750: ! 751: /* deinitialize services */ ! 752: writel(bios_adr, &dp2_ptr->u.ic.S_Info[0]); ! 753: writeb(0xff, &dp2_ptr->u.ic.S_Cmd_Indx); ! 754: writeb(0, &dp2_ptr->io.event); ! 755: retries = INIT_RETRIES; ! 756: gdth_delay(20); ! 757: while (readb(&dp2_ptr->u.ic.S_Status) != 0xff) { ! 758: if (--retries == 0) { ! 759: printk("GDT-ISA: Initialization error (DEINIT failed)\n"); ! 760: gdth_munmap(ha->brd); ! 761: return 0; ! 762: } ! 763: gdth_delay(1); ! 764: } ! 765: prot_ver = (unchar)readl(&dp2_ptr->u.ic.S_Info[0]); ! 766: writeb(0, &dp2_ptr->u.ic.Status); ! 767: writeb(0xff, &dp2_ptr->io.irqdel); ! 768: if (prot_ver != PROTOCOL_VERSION) { ! 769: printk("GDT-ISA: Illegal protocol version\n"); ! 770: gdth_munmap(ha->brd); ! 771: return 0; ! 772: } ! 773: ! 774: ha->type = GDT_ISA; ! 775: ha->ic_all_size = sizeof(dp2_ptr->u); ! 776: ha->stype= GDT2_ID; ! 777: ha->brd_phys = bios_adr >> 4; ! 778: ! 779: /* special request to controller BIOS */ ! 780: writel(0x00, &dp2_ptr->u.ic.S_Info[0]); ! 781: writel(0x00, &dp2_ptr->u.ic.S_Info[1]); ! 782: writel(0x01, &dp2_ptr->u.ic.S_Info[2]); ! 783: writel(0x00, &dp2_ptr->u.ic.S_Info[3]); ! 784: writeb(0xfe, &dp2_ptr->u.ic.S_Cmd_Indx); ! 785: writeb(0, &dp2_ptr->io.event); ! 786: retries = INIT_RETRIES; ! 787: gdth_delay(20); ! 788: while (readb(&dp2_ptr->u.ic.S_Status) != 0xfe) { ! 789: if (--retries == 0) { ! 790: printk("GDT-ISA: Initialization error\n"); ! 791: gdth_munmap(ha->brd); ! 792: return 0; ! 793: } ! 794: gdth_delay(1); ! 795: } ! 796: writeb(0, &dp2_ptr->u.ic.Status); ! 797: writeb(0xff, &dp2_ptr->io.irqdel); ! 798: return 1; ! 799: } ! 800: ! 801: ! 802: __initfunc (static int gdth_init_pci(gdth_pci_str *pcistr,gdth_ha_str *ha)) ! 803: { ! 804: register gdt6_dpram_str *dp6_ptr; ! 805: register gdt6c_dpram_str *dp6c_ptr; ! 806: register gdt6m_dpram_str *dp6m_ptr; ! 807: ulong retries; ! 808: unchar prot_ver; ! 809: int i, found = FALSE; ! 810: ! 811: TRACE(("gdth_init_pci()\n")); ! 812: ! 813: ha->brd_phys = (pcistr->bus << 8) | (pcistr->device_fn & 0xf8); ! 814: ha->stype = (ulong)pcistr->device_id; ! 815: ha->irq = pcistr->irq; ! 816: ! 817: if (ha->stype <= PCI_DEVICE_ID_VORTEX_GDT6000B) { /* GDT6000 or GDT6000B */ ! 818: TRACE2(("init_pci() dpmem %lx irq %d\n",pcistr->dpmem,ha->irq)); ! 819: ha->brd = gdth_mmap(pcistr->dpmem, sizeof(gdt6_dpram_str)); ! 820: if (ha->brd == NULL) { ! 821: printk("GDT-PCI: Initialization error (DPMEM remap error)\n"); ! 822: return 0; ! 823: } ! 824: dp6_ptr = (gdt6_dpram_str *)ha->brd; ! 825: /* reset interface area */ ! 826: memset_io((char *)&dp6_ptr->u,0,sizeof(dp6_ptr->u)); ! 827: if (readl(&dp6_ptr->u) != 0) { ! 828: printk("GDT-PCI: Initialization error (DPMEM write error)\n"); ! 829: gdth_munmap(ha->brd); ! 830: return 0; ! 831: } ! 832: ! 833: /* disable board interrupts, deinit services */ ! 834: writeb(0xff, &dp6_ptr->io.irqdel); ! 835: writeb(0x00, &dp6_ptr->io.irqen);; ! 836: writeb(0x00, &dp6_ptr->u.ic.S_Status); ! 837: writeb(0x00, &dp6_ptr->u.ic.Cmd_Index); ! 838: ! 839: writel(pcistr->dpmem, &dp6_ptr->u.ic.S_Info[0]); ! 840: writeb(0xff, &dp6_ptr->u.ic.S_Cmd_Indx); ! 841: writeb(0, &dp6_ptr->io.event); ! 842: retries = INIT_RETRIES; ! 843: gdth_delay(20); ! 844: while (readb(&dp6_ptr->u.ic.S_Status) != 0xff) { ! 845: if (--retries == 0) { ! 846: printk("GDT-PCI: Initialization error (DEINIT failed)\n"); ! 847: gdth_munmap(ha->brd); ! 848: return 0; ! 849: } ! 850: gdth_delay(1); ! 851: } ! 852: prot_ver = (unchar)readl(&dp6_ptr->u.ic.S_Info[0]); ! 853: writeb(0, &dp6_ptr->u.ic.S_Status); ! 854: writeb(0xff, &dp6_ptr->io.irqdel); ! 855: if (prot_ver != PROTOCOL_VERSION) { ! 856: printk("GDT-PCI: Illegal protocol version\n"); ! 857: gdth_munmap(ha->brd); ! 858: return 0; ! 859: } ! 860: ! 861: ha->type = GDT_PCI; ! 862: ha->ic_all_size = sizeof(dp6_ptr->u); ! 863: ! 864: /* special command to controller BIOS */ ! 865: writel(0x00, &dp6_ptr->u.ic.S_Info[0]); ! 866: writel(0x00, &dp6_ptr->u.ic.S_Info[1]); ! 867: writel(0x01, &dp6_ptr->u.ic.S_Info[2]); ! 868: writel(0x00, &dp6_ptr->u.ic.S_Info[3]); ! 869: writeb(0xfe, &dp6_ptr->u.ic.S_Cmd_Indx); ! 870: writeb(0, &dp6_ptr->io.event); ! 871: retries = INIT_RETRIES; ! 872: gdth_delay(20); ! 873: while (readb(&dp6_ptr->u.ic.S_Status) != 0xfe) { ! 874: if (--retries == 0) { ! 875: printk("GDT-PCI: Initialization error\n"); ! 876: gdth_munmap(ha->brd); ! 877: return 0; ! 878: } ! 879: gdth_delay(1); ! 880: } ! 881: writeb(0, &dp6_ptr->u.ic.S_Status); ! 882: writeb(0xff, &dp6_ptr->io.irqdel); ! 883: ! 884: } else if (ha->stype <= PCI_DEVICE_ID_VORTEX_GDT6555) { /* GDT6110, GDT6120, .. */ ! 885: ha->plx = (gdt6c_plx_regs *)pcistr->io; ! 886: TRACE2(("init_pci_new() dpmem %lx io %lx irq %d\n", ! 887: pcistr->dpmem,(ulong)ha->plx,ha->irq)); ! 888: ha->brd = gdth_mmap(pcistr->dpmem, sizeof(gdt6c_dpram_str)); ! 889: if (ha->brd == NULL) { ! 890: printk("GDT-PCI: Initialization error (DPMEM remap error)\n"); ! 891: gdth_munmap(ha->brd); ! 892: return 0; ! 893: } ! 894: dp6c_ptr = (gdt6c_dpram_str *)ha->brd; ! 895: /* reset interface area */ ! 896: memset_io((char *)&dp6c_ptr->u,0,sizeof(dp6c_ptr->u)); ! 897: if (readl(&dp6c_ptr->u) != 0) { ! 898: printk("GDT-PCI: Initialization error (DPMEM write error)\n"); ! 899: gdth_munmap(ha->brd); ! 900: return 0; ! 901: } ! 902: ! 903: /* disable board interrupts, deinit services */ ! 904: outb(0x00,PTR2USHORT(&ha->plx->control1)); ! 905: outb(0xff,PTR2USHORT(&ha->plx->edoor_reg)); ! 906: ! 907: writeb(0x00, &dp6c_ptr->u.ic.S_Status); ! 908: writeb(0x00, &dp6c_ptr->u.ic.Cmd_Index); ! 909: ! 910: writel(pcistr->dpmem, &dp6c_ptr->u.ic.S_Info[0]); ! 911: writeb(0xff, &dp6c_ptr->u.ic.S_Cmd_Indx); ! 912: ! 913: outb(1,PTR2USHORT(&ha->plx->ldoor_reg)); ! 914: ! 915: retries = INIT_RETRIES; ! 916: gdth_delay(20); ! 917: while (readb(&dp6c_ptr->u.ic.S_Status) != 0xff) { ! 918: if (--retries == 0) { ! 919: printk("GDT-PCI: Initialization error (DEINIT failed)\n"); ! 920: gdth_munmap(ha->brd); ! 921: return 0; ! 922: } ! 923: gdth_delay(1); ! 924: } ! 925: prot_ver = (unchar)readl(&dp6c_ptr->u.ic.S_Info[0]); ! 926: writeb(0, &dp6c_ptr->u.ic.Status); ! 927: if (prot_ver != PROTOCOL_VERSION) { ! 928: printk("GDT-PCI: Illegal protocol version\n"); ! 929: gdth_munmap(ha->brd); ! 930: return 0; ! 931: } ! 932: ! 933: ha->type = GDT_PCINEW; ! 934: ha->ic_all_size = sizeof(dp6c_ptr->u); ! 935: ! 936: /* special command to controller BIOS */ ! 937: writel(0x00, &dp6c_ptr->u.ic.S_Info[0]); ! 938: writel(0x00, &dp6c_ptr->u.ic.S_Info[1]); ! 939: writel(0x01, &dp6c_ptr->u.ic.S_Info[2]); ! 940: writel(0x00, &dp6c_ptr->u.ic.S_Info[3]); ! 941: writeb(0xfe, &dp6c_ptr->u.ic.S_Cmd_Indx); ! 942: ! 943: outb(1,PTR2USHORT(&ha->plx->ldoor_reg)); ! 944: ! 945: retries = INIT_RETRIES; ! 946: gdth_delay(20); ! 947: while (readb(&dp6c_ptr->u.ic.S_Status) != 0xfe) { ! 948: if (--retries == 0) { ! 949: printk("GDT-PCI: Initialization error\n"); ! 950: gdth_munmap(ha->brd); ! 951: return 0; ! 952: } ! 953: gdth_delay(1); ! 954: } ! 955: writeb(0, &dp6c_ptr->u.ic.S_Status); ! 956: ! 957: } else { /* MPR */ ! 958: TRACE2(("init_pci_mpr() dpmem %lx irq %d\n",pcistr->dpmem,ha->irq)); ! 959: ha->brd = gdth_mmap(pcistr->dpmem, sizeof(gdt6m_dpram_str)); ! 960: if (ha->brd == NULL) { ! 961: printk("GDT-PCI: Initialization error (DPMEM remap error)\n"); ! 962: return 0; ! 963: } ! 964: ! 965: /* check and reset interface area */ ! 966: dp6m_ptr = (gdt6m_dpram_str *)ha->brd; ! 967: writel(DPMEM_MAGIC, &dp6m_ptr->u); ! 968: if (readl(&dp6m_ptr->u) != DPMEM_MAGIC) { ! 969: printk("GDT-PCI: Cannot access DPMEM at 0x%x (shadowed?)\n", ! 970: (int)ha->brd); ! 971: found = FALSE; ! 972: for (i = 0xC8000; i < 0xE8000; i += 0x4000) { ! 973: pcibios_write_config_dword( pcistr->bus, pcistr->device_fn, ! 974: PCI_BASE_ADDRESS_0, i ); ! 975: gdth_munmap( ha->brd ); ! 976: ha->brd = gdth_mmap(i, sizeof(gdt6m_dpram_str)); ! 977: if (ha->brd == NULL) { ! 978: printk("GDT-PCI: Initialization error (DPMEM remap error)\n"); ! 979: return 0; ! 980: } ! 981: dp6m_ptr = (gdt6m_dpram_str *)ha->brd; ! 982: writel(DPMEM_MAGIC, &dp6m_ptr->u); ! 983: if (readl(&dp6m_ptr->u) == DPMEM_MAGIC) { ! 984: printk("GDT-PCI: Use free address at 0x%x\n", ! 985: (int)ha->brd); ! 986: found = TRUE; ! 987: break; ! 988: } ! 989: } ! 990: if (!found) { ! 991: printk("GDT-PCI: No free address found!\n"); ! 992: gdth_munmap( ha->brd ); ! 993: return 0; ! 994: } ! 995: } ! 996: memset_io((char *)&dp6m_ptr->u,0,sizeof(dp6m_ptr->u)); ! 997: ! 998: /* disable board interrupts, deinit services */ ! 999: writeb(readb(&dp6m_ptr->i960r.edoor_en_reg) | 4, ! 1000: &dp6m_ptr->i960r.edoor_en_reg); ! 1001: writeb(0xff, &dp6m_ptr->i960r.edoor_reg); ! 1002: writeb(0x00, &dp6m_ptr->u.ic.S_Status); ! 1003: writeb(0x00, &dp6m_ptr->u.ic.Cmd_Index); ! 1004: ! 1005: writel(pcistr->dpmem, &dp6m_ptr->u.ic.S_Info[0]); ! 1006: writeb(0xff, &dp6m_ptr->u.ic.S_Cmd_Indx); ! 1007: writeb(1, &dp6m_ptr->i960r.ldoor_reg); ! 1008: retries = INIT_RETRIES; ! 1009: gdth_delay(20); ! 1010: while (readb(&dp6m_ptr->u.ic.S_Status) != 0xff) { ! 1011: if (--retries == 0) { ! 1012: printk("GDT-PCI: Initialization error (DEINIT failed)\n"); ! 1013: gdth_munmap(ha->brd); ! 1014: return 0; ! 1015: } ! 1016: gdth_delay(1); ! 1017: } ! 1018: prot_ver = (unchar)readl(&dp6m_ptr->u.ic.S_Info[0]); ! 1019: writeb(0, &dp6m_ptr->u.ic.S_Status); ! 1020: if (prot_ver != PROTOCOL_VERSION) { ! 1021: printk("GDT-PCI: Illegal protocol version\n"); ! 1022: gdth_munmap(ha->brd); ! 1023: return 0; ! 1024: } ! 1025: ! 1026: ha->type = GDT_PCIMPR; ! 1027: ha->ic_all_size = sizeof(dp6m_ptr->u); ! 1028: ! 1029: /* special command to controller BIOS */ ! 1030: writel(0x00, &dp6m_ptr->u.ic.S_Info[0]); ! 1031: writel(0x00, &dp6m_ptr->u.ic.S_Info[1]); ! 1032: writel(0x01, &dp6m_ptr->u.ic.S_Info[2]); ! 1033: writel(0x00, &dp6m_ptr->u.ic.S_Info[3]); ! 1034: writeb(0xfe, &dp6m_ptr->u.ic.S_Cmd_Indx); ! 1035: writeb(1, &dp6m_ptr->i960r.ldoor_reg); ! 1036: retries = INIT_RETRIES; ! 1037: gdth_delay(20); ! 1038: while (readb(&dp6m_ptr->u.ic.S_Status) != 0xfe) { ! 1039: if (--retries == 0) { ! 1040: printk("GDT-PCI: Initialization error\n"); ! 1041: gdth_munmap(ha->brd); ! 1042: return 0; ! 1043: } ! 1044: gdth_delay(1); ! 1045: } ! 1046: writeb(0, &dp6m_ptr->u.ic.S_Status); ! 1047: } ! 1048: ! 1049: return 1; ! 1050: } ! 1051: ! 1052: ! 1053: /* controller protocol functions */ ! 1054: ! 1055: __initfunc (static void gdth_enable_int(int hanum)) ! 1056: { ! 1057: gdth_ha_str *ha; ! 1058: ulong flags; ! 1059: gdt2_dpram_str *dp2_ptr; ! 1060: gdt6_dpram_str *dp6_ptr; ! 1061: gdt6m_dpram_str *dp6m_ptr; ! 1062: ! 1063: TRACE(("gdth_enable_int() hanum %d\n",hanum)); ! 1064: ha = HADATA(gdth_ctr_tab[hanum]); ! 1065: ! 1066: save_flags(flags); ! 1067: cli(); ! 1068: ! 1069: if (ha->type == GDT_EISA) { ! 1070: outb(0xff, ha->bmic + EDOORREG); ! 1071: outb(0xff, ha->bmic + EDENABREG); ! 1072: outb(0x01, ha->bmic + EINTENABREG); ! 1073: } else if (ha->type == GDT_ISA) { ! 1074: dp2_ptr = (gdt2_dpram_str *)ha->brd; ! 1075: writeb(1, &dp2_ptr->io.irqdel); ! 1076: writeb(0, &dp2_ptr->u.ic.Cmd_Index); ! 1077: writeb(1, &dp2_ptr->io.irqen); ! 1078: } else if (ha->type == GDT_PCI) { ! 1079: dp6_ptr = (gdt6_dpram_str *)ha->brd; ! 1080: writeb(1, &dp6_ptr->io.irqdel); ! 1081: writeb(0, &dp6_ptr->u.ic.Cmd_Index); ! 1082: writeb(1, &dp6_ptr->io.irqen); ! 1083: } else if (ha->type == GDT_PCINEW) { ! 1084: outb(0xff, PTR2USHORT(&ha->plx->edoor_reg)); ! 1085: outb(0x03, PTR2USHORT(&ha->plx->control1)); ! 1086: } else if (ha->type == GDT_PCIMPR) { ! 1087: dp6m_ptr = (gdt6m_dpram_str *)ha->brd; ! 1088: writeb(0xff, &dp6m_ptr->i960r.edoor_reg); ! 1089: writeb(readb(&dp6m_ptr->i960r.edoor_en_reg) & ~4, ! 1090: &dp6m_ptr->i960r.edoor_en_reg); ! 1091: } ! 1092: restore_flags(flags); ! 1093: } ! 1094: ! 1095: ! 1096: static int gdth_get_status(unchar *pIStatus,int irq) ! 1097: { ! 1098: register gdth_ha_str *ha; ! 1099: int i; ! 1100: ! 1101: TRACE(("gdth_get_status() irq %d ctr_count %d\n", ! 1102: irq,gdth_ctr_count)); ! 1103: ! 1104: *pIStatus = 0; ! 1105: for (i=0; i<gdth_ctr_count; ++i) { ! 1106: ha = HADATA(gdth_ctr_tab[i]); ! 1107: if (ha->irq != (unchar)irq) /* check IRQ */ ! 1108: continue; ! 1109: if (ha->type == GDT_EISA) ! 1110: *pIStatus = inb((ushort)ha->bmic + EDOORREG); ! 1111: else if (ha->type == GDT_ISA) ! 1112: *pIStatus = readb(&((gdt2_dpram_str *)ha->brd)->u.ic.Cmd_Index); ! 1113: else if (ha->type == GDT_PCI) ! 1114: *pIStatus = readb(&((gdt6_dpram_str *)ha->brd)->u.ic.Cmd_Index); ! 1115: else if (ha->type == GDT_PCINEW) ! 1116: *pIStatus = inb(PTR2USHORT(&ha->plx->edoor_reg)); ! 1117: else if (ha->type == GDT_PCIMPR) ! 1118: *pIStatus = readb(&((gdt6m_dpram_str *)ha->brd)->i960r.edoor_reg); ! 1119: ! 1120: if (*pIStatus) ! 1121: return i; /* board found */ ! 1122: } ! 1123: return -1; ! 1124: } ! 1125: ! 1126: ! 1127: static int gdth_test_busy(int hanum) ! 1128: { ! 1129: register gdth_ha_str *ha; ! 1130: register int gdtsema0 = 0; ! 1131: ! 1132: TRACE(("gdth_test_busy() hanum %d\n",hanum)); ! 1133: ! 1134: ha = HADATA(gdth_ctr_tab[hanum]); ! 1135: if (ha->type == GDT_EISA) ! 1136: gdtsema0 = (int)inb(ha->bmic + SEMA0REG); ! 1137: else if (ha->type == GDT_ISA) ! 1138: gdtsema0 = (int)readb(&((gdt2_dpram_str *)ha->brd)->u.ic.Sema0); ! 1139: else if (ha->type == GDT_PCI) ! 1140: gdtsema0 = (int)readb(&((gdt6_dpram_str *)ha->brd)->u.ic.Sema0); ! 1141: else if (ha->type == GDT_PCINEW) ! 1142: gdtsema0 = (int)inb(PTR2USHORT(&ha->plx->sema0_reg)); ! 1143: else if (ha->type == GDT_PCIMPR) ! 1144: gdtsema0 = (int)readb(&((gdt6m_dpram_str *)ha->brd)->i960r.sema0_reg); ! 1145: ! 1146: return (gdtsema0 & 1); ! 1147: } ! 1148: ! 1149: ! 1150: static int gdth_get_cmd_index(int hanum) ! 1151: { ! 1152: register gdth_ha_str *ha; ! 1153: int i; ! 1154: ! 1155: TRACE(("gdth_get_cmd_index() hanum %d\n",hanum)); ! 1156: ! 1157: ha = HADATA(gdth_ctr_tab[hanum]); ! 1158: for (i=0; i<GDTH_MAXCMDS; ++i) { ! 1159: if (gdth_cmd_tab[i][hanum].cmnd == UNUSED_CMND) { ! 1160: gdth_cmd_tab[i][hanum].cmnd = ha->pccb->RequestBuffer; ! 1161: gdth_cmd_tab[i][hanum].service = ha->pccb->Service; ! 1162: ha->pccb->CommandIndex = (ulong)i+2; ! 1163: return (i+2); ! 1164: } ! 1165: } ! 1166: return 0; ! 1167: } ! 1168: ! 1169: ! 1170: static void gdth_set_sema0(int hanum) ! 1171: { ! 1172: register gdth_ha_str *ha; ! 1173: ! 1174: TRACE(("gdth_set_sema0() hanum %d\n",hanum)); ! 1175: ! 1176: ha = HADATA(gdth_ctr_tab[hanum]); ! 1177: if (ha->type == GDT_EISA) ! 1178: outb(1, ha->bmic + SEMA0REG); ! 1179: else if (ha->type == GDT_ISA) ! 1180: writeb(1, &((gdt2_dpram_str *)ha->brd)->u.ic.Sema0); ! 1181: else if (ha->type == GDT_PCI) ! 1182: writeb(1, &((gdt6_dpram_str *)ha->brd)->u.ic.Sema0); ! 1183: else if (ha->type == GDT_PCINEW) ! 1184: outb(1, PTR2USHORT(&ha->plx->sema0_reg)); ! 1185: else if (ha->type == GDT_PCIMPR) ! 1186: writeb(1, &((gdt6m_dpram_str *)ha->brd)->i960r.sema0_reg); ! 1187: ! 1188: } ! 1189: ! 1190: ! 1191: static void gdth_copy_command(int hanum) ! 1192: { ! 1193: register gdth_ha_str *ha; ! 1194: register gdth_cmd_str *cmd_ptr; ! 1195: register gdt6m_dpram_str *dp6m_ptr; ! 1196: register gdt6c_dpram_str *dp6c_ptr; ! 1197: gdt6_dpram_str *dp6_ptr; ! 1198: gdt2_dpram_str *dp2_ptr; ! 1199: ushort cp_count,dp_offset,cmd_no; ! 1200: ! 1201: TRACE(("gdth_copy_command() hanum %d\n",hanum)); ! 1202: ! 1203: ha = HADATA(gdth_ctr_tab[hanum]); ! 1204: cp_count = ha->cmd_len; ! 1205: dp_offset= ha->cmd_offs_dpmem; ! 1206: cmd_no = ha->cmd_cnt; ! 1207: cmd_ptr = ha->pccb; ! 1208: ! 1209: ++ha->cmd_cnt; ! 1210: if (ha->type == GDT_EISA) ! 1211: return; /* no DPMEM, no copy */ ! 1212: ! 1213: /* set cpcount dword aligned */ ! 1214: if (cp_count & 3) ! 1215: cp_count += (4 - (cp_count & 3)); ! 1216: ! 1217: ha->cmd_offs_dpmem += cp_count; ! 1218: ! 1219: /* set offset and service, copy command to DPMEM */ ! 1220: if (ha->type == GDT_ISA) { ! 1221: dp2_ptr = (gdt2_dpram_str *)ha->brd; ! 1222: writew(dp_offset + DPMEM_COMMAND_OFFSET, ! 1223: &dp2_ptr->u.ic.comm_queue[cmd_no].offset); ! 1224: writew((ushort)cmd_ptr->Service, ! 1225: &dp2_ptr->u.ic.comm_queue[cmd_no].serv_id); ! 1226: memcpy_toio(&dp2_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count); ! 1227: } else if (ha->type == GDT_PCI) { ! 1228: dp6_ptr = (gdt6_dpram_str *)ha->brd; ! 1229: writew(dp_offset + DPMEM_COMMAND_OFFSET, ! 1230: &dp6_ptr->u.ic.comm_queue[cmd_no].offset); ! 1231: writew((ushort)cmd_ptr->Service, ! 1232: &dp6_ptr->u.ic.comm_queue[cmd_no].serv_id); ! 1233: memcpy_toio(&dp6_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count); ! 1234: } else if (ha->type == GDT_PCINEW) { ! 1235: dp6c_ptr = (gdt6c_dpram_str *)ha->brd; ! 1236: writew(dp_offset + DPMEM_COMMAND_OFFSET, ! 1237: &dp6c_ptr->u.ic.comm_queue[cmd_no].offset); ! 1238: writew((ushort)cmd_ptr->Service, ! 1239: &dp6c_ptr->u.ic.comm_queue[cmd_no].serv_id); ! 1240: memcpy_toio(&dp6c_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count); ! 1241: } else if (ha->type == GDT_PCIMPR) { ! 1242: dp6m_ptr = (gdt6m_dpram_str *)ha->brd; ! 1243: writew(dp_offset + DPMEM_COMMAND_OFFSET, ! 1244: &dp6m_ptr->u.ic.comm_queue[cmd_no].offset); ! 1245: writew((ushort)cmd_ptr->Service, ! 1246: &dp6m_ptr->u.ic.comm_queue[cmd_no].serv_id); ! 1247: memcpy_toio(&dp6m_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count); ! 1248: } ! 1249: } ! 1250: ! 1251: ! 1252: static void gdth_release_event(int hanum) ! 1253: { ! 1254: register gdth_ha_str *ha; ! 1255: ! 1256: #ifdef GDTH_STATISTICS ! 1257: ulong i,j; ! 1258: for (i=0,j=0; j<GDTH_MAXCMDS; ++j) { ! 1259: if (gdth_cmd_tab[j][hanum].cmnd != UNUSED_CMND) ! 1260: ++i; ! 1261: } ! 1262: if (max_index < i) { ! 1263: max_index = i; ! 1264: TRACE3(("GDT: max_index = %d\n",(ushort)i)); ! 1265: } ! 1266: #endif ! 1267: ! 1268: TRACE(("gdth_release_event() hanum %d\n",hanum)); ! 1269: ha = HADATA(gdth_ctr_tab[hanum]); ! 1270: ! 1271: if (ha->pccb->OpCode == GDT_INIT) ! 1272: ha->pccb->Service |= 0x80; ! 1273: ! 1274: if (ha->type == GDT_EISA) { ! 1275: outb(ha->pccb->Service, ha->bmic + LDOORREG); ! 1276: if (ha->pccb->OpCode == GDT_INIT) /* store DMA buffer */ ! 1277: outl((ulong)ha->pccb, ha->bmic + MAILBOXREG); ! 1278: } else if (ha->type == GDT_ISA) ! 1279: writeb(0, &((gdt2_dpram_str *)ha->brd)->io.event); ! 1280: else if (ha->type == GDT_PCI) ! 1281: writeb(0, &((gdt6_dpram_str *)ha->brd)->io.event); ! 1282: else if (ha->type == GDT_PCINEW) ! 1283: outb(1, PTR2USHORT(&ha->plx->ldoor_reg)); ! 1284: else if (ha->type == GDT_PCIMPR) ! 1285: writeb(1, &((gdt6m_dpram_str *)ha->brd)->i960r.ldoor_reg); ! 1286: } ! 1287: ! 1288: ! 1289: static int gdth_wait(int hanum,int index,ulong time) ! 1290: { ! 1291: gdth_ha_str *ha; ! 1292: int answer_found = FALSE; ! 1293: ! 1294: TRACE(("gdth_wait() hanum %d index %d time %ld\n",hanum,index,time)); ! 1295: ! 1296: ha = HADATA(gdth_ctr_tab[hanum]); ! 1297: if (index == 0) ! 1298: return 1; /* no wait required */ ! 1299: ! 1300: gdth_from_wait = TRUE; ! 1301: do { ! 1302: #if LINUX_VERSION_CODE >= 0x010346 ! 1303: gdth_interrupt((int)ha->irq,NULL,NULL); ! 1304: #else ! 1305: gdth_interrupt((int)ha->irq,NULL); ! 1306: #endif ! 1307: if (wait_hanum==hanum && wait_index==index) { ! 1308: answer_found = TRUE; ! 1309: break; ! 1310: } ! 1311: gdth_delay(1); ! 1312: } while (--time); ! 1313: gdth_from_wait = FALSE; ! 1314: ! 1315: while (gdth_test_busy(hanum)) ! 1316: gdth_delay(0); ! 1317: ! 1318: return (answer_found); ! 1319: } ! 1320: ! 1321: ! 1322: static int gdth_internal_cmd(int hanum,unchar service,ushort opcode,ulong p1, ! 1323: ulong p2,ulong p3) ! 1324: { ! 1325: register gdth_ha_str *ha; ! 1326: register gdth_cmd_str *cmd_ptr; ! 1327: int retries,index; ! 1328: ! 1329: TRACE2(("gdth_internal_cmd() service %d opcode %d\n",service,opcode)); ! 1330: ! 1331: ha = HADATA(gdth_ctr_tab[hanum]); ! 1332: cmd_ptr = ha->pccb; ! 1333: memset((char*)cmd_ptr,0,sizeof(gdth_cmd_str)); ! 1334: ! 1335: /* make command */ ! 1336: for (retries = INIT_RETRIES;;) { ! 1337: cmd_ptr->Service = service; ! 1338: cmd_ptr->RequestBuffer = INTERNAL_CMND; ! 1339: if (!(index=gdth_get_cmd_index(hanum))) { ! 1340: TRACE(("GDT: No free command index found\n")); ! 1341: return 0; ! 1342: } ! 1343: gdth_set_sema0(hanum); ! 1344: cmd_ptr->OpCode = opcode; ! 1345: cmd_ptr->BoardNode = LOCALBOARD; ! 1346: if (service == CACHESERVICE) { ! 1347: if (opcode == GDT_IOCTL) { ! 1348: cmd_ptr->u.ioctl.subfunc = p1; ! 1349: cmd_ptr->u.ioctl.channel = p2; ! 1350: cmd_ptr->u.ioctl.param_size = (ushort)p3; ! 1351: cmd_ptr->u.ioctl.p_param = virt_to_bus(ha->pscratch); ! 1352: } else { ! 1353: cmd_ptr->u.cache.DeviceNo = (ushort)p1; ! 1354: cmd_ptr->u.cache.BlockNo = p2; ! 1355: } ! 1356: } else if (service == SCSIRAWSERVICE) { ! 1357: cmd_ptr->u.raw.direction = p1; ! 1358: cmd_ptr->u.raw.bus = (unchar)p2; ! 1359: cmd_ptr->u.raw.target = (unchar)p3; ! 1360: cmd_ptr->u.raw.lun = 0; ! 1361: } ! 1362: ha->cmd_len = sizeof(gdth_cmd_str); ! 1363: ha->cmd_offs_dpmem = 0; ! 1364: ha->cmd_cnt = 0; ! 1365: gdth_copy_command(hanum); ! 1366: gdth_release_event(hanum); ! 1367: gdth_delay(20); ! 1368: if (!gdth_wait(hanum,index,INIT_TIMEOUT)) { ! 1369: printk("GDT: Initialization error (timeout service %d)\n",service); ! 1370: return 0; ! 1371: } ! 1372: if (ha->status != S_BSY || --retries == 0) ! 1373: break; ! 1374: gdth_delay(1); ! 1375: } ! 1376: ! 1377: return (ha->status != S_OK ? 0:1); ! 1378: } ! 1379: ! 1380: ! 1381: /* search for devices */ ! 1382: ! 1383: __initfunc (static int gdth_search_drives(int hanum)) ! 1384: { ! 1385: register gdth_ha_str *ha; ! 1386: ushort cdev_cnt,i; ! 1387: unchar b,t,pos_found; ! 1388: ulong drv_cyls, drv_hds, drv_secs; ! 1389: ulong bus_no; ! 1390: gdth_getch_str *chn; ! 1391: gdth_iochan_str *ioc; ! 1392: ! 1393: TRACE(("gdth_search_drives() hanum %d\n",hanum)); ! 1394: ha = HADATA(gdth_ctr_tab[hanum]); ! 1395: ! 1396: /* initialize controller services, at first: screen service */ ! 1397: if (!gdth_internal_cmd(hanum,SCREENSERVICE,GDT_INIT,0,0,0)) { ! 1398: printk("GDT: Initialization error screen service (code %d)\n", ! 1399: ha->status); ! 1400: return 0; ! 1401: } ! 1402: TRACE2(("gdth_search_drives(): SCREENSERVICE initialized\n")); ! 1403: ! 1404: /* initialize cache service */ ! 1405: if (!gdth_internal_cmd(hanum,CACHESERVICE,GDT_INIT,LINUX_OS,0,0)) { ! 1406: printk("GDT: Initialization error cache service (code %d)\n", ! 1407: ha->status); ! 1408: return 0; ! 1409: } ! 1410: TRACE2(("gdth_search_drives(): CACHESERVICE initialized\n")); ! 1411: cdev_cnt = (ushort)ha->info; ! 1412: ! 1413: /* mount all cache devices */ ! 1414: gdth_internal_cmd(hanum,CACHESERVICE,GDT_MOUNT,0xffff,1,0); ! 1415: TRACE2(("gdth_search_drives(): mountall CACHESERVICE OK\n")); ! 1416: ! 1417: /* initialize cache service after mountall */ ! 1418: if (!gdth_internal_cmd(hanum,CACHESERVICE,GDT_INIT,LINUX_OS,0,0)) { ! 1419: printk("GDT: Initialization error cache service (code %d)\n", ! 1420: ha->status); ! 1421: return 0; ! 1422: } ! 1423: TRACE2(("gdth_search_drives() CACHES. init. after mountall\n")); ! 1424: cdev_cnt = (ushort)ha->info; ! 1425: ! 1426: /* detect number of SCSI buses - try new IOCTL */ ! 1427: ioc = (gdth_iochan_str *)DMADATA(gdth_ctr_tab[hanum]); ! 1428: ioc->version = -1UL; ! 1429: ioc->list_entries = MAXBUS; ! 1430: ioc->first_chan = 0; ! 1431: ioc->last_chan = MAXBUS-1; ! 1432: ioc->list_offset = GDTOFFSOF(gdth_iochan_str, list[0]); ! 1433: if (gdth_internal_cmd(hanum,CACHESERVICE,GDT_IOCTL,GET_IOCHAN_DESC, ! 1434: INVALID_CHANNEL,sizeof(gdth_iochan_str))) { ! 1435: TRACE2(("GET_IOCHAN_DESC supported!\n")); ! 1436: ha->bus_cnt = ioc->chan_count; ! 1437: for (bus_no = 0; bus_no < ha->bus_cnt; ++bus_no) ! 1438: if (ioc->list[bus_no].proc_id < MAXID) ! 1439: ha->id[bus_no][ioc->list[bus_no].proc_id].type = SIOP_DTYP; ! 1440: } else { ! 1441: /* old method */ ! 1442: chn = (gdth_getch_str *)DMADATA(gdth_ctr_tab[hanum]); ! 1443: for (bus_no = 0; bus_no < MAXBUS; ++bus_no) { ! 1444: chn->channel_no = bus_no; ! 1445: if (!gdth_internal_cmd(hanum,CACHESERVICE,GDT_IOCTL, ! 1446: SCSI_CHAN_CNT | L_CTRL_PATTERN, ! 1447: IO_CHANNEL | INVALID_CHANNEL, ! 1448: sizeof(gdth_getch_str))) { ! 1449: if (bus_no == 0) { ! 1450: printk("GDT: Error detecting SCSI channel count (0x%x)\n", ! 1451: ha->status); ! 1452: return 0; ! 1453: } ! 1454: break; ! 1455: } ! 1456: if (chn->siop_id < MAXID) ! 1457: ha->id[bus_no][chn->siop_id].type = SIOP_DTYP; ! 1458: } ! 1459: ha->bus_cnt = (unchar)bus_no; ! 1460: } ! 1461: TRACE2(("gdth_search_drives() %d SCSI channels\n",ha->bus_cnt)); ! 1462: ! 1463: /* read cache configuration */ ! 1464: if (!gdth_internal_cmd(hanum,CACHESERVICE,GDT_IOCTL,CACHE_INFO, ! 1465: INVALID_CHANNEL,sizeof(gdth_cinfo_str))) { ! 1466: printk("GDT: Initialization error cache service (code %d)\n", ! 1467: ha->status); ! 1468: return 0; ! 1469: } ! 1470: ha->cpar = ((gdth_cinfo_str *)DMADATA(gdth_ctr_tab[hanum]))->cpar; ! 1471: TRACE2(("gdth_search_drives() cinfo: vs %lx sta %d str %d dw %d b %d\n", ! 1472: ha->cpar.version,ha->cpar.state,ha->cpar.strategy, ! 1473: ha->cpar.write_back,ha->cpar.block_size)); ! 1474: ! 1475: /* read board info, fill ctr_name[] */ ! 1476: if (gdth_internal_cmd(hanum,CACHESERVICE,GDT_IOCTL,BOARD_INFO, ! 1477: INVALID_CHANNEL,sizeof(gdth_binfo_str))) { ! 1478: TRACE2(("BOARD_INFO supported!\n")); ! 1479: strcpy(ha->ctr_name, ((gdth_binfo_str *)DMADATA(gdth_ctr_tab[hanum]))->type_string); ! 1480: } else { ! 1481: strcpy(ha->ctr_name, gdth_ctr_name(hanum)); ! 1482: } ! 1483: TRACE2(("Controller name: %s\n",ha->ctr_name)); ! 1484: ! 1485: /* initialize raw service */ ! 1486: if (!gdth_internal_cmd(hanum,SCSIRAWSERVICE,GDT_INIT,0,0,0)) { ! 1487: printk("GDT: Initialization error raw service (code %d)\n", ! 1488: ha->status); ! 1489: return 0; ! 1490: } ! 1491: TRACE2(("gdth_search_drives(): RAWSERVICE initialized\n")); ! 1492: ! 1493: /* set/get features raw service (scatter/gather) */ ! 1494: ha->raw_feat = 0; ! 1495: if (gdth_internal_cmd(hanum,SCSIRAWSERVICE,GDT_SET_FEAT,SCATTER_GATHER, ! 1496: 0,0)) { ! 1497: TRACE2(("gdth_search_drives(): set features RAWSERVICE OK\n")); ! 1498: if (gdth_internal_cmd(hanum,SCSIRAWSERVICE,GDT_GET_FEAT,0,0,0)) { ! 1499: TRACE2(("gdth_search_dr(): get feat RAWSERVICE %ld\n", ! 1500: ha->info)); ! 1501: ha->raw_feat = (ushort)ha->info; ! 1502: } ! 1503: } ! 1504: ! 1505: /* set/get features cache service (equal to raw service) */ ! 1506: if (gdth_internal_cmd(hanum,CACHESERVICE,GDT_SET_FEAT,0, ! 1507: SCATTER_GATHER,0)) { ! 1508: TRACE2(("gdth_search_drives(): set features CACHESERVICE OK\n")); ! 1509: if (gdth_internal_cmd(hanum,CACHESERVICE,GDT_GET_FEAT,0,0,0)) { ! 1510: TRACE2(("gdth_search_dr(): get feat CACHESERV. %ld\n", ! 1511: ha->info)); ! 1512: ha->cache_feat = (ushort)ha->info; ! 1513: } ! 1514: } ! 1515: ! 1516: /* reserve drives for raw service */ ! 1517: for (i = 0; reserve_list[i].hanum != 0xff; ++i) { ! 1518: if (reserve_list[i].hanum < MAXHA && reserve_list[i].hanum == hanum && ! 1519: reserve_list[i].bus < MAXBUS && reserve_list[i].id < MAXID) { ! 1520: TRACE2(("gdth_search_drives(): reserve ha %d bus %d id %d\n", ! 1521: reserve_list[i].hanum, reserve_list[i].bus, ! 1522: reserve_list[i].id)); ! 1523: if (!gdth_internal_cmd(hanum,SCSIRAWSERVICE,GDT_RESERVE,0, ! 1524: reserve_list[i].bus, reserve_list[i].id)) { ! 1525: printk("GDT: Error raw service (RESERVE, code %d)\n", ! 1526: ha->status); ! 1527: } ! 1528: } ! 1529: } ! 1530: ! 1531: /* scanning for raw devices */ ! 1532: for (b=0; b<ha->bus_cnt; ++b) { ! 1533: for (t=0; t<MAXID; ++t) { ! 1534: TRACE(("gdth_search_drives() rawd. bus %d id %d\n",b,t)); ! 1535: if (ha->id[b][t].type != SIOP_DTYP && ! 1536: gdth_internal_cmd(hanum,SCSIRAWSERVICE,GDT_INFO,0,b,t)) { ! 1537: ha->id[b][t].type = RAW_DTYP; ! 1538: } ! 1539: } ! 1540: } ! 1541: ! 1542: /* scanning for cache devices */ ! 1543: for (i=0; i<cdev_cnt && i<MAX_HDRIVES; ++i) { ! 1544: TRACE(("gdth_search_drives() cachedev. %d\n",i)); ! 1545: if (gdth_internal_cmd(hanum,CACHESERVICE,GDT_INFO,i,0,0)) { ! 1546: /* dynamic relation between host drive number and Bus/ID */ ! 1547: /* search free position */ ! 1548: pos_found = FALSE; ! 1549: for (b=0,t=0; b<ha->bus_cnt; ++b) { ! 1550: for (t=0; t<MAXID; ++t) { ! 1551: if (ha->id[b][t].type == EMPTY_DTYP) { ! 1552: pos_found = TRUE; ! 1553: break; ! 1554: } ! 1555: } ! 1556: if (pos_found) ! 1557: break; ! 1558: } ! 1559: TRACE(("gdth_search_dr() drive %d free pos at bus/id %d/%d\n", ! 1560: i,b,t)); ! 1561: ! 1562: ha->id[b][t].type = CACHE_DTYP; ! 1563: ha->id[b][t].devtype = 0; ! 1564: ha->id[b][t].size = ha->info; ! 1565: ha->id[b][t].hostdrive = i; ! 1566: ! 1567: /* evaluate mapping (sectors per head, heads per cylinder) */ ! 1568: ha->id[b][t].size &= ~SECS32; ! 1569: if (ha->info2 == 0) { ! 1570: drv_cyls = ha->id[b][t].size /HEADS/SECS; ! 1571: if (drv_cyls <= MAXCYLS) { ! 1572: drv_hds = HEADS; ! 1573: drv_secs= SECS; ! 1574: } else { /* too high for 64*32 */ ! 1575: drv_cyls = ha->id[b][t].size /MEDHEADS/MEDSECS; ! 1576: if (drv_cyls <= MAXCYLS) { ! 1577: drv_hds = MEDHEADS; ! 1578: drv_secs= MEDSECS; ! 1579: } else { /* too high for 127*63 */ ! 1580: drv_cyls = ha->id[b][t].size /BIGHEADS/BIGSECS; ! 1581: drv_hds = BIGHEADS; ! 1582: drv_secs= BIGSECS; ! 1583: } ! 1584: } ! 1585: } else { ! 1586: drv_hds = ha->info2 & 0xff; ! 1587: drv_secs = (ha->info2 >> 8) & 0xff; ! 1588: drv_cyls = ha->id[b][t].size /drv_hds/drv_secs; ! 1589: } ! 1590: ha->id[b][t].heads = (unchar)drv_hds; ! 1591: ha->id[b][t].secs = (unchar)drv_secs; ! 1592: /* round size */ ! 1593: ha->id[b][t].size = drv_cyls * drv_hds * drv_secs; ! 1594: TRACE2(("gdth_search_dr() cdr. %d size %ld hds %ld scs %ld\n", ! 1595: i,ha->id[b][t].size,drv_hds,drv_secs)); ! 1596: ! 1597: /* get informations about device */ ! 1598: if (gdth_internal_cmd(hanum,CACHESERVICE,GDT_DEVTYPE,i, ! 1599: 0,0)) { ! 1600: TRACE(("gdth_search_dr() cache drive %d devtype %ld\n", ! 1601: i,ha->info)); ! 1602: ha->id[b][t].devtype = (ushort)ha->info; ! 1603: } ! 1604: } ! 1605: } ! 1606: ! 1607: TRACE(("gdth_search_drives() OK\n")); ! 1608: return 1; ! 1609: } ! 1610: ! 1611: ! 1612: /* command queueing/sending functions */ ! 1613: ! 1614: static void gdth_putq(int hanum,Scsi_Cmnd *scp,unchar priority) ! 1615: { ! 1616: register gdth_ha_str *ha; ! 1617: register Scsi_Cmnd *pscp; ! 1618: register Scsi_Cmnd *nscp; ! 1619: ulong flags; ! 1620: unchar b, t; ! 1621: ! 1622: TRACE(("gdth_putq() priority %d\n",priority)); ! 1623: save_flags(flags); ! 1624: cli(); ! 1625: ! 1626: ha = HADATA(gdth_ctr_tab[hanum]); ! 1627: scp->SCp.this_residual = (int)priority; ! 1628: gdth_update_timeout(hanum, scp, scp->timeout_per_command * 6); ! 1629: #if LINUX_VERSION_CODE >= 0x020000 ! 1630: b = scp->channel; ! 1631: #else ! 1632: b = NUMDATA(nscp->host)->busnum; ! 1633: #endif ! 1634: t = scp->target; ! 1635: #if LINUX_VERSION_CODE >= 0x010300 ! 1636: if (priority >= DEFAULT_PRI && ha->id[b][t].lock) { ! 1637: TRACE2(("gdth_putq(): locked IO -> update_timeout()\n")); ! 1638: scp->SCp.buffers_residual = gdth_update_timeout(hanum, scp, 0); ! 1639: } ! 1640: #endif ! 1641: ! 1642: if (ha->req_first==NULL) { ! 1643: ha->req_first = scp; /* queue was empty */ ! 1644: scp->SCp.ptr = NULL; ! 1645: } else { /* queue not empty */ ! 1646: pscp = ha->req_first; ! 1647: nscp = (Scsi_Cmnd *)pscp->SCp.ptr; ! 1648: /* priority: 0-highest,..,0xff-lowest */ ! 1649: while (nscp && (unchar)nscp->SCp.this_residual <= priority) { ! 1650: pscp = nscp; ! 1651: nscp = (Scsi_Cmnd *)pscp->SCp.ptr; ! 1652: } ! 1653: pscp->SCp.ptr = (char *)scp; ! 1654: scp->SCp.ptr = (char *)nscp; ! 1655: } ! 1656: restore_flags(flags); ! 1657: ! 1658: #ifdef GDTH_STATISTICS ! 1659: flags = 0; ! 1660: for (nscp=ha->req_first; nscp; nscp=(Scsi_Cmnd*)nscp->SCp.ptr) ! 1661: ++flags; ! 1662: if (max_rq < flags) { ! 1663: max_rq = flags; ! 1664: TRACE3(("GDT: max_rq = %d\n",(ushort)max_rq)); ! 1665: } ! 1666: #endif ! 1667: } ! 1668: ! 1669: static void gdth_next(int hanum) ! 1670: { ! 1671: register gdth_ha_str *ha; ! 1672: register Scsi_Cmnd *pscp; ! 1673: register Scsi_Cmnd *nscp; ! 1674: unchar b, t, next_cmd, firsttime; ! 1675: ushort hdrive; ! 1676: ulong flags; ! 1677: int cmd_index; ! 1678: ! 1679: TRACE(("gdth_next() hanum %d\n",hanum)); ! 1680: save_flags(flags); ! 1681: cli(); ! 1682: ! 1683: ha = HADATA(gdth_ctr_tab[hanum]); ! 1684: ha->cmd_cnt = ha->cmd_offs_dpmem = 0; ! 1685: next_cmd = firsttime = TRUE; ! 1686: cmd_index = 0; ! 1687: ! 1688: for (nscp = pscp = ha->req_first; nscp; nscp = (Scsi_Cmnd *)nscp->SCp.ptr) { ! 1689: if (nscp != pscp && nscp != (Scsi_Cmnd *)pscp->SCp.ptr) ! 1690: pscp = (Scsi_Cmnd *)pscp->SCp.ptr; ! 1691: #if LINUX_VERSION_CODE >= 0x020000 ! 1692: b = nscp->channel; ! 1693: #else ! 1694: b = NUMDATA(nscp->host)->busnum; ! 1695: #endif ! 1696: t = nscp->target; ! 1697: if (nscp->SCp.this_residual < DEFAULT_PRI || !ha->id[b][t].lock) { ! 1698: ! 1699: if (firsttime) { ! 1700: if (gdth_test_busy(hanum)) { /* controller busy ? */ ! 1701: TRACE(("gdth_next() controller %d busy !\n",hanum)); ! 1702: if (!gdth_polling) { ! 1703: restore_flags(flags); ! 1704: return; ! 1705: } ! 1706: while (gdth_test_busy(hanum)) ! 1707: gdth_delay(1); ! 1708: } ! 1709: firsttime = FALSE; ! 1710: } ! 1711: ! 1712: #if LINUX_VERSION_CODE >= 0x010300 ! 1713: if (nscp->done == gdth_scsi_done) { ! 1714: if (!(cmd_index=gdth_special_cmd(hanum,nscp,b))) ! 1715: next_cmd = FALSE; ! 1716: } else ! 1717: #endif ! 1718: if (ha->id[b][t].type != CACHE_DTYP) { ! 1719: if (!(cmd_index=gdth_fill_raw_cmd(hanum,nscp,b))) ! 1720: next_cmd = FALSE; ! 1721: } else { ! 1722: hdrive = ha->id[b][t].hostdrive; ! 1723: switch (nscp->cmnd[0]) { ! 1724: case TEST_UNIT_READY: ! 1725: case INQUIRY: ! 1726: case REQUEST_SENSE: ! 1727: case READ_CAPACITY: ! 1728: case VERIFY: ! 1729: case START_STOP: ! 1730: case MODE_SENSE: ! 1731: TRACE2(("cache cmd %x/%x/%x/%x/%x/%x\n",nscp->cmnd[0], ! 1732: nscp->cmnd[1],nscp->cmnd[2],nscp->cmnd[3], ! 1733: nscp->cmnd[4],nscp->cmnd[5])); ! 1734: gdth_internal_cache_cmd(hanum,nscp,b,&flags); ! 1735: break; ! 1736: ! 1737: case ALLOW_MEDIUM_REMOVAL: ! 1738: TRACE2(("cache cmd %x/%x/%x/%x/%x/%x\n",nscp->cmnd[0], ! 1739: nscp->cmnd[1],nscp->cmnd[2],nscp->cmnd[3], ! 1740: nscp->cmnd[4],nscp->cmnd[5])); ! 1741: if ( (nscp->cmnd[4]&1) && !(ha->id[b][t].devtype&1) ) { ! 1742: TRACE2(("Prevent r. nonremov. drive->do nothing\n")); ! 1743: nscp->result = DID_OK << 16; ! 1744: restore_flags( flags ); ! 1745: if (!nscp->SCp.have_data_in) ! 1746: nscp->SCp.have_data_in++; ! 1747: else ! 1748: nscp->scsi_done(nscp); ! 1749: save_flags( flags ); ! 1750: cli(); ! 1751: } else { ! 1752: nscp->cmnd[3] = (ha->id[b][t].devtype&1) ? 1:0; ! 1753: TRACE2(("Prevent/allow r. %d rem. drive %d\n", ! 1754: nscp->cmnd[4],nscp->cmnd[3])); ! 1755: if (!(cmd_index=gdth_fill_cache_cmd(hanum,nscp,hdrive))) ! 1756: next_cmd = FALSE; ! 1757: } ! 1758: break; ! 1759: ! 1760: case READ_6: ! 1761: case WRITE_6: ! 1762: case READ_10: ! 1763: case WRITE_10: ! 1764: if (!(cmd_index=gdth_fill_cache_cmd(hanum,nscp,hdrive))) ! 1765: next_cmd = FALSE; ! 1766: break; ! 1767: ! 1768: default: ! 1769: TRACE2(("cache cmd %x/%x/%x/%x/%x/%x\n",nscp->cmnd[0], ! 1770: nscp->cmnd[1],nscp->cmnd[2],nscp->cmnd[3], ! 1771: nscp->cmnd[4],nscp->cmnd[5])); ! 1772: printk("GDT: Unknown SCSI command 0x%x to cache service !\n", ! 1773: nscp->cmnd[0]); ! 1774: nscp->result = DID_ABORT << 16; ! 1775: restore_flags( flags ); ! 1776: if (!nscp->SCp.have_data_in) ! 1777: nscp->SCp.have_data_in++; ! 1778: else ! 1779: nscp->scsi_done(nscp); ! 1780: save_flags( flags ); ! 1781: cli(); ! 1782: break; ! 1783: } ! 1784: } ! 1785: ! 1786: if (!next_cmd) ! 1787: break; ! 1788: if (nscp == ha->req_first) ! 1789: ha->req_first = pscp = (Scsi_Cmnd *)nscp->SCp.ptr; ! 1790: else ! 1791: pscp->SCp.ptr = nscp->SCp.ptr; ! 1792: if (gdth_polling) ! 1793: break; ! 1794: } ! 1795: } ! 1796: ! 1797: if (ha->cmd_cnt > 0) { ! 1798: gdth_release_event(hanum); ! 1799: } ! 1800: ! 1801: restore_flags(flags); ! 1802: ! 1803: if (gdth_polling && ha->cmd_cnt > 0) { ! 1804: if (!gdth_wait(hanum,cmd_index,POLL_TIMEOUT)) ! 1805: printk("GDT: Controller %d: Command %d timed out !\n", ! 1806: hanum,cmd_index); ! 1807: } ! 1808: } ! 1809: ! 1810: static void gdth_copy_internal_data(Scsi_Cmnd *scp,char *buffer,ushort count) ! 1811: { ! 1812: ushort cpcount,i; ! 1813: ushort cpsum,cpnow; ! 1814: struct scatterlist *sl; ! 1815: ! 1816: cpcount = count<=(ushort)scp->bufflen ? count:(ushort)scp->bufflen; ! 1817: if (scp->use_sg) { ! 1818: sl = (struct scatterlist *)scp->request_buffer; ! 1819: for (i=0,cpsum=0; i<scp->use_sg; ++i,++sl) { ! 1820: cpnow = (ushort)sl->length; ! 1821: TRACE(("copy_internal() now %d sum %d count %d %d\n", ! 1822: cpnow,cpsum,cpcount,(ushort)scp->bufflen)); ! 1823: if (cpsum+cpnow > cpcount) ! 1824: cpnow = cpcount - cpsum; ! 1825: cpsum += cpnow; ! 1826: memcpy((char*)sl->address,buffer,cpnow); ! 1827: if (cpsum == cpcount) ! 1828: break; ! 1829: buffer += cpnow; ! 1830: } ! 1831: } else { ! 1832: TRACE(("copy_internal() count %d\n",cpcount)); ! 1833: memcpy((char*)scp->request_buffer,buffer,cpcount); ! 1834: } ! 1835: } ! 1836: ! 1837: static int gdth_internal_cache_cmd(int hanum,Scsi_Cmnd *scp, ! 1838: unchar b,ulong *flags) ! 1839: { ! 1840: register gdth_ha_str *ha; ! 1841: ushort hdrive; ! 1842: unchar t; ! 1843: gdth_inq_data inq; ! 1844: gdth_rdcap_data rdc; ! 1845: gdth_sense_data sd; ! 1846: gdth_modep_data mpd; ! 1847: ! 1848: ha = HADATA(gdth_ctr_tab[hanum]); ! 1849: t = scp->target; ! 1850: hdrive = ha->id[b][t].hostdrive; ! 1851: TRACE(("gdth_internal_cache_cmd() cmd 0x%x hdrive %d\n", ! 1852: scp->cmnd[0],hdrive)); ! 1853: ! 1854: if (scp->lun !=0) ! 1855: scp->result = DID_BAD_TARGET << 16; ! 1856: else { ! 1857: switch (scp->cmnd[0]) { ! 1858: case TEST_UNIT_READY: ! 1859: case VERIFY: ! 1860: case START_STOP: ! 1861: TRACE2(("Test/Verify/Start hdrive %d\n",hdrive)); ! 1862: break; ! 1863: ! 1864: case INQUIRY: ! 1865: TRACE2(("Inquiry hdrive %d devtype %d\n", ! 1866: hdrive,ha->id[b][t].devtype)); ! 1867: inq.type_qual = (ha->id[b][t].devtype&4) ? TYPE_ROM:TYPE_DISK; ! 1868: /* you can here set all disks to removable, if you want to do ! 1869: a flush using the ALLOW_MEDIUM_REMOVAL command */ ! 1870: inq.modif_rmb = ha->id[b][t].devtype&1 ? 0x80:0x00; ! 1871: inq.version = 2; ! 1872: inq.resp_aenc = 2; ! 1873: inq.add_length= 32; ! 1874: strcpy(inq.vendor,"ICP "); ! 1875: sprintf(inq.product,"Host Drive #%02d",hdrive); ! 1876: strcpy(inq.revision," "); ! 1877: gdth_copy_internal_data(scp,(char*)&inq,sizeof(gdth_inq_data)); ! 1878: break; ! 1879: ! 1880: case REQUEST_SENSE: ! 1881: TRACE2(("Request sense hdrive %d\n",hdrive)); ! 1882: sd.errorcode = 0x70; ! 1883: sd.segno = 0x00; ! 1884: sd.key = NO_SENSE; ! 1885: sd.info = 0; ! 1886: sd.add_length= 0; ! 1887: gdth_copy_internal_data(scp,(char*)&sd,sizeof(gdth_sense_data)); ! 1888: break; ! 1889: ! 1890: case MODE_SENSE: ! 1891: TRACE2(("Mode sense hdrive %d\n",hdrive)); ! 1892: memset((char*)&mpd,0,sizeof(gdth_modep_data)); ! 1893: mpd.hd.data_length = sizeof(gdth_modep_data); ! 1894: mpd.hd.dev_par = (ha->id[b][t].devtype&2) ? 0x80:0; ! 1895: mpd.hd.bd_length = sizeof(mpd.bd); ! 1896: mpd.bd.block_length[0] = (SECTOR_SIZE & 0x00ff0000) >> 16; ! 1897: mpd.bd.block_length[1] = (SECTOR_SIZE & 0x0000ff00) >> 8; ! 1898: mpd.bd.block_length[2] = (SECTOR_SIZE & 0x000000ff); ! 1899: gdth_copy_internal_data(scp,(char*)&mpd,sizeof(gdth_modep_data)); ! 1900: break; ! 1901: ! 1902: case READ_CAPACITY: ! 1903: TRACE2(("Read capacity hdrive %d\n",hdrive)); ! 1904: rdc.last_block_no = ntohl(ha->id[b][t].size-1); ! 1905: rdc.block_length = ntohl(SECTOR_SIZE); ! 1906: gdth_copy_internal_data(scp,(char*)&rdc,sizeof(gdth_rdcap_data)); ! 1907: break; ! 1908: ! 1909: default: ! 1910: TRACE2(("Internal cache cmd 0x%x unknown\n",scp->cmnd[0])); ! 1911: break; ! 1912: } ! 1913: scp->result = DID_OK << 16; ! 1914: } ! 1915: ! 1916: restore_flags(*flags); ! 1917: if (!scp->SCp.have_data_in) ! 1918: scp->SCp.have_data_in++; ! 1919: else ! 1920: scp->scsi_done(scp); ! 1921: save_flags(*flags); ! 1922: cli(); ! 1923: return 1; ! 1924: } ! 1925: ! 1926: static int gdth_fill_cache_cmd(int hanum,Scsi_Cmnd *scp,ushort hdrive) ! 1927: { ! 1928: register gdth_ha_str *ha; ! 1929: register gdth_cmd_str *cmdp; ! 1930: struct scatterlist *sl; ! 1931: ushort i; ! 1932: int cmd_index; ! 1933: ! 1934: ha = HADATA(gdth_ctr_tab[hanum]); ! 1935: cmdp = ha->pccb; ! 1936: TRACE(("gdth_fill_cache_cmd() cmd 0x%x cmdsize %d hdrive %d\n", ! 1937: scp->cmnd[0],scp->cmd_len,hdrive)); ! 1938: ! 1939: if (ha->type==GDT_EISA && ha->cmd_cnt>0) ! 1940: return 0; ! 1941: ! 1942: cmdp->Service = CACHESERVICE; ! 1943: cmdp->RequestBuffer = scp; ! 1944: /* search free command index */ ! 1945: if (!(cmd_index=gdth_get_cmd_index(hanum))) { ! 1946: TRACE(("GDT: No free command index found\n")); ! 1947: return 0; ! 1948: } ! 1949: /* if it's the first command, set command semaphore */ ! 1950: if (ha->cmd_cnt == 0) ! 1951: gdth_set_sema0(hanum); ! 1952: ! 1953: /* fill command */ ! 1954: if (scp->cmnd[0]==ALLOW_MEDIUM_REMOVAL) { ! 1955: if (scp->cmnd[4] & 1) /* prevent ? */ ! 1956: cmdp->OpCode = GDT_MOUNT; ! 1957: else if (scp->cmnd[3] & 1) /* removable drive ? */ ! 1958: cmdp->OpCode = GDT_UNMOUNT; ! 1959: else ! 1960: cmdp->OpCode = GDT_FLUSH; ! 1961: } else { ! 1962: if (scp->cmnd[0]==WRITE_6 || scp->cmnd[0]==WRITE_10) { ! 1963: if (gdth_write_through) ! 1964: cmdp->OpCode = GDT_WRITE_THR; ! 1965: else ! 1966: cmdp->OpCode = GDT_WRITE; ! 1967: } else { ! 1968: cmdp->OpCode = GDT_READ; ! 1969: } ! 1970: } ! 1971: ! 1972: cmdp->BoardNode = LOCALBOARD; ! 1973: cmdp->u.cache.DeviceNo = hdrive; ! 1974: ! 1975: if (scp->cmnd[0]==ALLOW_MEDIUM_REMOVAL) { ! 1976: cmdp->u.cache.BlockNo = 1; ! 1977: cmdp->u.cache.sg_canz = 0; ! 1978: } else { ! 1979: if (scp->cmd_len != 6) { ! 1980: cmdp->u.cache.BlockNo = ntohl(*(ulong*)&scp->cmnd[2]); ! 1981: cmdp->u.cache.BlockCnt= (ulong)ntohs(*(ushort*)&scp->cmnd[7]); ! 1982: } else { ! 1983: cmdp->u.cache.BlockNo = ntohl(*(ulong*)&scp->cmnd[0]) & 0x001fffffUL; ! 1984: cmdp->u.cache.BlockCnt= scp->cmnd[4]==0 ? 0x100 : scp->cmnd[4]; ! 1985: } ! 1986: ! 1987: if (scp->use_sg) { ! 1988: cmdp->u.cache.DestAddr= -1UL; ! 1989: sl = (struct scatterlist *)scp->request_buffer; ! 1990: for (i=0; i<scp->use_sg; ++i,++sl) { ! 1991: cmdp->u.cache.sg_lst[i].sg_ptr = virt_to_bus(sl->address); ! 1992: cmdp->u.cache.sg_lst[i].sg_len = (ulong)sl->length; ! 1993: } ! 1994: cmdp->u.cache.sg_canz = (ulong)i; ! 1995: ! 1996: #ifdef GDTH_STATISTICS ! 1997: if (max_sg < (ulong)i) { ! 1998: max_sg = (ulong)i; ! 1999: TRACE3(("GDT: max_sg = %d\n",i)); ! 2000: } ! 2001: #endif ! 2002: if (i<GDTH_MAXSG) ! 2003: cmdp->u.cache.sg_lst[i].sg_len = 0; ! 2004: } else { ! 2005: if (ha->cache_feat & SCATTER_GATHER) { ! 2006: cmdp->u.cache.DestAddr = -1UL; ! 2007: cmdp->u.cache.sg_canz = 1; ! 2008: cmdp->u.cache.sg_lst[0].sg_ptr = virt_to_bus(scp->request_buffer); ! 2009: cmdp->u.cache.sg_lst[0].sg_len = scp->request_bufflen; ! 2010: cmdp->u.cache.sg_lst[1].sg_len = 0; ! 2011: } else { ! 2012: cmdp->u.cache.DestAddr = virt_to_bus(scp->request_buffer); ! 2013: cmdp->u.cache.sg_canz= 0; ! 2014: } ! 2015: } ! 2016: } ! 2017: TRACE(("cache cmd: addr. %lx sganz %lx sgptr0 %lx sglen0 %lx\n", ! 2018: cmdp->u.cache.DestAddr,cmdp->u.cache.sg_canz, ! 2019: cmdp->u.cache.sg_lst[0].sg_ptr, ! 2020: cmdp->u.cache.sg_lst[0].sg_len)); ! 2021: TRACE(("cache cmd: cmd %d blockno. %ld, blockcnt %ld\n", ! 2022: cmdp->OpCode,cmdp->u.cache.BlockNo,cmdp->u.cache.BlockCnt)); ! 2023: ! 2024: /* evaluate command size, check space */ ! 2025: ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.cache.sg_lst) + ! 2026: (ushort)cmdp->u.cache.sg_canz * sizeof(gdth_sg_str); ! 2027: if (ha->cmd_len & 3) ! 2028: ha->cmd_len += (4 - (ha->cmd_len & 3)); ! 2029: ! 2030: if (ha->cmd_cnt > 0) { ! 2031: if ((ha->cmd_offs_dpmem + ha->cmd_len + DPMEM_COMMAND_OFFSET) > ! 2032: ha->ic_all_size) { ! 2033: TRACE2(("gdth_fill_cache() DPMEM overflow\n")); ! 2034: gdth_cmd_tab[cmd_index-2][hanum].cmnd = UNUSED_CMND; ! 2035: return 0; ! 2036: } ! 2037: } ! 2038: ! 2039: /* copy command */ ! 2040: gdth_copy_command(hanum); ! 2041: return cmd_index; ! 2042: } ! 2043: ! 2044: static int gdth_fill_raw_cmd(int hanum,Scsi_Cmnd *scp,unchar b) ! 2045: { ! 2046: register gdth_ha_str *ha; ! 2047: register gdth_cmd_str *cmdp; ! 2048: struct scatterlist *sl; ! 2049: ushort i; ! 2050: int cmd_index; ! 2051: unchar t,l; ! 2052: ! 2053: ha = HADATA(gdth_ctr_tab[hanum]); ! 2054: t = scp->target; ! 2055: l = scp->lun; ! 2056: cmdp = ha->pccb; ! 2057: TRACE(("gdth_fill_raw_cmd() cmd 0x%x bus %d ID %d LUN %d\n", ! 2058: scp->cmnd[0],b,t,l)); ! 2059: ! 2060: if (ha->type==GDT_EISA && ha->cmd_cnt>0) ! 2061: return 0; ! 2062: ! 2063: cmdp->Service = SCSIRAWSERVICE; ! 2064: cmdp->RequestBuffer = scp; ! 2065: /* search free command index */ ! 2066: if (!(cmd_index=gdth_get_cmd_index(hanum))) { ! 2067: TRACE(("GDT: No free command index found\n")); ! 2068: return 0; ! 2069: } ! 2070: /* if it's the first command, set command semaphore */ ! 2071: if (ha->cmd_cnt == 0) ! 2072: gdth_set_sema0(hanum); ! 2073: ! 2074: /* fill command */ ! 2075: cmdp->OpCode = GDT_WRITE; /* always */ ! 2076: cmdp->BoardNode = LOCALBOARD; ! 2077: cmdp->u.raw.reserved = 0; ! 2078: cmdp->u.raw.mdisc_time = 0; ! 2079: cmdp->u.raw.mcon_time = 0; ! 2080: cmdp->u.raw.clen = scp->cmd_len; ! 2081: cmdp->u.raw.target = t; ! 2082: cmdp->u.raw.lun = l; ! 2083: cmdp->u.raw.bus = b; ! 2084: cmdp->u.raw.priority = 0; ! 2085: cmdp->u.raw.link_p = NULL; ! 2086: cmdp->u.raw.sdlen = scp->request_bufflen; ! 2087: cmdp->u.raw.sense_len = 16; ! 2088: cmdp->u.raw.sense_data = virt_to_bus(scp->sense_buffer); ! 2089: cmdp->u.raw.direction = ! 2090: gdth_direction_tab[scp->cmnd[0]]==DOU ? DATA_OUT : DATA_IN; ! 2091: memcpy(cmdp->u.raw.cmd,scp->cmnd,12); ! 2092: ! 2093: if (scp->use_sg) { ! 2094: cmdp->u.raw.sdata = -1UL; ! 2095: sl = (struct scatterlist *)scp->request_buffer; ! 2096: for (i=0; i<scp->use_sg; ++i,++sl) { ! 2097: cmdp->u.raw.sg_lst[i].sg_ptr = virt_to_bus(sl->address); ! 2098: cmdp->u.raw.sg_lst[i].sg_len = (ulong)sl->length; ! 2099: } ! 2100: cmdp->u.raw.sg_ranz = (ulong)i; ! 2101: ! 2102: #ifdef GDTH_STATISTICS ! 2103: if (max_sg < (ulong)i) { ! 2104: max_sg = (ulong)i; ! 2105: TRACE3(("GDT: max_sg = %d\n",i)); ! 2106: } ! 2107: #endif ! 2108: if (i<GDTH_MAXSG) ! 2109: cmdp->u.raw.sg_lst[i].sg_len = 0; ! 2110: } else { ! 2111: if (ha->raw_feat & SCATTER_GATHER) { ! 2112: cmdp->u.raw.sdata = -1UL; ! 2113: cmdp->u.raw.sg_ranz= 1; ! 2114: cmdp->u.raw.sg_lst[0].sg_ptr = virt_to_bus(scp->request_buffer); ! 2115: cmdp->u.raw.sg_lst[0].sg_len = scp->request_bufflen; ! 2116: cmdp->u.raw.sg_lst[1].sg_len = 0; ! 2117: } else { ! 2118: cmdp->u.raw.sdata = virt_to_bus(scp->request_buffer); ! 2119: cmdp->u.raw.sg_ranz= 0; ! 2120: } ! 2121: } ! 2122: TRACE(("raw cmd: addr. %lx sganz %lx sgptr0 %lx sglen0 %lx\n", ! 2123: cmdp->u.raw.sdata,cmdp->u.raw.sg_ranz, ! 2124: cmdp->u.raw.sg_lst[0].sg_ptr, ! 2125: cmdp->u.raw.sg_lst[0].sg_len)); ! 2126: ! 2127: /* evaluate command size, check space */ ! 2128: ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.raw.sg_lst) + ! 2129: (ushort)cmdp->u.raw.sg_ranz * sizeof(gdth_sg_str); ! 2130: if (ha->cmd_len & 3) ! 2131: ha->cmd_len += (4 - (ha->cmd_len & 3)); ! 2132: ! 2133: if (ha->cmd_cnt > 0) { ! 2134: if ((ha->cmd_offs_dpmem + ha->cmd_len + DPMEM_COMMAND_OFFSET) > ! 2135: ha->ic_all_size) { ! 2136: TRACE2(("gdth_fill_raw() DPMEM overflow\n")); ! 2137: gdth_cmd_tab[cmd_index-2][hanum].cmnd = UNUSED_CMND; ! 2138: return 0; ! 2139: } ! 2140: } ! 2141: ! 2142: /* copy command */ ! 2143: gdth_copy_command(hanum); ! 2144: return cmd_index; ! 2145: } ! 2146: ! 2147: static int gdth_special_cmd(int hanum,Scsi_Cmnd *scp,unchar b) ! 2148: { ! 2149: register gdth_ha_str *ha; ! 2150: register gdth_cmd_str *cmdp; ! 2151: int cmd_index; ! 2152: ! 2153: ha = HADATA(gdth_ctr_tab[hanum]); ! 2154: cmdp= ha->pccb; ! 2155: TRACE2(("gdth_special_cmd(): ")); ! 2156: ! 2157: if (ha->type==GDT_EISA && ha->cmd_cnt>0) ! 2158: return 0; ! 2159: ! 2160: memcpy( cmdp, scp->request_buffer, sizeof(gdth_cmd_str)); ! 2161: cmdp->RequestBuffer = scp; ! 2162: ! 2163: /* search free command index */ ! 2164: if (!(cmd_index=gdth_get_cmd_index(hanum))) { ! 2165: TRACE(("GDT: No free command index found\n")); ! 2166: return 0; ! 2167: } ! 2168: ! 2169: /* if it's the first command, set command semaphore */ ! 2170: if (ha->cmd_cnt == 0) ! 2171: gdth_set_sema0(hanum); ! 2172: ! 2173: /* evaluate command size, check space */ ! 2174: if (cmdp->OpCode == GDT_IOCTL) { ! 2175: TRACE2(("IOCTL\n")); ! 2176: ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.ioctl.p_param) + sizeof(ulong); ! 2177: } else if (cmdp->Service == CACHESERVICE) { ! 2178: TRACE2(("cache command %d\n",cmdp->OpCode)); ! 2179: ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.cache.sg_lst) + sizeof(gdth_sg_str); ! 2180: } else if (cmdp->Service == SCSIRAWSERVICE) { ! 2181: TRACE2(("raw command %d/%d\n",cmdp->OpCode,cmdp->u.raw.cmd[0])); ! 2182: ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.raw.sg_lst) + sizeof(gdth_sg_str); ! 2183: } ! 2184: ! 2185: if (ha->cmd_len & 3) ! 2186: ha->cmd_len += (4 - (ha->cmd_len & 3)); ! 2187: ! 2188: if (ha->cmd_cnt > 0) { ! 2189: if ((ha->cmd_offs_dpmem + ha->cmd_len + DPMEM_COMMAND_OFFSET) > ! 2190: ha->ic_all_size) { ! 2191: TRACE2(("gdth_special_cmd() DPMEM overflow\n")); ! 2192: gdth_cmd_tab[cmd_index-2][hanum].cmnd = UNUSED_CMND; ! 2193: return 0; ! 2194: } ! 2195: } ! 2196: ! 2197: /* copy command */ ! 2198: gdth_copy_command(hanum); ! 2199: return cmd_index; ! 2200: } ! 2201: ! 2202: ! 2203: /* Controller event handling functions */ ! 2204: static gdth_evt_str *gdth_store_event(ushort source, ushort idx, ! 2205: gdth_evt_data *evt) ! 2206: { ! 2207: gdth_evt_str *e; ! 2208: ulong flags; ! 2209: struct timeval tv; ! 2210: ! 2211: TRACE2(("gdth_store_event() source %d idx %d\n", source, idx)); ! 2212: if (source == 0) /* no source -> no event */ ! 2213: return 0; ! 2214: ! 2215: save_flags(flags); ! 2216: cli(); ! 2217: if (ebuffer[elastidx].event_source == source && ! 2218: ebuffer[elastidx].event_idx == idx && ! 2219: !memcmp((char *)&ebuffer[elastidx].event_data.eu, ! 2220: (char *)&evt->eu, evt->size)) { ! 2221: e = &ebuffer[elastidx]; ! 2222: do_gettimeofday(&tv); ! 2223: e->last_stamp = tv.tv_sec; ! 2224: ++e->same_count; ! 2225: } else { ! 2226: if (ebuffer[elastidx].event_source != 0) { /* entry not free ? */ ! 2227: ++elastidx; ! 2228: if (elastidx == MAX_EVENTS) ! 2229: elastidx = 0; ! 2230: if (elastidx == eoldidx) { /* reached mark ? */ ! 2231: ++eoldidx; ! 2232: if (eoldidx == MAX_EVENTS) ! 2233: eoldidx = 0; ! 2234: } ! 2235: } ! 2236: e = &ebuffer[elastidx]; ! 2237: e->event_source = source; ! 2238: e->event_idx = idx; ! 2239: do_gettimeofday(&tv); ! 2240: e->first_stamp = e->last_stamp = tv.tv_sec; ! 2241: e->same_count = 1; ! 2242: e->event_data = *evt; ! 2243: } ! 2244: restore_flags(flags); ! 2245: return e; ! 2246: } ! 2247: ! 2248: static int gdth_read_event(int handle, gdth_evt_str *estr) ! 2249: { ! 2250: gdth_evt_str *e; ! 2251: int eindex; ! 2252: ulong flags; ! 2253: ! 2254: TRACE2(("gdth_read_event() handle %d\n", handle)); ! 2255: save_flags(flags); ! 2256: cli(); ! 2257: if (handle == -1) ! 2258: eindex = eoldidx; ! 2259: else ! 2260: eindex = handle; ! 2261: estr->event_source = 0; ! 2262: ! 2263: if (eindex >= MAX_EVENTS) { ! 2264: restore_flags(flags); ! 2265: return eindex; ! 2266: } ! 2267: e = &ebuffer[eindex]; ! 2268: if (e->event_source != 0) { ! 2269: if (eindex != elastidx) { ! 2270: if (++eindex == MAX_EVENTS) ! 2271: eindex = 0; ! 2272: } else { ! 2273: eindex = -1; ! 2274: } ! 2275: memcpy(estr, e, sizeof(gdth_evt_str)); ! 2276: } ! 2277: restore_flags(flags); ! 2278: return eindex; ! 2279: } ! 2280: ! 2281: static void gdth_readapp_event(unchar application, gdth_evt_str *estr) ! 2282: { ! 2283: gdth_evt_str *e; ! 2284: int eindex; ! 2285: ulong flags; ! 2286: unchar found = FALSE; ! 2287: ! 2288: TRACE2(("gdth_readapp_event() app. %d\n", application)); ! 2289: save_flags(flags); ! 2290: cli(); ! 2291: eindex = eoldidx; ! 2292: for (;;) { ! 2293: e = &ebuffer[eindex]; ! 2294: if (e->event_source == 0) ! 2295: break; ! 2296: if ((e->application & application) == 0) { ! 2297: e->application |= application; ! 2298: found = TRUE; ! 2299: break; ! 2300: } ! 2301: if (eindex == elastidx) ! 2302: break; ! 2303: if (++eindex == MAX_EVENTS) ! 2304: eindex = 0; ! 2305: } ! 2306: if (found) ! 2307: memcpy(estr, e, sizeof(gdth_evt_str)); ! 2308: else ! 2309: estr->event_source = 0; ! 2310: restore_flags(flags); ! 2311: } ! 2312: ! 2313: static void gdth_clear_events() ! 2314: { ! 2315: ulong flags; ! 2316: ! 2317: TRACE(("gdth_clear_events()")); ! 2318: save_flags(flags); ! 2319: cli(); ! 2320: ! 2321: eoldidx = elastidx = 0; ! 2322: ebuffer[0].event_source = 0; ! 2323: restore_flags(flags); ! 2324: } ! 2325: ! 2326: ! 2327: /* SCSI interface functions */ ! 2328: ! 2329: #if LINUX_VERSION_CODE >= 0x02015F ! 2330: static void do_gdth_interrupt(int irq,void *dev_id,struct pt_regs *regs) ! 2331: { ! 2332: ulong flags; ! 2333: ! 2334: spin_lock_irqsave(&io_request_lock, flags); ! 2335: gdth_interrupt(irq, dev_id, regs); ! 2336: spin_unlock_irqrestore(&io_request_lock, flags); ! 2337: } ! 2338: #endif ! 2339: ! 2340: #if LINUX_VERSION_CODE >= 0x010346 ! 2341: static void gdth_interrupt(int irq,void *dev_id,struct pt_regs *regs) ! 2342: #else ! 2343: static void gdth_interrupt(int irq,struct pt_regs *regs) ! 2344: #endif ! 2345: { ! 2346: register gdth_ha_str *ha; ! 2347: gdt6m_dpram_str *dp6m_ptr; ! 2348: gdt6_dpram_str *dp6_ptr; ! 2349: gdt2_dpram_str *dp2_ptr; ! 2350: Scsi_Cmnd *scp; ! 2351: int hanum; ! 2352: unchar IStatus; ! 2353: ushort CmdStatus, Service = 0; ! 2354: ulong InfoBytes, InfoBytes2 = 0; ! 2355: gdth_evt_data dvr; ! 2356: ! 2357: TRACE(("gdth_interrupt() IRQ %d\n",irq)); ! 2358: ! 2359: /* if polling and not from gdth_wait() -> return */ ! 2360: if (gdth_polling) { ! 2361: if (!gdth_from_wait) { ! 2362: return; ! 2363: } ! 2364: } ! 2365: ! 2366: wait_index = 0; ! 2367: ! 2368: /* search controller */ ! 2369: if ((hanum = gdth_get_status(&IStatus,irq)) == -1) { ! 2370: /* ! 2371: TRACE2(("gdth_interrupt(): Spurious interrupt received\n")); ! 2372: */ ! 2373: return; ! 2374: } ! 2375: ! 2376: #ifdef GDTH_STATISTICS ! 2377: ++act_ints; ! 2378: #endif ! 2379: ! 2380: ha = HADATA(gdth_ctr_tab[hanum]); ! 2381: if (ha->type == GDT_EISA) { ! 2382: if (IStatus & 0x80) { /* error flag */ ! 2383: IStatus &= ~0x80; ! 2384: CmdStatus = inw(ha->bmic + MAILBOXREG+8); ! 2385: TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,CmdStatus)); ! 2386: if (IStatus == ASYNCINDEX) { /* async. event ? */ ! 2387: Service = inw(ha->bmic + MAILBOXREG+10); ! 2388: InfoBytes2 = inl(ha->bmic + MAILBOXREG+4); ! 2389: } ! 2390: } else /* no error */ ! 2391: CmdStatus = S_OK; ! 2392: InfoBytes = inl(ha->bmic + MAILBOXREG+12); ! 2393: if (gdth_polling) /* init. -> more info */ ! 2394: InfoBytes2 = inl(ha->bmic + MAILBOXREG+4); ! 2395: outb(0xff, ha->bmic + EDOORREG); /* acknowledge interrupt */ ! 2396: outb(0x00, ha->bmic + SEMA1REG); /* reset status semaphore */ ! 2397: } else if (ha->type == GDT_ISA) { ! 2398: dp2_ptr = (gdt2_dpram_str *)ha->brd; ! 2399: if (IStatus & 0x80) { /* error flag */ ! 2400: IStatus &= ~0x80; ! 2401: CmdStatus = readw(&dp2_ptr->u.ic.Status); ! 2402: TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,CmdStatus)); ! 2403: if (IStatus == ASYNCINDEX) { /* async. event ? */ ! 2404: Service = readw(&dp2_ptr->u.ic.Service); ! 2405: InfoBytes2 = readl(&dp2_ptr->u.ic.Info[1]); ! 2406: } ! 2407: } else /* no error */ ! 2408: CmdStatus = S_OK; ! 2409: InfoBytes = readl(&dp2_ptr->u.ic.Info[0]); ! 2410: if (gdth_polling) /* init. -> more info */ ! 2411: InfoBytes2 = readl(&dp2_ptr->u.ic.Info[1]); ! 2412: writeb(0xff, &dp2_ptr->io.irqdel); /* acknowledge interrupt */ ! 2413: writeb(0, &dp2_ptr->u.ic.Cmd_Index); /* reset command index */ ! 2414: writeb(0, &dp2_ptr->io.Sema1); /* reset status semaphore */ ! 2415: } else if (ha->type == GDT_PCI) { ! 2416: dp6_ptr = (gdt6_dpram_str *)ha->brd; ! 2417: if (IStatus & 0x80) { /* error flag */ ! 2418: IStatus &= ~0x80; ! 2419: CmdStatus = readw(&dp6_ptr->u.ic.Status); ! 2420: TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,CmdStatus)); ! 2421: if (IStatus == ASYNCINDEX) { /* async. event ? */ ! 2422: Service = readw(&dp6_ptr->u.ic.Service); ! 2423: InfoBytes2 = readl(&dp6_ptr->u.ic.Info[1]); ! 2424: } ! 2425: } else /* no error */ ! 2426: CmdStatus = S_OK; ! 2427: InfoBytes = readl(&dp6_ptr->u.ic.Info[0]); ! 2428: if (gdth_polling) /* init. -> more info */ ! 2429: InfoBytes2 = readl(&dp6_ptr->u.ic.Info[1]); ! 2430: writeb(0xff, &dp6_ptr->io.irqdel); /* acknowledge interrupt */ ! 2431: writeb(0, &dp6_ptr->u.ic.Cmd_Index); /* reset command index */ ! 2432: writeb(0, &dp6_ptr->io.Sema1); /* reset status semaphore */ ! 2433: } else if (ha->type == GDT_PCINEW) { ! 2434: if (IStatus & 0x80) { /* error flag */ ! 2435: IStatus &= ~0x80; ! 2436: CmdStatus = inw(PTR2USHORT(&ha->plx->status)); ! 2437: TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,CmdStatus)); ! 2438: if (IStatus == ASYNCINDEX) { /* async. event ? */ ! 2439: Service = inw(PTR2USHORT(&ha->plx->service)); ! 2440: InfoBytes2 = inl(PTR2USHORT(&ha->plx->info[1])); ! 2441: } ! 2442: } else ! 2443: CmdStatus = S_OK; ! 2444: ! 2445: InfoBytes = inl(PTR2USHORT(&ha->plx->info[0])); ! 2446: if (gdth_polling) /* init. -> more info */ ! 2447: InfoBytes2 = inl(PTR2USHORT(&ha->plx->info[1])); ! 2448: outb(0xff, PTR2USHORT(&ha->plx->edoor_reg)); ! 2449: outb(0x00, PTR2USHORT(&ha->plx->sema1_reg)); ! 2450: } else if (ha->type == GDT_PCIMPR) { ! 2451: dp6m_ptr = (gdt6m_dpram_str *)ha->brd; ! 2452: if (IStatus & 0x80) { /* error flag */ ! 2453: IStatus &= ~0x80; ! 2454: CmdStatus = readw(&dp6m_ptr->i960r.status); ! 2455: TRACE2(("gdth_interrupt() error %d/%d\n",IStatus,CmdStatus)); ! 2456: if (IStatus == ASYNCINDEX) { /* async. event ? */ ! 2457: Service = readw(&dp6m_ptr->i960r.service); ! 2458: InfoBytes2 = readl(&dp6m_ptr->i960r.info[1]); ! 2459: } ! 2460: } else /* no error */ ! 2461: CmdStatus = S_OK; ! 2462: InfoBytes = readl(&dp6m_ptr->i960r.info[0]); ! 2463: if (gdth_polling) /* init. -> more info */ ! 2464: InfoBytes2 = readl(&dp6m_ptr->i960r.info[1]); ! 2465: writeb(0xff, &dp6m_ptr->i960r.edoor_reg); ! 2466: writeb(0, &dp6m_ptr->i960r.sema1_reg); ! 2467: } else { ! 2468: TRACE2(("gdth_interrupt() unknown controller type\n")); ! 2469: return; ! 2470: } ! 2471: ! 2472: TRACE(("gdth_interrupt() index %d stat %d info %ld\n", ! 2473: IStatus,CmdStatus,InfoBytes)); ! 2474: ha->status = CmdStatus; ! 2475: ha->info = InfoBytes; ! 2476: ha->info2 = InfoBytes2; ! 2477: ! 2478: if (gdth_from_wait) { ! 2479: wait_hanum = hanum; ! 2480: wait_index = (int)IStatus; ! 2481: } ! 2482: ! 2483: if (IStatus == ASYNCINDEX) { ! 2484: TRACE2(("gdth_interrupt() async. event\n")); ! 2485: gdth_async_event(hanum,Service); ! 2486: } else { ! 2487: if (IStatus == SPEZINDEX) { ! 2488: TRACE2(("Service unknown or not initialized !\n")); ! 2489: dvr.size = sizeof(dvr.eu.driver); ! 2490: dvr.eu.driver.ionode = hanum; ! 2491: gdth_store_event(ES_DRIVER, 4, &dvr); ! 2492: return; ! 2493: } ! 2494: scp = gdth_cmd_tab[IStatus-2][hanum].cmnd; ! 2495: Service = gdth_cmd_tab[IStatus-2][hanum].service; ! 2496: gdth_cmd_tab[IStatus-2][hanum].cmnd = UNUSED_CMND; ! 2497: if (scp == UNUSED_CMND) { ! 2498: TRACE2(("gdth_interrupt() index to unused command (%d)\n",IStatus)); ! 2499: dvr.size = sizeof(dvr.eu.driver); ! 2500: dvr.eu.driver.ionode = hanum; ! 2501: dvr.eu.driver.index = IStatus; ! 2502: gdth_store_event(ES_DRIVER, 1, &dvr); ! 2503: return; ! 2504: } ! 2505: if (scp == INTERNAL_CMND) { ! 2506: TRACE(("gdth_interrupt() answer to internal command\n")); ! 2507: return; ! 2508: } ! 2509: TRACE(("gdth_interrupt() sync. status\n")); ! 2510: gdth_sync_event(hanum,Service,IStatus,scp); ! 2511: } ! 2512: gdth_next(hanum); ! 2513: } ! 2514: ! 2515: static int gdth_sync_event(int hanum,int service,unchar index,Scsi_Cmnd *scp) ! 2516: { ! 2517: register gdth_ha_str *ha; ! 2518: gdth_msg_str *msg; ! 2519: gdth_cmd_str *cmdp; ! 2520: char c='\r'; ! 2521: ushort i; ! 2522: gdth_evt_data dvr; ! 2523: ! 2524: ha = HADATA(gdth_ctr_tab[hanum]); ! 2525: cmdp = ha->pccb; ! 2526: TRACE(("gdth_sync_event() scp %lx serv %d status %d\n", ! 2527: (ulong)scp,service,ha->status)); ! 2528: ! 2529: if (service == SCREENSERVICE) { ! 2530: msg = (gdth_msg_str *)ha->pscratch; ! 2531: TRACE(("len: %ld, answer: %d, ext: %d, alen: %ld\n", ! 2532: msg->msg_len,msg->msg_answer,msg->msg_ext,msg->msg_alen)); ! 2533: if (msg->msg_len) ! 2534: if (!(msg->msg_answer && msg->msg_ext)) { ! 2535: msg->msg_text[msg->msg_len] = '\0'; ! 2536: printk("%s",msg->msg_text); ! 2537: } ! 2538: ! 2539: if (msg->msg_ext && !msg->msg_answer) { ! 2540: while (gdth_test_busy(hanum)) ! 2541: gdth_delay(0); ! 2542: cmdp->Service = SCREENSERVICE; ! 2543: cmdp->RequestBuffer = SCREEN_CMND; ! 2544: gdth_get_cmd_index(hanum); ! 2545: gdth_set_sema0(hanum); ! 2546: cmdp->OpCode = GDT_READ; ! 2547: cmdp->BoardNode = LOCALBOARD; ! 2548: cmdp->u.screen.reserved = 0; ! 2549: cmdp->u.screen.msg_handle= msg->msg_handle; ! 2550: cmdp->u.screen.msg_addr = (ulong)msg; ! 2551: ha->cmd_offs_dpmem = 0; ! 2552: ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.msg_addr) ! 2553: + sizeof(ulong); ! 2554: ha->cmd_cnt = 0; ! 2555: gdth_copy_command(hanum); ! 2556: gdth_release_event(hanum); ! 2557: return 1; ! 2558: } ! 2559: ! 2560: if (msg->msg_answer && msg->msg_alen) { ! 2561: for (i=0; i<msg->msg_alen && i<MSGLEN; ++i) { ! 2562: /* getchar() ?? */ ! 2563: /* .. */ ! 2564: if (c == '\r') ! 2565: break; ! 2566: msg->msg_text[i] = c; ! 2567: } ! 2568: msg->msg_alen -= i; ! 2569: if (c!='\r' && msg->msg_alen!=0) { ! 2570: msg->msg_answer = 1; ! 2571: msg->msg_ext = 1; ! 2572: } else { ! 2573: msg->msg_ext = 0; ! 2574: msg->msg_answer = 0; ! 2575: } ! 2576: msg->msg_len = i; ! 2577: while (gdth_test_busy(hanum)) ! 2578: gdth_delay(0); ! 2579: cmdp->Service = SCREENSERVICE; ! 2580: cmdp->RequestBuffer = SCREEN_CMND; ! 2581: gdth_get_cmd_index(hanum); ! 2582: gdth_set_sema0(hanum); ! 2583: cmdp->OpCode = GDT_WRITE; ! 2584: cmdp->BoardNode = LOCALBOARD; ! 2585: cmdp->u.screen.reserved = 0; ! 2586: cmdp->u.screen.msg_handle= msg->msg_handle; ! 2587: cmdp->u.screen.msg_addr = (ulong)msg; ! 2588: ha->cmd_offs_dpmem = 0; ! 2589: ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.msg_addr) ! 2590: + sizeof(ulong); ! 2591: ha->cmd_cnt = 0; ! 2592: gdth_copy_command(hanum); ! 2593: gdth_release_event(hanum); ! 2594: return 1; ! 2595: } ! 2596: printk("\n"); ! 2597: ! 2598: } else { ! 2599: scp->SCp.Message = (int)ha->status; ! 2600: /* cache or raw service */ ! 2601: if (ha->status == S_OK) { ! 2602: scp->result = DID_OK << 16; ! 2603: } else if (ha->status == S_BSY) { ! 2604: TRACE2(("Controller busy -> retry !\n")); ! 2605: gdth_putq(hanum,scp,scp->SCp.this_residual); ! 2606: return 1; ! 2607: } else { ! 2608: if (service == CACHESERVICE) { ! 2609: memset((char*)scp->sense_buffer,0,16); ! 2610: scp->sense_buffer[0] = 0x70; ! 2611: scp->sense_buffer[2] = NOT_READY; ! 2612: scp->result = (DID_OK << 16) | (CHECK_CONDITION << 1); ! 2613: ! 2614: if (scp->done != gdth_scsi_done) { ! 2615: dvr.size = sizeof(dvr.eu.sync); ! 2616: dvr.eu.sync.ionode = hanum; ! 2617: dvr.eu.sync.service = service; ! 2618: dvr.eu.sync.status = ha->status; ! 2619: dvr.eu.sync.info = ha->info; ! 2620: dvr.eu.sync.hostdrive = ! 2621: #if LINUX_VERSION_CODE >= 0x020000 ! 2622: ha->id[scp->channel][scp->target].hostdrive; ! 2623: #else ! 2624: ha->id[NUMDATA(scp->host)->busnum][scp->target].hostdrive; ! 2625: #endif ! 2626: if (ha->status >= 0x8000) ! 2627: gdth_store_event(ES_SYNC, 0, &dvr); ! 2628: else ! 2629: gdth_store_event(ES_SYNC, service, &dvr); ! 2630: } ! 2631: } else { ! 2632: if (ha->status!=S_RAW_SCSI || ha->status==S_RAW_ILL || ha->info>=0x100) { ! 2633: scp->result = DID_BAD_TARGET << 16; ! 2634: } else { ! 2635: scp->result = (DID_OK << 16) | ha->info; ! 2636: } ! 2637: } ! 2638: } ! 2639: if (!scp->SCp.have_data_in) ! 2640: scp->SCp.have_data_in++; ! 2641: else ! 2642: scp->scsi_done(scp); ! 2643: } ! 2644: ! 2645: return 1; ! 2646: } ! 2647: ! 2648: static char *async_cache_tab[] = { ! 2649: /* 0*/ "\011\000\002\002\002\004\002\006\004" ! 2650: "GDT HA %u, service %u, async. status %u/%lu unknown", ! 2651: /* 1*/ "\011\000\002\002\002\004\002\006\004" ! 2652: "GDT HA %u, service %u, async. status %u/%lu unknown", ! 2653: /* 2*/ "\005\000\002\006\004" ! 2654: "GDT HA %u, Host Drive %lu not ready", ! 2655: /* 3*/ "\005\000\002\006\004" ! 2656: "GDT HA %u, Host Drive %lu: REASSIGN not successful and/or data error on reassigned blocks. Drive may crash in the future and should be replaced", ! 2657: /* 4*/ "\005\000\002\006\004" ! 2658: "GDT HA %u, mirror update on Host Drive %lu failed", ! 2659: /* 5*/ "\005\000\002\006\004" ! 2660: "GDT HA %u, Mirror Drive %lu failed", ! 2661: /* 6*/ "\005\000\002\006\004" ! 2662: "GDT HA %u, Mirror Drive %lu: REASSIGN not successful and/or data error on reassigned blocks. Drive may crash in the future and should be replaced", ! 2663: /* 7*/ "\005\000\002\006\004" ! 2664: "GDT HA %u, Host Drive %lu write protected", ! 2665: /* 8*/ "\005\000\002\006\004" ! 2666: "GDT HA %u, media changed in Host Drive %lu", ! 2667: /* 9*/ "\005\000\002\006\004" ! 2668: "GDT HA %u, Host Drive %lu is offline", ! 2669: /*10*/ "\005\000\002\006\004" ! 2670: "GDT HA %u, media change of Mirror Drive %lu", ! 2671: /*11*/ "\005\000\002\006\004" ! 2672: "GDT HA %u, Mirror Drive %lu is write protected", ! 2673: /*12*/ "\005\000\002\006\004" ! 2674: "GDT HA %u, general error on Host Drive %lu. Please check the devices of this drive!", ! 2675: /*13*/ "\007\000\002\006\002\010\002" ! 2676: "GDT HA %u, Array Drive %u: Cache Drive %u failed", ! 2677: /*14*/ "\005\000\002\006\002" ! 2678: "GDT HA %u, Array Drive %u: FAIL state entered", ! 2679: /*15*/ "\005\000\002\006\002" ! 2680: "GDT HA %u, Array Drive %u: error", ! 2681: /*16*/ "\007\000\002\006\002\010\002" ! 2682: "GDT HA %u, Array Drive %u: failed drive replaced by Cache Drive %u", ! 2683: /*17*/ "\005\000\002\006\002" ! 2684: "GDT HA %u, Array Drive %u: parity build failed", ! 2685: /*18*/ "\005\000\002\006\002" ! 2686: "GDT HA %u, Array Drive %u: drive rebuild failed", ! 2687: /*19*/ "\007\000\002\010\002" ! 2688: "GDT HA %u, Test of Hot Fix %u failed", ! 2689: /*20*/ "\005\000\002\006\002" ! 2690: "GDT HA %u, Array Drive %u: drive build finished successfully", ! 2691: /*21*/ "\005\000\002\006\002" ! 2692: "GDT HA %u, Array Drive %u: drive rebuild finished successfully", ! 2693: /*22*/ "\007\000\002\006\002\010\002" ! 2694: "GDT HA %u, Array Drive %u: Hot Fix %u activated", ! 2695: /*23*/ "\005\000\002\006\002" ! 2696: "GDT HA %u, Host Drive %u: processing of i/o aborted due to serious drive error", ! 2697: /*24*/ "\005\000\002\010\002" ! 2698: "GDT HA %u, mirror update on Cache Drive %u completed", ! 2699: /*25*/ "\005\000\002\010\002" ! 2700: "GDT HA %u, mirror update on Cache Drive %lu failed", ! 2701: /*26*/ "\005\000\002\006\002" ! 2702: "GDT HA %u, Array Drive %u: drive rebuild started", ! 2703: /*27*/ "\005\000\002\012\001" ! 2704: "GDT HA %u, Fault bus %u: SHELF OK detected", ! 2705: /*28*/ "\005\000\002\012\001" ! 2706: "GDT HA %u, Fault bus %u: SHELF not OK detected", ! 2707: /*29*/ "\007\000\002\012\001\013\001" ! 2708: "GDT HA %u, Fault bus %u, ID %u: Auto Hot Plug started", ! 2709: /*30*/ "\007\000\002\012\001\013\001" ! 2710: "GDT HA %u, Fault bus %u, ID %u: new disk detected", ! 2711: /*31*/ "\007\000\002\012\001\013\001" ! 2712: "GDT HA %u, Fault bus %u, ID %u: old disk detected", ! 2713: /*32*/ "\007\000\002\012\001\013\001" ! 2714: "GDT HA %u, Fault bus %u, ID %u: plugging an active disk is illegal", ! 2715: /*33*/ "\007\000\002\012\001\013\001" ! 2716: "GDT HA %u, Fault bus %u, ID %u: illegal device detected", ! 2717: /*34*/ "\011\000\002\012\001\013\001\006\004" ! 2718: "GDT HA %u, Fault bus %u, ID %u: insufficient disk capacity (%lu MB required)", ! 2719: /*35*/ "\007\000\002\012\001\013\001" ! 2720: "GDT HA %u, Fault bus %u, ID %u: disk write protected", ! 2721: /*36*/ "\007\000\002\012\001\013\001" ! 2722: "GDT HA %u, Fault bus %u, ID %u: disk not available", ! 2723: /*37*/ "\007\000\002\012\001\006\004" ! 2724: "GDT HA %u, Fault bus %u: swap detected (%lu)", ! 2725: /*38*/ "\007\000\002\012\001\013\001" ! 2726: "GDT HA %u, Fault bus %u, ID %u: Auto Hot Plug finished successfully", ! 2727: /*39*/ "\007\000\002\012\001\013\001" ! 2728: "GDT HA %u, Fault bus %u, ID %u: Auto Hot Plug aborted due to user Hot Plug", ! 2729: /*40*/ "\007\000\002\012\001\013\001" ! 2730: "GDT HA %u, Fault bus %u, ID %u: Auto Hot Plug aborted", ! 2731: /*41*/ "\007\000\002\012\001\013\001" ! 2732: "GDT HA %u, Fault bus %u, ID %u: Auto Hot Plug for Hot Fix started", ! 2733: /*42*/ "\005\000\002\006\002" ! 2734: "GDT HA %u, Array Drive %u: drive build started", ! 2735: /*43*/ "\003\000\002" ! 2736: "GDT HA %u, DRAM parity error detected", ! 2737: /*44*/ "\005\000\002\006\002" ! 2738: "GDT HA %u, Mirror Drive %u: update started", ! 2739: /*45*/ "\007\000\002\006\002\010\002" ! 2740: "GDT HA %u, Mirror Drive %u: Hot Fix %u activated", ! 2741: /*46*/ "\005\000\002\006\002" ! 2742: "GDT HA %u, Array Drive %u: no matching Pool Hot Fix Drive available", ! 2743: /*47*/ "\005\000\002\006\002" ! 2744: "GDT HA %u, Array Drive %u: Pool Hot Fix Drive available", ! 2745: /*48*/ "\005\000\002\006\002" ! 2746: "GDT HA %u, Mirror Drive %u: no matching Pool Hot Fix Drive available", ! 2747: /*49*/ "\005\000\002\006\002" ! 2748: "GDT HA %u, Mirror Drive %u: Pool Hot Fix Drive available", ! 2749: /*50*/ "\007\000\002\012\001\013\001" ! 2750: "GDT HA %u, SCSI bus %u, ID %u: IGNORE_WIDE_RESIDUE message received", ! 2751: /*51*/ "\005\000\002\006\002" ! 2752: "GDT HA %u, Array Drive %u: expand started", ! 2753: /*52*/ "\005\000\002\006\002" ! 2754: "GDT HA %u, Array Drive %u: expand finished successfully", ! 2755: /*53*/ "\005\000\002\006\002" ! 2756: "GDT HA %u, Array Drive %u: expand failed", ! 2757: /*54*/ "\003\000\002" ! 2758: "GDT HA %u, CPU temperature critical", ! 2759: /*55*/ "\003\000\002" ! 2760: "GDT HA %u, CPU temperature OK", ! 2761: /*56*/ "\005\000\002\006\004" ! 2762: "GDT HA %u, Host drive %lu created", ! 2763: /*57*/ "\005\000\002\006\002" ! 2764: "GDT HA %u, Array Drive %u: expand restarted", ! 2765: /*58*/ "\005\000\002\006\002" ! 2766: "GDT HA %u, Array Drive %u: expand stopped", ! 2767: }; ! 2768: ! 2769: ! 2770: static int gdth_async_event(int hanum,int service) ! 2771: { ! 2772: gdth_stackframe stack; ! 2773: gdth_evt_data dvr; ! 2774: char *f = NULL; ! 2775: int i,j; ! 2776: gdth_ha_str *ha; ! 2777: gdth_msg_str *msg; ! 2778: gdth_cmd_str *cmdp; ! 2779: int cmd_index; ! 2780: ! 2781: ha = HADATA(gdth_ctr_tab[hanum]); ! 2782: cmdp= ha->pccb; ! 2783: msg = (gdth_msg_str *)ha->pscratch; ! 2784: TRACE2(("gdth_async_event() ha %d serv %d\n", ! 2785: hanum,service)); ! 2786: ! 2787: if (service == SCREENSERVICE) { ! 2788: if (ha->status == MSG_REQUEST) { ! 2789: while (gdth_test_busy(hanum)) ! 2790: gdth_delay(0); ! 2791: cmdp->Service = SCREENSERVICE; ! 2792: cmdp->RequestBuffer = SCREEN_CMND; ! 2793: cmd_index = gdth_get_cmd_index(hanum); ! 2794: gdth_set_sema0(hanum); ! 2795: cmdp->OpCode = GDT_READ; ! 2796: cmdp->BoardNode = LOCALBOARD; ! 2797: cmdp->u.screen.reserved = 0; ! 2798: cmdp->u.screen.msg_handle= MSG_INV_HANDLE; ! 2799: cmdp->u.screen.msg_addr = (ulong)msg; ! 2800: ha->cmd_offs_dpmem = 0; ! 2801: ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.msg_addr) ! 2802: + sizeof(ulong); ! 2803: ha->cmd_cnt = 0; ! 2804: gdth_copy_command(hanum); ! 2805: if (ha->type == GDT_EISA) ! 2806: printk("[EISA slot %d] ",(ushort)ha->brd_phys); ! 2807: else if (ha->type == GDT_ISA) ! 2808: printk("[DPMEM 0x%4X] ",(ushort)ha->brd_phys); ! 2809: else ! 2810: printk("[PCI %d/%d] ",(ushort)(ha->brd_phys>>8), ! 2811: (ushort)((ha->brd_phys>>3)&0x1f)); ! 2812: gdth_release_event(hanum); ! 2813: } ! 2814: ! 2815: } else { ! 2816: dvr.size = sizeof(dvr.eu.async); ! 2817: dvr.eu.async.ionode = hanum; ! 2818: dvr.eu.async.service = service; ! 2819: dvr.eu.async.status = ha->status; ! 2820: dvr.eu.async.info = ha->info; ! 2821: *(ulong *)dvr.eu.async.scsi_coord = ha->info2; ! 2822: gdth_store_event(ES_ASYNC, service, &dvr); ! 2823: ! 2824: if (service==CACHESERVICE && INDEX_OK(ha->status,async_cache_tab)) { ! 2825: TRACE2(("GDT: Async. event cache service, event no.: %d\n", ! 2826: ha->status)); ! 2827: ! 2828: f = async_cache_tab[ha->status]; ! 2829: ! 2830: /* i: parameter to push, j: stack element to fill */ ! 2831: for (j=0,i=1; i < f[0]; i+=2) { ! 2832: switch (f[i+1]) { ! 2833: case 4: ! 2834: stack.b[j++] = *(ulong*)&dvr.eu.stream[(int)f[i]]; ! 2835: break; ! 2836: case 2: ! 2837: stack.b[j++] = *(ushort*)&dvr.eu.stream[(int)f[i]]; ! 2838: break; ! 2839: case 1: ! 2840: stack.b[j++] = *(unchar*)&dvr.eu.stream[(int)f[i]]; ! 2841: break; ! 2842: default: ! 2843: break; ! 2844: } ! 2845: } ! 2846: ! 2847: printk(&f[f[0]],stack); printk("\n"); ! 2848: ! 2849: } else { ! 2850: printk("GDT: Unknown async. event service %d event no. %d\n", ! 2851: service,ha->status); ! 2852: } ! 2853: } ! 2854: return 1; ! 2855: } ! 2856: ! 2857: ! 2858: #ifdef GDTH_STATISTICS ! 2859: void gdth_timeout(ulong data) ! 2860: { ! 2861: ulong flags,i; ! 2862: Scsi_Cmnd *nscp; ! 2863: gdth_ha_str *ha; ! 2864: int hanum = 0; ! 2865: ! 2866: save_flags(flags); ! 2867: cli(); ! 2868: ! 2869: for (act_stats=0,i=0; i<GDTH_MAXCMDS; ++i) ! 2870: if (gdth_cmd_tab[i][hanum].cmnd != UNUSED_CMND) ! 2871: ++act_stats; ! 2872: ! 2873: ha = HADATA(gdth_ctr_tab[hanum]); ! 2874: for (act_rq=0,nscp=ha->req_first; nscp; nscp=(Scsi_Cmnd*)nscp->SCp.ptr) ! 2875: ++act_rq; ! 2876: ! 2877: TRACE2(("gdth_to(): ints %ld, ios %ld, act_stats %ld, act_rq %ld\n", ! 2878: act_ints, act_ios, act_stats, act_rq)); ! 2879: act_ints = act_ios = 0; ! 2880: ! 2881: gdth_timer.expires = jiffies + 30 * HZ; ! 2882: add_timer(&gdth_timer); ! 2883: restore_flags(flags); ! 2884: } ! 2885: #endif ! 2886: ! 2887: ! 2888: __initfunc (int gdth_detect(Scsi_Host_Template *shtp)) ! 2889: { ! 2890: struct Scsi_Host *shp; ! 2891: gdth_ha_str *ha; ! 2892: unsigned long flags; ! 2893: ulong isa_bios; ! 2894: ushort eisa_slot,device_id,index; ! 2895: gdth_pci_str pcistr; ! 2896: int i,j,hanum; ! 2897: unchar b; ! 2898: ! 2899: ! 2900: #ifdef DEBUG_GDTH ! 2901: printk("GDT: This driver contains debugging information !! Trace level = %d\n", ! 2902: DebugState); ! 2903: printk(" Destination of debugging information: "); ! 2904: #ifdef __SERIAL__ ! 2905: #ifdef __COM2__ ! 2906: printk("Serial port COM2\n"); ! 2907: #else ! 2908: printk("Serial port COM1\n"); ! 2909: #endif ! 2910: #else ! 2911: printk("Console\n"); ! 2912: #endif ! 2913: gdth_delay(3000); ! 2914: #endif ! 2915: ! 2916: TRACE(("gdth_detect()\n")); ! 2917: ! 2918: if (disable_gdth_scan) { ! 2919: printk("GDT: Controller driver disabled from command line !\n"); ! 2920: return 0; ! 2921: } ! 2922: ! 2923: /* initializations */ ! 2924: gdth_polling = TRUE; b = 0; ! 2925: for (i=0; i<GDTH_MAXCMDS; ++i) ! 2926: for (j=0; j<MAXHA; ++j) ! 2927: gdth_cmd_tab[i][j].cmnd = UNUSED_CMND; ! 2928: for (i=0; i<4; ++i) ! 2929: for (j=0; j<MAXHA; ++j) ! 2930: gdth_ioctl_tab[i][j] = NULL; ! 2931: gdth_clear_events(); ! 2932: ! 2933: /* scanning for controllers, at first: ISA controller */ ! 2934: for (isa_bios=0xc8000UL; isa_bios<=0xd8000UL; isa_bios+=0x8000UL) { ! 2935: if (gdth_search_isa(isa_bios)) { /* controller found */ ! 2936: shp = scsi_register(shtp,sizeof(gdth_ext_str)); ! 2937: ha = HADATA(shp); ! 2938: if (!gdth_init_isa(isa_bios,ha)) { ! 2939: scsi_unregister(shp); ! 2940: continue; ! 2941: } ! 2942: /* controller found and initialized */ ! 2943: printk("Configuring GDT-ISA HA at BIOS 0x%05lX IRQ %u DRQ %u\n", ! 2944: isa_bios,ha->irq,ha->drq); ! 2945: ! 2946: save_flags(flags); ! 2947: cli(); ! 2948: #if LINUX_VERSION_CODE >= 0x02015F ! 2949: if (request_irq(ha->irq,do_gdth_interrupt,SA_INTERRUPT,"gdth",NULL)) ! 2950: #elif LINUX_VERSION_CODE >= 0x010346 ! 2951: if (request_irq(ha->irq,gdth_interrupt,SA_INTERRUPT,"gdth",NULL)) ! 2952: #else ! 2953: if (request_irq(ha->irq,gdth_interrupt,SA_INTERRUPT,"gdth")) ! 2954: #endif ! 2955: { ! 2956: printk("GDT-ISA: Unable to allocate IRQ\n"); ! 2957: restore_flags(flags); ! 2958: scsi_unregister(shp); ! 2959: continue; ! 2960: } ! 2961: if (request_dma(ha->drq,"gdth")) { ! 2962: printk("GDT-ISA: Unable to allocate DMA channel\n"); ! 2963: #if LINUX_VERSION_CODE >= 0x010346 ! 2964: free_irq(ha->irq,NULL); ! 2965: #else ! 2966: free_irq(ha->irq); ! 2967: #endif ! 2968: restore_flags(flags); ! 2969: scsi_unregister(shp); ! 2970: continue; ! 2971: } ! 2972: set_dma_mode(ha->drq,DMA_MODE_CASCADE); ! 2973: enable_dma(ha->drq); ! 2974: shp->unchecked_isa_dma = 1; ! 2975: shp->irq = ha->irq; ! 2976: shp->dma_channel = ha->drq; ! 2977: for (i=0; i<MAXID; ++i) { ! 2978: if (ha->id[0][i].type==SIOP_DTYP) { ! 2979: shp->this_id = i; ! 2980: break; ! 2981: } ! 2982: } ! 2983: hanum = gdth_ctr_count; ! 2984: gdth_ctr_tab[gdth_ctr_count++] = shp; ! 2985: gdth_ctr_vtab[gdth_ctr_vcount++] = shp; ! 2986: ! 2987: NUMDATA(shp)->hanum = (ushort)hanum; ! 2988: NUMDATA(shp)->busnum= 0; ! 2989: ! 2990: ha->pccb = CMDDATA(shp); ! 2991: ha->pscratch = DMADATA(shp); ! 2992: ha->req_first = NULL; ! 2993: for (i=0; i<MAXBUS; ++i) { ! 2994: for (j=0; j<MAXID; ++j) { ! 2995: ha->id[i][j].type = EMPTY_DTYP; ! 2996: ha->id[i][j].lock = 0; ! 2997: ha->id[i][j].heads = 0; ! 2998: } ! 2999: } ! 3000: restore_flags(flags); ! 3001: ! 3002: if (!gdth_search_drives(hanum)) { ! 3003: printk("GDT-ISA: Error during device scan\n"); ! 3004: --gdth_ctr_count; ! 3005: --gdth_ctr_vcount; ! 3006: save_flags(flags); ! 3007: cli(); ! 3008: #if LINUX_VERSION_CODE >= 0x010346 ! 3009: free_irq(ha->irq,NULL); ! 3010: #else ! 3011: free_irq(ha->irq); ! 3012: #endif ! 3013: restore_flags(flags); ! 3014: scsi_unregister(shp); ! 3015: continue; ! 3016: } ! 3017: ! 3018: #if LINUX_VERSION_CODE >= 0x020000 ! 3019: shp->max_id = 8; ! 3020: shp->max_lun = MAXLUN; ! 3021: shp->max_channel = ha->bus_cnt - 1; ! 3022: #else ! 3023: /* register addit. SCSI channels as virtual controllers */ ! 3024: for (b=1; b<ha->bus_cnt; ++b) { ! 3025: shp = scsi_register(shtp,sizeof(gdth_num_str)); ! 3026: shp->unchecked_isa_dma = 1; ! 3027: shp->irq = ha->irq; ! 3028: shp->dma_channel = ha->drq; ! 3029: for (i=0; i<MAXID; ++i) { ! 3030: if (ha->id[b][i].type==SIOP_DTYP) { ! 3031: shp->this_id = i; ! 3032: break; ! 3033: } ! 3034: } ! 3035: gdth_ctr_vtab[gdth_ctr_vcount++] = shp; ! 3036: NUMDATA(shp)->hanum = (ushort)hanum; ! 3037: NUMDATA(shp)->busnum = b; ! 3038: } ! 3039: #endif ! 3040: ! 3041: gdth_enable_int(hanum); ! 3042: } ! 3043: } ! 3044: ! 3045: /* scanning for EISA controllers */ ! 3046: for (eisa_slot=0x1000; eisa_slot<=0x8000; eisa_slot+=0x1000) { ! 3047: if (gdth_search_eisa(eisa_slot)) { /* controller found */ ! 3048: shp = scsi_register(shtp,sizeof(gdth_ext_str)); ! 3049: ha = HADATA(shp); ! 3050: if (!gdth_init_eisa(eisa_slot,ha)) { ! 3051: scsi_unregister(shp); ! 3052: continue; ! 3053: } ! 3054: /* controller found and initialized */ ! 3055: printk("Configuring GDT-EISA HA at Slot %d IRQ %u\n", ! 3056: eisa_slot>>12,ha->irq); ! 3057: ! 3058: save_flags(flags); ! 3059: cli(); ! 3060: #if LINUX_VERSION_CODE >= 0x02015F ! 3061: if (request_irq(ha->irq,do_gdth_interrupt,SA_INTERRUPT,"gdth",NULL)) ! 3062: #elif LINUX_VERSION_CODE >= 0x010346 ! 3063: if (request_irq(ha->irq,gdth_interrupt,SA_INTERRUPT,"gdth",NULL)) ! 3064: #else ! 3065: if (request_irq(ha->irq,gdth_interrupt,SA_INTERRUPT,"gdth")) ! 3066: #endif ! 3067: { ! 3068: printk("GDT-EISA: Unable to allocate IRQ\n"); ! 3069: restore_flags(flags); ! 3070: scsi_unregister(shp); ! 3071: continue; ! 3072: } ! 3073: shp->unchecked_isa_dma = 0; ! 3074: shp->irq = ha->irq; ! 3075: shp->dma_channel = 0xff; ! 3076: for (i=0; i<MAXID; ++i) { ! 3077: if (ha->id[0][i].type==SIOP_DTYP) { ! 3078: shp->this_id = i; ! 3079: break; ! 3080: } ! 3081: } ! 3082: hanum = gdth_ctr_count; ! 3083: gdth_ctr_tab[gdth_ctr_count++] = shp; ! 3084: gdth_ctr_vtab[gdth_ctr_vcount++] = shp; ! 3085: ! 3086: NUMDATA(shp)->hanum = (ushort)hanum; ! 3087: NUMDATA(shp)->busnum= 0; ! 3088: TRACE2(("EISA detect Bus 0: shp %lx hanum %d\n", ! 3089: (ulong)shp,NUMDATA(shp)->hanum)); ! 3090: ! 3091: ha->pccb = CMDDATA(shp); ! 3092: ha->pscratch = DMADATA(shp); ! 3093: ha->req_first = NULL; ! 3094: for (i=0; i<MAXBUS; ++i) { ! 3095: for (j=0; j<MAXID; ++j) { ! 3096: ha->id[i][j].type = EMPTY_DTYP; ! 3097: ha->id[i][j].lock = 0; ! 3098: ha->id[i][j].heads = 0; ! 3099: } ! 3100: } ! 3101: restore_flags(flags); ! 3102: ! 3103: if (!gdth_search_drives(hanum)) { ! 3104: printk("GDT-EISA: Error during device scan\n"); ! 3105: --gdth_ctr_count; ! 3106: --gdth_ctr_vcount; ! 3107: save_flags(flags); ! 3108: cli(); ! 3109: #if LINUX_VERSION_CODE >= 0x010346 ! 3110: free_irq(ha->irq,NULL); ! 3111: #else ! 3112: free_irq(ha->irq); ! 3113: #endif ! 3114: restore_flags(flags); ! 3115: scsi_unregister(shp); ! 3116: continue; ! 3117: } ! 3118: ! 3119: #if LINUX_VERSION_CODE >= 0x020000 ! 3120: shp->max_id = 8; ! 3121: shp->max_lun = MAXLUN; ! 3122: shp->max_channel = ha->bus_cnt - 1; ! 3123: #else ! 3124: /* register addit. SCSI channels as virtual controllers */ ! 3125: for (b=1; b<ha->bus_cnt; ++b) { ! 3126: shp = scsi_register(shtp,sizeof(gdth_num_str)); ! 3127: shp->unchecked_isa_dma = 0; ! 3128: shp->irq = ha->irq; ! 3129: shp->dma_channel = 0xff; ! 3130: for (i=0; i<MAXID; ++i) { ! 3131: if (ha->id[b][i].type==SIOP_DTYP) { ! 3132: shp->this_id = i; ! 3133: break; ! 3134: } ! 3135: } ! 3136: gdth_ctr_vtab[gdth_ctr_vcount++] = shp; ! 3137: NUMDATA(shp)->hanum = (ushort)hanum; ! 3138: NUMDATA(shp)->busnum = b; ! 3139: TRACE2(("EISA detect Bus %d: shp %lx hanum %d\n", ! 3140: NUMDATA(shp)->busnum,(ulong)shp, ! 3141: NUMDATA(shp)->hanum)); ! 3142: } ! 3143: #endif ! 3144: ! 3145: gdth_enable_int(hanum); ! 3146: } ! 3147: } ! 3148: ! 3149: /* scanning for PCI controllers */ ! 3150: for (device_id = 0; device_id <= PCI_DEVICE_ID_VORTEX_GDTMAXRP; ++device_id) { ! 3151: if (device_id > PCI_DEVICE_ID_VORTEX_GDT6555 && ! 3152: device_id < PCI_DEVICE_ID_VORTEX_GDT6x17RP) ! 3153: continue; ! 3154: for (index = 0; ; ++index) { ! 3155: if (!gdth_search_pci(device_id,index,&pcistr)) ! 3156: break; /* next device_id */ ! 3157: shp = scsi_register(shtp,sizeof(gdth_ext_str)); ! 3158: ha = HADATA(shp); ! 3159: if (!gdth_init_pci(&pcistr,ha)) { ! 3160: scsi_unregister(shp); ! 3161: continue; ! 3162: } ! 3163: /* controller found and initialized */ ! 3164: printk("Configuring GDT-PCI HA at %d/%d IRQ %u\n", ! 3165: pcistr.bus,pcistr.device_fn>>3,ha->irq); ! 3166: ! 3167: save_flags(flags); ! 3168: cli(); ! 3169: #if LINUX_VERSION_CODE >= 0x02015F ! 3170: if (request_irq(ha->irq,do_gdth_interrupt,SA_INTERRUPT|SA_SHIRQ,"gdth",NULL)) ! 3171: #elif LINUX_VERSION_CODE >= 0x010346 ! 3172: if (request_irq(ha->irq,gdth_interrupt,SA_INTERRUPT|SA_SHIRQ,"gdth",NULL)) ! 3173: #else ! 3174: if (request_irq(ha->irq,gdth_interrupt,SA_INTERRUPT|SA_SHIRQ,"gdth")) ! 3175: #endif ! 3176: { ! 3177: printk("GDT-PCI: Unable to allocate IRQ\n"); ! 3178: restore_flags(flags); ! 3179: scsi_unregister(shp); ! 3180: continue; ! 3181: } ! 3182: shp->unchecked_isa_dma = 0; ! 3183: shp->irq = ha->irq; ! 3184: shp->dma_channel = 0xff; ! 3185: for (i=0; i<MAXID; ++i) { ! 3186: if (ha->id[0][i].type==SIOP_DTYP) { ! 3187: shp->this_id = i; ! 3188: break; ! 3189: } ! 3190: } ! 3191: hanum = gdth_ctr_count; ! 3192: gdth_ctr_tab[gdth_ctr_count++] = shp; ! 3193: gdth_ctr_vtab[gdth_ctr_vcount++] = shp; ! 3194: ! 3195: NUMDATA(shp)->hanum = (ushort)hanum; ! 3196: NUMDATA(shp)->busnum= 0; ! 3197: ! 3198: ha->pccb = CMDDATA(shp); ! 3199: ha->pscratch = DMADATA(shp); ! 3200: ha->req_first = NULL; ! 3201: for (i=0; i<MAXBUS; ++i) { ! 3202: for (j=0; j<MAXID; ++j) { ! 3203: ha->id[i][j].type = EMPTY_DTYP; ! 3204: ha->id[i][j].lock = 0; ! 3205: ha->id[i][j].heads = 0; ! 3206: } ! 3207: } ! 3208: restore_flags(flags); ! 3209: ! 3210: if (!gdth_search_drives(hanum)) { ! 3211: printk("GDT-PCI: Error during device scan\n"); ! 3212: --gdth_ctr_count; ! 3213: --gdth_ctr_vcount; ! 3214: save_flags(flags); ! 3215: cli(); ! 3216: #if LINUX_VERSION_CODE >= 0x010346 ! 3217: free_irq(ha->irq,NULL); ! 3218: #else ! 3219: free_irq(ha->irq); ! 3220: #endif ! 3221: restore_flags(flags); ! 3222: scsi_unregister(shp); ! 3223: continue; ! 3224: } ! 3225: ! 3226: #if LINUX_VERSION_CODE >= 0x020000 ! 3227: shp->max_id = MAXID; ! 3228: shp->max_lun = MAXLUN; ! 3229: shp->max_channel = ha->bus_cnt - 1; ! 3230: #else ! 3231: /* register addit. SCSI channels as virtual controllers */ ! 3232: for (b=1; b<ha->bus_cnt; ++b) { ! 3233: shp = scsi_register(shtp,sizeof(gdth_num_str)); ! 3234: shp->unchecked_isa_dma = 0; ! 3235: shp->irq = ha->irq; ! 3236: shp->dma_channel = 0xff; ! 3237: for (i=0; i<MAXID; ++i) { ! 3238: if (ha->id[b][i].type==SIOP_DTYP) { ! 3239: shp->this_id = i; ! 3240: break; ! 3241: } ! 3242: } ! 3243: gdth_ctr_vtab[gdth_ctr_vcount++] = shp; ! 3244: NUMDATA(shp)->hanum = (ushort)hanum; ! 3245: NUMDATA(shp)->busnum = b; ! 3246: } ! 3247: #endif ! 3248: ! 3249: gdth_enable_int(hanum); ! 3250: } ! 3251: } ! 3252: ! 3253: TRACE2(("gdth_detect() %d controller detected\n",gdth_ctr_count)); ! 3254: if (gdth_ctr_count > 0) { ! 3255: #ifdef GDTH_STATISTICS ! 3256: TRACE2(("gdth_detect(): Initializing timer !\n")); ! 3257: init_timer(&gdth_timer); ! 3258: gdth_timer.expires = jiffies + HZ; ! 3259: gdth_timer.data = 0L; ! 3260: gdth_timer.function = gdth_timeout; ! 3261: add_timer(&gdth_timer); ! 3262: #endif ! 3263: #if LINUX_VERSION_CODE >= 0x020100 ! 3264: register_reboot_notifier(&gdth_notifier); ! 3265: #endif ! 3266: } ! 3267: gdth_polling = FALSE; ! 3268: return gdth_ctr_vcount; ! 3269: } ! 3270: ! 3271: ! 3272: int gdth_release(struct Scsi_Host *shp) ! 3273: { ! 3274: unsigned long flags; ! 3275: ! 3276: TRACE2(("gdth_release()\n")); ! 3277: ! 3278: if (NUMDATA(shp)->busnum == 0) { ! 3279: gdth_flush(NUMDATA(shp)->hanum); ! 3280: ! 3281: save_flags(flags); ! 3282: cli(); ! 3283: if (shp->irq) { ! 3284: #if LINUX_VERSION_CODE >= 0x010346 ! 3285: free_irq(shp->irq,NULL); ! 3286: #else ! 3287: free_irq(shp->irq); ! 3288: #endif ! 3289: } ! 3290: if (shp->dma_channel != 0xff) { ! 3291: free_dma(shp->dma_channel); ! 3292: } ! 3293: restore_flags(flags); ! 3294: gdth_ctr_released++; ! 3295: TRACE2(("gdth_release(): HA %d of %d\n", ! 3296: gdth_ctr_released, gdth_ctr_count)); ! 3297: ! 3298: if (gdth_ctr_released == gdth_ctr_count) { ! 3299: #ifdef GDTH_STATISTICS ! 3300: del_timer(&gdth_timer); ! 3301: #endif ! 3302: #if LINUX_VERSION_CODE >= 0x020100 ! 3303: unregister_reboot_notifier(&gdth_notifier); ! 3304: #endif ! 3305: } ! 3306: } ! 3307: ! 3308: scsi_unregister(shp); ! 3309: return 0; ! 3310: } ! 3311: ! 3312: ! 3313: static const char *gdth_ctr_name(int hanum) ! 3314: { ! 3315: gdth_ha_str *ha; ! 3316: ! 3317: TRACE2(("gdth_ctr_name()\n")); ! 3318: ! 3319: ha = HADATA(gdth_ctr_tab[hanum]); ! 3320: ! 3321: if (ha->type == GDT_EISA) { ! 3322: switch (ha->stype) { ! 3323: case GDT3_ID: ! 3324: return("GDT3000/3020"); ! 3325: case GDT3A_ID: ! 3326: return("GDT3000A/3020A/3050A"); ! 3327: case GDT3B_ID: ! 3328: return("GDT3000B/3010A"); ! 3329: } ! 3330: } else if (ha->type == GDT_ISA) { ! 3331: return("GDT2000/2020"); ! 3332: } else if (ha->type == GDT_PCI) { ! 3333: switch (ha->stype) { ! 3334: case PCI_DEVICE_ID_VORTEX_GDT60x0: ! 3335: return("GDT6000/6020/6050"); ! 3336: case PCI_DEVICE_ID_VORTEX_GDT6000B: ! 3337: return("GDT6000B/6010"); ! 3338: } ! 3339: } ! 3340: /* new controllers (GDT_PCINEW, GDT_PCIMPR, ..) use board_info IOCTL! */ ! 3341: ! 3342: return(""); ! 3343: } ! 3344: ! 3345: const char *gdth_info(struct Scsi_Host *shp) ! 3346: { ! 3347: int hanum; ! 3348: gdth_ha_str *ha; ! 3349: ! 3350: TRACE2(("gdth_info()\n")); ! 3351: hanum = NUMDATA(shp)->hanum; ! 3352: ha = HADATA(gdth_ctr_tab[hanum]); ! 3353: ! 3354: return ((const char *)ha->ctr_name); ! 3355: } ! 3356: ! 3357: /* old error handling */ ! 3358: int gdth_abort(Scsi_Cmnd *scp) ! 3359: { ! 3360: TRACE2(("gdth_abort() reason %d\n",scp->abort_reason)); ! 3361: return SCSI_ABORT_SNOOZE; ! 3362: } ! 3363: ! 3364: #if LINUX_VERSION_CODE >= 0x010346 ! 3365: int gdth_reset(Scsi_Cmnd *scp, unsigned int reset_flags) ! 3366: #else ! 3367: int gdth_reset(Scsi_Cmnd *scp) ! 3368: #endif ! 3369: { ! 3370: TRACE2(("gdth_reset()\n")); ! 3371: return SCSI_RESET_PUNT; ! 3372: } ! 3373: ! 3374: #if LINUX_VERSION_CODE >= 0x02015F ! 3375: /* new error handling */ ! 3376: int gdth_eh_abort(Scsi_Cmnd *scp) ! 3377: { ! 3378: TRACE2(("gdth_eh_abort()\n")); ! 3379: return FAILED; ! 3380: } ! 3381: ! 3382: int gdth_eh_device_reset(Scsi_Cmnd *scp) ! 3383: { ! 3384: TRACE2(("gdth_eh_device_reset()\n")); ! 3385: return FAILED; ! 3386: } ! 3387: ! 3388: int gdth_eh_bus_reset(Scsi_Cmnd *scp) ! 3389: { ! 3390: TRACE2(("gdth_eh_bus_reset()\n")); ! 3391: return FAILED; ! 3392: } ! 3393: ! 3394: int gdth_eh_host_reset(Scsi_Cmnd *scp) ! 3395: { ! 3396: TRACE2(("gdth_eh_host_reset()\n")); ! 3397: return FAILED; ! 3398: } ! 3399: #endif ! 3400: ! 3401: #if LINUX_VERSION_CODE >= 0x010300 ! 3402: int gdth_bios_param(Disk *disk,kdev_t dev,int *ip) ! 3403: #else ! 3404: int gdth_bios_param(Disk *disk,int dev,int *ip) ! 3405: #endif ! 3406: { ! 3407: unchar b, t; ! 3408: int hanum; ! 3409: gdth_ha_str *ha; ! 3410: int drv_hds, drv_secs; ! 3411: ! 3412: hanum = NUMDATA(disk->device->host)->hanum; ! 3413: b = disk->device->channel; ! 3414: t = disk->device->id; ! 3415: TRACE2(("gdth_bios_param() ha %d bus %d target %d\n", hanum, b, t)); ! 3416: ha = HADATA(gdth_ctr_tab[hanum]); ! 3417: ! 3418: if (ha->id[b][t].heads == 0) { ! 3419: /* raw device: evaluate mapping (sectors per head, heads per cylinder) */ ! 3420: if (disk->capacity /HEADS/SECS <= MAXCYLS) { ! 3421: drv_hds = HEADS; ! 3422: drv_secs= SECS; ! 3423: } else if (disk->capacity /MEDHEADS/MEDSECS <= MAXCYLS) { ! 3424: drv_hds = MEDHEADS; ! 3425: drv_secs= MEDSECS; ! 3426: } else { ! 3427: drv_hds = BIGHEADS; ! 3428: drv_secs= BIGSECS; ! 3429: } ! 3430: ha->id[b][t].heads = drv_hds; ! 3431: ha->id[b][t].secs = drv_secs; ! 3432: TRACE2(("gdth_bios_param(): raw device -> params evaluated\n")); ! 3433: } ! 3434: ! 3435: ip[0] = ha->id[b][t].heads; ! 3436: ip[1] = ha->id[b][t].secs; ! 3437: ip[2] = disk->capacity / ip[0] / ip[1]; ! 3438: ! 3439: TRACE2(("gdth_bios_param(): %d heads, %d secs, %d cyls\n", ! 3440: ip[0],ip[1],ip[2])); ! 3441: return 0; ! 3442: } ! 3443: ! 3444: ! 3445: static void internal_done(Scsi_Cmnd *scp) ! 3446: { ! 3447: scp->SCp.sent_command++; ! 3448: } ! 3449: ! 3450: int gdth_command(Scsi_Cmnd *scp) ! 3451: { ! 3452: TRACE2(("gdth_command()\n")); ! 3453: ! 3454: scp->SCp.sent_command = 0; ! 3455: gdth_queuecommand(scp,internal_done); ! 3456: ! 3457: while (!scp->SCp.sent_command) ! 3458: barrier(); ! 3459: return scp->result; ! 3460: } ! 3461: ! 3462: ! 3463: int gdth_queuecommand(Scsi_Cmnd *scp,void (*done)(Scsi_Cmnd *)) ! 3464: { ! 3465: int hanum; ! 3466: int priority; ! 3467: ! 3468: TRACE(("gdth_queuecommand() cmd 0x%x id %d lun %d\n", ! 3469: scp->cmnd[0],scp->target,scp->lun)); ! 3470: ! 3471: scp->scsi_done = (void *)done; ! 3472: scp->SCp.have_data_in = 1; ! 3473: hanum = NUMDATA(scp->host)->hanum; ! 3474: #ifdef GDTH_STATISTICS ! 3475: ++act_ios; ! 3476: #endif ! 3477: ! 3478: priority = DEFAULT_PRI; ! 3479: #if LINUX_VERSION_CODE >= 0x010300 ! 3480: if (scp->done == gdth_scsi_done) ! 3481: priority = scp->SCp.this_residual; ! 3482: #endif ! 3483: gdth_putq( hanum, scp, priority ); ! 3484: gdth_next( hanum ); ! 3485: return 0; ! 3486: } ! 3487: ! 3488: /* flush routine */ ! 3489: static void gdth_flush(int hanum) ! 3490: { ! 3491: int i, j; ! 3492: gdth_ha_str *ha; ! 3493: Scsi_Cmnd scp; ! 3494: Scsi_Device sdev; ! 3495: gdth_cmd_str gdtcmd; ! 3496: char cmnd[12]; ! 3497: ! 3498: TRACE2(("gdth_flush() hanum %d\n",hanum)); ! 3499: ha = HADATA(gdth_ctr_tab[hanum]); ! 3500: memset(&sdev,0,sizeof(Scsi_Device)); ! 3501: memset(&scp, 0,sizeof(Scsi_Cmnd)); ! 3502: sdev.host = gdth_ctr_tab[hanum]; ! 3503: sdev.id = sdev.host->this_id; ! 3504: scp.cmd_len = 12; ! 3505: scp.host = gdth_ctr_tab[hanum]; ! 3506: scp.target = sdev.host->this_id; ! 3507: scp.device = &sdev; ! 3508: scp.use_sg = 0; ! 3509: ! 3510: for (i = 0; i < MAXBUS; ++i) { ! 3511: for (j = 0; j < MAXID; ++j) { ! 3512: if (ha->id[i][j].type == CACHE_DTYP) { ! 3513: gdtcmd.BoardNode = LOCALBOARD; ! 3514: gdtcmd.Service = CACHESERVICE; ! 3515: gdtcmd.OpCode = GDT_FLUSH; ! 3516: gdtcmd.u.cache.DeviceNo = ha->id[i][j].hostdrive; ! 3517: gdtcmd.u.cache.BlockNo = 1; ! 3518: gdtcmd.u.cache.sg_canz = 0; ! 3519: TRACE2(("gdth_flush(): flush ha %d drive %d\n", ! 3520: hanum, ha->id[i][j].hostdrive)); ! 3521: { ! 3522: struct semaphore sem = MUTEX_LOCKED; ! 3523: scp.request.rq_status = RQ_SCSI_BUSY; ! 3524: scp.request.sem = &sem; ! 3525: scp.SCp.this_residual = IOCTL_PRI; ! 3526: scsi_do_cmd(&scp, cmnd, &gdtcmd, ! 3527: sizeof(gdth_cmd_str), gdth_scsi_done, ! 3528: 30*HZ, 1); ! 3529: down(&sem); ! 3530: } ! 3531: } ! 3532: } ! 3533: } ! 3534: } ! 3535: ! 3536: /* shutdown routine */ ! 3537: #if LINUX_VERSION_CODE >= 0x020100 ! 3538: static int gdth_halt(struct notifier_block *nb, ulong event, void *buf) ! 3539: #else ! 3540: void gdth_halt(void) ! 3541: #endif ! 3542: { ! 3543: int hanum; ! 3544: Scsi_Cmnd scp; ! 3545: Scsi_Device sdev; ! 3546: gdth_cmd_str gdtcmd; ! 3547: char cmnd[12]; ! 3548: ! 3549: #if LINUX_VERSION_CODE >= 0x020100 ! 3550: TRACE2(("gdth_halt() event %d\n",event)); ! 3551: if (event != SYS_RESTART && event != SYS_HALT && event != SYS_POWER_OFF) ! 3552: return NOTIFY_DONE; ! 3553: #else ! 3554: TRACE2(("gdth_halt()\n")); ! 3555: if (halt_called) { ! 3556: TRACE2(("already called\n")); ! 3557: return; ! 3558: } ! 3559: halt_called = TRUE; ! 3560: #endif ! 3561: printk("GDT: Flushing all host drives .. "); ! 3562: for (hanum = 0; hanum < gdth_ctr_count; ++hanum) { ! 3563: gdth_flush(hanum); ! 3564: ! 3565: /* controller reset */ ! 3566: memset(&sdev,0,sizeof(Scsi_Device)); ! 3567: memset(&scp, 0,sizeof(Scsi_Cmnd)); ! 3568: sdev.host = gdth_ctr_tab[hanum]; ! 3569: sdev.id = sdev.host->this_id; ! 3570: scp.cmd_len = 12; ! 3571: scp.host = gdth_ctr_tab[hanum]; ! 3572: scp.target = sdev.host->this_id; ! 3573: scp.device = &sdev; ! 3574: scp.use_sg = 0; ! 3575: ! 3576: gdtcmd.BoardNode = LOCALBOARD; ! 3577: gdtcmd.Service = CACHESERVICE; ! 3578: gdtcmd.OpCode = GDT_RESET; ! 3579: TRACE2(("gdth_halt(): reset controller %d\n", hanum)); ! 3580: { ! 3581: struct semaphore sem = MUTEX_LOCKED; ! 3582: scp.request.rq_status = RQ_SCSI_BUSY; ! 3583: scp.request.sem = &sem; ! 3584: scp.SCp.this_residual = IOCTL_PRI; ! 3585: scsi_do_cmd(&scp, cmnd, &gdtcmd, ! 3586: sizeof(gdth_cmd_str), gdth_scsi_done, ! 3587: 10*HZ, 1); ! 3588: down(&sem); ! 3589: } ! 3590: } ! 3591: printk("Done.\n"); ! 3592: ! 3593: #ifdef GDTH_STATISTICS ! 3594: del_timer(&gdth_timer); ! 3595: #endif ! 3596: #if LINUX_VERSION_CODE >= 0x020100 ! 3597: unregister_reboot_notifier(&gdth_notifier); ! 3598: return NOTIFY_OK; ! 3599: #endif ! 3600: } ! 3601: ! 3602: ! 3603: /* called from init/main.c */ ! 3604: __initfunc (void gdth_setup(char *str,int *ints)) ! 3605: { ! 3606: static size_t setup_idx = 0; ! 3607: ! 3608: TRACE2(("gdth_setup() str %s ints[0] %d ints[1] %d\n", ! 3609: str ? str:"NULL", ints[0], ! 3610: ints[0] ? ints[1]:0)); ! 3611: ! 3612: if (setup_idx >= MAXHA) { ! 3613: printk("GDT: gdth_setup() called too many times. Bad LILO params ?\n"); ! 3614: return; ! 3615: } ! 3616: if (ints[0] != 1) { ! 3617: printk("GDT: Illegal command line !\n"); ! 3618: printk("Usage: gdth=<IRQ>\n"); ! 3619: printk("Where: <IRQ>: valid EISA controller IRQ (10,11,12,14)\n"); ! 3620: printk(" or 0 to disable controller driver\n"); ! 3621: return; ! 3622: } ! 3623: if (ints[1] == 10 || ints[1] == 11 || ints[1] == 12 || ints[1] == 14) { ! 3624: irqs[setup_idx++] = ints[1]; ! 3625: irqs[setup_idx] = 0xff; ! 3626: return; ! 3627: } ! 3628: if (ints[1] == 0) { ! 3629: disable_gdth_scan = TRUE; ! 3630: return; ! 3631: } ! 3632: printk("GDT: Invalid IRQ (%d) specified\n",ints[1]); ! 3633: } ! 3634: ! 3635: ! 3636: #ifdef MODULE ! 3637: Scsi_Host_Template driver_template = GDTH; ! 3638: #include "scsi_module.c" ! 3639: #endif ! 3640:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.