![[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 [Early Linux] / linux / kernel / blk_drv / scsi|
Return to sd.c CVS log | Up to [Early Linux] / linux / kernel / blk_drv / scsi |
1.1 root 1: /*
2: * sd.c Copyright (C) 1992 Drew Eckhardt
3: * Linux scsi disk driver by
4: * Drew Eckhardt
5: *
6: * <[email protected]>
7: */
8:
9: #include <linux/config.h>
10:
11: #ifdef CONFIG_BLK_DEV_SD
12: #include <linux/string.h>
13: #include <linux/fs.h>
14: #include <linux/kernel.h>
15: #include <linux/sched.h>
16: #include "scsi.h"
17: #include "sd.h"
18:
19: #define MAJOR_NR 8
20:
21: #include "../blk.h"
22:
23: /*
24: static const char RCSid[] = "$Header:";
25: */
26:
27: #define MAX_RETRIES 5
28:
29: /*
30: * Time out in seconds
31: */
32:
33: #define SD_TIMEOUT 100
34:
35: Partition scsi_disks[MAX_SD << 4];
36: int NR_SD=0;
37: Scsi_Disk rscsi_disks[MAX_SD];
38: static int sd_sizes[MAX_SD << 4];
39: static int this_count;
40: static int the_result;
41:
42: extern int sd_ioctl(struct inode *, struct file *, unsigned long, unsigned long);
43:
44: static void sd_release(struct inode * inode, struct file * file)
45: {
46: sync_dev(inode->i_rdev);
47: }
48:
49: static struct file_operations sd_fops = {
50: NULL, /* lseek - default */
51: block_read, /* read - general block-dev read */
52: block_write, /* write - general block-dev write */
53: NULL, /* readdir - bad */
54: NULL, /* select */
55: sd_ioctl, /* ioctl */
56: NULL, /* no special open code */
57: sd_release /* release */
58: };
59:
60: /*
61: The sense_buffer is where we put data for all mode sense commands
62: performed.
63: */
64:
65: static unsigned char sense_buffer[255];
66:
67: /*
68: rw_intr is the interrupt routine for the device driver. It will
69: be notified on the end of a SCSI read / write, and
70: will take on of several actions based on success or failure.
71: */
72:
73: static void rw_intr (int host, int result)
74: {
75: if (HOST != host)
76: panic ("sd.o : rw_intr() recieving interrupt for different host.");
77:
78: /*
79: First case : we assume that the command succeeded. One of two things will
80: happen here. Either we will be finished, or there will be more
81: sectors that we were unable to read last time.
82: */
83:
84: if (!result)
85: if (!(CURRENT->nr_sectors -= this_count)) {
86: end_request(1);
87: do_sd_request();
88: } else {
89: CURRENT->nr_sectors -= this_count;
90: /*
91: The CURRENT->nr_sectors field is always done in 512 byte sectors,
92: even if this really isn't the case.
93: */
94:
95: (char *) CURRENT->buffer += this_count << 9;
96: CURRENT->sector += this_count;
97: CURRENT->errors = 0;
98: do_sd_request();
99: }
100:
101: /*
102: Now, if we were good little boys and girls, Santa left us a request
103: sense buffer. We can extract information from this, so we
104: can choose a block to remap, etc.
105: */
106:
107: else if (driver_byte(result) & DRIVER_SENSE) {
108: if (sugestion(result) == SUGGEST_REMAP) {
109: #ifdef REMAP
110: /*
111: Not yet implemented. A read will fail after being remapped,
112: a write will call the strategy routine again.
113: */
114:
115: if rscsi_disks[DEVICE_NR(CURRENT->dev)].remap
116: {
117: result = 0;
118: }
119: else
120:
121: #endif
122: }
123: /*
124: If we had an ILLEGAL REQUEST returned, then we may have performed
125: an unsupported command. The only thing this should be would be a ten
126: byte read where only a six byte read was supportted. Also, on a
127: system where READ CAPACITY failed, we mave have read past the end of the
128: disk.
129: */
130:
131: else if (sense_buffer[7] == ILLEGAL_REQUEST) {
132: if (rscsi_disks[DEVICE_NR(CURRENT->dev)].ten) {
133: rscsi_disks[DEVICE_NR(CURRENT->dev)].ten = 0;
134: do_sd_request();
135: result = 0;
136: } else {
137: }
138: }
139: }
140: if (result) {
141: printk("SCSI disk error : host %d id %d lun %d return code = %03x\n",
142: rscsi_disks[DEVICE_NR(CURRENT->dev)].device->host_no,
143: rscsi_disks[DEVICE_NR(CURRENT->dev)].device->id,
144: rscsi_disks[DEVICE_NR(CURRENT->dev)].device->lun);
145:
146: if (driver_byte(result) & DRIVER_SENSE)
147: printk("\tSense class %x, sense error %x, extended sense %x\n",
148: sense_class(sense_buffer[0]),
149: sense_error(sense_buffer[0]),
150: sense_buffer[2] & 0xf);
151:
152: end_request(0);
153: }
154: }
155:
156: /*
157: do_sd_request() is the request handler function for the sd driver.
158: Its function in life is to take block device requests, and translate
159: them to SCSI commands.
160: */
161:
162: void do_sd_request (void)
163: {
164: int dev, block;
165: unsigned char cmd[10];
166:
167: INIT_REQUEST;
168: dev = MINOR(CURRENT->dev);
169: block = CURRENT->sector;
170:
171: #ifdef DEBUG
172: printk("Doing sd request, dev = %d, block = %d\n", dev, block);
173: #endif
174:
175: if (dev >= (NR_SD << 4) || block + 2 > scsi_disks[dev].nr_sects ||
176: (dev % 16) > 5)
177: {
178: end_request(0);
179: goto repeat;
180: }
181:
182: block += scsi_disks[dev].start_sect;
183: dev = DEVICE_NR(dev);
184:
185: #ifdef DEBUG
186: printk("Real dev = %d, block = %d\n", dev, block);
187: #endif
188:
189: if (!rscsi_disks[dev].use)
190: {
191: end_request(0);
192: goto repeat;
193: }
194:
195: this_count = CURRENT->nr_sectors;
196: switch (CURRENT->cmd)
197: {
198: case WRITE :
199: if (!rscsi_disks[dev].device->writeable)
200: {
201: end_request(0);
202: goto repeat;
203: }
204: cmd[0] = WRITE_6;
205: break;
206: case READ :
207: cmd[0] = READ_6;
208: break;
209: default :
210: printk ("Unknown sd command %d\r\n", CURRENT->cmd);
211: panic("");
212: }
213:
214: cmd[1] = (LUN << 5) & 0xe0;
215:
216: if (((this_count > 0xff) || (block > 0x1fffff)) && rscsi_disks[dev].ten)
217: {
218: if (this_count > 0xffff)
219: this_count = 0xffff;
220:
221: cmd[0] += READ_10 - READ_6 ;
222: cmd[2] = (unsigned char) (block >> 24) & 0xff;
223: cmd[3] = (unsigned char) (block >> 16) & 0xff;
224: cmd[4] = (unsigned char) (block >> 8) & 0xff;
225: cmd[5] = (unsigned char) block & 0xff;
226: cmd[6] = cmd[9] = 0;
227: cmd[7] = (unsigned char) (this_count >> 8) & 0xff;
228: cmd[8] = (unsigned char) this_count & 0xff;
229: }
230: else
231: {
232: if (this_count > 0xff)
233: this_count = 0xff;
234:
235: cmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
236: cmd[2] = (unsigned char) ((block >> 8) & 0xff);
237: cmd[3] = (unsigned char) block & 0xff;
238: cmd[4] = (unsigned char) this_count;
239: cmd[5] = 0;
240: }
241:
242: scsi_do_cmd (HOST, ID, (void *) cmd, CURRENT->buffer, this_count << 9,
243: rw_intr, SD_TIMEOUT, sense_buffer, MAX_RETRIES);
244: }
245:
246: static void sd_init_done (int host, int result)
247: {
248: the_result = result;
249: }
250:
251: /*
252: The sd_init() function looks at all SCSI drives present, determines
253: their size, and reads partition table entries for them.
254: */
255:
256: void sd_init(void)
257: {
258: int i,j,k;
259: unsigned char cmd[10];
260: unsigned char buffer[513];
261:
262: Partition *p;
263:
264:
265: for (i = 0; i < NR_SD; ++i)
266: {
267: cmd[0] = READ_CAPACITY;
268: rscsi_disks[i].use = 1;
269: cmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
270: memset ((void *) &cmd[2], 0, 8);
271: the_result = -1;
272: #ifdef DEBUG
273: printk("Read capacity, disk %d at host = %d, id = %d\n", i,
274: rscsi_disks[i].device->host_no, rscsi_disks[i].device->id);
275: #endif
276: scsi_do_cmd (rscsi_disks[i].device->host_no ,
277: rscsi_disks[i].device->id,
278: (void *) cmd, (void *) buffer,
279: 512, sd_init_done, SD_TIMEOUT, sense_buffer,
280: MAX_RETRIES);
281:
282: while(the_result < 0);
283: /*
284: The SCSI standard says "READ CAPACITY is necessary for self confuring software"
285: While not mandatory, support of READ CAPACITY is strongly encouraged.
286:
287: We used to die if we couldn't successfully do a READ CAPACITY.
288: But, now we go on about our way. The side effects of this are
289:
290: 1. We can't know block size with certainty. I have said "512 bytes is it"
291: as this is most common.
292:
293: 2. Recovery from when some one attempts to read past the end of the raw device will
294: be slower.
295: */
296:
297: if (the_result)
298: {
299: printk ("Warning : SCSI device at host %d, id %d, lun %d failed READ CAPACITY.\n"
300: "status = %x, message = %02x, host = %02x, driver = %02x \n",
301: rscsi_disks[i].device->host_no, rscsi_disks[i].device->id,
302: rscsi_disks[i].device->lun,
303: status_byte(the_result),
304: msg_byte(the_result),
305: host_byte(the_result),
306: driver_byte(the_result)
307: );
308: if (driver_byte(the_result) & DRIVER_SENSE)
309: printk("Extended sense code = %1x \n", sense_buffer[2] & 0xf);
310: else
311: printk("Sense not available. \n");
312:
313: printk("Block size assumed to be 512 bytes, disk size 1GB. \n");
314: rscsi_disks[i].capacity = 0x1fffff;
315: rscsi_disks[i].sector_size = 512;
316: }
317: else
318: {
319: rscsi_disks[i].capacity = (buffer[0] << 24) |
320: (buffer[1] << 16) |
321: (buffer[2] << 8) |
322: buffer[3];
323:
324: if ((rscsi_disks[i].sector_size = (buffer[4] << 24) |
325: (buffer[5] << 16) |
326: (buffer[6] << 8) |
327: buffer[7]) != 512)
328: {
329: printk ("Unsupported sector size %d for sd %d",
330: rscsi_disks[i].sector_size, i);
331: rscsi_disks[i].use = 0;
332: }
333: }
334:
335: if (rscsi_disks[i].use)
336: {
337: scsi_disks[j = (i << 4)].start_sect = 0;
338:
339: sd_sizes[j]=(scsi_disks[j].nr_sects = rscsi_disks[i].capacity)>>1;
340: #ifdef DEBUG
341: printk("/dev/sd%1d size = %d\n", j, sd_sizes[j]);
342: #endif
343: cmd[0] = READ_6;
344: cmd[2] = cmd[3] = cmd[5] = 0;
345: cmd[4] = 1;
346: the_result = -1;
347:
348: scsi_do_cmd (rscsi_disks[i].device->host_no , rscsi_disks[i].device->id,
349: (void *) cmd, (void *) buffer, 512, sd_init_done, SD_TIMEOUT,
350: sense_buffer, MAX_RETRIES);
351:
352: while (the_result < 0);
353:
354:
355: if (the_result || (0xaa55 != *(unsigned short *)(buffer + 510)))
356: {
357: printk ("Cannot read partition table for sd %d"
358: "\n\r",i);
359: rscsi_disks[i].use = 0;
360: }
361: else
362: for (++j, k=j+4, p=(Partition *) (buffer + 0x1be); j < k; ++j, ++p)
363: {
364: memcpy ((void *) &scsi_disks[j], (void *) p, sizeof(Partition));
365: sd_sizes[j]=(scsi_disks[j].nr_sects)>>1;
366: #ifdef DEBUG
367: printk("/dev/sd%1d size = %d (%d blocks), offset = %d\n", j, scsi_disks[j].nr_sects, sd_sizes[j], scsi_disks[j].start_sect);
368: #endif
369: }
370:
371: rscsi_disks[i].ten = 1;
372: rscsi_disks[i].remap = 1;
373: }
374: }
375: blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
376: blk_size[MAJOR_NR] = sd_sizes;
377: blkdev_fops[MAJOR_NR] = &sd_fops;
378: }
379: #endif
380:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.