grf.c revision 1.66 
1/*	$NetBSD: grf.c,v 1.66 2021/04/27 14:48:28 thorpej Exp $ */
2
3/*
4 * Copyright (c) 1988 University of Utah.
5 * Copyright (c) 1990 The Regents of the University of California.
6 * 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. Neither the name of the University nor the names of its contributors
21 *    may be used to endorse or promote products derived from this software
22 *    without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 *
36 * from: Utah $Hdr: grf.c 1.31 91/01/21$
37 *
38 *	@(#)grf.c	7.8 (Berkeley) 5/7/91
39 */
40
41#include <sys/cdefs.h>
42__KERNEL_RCSID(0, "$NetBSD: grf.c,v 1.66 2021/04/27 14:48:28 thorpej Exp $");
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 grf_softc->g_mode routine.
48 */
49
50#include "view.h"
51#include "grf.h"
52#include "kbd.h"
53#include "wsdisplay.h"
54
55#include <sys/param.h>
56#include <sys/proc.h>
57#include <sys/ioctl.h>
58#include <sys/device.h>
59#include <sys/file.h>
60#include <sys/malloc.h>
61#include <sys/systm.h>
62#include <sys/vnode.h>
63#include <sys/mman.h>
64#include <sys/bus.h>
65#include <sys/kauth.h>
66
67#include <machine/cpu.h>
68
69#include <dev/cons.h>
70#include <dev/sun/fbio.h>
71#include <dev/wscons/wsconsio.h>
72#include <dev/wscons/wsdisplayvar.h>
73#include <dev/rasops/rasops.h>
74#include <dev/wscons/wsdisplay_vconsvar.h>
75
76#include <amiga/amiga/color.h>	/* DEBUG */
77#include <amiga/amiga/device.h>
78#include <amiga/dev/grfioctl.h>
79#include <amiga/dev/grfvar.h>
80#include <amiga/dev/itevar.h>
81#include <amiga/dev/kbdvar.h>
82#include <amiga/dev/viewioctl.h>
83
84#include <sys/conf.h>
85
86#if NGRF > 0
87#include "ite.h"
88#if NITE == 0
89#define	ite_on(u,f)
90#define	ite_off(u,f)
91#define ite_reinit(d)
92#endif
93
94int grfon(dev_t);
95int grfoff(dev_t);
96int grfsinfo(dev_t, struct grfdyninfo *);
97
98void grfattach(device_t, device_t, void *);
99int grfmatch(device_t, cfdata_t, void *);
100int grfprint(void *, const char *);
101#ifdef DEBUG
102void grfdebug(struct grf_softc *, const char *, ...);
103#endif
104/*
105 * pointers to grf drivers device structs
106 */
107struct grf_softc *grfsp[NGRF];
108
109CFATTACH_DECL_NEW(grf, 0,
110    grfmatch, grfattach, NULL, NULL);
111
112dev_type_open(grfopen);
113dev_type_close(grfclose);
114dev_type_ioctl(grfioctl);
115dev_type_mmap(grfmmap);
116
117const struct cdevsw grf_cdevsw = {
118	.d_open = grfopen,
119	.d_close = grfclose,
120	.d_read = nullread,
121	.d_write = nullwrite,
122	.d_ioctl = grfioctl,
123	.d_stop = nostop,
124	.d_tty = notty,
125	.d_poll = nopoll,
126	.d_mmap = grfmmap,
127	.d_kqfilter = nokqfilter,
128	.d_discard = nodiscard,
129	.d_flag = 0
130};
131
132/*
133 * only used in console init.
134 */
135static cfdata_t cfdata;
136
137#if NWSDISPLAY > 0
138static struct vcons_screen console_vcons;
139
140static void grf_init_screen(void *, struct vcons_screen *, int, long *);
141static struct rasops_info *grf_setup_rasops(struct grf_softc *,
142    struct vcons_screen *);
143
144cons_decl(grf);
145#endif
146
147/*
148 * match if the unit of grf matches its perspective
149 * low level board driver.
150 */
151int
152grfmatch(device_t parent, cfdata_t cf, void *aux)
153{
154	struct grf_softc *psc;
155
156	psc = device_private(parent);
157	if (cf->cf_unit != psc->g_unit)
158		return(0);
159	cfdata = cf;
160	return(1);
161}
162
163/*
164 * Attach.. plug pointer in and print some info.
165 * Then try and attach a wsdisplay or ite to us.
166 * Note: self is NULL durring console init.
167 */
168void
169grfattach(device_t parent, device_t self, void *aux)
170{
171#if NWSDISPLAY > 0
172	struct wsemuldisplaydev_attach_args wa;
173	long defattr;
174#endif
175	struct grf_softc *gp;
176	int maj;
177
178	gp = device_private(parent);
179	gp->g_device = self;
180	grfsp[gp->g_unit] = gp;
181
182	/*
183	 * find our major device number, make device
184	 */
185	maj = cdevsw_lookup_major(&grf_cdevsw);
186	gp->g_grfdev = makedev(maj, gp->g_unit);
187
188	if (self != NULL) {
189		printf(": width %d height %d", gp->g_display.gd_dwidth,
190		    gp->g_display.gd_dheight);
191		if (gp->g_display.gd_colors == 2)
192			printf(" monochrome\n");
193		else
194			printf(" colors %d\n", gp->g_display.gd_colors);
195
196#if NWSDISPLAY > 0
197		vcons_init(&gp->g_vd, gp, gp->g_defaultscr, gp->g_accessops);
198		gp->g_vd.init_screen = grf_init_screen;
199
200		if (gp->g_flags & GF_CONSOLE) {
201			console_vcons.scr_flags |= VCONS_SCREEN_IS_STATIC;
202			vcons_init_screen(&gp->g_vd,
203			    &console_vcons, 1, &defattr);
204			gp->g_defaultscr->textops =
205			    &console_vcons.scr_ri.ri_ops;
206			wsdisplay_cnattach(gp->g_defaultscr,
207			    &console_vcons.scr_ri, 0, 0, defattr);
208			vcons_replay_msgbuf(&console_vcons);
209		}
210
211		/* attach wsdisplay */
212		wa.console = (gp->g_flags & GF_CONSOLE) != 0;
213		wa.scrdata = gp->g_scrlist;
214		wa.accessops = gp->g_accessops;
215		wa.accesscookie = &gp->g_vd;
216		config_found(self, &wa, wsemuldisplaydevprint,
217		    CFARG_IATTR, "wsemuldisplaydev",
218		    CFARG_EOL);
219#endif  /* NWSDISPLAY > 0 */
220	}
221
222#if NWSDISPLAY == 0
223	/*
224	 * try and attach an ite
225	 */
226	amiga_config_found(cfdata, self, gp, grfprint,
227	    CFARG_IATTR, "grf",
228	    CFARG_EOL);
229#endif
230}
231
232int
233grfprint(void *aux, const char *pnp)
234{
235	if (pnp)
236		aprint_normal("ite at %s", pnp);
237	return(UNCONF);
238}
239
240/*ARGSUSED*/
241int
242grfopen(dev_t dev, int flags, int devtype, struct lwp *l)
243{
244	struct grf_softc *gp;
245
246	if (GRFUNIT(dev) >= NGRF || (gp = grfsp[GRFUNIT(dev)]) == NULL)
247		return(ENXIO);
248
249	if ((gp->g_flags & GF_ALIVE) == 0)
250		return(ENXIO);
251
252	if ((gp->g_flags & (GF_OPEN|GF_EXCLUDE)) == (GF_OPEN|GF_EXCLUDE))
253		return(EBUSY);
254
255	return(0);
256}
257
258/*ARGSUSED*/
259int
260grfclose(dev_t dev, int flags, int mode, struct lwp *l)
261{
262	struct grf_softc *gp;
263
264	gp = grfsp[GRFUNIT(dev)];
265	(void)grfoff(dev);
266	gp->g_flags &= GF_ALIVE;
267	return(0);
268}
269
270/*ARGSUSED*/
271int
272grfioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
273{
274	struct grf_softc *gp;
275	int error;
276
277	gp = grfsp[GRFUNIT(dev)];
278	error = 0;
279
280	switch (cmd) {
281	case OGRFIOCGINFO:
282	        /* argl.. no bank-member.. */
283	  	memcpy(data, (void *)&gp->g_display, sizeof(struct grfinfo)-4);
284		break;
285	case GRFIOCGINFO:
286		memcpy(data, (void *)&gp->g_display, sizeof(struct grfinfo));
287		break;
288	case GRFIOCON:
289		error = grfon(dev);
290		break;
291	case GRFIOCOFF:
292		error = grfoff(dev);
293		break;
294	case GRFIOCSINFO:
295		error = grfsinfo(dev, (struct grfdyninfo *) data);
296		break;
297	case GRFGETVMODE:
298		return(gp->g_mode(gp, GM_GRFGETVMODE, data, 0, 0));
299	case GRFSETVMODE:
300		error = gp->g_mode(gp, GM_GRFSETVMODE, data, 0, 0);
301		if (error == 0 && gp->g_itedev && !(gp->g_flags & GF_GRFON))
302			ite_reinit(gp->g_itedev);
303		break;
304	case GRFGETNUMVM:
305		return(gp->g_mode(gp, GM_GRFGETNUMVM, data, 0, 0));
306	/*
307	 * these are all hardware dependent, and have to be resolved
308	 * in the respective driver.
309	 */
310	case GRFIOCPUTCMAP:
311	case GRFIOCGETCMAP:
312	case GRFIOCSSPRITEPOS:
313	case GRFIOCGSPRITEPOS:
314	case GRFIOCSSPRITEINF:
315	case GRFIOCGSPRITEINF:
316	case GRFIOCGSPRITEMAX:
317	case GRFIOCBITBLT:
318    	case GRFIOCSETMON:
319	case GRFTOGGLE: /* Toggles between Cirrus boards and native ECS on
320                     Amiga. 15/11/94 ill */
321		/*
322		 * We need the minor dev number to get the overlay/image
323		 * information for grf_ul.
324		 */
325		return(gp->g_mode(gp, GM_GRFIOCTL, data, cmd, dev));
326
327	case GRFIOCBLANK:	/* blank ioctl, IOCON/OFF will turn ite on */
328	case FBIOSVIDEO:
329		error = gp->g_mode(gp, GM_GRFIOCTL, data, GRFIOCBLANK, dev);
330		if (!error)
331			gp->g_blank = *(int *)data;
332		return (error);
333
334	case FBIOGVIDEO:
335		*(int *)data = gp->g_blank;
336		return (0);
337
338	default:
339#if NVIEW > 0
340		/*
341		 * check to see whether it's a command recognized by the
342		 * view code if the unit is 0
343		 * XXX
344		 */
345		if (GRFUNIT(dev) == 0) {
346			extern const struct cdevsw view_cdevsw;
347
348			return((*view_cdevsw.d_ioctl)(dev, cmd, data, flag, l));
349		}
350#endif
351		error = EPASSTHROUGH;
352		break;
353
354	}
355	return(error);
356}
357
358/*
359 * map the contents of a graphics display card into process'
360 * memory space.
361 */
362paddr_t
363grfmmap(dev_t dev, off_t off, int prot)
364{
365	struct grf_softc *gp;
366	struct grfinfo *gi;
367
368	gp = grfsp[GRFUNIT(dev)];
369	gi = &gp->g_display;
370
371	/*
372	 * control registers
373	 */
374	if (off >= 0 && off < gi->gd_regsize)
375		return MD_BTOP((paddr_t)gi->gd_regaddr + off);
376
377	/*
378	 * frame buffer
379	 */
380	if (off >= gi->gd_regsize && off < gi->gd_regsize+gi->gd_fbsize) {
381		off -= gi->gd_regsize;
382		return MD_BTOP((paddr_t)gi->gd_fbaddr + off);
383	}
384	/* bogus */
385	return(-1);
386}
387
388int
389grfon(dev_t dev)
390{
391	struct grf_softc *gp;
392
393	gp = grfsp[GRFUNIT(dev)];
394
395	if (gp->g_flags & GF_GRFON)
396		return(0);
397
398	gp->g_flags |= GF_GRFON;
399	if (gp->g_itedev != NODEV)
400		ite_off(gp->g_itedev, 3);
401
402	return(gp->g_mode(gp, (dev & GRFOVDEV) ? GM_GRFOVON : GM_GRFON,
403							NULL, 0, 0));
404}
405
406int
407grfoff(dev_t dev)
408{
409	struct grf_softc *gp;
410	int error;
411
412	gp = grfsp[GRFUNIT(dev)];
413
414	if ((gp->g_flags & GF_GRFON) == 0)
415		return(0);
416
417	gp->g_flags &= ~GF_GRFON;
418	error = gp->g_mode(gp, (dev & GRFOVDEV) ? GM_GRFOVOFF : GM_GRFOFF,
419							NULL, 0, 0);
420
421	/*
422	 * Closely tied together no X's
423	 */
424	if (gp->g_itedev != NODEV)
425		ite_on(gp->g_itedev, 2);
426
427	return(error);
428}
429
430int
431grfsinfo(dev_t dev, struct grfdyninfo *dyninfo)
432{
433	struct grf_softc *gp;
434	int error;
435
436	gp = grfsp[GRFUNIT(dev)];
437	error = gp->g_mode(gp, GM_GRFCONFIG, dyninfo, 0, 0);
438
439	/*
440	 * Closely tied together no X's
441	 */
442	if (gp->g_itedev != NODEV)
443		ite_reinit(gp->g_itedev);
444	return(error);
445}
446
447#if NWSDISPLAY > 0
448void
449grfcnprobe(struct consdev *cd)
450{
451	struct grf_softc *gp;
452	int unit;
453
454	/*
455	 * Find the first working grf device for being console.
456	 * Ignore unit 0 (grfcc), which should use amidisplaycc instead.
457	 */
458	for (unit = 1; unit < NGRF; unit++) {
459		gp = grfsp[unit];
460		if (gp != NULL && (gp->g_flags & GF_ALIVE)) {
461			cd->cn_pri = CN_INTERNAL;
462			cd->cn_dev = NODEV;  /* initialized later by wscons */
463			return;
464		}
465	}
466
467	/* no grf console alive */
468	cd->cn_pri = CN_DEAD;
469}
470
471void
472grfcninit(struct consdev *cd)
473{
474	struct grf_softc *gp;
475	struct rasops_info *ri;
476	long defattr;
477	int unit;
478
479	/* find console grf and set up wsdisplay for it */
480	for (unit = 1; unit < NGRF; unit++) {
481		gp = grfsp[unit];
482		if (gp != NULL && (gp->g_flags & GF_ALIVE)) {
483			gp->g_flags |= GF_CONSOLE;  /* we are console! */
484
485			gp->g_defaultscr->ncols = gp->g_display.gd_fbwidth /
486			    gp->g_defaultscr->fontwidth;
487			gp->g_defaultscr->nrows = gp->g_display.gd_fbheight /
488			    gp->g_defaultscr->fontheight;
489
490			ri = grf_setup_rasops(gp, &console_vcons);
491			console_vcons.scr_cookie = gp;
492			defattr = 0;  /* XXX */
493
494			wsdisplay_preattach(gp->g_defaultscr, ri, 0, 0,
495			    defattr);
496#if NKBD > 0
497			/* tell kbd device it is used as console keyboard */
498			kbd_cnattach();
499#endif
500			return;
501		}
502	}
503	panic("grfcninit: lost console");
504}
505
506static void
507grf_init_screen(void *cookie, struct vcons_screen *scr, int existing,
508    long *defattr)
509{
510	struct grf_softc *gp;
511	struct rasops_info *ri __unused;
512
513	gp = cookie;
514	ri = grf_setup_rasops(gp, scr);
515}
516
517static struct rasops_info *
518grf_setup_rasops(struct grf_softc *gp, struct vcons_screen *scr)
519{
520	struct rasops_info *ri;
521	int i;
522
523	ri = &scr->scr_ri;
524	scr->scr_flags |= VCONS_DONT_READ;
525	memset(ri, 0, sizeof(struct rasops_info));
526
527	ri->ri_rows = gp->g_defaultscr->nrows;
528	ri->ri_cols = gp->g_defaultscr->ncols;
529	ri->ri_hw = scr;
530	ri->ri_ops.cursor    = gp->g_emulops->cursor;
531	ri->ri_ops.mapchar   = gp->g_emulops->mapchar;
532	ri->ri_ops.copyrows  = gp->g_emulops->copyrows;
533	ri->ri_ops.eraserows = gp->g_emulops->eraserows;
534	ri->ri_ops.copycols  = gp->g_emulops->copycols;
535	ri->ri_ops.erasecols = gp->g_emulops->erasecols;
536	ri->ri_ops.putchar   = gp->g_emulops->putchar;
537	ri->ri_ops.allocattr = gp->g_emulops->allocattr;
538
539	/* multiplication table for row-offsets */
540	for (i = 0; i < ri->ri_rows; i++)
541		gp->g_rowoffset[i] = i * ri->ri_cols;
542
543	return ri;
544}
545
546/*
547 * Called as fallback for ioctls which are not handled by the specific
548 * grf driver.
549 */
550int
551grf_wsioctl(void *v, void *vs, u_long cmd, void *data, int flag, struct lwp *l)
552{
553	struct wsdisplayio_fbinfo *iofbi;
554	struct wsdisplay_fbinfo *fbinfo;
555	struct vcons_data *vd;
556	struct grf_softc *gp;
557	struct vcons_screen *scr;
558	struct grfinfo *gi;
559
560	vd = v;
561	gp = vd->cookie;
562	scr = vd->active;
563
564	switch (cmd) {
565	case WSDISPLAYIO_GET_FBINFO:
566		if (scr != NULL) {
567			iofbi = data;
568			return wsdisplayio_get_fbinfo(&scr->scr_ri, iofbi);
569		}
570		return ENODEV;
571
572	case WSDISPLAYIO_GINFO:
573		if (scr != NULL) {
574			fbinfo = (struct wsdisplay_fbinfo *)data;
575			gi = &gp->g_display;
576
577			/*
578			 * We should return truth about the current mode here,
579			 * because X11 wsfb driver depends on this!
580			 */
581			fbinfo->height = gi->gd_fbheight;
582			fbinfo->width = gi->gd_fbwidth;
583			fbinfo->depth = gi->gd_planes;
584			fbinfo->cmsize = gi->gd_colors;
585			return 0;
586		}
587		return ENODEV;
588
589	case WSDISPLAYIO_GTYPE:
590		*(u_int *)data = WSDISPLAY_TYPE_GRF;
591		return 0;
592
593	case WSDISPLAYIO_SMODE:
594		if ((*(int *)data) != gp->g_wsmode) {
595			gp->g_wsmode = *(int *)data;
596			if (gp->g_wsmode == WSDISPLAYIO_MODE_EMUL &&
597			    scr != NULL)
598				vcons_redraw_screen(scr);
599		}
600		return 0;
601	}
602
603	return EPASSTHROUGH;
604}
605
606paddr_t
607grf_wsmmap(void *v, void *vs, off_t off, int prot)
608{
609	struct vcons_data *vd;
610	struct grf_softc *gp;
611	struct grfinfo *gi;
612
613	vd = v;
614	gp = vd->cookie;
615	gi = &gp->g_display;
616
617	/* Normal fb mapping */
618	if (off < gi->gd_fbsize)
619		return MD_BTOP(((paddr_t)gi->gd_fbaddr) + off);
620
621	/*
622	 * restrict all other mappings to processes with superuser privileges
623	 * or the kernel itself
624	 */
625	if (kauth_authorize_machdep(kauth_cred_get(), KAUTH_MACHDEP_UNMANAGEDMEM,
626	    NULL, NULL, NULL, NULL) != 0) {
627		aprint_normal("%s: permission to mmap denied.\n",
628		    device_xname(gp->g_device));
629		return -1;
630	}
631
632	/* Handle register mapping */
633	if ((off >= (paddr_t)gi->gd_regaddr) &&
634	    (off < ((paddr_t)gi->gd_regaddr + (size_t)gi->gd_regsize)))
635		return MD_BTOP(off);
636
637	if ((off >= (paddr_t)gi->gd_fbaddr) &&
638	    (off < ((paddr_t)gi->gd_fbaddr + (size_t)gi->gd_fbsize)))
639		return MD_BTOP(off);
640
641	return -1;
642}
643
644#endif  /* NWSDISPLAY > 0 */
645
646#endif	/* NGRF > 0 */
647