Annotation of sys/arch/sparc/dev/cgtwo.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: cgtwo.c,v 1.36 2006/12/03 16:40:06 miod Exp $ */
2: /* $NetBSD: cgtwo.c,v 1.22 1997/05/24 20:16:12 pk Exp $ */
3:
4: /*
5: * Copyright (c) 2002 Miodrag Vallat. All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: *
16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
20: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
24: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
25: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26: * POSSIBILITY OF SUCH DAMAGE.
27: *
28: *
29: * Copyright (c) 1992, 1993
30: * The Regents of the University of California. All rights reserved.
31: *
32: * This software was developed by the Computer Systems Engineering group
33: * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
34: * contributed to Berkeley.
35: *
36: * All advertising materials mentioning features or use of this software
37: * must display the following acknowledgement:
38: * This product includes software developed by the University of
39: * California, Lawrence Berkeley Laboratory.
40: *
41: * Redistribution and use in source and binary forms, with or without
42: * modification, are permitted provided that the following conditions
43: * are met:
44: * 1. Redistributions of source code must retain the above copyright
45: * notice, this list of conditions and the following disclaimer.
46: * 2. Redistributions in binary form must reproduce the above copyright
47: * notice, this list of conditions and the following disclaimer in the
48: * documentation and/or other materials provided with the distribution.
49: * 3. Neither the name of the University nor the names of its contributors
50: * may be used to endorse or promote products derived from this software
51: * without specific prior written permission.
52: *
53: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
54: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
55: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
56: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
57: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
58: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
59: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
60: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
61: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
62: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
63: * SUCH DAMAGE.
64: *
65: * from: @(#)cgthree.c 8.2 (Berkeley) 10/30/93
66: */
67:
68: /*
69: * color display (cgtwo) driver.
70: *
71: * Does not handle interrupts, even though they can occur.
72: *
73: * XXX should defer colormap updates to vertical retrace interrupts
74: */
75:
76: #include <sys/param.h>
77: #include <sys/systm.h>
78: #include <sys/buf.h>
79: #include <sys/device.h>
80: #include <sys/ioctl.h>
81: #include <sys/malloc.h>
82: #include <sys/mman.h>
83: #include <sys/tty.h>
84: #include <sys/conf.h>
85:
86: #include <uvm/uvm_extern.h>
87:
88: #include <machine/autoconf.h>
89: #include <machine/pmap.h>
90: #if defined(SUN4)
91: #include <machine/eeprom.h>
92: #endif
93: #include <machine/conf.h>
94:
95: #include <sparc/dev/cgtworeg.h>
96:
97: #include <dev/wscons/wsconsio.h>
98: #include <dev/wscons/wsdisplayvar.h>
99: #include <dev/rasops/rasops.h>
100: #include <machine/fbvar.h>
101:
102:
103: /* per-display variables */
104: struct cgtwo_softc {
105: struct sunfb sc_sunfb; /* common base part */
106: struct rom_reg sc_phys; /* display RAM (phys addr) */
107: volatile struct cg2statusreg *sc_reg; /* CG2 control registers */
108: volatile u_short *sc_ppmask;
109: volatile u_short *sc_cmap;
110: #define sc_redmap(cmap) ((cmap))
111: #define sc_greenmap(cmap) ((cmap) + CG2_CMSIZE)
112: #define sc_bluemap(cmap) ((cmap) + 2 * CG2_CMSIZE)
113: };
114:
115: void cgtwo_burner(void *, u_int, u_int);
116: int cgtwo_getcmap(struct cgtwo_softc *, struct wsdisplay_cmap *);
117: int cgtwo_ioctl(void *, u_long, caddr_t, int, struct proc *);
118: paddr_t cgtwo_mmap(void *, off_t, int);
119: int cgtwo_putcmap(struct cgtwo_softc *, struct wsdisplay_cmap *);
120: void cgtwo_setcolor(void *, u_int, u_int8_t, u_int8_t, u_int8_t);
121:
122: struct wsdisplay_accessops cgtwo_accessops = {
123: cgtwo_ioctl,
124: cgtwo_mmap,
125: NULL, /* alloc_screen */
126: NULL, /* free_screen */
127: NULL, /* show_screen */
128: NULL, /* load_font */
129: NULL, /* scrollback */
130: NULL, /* getchar */
131: cgtwo_burner,
132: NULL /* pollc */
133: };
134:
135: int cgtwomatch(struct device *, void *, void *);
136: void cgtwoattach(struct device *, struct device *, void *);
137:
138: struct cfattach cgtwo_ca = {
139: sizeof(struct cgtwo_softc), cgtwomatch, cgtwoattach
140: };
141:
142: struct cfdriver cgtwo_cd = {
143: NULL, "cgtwo", DV_DULL
144: };
145:
146: int
147: cgtwomatch(struct device *parent, void *vcf, void *aux)
148: {
149: struct cfdata *cf = vcf;
150: struct confargs *ca = aux;
151: struct romaux *ra = &ca->ca_ra;
152: caddr_t tmp;
153:
154: if (strcmp(cf->cf_driver->cd_name, ra->ra_name))
155: return (0);
156:
157: if (!CPU_ISSUN4 || ca->ca_bustype != BUS_VME16)
158: return (0);
159:
160: /* XXX - Must do our own mapping at CG2_CTLREG_OFF */
161: bus_untmp();
162: tmp = (caddr_t)mapdev(ra->ra_reg, TMPMAP_VA, CG2_CTLREG_OFF, NBPG);
163: if (probeget(tmp, 2) != -1)
164: return (1);
165:
166: return (0);
167: }
168:
169: void
170: cgtwoattach(struct device *parent, struct device *self, void *args)
171: {
172: struct cgtwo_softc *sc = (struct cgtwo_softc *)self;
173: struct confargs *ca = args;
174: int node = 0;
175: int isconsole = 0;
176:
177: if (CPU_ISSUN4) {
178: struct eeprom *eep = (struct eeprom *)eeprom_va;
179: /*
180: * Assume this is the console if there's no eeprom info
181: * to be found.
182: */
183: if (eep == NULL || eep->eeConsole == EE_CONS_COLOR)
184: isconsole = 1;
185: }
186:
187: /*
188: * When the ROM has mapped in a cgtwo display, the address
189: * maps only the video RAM, so in any case we have to map the
190: * registers ourselves.
191: */
192: sc->sc_phys = ca->ca_ra.ra_reg[0];
193: /* Apparently, the pixels are 32-bit data space */
194: sc->sc_phys.rr_iospace = PMAP_VME32;
195:
196: sc->sc_reg = (volatile struct cg2statusreg *)
197: mapiodev(ca->ca_ra.ra_reg,
198: CG2_ROPMEM_OFF + offsetof(struct cg2fb, status.reg),
199: sizeof(struct cg2statusreg));
200:
201: sc->sc_ppmask = (volatile u_short *)
202: mapiodev(ca->ca_ra.ra_reg,
203: CG2_ROPMEM_OFF + offsetof(struct cg2fb, ppmask.reg),
204: sizeof(u_short));
205:
206: sc->sc_cmap = (volatile u_short *)
207: mapiodev(ca->ca_ra.ra_reg,
208: CG2_ROPMEM_OFF + offsetof(struct cg2fb, redmap),
209: 3 * CG2_CMSIZE * sizeof(u_short));
210:
211: /* enable video */
212: *sc->sc_ppmask = 0xffff; /* enable all color planes... */
213: cgtwo_burner(sc, 1, 0); /* ... and video signals */
214:
215: fb_setsize(&sc->sc_sunfb, 8, 1152, 900, node, ca->ca_bustype);
216: sc->sc_sunfb.sf_ro.ri_bits = mapiodev(&sc->sc_phys, CG2_PIXMAP_OFF,
217: round_page(sc->sc_sunfb.sf_fbsize));
218: sc->sc_sunfb.sf_ro.ri_hw = sc;
219: fbwscons_init(&sc->sc_sunfb, isconsole ? 0 : RI_CLEAR);
220: fbwscons_setcolormap(&sc->sc_sunfb, cgtwo_setcolor);
221:
222: printf(": %dx%d\n", sc->sc_sunfb.sf_width, sc->sc_sunfb.sf_height);
223:
224: if (isconsole) {
225: fbwscons_console_init(&sc->sc_sunfb, -1);
226: }
227:
228: fbwscons_attach(&sc->sc_sunfb, &cgtwo_accessops, isconsole);
229: }
230:
231: int
232: cgtwo_ioctl(void *v, u_long cmd, caddr_t data, int flags, struct proc *p)
233: {
234: struct cgtwo_softc *sc = v;
235: struct wsdisplay_fbinfo *wdf;
236: struct wsdisplay_cmap *cm;
237: int error;
238:
239: switch (cmd) {
240: case WSDISPLAYIO_GTYPE:
241: *(u_int *)data = WSDISPLAY_TYPE_SUNCG2;
242: break;
243: case WSDISPLAYIO_GINFO:
244: wdf = (struct wsdisplay_fbinfo *)data;
245: wdf->height = sc->sc_sunfb.sf_height;
246: wdf->width = sc->sc_sunfb.sf_width;
247: wdf->depth = sc->sc_sunfb.sf_depth;
248: wdf->cmsize = CG2_CMSIZE;
249: break;
250: case WSDISPLAYIO_LINEBYTES:
251: *(u_int *)data = sc->sc_sunfb.sf_linebytes;
252: break;
253:
254: case WSDISPLAYIO_GETCMAP:
255: cm = (struct wsdisplay_cmap *)data;
256: error = cgtwo_getcmap(sc, cm);
257: if (error)
258: return (error);
259: break;
260:
261: case WSDISPLAYIO_PUTCMAP:
262: cm = (struct wsdisplay_cmap *)data;
263: error = cgtwo_putcmap(sc, cm);
264: if (error)
265: return (error);
266: break;
267:
268: case WSDISPLAYIO_SVIDEO:
269: case WSDISPLAYIO_GVIDEO:
270: break;
271:
272: case WSDISPLAYIO_GCURPOS:
273: case WSDISPLAYIO_SCURPOS:
274: case WSDISPLAYIO_GCURMAX:
275: case WSDISPLAYIO_GCURSOR:
276: case WSDISPLAYIO_SCURSOR:
277: default:
278: return (-1); /* not supported yet */
279: }
280:
281: return (0);
282: }
283:
284: paddr_t
285: cgtwo_mmap(void *v, off_t offset, int prot)
286: {
287: struct cgtwo_softc *sc = v;
288:
289: if (offset & PGOFSET)
290: return (-1);
291:
292: if (offset >= 0 && offset < sc->sc_sunfb.sf_fbsize) {
293: return (REG2PHYS(&sc->sc_phys,
294: CG2_PIXMAP_OFF + offset) | PMAP_NC);
295: }
296:
297: return (-1);
298: }
299:
300: void
301: cgtwo_burner(void *v, u_int on, u_int flags)
302: {
303: struct cgtwo_softc *sc = v;
304: int s;
305:
306: s = splhigh();
307: if (on)
308: sc->sc_reg->video_enab = 1;
309: else
310: sc->sc_reg->video_enab = 0;
311: splx(s);
312: }
313:
314: int
315: cgtwo_getcmap(struct cgtwo_softc *sc, struct wsdisplay_cmap *cmap)
316: {
317: u_int index = cmap->index, count = cmap->count, i;
318: u_char red[CG2_CMSIZE], green[CG2_CMSIZE], blue[CG2_CMSIZE];
319: volatile u_short *hwcmap = sc->sc_cmap;
320: int error;
321: volatile u_short *p;
322:
323:
324: if (index >= CG2_CMSIZE || count >= CG2_CMSIZE - index)
325: return (EINVAL);
326:
327: while (sc->sc_reg->retrace == 0)
328: DELAY(1);
329:
330: sc->sc_reg->update_cmap = 0;
331:
332: /* Copy hardware to local arrays. */
333: p = &sc_redmap(hwcmap)[index];
334: for (i = 0; i < count; i++)
335: red[i] = *p++;
336: p = &sc_greenmap(hwcmap)[index];
337: for (i = 0; i < count; i++)
338: green[i] = *p++;
339: p = &sc_bluemap(hwcmap)[index];
340: for (i = 0; i < count; i++)
341: blue[i] = *p++;
342:
343: sc->sc_reg->update_cmap = 1;
344:
345: /* Copy local arrays to user space. */
346: if ((error = copyout(red, cmap->red, count)) != 0)
347: return (error);
348: if ((error = copyout(green, cmap->green, count)) != 0)
349: return (error);
350: if ((error = copyout(blue, cmap->blue, count)) != 0)
351: return (error);
352:
353: return (0);
354: }
355:
356: int
357: cgtwo_putcmap(struct cgtwo_softc *sc, struct wsdisplay_cmap *cmap)
358: {
359: u_int index = cmap->index, count = cmap->count, i;
360: u_char red[CG2_CMSIZE], green[CG2_CMSIZE], blue[CG2_CMSIZE];
361: volatile u_short *hwcmap = sc->sc_cmap;
362: int error;
363: volatile u_short *p;
364:
365: if (index >= CG2_CMSIZE || count >= CG2_CMSIZE - index)
366: return (EINVAL);
367:
368: /* Copy from user space to local arrays. */
369: if ((error = copyin(cmap->red, red, count)) != 0)
370: return (error);
371: if ((error = copyin(cmap->green, green, count)) != 0)
372: return (error);
373: if ((error = copyin(cmap->blue, blue, count)) != 0)
374: return (error);
375:
376: while (sc->sc_reg->retrace == 0)
377: DELAY(1);
378:
379: sc->sc_reg->update_cmap = 0;
380:
381: /* Copy from local arrays to hardware. */
382: p = &sc_redmap(hwcmap)[index];
383: for (i = 0; i < count; i++)
384: *p++ = red[i];
385: p = &sc_greenmap(hwcmap)[index];
386: for (i = 0; i < count; i++)
387: *p++ = green[i];
388: p = &sc_bluemap(hwcmap)[index];
389: for (i = 0; i < count; i++)
390: *p++ = blue[i];
391:
392: sc->sc_reg->update_cmap = 1;
393:
394: return (0);
395: }
396:
397: void
398: cgtwo_setcolor(void *v, u_int index, u_int8_t r, u_int8_t g, u_int8_t b)
399: {
400: struct cgtwo_softc *sc = v;
401:
402: while (sc->sc_reg->retrace == 0)
403: DELAY(1);
404:
405: sc->sc_reg->update_cmap = 0;
406:
407: sc_redmap(sc->sc_cmap)[index] = r;
408: sc_greenmap(sc->sc_cmap)[index] = g;
409: sc_bluemap(sc->sc_cmap)[index] = b;
410:
411: sc->sc_reg->update_cmap = 1;
412: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to cgtwo.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc / dev