home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Trees / V7 / usr / sys / dev / dz.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-03  |  4.6 KB  |  268 lines
  1. /*
  2.  *    DZ11 driver
  3.  * CAUTION -- MODIFIED FROM WORKING VERSION BUT NEVER PROPERLY TESTED
  4.  */
  5.  
  6. #include "../h/param.h"
  7. #include "../h/dir.h"
  8. #include "../h/user.h"
  9. #include "../h/tty.h"
  10.  
  11. struct device *dz_addr[] = { (struct device *)0160100, (struct device *)0160110};
  12. int    dz_cnt = 16;
  13. struct tty dz_tty[16];
  14. char    dz_stat;
  15.  
  16. char    dz_speeds[] = {
  17.     0, 020, 021, 022, 023, 024, 0, 025,
  18.     026, 027, 030, 032, 034, 036, 0, 0,
  19.     };
  20.  
  21. #define    BITS7    020
  22. #define    BITS8    030
  23. #define    TWOSB    040
  24. #define    PENABLE    0100
  25. #define    OPAR    0200
  26. #define    RCVENA    010000
  27.  
  28. #define    IE    040140
  29. #define    PERROR    010000
  30. #define    FRERROR    020000
  31. #define    SSPEED    7    /* standard speed: 300 baud */
  32.  
  33. struct device {
  34.     int    dzcsr, dzrbuf;
  35.     char    dztcr, dzdtr;
  36.     char    dztbuf, dzbrk;
  37. };
  38. #define    dzlpr    dzrbuf
  39. #define    dzmsr    dzbrk
  40.  
  41. #define    ON    1
  42. #define    OFF    0
  43.  
  44.  
  45. dzopen(dev, flag)
  46. {
  47.     register struct tty *tp;
  48.     int x;
  49.     extern dzstart(), dzscan();
  50.  
  51.     x = dev;
  52.     dev = minor(dev);
  53.     if (dev >= dz_cnt) {
  54.         u.u_error = ENXIO;
  55.         return;
  56.     }
  57.     tp = &dz_tty[dev];
  58.     if ((tp->t_state&(ISOPEN|WOPEN)) == 0) {
  59.         tp->t_oproc = dzstart;
  60.         tp->t_iproc = NULL;
  61.         ttychars(tp);
  62.         tp->t_ispeed = SSPEED;
  63.         tp->t_ospeed = SSPEED;
  64.         tp->t_flags = ODDP|EVENP|ECHO;
  65.         dzparam(dev);
  66.     }
  67.     dzmodem(dev, ON);
  68.     spl6();
  69.     while ((tp->t_state&CARR_ON)==0) {
  70.         tp->t_state |= WOPEN;
  71.         sleep((caddr_t)&tp->t_rawq, TTIPRI);
  72.     }
  73.     ttyopen(x,tp);
  74.     spl0();
  75. }
  76.  
  77. dzclose(dev)
  78. {
  79.     register struct tty *tp;
  80.  
  81.     dev = minor(dev);
  82.     tp = &dz_tty[dev];
  83.     wflushtty(tp);
  84.     if (tp->t_state&HUPCLS) {
  85.         dzmodem(dev, OFF);
  86.     }
  87.     tp->t_state &= CARR_ON;
  88. }
  89.  
  90. dzread(dev)
  91. {
  92.     dev = minor(dev);
  93.     ttread(&dz_tty[dev]);
  94. }
  95.  
  96. dzwrite(dev)
  97. {
  98.     dev = minor(dev);
  99.     ttwrite(&dz_tty[dev]);
  100. }
  101.  
  102. dzioctl(dev, cmd, addr, flag)
  103. {
  104.     register struct tty *tp;
  105.  
  106.     dev = minor(dev);
  107.     tp = &dz_tty[dev];
  108.     if (ttioccomm(cmd, tp, (caddr_t)addr, dev)) {
  109.         if (cmd==TIOCSETP||cmd==TIOCSETN)
  110.             dzparam(dev);
  111.     } else {
  112.         u.u_error = ENOTTY;
  113.     }
  114. }
  115.  
  116. dzparam(dev)
  117. {
  118.     register struct tty *tp;
  119.     register struct device *dzaddr;
  120.     register lpr;
  121.  
  122.     tp = &dz_tty[dev];
  123.     dzaddr= dz_addr[dev>>3];
  124.     dzaddr->dzcsr = IE;
  125.     if (dz_stat==0) {
  126.         dzscan();
  127.         dz_stat++;
  128.     }
  129.     if (tp->t_ispeed==0) {    /* Hang up line */
  130.         dzmodem(dev, OFF);
  131.         return;
  132.     }
  133.     lpr = (dz_speeds[tp->t_ispeed]<<8)|(dev&07);
  134.     if (tp->t_flags&RAW)
  135.         lpr |= BITS8;
  136.     else
  137.         lpr |= BITS7|PENABLE;
  138.     if ((tp->t_flags&EVENP)==0)
  139.         lpr |= OPAR;
  140.     if (tp->t_ispeed == 3)    /* 110 baud */
  141.         lpr |= TWOSB;
  142.     dzaddr->dzlpr = lpr;
  143. }
  144.  
  145. dzrint(dev)
  146. {
  147.     register struct tty *tp;
  148.     register c;
  149.     register struct device *dzaddr;
  150.  
  151.     dzaddr = dz_addr[dev];
  152.     while ((c = dzaddr->dzrbuf) < 0) {    /* char. present */
  153.         tp = &dz_tty[((c>>8)&07)|(dev<<3)];
  154.         if (tp >= &dz_tty[dz_cnt])
  155.             continue;
  156.         if((tp->t_state&ISOPEN)==0) {
  157.             wakeup((caddr_t)&tp->t_rawq);
  158.             continue;
  159.         }
  160.         if (c&FRERROR)        /* break */
  161.             if (tp->t_flags&RAW)
  162.                 c = 0;        /* null (for getty) */
  163.             else
  164.                 c = 0177;    /* DEL (intr) */
  165.         if (c&PERROR)
  166.             if ((tp->t_flags&(EVENP|ODDP))==EVENP
  167.              || (tp->t_flags&(EVENP|ODDP))==ODDP )
  168.                 continue;
  169.         ttyinput(c, tp);
  170.     }
  171. }
  172.  
  173. dzxint(dev)
  174. {
  175.     register struct tty *tp;
  176.     register struct device *dzaddr;
  177.  
  178.     dzaddr = dz_addr[dev];
  179.     while(dzaddr->dzcsr<0) {    /* TX rdy */
  180.         tp = &dz_tty[((dev<<3)|(dzaddr->dzcsr>>8)&07)];
  181.         dzaddr->dztbuf = tp->t_char;
  182.         tp->t_state &= ~BUSY;
  183.         dzstart(tp);
  184.     }
  185. }
  186.  
  187. dzstart(tp)
  188. register struct tty *tp;
  189. {
  190.     register unit, c;
  191.     int s;
  192.     struct device *dzaddr;
  193.     extern ttrstrt();
  194.  
  195.     unit = tp - dz_tty;
  196.     dzaddr = dz_addr[unit>>3];
  197.     unit = 1<<(unit&07);
  198.     s = spl5();
  199.     if (tp->t_state&(TIMEOUT|BUSY)) {
  200.         splx(s);
  201.         return;
  202.     }
  203.     if (tp->t_state&TTSTOP) {
  204.         dzaddr->dztcr &= ~unit;
  205.         splx(s);
  206.         return;
  207.     }
  208.     if ((c=getc(&tp->t_outq)) >= 0) {
  209.         if (c>=0200 && (tp->t_flags&RAW)==0) {
  210.             dzaddr->dztcr &= ~unit;
  211.             tp->t_state |= TIMEOUT;
  212.             timeout(ttrstrt, (caddr_t)tp, (c&0177)+6);
  213.         } else {
  214.             tp->t_char = c;
  215.             tp->t_state |= BUSY;
  216.             dzaddr->dztcr |= unit;
  217.         }
  218.         if (tp->t_outq.c_cc<=TTLOWAT && tp->t_state&ASLEEP) {
  219.             tp->t_state &= ~ASLEEP;
  220.             wakeup((caddr_t)&tp->t_outq);
  221.         }
  222.     } else
  223.         dzaddr->dztcr &= ~unit;
  224.     splx(s);
  225. }
  226.  
  227. dzmodem(dev, flag)
  228. {
  229.     register struct device *dzaddr;
  230.     register bit;
  231.  
  232.     dzaddr = dz_addr[dev>>3];
  233.     bit = 1<<(dev&07);
  234.     if (flag==OFF)
  235.         dzaddr->dzdtr &= ~bit;
  236.     else    dzaddr->dzdtr |= bit;
  237. }
  238.  
  239. dzscan()
  240. {
  241.     register i;
  242.     register struct device *dzaddr;
  243.     register struct tty *tp;
  244.     char    bit;
  245.  
  246.     for (i=0; i<dz_cnt; i++) {
  247.         dzaddr = dz_addr[i>>3];
  248.         tp = &dz_tty[i];
  249.         bit = 1<<(i&07);
  250.         if (dzaddr->dzmsr&bit) {
  251.             if ((tp->t_state&CARR_ON)==0) {
  252.                 wakeup((caddr_t)&tp->t_rawq);
  253.                 tp->t_state |= CARR_ON;
  254.             }
  255.         } else {
  256.             if (tp->t_state&CARR_ON) {
  257.                 if (tp->t_state&ISOPEN) {
  258.                     signal(tp->t_pgrp, SIGHUP);
  259.                     dzaddr->dzdtr &= ~bit;
  260.                     flushtty(tp);
  261.                 }
  262.                 tp->t_state &= ~CARR_ON;
  263.             }
  264.         }
  265.     }
  266.     timeout(dzscan, (caddr_t)0, 120);
  267. }
  268.