home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Trees / V6 / usr / sys / dmr / ht.c < prev    next >
Encoding:
C/C++ Source or Header  |  1975-07-18  |  4.1 KB  |  249 lines
  1. #
  2. /*
  3.  */
  4.  
  5. /*
  6.  * TJU16 tape driver
  7.  */
  8.  
  9. #include "../param.h"
  10. #include "../buf.h"
  11. #include "../conf.h"
  12. #include "../user.h"
  13.  
  14. struct {
  15.     int    htcs1;
  16.     int    htwc;
  17.     int    htba;
  18.     int    htfc;
  19.     int    htcs2;
  20.     int    htds;
  21.     int    hter;
  22.     int    htas;
  23.     int    htck;
  24.     int    htdb;
  25.     int    htmr;
  26.     int    htdt;
  27.     int    htsn;
  28.     int    httc;
  29.     int    htbae;    /* 11/70 bus extension */
  30. };
  31.  
  32. struct    devtab    httab;
  33. struct    buf    rhtbuf;
  34.  
  35. #define    NUNIT    8
  36.  
  37. char    h_openf[NUNIT];
  38. char    *h_blkno[NUNIT];
  39. char    *h_nxrec[NUNIT];
  40.  
  41. #define    HTADDR    0172440
  42.  
  43. #define    GO    01
  44. #define    NOP    0
  45. #define    WEOF    026
  46. #define    SFORW    030
  47. #define    SREV    032
  48. #define    ERASE    024
  49. #define    REW    06
  50. #define    CLR    010
  51. #define    P800    01300        /* 800 + pdp11 mode */
  52. #define    P1600    02300        /* 1600 + pdp11 mode */
  53. #define    IENABLE    0100
  54. #define    CRDY    0200
  55. #define    EOF    04
  56. #define    DRY    0200
  57. #define    MOL    010000
  58. #define    PIP    020000
  59. #define    ERR    040000
  60.  
  61. #define    SSEEK    1
  62. #define    SIO    2
  63.  
  64. htopen(dev, flag)
  65. {
  66.     register unit;
  67.  
  68.     unit = dev.d_minor&077;
  69.     if (unit >= NUNIT || h_openf[unit])
  70.         u.u_error = ENXIO;
  71.     else {
  72.         h_openf[unit]++;
  73.         h_blkno[unit] = 0;
  74.         h_nxrec[unit] = 65535;
  75.         hcommand(dev, NOP);
  76.     }
  77. }
  78.  
  79. htclose(dev, flag)
  80. {
  81.     register int unit;
  82.  
  83.     unit = dev.d_minor&077;
  84.     h_openf[unit] = 0;
  85.     if (flag) {
  86.         hcommand(dev, WEOF);
  87.         hcommand(dev, WEOF);
  88.     }
  89.     hcommand(dev, REW);
  90. }
  91.  
  92. hcommand(dev, com)
  93. {
  94.     register unit;
  95.     extern lbolt;
  96.  
  97.     unit = dev.d_minor;
  98.     while (httab.d_active || (HTADDR->htcs1 & CRDY)==0)
  99.         sleep(&lbolt, 1);
  100.     HTADDR->htcs2 = (unit>>3)&07;
  101.     while((HTADDR->htds&DRY) == 0)
  102.         sleep(&lbolt, 1);
  103.     if(unit >= 64)
  104.         HTADDR->httc = P800 | (unit&07); else
  105.         HTADDR->httc = P1600 | (unit&07);
  106.     while((HTADDR->htds&(MOL|PIP)) != MOL)
  107.         sleep(&lbolt, 1);
  108.     HTADDR->htcs1 = com | GO;
  109. }
  110.  
  111. htstrategy(abp)
  112. struct buf *abp;
  113. {
  114.     register struct buf *bp;
  115.     register char **p;
  116.  
  117.     bp = abp;
  118.     p = &h_nxrec[bp->b_dev.d_minor&077];
  119.     if (*p <= bp->b_blkno) {
  120.         if (*p < bp->b_blkno) {
  121.             bp->b_flags =| B_ERROR;
  122.             iodone(bp);
  123.             return;
  124.         }
  125.         if (bp->b_flags&B_READ) {
  126.             clrbuf(bp);
  127.             iodone(bp);
  128.             return;
  129.         }
  130.     }
  131.     if ((bp->b_flags&B_READ)==0)
  132.         *p = bp->b_blkno + 1;
  133.     bp->av_forw = 0;
  134.     spl5();
  135.     if (httab.d_actf==0)
  136.         httab.d_actf = bp;
  137.     else
  138.         httab.d_actl->av_forw = bp;
  139.     httab.d_actl = bp;
  140.     if (httab.d_active==0)
  141.         htstart();
  142.     spl0();
  143. }
  144.  
  145. htstart()
  146. {
  147.     register struct buf *bp;
  148.     register int unit;
  149.     register char *blkno;
  150.  
  151.     loop:
  152.     if ((bp = httab.d_actf) == 0)
  153.         return;
  154.     unit = bp->b_dev.d_minor;
  155.     HTADDR->htcs2 = (unit>>3)&07;
  156.     if(unit >= 64)
  157.         HTADDR->httc = P800 | (unit&07); else
  158.         HTADDR->httc = P1600 | (unit&07);
  159.     unit =& 077;
  160.     blkno = h_blkno[unit];
  161.     if (h_openf[unit] < 0 || (HTADDR->htcs1 & CRDY)==0) {
  162.         bp->b_flags =| B_ERROR;
  163.         httab.d_actf = bp->av_forw;
  164.         iodone(bp);
  165.         goto loop;
  166.     }
  167.     if (blkno != bp->b_blkno) {
  168.         httab.d_active = SSEEK;
  169.         if (blkno < bp->b_blkno) {
  170.             HTADDR->htfc = blkno - bp->b_blkno;
  171.             HTADDR->htcs1 = SFORW|IENABLE|GO;
  172.         } else {
  173.             if (bp->b_blkno == 0)
  174.                 HTADDR->htcs1 = REW|IENABLE|GO;
  175.             else {
  176.                 HTADDR->htfc = bp->b_blkno - blkno;
  177.                 HTADDR->htcs1 = SREV|IENABLE|GO;
  178.             }
  179.         }
  180.         return;
  181.     }
  182.     httab.d_active = SIO;
  183.     rhstart(bp, &HTADDR->htfc, bp->b_wcount<<1, &HTADDR->htbae);
  184. }
  185.  
  186. htintr()
  187. {
  188.     register struct buf *bp;
  189.     register int unit;
  190.  
  191.     if ((bp = httab.d_actf)==0)
  192.         return;
  193.     unit = bp->b_dev.d_minor&077;
  194.     if (HTADDR->htcs1 & ERR) {
  195. /*
  196.         deverror(bp, HTADDR->hter, 0);
  197.  */
  198.         if(HTADDR->htds&EOF) {
  199.             if(bp != &rhtbuf && h_openf[unit])
  200.                 h_openf[unit] = -1;
  201.         }
  202.         HTADDR->htcs1 = ERR|CLR|GO;
  203.         if ((HTADDR->htds&DRY)!=0 && httab.d_active==SIO) {
  204.             if (++httab.d_errcnt < 10) {
  205.                 h_blkno[unit]++;
  206.                 httab.d_active = 0;
  207.                 htstart();
  208.                 return;
  209.             }
  210.         }
  211.         bp->b_flags =| B_ERROR;
  212.         httab.d_active = SIO;
  213.     }
  214.     if (httab.d_active == SIO) {
  215.         httab.d_errcnt = 0;
  216.         h_blkno[unit]++;
  217.         httab.d_actf = bp->av_forw;
  218.         httab.d_active = 0;
  219.         iodone(bp);
  220.         bp->b_resid = HTADDR->htfc;
  221.     } else
  222.         h_blkno[unit] = bp->b_blkno;
  223.     htstart();
  224. }
  225.  
  226. htread(dev)
  227. {
  228.     htphys(dev);
  229.     physio(htstrategy, &rhtbuf, dev, B_READ);
  230.     u.u_count = -rhtbuf.b_resid;
  231. }
  232.  
  233. htwrite(dev)
  234. {
  235.     htphys(dev);
  236.     physio(htstrategy, &rhtbuf, dev, B_WRITE);
  237.     u.u_count = 0;
  238. }
  239.  
  240. htphys(dev)
  241. {
  242.     register unit, a;
  243.  
  244.     unit = dev.d_minor;
  245.     a = lshift(u.u_offset, -9);
  246.     h_blkno[unit] = a;
  247.     h_nxrec[unit] = ++a;
  248. }
  249.