![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to in2000.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi|
Return to in2000.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi |
1.1 ! root 1: /* ! 2: * This file is in2000.c, written and ! 3: * Copyright (C) 1993 Brad McLean ! 4: * Last edit 1/19/95 TZ ! 5: * Disclaimer: ! 6: * Note: This is ugly. I know it, I wrote it, but my whole ! 7: * focus was on getting the damn thing up and out quickly. ! 8: * Future stuff that would be nice: Command chaining, and ! 9: * a local queue of commands would speed stuff up considerably. ! 10: * Disconnection needs some supporting code. All of this ! 11: * is beyond the scope of what I wanted to address, but if you ! 12: * have time and patience, more power to you. ! 13: * Also, there are some constants scattered throughout that ! 14: * should have defines, and I should have built functions to ! 15: * address the registers on the WD chip. ! 16: * Oh well, I'm out of time for this project. ! 17: * The one good thing to be said is that you can use the card. ! 18: */ ! 19: ! 20: /* ! 21: * This module was updated by Shaun Savage first on 5-13-93 ! 22: * At that time the write was fixed, irq detection, and some ! 23: * timing stuff. since that time other problems were fixed. ! 24: * On 7-20-93 this file was updated for patch level 11 ! 25: * There are still problems with it but it work on 95% of ! 26: * the machines. There are still problems with it working with ! 27: * IDE drives, as swap drive and HD that support reselection. ! 28: * But for most people it will work. ! 29: */ ! 30: /* More changes by Bill Earnest, [email protected] ! 31: * through 4/07/94. Includes rewrites of FIFO routines, ! 32: * length-limited commands to make swap partitions work. ! 33: * Merged the changes released by Larry Doolittle, based on input ! 34: * from Jon Luckey, Roger Sunshine, John Shifflett. The FAST_FIFO ! 35: * doesn't work for me. Scatter-gather code from Eric. The change to ! 36: * an IF stmt. in the interrupt routine finally made it stable. ! 37: * Limiting swap request size patch to ll_rw_blk.c not needed now. ! 38: * Please ignore the clutter of debug stmts., pretty can come later. ! 39: */ ! 40: /* Merged code from Matt Postiff improving the auto-sense validation ! 41: * for all I/O addresses. Some reports of problems still come in, but ! 42: * have been unable to reproduce or localize the cause. Some are from ! 43: * LUN > 0 problems, but that is not host specific. Now 6/6/94. ! 44: */ ! 45: /* Changes for 1.1.28 kernel made 7/19/94, code not affected. (WDE) ! 46: */ ! 47: /* Changes for 1.1.43+ kernels made 8/25/94, code added to check for ! 48: * new BIOS version, derived by [email protected]. (WDE) ! 49: * ! 50: * 1/7/95 Fix from Peter Lu ([email protected]) for datalen vs. dataptr ! 51: * logic, much more stable under load. ! 52: * ! 53: * 1/19/95 ([email protected]) Added module and biosparam support for ! 54: * larger SCSI hard drives (untested). ! 55: */ ! 56: ! 57: #ifdef MODULE ! 58: #include <linux/module.h> ! 59: #endif ! 60: ! 61: #include <linux/kernel.h> ! 62: #include <linux/head.h> ! 63: #include <linux/types.h> ! 64: #include <linux/string.h> ! 65: #include <linux/sched.h> ! 66: #include <linux/proc_fs.h> ! 67: #include <asm/dma.h> ! 68: #include <asm/system.h> ! 69: #include <asm/io.h> ! 70: #include <linux/blk.h> ! 71: #include "scsi.h" ! 72: #include "hosts.h" ! 73: #include "sd.h" ! 74: ! 75: #include "in2000.h" ! 76: #include<linux/stat.h> ! 77: ! 78: struct proc_dir_entry proc_scsi_in2000 = { ! 79: PROC_SCSI_IN2000, 6, "in2000", ! 80: S_IFDIR | S_IRUGO | S_IXUGO, 2 ! 81: }; ! 82: ! 83: /*#define FAST_FIFO_IO*/ ! 84: ! 85: /*#define DEBUG*/ ! 86: #ifdef DEBUG ! 87: #define DEB(x) x ! 88: #else ! 89: #define DEB(x) ! 90: #endif ! 91: ! 92: /* These functions are based on include/asm/io.h */ ! 93: #ifndef inw ! 94: inline static unsigned short inw( unsigned short port ) ! 95: { ! 96: unsigned short _v; ! 97: ! 98: __asm__ volatile ("inw %1,%0" ! 99: :"=a" (_v):"d" ((unsigned short) port)); ! 100: return _v; ! 101: } ! 102: #endif ! 103: ! 104: #ifndef outw ! 105: inline static void outw( unsigned short value, unsigned short port ) ! 106: { ! 107: __asm__ volatile ("outw %0,%1" ! 108: : /* no outputs */ ! 109: :"a" ((unsigned short) value), ! 110: "d" ((unsigned short) port)); ! 111: } ! 112: #endif ! 113: ! 114: /* These functions are lifted from drivers/block/hd.c */ ! 115: ! 116: #define port_read(port,buf,nr) \ ! 117: __asm__("cld;rep;insw": :"d" (port),"D" (buf),"c" (nr):"cx","di") ! 118: ! 119: #define port_write(port,buf,nr) \ ! 120: __asm__("cld;rep;outsw": :"d" (port),"S" (buf),"c" (nr):"cx","si") ! 121: ! 122: static unsigned int base; ! 123: static unsigned int ficmsk; ! 124: static unsigned char irq_level; ! 125: static int in2000_datalen; ! 126: static unsigned int in2000_nsegment; ! 127: static unsigned int in2000_current_segment; ! 128: static unsigned short *in2000_dataptr; ! 129: static char in2000_datawrite; ! 130: static struct scatterlist * in2000_scatter; ! 131: static Scsi_Cmnd *in2000_SCptr = 0; ! 132: ! 133: static void (*in2000_done)(Scsi_Cmnd *); ! 134: ! 135: static int in2000_test_port(int index) ! 136: { ! 137: static const int *bios_tab[] = { ! 138: (int *) 0xc8000, (int *) 0xd0000, (int *) 0xd8000 }; ! 139: int i; ! 140: char tmp; ! 141: ! 142: tmp = inb(INFLED); ! 143: /* First, see if the DIP switch values are valid */ ! 144: /* The test of B7 may fail on some early boards, mine works. */ ! 145: if ( ((~tmp & 0x3) != index ) || (tmp & 0x80) || !(tmp & 0x4) ) ! 146: return 0; ! 147: printk("IN-2000 probe got dip setting of %02X\n", tmp); ! 148: tmp = inb(INVERS); ! 149: /* Add some extra sanity checks here */ ! 150: for(i=0; i < 3; i++) ! 151: if(*(bios_tab[i]+0x04) == 0x41564f4e || ! 152: *(bios_tab[i]+0xc) == 0x61776c41) { ! 153: printk("IN-2000 probe found hdw. vers. %02x, BIOS at %06x\n", ! 154: tmp, (unsigned int)bios_tab[i]); ! 155: return 1; ! 156: } ! 157: printk("in2000 BIOS not found.\n"); ! 158: return 0; ! 159: } ! 160: ! 161: ! 162: /* ! 163: * retrieve the current transaction counter from the WD ! 164: */ ! 165: ! 166: static unsigned in2000_txcnt(void) ! 167: { ! 168: unsigned total=0; ! 169: ! 170: if(inb(INSTAT) & 0x20) return 0xffffff; /* not readable now */ ! 171: outb(TXCNTH,INSTAT); /* then autoincrement */ ! 172: total = (inb(INDATA) & 0xff) << 16; ! 173: outb(TXCNTM,INSTAT); ! 174: total += (inb(INDATA) & 0xff) << 8; ! 175: outb(TXCNTL,INSTAT); ! 176: total += (inb(INDATA) & 0xff); ! 177: return total; ! 178: } ! 179: ! 180: /* ! 181: * Note: the FIFO is screwy, and has a counter granularity of 16 bytes, so ! 182: * we have to reconcile the FIFO counter, the transaction byte count from the ! 183: * WD chip, and of course, our desired transaction size. It may look strange, ! 184: * and could probably use improvement, but it works, for now. ! 185: */ ! 186: ! 187: static void in2000_fifo_out(void) /* uses FIFOCNTR */ ! 188: { ! 189: unsigned count, infcnt, txcnt; ! 190: ! 191: infcnt = inb(INFCNT)& 0xfe; /* FIFO counter */ ! 192: do { ! 193: txcnt = in2000_txcnt(); ! 194: /*DEB(printk("FIw:%d %02x %d\n", in2000_datalen, infcnt, txcnt));*/ ! 195: count = (infcnt << 3) - 32; /* don't fill completely */ ! 196: if ( count > in2000_datalen ) ! 197: count = in2000_datalen; /* limit to actual data on hand */ ! 198: count >>= 1; /* Words, not bytes */ ! 199: #ifdef FAST_FIFO_IO ! 200: if ( count ) { ! 201: port_write(INFIFO, in2000_dataptr, count); ! 202: in2000_datalen -= (count<<1); ! 203: } ! 204: #else ! 205: while ( count-- ) ! 206: { ! 207: outw(*in2000_dataptr++, INFIFO); ! 208: in2000_datalen -= 2; ! 209: } ! 210: #endif ! 211: } while((in2000_datalen > 0) && ((infcnt = (inb(INFCNT)) & 0xfe) >= 0x20) ); ! 212: /* If scatter-gather, go on to next segment */ ! 213: if( !in2000_datalen && ++in2000_current_segment < in2000_nsegment) ! 214: { ! 215: in2000_scatter++; ! 216: in2000_datalen = in2000_scatter->length; ! 217: in2000_dataptr = (unsigned short*)in2000_scatter->address; ! 218: } ! 219: if ( in2000_datalen <= 0 ) ! 220: { ! 221: ficmsk = 0; ! 222: count = 32; /* Always says to use this much flush */ ! 223: while ( count-- ) ! 224: outw(0, INFIFO); ! 225: outb(2, ININTR); /* Mask FIFO Interrupts when done */ ! 226: } ! 227: } ! 228: ! 229: static void in2000_fifo_in(void) /* uses FIFOCNTR */ ! 230: { ! 231: unsigned fic, count, count2; ! 232: ! 233: count = inb(INFCNT) & 0xe1; ! 234: do{ ! 235: count2 = count; ! 236: count = (fic = inb(INFCNT)) & 0xe1; ! 237: } while ( count != count2 ); ! 238: DEB(printk("FIir:%d %02x %08x\n", in2000_datalen,fic,(unsigned int )in2000_dataptr)); ! 239: do { ! 240: count2 = in2000_txcnt(); /* bytes yet to come over SCSI bus */ ! 241: DEB(printk("FIr:%d %02x %08x %08x\n", in2000_datalen,fic,count2,(unsigned int)in2000_dataptr)); ! 242: if(count2 > 65536) count2 = 0; ! 243: if(fic > 128) count = 1024; ! 244: else if(fic > 64) count = 512; ! 245: else if (fic > 32) count = 256; ! 246: else if ( count2 < in2000_datalen ) /* if drive has < what we want */ ! 247: count = in2000_datalen - count2; /* FIFO has the rest */ ! 248: if ( count > in2000_datalen ) /* count2 is lesser of FIFO & rqst */ ! 249: count2 = in2000_datalen >> 1; /* converted to word count */ ! 250: else ! 251: count2 = count >> 1; ! 252: count >>= 1; /* also to words */ ! 253: count -= count2; /* extra left over in FIFO */ ! 254: #ifdef FAST_FIFO_IO ! 255: if ( count2 ) { ! 256: port_read(INFIFO, in2000_dataptr, count2); ! 257: in2000_datalen -= (count2<<1); ! 258: } ! 259: #else ! 260: while ( count2-- ) ! 261: { ! 262: *in2000_dataptr++ = inw(INFIFO); ! 263: in2000_datalen -=2; ! 264: } ! 265: #endif ! 266: } while((in2000_datalen > 0) && (fic = inb(INFCNT)) ); ! 267: DEB(printk("FIer:%d %02x %08x\n", in2000_datalen,fic,(unsigned int )in2000_dataptr)); ! 268: /* while ( count-- ) ! 269: inw(INFIFO);*/ /* Throw away some extra stuff */ ! 270: if( !in2000_datalen && ++in2000_current_segment < in2000_nsegment) ! 271: { ! 272: in2000_scatter++; ! 273: in2000_datalen = in2000_scatter->length; ! 274: in2000_dataptr = (unsigned short*)in2000_scatter->address; ! 275: } ! 276: if ( ! in2000_datalen ){ ! 277: outb(2, ININTR); /* Mask FIFO Interrupts when done */ ! 278: ficmsk = 0;} ! 279: } ! 280: ! 281: static void in2000_intr_handle(int irq, struct pt_regs *regs) ! 282: { ! 283: int result=0; ! 284: unsigned int count,auxstatus,scsistatus,cmdphase,scsibyte; ! 285: int action=0; ! 286: Scsi_Cmnd *SCptr; ! 287: ! 288: DEB(printk("INT:%d %02x %08x\n", in2000_datalen, inb(INFCNT),(unsigned int)in2000_dataptr)); ! 289: ! 290: if (( (ficmsk & (count = inb(INFCNT))) == 0xfe ) || ! 291: ( (inb(INSTAT) & 0x8c) == 0x80)) ! 292: { /* FIFO interrupt or WD interrupt */ ! 293: auxstatus = inb(INSTAT); /* need to save now */ ! 294: outb(SCSIST,INSTAT); ! 295: scsistatus = inb(INDATA); /* This clears the WD intrpt bit */ ! 296: outb(TARGETU,INSTAT); /* then autoincrement */ ! 297: scsibyte = inb(INDATA); /* Get the scsi status byte */ ! 298: outb(CMDPHAS,INSTAT); ! 299: cmdphase = inb(INDATA); ! 300: DEB(printk("(int2000:%02x %02x %02x %02x %02x)\n",count,auxstatus, ! 301: scsistatus,cmdphase,scsibyte)); ! 302: ! 303: /* Why do we assume that we need to send more data here??? ERY */ ! 304: if ( in2000_datalen ) /* data xfer pending */ ! 305: { ! 306: if ( in2000_dataptr == NULL ) ! 307: printk("int2000: dataptr=NULL datalen=%d\n", ! 308: in2000_datalen); ! 309: else if ( in2000_datawrite ) ! 310: in2000_fifo_out(); ! 311: else ! 312: in2000_fifo_in(); ! 313: } ! 314: if ( (auxstatus & 0x8c) == 0x80 ) ! 315: { /* There is a WD Chip interrupt & register read good */ ! 316: outb(2,ININTR); /* Disable fifo interrupts */ ! 317: ficmsk = 0; ! 318: result = DID_OK << 16; ! 319: /* 16=Select & transfer complete, 85=got disconnect */ ! 320: if ((scsistatus != 0x16) && (scsistatus != 0x85) ! 321: && (scsistatus != 0x42)){ ! 322: /* printk("(WDi2000:%02x %02x %02x %02x %02x)\n",count,auxstatus, ! 323: scsistatus,cmdphase,scsibyte);*/ ! 324: /* printk("QDAT:%d %08x %02x\n", ! 325: in2000_datalen,(unsigned int)in2000_dataptr,ficmsk);*/ ! 326: ; ! 327: } ! 328: switch ( scsistatus & 0xf0 ) ! 329: { ! 330: case 0x00: /* Card Reset Completed */ ! 331: action = 3; ! 332: break; ! 333: case 0x10: /* Successful Command Completion */ ! 334: if ( scsistatus & 0x8 ) ! 335: action = 1; ! 336: break; ! 337: case 0x20: /* Command Paused or Aborted */ ! 338: if ( (scsistatus & 0x8) ) ! 339: action = 1; ! 340: else if ( (scsistatus & 7) < 2 ) ! 341: action = 2; ! 342: else ! 343: result = DID_ABORT << 16; ! 344: break; ! 345: case 0x40: /* Terminated early */ ! 346: if ( scsistatus & 0x8 ) ! 347: action = 1; ! 348: else if ( (scsistatus & 7) > 2 ) ! 349: action = 2; ! 350: else ! 351: result = DID_TIME_OUT << 16; ! 352: break; ! 353: case 0x80: /* Service Required from SCSI bus */ ! 354: if ( scsistatus & 0x8 ) ! 355: action = 1; ! 356: else ! 357: action = 2; ! 358: break; ! 359: } /* end switch(scsistatus) */ ! 360: outb(0,INFLED); ! 361: switch ( action ) ! 362: { ! 363: case 0x02: /* Issue an abort */ ! 364: outb(COMMAND,INSTAT); ! 365: outb(1,INDATA); /* ABORT COMMAND */ ! 366: result = DID_ABORT << 16; ! 367: case 0x00: /* Basically all done */ ! 368: if ( ! in2000_SCptr ) ! 369: return; ! 370: in2000_SCptr->result = result | scsibyte; ! 371: SCptr = in2000_SCptr; ! 372: in2000_SCptr = 0; ! 373: if ( in2000_done ) ! 374: (*in2000_done)(SCptr); ! 375: break; ! 376: case 0x01: /* We need to reissue a command */ ! 377: outb(CMDPHAS,INSTAT); ! 378: switch ( scsistatus & 7 ) ! 379: { ! 380: case 0: /* Data out phase */ ! 381: case 1: /* Data in phase */ ! 382: case 4: /* Unspec info out phase */ ! 383: case 5: /* Unspec info in phase */ ! 384: case 6: /* Message in phase */ ! 385: case 7: /* Message in phase */ ! 386: outb(0x41,INDATA); /* rdy to disconn */ ! 387: break; ! 388: case 2: /* command phase */ ! 389: outb(0x30,INDATA); /* rdy to send cmd bytes */ ! 390: break; ! 391: case 3: /* status phase */ ! 392: outb(0x45,INDATA); /* To go to status phase,*/ ! 393: outb(TXCNTH,INSTAT); /* elim. data, autoinc */ ! 394: outb(0,INDATA); ! 395: outb(0,INDATA); ! 396: outb(0,INDATA); ! 397: in2000_datalen = 0; ! 398: in2000_dataptr = 0; ! 399: break; ! 400: } /* end switch(scsistatus) */ ! 401: outb(COMMAND,INSTAT); ! 402: outb(8,INDATA); /* RESTART THE COMMAND */ ! 403: break; ! 404: case 0x03: /* Finish up a Card Reset */ ! 405: outb(TIMEOUT,INSTAT); /* I got these values */ ! 406: /* by reverse Engineering */ ! 407: outb(IN2000_TMOUT,INDATA); /* the Always' bios. */ ! 408: outb(CONTROL,INSTAT); ! 409: outb(0,INDATA); ! 410: outb(SYNCTXR,INSTAT); ! 411: outb(0x40,INDATA); /* async, 4 cyc xfer per. */ ! 412: break; ! 413: } /* end switch(action) */ ! 414: } /* end if auxstatus for WD int */ ! 415: } /* end while intrpt active */ ! 416: } ! 417: ! 418: int in2000_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *)) ! 419: { ! 420: unchar direction; ! 421: unchar *cmd = (unchar *) SCpnt->cmnd; ! 422: unchar target = SCpnt->target; ! 423: void *buff = SCpnt->request_buffer; ! 424: unsigned long flags; ! 425: int bufflen = SCpnt->request_bufflen; ! 426: int timeout, size, loop; ! 427: int i; ! 428: ! 429: /* ! 430: * This SCSI command has no data phase, but unfortunately the mid-level ! 431: * SCSI drivers ask for 256 bytes of data xfer. Our card hangs if you ! 432: * do this, so we protect against it here. It would be nice if the mid- ! 433: * level could be changed, but who knows if that would break other host ! 434: * adapter drivers. ! 435: */ ! 436: if ( *cmd == TEST_UNIT_READY ) ! 437: bufflen = 0; ! 438: ! 439: /* ! 440: * What it looks like. Boy did I get tired of reading its output. ! 441: */ ! 442: if (*cmd == READ_10 || *cmd == WRITE_10) { ! 443: i = xscsi2int((cmd+1)); ! 444: } else if (*cmd == READ_6 || *cmd == WRITE_6) { ! 445: i = scsi2int((cmd+1)); ! 446: } else { ! 447: i = -1; ! 448: } ! 449: #ifdef DEBUG ! 450: printk("in2000qcmd: pos %d len %d ", i, bufflen); ! 451: printk("scsi cmd:"); ! 452: for (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]); ! 453: printk("\n"); ! 454: #endif ! 455: direction = 1; /* assume for most commands */ ! 456: if (*cmd == WRITE_10 || *cmd == WRITE_6) ! 457: direction = 0; ! 458: size = SCpnt->cmd_len; /* CDB length */ ! 459: /* ! 460: * Setup our current pointers ! 461: * This is where you would allocate a control structure in a queue, ! 462: * If you were going to upgrade this to do multiple issue. ! 463: * Note that datalen and dataptr exist because we can change the ! 464: * values during the course of the operation, while managing the ! 465: * FIFO. ! 466: * Note the nasty little first clause. In theory, the mid-level ! 467: * drivers should never hand us more than one command at a time, ! 468: * but just in case someone gets cute in configuring the driver, ! 469: * we'll protect them, although not very politely. ! 470: */ ! 471: if ( in2000_SCptr ) ! 472: { ! 473: printk("in2000_queue_command waiting for free command block!\n"); ! 474: while ( in2000_SCptr ) ! 475: barrier(); ! 476: } ! 477: for ( timeout = jiffies + 5; timeout > jiffies; ) ! 478: { ! 479: if ( ! ( inb(INSTAT) & 0xb0 ) ) ! 480: { ! 481: timeout = 0; ! 482: break; ! 483: } ! 484: else ! 485: { ! 486: inb(INSTAT); ! 487: outb(SCSIST,INSTAT); ! 488: inb(INDATA); ! 489: outb(TARGETU,INSTAT); /* then autoinc */ ! 490: inb(INDATA); ! 491: inb(INDATA); ! 492: } ! 493: } ! 494: if ( timeout ) ! 495: { ! 496: printk("in2000_queue_command timeout!\n"); ! 497: SCpnt->result = DID_TIME_OUT << 16; ! 498: (*done)(SCpnt); ! 499: return 1; ! 500: } ! 501: /* Added for scatter-gather support */ ! 502: in2000_nsegment = SCpnt->use_sg; ! 503: in2000_current_segment = 0; ! 504: if(SCpnt->use_sg){ ! 505: in2000_scatter = (struct scatterlist *) buff; ! 506: in2000_datalen = in2000_scatter->length; ! 507: in2000_dataptr = (unsigned short*)in2000_scatter->address; ! 508: } else { ! 509: in2000_scatter = NULL; ! 510: in2000_datalen = bufflen; ! 511: in2000_dataptr = (unsigned short*) buff; ! 512: }; ! 513: in2000_done = done; ! 514: in2000_SCptr = SCpnt; ! 515: /* ! 516: * Write the CDB to the card, then the LUN, the length, and the target. ! 517: */ ! 518: outb(TOTSECT, INSTAT); /* start here then autoincrement */ ! 519: for ( loop=0; loop < size; loop++ ) ! 520: outb(cmd[loop],INDATA); ! 521: outb(TARGETU,INSTAT); ! 522: outb(SCpnt->lun & 7,INDATA); ! 523: SCpnt->host_scribble = NULL; ! 524: outb(TXCNTH,INSTAT); /* then autoincrement */ ! 525: outb(bufflen>>16,INDATA); ! 526: outb(bufflen>>8,INDATA); ! 527: outb(bufflen,INDATA); ! 528: outb(target&7,INDATA); ! 529: /* ! 530: * Set up the FIFO ! 531: */ ! 532: save_flags(flags); ! 533: cli(); /* so FIFO init waits till WD set */ ! 534: outb(0,INFRST); ! 535: if ( direction == 1 ) ! 536: { ! 537: in2000_datawrite = 0; ! 538: outb(0,INFWRT); ! 539: } ! 540: else ! 541: { ! 542: in2000_datawrite = 1; ! 543: for ( loop=16; --loop; ) /* preload the outgoing fifo */ ! 544: { ! 545: outw(*in2000_dataptr++,INFIFO); ! 546: if(in2000_datalen > 0) in2000_datalen-=2; ! 547: } ! 548: } ! 549: ficmsk = 0xff; ! 550: /* ! 551: * Start it up ! 552: */ ! 553: outb(CONTROL,INSTAT); /* WD BUS Mode */ ! 554: outb(0x4C,INDATA); ! 555: if ( in2000_datalen ) /* if data xfer cmd */ ! 556: outb(0,ININTR); /* Enable FIFO intrpt some boards? */ ! 557: outb(COMMAND,INSTAT); ! 558: outb(0,INNLED); ! 559: outb(8,INDATA); /* Select w/ATN & Transfer */ ! 560: restore_flags(flags); /* let the intrpt rip */ ! 561: return 0; ! 562: } ! 563: ! 564: static volatile int internal_done_flag = 0; ! 565: static volatile int internal_done_errcode = 0; ! 566: ! 567: static void internal_done(Scsi_Cmnd * SCpnt) ! 568: { ! 569: internal_done_errcode = SCpnt->result; ! 570: ++internal_done_flag; ! 571: } ! 572: ! 573: int in2000_command(Scsi_Cmnd * SCpnt) ! 574: { ! 575: in2000_queuecommand(SCpnt, internal_done); ! 576: ! 577: while (!internal_done_flag); ! 578: internal_done_flag = 0; ! 579: return internal_done_errcode; ! 580: } ! 581: ! 582: int in2000_detect(Scsi_Host_Template * tpnt) ! 583: { ! 584: /* Order chosen to reduce conflicts with some multi-port serial boards */ ! 585: int base_tab[] = { 0x220,0x200,0x110,0x100 }; ! 586: int int_tab[] = { 15,14,11,10 }; ! 587: struct Scsi_Host * shpnt; ! 588: int loop, tmp; ! 589: ! 590: DEB(printk("in2000_detect: \n")); ! 591: ! 592: tpnt->proc_dir = &proc_scsi_in2000; ! 593: ! 594: for ( loop=0; loop < 4; loop++ ) ! 595: { ! 596: base = base_tab[loop]; ! 597: if ( in2000_test_port(loop)) break; ! 598: } ! 599: if ( loop == 4 ) ! 600: return 0; ! 601: ! 602: /* Read the dip switch values again for miscellaneous checking and ! 603: informative messages */ ! 604: tmp = inb(INFLED); ! 605: ! 606: /* Bit 2 tells us if interrupts are disabled */ ! 607: if ( (tmp & 0x4) == 0 ) { ! 608: printk("The IN-2000 is not configured for interrupt operation\n"); ! 609: printk("Change the DIP switch settings to enable interrupt operation\n"); ! 610: } ! 611: ! 612: /* Bit 6 tells us about floppy controller */ ! 613: printk("IN-2000 probe found floppy controller on IN-2000 "); ! 614: if ( (tmp & 0x40) == 0) ! 615: printk("enabled\n"); ! 616: else ! 617: printk("disabled\n"); ! 618: ! 619: /* Bit 5 tells us about synch/asynch mode */ ! 620: printk("IN-2000 probe found IN-2000 in "); ! 621: if ( (tmp & 0x20) == 0) ! 622: printk("synchronous mode\n"); ! 623: else ! 624: printk("asynchronous mode\n"); ! 625: ! 626: irq_level = int_tab [ ((~inb(INFLED)>>3)&0x3) ]; ! 627: ! 628: printk("Configuring IN2000 at IO:%x, IRQ %d" ! 629: #ifdef FAST_FIFO_IO ! 630: " (using fast FIFO I/O code)" ! 631: #endif ! 632: "\n",base, irq_level); ! 633: ! 634: outb(2,ININTR); /* Shut off the FIFO first, so it won't ask for data.*/ ! 635: if (request_irq(irq_level,in2000_intr_handle, 0, "in2000")) ! 636: { ! 637: printk("in2000_detect: Unable to allocate IRQ.\n"); ! 638: return 0; ! 639: } ! 640: outb(0,INFWRT); /* read mode so WD can intrpt */ ! 641: outb(SCSIST,INSTAT); ! 642: inb(INDATA); /* free status reg, clear WD intrpt */ ! 643: outb(OWNID,INSTAT); ! 644: outb(0x7,INDATA); /* we use addr 7 */ ! 645: outb(COMMAND,INSTAT); ! 646: outb(0,INDATA); /* do chip reset */ ! 647: shpnt = scsi_register(tpnt, 0); ! 648: /* Set these up so that we can unload the driver properly. */ ! 649: shpnt->io_port = base; ! 650: shpnt->n_io_port = 12; ! 651: shpnt->irq = irq_level; ! 652: request_region(base, 12,"in2000"); /* Prevent other drivers from using this space */ ! 653: return 1; ! 654: } ! 655: ! 656: int in2000_abort(Scsi_Cmnd * SCpnt) ! 657: { ! 658: DEB(printk("in2000_abort\n")); ! 659: /* ! 660: * Ask no stupid questions, just order the abort. ! 661: */ ! 662: outb(COMMAND,INSTAT); ! 663: outb(1,INDATA); /* Abort Command */ ! 664: return 0; ! 665: } ! 666: ! 667: static inline void delay( unsigned how_long ) ! 668: { ! 669: unsigned long time = jiffies + how_long; ! 670: while (jiffies < time) ; ! 671: } ! 672: ! 673: int in2000_reset(Scsi_Cmnd * SCpnt) ! 674: { ! 675: DEB(printk("in2000_reset called\n")); ! 676: /* ! 677: * Note: this is finished off by an incoming interrupt ! 678: */ ! 679: outb(0,INFWRT); /* read mode so WD can intrpt */ ! 680: outb(SCSIST,INSTAT); ! 681: inb(INDATA); ! 682: outb(OWNID,INSTAT); ! 683: outb(0x7,INDATA); /* ID=7,noadv, no parity, clk div=2 (8-10Mhz clk) */ ! 684: outb(COMMAND,INSTAT); ! 685: outb(0,INDATA); /* reset WD chip */ ! 686: delay(2); ! 687: #ifdef SCSI_RESET_PENDING ! 688: return SCSI_RESET_PENDING; ! 689: #else ! 690: if(SCpnt) SCpnt->flags |= NEEDS_JUMPSTART; ! 691: return 0; ! 692: #endif ! 693: } ! 694: ! 695: int in2000_biosparam(Disk * disk, kdev_t dev, int* iinfo) ! 696: { ! 697: int size = disk->capacity; ! 698: DEB(printk("in2000_biosparam\n")); ! 699: iinfo[0] = 64; ! 700: iinfo[1] = 32; ! 701: iinfo[2] = size >> 11; ! 702: /* This should approximate the large drive handling that the DOS ASPI manager ! 703: uses. Drives very near the boundaries may not be handled correctly (i.e. ! 704: near 2.0 Gb and 4.0 Gb) */ ! 705: if (iinfo[2] > 1024) { ! 706: iinfo[0] = 64; ! 707: iinfo[1] = 63; ! 708: iinfo[2] = disk->capacity / (iinfo[0] * iinfo[1]); ! 709: } ! 710: if (iinfo[2] > 1024) { ! 711: iinfo[0] = 128; ! 712: iinfo[1] = 63; ! 713: iinfo[2] = disk->capacity / (iinfo[0] * iinfo[1]); ! 714: } ! 715: if (iinfo[2] > 1024) { ! 716: iinfo[0] = 255; ! 717: iinfo[1] = 63; ! 718: iinfo[2] = disk->capacity / (iinfo[0] * iinfo[1]); ! 719: if (iinfo[2] > 1023) ! 720: iinfo[2] = 1023; ! 721: } ! 722: return 0; ! 723: } ! 724: ! 725: #ifdef MODULE ! 726: /* Eventually this will go into an include file, but this will be later */ ! 727: Scsi_Host_Template driver_template = IN2000; ! 728: ! 729: #include "scsi_module.c" ! 730: #endif ! 731:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.