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