![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scsi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / kernel / USRSRC / i8086 / drv|
Return to scsi.c CVS log | Up to [MW Coherent from dump] / coherent / d / kernel / USRSRC / i8086 / drv |
1.1 root 1: /*
2: * This is the generic SCSI part of the
3: * Adaptec AHA154x host adapter driver for the AT.
4: *
5: * $Log: scsi.c,v $
6: * Revision 1.10 91/11/12 07:50:21 bin
7: * 3204 kernel source for use with piggy's tboot code
8: *
9: * Revision 1.9 91/11/11 12:32:58 hal
10: * Get SD_HDS and SD_SPT from tboot.
11: *
12: * Revision 1.8 91/10/25 14:50:39 hal
13: * Make DMA channel patchable.
14: *
15: * Revision 1.7 91/10/22 13:40:36 hal
16: * Use sys on kernel header includes.
17: *
18: * Revision 1.6 91/06/10 13:28:11 hal
19: * Refix startup problem with HDGETA. Text cleanup.
20: *
21: * Revision 1.5 91/06/10 12:58:04 hal
22: * Partial fix for HDGETA failing if partition table absent.
23: *
24: * Revision 1.4 91/06/03 13:50:06 hal
25: * Add HDSETA.
26: *
27: * Revision 1.3 91/05/08 11:00:30 root
28: * Make number of heads - SD_HDS - patchable for Tandy.
29: *
30: * Revision 1.2 91/05/01 04:50:11 root
31: * Debug code and d_time/sw_active imbalance fixed.
32: *
33: * Revision 1.1 91/04/30 11:02:22 root
34: * Shipped with COH 3.1.0
35: *
36: */
37:
38: #include <sys/coherent.h>
39: #include <sys/fdisk.h>
40: #include <sys/hdioctl.h>
41: #include <sys/sdioctl.h>
42: #include <sys/buf.h>
43: #include <sys/con.h>
44: #include <sys/stat.h>
45: #include <sys/uproc.h>
46: #include <errno.h>
47: #include <sys/scsiwork.h>
48: #include <sys/typed.h>
49:
50: extern saddr_t sds;
51: extern short n_atdr;
52:
53: /*
54: * Configurable parameters
55: *
56: * Adaptec ROM translates at 64 heads, except the Tandy version, which
57: * uses 16 heads. Kernel variable SD_HDS is patchable for this reason.
58: */
59: #define DEF_AHA_HDS 64
60: #define DEF_AHA_SPT 32
61:
62: int SD_HDS = 0;
63: int SD_SPT = 0;
64:
65: #define NDRIVE (8 * 4) /* 8 SCSI ids and 4 LUNs */
66: #define SDMAJOR 13 /* Major Device Number */
67:
68: /*
69: * user configurable parameters
70: */
71: int SDIRQ = 11; /* Interrupt */
72: int SDBASE = 0x0330; /* Port base */
73: int SDDMA = 5; /* Used for first party DMA */
74:
75: /*
76: * LUN --------++
77: * device macros Special-+ ||
78: * minor device bits are of the form: 76543210
79: * ||| ||
80: * SCSI ID--+++ ||
81: * Partition ----++
82: * Partition mapping:
83: *
84: * Description Special Bit Partition # Device Type
85: * ----------- ----------- ----------- ------ ----
86: * partition a 0 00 /dev/sd??a disk
87: * partition b 0 01 /dev/sd??b disk
88: * partition c 0 10 /dev/sd??c disk
89: * partition d 0 11 /dev/sd??d disk
90: * partition table 1 00 /dev/sd??x disk
91: * no rewind tape 1 01 /dev/sd??n tape
92: * UNALLOCATED 1 10 --- ????
93: * rewind tape device 1 11 /dev/sd?? tape
94: */
95: #define DRIVENO(minor) (((minor) >> 2) & 0x1F) /* SCSI ID + LUN */
96: #define SCSIID(minor) (((minor) >> 4) & 0x7) /* SCSI ID */
97: #define LUN(minor) (((minor) >> 2) & 0x3) /* Logical Unit Number */
98: #define PARTITION(minor) ((minor) & 0x3) /* Partition */
99: #define sdmkdev(maj, s, drv) makedev((maj), ((s)|((drv)<<2)))
100:
101: /*
102: * Driver configuration.
103: */
104: void sdload();
105: void sdunload();
106: void sdopen();
107: void sdclose();
108: void sdread();
109: void sdwrite();
110: int sdioctl();
111: void sdblock();
112: int sdwatch();
113: int nulldev();
114: int nonedev();
115:
116: CON sdcon = {
117: DFBLK|DFCHR, /* Flags */
118: SDMAJOR, /* Major index */
119: sdopen, /* Open */
120: sdclose, /* Close */
121: sdblock, /* Block */
122: sdread, /* Read */
123: sdwrite, /* Write */
124: sdioctl, /* Ioctl */
125: nulldev, /* Powerfail */
126: sdwatch, /* Timeout */
127: sdload, /* Load */
128: sdunload /* Unload */
129: };
130:
131: /*
132: * host adapter routines
133: */
134: int aha_load(); /* initialize host adapter, DMA */
135: void aha_unload(); /* shutdown the host adapter */
136: int aha_start(); /* see if there's work */
137: int aha_command();
138:
139: /*
140: * Partition Parameters - copied from disk.
141: *
142: * There are NPARTN positions for the user partitions in array PPARM,
143: * plus 1 additional position to span the entire drive.
144: * Array pparmp[] contains a pointer to a kalloc()'ed PPARM
145: * entry if the drive actually exists, is a disk drive and if someone
146: * has attmpted to read a partition table from the drive.
147: */
148: typedef struct fdisk_s PPARM[NPARTN + 1]; /* 4 partitions + whole drive */
149: static PPARM *pparmp[NDRIVE]; /* one per possible drive */
150: #define WHOLE_DRIVE NPARTN /* index for whole drive */
151: #define PNULL ((PPARM *)0)
152:
153: /*
154: * Per disk controller data.
155: * Only one host adapter; no more, no less.
156: */
157: static
158: scsi_work_t sd;
159:
160: static BUF dbuf; /* For raw I/O */
161: static int sw_active;
162:
163: /**
164: *
165: * void
166: * sdload() - load routine.
167: *
168: * Action: The controller is reset and the interrupt vector is grabbed.
169: * The drive characteristics are set up at this time.
170: */
171: static void
172: sdload()
173: {
174: FIFO *ffp;
175: typed_space *tp;
176: extern typed_space boot_gift;
177:
178: /*
179: * Initialize Drive Controller.
180: */
181: sw_active = 0;
182: if (aha_load(SDDMA, SDIRQ, SDBASE, &sd) < 0) {
183: u.u_error = ENXIO;
184: return;
185: }
186:
187: /*
188: * Set values for # of heads and # of sectors per track.
189: *
190: * AHA translation mode uses the same # of heads
191: * and the same # of sectors per track for all drives.
192: *
193: * If these values are already patched, leave them alone.
194: * Otherwise, look in the data area written by tboot.
195: * If nothing from tboot, use default values.
196: */
197: if (SD_HDS == 0 || SD_SPT == 0) {
198: printf("AHA - heads & spt not both patched");
199: SD_HDS = DEF_AHA_HDS;
200: SD_SPT = DEF_AHA_SPT;
201: if (F_NULL != (ffp = fifo_open(&boot_gift, 0))) {
202: if (T_NULL != (tp = fifo_read(ffp))) {
203: BIOS_DISK *bdp = (BIOS_DISK *)tp->ts_data;
204: if ((T_BIOS_DISK == tp->ts_type) &&
205: (n_atdr == bdp->dp_drive) ) {
206: printf(" got values from tboot");
207: SD_HDS = bdp->dp_heads;
208: SD_SPT = bdp->dp_sectors;
209: }
210: }
211: fifo_close(ffp);
212: }
213: }
214: printf(" SD_HDS=%d SD_SPT=%d\n", SD_HDS, SD_SPT);
215:
216: /* aha_device_info(); */ /* enable after this gets fixed */
217: }
218:
219: /**
220: *
221: * void
222: * sdunload() - unload routine.
223: */
224: static void
225: sdunload()
226: {
227: register int i;
228:
229: if (sw_active > 0)
230: printf("aha154x: sdunload() athough %d active\n", sw_active);
231: aha_unload(SDIRQ);
232: for (i = 0; i < NDRIVE; ++i)
233: if (pparmp[i] != PNULL)
234: kfree(pparmp[i]); /* free any partition tables */
235: }
236:
237: /*
238: * int
239: * sdgetpartitions(dev) - load partition table for specified drive
240: *
241: * - return 1 on success and 0 on failure
242: */
243: int sdgetpartitions(dev)
244: dev_t dev;
245: {
246: register int i;
247: scsi_cmd_t sc;
248: unsigned char *buffer;
249: struct fdisk_s *fdp;
250: int d = DRIVENO(minor(dev));
251:
252: pparmp[d] = kalloc(sizeof *pparmp[0]);
253: fdp = (struct fdisk_s *) pparmp[d]; /* point to first entry */
254: buffer = kalloc(36+1);
255: if (buffer == NULL || pparmp[d] == PNULL) {
256: printf("aha154x: out of kernel memory\n");
257: u.u_error = EKSPACE;
258: return 0;
259: }
260: kclear(pparmp[d], sizeof *pparmp[0]);
261: sc.unit = d;
262: sc.block = 0L;
263: sc.blklen = 0;
264:
265: sc.buffer = VTOP2(buffer, sds);
266: ++drvl[SDMAJOR].d_time;
267: #if 0
268: sc.cmd = ScmdINQUIRY;
269: sc.buflen = 36;
270: aha_command(&sc);
271: aha_command(&sc);
272: buffer[36] = 0;
273: printf("SCSI Disk %s", &buffer[8]);
274: #endif
275: sc.cmd = ScmdREADCAPACITY;
276: sc.buflen = 8;
277:
278: for(i = 0; i < sc.buflen; ++i)
279: buffer[i] = 0;
280: aha_command(&sc);
281: aha_command(&sc);
282: #if VERBOSE
283: printf("buffer =");
284: for(i = 0; i < sc.buflen; ++i)
285: printf(" %x", buffer[i]);
286: printf("\n");
287: #endif
288: sc.block = (buffer[0]<<8) | buffer[1];
289: sc.block <<= 16;
290: sc.block |= (buffer[2]<<8) | buffer[3];
291:
292: sc.blklen = (buffer[6]<<8) | buffer[7];
293: #if VERBOSE
294: printf("SCSI %D. blocks of size %d\n", sc.block, sc.blklen);
295: #endif
296: kfree(buffer);
297: fdp[WHOLE_DRIVE].p_size = sc.block;
298: --drvl[SDMAJOR].d_time;
299: return fdisk(sdmkdev(major(dev), SDEV, d), pparmp[d]);
300: }
301:
302: /**
303: *
304: * void
305: * sdopen(dev, mode)
306: * dev_t dev;
307: * int mode;
308: *
309: * Input: dev = disk device to be opened.
310: * mode = access mode [IPR,IPW, IPR+IPW].
311: *
312: * Action: Validate the minor device.
313: * Update the paritition table if necessary.
314: */
315: static void
316: sdopen(dev, mode)
317: register dev_t dev;
318: {
319: register int p; /* partition */
320: register int d; /* drive (SCSI ID + LUN) */
321: struct fdisk_s *fdp; /* one partition entry */
322:
323: if (minor(dev) & SDEV) {
324: if (PARTITION(minor(dev)) != 0) { /* tape device ? */
325: u.u_error = ENXIO; /* not yet! */
326: devmsg(dev, "No tape yet");
327: } else {
328: ++drvl[SDMAJOR].d_time;
329: ++sw_active;
330: }
331: return;
332: }
333:
334: d = DRIVENO(minor(dev));
335: p = PARTITION(minor(dev));
336:
337: /*
338: * If partition not defined read partition characteristics.
339: */
340: if (pparmp[d] == PNULL) /* no entry yet for this drive ? */
341: if (!sdgetpartitions(dev)) {
342: u.u_error = ENXIO;
343: return;
344: }
345: /*
346: * Ensure partition lies within drive boundaries and is non-zero size.
347: */
348: fdp = (struct fdisk_s *) pparmp[d];
349: if ((fdp[p].p_base+fdp[p].p_size) > fdp[WHOLE_DRIVE].p_size) {
350: u.u_error = EBADFMT;
351: } else if (fdp[p].p_size == 0) {
352: u.u_error = ENODEV;
353: } else {
354: ++drvl[SDMAJOR].d_time;
355: ++sw_active;
356: }
357: }
358:
359: void sdclose(dev)
360: {
361: --drvl[SDMAJOR].d_time;
362: --sw_active;
363: }
364:
365: /**
366: *
367: * void
368: * sdread(dev, iop) - write a block to the raw disk
369: * dev_t dev;
370: * IO * iop;
371: *
372: * Input: dev = disk device to be written to.
373: * iop = pointer to source I/O structure.
374: *
375: * Action: Invoke the common raw I/O processing code.
376: */
377: static void
378: sdread(dev, iop)
379: dev_t dev;
380: IO *iop;
381: {
382: ioreq(&dbuf, iop, dev, BREAD, BFRAW|BFBLK|BFIOC);
383: }
384:
385: /**
386: *
387: * void
388: * sdwrite(dev, iop) - write a block to the raw disk
389: * dev_t dev;
390: * IO * iop;
391: *
392: * Input: dev = disk device to be written to.
393: * iop = pointer to source I/O structure.
394: *
395: * Action: Invoke the common raw I/O processing code.
396: */
397: static void
398: sdwrite(dev, iop)
399: dev_t dev;
400: IO *iop;
401: {
402: ioreq(&dbuf, iop, dev, BWRITE, BFRAW|BFBLK|BFIOC);
403: }
404:
405: /**
406: *
407: * int
408: * sdioctl(dev, cmd, arg)
409: * dev_t dev;
410: * int cmd;
411: * char * vec;
412: *
413: * Input: dev = disk device to be operated on.
414: * cmd = input/output request to be performed.
415: * vec = (pointer to) optional argument.
416: *
417: * Action: Validate the minor device.
418: * Update the paritition table if necessary.
419: */
420: static int
421: sdioctl(dev, cmd, vec)
422: register dev_t dev;
423: int cmd;
424: char * vec;
425: {
426: int d;
427: hdparm_t hdparm;
428: struct fdisk_s *fdp;
429: int do_getpt = 0; /* 1 if need to call sdgetpartitions() */
430:
431: d = DRIVENO(minor(dev));
432:
433: /*
434: * Identify input/output request.
435: */
436: switch (cmd) {
437:
438: case HDGETA:
439: /*
440: * If haven't loaded partition table yet for this drive,
441: * try to do it now. Note sdgetpartitions() will fail
442: * if there is a new drive (e.g. no signature). But all
443: * we need is allocation of pparmp[d] and capacity read
444: * properly from the drive.
445: */
446: if (pparmp[d] == PNULL) {
447: do_getpt = 1; /* REALLY just want Read Capacity */
448: sdgetpartitions(dev);
449: if (pparmp[d] == NULL) {
450: u.u_error = ENXIO;
451: return -1;
452: }
453: }
454: fdp = (struct fdisk_s *) pparmp[d];
455: *(short *)&hdparm.landc[0] =
456: *(short *)&hdparm.ncyl[0] = fdp[WHOLE_DRIVE].p_size
457: / (SD_HDS * SD_SPT);
458: hdparm.nhead = SD_HDS;
459: hdparm.nspt = SD_SPT;
460: kucopy(&hdparm, vec, sizeof hdparm);
461: /*
462: * I know it's ugly. But it gets around startup Catch-22.
463: *
464: * The fdisk command needs HDGETA. HDGETA invokes
465: * sdgetpartitions(), but we want to call it again
466: * after the partition table has been created by the fdisk
467: * command.
468: */
469: if (do_getpt) {
470: kfree(pparmp[d]);
471: pparmp[d] = PNULL; /* force re-read of p. table */
472: }
473: return 0;
474: case HDSETA:
475: /*
476: * Set hard disk attributes.
477: */
478: fdp = (struct fdisk_s *) pparmp[d];
479: ukcopy(vec, &hdparm, sizeof hdparm);
480: SD_HDS = hdparm.nhead;
481: SD_SPT = hdparm.nspt;
482: fdp[WHOLE_DRIVE].p_size =
483: (long)(*(short *)&hdparm.ncyl[0])
484: * (long)SD_HDS * (long)SD_SPT;
485:
486: return 0;
487: case SCSI_HA_CMD:
488: return aha_ioctl(cmd, vec);
489: case SCSI_CMD:
490: return 0;
491: case SCSI_CMD_IN:
492: return 0;
493: case SCSI_CMD_OUT:
494: return 0;
495:
496: default:
497: u.u_error = EINVAL;
498: return -1;
499: }
500: }
501:
502: /**
503: *
504: * void
505: * sdblock(bp) - queue a block to the disk
506: *
507: * Input: bp = pointer to block to be queued.
508: *
509: * Action: Queue a block to the disk.
510: * Make sure that the transfer is within the disk partition.
511: */
512: static void
513: sdblock(bp)
514: register BUF *bp;
515: {
516: register scsi_work_t *sw;
517: register int s;
518: struct fdisk_s *fdp;
519:
520: int p = PARTITION(minor(bp->b_dev));
521: int drv = DRIVENO(minor(bp->b_dev));
522:
523: if (minor(bp->b_dev) & SDEV)
524: p = WHOLE_DRIVE;
525: bp->b_resid = bp->b_count;
526:
527: fdp = (struct fdisk_s *) pparmp[drv];
528:
529: /*
530: * Range check disk region.
531: */
532: if (pparmp[drv] == PNULL) {
533: if (p == WHOLE_DRIVE) {
534: #if 0
535: /* Why did we only allow people to access the first block of WHOLE_DRIVE?
536: in cases where there was not a valid partition table? */
537: if ((bp->b_bno != 0) || (bp->b_count != BSIZE)) {
538: bp->b_flag |= BFERR;
539: bdone(bp);
540: return;
541: }
542: #endif
543: } else {
544: printf("aha154x: no partition table\n");
545: bp->b_flag |= BFERR;
546: bdone(bp);
547: return;
548: }
549: } else if ((bp->b_bno + (bp->b_count/BSIZE)) > fdp[p].p_size) {
550: bp->b_flag |= BFERR;
551: bdone(bp);
552: return;
553: }
554:
555: bp->b_actf = NULL;
556: sw = (scsi_work_t *)kalloc(sizeof(*sw));
557: if (sw == (scsi_work_t *)0) {
558: printf("aha154x: out of kernel memory\n");
559: bp->b_flag |= BFERR;
560: bdone(bp);
561: return;
562: }
563: sw->sw_bp = bp;
564: sw->sw_drv = drv;
565: sw->sw_type = 0;
566: if (p != WHOLE_DRIVE)
567: sw->sw_bno = fdp[p].p_base + bp->b_bno;
568: else
569: sw->sw_bno = bp->b_bno;
570: sw->sw_retry = 1;
571:
572: #if VERBOSE
573: printf("sdblock: drv %x bno %x:%x bp=%x, flag = %o\n",
574: drv, (long)sw->sw_bno, bp, bp->b_flag);
575: #endif
576:
577: s = sphi();
578: if (sd.sw_actf == NULL)
579: sd.sw_actf = sw;
580: else
581: sd.sw_actl->sw_actf = sw;
582: sd.sw_actl = sw;
583: spl(s);
584:
585: aha_start();
586: }
587:
588: sdwatch()
589: {
590: register i;
591:
592: if (i = aha_start())
593: #if VERBOSE
594: printf("sdwatch: started %d actions\n", i);
595: #else
596: ;
597: #endif
598: if (i = aha_completed())
599: #if VERBOSE
600: printf("sdwatch: completed %d actions\n", i);
601: #else
602: ;
603: #endif
604: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.