include reordering due to vn_if change

[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 756522f..41b61c6 100644 (file)
--- a/usr/src/sys/hp/dev/grf.c
+++ b/usr/src/sys/hp/dev/grf.c
@@ -9,9 +9,9 @@
  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

- * from: Utah $Hdr: grf.c 1.28 89/08/14$
+ * from: Utah $Hdr: grf.c 1.31 91/01/21$

  *
  *

- *     @(#)grf.c       7.2 (Berkeley) %G%
+ *     @(#)grf.c       7.10 (Berkeley) %G%

  */
 
 /*
  */
 
 /*


@@ -24,11 +24,9 @@
 #if NGRF > 0
 
 #include "param.h"
 #if NGRF > 0
 
 #include "param.h"

-#include "user.h"

 #include "proc.h"
 #include "ioctl.h"
 #include "file.h"
 #include "proc.h"
 #include "ioctl.h"
 #include "file.h"

-#include "mapmem.h"

 #include "malloc.h"
 
 #include "device.h"
 #include "malloc.h"
 
 #include "device.h"


@@ -41,6 +39,15 @@
 #include "../hpux/hpux.h"
 #endif
 
 #include "../hpux/hpux.h"
 #endif
 

+#include "vm/vm.h"
+#include "vm/vm_kern.h"
+#include "vm/vm_page.h"
+#include "vm/vm_pager.h"
+
+#include "vnode.h"
+#include "specdev.h"
+#include "mman.h"
+

 #include "ite.h"
 #if NITE == 0
 #define        iteon(u,f)
 #include "ite.h"
 #if NITE == 0
 #define        iteon(u,f)


@@ -74,15 +81,6 @@ int  ngrfdev = sizeof(grfdev) / sizeof(grfdev[0]);
 struct driver grfdriver = { grfprobe, "grf" };
 struct grf_softc grf_softc[NGRF];
 
 struct driver grfdriver = { grfprobe, "grf" };
 struct grf_softc grf_softc[NGRF];
 

-#ifdef MAPMEM
-int grfexit();
-struct mapmemops grfops = { (int (*)())0, (int (*)())0, grfexit, grfexit };
-#ifdef HPUXCOMPAT
-struct mapmemops grflckops = { (int (*)())0, (int (*)())0, grfexit, grfexit };
-struct mapmemops grfiomops = { (int (*)())0, (int (*)())0, grfexit, grfexit };
-#endif
-#endif
-

 #ifdef DEBUG
 int grfdebug = 0;
 #define GDB_DEVNO      0x01
 #ifdef DEBUG
 int grfdebug = 0;
 #define GDB_DEVNO      0x01


@@ -102,13 +100,13 @@ grfconfig()
        register struct hp_device *hd, *nhd;
 
        for (hw = sc_table; hw->hw_type; hw++) {
        register struct hp_device *hd, *nhd;
 
        for (hw = sc_table; hw->hw_type; hw++) {

-               if (hw->hw_type != BITMAP)
+               if (!HW_ISDEV(hw, D_BITMAP))

                        continue;
                /*
                 * Found one, now match up with a logical unit number
                 */
                nhd = NULL;             
                        continue;
                /*
                 * Found one, now match up with a logical unit number
                 */
                nhd = NULL;             

-               addr = hw->hw_addr;
+               addr = hw->hw_kva;

                for (hd = hp_dinit; hd->hp_driver; hd++) {
                        if (hd->hp_driver != &grfdriver || hd->hp_alive)
                                continue;
                for (hd = hp_dinit; hd->hp_driver; hd++) {
                        if (hd->hp_driver != &grfdriver || hd->hp_alive)
                                continue;


@@ -124,7 +122,7 @@ grfconfig()
                         * Not wildcarded.
                         * If exact match done searching, else keep looking.
                         */
                         * Not wildcarded.
                         * If exact match done searching, else keep looking.
                         */

-                       if ((caddr_t)sctoaddr(hd->hp_addr) == addr) {
+                       if (sctova(hd->hp_addr) == addr) {

                                nhd = hd;
                                break;
                        }
                                nhd = hd;
                                break;
                        }


@@ -132,9 +130,8 @@ grfconfig()
                /*
                 * Found a match, initialize
                 */
                /*
                 * Found a match, initialize
                 */

-               if (nhd && grfinit(addr, nhd->hp_unit)) {
+               if (nhd && grfinit(addr, nhd->hp_unit))

                        nhd->hp_addr = addr;
                        nhd->hp_addr = addr;

-               }

        }
 }
 
        }
 }
 


@@ -197,7 +194,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_flag & SHPUX)

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


@@ -233,16 +230,17 @@ grfclose(dev, flags)
 }
 
 /*ARGSUSED*/
 }
 
 /*ARGSUSED*/

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

        dev_t dev;
        caddr_t data;
        dev_t dev;
        caddr_t data;

+       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_flag & SHPUX)
+               return(hpuxgrfioctl(dev, cmd, data, flag, p));

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


@@ -264,15 +262,13 @@ grfioctl(dev, cmd, data, flag)
                error = grfoff(dev);
                break;
 
                error = grfoff(dev);
                break;
 

-#ifdef MAPMEM

        case GRFIOCMAP:
        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;
                break;

-#endif

 
        default:
                error = EINVAL;
 
        default:
                error = EINVAL;


@@ -295,46 +291,44 @@ grflock(gp, block)
        register struct grf_softc *gp;
        int block;
 {
        register struct grf_softc *gp;
        int block;
 {

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

        int error;
        extern char devioc[];
 
 #ifdef DEBUG
        if (grfdebug & GDB_LOCK)
                printf("grflock(%d): dev %x flags %x lockpid %x\n",
        int error;
        extern char devioc[];
 
 #ifdef DEBUG
        if (grfdebug & GDB_LOCK)
                printf("grflock(%d): dev %x flags %x lockpid %x\n",

-                      u.u_procp->p_pid, gp-grf_softc, gp->g_flags,
+                      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)
                       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]);
+                       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
 #endif

-               gp->g_locks[0] = 0;
-               if (gp->g_locks[gp->g_lockpslot] == 0) {
+               gp->g_lock->gl_lockslot = 0;
+               if (gp->g_lock->gl_locks[gp->g_lockpslot] == 0) {

                        gp->g_lockp = NULL;
                        gp->g_lockpslot = 0;
                }
        }
 #endif
        if (gp->g_lockp) {
                        gp->g_lockp = NULL;
                        gp->g_lockpslot = 0;
                }
        }
 #endif
        if (gp->g_lockp) {

-               if (gp->g_lockp == u.u_procp)
+               if (gp->g_lockp == p)

                        return(EBUSY);
                if (!block)
                        return(EAGAIN);
                do {
                        gp->g_flags |= GF_WANTED;
                        return(EBUSY);
                if (!block)
                        return(EAGAIN);
                do {
                        gp->g_flags |= GF_WANTED;

-                       sleep((caddr_t)&gp->g_flags, PZERO+1);
-

                        if (error = tsleep((caddr_t)&gp->g_flags,
                                           (PZERO+1) | PCATCH, devioc, 0))
                                return (error);
                        if (error = tsleep((caddr_t)&gp->g_flags,
                                           (PZERO+1) | PCATCH, devioc, 0))
                                return (error);

-

                } while (gp->g_lockp);
        }
                } while (gp->g_lockp);
        }

-       gp->g_lockp = u.u_procp;
+       gp->g_lockp = p;

 #ifdef HPUXCOMPAT
        if (gp->g_pid) {
                int slot = grffindpid(gp);
 #ifdef HPUXCOMPAT
        if (gp->g_pid) {
                int slot = grffindpid(gp);


@@ -342,8 +336,8 @@ grflock(gp, block)
                if (grfdebug & GDB_LOCK)
                        printf("  slot %d\n", slot);
 #endif
                if (grfdebug & GDB_LOCK)
                        printf("  slot %d\n", slot);
 #endif

-               gp->g_lockpslot = gp->g_locks[0] = slot;
-               gp->g_locks[slot] = 1;
+               gp->g_lockpslot = gp->g_lock->gl_lockslot = slot;
+               gp->g_lock->gl_locks[slot] = 1;

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


@@ -355,21 +349,21 @@ grfunlock(gp)
 #ifdef DEBUG
        if (grfdebug & GDB_LOCK)
                printf("grfunlock(%d): dev %x flags %x lockpid %d\n",
 #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,
+                      curproc->p_pid, gp-grf_softc, gp->g_flags,

                       gp->g_lockp ? gp->g_lockp->p_pid : -1);
 #endif
                       gp->g_lockp ? gp->g_lockp->p_pid : -1);
 #endif

-       if (gp->g_lockp != u.u_procp)
+       if (gp->g_lockp != curproc)

                return(EBUSY);
 #ifdef HPUXCOMPAT
        if (gp->g_pid) {
 #ifdef DEBUG
                if (grfdebug & GDB_LOCK)
                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]);
+                       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
 #endif

-               gp->g_locks[gp->g_lockpslot] = gp->g_locks[0] = 0;
-               gp->g_lockpslot = 0;
+               gp->g_lock->gl_locks[gp->g_lockpslot] = 0;
+               gp->g_lockpslot = gp->g_lock->gl_lockslot = 0;

        }
 #endif
        if (gp->g_flags & GF_WANTED) {
        }
 #endif
        if (gp->g_flags & GF_WANTED) {


@@ -390,9 +384,10 @@ grfmap(dev, off, prot)
 #ifdef HPUXCOMPAT
 
 /*ARGSUSED*/
 #ifdef HPUXCOMPAT
 
 /*ARGSUSED*/

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

        dev_t dev;
        caddr_t data;
        dev_t dev;
        caddr_t data;

+       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;


@@ -429,14 +424,13 @@ hpuxgrfioctl(dev, cmd, data, flag)
        case GCVARIABLE_CMAP:
                break;
 
        case GCVARIABLE_CMAP:
                break;
 

-#ifdef MAPMEM

        /* 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);


@@ -447,9 +441,13 @@ hpuxgrfioctl(dev, cmd, data, flag)
                struct grf_slot *sp = (struct grf_slot *)data;
 
                sp->slot = grffindpid(gp);
                struct grf_slot *sp = (struct grf_slot *)data;
 
                sp->slot = grffindpid(gp);

-               if (sp->slot)
+               if (sp->slot) {

                        error = grflckmmap(dev, (caddr_t *)&sp->addr);
                        error = grflckmmap(dev, (caddr_t *)&sp->addr);

-               else
+                       if (error && gp->g_pid) {
+                               free((caddr_t)gp->g_pid, M_DEVBUF);
+                               gp->g_pid = NULL;
+                       }
+               } else

                        error = EINVAL;         /* XXX */
                break;
        }
                        error = EINVAL;         /* XXX */
                break;
        }


@@ -460,14 +458,22 @@ hpuxgrfioctl(dev, cmd, data, flag)
         */
        case IOMAPMAP:
                error = iommap(dev, (caddr_t *)data);
         */
        case IOMAPMAP:
                error = iommap(dev, (caddr_t *)data);

+#if 0
+               /*
+                * It may not be worth kludging this (using p_devtmp) to
+                * make this work.  It was an undocumented side-effect
+                * in HP-UX that the mapped address was the return value
+                * of the ioctl.  The only thing I remember that counted
+                * on this behavior was the rbox X10 server.
+                */

                if (!error)
                        u.u_r.r_val1 = *(int *)data;    /* XXX: this sux */
                if (!error)
                        u.u_r.r_val1 = *(int *)data;    /* XXX: this sux */

+#endif

                break;
 
        case IOMAPUNMAP:
                error = iounmmap(dev, *(caddr_t *)data);
                break;
                break;
 
        case IOMAPUNMAP:
                error = iounmmap(dev, *(caddr_t *)data);
                break;

-#endif

 
        default:
                error = EINVAL;
 
        default:
                error = EINVAL;


@@ -501,9 +507,7 @@ grfoff(dev)
        struct grf_softc *gp = &grf_softc[unit];
        int error;
 
        struct grf_softc *gp = &grf_softc[unit];
        int error;
 

-#ifdef MAPMEM
-       (void) grfunmmap(dev, (caddr_t)0);
-#endif
+       (void) grfunmmap(dev, (caddr_t)0, curproc);

        error = (*grfdev[gp->g_type].gd_mode)
                        (gp, (dev&GRFOVDEV) ? GM_GRFOVOFF : GM_GRFOFF);
        /* XXX: see comment for iteoff above */
        error = (*grfdev[gp->g_type].gd_mode)
                        (gp, (dev&GRFOVDEV) ? GM_GRFOVOFF : GM_GRFOFF);
        /* XXX: see comment for iteoff above */


@@ -515,7 +519,6 @@ grfaddr(gp, off)
        struct grf_softc *gp;
        register int off;
 {
        struct grf_softc *gp;
        register int off;
 {

-#ifdef MAPMEM

        register struct grfinfo *gi = &gp->g_display;
 
        /* control registers */
        register struct grfinfo *gi = &gp->g_display;
 
        /* control registers */


@@ -527,7 +530,6 @@ grfaddr(gp, off)
                off -= gi->gd_regsize;
                return(((u_int)gi->gd_fbaddr + off) >> PGSHIFT);
        }
                off -= gi->gd_regsize;
                return(((u_int)gi->gd_fbaddr + off) >> PGSHIFT);
        }

-#endif

        /* bogus */
        return(-1);
 }
        /* bogus */
        return(-1);
 }


@@ -545,20 +547,17 @@ grfdevno(dev)
 {
        int unit = GRFUNIT(dev);
        struct grf_softc *gp = &grf_softc[unit];
 {
        int unit = GRFUNIT(dev);
        struct grf_softc *gp = &grf_softc[unit];

-       int newdev;
+       int newdev, sc;

 
        if (unit >= NGRF || (gp->g_flags&GF_ALIVE) == 0)
                return(bsdtohpuxdev(dev));
        /* magic major number */
        newdev = 12 << 24;
        /* now construct minor number */
 
        if (unit >= NGRF || (gp->g_flags&GF_ALIVE) == 0)
                return(bsdtohpuxdev(dev));
        /* magic major number */
        newdev = 12 << 24;
        /* now construct minor number */

-#if defined(HP360) || defined(HP370)
-       if (gp->g_display.gd_regaddr == (caddr_t)DIOIIBASE)
-               newdev |= 0x840200;
-       else
-#endif
-       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) {
+               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)


@@ -571,82 +570,53 @@ grfdevno(dev)
 }
 #endif
 
 }
 #endif
 

-#ifdef MAPMEM
-grfmapin(mp, off)
-       struct mapmem *mp;
-{
-       return(grfaddr(&grf_softc[GRFUNIT(mp->mm_id)], off));
-}
-
-grfmmap(dev, addrp)
+grfmmap(dev, addrp, p)

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

+       struct proc *p;

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

-       register struct mapmem *mp;
-       int len, grfmapin();
+       int len, error;
+       struct vnode vn;
+       struct specinfo si;
+       int flags;

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

-               printf("grfmmap(%d): addr %x\n", u.u_procp->p_pid, *addrp);
+               printf("grfmmap(%d): addr %x\n", p->p_pid, *addrp);

 #endif
        len = gp->g_display.gd_regsize + gp->g_display.gd_fbsize;
 #endif
        len = gp->g_display.gd_regsize + gp->g_display.gd_fbsize;

-       mp = mmalloc(minor(dev), addrp, len, MM_RW|MM_CI|MM_NOCORE, &grfops);
-       if (mp == MMNIL)
-               return(u.u_error);
-       if (!mmmapin(mp, grfmapin)) {
-               mmfree(mp);
-               return(u.u_error);
-       }
-       return(0);
+       flags = MAP_FILE|MAP_SHARED;
+       if (*addrp)
+               flags |= MAP_FIXED;
+       else
+               *addrp = (caddr_t)0x1000000;    /* XXX */
+       vn.v_type = VCHR;                       /* XXX */
+       vn.v_specinfo = &si;                    /* XXX */
+       vn.v_rdev = dev;                        /* XXX */
+       error = vm_mmap(&p->p_vmspace->vm_map, (vm_offset_t *)addrp,
+                       (vm_size_t)len, VM_PROT_ALL, flags, (caddr_t)&vn, 0);
+       return(error);

 }
 
 }
 

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

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

+       struct proc *p;

 {
 {

-       register struct mapmem *mp, **mpp;
-       int found, unit = minor(dev);
-
-#ifdef DEBUG
-       if (grfdebug & GDB_MMAP)
-               printf("grfunmmap(%d): id %d addr %x\n",
-                      u.u_procp->p_pid, unit, addr);
-#endif
-       found = 0;
-       mpp = &u.u_mmap;
-       for (mp = *mpp; mp; mp = *mpp) {
-               if (mp->mm_ops != &grfops || mp->mm_id != unit) {
-                       mpp = &mp->mm_next;
-                       continue;
-               }
-               if (addr &&
-                   (addr < mp->mm_uva || addr >= mp->mm_uva+mp->mm_size)) {
-                       mpp = &mp->mm_next;
-                       continue;
-               }
-               grfexit(mp);
-               found++;
-       }
-       return(found ? 0 : EINVAL);
-}
-
-grfexit(mp)
-       struct mapmem *mp;
-{
-       struct grf_softc *gp = &grf_softc[GRFUNIT(mp->mm_id)];
+       struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
+       vm_size_t size;
+       int rv;

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

-               printf("grfexit(%d): id %d %x@%x\n",
-                      u.u_procp->p_pid, mp->mm_id, mp->mm_size, mp->mm_uva);
-#endif
-       (void) grfunlock(gp);
-#ifdef HPUXCOMPAT
-       grfrmpid(gp);
+               printf("grfunmmap(%d): dev %x addr %x\n", p->p_pid, dev, addr);

 #endif
 #endif

-       mmmapout(mp);
-       mmfree(mp);
+       if (addr == 0)
+               return(EINVAL);         /* XXX: how do we deal with this? */
+       size = round_page(gp->g_display.gd_regsize + gp->g_display.gd_fbsize);
+       rv = vm_deallocate(&p->p_vmspace->vm_map, (vm_offset_t)addr, size);
+       return(rv == KERN_SUCCESS ? 0 : EINVAL);

 }
 
 #ifdef HPUXCOMPAT
 }
 
 #ifdef HPUXCOMPAT


@@ -654,56 +624,28 @@ iommap(dev, addrp)
        dev_t dev;
        caddr_t *addrp;
 {
        dev_t dev;
        caddr_t *addrp;
 {

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

        struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
        struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];

-       register struct mapmem *mp;
-       int len, grfmapin();

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

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

 #endif
 #endif

-       len = gp->g_display.gd_regsize;
-       mp = mmalloc(minor(dev), addrp, len, MM_RW|MM_CI|MM_NOCORE, &grfiomops);
-       if (mp == MMNIL)
-               return(u.u_error);
-       if (!mmmapin(mp, grfmapin)) {
-               mmfree(mp);
-               return(u.u_error);
-       }
-       return(0);
+       return(EINVAL);

 }
 
 iounmmap(dev, addr)
        dev_t dev;
        caddr_t addr;
 {
 }
 
 iounmmap(dev, addr)
        dev_t dev;
        caddr_t addr;
 {

-       struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
-       register struct mapmem *mp, **mpp;
-       int found, len, unit = minor(dev);
+       int unit = minor(dev);

 
 #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
 #endif

-       found = 0;
-       len = gp->g_display.gd_regsize;
-       mpp = &u.u_mmap;
-       for (mp = *mpp; mp; mp = *mpp) {
-               if (mp->mm_ops != &grfiomops || mp->mm_id != unit) {
-                       mpp = &mp->mm_next;
-                       continue;
-               }
-               if (addr &&
-                   (addr < mp->mm_uva || addr >= mp->mm_uva+mp->mm_size ||
-                   len != mp->mm_size)) {
-                       mpp = &mp->mm_next;
-                       continue;
-               }
-               grfexit(mp);
-               found++;
-       }
-       return(found ? 0 : EINVAL);
+       return(0);

 }
 
 /*
 }
 
 /*


@@ -725,7 +667,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)


@@ -760,7 +702,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++) {


@@ -779,68 +721,33 @@ grfrmpid(gp)
 #endif
 }
 
 #endif
 }
 

-/*ARGSUSED*/
-grflckmapin(mp, off)
-       struct mapmem *mp;
-{
-       u_int pa = kvtop((u_int)grf_softc[GRFUNIT(mp->mm_id)].g_locks);
-
-#ifdef DEBUG
-       if (grfdebug & GDB_LOCK)
-               printf("grflckmapin(%d): va %x pa %x\n", u.u_procp->p_pid,
-                      grf_softc[GRFUNIT(mp->mm_id)].g_locks, pa);
-#endif
-       return(pa >> PGSHIFT);
-}
-

 grflckmmap(dev, addrp)
        dev_t dev;
        caddr_t *addrp;
 {
 grflckmmap(dev, addrp)
        dev_t dev;
        caddr_t *addrp;
 {

-       struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
-       register struct mapmem *mp;
-       int grflckmapin();
-

 #ifdef DEBUG
 #ifdef DEBUG

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

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

-                      u.u_procp->p_pid, *addrp);
+                      p->p_pid, *addrp);

 #endif
 #endif

-       if (gp->g_locks == NULL) {
-               gp->g_locks = (u_char *) cialloc(NBPG);
-               if (gp->g_locks == NULL)
-                       return(ENOMEM);
-       }
-       mp = mmalloc(minor(dev), addrp, NBPG, MM_RW|MM_CI, &grflckops);
-       if (mp == MMNIL)
-               return(u.u_error);
-       if (!mmmapin(mp, grflckmapin)) {
-               mmfree(mp);
-               return(u.u_error);
-       }
-       return(0);
+       return(EINVAL);

 }
 
 grflckunmmap(dev, addr)
        dev_t dev;
        caddr_t addr;
 {
 }
 
 grflckunmmap(dev, addr)
        dev_t dev;
        caddr_t addr;
 {

-       register struct mapmem *mp;
+#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
 #endif

-       for (mp = u.u_mmap; mp; mp = mp->mm_next)
-               if (mp->mm_ops == &grflckops && mp->mm_id == unit &&
-                   mp->mm_uva == addr) {
-                       grfexit(mp);
-                       return(0);
-               }

        return(EINVAL);
 }
 #endif /* HPUXCOMPAT */
        return(EINVAL);
 }
 #endif /* HPUXCOMPAT */

-#endif /* MAPMEM */
+

 #endif /* NGRF > 0 */
 #endif /* NGRF > 0 */