/* * Copyright (c) 1988 University of Utah. * Copyright (c) 1990 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 * Science Department. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * from: Utah $Hdr: grf.c 1.31 91/01/21$ * * from: from: from: from: @(#)grf.c 7.8 (Berkeley) 5/7/91 * $Id: grf.c,v 1.4 1994/01/30 01:15:31 briggs Exp $ */ /* * Graphics display driver for the HP300. * This is the hardware-independent portion of the driver. * Hardware access is through the grfdev routines below. */ #define DEBUG 1 #include "grf.h" #if NGRF > 0 #include #include "param.h" #include "proc.h" #include "ioctl.h" #include "file.h" #include "malloc.h" #include #include "nubus.h" #include "grfioctl.h" #include "grfvar.h" #include #include #include #include #include #include #include #include #include "ite.h" #if NITE == 0 #define iteon(u,f) #define iteoff(u,f) #endif int grfprobe(); int macvideo_init(), macvideo_mode(); struct grfdev grfdev[] = { GID_MAC, GRFMAC, macvideo_init, macvideo_mode, "MacVideo", }; int ngrfdev = sizeof(grfdev) / sizeof(grfdev[0]); /* struct driver grfdriver = { grfprobe, "grf" }; */ struct grf_softc grf_softc[NGRF]; int gNumGrfDev=0; #ifdef DEBUG int grfdebug = 0xff; #define GDB_DEVNO 0x01 #define GDB_MMAP 0x02 #define GDB_IOMAP 0x04 #define GDB_LOCK 0x08 #endif /* * XXX: called from ite console init routine. * Does just what configure will do later but without printing anything. MF maybe i'll call this from larrys console stuff */ grfconfig() { #if 0 register caddr_t addr; register struct nubus_hw *hw; register struct mac_device *hd, *nhd; int i; for (i=0,hw = nubus_table;iSlot.type!=NUBUS_VIDEO) continue; /* * Found one, now match up with a logical unit number */ nhd = NULL; addr = hw->addr; for (hd = mac_dinit; hd->mac_driver; hd++) { if ((hd->mac_driver != &grfdriver) || hd->mac_alive) continue; nhd = hd; nhd->mac_addr = addr; nhd->mac_unit = gNumGrfDev++; break; /* * Not wildcarded. * If exact match done searching, else keep looking. */ /* if (sctova(hd->mac_addr) == addr) { */ /* nhd = hd; */ /* break; */ /* } */ } /* * Found a match, initialize */ if (nhd && grfprobe(nhd)) { nhd->mac_alive=1; hw->claimed = 1; } } #endif } /* * Normal init routine called by configure() code */ grfprobe(nu, unit) struct nubus_hw *nu; int unit; { struct grf_softc *gp = &grf_softc[unit]; if ((gp->g_flags & GF_ALIVE) == 0 && !grfinit(nu, unit)) { printf("\n"); return(0); } printf(": %d x %d ", 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 (%s) display\n", grfdev[gp->g_type].gd_desc, nu->Slot.name); return(1); } static int matchvideocard(parent, cf, aux) struct device *parent; struct cfdata *cf; void *aux; { struct nubus_hw *nu = (struct nubus_hw *) aux; return (nu->Slot.type == NUBUS_VIDEO); } static void grf_attach(parent, dev, aux) struct device *parent, *dev; void *aux; { struct nubus_hw *nu = (struct nubus_hw *) aux; grfprobe(nu, dev->dv_unit); } struct cfdriver grfcd = { NULL, "grf", matchvideocard, grf_attach, DV_DULL, sizeof(struct device), NULL, 0 }; grfinit(nu, unit) struct nubus_hw *nu; { struct grf_softc *gp = &grf_softc[unit]; struct grfreg *gr; register struct grfdev *gd; for (gd = grfdev; gd < &grfdev[ngrfdev]; gd++) /* if (gd->gd_hardid == gr->gr_id2) */ break; if (gd < &grfdev[ngrfdev] && (*gd->gd_init)(gp, nu)) { 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; { int unit = GRFUNIT(dev); register struct grf_softc *gp = &grf_softc[unit]; int error = 0; if (unit >= NGRF || (gp->g_flags & GF_ALIVE) == 0) return(ENXIO); if ((gp->g_flags & (GF_OPEN|GF_EXCLUDE)) == (GF_OPEN|GF_EXCLUDE)) return(EBUSY); /* * First open. * XXX: always put in graphics mode. */ error = 0; if ((gp->g_flags & GF_OPEN) == 0) { gp->g_flags |= GF_OPEN; error = grfon(dev); } return(error); } /*ARGSUSED*/ grfclose(dev, flags) dev_t dev; { register struct grf_softc *gp = &grf_softc[GRFUNIT(dev)]; (void) grfoff(dev); (void) grfunlock(gp); gp->g_flags &= GF_ALIVE; return(0); } /*ARGSUSED*/ grfioctl(dev, cmd, data, flag, p) dev_t dev; caddr_t data; struct proc *p; { register struct grf_softc *gp = &grf_softc[GRFUNIT(dev)]; int error; 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 GRFIOCON: error = grfon(dev); break; case GRFIOCOFF: error = grfoff(dev); break; case GRFIOCMAP: error = grfmmap(dev, (caddr_t *)data, p); printf("error %d from map ioctl\n",error); break; case GRFIOCUNMAP: error = grfunmmap(dev, *(caddr_t *)data, p); break; default: error = EINVAL; break; } return(error); } /*ARGSUSED*/ grfselect(dev, rw) dev_t dev; { if (rw == FREAD) return(0); return(1); } grflock(gp, 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", p->p_pid, gp-grf_softc, gp->g_flags, gp->g_lockp ? gp->g_lockp->p_pid : -1); #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; return(0); } grfunlock(gp) register struct grf_softc *gp; { #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_flags & GF_WANTED) { wakeup((caddr_t)&gp->g_flags); gp->g_flags &= ~GF_WANTED; } gp->g_lockp = NULL; return(0); } /*ARGSUSED*/ grfmap(dev, off, prot) dev_t dev; { return(grfaddr(&grf_softc[GRFUNIT(dev)], off)); } 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; { int unit = GRFUNIT(dev); struct grf_softc *gp = &grf_softc[unit]; int error; (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 */ 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); } #ifdef HPUXCOMPAT /* * Convert a BSD style minor devno to HPUX style. * We cannot just create HPUX style nodes as they require 24 bits * of minor device number and we only have 8. * XXX: This may give the wrong result for remote stats of other * machines where device 10 exists. */ grfdevno(dev) dev_t dev; { int unit = GRFUNIT(dev); struct grf_softc *gp = &grf_softc[unit]; 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 (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) newdev |= 0x01; #ifdef DEBUG if (grfdebug & GDB_DEVNO) printf("grfdevno: dev %x newdev %x\n", dev, newdev); #endif return(newdev); } #endif grfmmap(dev, addrp, p) dev_t dev; caddr_t *addrp; struct proc *p; { struct grf_softc *gp = &grf_softc[GRFUNIT(dev)]; int len, error; struct vnode vn; struct specinfo si; int flags; #ifdef DEBUG if (grfdebug & GDB_MMAP) 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; if (*addrp) flags |= MAP_FIXED; else { return 12; *addrp = (caddr_t)0x1000000; /* XXX */ } vn.v_type = VCHR; /* XXX */ vn.v_specinfo = &si; /* XXX */ vn.v_rdev = dev; /* XXX */ printf("*addrp = %x\n",*addrp); printf("params: 0x%x, 0x%x, %d\n",&p->p_vmspace->vm_map,(vm_offset_t *)addrp, (vm_size_t)len); printf("frame buffer address %x\n",gp->g_display.gd_fbaddr); 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); printf("back\n"); return(error); } grfunmmap(dev, addr, p) dev_t dev; caddr_t addr; struct proc *p; { struct grf_softc *gp = &grf_softc[GRFUNIT(dev)]; vm_size_t size; int rv; #ifdef DEBUG if (grfdebug & GDB_MMAP) printf("grfunmmap(%d): dev %x addr %x\n", p->p_pid, dev, addr); #endif 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 iommap(dev, addrp) dev_t dev; caddr_t *addrp; { struct proc *p = curproc; /* XXX */ struct grf_softc *gp = &grf_softc[GRFUNIT(dev)]; #ifdef DEBUG if (grfdebug & (GDB_MMAP|GDB_IOMAP)) printf("iommap(%d): addr %x\n", p->p_pid, *addrp); #endif return(EINVAL); } iounmmap(dev, addr) dev_t dev; caddr_t addr; { int unit = minor(dev); #ifdef DEBUG if (grfdebug & (GDB_MMAP|GDB_IOMAP)) printf("iounmmap(%d): id %d addr %x\n", curproc->p_pid, unit, addr); #endif return(0); } /* * Processes involved in framebuffer mapping via GCSLOT are recorded in * an array of pids. The first element is used to record the last slot used * (for faster lookups). The remaining elements record up to GRFMAXLCK-1 * process ids. Returns a slot number between 1 and GRFMAXLCK or 0 if no * slot is available. */ grffindpid(gp) struct grf_softc *gp; { register short pid, *sp; register int i, limit; int ni; if (gp->g_pid == NULL) { gp->g_pid = (short *) malloc(GRFMAXLCK * sizeof(short), M_DEVBUF, M_WAITOK); bzero((caddr_t)gp->g_pid, GRFMAXLCK * sizeof(short)); } 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) goto done; if (*sp == 0) ni = i; } i = ni; if (i < limit) { gp->g_pid[i] = pid; goto done; } if (++i == GRFMAXLCK) return(0); gp->g_pid[0] = i; gp->g_pid[i] = pid; done: #ifdef DEBUG if (grfdebug & GDB_LOCK) printf("grffindpid(%d): slot %d of %d\n", pid, i, gp->g_pid[0]); #endif return(i); } grfrmpid(gp) struct grf_softc *gp; { register short pid, *sp; register int limit, i; int mi; if (gp->g_pid == NULL || (limit = gp->g_pid[0]) == 0) return; pid = curproc->p_pid; limit = gp->g_pid[0]; mi = 0; for (i = 1, sp = &gp->g_pid[1]; i <= limit; i++, sp++) { if (*sp == pid) *sp = 0; else if (*sp) mi = i; } i = mi; if (i < limit) gp->g_pid[0] = i; #ifdef DEBUG if (grfdebug & GDB_LOCK) printf("grfrmpid(%d): slot %d of %d\n", pid, sp-gp->g_pid, gp->g_pid[0]); #endif } grflckmmap(dev, addrp) dev_t dev; caddr_t *addrp; { #ifdef DEBUG struct proc *p = curproc; /* XXX */ if (grfdebug & (GDB_MMAP|GDB_LOCK)) printf("grflckmmap(%d): addr %x\n", p->p_pid, *addrp); #endif return(EINVAL); } grflckunmmap(dev, addr) dev_t dev; caddr_t addr; { #ifdef DEBUG int unit = minor(dev); if (grfdebug & (GDB_MMAP|GDB_LOCK)) printf("grflckunmmap(%d): id %d addr %x\n", curproc->p_pid, unit, addr); #endif return(EINVAL); } #endif /* HPUXCOMPAT */ #endif /* NGRF > 0 */ int macvideo_init(struct grf_softc *gp,struct nubus_hw *nu) { int i=0; struct grfinfo *gi; struct imagedata *image; struct imagedata imageSpace; /* find out which nubus slot this guy is in, then get the video params */ image=(struct imagedata *)NUBUS_GetImageData(&(nu->Slot),&imageSpace ); gi = &(gp->g_display); gi->gd_regsize=0; gi->gd_colors=1; gi->gd_planes=1; gi->gd_dwidth=gi->gd_fbwidth=image->right; gi->gd_dheight=gi->gd_fbheight=image->bottom; gi->gd_fbsize=image->right*image->bottom; gi->gd_fbrowbytes=image->rowbytes; gi->gd_fbaddr=(caddr_t) ((u_long)image->offset+(u_long)nu->addr); gp->g_fbkva=gi->gd_fbaddr; gNumGrfDev++; return 1; } int macvideo_mode(struct grf_softc *gp,int cmd, void *arg) { return 0; }