![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to as.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / i386 / isa|
Return to as.c CVS log | Up to [Net/2] / Net2 / arch / i386 / isa |
1.1 root 1: /*
2: * Adaptech 1542 SCSI driver for 386bsd
3: *
4: * Pace Willisson [email protected] March 28, 1992
5: *
6: * Placed in the public domain with NO WARRANTIES, not even the
7: * implied warranties for MERCHANTABILITY or FITNESS FOR A
8: * PARTICULAR PURPOSE.
9: *
10: *
11: * This is a very early version - use with care.
12: *
13: * Here is the config info:
14: *
15: * controller as0 at isa? port 0x330 bio irq 11 drq 5 vector asintr
16: * disk dk6 at as0 drive 0
17: *
18: * Also, don't forget to update sys/i386/conf/files.i386.
19: *
20: * So far, used with:
21: *
22: * CDC WREN 5 600 Megabyte magnetic disk
23: * EXABYTE EXB-8200 8mm tape drive
24: * SONY CDU-541 cdrom
25: *
26: * The the tape stuff still needs a lot of working concerning
27: * file marks, end of tape handling and rewinding, but I have
28: * extracted tar tapes to a file system mounted on the CDC disk.
29: *
30: * minor number bits:
31: *
32: * 7 6 5 4 3 2 1 0
33: * +-----+ partition number
34: * +-----+ scsi target number
35: * +--+ unused (should be 0)
36: *
37: * For tape drives, set the partition number to 0 for regular,
38: * 1 for no rewind.
39: *
40: * Only supports LUN 0.
41: *
42: * To use with a read-write disk, first use diskpart to create
43: * a disktab entry, then use disklabel. Since I don't have
44: * the boot programs done yet, I faked it with:
45: *
46: * # cd /usr/mdec
47: * # cp wdboot asboot
48: * # cp bootwd bootas
49: *
50: * Now you can run disklabel, newfs, etc.
51: *
52: * Please send patches and names other perpherials that work to
53: * [email protected]. If you have trouble that you can't fix, please
54: * wait for the next release before contacting me.
55: */
56:
57: #include "as.h"
58: #if NAS > 0
59:
60: #include "param.h"
61: #include "dkbad.h"
62: #include "systm.h"
63: #include "conf.h"
64: #include "file.h"
65: #include "stat.h"
66: #include "ioctl.h"
67: #include "disklabel.h"
68: #include "buf.h"
69: #include "uio.h"
70: #include "i386/isa/isa_device.h"
71: #include "i386/isa/icu.h"
72: #include "syslog.h"
73: #include "vm/vm.h"
74: #include "kernel.h"
75:
76: #include "asreg.h"
77:
78: int asstrategy ();
79: int asabort ();
80: extern int hz;
81:
82: int asverbose = 0;
83:
84:
85: /* target id 7 is the controller itself */
86: #define NTARGETS 7
87:
88: struct mailbox_entry mailboxes[NTARGETS * 2] = {0};
89:
90: #define b_cylin b_resid /* fake cylinder number for disksort */
91:
92: /* maximum scatter list size for Adaptech controller */
93: #define NSCATTER 17
94:
95: /* this array must reside in contiguous physical memory */
96: struct asinfo {
97: dev_t dev;
98: struct buf requests;
99: struct mailbox_entry *mailbox;
100: int active;
101: struct ccb ccb;
102: unsigned int ccb_phys;
103: char scatter_list[NSCATTER * 6];
104:
105: struct disklabel label;
106: struct dos_partition dospart[NDOSPART];
107: int have_label;
108:
109: int scsi_lock;
110: struct buf *scsi_bp;
111: int scsi_cdb_len;
112: unsigned char scsi_cdb[MAXCDB];
113:
114: int tape; /* sequential */
115: int disk; /* nonsequential */
116: int read_only; /* CDROM */
117: int removable; /* unsupported and tested */
118: char vendor[9];
119: char model[17];
120: char revision[5];
121: int bs; /* device block size */
122:
123: int open_lock;
124: int open;
125: int units_open;
126:
127: int wlabel;
128:
129: int retry_count;
130: int start_time;
131: int restart_pending;
132:
133: } asinfo[NTARGETS] = {0};
134:
135: #define dev_part(dev) (minor (dev) & 7)
136: #define dev_target(dev) ((minor (dev) >> 3) & 7)
137: #define dev_rewind(dev) ((minor (dev) & 1) == 0)
138:
139: #define makeasdev(major, target, part) \
140: makedev ((major), ((target) << 3) | (part))
141:
142: int as_port;
143:
144: int asprobe(struct isa_device *), asattach(struct isa_device *),
145: asintr(dev_t);
146:
147: struct isa_driver asdriver = {
148: asprobe, asattach, "as",
149: };
150:
151: int
152: asprobe (struct isa_device *dvp)
153: {
154: int val;
155:
156: as_port = dvp->id_iobase;
157:
158: outb (as_port + AS_CONTROL, AS_CONTROL_SRST);
159: DELAY (30000);
160: val = inb (as_port + AS_STATUS);
161:
162: if (val == (AS_STATUS_INIT | AS_STATUS_IDLE))
163: return (1);
164: as_port = 0;
165: return (0);
166: }
167:
168: asattach (struct isa_device *dvp)
169: {
170: int i;
171: unsigned int physaddr;
172: int val;
173: int s;
174:
175: for (i = 0; i < NTARGETS; i++) {
176: asinfo[i].mailbox = &mailboxes[i];
177: asinfo[i].ccb_phys = vtophys (&asinfo[i].ccb);
178: }
179:
180: isa_dmacascade(dvp->id_drq);
181:
182: physaddr = vtophys (mailboxes);
183:
184: s = splbio ();
185: if (as_put_byte (AS_CMD_MAILBOX_INIT) < 0
186: || as_put_byte (NTARGETS) < 0
187: || as_put_byte (physaddr >> 16) < 0
188: || as_put_byte (physaddr >> 8) < 0
189: || as_put_byte (physaddr) < 0) {
190: splx (s);
191: return (EIO);
192: }
193: splx (s);
194: DELAY (300);
195: val = inb (as_port + AS_STATUS);
196:
197: if (val & AS_STATUS_INIT)
198: printf ("as: mailbox init error: 0x%x\n", val);
199: }
200:
201: int
202: ascmd (as, bp, direction, count, retrycount)
203: struct asinfo *as;
204: struct buf *bp;
205: int direction;
206: int count;
207: int retrycount;
208: {
209: int err;
210:
211: do {
212: if (asverbose)
213: printf ("ascmd ");
214: bp->b_bcount = count;
215: bp->b_error = 0;
216: bp->b_flags &= ~(B_READ | B_ERROR | B_DONE);
217: if (direction == B_READ)
218: bp->b_flags |= B_READ;
219:
220: bp->b_dev = as->dev;
221: bp->b_blkno = 0;
222:
223: as->scsi_bp = bp;
224: /* scsi_cdb, scsi_cdb_len set up by caller */
225:
226: asstrategy (bp);
227: err = biowait (bp);
228: as->scsi_bp = NULL;
229:
230: } while (err && --retrycount);
231:
232: return (err);
233: }
234:
235: asstring (dest, src, size)
236: char *dest;
237: char *src;
238: int size;
239: {
240: size--;
241: bcopy (src, dest, size);
242: while (size > 0 && dest[size - 1] == ' ')
243: size--;
244: dest[size] = 0;
245: }
246:
247: asopen (dev, flag)
248: dev_t dev;
249: int flag;
250: {
251: struct asinfo *as;
252: unsigned int physaddr;
253: struct buf *bp = NULL;
254: int retry;
255: unsigned char *cdb;
256: char *p, *q;
257: int n;
258: int error;
259: char vendor[9];
260: char model[17];
261: int disksize;
262:
263: if (as_port == 0 || dev_target (dev) >= NTARGETS)
264: return (ENXIO);
265:
266: as = &asinfo[dev_target (dev)];
267: as->dev = dev;
268:
269: while (as->open_lock)
270: if (error = tsleep ((caddr_t)as, PZERO|PCATCH, "scsiopen", 0))
271: return (error);
272:
273: if (as->open) {
274: if (as->tape)
275: return (EBUSY);
276:
277: if (as->have_label == 0 && dev_part (dev) != 3)
278: return (ENXIO);
279:
280: as->units_open |= 1 << dev_part (dev);
281: return (0);
282: }
283:
284: as->open_lock = 1;
285:
286: /* it seems like we might have to block here in case someone
287: * opens the device just after someone else closes
288: */
289: while (as->scsi_lock)
290: if (error = tsleep ((caddr_t)as, PZERO|PCATCH, "scsicmd", 0))
291: return (error);
292:
293: as->scsi_lock = 1;
294:
295: error = EIO;
296:
297: as->have_label = 0;
298: as->tape = 0;
299: as->disk = 0;
300: as->read_only = 0;
301: as->removable = 0;
302: bcopy(as->vendor, vendor, sizeof(vendor));
303: bcopy(as->model, model, sizeof(model));
304: as->vendor[0] = 0;
305: as->model[0] = 0;
306: as->revision[0] = 0;
307:
308: bp = geteblk (DEV_BSIZE);
309:
310: if (asverbose) {
311: printf ("openbuf = 0x%x phys 0x%x\n",
312: bp->b_un.b_addr, vtophys (bp->b_un.b_addr));
313: printf ("mailboxes = 0x%x\n", mailboxes);
314: }
315:
316: /* first, find out if a device is present, and just what it is */
317: as->scsi_cdb_len = 6;
318: cdb = as->scsi_cdb;
319: bzero (cdb, 6);
320: cdb[0] = 0x12; /* INQUIRY */
321: cdb[4] = 255; /* allocation length */
322: if (error = ascmd (as, bp, B_READ, DEV_BSIZE, 2))
323: /* does not respond to inquiry, obviously not CCS, give up */
324: goto done;
325:
326:
327: /* blather on console about it */
328: p = bp->b_un.b_addr;
329: if (asverbose) {
330: printf ("inquiry: ");
331: for (n = 0; n < 20; n++)
332: printf ("%x ", p[n] & 0xff);
333: printf ("\n");
334: for (n = 0; n < 40; n++) {
335: if (p[n] >= ' ' && p[n] < 0177)
336: printf ("%c", p[n]);
337: else
338: printf (".");
339: }
340: printf ("\n");
341: }
342:
343: switch (p[0]) {
344: case 0: /* normal disk */
345: case 4: /* write once disk */
346: as->disk = 1;
347: break;
348: case 5: /* read only disk */
349: as->read_only = 1;
350: as->disk = 1;
351: break;
352: case 1: /* tape */
353: as->tape = 1;
354: break;
355: case 0x7f:
356: printf ("logical unit not present\n");
357: goto done;
358: default:
359: printf ("unknown peripheral device type: 0x%x\n", p[0]);
360: goto done;
361: }
362:
363: as->removable = (p[1] & 0x80) ? 1 : 0;
364:
365: n = p[4] & 0xff;
366: if (n >= 31) {
367: asstring (as->vendor, p + 8, sizeof as->vendor);
368: asstring (as->model, p + 16, sizeof as->model);
369: asstring (as->revision, p + 32, sizeof as->revision);
370: }
371:
372: if(bcmp(as->vendor,vendor, sizeof(vendor)) != 0 ||
373: bcmp(as->model,model, sizeof(model)) != 0) {
374: printf("as%d: attached tgt %d <%s %s %s> ", 0, dev_target(dev),
375: as->vendor, as->model, as->revision);
376: if (as->read_only) printf("readonly ");
377: if (!as->removable) printf("winchester ");
378: if (as->tape) printf("tape ");
379: if (as->disk) printf("disk ");
380: printf("\n");
381: }
382:
383: /* probe for desired block size */
384:
385: /* assume default of 512, except if CDROM (2048) */
386: if (as->read_only)
387: as->bs = 2048;
388: else
389: as->bs = 512;
390:
391: bzero(cdb, 6);
392: cdb[0] = 0x1A; /* SCSI_MDSENSE */
393: cdb[4] = 255;
394: if (as->tape && ascmd (as, bp, B_READ, 12, 2) == 0) {
395: int minblk, maxblk;
396:
397: #ifdef notdef
398: /* blather about device more */
399: if(bcmp(as->vendor,vendor, sizeof(vendor)) != 0 ||
400: bcmp(as->model,model, sizeof(model)) != 0) {
401: p = bp->b_un.b_addr;
402: printf("as%d: data len %d medium %d speed/bufmode 0x%x desc len %d\n",
403: dev_target(dev), p[0], p[1], p[2], p[3]);
404: printf("as%d: density %d nblocks %d block len %d\n",
405: dev_target(dev), p[4],
406: (long)p[5]*65536+p[6]*256+p[7],
407: (long)p[9]*65536+p[10]*256+p[11]);
408: }
409: #endif
410:
411: /* obtain possible block sizes */
412: bzero(cdb, 6);
413: cdb[0] = 0x05; /* SCSI_RDLIMITS; */
414: if (ascmd (as, bp, B_READ, 12, 2) == 0) {
415: p = bp->b_un.b_addr;
416: minblk = p[4]*256+p[5];
417: maxblk = p[1]*65536+p[2]*256+p[3];
418: #ifdef notdef
419: if(bcmp(as->vendor,vendor, sizeof(vendor)) != 0 ||
420: bcmp(as->model,model, sizeof(model)) != 0) {
421: printf("as%d: limits: min block len %ld max block len %ld\n",
422: dev_target(dev), minblk, maxblk);
423: }
424: #endif
425: if ( minblk == maxblk )
426: as->bs = minblk;
427: else if (as->tape)
428: as->bs = 1;
429: }
430: }
431:
432: if (as->tape && dev_part(dev)) {
433: error = EIO;
434: goto done;
435: }
436:
437: as->scsi_cdb_len = 10;
438: bzero(cdb, 10);
439: cdb[0] = 0x25; /* SCSI_READCAPACITY */
440: disksize = 0;
441: if (as->disk && ascmd (as, bp, B_READ, 12, 2) == 0) {
442: p = bp->b_un.b_addr;
443: disksize = ntohl(*(long *)p);
444: as->bs = ntohl(*(long *)(p+4));
445:
446: }
447:
448: if(asverbose)
449: printf("block size %d disksize %d ", as->bs, disksize);
450:
451:
452: /* for standard disk, negotiate block size */
453: if (as->read_only == 0 && as->disk) {
454: /* do mode select to set the logical block size */
455: as->scsi_cdb_len = 6;
456: cdb = as->scsi_cdb;
457: bzero (cdb, 6);
458: cdb[0] = 0x15; /* MODE SELECT */
459: cdb[4] = 12; /* parameter list length */
460:
461: p = bp->b_un.b_addr;
462: bzero (p, 12);
463: p[3] = 8; /* block descriptor length */
464: n = as->bs == 1 ? 0 : as->bs;
465: p[9] = n >> 16;
466: p[10] = n >> 8;
467: p[11] = n;
468:
469: (void) ascmd (as, bp, B_WRITE, 12, 2);
470: }
471:
472: /* device online and ready? */
473: as->scsi_cdb_len = 6;
474: bzero(cdb, 6);
475: cdb[0] = 0x00; /* SCSI_UNITRDY */
476: if (error = ascmd (as, bp, B_READ, 12, 2)) {
477: printf("as%d: drive not online\n", dev_target(dev));
478: goto done;
479: }
480:
481: if (as->disk && as->read_only == 0) {
482: /* read disk label */
483: bzero ((caddr_t)&as->label, sizeof as->label);
484: as->label.d_secsize = as->bs;
485: as->label.d_secpercyl = 64*32;
486: as->label.d_type = DTYPE_SCSI;
487:
488:
489: /* read label using "d" partition */
490: if ((p = readdisklabel (
491: makeasdev (major (dev), dev_target (dev), 3),
492: asstrategy, &as->label, as->dospart, 0, 0)) == NULL){
493: as->have_label = 1;
494: } else {
495: if (disksize) {
496: as->label.d_subtype = DSTYPE_GEOMETRY;
497: as->label.d_npartitions = 3;
498: /* partition 0 holds bios, partition 1 ESDI */
499: as->label.d_partitions[2].p_size = disksize;
500: as->label.d_partitions[2].p_offset = 0;
501: }
502: if (asverbose || dev_part (dev) != 3)
503: printf ("error reading label: %s\n", p);
504: if (dev_part (dev) != 3) {
505: error = EINVAL;
506: goto done;
507: }
508: }
509: }
510:
511: /* may want to set logical block size here ? */
512: error = 0;
513:
514: done:
515: if (bp) {
516: bp->b_flags |= B_INVAL | B_AGE;
517: brelse (bp);
518: }
519:
520: if (error == 0)
521: as->open = 1;
522:
523: as->open_lock = 0;
524: as->scsi_lock = 0;
525: wakeup (as);
526:
527: return (error);
528: }
529:
530: asclose (dev, flag)
531: dev_t dev;
532: {
533: struct asinfo *as;
534: int error = 0;
535: unsigned char *cdb;
536: struct buf *bp;
537: int n;
538:
539: as = &asinfo[dev_target (dev)];
540:
541: while (as->open_lock)
542: if (error = tsleep ((caddr_t)as, PZERO|PCATCH, "scsiclose", 0))
543: return (error);
544:
545: as->open_lock = 1;
546:
547: if (as->tape) {
548: while (as->scsi_lock)
549: if (error = tsleep ((caddr_t)as, PZERO|PCATCH,
550: "scsicmd", 0))
551: return (error);
552:
553: as->scsi_lock = 1;
554:
555: bp = geteblk (DEV_BSIZE);
556:
557: if (0 && (flag & FWRITE) != 0) {
558: /* presume user will use tape again */
559: as->scsi_cdb_len = 6;
560: cdb = as->scsi_cdb;
561: bzero (cdb, 6);
562: cdb[0] = 0x10; /* write filemarks */
563: cdb[4] = 1; /* one of them */
564: error = ascmd (as, bp, B_READ, 0, 1);
565: }
566: if (dev_rewind (dev) || error) {
567: if ( error == 0 && (flag & FWRITE) != 0) {
568: /* presumption error correction */
569: as->scsi_cdb_len = 6;
570: cdb = as->scsi_cdb;
571: bzero (cdb, 6);
572: cdb[0] = 0x10; /* write filemarks */
573: cdb[4] = 1; /* one of them */
574: error |= ascmd (as, bp, B_READ, 0, 1);
575: }
576: as->scsi_cdb_len = 6;
577: cdb = as->scsi_cdb;
578: bzero (cdb, 6);
579: cdb[0] = 0x1; /* rewind */
580: cdb[1] = 1; /* don't wait until done */
581: error |= ascmd (as, bp, B_READ, 0, 1);
582: }
583: #ifdef notdef
584: } else {
585: cdb[0] = 0x11; /* backspace */
586: cdb[1] = 1; /* look at filemarks (instead of blocks) */
587: n = -1;
588: cdb[2] = n >> 16;
589: cdb[3] = n >> 8;
590: cdb[4] = n;
591: error = ascmd (as, bp, B_READ, 0, 1);
592: }
593: #endif
594:
595: bp->b_flags |= B_INVAL | B_AGE;
596: brelse (bp);
597:
598: as->scsi_lock = 0;
599: }
600:
601: as->units_open &= ~(1 << dev_part (dev));
602:
603: if (as->units_open == 0)
604: as->open = 0;
605:
606: as->open_lock = 0;
607:
608: wakeup (as);
609:
610: return (error);
611: }
612:
613: int
614: asioctl (dev, cmd, addr, flag)
615: dev_t dev;
616: int cmd;
617: caddr_t addr;
618: int flag;
619: {
620: struct scsicmd *cmdp;
621: struct asinfo *as;
622: int ccblen;
623: struct buf *bp;
624: int error = 0;
625: int direction;
626: struct disklabel *dl;
627: int old_wlabel;
628:
629: as = &asinfo[dev_target (dev)];
630:
631: switch (cmd) {
632: case DIOCGDINFO:
633: *(struct disklabel *)addr = as->label;
634: break;
635:
636: case DIOCSDINFO:
637: if ((flag & FWRITE) == 0) {
638: error = EBADF;
639: break;
640: }
641: dl = (struct disklabel *)addr;
642: if (error = setdisklabel(&as->label, dl, 0, as->dospart))
643: break;
644: as->have_label = 1;
645: break;
646:
647: case DIOCWLABEL:
648: if ((flag & FWRITE) == 0) {
649: error = EBADF;
650: break;
651: }
652: as->wlabel = *(int *)addr;
653: break;
654:
655: case DIOCWDINFO:
656: if ((flag & FWRITE) == 0) {
657: error = EBADF;
658: break;
659: }
660:
661: dl = (struct disklabel *)addr;
662:
663: if (error = setdisklabel (&as->label, dl, 0, as->dospart))
664: break;
665:
666: as->have_label = 1;
667:
668: old_wlabel = as->wlabel;
669: as->wlabel = 1;
670: error = writedisklabel(dev, asstrategy, &as->label,
671: as->dospart);
672: as->wlabel = old_wlabel;
673: break;
674:
675: case SCSICMD:
676: cmdp = (struct scsicmd *)addr;
677:
678: /* limited by max sizeof of geteblk */
679: if (cmdp->datalen >= 8192
680: || cmdp->cdblen >= MAXCDB) {
681: error = EINVAL;
682: break;
683: }
684:
685: ccblen = cmdp->ccblen;
686: if (ccblen > sizeof (struct ccb))
687: ccblen = sizeof (struct ccb);
688:
689: while (as->scsi_lock)
690: if (error = tsleep ((caddr_t)as, PZERO|PCATCH,
691: "scsicmd", 0))
692: break;
693:
694: as->scsi_lock = 1;
695:
696: bp = geteblk (cmdp->datalen);
697:
698: as->scsi_cdb_len = cmdp->cdblen;
699: if (error = copyin (cmdp->cdb, as->scsi_cdb, cmdp->cdblen))
700: goto done;
701:
702: direction = cmdp->readflag ? B_READ : B_WRITE;
703:
704: if (direction == B_WRITE)
705: if (error = copyin (cmdp->data,
706: bp->b_un.b_addr, cmdp->datalen))
707: goto done;
708:
709: ascmd (as, bp, direction, cmdp->datalen, 1);
710:
711: copyout (&as->ccb, cmdp->ccb, ccblen);
712: if (direction == B_READ)
713: copyout (bp->b_un.b_addr, cmdp->data, cmdp->datalen);
714: done:
715: bp->b_flags |= B_INVAL | B_AGE;
716: brelse (bp);
717: as->scsi_lock = 0;
718: wakeup (as);
719: break;
720: default:
721: error = ENOTTY;
722: break;
723: }
724: return (error);
725: }
726:
727: int
728: asstrategy (bp)
729: struct buf *bp;
730: {
731: struct asinfo *as;
732: int s;
733:
734: if (asverbose)
735: printf ("asstrategy %d %d ", bp->b_blkno, bp->b_bcount);
736: s = splbio ();
737:
738: as = &asinfo[dev_target (bp->b_dev)];
739:
740: if (as->tape) {
741: bp->av_forw = NULL;
742: if (as->requests.b_actf)
743: as->requests.b_actl->av_forw = bp;
744: else
745: as->requests.b_actf = bp;
746: as->requests.b_actl = bp;
747: } else {
748: if (bp != as->scsi_bp
749: && as->have_label == 0
750: && dev_part (bp->b_dev) != 3)
751: goto bad;
752:
753: bp->b_cylin = bp->b_blkno;
754: disksort (&as->requests, bp);
755: }
756:
757: if (as->active == 0)
758: asstart (as);
759:
760: splx (s);
761: return;
762:
763: bad:
764: bp->b_flags |= B_ERROR;
765: biodone (bp);
766: }
767:
768: asrestart (as)
769: struct asinfo *as;
770: {
771: int s;
772: s = splbio ();
773: as->restart_pending = 0;
774: as->retry_count++;
775: asstart (as);
776: splx (s);
777: }
778:
779: asstart (as)
780: struct asinfo *as;
781: {
782: struct buf *bp;
783: int blknum;
784: unsigned int physaddr;
785: struct ccb *ccb;
786: unsigned char *cdb;
787: int target;
788: char *p;
789: int n;
790: char *sp;
791: int nscatter;
792: int thistime;
793: int nbytes;
794: struct partition *part;
795: int blkno;
796: int nblocks;
797: int total;
798: int bs = as->bs;
799:
800:
801: if (as->restart_pending) {
802: as->restart_pending = 0;
803: untimeout (asrestart, as);
804: }
805:
806: again:
807: if ((bp = as->requests.b_actf) == NULL)
808: return;
809:
810: bp->b_error = 0;
811:
812: if (asverbose)
813: printf ("asstart %x ", bp);
814:
815: if (as->mailbox->cmd != 0) {
816: /* this can't happen, unless the card flakes */
817: printf ("asstart: mailbox not available\n");
818: bp->b_error = EIO;
819: goto bad;
820: }
821:
822: if (as->retry_count == 0) {
823: as->start_time = time.tv_sec;
824: } else {
825: if (time.tv_sec - as->start_time > 60) {
826: printf ("as: command timed out\n");
827: bp->b_error = EIO;
828: goto done;
829: }
830: }
831:
832: if (bp != as->scsi_bp) {
833: if (bp->b_bcount == 0)
834: goto done;
835:
836: if ((bp->b_bcount % bs) != 0) {
837: printf("as: partial block read\n");
838: bp->b_error = EIO;
839: goto bad;
840: }
841: }
842:
843: if (bp != as->scsi_bp) {
844:
845: blkno = bp->b_blkno;
846: nblocks = bp->b_bcount / bs;
847:
848: if (as->have_label && dev_part(bp->b_dev) != 3) {
849: part = &as->label.d_partitions[dev_part (bp->b_dev)];
850:
851: if (blkno > part->p_size) {
852: bp->b_error = EINVAL;
853: goto bad;
854: }
855: if (blkno == part->p_size) {
856: bp->b_resid = bp->b_bcount;
857: goto done;
858: }
859:
860: if (blkno + nblocks >= part->p_size)
861: nblocks = part->p_size - blkno;
862:
863: blkno += part->p_offset;
864: } else
865: blkno = (blkno * DEV_BSIZE)/bs;
866: if(asverbose)
867: printf("trans %d ", blkno);
868: if (nblocks > 255)
869: nblocks = 255;
870: total = nblocks * bs;
871: if(asverbose)
872: printf("total %d nblocks %d ", total, nblocks);
873: /*bp->b_bcount = total; /* XXX partial tape block read - wrong */
874: } else {
875: #ifdef nomore
876: if (as->fixed == 0) {
877: total = bp->b_bcount;
878: } else {
879: total = bp->b_bcount;
880: blkno = bp->b_blkno;
881: nblocks = bp->b_bcount / as->fixed;
882: }
883: #else
884: total = bp->b_bcount;
885: #endif
886: }
887:
888: p = bp->b_un.b_addr;
889: n = 0;
890: sp = as->scatter_list;
891: nscatter = 0;
892: while (n < total && nscatter < NSCATTER) {
893: thistime = page_size - ((vm_offset_t)p - trunc_page (p));
894:
895: if (n + thistime > total)
896: thistime = total - n;
897:
898: physaddr = vtophys (p);
899:
900: if (asverbose)
901: printf ("%d bytes to %x (%x)\n",
902: thistime, p, physaddr);
903: sp[0] = thistime >> 16;
904: sp[1] = thistime >> 8;
905: sp[2] = thistime;
906: sp[3] = physaddr >> 16;
907: sp[4] = physaddr >> 8;
908: sp[5] = physaddr;
909:
910: p += thistime;
911: n += thistime;
912: sp += 6;
913: nscatter++;
914: }
915:
916: if (nscatter == NSCATTER) {
917: printf("out of range, cannot happen?");
918: bp->b_error = ENXIO;
919: goto bad;
920: }
921:
922: ccb = &as->ccb;
923:
924: /* this only needed to make debugging easier */
925: bzero ((caddr_t)ccb, sizeof *ccb);
926:
927: if (nscatter)
928: ccb->ccb_opcode = 4; /* scatter cmd, return resid */
929: else
930: ccb->ccb_opcode = 3;
931: target = dev_target (bp->b_dev);
932: ccb->ccb_addr_and_control = target << 5;
933: if (bp->b_bcount != 0)
934: ccb->ccb_addr_and_control |= (bp->b_flags & B_READ) ? 8 : 0x10;
935: else
936: ccb->ccb_addr_and_control |= 0x18;
937:
938: nbytes = nscatter * 6;
939: ccb->ccb_data_len_msb = nbytes >> 16;
940: ccb->ccb_data_len_mid = nbytes >> 8;
941: ccb->ccb_data_len_lsb = nbytes;
942:
943: ccb->ccb_requst_sense_allocation_len = MAXSENSE;
944:
945: physaddr = vtophys (as->scatter_list);
946: ccb->ccb_data_ptr_msb = physaddr >> 16;
947: ccb->ccb_data_ptr_mid = physaddr >> 8;
948: ccb->ccb_data_ptr_lsb = physaddr;
949:
950: ccb->ccb_link_msb = 0;
951: ccb->ccb_link_mid = 0;
952: ccb->ccb_link_lsb = 0;
953: ccb->ccb_link_id = 0;
954: ccb->ccb_host_status = 0;
955: ccb->ccb_target_status = 0;
956: ccb->ccb_zero1 = 0;
957: ccb->ccb_zero2 = 0;
958:
959: cdb = ccb->ccb_cdb;
960: if (bp == as->scsi_bp) {
961: ccb->ccb_scsi_command_len = as->scsi_cdb_len;
962: bcopy (as->scsi_cdb, cdb, as->scsi_cdb_len);
963: } else if (as->tape) {
964: ccb->ccb_scsi_command_len = 6;
965: cdb[0] = (bp->b_flags & B_READ) ? 8 : 0xa;
966: if (as->bs == 1) {
967: cdb[1] = 0; /* logical unit 0, variable block size */
968: cdb[2] = bp->b_bcount >> 16;
969: cdb[3] = bp->b_bcount >> 8;
970: cdb[4] = bp->b_bcount;
971: } else {
972: cdb[1] = 1; /* fixed block size */
973: cdb[2] = nblocks >> 16;
974: cdb[3] = nblocks >> 8;
975: cdb[4] = nblocks;
976: }
977: cdb[5] = 0; /* control byte (used in linking) */
978: } else {
979: ccb->ccb_scsi_command_len = 10;
980: cdb[0] = (bp->b_flags & B_READ) ? 0x28 : 0x2a;
981: cdb[1] = 0;
982: *(long *) (cdb+2) = htonl(blkno);
983: *(short *) (cdb+7) = htons(nblocks);
984: cdb[9] = 0; /* control byte (used in linking) */
985: }
986:
987: #ifdef notdef
988: if (asverbose) {
989: printf ("ccb: ");
990: for (n = 0; n < 48; n++)
991: printf ("%02x ", ((unsigned char *)ccb)[n]);
992: printf ("\n");
993: }
994: #endif
995:
996: physaddr = vtophys (ccb);
997: as->mailbox->msb = physaddr >> 16;
998: as->mailbox->mid = physaddr >> 8;
999: as->mailbox->lsb = physaddr;
1000: as->mailbox->cmd = 1;
1001:
1002: /* tell controller to look in its mailbox */
1003: as_put_byte (AS_CMD_START_SCSI_COMMAND);
1004: as->active = 1;
1005: timeout (asabort, as, hz * 60 * 2);
1006: return;
1007:
1008: bad:
1009: bp->b_flags |= B_ERROR;
1010: done:
1011: asdone (as, 0);
1012: goto again;
1013: }
1014:
1015: asabort (as)
1016: struct asinfo *as;
1017: {
1018: int s;
1019: int physaddr;
1020: struct buf *bp;
1021:
1022: s = splbio ();
1023: if (as->active) {
1024: printf ("asabort %d\n", as - asinfo);
1025: physaddr = vtophys (&as->ccb);
1026: as->mailbox->msb = physaddr >> 16;
1027: as->mailbox->mid = physaddr >> 8;
1028: as->mailbox->lsb = physaddr;
1029: as->mailbox->cmd = 2;
1030: as_put_byte (AS_CMD_START_SCSI_COMMAND);
1031:
1032: as->active = 0;
1033: bp = as->requests.b_actf;
1034: if (bp) {
1035: bp->b_flags |= B_ERROR;
1036: asdone (as, 1);
1037: }
1038: }
1039: splx (s);
1040: }
1041:
1042: asintr (dev_t dev)
1043: {
1044: int didwork;
1045: int i, j;
1046: struct mailbox_entry *mp;
1047: unsigned int physaddr;
1048: int val;
1049:
1050: outb (as_port + AS_CONTROL, AS_CONTROL_IRST);
1051: #ifdef notdef
1052: if (asverbose)
1053: printf ("asintr %x ", cpl);
1054: #endif
1055: again:
1056: didwork = 0;
1057: for (i = NTARGETS; i < NTARGETS * 2; i++) {
1058: mp = &mailboxes[i];
1059:
1060: if ((val = mp->cmd) == 0)
1061: continue;
1062:
1063: didwork = 1;
1064:
1065: physaddr = (mp->msb << 16)
1066: | (mp->mid << 8)
1067: | mp->lsb;
1068:
1069: for (j = 0; j < NTARGETS; j++) {
1070: if (asinfo[j].ccb_phys == physaddr) {
1071: mp->cmd = 0;
1072: asintr1 (&asinfo[j], val);
1073: break;
1074: }
1075: }
1076: if (j == NTARGETS) {
1077: printf ("as: unknown mailbox paddr 0x%x\n", physaddr);
1078: mp->cmd = 0;
1079: }
1080: }
1081:
1082: if (didwork)
1083: goto again;
1084: }
1085:
1086: asintr1 (as, val)
1087: struct asinfo *as;
1088: int val;
1089: {
1090: struct buf *bp;
1091: struct ccb *ccb;
1092: int n;
1093: int bad;
1094: char *msg;
1095: char msgbuf[100];
1096: unsigned char *sp;
1097: int i,key;
1098:
1099: if (asverbose)
1100: printf ("asintr1 %x ", val);
1101: if (as->active == 0) {
1102: printf ("as: stray intr 0x%x\n", as->dev);
1103: return;
1104: }
1105:
1106: as->active = 0;
1107: untimeout (asabort, as);
1108:
1109: bp = as->requests.b_actf;
1110: ccb = &as->ccb;
1111:
1112: if (bp == as->scsi_bp) {
1113: /* no fancy error recovery in this case */
1114: if (asverbose)
1115: printf ("asintr1:scsicmd ");
1116: #if 0
1117: if (val != 1)
1118: bp->b_flags |= B_ERROR;
1119: goto next;
1120: #endif
1121: }
1122:
1123: bad = 0;
1124: msg = NULL;
1125:
1126: if (val != 1 && val != 4) {
1127: bad = 1;
1128: sprintf (msgbuf, "funny mailbox message 0x%x\n", val);
1129: msg = msgbuf;
1130: goto wrapup;
1131: }
1132:
1133: if (ccb->ccb_host_status != 0) {
1134: bad = 1;
1135: sprintf (msgbuf, "controller error 0x%x",
1136: ccb->ccb_host_status);
1137: msg = msgbuf;
1138: goto wrapup;
1139: }
1140:
1141: if (ccb->ccb_target_status == 0)
1142: /* good transfer */
1143: goto wrapup;
1144:
1145: if (ccb->ccb_target_status == 8) {
1146: /* target rejected command because it is busy
1147: * and wants us to try again later. We'll wait 1 second
1148: */
1149: as->restart_pending = 1;
1150: timeout (asrestart, as, hz);
1151: return;
1152: }
1153:
1154: if (ccb->ccb_target_status != 2) {
1155: bad = 1;
1156: sprintf (msgbuf, "target error 0x%x",
1157: ccb->ccb_target_status);
1158: msg = msgbuf;
1159: goto wrapup;
1160: }
1161:
1162: /* normal path for errors */
1163:
1164: sp = ccb_sense (ccb);
1165: /* check for extended sense information */
1166: if ((sp[0] & 0x7f) != 0x70) {
1167: /* none */
1168: bad = 1;
1169: sprintf (msgbuf, "scsi error 0x%x", sp[0] & 0x7f);
1170: msg = msgbuf;
1171: goto wrapup;
1172: }
1173:
1174: if (as->tape && (sp[2] & 0xf) == 0) {
1175: if (sp[2] & 0xe0) {
1176: /* either we read a file mark, the early warning EOT,
1177: * or the block size did not match. In any case, the
1178: * normal residue handling will work (I think)
1179: */
1180: goto wrapup;
1181: }
1182: }
1183:
1184: bad = 1;
1185:
1186: switch (key = sp[2] & 0xf) {
1187: case 1:
1188: msg = "soft error";
1189: bad = 0;
1190: break;
1191: case 2:
1192: msg = "not ready";
1193: break;
1194: case 3:
1195: msg = "hard error";
1196: break;
1197: case 4:
1198: msg = "target hardware error";
1199: break;
1200: case 5:
1201: msg = "illegal request";
1202: break;
1203: case 6:
1204: msg = "unit attention error";
1205: break;
1206: case 7:
1207: msg = "write protect error";
1208: break;
1209: case 0xd:
1210: msg = "volume overflow";
1211: break;
1212: default:
1213: sprintf (msgbuf, "scsi extended error 0x%x", sp[2] & 0xf);
1214: msg = msgbuf;
1215: break;
1216: }
1217:
1218: wrapup:
1219:
1220: if (bad && msg == NULL)
1221: msg = "unknown error";
1222:
1223: if (msg && key != 6) {
1224: diskerr (bp, "as", msg,
1225: LOG_PRINTF,
1226: -1, /* number of successful blks */
1227: as->have_label ? &as->label : NULL);
1228: printf ("\n");
1229: }
1230:
1231: if (bad && key != 6) {
1232: bp->b_flags |= B_ERROR;
1233: printf ("scsi sense: ");
1234: sp = ccb_sense (ccb);
1235: for (i = 0; i < 30; i++)
1236: printf ("%x ", sp[i] & 0xff);
1237: printf ("\n");
1238: }
1239:
1240: bp->b_resid = (ccb->ccb_data_len_msb << 16)
1241: | (ccb->ccb_data_len_mid << 8)
1242: | ccb->ccb_data_len_lsb;
1243: if (bp != as->scsi_bp && bp->b_resid != 0)
1244: printf ("scsi resid = %d\n", bp->b_resid);
1245:
1246: next:
1247: asdone (as, 1);
1248: }
1249:
1250: asdone (as, restart)
1251: struct asinfo *as;
1252: int restart;
1253: {
1254: struct buf *bp;
1255:
1256: bp = as->requests.b_actf;
1257: as->requests.b_actf = bp->av_forw;
1258: biodone (bp);
1259: as->retry_count = 0;
1260: if (restart && as->requests.b_actf)
1261: asstart (as);
1262: }
1263:
1264: int
1265: assize (dev)
1266: dev_t dev;
1267: {
1268: struct asinfo *as;
1269: struct disklabel *lp;
1270: int val;
1271:
1272: if (as_port == 0 || dev_target (dev) >= NTARGETS)
1273: return (ENXIO);
1274:
1275: as = &asinfo[dev_target (dev)];
1276:
1277: if (as->open == 0
1278: && asopen (dev, FREAD, S_IFBLK, NULL) != 0)
1279: return (0);
1280:
1281: if (as->have_label == 0)
1282: return (0);
1283:
1284: lp = &as->label;
1285: val = lp->d_partitions[dev_part (dev)].p_size
1286: * lp->d_secsize / DEV_BSIZE;
1287: (void) asclose(dev, FREAD, S_IFBLK, NULL);
1288: return (val);
1289: }
1290:
1291: int
1292: as_put_byte (val)
1293: int val;
1294: {
1295: int i;
1296:
1297: for (i = 100; i > 0; i--) {
1298: if ((inb (as_port + AS_STATUS) & AS_STATUS_CDF) == 0)
1299: break;
1300: DELAY (100);
1301: }
1302: if (i == 0) {
1303: printf ("as: put byte timed out\n");
1304: return (-1);
1305: }
1306: outb (as_port + AS_DATA_OUT, val);
1307: return (0);
1308: }
1309:
1310: int
1311: as_get_byte (as)
1312: {
1313: int i;
1314:
1315: for (i = 100; i > 0; i--) {
1316: if ((inb (as_port + AS_STATUS) & AS_STATUS_DF) != 0)
1317: break;
1318: DELAY (100);
1319: }
1320: if (i == 0) {
1321: printf ("as_get_byte timed out\n");
1322: return (-1);
1323: }
1324: return (inb (as_port + AS_DATA_OUT) & 0xff);
1325: }
1326: #endif /* NAS */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.