strategy returns void, ioctl cmd is u_long

[unix-history] / usr / src / sys / hp / dev / grf.c

diff --git a/usr/src/sys/hp/dev/grf.c b/usr/src/sys/hp/dev/grf.c
index 80ca644..bf59913 100644 (file)
--- a/usr/src/sys/hp/dev/grf.c
+++ b/usr/src/sys/hp/dev/grf.c
@@ -1,7 +1,7 @@
 /*
  * Copyright (c) 1988 University of Utah.
 /*
  * Copyright (c) 1988 University of Utah.

- * Copyright (c) 1990 The Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1990, 1993
+ *     The Regents of the University of California.  All rights reserved.

  *
  * This code is derived from software contributed to Berkeley by
  * the Systems Programming Group of the University of Utah Computer
  *
  * This code is derived from software contributed to Berkeley by
  * the Systems Programming Group of the University of Utah Computer


@@ -9,77 +9,51 @@
  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

- * from: Utah $Hdr: grf.c 1.28 89/08/14$
+ * from: Utah $Hdr: grf.c 1.36 93/08/13$

  *
  *

- *     @(#)grf.c       7.5 (Berkeley) %G%
+ *     @(#)grf.c       8.5 (Berkeley) %G%

  */
 
 /*
  */
 
 /*

- * Graphics display driver for the HP300.
+ * Graphics display driver for HP 300/400/700/800 machines.

  * This is the hardware-independent portion of the driver.
  * This is the hardware-independent portion of the driver.

- * Hardware access is through the grfdev routines below.
+ * Hardware access is through the machine dependent grf switch routines.

  */
 
 #include "grf.h"
 #if NGRF > 0
 
  */
 
 #include "grf.h"
 #if NGRF > 0
 

-#include "param.h"
-#include "user.h"
-#include "proc.h"
-#include "ioctl.h"
-#include "file.h"
-#include "malloc.h"
+#include <sys/param.h>
+#include <sys/proc.h>
+#include <sys/ioctl.h>
+#include <sys/file.h>
+#include <sys/malloc.h>
+#include <sys/vnode.h>
+#include <sys/mman.h>

 
 

-#include "device.h"
-#include "grfioctl.h"
-#include "grfvar.h"
+#include <hp/dev/grfioctl.h>
+#include <hp/dev/grfvar.h>
+#include <hp/dev/grfreg.h>

 
 

-#include "machine/cpu.h"
+#include <machine/cpu.h>

 
 #ifdef HPUXCOMPAT
 
 #ifdef HPUXCOMPAT

-#include "../hpux/hpux.h"
+#include <hp/hpux/hpux.h>

 #endif
 
 #endif
 

-#include "../vm/vm_param.h"
-#include "../vm/vm_map.h"
-#include "../vm/vm_kern.h"
-#include "../vm/vm_page.h"
-#include "../vm/vm_pager.h"
-#include "specdev.h"
-#include "vnode.h"
-#include "mman.h"
+#include <vm/vm.h>
+#include <vm/vm_kern.h>
+#include <vm/vm_page.h>
+#include <vm/vm_pager.h>

 
 

-#include "ite.h"
+#include <miscfs/specfs/specdev.h>
+
+#include <ite.h>

 #if NITE == 0
 #define        iteon(u,f)
 #define        iteoff(u,f)
 #endif
 
 #if NITE == 0
 #define        iteon(u,f)
 #define        iteoff(u,f)
 #endif
 

-int    grfprobe();
-int    tc_init(), tc_mode();
-int    gb_init(), gb_mode();
-int    rb_init(), rb_mode();
-int    dv_init(), dv_mode();
-
-struct grfdev grfdev[] = {
-       GID_TOPCAT,     GRFBOBCAT,      tc_init,        tc_mode,
-       "topcat",
-       GID_GATORBOX,   GRFGATOR,       gb_init,        gb_mode,
-       "gatorbox",
-       GID_RENAISSANCE,GRFRBOX,        rb_init,        rb_mode,
-       "renaissance",
-       GID_LRCATSEYE,  GRFCATSEYE,     tc_init,        tc_mode,
-       "lo-res catseye",
-       GID_HRCCATSEYE, GRFCATSEYE,     tc_init,        tc_mode,
-       "hi-res catseye",
-       GID_HRMCATSEYE, GRFCATSEYE,     tc_init,        tc_mode,
-       "hi-res catseye",
-       GID_DAVINCI,    GRFDAVINCI,     dv_init,        dv_mode,
-       "davinci",
-};
-int    ngrfdev = sizeof(grfdev) / sizeof(grfdev[0]);
-
-struct driver grfdriver = { grfprobe, "grf" };

 struct grf_softc grf_softc[NGRF];
 
 #ifdef DEBUG
 struct grf_softc grf_softc[NGRF];
 
 #ifdef DEBUG


@@ -90,99 +64,10 @@ int grfdebug = 0;
 #define GDB_LOCK       0x08
 #endif
 
 #define GDB_LOCK       0x08
 #endif
 

-/*
- * XXX: called from ite console init routine.
- * Does just what configure will do later but without printing anything.
- */
-grfconfig()
-{
-       register caddr_t addr;
-       register struct hp_hw *hw;
-       register struct hp_device *hd, *nhd;
-
-       for (hw = sc_table; hw->hw_type; hw++) {
-               if (hw->hw_type != BITMAP)
-                       continue;
-               /*
-                * Found one, now match up with a logical unit number
-                */
-               nhd = NULL;             
-               addr = hw->hw_addr;
-               for (hd = hp_dinit; hd->hp_driver; hd++) {
-                       if (hd->hp_driver != &grfdriver || hd->hp_alive)
-                               continue;
-                       /*
-                        * Wildcarded.  If first, remember as possible match.
-                        */
-                       if (hd->hp_addr == NULL) {
-                               if (nhd == NULL)
-                                       nhd = hd;
-                               continue;
-                       }
-                       /*
-                        * Not wildcarded.
-                        * If exact match done searching, else keep looking.
-                        */
-                       if ((caddr_t)sctoaddr(hd->hp_addr) == addr) {
-                               nhd = hd;
-                               break;
-                       }
-               }
-               /*
-                * Found a match, initialize
-                */
-               if (nhd && grfinit(addr, nhd->hp_unit)) {
-                       nhd->hp_addr = addr;
-               }
-       }
-}
-
-/*
- * Normal init routine called by configure() code
- */
-grfprobe(hd)
-       struct hp_device *hd;
-{
-       struct grf_softc *gp = &grf_softc[hd->hp_unit];
-
-       if ((gp->g_flags & GF_ALIVE) == 0 &&
-           !grfinit(hd->hp_addr, hd->hp_unit))
-               return(0);
-       printf("grf%d: %d x %d ", hd->hp_unit,
-              gp->g_display.gd_dwidth, gp->g_display.gd_dheight);
-       if (gp->g_display.gd_colors == 2)
-               printf("monochrome");
-       else
-               printf("%d color", gp->g_display.gd_colors);
-       printf(" %s display\n", grfdev[gp->g_type].gd_desc);
-       return(1);
-}
-
-grfinit(addr, unit)
-       caddr_t addr;
-{
-       struct grf_softc *gp = &grf_softc[unit];
-       struct grfreg *gr;
-       register struct grfdev *gd;
-
-       gr = (struct grfreg *) addr;
-       if (gr->gr_id != GRFHWID)
-               return(0);
-       for (gd = grfdev; gd < &grfdev[ngrfdev]; gd++)
-               if (gd->gd_hardid == gr->gr_id2)
-                       break;
-       if (gd < &grfdev[ngrfdev] && (*gd->gd_init)(gp, addr)) {
-               gp->g_display.gd_id = gd->gd_softid;
-               gp->g_type = gd - grfdev;
-               gp->g_flags = GF_ALIVE;
-               return(1);
-       }
-       return(0);
-}
-

 /*ARGSUSED*/
 grfopen(dev, flags)
        dev_t dev;
 /*ARGSUSED*/
 grfopen(dev, flags)
        dev_t dev;

+       int flags;

 {
        int unit = GRFUNIT(dev);
        register struct grf_softc *gp = &grf_softc[unit];
 {
        int unit = GRFUNIT(dev);
        register struct grf_softc *gp = &grf_softc[unit];


@@ -196,7 +81,7 @@ grfopen(dev, flags)
        /*
         * XXX: cannot handle both HPUX and BSD processes at the same time
         */
        /*
         * XXX: cannot handle both HPUX and BSD processes at the same time
         */

-       if (u.u_procp->p_flag & SHPUX)
+       if (curproc->p_md.md_flags & MDP_HPUX)

                if (gp->g_flags & GF_BSDOPEN)
                        return(EBUSY);
                else
                if (gp->g_flags & GF_BSDOPEN)
                        return(EBUSY);
                else


@@ -222,35 +107,36 @@ grfopen(dev, flags)
 /*ARGSUSED*/
 grfclose(dev, flags)
        dev_t dev;
 /*ARGSUSED*/
 grfclose(dev, flags)
        dev_t dev;

+       int flags;

 {
        register struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
 
        (void) grfoff(dev);
 {
        register struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
 
        (void) grfoff(dev);

+#ifdef HPUXCOMPAT

        (void) grfunlock(gp);
        (void) grfunlock(gp);

+#endif

        gp->g_flags &= GF_ALIVE;
        return(0);
 }
 
 /*ARGSUSED*/
        gp->g_flags &= GF_ALIVE;
        return(0);
 }
 
 /*ARGSUSED*/

-grfioctl(dev, cmd, data, flag)
+grfioctl(dev, cmd, data, flag, p)

        dev_t dev;
        dev_t dev;

+       u_long cmd;

        caddr_t data;
        caddr_t data;

+       int flag;
+       struct proc *p;

 {
        register struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
        int error;
 
 #ifdef HPUXCOMPAT
 {
        register struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
        int error;
 
 #ifdef HPUXCOMPAT

-       if (u.u_procp->p_flag & SHPUX)
-               return(hpuxgrfioctl(dev, cmd, data, flag));
+       if (p->p_md.md_flags & MDP_HPUX)
+               return(hpuxgrfioctl(dev, cmd, data, flag, p));

 #endif
        error = 0;
        switch (cmd) {
 
 #endif
        error = 0;
        switch (cmd) {
 

-       /* XXX: compatibility hack */
-       case OGRFIOCGINFO:
-               bcopy((caddr_t)&gp->g_display, data, sizeof(struct ogrfinfo));
-               break;
-

        case GRFIOCGINFO:
                bcopy((caddr_t)&gp->g_display, data, sizeof(struct grfinfo));
                break;
        case GRFIOCGINFO:
                bcopy((caddr_t)&gp->g_display, data, sizeof(struct grfinfo));
                break;


@@ -264,11 +150,11 @@ grfioctl(dev, cmd, data, flag)
                break;
 
        case GRFIOCMAP:
                break;
 
        case GRFIOCMAP:

-               error = grfmmap(dev, (caddr_t *)data);
+               error = grfmmap(dev, (caddr_t *)data, p);

                break;
 
        case GRFIOCUNMAP:
                break;
 
        case GRFIOCUNMAP:

-               error = grfunmmap(dev, *(caddr_t *)data);
+               error = grfunmmap(dev, *(caddr_t *)data, p);

                break;
 
        default:
                break;
 
        default:


@@ -282,112 +168,85 @@ grfioctl(dev, cmd, data, flag)
 /*ARGSUSED*/
 grfselect(dev, rw)
        dev_t dev;
 /*ARGSUSED*/
 grfselect(dev, rw)
        dev_t dev;

+       int rw;

 {
        if (rw == FREAD)
                return(0);
        return(1);
 }
 
 {
        if (rw == FREAD)
                return(0);
        return(1);
 }
 

-grflock(gp, block)
-       register struct grf_softc *gp;
-       int block;
+/*ARGSUSED*/
+grfmap(dev, off, prot)
+       dev_t dev;
+       int off, prot;

 {
 {

-       struct proc *p = u.u_procp;             /* XXX */
-       int error;
-       extern char devioc[];
-
-#ifdef DEBUG
-       if (grfdebug & GDB_LOCK)
-               printf("grflock(%d): dev %x flags %x lockpid %x\n",
-                      p->p_pid, gp-grf_softc, gp->g_flags,
-                      gp->g_lockp ? gp->g_lockp->p_pid : -1);
-#endif
-#ifdef HPUXCOMPAT
-       if (gp->g_pid) {
-#ifdef DEBUG
-               if (grfdebug & GDB_LOCK)
-                       printf("  lock[0] %d lockslot %d lock[lockslot] %d\n",
-                              gp->g_locks[0], gp->g_lockpslot,
-                              gp->g_locks[gp->g_lockpslot]);
-#endif
-               gp->g_locks[0] = 0;
-               if (gp->g_locks[gp->g_lockpslot] == 0) {
-                       gp->g_lockp = NULL;
-                       gp->g_lockpslot = 0;
-               }
-       }
-#endif
-       if (gp->g_lockp) {
-               if (gp->g_lockp == p)
-                       return(EBUSY);
-               if (!block)
-                       return(EAGAIN);
-               do {
-                       gp->g_flags |= GF_WANTED;
-                       if (error = tsleep((caddr_t)&gp->g_flags,
-                                          (PZERO+1) | PCATCH, devioc, 0))
-                               return (error);
-               } while (gp->g_lockp);
-       }
-       gp->g_lockp = p;
-#ifdef HPUXCOMPAT
-       if (gp->g_pid) {
-               int slot = grffindpid(gp);
-#ifdef DEBUG
-               if (grfdebug & GDB_LOCK)
-                       printf("  slot %d\n", slot);
-#endif
-               gp->g_lockpslot = gp->g_locks[0] = slot;
-               gp->g_locks[slot] = 1;
-       }
-#endif
-       return(0);
+       return(grfaddr(&grf_softc[GRFUNIT(dev)], off));

 }
 
 }
 

-grfunlock(gp)
-       register struct grf_softc *gp;
+grfon(dev)
+       dev_t dev;

 {
 {

-#ifdef DEBUG
-       if (grfdebug & GDB_LOCK)
-               printf("grfunlock(%d): dev %x flags %x lockpid %d\n",
-                      u.u_procp->p_pid, gp-grf_softc, gp->g_flags,
-                      gp->g_lockp ? gp->g_lockp->p_pid : -1);
-#endif
-       if (gp->g_lockp != u.u_procp)
-               return(EBUSY);
-#ifdef HPUXCOMPAT
-       if (gp->g_pid) {
-#ifdef DEBUG
-               if (grfdebug & GDB_LOCK)
-                       printf("  lock[0] %d lockslot %d lock[lockslot] %d\n",
-                              gp->g_locks[0], gp->g_lockpslot,
-                              gp->g_locks[gp->g_lockpslot]);
-#endif
-               gp->g_locks[gp->g_lockpslot] = gp->g_locks[0] = 0;
-               gp->g_lockpslot = 0;
-       }
-#endif
-       if (gp->g_flags & GF_WANTED) {
-               wakeup((caddr_t)&gp->g_flags); 
-               gp->g_flags &= ~GF_WANTED;
-       }
-       gp->g_lockp = NULL;
-       return(0);
+       int unit = GRFUNIT(dev);
+       struct grf_softc *gp = &grf_softc[unit];
+
+       /*
+        * XXX: iteoff call relies on devices being in same order
+        * as ITEs and the fact that iteoff only uses the minor part
+        * of the dev arg.
+        */
+       iteoff(unit, 3);
+       return((*gp->g_sw->gd_mode)(gp,
+                                   (dev&GRFOVDEV) ? GM_GRFOVON : GM_GRFON,
+                                   (caddr_t)0));

 }
 
 }
 

-/*ARGSUSED*/
-grfmap(dev, off, prot)
+grfoff(dev)

        dev_t dev;
 {
        dev_t dev;
 {

-       return(grfaddr(&grf_softc[GRFUNIT(dev)], off));
+       int unit = GRFUNIT(dev);
+       struct grf_softc *gp = &grf_softc[unit];
+       int error;
+
+       (void) grfunmmap(dev, (caddr_t)0, curproc);
+       error = (*gp->g_sw->gd_mode)(gp,
+                                    (dev&GRFOVDEV) ? GM_GRFOVOFF : GM_GRFOFF,
+                                    (caddr_t)0);
+       /* XXX: see comment for iteoff above */
+       iteon(unit, 2);
+       return(error);

 }
 
 }
 

+grfaddr(gp, off)
+       struct grf_softc *gp;
+       register int off;
+{
+       register struct grfinfo *gi = &gp->g_display;
+
+       /* control registers */
+       if (off >= 0 && off < gi->gd_regsize)
+               return(((u_int)gi->gd_regaddr + off) >> PGSHIFT);
+
+       /* frame buffer */
+       if (off >= gi->gd_regsize && off < gi->gd_regsize+gi->gd_fbsize) {
+               off -= gi->gd_regsize;
+               return(((u_int)gi->gd_fbaddr + off) >> PGSHIFT);
+       }
+       /* bogus */
+       return(-1);
+}
+
+/*
+ * HP-UX compatibility routines
+ */

 #ifdef HPUXCOMPAT
 
 /*ARGSUSED*/
 #ifdef HPUXCOMPAT
 
 /*ARGSUSED*/

-hpuxgrfioctl(dev, cmd, data, flag)
+hpuxgrfioctl(dev, cmd, data, flag, p)

        dev_t dev;
        dev_t dev;

+       u_long cmd;

        caddr_t data;
        caddr_t data;

+       int flag;
+       struct proc *p;

 {
        register struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
        int error;
 {
        register struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
        int error;


@@ -426,11 +285,11 @@ hpuxgrfioctl(dev, cmd, data, flag)
 
        /* map in control regs and frame buffer */
        case GCMAP:
 
        /* map in control regs and frame buffer */
        case GCMAP:

-               error = grfmmap(dev, (caddr_t *)data);
+               error = grfmmap(dev, (caddr_t *)data, p);

                break;
 
        case GCUNMAP:
                break;
 
        case GCUNMAP:

-               error = grfunmmap(dev, *(caddr_t *)data);
+               error = grfunmmap(dev, *(caddr_t *)data, p);

                /* XXX: HP-UX uses GCUNMAP to get rid of GCSLOT memory */
                if (error)
                        error = grflckunmmap(dev, *(caddr_t *)data);
                /* XXX: HP-UX uses GCUNMAP to get rid of GCSLOT memory */
                if (error)
                        error = grflckunmmap(dev, *(caddr_t *)data);


@@ -452,6 +311,10 @@ hpuxgrfioctl(dev, cmd, data, flag)
                break;
        }
 
                break;
        }
 

+       case GCDESCRIBE:
+               error = (*gp->g_sw->gd_mode)(gp, GM_DESCRIBE, data);
+               break;
+

        /*
         * XXX: only used right now to map in rbox control registers
         * Will be replaced in the future with a real IOMAP interface.
        /*
         * XXX: only used right now to map in rbox control registers
         * Will be replaced in the future with a real IOMAP interface.


@@ -482,59 +345,88 @@ hpuxgrfioctl(dev, cmd, data, flag)
        return(error);
 }
 
        return(error);
 }
 

-#endif
-
-grfon(dev)
-       dev_t dev;
-{
-       int unit = GRFUNIT(dev);
-       struct grf_softc *gp = &grf_softc[unit];
-
-       /*
-        * XXX: iteoff call relies on devices being in same order
-        * as ITEs and the fact that iteoff only uses the minor part
-        * of the dev arg.
-        */
-       iteoff(unit, 3);
-       return((*grfdev[gp->g_type].gd_mode)
-                       (gp, (dev&GRFOVDEV) ? GM_GRFOVON : GM_GRFON));
-}
-
-grfoff(dev)
-       dev_t dev;
+grflock(gp, block)
+       register struct grf_softc *gp;
+       int block;

 {
 {

-       int unit = GRFUNIT(dev);
-       struct grf_softc *gp = &grf_softc[unit];
+       struct proc *p = curproc;               /* XXX */

        int error;
        int error;

+       extern char devioc[];

 
 

-       (void) grfunmmap(dev, (caddr_t)0);
-       error = (*grfdev[gp->g_type].gd_mode)
-                       (gp, (dev&GRFOVDEV) ? GM_GRFOVOFF : GM_GRFOFF);
-       /* XXX: see comment for iteoff above */
-       iteon(unit, 2);
-       return(error);
+#ifdef DEBUG
+       if (grfdebug & GDB_LOCK)
+               printf("grflock(%d): dev %x flags %x lockpid %x\n",
+                      p->p_pid, gp-grf_softc, gp->g_flags,
+                      gp->g_lockp ? gp->g_lockp->p_pid : -1);
+#endif
+       if (gp->g_pid) {
+#ifdef DEBUG
+               if (grfdebug & GDB_LOCK)
+                       printf(" lockpslot %d lockslot %d lock[lockslot] %d\n",
+                              gp->g_lock->gl_lockslot, gp->g_lockpslot,
+                              gp->g_lock->gl_locks[gp->g_lockpslot]);
+#endif
+               gp->g_lock->gl_lockslot = 0;
+               if (gp->g_lock->gl_locks[gp->g_lockpslot] == 0) {
+                       gp->g_lockp = NULL;
+                       gp->g_lockpslot = 0;
+               }
+       }
+       if (gp->g_lockp) {
+               if (gp->g_lockp == p)
+                       return(EBUSY);
+               if (!block)
+                       return(OEAGAIN);
+               do {
+                       gp->g_flags |= GF_WANTED;
+                       if (error = tsleep((caddr_t)&gp->g_flags,
+                                          (PZERO+1) | PCATCH, devioc, 0))
+                               return (error);
+               } while (gp->g_lockp);
+       }
+       gp->g_lockp = p;
+       if (gp->g_pid) {
+               int slot = grffindpid(gp);
+
+#ifdef DEBUG
+               if (grfdebug & GDB_LOCK)
+                       printf("  slot %d\n", slot);
+#endif
+               gp->g_lockpslot = gp->g_lock->gl_lockslot = slot;
+               gp->g_lock->gl_locks[slot] = 1;
+       }
+       return(0);

 }
 
 }
 

-grfaddr(gp, off)
-       struct grf_softc *gp;
-       register int off;
+grfunlock(gp)
+       register struct grf_softc *gp;

 {
 {

-       register struct grfinfo *gi = &gp->g_display;
-
-       /* control registers */
-       if (off >= 0 && off < gi->gd_regsize)
-               return(((u_int)gi->gd_regaddr + off) >> PGSHIFT);
-
-       /* frame buffer */
-       if (off >= gi->gd_regsize && off < gi->gd_regsize+gi->gd_fbsize) {
-               off -= gi->gd_regsize;
-               return(((u_int)gi->gd_fbaddr + off) >> PGSHIFT);
+#ifdef DEBUG
+       if (grfdebug & GDB_LOCK)
+               printf("grfunlock(%d): dev %x flags %x lockpid %d\n",
+                      curproc->p_pid, gp-grf_softc, gp->g_flags,
+                      gp->g_lockp ? gp->g_lockp->p_pid : -1);
+#endif
+       if (gp->g_lockp != curproc)
+               return(EBUSY);
+       if (gp->g_pid) {
+#ifdef DEBUG
+               if (grfdebug & GDB_LOCK)
+                       printf(" lockpslot %d lockslot %d lock[lockslot] %d\n",
+                              gp->g_lock->gl_lockslot, gp->g_lockpslot,
+                              gp->g_lock->gl_locks[gp->g_lockpslot]);
+#endif
+               gp->g_lock->gl_locks[gp->g_lockpslot] = 0;
+               gp->g_lockpslot = gp->g_lock->gl_lockslot = 0;

        }
        }

-       /* bogus */
-       return(-1);
+       if (gp->g_flags & GF_WANTED) {
+               wakeup((caddr_t)&gp->g_flags); 
+               gp->g_flags &= ~GF_WANTED;
+       }
+       gp->g_lockp = NULL;
+       return(0);

 }
 
 }
 

-#ifdef HPUXCOMPAT

 /*
  * Convert a BSD style minor devno to HPUX style.
  * We cannot just create HPUX style nodes as they require 24 bits
 /*
  * Convert a BSD style minor devno to HPUX style.
  * We cannot just create HPUX style nodes as they require 24 bits


@@ -554,8 +446,10 @@ grfdevno(dev)
        /* magic major number */
        newdev = 12 << 24;
        /* now construct minor number */
        /* magic major number */
        newdev = 12 << 24;
        /* now construct minor number */

-       if (gp->g_display.gd_regaddr != (caddr_t)GRFIADDR)
-               newdev |= ((u_int)gp->g_display.gd_regaddr-EXTIOBASE) | 0x200;
+       if (gp->g_display.gd_regaddr != (caddr_t)GRFIADDR) {
+               int sc = patosc(gp->g_display.gd_regaddr);
+               newdev |= (sc << 16) | 0x200;
+       }

        if (dev & GRFIMDEV)
                newdev |= 0x02;
        else if (dev & GRFOVDEV)
        if (dev & GRFIMDEV)
                newdev |= 0x02;
        else if (dev & GRFOVDEV)


@@ -566,13 +460,14 @@ grfdevno(dev)
 #endif
        return(newdev);
 }
 #endif
        return(newdev);
 }

-#endif

 
 

-grfmmap(dev, addrp)
+#endif /* HPUXCOMPAT */
+
+grfmmap(dev, addrp, p)

        dev_t dev;
        caddr_t *addrp;
        dev_t dev;
        caddr_t *addrp;

+       struct proc *p;

 {
 {

-       struct proc *p = u.u_procp;             /* XXX */

        struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
        int len, error;
        struct vnode vn;
        struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
        int len, error;
        struct vnode vn;


@@ -584,7 +479,7 @@ grfmmap(dev, addrp)
                printf("grfmmap(%d): addr %x\n", p->p_pid, *addrp);
 #endif
        len = gp->g_display.gd_regsize + gp->g_display.gd_fbsize;
                printf("grfmmap(%d): addr %x\n", p->p_pid, *addrp);
 #endif
        len = gp->g_display.gd_regsize + gp->g_display.gd_fbsize;

-       flags = MAP_FILE|MAP_SHARED;
+       flags = MAP_SHARED;

        if (*addrp)
                flags |= MAP_FIXED;
        else
        if (*addrp)
                flags |= MAP_FIXED;
        else


@@ -592,16 +487,19 @@ grfmmap(dev, addrp)
        vn.v_type = VCHR;                       /* XXX */
        vn.v_specinfo = &si;                    /* XXX */
        vn.v_rdev = dev;                        /* XXX */
        vn.v_type = VCHR;                       /* XXX */
        vn.v_specinfo = &si;                    /* XXX */
        vn.v_rdev = dev;                        /* XXX */

-       error = vm_mmap(u.u_procp->p_map, (vm_offset_t *)addrp,
-                       (vm_size_t)len, VM_PROT_ALL, flags, (caddr_t)&vn, 0);
+       error = vm_mmap(&p->p_vmspace->vm_map, (vm_offset_t *)addrp,
+                       (vm_size_t)len, VM_PROT_ALL, VM_PROT_ALL,
+                       flags, (caddr_t)&vn, 0);
+       if (error == 0)
+               (void) (*gp->g_sw->gd_mode)(gp, GM_MAP, *addrp);

        return(error);
 }
 
        return(error);
 }
 

-grfunmmap(dev, addr)
+grfunmmap(dev, addr, p)

        dev_t dev;
        caddr_t addr;
        dev_t dev;
        caddr_t addr;

+       struct proc *p;

 {
 {

-       struct proc *p = u.u_procp;             /* XXX */

        struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
        vm_size_t size;
        int rv;
        struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
        vm_size_t size;
        int rv;


@@ -612,8 +510,9 @@ grfunmmap(dev, addr)
 #endif
        if (addr == 0)
                return(EINVAL);         /* XXX: how do we deal with this? */
 #endif
        if (addr == 0)
                return(EINVAL);         /* XXX: how do we deal with this? */

+       (void) (*gp->g_sw->gd_mode)(gp, GM_UNMAP, 0);

        size = round_page(gp->g_display.gd_regsize + gp->g_display.gd_fbsize);
        size = round_page(gp->g_display.gd_regsize + gp->g_display.gd_fbsize);

-       rv = vm_deallocate(p->p_map, (vm_offset_t)addr, size);
+       rv = vm_deallocate(&p->p_vmspace->vm_map, (vm_offset_t)addr, size);

        return(rv == KERN_SUCCESS ? 0 : EINVAL);
 }
 
        return(rv == KERN_SUCCESS ? 0 : EINVAL);
 }
 


@@ -622,12 +521,10 @@ iommap(dev, addrp)
        dev_t dev;
        caddr_t *addrp;
 {
        dev_t dev;
        caddr_t *addrp;
 {

-       struct proc *p = u.u_procp;             /* XXX */
-       struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];

 
 #ifdef DEBUG
        if (grfdebug & (GDB_MMAP|GDB_IOMAP))
 
 #ifdef DEBUG
        if (grfdebug & (GDB_MMAP|GDB_IOMAP))

-               printf("iommap(%d): addr %x\n", p->p_pid, *addrp);
+               printf("iommap(%d): addr %x\n", curproc->p_pid, *addrp);

 #endif
        return(EINVAL);
 }
 #endif
        return(EINVAL);
 }


@@ -641,7 +538,7 @@ iounmmap(dev, addr)
 #ifdef DEBUG
        if (grfdebug & (GDB_MMAP|GDB_IOMAP))
                printf("iounmmap(%d): id %d addr %x\n",
 #ifdef DEBUG
        if (grfdebug & (GDB_MMAP|GDB_IOMAP))
                printf("iounmmap(%d): id %d addr %x\n",

-                      u.u_procp->p_pid, unit, addr);
+                      curproc->p_pid, unit, addr);

 #endif
        return(0);
 }
 #endif
        return(0);
 }


@@ -665,7 +562,7 @@ grffindpid(gp)
                        malloc(GRFMAXLCK * sizeof(short), M_DEVBUF, M_WAITOK);
                bzero((caddr_t)gp->g_pid, GRFMAXLCK * sizeof(short));
        }
                        malloc(GRFMAXLCK * sizeof(short), M_DEVBUF, M_WAITOK);
                bzero((caddr_t)gp->g_pid, GRFMAXLCK * sizeof(short));
        }

-       pid = u.u_procp->p_pid;
+       pid = curproc->p_pid;

        ni = limit = gp->g_pid[0];
        for (i = 1, sp = &gp->g_pid[1]; i <= limit; i++, sp++) {
                if (*sp == pid)
        ni = limit = gp->g_pid[0];
        for (i = 1, sp = &gp->g_pid[1]; i <= limit; i++, sp++) {
                if (*sp == pid)


@@ -700,7 +597,7 @@ grfrmpid(gp)
 
        if (gp->g_pid == NULL || (limit = gp->g_pid[0]) == 0)
                return;
 
        if (gp->g_pid == NULL || (limit = gp->g_pid[0]) == 0)
                return;

-       pid = u.u_procp->p_pid;
+       pid = curproc->p_pid;

        limit = gp->g_pid[0];
        mi = 0;
        for (i = 1, sp = &gp->g_pid[1]; i <= limit; i++, sp++) {
        limit = gp->g_pid[0];
        mi = 0;
        for (i = 1, sp = &gp->g_pid[1]; i <= limit; i++, sp++) {


@@ -723,9 +620,9 @@ grflckmmap(dev, addrp)
        dev_t dev;
        caddr_t *addrp;
 {
        dev_t dev;
        caddr_t *addrp;
 {

-       struct proc *p = u.u_procp;             /* XXX */
-

 #ifdef DEBUG
 #ifdef DEBUG

+       struct proc *p = curproc;               /* XXX */
+

        if (grfdebug & (GDB_MMAP|GDB_LOCK))
                printf("grflckmmap(%d): addr %x\n",
                       p->p_pid, *addrp);
        if (grfdebug & (GDB_MMAP|GDB_LOCK))
                printf("grflckmmap(%d): addr %x\n",
                       p->p_pid, *addrp);


@@ -737,12 +634,12 @@ grflckunmmap(dev, addr)
        dev_t dev;
        caddr_t addr;
 {
        dev_t dev;
        caddr_t addr;
 {

+#ifdef DEBUG

        int unit = minor(dev);
 
        int unit = minor(dev);
 

-#ifdef DEBUG

        if (grfdebug & (GDB_MMAP|GDB_LOCK))
                printf("grflckunmmap(%d): id %d addr %x\n",
        if (grfdebug & (GDB_MMAP|GDB_LOCK))
                printf("grflckunmmap(%d): id %d addr %x\n",

-                      u.u_procp->p_pid, unit, addr);
+                      curproc->p_pid, unit, addr);

 #endif
        return(EINVAL);
 }
 #endif
        return(EINVAL);
 }