Return to pas16.c CVS log

Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi

Annotation of Gnu-Mach/i386/i386at/gpl/linux/scsi/pas16.c, revision 1.1

1.1     ! root        1: #define AUTOSENSE
        !             2: #define PSEUDO_DMA
        !             3: #define FOO
        !             4: #define UNSAFE  /* Not unsafe for PAS16 -- use it */
        !             5: 
        !             6: /*
        !             7:  * This driver adapted from Drew Eckhardt's Trantor T128 driver
        !             8:  *
        !             9:  * Copyright 1993, Drew Eckhardt
        !            10:  *     Visionary Computing
        !            11:  *     (Unix and Linux consulting and custom programming)
        !            12:  *     [email protected]
        !            13:  *      +1 (303) 666-5836
        !            14:  *
        !            15:  *  ( Based on T128 - DISTRIBUTION RELEASE 3. ) 
        !            16:  *
        !            17:  * Modified to work with the Pro Audio Spectrum/Studio 16
        !            18:  * by John Weidman.
        !            19:  *
        !            20:  *
        !            21:  * For more information, please consult 
        !            22:  *
        !            23:  * Media Vision
        !            24:  * (510) 770-8600
        !            25:  * (800) 348-7116
        !            26:  * 
        !            27:  * and 
        !            28:  *
        !            29:  * NCR 5380 Family
        !            30:  * SCSI Protocol Controller
        !            31:  * Databook
        !            32:  *
        !            33:  * NCR Microelectronics
        !            34:  * 1635 Aeroplaza Drive
        !            35:  * Colorado Springs, CO 80916
        !            36:  * 1+ (719) 578-3400
        !            37:  * 1+ (800) 334-5454
        !            38:  */
        !            39: 
        !            40: /*
        !            41:  * Options : 
        !            42:  * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
        !            43:  *      for commands that return with a CHECK CONDITION status. 
        !            44:  *
        !            45:  * LIMIT_TRANSFERSIZE - if defined, limit the pseudo-dma transfers to 512
        !            46:  *      bytes at a time.  Since interrupts are disabled by default during
        !            47:  *      these transfers, we might need this to give reasonable interrupt
        !            48:  *      service time if the transfer size gets too large.
        !            49:  *
        !            50:  * PSEUDO_DMA - enables PSEUDO-DMA hardware, should give a 3-4X performance
        !            51:  * increase compared to polled I/O.
        !            52:  *
        !            53:  * PARITY - enable parity checking.  Not supported.
        !            54:  * 
        !            55:  * SCSI2 - enable support for SCSI-II tagged queueing.  Untested.
        !            56:  *
        !            57:  * UNSAFE - leave interrupts enabled during pseudo-DMA transfers.  This
        !            58:  *         parameter comes from the NCR5380 code.  It is NOT unsafe with
        !            59:  *         the PAS16 and you should use it.  If you don't you will have
        !            60:  *         a problem with dropped characters during high speed
        !            61:  *         communications during SCSI transfers.  If you really don't
        !            62:  *         want to use UNSAFE you can try defining LIMIT_TRANSFERSIZE or
        !            63:  *         twiddle with the transfer size in the high level code.
        !            64:  *
        !            65:  * USLEEP - enable support for devices that don't disconnect.  Untested.
        !            66:  *
        !            67:  * The card is detected and initialized in one of several ways : 
        !            68:  * 1.  Autoprobe (default) - There are many different models of
        !            69:  *     the Pro Audio Spectrum/Studio 16, and I only have one of
        !            70:  *     them, so this may require a little tweaking.  An interrupt
        !            71:  *     is triggered to autoprobe for the interrupt line.  Note:
        !            72:  *     with the newer model boards, the interrupt is set via
        !            73:  *     software after reset using the default_irq for the
        !            74:  *     current board number.
        !            75:  *
        !            76:  *
        !            77:  * 2.  With command line overrides - pas16=port,irq may be 
        !            78:  *     used on the LILO command line to override the defaults.
        !            79:  *
        !            80:  * 3.  With the PAS16_OVERRIDE compile time define.  This is 
        !            81:  *     specified as an array of address, irq tuples.  Ie, for
        !            82:  *     one board at the default 0x388 address, IRQ10, I could say 
        !            83:  *     -DPAS16_OVERRIDE={{0x388, 10}}
        !            84:  *     NOTE:  Untested.
        !            85:  *     
        !            86:  *     Note that if the override methods are used, place holders must
        !            87:  *     be specified for other boards in the system.
        !            88:  *
        !            89:  *
        !            90:  * Configuration notes :
        !            91:  *   The current driver does not support interrupt sharing with the
        !            92:  *   sound portion of the card.  If you use the same irq for the
        !            93:  *   scsi port and sound you will have problems.  Either use
        !            94:  *   a different irq for the scsi port or don't use interrupts
        !            95:  *   for the scsi port.
        !            96:  *
        !            97:  *   If you have problems with your card not being recognized, use
        !            98:  *   the LILO command line override.  Try to get it recognized without
        !            99:  *   interrupts.  Ie, for a board at the default 0x388 base port,
        !           100:  *   boot: linux pas16=0x388,255
        !           101:  *
        !           102:  *     (255 is the IRQ_NONE constant in NCR5380.h)
        !           103:  */
        !           104:  
        !           105: #ifdef MODULE
        !           106: #include <linux/module.h>
        !           107: #endif
        !           108: 
        !           109: #include <asm/system.h>
        !           110: #include <linux/signal.h>
        !           111: #include <linux/proc_fs.h>
        !           112: #include <linux/sched.h>
        !           113: #include <asm/io.h>
        !           114: #include <linux/blk.h>
        !           115: #include "scsi.h"
        !           116: #include "hosts.h"
        !           117: #include "pas16.h"
        !           118: #define AUTOPROBE_IRQ
        !           119: #include "NCR5380.h"
        !           120: #include "constants.h"
        !           121: #include "sd.h"
        !           122: 
        !           123: #include<linux/stat.h>
        !           124: 
        !           125: struct proc_dir_entry proc_scsi_pas16 = {
        !           126:     PROC_SCSI_PAS16, 5, "pas16",
        !           127:     S_IFDIR | S_IRUGO | S_IXUGO, 2
        !           128: };
        !           129: 
        !           130: int scsi_irq_translate[] =
        !           131:        { 0,  0,  1,  2,  3,  4,  5,  6, 0,  0,  7,  8,  9,  0, 10, 11 };
        !           132: 
        !           133: /* The default_irqs array contains values used to set the irq into the
        !           134:  * board via software (as must be done on newer model boards without
        !           135:  * irq jumpers on the board).  The first value in the array will be
        !           136:  * assigned to logical board 0, the next to board 1, etc.
        !           137:  */
        !           138: int default_irqs[] = {  PAS16_DEFAULT_BOARD_1_IRQ,
        !           139:                        PAS16_DEFAULT_BOARD_2_IRQ,
        !           140:                        PAS16_DEFAULT_BOARD_3_IRQ,
        !           141:                        PAS16_DEFAULT_BOARD_4_IRQ
        !           142:                     };
        !           143: 
        !           144: static struct override {
        !           145:     unsigned short io_port;
        !           146:     int  irq;
        !           147: } overrides 
        !           148: #ifdef PAS16_OVERRIDE
        !           149:     [] = PAS16_OVERRIDE;
        !           150: #else
        !           151:     [4] = {{0,IRQ_AUTO}, {0,IRQ_AUTO}, {0,IRQ_AUTO},
        !           152:        {0,IRQ_AUTO}};
        !           153: #endif
        !           154: 
        !           155: #define NO_OVERRIDES (sizeof(overrides) / sizeof(struct override))
        !           156: 
        !           157: static struct base {
        !           158:     unsigned short io_port;
        !           159:     int noauto;
        !           160: } bases[] = { {PAS16_DEFAULT_BASE_1, 0},
        !           161:              {PAS16_DEFAULT_BASE_2, 0},
        !           162:              {PAS16_DEFAULT_BASE_3, 0},
        !           163:              {PAS16_DEFAULT_BASE_4, 0}
        !           164:            };
        !           165: 
        !           166: #define NO_BASES (sizeof (bases) / sizeof (struct base))
        !           167: 
        !           168: unsigned short  pas16_offset[ 8 ] =
        !           169:     {
        !           170:        0x1c00,    /* OUTPUT_DATA_REG */
        !           171:        0x1c01,    /* INITIATOR_COMMAND_REG */
        !           172:        0x1c02,    /* MODE_REG */
        !           173:        0x1c03,    /* TARGET_COMMAND_REG */
        !           174:        0x3c00,    /* STATUS_REG ro, SELECT_ENABLE_REG wo */
        !           175:        0x3c01,    /* BUS_AND_STATUS_REG ro, START_DMA_SEND_REG wo */
        !           176:        0x3c02,    /* INPUT_DATA_REGISTER ro, (N/A on PAS16 ?)
        !           177:                    * START_DMA_TARGET_RECEIVE_REG wo
        !           178:                    */
        !           179:        0x3c03,    /* RESET_PARITY_INTERRUPT_REG ro,
        !           180:                    * START_DMA_INITIATOR_RECEIVE_REG wo
        !           181:                    */
        !           182:     };
        !           183: 
        !           184: 
        !           185: 
        !           186: /*
        !           187:  * Function : enable_board( int  board_num, unsigned short port )
        !           188:  *
        !           189:  * Purpose :  set address in new model board
        !           190:  *
        !           191:  * Inputs : board_num - logical board number 0-3, port - base address
        !           192:  *
        !           193:  */
        !           194: 
        !           195: void   enable_board( int  board_num,  unsigned short port )
        !           196: {
        !           197:     outb( 0xbc + board_num, MASTER_ADDRESS_PTR );
        !           198:     outb( port >> 2, MASTER_ADDRESS_PTR );
        !           199: }
        !           200: 
        !           201: 
        !           202: 
        !           203: /*
        !           204:  * Function : init_board( unsigned short port, int irq )
        !           205:  *
        !           206:  * Purpose :  Set the board up to handle the SCSI interface
        !           207:  *
        !           208:  * Inputs : port - base address of the board,
        !           209:  *         irq - irq to assign to the SCSI port
        !           210:  *         force_irq - set it even if it conflicts with sound driver
        !           211:  *
        !           212:  */
        !           213: 
        !           214: void   init_board( unsigned short io_port, int irq, int force_irq )
        !           215: {
        !           216:        unsigned int    tmp;
        !           217:        unsigned int    pas_irq_code;
        !           218: 
        !           219:        /* Initialize the SCSI part of the board */
        !           220: 
        !           221:        outb( 0x30, io_port + P_TIMEOUT_COUNTER_REG );  /* Timeout counter */
        !           222:        outb( 0x01, io_port + P_TIMEOUT_STATUS_REG_OFFSET );   /* Reset TC */
        !           223:        outb( 0x01, io_port + WAIT_STATE );   /* 1 Wait state */
        !           224: 
        !           225:        NCR5380_read( RESET_PARITY_INTERRUPT_REG );
        !           226: 
        !           227:        /* Set the SCSI interrupt pointer without mucking up the sound
        !           228:         * interrupt pointer in the same byte.
        !           229:         */
        !           230:        pas_irq_code = ( irq < 16 ) ? scsi_irq_translate[irq] : 0;
        !           231:        tmp = inb( io_port + IO_CONFIG_3 );
        !           232: 
        !           233:        if( (( tmp & 0x0f ) == pas_irq_code) && pas_irq_code > 0 
        !           234:            && !force_irq )
        !           235:        {
        !           236:            printk( "pas16: WARNING: Can't use same irq as sound "
        !           237:                    "driver -- interrupts disabled\n" );
        !           238:            /* Set up the drive parameters, disable 5380 interrupts */
        !           239:            outb( 0x4d, io_port + SYS_CONFIG_4 );
        !           240:        }
        !           241:        else
        !           242:        {
        !           243:            tmp = (  tmp & 0x0f ) | ( pas_irq_code << 4 );
        !           244:            outb( tmp, io_port + IO_CONFIG_3 );
        !           245: 
        !           246:            /* Set up the drive parameters and enable 5380 interrupts */
        !           247:            outb( 0x6d, io_port + SYS_CONFIG_4 );
        !           248:        }
        !           249: }
        !           250: 
        !           251: 
        !           252: /*
        !           253:  * Function : pas16_hw_detect( unsigned short board_num )
        !           254:  *
        !           255:  * Purpose : determine if a pas16 board is present
        !           256:  * 
        !           257:  * Inputs : board_num - logical board number ( 0 - 3 )
        !           258:  *
        !           259:  * Returns : 0 if board not found, 1 if found.
        !           260:  */
        !           261: 
        !           262: int     pas16_hw_detect( unsigned short  board_num )
        !           263: {
        !           264:     unsigned char      board_rev, tmp;
        !           265:     unsigned short     io_port = bases[ board_num ].io_port;
        !           266: 
        !           267:     /* See if we can find a PAS16 board at the address associated
        !           268:      * with this logical board number.
        !           269:      */
        !           270: 
        !           271:     /* First, attempt to take a newer model board out of reset and
        !           272:      * give it a base address.  This shouldn't affect older boards.
        !           273:      */
        !           274:     enable_board( board_num, io_port );
        !           275: 
        !           276:     /* Now see if it looks like a PAS16 board */
        !           277:     board_rev = inb( io_port + PCB_CONFIG );
        !           278: 
        !           279:     if( board_rev == 0xff )
        !           280:        return 0;
        !           281: 
        !           282:     tmp = board_rev ^ 0xe0;
        !           283: 
        !           284:     outb( tmp, io_port + PCB_CONFIG );
        !           285:     tmp = inb( io_port + PCB_CONFIG );
        !           286:     outb( board_rev, io_port + PCB_CONFIG );
        !           287: 
        !           288:     if( board_rev != tmp )     /* Not a PAS-16 */
        !           289:        return 0;
        !           290: 
        !           291:     if( ( inb( io_port + OPERATION_MODE_1 ) & 0x03 ) != 0x03 ) 
        !           292:        return 0;       /* return if no SCSI interface found */
        !           293: 
        !           294:     /* Mediavision has some new model boards that return ID bits
        !           295:      * that indicate a SCSI interface, but they're not (LMS).  We'll
        !           296:      * put in an additional test to try and weed them out.
        !           297:      */
        !           298: 
        !           299:     outb( 0x01, io_port + WAIT_STATE );        /* 1 Wait state */
        !           300:     NCR5380_write( MODE_REG, 0x20 );           /* Is it really SCSI? */
        !           301:     if( NCR5380_read( MODE_REG ) != 0x20 )     /* Write to a reg.    */
        !           302:        return 0;                               /* and try to read    */
        !           303:     NCR5380_write( MODE_REG, 0x00 );           /* it back.           */
        !           304:     if( NCR5380_read( MODE_REG ) != 0x00 )
        !           305:        return 0;
        !           306: 
        !           307:     return 1;
        !           308: }
        !           309: 
        !           310: 
        !           311: /*
        !           312:  * Function : pas16_setup(char *str, int *ints)
        !           313:  *
        !           314:  * Purpose : LILO command line initialization of the overrides array,
        !           315:  * 
        !           316:  * Inputs : str - unused, ints - array of integer parameters with ints[0]
        !           317:  *     equal to the number of ints.
        !           318:  *
        !           319:  */
        !           320: 
        !           321: void pas16_setup(char *str, int *ints) {
        !           322:     static int commandline_current = 0;
        !           323:     int i;
        !           324:     if (ints[0] != 2) 
        !           325:        printk("pas16_setup : usage pas16=io_port,irq\n");
        !           326:     else 
        !           327:        if (commandline_current < NO_OVERRIDES) {
        !           328:            overrides[commandline_current].io_port = (unsigned short) ints[1];
        !           329:            overrides[commandline_current].irq = ints[2];
        !           330:            for (i = 0; i < NO_BASES; ++i)
        !           331:                if (bases[i].io_port == (unsigned short) ints[1]) {
        !           332:                    bases[i].noauto = 1;
        !           333:                    break;
        !           334:                }
        !           335:            ++commandline_current;
        !           336:        }
        !           337: }
        !           338: 
        !           339: /* 
        !           340:  * Function : int pas16_detect(Scsi_Host_Template * tpnt)
        !           341:  *
        !           342:  * Purpose : detects and initializes PAS16 controllers
        !           343:  *     that were autoprobed, overridden on the LILO command line, 
        !           344:  *     or specified at compile time.
        !           345:  *
        !           346:  * Inputs : tpnt - template for this SCSI adapter.
        !           347:  * 
        !           348:  * Returns : 1 if a host adapter was found, 0 if not.
        !           349:  *
        !           350:  */
        !           351: 
        !           352: int pas16_detect(Scsi_Host_Template * tpnt) {
        !           353:     static int current_override = 0;
        !           354:     static unsigned short current_base = 0;
        !           355:     struct Scsi_Host *instance;
        !           356:     unsigned short io_port;
        !           357:     int  count;
        !           358: 
        !           359:     tpnt->proc_dir = &proc_scsi_pas16;
        !           360: 
        !           361:     for (count = 0; current_override < NO_OVERRIDES; ++current_override) {
        !           362:        io_port = 0;
        !           363: 
        !           364:        if (overrides[current_override].io_port)
        !           365:        {
        !           366:            io_port = overrides[current_override].io_port;
        !           367:            enable_board( current_override, io_port );
        !           368:            init_board( io_port, overrides[current_override].irq, 1 );
        !           369:        }
        !           370:        else
        !           371:            for (; !io_port && (current_base < NO_BASES); ++current_base) {
        !           372: #if (PDEBUG & PDEBUG_INIT)
        !           373:     printk("scsi-pas16 : probing io_port %04x\n", (unsigned int) bases[current_base].io_port);
        !           374: #endif
        !           375:                if ( !bases[current_base].noauto &&
        !           376:                     pas16_hw_detect( current_base ) ){
        !           377:                        io_port = bases[current_base].io_port;
        !           378:                        init_board( io_port, default_irqs[ current_base ], 0 ); 
        !           379: #if (PDEBUG & PDEBUG_INIT)
        !           380:                        printk("scsi-pas16 : detected board.\n");
        !           381: #endif
        !           382:                }
        !           383:     }
        !           384: 
        !           385: 
        !           386: #if defined(PDEBUG) && (PDEBUG & PDEBUG_INIT)
        !           387:        printk("scsi-pas16 : io_port = %04x\n", (unsigned int) io_port);
        !           388: #endif
        !           389: 
        !           390:        if (!io_port)
        !           391:            break;
        !           392: 
        !           393:        instance = scsi_register (tpnt, sizeof(struct NCR5380_hostdata));
        !           394:        instance->io_port = io_port;
        !           395: 
        !           396:        NCR5380_init(instance, 0);
        !           397: 
        !           398:        if (overrides[current_override].irq != IRQ_AUTO)
        !           399:            instance->irq = overrides[current_override].irq;
        !           400:        else 
        !           401:            instance->irq = NCR5380_probe_irq(instance, PAS16_IRQS);
        !           402: 
        !           403:        if (instance->irq != IRQ_NONE) 
        !           404:            if (request_irq(instance->irq, pas16_intr, SA_INTERRUPT, "pas16")) {
        !           405:                printk("scsi%d : IRQ%d not free, interrupts disabled\n", 
        !           406:                    instance->host_no, instance->irq);
        !           407:                instance->irq = IRQ_NONE;
        !           408:            } 
        !           409: 
        !           410:        if (instance->irq == IRQ_NONE) {
        !           411:            printk("scsi%d : interrupts not enabled. for better interactive performance,\n", instance->host_no);
        !           412:            printk("scsi%d : please jumper the board for a free IRQ.\n", instance->host_no);
        !           413:            /* Disable 5380 interrupts, leave drive params the same */
        !           414:            outb( 0x4d, io_port + SYS_CONFIG_4 );
        !           415:            outb( (inb(io_port + IO_CONFIG_3) & 0x0f), io_port + IO_CONFIG_3 );
        !           416:        }
        !           417: 
        !           418: #if defined(PDEBUG) && (PDEBUG & PDEBUG_INIT)
        !           419:        printk("scsi%d : irq = %d\n", instance->host_no, instance->irq);
        !           420: #endif
        !           421: 
        !           422:        printk("scsi%d : at 0x%04x", instance->host_no, (int) 
        !           423:            instance->io_port);
        !           424:        if (instance->irq == IRQ_NONE)
        !           425:            printk (" interrupts disabled");
        !           426:        else 
        !           427:            printk (" irq %d", instance->irq);
        !           428:        printk(" options CAN_QUEUE=%d  CMD_PER_LUN=%d release=%d",
        !           429:            CAN_QUEUE, CMD_PER_LUN, PAS16_PUBLIC_RELEASE);
        !           430:        NCR5380_print_options(instance);
        !           431:        printk("\n");
        !           432: 
        !           433:        ++current_override;
        !           434:        ++count;
        !           435:     }
        !           436:     return count;
        !           437: }
        !           438: 
        !           439: /*
        !           440:  * Function : int pas16_biosparam(Disk *disk, kdev_t dev, int *ip)
        !           441:  *
        !           442:  * Purpose : Generates a BIOS / DOS compatible H-C-S mapping for 
        !           443:  *     the specified device / size.
        !           444:  * 
        !           445:  * Inputs : size = size of device in sectors (512 bytes), dev = block device
        !           446:  *     major / minor, ip[] = {heads, sectors, cylinders}  
        !           447:  *
        !           448:  * Returns : always 0 (success), initializes ip
        !           449:  *     
        !           450:  */
        !           451: 
        !           452: /* 
        !           453:  * XXX Most SCSI boards use this mapping, I could be incorrect.  Some one
        !           454:  * using hard disks on a trantor should verify that this mapping corresponds
        !           455:  * to that used by the BIOS / ASPI driver by running the linux fdisk program
        !           456:  * and matching the H_C_S coordinates to what DOS uses.
        !           457:  */
        !           458: 
        !           459: int pas16_biosparam(Disk * disk, kdev_t dev, int * ip)
        !           460: {
        !           461:   int size = disk->capacity;
        !           462:   ip[0] = 64;
        !           463:   ip[1] = 32;
        !           464:   ip[2] = size >> 11;          /* I think I have it as /(32*64) */
        !           465:   if( ip[2] > 1024 ) {         /* yes, >, not >= */
        !           466:        ip[0]=255;
        !           467:        ip[1]=63;
        !           468:        ip[2]=size/(63*255);
        !           469:        if( ip[2] > 1023 )      /* yes >1023... */
        !           470:                ip[2] = 1023;
        !           471:   }
        !           472: 
        !           473:   return 0;
        !           474: }
        !           475: 
        !           476: /*
        !           477:  * Function : int NCR5380_pread (struct Scsi_Host *instance, 
        !           478:  *     unsigned char *dst, int len)
        !           479:  *
        !           480:  * Purpose : Fast 5380 pseudo-dma read function, transfers len bytes to 
        !           481:  *     dst
        !           482:  * 
        !           483:  * Inputs : dst = destination, len = length in bytes
        !           484:  *
        !           485:  * Returns : 0 on success, non zero on a failure such as a watchdog 
        !           486:  *     timeout.
        !           487:  */
        !           488: 
        !           489: static inline int NCR5380_pread (struct Scsi_Host *instance, unsigned char *dst,
        !           490:     int len) {
        !           491:     register unsigned char  *d = dst;
        !           492:     register unsigned short reg = (unsigned short) (instance->io_port + 
        !           493:        P_DATA_REG_OFFSET);
        !           494:     register i = len;
        !           495: 
        !           496:     while ( !(inb(instance->io_port + P_STATUS_REG_OFFSET) & P_ST_RDY) );
        !           497: 
        !           498:     insb( reg, d, i );
        !           499: 
        !           500:     if ( inb(instance->io_port + P_TIMEOUT_STATUS_REG_OFFSET) & P_TS_TIM) {
        !           501:        outb( P_TS_CT, instance->io_port + P_TIMEOUT_STATUS_REG_OFFSET);
        !           502:        printk("scsi%d : watchdog timer fired in NCR5380_pread()\n",
        !           503:            instance->host_no);
        !           504:        return -1;
        !           505:     } else
        !           506:        return 0;
        !           507: }
        !           508: 
        !           509: /*
        !           510:  * Function : int NCR5380_pwrite (struct Scsi_Host *instance, 
        !           511:  *     unsigned char *src, int len)
        !           512:  *
        !           513:  * Purpose : Fast 5380 pseudo-dma write function, transfers len bytes from
        !           514:  *     src
        !           515:  * 
        !           516:  * Inputs : src = source, len = length in bytes
        !           517:  *
        !           518:  * Returns : 0 on success, non zero on a failure such as a watchdog 
        !           519:  *     timeout.
        !           520:  */
        !           521: 
        !           522: static inline int NCR5380_pwrite (struct Scsi_Host *instance, unsigned char *src,
        !           523:     int len) {
        !           524:     register unsigned char *s = src;
        !           525:     register unsigned short reg = (instance->io_port + P_DATA_REG_OFFSET);
        !           526:     register i = len;
        !           527: 
        !           528:     while ( !((inb(instance->io_port + P_STATUS_REG_OFFSET)) & P_ST_RDY) );
        !           529:  
        !           530:     outsb( reg, s, i );
        !           531: 
        !           532:     if (inb(instance->io_port + P_TIMEOUT_STATUS_REG_OFFSET) & P_TS_TIM) {
        !           533:        outb( P_TS_CT, instance->io_port + P_TIMEOUT_STATUS_REG_OFFSET);
        !           534:        printk("scsi%d : watchdog timer fired in NCR5380_pwrite()\n",
        !           535:            instance->host_no);
        !           536:        return -1;
        !           537:     } else 
        !           538:        return 0;
        !           539: }
        !           540: 
        !           541: #ifdef MACH
        !           542: #include "NCR5380.src"
        !           543: #else
        !           544: #include "NCR5380.c"
        !           545: #endif
        !           546: 
        !           547: #ifdef MODULE
        !           548: /* Eventually this will go into an include file, but this will be later */
        !           549: Scsi_Host_Template driver_template = MV_PAS16;
        !           550: 
        !           551: #include <linux/module.h>
        !           552: #include "scsi_module.c"
        !           553: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.