Home | History | Annotate | Line # | Download | only in dev
grf.c revision 1.9 
      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.9 1994/02/17 09:10:32 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 #include <sys/conf.h>
     59 #include <sys/systm.h>
     60 
     61 #include <amiga/dev/device.h>
     62 #include <amiga/dev/grfioctl.h>
     63 #include <amiga/dev/grfvar.h>
     64 
     65 #include <machine/cpu.h>
     66 
     67 #include <vm/vm.h>
     68 #include <vm/vm_kern.h>
     69 #include <vm/vm_page.h>
     70 #include <vm/vm_pager.h>
     71 
     72 #include <miscfs/specfs/specdev.h>
     73 #include <sys/vnode.h>
     74 #include <sys/mman.h>
     75 
     76 #if defined (__STDC__)
     77 #define GET_CHRDEV_MAJOR(dev, maj) { \
     78 	for(maj = 0; maj < nchrdev; maj++) \
     79 		if (cdevsw[maj].d_open == dev ## open) \
     80 			break; \
     81 }
     82 #else
     83 #define GET_CHRDEV_MAJOR(dev, maj) { \
     84 	for(maj = 0; maj < nchrdev; maj++) \
     85 		if (cdevsw[maj].d_open == dev/**/open) \
     86 			break; \
     87 }
     88 #endif
     89 
     90 #include "ite.h"
     91 #if NITE == 0
     92 #define	ite_on(u,f)
     93 #define	ite_off(u,f)
     94 #define ite_reinit(d)
     95 #endif
     96 
     97 int	grfprobe();
     98 int	cc_init(), cc_mode();
     99 int	tg_init(), tg_mode();
    100 int	rt_init(), rt_mode();
    101 
    102 struct grfdev grfdev[] = {
    103 	MANUF_BUILTIN,		PROD_BUILTIN_DISPLAY,
    104 		cc_init,  cc_mode,  "custom chips",
    105 	MANUF_UNILOWELL,	PROD_UNILOWELL_A2410,
    106 		tg_init,  tg_mode,    "A2410 TIGA",
    107 	MANUF_MACROSYSTEM,	PROD_MACROSYSTEM_RETINA,
    108 		rt_init,  rt_mode,    "Retina",
    109 };
    110 int	ngrfdev = sizeof(grfdev) / sizeof(grfdev[0]);
    111 
    112 struct	driver grfdriver = { grfprobe, "grf" };
    113 struct	grf_softc grf_softc[NGRF];
    114 
    115 #ifdef DEBUG
    116 int grfdebug = 0;
    117 #define GDB_DEVNO	0x01
    118 #define GDB_MMAP	0x02
    119 #define GDB_IOMAP	0x04
    120 #define GDB_LOCK	0x08
    121 #endif
    122 
    123 /*
    124  * XXX: called from ite console init routine.
    125  * Does just what configure will do later but without printing anything.
    126  */
    127 grfconfig()
    128 {
    129 	register caddr_t addr;
    130 	register struct amiga_hw *hw;
    131 	register struct amiga_device *ad, *nad;
    132 
    133 	for (hw = sc_table; hw->hw_type; hw++) {
    134 	        if (!HW_ISDEV(hw, D_BITMAP))
    135 			continue;
    136 		/*
    137 		 * Found one, now match up with a logical unit number
    138 		 */
    139 		nad = NULL;
    140 		addr = hw->hw_kva;
    141 		for (ad = amiga_dinit; ad->amiga_driver; ad++) {
    142 			if (ad->amiga_driver != &grfdriver || ad->amiga_alive)
    143 				continue;
    144 			/*
    145 			 * Wildcarded.  If first, remember as possible match.
    146 			 */
    147 			if (ad->amiga_addr == NULL) {
    148 				if (nad == NULL)
    149 					nad = ad;
    150 				continue;
    151 			}
    152 			/*
    153 			 * Not wildcarded.
    154 			 * If exact match done searching, else keep looking.
    155 			 */
    156 			if (((hw->hw_manufacturer << 16) | hw->hw_product)
    157 			    == (u_int) ad->amiga_addr) {
    158 				nad = ad;
    159 				break;
    160 			}
    161 		}
    162 		/*
    163 		 * Found a match, initialize
    164 		 */
    165 		if (nad && grfinit (nad, hw))
    166 		  nad->amiga_addr = addr;
    167 	}
    168 }
    169 
    170 /*
    171  * Normal init routine called by configure() code
    172  */
    173 grfprobe(ad)
    174 	struct amiga_device *ad;
    175 {
    176 	struct grf_softc *gp = &grf_softc[ad->amiga_unit];
    177 
    178 	/* can't reinit, as ad->amiga_addr no longer contains
    179 	   manuf/prod information */
    180 	if ((gp->g_flags & GF_ALIVE) == 0 /* &&
    181 	    !grfinit (ad) */)
    182 		return(0);
    183 	printf("grf%d: %d x %d ", ad->amiga_unit,
    184 	       gp->g_display.gd_dwidth, gp->g_display.gd_dheight);
    185 	if (gp->g_display.gd_colors == 2)
    186 		printf("monochrome");
    187 	else
    188 		printf("%d color", gp->g_display.gd_colors);
    189 	printf(" %s display\n", grfdev[gp->g_type].gd_desc);
    190 	return(1);
    191 }
    192 
    193 grfinit(ad, ahw)
    194 	struct amiga_device *ad;
    195 	struct amiga_hw *ahw;
    196 {
    197 	struct grf_softc *gp = &grf_softc[ad->amiga_unit];
    198 	register struct grfdev *gd;
    199 
    200 	for (gd = grfdev; gd < &grfdev[ngrfdev]; gd++)
    201 	  if (((gd->gd_manuf << 16) | gd->gd_prod) == (u_int)ad->amiga_addr)
    202 	    break;
    203 
    204 	if (gd < &grfdev[ngrfdev] && (*gd->gd_init)(gp, ad, ahw)) {
    205 		gp->g_type = gd - grfdev;
    206 		gp->g_flags = GF_ALIVE;
    207 		return(1);
    208 	}
    209 	return(0);
    210 }
    211 
    212 /*ARGSUSED*/
    213 grfopen(dev, flags)
    214 	dev_t dev;
    215 {
    216 	int unit = GRFUNIT(dev);
    217 	register struct grf_softc *gp = &grf_softc[unit];
    218 	int error = 0;
    219 
    220 	if (unit >= NGRF || (gp->g_flags & GF_ALIVE) == 0)
    221 		return(ENXIO);
    222 	if ((gp->g_flags & (GF_OPEN|GF_EXCLUDE)) == (GF_OPEN|GF_EXCLUDE))
    223 		return(EBUSY);
    224 #if 0
    225 	/*
    226 	 * First open.
    227 	 * XXX: always put in graphics mode.
    228 	 */
    229 	error = 0;
    230 	if ((gp->g_flags & GF_OPEN) == 0) {
    231 		gp->g_flags |= GF_OPEN;
    232 		error = grfon(dev);
    233 	}
    234 #endif
    235 	return(error);
    236 }
    237 
    238 /*ARGSUSED*/
    239 grfclose(dev, flags)
    240 	dev_t dev;
    241 {
    242 	register struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
    243 
    244 	(void) grfoff(dev);
    245 	(void) grfunlock(gp);
    246 	gp->g_flags &= GF_ALIVE;
    247 	return(0);
    248 }
    249 
    250 /*ARGSUSED*/
    251 grfioctl(dev, cmd, data, flag, p)
    252 	dev_t dev;
    253 	caddr_t data;
    254 	struct proc *p;
    255 {
    256 	register struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
    257 	int error;
    258 
    259 	error = 0;
    260 	switch (cmd) {
    261 
    262 	case OGRFIOCGINFO:
    263 	        /* argl.. no bank-member.. */
    264 	  	bcopy((caddr_t)&gp->g_display, data, sizeof(struct grfinfo)-4);
    265 		break;
    266 
    267 	case GRFIOCGINFO:
    268 		bcopy((caddr_t)&gp->g_display, data, sizeof(struct grfinfo));
    269 		break;
    270 
    271 	case GRFIOCON:
    272 		error = grfon(dev);
    273 		break;
    274 
    275 	case GRFIOCOFF:
    276 		error = grfoff(dev);
    277 		break;
    278 
    279 	case GRFIOCMAP:
    280 		error = grfmmap(dev, (caddr_t *)data, p);
    281 		break;
    282 
    283 	case GRFIOCUNMAP:
    284 		error = grfunmmap(dev, *(caddr_t *)data, p);
    285 		break;
    286 
    287 	case GRFIOCSINFO:
    288 		error = grfsinfo (dev, (struct grfdyninfo *) data);
    289 		break;
    290 
    291 	case GRFGETVMODE:
    292 		return grfdev[gp->g_type].gd_mode (gp, GM_GRFGETVMODE, data);
    293 
    294 	case GRFSETVMODE:
    295 		error = grfdev[gp->g_type].gd_mode (gp, GM_GRFSETVMODE, data);
    296 		if (! error)
    297 		  {
    298 		    /* XXX */
    299 		    ite_reinit (GRFUNIT (dev));
    300 		  }
    301 		break;
    302 
    303 	case GRFGETNUMVM:
    304 		return grfdev[gp->g_type].gd_mode (gp, GM_GRFGETNUMVM, data);
    305 
    306 		/* these are all hardware dependant, and have to be resolved
    307 		   in the respective driver. */
    308 	case GRFIOCPUTCMAP:
    309 	case GRFIOCGETCMAP:
    310 	case GRFIOCSSPRITEPOS:
    311 	case GRFIOCGSPRITEPOS:
    312 	case GRFIOCSSPRITEINF:
    313 	case GRFIOCGSPRITEINF:
    314 	case GRFIOCGSPRITEMAX:
    315 		return grfdev[gp->g_type].gd_mode (gp, GM_GRFIOCTL, cmd, data);
    316 
    317 	default:
    318 		/* check to see whether it's a command recognized by the
    319 		   view code if the unit is 0 XXX */
    320 		if (GRFUNIT(dev) == 0)
    321 		  return viewioctl (dev, cmd, data, flag, p);
    322 		error = EINVAL;
    323 		break;
    324 
    325 	}
    326 	return(error);
    327 }
    328 
    329 /*ARGSUSED*/
    330 grfselect(dev, rw)
    331 	dev_t dev;
    332 {
    333 	if (rw == FREAD)
    334 		return(0);
    335 	return(1);
    336 }
    337 
    338 grflock(gp, block)
    339 	register struct grf_softc *gp;
    340 	int block;
    341 {
    342 	struct proc *p = curproc;		/* XXX */
    343 	int error;
    344 	extern char devioc[];
    345 
    346 #ifdef DEBUG
    347 	if (grfdebug & GDB_LOCK)
    348 		printf("grflock(%d): dev %x flags %x lockpid %x\n",
    349 		       p->p_pid, gp-grf_softc, gp->g_flags,
    350 		       gp->g_lockp ? gp->g_lockp->p_pid : -1);
    351 #endif
    352 	if (gp->g_lockp) {
    353 		if (gp->g_lockp == p)
    354 			return(EBUSY);
    355 		if (!block)
    356 			return(EAGAIN);
    357 		do {
    358 			gp->g_flags |= GF_WANTED;
    359 			if (error = tsleep((caddr_t)&gp->g_flags,
    360 					   (PZERO+1) | PCATCH, devioc, 0))
    361 				return (error);
    362 		} while (gp->g_lockp);
    363 	}
    364 	gp->g_lockp = p;
    365 	return(0);
    366 }
    367 
    368 grfunlock(gp)
    369 	register struct grf_softc *gp;
    370 {
    371 #ifdef DEBUG
    372 	if (grfdebug & GDB_LOCK)
    373 		printf("grfunlock(%d): dev %x flags %x lockpid %d\n",
    374 		       curproc->p_pid, gp-grf_softc, gp->g_flags,
    375 		       gp->g_lockp ? gp->g_lockp->p_pid : -1);
    376 #endif
    377 	if (gp->g_lockp != curproc)
    378 		return(EBUSY);
    379 	if (gp->g_flags & GF_WANTED) {
    380 		wakeup((caddr_t)&gp->g_flags);
    381 		gp->g_flags &= ~GF_WANTED;
    382 	}
    383 	gp->g_lockp = NULL;
    384 	return(0);
    385 }
    386 
    387 /*ARGSUSED*/
    388 grfmap(dev, off, prot)
    389 	dev_t dev;
    390 {
    391 	return(grfaddr(&grf_softc[GRFUNIT(dev)], off));
    392 }
    393 
    394 grfon(dev)
    395 	dev_t dev;
    396 {
    397 	extern int iteopen __P((dev_t, int, int, struct proc *));
    398 	int maj;
    399 	int unit = GRFUNIT(dev);
    400 	struct grf_softc *gp = &grf_softc[unit];
    401 
    402 	if (gp->g_flags & GF_GRFON)
    403 	  return 0;
    404 	gp->g_flags |= GF_GRFON;
    405 
    406 	/* XXX relies on the unit matching */
    407 	GET_CHRDEV_MAJOR(ite, maj);
    408 	ite_off(makedev(maj,unit), 3);
    409 	return((*grfdev[gp->g_type].gd_mode)
    410 			(gp, (dev&GRFOVDEV) ? GM_GRFOVON : GM_GRFON));
    411 }
    412 
    413 grfoff(dev)
    414 	dev_t dev;
    415 {
    416 	extern int iteopen __P((dev_t, int, int, struct proc *));
    417 	int maj;
    418 	int unit = GRFUNIT(dev);
    419 	struct grf_softc *gp = &grf_softc[unit];
    420 	int error;
    421 
    422 	if (!(gp->g_flags & GF_GRFON))
    423 	  return 0;
    424 	gp->g_flags &= ~GF_GRFON;
    425 
    426 	(void) grfunmmap(dev, (caddr_t)0, curproc);
    427 	error = (*grfdev[gp->g_type].gd_mode)
    428 			(gp, (dev&GRFOVDEV) ? GM_GRFOVOFF : GM_GRFOFF);
    429 	/* XXX relies on the unit matching */
    430 	GET_CHRDEV_MAJOR(ite, maj);
    431 	ite_on(makedev(maj,unit), 2);
    432 	return(error);
    433 }
    434 
    435 grfsinfo(dev, dyninfo)
    436 	dev_t dev;
    437 	struct grfdyninfo *dyninfo;
    438 {
    439 	int unit = GRFUNIT(dev);
    440 	struct grf_softc *gp = &grf_softc[unit];
    441 	int error;
    442 
    443 	error = grfdev[gp->g_type].gd_mode (gp, GM_GRFCONFIG, dyninfo);
    444 	/* XXX: see comment for iteoff above */
    445 	ite_reinit (unit);
    446 	return(error);
    447 }
    448 
    449 grfaddr(gp, off)
    450 	struct grf_softc *gp;
    451 	register int off;
    452 {
    453 	register struct grfinfo *gi = &gp->g_display;
    454 
    455 	/* control registers */
    456 	if (off >= 0 && off < gi->gd_regsize)
    457 		return(((u_int)gi->gd_regaddr + off) >> PGSHIFT);
    458 
    459 	/* frame buffer */
    460 	if (off >= gi->gd_regsize && off < gi->gd_regsize+gi->gd_fbsize) {
    461 		off -= gi->gd_regsize;
    462 #ifdef BANKEDDEVPAGER
    463 		if (gi->gd_bank_size)
    464 		  off %= gi->gd_bank_size;
    465 #endif
    466 		return(((u_int)gi->gd_fbaddr + off) >> PGSHIFT);
    467 	}
    468 	/* bogus */
    469 	return(-1);
    470 }
    471 
    472 grfmmap(dev, addrp, p)
    473 	dev_t dev;
    474 	caddr_t *addrp;
    475 	struct proc *p;
    476 {
    477 	struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
    478 	int len, error;
    479 	struct vnode vn;
    480 	struct specinfo si;
    481 	int flags;
    482 
    483 #ifdef DEBUG
    484 	if (grfdebug & GDB_MMAP)
    485 		printf("grfmmap(%d): addr %x\n", p->p_pid, *addrp);
    486 #endif
    487 	len = gp->g_display.gd_regsize + gp->g_display.gd_fbsize;
    488 	flags = MAP_FILE|MAP_SHARED;
    489 	if (*addrp)
    490 		flags |= MAP_FIXED;
    491 	else {
    492 		/*
    493 		 * XXX if no hint provided for a non-fixed mapping place it after
    494 		 * the end of the largest possible heap.
    495 		 *
    496 		 * There should really be a pmap call to determine a reasonable
    497 		 * location.
    498 		 */
    499 		*addrp = (caddr_t) round_page(p->p_vmspace->vm_daddr + MAXDSIZ);
    500 	}
    501 	bzero (&vn, sizeof (vn));
    502 	bzero (&si, sizeof (si));
    503 	vn.v_type = VCHR;			/* XXX */
    504 	vn.v_specinfo = &si;			/* XXX */
    505 	vn.v_rdev = dev;			/* XXX */
    506   	error = vm_mmap(&p->p_vmspace->vm_map, (vm_offset_t *)addrp,
    507 			(vm_size_t)len, VM_PROT_ALL, VM_PROT_ALL, flags,
    508 			(caddr_t)&vn, 0);
    509 	return(error);
    510 }
    511 
    512 grfunmmap(dev, addr, p)
    513 	dev_t dev;
    514 	caddr_t addr;
    515 	struct proc *p;
    516 {
    517 	struct grf_softc *gp = &grf_softc[GRFUNIT(dev)];
    518 	vm_size_t size;
    519 	int rv;
    520 
    521 #ifdef DEBUG
    522 	if (grfdebug & GDB_MMAP)
    523 		printf("grfunmmap(%d): dev %x addr %x\n", p->p_pid, dev, addr);
    524 #endif
    525 	if (addr == 0)
    526 		return(EINVAL);		/* XXX: how do we deal with this? */
    527 	size = round_page(gp->g_display.gd_regsize + gp->g_display.gd_fbsize);
    528 	rv = vm_deallocate(p->p_vmspace->vm_map, (vm_offset_t)addr, size);
    529 	return(rv == KERN_SUCCESS ? 0 : EINVAL);
    530 }
    531 
    532 #ifdef BANKEDDEVPAGER
    533 
    534 int
    535 grfbanked_get (dev, off, prot)
    536      dev_t dev;
    537      off_t off;
    538      int   prot;
    539 {
    540   int unit = GRFUNIT(dev);
    541   struct grf_softc *gp = &grf_softc[unit];
    542   int error, bank;
    543   struct grfinfo *gi = &gp->g_display;
    544 
    545   off -= gi->gd_regsize;
    546   if (off < 0 || off >= gi->gd_fbsize)
    547     return -1;
    548 
    549   error = grfdev[gp->g_type].gd_mode (gp, GM_GRFGETBANK, &bank, off, prot);
    550   return error ? -1 : bank;
    551 }
    552 
    553 int
    554 grfbanked_cur (dev)
    555      dev_t dev;
    556 {
    557   int unit = GRFUNIT(dev);
    558   struct grf_softc *gp = &grf_softc[unit];
    559   int error, bank;
    560 
    561   error = grfdev[gp->g_type].gd_mode (gp, GM_GRFGETCURBANK, &bank);
    562   return error ? -1 : bank;
    563 }
    564 
    565 int
    566 grfbanked_set (dev, bank)
    567      dev_t dev;
    568      int bank;
    569 {
    570   int unit = GRFUNIT(dev);
    571   struct grf_softc *gp = &grf_softc[unit];
    572 
    573   return grfdev[gp->g_type].gd_mode (gp, GM_GRFSETBANK, bank) ? -1 : 0;
    574 }
    575 
    576 #endif /* BANKEDDEVPAGER */
    577 
    578 #endif	/* NGRF > 0 */
    579