projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
fix to reeves fix of dgo handling (reset b_active to 1)
[unix-history] / usr / src / sys / vax / uba / dz.c
diff --git a/usr/src/sys/vax/uba/dz.c b/usr/src/sys/vax/uba/dz.c
index 41db662..6d0c76d 100644 (file)
--- a/usr/src/sys/vax/uba/dz.c
+++ b/usr/src/sys/vax/uba/dz.c
@@ -1,9 +1,9 @@
-/*     dz.c    4.24    81/04/02        */
+/*     dz.c    4.38    82/05/19        */
 
 #include "dz.h"
 #if NDZ > 0
 /*
 
 #include "dz.h"
 #if NDZ > 0
 /*
- *  DZ-11 Driver
+ *  DZ-11 and DZ32 Driver
  *
  * This driver mimics dh.c; see it for explanation of common code.
  */
  *
  * This driver mimics dh.c; see it for explanation of common code.
  */
@@ -13,6 +13,7 @@
 #include "../h/tty.h"
 #include "../h/dir.h"
 #include "../h/user.h"
 #include "../h/tty.h"
 #include "../h/dir.h"
 #include "../h/user.h"
+#include "../h/proc.h"
 #include "../h/map.h"
 #include "../h/pte.h"
 #include "../h/buf.h"
 #include "../h/map.h"
 #include "../h/pte.h"
 #include "../h/buf.h"
@@ -22,7 +23,6 @@
 #include "../h/pdma.h"
 #include "../h/bk.h"
 #include "../h/file.h"
 #include "../h/pdma.h"
 #include "../h/bk.h"
 #include "../h/file.h"
-#include "../h/mx.h"
 
 /*
  * Driver information for auto-configuration stuff.
 
 /*
  * Driver information for auto-configuration stuff.
@@ -39,34 +39,57 @@ struct      uba_driver dzdriver =
  * Registers and bits
  */
 
  * Registers and bits
  */
 
-/* Bits in dzlpr */
-#define        BITS7   020
-#define        BITS8   030
-#define        TWOSB   040
+/* bits in dzlpr */
+#define        BITS7   0020
+#define        BITS8   0030
+#define        TWOSB   0040
 #define        PENABLE 0100
 #define        OPAR    0200
 
 #define        PENABLE 0100
 #define        OPAR    0200
 
-/* Bits in dzrbuf */
+/* bits in dzrbuf */
 #define        DZ_PE   010000
 #define        DZ_FE   020000
 #define        DZ_DO   040000
 
 #define        DZ_PE   010000
 #define        DZ_FE   020000
 #define        DZ_DO   040000
 
-/* Bits in dzcsr */
-#define        DZ_CLR  020             /* Reset dz */
-#define        DZ_MSE  040             /* Master Scan Enable */
-#define        DZ_RIE  0100            /* Receiver Interrupt Enable */
+/* bits in dzcsr */
+#define        DZ_32   000001          /* DZ32 mode */
+#define        DZ_MIE  000002          /* Modem Interrupt Enable */
+#define        DZ_CLR  000020          /* Reset dz */
+#define        DZ_MSE  000040          /* Master Scan Enable */
+#define        DZ_RIE  000100          /* Receiver Interrupt Enable */
+#define DZ_MSC 004000          /* Modem Status Change */
 #define        DZ_SAE  010000          /* Silo Alarm Enable */
 #define        DZ_TIE  040000          /* Transmit Interrupt Enable */
 #define        DZ_SAE  010000          /* Silo Alarm Enable */
 #define        DZ_TIE  040000          /* Transmit Interrupt Enable */
-#if NBK == 0
-#define        DZ_IEN  (DZ_MSE|DZ_RIE|DZ_TIE)
-#else
-#define        DZ_IEN  (DZ_MSE|DZ_RIE|DZ_TIE|DZ_SAE)
-#endif
+#define        DZ_IEN  (DZ_32|DZ_MIE|DZ_MSE|DZ_RIE|DZ_TIE|DZ_SAE)
 
 
-/* Flags for modem-control */
-#define        DZ_ON   1
+/* flags for modem-control */
+#define        DZ_ON   DZ_DTR
 #define        DZ_OFF  0
 #define        DZ_OFF  0
+
+/* bits in dzlcs */
+#define DZ_ACK 0100000         /* ACK bit in dzlcs */
+#define DZ_RTS 0010000         /* Request To Send */
+#define        DZ_ST   0004000         /* Secondary Transmit */
+#define        DZ_BRK  0002000         /* Break */
+#define DZ_DTR 0001000         /* Data Terminal Ready */
+#define        DZ_LE   0000400         /* Line Enable */
+#define        DZ_DSR  0000200         /* Data Set Ready */
+#define        DZ_RI   0000100         /* Ring Indicate */
+#define DZ_CD  0000040         /* Carrier Detect */
+#define        DZ_CTS  0000020         /* Clear To Send */
+#define        DZ_SR   0000010         /* Secondary Receive */
  
  
+/* bits in dm lsr, copied from dh.c */
+#define        DML_DSR         0000400         /* data set ready, not a real DM bit */
+#define        DML_RNG         0000200         /* ring */
+#define        DML_CAR         0000100         /* carrier detect */
+#define        DML_CTS         0000040         /* clear to send */
+#define        DML_SR          0000020         /* secondary receive */
+#define        DML_ST          0000010         /* secondary transmit */
+#define        DML_RTS         0000004         /* request to send */
+#define        DML_DTR         0000002         /* data terminal ready */
+#define        DML_LE          0000001         /* line enable */
+
 int    dzstart(), dzxint(), dzdma();
 int    ttrstrt();
 struct tty dz_tty[NDZLINE];
 int    dzstart(), dzxint(), dzdma();
 int    ttrstrt();
 struct tty dz_tty[NDZLINE];
@@ -74,23 +97,44 @@ int dz_cnt = { NDZLINE };
 int    dzact;
 
 struct device {
 int    dzact;
 
 struct device {
-       short   dzcsr;          /* control-status register */
-       short   dzrbuf;         /* receiver buffer */
-#define        dzlpr   dzrbuf          /* line parameter reg is write of dzrbuf */
-       char    dztcr;          /* transmit control register */
-       char    dzdtr;          /* data terminal ready */
-       char    dztbuf;         /* transmit buffer */
-       char    dzbrk;          /* break control */
-#define        dzmsr   dzbrk           /* modem status register */
+       short dzcsr;
+       short dzrbuf;
+       union {
+               struct {
+                       char    dztcr0;
+                       char    dzdtr0;
+                       char    dztbuf0;
+                       char    dzbrk0;
+               } dz11;
+               struct {
+                       short   dzlcs0;
+                       char    dztbuf0;
+                       char    dzlnen0;
+               } dz32;
+       } dzun;
 };
 };
+
+#define dzlpr  dzrbuf
+#define dzmsr  dzun.dz11.dzbrk0
+#define dztcr  dzun.dz11.dztcr0
+#define dzdtr  dzun.dz11.dzdtr0
+#define dztbuf dzun.dz11.dztbuf0
+#define dzlcs  dzun.dz32.dzlcs0
+#define        dzbrk   dzmsr
+#define dzlnen dzun.dz32.dzlnen0
+#define dzmtsr dzun.dz32.dztbuf0;
+
+#define dzwait(x)      while (((x)->dzlcs & DZ_ACK) == 0)
+
 /*
  * Software copy of dzbrk since it isn't readable
  */
 char   dz_brk[NDZ];
 char   dzsoftCAR[NDZ];
 /*
  * Software copy of dzbrk since it isn't readable
  */
 char   dz_brk[NDZ];
 char   dzsoftCAR[NDZ];
+char   dz_lnen[NDZ];   /* saved line enable bits for DZ32 */
 
 /*
 
 /*
- * The dz doesn't interrupt on carrier transitions, so
+ * The dz11 doesn't interrupt on carrier transitions, so
  * we have to use a timer to watch it.
  */
 char   dz_timer;               /* timer started? */
  * we have to use a timer to watch it.
  */
 char   dz_timer;               /* timer started? */
@@ -101,8 +145,16 @@ char       dz_timer;               /* timer started? */
 struct pdma dzpdma[NDZLINE];
 
 char   dz_speeds[] =
 struct pdma dzpdma[NDZLINE];
 
 char   dz_speeds[] =
-       { 0,020,021,022,023,024,0,025,026,027,030,032,034,036,0,0 };
+       { 0,020,021,022,023,024,0,025,026,027,030,032,034,036,037,0 };
  
  
+#ifndef PORTSELECTOR
+#define        ISPEED  B300
+#define        IFLAGS  (EVENP|ODDP|ECHO)
+#else
+#define        ISPEED  B4800
+#define        IFLAGS  (EVENP|ODDP)
+#endif
+
 dzprobe(reg)
        caddr_t reg;
 {
 dzprobe(reg)
        caddr_t reg;
 {
@@ -111,11 +163,15 @@ dzprobe(reg)
 
 #ifdef lint
        br = 0; cvec = br; br = cvec;
 
 #ifdef lint
        br = 0; cvec = br; br = cvec;
+       dzrint(0); dzxint((struct tty *)0);
 #endif
 #endif
-       dzaddr->dzcsr = DZ_TIE|DZ_MSE;
-       dzaddr->dztcr = 1;              /* enable any line */
+       dzaddr->dzcsr = DZ_TIE|DZ_MSE|DZ_32;
+       if (dzaddr->dzcsr & DZ_32)
+               dzaddr->dzlnen = 1;
+       else
+               dzaddr->dztcr = 1;              /* enable any line */
        DELAY(100000);
        DELAY(100000);
-       dzaddr->dzcsr = DZ_CLR;         /* reset everything */
+       dzaddr->dzcsr = DZ_CLR|DZ_32;           /* reset everything */
        if (cvec && cvec != 0x200)
                cvec -= 4;
        return (1);
        if (cvec && cvec != 0x200)
                cvec -= 4;
        return (1);
@@ -140,7 +196,6 @@ dzattach(ui)
                dz_timer++;
                timeout(dzscan, (caddr_t)0, hz);
        }
                dz_timer++;
                timeout(dzscan, (caddr_t)0, hz);
        }
-       return (1);
 }
 
 /*ARGSUSED*/
 }
 
 /*ARGSUSED*/
@@ -158,22 +213,21 @@ dzopen(dev, flag)
        tp = &dz_tty[unit];
        tp->t_addr = (caddr_t)&dzpdma[unit];
        tp->t_oproc = dzstart;
        tp = &dz_tty[unit];
        tp->t_addr = (caddr_t)&dzpdma[unit];
        tp->t_oproc = dzstart;
-       tp->t_iproc = NULL;
-       tp->t_state |= WOPEN;
-       if ((tp->t_state & ISOPEN) == 0) {
+       tp->t_state |= TS_WOPEN;
+       if ((tp->t_state & TS_ISOPEN) == 0) {
                ttychars(tp);
                ttychars(tp);
-               tp->t_ospeed = tp->t_ispeed = B300;
-               tp->t_flags = ODDP|EVENP|ECHO;
-               /* tp->t_state |= HUPCLS; */
+               tp->t_ospeed = tp->t_ispeed = ISPEED;
+               tp->t_flags = IFLAGS;
+               /* tp->t_state |= TS_HUPCLS; */
                dzparam(unit);
                dzparam(unit);
-       } else if (tp->t_state&XCLUDE && u.u_uid != 0) {
+       } else if (tp->t_state&TS_XCLUDE && u.u_uid != 0) {
                u.u_error = EBUSY;
                return;
        }
                u.u_error = EBUSY;
                return;
        }
-       dzmodem(unit, DZ_ON);
+       (void) dzmctl(dev, DZ_ON, DMSET);
        (void) spl5();
        (void) spl5();
-       while ((tp->t_state & CARR_ON) == 0) {
-               tp->t_state |= WOPEN;
+       while ((tp->t_state & TS_CARR_ON) == 0) {
+               tp->t_state |= TS_WOPEN;
                sleep((caddr_t)&tp->t_rawq, TTIPRI);
        }
        (void) spl0();
                sleep((caddr_t)&tp->t_rawq, TTIPRI);
        }
        (void) spl0();
@@ -186,16 +240,20 @@ dzclose(dev, flag)
 {
        register struct tty *tp;
        register int unit;
 {
        register struct tty *tp;
        register int unit;
+       register struct device *dzaddr;
        int dz;
  
        unit = minor(dev);
        dz = unit >> 3;
        tp = &dz_tty[unit];
        (*linesw[tp->t_line].l_close)(tp);
        int dz;
  
        unit = minor(dev);
        dz = unit >> 3;
        tp = &dz_tty[unit];
        (*linesw[tp->t_line].l_close)(tp);
-       ((struct pdma *)(tp->t_addr))->p_addr->dzbrk =
-           (dz_brk[dz] &= ~(1 << (unit&07)));
-       if (tp->t_state & HUPCLS)
-               dzmodem(unit, DZ_OFF);
+       dzaddr = dzpdma[unit].p_addr;
+       if (dzaddr->dzcsr&DZ_32)
+               (void) dzmctl(dev, DZ_BRK, DMBIC);
+       else
+               dzaddr->dzbrk = (dz_brk[dz] &= ~(1 << (unit&07)));
+       if ((tp->t_state&(TS_HUPCLS|TS_WOPEN)) || (tp->t_state&TS_ISOPEN) == 0)
+               (void) dzmctl(dev, DZ_OFF, DMSET);
        ttyclose(tp);
 }
  
        ttyclose(tp);
 }
  
@@ -233,12 +291,40 @@ dzrint(dz)
        unit = dz * 8;
        dzaddr = dzpdma[unit].p_addr;
        tp0 = &dz_tty[unit];
        unit = dz * 8;
        dzaddr = dzpdma[unit].p_addr;
        tp0 = &dz_tty[unit];
+       dzaddr->dzcsr &= ~(DZ_RIE|DZ_MIE);      /* the manual says this song */
+       dzaddr->dzcsr |= DZ_RIE|DZ_MIE;         /*   and dance is necessary */
+       while (dzaddr->dzcsr & DZ_MSC) {        /* DZ32 modem change interrupt */
+               c = dzaddr->dzmtsr;
+               tp = tp0 + (c&7);
+               if (tp >= &dz_tty[dz_cnt])
+                       break;
+               dzaddr->dzlcs = c&7;    /* get status of modem lines */
+               dzwait(dzaddr);         /* wait for them */
+               if (c & DZ_CD)          /* carrier status change? */
+               if (dzaddr->dzlcs & DZ_CD) {    /* carrier up? */
+                       if ((tp->t_state&TS_CARR_ON) == 0) {
+                               wakeup((caddr_t)&tp->t_rawq);
+                               tp->t_state |= TS_CARR_ON;
+                       }
+               } else {        /* no carrier */
+                       if (tp->t_state&TS_CARR_ON) {
+                               gsignal(tp->t_pgrp, SIGHUP);
+                               gsignal(tp->t_pgrp, SIGCONT);
+                               dzaddr->dzlcs = DZ_ACK|(c&7);
+                               flushtty(tp, FREAD|FWRITE);
+                       }
+                       tp->t_state &= ~TS_CARR_ON;
+               }
+       }
        while ((c = dzaddr->dzrbuf) < 0) {      /* char present */
                tp = tp0 + ((c>>8)&07);
                if (tp >= &dz_tty[dz_cnt])
                        continue;
        while ((c = dzaddr->dzrbuf) < 0) {      /* char present */
                tp = tp0 + ((c>>8)&07);
                if (tp >= &dz_tty[dz_cnt])
                        continue;
-               if ((tp->t_state & ISOPEN) == 0) {
+               if ((tp->t_state & TS_ISOPEN) == 0) {
                        wakeup((caddr_t)&tp->t_rawq);
                        wakeup((caddr_t)&tp->t_rawq);
+#ifdef PORTSELECTOR
+                       if ((tp->t_state&TS_WOPEN) == 0)
+#endif
                        continue;
                }
                if (c&DZ_FE)
                        continue;
                }
                if (c&DZ_FE)
@@ -247,7 +333,7 @@ dzrint(dz)
                        else
                                c = tun.t_intrc;
                if (c&DZ_DO && overrun == 0) {
                        else
                                c = tun.t_intrc;
                if (c&DZ_DO && overrun == 0) {
-                       printf("dz%d: silo overflow\n", dz);
+                       /* printf("dz%d,%d: silo overflow\n", dz, (c>>8)&7); */
                        overrun = 1;
                }
                if (c&DZ_PE)    
                        overrun = 1;
                }
                if (c&DZ_PE)    
@@ -272,6 +358,8 @@ dzioctl(dev, cmd, addr, flag)
        register struct tty *tp;
        register int unit = minor(dev);
        register int dz = unit >> 3;
        register struct tty *tp;
        register int unit = minor(dev);
        register int dz = unit >> 3;
+       register struct device *dzaddr;
+       int temp;
  
        tp = &dz_tty[unit];
        cmd = (*linesw[tp->t_line].l_ioctl)(tp, cmd, addr);
  
        tp = &dz_tty[unit];
        cmd = (*linesw[tp->t_line].l_ioctl)(tp, cmd, addr);
@@ -283,23 +371,78 @@ dzioctl(dev, cmd, addr, flag)
        } else switch(cmd) {
 
        case TIOCSBRK:
        } else switch(cmd) {
 
        case TIOCSBRK:
-               ((struct pdma *)(tp->t_addr))->p_addr->dzbrk =
-                       (dz_brk[dz] |= 1 << (unit&07));
+               dzaddr = ((struct pdma *)(tp->t_addr))->p_addr;
+               if (dzaddr->dzcsr&DZ_32)
+                       (void) dzmctl(dev, DZ_BRK, DMBIS);
+               else
+                       dzaddr->dzbrk = (dz_brk[dz] |= 1 << (unit&07));
                break;
        case TIOCCBRK:
                break;
        case TIOCCBRK:
-               ((struct pdma *)(tp->t_addr))->p_addr->dzbrk =
-                       (dz_brk[dz] &= ~(1 << (unit&07)));
+               dzaddr = ((struct pdma *)(tp->t_addr))->p_addr;
+               if (dzaddr->dzcsr&DZ_32)
+                       (void) dzmctl(dev, DZ_BRK, DMBIC);
+               else
+                       dzaddr->dzbrk = (dz_brk[dz] &= ~(1 << (unit&07)));
                break;
        case TIOCSDTR:
                break;
        case TIOCSDTR:
-               dzmodem(unit, DZ_ON);
+               (void) dzmctl(dev, DZ_DTR|DZ_RTS, DMBIS);
                break;
        case TIOCCDTR:
                break;
        case TIOCCDTR:
-               dzmodem(unit, DZ_OFF);
+               (void) dzmctl(dev, DZ_DTR|DZ_RTS, DMBIC);
+               break;
+       case TIOCMSET:
+               if (copyin(addr, (caddr_t) &temp, sizeof(temp)))
+                       u.u_error = EFAULT;
+               else
+                       (void) dzmctl(dev, dmtodz(temp), DMSET);
+               break;
+       case TIOCMBIS:
+               if (copyin(addr, (caddr_t) &temp, sizeof(temp)))
+                       u.u_error = EFAULT;
+               else
+                       (void) dzmctl(dev, dmtodz(temp), DMBIS);
+               break;
+       case TIOCMBIC:
+               if (copyin(addr, (caddr_t) &temp, sizeof(temp)))
+                       u.u_error = EFAULT;
+               else
+                       (void) dzmctl(dev, dmtodz(temp), DMBIC);
+               break;
+       case TIOCMGET:
+               temp = dztodm(dzmctl(dev, 0, DMGET));
+               if (copyout((caddr_t) &temp, addr, sizeof(temp)))
+                       u.u_error = EFAULT;
                break;
        default:
                u.u_error = ENOTTY;
        }
 }
                break;
        default:
                u.u_error = ENOTTY;
        }
 }
+
+dmtodz(bits)
+       register int bits;
+{
+       register int b;
+
+       b = (bits >>1) & 0370;
+       if (bits & DML_ST) b |= DZ_ST;
+       if (bits & DML_RTS) b |= DZ_RTS;
+       if (bits & DML_DTR) b |= DZ_DTR;
+       if (bits & DML_LE) b |= DZ_LE;
+       return(b);
+}
+
+dztodm(bits)
+       register int bits;
+{
+       register int b;
+
+       b = (bits << 1) & 0360;
+       if (bits & DZ_DSR) b |= DML_DSR;
+       if (bits & DZ_DTR) b |= DML_DTR;
+       if (bits & DZ_ST) b |= DML_ST;
+       if (bits & DZ_RTS) b |= DML_RTS;
+       return(b);
+}
  
 dzparam(unit)
        register int unit;
  
 dzparam(unit)
        register int unit;
@@ -313,7 +456,7 @@ dzparam(unit)
        dzaddr->dzcsr = DZ_IEN;
        dzact |= (1<<(unit>>3));
        if (tp->t_ispeed == 0) {
        dzaddr->dzcsr = DZ_IEN;
        dzact |= (1<<(unit>>3));
        if (tp->t_ispeed == 0) {
-               dzmodem(unit, DZ_OFF);          /* hang up line */
+               (void) dzmctl(unit, DZ_OFF, DMSET);     /* hang up line */
                return;
        }
        lpr = (dz_speeds[tp->t_ispeed]<<8) | (unit & 07);
                return;
        }
        lpr = (dz_speeds[tp->t_ispeed]<<8) | (unit & 07);
@@ -332,21 +475,28 @@ dzxint(tp)
        register struct tty *tp;
 {
        register struct pdma *dp;
        register struct tty *tp;
 {
        register struct pdma *dp;
-       register s;
+       register s, dz, unit;
  
        s = spl5();             /* block pdma interrupts */
        dp = (struct pdma *)tp->t_addr;
  
        s = spl5();             /* block pdma interrupts */
        dp = (struct pdma *)tp->t_addr;
-       tp->t_state &= ~BUSY;
-       if (tp->t_state & FLUSH)
-               tp->t_state &= ~FLUSH;
-       else
+       tp->t_state &= ~TS_BUSY;
+       if (tp->t_state & TS_FLUSH)
+               tp->t_state &= ~TS_FLUSH;
+       else {
                ndflush(&tp->t_outq, dp->p_mem-tp->t_outq.c_cf);
                ndflush(&tp->t_outq, dp->p_mem-tp->t_outq.c_cf);
+               dp->p_end = dp->p_mem = tp->t_outq.c_cf;
+       }
        if (tp->t_line)
                (*linesw[tp->t_line].l_start)(tp);
        else
                dzstart(tp);
        if (tp->t_line)
                (*linesw[tp->t_line].l_start)(tp);
        else
                dzstart(tp);
-       if (tp->t_outq.c_cc == 0 || (tp->t_state&BUSY)==0)
-               dp->p_addr->dztcr &= ~(1 << (minor(tp->t_dev)&07));
+       dz = minor(tp->t_dev) >> 3;
+       unit = minor(tp->t_dev) & 7;
+       if (tp->t_outq.c_cc == 0 || (tp->t_state&TS_BUSY)==0)
+               if (dp->p_addr->dzcsr & DZ_32)
+                       dp->p_addr->dzlnen = (dz_lnen[dz] &= ~(1<<unit));
+               else
+                       dp->p_addr->dztcr &= ~(1<<unit);
        splx(s);
 }
 
        splx(s);
 }
 
@@ -356,37 +506,46 @@ dzstart(tp)
        register struct pdma *dp;
        register struct device *dzaddr;
        register int cc;
        register struct pdma *dp;
        register struct device *dzaddr;
        register int cc;
-       int s;
+       int s, dz, unit;
  
        dp = (struct pdma *)tp->t_addr;
        dzaddr = dp->p_addr;
        s = spl5();
  
        dp = (struct pdma *)tp->t_addr;
        dzaddr = dp->p_addr;
        s = spl5();
-       if (tp->t_state & (TIMEOUT|BUSY|TTSTOP))
+       if (tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP))
                goto out;
                goto out;
-       if (tp->t_state&ASLEEP && tp->t_outq.c_cc <= TTLOWAT(tp)) {
-               tp->t_state &= ~ASLEEP;
-               if (tp->t_chan)
-                       mcstart(tp->t_chan, (caddr_t)&tp->t_outq);
-               else
+       if (tp->t_outq.c_cc <= TTLOWAT(tp)) {
+               if (tp->t_state&TS_ASLEEP) {
+                       tp->t_state &= ~TS_ASLEEP;
                        wakeup((caddr_t)&tp->t_outq);
                        wakeup((caddr_t)&tp->t_outq);
+               }
+               if (tp->t_wsel) {
+                       selwakeup(tp->t_wsel, tp->t_state & TS_WCOLL);
+                       tp->t_wsel = 0;
+                       tp->t_state &= ~TS_WCOLL;
+               }
        }
        if (tp->t_outq.c_cc == 0)
                goto out;
        }
        if (tp->t_outq.c_cc == 0)
                goto out;
-       if (tp->t_flags&RAW)
+       if ((tp->t_flags&RAW) || (tp->t_local&LLITOUT))
                cc = ndqb(&tp->t_outq, 0);
        else {
                cc = ndqb(&tp->t_outq, 0200);
                if (cc == 0) {
                        cc = getc(&tp->t_outq);
                        timeout(ttrstrt, (caddr_t)tp, (cc&0x7f) + 6);
                cc = ndqb(&tp->t_outq, 0);
        else {
                cc = ndqb(&tp->t_outq, 0200);
                if (cc == 0) {
                        cc = getc(&tp->t_outq);
                        timeout(ttrstrt, (caddr_t)tp, (cc&0x7f) + 6);
-                       tp->t_state |= TIMEOUT;
+                       tp->t_state |= TS_TIMEOUT;
                        goto out;
                }
        }
                        goto out;
                }
        }
-       tp->t_state |= BUSY;
+       tp->t_state |= TS_BUSY;
        dp->p_end = dp->p_mem = tp->t_outq.c_cf;
        dp->p_end += cc;
        dp->p_end = dp->p_mem = tp->t_outq.c_cf;
        dp->p_end += cc;
-       dzaddr->dztcr |= 1 << (minor(tp->t_dev) & 07);  /* force intr */
+       dz = minor(tp->t_dev) >> 3;
+       unit = minor(tp->t_dev) & 7;
+       if (dzaddr->dzcsr & DZ_32)
+               dzaddr->dzlnen = (dz_lnen[dz] |= (1<<unit));
+       else
+               dzaddr->dztcr |= (1<<unit);
 out:
        splx(s);
 }
 out:
        splx(s);
 }
@@ -403,26 +562,68 @@ dzstop(tp, flag)
 
        dp = (struct pdma *)tp->t_addr;
        s = spl5();
 
        dp = (struct pdma *)tp->t_addr;
        s = spl5();
-       if (tp->t_state & BUSY) {
+       if (tp->t_state & TS_BUSY) {
                dp->p_end = dp->p_mem;
                dp->p_end = dp->p_mem;
-               if ((tp->t_state&TTSTOP)==0)
-                       tp->t_state |= FLUSH;
+               if ((tp->t_state&TS_TTSTOP)==0)
+                       tp->t_state |= TS_FLUSH;
        }
        splx(s);
 }
  
        }
        splx(s);
 }
  
-dzmodem(unit, flag)
-       register int unit;
+dzmctl(dev, bits, how)
+       dev_t dev;
+       int bits, how;
 {
        register struct device *dzaddr;
 {
        register struct device *dzaddr;
-       register char bit;
- 
+       register int unit, mbits;
+       int b, s;
+
+       unit = minor(dev);
+       b = 1<<(unit&7);
        dzaddr = dzpdma[unit].p_addr;
        dzaddr = dzpdma[unit].p_addr;
-       bit = 1<<(unit&07);
-       if (flag == DZ_OFF)
-               dzaddr->dzdtr &= ~bit;
-       else
-               dzaddr->dzdtr |= bit;
+       s = spl5();
+       if (dzaddr->dzcsr & DZ_32) {
+               dzwait(dzaddr)
+               DELAY(100);             /* IS 100 TOO MUCH? */
+               dzaddr->dzlcs = unit&7;
+               DELAY(100);
+               dzwait(dzaddr)
+               DELAY(100);
+               mbits = dzaddr->dzlcs;
+               mbits &= 0177770;
+       } else {
+               mbits = (dzaddr->dzdtr & b) ? DZ_DTR : 0;
+               mbits |= (dzaddr->dzmsr & b) ? DZ_CD : 0;
+               mbits |= (dzaddr->dztbuf & b) ? DZ_RI : 0;
+       }
+       switch (how) {
+       case DMSET:
+               mbits = bits;
+               break;
+
+       case DMBIS:
+               mbits |= bits;
+               break;
+
+       case DMBIC:
+               mbits &= ~bits;
+               break;
+
+       case DMGET:
+               (void) splx(s);
+               return(mbits);
+       }
+       if (dzaddr->dzcsr & DZ_32) {
+               mbits |= DZ_ACK|(unit&7);
+               dzaddr->dzlcs = mbits;
+       } else {
+               if (mbits & DZ_DTR)
+                       dzaddr->dzdtr |= b;
+               else
+                       dzaddr->dzdtr &= ~b;
+       }
+       (void) splx(s);
+       return(mbits);
 }
  
 dzscan()
 }
  
 dzscan()
@@ -431,6 +632,7 @@ dzscan()
        register struct device *dzaddr;
        register bit;
        register struct tty *tp;
        register struct device *dzaddr;
        register bit;
        register struct tty *tp;
+       register car;
  
        for (i = 0; i < dz_cnt ; i++) {
                dzaddr = dzpdma[i].p_addr;
  
        for (i = 0; i < dz_cnt ; i++) {
                dzaddr = dzpdma[i].p_addr;
@@ -438,23 +640,32 @@ dzscan()
                        continue;
                tp = &dz_tty[i];
                bit = 1<<(i&07);
                        continue;
                tp = &dz_tty[i];
                bit = 1<<(i&07);
-               if ((dzsoftCAR[i>>3]&bit) || (dzaddr->dzmsr&bit)) {
+               car = 0;
+               if (dzsoftCAR[i>>3]&bit)
+                       car = 1;
+               else if (dzaddr->dzcsr & DZ_32) {
+                       dzaddr->dzlcs = i&07;
+                       dzwait(dzaddr);
+                       car = dzaddr->dzlcs & DZ_CD;
+               } else
+                       car = dzaddr->dzmsr&bit;
+               if (car) {
                        /* carrier present */
                        /* carrier present */
-                       if ((tp->t_state & CARR_ON) == 0) {
+                       if ((tp->t_state & TS_CARR_ON) == 0) {
                                wakeup((caddr_t)&tp->t_rawq);
                                wakeup((caddr_t)&tp->t_rawq);
-                               tp->t_state |= CARR_ON;
+                               tp->t_state |= TS_CARR_ON;
                        }
                } else {
                        }
                } else {
-                       if ((tp->t_state&CARR_ON) &&
+                       if ((tp->t_state&TS_CARR_ON) &&
                            (tp->t_local&LNOHANG)==0) {
                                /* carrier lost */
                            (tp->t_local&LNOHANG)==0) {
                                /* carrier lost */
-                               if (tp->t_state&ISOPEN) {
+                               if (tp->t_state&TS_ISOPEN) {
                                        gsignal(tp->t_pgrp, SIGHUP);
                                        gsignal(tp->t_pgrp, SIGCONT);
                                        dzaddr->dzdtr &= ~bit;
                                        flushtty(tp, FREAD|FWRITE);
                                }
                                        gsignal(tp->t_pgrp, SIGHUP);
                                        gsignal(tp->t_pgrp, SIGCONT);
                                        dzaddr->dzdtr &= ~bit;
                                        flushtty(tp, FREAD|FWRITE);
                                }
-                               tp->t_state &= ~CARR_ON;
+                               tp->t_state &= ~TS_CARR_ON;
                        }
                }
        }
                        }
                }
        }
@@ -487,10 +698,10 @@ dzreset(uban)
                if (unit%8 == 0)
                        printf(" dz%d", unit>>3);
                tp = &dz_tty[unit];
                if (unit%8 == 0)
                        printf(" dz%d", unit>>3);
                tp = &dz_tty[unit];
-               if (tp->t_state & (ISOPEN|WOPEN)) {
+               if (tp->t_state & (TS_ISOPEN|TS_WOPEN)) {
                        dzparam(unit);
                        dzparam(unit);
-                       dzmodem(unit, DZ_ON);
-                       tp->t_state &= ~BUSY;
+                       (void) dzmctl(unit, DZ_ON, DMSET);
+                       tp->t_state &= ~TS_BUSY;
                        dzstart(tp);
                }
        }
                        dzstart(tp);
                }
        }
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.