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