Home | History | Annotate | Line # | Download | only in dev
grf.c revision 1.8 
      1 /*
      2  * Copyright (c) 1988 University of Utah.
      3  * Copyright (c) 1990 The Regents of the University of California.
      4  * All rights reserved.
      5  *
      6  * This code is derived from software contributed to Berkeley by
      7  * the Systems Programming Group of the University of Utah Computer
      8  * Science Department.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. All advertising materials mentioning features or use of this software
     19  *    must display the following acknowledgement:
     20  *	This product includes software developed by the University of
     21  *	California, Berkeley and its contributors.
     22  * 4. Neither the name of the University nor the names of its contributors
     23  *    may be used to endorse or promote products derived from this software
     24  *    without specific prior written permission.
     25  *
     26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     36  * SUCH DAMAGE.
     37  *
     38  * from: Utah $Hdr: grf.c 1.31 91/01/21$
     39  *
     40  *	@(#)grf.c	7.8 (Berkeley) 5/7/91
     41  *	$Id: grf.c,v 1.8 1994/02/13 21:10:24 chopps Exp $
     42  */
     43 
     44 /*
     45  * Graphics display driver for the AMIGA
     46  * This is the hardware-independent portion of the driver.
     47  * Hardware access is through the grfdev routines below.
     48  */
     49 
     50 #include "grf.h"
     51 #if NGRF > 0
     52 
     53 #include <sys/param.h>
     54 #include <sys/proc.h>
     55 #include <sys/ioctl.h>
     56 #include <sys/file.h>
     57 #include <sys/malloc.h>
     58 
     59 #include <amiga/dev/device.h>
     60 #include <amiga/dev/grfioctl.h>
     61 #include <amiga/dev/grfvar.h>
     62 
     63 #include <machine/cpu.h>
     64 
     65 #include <vm/vm.h>
     66 #include <vm/vm_kern.h>
     67 #include <vm/vm_page.h>
     68 #include <vm/vm_pager.h>
     69 
     70 #include <miscfs/specfs/specdev.h>
     71 #include <sys/vnode.h>
     72 #include <sys/mman.h>
     73 
     74 #include "ite.h"
     75 #if NITE == 0
     76 #define	iteon(u,f)
     77 #define	iteoff(u,f)
     78 #endif
     79 
     80 int	grfprobe();
     81 int	cc_init(), cc_mode();
     82 int	tg_init(), tg_mode();
     83 int	rt_init(), rt_mode();
     84 
     85 struct grfdev grfdev[] = {
     86 	MANUF_BUILTIN,		PROD_BUILTIN_DISPLAY,
     87 		cc_init,  cc_mode,  "custom chips",
     88 	MANUF_UNILOWELL,	PROD_UNILOWELL_A2410,
     89 		tg_init,  tg_mode,    "A2410 TIGA",
     90 	MANUF_MACROSYSTEM,	PROD_MACROSYSTEM_RETINA,
     91 		rt_init,  rt_mode,    "Retina",
     92 };
     93 int	ngrfdev = sizeof(grfdev) / sizeof(grfdev[0]);
     94 
     95 struct	driver grfdriver = { grfprobe, "grf" };
     96 struct	grf_softc grf_softc[NGRF];
     97 
     98 #ifdef DEBUG
     99 int grfdebug = 0;
    100 #define GDB_DEVNO	0x01
    101 #define GDB_MMAP	0x02
    102 #define GDB_IOMAP	0x04
    103 #define GDB_LOCK	0x08
    104 #endif
    105 
    106 /*
    107  * XXX: called from ite console init routine.
    108  * Does just what configure will do later but without printing anything.
    109  */
    110 grfconfig()
    111 {
    112 	register caddr_t addr;
    113 	register struct amiga_hw *hw;
    114 	register struct amiga_device *ad, *nad;
    115 
    116 	for (hw = sc_table; hw->hw_type; hw++) {
    117 	        if (!HW_ISDEV(hw, D_BITMAP))
    118 			continue;
    119 		/*
    120 		 * Found one, now match up with a logical unit number
    121 		 */
    122 		nad = NULL;
    123 		addr = hw->hw_kva;
    124 		for (ad = amiga_dinit; ad->amiga_driver; ad++) {
    125 			if (ad->amiga_driver != &grfdriver || ad->amiga_alive)
    126 				continue;
    127 			/*
    128 			 * Wildcarded.  If first, remember as possible match.
    129 			 */
    130 			if (ad->amiga_addr == NULL) {
    131 				if (nad == NULL)
    132 					nad = ad;
    133 				continue;
    134 			}
    135 			/*
    136 			 * Not wildcarded.
    137 			 * If exact match done searching, else keep looking.
    138 			 */
    139 			if (((hw->hw_manufacturer << 16) | hw->hw_product)
    140 			    == (u_int) ad->amiga_addr) {
    141 				nad = ad;
    142 				break;
    143 			}
    144 		}
    145 		/*
    146 		 * Found a match, initialize
    147 		 */
    148 		if (nad && grfinit (nad, hw))
    149 		  nad->amiga_addr = addr;
    150 	}
    151 }
    152 
    153 /*
    154  * Normal init routine called by configure() code
    155  */
    156 grfprobe(ad)
    157 	struct amiga_device *ad;
    158 {
    159 	struct grf_softc *gp = &grf_softc[ad->amiga_unit];
    160 
    161 	/* can't reinit, as ad->amiga_addr no longer contains
    162 	   manuf/prod information */
    163 	if ((gp->g_flags & GF_ALIVE) == 0 /* &&
    164 	    !grfinit (ad) */)
    165 		return(0);
    166 	printf("grf%d: %d x %d ", ad->amiga_unit,
    167 	       gp->g_display.gd_dwidth, gp->g_display.gd_dheight);
    168 	if (gp->g_display.gd_colors == 2)
    169 		printf("monochrome");
    170 	else
    171 		printf("%d color", gp->g_display.gd_colors);
    172 	printf(" %s display\n", grfdev[gp->g_type].gd_desc);
    173 	return(1);
    174 }
    175 
    176 grfinit(ad, ahw)
    177 	struct amiga_device *ad;
    178 	struct amiga_hw *ahw;
    179 {
    180 	struct grf_softc *gp = &grf_softc[ad->amiga_unit];
    181 	register struct grfdev *gd;
    182 
    183 	for (gd = grfdev; gd < &grfdev[ngrfdev]; gd++)
    184 	  if (((gd->gd_manuf << 16) | gd->gd_prod) == (u_int)ad->amiga_addr)
    185 	    break;
    186 
    187 	if (gd < &grfdev[ngrfdev] && (*gd->gd_init)(gp, ad, ahw)) {
    188 		gp->g_type = gd - grfdev;
    189 		gp->g_flags = GF_ALIVE;
    190 		return(1);
    191 	}
    192 	return(0);
    193 }
    194 
    195 /*ARGSUSED*/
    196 grfopen(dev, flags)
    197 	dev_t dev;
    198 {
    199 	int unit = GRFUNIT(dev);
    200 	register struct grf_softc *gp = &grf_softc[unit];
    201 	int error = 0;
    202 
    203 	if (unit >= NGRF || (gp->g_flags & GF_ALIVE) == 0)
    204 		return(ENXIO);
    205 	if ((gp->g_flags & (GF_OPEN|GF_EXCLUDE)) == (GF_OPEN|GF_EXCLUDE))
    206 		return(EBUSY);
    207 #if 0
    208 	/*
    209 	 * First open.
    210 	 * XXX: always put in graphics mode.
    211 	 */
    212 	error = 0;
    213 	if ((gp->g_flags & GF_OPEN) == 0) {
    214 		gp->g_flags |= GF_OPEN;
    215 		error = grfon(dev);
    216 	}
    217 #endif
    218 	return(error);
    219 }
    220 
    221 /*ARGSUSED*/
    222 grfclose(dev, flags)
    223 	dev_t dev;
    224 {
    225 	register struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
    226 
    227 	(void) grfoff(dev);
    228 	(void) grfunlock(gp);
    229 	gp->g_flags &= GF_ALIVE;
    230 	return(0);
    231 }
    232 
    233 /*ARGSUSED*/
    234 grfioctl(dev, cmd, data, flag, p)
    235 	dev_t dev;
    236 	caddr_t data;
    237 	struct proc *p;
    238 {
    239 	register struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
    240 	int error;
    241 
    242 	error = 0;
    243 	switch (cmd) {
    244 
    245 	case OGRFIOCGINFO:
    246 	        /* argl.. no bank-member.. */
    247 	  	bcopy((caddr_t)&gp->g_display, data, sizeof(struct grfinfo)-4);
    248 		break;
    249 
    250 	case GRFIOCGINFO:
    251 		bcopy((caddr_t)&gp->g_display, data, sizeof(struct grfinfo));
    252 		break;
    253 
    254 	case GRFIOCON:
    255 		error = grfon(dev);
    256 		break;
    257 
    258 	case GRFIOCOFF:
    259 		error = grfoff(dev);
    260 		break;
    261 
    262 	case GRFIOCMAP:
    263 		error = grfmmap(dev, (caddr_t *)data, p);
    264 		break;
    265 
    266 	case GRFIOCUNMAP:
    267 		error = grfunmmap(dev, *(caddr_t *)data, p);
    268 		break;
    269 
    270 	case GRFIOCSINFO:
    271 		error = grfsinfo (dev, (struct grfdyninfo *) data);
    272 		break;
    273 
    274 	case GRFGETVMODE:
    275 		return grfdev[gp->g_type].gd_mode (gp, GM_GRFGETVMODE, data);
    276 
    277 	case GRFSETVMODE:
    278 		error = grfdev[gp->g_type].gd_mode (gp, GM_GRFSETVMODE, data);
    279 		if (! error)
    280 		  {
    281 		    /* XXX */
    282 		    itereinit (GRFUNIT (dev));
    283 		  }
    284 		break;
    285 
    286 	case GRFGETNUMVM:
    287 		return grfdev[gp->g_type].gd_mode (gp, GM_GRFGETNUMVM, data);
    288 
    289 		/* these are all hardware dependant, and have to be resolved
    290 		   in the respective driver. */
    291 	case GRFIOCPUTCMAP:
    292 	case GRFIOCGETCMAP:
    293 	case GRFIOCSSPRITEPOS:
    294 	case GRFIOCGSPRITEPOS:
    295 	case GRFIOCSSPRITEINF:
    296 	case GRFIOCGSPRITEINF:
    297 	case GRFIOCGSPRITEMAX:
    298 		return grfdev[gp->g_type].gd_mode (gp, GM_GRFIOCTL, cmd, data);
    299 
    300 	default:
    301 		/* check to see whether it's a command recognized by the
    302 		   view code if the unit is 0 XXX */
    303 		if (GRFUNIT(dev) == 0)
    304 		  return viewioctl (dev, cmd, data, flag, p);
    305 		error = EINVAL;
    306 		break;
    307 
    308 	}
    309 	return(error);
    310 }
    311 
    312 /*ARGSUSED*/
    313 grfselect(dev, rw)
    314 	dev_t dev;
    315 {
    316 	if (rw == FREAD)
    317 		return(0);
    318 	return(1);
    319 }
    320 
    321 grflock(gp, block)
    322 	register struct grf_softc *gp;
    323 	int block;
    324 {
    325 	struct proc *p = curproc;		/* XXX */
    326 	int error;
    327 	extern char devioc[];
    328 
    329 #ifdef DEBUG
    330 	if (grfdebug & GDB_LOCK)
    331 		printf("grflock(%d): dev %x flags %x lockpid %x\n",
    332 		       p->p_pid, gp-grf_softc, gp->g_flags,
    333 		       gp->g_lockp ? gp->g_lockp->p_pid : -1);
    334 #endif
    335 	if (gp->g_lockp) {
    336 		if (gp->g_lockp == p)
    337 			return(EBUSY);
    338 		if (!block)
    339 			return(EAGAIN);
    340 		do {
    341 			gp->g_flags |= GF_WANTED;
    342 			if (error = tsleep((caddr_t)&gp->g_flags,
    343 					   (PZERO+1) | PCATCH, devioc, 0))
    344 				return (error);
    345 		} while (gp->g_lockp);
    346 	}
    347 	gp->g_lockp = p;
    348 	return(0);
    349 }
    350 
    351 grfunlock(gp)
    352 	register struct grf_softc *gp;
    353 {
    354 #ifdef DEBUG
    355 	if (grfdebug & GDB_LOCK)
    356 		printf("grfunlock(%d): dev %x flags %x lockpid %d\n",
    357 		       curproc->p_pid, gp-grf_softc, gp->g_flags,
    358 		       gp->g_lockp ? gp->g_lockp->p_pid : -1);
    359 #endif
    360 	if (gp->g_lockp != curproc)
    361 		return(EBUSY);
    362 	if (gp->g_flags & GF_WANTED) {
    363 		wakeup((caddr_t)&gp->g_flags);
    364 		gp->g_flags &= ~GF_WANTED;
    365 	}
    366 	gp->g_lockp = NULL;
    367 	return(0);
    368 }
    369 
    370 /*ARGSUSED*/
    371 grfmap(dev, off, prot)
    372 	dev_t dev;
    373 {
    374 	return(grfaddr(&grf_softc[GRFUNIT(dev)], off));
    375 }
    376 
    377 
    378 grfon(dev)
    379 	dev_t dev;
    380 {
    381 	int unit = GRFUNIT(dev);
    382 	struct grf_softc *gp = &grf_softc[unit];
    383 
    384 	if (gp->g_flags & GF_GRFON)
    385 	  return 0;
    386 	gp->g_flags |= GF_GRFON;
    387 
    388 	/*
    389 	 * XXX: iteoff call relies on devices being in same order
    390 	 * as ITEs and the fact that iteoff only uses the minor part
    391 	 * of the dev arg.
    392 	 */
    393 	iteoff(unit, 3);
    394 	return((*grfdev[gp->g_type].gd_mode)
    395 			(gp, (dev&GRFOVDEV) ? GM_GRFOVON : GM_GRFON));
    396 }
    397 
    398 grfoff(dev)
    399 	dev_t dev;
    400 {
    401 	int unit = GRFUNIT(dev);
    402 	struct grf_softc *gp = &grf_softc[unit];
    403 	int error;
    404 
    405 	if (!(gp->g_flags & GF_GRFON))
    406 	  return 0;
    407 	gp->g_flags &= ~GF_GRFON;
    408 
    409 	(void) grfunmmap(dev, (caddr_t)0, curproc);
    410 	error = (*grfdev[gp->g_type].gd_mode)
    411 			(gp, (dev&GRFOVDEV) ? GM_GRFOVOFF : GM_GRFOFF);
    412 	/* XXX: see comment for iteoff above */
    413 	iteon(unit, 2);
    414 	return(error);
    415 }
    416 
    417 grfsinfo(dev, dyninfo)
    418 	dev_t dev;
    419 	struct grfdyninfo *dyninfo;
    420 {
    421 	int unit = GRFUNIT(dev);
    422 	struct grf_softc *gp = &grf_softc[unit];
    423 	int error;
    424 
    425 	error = grfdev[gp->g_type].gd_mode (gp, GM_GRFCONFIG, dyninfo);
    426 	/* XXX: see comment for iteoff above */
    427 	itereinit (unit);
    428 	return(error);
    429 }
    430 
    431 grfaddr(gp, off)
    432 	struct grf_softc *gp;
    433 	register int off;
    434 {
    435 	register struct grfinfo *gi = &gp->g_display;
    436 
    437 	/* control registers */
    438 	if (off >= 0 && off < gi->gd_regsize)
    439 		return(((u_int)gi->gd_regaddr + off) >> PGSHIFT);
    440 
    441 	/* frame buffer */
    442 	if (off >= gi->gd_regsize && off < gi->gd_regsize+gi->gd_fbsize) {
    443 		off -= gi->gd_regsize;
    444 #ifdef BANKEDDEVPAGER
    445 		if (gi->gd_bank_size)
    446 		  off %= gi->gd_bank_size;
    447 #endif
    448 		return(((u_int)gi->gd_fbaddr + off) >> PGSHIFT);
    449 	}
    450 	/* bogus */
    451 	return(-1);
    452 }
    453 
    454 grfmmap(dev, addrp, p)
    455 	dev_t dev;
    456 	caddr_t *addrp;
    457 	struct proc *p;
    458 {
    459 	struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
    460 	int len, error;
    461 	struct vnode vn;
    462 	struct specinfo si;
    463 	int flags;
    464 
    465 #ifdef DEBUG
    466 	if (grfdebug & GDB_MMAP)
    467 		printf("grfmmap(%d): addr %x\n", p->p_pid, *addrp);
    468 #endif
    469 	len = gp->g_display.gd_regsize + gp->g_display.gd_fbsize;
    470 	flags = MAP_FILE|MAP_SHARED;
    471 	if (*addrp)
    472 		flags |= MAP_FIXED;
    473 	else {
    474 		/*
    475 		 * XXX if no hint provided for a non-fixed mapping place it after
    476 		 * the end of the largest possible heap.
    477 		 *
    478 		 * There should really be a pmap call to determine a reasonable
    479 		 * location.
    480 		 */
    481 		*addrp = (caddr_t) round_page(p->p_vmspace->vm_daddr + MAXDSIZ);
    482 	}
    483 	bzero (&vn, sizeof (vn));
    484 	bzero (&si, sizeof (si));
    485 	vn.v_type = VCHR;			/* XXX */
    486 	vn.v_specinfo = &si;			/* XXX */
    487 	vn.v_rdev = dev;			/* XXX */
    488   	error = vm_mmap(&p->p_vmspace->vm_map, (vm_offset_t *)addrp,
    489 			(vm_size_t)len, VM_PROT_ALL, VM_PROT_ALL, flags,
    490 			(caddr_t)&vn, 0);
    491 	return(error);
    492 }
    493 
    494 grfunmmap(dev, addr, p)
    495 	dev_t dev;
    496 	caddr_t addr;
    497 	struct proc *p;
    498 {
    499 	struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
    500 	vm_size_t size;
    501 	int rv;
    502 
    503 #ifdef DEBUG
    504 	if (grfdebug & GDB_MMAP)
    505 		printf("grfunmmap(%d): dev %x addr %x\n", p->p_pid, dev, addr);
    506 #endif
    507 	if (addr == 0)
    508 		return(EINVAL);		/* XXX: how do we deal with this? */
    509 	size = round_page(gp->g_display.gd_regsize + gp->g_display.gd_fbsize);
    510 	rv = vm_deallocate(p->p_vmspace->vm_map, (vm_offset_t)addr, size);
    511 	return(rv == KERN_SUCCESS ? 0 : EINVAL);
    512 }
    513 
    514 #ifdef BANKEDDEVPAGER
    515 
    516 int
    517 grfbanked_get (dev, off, prot)
    518      dev_t dev;
    519      off_t off;
    520      int   prot;
    521 {
    522   int unit = GRFUNIT(dev);
    523   struct grf_softc *gp = &grf_softc[unit];
    524   int error, bank;
    525   struct grfinfo *gi = &gp->g_display;
    526 
    527   off -= gi->gd_regsize;
    528   if (off < 0 || off >= gi->gd_fbsize)
    529     return -1;
    530 
    531   error = grfdev[gp->g_type].gd_mode (gp, GM_GRFGETBANK, &bank, off, prot);
    532   return error ? -1 : bank;
    533 }
    534 
    535 int
    536 grfbanked_cur (dev)
    537      dev_t dev;
    538 {
    539   int unit = GRFUNIT(dev);
    540   struct grf_softc *gp = &grf_softc[unit];
    541   int error, bank;
    542 
    543   error = grfdev[gp->g_type].gd_mode (gp, GM_GRFGETCURBANK, &bank);
    544   return error ? -1 : bank;
    545 }
    546 
    547 int
    548 grfbanked_set (dev, bank)
    549      dev_t dev;
    550      int bank;
    551 {
    552   int unit = GRFUNIT(dev);
    553   struct grf_softc *gp = &grf_softc[unit];
    554 
    555   return grfdev[gp->g_type].gd_mode (gp, GM_GRFSETBANK, bank) ? -1 : 0;
    556 }
    557 
    558 #endif /* BANKEDDEVPAGER */
    559 
    560 #endif	/* NGRF > 0 */
    561