Home | History | Annotate | Line # | Download | only in dev
grf.c revision 1.12 
      1 /*	$NetBSD: grf.c,v 1.12 1998/10/11 23:21:03 chuck Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1988 University of Utah.
      5  * Copyright (c) 1990, 1993
      6  *	The Regents of the University of California.  All rights reserved.
      7  *
      8  * This code is derived from software contributed to Berkeley by
      9  * the Systems Programming Group of the University of Utah Computer
     10  * Science Department.
     11  *
     12  * Redistribution and use in source and binary forms, with or without
     13  * modification, are permitted provided that the following conditions
     14  * are met:
     15  * 1. Redistributions of source code must retain the above copyright
     16  *    notice, this list of conditions and the following disclaimer.
     17  * 2. Redistributions in binary form must reproduce the above copyright
     18  *    notice, this list of conditions and the following disclaimer in the
     19  *    documentation and/or other materials provided with the distribution.
     20  * 3. All advertising materials mentioning features or use of this software
     21  *    must display the following acknowledgement:
     22  *	This product includes software developed by the University of
     23  *	California, Berkeley and its contributors.
     24  * 4. Neither the name of the University nor the names of its contributors
     25  *    may be used to endorse or promote products derived from this software
     26  *    without specific prior written permission.
     27  *
     28  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     29  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     32  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     34  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     36  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     37  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     38  * SUCH DAMAGE.
     39  *
     40  * from: Utah $Hdr: grf.c 1.36 93/08/13$
     41  *
     42  *	@(#)grf.c	8.4 (Berkeley) 1/12/94
     43  */
     44 
     45 /*
     46  * Graphics display driver for the X68K machines.
     47  * This is the hardware-independent portion of the driver.
     48  * Hardware access is through the machine dependent grf switch routines.
     49  */
     50 
     51 #include "opt_uvm.h"
     52 #include "opt_compat_hpux.h"
     53 
     54 #include <sys/param.h>
     55 #include <sys/systm.h>
     56 #include <sys/device.h>
     57 #include <sys/proc.h>
     58 #include <sys/ioctl.h>
     59 #include <sys/file.h>
     60 #include <sys/malloc.h>
     61 #include <sys/vnode.h>
     62 #include <sys/mman.h>
     63 #include <sys/poll.h>
     64 #include <sys/conf.h>
     65 
     66 #include <machine/grfioctl.h>
     67 
     68 #include <x68k/dev/grfvar.h>
     69 #include <x68k/dev/itevar.h>
     70 
     71 #include <machine/cpu.h>
     72 
     73 #ifdef COMPAT_HPUX
     74 #include <compat/hpux/hpux.h>
     75 extern struct emul emul_hpux;
     76 #endif
     77 
     78 #include <vm/vm.h>
     79 #include <vm/vm_kern.h>
     80 #include <vm/vm_page.h>
     81 #include <vm/vm_pager.h>
     82 
     83 #if defined(UVM)
     84 #include <uvm/uvm.h>
     85 #endif
     86 
     87 #include <miscfs/specfs/specdev.h>
     88 
     89 #include "ite.h"
     90 #if NITE == 0
     91 #define	iteon(u,f)
     92 #define	iteoff(u,f)
     93 #define	ite_reinit(u)
     94 #endif
     95 
     96 #ifdef DEBUG
     97 int grfdebug = 0;
     98 #define GDB_DEVNO	0x01
     99 #define GDB_MMAP	0x02
    100 #define GDB_IOMAP	0x04
    101 #define GDB_LOCK	0x08
    102 #endif
    103 
    104 cdev_decl(grf);
    105 int grfon __P((dev_t));
    106 int grfoff __P((dev_t));
    107 int grfaddr __P((struct grf_softc *, int));
    108 int grfmap __P((dev_t, caddr_t *, struct proc *));
    109 int grfunmap __P((dev_t, caddr_t, struct proc *));
    110 
    111 extern struct cfdriver grf_cd;
    112 
    113 /*ARGSUSED*/
    114 int
    115 grfopen(dev, flags, mode, p)
    116 	dev_t dev;
    117 	int flags, mode;
    118 	struct proc *p;
    119 {
    120 	int unit = GRFUNIT(dev);
    121 	register struct grf_softc *gp;
    122 	int error = 0;
    123 
    124 	if (unit >= grf_cd.cd_ndevs ||
    125 	    (gp = grf_cd.cd_devs[unit]) == NULL ||
    126 	    (gp->g_flags & GF_ALIVE) == 0)
    127 		return (ENXIO);
    128 
    129 	if ((gp->g_flags & (GF_OPEN|GF_EXCLUDE)) == (GF_OPEN|GF_EXCLUDE))
    130 		return(EBUSY);
    131 #ifdef COMPAT_HPUX
    132 	/*
    133 	 * XXX: cannot handle both HPUX and BSD processes at the same time
    134 	 */
    135 	if (p->p_emul == &emul_hpux)
    136 		if (gp->g_flags & GF_BSDOPEN)
    137 			return(EBUSY);
    138 		else
    139 			gp->g_flags |= GF_HPUXOPEN;
    140 	else
    141 		if (gp->g_flags & GF_HPUXOPEN)
    142 			return(EBUSY);
    143 		else
    144 			gp->g_flags |= GF_BSDOPEN;
    145 #endif
    146 	/*
    147 	 * First open.
    148 	 * XXX: always put in graphics mode.
    149 	 */
    150 	error = 0;
    151 	if ((gp->g_flags & GF_OPEN) == 0) {
    152 		gp->g_flags |= GF_OPEN;
    153 		error = grfon(dev);
    154 	}
    155 	return(error);
    156 }
    157 
    158 /*ARGSUSED*/
    159 int
    160 grfclose(dev, flags, mode, p)
    161 	dev_t dev;
    162 	int flags, mode;
    163 	struct proc *p;
    164 {
    165 	register struct grf_softc *gp = grf_cd.cd_devs[GRFUNIT(dev)];
    166 
    167 	if ((gp->g_flags & GF_ALIVE) == 0)
    168 		return (ENXIO);
    169 
    170 	(void) grfoff(dev);
    171 #ifdef COMPAT_HPUX
    172 	(void) grfunlock(gp);
    173 #endif
    174 	gp->g_flags &= GF_ALIVE;
    175 	return(0);
    176 }
    177 
    178 /*ARGSUSED*/
    179 int
    180 grfioctl(dev, cmd, data, flag, p)
    181 	dev_t dev;
    182 	u_long cmd;
    183 	caddr_t data;
    184 	int flag;
    185 	struct proc *p;
    186 {
    187 	int unit = GRFUNIT(dev);
    188 	register struct grf_softc *gp = grf_cd.cd_devs[unit];
    189 	int error;
    190 
    191 	if ((gp->g_flags & GF_ALIVE) == 0)
    192 		return (ENXIO);
    193 
    194 #ifdef COMPAT_HPUX
    195 	if (p->p_emul == &emul_hpux)
    196 		return(hpuxgrfioctl(dev, cmd, data, flag, p));
    197 #endif
    198 	error = 0;
    199 	switch (cmd) {
    200 
    201 	case GRFIOCGINFO:
    202 		bcopy((caddr_t)&gp->g_display, data, sizeof(struct grfinfo));
    203 		break;
    204 
    205 	case GRFIOCON:
    206 		error = grfon(dev);
    207 		break;
    208 
    209 	case GRFIOCOFF:
    210 		error = grfoff(dev);
    211 		break;
    212 
    213 	case GRFIOCMAP:
    214 		error = grfmap(dev, (caddr_t *)data, p);
    215 		break;
    216 
    217 	case GRFIOCUNMAP:
    218 		error = grfunmap(dev, *(caddr_t *)data, p);
    219 		break;
    220 
    221 	case GRFSETVMODE:
    222 		error = (*gp->g_sw->gd_mode)(gp, GM_GRFSETVMODE, data);
    223 		if (error == 0)
    224 			ite_reinit(unit);
    225 		break;
    226 
    227 	default:
    228 		error = EINVAL;
    229 		break;
    230 
    231 	}
    232 	return(error);
    233 }
    234 
    235 /*ARGSUSED*/
    236 int
    237 grfpoll(dev, events, p)
    238 	dev_t dev;
    239 	int events;
    240 	struct proc *p;
    241 {
    242 
    243 	return (events & (POLLOUT | POLLWRNORM));
    244 }
    245 
    246 /*ARGSUSED*/
    247 int
    248 grfmmap(dev, off, prot)
    249 	dev_t dev;
    250 	int off, prot;
    251 {
    252 
    253 	return (grfaddr(grf_cd.cd_devs[GRFUNIT(dev)], off));
    254 }
    255 
    256 int
    257 grfon(dev)
    258 	dev_t dev;
    259 {
    260 	int unit = GRFUNIT(dev);
    261 	struct grf_softc *gp = grf_cd.cd_devs[unit];
    262 
    263 	/*
    264 	 * XXX: iteoff call relies on devices being in same order
    265 	 * as ITEs and the fact that iteoff only uses the minor part
    266 	 * of the dev arg.
    267 	 */
    268 	iteoff(unit, 2);
    269 	return((*gp->g_sw->gd_mode)(gp,
    270 				    (dev&GRFOVDEV) ? GM_GRFOVON : GM_GRFON,
    271 				    (caddr_t)0));
    272 }
    273 
    274 int
    275 grfoff(dev)
    276 	dev_t dev;
    277 {
    278 	int unit = GRFUNIT(dev);
    279 	struct grf_softc *gp = grf_cd.cd_devs[unit];
    280 	int error;
    281 
    282 	(void) grfunmap(dev, (caddr_t)0, curproc);
    283 	error = (*gp->g_sw->gd_mode)(gp,
    284 				     (dev&GRFOVDEV) ? GM_GRFOVOFF : GM_GRFOFF,
    285 				     (caddr_t)0);
    286 	/* XXX: see comment for iteoff above */
    287 	iteon(unit, 2);
    288 	return(error);
    289 }
    290 
    291 int
    292 grfaddr(gp, off)
    293 	struct grf_softc *gp;
    294 	register int off;
    295 {
    296 	register struct grfinfo *gi = &gp->g_display;
    297 
    298 	/* control registers */
    299 	if (off >= 0 && off < gi->gd_regsize)
    300 		return(((u_int)gi->gd_regaddr + off) >> PGSHIFT);
    301 
    302 	/* frame buffer */
    303 	if (off >= gi->gd_regsize && off < gi->gd_regsize+gi->gd_fbsize) {
    304 		off -= gi->gd_regsize;
    305 		return(((u_int)gi->gd_fbaddr + off) >> PGSHIFT);
    306 	}
    307 	/* bogus */
    308 	return(-1);
    309 }
    310 
    311 /*
    312  * HP-UX compatibility routines
    313  */
    314 #ifdef COMPAT_HPUX
    315 
    316 /*ARGSUSED*/
    317 int
    318 hpuxgrfioctl(dev, cmd, data, flag, p)
    319 	dev_t dev;
    320 	int cmd;
    321 	caddr_t data;
    322 	int flag;
    323 	struct proc *p;
    324 {
    325 	register struct grf_softc *gp = grf_cd.cd_devs[GRFUNIT(dev)];
    326 	int error;
    327 
    328 	error = 0;
    329 	switch (cmd) {
    330 
    331 	case GCID:
    332 		*(int *)data = gp->g_display.gd_id;
    333 		break;
    334 
    335 	case GCON:
    336 		error = grfon(dev);
    337 		break;
    338 
    339 	case GCOFF:
    340 		error = grfoff(dev);
    341 		break;
    342 
    343 	case GCLOCK:
    344 		error = grflock(gp, 1);
    345 		break;
    346 
    347 	case GCUNLOCK:
    348 		error = grfunlock(gp);
    349 		break;
    350 
    351 	case GCAON:
    352 	case GCAOFF:
    353 		break;
    354 
    355 	/* GCSTATIC is implied by our implementation */
    356 	case GCSTATIC_CMAP:
    357 	case GCVARIABLE_CMAP:
    358 		break;
    359 
    360 	/* map in control regs and frame buffer */
    361 	case GCMAP:
    362 		error = grfmap(dev, (caddr_t *)data, p);
    363 		break;
    364 
    365 	case GCUNMAP:
    366 		error = grfunmap(dev, *(caddr_t *)data, p);
    367 		/* XXX: HP-UX uses GCUNMAP to get rid of GCSLOT memory */
    368 		if (error)
    369 			error = grflckunmmap(dev, *(caddr_t *)data);
    370 		break;
    371 
    372 	case GCSLOT:
    373 	{
    374 		struct grf_slot *sp = (struct grf_slot *)data;
    375 
    376 		sp->slot = grffindpid(gp);
    377 		if (sp->slot) {
    378 			error = grflckmmap(dev, (caddr_t *)&sp->addr);
    379 			if (error && gp->g_pid) {
    380 				free((caddr_t)gp->g_pid, M_DEVBUF);
    381 				gp->g_pid = NULL;
    382 			}
    383 		} else
    384 			error = EINVAL;		/* XXX */
    385 		break;
    386 	}
    387 
    388 	case GCDESCRIBE:
    389 		error = (*gp->g_sw->gd_mode)(gp, GM_DESCRIBE, data);
    390 		break;
    391 
    392 	/*
    393 	 * XXX: only used right now to map in rbox control registers
    394 	 * Will be replaced in the future with a real IOMAP interface.
    395 	 */
    396 	case IOMAPMAP:
    397 		error = iommap(dev, (caddr_t *)data);
    398 #if 0
    399 		/*
    400 		 * It may not be worth kludging this (using p_devtmp) to
    401 		 * make this work.  It was an undocumented side-effect
    402 		 * in HP-UX that the mapped address was the return value
    403 		 * of the ioctl.  The only thing I remember that counted
    404 		 * on this behavior was the rbox X10 server.
    405 		 */
    406 		if (!error)
    407 			u.u_r.r_val1 = *(int *)data;	/* XXX: this sux */
    408 #endif
    409 		break;
    410 
    411 	case IOMAPUNMAP:
    412 		error = iounmmap(dev, *(caddr_t *)data);
    413 		break;
    414 
    415 	default:
    416 		error = EINVAL;
    417 		break;
    418 	}
    419 	return(error);
    420 }
    421 
    422 int
    423 grflock(gp, block)
    424 	register struct grf_softc *gp;
    425 	int block;
    426 {
    427 	struct proc *p = curproc;		/* XXX */
    428 	int error;
    429 	extern char devioc[];
    430 
    431 #ifdef DEBUG
    432 	if (grfdebug & GDB_LOCK)
    433 		printf("grflock(%d): flags %x lockpid %x\n",
    434 		       p->p_pid, gp->g_flags,
    435 		       gp->g_lockp ? gp->g_lockp->p_pid : -1);
    436 #endif
    437 	if (gp->g_pid) {
    438 #ifdef DEBUG
    439 		if (grfdebug & GDB_LOCK)
    440 			printf(" lockpslot %d lockslot %d lock[lockslot] %d\n",
    441 			       gp->g_lock->gl_lockslot, gp->g_lockpslot,
    442 			       gp->g_lock->gl_locks[gp->g_lockpslot]);
    443 #endif
    444 		gp->g_lock->gl_lockslot = 0;
    445 		if (gp->g_lock->gl_locks[gp->g_lockpslot] == 0) {
    446 			gp->g_lockp = NULL;
    447 			gp->g_lockpslot = 0;
    448 		}
    449 	}
    450 	if (gp->g_lockp) {
    451 		if (gp->g_lockp == p)
    452 			return(EBUSY);
    453 		if (!block)
    454 			return(OEAGAIN);
    455 		do {
    456 			gp->g_flags |= GF_WANTED;
    457 			if ((error = tsleep((caddr_t)&gp->g_flags,
    458 					   (PZERO+1) | PCATCH, devioc, 0)))
    459 				return (error);
    460 		} while (gp->g_lockp);
    461 	}
    462 	gp->g_lockp = p;
    463 	if (gp->g_pid) {
    464 		int slot = grffindpid(gp);
    465 
    466 #ifdef DEBUG
    467 		if (grfdebug & GDB_LOCK)
    468 			printf("  slot %d\n", slot);
    469 #endif
    470 		gp->g_lockpslot = gp->g_lock->gl_lockslot = slot;
    471 		gp->g_lock->gl_locks[slot] = 1;
    472 	}
    473 	return(0);
    474 }
    475 
    476 int
    477 grfunlock(gp)
    478 	register struct grf_softc *gp;
    479 {
    480 #ifdef DEBUG
    481 	if (grfdebug & GDB_LOCK)
    482 		printf("grfunlock(%d): flags %x lockpid %d\n",
    483 		       curproc->p_pid, gp->g_flags,
    484 		       gp->g_lockp ? gp->g_lockp->p_pid : -1);
    485 #endif
    486 	if (gp->g_lockp != curproc)
    487 		return(EBUSY);
    488 	if (gp->g_pid) {
    489 #ifdef DEBUG
    490 		if (grfdebug & GDB_LOCK)
    491 			printf(" lockpslot %d lockslot %d lock[lockslot] %d\n",
    492 			       gp->g_lock->gl_lockslot, gp->g_lockpslot,
    493 			       gp->g_lock->gl_locks[gp->g_lockpslot]);
    494 #endif
    495 		gp->g_lock->gl_locks[gp->g_lockpslot] = 0;
    496 		gp->g_lockpslot = gp->g_lock->gl_lockslot = 0;
    497 	}
    498 	if (gp->g_flags & GF_WANTED) {
    499 		wakeup((caddr_t)&gp->g_flags);
    500 		gp->g_flags &= ~GF_WANTED;
    501 	}
    502 	gp->g_lockp = NULL;
    503 	return(0);
    504 }
    505 
    506 /*
    507  * Convert a BSD style minor devno to HPUX style.
    508  * We cannot just create HPUX style nodes as they require 24 bits
    509  * of minor device number and we only have 8.
    510  * XXX: This may give the wrong result for remote stats of other
    511  * machines where device 10 exists.
    512  */
    513 int
    514 grfdevno(dev)
    515 	dev_t dev;
    516 {
    517 	int unit = GRFUNIT(dev);
    518 	struct grf_softc *gp;
    519 	int newdev;
    520 
    521 	if (unit >= grf_cd.cd_ndevs ||
    522 	    (gp = grf_cd.cd_devs[unit]) == NULL ||
    523 	    (gp->g_flags&GF_ALIVE) == 0)
    524 		return(bsdtohpuxdev(dev));
    525 	/* magic major number */
    526 	newdev = 12 << 24;
    527 	/* now construct minor number */
    528 	if (gp->g_display.gd_regaddr != (caddr_t)GRFIADDR) {
    529 		int sc = patosc(gp->g_display.gd_regaddr);
    530 		newdev |= (sc << 16) | 0x200;
    531 	}
    532 	if (dev & GRFIMDEV)
    533 		newdev |= 0x02;
    534 	else if (dev & GRFOVDEV)
    535 		newdev |= 0x01;
    536 #ifdef DEBUG
    537 	if (grfdebug & GDB_DEVNO)
    538 		printf("grfdevno: dev %x newdev %x\n", dev, newdev);
    539 #endif
    540 	return(newdev);
    541 }
    542 
    543 #endif	/* COMPAT_HPUX */
    544 
    545 int
    546 grfmap(dev, addrp, p)
    547 	dev_t dev;
    548 	caddr_t *addrp;
    549 	struct proc *p;
    550 {
    551 	struct grf_softc *gp = grf_cd.cd_devs[GRFUNIT(dev)];
    552 	int len, error;
    553 	struct vnode vn;
    554 	struct specinfo si;
    555 	int flags;
    556 
    557 #ifdef DEBUG
    558 	if (grfdebug & GDB_MMAP)
    559 		printf("grfmap(%d): addr %p\n", p->p_pid, *addrp);
    560 #endif
    561 	len = gp->g_display.gd_regsize + gp->g_display.gd_fbsize;
    562 	flags = MAP_SHARED;
    563 	if (*addrp)
    564 		flags |= MAP_FIXED;
    565 	else
    566 		*addrp = (caddr_t)0x1000000;	/* XXX */
    567 	vn.v_type = VCHR;			/* XXX */
    568 	vn.v_specinfo = &si;			/* XXX */
    569 	vn.v_rdev = dev;			/* XXX */
    570 #if defined(UVM)
    571 	error = uvm_mmap(&p->p_vmspace->vm_map, (vaddr_t *)addrp,
    572 			 (vsize_t)len, VM_PROT_ALL, VM_PROT_ALL,
    573 			 flags, (caddr_t)&vn, 0);
    574 #else
    575 	error = vm_mmap(&p->p_vmspace->vm_map, (vaddr_t *)addrp,
    576 			(vsize_t)len, VM_PROT_ALL, VM_PROT_ALL,
    577 			flags, (caddr_t)&vn, 0);
    578 #endif
    579 	if (error == 0)
    580 		(void) (*gp->g_sw->gd_mode)(gp, GM_MAP, *addrp);
    581 	return(error);
    582 }
    583 
    584 int
    585 grfunmap(dev, addr, p)
    586 	dev_t dev;
    587 	caddr_t addr;
    588 	struct proc *p;
    589 {
    590 	struct grf_softc *gp = grf_cd.cd_devs[GRFUNIT(dev)];
    591 	vsize_t size;
    592 	int rv;
    593 
    594 #ifdef DEBUG
    595 	if (grfdebug & GDB_MMAP)
    596 		printf("grfunmap(%d): dev %x addr %p\n", p->p_pid, dev, addr);
    597 #endif
    598 	if (addr == 0)
    599 		return(EINVAL);		/* XXX: how do we deal with this? */
    600 	(void) (*gp->g_sw->gd_mode)(gp, GM_UNMAP, 0);
    601 	size = round_page(gp->g_display.gd_regsize + gp->g_display.gd_fbsize);
    602 #if defined(UVM)
    603 	rv = uvm_unmap(&p->p_vmspace->vm_map, (vaddr_t)addr,
    604 	    (vaddr_t)addr + size);
    605 #else
    606 	rv = vm_deallocate(&p->p_vmspace->vm_map, (vaddr_t)addr, size);
    607 #endif
    608 	return(rv == KERN_SUCCESS ? 0 : EINVAL);
    609 }
    610 
    611 #ifdef COMPAT_HPUX
    612 int
    613 iommap(dev, addrp)
    614 	dev_t dev;
    615 	caddr_t *addrp;
    616 {
    617 
    618 #ifdef DEBUG
    619 	if (grfdebug & (GDB_MMAP|GDB_IOMAP))
    620 		printf("iommap(%d): addr %p\n", curproc->p_pid, *addrp);
    621 #endif
    622 	return(EINVAL);
    623 }
    624 
    625 int
    626 iounmmap(dev, addr)
    627 	dev_t dev;
    628 	caddr_t addr;
    629 {
    630 #ifdef DEBUG
    631 	int unit = minor(dev);
    632 
    633 	if (grfdebug & (GDB_MMAP|GDB_IOMAP))
    634 		printf("iounmmap(%d): id %d addr %p\n",
    635 		       curproc->p_pid, unit, addr);
    636 #endif
    637 	return(0);
    638 }
    639 
    640 /*
    641  * Processes involved in framebuffer mapping via GCSLOT are recorded in
    642  * an array of pids.  The first element is used to record the last slot used
    643  * (for faster lookups).  The remaining elements record up to GRFMAXLCK-1
    644  * process ids.  Returns a slot number between 1 and GRFMAXLCK or 0 if no
    645  * slot is available.
    646  */
    647 int
    648 grffindpid(gp)
    649 	struct grf_softc *gp;
    650 {
    651 	register short pid, *sp;
    652 	register int i, limit;
    653 	int ni;
    654 
    655 	if (gp->g_pid == NULL) {
    656 		gp->g_pid = (short *)
    657 			malloc(GRFMAXLCK * sizeof(short), M_DEVBUF, M_WAITOK);
    658 		bzero((caddr_t)gp->g_pid, GRFMAXLCK * sizeof(short));
    659 	}
    660 	pid = curproc->p_pid;
    661 	ni = limit = gp->g_pid[0];
    662 	for (i = 1, sp = &gp->g_pid[1]; i <= limit; i++, sp++) {
    663 		if (*sp == pid)
    664 			goto done;
    665 		if (*sp == 0)
    666 			ni = i;
    667 	}
    668 	i = ni;
    669 	if (i < limit) {
    670 		gp->g_pid[i] = pid;
    671 		goto done;
    672 	}
    673 	if (++i == GRFMAXLCK)
    674 		return(0);
    675 	gp->g_pid[0] = i;
    676 	gp->g_pid[i] = pid;
    677 done:
    678 #ifdef DEBUG
    679 	if (grfdebug & GDB_LOCK)
    680 		printf("grffindpid(%d): slot %d of %d\n",
    681 		       pid, i, gp->g_pid[0]);
    682 #endif
    683 	return(i);
    684 }
    685 
    686 void
    687 grfrmpid(gp)
    688 	struct grf_softc *gp;
    689 {
    690 	register short pid, *sp;
    691 	register int limit, i;
    692 	int mi;
    693 
    694 	if (gp->g_pid == NULL || (limit = gp->g_pid[0]) == 0)
    695 		return;
    696 	pid = curproc->p_pid;
    697 	limit = gp->g_pid[0];
    698 	mi = 0;
    699 	for (i = 1, sp = &gp->g_pid[1]; i <= limit; i++, sp++) {
    700 		if (*sp == pid)
    701 			*sp = 0;
    702 		else if (*sp)
    703 			mi = i;
    704 	}
    705 	i = mi;
    706 	if (i < limit)
    707 		gp->g_pid[0] = i;
    708 #ifdef DEBUG
    709 	if (grfdebug & GDB_LOCK)
    710 		printf("grfrmpid(%d): slot %d of %d\n",
    711 		       pid, sp-gp->g_pid, gp->g_pid[0]);
    712 #endif
    713 }
    714 
    715 int
    716 grflckmmap(dev, addrp)
    717 	dev_t dev;
    718 	caddr_t *addrp;
    719 {
    720 #ifdef DEBUG
    721 	struct proc *p = curproc;		/* XXX */
    722 
    723 	if (grfdebug & (GDB_MMAP|GDB_LOCK))
    724 		printf("grflckmmap(%d): addr %p\n",
    725 		       p->p_pid, *addrp);
    726 #endif
    727 	return(EINVAL);
    728 }
    729 
    730 int
    731 grflckunmmap(dev, addr)
    732 	dev_t dev;
    733 	caddr_t addr;
    734 {
    735 #ifdef DEBUG
    736 	int unit = minor(dev);
    737 
    738 	if (grfdebug & (GDB_MMAP|GDB_LOCK))
    739 		printf("grflckunmmap(%d): id %d addr %p\n",
    740 		       curproc->p_pid, unit, addr);
    741 #endif
    742 	return(EINVAL);
    743 }
    744 #endif	/* COMPAT_HPUX */
    745