1/*	$NetBSD: cgthree.c,v 1.28 2010/09/14 19:36:13 macallan Exp $ */
2
3/*-
4 * Copyright (c) 1998 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Paul Kranenburg.
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 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32/*
33 * color display (cgthree) driver.
34 *
35 * Does not handle interrupts, even though they can occur.
36 *
37 * XXX should defer colormap updates to vertical retrace interrupts
38 */
39
40#include <sys/cdefs.h>
41__KERNEL_RCSID(0, "$NetBSD: cgthree.c,v 1.28 2010/09/14 19:36:13 macallan Exp $");
42
43#include <sys/param.h>
44#include <sys/systm.h>
45#include <sys/buf.h>
46#include <sys/device.h>
47#include <sys/ioctl.h>
48#include <sys/malloc.h>
49#include <sys/mman.h>
50#include <sys/tty.h>
51#include <sys/conf.h>
52
53#include <sys/bus.h>
54#include <machine/autoconf.h>
55
56#include <dev/sun/fbio.h>
57#include <dev/sun/fbvar.h>
58
59#include <dev/sun/btreg.h>
60#include <dev/sun/btvar.h>
61#include <dev/sun/cgthreereg.h>
62#include <dev/sun/cgthreevar.h>
63
64#if NWSDISPLAY > 0
65#include <dev/wscons/wsconsio.h>
66#include <dev/wsfont/wsfont.h>
67#include <dev/rasops/rasops.h>
68
69#include "opt_wsemul.h"
70#endif
71
72#include "ioconf.h"
73
74static void	cgthreeunblank(device_t);
75static void	cgthreeloadcmap(struct cgthree_softc *, int, int);
76static void	cgthree_set_video(struct cgthree_softc *, int);
77static int	cgthree_get_video(struct cgthree_softc *);
78
79dev_type_open(cgthreeopen);
80dev_type_ioctl(cgthreeioctl);
81dev_type_mmap(cgthreemmap);
82
83const struct cdevsw cgthree_cdevsw = {
84	cgthreeopen, nullclose, noread, nowrite, cgthreeioctl,
85	nostop, notty, nopoll, cgthreemmap, nokqfilter, D_OTHER
86};
87
88/* frame buffer generic driver */
89static struct fbdriver cgthreefbdriver = {
90	cgthreeunblank, cgthreeopen, nullclose, cgthreeioctl, nopoll,
91	cgthreemmap, nokqfilter
92};
93
94/* Video control parameters */
95struct cg3_videoctrl {
96	unsigned char	sense;		/* Monitor sense value */
97	unsigned char	vctrl[12];
98} cg3_videoctrl[] = {
99/* Missing entries: sense 0x10, 0x30, 0x50 */
100	{ 0x40, /* this happens to be my 19'' 1152x900 gray-scale monitor */
101	   {0xbb, 0x2b, 0x3, 0xb, 0xb3, 0x3, 0xaf, 0x2b, 0x2, 0xa, 0xff, 0x1}
102	},
103	{ 0x00, /* default? must be last */
104	   {0xbb, 0x2b, 0x3, 0xb, 0xb3, 0x3, 0xaf, 0x2b, 0x2, 0xa, 0xff, 0x1}
105	}
106};
107
108#if NWSDISPLAY > 0
109#ifdef RASTERCONSOLE
110#error RASTERCONSOLE and wsdisplay are mutually exclusive
111#endif
112
113static void cg3_setup_palette(struct cgthree_softc *);
114
115struct wsscreen_descr cgthree_defaultscreen = {
116	"std",
117	0, 0,	/* will be filled in -- XXX shouldn't, it's global */
118	NULL,		/* textops */
119	8, 16,	/* font width/height */
120	WSSCREEN_WSCOLORS,	/* capabilities */
121	NULL	/* modecookie */
122};
123
124static int 	cgthree_ioctl(void *, void *, u_long, void *, int, struct lwp *);
125static paddr_t	cgthree_mmap(void *, void *, off_t, int);
126static void	cgthree_init_screen(void *, struct vcons_screen *, int, long *);
127
128int	cgthree_putcmap(struct cgthree_softc *, struct wsdisplay_cmap *);
129int	cgthree_getcmap(struct cgthree_softc *, struct wsdisplay_cmap *);
130
131struct wsdisplay_accessops cgthree_accessops = {
132	cgthree_ioctl,
133	cgthree_mmap,
134	NULL,	/* alloc_screen */
135	NULL,	/* free_screen */
136	NULL,	/* show_screen */
137	NULL, 	/* load_font */
138	NULL,	/* pollc */
139	NULL	/* scroll */
140};
141
142const struct wsscreen_descr *_cgthree_scrlist[] = {
143	&cgthree_defaultscreen
144};
145
146struct wsscreen_list cgthree_screenlist = {
147	sizeof(_cgthree_scrlist) / sizeof(struct wsscreen_descr *),
148	_cgthree_scrlist
149};
150
151
152extern const u_char rasops_cmap[768];
153
154static struct vcons_screen cg3_console_screen;
155#endif /* NWSDISPLAY > 0 */
156
157void
158cgthreeattach(struct cgthree_softc *sc, const char *name, int isconsole)
159{
160	int i;
161	struct fbdevice *fb = &sc->sc_fb;
162#if NWSDISPLAY > 0
163	struct wsemuldisplaydev_attach_args aa;
164	struct rasops_info *ri = &cg3_console_screen.scr_ri;
165	unsigned long defattr;
166#endif
167	volatile struct fbcontrol *fbc = sc->sc_fbc;
168	volatile struct bt_regs *bt = &fbc->fbc_dac;
169
170	fb->fb_driver = &cgthreefbdriver;
171	fb->fb_type.fb_cmsize = 256;
172	fb->fb_type.fb_size = fb->fb_type.fb_height * fb->fb_linebytes;
173	printf(": %s, %d x %d", name,
174		fb->fb_type.fb_width, fb->fb_type.fb_height);
175
176	/* Transfer video magic to board, if it's not running */
177	if ((fbc->fbc_ctrl & FBC_TIMING) == 0) {
178		int sense = (fbc->fbc_status & FBS_MSENSE);
179		/* Search table for video timings fitting this monitor */
180		for (i = 0; i < sizeof(cg3_videoctrl)/sizeof(cg3_videoctrl[0]);
181		     i++) {
182			int j;
183			if (sense != cg3_videoctrl[i].sense)
184				continue;
185
186			printf(" setting video ctrl");
187			for (j = 0; j < 12; j++)
188				fbc->fbc_vcontrol[j] =
189					cg3_videoctrl[i].vctrl[j];
190			fbc->fbc_ctrl |= FBC_TIMING;
191			break;
192		}
193	}
194
195	/* make sure we are not blanked */
196	cgthree_set_video(sc, 1);
197	BT_INIT(bt, 0);
198
199	if (isconsole) {
200		printf(" (console)\n");
201#ifdef RASTERCONSOLE
202		fbrcons_init(fb);
203#endif
204	} else
205		printf("\n");
206
207	fb_attach(fb, isconsole);
208
209#if NWSDISPLAY > 0
210	sc->sc_width = fb->fb_type.fb_width;
211	sc->sc_stride = fb->fb_type.fb_width;
212	sc->sc_height = fb->fb_type.fb_height;
213
214	/* setup rasops and so on for wsdisplay */
215	sc->sc_mode = WSDISPLAYIO_MODE_EMUL;
216
217	vcons_init(&sc->vd, sc, &cgthree_defaultscreen, &cgthree_accessops);
218	sc->vd.init_screen = cgthree_init_screen;
219
220	if(isconsole) {
221		/* we mess with cg3_console_screen only once */
222		vcons_init_screen(&sc->vd, &cg3_console_screen, 1,
223		    &defattr);
224		memset(sc->sc_fb.fb_pixels, (defattr >> 16) & 0xff,
225		    sc->sc_stride * sc->sc_height);
226		cg3_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC;
227
228		cgthree_defaultscreen.textops = &ri->ri_ops;
229		cgthree_defaultscreen.capabilities = ri->ri_caps;
230		cgthree_defaultscreen.nrows = ri->ri_rows;
231		cgthree_defaultscreen.ncols = ri->ri_cols;
232		sc->vd.active = &cg3_console_screen;
233		wsdisplay_cnattach(&cgthree_defaultscreen, ri, 0, 0, defattr);
234		vcons_replay_msgbuf(&cg3_console_screen);
235	} else {
236		/*
237		 * we're not the console so we just clear the screen and don't
238		 * set up any sort of text display
239		 */
240	}
241
242	/* Initialize the default color map. */
243	cg3_setup_palette(sc);
244
245	aa.scrdata = &cgthree_screenlist;
246	aa.console = isconsole;
247	aa.accessops = &cgthree_accessops;
248	aa.accesscookie = &sc->vd;
249	config_found(sc->sc_dev, &aa, wsemuldisplaydevprint);
250#else
251	/* Initialize the default color map. */
252	bt_initcmap(&sc->sc_cmap, 256);
253	cgthreeloadcmap(sc, 0, 256);
254#endif
255
256}
257
258
259int
260cgthreeopen(dev_t dev, int flags, int mode, struct lwp *l)
261{
262	int unit = minor(dev);
263
264	if (device_lookup(&cgthree_cd, unit) == NULL)
265		return (ENXIO);
266	return (0);
267}
268
269int
270cgthreeioctl(dev_t dev, u_long cmd, void *data, int flags, struct lwp *l)
271{
272	struct cgthree_softc *sc = device_lookup_private(&cgthree_cd,
273							 minor(dev));
274	struct fbgattr *fba;
275	int error;
276
277	switch (cmd) {
278
279	case FBIOGTYPE:
280		*(struct fbtype *)data = sc->sc_fb.fb_type;
281		break;
282
283	case FBIOGATTR:
284		fba = (struct fbgattr *)data;
285		fba->real_type = sc->sc_fb.fb_type.fb_type;
286		fba->owner = 0;		/* XXX ??? */
287		fba->fbtype = sc->sc_fb.fb_type;
288		fba->sattr.flags = 0;
289		fba->sattr.emu_type = sc->sc_fb.fb_type.fb_type;
290		fba->sattr.dev_specific[0] = -1;
291		fba->emu_types[0] = sc->sc_fb.fb_type.fb_type;
292		fba->emu_types[1] = -1;
293		break;
294
295	case FBIOGETCMAP:
296#define p ((struct fbcmap *)data)
297		return (bt_getcmap(p, &sc->sc_cmap, 256, 1));
298
299	case FBIOPUTCMAP:
300		/* copy to software map */
301		error = bt_putcmap(p, &sc->sc_cmap, 256, 1);
302		if (error)
303			return (error);
304		/* now blast them into the chip */
305		/* XXX should use retrace interrupt */
306		cgthreeloadcmap(sc, p->index, p->count);
307#undef p
308		break;
309
310	case FBIOGVIDEO:
311		*(int *)data = cgthree_get_video(sc);
312		break;
313
314	case FBIOSVIDEO:
315		cgthree_set_video(sc, *(int *)data);
316		break;
317
318	default:
319		return (ENOTTY);
320	}
321	return (0);
322}
323
324/*
325 * Undo the effect of an FBIOSVIDEO that turns the video off.
326 */
327static void
328cgthreeunblank(device_t self)
329{
330	struct cgthree_softc *sc = device_private(self);
331
332	cgthree_set_video(sc, 1);
333}
334
335static void
336cgthree_set_video(struct cgthree_softc *sc, int enable)
337{
338
339	if (enable)
340		sc->sc_fbc->fbc_ctrl |= FBC_VENAB;
341	else
342		sc->sc_fbc->fbc_ctrl &= ~FBC_VENAB;
343}
344
345static int
346cgthree_get_video(struct cgthree_softc *sc)
347{
348
349	return ((sc->sc_fbc->fbc_ctrl & FBC_VENAB) != 0);
350}
351
352/*
353 * Load a subset of the current (new) colormap into the Brooktree DAC.
354 */
355static void
356cgthreeloadcmap(struct cgthree_softc *sc, int start, int ncolors)
357{
358	volatile struct bt_regs *bt;
359	u_int *ip;
360	int count;
361
362	ip = &sc->sc_cmap.cm_chip[BT_D4M3(start)];	/* start/4 * 3 */
363	count = BT_D4M3(start + ncolors - 1) - BT_D4M3(start) + 3;
364	bt = &sc->sc_fbc->fbc_dac;
365	bt->bt_addr = BT_D4M4(start);
366	while (--count >= 0)
367		bt->bt_cmap = *ip++;
368}
369
370/*
371 * Return the address that would map the given device at the given
372 * offset, allowing for the given protection, or return -1 for error.
373 *
374 * The cg3 is mapped starting at 256KB, for pseudo-compatibility with
375 * the cg4 (which had an overlay plane in the first 128K and an enable
376 * plane in the next 128K).  X11 uses only 256k+ region but tries to
377 * map the whole thing, so we repeatedly map the first 256K to the
378 * first page of the color screen.  If someone tries to use the overlay
379 * and enable regions, they will get a surprise....
380 *
381 * As well, mapping at an offset of 0x04000000 causes the cg3 to be
382 * mapped in flat mode without the cg4 emulation.
383 */
384paddr_t
385cgthreemmap(dev_t dev, off_t off, int prot)
386{
387	struct cgthree_softc *sc = device_lookup_private(&cgthree_cd,
388							 minor(dev));
389
390#define START		(128*1024 + 128*1024)
391#define NOOVERLAY	(0x04000000)
392
393	if (off & PGOFSET)
394		panic("cgthreemmap");
395	if (off < 0)
396		return (-1);
397	if ((u_int)off >= NOOVERLAY)
398		off -= NOOVERLAY;
399	else if ((u_int)off >= START)
400		off -= START;
401	else
402		off = 0;
403
404	if (off >= sc->sc_fb.fb_type.fb_size)
405		return (-1);
406
407	return (bus_space_mmap(sc->sc_bustag,
408		sc->sc_paddr, CG3REG_MEM + off,
409		prot, BUS_SPACE_MAP_LINEAR));
410}
411
412#if NWSDISPLAY > 0
413
414static void
415cg3_setup_palette(struct cgthree_softc *sc)
416{
417	int i, j;
418
419	j = 0;
420	for (i = 0; i < 256; i++) {
421		sc->sc_cmap.cm_map[i][0] = rasops_cmap[j];
422		j++;
423		sc->sc_cmap.cm_map[i][1] = rasops_cmap[j];
424		j++;
425		sc->sc_cmap.cm_map[i][2] = rasops_cmap[j];
426		j++;
427	}
428	cgthreeloadcmap(sc, 0, 256);
429}
430
431int
432cgthree_ioctl(void *v, void *vs, u_long cmd, void *data, int flag,
433	struct lwp *l)
434{
435	/* we'll probably need to add more stuff here */
436	struct vcons_data *vd = v;
437	struct cgthree_softc *sc = vd->cookie;
438	struct wsdisplay_fbinfo *wdf;
439	struct rasops_info *ri = &sc->sc_fb.fb_rinfo;
440	struct vcons_screen *ms = sc->vd.active;
441	switch (cmd) {
442		case WSDISPLAYIO_GTYPE:
443			*(u_int *)data = WSDISPLAY_TYPE_SUNTCX;
444			return 0;
445		case WSDISPLAYIO_GINFO:
446			wdf = (void *)data;
447			wdf->height = ri->ri_height;
448			wdf->width = ri->ri_width;
449			wdf->depth = ri->ri_depth;
450			wdf->cmsize = 256;
451			return 0;
452
453		case WSDISPLAYIO_GETCMAP:
454			return cgthree_getcmap(sc,
455			    (struct wsdisplay_cmap *)data);
456		case WSDISPLAYIO_PUTCMAP:
457			return cgthree_putcmap(sc,
458			    (struct wsdisplay_cmap *)data);
459
460		case WSDISPLAYIO_SMODE:
461			{
462				int new_mode = *(int*)data;
463				if (new_mode != sc->sc_mode)
464				{
465					sc->sc_mode = new_mode;
466					if(new_mode == WSDISPLAYIO_MODE_EMUL)
467					{
468						cg3_setup_palette(sc);
469						vcons_redraw_screen(ms);
470					}
471				}
472			}
473	}
474	return EPASSTHROUGH;
475}
476
477paddr_t
478cgthree_mmap(void *v, void *vs, off_t offset, int prot)
479{
480	/* I'm not at all sure this is the right thing to do */
481	return cgthreemmap(0, offset, prot); /* assume minor dev 0 for now */
482}
483
484int
485cgthree_putcmap(struct cgthree_softc *sc, struct wsdisplay_cmap *cm)
486{
487	u_int index = cm->index;
488	u_int count = cm->count;
489	int error,i;
490	if (index >= 256 || count > 256 || index + count > 256)
491		return EINVAL;
492
493	for (i = 0; i < count; i++)
494	{
495		error = copyin(&cm->red[i],
496		    &sc->sc_cmap.cm_map[index + i][0], 1);
497		if (error)
498			return error;
499		error = copyin(&cm->green[i],
500		    &sc->sc_cmap.cm_map[index + i][1],
501		    1);
502		if (error)
503			return error;
504		error = copyin(&cm->blue[i],
505		    &sc->sc_cmap.cm_map[index + i][2], 1);
506		if (error)
507			return error;
508	}
509	cgthreeloadcmap(sc, index, count);
510
511	return 0;
512}
513
514int
515cgthree_getcmap(struct cgthree_softc *sc, struct wsdisplay_cmap *cm)
516{
517	u_int index = cm->index;
518	u_int count = cm->count;
519	int error,i;
520
521	if (index >= 256 || count > 256 || index + count > 256)
522		return EINVAL;
523
524	for (i = 0; i < count; i++)
525	{
526		error = copyout(&sc->sc_cmap.cm_map[index + i][0],
527		    &cm->red[i], 1);
528		if (error)
529			return error;
530		error = copyout(&sc->sc_cmap.cm_map[index + i][1],
531		    &cm->green[i], 1);
532		if (error)
533			return error;
534		error = copyout(&sc->sc_cmap.cm_map[index + i][2],
535		    &cm->blue[i], 1);
536		if (error)
537			return error;
538	}
539
540	return 0;
541}
542
543void
544cgthree_init_screen(void *cookie, struct vcons_screen *scr,
545    int existing, long *defattr)
546{
547	struct cgthree_softc *sc = cookie;
548	struct rasops_info *ri = &scr->scr_ri;
549
550	scr->scr_flags |= VCONS_DONT_READ;
551
552	ri->ri_depth = 8;
553	ri->ri_width = sc->sc_width;
554	ri->ri_height = sc->sc_height;
555	ri->ri_stride = sc->sc_stride;
556	ri->ri_flg = RI_CENTER;
557
558	ri->ri_bits = sc->sc_fb.fb_pixels;
559
560	rasops_init(ri, 0, 0);
561	ri->ri_caps = WSSCREEN_WSCOLORS | WSSCREEN_REVERSE;
562	rasops_reconfig(ri, sc->sc_height / ri->ri_font->fontheight,
563		    sc->sc_width / ri->ri_font->fontwidth);
564
565	ri->ri_hw = scr;
566}
567
568#endif /* NWSDISPLAY > 0 */
569