Return to sd.c CVS log

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

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

1.1     ! root        1: /*
        !             2:  *      sd.c Copyright (C) 1992 Drew Eckhardt 
        !             3:  *           Copyright (C) 1993, 1994, 1995 Eric Youngdale
        !             4:  *
        !             5:  *      Linux scsi disk driver
        !             6:  *              Initial versions: Drew Eckhardt 
        !             7:  *              Subsequent revisions: Eric Youngdale
        !             8:  *
        !             9:  *      <[email protected]>
        !            10:  *
        !            11:  *       Modified by Eric Youngdale [email protected] to
        !            12:  *       add scatter-gather, multiple outstanding request, and other
        !            13:  *       enhancements.
        !            14:  *
        !            15:  *       Modified by Eric Youngdale [email protected] to support loadable
        !            16:  *       low-level scsi drivers.
        !            17:  */
        !            18: 
        !            19: #include <linux/module.h>
        !            20: #ifdef MODULE
        !            21: /*
        !            22:  * This is a variable in scsi.c that is set when we are processing something
        !            23:  * after boot time.  By definition, this is true when we are a loadable module
        !            24:  * ourselves.
        !            25:  */
        !            26: #define MODULE_FLAG 1
        !            27: #else
        !            28: #define MODULE_FLAG scsi_loadable_module_flag
        !            29: #endif /* MODULE */
        !            30: 
        !            31: #include <linux/fs.h>
        !            32: #include <linux/kernel.h>
        !            33: #include <linux/sched.h>
        !            34: #include <linux/mm.h>
        !            35: #include <linux/string.h>
        !            36: #include <linux/errno.h>
        !            37: #include <asm/system.h>
        !            38: 
        !            39: #define MAJOR_NR SCSI_DISK_MAJOR
        !            40: #include <linux/blk.h>
        !            41: #include "scsi.h"
        !            42: #include "hosts.h"
        !            43: #include "sd.h"
        !            44: #include "scsi_ioctl.h"
        !            45: #include "constants.h"
        !            46: 
        !            47: #include <linux/genhd.h>
        !            48: 
        !            49: /*
        !            50:  *  static const char RCSid[] = "$Header:";
        !            51:  */
        !            52: 
        !            53: #define MAX_RETRIES 5
        !            54: 
        !            55: /*
        !            56:  *  Time out in seconds for disks and Magneto-opticals (which are slower).
        !            57:  */
        !            58: 
        !            59: #define SD_TIMEOUT (7 * HZ)
        !            60: #define SD_MOD_TIMEOUT (8 * HZ)
        !            61: 
        !            62: #define CLUSTERABLE_DEVICE(SC) (SC->host->use_clustering && \
        !            63:                                SC->device->type != TYPE_MOD)
        !            64: 
        !            65: struct hd_struct * sd;
        !            66: 
        !            67: Scsi_Disk * rscsi_disks = NULL;
        !            68: static int * sd_sizes;
        !            69: static int * sd_blocksizes;
        !            70: static int * sd_hardsizes;              /* Hardware sector size */
        !            71: 
        !            72: extern int sd_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
        !            73: 
        !            74: static int check_scsidisk_media_change(kdev_t);
        !            75: static int fop_revalidate_scsidisk(kdev_t);
        !            76: 
        !            77: static sd_init_onedisk(int);
        !            78: 
        !            79: static void requeue_sd_request (Scsi_Cmnd * SCpnt);
        !            80: 
        !            81: static int sd_init(void);
        !            82: static void sd_finish(void);
        !            83: static int sd_attach(Scsi_Device *);
        !            84: static int sd_detect(Scsi_Device *);
        !            85: static void sd_detach(Scsi_Device *);
        !            86: 
        !            87: struct Scsi_Device_Template sd_template = 
        !            88: { NULL, "disk", "sd", NULL, TYPE_DISK, 
        !            89:       SCSI_DISK_MAJOR, 0, 0, 0, 1,
        !            90:       sd_detect, sd_init,
        !            91:       sd_finish, sd_attach, sd_detach
        !            92: };
        !            93: 
        !            94: static int sd_open(struct inode * inode, struct file * filp)
        !            95: {
        !            96:     int target;
        !            97:     target =  DEVICE_NR(inode->i_rdev);
        !            98:     
        !            99:     if(target >= sd_template.dev_max || !rscsi_disks[target].device)
        !           100:        return -ENXIO;   /* No such device */
        !           101:     
        !           102:     /* 
        !           103:      * Make sure that only one process can do a check_change_disk at one time.
        !           104:      * This is also used to lock out further access when the partition table 
        !           105:      * is being re-read. 
        !           106:      */
        !           107:     
        !           108:     while (rscsi_disks[target].device->busy)
        !           109:     barrier();   
        !           110:     if(rscsi_disks[target].device->removable) {
        !           111:        check_disk_change(inode->i_rdev);
        !           112:        
        !           113:        /*
        !           114:         * If the drive is empty, just let the open fail.
        !           115:         */
        !           116:        if ( !rscsi_disks[target].ready ) {
        !           117:            return -ENXIO;
        !           118:        }
        !           119: 
        !           120:        /*
        !           121:         * Similarily, if the device has the write protect tab set,
        !           122:         * have the open fail if the user expects to be able to write
        !           123:         * to the thing.
        !           124:         */
        !           125:        if ( (rscsi_disks[target].write_prot) && (filp->f_mode & 2) ) { 
        !           126:            return -EROFS;
        !           127:        }
        !           128: 
        !           129:        if(!rscsi_disks[target].device->access_count)
        !           130:            sd_ioctl(inode, NULL, SCSI_IOCTL_DOORLOCK, 0);
        !           131:     };
        !           132: 
        !           133:     /*
        !           134:      * See if we are requesting a non-existent partition.  Do this
        !           135:      * after checking for disk change.
        !           136:      */
        !           137:     if(sd_sizes[MINOR(inode->i_rdev)] == 0)
        !           138:        return -ENXIO;
        !           139:     
        !           140:     rscsi_disks[target].device->access_count++;
        !           141:     if (rscsi_disks[target].device->host->hostt->usage_count)
        !           142:        (*rscsi_disks[target].device->host->hostt->usage_count)++;
        !           143:     if(sd_template.usage_count) (*sd_template.usage_count)++;
        !           144:     return 0;
        !           145: }
        !           146: 
        !           147: static void sd_release(struct inode * inode, struct file * file)
        !           148: {
        !           149:     int target;
        !           150:     sync_dev(inode->i_rdev);
        !           151:     
        !           152:     target =  DEVICE_NR(inode->i_rdev);
        !           153:     
        !           154:     rscsi_disks[target].device->access_count--;
        !           155:     if (rscsi_disks[target].device->host->hostt->usage_count)
        !           156:        (*rscsi_disks[target].device->host->hostt->usage_count)--;
        !           157:     if(sd_template.usage_count) (*sd_template.usage_count)--;
        !           158:     
        !           159:     if(rscsi_disks[target].device->removable) {
        !           160:        if(!rscsi_disks[target].device->access_count)
        !           161:            sd_ioctl(inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0);
        !           162:     }
        !           163: }
        !           164: 
        !           165: static void sd_geninit(struct gendisk *);
        !           166: 
        !           167: static struct file_operations sd_fops = {
        !           168:     NULL,                        /* lseek - default */
        !           169:     block_read,                  /* read - general block-dev read */
        !           170:     block_write,                 /* write - general block-dev write */
        !           171:     NULL,                        /* readdir - bad */
        !           172:     NULL,                        /* select */
        !           173:     sd_ioctl,                    /* ioctl */
        !           174:     NULL,                        /* mmap */
        !           175:     sd_open,                     /* open code */
        !           176:     sd_release,                  /* release */
        !           177:     block_fsync,                 /* fsync */
        !           178:     NULL,                        /* fasync */
        !           179:     check_scsidisk_media_change, /* Disk change */
        !           180:     fop_revalidate_scsidisk      /* revalidate */
        !           181: };
        !           182: 
        !           183: static struct gendisk sd_gendisk = {
        !           184:     MAJOR_NR,                    /* Major number */
        !           185:     "sd",                        /* Major name */
        !           186:     4,                           /* Bits to shift to get real from partition */
        !           187:     1 << 4,                      /* Number of partitions per real */
        !           188:     0,                           /* maximum number of real */
        !           189:     sd_geninit,                  /* init function */
        !           190:     NULL,                        /* hd struct */
        !           191:     NULL,                        /* block sizes */
        !           192:     0,                           /* number */
        !           193:     NULL,                        /* internal */
        !           194:     NULL                         /* next */
        !           195: };
        !           196: 
        !           197: static void sd_geninit (struct gendisk *ignored)
        !           198: {
        !           199:     int i;
        !           200:     
        !           201:     for (i = 0; i < sd_template.dev_max; ++i)
        !           202:        if(rscsi_disks[i].device) 
        !           203:            sd[i << 4].nr_sects = rscsi_disks[i].capacity;
        !           204: #if 0
        !           205:     /* No longer needed - we keep track of this as we attach/detach */
        !           206:     sd_gendisk.nr_real = sd_template.dev_max;
        !           207: #endif
        !           208: }
        !           209: 
        !           210: /*
        !           211:  * rw_intr is the interrupt routine for the device driver.  It will
        !           212:  * be notified on the end of a SCSI read / write, and
        !           213:  * will take on of several actions based on success or failure.
        !           214:  */
        !           215: 
        !           216: static void rw_intr (Scsi_Cmnd *SCpnt)
        !           217: {
        !           218:     int result = SCpnt->result;
        !           219:     int this_count = SCpnt->bufflen >> 9;
        !           220:     
        !           221: #ifdef DEBUG
        !           222:     printk("sd%c : rw_intr(%d, %d)\n", 'a' + MINOR(SCpnt->request.rq_dev), 
        !           223:           SCpnt->host->host_no, result);
        !           224: #endif
        !           225:     
        !           226:     /*
        !           227:      * First case : we assume that the command succeeded.  One of two things 
        !           228:      * will happen here.  Either we will be finished, or there will be more
        !           229:      * sectors that we were unable to read last time.
        !           230:      */
        !           231: 
        !           232:     if (!result) {
        !           233:        
        !           234: #ifdef DEBUG
        !           235:        printk("sd%c : %d sectors remain.\n", 'a' + MINOR(SCpnt->request.rq_dev),
        !           236:               SCpnt->request.nr_sectors);
        !           237:        printk("use_sg is %d\n ",SCpnt->use_sg);
        !           238: #endif
        !           239:        if (SCpnt->use_sg) {
        !           240:            struct scatterlist * sgpnt;
        !           241:            int i;
        !           242:            sgpnt = (struct scatterlist *) SCpnt->buffer;
        !           243:            for(i=0; i<SCpnt->use_sg; i++) {
        !           244: #ifdef DEBUG
        !           245:                printk(":%x %x %d\n",sgpnt[i].alt_address, sgpnt[i].address, 
        !           246:                       sgpnt[i].length);
        !           247: #endif
        !           248:                if (sgpnt[i].alt_address) {
        !           249:                    if (SCpnt->request.cmd == READ)
        !           250:                        memcpy(sgpnt[i].alt_address, sgpnt[i].address, 
        !           251:                               sgpnt[i].length);
        !           252:                    scsi_free(sgpnt[i].address, sgpnt[i].length);
        !           253:                };
        !           254:            };
        !           255: 
        !           256:            /* Free list of scatter-gather pointers */
        !           257:            scsi_free(SCpnt->buffer, SCpnt->sglist_len);  
        !           258:        } else {
        !           259:            if (SCpnt->buffer != SCpnt->request.buffer) {
        !           260: #ifdef DEBUG
        !           261:                printk("nosg: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
        !           262:                       SCpnt->bufflen);
        !           263: #endif  
        !           264:                if (SCpnt->request.cmd == READ)
        !           265:                    memcpy(SCpnt->request.buffer, SCpnt->buffer,
        !           266:                           SCpnt->bufflen);
        !           267:                scsi_free(SCpnt->buffer, SCpnt->bufflen);
        !           268:            };
        !           269:        };
        !           270:        /*
        !           271:         * If multiple sectors are requested in one buffer, then
        !           272:         * they will have been finished off by the first command.
        !           273:         * If not, then we have a multi-buffer command.
        !           274:         */
        !           275:        if (SCpnt->request.nr_sectors > this_count)
        !           276:        {
        !           277:            SCpnt->request.errors = 0;
        !           278:            
        !           279:            if (!SCpnt->request.bh)
        !           280:            {
        !           281: #ifdef DEBUG
        !           282:                printk("sd%c : handling page request, no buffer\n",
        !           283:                       'a' + MINOR(SCpnt->request.rq_dev));
        !           284: #endif
        !           285:                /*
        !           286:                 * The SCpnt->request.nr_sectors field is always done in 
        !           287:                 * 512 byte sectors, even if this really isn't the case.
        !           288:                 */
        !           289:                panic("sd.c: linked page request (%lx %x)",
        !           290:                      SCpnt->request.sector, this_count);
        !           291:            }
        !           292:        }
        !           293:        SCpnt = end_scsi_request(SCpnt, 1, this_count);
        !           294:        requeue_sd_request(SCpnt);
        !           295:        return;
        !           296:     }
        !           297:     
        !           298:     /* Free up any indirection buffers we allocated for DMA purposes. */
        !           299:     if (SCpnt->use_sg) {
        !           300:        struct scatterlist * sgpnt;
        !           301:        int i;
        !           302:        sgpnt = (struct scatterlist *) SCpnt->buffer;
        !           303:        for(i=0; i<SCpnt->use_sg; i++) {
        !           304: #ifdef DEBUG
        !           305:            printk("err: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
        !           306:                   SCpnt->bufflen);
        !           307: #endif
        !           308:            if (sgpnt[i].alt_address) {
        !           309:                scsi_free(sgpnt[i].address, sgpnt[i].length);
        !           310:            };
        !           311:        };
        !           312:        scsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
        !           313:     } else {
        !           314: #ifdef DEBUG
        !           315:        printk("nosgerr: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
        !           316:               SCpnt->bufflen);
        !           317: #endif
        !           318:        if (SCpnt->buffer != SCpnt->request.buffer)
        !           319:            scsi_free(SCpnt->buffer, SCpnt->bufflen);
        !           320:     };
        !           321:     
        !           322:     /*
        !           323:      * Now, if we were good little boys and girls, Santa left us a request
        !           324:      * sense buffer.  We can extract information from this, so we
        !           325:      * can choose a block to remap, etc.
        !           326:      */
        !           327: 
        !           328:     if (driver_byte(result) != 0) {
        !           329:        if (suggestion(result) == SUGGEST_REMAP) {
        !           330: #ifdef REMAP
        !           331:            /*
        !           332:             * Not yet implemented.  A read will fail after being remapped,
        !           333:             * a write will call the strategy routine again.
        !           334:             */
        !           335:            if rscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].remap
        !           336:            {
        !           337:                result = 0;
        !           338:            }
        !           339:            else
        !           340: #endif
        !           341:        }
        !           342:        
        !           343:        if ((SCpnt->sense_buffer[0] & 0x7f) == 0x70) {
        !           344:            if ((SCpnt->sense_buffer[2] & 0xf) == UNIT_ATTENTION) {
        !           345:                if(rscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->removable) {
        !           346:                    /* detected disc change.  set a bit and quietly refuse
        !           347:                     * further access.
        !           348:                     */  
        !           349:                    rscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->changed = 1;
        !           350:                    SCpnt = end_scsi_request(SCpnt, 0, this_count);
        !           351:                    requeue_sd_request(SCpnt);
        !           352:                    return;
        !           353:                }
        !           354:                 else
        !           355:                 {
        !           356:                     /*
        !           357:                      * Must have been a power glitch, or a bus reset.
        !           358:                      * Could not have been a media change, so we just retry
        !           359:                      * the request and see what happens.
        !           360:                      */
        !           361:                     requeue_sd_request(SCpnt);
        !           362:                     return;
        !           363:                 }
        !           364:            }
        !           365:        }
        !           366:        
        !           367:        
        !           368:        /* If we had an ILLEGAL REQUEST returned, then we may have
        !           369:         * performed an unsupported command.  The only thing this should be 
        !           370:         * would be a ten byte read where only a six byte read was supported.
        !           371:         * Also, on a system where READ CAPACITY failed, we have have read 
        !           372:         * past the end of the disk. 
        !           373:         */
        !           374: 
        !           375:        if (SCpnt->sense_buffer[2] == ILLEGAL_REQUEST) {
        !           376:            if (rscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].ten) {
        !           377:                rscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].ten = 0;
        !           378:                requeue_sd_request(SCpnt);
        !           379:                result = 0;
        !           380:            } else {
        !           381:                /* ???? */
        !           382:            }
        !           383:        }
        !           384:     }  /* driver byte != 0 */
        !           385:     if (result) {
        !           386:        printk("SCSI disk error : host %d channel %d id %d lun %d return code = %x\n",
        !           387:               rscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->host->host_no,
        !           388:               rscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->channel,
        !           389:           rscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->id,
        !           390:             rscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->lun, result);
        !           391:        
        !           392:        if (driver_byte(result) & DRIVER_SENSE)
        !           393:            print_sense("sd", SCpnt);
        !           394:        SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.current_nr_sectors);
        !           395:        requeue_sd_request(SCpnt);
        !           396:        return;
        !           397:     }
        !           398: }
        !           399: 
        !           400: /*
        !           401:  * requeue_sd_request() is the request handler function for the sd driver.
        !           402:  * Its function in life is to take block device requests, and translate
        !           403:  * them to SCSI commands.
        !           404:  */
        !           405: 
        !           406: static void do_sd_request (void)
        !           407: {
        !           408:     Scsi_Cmnd * SCpnt = NULL;
        !           409:     Scsi_Device * SDev;
        !           410:     struct request * req = NULL;
        !           411:     unsigned long flags;
        !           412:     int flag = 0;
        !           413:     
        !           414:     save_flags(flags);
        !           415:     while (1==1){
        !           416:        cli();
        !           417:        if (CURRENT != NULL && CURRENT->rq_status == RQ_INACTIVE) {
        !           418:            restore_flags(flags);
        !           419:            return;
        !           420:        };
        !           421:        
        !           422:        INIT_SCSI_REQUEST;
        !           423:         SDev = rscsi_disks[DEVICE_NR(CURRENT->rq_dev)].device;
        !           424:         
        !           425:         /*
        !           426:          * I am not sure where the best place to do this is.  We need
        !           427:          * to hook in a place where we are likely to come if in user
        !           428:          * space.
        !           429:          */
        !           430:         if( SDev->was_reset )
        !           431:         {
        !           432:            /*
        !           433:             * We need to relock the door, but we might
        !           434:             * be in an interrupt handler.  Only do this
        !           435:             * from user space, since we do not want to
        !           436:             * sleep from an interrupt.
        !           437:             */
        !           438:            if( SDev->removable && !intr_count )
        !           439:            {
        !           440:                 scsi_ioctl(SDev, SCSI_IOCTL_DOORLOCK, 0);
        !           441:            }
        !           442:            SDev->was_reset = 0;
        !           443:         }
        !           444:                
        !           445:        /* We have to be careful here. allocate_device will get a free pointer,
        !           446:         * but there is no guarantee that it is queueable.  In normal usage, 
        !           447:         * we want to call this, because other types of devices may have the 
        !           448:         * host all tied up, and we want to make sure that we have at least 
        !           449:         * one request pending for this type of device. We can also come 
        !           450:         * through here while servicing an interrupt, because of the need to 
        !           451:         * start another command. If we call allocate_device more than once, 
        !           452:         * then the system can wedge if the command is not queueable. The 
        !           453:         * request_queueable function is safe because it checks to make sure 
        !           454:         * that the host is able to take another command before it returns
        !           455:         * a pointer.  
        !           456:         */
        !           457: 
        !           458:        if (flag++ == 0)
        !           459:            SCpnt = allocate_device(&CURRENT,
        !           460:                                    rscsi_disks[DEVICE_NR(CURRENT->rq_dev)].device, 0); 
        !           461:        else SCpnt = NULL;
        !           462:        
        !           463:        /*
        !           464:         * The following restore_flags leads to latency problems.  FIXME.
        !           465:         * Using a "sti()" gets rid of the latency problems but causes
        !           466:         * race conditions and crashes.
        !           467:         */
        !           468:        restore_flags(flags);
        !           469: 
        !           470:        /* This is a performance enhancement. We dig down into the request 
        !           471:         * list and try and find a queueable request (i.e. device not busy, 
        !           472:         * and host able to accept another command. If we find one, then we 
        !           473:         * queue it. This can make a big difference on systems with more than 
        !           474:         * one disk drive.  We want to have the interrupts off when monkeying 
        !           475:         * with the request list, because otherwise the kernel might try and 
        !           476:         * slip in a request in between somewhere. 
        !           477:         */
        !           478: 
        !           479:        if (!SCpnt && sd_template.nr_dev > 1){
        !           480:            struct request *req1;
        !           481:            req1 = NULL;
        !           482:            cli();
        !           483:            req = CURRENT;
        !           484:            while(req){
        !           485:                SCpnt = request_queueable(req, rscsi_disks[DEVICE_NR(req->rq_dev)].device);
        !           486:                if(SCpnt) break;
        !           487:                req1 = req;
        !           488:                req = req->next;
        !           489:            };
        !           490:            if (SCpnt && req->rq_status == RQ_INACTIVE) {
        !           491:                if (req == CURRENT) 
        !           492:                    CURRENT = CURRENT->next;
        !           493:                else
        !           494:                    req1->next = req->next;
        !           495:            };
        !           496:            restore_flags(flags);
        !           497:        };
        !           498:        
        !           499:        if (!SCpnt) return; /* Could not find anything to do */
        !           500:        
        !           501:        /* Queue command */
        !           502:        requeue_sd_request(SCpnt);
        !           503:     };  /* While */
        !           504: }    
        !           505: 
        !           506: static void requeue_sd_request (Scsi_Cmnd * SCpnt)
        !           507: {
        !           508:     int dev, devm, block, this_count;
        !           509:     unsigned char cmd[10];
        !           510:     int bounce_size, contiguous;
        !           511:     int max_sg;
        !           512:     struct buffer_head * bh, *bhp;
        !           513:     char * buff, *bounce_buffer;
        !           514:     
        !           515:  repeat:
        !           516:     
        !           517:     if(!SCpnt || SCpnt->request.rq_status == RQ_INACTIVE) {
        !           518:        do_sd_request();
        !           519:        return;
        !           520:     }
        !           521:     
        !           522:     devm =  MINOR(SCpnt->request.rq_dev);
        !           523:     dev = DEVICE_NR(SCpnt->request.rq_dev);
        !           524: 
        !           525:     block = SCpnt->request.sector;
        !           526:     this_count = 0;
        !           527: 
        !           528: #ifdef DEBUG
        !           529:     printk("Doing sd request, dev = %d, block = %d\n", devm, block);
        !           530: #endif
        !           531:     
        !           532:     if (devm >= (sd_template.dev_max << 4) || 
        !           533:        !rscsi_disks[dev].device ||
        !           534:        block + SCpnt->request.nr_sectors > sd[devm].nr_sects)
        !           535:     {
        !           536:        SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
        !           537:        goto repeat;
        !           538:     }
        !           539:     
        !           540:     block += sd[devm].start_sect;
        !           541:     
        !           542:     if (rscsi_disks[dev].device->changed)
        !           543:     {
        !           544:        /*
        !           545:         * quietly refuse to do anything to a changed disc until the changed 
        !           546:         * bit has been reset
        !           547:         */
        !           548:        /* printk("SCSI disk has been changed. Prohibiting further I/O.\n"); */
        !           549:        SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
        !           550:        goto repeat;
        !           551:     }
        !           552:     
        !           553: #ifdef DEBUG
        !           554:     printk("sd%c : real dev = /dev/sd%c, block = %d\n", 
        !           555:           'a' + devm, dev, block);
        !           556: #endif
        !           557:     
        !           558:     /*
        !           559:      * If we have a 1K hardware sectorsize, prevent access to single
        !           560:      * 512 byte sectors.  In theory we could handle this - in fact
        !           561:      * the scsi cdrom driver must be able to handle this because
        !           562:      * we typically use 1K blocksizes, and cdroms typically have
        !           563:      * 2K hardware sectorsizes.  Of course, things are simpler
        !           564:      * with the cdrom, since it is read-only.  For performance
        !           565:      * reasons, the filesystems should be able to handle this
        !           566:      * and not force the scsi disk driver to use bounce buffers
        !           567:      * for this.
        !           568:      */
        !           569:     if (rscsi_disks[dev].sector_size == 1024)
        !           570:        if((block & 1) || (SCpnt->request.nr_sectors & 1)) {
        !           571:            printk("sd.c:Bad block number requested");
        !           572:            SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
        !           573:            goto repeat;
        !           574:        }
        !           575:     
        !           576:     switch (SCpnt->request.cmd)
        !           577:     {
        !           578:     case WRITE :
        !           579:        if (!rscsi_disks[dev].device->writeable)
        !           580:        {
        !           581:            SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
        !           582:            goto repeat;
        !           583:        }
        !           584:        cmd[0] = WRITE_6;
        !           585:        break;
        !           586:     case READ :
        !           587:        cmd[0] = READ_6;
        !           588:        break;
        !           589:     default :
        !           590:        panic ("Unknown sd command %d\n", SCpnt->request.cmd);
        !           591:     }
        !           592:     
        !           593:     SCpnt->this_count = 0;
        !           594:     
        !           595:     /* If the host adapter can deal with very large scatter-gather
        !           596:      * requests, it is a waste of time to cluster 
        !           597:      */
        !           598:     contiguous = (!CLUSTERABLE_DEVICE(SCpnt) ? 0 :1);
        !           599:     bounce_buffer = NULL;
        !           600:     bounce_size = (SCpnt->request.nr_sectors << 9);
        !           601:     
        !           602:     /* First see if we need a bounce buffer for this request. If we do, make 
        !           603:      * sure that we can allocate a buffer. Do not waste space by allocating 
        !           604:      * a bounce buffer if we are straddling the 16Mb line 
        !           605:      */ 
        !           606:     if (contiguous && SCpnt->request.bh &&
        !           607:        ((long) SCpnt->request.bh->b_data) 
        !           608:        + (SCpnt->request.nr_sectors << 9) - 1 > ISA_DMA_THRESHOLD 
        !           609:        && SCpnt->host->unchecked_isa_dma) {
        !           610:        if(((long) SCpnt->request.bh->b_data) > ISA_DMA_THRESHOLD)
        !           611:            bounce_buffer = (char *) scsi_malloc(bounce_size);
        !           612:        if(!bounce_buffer) contiguous = 0;
        !           613:     };
        !           614:     
        !           615:     if(contiguous && SCpnt->request.bh && SCpnt->request.bh->b_reqnext)
        !           616:        for(bh = SCpnt->request.bh, bhp = bh->b_reqnext; bhp; bh = bhp, 
        !           617:            bhp = bhp->b_reqnext) {
        !           618:            if(!CONTIGUOUS_BUFFERS(bh,bhp)) { 
        !           619:                if(bounce_buffer) scsi_free(bounce_buffer, bounce_size);
        !           620:                contiguous = 0;
        !           621:                break;
        !           622:            } 
        !           623:        };
        !           624:     if (!SCpnt->request.bh || contiguous) {
        !           625:        
        !           626:        /* case of page request (i.e. raw device), or unlinked buffer */
        !           627:        this_count = SCpnt->request.nr_sectors;
        !           628:        buff = SCpnt->request.buffer;
        !           629:        SCpnt->use_sg = 0;
        !           630:        
        !           631:     } else if (SCpnt->host->sg_tablesize == 0 ||
        !           632:               (need_isa_buffer && dma_free_sectors <= 10)) {
        !           633:        
        !           634:        /* Case of host adapter that cannot scatter-gather.  We also
        !           635:         * come here if we are running low on DMA buffer memory.  We set
        !           636:         * a threshold higher than that we would need for this request so
        !           637:         * we leave room for other requests.  Even though we would not need
        !           638:         * it all, we need to be conservative, because if we run low enough
        !           639:         * we have no choice but to panic. 
        !           640:         */
        !           641:        if (SCpnt->host->sg_tablesize != 0 &&
        !           642:            need_isa_buffer && 
        !           643:            dma_free_sectors <= 10)
        !           644:            printk("Warning: SCSI DMA buffer space running low.  Using non scatter-gather I/O.\n");
        !           645:        
        !           646:        this_count = SCpnt->request.current_nr_sectors;
        !           647:        buff = SCpnt->request.buffer;
        !           648:        SCpnt->use_sg = 0;
        !           649:        
        !           650:     } else {
        !           651:        
        !           652:        /* Scatter-gather capable host adapter */
        !           653:        struct scatterlist * sgpnt;
        !           654:        int count, this_count_max;
        !           655:        int counted;
        !           656:        
        !           657:        bh = SCpnt->request.bh;
        !           658:        this_count = 0;
        !           659:        this_count_max = (rscsi_disks[dev].ten ? 0xffff : 0xff);
        !           660:        count = 0;
        !           661:        bhp = NULL;
        !           662:        while(bh) {
        !           663:            if ((this_count + (bh->b_size >> 9)) > this_count_max) break;
        !           664:            if(!bhp || !CONTIGUOUS_BUFFERS(bhp,bh) ||
        !           665:               !CLUSTERABLE_DEVICE(SCpnt) ||
        !           666:               (SCpnt->host->unchecked_isa_dma &&
        !           667:                ((unsigned long) bh->b_data-1) == ISA_DMA_THRESHOLD)) {
        !           668:                if (count < SCpnt->host->sg_tablesize) count++;
        !           669:                else break;
        !           670:            };
        !           671:            this_count += (bh->b_size >> 9);
        !           672:            bhp = bh;
        !           673:            bh = bh->b_reqnext;
        !           674:        };
        !           675: #if 0
        !           676:        if(SCpnt->host->unchecked_isa_dma &&
        !           677:           ((unsigned int) SCpnt->request.bh->b_data-1) == ISA_DMA_THRESHOLD) count--;
        !           678: #endif
        !           679:        SCpnt->use_sg = count;  /* Number of chains */
        !           680:        count = 512;/* scsi_malloc can only allocate in chunks of 512 bytes */
        !           681:        while( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
        !           682:            count = count << 1;
        !           683:        SCpnt->sglist_len = count;
        !           684:        max_sg = count / sizeof(struct scatterlist);
        !           685:        if(SCpnt->host->sg_tablesize < max_sg) 
        !           686:            max_sg = SCpnt->host->sg_tablesize;
        !           687:        sgpnt = (struct scatterlist * ) scsi_malloc(count);
        !           688:        if (!sgpnt) {
        !           689:            printk("Warning - running *really* short on DMA buffers\n");
        !           690:            SCpnt->use_sg = 0;    /* No memory left - bail out */
        !           691:            this_count = SCpnt->request.current_nr_sectors;
        !           692:            buff = SCpnt->request.buffer;
        !           693:        } else {
        !           694:            memset(sgpnt, 0, count);  /* Zero so it is easy to fill, but only
        !           695:                                       * if memory is available 
        !           696:                                       */
        !           697:            buff = (char *) sgpnt;
        !           698:            counted = 0;
        !           699:            for(count = 0, bh = SCpnt->request.bh, bhp = bh->b_reqnext;
        !           700:                count < SCpnt->use_sg && bh; 
        !           701:                count++, bh = bhp) {
        !           702:                
        !           703:                bhp = bh->b_reqnext;
        !           704:                
        !           705:                if(!sgpnt[count].address) sgpnt[count].address = bh->b_data;
        !           706:                sgpnt[count].length += bh->b_size;
        !           707:                counted += bh->b_size >> 9;
        !           708:                
        !           709:                if (((long) sgpnt[count].address) + sgpnt[count].length - 1 > 
        !           710:                    ISA_DMA_THRESHOLD && (SCpnt->host->unchecked_isa_dma) &&
        !           711:                    !sgpnt[count].alt_address) {
        !           712:                    sgpnt[count].alt_address = sgpnt[count].address;
        !           713:                    /* We try and avoid exhausting the DMA pool, since it is 
        !           714:                     * easier to control usage here. In other places we might 
        !           715:                     * have a more pressing need, and we would be screwed if 
        !           716:                     * we ran out */
        !           717:                    if(dma_free_sectors < (sgpnt[count].length >> 9) + 10) {
        !           718:                        sgpnt[count].address = NULL;
        !           719:                    } else {
        !           720:                        sgpnt[count].address = 
        !           721:                            (char *) scsi_malloc(sgpnt[count].length);
        !           722:                    };
        !           723:                    /* If we start running low on DMA buffers, we abort the 
        !           724:                     * scatter-gather operation, and free all of the memory 
        !           725:                     * we have allocated.  We want to ensure that all scsi 
        !           726:                     * operations are able to do at least a non-scatter/gather
        !           727:                     * operation */
        !           728:                    if(sgpnt[count].address == NULL){ /* Out of dma memory */
        !           729: #if 0
        !           730:                        printk("Warning: Running low on SCSI DMA buffers");
        !           731:                        /* Try switching back to a non s-g operation. */
        !           732:                        while(--count >= 0){
        !           733:                            if(sgpnt[count].alt_address) 
        !           734:                                scsi_free(sgpnt[count].address, 
        !           735:                                          sgpnt[count].length);
        !           736:                        };
        !           737:                        this_count = SCpnt->request.current_nr_sectors;
        !           738:                        buff = SCpnt->request.buffer;
        !           739:                        SCpnt->use_sg = 0;
        !           740:                        scsi_free(sgpnt, SCpnt->sglist_len);
        !           741: #endif
        !           742:                        SCpnt->use_sg = count;
        !           743:                        this_count = counted -= bh->b_size >> 9;
        !           744:                        break;
        !           745:                    };
        !           746:                    
        !           747:                };
        !           748:                
        !           749:                /* Only cluster buffers if we know that we can supply DMA 
        !           750:                 * buffers large enough to satisfy the request. Do not cluster
        !           751:                 * a new request if this would mean that we suddenly need to 
        !           752:                 * start using DMA bounce buffers */
        !           753:                if(bhp && CONTIGUOUS_BUFFERS(bh,bhp) 
        !           754:                   && CLUSTERABLE_DEVICE(SCpnt)) {
        !           755:                    char * tmp;
        !           756:                    
        !           757:                    if (((long) sgpnt[count].address) + sgpnt[count].length +
        !           758:                        bhp->b_size - 1 > ISA_DMA_THRESHOLD && 
        !           759:                        (SCpnt->host->unchecked_isa_dma) &&
        !           760:                        !sgpnt[count].alt_address) continue;
        !           761:                    
        !           762:                    if(!sgpnt[count].alt_address) {count--; continue; }
        !           763:                    if(dma_free_sectors > 10)
        !           764:                        tmp = (char *) scsi_malloc(sgpnt[count].length 
        !           765:                                                   + bhp->b_size);
        !           766:                    else {
        !           767:                        tmp = NULL;
        !           768:                        max_sg = SCpnt->use_sg;
        !           769:                    };
        !           770:                    if(tmp){
        !           771:                        scsi_free(sgpnt[count].address, sgpnt[count].length);
        !           772:                        sgpnt[count].address = tmp;
        !           773:                        count--;
        !           774:                        continue;
        !           775:                    };
        !           776:                    
        !           777:                    /* If we are allowed another sg chain, then increment 
        !           778:                     * counter so we can insert it.  Otherwise we will end 
        !           779:                     up truncating */
        !           780:                    
        !           781:                    if (SCpnt->use_sg < max_sg) SCpnt->use_sg++;
        !           782:                };  /* contiguous buffers */
        !           783:            }; /* for loop */
        !           784:            
        !           785:            /* This is actually how many we are going to transfer */
        !           786:            this_count = counted; 
        !           787:            
        !           788:            if(count < SCpnt->use_sg || SCpnt->use_sg 
        !           789:               > SCpnt->host->sg_tablesize){
        !           790:                bh = SCpnt->request.bh;
        !           791:                printk("Use sg, count %d %x %d\n", 
        !           792:                       SCpnt->use_sg, count, dma_free_sectors);
        !           793:                printk("maxsg = %x, counted = %d this_count = %d\n", 
        !           794:                       max_sg, counted, this_count);
        !           795:                while(bh){
        !           796:                    printk("[%p %lx] ", bh->b_data, bh->b_size);
        !           797:                    bh = bh->b_reqnext;
        !           798:                };
        !           799:                if(SCpnt->use_sg < 16)
        !           800:                    for(count=0; count<SCpnt->use_sg; count++)
        !           801:                        printk("{%d:%p %p %d}  ", count,
        !           802:                               sgpnt[count].address,
        !           803:                               sgpnt[count].alt_address,
        !           804:                               sgpnt[count].length);
        !           805:                panic("Ooops");
        !           806:            };
        !           807:            
        !           808:            if (SCpnt->request.cmd == WRITE)
        !           809:                for(count=0; count<SCpnt->use_sg; count++)
        !           810:                    if(sgpnt[count].alt_address)
        !           811:                        memcpy(sgpnt[count].address, sgpnt[count].alt_address, 
        !           812:                               sgpnt[count].length);
        !           813:        };  /* Able to malloc sgpnt */
        !           814:     };  /* Host adapter capable of scatter-gather */
        !           815:     
        !           816:     /* Now handle the possibility of DMA to addresses > 16Mb */
        !           817:     
        !           818:     if(SCpnt->use_sg == 0){
        !           819:        if (((long) buff) + (this_count << 9) - 1 > ISA_DMA_THRESHOLD && 
        !           820:            (SCpnt->host->unchecked_isa_dma)) {
        !           821:            if(bounce_buffer)
        !           822:                buff = bounce_buffer;
        !           823:            else
        !           824:                buff = (char *) scsi_malloc(this_count << 9);
        !           825:            if(buff == NULL) {  /* Try backing off a bit if we are low on mem*/
        !           826:                this_count = SCpnt->request.current_nr_sectors;
        !           827:                buff = (char *) scsi_malloc(this_count << 9);
        !           828:                if(!buff) panic("Ran out of DMA buffers.");
        !           829:            };
        !           830:            if (SCpnt->request.cmd == WRITE)
        !           831:                memcpy(buff, (char *)SCpnt->request.buffer, this_count << 9);
        !           832:        };
        !           833:     };
        !           834: #ifdef DEBUG
        !           835:     printk("sd%c : %s %d/%d 512 byte blocks.\n", 
        !           836:           'a' + devm,
        !           837:           (SCpnt->request.cmd == WRITE) ? "writing" : "reading",
        !           838:           this_count, SCpnt->request.nr_sectors);
        !           839: #endif
        !           840:     
        !           841:     cmd[1] = (SCpnt->lun << 5) & 0xe0;
        !           842:     
        !           843:     if (rscsi_disks[dev].sector_size == 1024){
        !           844:        if(block & 1) panic("sd.c:Bad block number requested");
        !           845:        if(this_count & 1) panic("sd.c:Bad block number requested");
        !           846:        block = block >> 1;
        !           847:        this_count = this_count >> 1;
        !           848:     };
        !           849:     
        !           850:     if (rscsi_disks[dev].sector_size == 256){
        !           851:        block = block << 1;
        !           852:        this_count = this_count << 1;
        !           853:     };
        !           854:     
        !           855:     if (((this_count > 0xff) ||  (block > 0x1fffff)) && rscsi_disks[dev].ten)
        !           856:     {
        !           857:        if (this_count > 0xffff)
        !           858:            this_count = 0xffff;
        !           859:        
        !           860:        cmd[0] += READ_10 - READ_6 ;
        !           861:        cmd[2] = (unsigned char) (block >> 24) & 0xff;
        !           862:        cmd[3] = (unsigned char) (block >> 16) & 0xff;
        !           863:        cmd[4] = (unsigned char) (block >> 8) & 0xff;
        !           864:        cmd[5] = (unsigned char) block & 0xff;
        !           865:        cmd[6] = cmd[9] = 0;
        !           866:        cmd[7] = (unsigned char) (this_count >> 8) & 0xff;
        !           867:        cmd[8] = (unsigned char) this_count & 0xff;
        !           868:     }
        !           869:     else
        !           870:     {
        !           871:        if (this_count > 0xff)
        !           872:            this_count = 0xff;
        !           873:        
        !           874:        cmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
        !           875:        cmd[2] = (unsigned char) ((block >> 8) & 0xff);
        !           876:        cmd[3] = (unsigned char) block & 0xff;
        !           877:        cmd[4] = (unsigned char) this_count;
        !           878:        cmd[5] = 0;
        !           879:     }
        !           880:     
        !           881:     /*
        !           882:      * We shouldn't disconnect in the middle of a sector, so with a dumb 
        !           883:      * host adapter, it's safe to assume that we can at least transfer 
        !           884:      * this many bytes between each connect / disconnect.  
        !           885:      */
        !           886:     
        !           887:     SCpnt->transfersize = rscsi_disks[dev].sector_size;
        !           888:     SCpnt->underflow = this_count << 9; 
        !           889:     scsi_do_cmd (SCpnt, (void *) cmd, buff, 
        !           890:                 this_count * rscsi_disks[dev].sector_size,
        !           891:                 rw_intr, 
        !           892:                 (SCpnt->device->type == TYPE_DISK ? 
        !           893:                  SD_TIMEOUT : SD_MOD_TIMEOUT),
        !           894:                 MAX_RETRIES);
        !           895: }
        !           896: 
        !           897: static int check_scsidisk_media_change(kdev_t full_dev){
        !           898:     int retval;
        !           899:     int target;
        !           900:     struct inode inode;
        !           901:     int flag = 0;
        !           902:     
        !           903:     target =  DEVICE_NR(full_dev);
        !           904:     
        !           905:     if (target >= sd_template.dev_max ||
        !           906:        !rscsi_disks[target].device) {
        !           907:        printk("SCSI disk request error: invalid device.\n");
        !           908:        return 0;
        !           909:     };
        !           910:     
        !           911:     if(!rscsi_disks[target].device->removable) return 0;
        !           912:     
        !           913:     inode.i_rdev = full_dev;  /* This is all we really need here */
        !           914:     retval = sd_ioctl(&inode, NULL, SCSI_IOCTL_TEST_UNIT_READY, 0);
        !           915:     
        !           916:     if(retval){ /* Unable to test, unit probably not ready.  This usually
        !           917:                 * means there is no disc in the drive.  Mark as changed,
        !           918:                 * and we will figure it out later once the drive is
        !           919:                 * available again.  */
        !           920:        
        !           921:        rscsi_disks[target].ready = 0;
        !           922:        rscsi_disks[target].device->changed = 1;
        !           923:        return 1; /* This will force a flush, if called from
        !           924:                   * check_disk_change */
        !           925:     };
        !           926:     
        !           927:     /* 
        !           928:      * for removable scsi disk ( FLOPTICAL ) we have to recognise the
        !           929:      * presence of disk in the drive. This is kept in the Scsi_Disk
        !           930:      * struct and tested at open !  Daniel Roche ( [email protected] ) 
        !           931:      */
        !           932:     
        !           933:     rscsi_disks[target].ready = 1;     /* FLOPTICAL */
        !           934: 
        !           935:     retval = rscsi_disks[target].device->changed;
        !           936:     if(!flag) rscsi_disks[target].device->changed = 0;
        !           937:     return retval;
        !           938: }
        !           939: 
        !           940: static void sd_init_done (Scsi_Cmnd * SCpnt)
        !           941: {
        !           942:     struct request * req;
        !           943:     
        !           944:     req = &SCpnt->request;
        !           945:     req->rq_status = RQ_SCSI_DONE; /* Busy, but indicate request done */
        !           946:     
        !           947:     if (req->sem != NULL) {
        !           948:        up(req->sem);
        !           949:     }
        !           950: }
        !           951: 
        !           952: static int sd_init_onedisk(int i)
        !           953: {
        !           954:     unsigned char cmd[10];
        !           955:     unsigned char *buffer;
        !           956:     unsigned long spintime;
        !           957:     int the_result, retries;
        !           958:     Scsi_Cmnd * SCpnt;
        !           959:     
        !           960:     /* We need to retry the READ_CAPACITY because a UNIT_ATTENTION is 
        !           961:      * considered a fatal error, and many devices report such an error 
        !           962:      * just after a scsi bus reset. 
        !           963:      */
        !           964:     
        !           965:     SCpnt = allocate_device(NULL, rscsi_disks[i].device, 1);
        !           966:     buffer = (unsigned char *) scsi_malloc(512);
        !           967:     
        !           968:     spintime = 0;
        !           969:     
        !           970:     /* Spin up drives, as required.  Only do this at boot time */
        !           971:     if (!MODULE_FLAG){
        !           972:        do{
        !           973:            retries = 0;
        !           974:            while(retries < 3)
        !           975:            {
        !           976:                cmd[0] = TEST_UNIT_READY;
        !           977:                cmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
        !           978:                memset ((void *) &cmd[2], 0, 8);
        !           979:                SCpnt->cmd_len = 0;
        !           980:                SCpnt->sense_buffer[0] = 0;
        !           981:                SCpnt->sense_buffer[2] = 0;
        !           982: 
        !           983:                {
        !           984:                    struct semaphore sem = MUTEX_LOCKED;
        !           985:                    /* Mark as really busy again */
        !           986:                    SCpnt->request.rq_status = RQ_SCSI_BUSY;
        !           987:                    SCpnt->request.sem = &sem;
        !           988:                    scsi_do_cmd (SCpnt,
        !           989:                                 (void *) cmd, (void *) buffer,
        !           990:                                 512, sd_init_done,  SD_TIMEOUT,
        !           991:                                 MAX_RETRIES);
        !           992:                    down(&sem);
        !           993:                }
        !           994: 
        !           995:                the_result = SCpnt->result;
        !           996:                retries++;
        !           997:                if(   the_result == 0
        !           998:                   || SCpnt->sense_buffer[2] != UNIT_ATTENTION)
        !           999:                    break;
        !          1000:            }
        !          1001:            
        !          1002:            /* Look for non-removable devices that return NOT_READY.  
        !          1003:             * Issue command to spin up drive for these cases. */
        !          1004:            if(the_result && !rscsi_disks[i].device->removable && 
        !          1005:               SCpnt->sense_buffer[2] == NOT_READY) {
        !          1006:                int time1;
        !          1007:                if(!spintime){
        !          1008:                    printk( "sd%c: Spinning up disk...", 'a' + i );
        !          1009:                    cmd[0] = START_STOP;
        !          1010:                    cmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
        !          1011:                    cmd[1] |= 1;  /* Return immediately */
        !          1012:                    memset ((void *) &cmd[2], 0, 8);
        !          1013:                    cmd[4] = 1; /* Start spin cycle */
        !          1014:                    SCpnt->cmd_len = 0;
        !          1015:                    SCpnt->sense_buffer[0] = 0;
        !          1016:                    SCpnt->sense_buffer[2] = 0;
        !          1017:                    
        !          1018:                    {
        !          1019:                        struct semaphore sem = MUTEX_LOCKED;
        !          1020:                        /* Mark as really busy again */
        !          1021:                        SCpnt->request.rq_status = RQ_SCSI_BUSY; 
        !          1022:                        SCpnt->request.sem = &sem;
        !          1023:                        scsi_do_cmd (SCpnt,
        !          1024:                                     (void *) cmd, (void *) buffer,
        !          1025:                                     512, sd_init_done,  SD_TIMEOUT,
        !          1026:                                     MAX_RETRIES);
        !          1027:                        down(&sem);
        !          1028:                    }
        !          1029:                    
        !          1030:                    spintime = jiffies;
        !          1031:                }
        !          1032:                
        !          1033:                time1 = jiffies;
        !          1034:                while(jiffies < time1 + HZ); /* Wait 1 second for next try */
        !          1035:                printk( "." );
        !          1036:            };
        !          1037:        } while(the_result && spintime && spintime+100*HZ > jiffies);
        !          1038:        if (spintime) {
        !          1039:            if (the_result)
        !          1040:                printk( "not responding...\n" );
        !          1041:            else
        !          1042:                printk( "ready\n" );
        !          1043:        }
        !          1044:     };  /* !MODULE_FLAG */
        !          1045:     
        !          1046:     
        !          1047:     retries = 3;
        !          1048:     do {
        !          1049:        cmd[0] = READ_CAPACITY;
        !          1050:        cmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
        !          1051:        memset ((void *) &cmd[2], 0, 8);
        !          1052:        memset ((void *) buffer, 0, 8);
        !          1053:        SCpnt->cmd_len = 0;
        !          1054:        SCpnt->sense_buffer[0] = 0;
        !          1055:        SCpnt->sense_buffer[2] = 0;
        !          1056: 
        !          1057:        {
        !          1058:            struct semaphore sem = MUTEX_LOCKED;
        !          1059:            /* Mark as really busy again */
        !          1060:            SCpnt->request.rq_status = RQ_SCSI_BUSY;
        !          1061:            SCpnt->request.sem = &sem;
        !          1062:            scsi_do_cmd (SCpnt,
        !          1063:                         (void *) cmd, (void *) buffer,
        !          1064:                         8, sd_init_done,  SD_TIMEOUT,
        !          1065:                         MAX_RETRIES);
        !          1066:            down(&sem); /* sleep until it is ready */
        !          1067:        }
        !          1068:        
        !          1069:        the_result = SCpnt->result;
        !          1070:        retries--;
        !          1071:        
        !          1072:     } while(the_result && retries);
        !          1073:     
        !          1074:     SCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
        !          1075:     
        !          1076:     wake_up(&SCpnt->device->device_wait); 
        !          1077:     
        !          1078:     /* Wake up a process waiting for device */
        !          1079:     
        !          1080:     /*
        !          1081:      * The SCSI standard says: 
        !          1082:      * "READ CAPACITY is necessary for self configuring software"
        !          1083:      *  While not mandatory, support of READ CAPACITY is strongly encouraged.
        !          1084:      *  We used to die if we couldn't successfully do a READ CAPACITY.
        !          1085:      *  But, now we go on about our way.  The side effects of this are
        !          1086:      *
        !          1087:      *  1. We can't know block size with certainty. I have said "512 bytes 
        !          1088:      *     is it" as this is most common.
        !          1089:      *
        !          1090:      *  2. Recovery from when some one attempts to read past the end of the 
        !          1091:      *     raw device will be slower.
        !          1092:      */
        !          1093:     
        !          1094:     if (the_result)
        !          1095:     {
        !          1096:        printk ("sd%c : READ CAPACITY failed.\n"
        !          1097:                "sd%c : status = %x, message = %02x, host = %d, driver = %02x \n",
        !          1098:                'a' + i, 'a' + i,
        !          1099:                status_byte(the_result),
        !          1100:                msg_byte(the_result),
        !          1101:                host_byte(the_result),
        !          1102:                driver_byte(the_result)
        !          1103:                );
        !          1104:        if (driver_byte(the_result)  & DRIVER_SENSE)
        !          1105:            printk("sd%c : extended sense code = %1x \n", 
        !          1106:                   'a' + i, SCpnt->sense_buffer[2] & 0xf);
        !          1107:        else
        !          1108:            printk("sd%c : sense not available. \n", 'a' + i);
        !          1109:        
        !          1110:        printk("sd%c : block size assumed to be 512 bytes, disk size 1GB.  \n",
        !          1111:               'a' + i);
        !          1112:        rscsi_disks[i].capacity = 0x1fffff;
        !          1113:        rscsi_disks[i].sector_size = 512;
        !          1114:        
        !          1115:        /* Set dirty bit for removable devices if not ready - sometimes drives
        !          1116:         * will not report this properly. */
        !          1117:        if(rscsi_disks[i].device->removable && 
        !          1118:           SCpnt->sense_buffer[2] == NOT_READY)
        !          1119:            rscsi_disks[i].device->changed = 1;
        !          1120:        
        !          1121:     }
        !          1122:     else
        !          1123:     {
        !          1124:        /*
        !          1125:         * FLOPTICAL , if read_capa is ok , drive is assumed to be ready 
        !          1126:         */
        !          1127:        rscsi_disks[i].ready = 1;
        !          1128: 
        !          1129:        rscsi_disks[i].capacity = (buffer[0] << 24) |
        !          1130:            (buffer[1] << 16) |
        !          1131:                (buffer[2] << 8) |
        !          1132:                    buffer[3];
        !          1133:        
        !          1134:        rscsi_disks[i].sector_size = (buffer[4] << 24) |
        !          1135:            (buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
        !          1136: 
        !          1137:        if (rscsi_disks[i].sector_size == 0) {
        !          1138:          rscsi_disks[i].sector_size = 512;
        !          1139:          printk("sd%c : sector size 0 reported, assuming 512.\n", 'a' + i);
        !          1140:        }
        !          1141:  
        !          1142:        
        !          1143:        if (rscsi_disks[i].sector_size != 512 &&
        !          1144:            rscsi_disks[i].sector_size != 1024 &&
        !          1145:            rscsi_disks[i].sector_size != 256)
        !          1146:        {
        !          1147:            printk ("sd%c : unsupported sector size %d.\n",
        !          1148:                    'a' + i, rscsi_disks[i].sector_size);
        !          1149:            if(rscsi_disks[i].device->removable){
        !          1150:                rscsi_disks[i].capacity = 0;
        !          1151:            } else {
        !          1152:                printk ("scsi : deleting disk entry.\n");
        !          1153:                rscsi_disks[i].device = NULL;
        !          1154:                sd_template.nr_dev--;
        !          1155:                return i;
        !          1156:            };
        !          1157:        }
        !          1158:     {
        !          1159:        /*
        !          1160:         * The msdos fs need to know the hardware sector size
        !          1161:         * So I have created this table. See ll_rw_blk.c
        !          1162:         * Jacques Gelinas ([email protected])
        !          1163:         */
        !          1164:        int m;
        !          1165:        int hard_sector = rscsi_disks[i].sector_size;
        !          1166:        /* There is 16 minor allocated for each devices */
        !          1167:        for (m=i<<4; m<((i+1)<<4); m++){
        !          1168:            sd_hardsizes[m] = hard_sector;
        !          1169:        }
        !          1170:        printk ("SCSI Hardware sector size is %d bytes on device sd%c\n",
        !          1171:                hard_sector,i+'a');
        !          1172:     }
        !          1173:        if(rscsi_disks[i].sector_size == 1024)
        !          1174:            rscsi_disks[i].capacity <<= 1;  /* Change into 512 byte sectors */
        !          1175:        if(rscsi_disks[i].sector_size == 256)
        !          1176:            rscsi_disks[i].capacity >>= 1;  /* Change into 512 byte sectors */
        !          1177:     }
        !          1178:     
        !          1179: 
        !          1180:     /*
        !          1181:      * Unless otherwise specified, this is not write protected.
        !          1182:      */
        !          1183:     rscsi_disks[i].write_prot = 0;
        !          1184:     if ( rscsi_disks[i].device->removable && rscsi_disks[i].ready ) {
        !          1185:        /* FLOPTICAL */
        !          1186: 
        !          1187:        /* 
        !          1188:         *      for removable scsi disk ( FLOPTICAL ) we have to recognise  
        !          1189:         * the Write Protect Flag. This flag is kept in the Scsi_Disk struct
        !          1190:         * and tested at open !
        !          1191:         * Daniel Roche ( [email protected] )
        !          1192:         */
        !          1193:        
        !          1194:        memset ((void *) &cmd[0], 0, 8);
        !          1195:        cmd[0] = MODE_SENSE;
        !          1196:        cmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
        !          1197:        cmd[2] = 1;      /* page code 1 ?? */
        !          1198:        cmd[4] = 12;
        !          1199:        SCpnt->cmd_len = 0;
        !          1200:        SCpnt->sense_buffer[0] = 0;
        !          1201:        SCpnt->sense_buffer[2] = 0;
        !          1202: 
        !          1203:        /* same code as READCAPA !! */
        !          1204:        {
        !          1205:            struct semaphore sem = MUTEX_LOCKED;
        !          1206:            SCpnt->request.rq_status = RQ_SCSI_BUSY;  /* Mark as really busy again */
        !          1207:            SCpnt->request.sem = &sem;
        !          1208:            scsi_do_cmd (SCpnt,
        !          1209:                         (void *) cmd, (void *) buffer,
        !          1210:                         512, sd_init_done,  SD_TIMEOUT,
        !          1211:                         MAX_RETRIES);
        !          1212:            down(&sem);
        !          1213:        }
        !          1214:        
        !          1215:        the_result = SCpnt->result;
        !          1216:        SCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
        !          1217:        wake_up(&SCpnt->device->device_wait); 
        !          1218:        
        !          1219:        if ( the_result ) {
        !          1220:            printk ("sd%c: test WP failed, assume Write Protected\n",i+'a');
        !          1221:            rscsi_disks[i].write_prot = 1;
        !          1222:        } else {
        !          1223:            rscsi_disks[i].write_prot = ((buffer[2] & 0x80) != 0);
        !          1224:            printk ("sd%c: Write Protect is %s\n",i+'a',
        !          1225:                    rscsi_disks[i].write_prot ? "on" : "off");
        !          1226:        }
        !          1227:        
        !          1228:     }  /* check for write protect */
        !          1229:  
        !          1230:     rscsi_disks[i].ten = 1;
        !          1231:     rscsi_disks[i].remap = 1;
        !          1232:     scsi_free(buffer, 512);
        !          1233:     return i;
        !          1234: }
        !          1235: 
        !          1236: /*
        !          1237:  * The sd_init() function looks at all SCSI drives present, determines
        !          1238:  * their size, and reads partition table entries for them.
        !          1239:  */
        !          1240: 
        !          1241: static int sd_registered = 0;
        !          1242: 
        !          1243: static int sd_init()
        !          1244: {
        !          1245:     int i;
        !          1246:     
        !          1247:     if (sd_template.dev_noticed == 0) return 0;
        !          1248:     
        !          1249:     if(!sd_registered) {
        !          1250:          if (register_blkdev(MAJOR_NR,"sd",&sd_fops)) {
        !          1251:              printk("Unable to get major %d for SCSI disk\n",MAJOR_NR);
        !          1252:              return 1;
        !          1253:          }
        !          1254:          sd_registered++;
        !          1255:       }
        !          1256:     
        !          1257:     /* We do not support attaching loadable devices yet. */
        !          1258:     if(rscsi_disks) return 0;
        !          1259:     
        !          1260:     sd_template.dev_max = sd_template.dev_noticed + SD_EXTRA_DEVS;
        !          1261:     
        !          1262:     rscsi_disks = (Scsi_Disk *) 
        !          1263:        scsi_init_malloc(sd_template.dev_max * sizeof(Scsi_Disk), GFP_ATOMIC);
        !          1264:     memset(rscsi_disks, 0, sd_template.dev_max * sizeof(Scsi_Disk));
        !          1265:     
        !          1266:     sd_sizes = (int *) scsi_init_malloc((sd_template.dev_max << 4) * 
        !          1267:                                        sizeof(int), GFP_ATOMIC);
        !          1268:     memset(sd_sizes, 0, (sd_template.dev_max << 4) * sizeof(int));
        !          1269:     
        !          1270:     sd_blocksizes = (int *) scsi_init_malloc((sd_template.dev_max << 4) * 
        !          1271:                                             sizeof(int), GFP_ATOMIC);
        !          1272:     
        !          1273:     sd_hardsizes = (int *) scsi_init_malloc((sd_template.dev_max << 4) * 
        !          1274:                                            sizeof(int), GFP_ATOMIC);
        !          1275:     
        !          1276:     for(i=0;i<(sd_template.dev_max << 4);i++){
        !          1277:        sd_blocksizes[i] = 1024;
        !          1278:        sd_hardsizes[i] = 512;
        !          1279:     }
        !          1280:     blksize_size[MAJOR_NR] = sd_blocksizes;
        !          1281:     hardsect_size[MAJOR_NR] = sd_hardsizes;
        !          1282:     sd = (struct hd_struct *) scsi_init_malloc((sd_template.dev_max << 4) *
        !          1283:                                               sizeof(struct hd_struct),
        !          1284:                                               GFP_ATOMIC);
        !          1285:     
        !          1286:     
        !          1287:     sd_gendisk.max_nr = sd_template.dev_max;
        !          1288:     sd_gendisk.part = sd;
        !          1289:     sd_gendisk.sizes = sd_sizes;
        !          1290:     sd_gendisk.real_devices = (void *) rscsi_disks;
        !          1291:     return 0;
        !          1292: }
        !          1293: 
        !          1294: static void sd_finish()
        !          1295: {
        !          1296:     int i;
        !          1297: 
        !          1298:     blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
        !          1299:     
        !          1300:     sd_gendisk.next = gendisk_head;
        !          1301:     gendisk_head = &sd_gendisk;
        !          1302:     
        !          1303:     for (i = 0; i < sd_template.dev_max; ++i)
        !          1304:        if (!rscsi_disks[i].capacity && 
        !          1305:            rscsi_disks[i].device)
        !          1306:        {
        !          1307:            if (MODULE_FLAG
        !          1308:                && !rscsi_disks[i].has_part_table) {
        !          1309:                sd_sizes[i << 4] = rscsi_disks[i].capacity;
        !          1310:                /* revalidate does sd_init_onedisk via MAYBE_REINIT*/
        !          1311:                revalidate_scsidisk(MKDEV(MAJOR_NR, i << 4), 0);
        !          1312:            }
        !          1313:            else
        !          1314:                i=sd_init_onedisk(i);
        !          1315:            rscsi_disks[i].has_part_table = 1;
        !          1316:        }
        !          1317:     
        !          1318:     /* If our host adapter is capable of scatter-gather, then we increase
        !          1319:      * the read-ahead to 16 blocks (32 sectors).  If not, we use
        !          1320:      * a two block (4 sector) read ahead. 
        !          1321:      */
        !          1322:     if(rscsi_disks[0].device && rscsi_disks[0].device->host->sg_tablesize)
        !          1323:        read_ahead[MAJOR_NR] = 120;  /* 120 sector read-ahead */
        !          1324:     else
        !          1325:        read_ahead[MAJOR_NR] = 4;  /* 4 sector read-ahead */
        !          1326: 
        !          1327:     return;
        !          1328: }
        !          1329: 
        !          1330: static int sd_detect(Scsi_Device * SDp){
        !          1331:     if(SDp->type != TYPE_DISK && SDp->type != TYPE_MOD) return 0;
        !          1332:     
        !          1333:     printk("Detected scsi disk sd%c at scsi%d, channel %d, id %d, lun %d\n", 
        !          1334:           'a'+ (sd_template.dev_noticed++),
        !          1335:           SDp->host->host_no, SDp->channel, SDp->id, SDp->lun); 
        !          1336:     
        !          1337:     return 1;
        !          1338: }
        !          1339: 
        !          1340: static int sd_attach(Scsi_Device * SDp){
        !          1341:     Scsi_Disk * dpnt;
        !          1342:     int i;
        !          1343:     
        !          1344:     if(SDp->type != TYPE_DISK && SDp->type != TYPE_MOD) return 0;
        !          1345:     
        !          1346:     if(sd_template.nr_dev >= sd_template.dev_max) {
        !          1347:        SDp->attached--;
        !          1348:        return 1;
        !          1349:     }
        !          1350:     
        !          1351:     for(dpnt = rscsi_disks, i=0; i<sd_template.dev_max; i++, dpnt++) 
        !          1352:        if(!dpnt->device) break;
        !          1353:     
        !          1354:     if(i >= sd_template.dev_max) panic ("scsi_devices corrupt (sd)");
        !          1355:     
        !          1356:     SDp->scsi_request_fn = do_sd_request;
        !          1357:     rscsi_disks[i].device = SDp;
        !          1358:     rscsi_disks[i].has_part_table = 0;
        !          1359:     sd_template.nr_dev++;
        !          1360:     sd_gendisk.nr_real++;
        !          1361:     return 0;
        !          1362: }
        !          1363: 
        !          1364: #define DEVICE_BUSY rscsi_disks[target].device->busy
        !          1365: #define USAGE rscsi_disks[target].device->access_count
        !          1366: #define CAPACITY rscsi_disks[target].capacity
        !          1367: #define MAYBE_REINIT  sd_init_onedisk(target)
        !          1368: #define GENDISK_STRUCT sd_gendisk
        !          1369: 
        !          1370: /* This routine is called to flush all partitions and partition tables
        !          1371:  * for a changed scsi disk, and then re-read the new partition table.
        !          1372:  * If we are revalidating a disk because of a media change, then we
        !          1373:  * enter with usage == 0.  If we are using an ioctl, we automatically have
        !          1374:  * usage == 1 (we need an open channel to use an ioctl :-), so this
        !          1375:  * is our limit.
        !          1376:  */
        !          1377: int revalidate_scsidisk(kdev_t dev, int maxusage){
        !          1378:     int target;
        !          1379:     struct gendisk * gdev;
        !          1380:     unsigned long flags;
        !          1381:     int max_p;
        !          1382:     int start;
        !          1383:     int i;
        !          1384:     
        !          1385:     target =  DEVICE_NR(dev);
        !          1386:     gdev = &GENDISK_STRUCT;
        !          1387:     
        !          1388:     save_flags(flags);
        !          1389:     cli();
        !          1390:     if (DEVICE_BUSY || USAGE > maxusage) {
        !          1391:        restore_flags(flags);
        !          1392:        printk("Device busy for revalidation (usage=%d)\n", USAGE);
        !          1393:        return -EBUSY;
        !          1394:     };
        !          1395:     DEVICE_BUSY = 1;
        !          1396:     restore_flags(flags);
        !          1397:     
        !          1398:     max_p = gdev->max_p;
        !          1399:     start = target << gdev->minor_shift;
        !          1400:     
        !          1401:     for (i=max_p - 1; i >=0 ; i--) {
        !          1402:        int minor = start+i;
        !          1403:        kdev_t devi = MKDEV(MAJOR_NR, minor);
        !          1404:        sync_dev(devi);
        !          1405:        invalidate_inodes(devi);
        !          1406:        invalidate_buffers(devi);
        !          1407:        gdev->part[minor].start_sect = 0;
        !          1408:        gdev->part[minor].nr_sects = 0;
        !          1409:         /*
        !          1410:          * Reset the blocksize for everything so that we can read
        !          1411:          * the partition table.
        !          1412:          */
        !          1413:         blksize_size[MAJOR_NR][minor] = 1024;
        !          1414:     };
        !          1415:     
        !          1416: #ifdef MAYBE_REINIT
        !          1417:     MAYBE_REINIT;
        !          1418: #endif
        !          1419:     
        !          1420:     gdev->part[start].nr_sects = CAPACITY;
        !          1421:     resetup_one_dev(gdev, target);
        !          1422:     
        !          1423:     DEVICE_BUSY = 0;
        !          1424:     return 0;
        !          1425: }
        !          1426: 
        !          1427: static int fop_revalidate_scsidisk(kdev_t dev){
        !          1428:     return revalidate_scsidisk(dev, 0);
        !          1429: }
        !          1430: 
        !          1431: 
        !          1432: static void sd_detach(Scsi_Device * SDp)
        !          1433: {
        !          1434:     Scsi_Disk * dpnt;
        !          1435:     int i;
        !          1436:     int max_p;
        !          1437:     int start;
        !          1438:     
        !          1439:     for(dpnt = rscsi_disks, i=0; i<sd_template.dev_max; i++, dpnt++) 
        !          1440:        if(dpnt->device == SDp) {
        !          1441:            
        !          1442:            /* If we are disconnecting a disk driver, sync and invalidate 
        !          1443:             * everything */
        !          1444:            max_p = sd_gendisk.max_p;
        !          1445:            start = i << sd_gendisk.minor_shift;
        !          1446:            
        !          1447:            for (i=max_p - 1; i >=0 ; i--) {
        !          1448:                int minor = start+i;
        !          1449:                kdev_t devi = MKDEV(MAJOR_NR, minor);
        !          1450:                sync_dev(devi);
        !          1451:                invalidate_inodes(devi);
        !          1452:                invalidate_buffers(devi);
        !          1453:                sd_gendisk.part[minor].start_sect = 0;
        !          1454:                sd_gendisk.part[minor].nr_sects = 0;
        !          1455:                sd_sizes[minor] = 0;
        !          1456:            };
        !          1457:            
        !          1458:            dpnt->has_part_table = 0;
        !          1459:            dpnt->device = NULL;
        !          1460:            dpnt->capacity = 0;
        !          1461:            SDp->attached--;
        !          1462:            sd_template.dev_noticed--;
        !          1463:            sd_template.nr_dev--;
        !          1464:            sd_gendisk.nr_real--;
        !          1465:            return;
        !          1466:        }
        !          1467:     return;
        !          1468: }
        !          1469: 
        !          1470: #ifdef MODULE
        !          1471: 
        !          1472: int init_module(void) {
        !          1473:     sd_template.usage_count = &mod_use_count_;
        !          1474:     return scsi_register_module(MODULE_SCSI_DEV, &sd_template);
        !          1475: }
        !          1476: 
        !          1477: void cleanup_module( void) 
        !          1478: {
        !          1479:     struct gendisk * prev_sdgd;
        !          1480:     struct gendisk * sdgd;
        !          1481:     
        !          1482:     scsi_unregister_module(MODULE_SCSI_DEV, &sd_template);
        !          1483:     unregister_blkdev(SCSI_DISK_MAJOR, "sd");
        !          1484:     sd_registered--;
        !          1485:     if( rscsi_disks != NULL )
        !          1486:     {
        !          1487:        scsi_init_free((char *) rscsi_disks,
        !          1488:                       (sd_template.dev_noticed + SD_EXTRA_DEVS) 
        !          1489:                       * sizeof(Scsi_Disk));
        !          1490:        
        !          1491:        scsi_init_free((char *) sd_sizes, sd_template.dev_max * sizeof(int));
        !          1492:        scsi_init_free((char *) sd_blocksizes, sd_template.dev_max * sizeof(int));
        !          1493:        scsi_init_free((char *) sd_hardsizes, sd_template.dev_max * sizeof(int));
        !          1494:        scsi_init_free((char *) sd, 
        !          1495:                       (sd_template.dev_max << 4) * sizeof(struct hd_struct));
        !          1496:        /*
        !          1497:         * Now remove sd_gendisk from the linked list
        !          1498:         */
        !          1499:        sdgd = gendisk_head;
        !          1500:        prev_sdgd = NULL;
        !          1501:        while(sdgd != &sd_gendisk)
        !          1502:        {
        !          1503:            prev_sdgd = sdgd;
        !          1504:            sdgd = sdgd->next;
        !          1505:        }
        !          1506:        
        !          1507:        if(sdgd != &sd_gendisk)
        !          1508:            printk("sd_gendisk not in disk chain.\n");
        !          1509:        else {
        !          1510:            if(prev_sdgd != NULL)
        !          1511:                prev_sdgd->next = sdgd->next;
        !          1512:            else
        !          1513:                gendisk_head = sdgd->next;
        !          1514:        }
        !          1515:     }
        !          1516:     
        !          1517:     blksize_size[MAJOR_NR] = NULL;
        !          1518:     blk_dev[MAJOR_NR].request_fn = NULL;
        !          1519:     blk_size[MAJOR_NR] = NULL;  
        !          1520:     hardsect_size[MAJOR_NR] = NULL;
        !          1521:     read_ahead[MAJOR_NR] = 0;
        !          1522:     sd_template.dev_max = 0;
        !          1523: }
        !          1524: #endif /* MODULE */
        !          1525: 
        !          1526: /*
        !          1527:  * Overrides for Emacs so that we almost follow Linus's tabbing style.
        !          1528:  * Emacs will notice this stuff at the end of the file and automatically
        !          1529:  * adjust the settings for this buffer only.  This must remain at the end
        !          1530:  * of the file.
        !          1531:  * ---------------------------------------------------------------------------
        !          1532:  * Local variables:
        !          1533:  * c-indent-level: 4
        !          1534:  * c-brace-imaginary-offset: 0
        !          1535:  * c-brace-offset: -4
        !          1536:  * c-argdecl-indent: 4
        !          1537:  * c-label-offset: -4
        !          1538:  * c-continued-statement-offset: 4
        !          1539:  * c-continued-brace-offset: 0
        !          1540:  * indent-tabs-mode: nil
        !          1541:  * tab-width: 8
        !          1542:  * End:
        !          1543:  */

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