![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi|
Return to sd.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi |
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.