add correct Berkeley copyright

[unix-history] / usr / src / sys / vax / uba / qd.c

diff --git a/usr/src/sys/vax/uba/qd.c b/usr/src/sys/vax/uba/qd.c
index 6d4bf26..916a8dc 100644 (file)
--- a/usr/src/sys/vax/uba/qd.c
+++ b/usr/src/sys/vax/uba/qd.c
@@ -1,16 +1,25 @@
 /*
 /*

- * Copyright (c) 1982, 1986 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+ * Copyright (c) 1988 Regents of the University of California.
+ * All rights reserved.

  *
  *

- *     @(#)qd.c        1.4  Berkeley  %G%
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

  *
  *

- * derived from: "@(#)qd.c     1.40    ULTRIX  10/2/86";
+ *     @(#)qd.c        1.10 (Berkeley) %G%

  */
 
 /************************************************************************
 *                                                                      *
  */
 
 /************************************************************************
 *                                                                      *

-*                      Copyright (c) 1985, 1986 by                     *
+*                      Copyright (c) 1985-1988 by                      *

 *              Digital Equipment Corporation, Maynard, MA              *
 *                      All rights reserved.                            *
 *                                                                      *
 *              Digital Equipment Corporation, Maynard, MA              *
 *                      All rights reserved.                            *
 *                                                                      *


@@ -29,13 +38,15 @@
 *   of its software on equipment which is not supplied by Digital.     *
 *                                                                      *
 *************************************************************************/
 *   of its software on equipment which is not supplied by Digital.     *
 *                                                                      *
 *************************************************************************/

+

 /*
 /*

- * qd.c - QDSS display driver
+ * qd.c - QDSS display driver for VAXSTATION-II GPX workstation

  */
 
 #include "qd.h"
  */
 
 #include "qd.h"

-#if NQD > 0

 
 

+#if NQD > 0
+#include "types.h"

 #include "../machine/pte.h"
 #include "../machine/mtpr.h"
 #include "../machine/cpu.h"
 #include "../machine/pte.h"
 #include "../machine/mtpr.h"
 #include "../machine/cpu.h"


@@ -48,79 +59,80 @@
 #include "map.h"
 #include "buf.h"
 #include "vm.h"
 #include "map.h"
 #include "buf.h"
 #include "vm.h"

+#include "bk.h"

 #include "clist.h"
 #include "file.h"
 #include "uio.h"
 #include "kernel.h"
 #include "clist.h"
 #include "file.h"
 #include "uio.h"
 #include "kernel.h"

+#include "exec.h"
+#include "proc.h"

 #include "ubareg.h"
 #include "ubavar.h"
 #include "syslog.h"
 #include "ubareg.h"
 #include "ubavar.h"
 #include "syslog.h"

-#include "qduser.h"    /* definitions shared with client */
-#include "qdreg.h"
+#include "qduser.h"    /* definitions shared with user level client */
+#include "qdreg.h"     /* QDSS device register structures */

 
 /*
 
 /*

-* QDSS driver status flags for tracking operational state 
-*/
-
+ * QDSS driver status flags for tracking operational state 
+ */

 struct qdflags {
 struct qdflags {

-
-    u_int inuse;           /* which minor dev's are in use now */
-    u_int config;          /* I/O page register content */
-    u_int mapped;          /* user mapping status word */
-    u_int kernel_loop;     /* if kernel console is redirected */
-    u_int user_dma;        /* DMA from user space in progress */
-    u_short pntr_id;       /* type code of pointing device */
-    u_short duart_imask;    /* shadowing for duart intrpt mask reg */
-    u_short adder_ie;      /* shadowing for adder intrpt enbl reg */
-    u_short curs_acc;      /* cursor acceleration factor */
-    u_short curs_thr;      /* cursor acceleration threshold level */
-    u_short tab_res;       /* tablet resolution factor */
-    u_short selmask;       /* mask for active qd select entries */
+       u_int inuse;            /* which minor dev's are in use now */
+       u_int config;           /* I/O page register content */
+       u_int mapped;           /* user mapping status word */
+       u_int kernel_loop;      /* if kernel console is redirected */
+       u_int user_dma;         /* DMA from user space in progress */
+       u_short pntr_id;        /* type code of pointing device */
+       u_short duart_imask;    /* shadowing for duart intrpt mask reg */
+       u_short adder_ie;       /* shadowing for adder intrpt enbl reg */
+       u_short curs_acc;       /* cursor acceleration factor */
+       u_short curs_thr;       /* cursor acceleration threshold level */
+       u_short tab_res;        /* tablet resolution factor */
+       u_short selmask;        /* mask for active qd select entries */

 };
 
 };
 

-/* #define POSIXTTY (4.4BSD) */
-
-/* bit definitions for "inuse" entry  */
+/*
+ * bit definitions for 'inuse' entry  
+ */

 #define CONS_DEV       0x01
 #define CONS_DEV       0x01

-#define ALTCONS_DEV    0x02

 #define GRAPHIC_DEV    0x04
 
 #define GRAPHIC_DEV    0x04
 

-/* bit definitions for 'mapped' member of flag structure */
+/*
+ * bit definitions for 'mapped' member of flag structure 
+ */

 #define MAPDEV         0x01            /* hardware is mapped */
 #define MAPDMA         0x02            /* DMA buffer mapped */
 #define MAPEQ          0x04            /* event queue buffer mapped */
 #define MAPSCR         0x08            /* scroll param area mapped */
 #define MAPCOLOR       0x10            /* color map writing buffer mapped */
 
 #define MAPDEV         0x01            /* hardware is mapped */
 #define MAPDMA         0x02            /* DMA buffer mapped */
 #define MAPEQ          0x04            /* event queue buffer mapped */
 #define MAPSCR         0x08            /* scroll param area mapped */
 #define MAPCOLOR       0x10            /* color map writing buffer mapped */
 

-/* bit definitions for 'selmask' member of qdflag structure */
-
+/*
+ * bit definitions for 'selmask' member of qdflag structure 
+ */

 #define SEL_READ       0x01            /* read select is active */
 #define SEL_WRITE      0x02            /* write select is active */
 
 /*
 #define SEL_READ       0x01            /* read select is active */
 #define SEL_WRITE      0x02            /* write select is active */
 
 /*

-* constants used in shared memory operations 
-*/
-
+ * constants used in shared memory operations 
+ */

 #define EVENT_BUFSIZE  1024    /* # of bytes per device's event buffer */
 #define MAXEVENTS  ( (EVENT_BUFSIZE - sizeof(struct qdinput))   \
 #define EVENT_BUFSIZE  1024    /* # of bytes per device's event buffer */
 #define MAXEVENTS  ( (EVENT_BUFSIZE - sizeof(struct qdinput))   \

-                    / sizeof(struct _vs_event) )
+       / sizeof(struct _vs_event) )

 #define DMA_BUFSIZ     (1024 * 10)
 #define COLOR_BUFSIZ  ((sizeof(struct color_buf) + 512) & ~0x01FF)
 
 /*
 #define DMA_BUFSIZ     (1024 * 10)
 #define COLOR_BUFSIZ  ((sizeof(struct color_buf) + 512) & ~0x01FF)
 
 /*

-* reference to an array of "uba_device" structures built by the auto
-* configuration program.  The uba_device structure decribes the device
-* sufficiently for the driver to talk to it.  The auto configuration code
-* fills in the uba_device structures (located in ioconf.c) from user
-* maintained info.  
-*/
-
+ * reference to an array of "uba_device" structures built by the auto
+ * configuration program.  The uba_device structure decribes the device
+ * sufficiently for the driver to talk to it.  The auto configuration code
+ * fills in the uba_device structures (located in ioconf.c) from user
+ * maintained info.  
+ */

 struct uba_device *qdinfo[NQD];  /* array of pntrs to each QDSS's */
 struct uba_device *qdinfo[NQD];  /* array of pntrs to each QDSS's */

-                                /* uba structures  */

 struct tty qd_tty[NQD*4];      /* teletype structures for each.. */
 struct tty qd_tty[NQD*4];      /* teletype structures for each.. */

-                               /* ..possible minor device */
-
-struct qd_softc qd_softc[NQD];
+extern char qvmem[][128*NBPG];
+extern struct pte QVmap[][128];
+#define CHUNK    (64 * 1024)
+#define QMEMSIZE  (1024 * 1024 * 4)    /* 4 meg */

 
 /*
  * static storage used by multiple functions in this code  
 
 /*
  * static storage used by multiple functions in this code  


@@ -130,95 +142,73 @@ struct qdflags qdflags[NQD];      /* QDSS device status flags */
 struct qdmap qdmap[NQD];       /* QDSS register map structure */
 caddr_t qdbase[NQD];           /* base address of each QDSS unit */
 struct buf qdbuf[NQD];         /* buf structs used by strategy */
 struct qdmap qdmap[NQD];       /* QDSS register map structure */
 caddr_t qdbase[NQD];           /* base address of each QDSS unit */
 struct buf qdbuf[NQD];         /* buf structs used by strategy */

-char one_only[NQD];            /* lock for single process access */
+short qdopened[NQD];           /* graphics device is open exclusive use */

 
 /*
 
 /*

-* The array "event_shared[]" is made up of a number of event queue buffers
-* equal to the number of QDSS's configured into the running kernel (NQD).
-* Each event queue buffer begins with an event queue header (struct qdinput)
-* followed by a group of event queue entries (struct _vs_event).  The array
-* "*eq_header[]" is an array of pointers to the start of each event queue
-* buffer in "event_shared[]".  
-*/
-
+ * the array "event_shared[]" is made up of a number of event queue buffers
+ * equal to the number of QDSS's configured into the running kernel (NQD).
+ * Each event queue buffer begins with an event queue header (struct qdinput)
+ * followed by a group of event queue entries (struct _vs_event).  The array
+ * "*eq_header[]" is an array of pointers to the start of each event queue
+ * buffer in "event_shared[]".  
+ */

 #define EQSIZE ((EVENT_BUFSIZE * NQD) + 512)
 
 char event_shared[EQSIZE];         /* reserve space for event bufs */
 struct qdinput *eq_header[NQD];     /* event queue header pntrs */
 
 /*
 #define EQSIZE ((EVENT_BUFSIZE * NQD) + 512)
 
 char event_shared[EQSIZE];         /* reserve space for event bufs */
 struct qdinput *eq_header[NQD];     /* event queue header pntrs */
 
 /*

-* This allocation method reserves enough memory pages for NQD shared DMA I/O
-* buffers.  Each buffer must consume an integral number of memory pages to
-* guarantee that a following buffer will begin on a page boundary.  Also,
-* enough space is allocated so that the FIRST I/O buffer can start at the
-* 1st page boundary after "&DMA_shared".  Page boundaries are used so that
-* memory protections can be turned on/off for individual buffers. 
-*/
-
+ * This allocation method reserves enough memory pages for NQD shared DMA I/O
+ * buffers.  Each buffer must consume an integral number of memory pages to
+ * guarantee that a following buffer will begin on a page boundary.  Also,
+ * enough space is allocated so that the FIRST I/O buffer can start at the
+ * 1st page boundary after "&DMA_shared".  Page boundaries are used so that
+ * memory protections can be turned on/off for individual buffers. 
+ */

 #define IOBUFSIZE  ((DMA_BUFSIZ * NQD) + 512)
 
 char DMA_shared[IOBUFSIZE];        /* reserve I/O buffer space */
 struct DMAreq_header *DMAheader[NQD];  /* DMA buffer header pntrs */
 
 /*
 #define IOBUFSIZE  ((DMA_BUFSIZ * NQD) + 512)
 
 char DMA_shared[IOBUFSIZE];        /* reserve I/O buffer space */
 struct DMAreq_header *DMAheader[NQD];  /* DMA buffer header pntrs */
 
 /*

-* The driver assists a client in scroll operations by loading dragon
-* registers from an interrupt service routine. The loading is done using
-* parameters found in memory shrade between the driver and it's client.
-* The scroll parameter structures are ALL loacted in the same memory page
-* for reasons of memory economy.  
-*/
-
+ * The driver assists a client in scroll operations by loading dragon
+ * registers from an interrupt service routine.        The loading is done using
+ * parameters found in memory shrade between the driver and it's client.
+ * The scroll parameter structures are ALL loacted in the same memory page
+ * for reasons of memory economy.  
+ */

 char scroll_shared[2 * 512];   /* reserve space for scroll structs */
 struct scroll *scroll[NQD];    /* pointers to scroll structures */
 
 /*
 char scroll_shared[2 * 512];   /* reserve space for scroll structs */
 struct scroll *scroll[NQD];    /* pointers to scroll structures */
 
 /*

-* the driver is programmable to provide the user with color map write
-* services at VSYNC interrupt time.  At interrupt time the driver loads
-* the color map with any user-requested load data found in shared memory 
-*/
-
+ * the driver is programmable to provide the user with color map write
+ * services at VSYNC interrupt time.  At interrupt time the driver loads
+ * the color map with any user-requested load data found in shared memory 
+ */

 #define COLOR_SHARED  ((COLOR_BUFSIZ * NQD) + 512)
 
 #define COLOR_SHARED  ((COLOR_BUFSIZ * NQD) + 512)
 

-char color_shared[COLOR_SHARED];      /* color bufs */
+char color_shared[COLOR_SHARED];      /* reserve space: color bufs */

 struct color_buf *color_buf[NQD];     /* pointers to color bufs */
 
 /*
 struct color_buf *color_buf[NQD];     /* pointers to color bufs */
 
 /*

-* mouse input event structures 
-*/
-
+ * mouse input event structures 
+ */

 struct mouse_report last_rep[NQD];
 struct mouse_report current_rep[NQD];
 
 struct mouse_report last_rep[NQD];
 struct mouse_report current_rep[NQD];
 

-/*
-* input event "select" use 
-*/
-
-struct proc *rsel[NQD];        /* process waiting for select */
-
-/*
-* console cursor structure 
-*/
-
-struct _vs_cursor cursor[NQD];
-
-
-
+struct proc *qdrsel[NQD];      /* process waiting for select */
+struct _vs_cursor cursor[NQD]; /* console cursor */
+int qdcount = 0;               /* count of successfully probed qd's */

 int nNQD = NQD;
 int nNQD = NQD;

-

 int DMAbuf_size = DMA_BUFSIZ;
 int DMAbuf_size = DMA_BUFSIZ;

+int QDlast_DMAtype;             /* type of the last DMA operation */

 
 

-
+#define QDSSMAJOR      41      /* QDSS major device number */

 /*
  * macro to get system time.  Used to time stamp event queue entries 
  */
 /*
  * macro to get system time.  Used to time stamp event queue entries 
  */

-

 #define TOY ((time.tv_sec * 100) + (time.tv_usec / 10000))
 
 #define TOY ((time.tv_sec * 100) + (time.tv_usec / 10000))
 

-/*
-* the "ioconf.c" program, built and used by auto config, externally refers
-* to definitions below.  
-*/
-

 int qdprobe();
 int qdattach();
 int qddint();                  /* DMA gate array intrpt service */
 int qdprobe();
 int qdattach();
 int qddint();                  /* DMA gate array intrpt service */


@@ -227,200 +217,163 @@ int qdiint();
 
 u_short qdstd[] = { 0 };
 
 
 u_short qdstd[] = { 0 };
 

-struct uba_driver qddriver = { /* externally referenced: ioconf.c */
-
-    qdprobe,                   /* device probe entry */
-    0,                         /* no slave device */
-    qdattach,                  /* device attach entry */
-    0,                         /* no "fill csr/ba to start" */
-    qdstd,                     /* device addresses */
-    "qd",                      /* device name string */
-    qdinfo                     /* ptr to QDSS's uba_device struct */
+struct uba_driver qddriver = {
+       qdprobe,                /* device probe entry */
+       0,                      /* no slave device */
+       qdattach,               /* device attach entry */
+       0,                      /* no "fill csr/ba to start" */
+       qdstd,                  /* device addresses */
+       "qd",                   /* device name string */
+       qdinfo                  /* ptr to QDSS's uba_device struct */

 };
 
 };
 

-extern char qvmem[][128*NBPG];
-extern struct pte QVmap[][128];
-
-/*
- * v_putc is used to redirect the console cnputc to the virtual console
- * vputc.  consops is used to direct the console device to the qvss console.
- */
-extern (*v_putc)();
-extern struct cdevsw *consops;
-
-/*
-* general defines */
-
-#define QDPRIOR (PZERO-1)
-
+#define QDPRIOR (PZERO-1)              /* must be negative */

 #define FALSE  0
 #define TRUE   ~FALSE
 #define FALSE  0
 #define TRUE   ~FALSE

-

 #define BAD    -1
 #define GOOD   0
 
 /*
 #define BAD    -1
 #define GOOD   0
 
 /*

- * Macro to create a system virtual page number from system virtual adrs.
+ * macro to create a system virtual page number from system virtual adrs 

  */
  */

-

 #define VTOP(x)  (((int)x & ~0xC0000000) >> PGSHIFT)
 
 /*
  * QDSS register address offsets from start of QDSS address space 
  */
 #define VTOP(x)  (((int)x & ~0xC0000000) >> PGSHIFT)
 
 /*
  * QDSS register address offsets from start of QDSS address space 
  */

-

 #define QDSIZE  (52 * 1024)    /* size of entire QDSS foot print */
 #define QDSIZE  (52 * 1024)    /* size of entire QDSS foot print */

-

 #define TMPSIZE  (16 * 1024)   /* template RAM is 8k SHORT WORDS */
 #define TMPSTART 0x8000        /* offset of template RAM from base adrs */
 #define TMPSIZE  (16 * 1024)   /* template RAM is 8k SHORT WORDS */
 #define TMPSTART 0x8000        /* offset of template RAM from base adrs */

-

 #define REGSIZE  (5 * 512)     /* regs touch 2.5k (5 pages) of addr space */
 #define REGSTART 0xC000        /* offset of reg pages from base adrs */
 #define REGSIZE  (5 * 512)     /* regs touch 2.5k (5 pages) of addr space */
 #define REGSTART 0xC000        /* offset of reg pages from base adrs */

-

 #define ADDER  (REGSTART+0x000)
 #define DGA    (REGSTART+0x200)
 #define DUART  (REGSTART+0x400)
 #define MEMCSR (REGSTART+0x800)
 #define ADDER  (REGSTART+0x000)
 #define DGA    (REGSTART+0x200)
 #define DUART  (REGSTART+0x400)
 #define MEMCSR (REGSTART+0x800)

-

 #define CLRSIZE  (3 * 512)             /* color map size */
 #define CLRSTART (REGSTART+0xA00)      /* color map start offset from base */
 #define CLRSIZE  (3 * 512)             /* color map size */
 #define CLRSTART (REGSTART+0xA00)      /* color map start offset from base */

-                                       /*  0x0C00 really */
+/*  0x0C00 really */

 #define RED    (CLRSTART+0x000)
 #define BLUE   (CLRSTART+0x200)
 #define GREEN  (CLRSTART+0x400)
 
 #define RED    (CLRSTART+0x000)
 #define BLUE   (CLRSTART+0x200)
 #define GREEN  (CLRSTART+0x400)
 

-/*
- * Values used in mapping QDSS hardware into the Q memory space.
- */
-
-#define CHUNK    (64 * 1024)
-#define QMEMSIZE  (1024 * 1024 * 4)

 
 /*
 
 /*

-* QDSS minor device numbers.  The *real* minor device numbers are in
-* the bottom two bits of the major/minor device spec.  Bits 2 and up are
-* used to specify the QDSS device number (ie: which one?)
-*/
-
-#define QDSSMAJOR      41              /* QDSS major device number */
+ * QDSS minor device numbers.  The *real* minor device numbers are in
+ * the bottom two bits of the major/minor device spec.  Bits 2 and up are
+ * used to specify the QDSS device number (ie: which one?) 
+ */

 
 #define CONS           0
 
 #define CONS           0

-#define ALTCONS        1

 #define GRAPHIC        2
 
 /*
 #define GRAPHIC        2
 
 /*

- * console cursor bitmap (block cursor type) 
+ * console cursor bitmap (white block cursor)  

  */
  */

-
-       short cons_cursor[32] = {      /* white block cursor */
-
- /* A */ 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF,
-        0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF,
- /* B */ 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF,
-        0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF
-
-       };
+short cons_cursor[32] = {
+       /* A */ 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF,
+       0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF,
+       /* B */ 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF,
+       0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF
+};

 
 /*
  * constants used in font operations 
  */
 
 /*
  * constants used in font operations 
  */

-
-#define CHARS          95                      /* # of chars in the font */
+#define CHARS          190                     /* # of chars in the font */

 #define CHAR_HEIGHT    15                      /* char height in pixels */
 #define CHAR_WIDTH     8                       /* char width in pixels*/
 #define FONT_WIDTH     (CHAR_WIDTH * CHARS)    /* font width in pixels */
 #define ROWS           CHAR_HEIGHT
 #define CHAR_HEIGHT    15                      /* char height in pixels */
 #define CHAR_WIDTH     8                       /* char width in pixels*/
 #define FONT_WIDTH     (CHAR_WIDTH * CHARS)    /* font width in pixels */
 #define ROWS           CHAR_HEIGHT

-
-

 #define FONT_X         0                       /* font's off screen adrs */
 #define FONT_Y         (2048 - CHAR_HEIGHT)
 #define FONT_X         0                       /* font's off screen adrs */
 #define FONT_Y         (2048 - CHAR_HEIGHT)

-/*
-#define FONT_Y         200
-*/

 
 

-extern char q_font[];          /* reference font object code */
+/* Offset to second row characters (XXX - should remove) */
+#define FONT_OFFSET    ((MAX_SCREEN_X/CHAR_WIDTH)*CHAR_HEIGHT)

 
 

-extern char q_key[];           /* reference key xlation tables */
-extern char q_shift_key[];
+extern char q_font[];          /* reference font object code */
+extern u_short q_key[];        /* reference key xlation tables */
+extern u_short q_shift_key[];

 extern char *q_special[];
 
 /*
 extern char *q_special[];
 
 /*

- * definitions for cursor acceleration reporting
+ * definitions for cursor acceleration reporting  

  */
  */

-

 #define ACC_OFF        0x01            /* acceleration is inactive */
 
 #define ACC_OFF        0x01            /* acceleration is inactive */
 

-int qdputc();          /* used to direct kernel console output *
-int qdstart();         /* used to direct /dev/console output *
+/*
+ * virtual console support.
+ */
+extern (*v_putc)();
+extern struct cdevsw *consops;
+int qdputc();
+int qdstart();

 
 /*
  * LK-201 state storage for input console keyboard conversion to ASCII 
  */
 
 /*
  * LK-201 state storage for input console keyboard conversion to ASCII 
  */

-

 struct q_keyboard {
 struct q_keyboard {

-    int shift;                 /* state variables      */
-    int cntrl;
-    int lock;
-    int lastcode;              /* last keycode typed   */
-    unsigned kup[8];           /* bits for each keycode*/
-    unsigned dkeys[8];         /* down/up mode keys    */
-    char last;                 /* last character       */
+       int shift;                      /* state variables      */
+       int cntrl;
+       int lock;
+       int lastcode;                   /* last keycode typed   */
+       unsigned kup[8];                /* bits for each keycode*/
+       unsigned dkeys[8];              /* down/up mode keys    */
+       char last;                      /* last character       */

 } q_keyboard;
 
 } q_keyboard;
 

+/*
+ * tty settings on first open
+ */
+#define IFLAGS (EVENP|ECHO|XTABS|CRMOD)
+#ifdef POSIXTTY
+#define IFLAG (BRKINT|ISTRIP|IXON|IXANY|ICRNL|IEXTEN|IMAXBEL)
+#define OFLAG (OPOST|OXTABS|ONLCR)
+#define LFLAG (ISIG|ICANON|ECHO)
+#define CFLAG (PARENB|CREAD|CS7|CLOCAL)
+#endif

 
 

-/*********************************************************************
-*
-*      qdcons_init - init QDSS as console (BEFORE probe routine)
-*
-*********************************************************************/
+/*
+ * Init QDSS as console (before probe routine)
+ */

 
 qdcons_init()
 {
 
 qdcons_init()
 {

-       register u_int unit;
-
-       struct percpu *pcpu;            /* pointer to percpu structure */
-       register struct qbus *qb;
-       int *ptep;                      /* page table entry pointer */
+       register unit;

        caddr_t phys_adr;               /* physical QDSS base adrs */
        caddr_t phys_adr;               /* physical QDSS base adrs */

-       u_int mapix;                    /* index into QMEMmap[] array */
-
+       u_int mapix;                    /* index into QVmap[] array */
+       struct percpu *pcpu;            /* pointer to cpusw structure  */
+       register struct qbus *qb;

        u_short *qdaddr;                /* address of QDSS IO page CSR */
        u_short *devptr;                /* vitual device space */
        u_short *qdaddr;                /* address of QDSS IO page CSR */
        u_short *devptr;                /* vitual device space */

-       extern  cnputc();               /* standard serial console putc */
+       extern cnputc();

 
 #define QDSSCSR 0x1F00
 
 
 #define QDSSCSR 0x1F00
 

-       /*
-        * if console already configured, dont do again.
-        */

        if (v_putc != cnputc)
        if (v_putc != cnputc)

-               return;
+           return 0;

 
        unit = 0;
 
        /*
         * find the cpusw entry that matches this machine. 
         */
 
        unit = 0;
 
        /*
         * find the cpusw entry that matches this machine. 
         */

-

        for (pcpu = percpu; pcpu && pcpu->pc_cputype != cpu; pcpu++)
                ;
        if (pcpu == NULL)
        for (pcpu = percpu; pcpu && pcpu->pc_cputype != cpu; pcpu++)
                ;
        if (pcpu == NULL)

-               return;
-
+           return 0;

 
        /*
 
        /*

-        * Map device registers - the last 8K of umem.
+        * Map device registers - the last 8K of qvmem.

         */
        qb = (struct qbus *)pcpu->pc_io->io_details;
        ioaccess(qb->qb_iopage, UMEMmap[0] + qb->qb_memsize,
         */
        qb = (struct qbus *)pcpu->pc_io->io_details;
        ioaccess(qb->qb_iopage, UMEMmap[0] + qb->qb_memsize,

-               UBAIOPAGES * NBPG);
-
+                UBAIOPAGES * NBPG);

        devptr = (u_short *)((char *)umem[0]+(qb->qb_memsize * NBPG));
        qdaddr = (u_short *)((u_int)devptr + ubdevreg(QDSSCSR));
        devptr = (u_short *)((char *)umem[0]+(qb->qb_memsize * NBPG));
        qdaddr = (u_short *)((u_int)devptr + ubdevreg(QDSSCSR));

-       if (badaddr(qdaddr, sizeof(short)))  {
-               log(LOG_ERR, "Can't find qdss (badaddr)\n"); /* debug */
-               return(0);
-       }
+       if (badaddr((caddr_t)qdaddr, sizeof(short)))
+               return 0;
+

        /*
         * Map q-bus memory used by qdss. (separate map)
         */
        /*
         * Map q-bus memory used by qdss. (separate map)
         */


@@ -430,10 +383,7 @@ qdcons_init()
 
        /*
         * tell QDSS which Q memory address base to decode 
 
        /*
         * tell QDSS which Q memory address base to decode 

-        */
-
-       /* 
-        * shifted right 16 bits - its in 64K units
+        * (shifted right 16 bits - its in 64K units)

         */
        *qdaddr = (u_short)((int)mapix >> 16);
        qdflags[unit].config = *(u_short *)qdaddr;
         */
        *qdaddr = (u_short)((int)mapix >> 16);
        qdflags[unit].config = *(u_short *)qdaddr;


@@ -441,9 +391,7 @@ qdcons_init()
        /*
         * load qdmap struct with the virtual addresses of the QDSS elements 
         */
        /*
         * load qdmap struct with the virtual addresses of the QDSS elements 
         */

-
-       qdbase[unit] = (caddr_t) qvmem[0];
-
+       qdbase[unit] = (caddr_t) (qvmem[0]);

        qdmap[unit].template = qdbase[unit] + TMPSTART;
        qdmap[unit].adder = qdbase[unit] + ADDER;
        qdmap[unit].dga = qdbase[unit] + DGA;
        qdmap[unit].template = qdbase[unit] + TMPSTART;
        qdmap[unit].adder = qdbase[unit] + ADDER;
        qdmap[unit].dga = qdbase[unit] + DGA;


@@ -456,13 +404,12 @@ qdcons_init()
        qdflags[unit].duart_imask = 0;  /* init shadow variables */
 
        /*
        qdflags[unit].duart_imask = 0;  /* init shadow variables */
 
        /*

-        * init the QDSS 
+        * init the QDSS  

         */
         */

-
-       /***
+       /* 

        printf("qdbase[0] = %x, qdmap[0].memcsr = %x\n",
                (char *)qdbase[0], qdmap[0].memcsr);
        printf("qdbase[0] = %x, qdmap[0].memcsr = %x\n",
                (char *)qdbase[0], qdmap[0].memcsr);

-       ***/
+       */

 
        *(short *)qdmap[unit].memcsr |= SYNC_ON; /* once only: turn on sync */
 
 
        *(short *)qdmap[unit].memcsr |= SYNC_ON; /* once only: turn on sync */
 


@@ -474,205 +421,186 @@ qdcons_init()
        ldfont(unit);                   /* load the console font */
        ldcursor(unit, cons_cursor);    /* load default cursor map */
        setup_input(unit);              /* init the DUART */
        ldfont(unit);                   /* load the console font */
        ldcursor(unit, cons_cursor);    /* load default cursor map */
        setup_input(unit);              /* init the DUART */

-
-       v_putc = qdputc;
-       consops = &cdevsw[QDSSMAJOR];
-
-       return(1);
+       v_putc = qdputc;                /* kernel console output to qdss */
+       consops = &cdevsw[QDSSMAJOR];   /* virtual console is qdss */
+       return 1;

 
 } /* qdcons_init */
 
 
 } /* qdcons_init */
 

-/*********************************************************************
-*
-*      qdprobe()... configure QDSS into Q memory and make it intrpt
-*
-**********************************************************************
-*
-*  calling convention:
-*                      qdprobe(reg, ctlr);
-*                      caddr_t reg;
-*                      int ctlr;
-*
-*      where: reg - a character pointer to the QDSS I/O page register
-*             ctlr - controller number (?)
-*
-*  side effects: QDSS gets mapped into Qbus memory space at the first
-*               vacant 64kb boundary counting back from the top of
-*               Qbus memory space (qmem+4mb)
-*
-*  return: QDSS bus request level and vector address returned in
-*         registers by UNIX convention.
-*
-*****************/
-
+/*
+ *  Configure QDSS into Q memory and make it intrpt.
+ *
+ *  side effects: QDSS gets mapped into Qbus memory space at the first
+ *              vacant 64kb boundary counting back from the top of
+ *              Qbus memory space (qvmem+4mb)
+ *
+ *  return: QDSS bus request level and vector address returned in
+ *        registers by UNIX convention.
+ *
+ */

 qdprobe(reg)
 qdprobe(reg)

-caddr_t reg;
+       caddr_t reg;    /* character pointer to the QDSS I/O page register */

 {
 {

-       register int br, cvec;  /* value-result */
-
+       register int br, cvec;          /* value-result */

        register int unit;
        register int unit;

-

        struct dga *dga;                /* pointer to gate array structure */
        struct dga *dga;                /* pointer to gate array structure */

-       struct cpusw *cpup;             /* pointer to the cpusw structure */
-
-       int *ptep;                      /* page table entry pointer */

        int vector;
        int vector;

-
+#ifdef notdef
+       int *ptep;                      /* page table entry pointer */

        caddr_t phys_adr;               /* physical QDSS base adrs */
        u_int mapix;
        caddr_t phys_adr;               /* physical QDSS base adrs */
        u_int mapix;

+#endif

 
 #ifdef lint
 
 #ifdef lint

-       br = 0; cvec = br; br = cvec;
+       br = 0; cvec = br; br = cvec; nNQD = br; br = nNQD;
+       qddint(0); qdaint(0); qdiint(0); (void)qdgetc();

 #endif
 
        /*
 #endif
 
        /*

-       * calculate board unit number from I/O page register address  
-       */
-
+        * calculate board unit number from I/O page register address  
+        */

        unit = (int) (((int)reg >> 1) & 0x0007);
 
        unit = (int) (((int)reg >> 1) & 0x0007);
 

-/*
-* QDSS regs must be mapped to Qbus memory space at a 64kb physical boundary.
-* The Qbus memory space is mapped into the system memory space at config
-* time.  After config runs, "qmem[0]" (ubavar.h) holds the system virtual adrs
-* of the start of Qbus memory. The Qbus memory page table is found via
-* an array of pte ptrs called "QMEMmap[]" (ubavar.h) which is also loaded at
-* config time. These are the variables used below to find a vacant 64kb
-* boundary in Qbus memory, and load it's corresponding physical adrs into
-* the QDSS's I/O page CSR.  
-*/
+       /*
+        * QDSS regs must be mapped to Qbus memory space at a 64kb
+        * physical boundary.  The Qbus memory space is mapped into
+        * the system memory space at config time.  After config
+        * runs, "qvmem[0]" (ubavar.h) holds the system virtual adrs
+        * of the start of Qbus memory.   The Qbus memory page table
+        * is found via an array of pte ptrs called "QVmap[]" (ubavar.h)
+        * which is also loaded at config time.   These are the
+        * variables used below to find a vacant 64kb boundary in
+        * Qbus memory, and load it's corresponding physical adrs
+        * into the QDSS's I/O page CSR.  
+        */
+
+       /*
+        * Only if QD is the graphics device.
+        */

 
        /* if this QDSS is NOT the console, then do init here.. */
 
 
        /* if this QDSS is NOT the console, then do init here.. */
 

-       /****** XXX - REMOVED (can't test) - STILL NEED TO DO FOR NQD > 1 ***/
-#ifdef notdef
-       if (v_consputc != qdputc  ||  unit != 0) {
-
-           /*
-            * read QDSS config info
-            */
-           qdflags[unit].config = *(u_short *)reg;
-
-           /*
-            * find an empty 64kb adrs boundary 
-            */
-           qdbase[unit] = (caddr_t) (qmem[0] + QMEMSIZE - CHUNK);
-
-           /*
-            * find the cpusw entry that matches this machine. 
-            */
-           cpup = &cpusw[cpu];
-           while ( !(BADADDR(qdbase[unit], sizeof(short))) )
-               qdbase[unit] -= CHUNK;
-
-           /*
-            * tell QDSS which Q memory address base to decode 
-            */
-           mapix = (int) (VTOP(qdbase[unit]) - VTOP(qmem[0]));
-           ptep = (int *) QMEMmap[0] + mapix;
-           phys_adr = (caddr_t) (((int)*ptep & 0x001FFFFF) << PGSHIFT);
-           *(u_short *)reg = (u_short) ((int)phys_adr >> 16);
-
-           /*
-            * load QDSS adrs map with system addresses of device regs
-            */
-           qdmap[unit].template = qdbase[unit] + TMPSTART;
-           qdmap[unit].adder = qdbase[unit] + ADDER;
-           qdmap[unit].dga = qdbase[unit] + DGA;
-           qdmap[unit].duart = qdbase[unit] + DUART;
-           qdmap[unit].memcsr = qdbase[unit] + MEMCSR;
-           qdmap[unit].red = qdbase[unit] + RED;
-           qdmap[unit].blue = qdbase[unit] + BLUE;
-           qdmap[unit].green = qdbase[unit] + GREEN;
-
-           /* device init */
-
-           cursor[unit].x = 0;
-           cursor[unit].y = 0;
-           init_shared(unit);          /* init shared memory */
-           setup_dragon(unit);         /* init the ADDER/VIPER stuff */
-           ldcursor(unit, cons_cursor);        /* load default cursor map */
-           setup_input(unit);          /* init the DUART */
-           clear_qd_screen(unit);
-           ldfont(unit);                       /* load the console font */
-
-           /* once only: turn on sync */
-
-           *(short *)qdmap[unit].memcsr |= SYNC_ON;
+       if (unit != 0) {
+               printf("qd: can't support two qdss's (yet)\n");
+#ifdef notdef  /* can't test */
+               if (v_consputc != qdputc  ||  unit != 0) {
+
+                       /*
+                       * read QDSS config info 
+                       */
+                       qdflags[unit].config = *(u_short *)reg;
+
+                       /*
+                       * find an empty 64kb adrs boundary 
+                       */
+
+                       qdbase[unit] = (caddr_t) (qvmem[0] + QMEMSIZE - CHUNK);
+
+                       /*
+                       * find the cpusw entry that matches this machine. 
+                       */
+                       cpup = &cpusw[cpu];
+                       while (!(BADADDR(qdbase[unit], sizeof(short))))
+                               qdbase[unit] -= CHUNK;
+
+                       /*
+                       * tell QDSS which Q memory address base to decode 
+                       */
+                       mapix = (int) (VTOP(qdbase[unit]) - VTOP(qvmem[0]));
+                       ptep = (int *) QVmap[0] + mapix;
+                       phys_adr = (caddr_t)(((int)*ptep&0x001FFFFF)<<PGSHIFT);
+                       *(u_short *)reg = (u_short) ((int)phys_adr >> 16);
+
+                       /*
+                       * load QDSS adrs map with system addresses 
+                       * of device regs 
+                       */
+                       qdmap[unit].template = qdbase[unit] + TMPSTART;
+                       qdmap[unit].adder = qdbase[unit] + ADDER;
+                       qdmap[unit].dga = qdbase[unit] + DGA;
+                       qdmap[unit].duart = qdbase[unit] + DUART;
+                       qdmap[unit].memcsr = qdbase[unit] + MEMCSR;
+                       qdmap[unit].red = qdbase[unit] + RED;
+                       qdmap[unit].blue = qdbase[unit] + BLUE;
+                       qdmap[unit].green = qdbase[unit] + GREEN;
+
+                       /* device init */
+
+                       cursor[unit].x = 0;
+                       cursor[unit].y = 0;
+                       init_shared(unit);              /* init shared memory */
+                       setup_dragon(unit);     /* init the ADDER/VIPER stuff */
+                       ldcursor(unit, cons_cursor);    /* load default cursor map */
+                       setup_input(unit);              /* init the DUART */
+                       clear_qd_screen(unit);
+                       ldfont(unit);                   /* load the console font */
+
+                       /* once only: turn on sync */
+
+                       *(short *)qdmap[unit].memcsr |= SYNC_ON;
+               }
+#endif /*notdef*/

        }
        }

-#endif /* notdef */

 
 

-/*
- * the QDSS interrupts at HEX vectors xx0 (DMA) xx4 (ADDER) and xx8 (DUART).
- * Therefore, we take three vectors from the vector pool, and then continue
- * to take them until we get a xx0 HEX vector.  The pool provides vectors
- * in contiguous decending order.  
- */
+       /*
+       * The QDSS interrupts at HEX vectors xx0 (DMA) xx4
+       * (ADDER) and xx8 (DUART).  Therefore, we take three
+       * vectors from the vector pool, and then continue
+       * to take them until we get a xx0 HEX vector.  The
+       * pool provides vectors in contiguous decending
+       * order.  
+       */

 
        vector = (uba_hd[0].uh_lastiv -= 4*3);  /* take three vectors */
 
 
        vector = (uba_hd[0].uh_lastiv -= 4*3);  /* take three vectors */
 

-       while (vector & 0x0F) {                    /* if lo nibble != 0.. */
-           vector = (uba_hd[0].uh_lastiv -= 4);  /* ..take another vector */
+       while (vector & 0x0F) {            /* if lo nibble != 0.. */
+               /* ..take another vector */
+               vector = (uba_hd[0].uh_lastiv -= 4);  

        }
 
        /*
        }
 
        /*

-        * setup DGA to do a DMA interrupt (transfer count = 0)
-        */
-
+       * setup DGA to do a DMA interrupt (transfer count = 0)  
+       */

        dga = (struct dga *) qdmap[unit].dga;
        dga = (struct dga *) qdmap[unit].dga;

-
-       dga->csr = (short) HALT;              /* disable everything */
-       dga->ivr = (short) vector;            /* load intrpt base vector */
-       dga->bytcnt_lo = (short) 0;           /* DMA xfer count = 0 */
+       dga->csr = (short) HALT;        /* disable everything */
+       dga->ivr = (short) vector;      /* load intrpt base vector */
+       dga->bytcnt_lo = (short) 0;     /* DMA xfer count = 0 */

        dga->bytcnt_hi = (short) 0;
 
        dga->bytcnt_hi = (short) 0;
 

-       /* turn on DMA interrupts */
-
+       /* 
+       * turn on DMA interrupts 
+       */

        dga->csr &= ~SET_DONE_FIFO;
        dga->csr |= DMA_IE | DL_ENB;
 
        DELAY(20000);                   /* wait for the intrpt */
        dga->csr &= ~SET_DONE_FIFO;
        dga->csr |= DMA_IE | DL_ENB;
 
        DELAY(20000);                   /* wait for the intrpt */

-

        dga->csr = HALT;                /* stop the wheels */
 
        if (cvec != vector)             /* if vector != base vector.. */
        dga->csr = HALT;                /* stop the wheels */
 
        if (cvec != vector)             /* if vector != base vector.. */

-           return(0);                  /* ..return = 'no device' */
+               return(0);              /* ..return = 'no device' */
+
+       /*
+       * score this as an existing qdss
+       */
+       qdcount++;

 
        return(sizeof(short));      /* return size of QDSS I/O page reg */
 
 } /* qdprobe */
 
 
        return(sizeof(short));      /* return size of QDSS I/O page reg */
 
 } /* qdprobe */
 

-/*****************************************************************
-*
-*      qdattach - one-time initialization
-*
-******************************************************************
-*
-*  calling convention:
-*                      qdattach(ui);
-*                      struct uba_device *ui;
-*
-*              where: ui - pointer to the QDSS's uba_device structure
-*
-*  side effects: none
-*       return: none
-*
-*************************/
-

 qdattach(ui)
 qdattach(ui)

-struct uba_device *ui;
+       struct uba_device *ui;

 {
 {

-       register u_int unit;            /* QDSS module # for this call */
+       register unit;                  /* QDSS module # for this call */

 
        unit = ui->ui_unit;             /* get QDSS number */
 
        /*
 
        unit = ui->ui_unit;             /* get QDSS number */
 
        /*

-        * init "qdflags[]" for this QDSS 
-        */
-
+       * init "qdflags[]" for this QDSS 
+       */

        qdflags[unit].inuse = 0;        /* init inuse variable EARLY! */
        qdflags[unit].mapped = 0;
        qdflags[unit].inuse = 0;        /* init inuse variable EARLY! */
        qdflags[unit].mapped = 0;

-       qdflags[unit].kernel_loop = 0;
+       qdflags[unit].kernel_loop = -1;

        qdflags[unit].user_dma = 0;
        qdflags[unit].curs_acc = ACC_OFF;
        qdflags[unit].curs_thr = 128;
        qdflags[unit].user_dma = 0;
        qdflags[unit].curs_acc = ACC_OFF;
        qdflags[unit].curs_thr = 128;


@@ -689,336 +617,247 @@ struct uba_device *ui;
        /*
        * init the "latest mouse report" structure 
        */
        /*
        * init the "latest mouse report" structure 
        */

-

        last_rep[unit].state = 0;
        last_rep[unit].dx = 0;
        last_rep[unit].dy = 0;
        last_rep[unit].bytcnt = 0;
 
        /*
        last_rep[unit].state = 0;
        last_rep[unit].dx = 0;
        last_rep[unit].dy = 0;
        last_rep[unit].bytcnt = 0;
 
        /*

-       * init the event queue (except mouse position)
+       * init the event queue (except mouse position) 

        */
        */

-
-       eq_header[unit]->header.events = (struct _vs_event *)
-                                         ((int)eq_header[unit]
-                                          + sizeof(struct qdinput));
+       eq_header[unit]->header.events = 
+           (struct _vs_event *)((int)eq_header[unit] + sizeof(struct qdinput));

 
        eq_header[unit]->header.size = MAXEVENTS;
        eq_header[unit]->header.head = 0;
        eq_header[unit]->header.tail = 0;
 
        /*
 
        eq_header[unit]->header.size = MAXEVENTS;
        eq_header[unit]->header.head = 0;
        eq_header[unit]->header.tail = 0;
 
        /*

-       * init single process access lock switch 
-       */
-
-       one_only[unit] = 0;
+        * open exclusive for graphics device.
+        */
+       qdopened[unit] = 0;

 
 } /* qdattach */
 
 
 } /* qdattach */
 

-/***************************************************************
-*
-*      qdopen - open a minor device
-*
-****************************************************************
-*
-*  calling convention: qdopen(dev, flag);
-*                     dev_t dev;
-*                     int flag;
-*
-*  side effects: none
-*
-*********************/
-
+/*ARGSUSED*/

 qdopen(dev, flag)
 qdopen(dev, flag)

-dev_t dev;
-int flag;
+       dev_t dev;
+       int flag;

 {
        register struct uba_device *ui; /* ptr to uba structures */
        register struct dga *dga;       /* ptr to gate array struct */
        register struct tty *tp;
 {
        register struct uba_device *ui; /* ptr to uba structures */
        register struct dga *dga;       /* ptr to gate array struct */
        register struct tty *tp;

-       int qdstart();
-
-       struct adder *adder;

        struct duart *duart;
        struct duart *duart;

-
-       u_int unit;
-       u_int minor_dev;
-       int s;
+       int unit;
+       int minor_dev;

 
        minor_dev = minor(dev); /* get QDSS minor device number */
        unit = minor_dev >> 2;
 
 
        minor_dev = minor(dev); /* get QDSS minor device number */
        unit = minor_dev >> 2;
 

-       /* check for illegal conditions */
-
+       /*
+       * check for illegal conditions  
+       */

        ui = qdinfo[unit];              /* get ptr to QDSS device struct */
        ui = qdinfo[unit];              /* get ptr to QDSS device struct */

-

        if (ui == 0  || ui->ui_alive == 0)
        if (ui == 0  || ui->ui_alive == 0)

-           return(ENXIO);              /* no such device or address */
+               return(ENXIO);          /* no such device or address */

 
 

-       /* init stuff */
-
-       adder = (struct adder *) qdmap[unit].adder;

        duart = (struct duart *) qdmap[unit].duart;
        dga = (struct dga *) qdmap[unit].dga;
 
        duart = (struct duart *) qdmap[unit].duart;
        dga = (struct dga *) qdmap[unit].dga;
 

-       /* if this is the graphic device... */
-

        if ((minor_dev & 0x03) == 2) {
        if ((minor_dev & 0x03) == 2) {

-
-           if (one_only[unit] != 0)
-               return(EBUSY);
-           else
-               one_only[unit] = 1;
-
-           qdflags[unit].inuse |= GRAPHIC_DEV;  /* graphics dev is open */
-
-           /* enble kbd & mouse intrpts in DUART mask reg */
-
-           qdflags[unit].duart_imask |= 0x22;
-           duart->imask = qdflags[unit].duart_imask;
-
-       /*
-        * if the open call is to the console or the alternate console... 
-        */
-       } else { 
-
-           qdflags[unit].inuse |= CONS_DEV;  /* mark console as open */
-           dga->csr |= CURS_ENB;
-
-           qdflags[unit].duart_imask |= 0x02;
-           duart->imask = qdflags[unit].duart_imask;
-
-           /*-------------------------------
-           * some setup for tty handling */
-
-           tp = &qd_tty[minor_dev];
-
-           tp->t_addr = ui->ui_addr;
-           tp->t_oproc = qdstart;
-
-           if ((tp->t_state & TS_ISOPEN) == 0) {
-
-               ttychars(tp);
-               tp->t_state = TS_ISOPEN | TS_CARR_ON;
-               tp->t_ispeed = B9600;
-               tp->t_ospeed = B9600;
-
-               if( (minor_dev & 0x03) == 0 ) { 
-                   tp->t_flags = XTABS|EVENP|ECHO|CRMOD;
+               /*
+               * this is the graphic device... 
+               */
+               if (qdopened[unit] != 0)
+                       return(EBUSY);
+               else
+                       qdopened[unit] = 1;
+               qdflags[unit].inuse |= GRAPHIC_DEV;  /* graphics dev is open */
+               /*
+                * enble kbd & mouse intrpts in DUART mask reg 
+                */
+               qdflags[unit].duart_imask |= 0x22;
+               duart->imask = qdflags[unit].duart_imask;
+       } else {
+               /*
+               * this is the console 
+               */
+               qdflags[unit].inuse |= CONS_DEV;  /* mark console as open */
+               dga->csr |= CURS_ENB;
+               qdflags[unit].duart_imask |= 0x02;
+               duart->imask = qdflags[unit].duart_imask;
+               /*
+               * some setup for tty handling 
+               */
+               tp = &qd_tty[minor_dev];
+               tp->t_addr = ui->ui_addr;
+               tp->t_oproc = qdstart;
+               if ((tp->t_state & TS_ISOPEN) == 0) {
+                       ttychars(tp);
+                       tp->t_flags = IFLAGS;
+                       tp->t_ispeed = B9600;
+                       tp->t_ospeed = B9600;
+                       tp->t_state = TS_ISOPEN | TS_CARR_ON;

 #ifdef POSIXTTY
 #ifdef POSIXTTY

-                   tp->t_iflag = TTYDEF_IFLAG;
-                   tp->t_oflag = TTYDEF_OFLAG;
-                   tp->t_lflag = TTYDEF_LFLAG;
-                   tp->t_cflag = TTYDEF_CFLAG;
+                       tp->t_iflag = TTYDEF_IFLAG;
+                       tp->t_oflag = TTYDEF_OFLAG;
+                       tp->t_lflag = TTYDEF_LFLAG;
+                       tp->t_cflag = TTYDEF_CFLAG;

 #endif
                }
 #endif
                }

-               else {
-                   tp->t_flags = RAW;
-               }
-           }
-
-           /*----------------------------------------
-           * enable intrpts, open line discipline */
-
-           dga->csr |= GLOBAL_IE;      /* turn on the interrupts */
-           return ((*linesw[tp->t_line].l_open)(dev, tp));
+               /*
+               * enable intrpts, open line discipline 
+               */
+               dga->csr |= GLOBAL_IE;  /* turn on the interrupts */
+               return ((*linesw[tp->t_line].l_open)(dev, tp));

        }
        }

-

        dga->csr |= GLOBAL_IE;  /* turn on the interrupts */
        return(0);
 
 } /* qdopen */
 
        dga->csr |= GLOBAL_IE;  /* turn on the interrupts */
        return(0);
 
 } /* qdopen */
 

-/***************************************************************
-*
-*      qdclose - clean up on the way out
-*
-****************************************************************
-*
-*  calling convention: qdclose();
-*
-*  side effects: none
-*
-*  return: none
-*
-*********************/
-
+/*ARGSUSED*/

 qdclose(dev, flag)
 qdclose(dev, flag)

-dev_t dev;
-int flag;
+       dev_t dev;
+       int flag;

 {
        register struct tty *tp;
        register struct qdmap *qd;
        register int *ptep;
 {
        register struct tty *tp;
        register struct qdmap *qd;
        register int *ptep;

-       int i;                          /* SIGNED index */
-

        struct dga *dga;                /* gate array register map pointer */
        struct duart *duart;
        struct adder *adder;
        struct dga *dga;                /* gate array register map pointer */
        struct duart *duart;
        struct adder *adder;

-
-       u_int unit;
-       u_int minor_dev;
+       int unit;
+       int minor_dev;

        u_int mapix;
        u_int mapix;

+       int i;                          /* SIGNED index */

 
        minor_dev = minor(dev);         /* get minor device number */
        unit = minor_dev >> 2;          /* get QDSS number */
        qd = &qdmap[unit];
 
 
        minor_dev = minor(dev);         /* get minor device number */
        unit = minor_dev >> 2;          /* get QDSS number */
        qd = &qdmap[unit];
 

-       /*
-        * if this is the graphic device... 
-        */
-

        if ((minor_dev & 0x03) == 2) {
        if ((minor_dev & 0x03) == 2) {

-           if (one_only[unit] != 1)    /* unlock driver */
-               return(EBUSY);
-           else
-               one_only[unit] = 0;
+               /*
+               * this is the graphic device... 
+               */
+               if (qdopened[unit] != 1)
+                       return(EBUSY);
+               else
+                       qdopened[unit] = 0;     /* allow it to be re-opened */
+               /*
+               * re-protect device memory 
+               */
+               if (qdflags[unit].mapped & MAPDEV) {
+                       /*
+                       * TEMPLATE RAM 
+                       */
+                       mapix = VTOP((int)qd->template) - VTOP(qvmem[0]);
+                       ptep = (int *)(QVmap[0] + mapix);
+                       for (i = 0; i < btop(TMPSIZE); i++, ptep++)
+                               *ptep = (*ptep & ~PG_PROT) | PG_V | PG_KW;
+                       /*
+                       * ADDER 
+                       */
+                       mapix = VTOP((int)qd->adder) - VTOP(qvmem[0]);
+                       ptep = (int *)(QVmap[0] + mapix);
+                       for (i = 0; i < btop(REGSIZE); i++, ptep++)
+                               *ptep = (*ptep & ~PG_PROT) | PG_V | PG_KW;
+                       /*
+                       * COLOR MAPS 
+                       */
+                       mapix = VTOP((int)qd->red) - VTOP(qvmem[0]);
+                       ptep = (int *)(QVmap[0] + mapix);
+                       for (i = 0; i < btop(CLRSIZE); i++, ptep++)
+                               *ptep = (*ptep & ~PG_PROT) | PG_V | PG_KW;
+               }

 
 

-           /*
-           * re-protect device memory 
-           */
+               /*
+               * re-protect DMA buffer and free the map registers 
+               */
+               if (qdflags[unit].mapped & MAPDMA) {
+                       dga = (struct dga *) qdmap[unit].dga;
+                       adder = (struct adder *) qdmap[unit].adder;
+                       dga->csr &= ~DMA_IE;
+                       dga->csr &= ~0x0600;         /* kill DMA */
+                       adder->command = CANCEL;
+                       /* 
+                        * if DMA was running, flush spurious intrpt 
+                        */
+                       if (dga->bytcnt_lo != 0) {
+                               dga->bytcnt_lo = 0;
+                               dga->bytcnt_hi = 0;
+                               DMA_SETIGNORE(DMAheader[unit]);
+                               dga->csr |= DMA_IE;
+                               dga->csr &= ~DMA_IE;
+                       }
+                       ptep = (int *)
+                          ((VTOP(DMAheader[unit]*4)) + (mfpr(SBR)|0x80000000));
+                       for (i = 0; i < btop(DMAbuf_size); i++, ptep++)
+                               *ptep = (*ptep & ~PG_PROT) | PG_V | PG_KW;
+                       ubarelse(0, &Qbus_unmap[unit]);
+               }

 
 

-           if (qdflags[unit].mapped & MAPDEV) {
-
-               /* TEMPLATE RAM */
-
-               mapix = VTOP((int)qd->template) - VTOP(qvmem[0]);
-               ptep = (int *)(QVmap[0] + mapix);
-
-               for (i = VTOP(TMPSIZE); i > 0; --i)
-                   *ptep++ = (*ptep & ~PG_PROT) | PG_V | PG_KW;
-
-               /* ADDER */
-
-               mapix = VTOP((int)qd->adder) - VTOP(qvmem[0]);
-               ptep = (int *)(QVmap[0] + mapix);
-
-               for (i = VTOP(REGSIZE); i > 0; --i)
-                   *ptep++ = (*ptep & ~PG_PROT) | PG_V | PG_KW;
-
-               /* COLOR MAPS */
-
-               mapix = VTOP((int)qd->red) - VTOP(qvmem[0]);
-               ptep = (int *)(QVmap[0] + mapix);
-
-               for (i = VTOP(CLRSIZE); i > 0; --i)
-                   *ptep++ = (*ptep & ~PG_PROT) | PG_V | PG_KW;
-           }
-
-           /* 
-            * re-protect DMA buffer and free the map registers 
-            */
-
-           if (qdflags[unit].mapped & MAPDMA) {
-
-               dga = (struct dga *) qdmap[unit].dga;
-               adder = (struct adder *) qdmap[unit].adder;
-
-               dga->csr &= ~DMA_IE;
-               dga->csr &= ~0x0600;         /* kill DMA */
-               adder->command = CANCEL;
-
-               /* if DMA was running, flush spurious intrpt */
-
-               if (dga->bytcnt_lo != 0) {
-                   dga->bytcnt_lo = 0;
-                   dga->bytcnt_hi = 0;
-                   DMA_SETIGNORE(DMAheader[unit]);
-                   dga->csr |= DMA_IE;
-                   dga->csr &= ~DMA_IE;
+               /*
+               * re-protect 1K (2 pages) event queue 
+               */
+               if (qdflags[unit].mapped & MAPEQ) {
+                       ptep = (int *)
+                          ((VTOP(eq_header[unit])*4) + (mfpr(SBR)|0x80000000));
+                       *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V; ptep++;
+                       *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V;

                }
                }

-
-               ptep = (int *)
-                       ((VTOP(DMAheader[unit]*4)) + (mfpr(SBR)|0x80000000));
-
-               for (i = (DMAbuf_size >> PGSHIFT); i > 0; --i)
-                   *ptep++ = (*ptep & ~PG_PROT) | PG_V | PG_KW;
-
-               ubarelse(0, &Qbus_unmap[unit]);
-           }
-
-           /*
-            * re-protect 1K (2 pages) event queue 
-            */
-
-           if (qdflags[unit].mapped & MAPEQ) {
-
-               ptep = (int *)
-                       ((VTOP(eq_header[unit])*4) + (mfpr(SBR)|0x80000000));
-
-               *ptep++ = (*ptep & ~PG_PROT) | PG_KW | PG_V;
-               *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V;
-           }
-
-           /*
-            * re-protect scroll param area and disable scroll intrpts  
-            */
-
-           if (qdflags[unit].mapped & MAPSCR) {
-
-               ptep = (int *) ((VTOP(scroll[unit]) * 4)
-                                   + (mfpr(SBR) | 0x80000000));
-
-               /* re-protect 512 scroll param area */
-
-               *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V;
-
-               adder = (struct adder *) qdmap[unit].adder;
-               qdflags[unit].adder_ie &= ~FRAME_SYNC;
-               adder->interrupt_enable = qdflags[unit].adder_ie;
-           }
-
-           /*
-            * re-protect color map write buffer area and kill intrpts 
-            */
-
-           if (qdflags[unit].mapped & MAPCOLOR) {
-
-               ptep = (int *) ((VTOP(color_buf[unit]) * 4)
-                                   + (mfpr(SBR) | 0x80000000));
-
-               *ptep++ = (*ptep & ~PG_PROT) | PG_KW | PG_V;
-               *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V;
-
-               color_buf[unit]->status = 0;
-
-               adder = (struct adder *) qdmap[unit].adder;
-               qdflags[unit].adder_ie &= ~VSYNC;
-               adder->interrupt_enable = qdflags[unit].adder_ie;
-           }
-
-           /*
-            * flag that everthing is unmapped 
-            */
-
-           mtpr(TBIA, 0);              /* invalidate translation buf */
-           qdflags[unit].mapped = 0;   /* flag everything unmapped */
-           qdflags[unit].inuse &= ~GRAPHIC_DEV;
-           qdflags[unit].curs_acc = ACC_OFF;
-           qdflags[unit].curs_thr = 128;
-
-           /*
-            * restore the console 
-            */
-
+               /*
+               * re-protect scroll param area and disable scroll intrpts  
+               */
+               if (qdflags[unit].mapped & MAPSCR) {
+                       ptep = (int *) ((VTOP(scroll[unit]) * 4)
+                               + (mfpr(SBR) | 0x80000000));
+                       /*
+                        * re-protect 512 scroll param area 
+                        */
+                       *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V;
+                       adder = (struct adder *) qdmap[unit].adder;
+                       qdflags[unit].adder_ie &= ~FRAME_SYNC;
+                       adder->interrupt_enable = qdflags[unit].adder_ie;
+               }
+               /*
+               * re-protect color map write buffer area and kill intrpts 
+               */
+               if (qdflags[unit].mapped & MAPCOLOR) {
+                       ptep = (int *) ((VTOP(color_buf[unit]) * 4)
+                               + (mfpr(SBR) | 0x80000000));
+                       *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V; ptep++;
+                       *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V;
+                       color_buf[unit]->status = 0;
+                       adder = (struct adder *) qdmap[unit].adder;
+                       qdflags[unit].adder_ie &= ~VSYNC;
+                       adder->interrupt_enable = qdflags[unit].adder_ie;
+               }
+               mtpr(TBIA, 0);          
+               /* flag everything now unmapped */
+               qdflags[unit].mapped = 0;   
+               qdflags[unit].inuse &= ~GRAPHIC_DEV;
+               qdflags[unit].curs_acc = ACC_OFF;
+               qdflags[unit].curs_thr = 128;
+               /*
+               * restore the console 
+               */

                dga = (struct dga *) qdmap[unit].dga;
                adder = (struct adder *) qdmap[unit].adder;
                dga = (struct dga *) qdmap[unit].dga;
                adder = (struct adder *) qdmap[unit].adder;

-

                dga->csr &= ~DMA_IE;
                dga->csr &= ~0x0600;    /* halt the DMA! (just in case...) */
                dga->csr |= DMA_ERR;    /* clear error condition */
                adder->command = CANCEL;
                dga->csr &= ~DMA_IE;
                dga->csr &= ~0x0600;    /* halt the DMA! (just in case...) */
                dga->csr |= DMA_ERR;    /* clear error condition */
                adder->command = CANCEL;

-
-               /* if DMA was running, flush spurious intrpt */
-
+               /*
+                * if DMA was running, flush spurious intrpt 
+                */

                if (dga->bytcnt_lo != 0) {
                if (dga->bytcnt_lo != 0) {

-                   dga->bytcnt_lo = 0;
-                   dga->bytcnt_hi = 0;
-                   DMA_SETIGNORE(DMAheader[unit]);
-                   dga->csr |= DMA_IE;
-                   dga->csr &= ~DMA_IE;
+                       dga->bytcnt_lo = 0;
+                       dga->bytcnt_hi = 0;
+                       DMA_SETIGNORE(DMAheader[unit]);
+                       dga->csr |= DMA_IE;
+                       dga->csr &= ~DMA_IE;

                }
                }

-

                init_shared(unit);              /* init shared memory */
                setup_dragon(unit);             /* init ADDER/VIPER */
                ldcursor(unit, cons_cursor);    /* load default cursor map */
                init_shared(unit);              /* init shared memory */
                setup_dragon(unit);             /* init ADDER/VIPER */
                ldcursor(unit, cons_cursor);    /* load default cursor map */


@@ -1026,129 +865,91 @@ int flag;
                ldfont(unit);
                cursor[unit].x = 0;
                cursor[unit].y = 0;
                ldfont(unit);
                cursor[unit].x = 0;
                cursor[unit].y = 0;

-
-           /* 
-            * shut off the mouse rcv intrpt and turn on kbd intrpts 
-            */
-           duart = (struct duart *) qdmap[unit].duart;
-           qdflags[unit].duart_imask &= ~(0x20);
-           qdflags[unit].duart_imask |= 0x02;
-           duart->imask = qdflags[unit].duart_imask;
-           /*
-            * shut off interrupts if all is closed  
-            */
-           if (!(qdflags[unit].inuse & (CONS_DEV | ALTCONS_DEV))) {
-               dga = (struct dga *) qdmap[unit].dga;
-               dga->csr &= ~(GLOBAL_IE | DMA_IE);
-           }
-       }
-       else { /* if this is the console or the alternate console  */
-           tp = &qd_tty[minor_dev];
-
-           (*linesw[tp->t_line].l_close)(tp);
-           ttyclose(tp);
-           tp->t_state = 0;
-           qdflags[unit].inuse &= ~CONS_DEV;
-           /*
-            * if graphics device is closed, kill interrupts 
-            */
-           if (!(qdflags[unit].inuse & GRAPHIC_DEV)) {
-               dga = (struct dga *) qdmap[unit].dga;
-               dga->csr &= ~(GLOBAL_IE | DMA_IE);
-           }
+               /*
+                * shut off the mouse rcv intrpt and turn on kbd intrpts 
+                */
+               duart = (struct duart *) qdmap[unit].duart;
+               qdflags[unit].duart_imask &= ~(0x20);
+               qdflags[unit].duart_imask |= 0x02;
+               duart->imask = qdflags[unit].duart_imask;
+               /*
+               * shut off interrupts if all is closed  
+               */
+               if (!(qdflags[unit].inuse & CONS_DEV)) {
+                       dga = (struct dga *) qdmap[unit].dga;
+                       dga->csr &= ~(GLOBAL_IE | DMA_IE);
+               }
+       } else {
+               /*
+               * this is the console 
+               */
+               tp = &qd_tty[minor_dev];
+               (*linesw[tp->t_line].l_close)(tp);
+               ttyclose(tp);
+               tp->t_state = 0;
+               qdflags[unit].inuse &= ~CONS_DEV;
+               /*
+               * if graphics device is closed, kill interrupts 
+               */
+               if (!(qdflags[unit].inuse & GRAPHIC_DEV)) {
+                       dga = (struct dga *) qdmap[unit].dga;
+                       dga->csr &= ~(GLOBAL_IE | DMA_IE);
+               }

        }
 
        return(0);
 
 } /* qdclose */
 
        }
 
        return(0);
 
 } /* qdclose */
 

-/***************************************************************
-*
-*      qdioctl - provide QDSS control services
-*
-****************************************************************
-*
-*  calling convention: qdioctl(dev, cmd, datap, flags);
-*
-*              where:  dev - the major/minor device number
-*                      cmd - the user-passed command argument
-*                      datap - ptr to user input buff (128 bytes max)
-*                      flags - "f_flags" from "struct file" in file.h
-*
-*
-*      - here is the format for the input "cmd" argument
-*
-*      31     29 28    23 22         16 15             8 7              0
-*      +----------------------------------------------------------------+
-*      |I/O type|        | buff length | device ID char |  user command |
-*      +----------------------------------------------------------------+
-*
-*  Return data is in the data buffer pointed to by "datap" input spec
-*
-*********************/
-

 qdioctl(dev, cmd, datap, flags)
 qdioctl(dev, cmd, datap, flags)

-dev_t dev;
-int cmd;
-caddr_t datap;
-int flags;
+       dev_t dev;
+       int cmd;
+       register caddr_t datap;
+       int flags;

 {
        register int *ptep;             /* page table entry pointer */
        register int mapix;             /* QVmap[] page table index */
        register struct _vs_event *event;
        register struct tty *tp;
 {
        register int *ptep;             /* page table entry pointer */
        register int mapix;             /* QVmap[] page table index */
        register struct _vs_event *event;
        register struct tty *tp;

-
+       register i;

        struct qdmap *qd;               /* pointer to device map struct */
        struct dga *dga;                /* Gate Array reg structure pntr */
        struct duart *duart;            /* DUART reg structure pointer */
        struct adder *adder;            /* ADDER reg structure pointer */
        struct qdmap *qd;               /* pointer to device map struct */
        struct dga *dga;                /* Gate Array reg structure pntr */
        struct duart *duart;            /* DUART reg structure pointer */
        struct adder *adder;            /* ADDER reg structure pointer */

-

        struct prgkbd *cmdbuf;
        struct prg_cursor *curs;
        struct _vs_cursor *pos;
        struct prgkbd *cmdbuf;
        struct prg_cursor *curs;
        struct _vs_cursor *pos;

-
-       u_int unit = minor(dev) >> 2;   /* number of caller's QDSS */
+       int unit = minor(dev) >> 2;     /* number of caller's QDSS */

        u_int minor_dev = minor(dev);
        u_int minor_dev = minor(dev);

-       struct uba_device *ui = qdinfo[unit];
-       struct qd_softc *sc = &qd_softc[ui->ui_unit];
-       /* struct devget *devget; */
-

        int error;
        int s;
        int error;
        int s;

-
-       int i;                          /* SIGNED index */
-       int sbr;                        /* SBR variable (you silly boy) */
-       u_int ix;
-
-       short status;
-       short *shortp;                  /* generic pointer to a short */
-       char *chrp;                     /* generic character pointer */
-

        short *temp;                    /* a pointer to template RAM */
 
        short *temp;                    /* a pointer to template RAM */
 

-       /* service graphic device ioctl commands */
+       /*
+       * service graphic device ioctl commands 
+       */

        switch (cmd) {
        switch (cmd) {

-           /*
-            * extract the oldest event from the event queue 
-            */
-           case QD_GETEVENT:
+
+       case QD_GETEVENT:
+               /*
+               * extract the oldest event from the event queue 
+               */

                if (ISEMPTY(eq_header[unit])) {
                if (ISEMPTY(eq_header[unit])) {

-                   event = (struct _vs_event *) datap;
-                   event->vse_device = VSE_NULL;
-                   break;
+                       event = (struct _vs_event *) datap;
+                       event->vse_device = VSE_NULL;
+                       break;

                }
                event = (struct _vs_event *) GETBEGIN(eq_header[unit]);
                }
                event = (struct _vs_event *) GETBEGIN(eq_header[unit]);

-               s = spltty();
+               s = spl5();

                GETEND(eq_header[unit]);
                splx(s);
                GETEND(eq_header[unit]);
                splx(s);

-               bcopy(event, datap, sizeof(struct _vs_event));
+               bcopy((caddr_t)event, datap, sizeof(struct _vs_event));

                break;
 
                break;
 

-           /*-------------------------------------------------------
-           * init the dragon stuff, DUART, and driver variables  */
-
-           case QD_RESET:
-
+       case QD_RESET:
+               /*
+               * init the dragon stuff, DUART, and driver variables  
+               */

                init_shared(unit);              /* init shared memory */
                setup_dragon(unit);           /* init the ADDER/VIPER stuff */
                clear_qd_screen(unit);
                init_shared(unit);              /* init shared memory */
                setup_dragon(unit);           /* init the ADDER/VIPER stuff */
                clear_qd_screen(unit);


@@ -1157,53 +958,50 @@ int flags;
                setup_input(unit);              /* init the DUART */
                break;
 
                setup_input(unit);              /* init the DUART */
                break;
 

-           /*----------------------------------------
-           * init the DUART and driver variables  */
-
-           case QD_SET:
-
+       case QD_SET:
+               /*
+               * init the DUART and driver variables  
+               */

                init_shared(unit);
                setup_input(unit);
                break;
 
                init_shared(unit);
                setup_input(unit);
                break;
 

-           /*---------------------------------------------------------------
-           * clear the QDSS screen.  (NOTE that this reinits the dragon) */
-
-           case QD_CLRSCRN:
-
+       case QD_CLRSCRN:
+               /*
+               * clear the QDSS screen.  (NOTE that this reinits the dragon) 
+               */
+#ifdef notdef  /* has caused problems and isn't necessary */

                setup_dragon(unit);
                clear_qd_screen(unit);
                setup_dragon(unit);
                clear_qd_screen(unit);

+#endif

                break;
 
                break;
 

-           /*------------------------------------
-           * load a cursor into template RAM  */
-
-           case QD_WTCURSOR:
-
-               ldcursor(unit, datap);
+       case QD_WTCURSOR:
+               /*
+               * load a cursor into template RAM  
+               */
+               ldcursor(unit, (short *)datap);

                break;
 
                break;
 

-           case QD_RDCURSOR:
+       case QD_RDCURSOR:

 
                temp = (short *) qdmap[unit].template;
 
                temp = (short *) qdmap[unit].template;

-
-               /* cursor is 32 WORDS from the end of the 8k WORD...
-               *  ...template space */
-
+               /*
+                * cursor is 32 WORDS from the end of the 8k WORD...
+                *  ...template space 
+                */

                temp += (8 * 1024) - 32;
                temp += (8 * 1024) - 32;

-

                for (i = 0; i < 32; ++i, datap += sizeof(short))
                for (i = 0; i < 32; ++i, datap += sizeof(short))

-                   *(short *)datap = *temp++;
+                       *(short *)datap = *temp++;

                break;
 
                break;
 

-           /*------------------------------
-           * position the mouse cursor  */
-
-           case QD_POSCURSOR:
-
+       case QD_POSCURSOR:
+               /*
+               * position the mouse cursor  
+               */

                dga = (struct dga *) qdmap[unit].dga;
                pos = (struct _vs_cursor *) datap;
                dga = (struct dga *) qdmap[unit].dga;
                pos = (struct _vs_cursor *) datap;

-               s = spltty();
+               s = spl5();

                dga->x_cursor = TRANX(pos->x);
                dga->y_cursor = TRANY(pos->y);
                eq_header[unit]->curs_pos.x = pos->x;
                dga->x_cursor = TRANX(pos->x);
                dga->y_cursor = TRANY(pos->y);
                eq_header[unit]->curs_pos.x = pos->x;


@@ -1211,492 +1009,436 @@ int flags;
                splx(s);
                break;
 
                splx(s);
                break;
 

-           /*--------------------------------------
-           * set the cursor acceleration factor */
-
-           case QD_PRGCURSOR:
-
+       case QD_PRGCURSOR:
+               /*
+               * set the cursor acceleration factor 
+               */

                curs = (struct prg_cursor *) datap;
                curs = (struct prg_cursor *) datap;

-               s = spltty();
+               s = spl5();

                qdflags[unit].curs_acc = curs->acc_factor;
                qdflags[unit].curs_thr = curs->threshold;
                splx(s);
                break;
 
                qdflags[unit].curs_acc = curs->acc_factor;
                qdflags[unit].curs_thr = curs->threshold;
                splx(s);
                break;
 

-           /*---------------------------------------
-           * enable 'user write' to device pages */
-
-           case QD_MAPDEVICE:
-
-               /*--------------
-               * init stuff */
-
+       case QD_MAPDEVICE:
+               /*
+               * enable 'user write' to device pages 
+               */

                qdflags[unit].mapped |= MAPDEV;
                qd = (struct qdmap *) &qdmap[unit];
                qdflags[unit].mapped |= MAPDEV;
                qd = (struct qdmap *) &qdmap[unit];

-
-               /*-------------------------------------
-               * enable user write to template RAM */
-
+               /*
+               * enable user write to template RAM 
+               */

                mapix = VTOP((int)qd->template) - VTOP(qvmem[0]);
                ptep = (int *)(QVmap[0] + mapix);
                mapix = VTOP((int)qd->template) - VTOP(qvmem[0]);
                ptep = (int *)(QVmap[0] + mapix);

-
-               for (i = VTOP(TMPSIZE); i > 0; --i)
-                   *ptep++ = (*ptep & ~PG_PROT) | PG_UW | PG_V;
-
-               /*----------------------------------
-               * enable user write to registers */
-
+               for (i = 0; i < btop(TMPSIZE); i++, ptep++)
+                       *ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;
+               /*
+               * enable user write to registers 
+               */

                mapix = VTOP((int)qd->adder) - VTOP(qvmem[0]);
                ptep = (int *)(QVmap[0] + mapix);
                mapix = VTOP((int)qd->adder) - VTOP(qvmem[0]);
                ptep = (int *)(QVmap[0] + mapix);

-
-               for (i = VTOP(REGSIZE); i > 0; --i)
-                   *ptep++ = (*ptep & ~PG_PROT) | PG_UW | PG_V;
-
-               /*-----------------------------------
-               * enable user write to color maps */
-
+               for (i = 0; i < btop(REGSIZE); i++, ptep++)
+                       *ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;
+               /*
+               * enable user write to color maps 
+               */

                mapix = VTOP((int)qd->red) - VTOP(qvmem[0]);
                ptep = (int *)(QVmap[0] + mapix);
                mapix = VTOP((int)qd->red) - VTOP(qvmem[0]);
                ptep = (int *)(QVmap[0] + mapix);

-
-               for (i = VTOP(CLRSIZE); i > 0; --i)
-                   *ptep++ = (*ptep & ~PG_PROT) | PG_UW | PG_V;
-
-               /*------------------------------
-               * enable user write to DUART */
-
+               for (i = 0; i < btop(CLRSIZE); i++, ptep++)
+                       *ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;
+               /*
+               * enable user write to DUART 
+               */

                mapix = VTOP((int)qd->duart) - VTOP(qvmem[0]);
                ptep = (int *)(QVmap[0] + mapix);
                *ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V; /* duart page */
 
                mapix = VTOP((int)qd->duart) - VTOP(qvmem[0]);
                ptep = (int *)(QVmap[0] + mapix);
                *ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V; /* duart page */
 

-               mtpr(TBIA, 0);          /* smash CPU's translation buffer */
-
-               /*------------------------------------------
-               * stuff qdmap structure in return buffer */
+               mtpr(TBIA, 0);          /* invalidate translation buffer */

 
 

-               bcopy(qd, datap, sizeof(struct qdmap));
+               /*
+                * stuff qdmap structure in return buffer 
+                */
+               bcopy((caddr_t)qd, datap, sizeof(struct qdmap));

                break;
 
                break;
 

-           /*-------------------------------------
-           * do setup for DMA by user process  */
-
-           case QD_MAPIOBUF:
-
-               /*------------------------------------------------
-               * set 'user write enable' bits for DMA buffer  */
-
+       case QD_MAPIOBUF:
+               /*
+                * do setup for DMA by user process     
+                *
+                * set 'user write enable' bits for DMA buffer  
+                */

                qdflags[unit].mapped |= MAPDMA;
                qdflags[unit].mapped |= MAPDMA;

-

                ptep = (int *) ((VTOP(DMAheader[unit]) * 4)
                ptep = (int *) ((VTOP(DMAheader[unit]) * 4)

-                               + (mfpr(SBR) | 0x80000000));
-
-               for (i = (DMAbuf_size >> PGSHIFT); i > 0; --i)
-                   *ptep++ = (*ptep & ~PG_PROT) | PG_UW | PG_V;
-
-               mtpr(TBIA, 0);                  /* clr CPU translation buf */
-
-               /*-------------------------------------
-               * set up QBUS map registers for DMA */
-
+                       + (mfpr(SBR) | 0x80000000));
+               for (i = 0; i < btop(DMAbuf_size); i++, ptep++)
+                       *ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;
+               mtpr(TBIA, 0);          /* invalidate translation buffer */
+               /*
+               * set up QBUS map registers for DMA 
+               */

                DMAheader[unit]->QBAreg =
                DMAheader[unit]->QBAreg =

-                               uballoc(0, DMAheader[unit], DMAbuf_size, 0);
-
+                   uballoc(0, (caddr_t)DMAheader[unit], DMAbuf_size, 0);

                if (DMAheader[unit]->QBAreg == 0)
                    printf("qd%d: qdioctl: QBA setup error\n", unit);
                if (DMAheader[unit]->QBAreg == 0)
                    printf("qd%d: qdioctl: QBA setup error\n", unit);

-

                Qbus_unmap[unit] = DMAheader[unit]->QBAreg;
                DMAheader[unit]->QBAreg &= 0x3FFFF;
                Qbus_unmap[unit] = DMAheader[unit]->QBAreg;
                DMAheader[unit]->QBAreg &= 0x3FFFF;

-
-               /*----------------------
-               * return I/O buf adr */
-
+               /*
+               * return I/O buf adr 
+               */

                *(int *)datap = (int) DMAheader[unit];
                break;
 
                *(int *)datap = (int) DMAheader[unit];
                break;
 

-           /*----------------------------------------------------------------
-           * map the shared scroll param area and enable scroll interpts  */
-
-           case QD_MAPSCROLL:
-
+       case QD_MAPSCROLL:
+               /*
+               * map the shared scroll param area and enable scroll interpts  
+               */

                qdflags[unit].mapped |= MAPSCR;
                qdflags[unit].mapped |= MAPSCR;

-

                ptep = (int *) ((VTOP(scroll[unit]) * 4)
                ptep = (int *) ((VTOP(scroll[unit]) * 4)

-                               + (mfpr(SBR) | 0x80000000));
-
-               /* allow user write to scroll area */
-
+                       + (mfpr(SBR) | 0x80000000));
+               /*
+                * allow user write to scroll area 
+                */

                *ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;
                *ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;

-
-               mtpr(TBIA, 0);                  /* clr CPU translation buf */
-
+               mtpr(TBIA, 0);                  /* invalidate translation buf */

                scroll[unit]->status = 0;
                scroll[unit]->status = 0;

-

                adder = (struct adder *) qdmap[unit].adder;
                adder = (struct adder *) qdmap[unit].adder;

-

                qdflags[unit].adder_ie |= FRAME_SYNC;
                adder->interrupt_enable = qdflags[unit].adder_ie;
                qdflags[unit].adder_ie |= FRAME_SYNC;
                adder->interrupt_enable = qdflags[unit].adder_ie;

-
-               /* return scroll area address */
-
-               *(int *)datap = (int) scroll[unit];
+               *(int *)datap = (int) scroll[unit]; /* return scroll area */

                break;
 
                break;
 

-           /*-------------------------------------------------------------
-           * unmap shared scroll param area and disable scroll intrpts */
-
-           case QD_UNMAPSCROLL:
-
+       case QD_UNMAPSCROLL:
+               /*
+               * unmap shared scroll param area and disable scroll intrpts 
+               */

                if (qdflags[unit].mapped & MAPSCR) {
                if (qdflags[unit].mapped & MAPSCR) {

-
-                   qdflags[unit].mapped &= ~MAPSCR;
-
-                   ptep = (int *) ((VTOP(scroll[unit]) * 4)
-                                   + (mfpr(SBR) | 0x80000000));
-
-                   /* re-protect 512 scroll param area */
-
-                   *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V;
-
-                   mtpr(TBIA, 0);      /* smash CPU's translation buf */
-
-                   adder = (struct adder *) qdmap[unit].adder;
-                   qdflags[unit].adder_ie &= ~FRAME_SYNC;
-                   adder->interrupt_enable = qdflags[unit].adder_ie;
+                       qdflags[unit].mapped &= ~MAPSCR;
+                       ptep = (int *) ((VTOP(scroll[unit]) * 4)
+                               + (mfpr(SBR) | 0x80000000));
+                       /*
+                        * re-protect 512 scroll param area 
+                        */
+                       *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V;
+                       mtpr(TBIA, 0);  /* smash CPU's translation buf */
+                       adder = (struct adder *) qdmap[unit].adder;
+                       qdflags[unit].adder_ie &= ~FRAME_SYNC;
+                       adder->interrupt_enable = qdflags[unit].adder_ie;

                }
                break;
 
                }
                break;
 

-           /*-----------------------------------------------------------
-           * map shared color map write buf and turn on vsync intrpt */
-
-           case QD_MAPCOLOR:
-
+       case QD_MAPCOLOR:
+               /*
+               * map shared color map write buf and turn on vsync intrpt 
+               */

                qdflags[unit].mapped |= MAPCOLOR;
                qdflags[unit].mapped |= MAPCOLOR;

-

                ptep = (int *) ((VTOP(color_buf[unit]) * 4)
                ptep = (int *) ((VTOP(color_buf[unit]) * 4)

-                               + (mfpr(SBR) | 0x80000000));
-
-               /* allow user write to color map write buffer */
-
-               *ptep++ = (*ptep & ~PG_PROT) | PG_UW | PG_V;
+                       + (mfpr(SBR) | 0x80000000));
+               /*
+                * allow user write to color map write buffer 
+                */
+               *ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V; ptep++;

                *ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;
                *ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;

-

                mtpr(TBIA, 0);                  /* clr CPU translation buf */
                mtpr(TBIA, 0);                  /* clr CPU translation buf */

-

                adder = (struct adder *) qdmap[unit].adder;
                adder = (struct adder *) qdmap[unit].adder;

-

                qdflags[unit].adder_ie |= VSYNC;
                adder->interrupt_enable = qdflags[unit].adder_ie;
                qdflags[unit].adder_ie |= VSYNC;
                adder->interrupt_enable = qdflags[unit].adder_ie;

-
-               /* return scroll area address */
-
+               /*
+                * return color area address 
+                */

                *(int *)datap = (int) color_buf[unit];
                break;
 
                *(int *)datap = (int) color_buf[unit];
                break;
 

-           /*--------------------------------------------------------------
-           * unmap shared color map write buffer and kill VSYNC intrpts */
-
-           case QD_UNMAPCOLOR:
-
+       case QD_UNMAPCOLOR:
+               /*
+                * unmap shared color map write buffer and kill VSYNC intrpts 
+                */

                if (qdflags[unit].mapped & MAPCOLOR) {
                if (qdflags[unit].mapped & MAPCOLOR) {

-
-                   qdflags[unit].mapped &= ~MAPCOLOR;
-
-                   ptep = (int *) ((VTOP(color_buf[unit]) * 4)
-                                   + (mfpr(SBR) | 0x80000000));
-
-                   /* re-protect color map write buffer */
-
-                   *ptep++ = (*ptep & ~PG_PROT) | PG_KW | PG_V;
-                   *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V;
-
-                   mtpr(TBIA, 0);      /* smash CPU's translation buf */
-
-                   adder = (struct adder *) qdmap[unit].adder;
-
-                   qdflags[unit].adder_ie &= ~VSYNC;
-                   adder->interrupt_enable = qdflags[unit].adder_ie;
+                       qdflags[unit].mapped &= ~MAPCOLOR;
+                       ptep = (int *) ((VTOP(color_buf[unit]) * 4)
+                               + (mfpr(SBR) | 0x80000000));
+                       /*
+                        * re-protect color map write buffer 
+                        */
+                       *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V; ptep++;
+                       *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V;
+                       mtpr(TBIA, 0);
+                       adder = (struct adder *) qdmap[unit].adder;
+                       qdflags[unit].adder_ie &= ~VSYNC;
+                       adder->interrupt_enable = qdflags[unit].adder_ie;

                }
                break;
 
                }
                break;
 

-           /*---------------------------------------------
-           * give user write access to the event queue */
-
-           case QD_MAPEVENT:
-
+       case QD_MAPEVENT:
+               /*
+               * give user write access to the event queue 
+               */

                qdflags[unit].mapped |= MAPEQ;
                qdflags[unit].mapped |= MAPEQ;

-

                ptep = (int *) ((VTOP(eq_header[unit]) * 4)
                ptep = (int *) ((VTOP(eq_header[unit]) * 4)

-                               + (mfpr(SBR) | 0x80000000));
-
-               /* allow user write to 1K event queue */
-
-               *ptep++ = (*ptep & ~PG_PROT) | PG_UW | PG_V;
+                       + (mfpr(SBR) | 0x80000000));
+               /*
+                * allow user write to 1K event queue 
+                */
+               *ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V; ptep++;

                *ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;
                *ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;

-

                mtpr(TBIA, 0);                  /* clr CPU translation buf */
                mtpr(TBIA, 0);                  /* clr CPU translation buf */

-
-               /* return event queue address */
-
-               *(int *)datap = (int) eq_header[unit];
+               /*
+                * return event queue address 
+                */
+               *(int *)datap = (int)eq_header[unit];

                break;
 
                break;
 

-           /*-----------------------------------------------
-           * pass caller's programming commands to LK201 */
-
-           case QD_PRGKBD:
-
-               duart = (struct duart *) qdmap[unit].duart;
-               cmdbuf = (struct prgkbd *) datap;    /* pnt to kbd cmd buf */
-
-               /*----------------
-               * send command */
-
+       case QD_PRGKBD:
+               /*
+               * pass caller's programming commands to LK201 
+               */
+               duart = (struct duart *)qdmap[unit].duart;
+               cmdbuf = (struct prgkbd *)datap;    /* pnt to kbd cmd buf */
+               /*
+               * send command 
+               */

                for (i = 1000; i > 0; --i) {
                for (i = 1000; i > 0; --i) {

-                   if ((status = duart->statusA) & XMT_RDY) {
-                       duart->dataA = cmdbuf->cmd;
-                       break;
-                   }
+                       if (duart->statusA&XMT_RDY) {
+                               duart->dataA = cmdbuf->cmd;
+                               break;
+                       }

                }
                }

-

                if (i == 0) {
                if (i == 0) {

-                   printf("qd%d: qdioctl: timeout on XMT_RDY [1]\n", unit);
-                   break;
+                       printf("qd%d: qdioctl: timeout on XMT_RDY [1]\n", unit);
+                       break;

                }
                }

-
-               /*----------------
-               * send param1? */
-
+               /*
+               * send param1? 
+               */

                if (cmdbuf->cmd & LAST_PARAM)
                if (cmdbuf->cmd & LAST_PARAM)

-                   break;
-
-               for (i = 1000; i > 0; --i) {
-                   if ((status = duart->statusA) & XMT_RDY) {
-                       duart->dataA = cmdbuf->param1;

                        break;
                        break;

-                   }
+               for (i = 1000; i > 0; --i) {
+                       if (duart->statusA&XMT_RDY) {
+                               duart->dataA = cmdbuf->param1;
+                               break;
+                       }

                }
                }

-

                if (i == 0) {
                if (i == 0) {

-                   printf("\nqd%d: qdioctl: timeout on XMT_RDY [2]\n", unit);
-                   break;
+                       printf("qd%d: qdioctl: timeout on XMT_RDY [2]\n", unit);
+                       break;

                }
                }

-
-               /*----------------
-               * send param2? */
-
+               /*
+               * send param2? 
+               */

                if (cmdbuf->param1 & LAST_PARAM)
                    break;
                if (cmdbuf->param1 & LAST_PARAM)
                    break;

-

                for (i = 1000; i > 0; --i) {
                for (i = 1000; i > 0; --i) {

-                   if ((status = duart->statusA) & XMT_RDY) {
-                       duart->dataA = cmdbuf->param2;
-                       break;
-                   }
+                       if (duart->statusA&XMT_RDY) {
+                               duart->dataA = cmdbuf->param2;
+                               break;
+                       }

                }
                }

-

                if (i == 0) {
                if (i == 0) {

-                   printf("qd%d: qdioctl: timeout on XMT_RDY [3]\n", unit);
-                   break;
+                       printf("qd%d: qdioctl: timeout on XMT_RDY [3]\n", unit);
+                       break;

                }
                }

-

                break;
 
                break;
 

-           /*----------------------------------------------------
-           * pass caller's programming commands to the mouse  */
-
-           case QD_PRGMOUSE:
-
+       case QD_PRGMOUSE:
+               /*
+               * pass caller's programming commands to the mouse  
+               */

                duart = (struct duart *) qdmap[unit].duart;
                duart = (struct duart *) qdmap[unit].duart;

-

                for (i = 1000; i > 0; --i) {
                for (i = 1000; i > 0; --i) {

-                   if ((status = duart->statusB) & XMT_RDY) {
-                       duart->dataB = *datap;
-                       break;
-                   }
+                       if (duart->statusB&XMT_RDY) {
+                               duart->dataB = *datap;
+                               break;
+                       }

                }
                }

-

                if (i == 0) {
                if (i == 0) {

-                   printf("qd%d: qdioctl: timeout on XMT_RDY [4]\n", unit);
+                       printf("qd%d: qdioctl: timeout on XMT_RDY [4]\n", unit);

                }
                }

-

                break;
 
                break;
 

-           /*----------------------------------------------
-           * get QDSS configuration word and return it  */
-
-           case QD_RDCONFIG:
-
+       case QD_RDCONFIG:
+               /*
+               * get QDSS configuration word and return it  
+               */

                *(short *)datap = qdflags[unit].config;
                break;
 
                *(short *)datap = qdflags[unit].config;
                break;
 

-           /*----------------------
-           * program the tablet */
-
-           case QD_PRGTABLET:
+       case QD_KERN_LOOP:
+       case QD_KERN_UNLOOP:
+               /*
+                * vestige from ultrix.  BSD uses TIOCCONS to redirect
+                * kernel console output.
+                */
+               break;

 
 

+       case QD_PRGTABLET:
+               /*
+               * program the tablet 
+               */

                duart = (struct duart *) qdmap[unit].duart;
                duart = (struct duart *) qdmap[unit].duart;

-

                for (i = 1000; i > 0; --i) {
                for (i = 1000; i > 0; --i) {

-                   if ((status = duart->statusB) & XMT_RDY) {
-                       duart->dataB = *datap;
-                       break;
-                   }
+                       if (duart->statusB&XMT_RDY) {
+                               duart->dataB = *datap;
+                               break;
+                       }

                }
                }

-

                if (i == 0) {
                if (i == 0) {

-                   printf("qd%d: qdioctl: timeout on XMT_RDY [5]\n", unit);
+                       printf("qd%d: qdioctl: timeout on XMT_RDY [5]\n", unit);

                }
                }

-

                break;
 
                break;
 

-           /*-----------------------------------------------
-           * program the tablet report resolution factor */
-
-           case QD_PRGTABRES:
-
+       case QD_PRGTABRES:
+               /*
+               * program the tablet report resolution factor 
+               */

                qdflags[unit].tab_res = *(short *)datap;
                break;
 
                qdflags[unit].tab_res = *(short *)datap;
                break;
 

-           default:
-               /*-----------------------------
-               * service tty type ioctl's  */
-
-                   if (!(minor_dev & 0x02)) {
-
+       default:
+               /*
+               * service tty ioctl's  
+               */
+               if (!(minor_dev & 0x02)) {

                        tp = &qd_tty[minor_dev];
                        tp = &qd_tty[minor_dev];

-
-                       error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, datap, flags);
+                       error = 
+                          (*linesw[tp->t_line].l_ioctl)(tp, cmd, datap, flags);

                        if (error >= 0) {
                        if (error >= 0) {

-                           return(error);
+                               return(error);

                        }
                        }

-

                        error = ttioctl(tp, cmd, datap, flags);
                        if (error >= 0) {
                        error = ttioctl(tp, cmd, datap, flags);
                        if (error >= 0) {

-                           return(error);
+                               return(error);

                        }
                        }

-                   }
-                   break;
+               }
+               break;

        }
 
        }
 

-/*--------------------------------
-* clean up and get outta here  */
-

        return(0);
 
 } /* qdioctl */
 
        return(0);
 
 } /* qdioctl */
 

-/**********************************************************************
-*
-*      qdselect()... service select call for event queue input
-*
-**********************************************************************/
-

 qdselect(dev, rw)
 qdselect(dev, rw)

-dev_t dev;
-int rw;
+       dev_t dev;
+       int rw;

 {
 {

-       register int s;
-       register int unit;
+       register s;
+       register unit;
+       register struct tty *tp;
+       u_int minor_dev = minor(dev);

 
 

-       s = spltty();
-       unit = minor(dev) >> 2;
+       s = spl5();
+       unit = minor_dev >> 2;

 
        switch (rw) {
 
        switch (rw) {

-
-           case FREAD:                 /* event available? */
-
-               if(!(ISEMPTY(eq_header[unit]))) {
-                   splx(s);
-                   return(1);          /* return "1" if event exists */
+       case FREAD:
+               if ((minor_dev & 0x03) == 2) {
+                       /*
+                       * this is a graphics device, so check for events
+                       */
+                       if(!(ISEMPTY(eq_header[unit]))) {
+                               splx(s);
+                               return(1);
+                       }
+                       qdrsel[unit] = u.u_procp;
+                       qdflags[unit].selmask |= SEL_READ;
+                       splx(s);
+                       return(0);
+               } else {
+                       /*
+                       * this is a tty device
+                       */
+                       tp = &qd_tty[minor_dev];
+                       if (ttnread(tp))
+                           return(1);
+                       tp->t_rsel = u.u_procp;
+                       splx(s);
+                       return(0);

                }
                }

-               rsel[unit] = u.u_procp;
-               qdflags[unit].selmask |= SEL_READ;
-               splx(s);
-               return(0);

 
 

-           case FWRITE:                /* DMA done? */
-
-               if (DMA_ISEMPTY(DMAheader[unit])) {
-                   splx(s);
-                   return(1);          /* return "1" if DMA is done */
+       case FWRITE:
+               if ((minor(dev) & 0x03) == 2) {
+                       /*
+                       * this is a graphics device, so check for dma buffers
+                       */
+                       if (DMA_ISEMPTY(DMAheader[unit]))
+                           {
+                               splx(s);
+                               return(1);
+                       }
+                       qdrsel[unit] = u.u_procp;
+                       qdflags[unit].selmask |= SEL_WRITE;
+                       splx(s);
+                       return(0);
+               } else {
+                       /*
+                       * this is a tty device
+                       */
+                       tp = &qd_tty[minor_dev];
+                       if (tp->t_outq.c_cc <= TTLOWAT(tp))
+                           return(1);
+                       tp->t_wsel = u.u_procp;
+                       splx(s);
+                       return(0);

                }
                }

-               rsel[unit] = u.u_procp;
-               qdflags[unit].selmask |= SEL_WRITE;
-               splx(s);
-               return(0);

        }
        }

+       splx(s);
+       return(0);

 
 } /* qdselect() */
 
 
 } /* qdselect() */
 

-/***************************************************************
-*
-*      qdwrite()... output to the QDSS screen as a TTY
-*
-***************************************************************/
-

 extern qd_strategy();
 
 qdwrite(dev, uio)
 extern qd_strategy();
 
 qdwrite(dev, uio)

-dev_t dev;
-struct uio *uio;
+       dev_t dev;
+       struct uio *uio;

 {
        register struct tty *tp;
 {
        register struct tty *tp;

-       register int minor_dev;
-       register int unit;
+       register minor_dev;
+       register unit;

 
        minor_dev = minor(dev);
        unit = (minor_dev >> 2) & 0x07;
 
 
        minor_dev = minor(dev);
        unit = (minor_dev >> 2) & 0x07;
 

-       /*------------------------------
-       * if this is the console...  */
-
-       if ((minor_dev & 0x03) != 0x02  &&
-            qdflags[unit].inuse & CONS_DEV) {
-           tp = &qd_tty[minor_dev];
-           return ((*linesw[tp->t_line].l_write)(tp, uio));
-       }
-
-       /*------------------------------------------------
-       * else this must be a DMA xfer from user space */
-
-       else if (qdflags[unit].inuse & GRAPHIC_DEV) {
-           return (physio(qd_strategy, &qdbuf[unit],
-                          dev, B_WRITE, minphys, uio));
+       if (((minor_dev&0x03) != 0x02) && (qdflags[unit].inuse&CONS_DEV)) {
+               /*
+               * this is the console...  
+               */
+               tp = &qd_tty[minor_dev];
+               return ((*linesw[tp->t_line].l_write)(tp, uio));
+       } else if (qdflags[unit].inuse & GRAPHIC_DEV) {
+               /*
+               * this is a DMA xfer from user space 
+               */
+               return (physio(qd_strategy, &qdbuf[unit],
+               dev, B_WRITE, minphys, uio));

        }
        }

+       return (ENXIO);

 }
 
 }
 

-/***************************************************************
-*
-*      qdread()... read from QDSS keyboard as a TTY
-*
-***************************************************************/
-

 qdread(dev, uio)
 qdread(dev, uio)

-dev_t dev;
-struct uio *uio;
+       dev_t dev;
+       struct uio *uio;

 {
        register struct tty *tp;
 {
        register struct tty *tp;

-       register int minor_dev;
-       register int unit;
+       register minor_dev;
+       register unit;

 
        minor_dev = minor(dev);
        unit = (minor_dev >> 2) & 0x07;
 
 
        minor_dev = minor(dev);
        unit = (minor_dev >> 2) & 0x07;
 

-       /*------------------------------
-       * if this is the console...  */
-
-       if ((minor_dev & 0x03) != 0x02  &&
-            qdflags[unit].inuse & CONS_DEV) {
-           tp = &qd_tty[minor_dev];
-           return ((*linesw[tp->t_line].l_read)(tp, uio));
-       }
-
-       /*------------------------------------------------
-       * else this must be a bitmap-to-processor xfer */
-
-       else if (qdflags[unit].inuse & GRAPHIC_DEV) {
-           return (physio(qd_strategy, &qdbuf[unit],
-                          dev, B_READ, minphys, uio));
+       if ((minor_dev & 0x03) != 0x02 && qdflags[unit].inuse & CONS_DEV) {
+               /*
+               * this is the console
+               */
+               tp = &qd_tty[minor_dev];
+               return ((*linesw[tp->t_line].l_read)(tp, uio));
+       } else if (qdflags[unit].inuse & GRAPHIC_DEV) {
+               /*
+               * this is a bitmap-to-processor xfer 
+               */
+               return (physio(qd_strategy, &qdbuf[unit],
+               dev, B_READ, minphys, uio));

        }
        }

+       return (ENXIO);

 }
 
 /***************************************************************
 }
 
 /***************************************************************


@@ -1706,212 +1448,181 @@ struct uio *uio;
 ***************************************************************/
 
 qd_strategy(bp)
 ***************************************************************/
 
 qd_strategy(bp)

-register struct buf *bp;
+       register struct buf *bp;

 {
        register struct dga *dga;
        register struct adder *adder;
 {
        register struct dga *dga;
        register struct adder *adder;

-
-       char *DMAbufp;
-
+       register unit;

        int QBAreg;
        int QBAreg;

-       int bytcnt;

        int s;
        int s;

-       int unit;

        int cookie;
 
        int cookie;
 

-       int i,j,k;
-

        unit = (minor(bp->b_dev) >> 2) & 0x07;
 
        /*
        * init pointers 
        */
        unit = (minor(bp->b_dev) >> 2) & 0x07;
 
        /*
        * init pointers 
        */

-

        if ((QBAreg = ubasetup(0, bp, 0)) == 0) {
        if ((QBAreg = ubasetup(0, bp, 0)) == 0) {

-           printf("qd%d: qd_strategy: QBA setup error\n", unit);
-           goto STRAT_ERR;
+               printf("qd%d: qd_strategy: QBA setup error\n", unit);
+               goto STRAT_ERR;

        }
        }

-

        dga = (struct dga *) qdmap[unit].dga;
        dga = (struct dga *) qdmap[unit].dga;

-
-       s = spltty();
-
+       s = spl5();

        qdflags[unit].user_dma = -1;
        qdflags[unit].user_dma = -1;

-

        dga->csr |= DMA_IE;
        dga->csr |= DMA_IE;

-

        cookie = QBAreg & 0x3FFFF;
        dga->adrs_lo = (short) cookie;
        dga->adrs_hi = (short) (cookie >> 16);
        cookie = QBAreg & 0x3FFFF;
        dga->adrs_lo = (short) cookie;
        dga->adrs_hi = (short) (cookie >> 16);

-

        dga->bytcnt_lo = (short) bp->b_bcount;
        dga->bytcnt_hi = (short) (bp->b_bcount >> 16);
 
        while (qdflags[unit].user_dma) {
        dga->bytcnt_lo = (short) bp->b_bcount;
        dga->bytcnt_hi = (short) (bp->b_bcount >> 16);
 
        while (qdflags[unit].user_dma) {

-           sleep((caddr_t)&qdflags[unit].user_dma, QDPRIOR);
+               sleep((caddr_t)&qdflags[unit].user_dma, QDPRIOR);

        }
        }

-

        splx(s);
        ubarelse(0, &QBAreg);
        splx(s);
        ubarelse(0, &QBAreg);

-

        if (!(dga->csr & DMA_ERR)) {
        if (!(dga->csr & DMA_ERR)) {

-           iodone(bp);
-           return;
+               iodone(bp);
+               return;

        }
 
 STRAT_ERR:
        adder = (struct adder *) qdmap[unit].adder;
        }
 
 STRAT_ERR:
        adder = (struct adder *) qdmap[unit].adder;

-       adder->command = CANCEL;                /* cancel adder activity */
+       adder->command = CANCEL;        /* cancel adder activity */

        dga->csr &= ~DMA_IE;
        dga->csr &= ~0x0600;            /* halt DMA (reset fifo) */
        dga->csr |= DMA_ERR;            /* clear error condition */
        bp->b_flags |= B_ERROR;         /* flag an error to physio() */
 
        dga->csr &= ~DMA_IE;
        dga->csr &= ~0x0600;            /* halt DMA (reset fifo) */
        dga->csr |= DMA_ERR;            /* clear error condition */
        bp->b_flags |= B_ERROR;         /* flag an error to physio() */
 

-       /* if DMA was running, flush spurious intrpt */
-
+       /*
+        * if DMA was running, flush spurious intrpt 
+        */

        if (dga->bytcnt_lo != 0) {
        if (dga->bytcnt_lo != 0) {

-           dga->bytcnt_lo = 0;
-           dga->bytcnt_hi = 0;
-           DMA_SETIGNORE(DMAheader[unit]);
-           dga->csr |= DMA_IE;
+               dga->bytcnt_lo = 0;
+               dga->bytcnt_hi = 0;
+               DMA_SETIGNORE(DMAheader[unit]);
+               dga->csr |= DMA_IE;

        }
        }

-

        iodone(bp);
 
 } /* qd_strategy */
 
        iodone(bp);
 
 } /* qd_strategy */
 

-/*******************************************************************
-*
-*      qdstart()... startup output to the console screen
-*
-********************************************************************
-* NOTE - You must have tty.c fixed so it doesn't try to sleep
-*      waiting for a transmitter interrupt (which would never occur).
-*      Writes to the QDSS are synchronous and have (essentially)
-*      completed by the time the start routine returns.
-*
-*      calling convention:
-*
-*              qdstart(tp);
-*              struct tty *tp;         # pointer to tty structure
-*
-********/
-
+/*
+ *  Start output to the console screen
+ */

 qdstart(tp)
 qdstart(tp)

-register struct tty *tp;
+       register struct tty *tp;

 {
 {

-       register int which_unit, unit, c;
+       register which_unit, unit, c;

        int s;
 
        unit = minor(tp->t_dev);
        which_unit = (unit >> 2) & 0x3;
        int s;
 
        unit = minor(tp->t_dev);
        which_unit = (unit >> 2) & 0x3;

-       /* unit &= 0x03; */
+       unit &= 0x03;
+
+       s = spl5();

 
 

-       /* If it's currently active, or delaying, no need to do anything. */
-       s = spltty();
+       /*
+       * If it's currently active, or delaying, no need to do anything. 
+       */

        if (tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP))
                goto out;
 
        /*
        if (tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP))
                goto out;
 
        /*

-        * XXX - this loop is at spltty.  not good, but hardly worth
-        * fixing since the glass tty is only used when the window
-        * system isn't running.  if you debug window systems you
-        * might want to rethink this.
-        */
+       * Display chars until the queue is empty.
+       * Drop input from anything but the console
+       * device on the floor.  
+       *
+       * XXX - this loop is done at spltty.
+       *
+       */

        while (tp->t_outq.c_cc) {
                c = getc(&tp->t_outq);
        while (tp->t_outq.c_cc) {
                c = getc(&tp->t_outq);

-               blitc(which_unit, c & 0xFF);
+               if (unit == 0)
+                       blitc(which_unit, (u_char)c);

        }
        }

-       tp->t_state &= ~TS_BUSY;
-       if (tp->t_state&TS_ASLEEP) {
-               tp->t_state &= ~TS_ASLEEP;
-               wakeup((caddr_t)&tp->t_outq);
+       /*
+       * If there are sleepers, and output has drained below low
+       * water mark, wake up the sleepers. 
+       */
+       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);
+               }

        }
 
        }
 

+       tp->t_state &= ~TS_BUSY;
+

 out:
        splx(s);
 
 } /* qdstart */
 
 out:
        splx(s);
 
 } /* qdstart */
 

-
-/*******************************************************************
-*
-*      qdstop()... stop the tty
-*
-*******************************************************************/
-
+/*ARGSUSED*/

 qdstop(tp, flag)
 qdstop(tp, flag)

-register struct tty *tp;
-int flag;
+       register struct tty *tp;
+       int flag;

 {
        register int s;
 
 {
        register int s;
 

-#ifdef notdef  /* not needed - qdss is synchronous */
-       s = spltty();   /* block intrpts during state modification */
-       if (tp->t_state & TS_BUSY) {
-           if ((tp->t_state & TS_TTSTOP) == 0) {
-               tp->t_state |= TS_FLUSH;
-           } else
-               tp->t_state &= ~TS_BUSY;
-       }
+       s = spl5();     /* block intrpts during state modification */
+       if (tp->t_state & TS_BUSY)
+               if ((tp->t_state & TS_TTSTOP) == 0)
+                       tp->t_state |= TS_FLUSH;
+               else
+                       tp->t_state &= ~TS_BUSY;

        splx(s);
        splx(s);

-#endif

 }
 
 }
 

-/*******************************************************************
-*
-*      blitc()... output a character to the QDSS screen
-*
-********************************************************************
-*
-*      calling convention:
-*
-*              blitc(chr);
-*              char chr;               ;character to be displayed
-*
-********/
+/*
+ *  Output a character to the QDSS screen
+ */

 
 blitc(unit, chr)
 
 blitc(unit, chr)

-int unit;
-char chr;
+       register unit;
+       register u_char chr;

 {
        register struct adder *adder;
        register struct dga *dga;
        register int i;
 {
        register struct adder *adder;
        register struct dga *dga;
        register int i;

-       static   short inescape[NQD];
-
-       short x;
+       int nograph = !(qdflags[unit].inuse&GRAPHIC_DEV);
+       static short inescape[NQD];

 
 

-       /* init stuff  */
-
-       adder = (struct adder *) qdmap[unit].adder;
+       adder = (struct adder *)qdmap[unit].adder;

        dga = (struct dga *) qdmap[unit].dga;
        dga = (struct dga *) qdmap[unit].dga;

-
-       chr &= 0x7F;
-
+       /* 
+        * BSD comment: this (&=0177) defeats the extended character 
+        * set code for the glass tty, but if i had the time i would 
+        * spend it ripping out the code completely.  This driver
+        * is too big for its own good.
+        */
+       chr &= 0177;

        /*
        /*

-        *  Support cursor addressing so vi will work.
-        *  Decode for "\E=%.%." cursor motion description.
+        * Cursor addressing (so vi will work).
+        * Decode for "\E=%.%." cursor motion description.
+        * Corresponds to type "qdcons" in /etc/termcap:
+        *
+        *    qd|qdss|qdcons|qdss glass tty (4.4 BSD):\
+        *      :am:do=^J:le=^H:bs:cm=\E=%.%.:cl=1^Z:co#128:li#57::nd=^L:up=^K:

         *
         *

-        *  If we've seen an escape, grab up to three more
-        *  characters, bailing out if necessary. 

         */
         */

-       if (inescape[unit]) {   
+       if (inescape[unit] && nograph) {        

                switch (inescape[unit]++) {
                case 1:
                        if (chr != '=') {
                switch (inescape[unit]++) {
                case 1:
                        if (chr != '=') {

-                               /* bogus escape sequence */
+                               /* abort escape sequence */

                                inescape[unit] = 0;
                                blitc(unit, chr);
                        }
                                inescape[unit] = 0;
                                blitc(unit, chr);
                        }

-                       return(0);
+                       return;

                case 2:
                        /* position row */
                        cursor[unit].y = CHAR_HEIGHT * chr;
                        if (cursor[unit].y > 863 - CHAR_HEIGHT)
                                cursor[unit].y = 863 - CHAR_HEIGHT;
                        dga->y_cursor = TRANY(cursor[unit].y);
                case 2:
                        /* position row */
                        cursor[unit].y = CHAR_HEIGHT * chr;
                        if (cursor[unit].y > 863 - CHAR_HEIGHT)
                                cursor[unit].y = 863 - CHAR_HEIGHT;
                        dga->y_cursor = TRANY(cursor[unit].y);

-                       return(0);
+                       return;

                case 3:
                        /* position column */
                        cursor[unit].x = CHAR_WIDTH * chr;
                case 3:
                        /* position column */
                        cursor[unit].x = CHAR_WIDTH * chr;


@@ -1919,179 +1630,178 @@ char chr;
                                cursor[unit].x = 1023 - CHAR_WIDTH;
                        dga->x_cursor = TRANX(cursor[unit].x);
                        inescape[unit] = 0;
                                cursor[unit].x = 1023 - CHAR_WIDTH;
                        dga->x_cursor = TRANX(cursor[unit].x);
                        inescape[unit] = 0;

-                       return(0);
+                       return;

                default:
                        inescape[unit] = 0;
                        blitc(unit, chr);
                }
        }
                default:
                        inescape[unit] = 0;
                        blitc(unit, chr);
                }
        }

-                       

 
        switch (chr) {
 
        switch (chr) {

-
-           case '\r':                  /* return char */
+       case '\r':                      /* return char */

                cursor[unit].x = 0;
                cursor[unit].x = 0;

-               dga->x_cursor = TRANX(cursor[unit].x);
-               return(0);
-
-           case '\t':                  /* tab char */
+               if (nograph)
+                       dga->x_cursor = TRANX(cursor[unit].x);
+               return;

 
 

+       case '\t':                      /* tab char */

                for (i = 8 - ((cursor[unit].x >> 3) & 0x07); i > 0; --i) {
                for (i = 8 - ((cursor[unit].x >> 3) & 0x07); i > 0; --i) {

-                   blitc(unit, ' ');
+                       blitc(unit, ' ');

                }
                }

-               return(0);
-
-           case '\n':                  /* line feed char */
+               return;

 
 

+       case '\n':                      /* line feed char */

                if ((cursor[unit].y += CHAR_HEIGHT) > (863 - CHAR_HEIGHT)) {
                if ((cursor[unit].y += CHAR_HEIGHT) > (863 - CHAR_HEIGHT)) {

-                   if (qdflags[unit].inuse & GRAPHIC_DEV) {
-                       cursor[unit].y = 0;
-                   } else {
-                       cursor[unit].y -= CHAR_HEIGHT;
-                       scroll_up(adder);
-                   }
+                       if (nograph) {
+                               cursor[unit].y -= CHAR_HEIGHT;
+                               scroll_up(adder);
+                       } else
+                               cursor[unit].y = 0;

                }
                }

-               dga->y_cursor = TRANY(cursor[unit].y);
-               return(0);
+               if (nograph)
+                       dga->y_cursor = TRANY(cursor[unit].y);
+               return;

 
 

-           case '\b':                  /* backspace char */
+       case '\b':                      /* backspace char */

                if (cursor[unit].x > 0) {
                if (cursor[unit].x > 0) {

-                   cursor[unit].x -= CHAR_WIDTH;
-                   dga->x_cursor = TRANX(cursor[unit].x);
+                       cursor[unit].x -= CHAR_WIDTH;
+                       if (nograph)
+                               dga->x_cursor = TRANX(cursor[unit].x);

                }
                }

-               return(0);
-
-           case CTRL('k'):             /* cursor up */
-               if (cursor[unit].y > 0) {
+               return;
+       case CTRL('k'):         /* cursor up */
+               if (nograph && cursor[unit].y > 0) {

                        cursor[unit].y -= CHAR_HEIGHT;
                        dga->y_cursor = TRANY(cursor[unit].y);
                }
                        cursor[unit].y -= CHAR_HEIGHT;
                        dga->y_cursor = TRANY(cursor[unit].y);
                }

-               return(0);
+               return;

 
 

-           case CTRL('^'):             /* home cursor */
-               cursor[unit].x = 0;
-               dga->x_cursor = TRANX(cursor[unit].x);
-               cursor[unit].y = 0;
-               dga->y_cursor = TRANY(cursor[unit].y);
-               return(0);
+       case CTRL('^'):         /* home cursor */
+               if (nograph) {
+                       cursor[unit].x = 0;
+                       dga->x_cursor = TRANX(cursor[unit].x);
+                       cursor[unit].y = 0;
+                       dga->y_cursor = TRANY(cursor[unit].y);
+               }
+               return;

 
 

-           case CTRL('l'):             /* cursor right */
-               if (cursor[unit].x < 1023 - CHAR_WIDTH) {
+       case CTRL('l'):         /* cursor right */
+               if (nograph && cursor[unit].x < 1023 - CHAR_WIDTH) {

                        cursor[unit].x += CHAR_WIDTH;
                        dga->x_cursor = TRANX(cursor[unit].x);
                }
                        cursor[unit].x += CHAR_WIDTH;
                        dga->x_cursor = TRANX(cursor[unit].x);
                }

-               return(0);
+               return;

 
 

-           case CTRL('z'):             /* clear screen */
-               setup_dragon(unit);     
-               clear_qd_screen(unit);
-               /* and home cursor - termcap seems to assume this */
-               cursor[unit].x = 0;
-               dga->x_cursor = TRANX(cursor[unit].x);
-               cursor[unit].y = 0;
-               dga->y_cursor = TRANY(cursor[unit].y);
-               return(0);
+       case CTRL('z'):         /* clear screen */
+               if (nograph) {
+                       setup_dragon(unit);     
+                       clear_qd_screen(unit);
+                       /* home cursor - termcap seems to assume this */
+                       cursor[unit].x = 0;
+                       dga->x_cursor = TRANX(cursor[unit].x);
+                       cursor[unit].y = 0;
+                       dga->y_cursor = TRANY(cursor[unit].y);
+               }
+               return;

 
 

-           case '\033':                /* start escape sequence */
-               inescape[unit] = 1;
-               return(0);
+       case '\033':            /* start escape sequence */
+               if (nograph)
+                       inescape[unit] = 1;
+               return;

 
 

-           default:
-               if (chr < ' ' || chr > '~')
-                   return(0);
+       default:
+               if ((chr < ' ') || (chr > '~'))
+                       return;

        }
        }

-
-       /* setup VIPER operand control registers  */
-
+       /*
+        * setup VIPER operand control registers  
+        */

        write_ID(adder, CS_UPDATE_MASK, 0x0001);  /* select plane #0 */
        write_ID(adder, SRC1_OCR_B,
        write_ID(adder, CS_UPDATE_MASK, 0x0001);  /* select plane #0 */
        write_ID(adder, SRC1_OCR_B,

-                       EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY);
-
+       EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY);

        write_ID(adder, CS_UPDATE_MASK, 0x00FE);  /* select other planes */
        write_ID(adder, SRC1_OCR_B,
        write_ID(adder, CS_UPDATE_MASK, 0x00FE);  /* select other planes */
        write_ID(adder, SRC1_OCR_B,

-                       EXT_SOURCE | INT_NONE | NO_ID | BAR_SHIFT_DELAY);
-
+       EXT_SOURCE | INT_NONE | NO_ID | BAR_SHIFT_DELAY);

        write_ID(adder, CS_UPDATE_MASK, 0x00FF);  /* select all planes */
        write_ID(adder, DST_OCR_B,
        write_ID(adder, CS_UPDATE_MASK, 0x00FF);  /* select all planes */
        write_ID(adder, DST_OCR_B,

-                       EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
-
+       EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);

        write_ID(adder, MASK_1, 0xFFFF);
        write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 1);
        write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
        write_ID(adder, MASK_1, 0xFFFF);
        write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 1);
        write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);

-
-       /* load DESTINATION origin and vectors  */
-
+       adder->x_clip_min = 0;
+       adder->x_clip_max = 1024;
+       adder->y_clip_min = 0;
+       adder->y_clip_max = 864;
+       /*
+        * load DESTINATION origin and vectors  
+        */

        adder->fast_dest_dy = 0;
        adder->slow_dest_dx = 0;
        adder->error_1 = 0;
        adder->error_2 = 0;
        adder->fast_dest_dy = 0;
        adder->slow_dest_dx = 0;
        adder->error_1 = 0;
        adder->error_2 = 0;

-

        adder->rasterop_mode = DST_WRITE_ENABLE | NORMAL;
        adder->rasterop_mode = DST_WRITE_ENABLE | NORMAL;

-
-       wait_status(adder, RASTEROP_COMPLETE);
-
+       (void)wait_status(adder, RASTEROP_COMPLETE);

        adder->destination_x = cursor[unit].x;
        adder->fast_dest_dx = CHAR_WIDTH;
        adder->destination_x = cursor[unit].x;
        adder->fast_dest_dx = CHAR_WIDTH;

-

        adder->destination_y = cursor[unit].y;
        adder->slow_dest_dy = CHAR_HEIGHT;
        adder->destination_y = cursor[unit].y;
        adder->slow_dest_dy = CHAR_HEIGHT;

-
-       /* load SOURCE origin and vectors  */
-
-       adder->source_1_x = FONT_X + ((chr - ' ') * CHAR_WIDTH);
-       adder->source_1_y = FONT_Y;
-
+       /*
+        * load SOURCE origin and vectors  
+        */
+       if ((chr - ' ') > (CHARS - 1))  {
+               printf("Invalid character (x)%x in blitc\n",chr);
+               chr = ' ';
+       }
+       /*
+        * X position is modulo the number of characters per line 
+        */
+       adder->source_1_x = FONT_X + 
+           (((chr - ' ') % (MAX_SCREEN_X/CHAR_WIDTH)) * CHAR_WIDTH);
+       /*
+        * Point to either first or second row 
+        */
+       adder->source_1_y = 2048 - 15 * 
+           (((chr - ' ')/(MAX_SCREEN_X/CHAR_WIDTH)) + 1);

        adder->source_1_dx = CHAR_WIDTH;
        adder->source_1_dy = CHAR_HEIGHT;
        adder->source_1_dx = CHAR_WIDTH;
        adder->source_1_dy = CHAR_HEIGHT;

-

        write_ID(adder, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE);
        adder->cmd = RASTEROP | OCRB | 0 | S1E | DTE;
        write_ID(adder, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE);
        adder->cmd = RASTEROP | OCRB | 0 | S1E | DTE;

-
-       /* update console cursor coordinates */
-
+       /*
+        * update console cursor coordinates 
+        */

        cursor[unit].x += CHAR_WIDTH;
        cursor[unit].x += CHAR_WIDTH;

-       dga->x_cursor = TRANX(cursor[unit].x);
-
-       /* auto-wrap margin */
+       if (nograph)
+               dga->x_cursor = TRANX(cursor[unit].x);

        if (cursor[unit].x > (1024 - CHAR_WIDTH)) {
        if (cursor[unit].x > (1024 - CHAR_WIDTH)) {

-           blitc(unit, '\r');
-           blitc(unit, '\n');
+               blitc(unit, '\r');
+               blitc(unit, '\n');

        }
 
 } /* blitc */
 
        }
 
 } /* blitc */
 

-qdreset(){}
-qd_init(){}
-
-/******************************************************************
-*
-*      INTERRUPT SERVICE ROUTINES START HERE:
-*
-******************************************************************/
+qdreset() { }

 
 

-/*****************************************************************
-*
-*      qddint()... service "DMA DONE" interrupt condition
-*
-*****************************************************************/
+/*
+ *  INTERRUPT SERVICE ROUTINES
+ */

 
 

+/*
+ *  Service "DMA DONE" interrupt condition
+ */

 qddint(qd)
 qddint(qd)

-int qd;
+       register qd;

 {
        register struct DMAreq_header *header;
        register struct DMAreq *request;
        register struct dga *dga;
        struct adder *adder;
 {
        register struct DMAreq_header *header;
        register struct DMAreq *request;
        register struct dga *dga;
        struct adder *adder;

-

        int cookie;                     /* DMA adrs for QDSS */
        int cookie;                     /* DMA adrs for QDSS */

-       int i;

 
 

-       spl4();                         /* allow interval timer in */
+       (void)spl4();                   /* allow interval timer in */

 
        /*
        * init pointers 
        */
 
        /*
        * init pointers 
        */

-

        header = DMAheader[qd];             /* register for optimization */
        dga = (struct dga *) qdmap[qd].dga;
        adder = (struct adder *) qdmap[qd].adder;
        header = DMAheader[qd];             /* register for optimization */
        dga = (struct dga *) qdmap[qd].dga;
        adder = (struct adder *) qdmap[qd].adder;


@@ -2099,128 +1809,150 @@ int qd;
        /*
        * if this interrupt flagged as bogus for interrupt flushing purposes.. 
        */
        /*
        * if this interrupt flagged as bogus for interrupt flushing purposes.. 
        */

-

        if (DMA_ISIGNORE(header)) {
        if (DMA_ISIGNORE(header)) {

-           DMA_CLRIGNORE(header);
-           return;
+               DMA_CLRIGNORE(header);
+               return;

        }
 
        }
 

-/*----------------------------------------------------
-* dump a DMA hardware error message if appropriate */
-
+       /*
+       * dump a DMA hardware error message if appropriate
+       */

        if (dga->csr & DMA_ERR) {
 
        if (dga->csr & DMA_ERR) {
 

-           if (dga->csr & PARITY_ERR)
-               printf("qd%d: qddint: DMA hardware parity fault.\n", qd);
+               if (dga->csr & PARITY_ERR)
+                   printf("qd%d: qddint: DMA hardware parity fault.\n", qd);

 
 

-           if (dga->csr & BUS_ERR)
-               printf("qd%d: qddint: DMA hardware bus error.\n", qd);
+               if (dga->csr & BUS_ERR)
+                   printf("qd%d: qddint: DMA hardware bus error.\n", qd);

        }
 
        }
 

-/*----------------------------------------
-* if this was a DMA from user space... */
-
+       /*
+       * if this was a DMA from user space... 
+       */

        if (qdflags[qd].user_dma) {
        if (qdflags[qd].user_dma) {

-           qdflags[qd].user_dma = 0;
-           wakeup((caddr_t)&qdflags[qd].user_dma);
-           return;
+               qdflags[qd].user_dma = 0;
+               wakeup((caddr_t)&qdflags[qd].user_dma);
+               return;

        }
 
        }
 

-/*------------------------------------------------------------------------
-* if we're doing DMA request queue services, field the error condition */
-
+       /*
+       * if we're doing DMA request queue services, field the error condition 
+       */

        if (dga->csr & DMA_ERR) {
 
        if (dga->csr & DMA_ERR) {
 

-           dga->csr &= ~0x0600;                /* halt DMA (reset fifo) */
-           dga->csr |= DMA_ERR;                /* clear error condition */
-           adder->command = CANCEL;            /* cancel adder activity */
+               dga->csr &= ~0x0600;            /* halt DMA (reset fifo) */
+               dga->csr |= DMA_ERR;            /* clear error condition */
+               adder->command = CANCEL;        /* cancel adder activity */

 
 

-           DMA_SETERROR(header);       /* flag error in header status word */
-           DMA_CLRACTIVE(header);
-           header->DMAreq[header->oldest].DMAdone |= HARD_ERROR;
-           header->newest = header->oldest;
-           header->used = 0;
+               DMA_SETERROR(header);   /* flag error in header status word */
+               DMA_CLRACTIVE(header);
+               header->DMAreq[header->oldest].DMAdone |= HARD_ERROR;
+               header->newest = header->oldest;
+               header->used = 0;

 
 

-           if (rsel[qd] && qdflags[qd].selmask & SEL_WRITE) {
-               selwakeup(rsel[qd], 0);
-               rsel[qd] = 0;
-               qdflags[qd].selmask &= ~SEL_WRITE;
-           }
-
-           if (dga->bytcnt_lo != 0) {
-               dga->bytcnt_lo = 0;
-               dga->bytcnt_hi = 0;
-               DMA_SETIGNORE(header);
-           }
+               if (qdrsel[qd] && qdflags[qd].selmask & SEL_WRITE) {
+                       selwakeup(qdrsel[qd], 0);
+                       qdrsel[qd] = 0;
+                       qdflags[qd].selmask &= ~SEL_WRITE;
+               }

 
 

-           return;
+               if (dga->bytcnt_lo != 0) {
+                       dga->bytcnt_lo = 0;
+                       dga->bytcnt_hi = 0;
+                       DMA_SETIGNORE(header);
+               }
+               return;

        }
 
        }
 

-/*----------------------------------------------------------------------------
-* if the DMA request queue is now becoming non-full, wakeup "select" client */
-
+       /*
+       * if the DMA request queue is now becoming non-full, 
+       * wakeup "select" client.
+       */

        if (DMA_ISFULL(header)) {
        if (DMA_ISFULL(header)) {

-
-           if (rsel[qd] && qdflags[qd].selmask & SEL_WRITE) {
-               selwakeup(rsel[qd], 0);
-               rsel[qd] = 0;
-               qdflags[qd].selmask &= ~SEL_WRITE;
-           }
+               if (qdrsel[qd] && qdflags[qd].selmask & SEL_WRITE) {
+                       selwakeup(qdrsel[qd], 0);
+                       qdrsel[qd] = 0;
+                       qdflags[qd].selmask &= ~SEL_WRITE;
+               }

        }
 
        header->DMAreq[header->oldest].DMAdone |= REQUEST_DONE;
        }
 
        header->DMAreq[header->oldest].DMAdone |= REQUEST_DONE;

+       QDlast_DMAtype = header->DMAreq[header->oldest].DMAtype;

 
 

-       if (DMA_ISEMPTY(header)) {
-           printf("qd%d: qddint: unexpected interrupt\n", qd);
+       /* check for unexpected interrupt */
+       if (DMA_ISEMPTY(header))

            return;
            return;

-       }

 
        DMA_GETEND(header);     /* update request queue indices */
 
 
        DMA_GETEND(header);     /* update request queue indices */
 

-/*------------------------------------------------------------
-* if no more DMA pending, wake up "select" client and exit */
-
+       /*
+       * if no more DMA pending, wake up "select" client and exit 
+       */

        if (DMA_ISEMPTY(header)) {
 
        if (DMA_ISEMPTY(header)) {
 

-           if (rsel[qd] && qdflags[qd].selmask & SEL_WRITE) {
-               selwakeup(rsel[qd], 0);
-               rsel[qd] = 0;
-               qdflags[qd].selmask &= ~SEL_WRITE;
-           }
+               if (qdrsel[qd] && qdflags[qd].selmask & SEL_WRITE) {
+                       selwakeup(qdrsel[qd], 0);
+                       qdrsel[qd] = 0;
+                       qdflags[qd].selmask &= ~SEL_WRITE;
+               }

 
 

-           DMA_CLRACTIVE(header);  /* flag DMA done */
-           return;
+               DMA_CLRACTIVE(header);  /* flag DMA done */
+               return;

        }
 
        }
 

-/*---------------------------
-* initiate next DMA xfer  */
-
+       /*
+       * initiate next DMA xfer  
+       */

        request = DMA_GETBEGIN(header);
        request = DMA_GETBEGIN(header);

+       if (request->DMAtype != QDlast_DMAtype) {
+               dga->csr &= ~0x0600;      /* halt DMA (reset fifo) */
+               adder->command = CANCEL;  /* cancel adder activity */
+       }
+

 
        switch (request->DMAtype) {
 
 
        switch (request->DMAtype) {
 

-           case DISPLIST:
-               dga->csr |= DL_ENB;
+       case DISPLIST:
+               if (request->DMAtype != QDlast_DMAtype) {
+                       dga->csr |= DL_ENB;
+                       dga->csr &= ~(BTOP_ENB | BYTE_DMA);
+               }

                break;
 
                break;
 

-           case PTOB:
-               dga->csr |= PTOB_ENB;
+       case PTOB:
+               if (request->DMAtype != QDlast_DMAtype) {
+                       if (request->DMAdone & BYTE_PACK)
+                           dga->csr |= (PTOB_ENB | BYTE_DMA);
+                       else {
+                               dga->csr |= PTOB_ENB;
+                               dga->csr &= ~BYTE_DMA;
+                       }
+               }

                break;
 
                break;
 

-           case BTOP:
-               dga->csr |= BTOP_ENB;
+       case BTOP:
+               if (request->DMAtype != QDlast_DMAtype) {
+                       if (request->DMAdone & BYTE_PACK) {
+                               dga->csr &= ~DL_ENB;
+                               dga->csr |= (BTOP_ENB | BYTE_DMA);
+                       }
+                       else {
+                               dga->csr |= BTOP_ENB;
+                               dga->csr &= ~(BYTE_DMA | DL_ENB);
+                       }
+               }

                break;
                break;

-
-           default:
+       default:

                printf("qd%d: qddint: illegal DMAtype parameter.\n", qd);
                DMA_CLRACTIVE(header);  /* flag DMA done */
                return;
        }
 
        if (request->DMAdone & COUNT_ZERO) {
                printf("qd%d: qddint: illegal DMAtype parameter.\n", qd);
                DMA_CLRACTIVE(header);  /* flag DMA done */
                return;
        }
 
        if (request->DMAdone & COUNT_ZERO) {

-           dga->csr &= ~SET_DONE_FIFO;
-       } else if (request->DMAdone & FIFO_EMPTY) {
-           dga->csr |= SET_DONE_FIFO;
+               dga->csr &= ~SET_DONE_FIFO;
+       } 
+       else if (request->DMAdone & FIFO_EMPTY) {
+               dga->csr |= SET_DONE_FIFO;

        }
 
        if (request->DMAdone & WORD_PACK)
        }
 
        if (request->DMAdone & WORD_PACK)


@@ -2229,6 +1961,7 @@ int qd;
            dga->csr |= BYTE_DMA;
 
        dga->csr |= DMA_IE;
            dga->csr |= BYTE_DMA;
 
        dga->csr |= DMA_IE;

+       QDlast_DMAtype = request->DMAtype;

 
        cookie = ((int)request->bufp - (int)header) + (int)header->QBAreg;
 
 
        cookie = ((int)request->bufp - (int)header) + (int)header->QBAreg;
 


@@ -2241,695 +1974,675 @@ int qd;
        return;
 }
 
        return;
 }
 

-/*****************************************************************
-*
-*      qdaint()... ADDER interrupt service
-*
-*****************************************************************/
-
+/*
+ * ADDER interrupt service routine
+ */

 qdaint(qd)
 qdaint(qd)

-register int qd;
+       register qd;

 {
        register struct adder *adder;
        struct color_buf *cbuf;
 {
        register struct adder *adder;
        struct color_buf *cbuf;

-
-       short stat;

        int i;
        register struct rgb *rgbp;
        register short *red;
        register short *green;
        register short *blue;
 
        int i;
        register struct rgb *rgbp;
        register short *red;
        register short *green;
        register short *blue;
 

-       spl4();                         /* allow interval timer in */
+       (void)spl4();                   /* allow interval timer in */

 
        adder = (struct adder *) qdmap[qd].adder;
 
 
        adder = (struct adder *) qdmap[qd].adder;
 

-/*------------------------------------------------------------------------
-* service the vertical blank interrupt (VSYNC bit) by loading any pending
-* color map load request  */
-
+       /*
+       * service the vertical blank interrupt (VSYNC bit) by loading 
+       * any pending color map load request  
+       */

        if (adder->status & VSYNC) {
        if (adder->status & VSYNC) {

-           adder->status &= ~VSYNC;            /* clear the interrupt */
-
-           cbuf = color_buf[qd];
-           if (cbuf->status & LOAD_COLOR_MAP) {
-
-               red = (short *) qdmap[qd].red;
-               green = (short *) qdmap[qd].green;
-               blue = (short *) qdmap[qd].blue;
-
-               for (i = cbuf->count, rgbp = cbuf->rgb; --i >= 0; rgbp++) {
+               adder->status &= ~VSYNC;        /* clear the interrupt */
+               cbuf = color_buf[qd];
+               if (cbuf->status & LOAD_COLOR_MAP) {
+
+                       red = (short *) qdmap[qd].red;
+                       green = (short *) qdmap[qd].green;
+                       blue = (short *) qdmap[qd].blue;
+
+                       for (i = cbuf->count, rgbp = cbuf->rgb;
+                            --i >= 0; rgbp++) {
+                               red[rgbp->offset] = (short) rgbp->red;
+                               green[rgbp->offset] = (short) rgbp->green;
+                               blue[rgbp->offset] = (short) rgbp->blue;
+                       }

 
 

-                   red[rgbp->offset] = (short) rgbp->red;
-                   green[rgbp->offset] = (short) rgbp->green;
-                   blue[rgbp->offset] = (short) rgbp->blue;
+                       cbuf->status &= ~LOAD_COLOR_MAP;

                }
                }

-
-               cbuf->status &= ~LOAD_COLOR_MAP;
-           }

        }
 
        }
 

-/*-------------------------------------------------
-* service the scroll interrupt (FRAME_SYNC bit) */
-
+       /*
+       * service the scroll interrupt (FRAME_SYNC bit) 
+       */

        if (adder->status & FRAME_SYNC) {
        if (adder->status & FRAME_SYNC) {

-           adder->status &= ~FRAME_SYNC;       /* clear the interrupt */
+               adder->status &= ~FRAME_SYNC;   /* clear the interrupt */

 
 

-           if (scroll[qd]->status & LOAD_REGS) {
+               if (scroll[qd]->status & LOAD_REGS) {

 
 

-               for ( i = 1000, adder->status = 0
-                   ; i > 0  &&  !((stat = adder->status) & ID_SCROLL_READY)
-                   ; --i);
+                       for (i = 1000, adder->status = 0; i > 0 && 
+                            !(adder->status&ID_SCROLL_READY); --i)
+                             ;

 
 

-               if (i == 0) {
-                   printf("qd%d: qdaint: timeout on ID_SCROLL_READY\n", qd);
-                   return;
-               }
+                       if (i == 0) {
+                           printf("qd%d: qdaint: timeout on ID_SCROLL_READY\n",
+                               qd);
+                               return;
+                       }

 
 

-               adder->ID_scroll_data = scroll[qd]->viper_constant;
-               adder->ID_scroll_command = ID_LOAD | SCROLL_CONSTANT;
+                       adder->ID_scroll_data = scroll[qd]->viper_constant;
+                       adder->ID_scroll_command = ID_LOAD | SCROLL_CONSTANT;

 
 

-               adder->y_scroll_constant = scroll[qd]->y_scroll_constant;
-               adder->y_offset_pending = scroll[qd]->y_offset;
+                       adder->y_scroll_constant =
+                               scroll[qd]->y_scroll_constant;
+                       adder->y_offset_pending = scroll[qd]->y_offset;

 
 

-               if (scroll[qd]->status & LOAD_INDEX) {
+                       if (scroll[qd]->status & LOAD_INDEX) {

 
 

-                   adder->x_index_pending = scroll[qd]->x_index_pending;
-                   adder->y_index_pending = scroll[qd]->y_index_pending;
-               }
+                               adder->x_index_pending = 
+                                       scroll[qd]->x_index_pending;
+                               adder->y_index_pending = 
+                                       scroll[qd]->y_index_pending;
+                       }

 
 

-           scroll[qd]->status = 0x00;
-           }
+                       scroll[qd]->status = 0x00;
+               }

        }
 }
 
        }
 }
 

-/*****************************************************************
-*
-*      qdiint()... DUART input interrupt service routine
-*
-*****************************************************************/
+/*
+ *  DUART input interrupt service routine
+ *
+ *  XXX - this routine should be broken out - it is essentially
+ *           straight line code.
+ */

 
 qdiint(qd)
 
 qdiint(qd)

-register int qd;
+       register qd;

 {
        register struct _vs_event *event;
        register struct qdinput *eqh;
 {
        register struct _vs_event *event;
        register struct qdinput *eqh;

-

        struct dga *dga;
        struct duart *duart;
        struct mouse_report *new_rep;
        struct dga *dga;
        struct duart *duart;
        struct mouse_report *new_rep;

-

        struct uba_device *ui;
        struct tty *tp;
        struct uba_device *ui;
        struct tty *tp;

-
-       char chr;
-       int i,j;
-       int k,l;
-
+       u_short chr;

        u_short status;
        u_short data;
        u_short key;
        u_short status;
        u_short data;
        u_short key;

-

        char do_wakeup = 0;             /* flag to do a select wakeup call */
        char a, b, c;                   /* mouse button test variables */
 
        char do_wakeup = 0;             /* flag to do a select wakeup call */
        char a, b, c;                   /* mouse button test variables */
 

-       spl4();                         /* allow interval timer in */
+       (void)spl4();                   /* allow interval timer in */

 
        eqh = eq_header[qd];            /* optimized as a register */
        new_rep = &current_rep[qd];
        duart = (struct duart *) qdmap[qd].duart;
 
 
        eqh = eq_header[qd];            /* optimized as a register */
        new_rep = &current_rep[qd];
        duart = (struct duart *) qdmap[qd].duart;
 

-/*-----------------------------------------
-* if the graphic device is turned on.. */
-
+       /*
+       * if the graphic device is turned on..  
+       */

        if (qdflags[qd].inuse & GRAPHIC_DEV) {
        if (qdflags[qd].inuse & GRAPHIC_DEV) {

+               /*
+               * empty DUART 
+               */
+               while (duart->statusA&RCV_RDY || duart->statusB&RCV_RDY) {
+                       /*
+                        * pick up LK-201 input (if any) 
+                        */
+                       if (duart->statusA&RCV_RDY) {

 
 

-           /*---------------
-           * empty DUART */
+                               /* if error condition, then reset it */

 
 

-           while ((status = duart->statusA) & RCV_RDY  ||
-                  (status = duart->statusB) & RCV_RDY) {
+                               if (duart->statusA&0x70) {
+                                       duart->cmdA = 0x40;
+                                       continue;
+                               }

 
 

-               /*---------------------------------
-               * pick up LK-201 input (if any) */
+                               /* event queue full now? (overflow condition) */

 
 

-               if ((status = duart->statusA) & RCV_RDY) {
+                               if (ISFULL(eqh) == TRUE) {
+                                       printf(
+                                        "qd%d: qdiint: event queue overflow\n",
+                                          qd);
+                                       break;
+                               }

 
 

-                   /* if error condition, then reset it */
+                               /*
+                               * Check for various keyboard errors  */

 
 

-                   if ((status = duart->statusA) & 0x70) {
-                       duart->cmdA = 0x40;
-                       continue;
-                   }
+                               key = duart->dataA & 0xFF;

 
 

-                   /* event queue full now? (overflow condition) */
+                               if (key==LK_POWER_ERROR ||
+                                   key==LK_KDOWN_ERROR ||
+                                   key == LK_INPUT_ERROR || 
+                                   key == LK_OUTPUT_ERROR) {
+                                       printf(
+                                   "qd%d: qdiint: keyboard error, code = %x\n",
+                                       qd,key);
+                                       return;
+                               }

 
 

-                   if (ISFULL(eqh) == TRUE) {
-                       printf("qd%d: qdiint: event queue overflow\n", qd);
-                       break;
-                   }
+                               if (key < LK_LOWEST)
+                                   return;

 
 

-                   /*--------------------------------------
-                   * Check for various keyboard errors  */
+                               ++do_wakeup;  /* request a select wakeup call */

 
 

-                   key = duart->dataA & 0xFF;
+                               event = PUTBEGIN(eqh);
+                               PUTEND(eqh);

 
 

-                   if( key == LK_POWER_ERROR || key == LK_KDOWN_ERROR ||
-                       key == LK_INPUT_ERROR || key == LK_OUTPUT_ERROR) {
-                       printf("qd%d: qdiint: keyboard error, code = %x\n",
-                               qd, key);
-                       return(0);
-                   }
+                               event->vse_key = key;
+                               event->vse_key &= 0x00FF;
+                               event->vse_x = eqh->curs_pos.x;
+                               event->vse_y = eqh->curs_pos.y;
+                               event->vse_time = TOY;
+                               event->vse_type = VSE_BUTTON;
+                               event->vse_direction = VSE_KBTRAW;
+                               event->vse_device = VSE_DKB;
+                       }

 
 

-                   if (key < LK_LOWEST)
-                       return(0);
+                       /*
+                       * pick up the mouse input (if any)  */

 
 

-                   ++do_wakeup;        /* request a select wakeup call */
+                       if ((status = duart->statusB) & RCV_RDY  &&
+                           qdflags[qd].pntr_id == MOUSE_ID) {

 
 

-                   event = PUTBEGIN(eqh);
-                   PUTEND(eqh);
+                               if (status & 0x70) {
+                                       duart->cmdB = 0x40;
+                                       continue;
+                               }

 
 

-                   event->vse_key = key;
-                   event->vse_key &= 0x00FF;
-                   event->vse_x = eqh->curs_pos.x;
-                   event->vse_y = eqh->curs_pos.y;
-                   event->vse_time = TOY;
-                   event->vse_type = VSE_BUTTON;
-                   event->vse_direction = VSE_KBTRAW;
-                   event->vse_device = VSE_DKB;
-               }
+                               /* event queue full now? (overflow condition) */

 
 

-               /*-------------------------------------
-               * pick up the mouse input (if any)  */
+                               if (ISFULL(eqh) == TRUE) {
+                                       printf(
+                                       "qd%d: qdiint: event queue overflow\n",
+                                            qd);
+                                       break;
+                               }

 
 

-               if ((status = duart->statusB) & RCV_RDY  &&
-                    qdflags[qd].pntr_id == MOUSE_ID) {
+                               data = duart->dataB;      /* get report byte */
+                               ++new_rep->bytcnt; /* bump report byte count */

 
 

-                   if (status & 0x70) {
-                       duart->cmdB = 0x40;
-                       continue;
-                   }
+                               /*
+                               * if 1st byte of report.. */

 
 

-                   /* event queue full now? (overflow condition) */
+                               if ( data & START_FRAME) {
+                                       new_rep->state = data;
+                                       if (new_rep->bytcnt > 1) {
+                                               /* start of new frame */
+                                               new_rep->bytcnt = 1;    
+                                               /* ..continue looking */
+                                               continue;                   
+                                       }
+                               }

 
 

-                   if (ISFULL(eqh) == TRUE) {
-                       printf("qd%d: qdiint: event queue overflow\n", qd);
-                       break;
-                   }
+                               /*
+                               * if 2nd byte of report.. */

 
 

-                   data = duart->dataB;      /* get report byte */
-                   ++new_rep->bytcnt;        /* bump report byte count */
+                               else if (new_rep->bytcnt == 2) {
+                                       new_rep->dx = data & 0x00FF;
+                               }

 
 

-                   /*---------------------------
-                   * if 1st byte of report.. */
+                               /*
+                               * if 3rd byte of report, load input event queue */

 
 

-                   if ( data & START_FRAME) {
-                       new_rep->state = data;
-                       if (new_rep->bytcnt > 1) {
-                           new_rep->bytcnt = 1;    /* start of new frame */
-                           continue;               /* ..continue looking */
-                       }
-                   }
-
-                   /*---------------------------
-                   * if 2nd byte of report.. */
-
-                   else if (new_rep->bytcnt == 2) {
-                       new_rep->dx = data & 0x00FF;
-                   }
-
-                   /*-------------------------------------------------
-                   * if 3rd byte of report, load input event queue */
-
-                   else if (new_rep->bytcnt == 3) {
-
-                       new_rep->dy = data & 0x00FF;
-                       new_rep->bytcnt = 0;
-
-                       /*-----------------------------------
-                       * if mouse position has changed.. */
-
-                       if (new_rep->dx != 0  ||  new_rep->dy != 0) {
-
-                           /*---------------------------------------------
-                           * calculate acceleration factor, if needed  */
-
-                           if (qdflags[qd].curs_acc > ACC_OFF) {
-
-                               if (qdflags[qd].curs_thr <= new_rep->dx)
-                                   new_rep->dx +=
-                                       (new_rep->dx - qdflags[qd].curs_thr)
-                                        * qdflags[qd].curs_acc;
-
-                               if (qdflags[qd].curs_thr <= new_rep->dy)
-                                   new_rep->dy +=
-                                       (new_rep->dy - qdflags[qd].curs_thr)
-                                        * qdflags[qd].curs_acc;
-                           }
-
-                           /*-------------------------------------
-                           * update cursor position coordinates */
-
-                           if (new_rep->state & X_SIGN) {
-                               eqh->curs_pos.x += new_rep->dx;
-                               if (eqh->curs_pos.x > 1023)
-                                   eqh->curs_pos.x = 1023;
-                           }
-                           else {
-                               eqh->curs_pos.x -= new_rep->dx;
-                               if (eqh->curs_pos.x < -15)
-                                   eqh->curs_pos.x = -15;
-                           }
-
-                           if (new_rep->state & Y_SIGN) {
-                                eqh->curs_pos.y -= new_rep->dy;
-                                if (eqh->curs_pos.y < -15)
-                                    eqh->curs_pos.y = -15;
-                           }
-                           else {
-                               eqh->curs_pos.y += new_rep->dy;
-                               if (eqh->curs_pos.y > 863)
-                                   eqh->curs_pos.y = 863;
-                           }
-
-                           /*---------------------------------
-                           * update cursor screen position */
-
-                           dga = (struct dga *) qdmap[qd].dga;
-                           dga->x_cursor = TRANX(eqh->curs_pos.x);
-                           dga->y_cursor = TRANY(eqh->curs_pos.y);
-
-                           /*--------------------------------------------
-                           * if cursor is in the box, no event report */
-
-                           if (eqh->curs_pos.x <= eqh->curs_box.right  &&
-                               eqh->curs_pos.x >= eqh->curs_box.left  &&
-                               eqh->curs_pos.y >= eqh->curs_box.top  &&
-                               eqh->curs_pos.y <= eqh->curs_box.bottom ) {
-                                   goto GET_MBUTTON;
-                           }
-
-                           /*---------------------------------
-                           * report the mouse motion event */
-
-                           event = PUTBEGIN(eqh);
-                           PUTEND(eqh);
-
-                           ++do_wakeup;   /* request a select wakeup call */
-
-                           event->vse_x = eqh->curs_pos.x;
-                           event->vse_y = eqh->curs_pos.y;
-
-                           event->vse_device = VSE_MOUSE;  /* mouse */
-                           event->vse_type = VSE_MMOTION;  /* pos changed */
-                           event->vse_key = 0;
-                           event->vse_direction = 0;
-                           event->vse_time = TOY;      /* time stamp */
-                       }
+                               else if (new_rep->bytcnt == 3) {

 
 

-GET_MBUTTON:
-                       /*-------------------------------
-                       * if button state has changed */
+                                       new_rep->dy = data & 0x00FF;
+                                       new_rep->bytcnt = 0;

 
 

-                       a = new_rep->state & 0x07;    /*mask nonbutton bits */
-                       b = last_rep[qd].state & 0x07;
+                                       /*
+                                       * if mouse position has changed.. */

 
 

-                       if (a ^ b) {
+                                       if (new_rep->dx != 0  ||  new_rep->dy != 0) {

 
 

-                           for ( c = 1;  c < 8; c <<= 1) {
+                                               /*
+                                               * calculate acceleration factor, if needed      */

 
 

-                               if (!( c & (a ^ b))) /* this button change? */
-                                   continue;
+                                               if (qdflags[qd].curs_acc > ACC_OFF) {

 
 

-                               /* event queue full? (overflow condition) */
+                                                       if (qdflags[qd].curs_thr <= new_rep->dx)
+                                                           new_rep->dx +=
+                                                           (new_rep->dx - qdflags[qd].curs_thr)
+                                                           * qdflags[qd].curs_acc;

 
 

-                               if (ISFULL(eqh) == TRUE) {
-                                   printf("qd%d: qdiint: event queue overflow\n", qd);
-                                   break;
-                               }
+                                                       if (qdflags[qd].curs_thr <= new_rep->dy)
+                                                           new_rep->dy +=
+                                                           (new_rep->dy - qdflags[qd].curs_thr)
+                                                           * qdflags[qd].curs_acc;
+                                               }

 
 

-                               event = PUTBEGIN(eqh);  /* get new event */
-                               PUTEND(eqh);
+                                               /*
+                                               * update cursor position coordinates */

 
 

-                               ++do_wakeup;   /* request select wakeup */
+                                               if (new_rep->state & X_SIGN) {
+                                                       eqh->curs_pos.x += new_rep->dx;
+                                                       if (eqh->curs_pos.x > 1023)
+                                                           eqh->curs_pos.x = 1023;
+                                               }
+                                               else {
+                                                       eqh->curs_pos.x -= new_rep->dx;
+                                                       if (eqh->curs_pos.x < -15)
+                                                           eqh->curs_pos.x = -15;
+                                               }

 
 

-                               event->vse_x = eqh->curs_pos.x;
-                               event->vse_y = eqh->curs_pos.y;
+                                               if (new_rep->state & Y_SIGN) {
+                                                       eqh->curs_pos.y -= new_rep->dy;
+                                                       if (eqh->curs_pos.y < -15)
+                                                           eqh->curs_pos.y = -15;
+                                               }
+                                               else {
+                                                       eqh->curs_pos.y += new_rep->dy;
+                                                       if (eqh->curs_pos.y > 863)
+                                                           eqh->curs_pos.y = 863;
+                                               }

 
 

-                               event->vse_device = VSE_MOUSE;  /* mouse */
-                               event->vse_type = VSE_BUTTON; /* new button */
-                               event->vse_time = TOY;        /* time stamp */
+                                               /*
+                                               * update cursor screen position */

 
 

-                               /* flag changed button and if up or down */
+                                               dga = (struct dga *) qdmap[qd].dga;
+                                               dga->x_cursor = TRANX(eqh->curs_pos.x);
+                                               dga->y_cursor = TRANY(eqh->curs_pos.y);

 
 

-                               if (c == RIGHT_BUTTON)
-                                   event->vse_key = VSE_RIGHT_BUTTON;
-                               else if (c == MIDDLE_BUTTON)
-                                   event->vse_key = VSE_MIDDLE_BUTTON;
-                               else if (c == LEFT_BUTTON)
-                                   event->vse_key = VSE_LEFT_BUTTON;
+                                               /*
+                                               * if cursor is in the box, no event report */

 
 

-                               /* set bit = button depressed */
+                                               if (eqh->curs_pos.x <= eqh->curs_box.right      &&
+                                                   eqh->curs_pos.x >= eqh->curs_box.left  &&
+                                                   eqh->curs_pos.y >= eqh->curs_box.top  &&
+                                                   eqh->curs_pos.y <= eqh->curs_box.bottom ) {
+                                                       goto GET_MBUTTON;
+                                               }

 
 

-                               if (c & a)
-                                   event->vse_direction = VSE_KBTDOWN;
-                               else
-                                   event->vse_direction = VSE_KBTUP;
-                           }
-                       }
+                                               /*
+                                               * report the mouse motion event */

 
 

-                       /* refresh last report */
+                                               event = PUTBEGIN(eqh);
+                                               PUTEND(eqh);

 
 

-                       last_rep[qd] = current_rep[qd];
+                                               ++do_wakeup;   /* request a select wakeup call */

 
 

-                   }  /* get last byte of report */
-               } /* pickup mouse input */
+                                               event->vse_x = eqh->curs_pos.x;
+                                               event->vse_y = eqh->curs_pos.y;

 
 

-               /*--------------------------------
-               * pickup tablet input, if any  */
+                                               event->vse_device = VSE_MOUSE;  /* mouse */
+                                               event->vse_type = VSE_MMOTION;  /* pos changed */
+                                               event->vse_key = 0;
+                                               event->vse_direction = 0;
+                                               event->vse_time = TOY;  /* time stamp */
+                                       }

 
 

-               else if ((status = duart->statusB) & RCV_RDY  &&
-                        qdflags[qd].pntr_id == TABLET_ID) {
+GET_MBUTTON:
+                                       /*
+                                       * if button state has changed */

 
 

-                   if (status & 0x70) {
-                       duart->cmdB = 0x40;
-                       continue;
-                   }
+                                       a = new_rep->state & 0x07;    /*mask nonbutton bits */
+                                       b = last_rep[qd].state & 0x07;

 
 

-                   /* event queue full now? (overflow condition) */
+                                       if (a ^ b) {

 
 

-                   if (ISFULL(eqh) == TRUE) {
-                       printf("qd%d: qdiint: event queue overflow\n", qd);
-                       break;
-                   }
+                                               for ( c = 1;  c < 8; c <<= 1) {

 
 

-                   data = duart->dataB;      /* get report byte */
-                   ++new_rep->bytcnt;        /* bump report byte count */
+                                                       if (!( c & (a ^ b))) /* this button change? */
+                                                           continue;

 
 

-                   /*---------------------------
-                   * if 1st byte of report.. */
+                                                       /* event queue full? (overflow condition) */

 
 

-                   if (data & START_FRAME) {
-                       new_rep->state = data;
-                       if (new_rep->bytcnt > 1) {
-                           new_rep->bytcnt = 1;    /* start of new frame */
-                           continue;               /* ..continue looking */
-                       }
-                   }
+                                                       if (ISFULL(eqh) == TRUE) {
+                                                               printf("qd%d: qdiint: event queue overflow\n", qd);
+                                                               break;
+                                                       }

 
 

-                   /*---------------------------
-                   * if 2nd byte of report.. */
+                                                       event = PUTBEGIN(eqh);  /* get new event */
+                                                       PUTEND(eqh);

 
 

-                   else if (new_rep->bytcnt == 2) {
-                       new_rep->dx = data & 0x3F;
-                   }
+                                                       ++do_wakeup;   /* request select wakeup */

 
 

-                   /*---------------------------
-                   * if 3rd byte of report.. */
+                                                       event->vse_x = eqh->curs_pos.x;
+                                                       event->vse_y = eqh->curs_pos.y;

 
 

-                   else if (new_rep->bytcnt == 3) {
-                       new_rep->dx |= (data & 0x3F) << 6;
-                   }
+                                                       event->vse_device = VSE_MOUSE;  /* mouse */
+                                                       event->vse_type = VSE_BUTTON; /* new button */
+                                                       event->vse_time = TOY;        /* time stamp */

 
 

-                   /*---------------------------
-                   * if 4th byte of report.. */
+                                                       /* flag changed button and if up or down */

 
 

-                   else if (new_rep->bytcnt == 4) {
-                       new_rep->dy = data & 0x3F;
-                   }
+                                                       if (c == RIGHT_BUTTON)
+                                                           event->vse_key = VSE_RIGHT_BUTTON;
+                                                       else if (c == MIDDLE_BUTTON)
+                                                           event->vse_key = VSE_MIDDLE_BUTTON;
+                                                       else if (c == LEFT_BUTTON)
+                                                           event->vse_key = VSE_LEFT_BUTTON;

 
 

-                   /*-------------------------------------------------
-                   * if 5th byte of report, load input event queue */
+                                                       /* set bit = button depressed */

 
 

-                   else if (new_rep->bytcnt == 5) {
+                                                       if (c & a)
+                                                           event->vse_direction = VSE_KBTDOWN;
+                                                       else
+                                                               event->vse_direction = VSE_KBTUP;
+                                               }
+                                       }

 
 

-                       new_rep->dy |= (data & 0x3F) << 6;
-                       new_rep->bytcnt = 0;
+                                       /* refresh last report */

 
 

-                       /*-------------------------------------
-                       * update cursor position coordinates */
+                                       last_rep[qd] = current_rep[qd];

 
 

-                       new_rep->dx /= qdflags[qd].tab_res;
-                       new_rep->dy = (2200 - new_rep->dy)
-                                     / qdflags[qd].tab_res;
+                               }  /* get last byte of report */
+                       } else if ((status = duart->statusB)&RCV_RDY &&
+                                  qdflags[qd].pntr_id == TABLET_ID) {
+                               /*
+                               * pickup tablet input, if any  
+                               */
+                               if (status&0x70) {
+                                       duart->cmdB = 0x40;
+                                       continue;
+                               }
+                               /* 
+                                * event queue full now? (overflow condition) 
+                                */
+                               if (ISFULL(eqh) == TRUE) {
+                                       printf("qd%d: qdiint: event queue overflow\n", qd);
+                                       break;
+                               }

 
 

-                       if (new_rep->dx > 1023) {
-                           new_rep->dx = 1023;
-                       }
-                       if (new_rep->dy > 863) {
-                           new_rep->dy = 863;
-                       }
+                               data = duart->dataB;      /* get report byte */
+                               ++new_rep->bytcnt;            /* bump report byte count */

 
 

-                       /*
-                        * report an event if the puck/stylus has moved
-                        */
+                               /*
+                               * if 1st byte of report.. */

 
 

-                       if (eqh->curs_pos.x != new_rep->dx ||
-                           eqh->curs_pos.y != new_rep->dy) {
+                               if (data & START_FRAME) {
+                                       new_rep->state = data;
+                                       if (new_rep->bytcnt > 1) {
+                                               new_rep->bytcnt = 1;    /* start of new frame */
+                                               continue;                   /* ..continue looking */
+                                       }
+                               }

 
 

-                           eqh->curs_pos.x = new_rep->dx;
-                           eqh->curs_pos.y = new_rep->dy;
+                               /*
+                               * if 2nd byte of report.. */

 
 

-                           /*---------------------------------
-                           * update cursor screen position */
+                               else if (new_rep->bytcnt == 2) {
+                                       new_rep->dx = data & 0x3F;
+                               }

 
 

-                           dga = (struct dga *) qdmap[qd].dga;
-                           dga->x_cursor = TRANX(eqh->curs_pos.x);
-                           dga->y_cursor = TRANY(eqh->curs_pos.y);
+                               /*
+                               * if 3rd byte of report.. */

 
 

-                           /*
-                            * if cursor is in the box, no event report
-                            */
+                               else if (new_rep->bytcnt == 3) {
+                                       new_rep->dx |= (data & 0x3F) << 6;
+                               }

 
 

-                           if (eqh->curs_pos.x <= eqh->curs_box.right  &&
-                               eqh->curs_pos.x >= eqh->curs_box.left  &&
-                               eqh->curs_pos.y >= eqh->curs_box.top  &&
-                               eqh->curs_pos.y <= eqh->curs_box.bottom ) {
-                               goto GET_TBUTTON;
-                           }
+                               /*
+                               * if 4th byte of report.. */

 
 

-                           /*---------------------------------
-                           * report the tablet motion event */
+                               else if (new_rep->bytcnt == 4) {
+                                       new_rep->dy = data & 0x3F;
+                               }

 
 

-                           event = PUTBEGIN(eqh);
-                           PUTEND(eqh);
+                               /*
+                               * if 5th byte of report, load input event queue */

 
 

-                           ++do_wakeup;   /* request a select wakeup call */
+                               else if (new_rep->bytcnt == 5) {

 
 

-                           event->vse_x = eqh->curs_pos.x;
-                           event->vse_y = eqh->curs_pos.y;
+                                       new_rep->dy |= (data & 0x3F) << 6;
+                                       new_rep->bytcnt = 0;

 
 

-                           event->vse_device = VSE_TABLET;  /* tablet */
-                           /*
-                            * right now, X handles tablet motion the same
-                            * as mouse motion
-                            */
-                           event->vse_type = VSE_MMOTION;   /* pos changed */
-                           event->vse_key = 0;
-                           event->vse_direction = 0;
-                           event->vse_time = TOY;      /* time stamp */
-                       }
-GET_TBUTTON:
-                       /*-------------------------------
-                       * if button state has changed */
+                                       /*
+                                       * update cursor position coordinates */

 
 

-                       a = new_rep->state & 0x1E;   /* mask nonbutton bits */
-                       b = last_rep[qd].state & 0x1E;
+                                       new_rep->dx /= qdflags[qd].tab_res;
+                                       new_rep->dy = (2200 - new_rep->dy)
+                                           / qdflags[qd].tab_res;

 
 

-                       if (a ^ b) {
+                                       if (new_rep->dx > 1023) {
+                                               new_rep->dx = 1023;
+                                       }
+                                       if (new_rep->dy > 863) {
+                                               new_rep->dy = 863;
+                                       }

 
 

-                           /* event queue full now? (overflow condition) */
+                                       /*
+                                       * report an event if the puck/stylus has moved
+                                       */

 
 

-                           if (ISFULL(eqh) == TRUE) {
-                               printf("qd%d: qdiint: event queue overflow\n",
-                                       qd);
-                               break;
-                           }
+                                       if (eqh->curs_pos.x != new_rep->dx ||
+                                           eqh->curs_pos.y != new_rep->dy) {

 
 

-                           event = PUTBEGIN(eqh);  /* get new event */
-                           PUTEND(eqh);
+                                               eqh->curs_pos.x = new_rep->dx;
+                                               eqh->curs_pos.y = new_rep->dy;

 
 

-                           ++do_wakeup;   /* request a select wakeup call */
+                                               /*
+                                               * update cursor screen position */

 
 

-                           event->vse_x = eqh->curs_pos.x;
-                           event->vse_y = eqh->curs_pos.y;
+                                               dga = (struct dga *) qdmap[qd].dga;
+                                               dga->x_cursor = TRANX(eqh->curs_pos.x);
+                                               dga->y_cursor = TRANY(eqh->curs_pos.y);

 
 

-                           event->vse_device = VSE_TABLET;  /* tablet */
-                           event->vse_type = VSE_BUTTON; /* button changed */
-                           event->vse_time = TOY;         /* time stamp */
+                                               /*
+                                               * if cursor is in the box, no event report
+                                               */

 
 

-                           /* define the changed button and if up or down */
+                                               if (eqh->curs_pos.x <= eqh->curs_box.right      &&
+                                                   eqh->curs_pos.x >= eqh->curs_box.left  &&
+                                                   eqh->curs_pos.y >= eqh->curs_box.top  &&
+                                                   eqh->curs_pos.y <= eqh->curs_box.bottom ) {
+                                                       goto GET_TBUTTON;
+                                               }

 
 

-                           for ( c = 1;  c <= 0x10; c <<= 1) {
-                               if (c & (a ^ b)) {
-                                   if (c == T_LEFT_BUTTON)
-                                       event->vse_key = VSE_T_LEFT_BUTTON;
-                                   else if (c == T_FRONT_BUTTON)
-                                       event->vse_key = VSE_T_FRONT_BUTTON;
-                                   else if (c == T_RIGHT_BUTTON)
-                                       event->vse_key = VSE_T_RIGHT_BUTTON;
-                                   else if (c == T_BACK_BUTTON)
-                                       event->vse_key = VSE_T_BACK_BUTTON;
-                                   break;
-                               }
-                           }
+                                               /*
+                                               * report the tablet motion event */

 
 

-                           /* set bit = button depressed */
+                                               event = PUTBEGIN(eqh);
+                                               PUTEND(eqh);

 
 

-                           if (c & a)
-                               event->vse_direction = VSE_KBTDOWN;
-                           else
-                               event->vse_direction = VSE_KBTUP;
-                       }
+                                               ++do_wakeup;   /* request a select wakeup call */

 
 

-                       /* refresh last report */
+                                               event->vse_x = eqh->curs_pos.x;
+                                               event->vse_y = eqh->curs_pos.y;

 
 

-                       last_rep[qd] = current_rep[qd];
+                                               event->vse_device = VSE_TABLET;  /* tablet */
+                                               /*
+                                               * right now, X handles tablet motion the same
+                                               * as mouse motion
+                                               */
+                                               event->vse_type = VSE_MMOTION;   /* pos changed */
+                                               event->vse_key = 0;
+                                               event->vse_direction = 0;
+                                               event->vse_time = TOY;  /* time stamp */
+                                       }
+GET_TBUTTON:
+                                       /*
+                                       * if button state has changed */

 
 

-                   } /* get last byte of report */
-               } /* pick up tablet input */
+                                       a = new_rep->state & 0x1E;   /* mask nonbutton bits */
+                                       b = last_rep[qd].state & 0x1E;

 
 

-           } /* while input available.. */
+                                       if (a ^ b) {

 
 

-           /*---------------------
-           * do select wakeup  */
+                                               /* event queue full now? (overflow condition) */

 
 

-           if (rsel[qd] && do_wakeup && qdflags[qd].selmask & SEL_READ) {
-               selwakeup(rsel[qd], 0);
-               rsel[qd] = 0;
-               qdflags[qd].selmask &= ~SEL_READ;
-               do_wakeup = 0;
-           }
-       }
+                                               if (ISFULL(eqh) == TRUE) {
+                                                       printf("qd%d: qdiint: event queue overflow\n",qd);
+                                                       break;
+                                               }

 
 

-       /*-----------------------------------------------------------------
-       * if the graphic device is not turned on, this is console input */
+                                               event = PUTBEGIN(eqh);  /* get new event */
+                                               PUTEND(eqh);

 
 

-       else {
+                                               ++do_wakeup;   /* request a select wakeup call */

 
 

-           ui = qdinfo[qd];
-           if (ui == 0 || ui->ui_alive == 0)
-               return(0);
+                                               event->vse_x = eqh->curs_pos.x;
+                                               event->vse_y = eqh->curs_pos.y;

 
 

-           tp = &qd_tty[qd << 2];
+                                               event->vse_device = VSE_TABLET;  /* tablet */
+                                               event->vse_type = VSE_BUTTON; /* button changed */
+                                               event->vse_time = TOY;     /* time stamp */

 
 

-           /*--------------------------------------
-           * Get a character from the keyboard. */
+                                               /* define the changed button and if up or down */

 
 

-           while ((status = duart->statusA) & RCV_RDY) {
+                                               for ( c = 1;  c <= 0x10; c <<= 1) {
+                                                       if (c & (a ^ b)) {
+                                                               if (c == T_LEFT_BUTTON)
+                                                                   event->vse_key = VSE_T_LEFT_BUTTON;
+                                                               else if (c == T_FRONT_BUTTON)
+                                                                   event->vse_key = VSE_T_FRONT_BUTTON;
+                                                               else if (c == T_RIGHT_BUTTON)
+                                                                   event->vse_key = VSE_T_RIGHT_BUTTON;
+                                                               else if (c == T_BACK_BUTTON)
+                                                                   event->vse_key = VSE_T_BACK_BUTTON;
+                                                               break;
+                                                       }
+                                               }

 
 

-               key = duart->dataA;
-               key &= 0xFF;
+                                               /* set bit = button depressed */

 
 

-               /*--------------------------------------
-               * Check for various keyboard errors  */
+                                               if (c & a)
+                                                   event->vse_direction = VSE_KBTDOWN;
+                                               else
+                                                       event->vse_direction = VSE_KBTUP;
+                                       }

 
 

-               if( key == LK_POWER_ERROR || key == LK_KDOWN_ERROR ||
-                   key == LK_INPUT_ERROR || key == LK_OUTPUT_ERROR) {
-                       printf("qd%d: qdiint: Keyboard error, code = %x\n",
-                               qd, key);
-                       return(0);
-               }
+                                       /* refresh last report */

 
 

-               if (key < LK_LOWEST)
-                   return(0);
+                                       last_rep[qd] = current_rep[qd];

 
 

-               /*---------------------------------
-               * See if its a state change key */
+                               } /* get last byte of report */
+                       } /* pick up tablet input */

 
 

-               switch (key) {
+               } /* while input available.. */

 
 

-                   case LOCK:
-                       q_keyboard.lock ^= 0xffff;      /* toggle */
-                       if (q_keyboard.lock)
-                           led_control(qd, LK_LED_ENABLE, LK_LED_LOCK);
-                       else
-                           led_control(qd, LK_LED_DISABLE, LK_LED_LOCK);
+               /*
+               * do select wakeup      
+               */
+               if (qdrsel[qd] && do_wakeup && qdflags[qd].selmask & SEL_READ) {
+                       selwakeup(qdrsel[qd], 0);
+                       qdrsel[qd] = 0;
+                       qdflags[qd].selmask &= ~SEL_READ;
+                       do_wakeup = 0;
+               }
+       } else {
+               /*
+                * if the graphic device is not turned on, this is console input
+                */
+               ui = qdinfo[qd];
+               if (ui == 0 || ui->ui_alive == 0)

                        return;
 
                        return;
 

-                   case SHIFT:
-                       q_keyboard.shift ^= 0xFFFF;
-                       return;
+               tp = &qd_tty[qd << 2];

 
 

-                   case CNTRL:
-                       q_keyboard.cntrl ^= 0xFFFF;
-                       return;
+               /*
+                * Get a character from the keyboard. 
+                */
+               while (duart->statusA&RCV_RDY) {
+                       key = duart->dataA;
+                       key &= 0xFF;
+                       /*
+                       * Check for various keyboard errors  
+                       */
+                       if (key == LK_POWER_ERROR || key == LK_KDOWN_ERROR ||
+                           key == LK_INPUT_ERROR || key == LK_OUTPUT_ERROR) {
+                               printf("qd%d: qdiint: Keyboard error, code = %x\n",qd,key);
+                               return;
+                       }

 
 

-                   case ALLUP:
-                       q_keyboard.cntrl = 0;
-                       q_keyboard.shift = 0;
-                       return;
+                       if (key < LK_LOWEST)
+                           return;

 
 

-                   case REPEAT:
-                       chr = q_keyboard.last;
-                       break;
+                       /*
+                       * See if its a state change key */

 
 

-                   /*-------------------------------------------------------
-                   * Test for cntrl characters. If set, see if the character
-                   * is elligible to become a control character. */
+                       switch (key) {

 
 

-                   default:
+                       case LOCK:
+                               q_keyboard.lock ^= 0xffff;      /* toggle */
+                               if (q_keyboard.lock)
+                                       (void)led_control(qd, LK_LED_ENABLE,
+                                                         LK_LED_LOCK);
+                               else
+                                       (void)led_control(qd, LK_LED_DISABLE,
+                                                         LK_LED_LOCK);
+                               return;

 
 

-                       if (q_keyboard.cntrl) {
-                               chr = q_key[key];
-                               if (chr >= ' ' && chr <= '~')
-                                   chr &= 0x1F;
-                       }
-                       else if( q_keyboard.lock || q_keyboard.shift )
-                           chr = q_shift_key[key];
-                       else
-                           chr = q_key[key];
-                       break;
-               }
+                       case SHIFT:
+                               q_keyboard.shift ^= 0xFFFF;
+                               return;

 
 

-               q_keyboard.last = chr;
+                       case CNTRL:
+                               q_keyboard.cntrl ^= 0xFFFF;
+                               return;

 
 

-               /*-----------------------------------
-               * Check for special function keys */
+                       case ALLUP:
+                               q_keyboard.cntrl = 0;
+                               q_keyboard.shift = 0;
+                               return;

 
 

-               if (chr & 0x80) {
-                       char *string;
-                       string = q_special[chr & 0x7F];
-                       while(*string)
-                           (*linesw[tp->t_line].l_rint)(*string++, tp);
-               }
-               else {
-                       (*linesw[tp->t_line].l_rint)(chr, tp);
-               }
-           }
-       }
+                       case REPEAT:
+                               chr = q_keyboard.last;
+                               break;

 
 

-       return(0);
+                               /*
+                               * Test for cntrl characters. If set, see if the character
+                               * is elligible to become a control character. */

 
 

-} /* qdiint */
+                       default:

 
 

-/******************************************************************
-*
-*      THE SUBROUTINES START HERE:
-*
-******************************************************************/
+                               if (q_keyboard.cntrl) {
+                                       chr = q_key[key];
+                                       if (chr >= ' ' && chr <= '~')
+                                           chr &= 0x1F;
+                                       else if (chr >= 0xA1 && chr <= 0xFE)
+                                           chr &= 0x9F;
+                               }
+                               else if( q_keyboard.lock || q_keyboard.shift )
+                                   chr = q_shift_key[key];
+                               else
+                                       chr = q_key[key];
+                               break;
+                       }

 
 

-/*****************************************************************
-*
-*      clear_qd_screen()... clear the QDSS screen
-*
-******************************************************************
-*
-*                           >>> NOTE <<<
-*
-*   This code requires that certain adder initialization be valid.  To
-*   assure that this requirement is satisfied, this routine should be
-*   called only after calling the "setup_dragon()" function.
-*
-*   Clear the bitmap a piece at a time. Since the fast scroll clear
-*   only clears the current displayed portion of the bitmap put a
-*   temporary value in the y limit register so we can access whole
-*   bitmap
-*
-****************/
+                       q_keyboard.last = chr;
+
+                       /*
+                       * Check for special function keys */
+
+                       if (chr & 0x100) {
+                               char *string;
+                               string = q_special[chr & 0x7F];
+                               while(*string)
+                                   (*linesw[tp->t_line].l_rint)(*string++, tp);
+                       }
+                       else {
+                               (*linesw[tp->t_line].l_rint)(chr&0177, tp);
+                       }
+               }
+       }
+} /* qdiint */

 
 

+/*
+ *
+ * Clear the QDSS screen
+ *
+ *                          >>> NOTE <<<
+ *
+ *   This code requires that certain adder initialization be valid.  To
+ *   assure that this requirement is satisfied, this routine should be
+ *   called only after calling the "setup_dragon()" function.
+ *
+ *   Clear the bitmap a piece at a time. Since the fast scroll clear
+ *   only clears the current displayed portion of the bitmap put a
+ *   temporary value in the y limit register so we can access whole
+ *   bitmap
+ *
+ */

 clear_qd_screen(unit)
 clear_qd_screen(unit)

-int unit;
+       int unit;

 {
        register struct adder *adder;
        adder = (struct adder *) qdmap[unit].adder;
 {
        register struct adder *adder;
        adder = (struct adder *) qdmap[unit].adder;


@@ -2937,493 +2650,426 @@ int unit;
        adder->x_limit = 1024;
        adder->y_limit = 2048 - CHAR_HEIGHT;
        adder->y_offset_pending = 0;
        adder->x_limit = 1024;
        adder->y_limit = 2048 - CHAR_HEIGHT;
        adder->y_offset_pending = 0;

+#define WSV  (void)wait_status(adder, VSYNC); (void)wait_status(adder, VSYNC)
+       WSV;
+       adder->y_scroll_constant = SCROLL_ERASE;
+       WSV;
+       adder->y_offset_pending = 864;
+       WSV;
+       adder->y_scroll_constant = SCROLL_ERASE;
+       WSV;
+       adder->y_offset_pending = 1728;
+       WSV;
+       adder->y_scroll_constant = SCROLL_ERASE;
+       WSV;
+       adder->y_offset_pending = 0;     /* back to normal */
+       WSV;
+       adder->x_limit = MAX_SCREEN_X;
+       adder->y_limit = MAX_SCREEN_Y + FONT_HEIGHT;
+#undef WSV

 
 

-       wait_status(adder, VSYNC);      /* wait at LEAST 1 full frame */
-       wait_status(adder, VSYNC);
+} /* clear_qd_screen */

 
 

-       adder->y_scroll_constant = SCROLL_ERASE;
+/*
+ *  kernel console output to the glass tty
+ */
+qdputc(chr)
+       register char chr;
+{

 
 

-       wait_status(adder, VSYNC);
-       wait_status(adder, VSYNC);
+       /*
+        * if system is now physical, forget it (ie: crash DUMP) 
+        */
+       if ((mfpr(MAPEN) & 1) == 0)
+               return;

 
 

-       adder->y_offset_pending = 864;
+       blitc(0, (u_char)(chr & 0xff));
+       if ((chr & 0177) == '\n')
+               blitc(0, '\r');

 
 

-       wait_status(adder, VSYNC);
-       wait_status(adder, VSYNC);
+} /* qdputc */

 
 

-       adder->y_scroll_constant = SCROLL_ERASE;
+/*
+ *  load the mouse cursor's template RAM bitmap
+ */
+ldcursor(unit, bitmap)
+       int unit;
+       register short *bitmap;
+{
+       register struct dga *dga;
+       register short *temp;
+       register int i;
+       int curs;

 
 

-       wait_status(adder, VSYNC);
-       wait_status(adder, VSYNC);
+       dga = (struct dga *) qdmap[unit].dga;
+       temp = (short *) qdmap[unit].template;

 
 

-       adder->y_offset_pending = 1728;
+       if (dga->csr & CURS_ENB) {      /* if the cursor is enabled.. */
+               curs = -1;              /* ..note that.. */
+               dga->csr &= ~CURS_ENB;  /* ..and shut it off */
+       } else 
+               curs = 0;

 
 

-       wait_status(adder, VSYNC);
-       wait_status(adder, VSYNC);
+       dga->csr &= ~CURS_ENB;          /* shut off the cursor */

 
 

-       adder->y_scroll_constant = SCROLL_ERASE;
+       temp += (8 * 1024) - 32;        /* cursor is 32 WORDS from the end */
+       /* ..of the 8k WORD template space */
+       for (i = 0; i < 32; ++i)
+               *temp++ = *bitmap++;

 
 

-       wait_status(adder, VSYNC);
-       wait_status(adder, VSYNC);
+       if (curs) {                     /* if cursor was enabled.. */
+               dga->csr |= CURS_ENB;   /* ..turn it back on */
+       }

 
 

-       adder->y_offset_pending = 0;     /* back to normal */
+} /* ldcursor */

 
 

-       wait_status(adder, VSYNC);
-       wait_status(adder, VSYNC);
+/*
+ *  Put the console font in the QDSS off-screen memory
+ */
+ldfont(unit)
+       int unit;
+{
+       register struct adder *adder;

 
 

-       adder->x_limit = MAX_SCREEN_X;
-       adder->y_limit = MAX_SCREEN_Y + FONT_HEIGHT;
+       register i, j, k, max_chars_line;
+       register short packed;

 
 

-} /* clear_qd_screen */
+       adder = (struct adder *) qdmap[unit].adder;

 
 

-/**********************************************************************
-*
-*      qdputc()... route kernel console output to display destination
-*
-***********************************************************************
-*
-*      calling convention:
-*
-*              qdputc(chr);
-*
-*      where:  char chr;        ;character for output
-*
-****************/
+       /*
+       * setup VIPER operand control registers  
+       */
+       write_ID(adder, MASK_1, 0xFFFF);
+       write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
+       write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);

 
 

-qdputc(chr)
-register char chr;
-{
+       write_ID(adder, SRC1_OCR_B,
+       EXT_NONE | INT_NONE | ID | BAR_SHIFT_DELAY);
+       write_ID(adder, SRC2_OCR_B,
+       EXT_NONE | INT_NONE | ID | BAR_SHIFT_DELAY);
+       write_ID(adder, DST_OCR_B,
+       EXT_SOURCE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
+
+       adder->rasterop_mode = DST_WRITE_ENABLE | DST_INDEX_ENABLE | NORMAL;
+
+       /*
+       * load destination data  
+       */
+       (void)wait_status(adder, RASTEROP_COMPLETE);
+
+       adder->destination_x = FONT_X;
+       adder->destination_y = FONT_Y;
+#if FONT_WIDTH > MAX_SCREEN_X
+       adder->fast_dest_dx = MAX_SCREEN_X;
+#else
+       adder->fast_dest_dx = FONT_WIDTH;
+#endif
+       adder->slow_dest_dy = CHAR_HEIGHT;
+
+       /*
+       * setup for processor to bitmap xfer  */
+
+       write_ID(adder, CS_UPDATE_MASK, 0x0001);
+       adder->cmd = PBT | OCRB | 2 | DTE | 2;

 
 

-       /* if system is now physical, forget it (ie: crash DUMP) */
-       if ( (mfpr(MAPEN) & 1) == 0 )
+       /*
+       * Figure out how many characters can be stored on one "line" of 
+       * offscreen memory.
+       */
+       max_chars_line = MAX_SCREEN_X/(CHAR_WIDTH*2);
+       if ((CHARS/2 + CHARS%2) < max_chars_line)
+           max_chars_line = CHARS/2 + CHARS%2;
+
+       /*
+       * iteratively do the processor to bitmap xfer */
+
+       for (i = 0; i < ROWS; ++i) {
+
+               /* PTOB a scan line */
+
+               for (j = 0, k = i; j < max_chars_line; ++j) {
+                       /* PTOB one scan of a char cell */
+
+                       packed = q_font[k];
+                       k += ROWS;
+                       packed |= ((short)q_font[k] << 8);
+                       k += ROWS;
+
+                       (void)wait_status(adder, TX_READY);
+                       adder->id_data = packed;
+               }
+       }
+
+       /*
+        * (XXX XXX XXX - should remove)
+        *
+        * Copy the second row of characters.  Subtract the first
+        * row from the total number.  Divide this quantity by 2
+        * because 2 chars are stored in a short in the PTOB loop
+        * below.  Figure out how many characters can be stored on
+        * one "line" of offscreen memory 
+        */
+
+       max_chars_line = MAX_SCREEN_X/(CHAR_WIDTH*2);
+       if ((CHARS/2 + CHARS%2) < max_chars_line)

            return;
            return;

+       max_chars_line = (CHARS/2 + CHARS%2) - max_chars_line; /* 95 - 64 */
+       /* Paranoia check to see if 3rd row may be needed */
+       if (max_chars_line > (MAX_SCREEN_X/(CHAR_WIDTH*2)))
+           max_chars_line = MAX_SCREEN_X/(CHAR_WIDTH*2);

 
 

-        blitc(0, chr & 0xff);
-       if ((chr & 0177) == '\n')
-               blitc(0, '\r');
+       adder->destination_x = FONT_X;
+       adder->destination_y = FONT_Y - CHAR_HEIGHT;
+       adder->fast_dest_dx = max_chars_line * CHAR_WIDTH * 2;
+       adder->slow_dest_dy = CHAR_HEIGHT;

 
 

+       /*
+       * setup for processor to bitmap xfer  
+       */
+       write_ID(adder, CS_UPDATE_MASK, 0x0001);
+       adder->cmd = PBT | OCRB | 2 | DTE | 2;

 
 

-} /* qdputc */
+       /*
+       * iteratively do the processor to bitmap xfer 
+       */
+       for (i = 0; i < ROWS; ++i) {
+               /* 
+                * PTOB a scan line 
+                */
+               for (j = 0, k = i; j < max_chars_line; ++j) {
+                       /*
+                        * PTOB one scan of a char cell 
+                        */
+                       packed = q_font[k + FONT_OFFSET];
+                       k += ROWS;
+                       packed |= ((short)q_font[k + FONT_OFFSET] << 8);
+                       k += ROWS;
+                       (void)wait_status(adder, TX_READY);
+                       adder->id_data = packed;
+               }
+       }

 
 

-/*******************************************************************
-*
-*      qdgetc()... get a character from the LK201
-*
-*******************************************************************
-*
-*      calling convention:
-*
-*              qdgetc();
-*
-*      returns:  the character read.
-*
-****************/
+}  /* ldfont */

 
 

+/*
+ *  Get a character from the LK201 (polled)
+ */

 qdgetc()
 {
        register short key;
        register char chr;
        register struct duart *duart;
 
 qdgetc()
 {
        register short key;
        register char chr;
        register struct duart *duart;
 

-       u_int status;
-

        duart = (struct duart *) qdmap[0].duart;
 
        duart = (struct duart *) qdmap[0].duart;
 

-       /*--------------------------------------
-       * Get a character from the keyboard. */
-
+       /*
+       * Get a character from the keyboard. 
+       */

 LOOP:
 LOOP:

-       while (!((status = duart->statusA) & RCV_RDY))
-                       ;
+       while (!(duart->statusA&RCV_RDY))
+               ;

 
        key = duart->dataA;
        key &= 0xFF;
 
 
        key = duart->dataA;
        key &= 0xFF;
 

-       /*--------------------------------------
+       /*

        * Check for various keyboard errors  */
 
        * Check for various keyboard errors  */
 

-       if( key == LK_POWER_ERROR || key == LK_KDOWN_ERROR ||
+       if (key == LK_POWER_ERROR || key == LK_KDOWN_ERROR ||

            key == LK_INPUT_ERROR || key == LK_OUTPUT_ERROR) {
                printf("Keyboard error, code = %x\n", key);
                return(0);
        }
 
        if (key < LK_LOWEST)
            key == LK_INPUT_ERROR || key == LK_OUTPUT_ERROR) {
                printf("Keyboard error, code = %x\n", key);
                return(0);
        }
 
        if (key < LK_LOWEST)

-           return(0);
-
-       /*---------------------------------
-       * See if its a state change key */
+               return(0);

 
 

+       /*
+        * See if its a state change key 
+        */

        switch (key) {
 
        switch (key) {
 

-           case LOCK:
+       case LOCK:

                q_keyboard.lock ^= 0xffff;      /* toggle */
                if (q_keyboard.lock)
                q_keyboard.lock ^= 0xffff;      /* toggle */
                if (q_keyboard.lock)

-                   led_control(LK_LED_ENABLE, LK_LED_LOCK);
+                       (void)led_control(0, LK_LED_ENABLE, LK_LED_LOCK);

                else
                else

-                   led_control(LK_LED_DISABLE, LK_LED_LOCK);
+                       (void)led_control(0, LK_LED_DISABLE, LK_LED_LOCK);

                goto LOOP;
 
                goto LOOP;
 

-           case SHIFT:
+       case SHIFT:

                q_keyboard.shift ^= 0xFFFF;
                goto LOOP;
 
                q_keyboard.shift ^= 0xFFFF;
                goto LOOP;
 

-           case CNTRL:
+       case CNTRL:

                q_keyboard.cntrl ^= 0xFFFF;
                goto LOOP;
 
                q_keyboard.cntrl ^= 0xFFFF;
                goto LOOP;
 

-           case ALLUP:
+       case ALLUP:

                q_keyboard.cntrl = 0;
                q_keyboard.shift = 0;
                goto LOOP;
 
                q_keyboard.cntrl = 0;
                q_keyboard.shift = 0;
                goto LOOP;
 

-           case REPEAT:
+       case REPEAT:

                chr = q_keyboard.last;
                break;
 
                chr = q_keyboard.last;
                break;
 

-           /*-------------------------------------------------------
-           * Test for cntrl characters. If set, see if the character
-           * is elligible to become a control character. */
-
-           default:
+               /*
+               * Test for cntrl characters. If set, see if the character
+               * is elligible to become a control character. 
+               */
+       default:

 
                if (q_keyboard.cntrl) {
 
                if (q_keyboard.cntrl) {

-                   chr = q_key[key];
-                   if (chr >= ' ' && chr <= '~')
-                       chr &= 0x1F;
+                       chr = q_key[key];
+                       if (chr >= ' ' && chr <= '~')
+                           chr &= 0x1F;

                }
                else if ( q_keyboard.lock || q_keyboard.shift )
                    chr = q_shift_key[key];
                else
                }
                else if ( q_keyboard.lock || q_keyboard.shift )
                    chr = q_shift_key[key];
                else

-                   chr = q_key[key];
+                       chr = q_key[key];

                break;
        }
 
        if (chr < ' ' && chr > '~')     /* if input is non-displayable */
                break;
        }
 
        if (chr < ' ' && chr > '~')     /* if input is non-displayable */

-           return(0);                  /* ..then pitch it! */
+               return(0);              /* ..then pitch it! */

 
        q_keyboard.last = chr;
 
 
        q_keyboard.last = chr;
 

-       /*-----------------------------------
+       /*

        * Check for special function keys */
 
        if (chr & 0x80)                 /* pitch the function keys */
        * Check for special function keys */
 
        if (chr & 0x80)                 /* pitch the function keys */

-           return(0);
+               return(0);

        else
        else

-           return(chr);
+               return(chr);

 
 } /* qdgetc */
 
 
 } /* qdgetc */
 

-/**********************************************************************
-*
-*      ldcursor()... load the mouse cursor's template RAM bitmap
-*
-*********************************************************************
-*
-*      calling convention:
-*
-*              ldcursor(unit, bitmap);
-*              u_int unit;
-*              short *bitmap;
-*
-****************/
-
-ldcursor(unit, bitmap)
-u_int unit;
-short *bitmap;
-{
-       register struct dga *dga;
-       register short *temp;
-       register int i;
-
-       int cursor;
-
-       dga = (struct dga *) qdmap[unit].dga;
-       temp = (short *) qdmap[unit].template;
-
-       if (dga->csr & CURS_ENB) {      /* if the cursor is enabled.. */
-           cursor = -1;                /* ..note that.. */
-           dga->csr &= ~CURS_ENB;      /* ..and shut it off */
-       }
-       else {
-           cursor = 0;
-       }
-
-       dga->csr &= ~CURS_ENB;          /* shut off the cursor */
-
-       temp += (8 * 1024) - 32;        /* cursor is 32 WORDS from the end */
-                                       /* ..of the 8k WORD template space */
-       for (i = 0; i < 32; ++i)
-           *temp++ = *bitmap++;
-
-       if (cursor) {                   /* if cursor was enabled.. */
-           dga->csr |= CURS_ENB;       /* ..turn it back on */
-       }
-
-       return(0);
-
-} /* ldcursor */
-
-/**********************************************************************
-*
-*      ldfont()... put the console font in the QDSS off-screen memory
-*
-***********************************************************************
-*
-*      calling convention:
-*
-*              ldfont(unit);
-*              u_int unit;     ;QDSS unit number
-*
-****************/
-
-ldfont(unit)
-u_int unit;
-{
-       register struct adder *adder;
-
-       int i;          /* scratch variables */
-       int j;
-       int k;
-       short packed;
-
-       adder = (struct adder *) qdmap[unit].adder;
-
-       /*------------------------------------------
-       * setup VIPER operand control registers  */
-
-       write_ID(adder, MASK_1, 0xFFFF);
-       write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
-       write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
-
-       write_ID(adder, SRC1_OCR_B,
-                       EXT_NONE | INT_NONE | ID | BAR_SHIFT_DELAY);
-       write_ID(adder, SRC2_OCR_B,
-                       EXT_NONE | INT_NONE | ID | BAR_SHIFT_DELAY);
-       write_ID(adder, DST_OCR_B,
-                       EXT_SOURCE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
-
-       adder->rasterop_mode = DST_WRITE_ENABLE | DST_INDEX_ENABLE | NORMAL;
-
-       /*--------------------------
-       * load destination data  */
-
-       wait_status(adder, RASTEROP_COMPLETE);
-
-       adder->destination_x = FONT_X;
-       adder->destination_y = FONT_Y;
-       adder->fast_dest_dx = FONT_WIDTH;
-       adder->slow_dest_dy = CHAR_HEIGHT;
-
-       /*---------------------------------------
-       * setup for processor to bitmap xfer  */
-
-       write_ID(adder, CS_UPDATE_MASK, 0x0001);
-       adder->cmd = PBT | OCRB | 2 | DTE | 2;
-
-       /*-----------------------------------------------
-       * iteratively do the processor to bitmap xfer */
-
-       for (i = 0; i < ROWS; ++i) {
-
-           /* PTOB a scan line */
-
-           for (j = 0, k = i; j < 48; ++j) {
-
-               /* PTOB one scan of a char cell */
-
-               packed = q_font[k];
-               k += ROWS;
-               packed |= ((short)q_font[k] << 8);
-               k += ROWS;
-
-               wait_status(adder, TX_READY);
-               adder->id_data = packed;
-           }
-       }
-
-}  /* ldfont */
-
-/*********************************************************************
-*
-*      led_control()... twiddle LK-201 LED's
-*
-**********************************************************************
-*
-*      led_control(unit, cmd, led_mask);
-*      u_int unit;     QDSS number
-*      int cmd;        LED enable/disable command
-*      int led_mask;   which LED(s) to twiddle
-*
-*************/
-
+/*
+ *  led_control()... twiddle LK-201 LED's
+ */

 led_control(unit, cmd, led_mask)
 led_control(unit, cmd, led_mask)

-u_int unit;
-int cmd;
-int led_mask;
+       int unit, cmd, led_mask;

 {
 {

-       register int i;
-       register int status;
+       register i;

        register struct duart *duart;
 
        register struct duart *duart;
 

-       duart = (struct duart *) qdmap[unit].duart;
+       duart = (struct duart *)qdmap[unit].duart;

 
        for (i = 1000; i > 0; --i) {
 
        for (i = 1000; i > 0; --i) {

-           if ((status = duart->statusA) & XMT_RDY) {
-               duart->dataA = cmd;
-               break;
-           }
+               if (duart->statusA&XMT_RDY) {
+                       duart->dataA = cmd;
+                       break;
+               }

        }
        }

-

        for (i = 1000; i > 0; --i) {
        for (i = 1000; i > 0; --i) {

-           if ((status = duart->statusA) & XMT_RDY) {
-               duart->dataA = led_mask;
-               break;
-           }
+               if (duart->statusA&XMT_RDY) {
+                       duart->dataA = led_mask;
+                       break;
+               }

        }
        }

-

        if (i == 0)
        if (i == 0)

-           return(BAD);
-
+               return(BAD);

        return(GOOD);
 
 } /* led_control */
 
        return(GOOD);
 
 } /* led_control */
 

-/*******************************************************************
-*
-*      scroll_up()... move the screen up one character height
-*
-********************************************************************
-*
-*      calling convention:
-*
-*              scroll_up(adder);
-*              struct adder *adder;    ;address of adder
-*
-********/
-
+/*
+ *  scroll_up()... move the screen up one character height
+ */

 scroll_up(adder)
 scroll_up(adder)

-register struct adder *adder;
+       register struct adder *adder;

 {
 {

-
-       /*------------------------------------------
-       * setup VIPER operand control registers  */
-
-       wait_status(adder, ADDRESS_COMPLETE);
-
+       /*
+       * setup VIPER operand control registers  
+       */
+       (void)wait_status(adder, ADDRESS_COMPLETE);

        write_ID(adder, CS_UPDATE_MASK, 0x00FF);  /* select all planes */
        write_ID(adder, CS_UPDATE_MASK, 0x00FF);  /* select all planes */

-

        write_ID(adder, MASK_1, 0xFFFF);
        write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
        write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
        write_ID(adder, MASK_1, 0xFFFF);
        write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
        write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);

-

        write_ID(adder, SRC1_OCR_B,
        write_ID(adder, SRC1_OCR_B,

-                       EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY);
+       EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY);

        write_ID(adder, DST_OCR_B,
        write_ID(adder, DST_OCR_B,

-                       EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
-
-       /*----------------------------------------
-       * load DESTINATION origin and vectors  */
-
+       EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
+       /*
+        * load DESTINATION origin and vectors  
+        */

        adder->fast_dest_dy = 0;
        adder->slow_dest_dx = 0;
        adder->error_1 = 0;
        adder->error_2 = 0;
        adder->fast_dest_dy = 0;
        adder->slow_dest_dx = 0;
        adder->error_1 = 0;
        adder->error_2 = 0;

-

        adder->rasterop_mode = DST_WRITE_ENABLE | NORMAL;
        adder->rasterop_mode = DST_WRITE_ENABLE | NORMAL;

-

        adder->destination_x = 0;
        adder->fast_dest_dx = 1024;
        adder->destination_x = 0;
        adder->fast_dest_dx = 1024;

-

        adder->destination_y = 0;
        adder->slow_dest_dy = 864 - CHAR_HEIGHT;
        adder->destination_y = 0;
        adder->slow_dest_dy = 864 - CHAR_HEIGHT;

-
-       /*-----------------------------------
-       * load SOURCE origin and vectors  */
-
+       /*
+        * load SOURCE origin and vectors  
+        */

        adder->source_1_x = 0;
        adder->source_1_dx = 1024;
        adder->source_1_x = 0;
        adder->source_1_dx = 1024;

-

        adder->source_1_y = 0 + CHAR_HEIGHT;
        adder->source_1_dy = 864 - CHAR_HEIGHT;
        adder->source_1_y = 0 + CHAR_HEIGHT;
        adder->source_1_dy = 864 - CHAR_HEIGHT;

-

        write_ID(adder, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE);
        adder->cmd = RASTEROP | OCRB | 0 | S1E | DTE;
        write_ID(adder, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE);
        adder->cmd = RASTEROP | OCRB | 0 | S1E | DTE;

-
-       /*--------------------------------------------
-       * do a rectangle clear of last screen line */
-
+       /*
+        * do a rectangle clear of last screen line 
+        */

        write_ID(adder, MASK_1, 0xffff);
        write_ID(adder, SOURCE, 0xffff);
        write_ID(adder,DST_OCR_B,
        write_ID(adder, MASK_1, 0xffff);
        write_ID(adder, SOURCE, 0xffff);
        write_ID(adder,DST_OCR_B,

-               (EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY));
+       (EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY));

        write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 0);
        adder->error_1 = 0;
        adder->error_2 = 0;
        write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 0);
        adder->error_1 = 0;
        adder->error_2 = 0;

-       adder->slow_dest_dx = 0;        /* set up the width of  */
+       adder->slow_dest_dx = 0;                /* set up the width of  */

        adder->slow_dest_dy = CHAR_HEIGHT;      /* rectangle */
        adder->slow_dest_dy = CHAR_HEIGHT;      /* rectangle */

-

        adder->rasterop_mode = (NORMAL | DST_WRITE_ENABLE) ;
        adder->rasterop_mode = (NORMAL | DST_WRITE_ENABLE) ;

-       wait_status(adder, RASTEROP_COMPLETE);
+       (void)wait_status(adder, RASTEROP_COMPLETE);

        adder->destination_x = 0;
        adder->destination_y = 864 - CHAR_HEIGHT;
        adder->destination_x = 0;
        adder->destination_y = 864 - CHAR_HEIGHT;

-

        adder->fast_dest_dx = 1024;     /* set up the height    */
        adder->fast_dest_dy = 0;        /* of rectangle         */
        adder->fast_dest_dx = 1024;     /* set up the height    */
        adder->fast_dest_dy = 0;        /* of rectangle         */

-

        write_ID(adder, LU_FUNCTION_R2, (FULL_SRC_RESOLUTION | LF_SOURCE));
        adder->cmd = (RASTEROP | OCRB | LF_R2 | DTE ) ;
 
 } /* scroll_up */
 
        write_ID(adder, LU_FUNCTION_R2, (FULL_SRC_RESOLUTION | LF_SOURCE));
        adder->cmd = (RASTEROP | OCRB | LF_R2 | DTE ) ;
 
 } /* scroll_up */
 

-/********************************************************************
-*
-*      init_shared()... init shared memory pointers and structures
-*
-*********************************************************************
-*
-*      calling convention:
-*
-*              init_shared(unit);
-*              u_int unit;
-*
-****************/
-
+/*
+ *  init shared memory pointers and structures
+ */

 init_shared(unit)
 init_shared(unit)

-register u_int unit;
+       register unit;

 {
        register struct dga *dga;
 
        dga = (struct dga *) qdmap[unit].dga;
 
 {
        register struct dga *dga;
 
        dga = (struct dga *) qdmap[unit].dga;
 

-       /*--------------------------------------------------
+       /*

        * initialize the event queue pointers and header */
 
        eq_header[unit] = (struct qdinput *)
        * initialize the event queue pointers and header */
 
        eq_header[unit] = (struct qdinput *)

-                         ((((int)event_shared & ~(0x01FF)) + 512)
-                          + (EVENT_BUFSIZE * unit));
-
+           ((((int)event_shared & ~(0x01FF)) + 512)
+               + (EVENT_BUFSIZE * unit));

        eq_header[unit]->curs_pos.x = 0;
        eq_header[unit]->curs_pos.y = 0;
        eq_header[unit]->curs_pos.x = 0;
        eq_header[unit]->curs_pos.y = 0;

-

        dga->x_cursor = TRANX(eq_header[unit]->curs_pos.x);
        dga->y_cursor = TRANY(eq_header[unit]->curs_pos.y);
        dga->x_cursor = TRANX(eq_header[unit]->curs_pos.x);
        dga->y_cursor = TRANY(eq_header[unit]->curs_pos.y);

-

        eq_header[unit]->curs_box.left = 0;
        eq_header[unit]->curs_box.right = 0;
        eq_header[unit]->curs_box.top = 0;
        eq_header[unit]->curs_box.bottom = 0;
        eq_header[unit]->curs_box.left = 0;
        eq_header[unit]->curs_box.right = 0;
        eq_header[unit]->curs_box.top = 0;
        eq_header[unit]->curs_box.bottom = 0;

-
-       /*---------------------------------------------------------
-       * assign a pointer to the DMA I/O buffer for this QDSS. */
-
+       /*
+        * assign a pointer to the DMA I/O buffer for this QDSS. 
+        */

        DMAheader[unit] = (struct DMAreq_header *)
        DMAheader[unit] = (struct DMAreq_header *)

-                         (((int)(&DMA_shared[0] + 512) & ~0x1FF)
-                          + (DMAbuf_size * unit));
-
+           (((int)(&DMA_shared[0] + 512) & ~0x1FF)
+               + (DMAbuf_size * unit));

        DMAheader[unit]->DMAreq = (struct DMAreq *) ((int)DMAheader[unit]
        DMAheader[unit]->DMAreq = (struct DMAreq *) ((int)DMAheader[unit]

-                                 + sizeof(struct DMAreq_header));
-
+           + sizeof(struct DMAreq_header));

        DMAheader[unit]->QBAreg = 0;
        DMAheader[unit]->status = 0;
        DMAheader[unit]->shared_size = DMAbuf_size;
        DMAheader[unit]->QBAreg = 0;
        DMAheader[unit]->status = 0;
        DMAheader[unit]->shared_size = DMAbuf_size;


@@ -3431,81 +3077,60 @@ register u_int unit;
        DMAheader[unit]->size = 10;     /* default = 10 requests */
        DMAheader[unit]->oldest = 0;
        DMAheader[unit]->newest = 0;
        DMAheader[unit]->size = 10;     /* default = 10 requests */
        DMAheader[unit]->oldest = 0;
        DMAheader[unit]->newest = 0;

-
-       /*-----------------------------------------------------------
-       * assign a pointer to the scroll structure for this QDSS. */
-
+       /*
+       * assign a pointer to the scroll structure for this QDSS. 
+       */

        scroll[unit] = (struct scroll *)
        scroll[unit] = (struct scroll *)

-                        (((int)(&scroll_shared[0] + 512) & ~0x1FF)
-                          + (sizeof(struct scroll) * unit));
-
+           (((int)(&scroll_shared[0] + 512) & ~0x1FF)
+               + (sizeof(struct scroll) * unit));

        scroll[unit]->status = 0;
        scroll[unit]->viper_constant = 0;
        scroll[unit]->y_scroll_constant = 0;
        scroll[unit]->y_offset = 0;
        scroll[unit]->x_index_pending = 0;
        scroll[unit]->y_index_pending = 0;
        scroll[unit]->status = 0;
        scroll[unit]->viper_constant = 0;
        scroll[unit]->y_scroll_constant = 0;
        scroll[unit]->y_offset = 0;
        scroll[unit]->x_index_pending = 0;
        scroll[unit]->y_index_pending = 0;

-
-       /*----------------------------------------------------------------
-       * assign a pointer to the color map write buffer for this QDSS */
-
+       /*
+       * assign a pointer to the color map write buffer for this QDSS 
+       */

        color_buf[unit] = (struct color_buf *)
        color_buf[unit] = (struct color_buf *)

-                          (((int)(&color_shared[0] + 512) & ~0x1FF)
-                           + (COLOR_BUFSIZ * unit));
-
+           (((int)(&color_shared[0] + 512) & ~0x1FF)
+               + (COLOR_BUFSIZ * unit));

        color_buf[unit]->status = 0;
        color_buf[unit]->count = 0;
 
 } /* init_shared */
 
        color_buf[unit]->status = 0;
        color_buf[unit]->count = 0;
 
 } /* init_shared */
 

-/*********************************************************************
-*
-*      setup_dragon()... init the ADDER, VIPER, bitmaps, & color map
-*
-**********************************************************************
-*
-*      calling convention:
-*
-*              setup_dragon();
-*
-*      return: NONE
-*
-************************/
-
+/*
+ * init the ADDER, VIPER, bitmaps, & color map
+ */

 setup_dragon(unit)
 setup_dragon(unit)

-u_int unit;
+       int unit;

 {
 
        register struct adder *adder;
        register struct dga *dga;
        short *memcsr;
 {
 
        register struct adder *adder;
        register struct dga *dga;
        short *memcsr;

-
-       int i;                  /* general purpose variables */
-       int status;
-
+       register i;

        short top;              /* clipping/scrolling boundaries */
        short bottom;
        short right;
        short left;
        short top;              /* clipping/scrolling boundaries */
        short bottom;
        short right;
        short left;

-

        short *red;             /* color map pointers */
        short *green;
        short *blue;
 
        short *red;             /* color map pointers */
        short *green;
        short *blue;
 

-       /*------------------
-       * init for setup */
-
+       /*
+       * init for setup 
+       */

        adder = (struct adder *) qdmap[unit].adder;
        dga = (struct dga *) qdmap[unit].dga;
        memcsr = (short *) qdmap[unit].memcsr;
        adder = (struct adder *) qdmap[unit].adder;
        dga = (struct dga *) qdmap[unit].dga;
        memcsr = (short *) qdmap[unit].memcsr;

-

        dga->csr &= ~(DMA_IE | 0x700);  /* halt DMA and kill the intrpts */
        *memcsr = SYNC_ON;              /* blank screen and turn off LED's */
        adder->command = CANCEL;
        dga->csr &= ~(DMA_IE | 0x700);  /* halt DMA and kill the intrpts */
        *memcsr = SYNC_ON;              /* blank screen and turn off LED's */
        adder->command = CANCEL;

-
-       /*----------------------
-       * set monitor timing */
-
+       /*
+       * set monitor timing 
+       */

        adder->x_scan_count_0 = 0x2800;
        adder->x_scan_count_1 = 0x1020;
        adder->x_scan_count_2 = 0x003A;
        adder->x_scan_count_0 = 0x2800;
        adder->x_scan_count_1 = 0x1020;
        adder->x_scan_count_2 = 0x003A;


@@ -3515,67 +3140,62 @@ u_int unit;
        adder->x_scan_count_6 = 0x313C;
        adder->sync_phase_adj = 0x0100;
        adder->x_scan_conf = 0x00C8;
        adder->x_scan_count_6 = 0x313C;
        adder->sync_phase_adj = 0x0100;
        adder->x_scan_conf = 0x00C8;

-
-       /*---------------------------------------------------------
-       * got a bug in secound pass ADDER! lets take care of it */
-
-       /* normally, just use the code in the following bug fix code, but to
-       * make repeated demos look pretty, load the registers as if there was
-       * no bug and then test to see if we are getting sync */
-
+       /*
+        * got a bug in secound pass ADDER! lets take care of it 
+        *
+        * normally, just use the code in the following bug fix code, but to
+        * make repeated demos look pretty, load the registers as if there was
+        * no bug and then test to see if we are getting sync 
+        */

        adder->y_scan_count_0 = 0x135F;
        adder->y_scan_count_1 = 0x3363;
        adder->y_scan_count_2 = 0x2366;
        adder->y_scan_count_3 = 0x0388;
        adder->y_scan_count_0 = 0x135F;
        adder->y_scan_count_1 = 0x3363;
        adder->y_scan_count_2 = 0x2366;
        adder->y_scan_count_3 = 0x0388;

-
-       /* if no sync, do the bug fix code */
-
+       /*
+        * if no sync, do the bug fix code 
+        */

        if (wait_status(adder, VSYNC) == BAD) {
        if (wait_status(adder, VSYNC) == BAD) {

-
-           /* first load all Y scan registers with very short frame and
-           * wait for scroll service.  This guarantees at least one SYNC
-           * to fix the pass 2 Adder initialization bug (synchronizes
-           * XCINCH with DMSEEDH) */
-
-           adder->y_scan_count_0 = 0x01;
-           adder->y_scan_count_1 = 0x01;
-           adder->y_scan_count_2 = 0x01;
-           adder->y_scan_count_3 = 0x01;
-
-           wait_status(adder, VSYNC);  /* delay at least 1 full frame time */
-           wait_status(adder, VSYNC);
-
-           /* now load the REAL sync values (in reverse order just to
-           *  be safe.  */
-
-           adder->y_scan_count_3 = 0x0388;
-           adder->y_scan_count_2 = 0x2366;
-           adder->y_scan_count_1 = 0x3363;
-           adder->y_scan_count_0 = 0x135F;
+               /* first load all Y scan registers with very short frame and
+                * wait for scroll service.  This guarantees at least one SYNC
+                * to fix the pass 2 Adder initialization bug (synchronizes
+                * XCINCH with DMSEEDH) 
+                */
+               adder->y_scan_count_0 = 0x01;
+               adder->y_scan_count_1 = 0x01;
+               adder->y_scan_count_2 = 0x01;
+               adder->y_scan_count_3 = 0x01;
+               /*
+                * delay at least 1 full frame time 
+                */
+               (void)wait_status(adder, VSYNC);        
+               (void)wait_status(adder, VSYNC);
+               /*
+                * now load the REAL sync values (in reverse order just to
+                * be safe.  
+                */
+               adder->y_scan_count_3 = 0x0388;
+               adder->y_scan_count_2 = 0x2366;
+               adder->y_scan_count_1 = 0x3363;
+               adder->y_scan_count_0 = 0x135F;

        }
        }

-

        *memcsr = SYNC_ON | UNBLANK;    /* turn off leds and turn on video */
        *memcsr = SYNC_ON | UNBLANK;    /* turn off leds and turn on video */

-
-       /*----------------------------
-       * zero the index registers */
-
+       /*
+        * zero the index registers 
+        */

        adder->x_index_pending = 0;
        adder->y_index_pending = 0;
        adder->x_index_new = 0;
        adder->y_index_new = 0;
        adder->x_index_old = 0;
        adder->y_index_old = 0;
        adder->x_index_pending = 0;
        adder->y_index_pending = 0;
        adder->x_index_new = 0;
        adder->y_index_new = 0;
        adder->x_index_old = 0;
        adder->y_index_old = 0;

-

        adder->pause = 0;
        adder->pause = 0;

-
-       /*----------------------------------------
-       * set rasterop mode to normal pen down */
-
+       /*
+        * set rasterop mode to normal pen down 
+        */

        adder->rasterop_mode = DST_WRITE_ENABLE | DST_INDEX_ENABLE | NORMAL;
        adder->rasterop_mode = DST_WRITE_ENABLE | DST_INDEX_ENABLE | NORMAL;

-
-       /*--------------------------------------------------
-       * set the rasterop registers to a default values */
-
+       /*
+        * set the rasterop registers to a default values 
+        */

        adder->source_1_dx = 1;
        adder->source_1_dy = 1;
        adder->source_1_x = 0;
        adder->source_1_dx = 1;
        adder->source_1_dy = 1;
        adder->source_1_x = 0;


@@ -3588,90 +3208,73 @@ u_int unit;
        adder->slow_dest_dy = 1;
        adder->error_1 = 0;
        adder->error_2 = 0;
        adder->slow_dest_dy = 1;
        adder->error_1 = 0;
        adder->error_2 = 0;

-
-       /*------------------------
-       * scale factor = unity */
-
+       /*
+        * scale factor = UNITY 
+        */

        adder->fast_scale = UNITY;
        adder->slow_scale = UNITY;
        adder->fast_scale = UNITY;
        adder->slow_scale = UNITY;

-
-       /*-------------------------------
-       * set the source 2 parameters */
-
+       /*
+        * set the source 2 parameters 
+        */

        adder->source_2_x = 0;
        adder->source_2_y = 0;
        adder->source_2_size = 0x0022;
        adder->source_2_x = 0;
        adder->source_2_y = 0;
        adder->source_2_size = 0x0022;

-
-       /*-----------------------------------------------
-       * initialize plane addresses for eight vipers */
-
+       /*
+       * initialize plane addresses for eight vipers 
+       */

        write_ID(adder, CS_UPDATE_MASK, 0x0001);
        write_ID(adder, PLANE_ADDRESS, 0x0000);
        write_ID(adder, CS_UPDATE_MASK, 0x0001);
        write_ID(adder, PLANE_ADDRESS, 0x0000);

-

        write_ID(adder, CS_UPDATE_MASK, 0x0002);
        write_ID(adder, PLANE_ADDRESS, 0x0001);
        write_ID(adder, CS_UPDATE_MASK, 0x0002);
        write_ID(adder, PLANE_ADDRESS, 0x0001);

-

        write_ID(adder, CS_UPDATE_MASK, 0x0004);
        write_ID(adder, PLANE_ADDRESS, 0x0002);
        write_ID(adder, CS_UPDATE_MASK, 0x0004);
        write_ID(adder, PLANE_ADDRESS, 0x0002);

-

        write_ID(adder, CS_UPDATE_MASK, 0x0008);
        write_ID(adder, PLANE_ADDRESS, 0x0003);
        write_ID(adder, CS_UPDATE_MASK, 0x0008);
        write_ID(adder, PLANE_ADDRESS, 0x0003);

-

        write_ID(adder, CS_UPDATE_MASK, 0x0010);
        write_ID(adder, PLANE_ADDRESS, 0x0004);
        write_ID(adder, CS_UPDATE_MASK, 0x0010);
        write_ID(adder, PLANE_ADDRESS, 0x0004);

-

        write_ID(adder, CS_UPDATE_MASK, 0x0020);
        write_ID(adder, PLANE_ADDRESS, 0x0005);
        write_ID(adder, CS_UPDATE_MASK, 0x0020);
        write_ID(adder, PLANE_ADDRESS, 0x0005);

-

        write_ID(adder, CS_UPDATE_MASK, 0x0040);
        write_ID(adder, PLANE_ADDRESS, 0x0006);
        write_ID(adder, CS_UPDATE_MASK, 0x0040);
        write_ID(adder, PLANE_ADDRESS, 0x0006);

-

        write_ID(adder, CS_UPDATE_MASK, 0x0080);
        write_ID(adder, PLANE_ADDRESS, 0x0007);
        write_ID(adder, CS_UPDATE_MASK, 0x0080);
        write_ID(adder, PLANE_ADDRESS, 0x0007);

-
-       /* initialize the external registers. */
-
+       /*
+        * initialize the external registers. 
+        */

        write_ID(adder, CS_UPDATE_MASK, 0x00FF);
        write_ID(adder, CS_SCROLL_MASK, 0x00FF);
        write_ID(adder, CS_UPDATE_MASK, 0x00FF);
        write_ID(adder, CS_SCROLL_MASK, 0x00FF);

-
-       /* initialize resolution mode */
-
+       /*
+        * initialize resolution mode 
+        */

        write_ID(adder, MEMORY_BUS_WIDTH, 0x000C);     /* bus width = 16 */
        write_ID(adder, RESOLUTION_MODE, 0x0000);      /* one bit/pixel */
        write_ID(adder, MEMORY_BUS_WIDTH, 0x000C);     /* bus width = 16 */
        write_ID(adder, RESOLUTION_MODE, 0x0000);      /* one bit/pixel */

-
-       /* initialize viper registers */
-
+       /*
+        * initialize viper registers 
+        */

        write_ID(adder, SCROLL_CONSTANT, SCROLL_ENABLE|VIPER_LEFT|VIPER_UP);
        write_ID(adder, SCROLL_FILL, 0x0000);
        write_ID(adder, SCROLL_CONSTANT, SCROLL_ENABLE|VIPER_LEFT|VIPER_UP);
        write_ID(adder, SCROLL_FILL, 0x0000);

-
-       /*----------------------------------------------------
-       * set clipping and scrolling limits to full screen */
-
-       for ( i = 1000, adder->status = 0
-           ; i > 0  &&  !((status = adder->status) & ADDRESS_COMPLETE)
-           ; --i);
-
+       /*
+        * set clipping and scrolling limits to full screen 
+        */
+       for (i = 1000, adder->status = 0; 
+            i > 0 && !(adder->status&ADDRESS_COMPLETE); --i)
+               ;

        if (i == 0)
        if (i == 0)

-           printf("qd%d: setup_dragon: timeout on ADDRESS_COMPLETE\n", unit);
-
+           printf("qd%d: setup_dragon: timeout on ADDRESS_COMPLETE\n",unit);

        top = 0;
        bottom = 2048;
        left = 0;
        right = 1024;
        top = 0;
        bottom = 2048;
        left = 0;
        right = 1024;

-

        adder->x_clip_min = left;
        adder->x_clip_max = right;
        adder->y_clip_min = top;
        adder->y_clip_max = bottom;
        adder->x_clip_min = left;
        adder->x_clip_max = right;
        adder->y_clip_min = top;
        adder->y_clip_max = bottom;

-

        adder->scroll_x_min = left;
        adder->scroll_x_max = right;
        adder->scroll_y_min = top;
        adder->scroll_y_max = bottom;
        adder->scroll_x_min = left;
        adder->scroll_x_max = right;
        adder->scroll_y_min = top;
        adder->scroll_y_max = bottom;

-
-       wait_status(adder, VSYNC);      /* wait at LEAST 1 full frame */
-       wait_status(adder, VSYNC);
-
+       (void)wait_status(adder, VSYNC);        /* wait at LEAST 1 full frame */
+       (void)wait_status(adder, VSYNC);

        adder->x_index_pending = left;
        adder->y_index_pending = top;
        adder->x_index_new = left;
        adder->x_index_pending = left;
        adder->y_index_pending = top;
        adder->x_index_new = left;


@@ -3679,53 +3282,47 @@ u_int unit;
        adder->x_index_old = left;
        adder->y_index_old = top;
 
        adder->x_index_old = left;
        adder->y_index_old = top;
 

-       for ( i = 1000, adder->status = 0
-           ; i > 0  &&  !((status = adder->status) & ADDRESS_COMPLETE)
-           ; --i);
-
+       for (i = 1000, adder->status = 0; i > 0 && 
+            !(adder->status&ADDRESS_COMPLETE) ; --i)
+               ;

        if (i == 0)
        if (i == 0)

-           printf("qd%d: setup_dragon: timeout on ADDRESS_COMPLETE\n", unit);
+              printf("qd%d: setup_dragon: timeout on ADDRESS_COMPLETE\n",unit);

 
        write_ID(adder, LEFT_SCROLL_MASK, 0x0000);
        write_ID(adder, RIGHT_SCROLL_MASK, 0x0000);
 
        write_ID(adder, LEFT_SCROLL_MASK, 0x0000);
        write_ID(adder, RIGHT_SCROLL_MASK, 0x0000);

-
-       /*------------------------------------------------------------
-       * set source and the mask register to all ones (ie: white) */
-
+       /*
+       * set source and the mask register to all ones (ie: white) o
+       */

        write_ID(adder, SOURCE, 0xFFFF);
        write_ID(adder, MASK_1, 0xFFFF);
        write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
        write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
        write_ID(adder, SOURCE, 0xFFFF);
        write_ID(adder, MASK_1, 0xFFFF);
        write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
        write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);

-
-       /*--------------------------------------------------------------
-       * initialize Operand Control Register banks for fill command */
-
+       /*
+       * initialize Operand Control Register banks for fill command 
+       */

        write_ID(adder, SRC1_OCR_A, EXT_NONE | INT_M1_M2  | NO_ID | WAIT);
        write_ID(adder, SRC2_OCR_A, EXT_NONE | INT_SOURCE | NO_ID | NO_WAIT);
        write_ID(adder, DST_OCR_A, EXT_NONE | INT_NONE   | NO_ID | NO_WAIT);
        write_ID(adder, SRC1_OCR_A, EXT_NONE | INT_M1_M2  | NO_ID | WAIT);
        write_ID(adder, SRC2_OCR_A, EXT_NONE | INT_SOURCE | NO_ID | NO_WAIT);
        write_ID(adder, DST_OCR_A, EXT_NONE | INT_NONE   | NO_ID | NO_WAIT);

-

        write_ID(adder, SRC1_OCR_B, EXT_NONE | INT_SOURCE | NO_ID | WAIT);
        write_ID(adder, SRC2_OCR_B, EXT_NONE | INT_M1_M2  | NO_ID | NO_WAIT);
        write_ID(adder, DST_OCR_B, EXT_NONE | INT_NONE | NO_ID | NO_WAIT);
        write_ID(adder, SRC1_OCR_B, EXT_NONE | INT_SOURCE | NO_ID | WAIT);
        write_ID(adder, SRC2_OCR_B, EXT_NONE | INT_M1_M2  | NO_ID | NO_WAIT);
        write_ID(adder, DST_OCR_B, EXT_NONE | INT_NONE | NO_ID | NO_WAIT);

-
-       /*------------------------------------------------------------------
+       /*

        * init Logic Unit Function registers, (these are just common values,
        * init Logic Unit Function registers, (these are just common values,

-* and may be changed as required).  */
-
+       * and may be changed as required).  
+       */

        write_ID(adder, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE);
        write_ID(adder, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE);

-       write_ID(adder, LU_FUNCTION_R2, FULL_SRC_RESOLUTION | LF_SOURCE | INV_M1_M2);
+       write_ID(adder, LU_FUNCTION_R2, FULL_SRC_RESOLUTION | LF_SOURCE |
+                INV_M1_M2);

        write_ID(adder, LU_FUNCTION_R3, FULL_SRC_RESOLUTION | LF_D_OR_S);
        write_ID(adder, LU_FUNCTION_R4, FULL_SRC_RESOLUTION | LF_D_XOR_S);
        write_ID(adder, LU_FUNCTION_R3, FULL_SRC_RESOLUTION | LF_D_OR_S);
        write_ID(adder, LU_FUNCTION_R4, FULL_SRC_RESOLUTION | LF_D_XOR_S);

-
-       /*----------------------------------------
-       * load the color map for black & white */
-
-       for ( i = 0, adder->status = 0
-           ; i < 10000  &&  !((status = adder->status) & VSYNC)
-           ; ++i);
+       /*
+       * load the color map for black & white 
+       */
+       for (i = 0, adder->status = 0; i < 10000 && !(adder->status&VSYNC); ++i)
+               ;

 
        if (i == 0)
 
        if (i == 0)

-           printf("qd%d: setup_dragon: timeout on VSYNC\n", unit);
+               printf("qd%d: setup_dragon: timeout on VSYNC\n", unit);

 
        red = (short *) qdmap[unit].red;
        green = (short *) qdmap[unit].green;
 
        red = (short *) qdmap[unit].red;
        green = (short *) qdmap[unit].green;


@@ -3739,8 +3336,9 @@ u_int unit;
        *green-- = 0xFF;
        *blue-- = 0xFF;
 
        *green-- = 0xFF;
        *blue-- = 0xFF;
 

-       /*----------------------------------
-       * set color map for mouse cursor */
+       /*
+       * set color map for mouse cursor 
+       */

 
        red += 254;
        green += 254;
 
        red += 254;
        green += 254;


@@ -3754,286 +3352,226 @@ u_int unit;
        *green = 0xFF;
        *blue = 0xFF;
 
        *green = 0xFF;
        *blue = 0xFF;
 

-       return(0);
-

 } /* setup_dragon */
 
 } /* setup_dragon */
 

-/******************************************************************
-*
-*      setup_input()... init the DUART and set defaults in input
-*                       devices
-*
-*******************************************************************
-*
-*      calling convention:
-*
-*              setup_input(unit);
-*
-*      where: unit - is the QDSS unit number to be setup
-*
-*********/
-
+/*
+ * Init the DUART and set defaults in input
+ */

 setup_input(unit)
 setup_input(unit)

-u_int unit;
+       int unit;

 {
        register struct duart *duart;   /* DUART register structure pointer */
 {
        register struct duart *duart;   /* DUART register structure pointer */

-       register int i;                 /* scratch variable */
-       register int bits;
-
+       register i, bits;

        char id_byte;
        char id_byte;

-       short status;
-
-       /*---------------
-       * init stuff */

 
        duart = (struct duart *) qdmap[unit].duart;
        duart->imask = 0;
 
 
        duart = (struct duart *) qdmap[unit].duart;
        duart->imask = 0;
 

-       /*---------------------------------------------
-       * setup the DUART for kbd & pointing device */
-
-       duart->cmdA = RESET_M;    /* reset mode reg ptr for kbd */
-       duart->modeA = 0x13;      /* 8 bits, no parity, rcv IE, */
-                                 /* no RTS control,char error mode */
-       duart->modeA = 0x07;      /* 1 stop bit,CTS does not IE XMT */
-                                 /* no RTS control,no echo or loop */
-       duart->cmdB = RESET_M;    /* reset mode reg pntr for host */
-       duart->modeB = 0x07;      /* 8 bits, odd parity, rcv IE.. */
-                                 /* ..no RTS cntrl, char error mode */
-       duart->modeB = 0x07;      /* 1 stop bit,CTS does not IE XMT */
-                                 /* no RTS control,no echo or loop */
-
-       duart->auxctl = 0x00;     /* baud rate set 1 */
-
-       duart->clkselA = 0x99;    /* 4800 baud for kbd */
-       duart->clkselB = 0x99;    /* 4800 baud for mouse */
+       /*
+       * setup the DUART for kbd & pointing device 
+       */
+       duart->cmdA = RESET_M;  /* reset mode reg ptr for kbd */
+       duart->modeA = 0x13;    /* 8 bits, no parity, rcv IE, */
+                               /* no RTS control,char error mode */
+       duart->modeA = 0x07;    /* 1 stop bit,CTS does not IE XMT */
+                               /* no RTS control,no echo or loop */
+       duart->cmdB = RESET_M;  /* reset mode reg pntr for host */
+       duart->modeB = 0x07;    /* 8 bits, odd parity, rcv IE.. */
+                               /* ..no RTS cntrl, char error mode */
+       duart->modeB = 0x07;    /* 1 stop bit,CTS does not IE XMT */
+                               /* no RTS control,no echo or loop */
+       duart->auxctl = 0x00;   /* baud rate set 1 */
+       duart->clkselA = 0x99;  /* 4800 baud for kbd */
+       duart->clkselB = 0x99;  /* 4800 baud for mouse */

 
        /* reset everything for keyboard */
 
        for (bits = RESET_M; bits < START_BREAK; bits += 0x10)
 
        /* reset everything for keyboard */
 
        for (bits = RESET_M; bits < START_BREAK; bits += 0x10)

-           duart->cmdA = bits;
+               duart->cmdA = bits;

 
        /* reset everything for host */
 
        for (bits = RESET_M; bits < START_BREAK; bits += 0x10)
 
        /* reset everything for host */
 
        for (bits = RESET_M; bits < START_BREAK; bits += 0x10)

-            duart->cmdB = bits;
+               duart->cmdB = bits;

 
        duart->cmdA = EN_RCV | EN_XMT; /* enbl xmt & rcv for kbd */
        duart->cmdB = EN_RCV | EN_XMT; /* enbl xmt & rcv for pointer device */
 
 
        duart->cmdA = EN_RCV | EN_XMT; /* enbl xmt & rcv for kbd */
        duart->cmdB = EN_RCV | EN_XMT; /* enbl xmt & rcv for pointer device */
 

-       /*--------------------------------------------
-       * init keyboard defaults (DUART channel A) */
-
+       /*
+       * init keyboard defaults (DUART channel A) 
+       */

        for (i = 500; i > 0; --i) {
        for (i = 500; i > 0; --i) {

-           if ((status = duart->statusA) & XMT_RDY) {
-               duart->dataA = LK_DEFAULTS;
-               break;
-           }
+               if (duart->statusA&XMT_RDY) {
+                       duart->dataA = LK_DEFAULTS;
+                       break;
+               }

        }
 
        for (i = 100000; i > 0; --i) {
        }
 
        for (i = 100000; i > 0; --i) {

-           if ((status = duart->statusA) & RCV_RDY) {
-               break;
-           }
+               if (duart->statusA&RCV_RDY) {
+                       break;
+               }

        }
 
        }
 

-       status = duart->dataA;          /* flush the ACK */
-
-       /*--------------------------------
-       * identify the pointing device */
+       if (duart->dataA)       /* flush the ACK */
+               ;               

 
 

+       /*
+       * identify the pointing device 
+       */

        for (i = 500; i > 0; --i) {
        for (i = 500; i > 0; --i) {

-           if ((status = duart->statusB) & XMT_RDY) {
-               duart->dataB = SELF_TEST;
-               break;
-           }
+               if (duart->statusB&XMT_RDY) {
+                       duart->dataB = SELF_TEST;
+                       break;
+               }

        }
 
        }
 

-       /*-----------------------------------------
+       /*

        * wait for 1st byte of self test report */
 
        for (i = 100000; i > 0; --i) {
        * wait for 1st byte of self test report */
 
        for (i = 100000; i > 0; --i) {

-           if ((status = duart->statusB) & RCV_RDY) {
-               break;
-           }
+               if (duart->statusB&RCV_RDY) {
+                       break;
+               }

        }
 
        if (i == 0) {
        }
 
        if (i == 0) {

-           printf("qd[%d]: setup_input: timeout on 1st byte of self test\n",
-                  unit);
-           goto OUT;
+               printf("qd[%d]: setup_input: timeout on 1st byte of self test\n"
+                      ,unit);
+               goto OUT;

        }
 
        }
 

-       status = duart->dataB;
-
-       /*-----------------------------------------
-       * wait for ID byte of self test report  */
+       if (duart->dataB)
+               ;

 
 

+       /*
+       * wait for ID byte of self test report  
+       */

        for (i = 100000; i > 0; --i) {
        for (i = 100000; i > 0; --i) {

-           if ((status = duart->statusB) & RCV_RDY) {
-               break;
-           }
+               if (duart->statusB&RCV_RDY) {
+                       break;
+               }

        }
 
        if (i == 0) {
        }
 
        if (i == 0) {

-           printf("qd[%d]: setup_input: timeout on 2nd byte of self test\n",
-                  unit);
-           goto OUT;
+               printf("qd[%d]: setup_input: timeout on 2nd byte of self test\n", unit);
+               goto OUT;

        }
 
        id_byte = duart->dataB;
 
        }
 
        id_byte = duart->dataB;
 

-       /*------------------------------------
-       * wait for other bytes to come in  */
-
+       /*
+       * wait for other bytes to come in  
+       */

        for (i = 100000; i > 0; --i) {
        for (i = 100000; i > 0; --i) {

-           if ((status = duart->statusB) & RCV_RDY) {
-               status = duart->dataB;
-               break;
-           }
+               if (duart->statusB & RCV_RDY) {
+                       if (duart->dataB)
+                               ;
+                       break;
+               }

        }
        }

-

        if (i == 0) {
        if (i == 0) {

-           printf("qd[%d]: setup_input: timeout on 3rd byte of self test\n",
-                  unit);
-           goto OUT;
+               printf("qd[%d]: setup_input: timeout on 3rd byte of self test\n", unit);
+               goto OUT;

        }
        }

-

        for (i = 100000; i > 0; --i) {
        for (i = 100000; i > 0; --i) {

-           if ((status = duart->statusB) & RCV_RDY) {
-               status = duart->dataB;
-               break;
-           }
+               if (duart->statusB&RCV_RDY) {
+                       if (duart->dataB)
+                               ;
+                       break;
+               }

        }
        }

-

        if (i == 0) {
        if (i == 0) {

-           printf("qd[%d]: setup_input: timeout on 4th byte of self test\n",
-                  unit);
-           goto OUT;
+               printf("qd[%d]: setup_input: timeout on 4th byte of self test\n", unit);
+               goto OUT;

        }
        }

-
-       /*----------------------------------------------
-       * flag pointing device type and set defaults */
-
-       for (i=100000; i>0; --i);
+       /*
+       * flag pointing device type and set defaults 
+       */
+       for (i=100000; i>0; --i)
+               ;               /*XXX*/

 
        if ((id_byte & 0x0F) != TABLET_ID) {
 
        if ((id_byte & 0x0F) != TABLET_ID) {

+               qdflags[unit].pntr_id = MOUSE_ID;

 
 

-           qdflags[unit].pntr_id = MOUSE_ID;
-
-           for (i = 500; i > 0; --i) {
-               if ((status = duart->statusB) & XMT_RDY) {
-                   duart->dataB = INC_STREAM_MODE;
-                   break;
+               for (i = 500; i > 0; --i) {
+                       if (duart->statusB&XMT_RDY) {
+                               duart->dataB = INC_STREAM_MODE;
+                               break;
+                       }

                }
                }

-           }
-       } else {
-
-           qdflags[unit].pntr_id = TABLET_ID;
+       } 
+       else {
+               qdflags[unit].pntr_id = TABLET_ID;

 
 

-           for (i = 500; i > 0; --i) {
-               if ((status = duart->statusB) & XMT_RDY) {
-                   duart->dataB = T_STREAM;
-                   break;
+               for (i = 500; i > 0; --i) {
+                       if (duart->statusB&XMT_RDY) {
+                               duart->dataB = T_STREAM;
+                               break;
+                       }

                }
                }

-           }

        }
        }

-
-       /*--------
-       * exit */
-

 OUT:
        duart->imask = qdflags[unit].duart_imask;
 OUT:
        duart->imask = qdflags[unit].duart_imask;

-       return(0);

 
 } /* setup_input */
 
 
 } /* setup_input */
 

-/**********************************************************************
-*
-*      wait_status()... delay for at least one display frame time
-*
-***********************************************************************
-*
-*      calling convention:
-*
-*              wait_status(adder, mask);
-*              struct *adder adder;
-*              int mask;
-*
-*      return: BAD means that we timed out without ever seeing the
-*                    vertical sync status bit
-*              GOOD otherwise
-*
-**************/
-
+/*
+ * delay for at least one display frame time
+ *
+ *     return: BAD means that we timed out without ever seeing the
+ *                   vertical sync status bit
+ *             GOOD otherwise
+ */

 wait_status(adder, mask)
 wait_status(adder, mask)

-register struct adder *adder;
-register int mask;
+       register struct adder *adder;
+       register int mask;

 {
 {

-       register short status;
-       int i;
+       register i;

 
 

-       for ( i = 10000, adder->status = 0
-           ; i > 0  &&  !((status = adder->status) & mask)
-           ; --i);
+       for (i = 10000, adder->status = 0 ; i > 0  &&  
+            !(adder->status&mask) ; --i)
+               ;

 
        if (i == 0) {
 
        if (i == 0) {

-           printf("wait_status: timeout polling for 0x%x in adder->status\n",
-                  mask);
-           return(BAD);
+               printf("wait_status: timeout polling for 0x%x in adder->status\n", mask);
+               return(BAD);

        }
 
        return(GOOD);
 
 } /* wait_status */
 
        }
 
        return(GOOD);
 
 } /* wait_status */
 

-/**********************************************************************
-*
-*      write_ID()... write out onto the ID bus
-*
-***********************************************************************
-*
-*      calling convention:
-*
-*              struct *adder adder;    ;pntr to ADDER structure
-*              short adrs;             ;VIPER address
-*              short data;             ;data to be written
-*              write_ID(adder);
-*
-*      return: BAD means that we timed out waiting for status bits
-*                    VIPER-access-specific status bits
-*              GOOD otherwise
-*
-**************/
-
+/*
+ * write out onto the ID bus
+ */

 write_ID(adder, adrs, data)
 write_ID(adder, adrs, data)

-register struct adder *adder;
-register short adrs;
-register short data;
+       register struct adder *adder;
+       register short adrs;
+       register short data;

 {
 {

-       int i;
-       short status;
+       register i;

 
 

-       for ( i = 100000, adder->status = 0;
-             i > 0  &&  !((status = adder->status) & ADDRESS_COMPLETE); --i)
+       for (i = 100000, adder->status = 0 ; 
+             i > 0  &&  !(adder->status&ADDRESS_COMPLETE) ; --i)

                ;
 
        if (i == 0)
                ;
 
        if (i == 0)

-           goto ERR;
+               goto ERR;

 
 

-       for ( i = 100000, adder->status = 0;
-             i > 0  &&  !((status = adder->status) & TX_READY); --i)
+       for (i = 100000, adder->status = 0 ; 
+             i > 0  &&  !(adder->status&TX_READY) ; --i)

                ;
 
        if (i > 0) {
                ;
 
        if (i > 0) {

-           adder->id_data = data;
-           adder->command = ID_LOAD | adrs;
-           return(GOOD);
+               adder->id_data = data;
+               adder->command = ID_LOAD | adrs;
+               return ;

        }
 
 ERR:
        printf("write_ID: timeout trying to write to VIPER\n");
        }
 
 ERR:
        printf("write_ID: timeout trying to write to VIPER\n");

-       return(BAD);
+       return ;

 
 } /* write_ID */
 #endif
 
 } /* write_ID */
 #endif