Annotation of sys/dev/sbus/cgtwelve.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: cgtwelve.c,v 1.5 2007/03/13 19:40:49 miod Exp $ */
2:
3: /*
4: * Copyright (c) 2002, 2003 Miodrag Vallat. All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions
8: * are met:
9: * 1. Redistributions of source code must retain the above copyright
10: * notice, this list of conditions and the following disclaimer.
11: * 2. Redistributions in binary form must reproduce the above copyright
12: * notice, this list of conditions and the following disclaimer in the
13: * documentation and/or other materials provided with the distribution.
14: *
15: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
19: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
21: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
23: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
24: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25: * POSSIBILITY OF SUCH DAMAGE.
26: */
27:
28: /*
29: * cgtwelve (GS) accelerated 24-bit framebuffer driver.
30: *
31: * Enough experiments and SMI's cg12reg.h made this possible.
32: */
33:
34: /*
35: * The cgtwelve framebuffer is a 3-slot SBUS card, that will fit only in
36: * SPARCstation 1, 1+, 2 and 5, or in an xbox SBUS extension.
37: *
38: * It is a 24-bit 3D accelerated framebuffer made by Matrox, featuring 4MB
39: * (regular model) or 8MB (high-res model) of video memory, a complex
40: * windowing engine, double buffering modes, three video planes (overlay,
41: * 8 bit and 24 bit color), and a lot of colormap combinations.
42: *
43: * All of this is driven by a set of three Bt462 ramdacs (latched unless
44: * explicitely programmed), and a couple of other Matrox-specific chips.
45: *
46: * XXX The high res card is untested.
47: */
48:
49: #include <sys/param.h>
50: #include <sys/systm.h>
51: #include <sys/buf.h>
52: #include <sys/device.h>
53: #include <sys/ioctl.h>
54: #include <sys/conf.h>
55:
56: #include <uvm/uvm_extern.h>
57:
58: #include <machine/autoconf.h>
59: #include <machine/bus.h>
60: #include <machine/pmap.h>
61: #include <machine/cpu.h>
62: #include <machine/conf.h>
63:
64: #include <dev/wscons/wsconsio.h>
65: #include <dev/wscons/wsdisplayvar.h>
66: #include <dev/rasops/rasops.h>
67: #include <machine/fbvar.h>
68:
69: #include <dev/sbus/sbusvar.h>
70:
71: #include <dev/sbus/cgtwelvereg.h>
72:
73: #include <dev/cons.h> /* for prom console hook */
74:
75: /* per-display variables */
76: struct cgtwelve_softc {
77: struct sunfb sc_sunfb; /* common base device */
78: bus_space_tag_t sc_bustag;
79: bus_addr_t sc_paddr;
80:
81: volatile struct cgtwelve_dpu *sc_dpu;
82: volatile struct cgtwelve_apu *sc_apu;
83: volatile struct cgtwelve_dac *sc_ramdac; /* RAMDAC registers */
84: volatile u_char *sc_overlay; /* overlay or enable plane */
85: volatile u_long *sc_inten; /* true color plane */
86:
87: int sc_highres;
88: int sc_nscreens;
89: };
90:
91: int cgtwelve_ioctl(void *, u_long, caddr_t, int, struct proc *);
92: int cgtwelve_alloc_screen(void *, const struct wsscreen_descr *, void **,
93: int *, int *, long *);
94: void cgtwelve_free_screen(void *, void *);
95: int cgtwelve_show_screen(void *, void *, int, void (*cb)(void *, int, int),
96: void *);
97: paddr_t cgtwelve_mmap(void *, off_t, int);
98: void cgtwelve_reset(struct cgtwelve_softc *, int);
99: void cgtwelve_prom(void *);
100:
101: static __inline__ void cgtwelve_ramdac_wraddr(struct cgtwelve_softc *sc,
102: u_int32_t addr);
103:
104: struct wsdisplay_accessops cgtwelve_accessops = {
105: cgtwelve_ioctl,
106: cgtwelve_mmap,
107: cgtwelve_alloc_screen,
108: cgtwelve_free_screen,
109: cgtwelve_show_screen,
110: NULL, /* load_font */
111: NULL, /* scrollback */
112: NULL, /* getchar */
113: NULL /* burner */
114: };
115:
116: int cgtwelvematch(struct device *, void *, void *);
117: void cgtwelveattach(struct device *, struct device *, void *);
118:
119: struct cfattach cgtwelve_ca = {
120: sizeof(struct cgtwelve_softc), cgtwelvematch, cgtwelveattach
121: };
122:
123: struct cfdriver cgtwelve_cd = {
124: NULL, "cgtwelve", DV_DULL
125: };
126:
127:
128: /*
129: * Match a cgtwelve.
130: */
131: int
132: cgtwelvematch(struct device *parent, void *vcf, void *aux)
133: {
134: struct cfdata *cf = vcf;
135: struct sbus_attach_args *sa = aux;
136:
137: if (strcmp(cf->cf_driver->cd_name, sa->sa_name) != 0)
138: return (0);
139:
140: return (1);
141: }
142:
143: /*
144: * Attach and initialize a cgtwelve.
145: */
146: void
147: cgtwelveattach(struct device *parent, struct device *self, void *args)
148: {
149: struct cgtwelve_softc *sc = (struct cgtwelve_softc *)self;
150: struct sbus_attach_args *sa = args;
151: bus_space_tag_t bt;
152: bus_space_handle_t bh;
153: int node, isconsole = 0;
154: char *ps;
155:
156: bt = sa->sa_bustag;
157: node = sa->sa_node;
158:
159: printf(": %s", getpropstring(node, "model"));
160: ps = getpropstring(node, "dev_id");
161: if (*ps != '\0')
162: printf(" (%s)", ps);
163: printf("\n");
164:
165: isconsole = node == fbnode;
166:
167: if (sa->sa_nreg == 0) {
168: printf("%s: no SBus registers!\n", self->dv_xname);
169: return;
170: }
171:
172: sc->sc_bustag = bt;
173:
174: /*
175: * Map registers
176: */
177: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset +
178: CG12_OFF_DPU, sizeof(struct cgtwelve_dpu),
179: BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
180: printf("%s: can't map DPU registers\n", self->dv_xname);
181: return;
182: }
183: sc->sc_dpu = bus_space_vaddr(bt, bh);
184: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset +
185: CG12_OFF_APU, sizeof(struct cgtwelve_apu),
186: BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
187: printf("%s: can't map APU registers\n", self->dv_xname);
188: return;
189: }
190: sc->sc_apu = bus_space_vaddr(bt, bh);
191: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset +
192: CG12_OFF_DAC, sizeof(struct cgtwelve_dac),
193: BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
194: printf("%s: can't map RAMDAC registers\n", self->dv_xname);
195: return;
196: }
197: sc->sc_ramdac = bus_space_vaddr(bt, bh);
198:
199: /*
200: * The console is using the 1-bit overlay plane, while the prom
201: * will correctly report 32 bit depth.
202: */
203: fb_setsize(&sc->sc_sunfb, 1, CG12_WIDTH, CG12_HEIGHT,
204: node, 0);
205: sc->sc_sunfb.sf_depth = 1;
206: sc->sc_sunfb.sf_linebytes = sc->sc_sunfb.sf_width / 8;
207: sc->sc_sunfb.sf_fbsize = sc->sc_sunfb.sf_height *
208: sc->sc_sunfb.sf_linebytes;
209:
210: sc->sc_highres = sc->sc_sunfb.sf_width == CG12_WIDTH_HR;
211:
212: /*
213: * Map planes
214: */
215: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset +
216: (sc->sc_highres ? CG12_OFF_OVERLAY0_HR : CG12_OFF_OVERLAY0),
217: round_page(sc->sc_highres ? CG12_SIZE_OVERLAY_HR :
218: CG12_SIZE_OVERLAY), BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
219: printf("%s: can't map overlay plane\n", self->dv_xname);
220: return;
221: }
222: sc->sc_overlay = bus_space_vaddr(bt, bh);
223: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset +
224: (sc->sc_highres ? CG12_OFF_INTEN_HR : CG12_OFF_INTEN),
225: round_page(sc->sc_highres ? CG12_SIZE_COLOR24_HR :
226: CG12_SIZE_COLOR24), BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
227: printf("%s: can't map color plane\n", self->dv_xname);
228: return;
229: }
230: sc->sc_inten = bus_space_vaddr(bt, bh);
231: sc->sc_paddr = sbus_bus_addr(bt, sa->sa_slot, sa->sa_offset +
232: (sc->sc_highres ? CG12_OFF_INTEN_HR : CG12_OFF_INTEN));
233:
234: /* reset cursor & frame buffer controls */
235: sc->sc_sunfb.sf_depth = 0; /* force action */
236: cgtwelve_reset(sc, 1);
237:
238: sc->sc_sunfb.sf_ro.ri_bits = (void *)sc->sc_overlay;
239: sc->sc_sunfb.sf_ro.ri_hw = sc;
240: fbwscons_init(&sc->sc_sunfb, isconsole ? 0 : RI_CLEAR);
241:
242: if (isconsole) {
243: fbwscons_console_init(&sc->sc_sunfb, -1);
244: shutdownhook_establish(cgtwelve_prom, sc);
245: }
246:
247: printf("%s: %dx%d", self->dv_xname,
248: sc->sc_sunfb.sf_width, sc->sc_sunfb.sf_height);
249: ps = getpropstring(node, "ucoderev");
250: if (*ps != '\0')
251: printf(", microcode rev. %s", ps);
252: printf("\n");
253:
254: fbwscons_attach(&sc->sc_sunfb, &cgtwelve_accessops, isconsole);
255: }
256:
257: int
258: cgtwelve_ioctl(void *dev, u_long cmd, caddr_t data, int flags, struct proc *p)
259: {
260: struct cgtwelve_softc *sc = dev;
261: struct wsdisplay_fbinfo *wdf;
262:
263: /*
264: * Note that, although the emulation (text) mode is running in the
265: * overlay plane, we advertize the frame buffer as the full-blown
266: * 32-bit beast it is.
267: */
268: switch (cmd) {
269: case WSDISPLAYIO_GTYPE:
270: *(u_int *)data = WSDISPLAY_TYPE_SUNCG12;
271: break;
272: case WSDISPLAYIO_GINFO:
273: wdf = (struct wsdisplay_fbinfo *)data;
274: wdf->height = sc->sc_sunfb.sf_height;
275: wdf->width = sc->sc_sunfb.sf_width;
276: wdf->depth = 32;
277: wdf->cmsize = 0;
278: break;
279: case WSDISPLAYIO_GETSUPPORTEDDEPTH:
280: *(u_int *)data = WSDISPLAYIO_DEPTH_24_32;
281: break;
282: case WSDISPLAYIO_LINEBYTES:
283: *(u_int *)data = sc->sc_sunfb.sf_linebytes * 32;
284: break;
285:
286: case WSDISPLAYIO_GETCMAP:
287: case WSDISPLAYIO_PUTCMAP:
288: break;
289:
290: case WSDISPLAYIO_SMODE:
291: if (*(int *)data == WSDISPLAYIO_MODE_EMUL) {
292: /* Back from X11 to text mode */
293: cgtwelve_reset(sc, 1);
294: } else {
295: /* Starting X11, switch to 32 bit mode */
296: cgtwelve_reset(sc, 32);
297: }
298: break;
299:
300: case WSDISPLAYIO_SVIDEO:
301: case WSDISPLAYIO_GVIDEO:
302: break;
303:
304: default:
305: return (-1); /* not supported yet */
306: }
307:
308: return (0);
309: }
310:
311: /*
312: * Clean up hardware state (e.g., after bootup or after X crashes).
313: */
314: void
315: cgtwelve_reset(struct cgtwelve_softc *sc, int depth)
316: {
317: u_int32_t c;
318:
319: if (sc->sc_sunfb.sf_depth != depth) {
320: if (depth == 1) {
321: /*
322: * Select the enable plane as sc_overlay, and fill it.
323: */
324: sc->sc_apu->hpage = sc->sc_highres ?
325: CG12_HPAGE_ENABLE_HR : CG12_HPAGE_ENABLE;
326: sc->sc_apu->haccess = CG12_HACCESS_ENABLE;
327: sc->sc_dpu->pln_sl_host = CG12_PLN_SL_ENABLE;
328: sc->sc_dpu->pln_rd_msk_host = CG12_PLN_RD_ENABLE;
329: sc->sc_dpu->pln_wr_msk_host = CG12_PLN_WR_ENABLE;
330:
331: memset((void *)sc->sc_overlay, 0xff, sc->sc_highres ?
332: CG12_SIZE_ENABLE_HR : CG12_SIZE_ENABLE);
333:
334: /*
335: * Select the overlay plane as sc_overlay.
336: */
337: sc->sc_apu->hpage = sc->sc_highres ?
338: CG12_HPAGE_OVERLAY_HR : CG12_HPAGE_OVERLAY;
339: sc->sc_apu->haccess = CG12_HACCESS_OVERLAY;
340: sc->sc_dpu->pln_sl_host = CG12_PLN_SL_OVERLAY;
341: sc->sc_dpu->pln_rd_msk_host = CG12_PLN_RD_OVERLAY;
342: sc->sc_dpu->pln_wr_msk_host = CG12_PLN_WR_OVERLAY;
343:
344: /*
345: * Upload a strict mono colormap, or the text
346: * upon returning from 32 bit mode would appear
347: * as (slightly dark) white on white.
348: */
349: cgtwelve_ramdac_wraddr(sc, 0);
350: sc->sc_ramdac->color = 0x00000000;
351: for (c = 1; c < 256; c++)
352: sc->sc_ramdac->color = 0x00ffffff;
353: } else {
354: /*
355: * Select the overlay plane as sc_overlay.
356: */
357: sc->sc_apu->hpage = sc->sc_highres ?
358: CG12_HPAGE_OVERLAY_HR : CG12_HPAGE_OVERLAY;
359: sc->sc_apu->haccess = CG12_HACCESS_OVERLAY;
360: sc->sc_dpu->pln_sl_host = CG12_PLN_SL_OVERLAY;
361: sc->sc_dpu->pln_rd_msk_host = CG12_PLN_RD_OVERLAY;
362: sc->sc_dpu->pln_wr_msk_host = CG12_PLN_WR_OVERLAY;
363:
364: /*
365: * Do not attempt to somewhat preserve screen
366: * contents - reading the overlay plane and writing
367: * to the color plane at the same time is not
368: * reliable, and allocating memory to save a copy
369: * of the overlay plane would be awful.
370: */
371: bzero((void *)sc->sc_overlay, sc->sc_highres ?
372: CG12_SIZE_OVERLAY_HR : CG12_SIZE_OVERLAY);
373:
374: /*
375: * Select the enable plane as sc_overlay, and clear it.
376: */
377: sc->sc_apu->hpage = sc->sc_highres ?
378: CG12_HPAGE_ENABLE_HR : CG12_HPAGE_ENABLE;
379: sc->sc_apu->haccess = CG12_HACCESS_ENABLE;
380: sc->sc_dpu->pln_sl_host = CG12_PLN_SL_ENABLE;
381: sc->sc_dpu->pln_rd_msk_host = CG12_PLN_RD_ENABLE;
382: sc->sc_dpu->pln_wr_msk_host = CG12_PLN_WR_ENABLE;
383:
384: bzero((void *)sc->sc_overlay, sc->sc_highres ?
385: CG12_SIZE_ENABLE_HR : CG12_SIZE_ENABLE);
386:
387: /*
388: * Select the intensity (color) plane, and clear it.
389: */
390: sc->sc_apu->hpage = sc->sc_highres ?
391: CG12_HPAGE_24BIT_HR : CG12_HPAGE_24BIT;
392: sc->sc_apu->haccess = CG12_HACCESS_24BIT;
393: sc->sc_dpu->pln_sl_host = CG12_PLN_SL_24BIT;
394: sc->sc_dpu->pln_rd_msk_host = CG12_PLN_RD_24BIT;
395: sc->sc_dpu->pln_wr_msk_host = CG12_PLN_WR_24BIT;
396:
397: memset((void *)sc->sc_inten, 0x00ffffff,
398: sc->sc_highres ?
399: CG12_SIZE_COLOR24_HR : CG12_SIZE_COLOR24);
400:
401: /*
402: * Use a direct colormap (ramp)
403: */
404: cgtwelve_ramdac_wraddr(sc, 0);
405: for (c = 0; c < 256; c++)
406: sc->sc_ramdac->color = c | (c << 8) | (c << 16);
407: }
408: }
409:
410: sc->sc_sunfb.sf_depth = depth;
411: }
412:
413: /*
414: * Return the address that would map the given device at the given
415: * offset, allowing for the given protection, or return -1 for error.
416: */
417: paddr_t
418: cgtwelve_mmap(void *v, off_t offset, int prot)
419: {
420: struct cgtwelve_softc *sc = v;
421:
422: if (offset & PGOFSET || offset < 0)
423: return (-1);
424:
425: /*
426: * Note that mmap() will invoke this function only if we are NOT
427: * in emulation mode, so we can assume 32 bit mode safely here.
428: */
429: if (offset < sc->sc_sunfb.sf_fbsize * 32) {
430: return (bus_space_mmap(sc->sc_bustag, sc->sc_paddr, offset,
431: prot, BUS_SPACE_MAP_LINEAR));
432: }
433:
434: return (-1);
435: }
436:
437: int
438: cgtwelve_alloc_screen(void *v, const struct wsscreen_descr *type,
439: void **cookiep, int *curxp, int *curyp, long *attrp)
440: {
441: struct cgtwelve_softc *sc = v;
442:
443: if (sc->sc_nscreens > 0)
444: return (ENOMEM);
445:
446: *cookiep = &sc->sc_sunfb.sf_ro;
447: *curyp = 0;
448: *curxp = 0;
449: sc->sc_sunfb.sf_ro.ri_ops.alloc_attr(&sc->sc_sunfb.sf_ro,
450: 0, 0, 0, attrp);
451: sc->sc_nscreens++;
452: return (0);
453: }
454:
455: void
456: cgtwelve_free_screen(void *v, void *cookie)
457: {
458: struct cgtwelve_softc *sc = v;
459:
460: sc->sc_nscreens--;
461: }
462:
463: int
464: cgtwelve_show_screen(void *v, void *cookie, int waitok,
465: void (*cb)(void *, int, int), void *cbarg)
466: {
467: return (0);
468: }
469:
470: /*
471: * Simple Bt462 programming routines.
472: */
473:
474: static __inline__ void
475: cgtwelve_ramdac_wraddr(struct cgtwelve_softc *sc, u_int32_t addr)
476: {
477: sc->sc_ramdac->addr_lo = (addr & 0xff);
478: sc->sc_ramdac->addr_hi = ((addr >> 8) & 0xff);
479: }
480:
481: /*
482: * Shutdown hook used to restore PROM-compatible video mode on shutdown,
483: * so that the PROM prompt is visible again.
484: */
485: void
486: cgtwelve_prom(void *v)
487: {
488: struct cgtwelve_softc *sc = v;
489: extern struct consdev consdev_prom;
490:
491: if (sc->sc_sunfb.sf_depth != 1) {
492: cgtwelve_reset(sc, 1);
493:
494: /*
495: * Go back to prom output for the last few messages, so they
496: * will be displayed correctly.
497: */
498: cn_tab = &consdev_prom;
499: }
500: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to cgtwelve.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / sbus