![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to st.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.286|
Return to st.c CVS log | Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / io.286 |
1.1 root 1: /* (-lgl
2: * COHERENT Driver Kit Version 1.1.0
3: * Copyright (c) 1982, 1990 by Mark Williams Company.
4: * All rights reserved. May not be copied without permission.
5: -lgl) */
6: /*
7: * This is a driver for the
8: * Archive SC-400 Series Tape Controller.
9: */
10: #include <sys/coherent.h>
11: #include <sys/buf.h>
12: #include <sys/con.h>
13: #include <sys/const.h>
14: #include <sys/devices.h>
15: #include <sys/inode.h>
16: #include <sys/mtioctl.h>
17: #include <sys/sched.h>
18: #include <sys/seg.h>
19: #include <sys/stat.h>
20: #include <errno.h>
21:
22: /*
23: * Fixed parameters.
24: */
25: #define NCMDS 8 /* Max # chained commands */
26:
27: /*
28: * Configurable parameters
29: */
30: int STIRQ = 3; /* IRQ Level 3 */
31: int STPORT = 0x200; /* I/O Port */
32: int STDMA = 1; /* DMA Channel */
33:
34: #define BIT(n) (1 << (n))
35:
36: /*
37: * Forward referenced functions.
38: */
39: void stcache();
40: void stflush();
41: void stinvoke();
42: void ststart();
43: void stintr();
44: void strecov();
45: void stnext();
46: void stdiag();
47: void stspin();
48:
49: /*
50: * Driver configuration.
51: */
52: int stload();
53: int stuload();
54: int stopen();
55: int stclose();
56: int stread();
57: int stwrite();
58: int stioctl();
59: void stwatch();
60: int nulldev();
61: int nonedev();
62:
63: CON stcon = {
64: DFCHR, /* Flags */
65: ST_MAJOR, /* Major index */
66: stopen, /* Open */
67: stclose, /* Close */
68: nonedev, /* Block */
69: stread, /* Read */
70: stwrite, /* Write */
71: stioctl, /* Ioctl */
72: nulldev, /* Powerfail */
73: stwatch, /* Timeout */
74: stload, /* Load */
75: stuload /* Unload */
76: };
77:
78: /*
79: * I/O Port Addresses
80: */
81: #define DATA_REG (STPORT+0) /* Data register */
82: #define CTRL_REG (STPORT+1) /* Control/Status register */
83: #define DMAGO_REG (STPORT+2) /* DMA Go register */
84: #define DMARST_REG (STPORT+3) /* DMA reset register */
85:
86: /*
87: * Control Register
88: */
89: #define CR_RSTSAC BIT(7) /* 1 -> reset control micro */
90: #define CR_REQ BIT(6) /* 1 -> request to LSI chip */
91: #define CR_IEN BIT(5) /* 1 -> enables interrupts */
92: #define CR_DNIEN BIT(4) /* 1 -> enable DONE interrupts */
93:
94: /*
95: * Status Register
96: */
97: #define SR_IRQF BIT(7) /* 1 -> Interrupt Request Flag */
98: #define SR_NRDY BIT(6) /* 0 -> Ready */
99: #define SR_NEXC BIT(5) /* 0 -> Exception */
100: #define SR_DONE BIT(4) /* 1 -> DMA Done */
101: #define SR_TO_PC BIT(3) /* 1 -> Direction is to PC */
102:
103: /*
104: * Controller Commands.
105: */
106: #define CC_SELECT 0x01 /* Select Drive 0 */
107: #define CC_LOCK 0x11 /* Select Drive 0 and Lock */
108: #define CC_BOT 0x21 /* Rewind to beginning of tape */
109: #define CC_ERASE 0x22 /* Completely erase cartridge */
110: #define CC_TENSION 0x24 /* Wind tape to BOT, EOT, BOT */
111: #define CC_AUTO 0x25 /* Select auto-initialization */
112: #define CC_QIC11 0x26 /* Select QIC-11 media format */
113: #define CC_QIC24 0x27 /* Select QIC-24 media format */
114: #define CC_WRITE 0x40 /* Write to tape */
115: #define CC_WFM 0x60 /* Write file mark */
116: #define CC_READ 0x80 /* Read from tape */
117: #define CC_RFM 0xA0 /* Skip past next file mark */
118: #define CC_SENSE 0xC0 /* Read controller status */
119:
120: /*
121: * Sense Status Bytes 0 and 1.
122: */
123: #define SS0_FIL BIT(0) /* File Mark Detected */
124: #define SS0_BNL BIT(1) /* Bad Block Not located */
125: #define SS0_UDA BIT(2) /* Unrecoverable data error */
126: #define SS0_EOM BIT(3) /* End of media */
127: #define SS0_WRP BIT(4) /* Write Protected Cartridge */
128: #define SS0_USL BIT(5) /* Unselected Drive */
129: #define SS0_CNI BIT(6) /* Cartridge Not In Place */
130: #define SS0_ERR (SS0_BNL+SS0_UDA+SS0_USL+SS0_CNI)
131:
132: #define SS1_POR BIT(0) /* Power on Reset Occurred */
133: #define SS1_BOM BIT(3) /* Beginning of media */
134: #define SS1_MBD BIT(4) /* Marginal Block Detected */
135: #define SS1_NDT BIT(5) /* No Data Detected */
136: #define SS1_ILL BIT(6) /* Illegal Command */
137: #define SS1_ERR (SS1_NDT+SS1_ILL)
138:
139: /*
140: * Device States.
141: */
142: #define SDEAD 0 /* controller not found */
143: #define SIDLE 1 /* controller idle */
144: #define SCMD 2 /* initiating command */
145: #define SRUN 3 /* performing command */
146: #define SRDWR 4 /* starting read/write */
147: #define SBLOCK 5 /* performing read/write */
148: #define SBLEND 6 /* concluding block i/o */
149: #define SSENSE 7 /* reading status bytes */
150: #define SSDONE 8 /* concluding status sense */
151:
152: /*
153: * Driver State Information.
154: */
155: struct st_s {
156: int st_state;
157: int st_mode; /* IPR or IPW */
158: int st_iocmd; /* CC_READ or CC_WRITE */
159: int st_cmd; /* last command executed */
160: int st_cmds[NCMDS]; /* list of chained commands */
161: int st_ncmds; /* num of chained commands */
162: int st_iswr;
163: int st_wasio;
164: int st_iseof;
165: int st_error;
166: paddr_t st_paddr;
167: fsize_t st_resid;
168: fsize_t st_size;
169: saddr_t st_sel;
170: SEG * st_seg;
171: char st_status[6];
172: int st_nstat;
173: int st_rdys; /* number of ready watchdogs */
174: int st_nlost; /* number of lost interrupts */
175: } st;
176:
177: /**
178: *
179: * void
180: * stload() -- initialize tape device
181: *
182: * Action: Reset tape controller and drive.
183: * Seize tape interrupt vector.
184: *
185: * Note: If the tape controller is present and operational,
186: * a interrupt will occur and set st.st_state to SIDLE.
187: */
188: static
189: stload()
190: {
191: /*
192: * Paranoia - Turn off DMA.
193: * Should already be turned off.
194: */
195: dmaoff( STDMA );
196:
197: /*
198: * Reset tape controller and drive
199: */
200: outb( CTRL_REG, CR_RSTSAC );
201:
202: /*
203: * Wait at least 25 microseconds
204: */
205: stspin( 25 );
206:
207: /*
208: * Terminate reset condition
209: */
210: outb( CTRL_REG, CR_IEN );
211:
212: /*
213: * Seize tape interrupt vector.
214: */
215: setivec( STIRQ, &stintr );
216: }
217:
218: /**
219: *
220: * stuload( dev ) -- Unload tape device.
221: * dev_t dev;
222: */
223: stuload( dev )
224: dev_t dev;
225: {
226: /*
227: * Turn off DMA.
228: */
229: dmaoff( STDMA );
230:
231: /*
232: * Release tape interrupt vector.
233: */
234: clrivec( STIRQ );
235:
236: /*
237: * Disable tape interrupts.
238: */
239: outb( CTRL_REG, 0 );
240: }
241:
242: /**
243: *
244: * stopen( dev, mode ) -- open tape device
245: * dev_t dev;
246: * int mode;
247: *
248: * Input: dev = tape device to be opened.
249: * mode = desired access mode.
250: *
251: * Action: Refuse access if tape drive does not exist or is in use.
252: * Refuse simultaneous read and write access.
253: * Refuse access if cartridge is not inserted in tape drive.
254: * Refuse write access to a write protected cartridge.
255: * Allocate tape cache.
256: * Initialize device state.
257: * Lock tape cartridge.
258: */
259: static
260: stopen( dev, mode )
261: register dev_t dev;
262: register int mode;
263: {
264: int s;
265:
266: /*
267: * Refuse access if no tape drive.
268: */
269: if ( st.st_state == SDEAD ) {
270: u.u_error = ENXIO;
271: return;
272: }
273:
274: /*
275: * Refuse access if tape drive is already open.
276: */
277: if ( st.st_mode != 0 ) {
278: u.u_error = EDBUSY;
279: return;
280: }
281:
282: /*
283: * Access must be read-only or write-only.
284: */
285: if ( (mode != IPR) && (mode != IPW) ) {
286: u.u_error = EINVAL;
287: return;
288: }
289:
290: /*
291: * Wait for tape drive to become idle.
292: */
293: if ( stwait() < 0 ) {
294: u.u_error = EINTR;
295: return;
296: }
297:
298: /*
299: * Initialize tape interface.
300: */
301: s = sphi();
302: outb( DMARST_REG, 0 );
303: outb( CTRL_REG, CR_IEN );
304: spl( s );
305:
306: /*
307: * Obtain tape status.
308: */
309: stinvoke( CC_SENSE );
310:
311: /*
312: * Wait for tape status.
313: */
314: if ( stwait() < 0 ) {
315: u.u_error = EINTR;
316: return;
317: }
318:
319: /*
320: * Refuse access if no cartridge.
321: */
322: if ( st.st_status[0] & (SS0_CNI|SS0_USL) ) {
323: u.u_error = EDATTN;
324: return;
325: }
326:
327: /*
328: * Refuse write access to a write protected cartridge.
329: */
330: if ( (mode == IPW) && (st.st_status[0] & SS0_WRP) ) {
331: u.u_error = EROFS;
332: return;
333: }
334:
335: /*
336: * Calculate desired cache size in Kbytes.
337: */
338: st.st_size = minor(dev) & ~0x80;
339: if ( st.st_size == 0 )
340: st.st_size = 256;
341:
342: /*
343: * Allocate cache
344: */
345: for ( st.st_size *= 1024; st.st_size != 0; st.st_size -= 1024 )
346: if ( st.st_seg = salloc( st.st_size, SFSYST|SFNSWP|SFNCLR ) )
347: break;
348:
349: /*
350: * Refuse access if couldn't allocate cache.
351: */
352: if ( st.st_seg == 0 ) {
353: u.u_error = ENOMEM;
354: return;
355: };
356:
357: /*
358: * Initialize device state.
359: */
360: st.st_sel = FP_SEL(st.st_seg->s_faddr);
361: st.st_iswr = (mode == IPW);
362: st.st_paddr = st.st_seg->s_paddr;
363: st.st_resid = (mode == IPW) ? st.st_size : 0 ;
364: st.st_iocmd = (mode == IPW) ? CC_WRITE : CC_READ ;
365: st.st_mode = mode;
366: st.st_iseof = 0;
367: st.st_wasio = 0;
368: st.st_error = 0;
369: st.st_rdys = 0;
370: st.st_nlost = 0;
371:
372: /*
373: * Lock cartridge if at beginning of media.
374: */
375: if ( st.st_status[1] & SS1_BOM )
376: stinvoke( CC_LOCK );
377: }
378:
379: /**
380: *
381: * stclose( dev, mode ) -- close tape device
382: * dev_t dev;
383: * int mode;
384: *
385: * Input: dev = tape device to be closed.
386: * mode = access mode.
387: *
388: * Action: If access mode was for writing, flush the tape cache.
389: * If data was written to tape, write a file mark.
390: * If data was read from tape on the non rewinding device,
391: * read until end of file or an error is encountered.
392: * Rewind the tape if the rewinding device is open.
393: * Unlock the tape cartridge.
394: * Clear tape state and release tape cache memory.
395: */
396: static
397: stclose( dev, mode )
398: register dev_t dev;
399: {
400: /*
401: * Check if tape was opened for writing.
402: */
403: if ( st.st_iswr ) {
404:
405: /*
406: * Flush the tape cache.
407: */
408: stflush();
409:
410: /*
411: * Write a file mark if data was written to tape.
412: */
413: if ( st.st_wasio )
414: stinvoke( CC_WFM );
415: }
416:
417: /*
418: * Check if non-rewinding device was opened for reading.
419: */
420: else if ( st.st_wasio && (dev & 0x80 ) ) {
421:
422: /*
423: * Read file mark if not just past one.
424: */
425: if ( (st.st_status[0] & SS0_FIL) == 0 )
426: stinvoke( CC_RFM );
427: }
428:
429: /*
430: * Rewinding device.
431: */
432: if ( (dev & 0x80) == 0 ) {
433:
434: /*
435: * Wait for controller to idle.
436: */
437: while ( stwait() < 0 )
438: ;
439:
440: /*
441: * Initiate rewind.
442: */
443: stinvoke( CC_BOT );
444:
445: /*
446: * Unlock the drive [turn off the light].
447: */
448: stinvoke( CC_SELECT );
449: }
450:
451: /*
452: * Clear tape state, releasing tape cache.
453: */
454: sfree( st.st_seg );
455: st.st_seg = 0;
456: st.st_mode = 0;
457: }
458:
459: /**
460: *
461: * stread( dev, iop ) -- tape device read
462: * dev_t dev;
463: * IO * iop;
464: *
465: * Input: dev = tape device to be read from.
466: * iop = pointer to IO structure.
467: *
468: * Action: Transfer data from tape cache to user memory,
469: * filling the cache as required by initiating reads from tape.
470: */
471:
472: static
473: stread( dev, iop )
474: dev_t dev;
475: register IO * iop;
476: {
477: register int n;
478: register int ioc;
479:
480: ioc = iop->io_ioc;
481:
482: while ( iop->io_ioc > 0 ) {
483:
484: /*
485: * Check for empty cache.
486: */
487: while ( st.st_resid == 0 ) {
488:
489: /*
490: * Special handling if end of file was encountered.
491: */
492: if ( st.st_iseof ) {
493:
494: /*
495: * Clear EOF if no data was transferred yet.
496: */
497: if ( ioc == iop->io_ioc )
498: st.st_iseof = 0;
499:
500: return;
501: }
502:
503: /*
504: * Abort on I/O error.
505: */
506: if ( u.u_error = st.st_error ) {
507: stdiag();
508: return;
509: }
510:
511: /*
512: * Fill the cache from tape.
513: */
514: stcache();
515: }
516:
517: /*
518: * Determine max data transferable in one chunk.
519: */
520: n = iop->io_ioc;
521: if ( n > st.st_resid )
522: n = st.st_resid;
523:
524: /*
525: * Transfer some data from cache to user memory.
526: */
527: if ( pucopy( st.st_paddr, iop->io_base, n ) != n )
528: return;
529:
530: /*
531: * Update addresses and counts.
532: */
533: iop->io_base += n;
534: iop->io_ioc -= n;
535: st.st_resid -= n;
536: st.st_paddr += n;
537: }
538: }
539:
540: /**
541: *
542: * stwrite( dev, iop ) -- write to tape device
543: * dev_t dev;
544: * IO * iop;
545: *
546: * Input: dev = tape device to be written to.
547: * iop = pointer to IO structure.
548: *
549: * Action: Transfer data from user memory to tape cache,
550: * flushing the cache as required by initiating writes to tape.
551: */
552:
553: static
554: stwrite( dev, iop )
555: dev_t dev;
556: register IO *iop;
557: {
558: register int n;
559:
560: while ( iop->io_ioc > 0 ) {
561:
562: /*
563: * Determine max data transferable in one chunk.
564: */
565: n = iop->io_ioc;
566: if ( n > st.st_resid )
567: n = st.st_resid;
568:
569: /*
570: * Transfer some data from user memory to cache.
571: */
572: if ( upcopy( iop->io_base, st.st_paddr, n ) != n )
573: break;
574:
575: /*
576: * Update addresses and counts.
577: */
578: iop->io_base += n;
579: iop->io_ioc -= n;
580: st.st_paddr += n;
581: st.st_resid -= n;
582:
583: /*
584: * Flush the cache to tape if full.
585: */
586: if ( st.st_resid == 0 )
587: stflush();
588:
589: /*
590: * Abort on I/O error.
591: */
592: if ( u.u_error = st.st_error ) {
593: stdiag();
594: return;
595: }
596: }
597: }
598:
599: /**
600: *
601: * stioctl( dev, cmd, arg ) -- service tape I/O control requests
602: * int dev;
603: * int cmd;
604: * int arg;
605: *
606: * Input: dev = tape device to be serviced
607: * cmd = ioctl command
608: * arg = argument to ioctl command
609: *
610: * Action: Service tape I/O control request.
611: */
612:
613: static
614: stioctl( dev, cmd, arg )
615: {
616: if ( st.st_iswr )
617: stflush();
618:
619: st.st_error = EINVAL;
620:
621: switch ( cmd ) {
622:
623: case MTERASE:
624: stinvoke( CC_ERASE );
625: break;
626:
627: case MTTENSE:
628: stinvoke( CC_TENSION );
629: break;
630:
631: case MTREWIND:
632: if ( st.st_iswr && st.st_wasio ) {
633: stinvoke( CC_WFM );
634: st.st_wasio = 0;
635: }
636: stinvoke( CC_BOT );
637: break;
638:
639: case MTWEOF:
640: if ( st.st_iswr ) {
641: stinvoke( CC_WFM );
642: st.st_wasio = 0;
643: }
644: break;
645:
646: case MTFSKIP:
647: if ( ! st.st_iswr ) {
648: if ( ! st.st_iseof )
649: stinvoke( CC_RFM );
650: st.st_iseof = 0;
651: st.st_resid = 0;
652: }
653: break;
654: }
655:
656: /*
657: * Record tape error code.
658: */
659: u.u_error = st.st_error;
660: }
661:
662: /**
663: *
664: * void
665: * stcache() -- read from tape into cache
666: *
667: * Action: Read as much data as possible into the tape cache.
668: * Set st.st_paddr to the cache address.
669: * Set st.st_resid to the number of data bytes in the cache.
670: */
671: static void
672: stcache()
673: {
674: /*
675: * Try to fill cache from tape.
676: */
677: st.st_paddr = st.st_seg->s_paddr;
678: st.st_resid = st.st_size;
679: ststart();
680:
681: /*
682: * Update cache information.
683: */
684: st.st_paddr = st.st_seg->s_paddr;
685: st.st_resid = st.st_size - st.st_resid;
686:
687: /*
688: * Clear the cache on I/O error.
689: */
690: if ( st.st_error )
691: st.st_resid = 0;
692: }
693:
694: /**
695: *
696: * void
697: * stflush() -- flush cache to tape
698: *
699: * Action: Ensure tape cache is block aligned.
700: * Write cache to the tape.
701: * Set st.st_paddr to the cache address.
702: * Set st.st_resid to the number of cache bytes available.
703: */
704: static void
705: stflush()
706: {
707: static char zc;
708:
709: /*
710: * Check for empty cache.
711: */
712: if ( st.st_resid == st.st_size )
713: return;
714:
715: /*
716: * Block align the cache.
717: */
718: while ( st.st_resid % BSIZE ) {
719: kpcopy( &zc, st.st_paddr, 1 );
720: st.st_paddr++;
721: st.st_resid--;
722: }
723:
724: /*
725: * Flush the cache to tape.
726: */
727: st.st_paddr = st.st_seg->s_paddr;
728: st.st_resid = st.st_size - st.st_resid;
729: ststart();
730:
731: /*
732: * Update cache information.
733: */
734: st.st_paddr = st.st_seg->s_paddr;
735: st.st_resid = st.st_size;
736: }
737:
738: /**
739: *
740: * void
741: * stinvoke() -- start tape control operation
742: *
743: * Action: Initiate tape control operation.
744: */
745: static void
746: stinvoke( cmd )
747: int cmd;
748: {
749: register int s;
750:
751: /*
752: * Disable interrupts.
753: */
754: s = sphi();
755:
756: /*
757: * Wait for controller to become idle.
758: */
759: while ( st.st_state != SIDLE ) {
760:
761: /*
762: * Create chained command if possible.
763: */
764: if ( st.st_ncmds < NCMDS ) {
765: st.st_cmds[ st.st_ncmds++ ] = cmd;
766: spl( s );
767: return;
768: }
769:
770: sleep( &st, CVTTOUT, IVTTOUT, SVTTOUT );
771: }
772:
773: /*
774: * Setup for tape operation.
775: */
776: drvl[ST_MAJOR].d_time = 1;
777: st.st_state = SCMD;
778: st.st_error = 0;
779: st.st_rdys = 0;
780: stspin( 100 );
781:
782: /*
783: * Request tape operation.
784: * Do NOT wait for results.
785: */
786: outb( DATA_REG, st.st_cmd = cmd );
787: outb( CTRL_REG, CR_IEN+CR_REQ );
788:
789: /*
790: * Enable interrupts.
791: */
792: spl( s );
793: }
794:
795: /**
796: *
797: * void
798: * ststart() -- start tape read/write operation
799: *
800: * Action: Initiate tape read/write operation.
801: * Wait for tape operation to complete.
802: */
803: static void
804: ststart()
805: {
806: register int s;
807:
808: /*
809: * Disable interrupts.
810: */
811: s = sphi();
812:
813: /*
814: * Wait for controller to become idle.
815: */
816: while ( st.st_state != SIDLE )
817: sleep( &st, CVTTOUT, IVTTOUT, SVTTOUT );
818:
819: /*
820: * Setup for tape read/write.
821: */
822: drvl[ST_MAJOR].d_time = 1;
823: st.st_state = SRDWR;
824: st.st_error = 0;
825: st.st_rdys = 0;
826: stspin( 100 );
827:
828: /*
829: * Tape read/write was last command executed.
830: */
831: if ( st.st_cmd == st.st_iocmd ) {
832: /*
833: * Resume tape i/o operation.
834: * Simulate RDY interrupt.
835: */
836: stintr();
837: }
838: else {
839: /*
840: * Request tape operation.
841: */
842: outb( DATA_REG, st.st_cmd = st.st_iocmd );
843: outb( CTRL_REG, CR_IEN+CR_REQ );
844: }
845:
846: /*
847: * Wait for tape operation to complete.
848: */
849: while ( st.st_state != SIDLE )
850: sleep( &st, CVTTOUT, IVTTOUT, SVTTOUT );
851:
852: /*
853: * Enable interrupts.
854: */
855: spl( s );
856: }
857:
858: /**
859: *
860: * void
861: * stintr() -- tape interrupt handler
862: *
863: * Action: Service tape interrupts.
864: * Perform transitions to new tape states.
865: * Wake sleeping processes if appropriate.
866: */
867: static void
868: stintr()
869: {
870: register int csr;
871: register int s;
872:
873: s = sphi();
874: csr = inb( CTRL_REG );
875:
876: /*
877: * Initiate exception recovery.
878: */
879: if ( (csr & SR_NEXC) == 0 ) {
880: strecov();
881: spl( s );
882: return;
883: }
884:
885: /*
886: * Clear ready watchdog count.
887: */
888: st.st_rdys = 0;
889:
890: /*
891: * Process normal operations.
892: */
893: switch ( st.st_state ) {
894:
895: case SCMD:
896: /*
897: * Command has been acknowledged.
898: * Wait for command completion.
899: */
900: outb( CTRL_REG, CR_IEN );
901: st.st_state = (st.st_cmd == CC_SENSE) ? SSENSE : SRUN;
902: st.st_nstat = 0;
903: break;
904:
905: case SRUN:
906: /*
907: * Command has completed.
908: * Chain a sense status command if no other chained commands.
909: */
910: if ( st.st_ncmds == 0 )
911: st.st_cmds[ st.st_ncmds++ ] = CC_SENSE;
912:
913: /*
914: * Initiate next chained command.
915: */
916: stnext();
917: break;
918:
919: case SRDWR:
920: /*
921: * Read/Write command had been acknowledged.
922: * Clear tape request, enable done interrupt.
923: */
924: outb( CTRL_REG, CR_IEN+CR_DNIEN );
925:
926: /*
927: * Define direct memory access parameters.
928: */
929: dmaon( STDMA, st.st_paddr, BSIZE, st.st_iswr );
930:
931: /*
932: * If tape read command, wait for interface to switch direction
933: */
934: if ( st.st_iocmd == CC_READ )
935: while ( (inb(CTRL_REG) & SR_TO_PC) != SR_TO_PC )
936: ;
937:
938: /*
939: * Enable DMA transfer on tape interface and at DMA controller chip.
940: */
941: st.st_state = SBLOCK;
942: outb( DMAGO_REG, 0 );
943: dmago( STDMA );
944: break;
945:
946: case SBLOCK:
947: /*
948: * Perform Block I/O.
949: * Ignore RDY interrupt, wait for [DMA] DONE interrupt.
950: */
951: if ( (csr & SR_DONE) == 0 )
952: break;
953:
954: /*
955: * Turn off DMA.
956: */
957: dmaoff( STDMA );
958:
959: /*
960: * If more data remains to be transferred, reenable DMA.
961: * NOTE: do -= BEFORE if() to avoid potential compiler bug.
962: */
963: st.st_resid -= BSIZE;
964: if ( st.st_resid > 0 ) {
965: st.st_paddr += BSIZE;
966: dmaon( STDMA, st.st_paddr, BSIZE, st.st_iswr );
967: outb( DMAGO_REG, 0 );
968: dmago( STDMA );
969: break;
970: }
971:
972: /*
973: * Disable done interrupt.
974: * Wait for I/O completion.
975: */
976: outb( CTRL_REG, CR_IEN );
977: st.st_state = SBLEND;
978: break;
979:
980: case SBLEND:
981: /*
982: * Completion of Block I/O.
983: * Clear the file mark and beginning of media indicators.
984: * Record the fact that data has been transferred.
985: */
986: st.st_status[0] &= ~SS0_FIL;
987: st.st_status[1] &= ~SS1_BOM;
988: st.st_wasio = 1;
989: stnext();
990: break;
991:
992: case SSENSE:
993: /*
994: * Sense Status Byte.
995: * Wait for availability.
996: */
997: do {
998: csr = inb(CTRL_REG) & (SR_NRDY|SR_TO_PC);
999: } while ( csr != SR_TO_PC );
1000:
1001: /*
1002: * Save status byte.
1003: */
1004: st.st_status[st.st_nstat] = inb(DATA_REG);
1005:
1006: /*
1007: * Acknowledge reception.
1008: * CR_REQ must be present for at least 20 microseconds.
1009: */
1010: outb( CTRL_REG, CR_IEN+CR_REQ );
1011: stspin( 20 );
1012: outb( CTRL_REG, CR_IEN );
1013:
1014: /*
1015: * Change state to status completion if all bytes saved.
1016: */
1017: if ( ++(st.st_nstat) == 6 )
1018: st.st_state = SSDONE;
1019: break;
1020:
1021: case SSDONE:
1022: /*
1023: * Completion of Sense Status Command.
1024: * Check for file mark.
1025: */
1026: if ( st.st_status[0] & SS0_FIL ) {
1027: outb( DMARST_REG, 0 );
1028: st.st_iseof = 1;
1029: }
1030:
1031: /*
1032: * Check for I/O error.
1033: */
1034: else if ( (st.st_status[0] & SS0_ERR) ||
1035: (st.st_status[1] & SS1_ERR) ) {
1036: st.st_error = EIO;
1037: }
1038:
1039: /*
1040: * Check for write protected cartridge.
1041: */
1042: else if ( (st.st_iocmd == CC_WRITE) &&
1043: (st.st_status[0] & SS0_WRP) ) {
1044: st.st_error = EROFS;
1045: }
1046:
1047: stnext();
1048: break;
1049: }
1050:
1051: spl( s );
1052: }
1053:
1054: /**
1055: *
1056: * void
1057: * strecov() -- initiate recovery from exception conditions
1058: *
1059: * Action: Invoked when the tape controller asserts EXCEPTION.
1060: * A sense status command is initiated to clear the exception.
1061: */
1062: static void
1063: strecov()
1064: {
1065: /*
1066: * Ensure tape interface is idle.
1067: */
1068: outb( CTRL_REG, CR_IEN );
1069: stspin( 100 );
1070:
1071: /*
1072: * Turn off DMA on read/write exception.
1073: */
1074: if ( st.st_cmd == st.st_iocmd )
1075: dmaoff( STDMA );
1076:
1077: /*
1078: * Initiate sense status command.
1079: */
1080: outb( DATA_REG, st.st_cmd = CC_SENSE );
1081: outb( CTRL_REG, CR_IEN+CR_REQ );
1082: drvl[ST_MAJOR].d_time = 1;
1083: st.st_state = SCMD;
1084: st.st_error = 0;
1085: st.st_rdys = 0;
1086: }
1087:
1088: /**
1089: *
1090: * static void
1091: * stnext() -- initiate next chained command.
1092: */
1093: static void
1094: stnext()
1095: {
1096: /*
1097: * Ensure tape interface is idle.
1098: */
1099: outb( CTRL_REG, CR_IEN );
1100: drvl[ST_MAJOR].d_time = 0;
1101: st.st_state = SIDLE;
1102: stspin( 100 );
1103:
1104: /*
1105: * Initiate a chained command.
1106: */
1107: if ( st.st_ncmds ) {
1108: outb( DATA_REG, st.st_cmd = st.st_cmds[ --st.st_ncmds ] );
1109: outb( CTRL_REG, CR_IEN+CR_REQ );
1110: drvl[ST_MAJOR].d_time = 1;
1111: st.st_state = SCMD;
1112: st.st_error = 0;
1113: st.st_rdys = 0;
1114: return;
1115: }
1116:
1117: /*
1118: * Wake waiting processes.
1119: */
1120: wakeup( &st );
1121: }
1122:
1123: /**
1124: *
1125: * void
1126: * stwatch() -- periodic [1 sec] watchdog
1127: *
1128: * Action: If an exception condition exists, initate recovery actions.
1129: * If ready condition exists for 1-2 seconds, simulate interrupt.
1130: *
1131: * Notes: If an exception condition occurs after a ready interrupt has
1132: * been serviced, but before the ready condition is cleared,
1133: * the exception interrupt will not occur, and is simulated here.
1134: */
1135: static void
1136: stwatch()
1137: {
1138: register int csr;
1139: register int s;
1140:
1141: /*
1142: * Disable interrupts, preventing critical race with stintr().
1143: */
1144: s = sphi();
1145: csr = inb(CTRL_REG);
1146:
1147: /*
1148: * Initiate recovery from exception conditions.
1149: */
1150: if ( (csr & SR_NEXC) == 0 )
1151: strecov();
1152:
1153: /*
1154: * Reset ready watchdog if not ready.
1155: */
1156: else if ( csr & SR_NRDY )
1157: st.st_rdys = 0;
1158:
1159: /*
1160: * Simulate lost ready interrupts after 2 seconds.
1161: */
1162: else if ( ++st.st_rdys >= 2 )
1163: stintr();
1164:
1165: /*
1166: * Enable interrupts.
1167: */
1168: spl( s );
1169: }
1170:
1171: /**
1172: *
1173: * void
1174: * stdiag() - Report tape status.
1175: *
1176: * Action: Identify and report the highest priority tape error.
1177: * There will normally only be one valid error present.
1178: * The USL error can invalidate most remaining flags.
1179: * The CNI error can invalidate cartridge related flags.
1180: *
1181: * Notes: Never called from interrupt level, but always from background.
1182: */
1183: static void
1184: stdiag()
1185: {
1186: if ( st.st_status[0] & SS0_USL )
1187: printf( "st: Unselected Drive\n" );
1188:
1189: else if ( st.st_status[0] & SS0_CNI )
1190: printf( "st: Cartridge missing\n" );
1191:
1192: else if ( st.st_status[1] & SS1_NDT )
1193: printf( "st: No data detected\n" );
1194:
1195: else if ( st.st_status[0] & SS0_BNL )
1196: printf( "st: Bad block not located\n" );
1197:
1198: else if ( st.st_status[0] & SS0_UDA )
1199: printf( "st: Unrecoverable data error\n" );
1200:
1201: else if ( st.st_status[1] & SS1_ILL )
1202: printf( "st: Illegal command\n" );
1203:
1204: else
1205: printf( "st: %x\n", (st.st_status[1] << 8) + st.st_status[0] );
1206: }
1207:
1208: /**
1209: *
1210: * int
1211: * stwait() -- wait for tape controller to idle.
1212: *
1213: * Return: 0 = tape controller idle.
1214: * -1 = signal received.
1215: */
1216: static int
1217: stwait()
1218: {
1219: int s;
1220:
1221: s = sphi();
1222: while ( st.st_state != SIDLE ) {
1223:
1224: sleep( &st, CVTTOUT, IVTTOUT, SVTTOUT );
1225:
1226: if ( SELF->p_ssig ) {
1227: spl( s );
1228: return -1;
1229: }
1230: }
1231: spl( s );
1232:
1233: return 0;
1234: }
1235:
1236: /**
1237: *
1238: * void
1239: * stspin( usec ) -- delay execution
1240: * int usec;
1241: *
1242: * Input: usec = number of micro-seconds to delay.
1243: *
1244: * Action: Wait at least 'usec' micro-seconds.
1245: *
1246: * Notes: Provides minimum delay required at times by tape controller.
1247: * Should function properly up to at least 16 Mhz system clock.
1248: */
1249:
1250: static void
1251: stspin( usec )
1252: register int usec;
1253: {
1254: while ( --usec >= 0 )
1255: ;
1256: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.