Annotation of sys/arch/sparc/dev/rfx.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rfx.c,v 1.12 2007/02/18 18:40:35 miod Exp $ */
2:
3: /*
4: * Copyright (c) 2004, Miodrag Vallat.
5: * 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:
30: /*
31: * Driver for the Vitec RasterFlex family of frame buffers.
32: * It should support RasterFlex-24, RasterFlex-32 and RasterFlex-HR.
33: */
34:
35: #include <sys/param.h>
36: #include <sys/systm.h>
37: #include <sys/buf.h>
38: #include <sys/device.h>
39: #include <sys/ioctl.h>
40: #include <sys/malloc.h>
41: #include <sys/mman.h>
42: #include <sys/tty.h>
43: #include <sys/conf.h>
44:
45: #include <uvm/uvm_extern.h>
46:
47: #include <machine/autoconf.h>
48: #include <machine/pmap.h>
49: #include <machine/cpu.h>
50: #include <machine/conf.h>
51:
52: #include <dev/wscons/wsconsio.h>
53: #include <dev/wscons/wsdisplayvar.h>
54: #include <dev/rasops/rasops.h>
55: #include <machine/fbvar.h>
56:
57: #include <sparc/dev/sbusvar.h>
58:
59: #include <dev/ic/bt463reg.h>
60:
61: /*
62: * Configuration structure
63: */
64: struct rfx_config {
65: u_int16_t unknown;
66: u_int16_t version;
67: u_int32_t scanline;
68: u_int32_t maxwidth; /* unsure */
69: u_int32_t maxheight; /* unsure */
70: u_int32_t width;
71: u_int32_t height;
72: };
73:
74: /*
75: * In-memory offsets
76: */
77:
78: #define RFX_RAMDAC_ADDR 0x00020000
79: #define RFX_RAMDAC_SIZE 0x00000004
80:
81: #define RFX_CONTROL_ADDR 0x00040000
82: #define RFX_CONTROL_SIZE 0x000000e0
83:
84: #define RFX_INIT_ADDR 0x00018000
85: #define RFX_INIT_OFFSET 0x0000001c
86: #define RFX_INIT_SIZE 0x00008000
87:
88: #define RFX_VRAM_ADDR 0x00100000
89:
90: /*
91: * Control registers
92: */
93:
94: #define RFX_VIDCTRL_REG 0x10
95: #define RFX_VSYNC_ENABLE 0x00000001
96: #define RFX_VIDEO_DISABLE 0x00000002
97:
98: /*
99: * Shadow colormap
100: */
101: struct rfx_cmap {
102: u_int8_t red[256];
103: u_int8_t green[256];
104: u_int8_t blue[256];
105: };
106:
107: struct rfx_softc {
108: struct sunfb sc_sunfb;
109: struct rom_reg sc_phys;
110: struct intrhand sc_ih;
111:
112: struct rfx_cmap sc_cmap;
113: volatile u_int8_t *sc_ramdac;
114: volatile u_int32_t *sc_ctrl;
115: };
116:
117: void rfx_burner(void *, u_int, u_int);
118: int rfx_ioctl(void *, u_long, caddr_t, int, struct proc *);
119: paddr_t rfx_mmap(void *, off_t, int);
120:
121: int rfx_getcmap(struct rfx_cmap *, struct wsdisplay_cmap *);
122: void rfx_initialize(struct rfx_softc *, struct rfx_config *);
123: int rfx_intr(void *);
124: void rfx_loadcmap(struct rfx_softc *, int, int);
125: int rfx_putcmap(struct rfx_cmap *, struct wsdisplay_cmap *);
126: void rfx_setcolor(void *, u_int, u_int8_t, u_int8_t, u_int8_t);
127:
128: struct wsdisplay_accessops rfx_accessops = {
129: rfx_ioctl,
130: rfx_mmap,
131: NULL, /* alloc_screen */
132: NULL, /* free_screen */
133: NULL, /* show_screen */
134: NULL, /* load_font */
135: NULL, /* scrollback */
136: NULL, /* getchar */
137: rfx_burner,
138: NULL /* pollc */
139: };
140:
141: int rfxmatch(struct device *, void *, void *);
142: void rfxattach(struct device *, struct device *, void *);
143:
144: #if defined(OpenBSD)
145:
146: struct cfattach rfx_ca = {
147: sizeof (struct rfx_softc), rfxmatch, rfxattach
148: };
149:
150: struct cfdriver rfx_cd = {
151: NULL, "rfx", DV_DULL
152: };
153:
154: #else
155:
156: CFATTACH_DECL(rfx, sizeof (struct rfx_softc), rfxmatch, rfxattach, NULL, NULL);
157:
158: #endif
159:
160: /*
161: * Match a supported RasterFlex card.
162: */
163: int
164: rfxmatch(struct device *parent, void *vcf, void *aux)
165: {
166: struct confargs *ca = aux;
167: struct romaux *ra = &ca->ca_ra;
168: const char *device = ra->ra_name;
169:
170: /* skip vendor name (could be CWARE, VITec, ...) */
171: while (*device != ',' && *device != '\0')
172: device++;
173: if (*device == '\0')
174: device = ra->ra_name;
175: else
176: device++;
177:
178: if (strncmp(device, "RasterFLEX", strlen("RasterFLEX")) != 0)
179: return (0);
180:
181: /* RasterVideo and RasterFlex-TV are frame grabbers */
182: if (strcmp(device, "RasterFLEX-TV") == 0)
183: return (0);
184:
185: return (1);
186: }
187:
188: /*
189: * Attach and initialize a rfx display, as well as a child wsdisplay.
190: */
191: void
192: rfxattach(struct device *parent, struct device *self, void *args)
193: {
194: struct rfx_softc *sc = (struct rfx_softc *)self;
195: struct confargs *ca = args;
196: const char *device = ca->ca_ra.ra_name;
197: struct rfx_config cf;
198: int node, cflen, isconsole;
199: #if 0
200: int pri;
201: #endif
202:
203: #if 0
204: pri = ca->ca_ra.ra_intr[0].int_pri;
205: printf(" pri %d", pri);
206: #endif
207:
208: /* skip vendor name (could be CWARE, VITec, ...) */
209: while (*device != ',' && *device != '\0')
210: device++;
211: if (*device == '\0')
212: device = ca->ca_ra.ra_name;
213: else
214: device++;
215: printf(": %s", device);
216:
217: if (ca->ca_ra.ra_nreg == 0) {
218: printf("\n%s: no SBus registers!\n",
219: self->dv_xname);
220: return;
221: }
222:
223: node = ca->ca_ra.ra_node;
224: isconsole = node == fbnode;
225:
226: /*
227: * Parse configuration structure
228: */
229: cflen = getproplen(node, "configuration");
230: if (cflen != sizeof cf) {
231: printf(", unknown %d bytes conf. structure", cflen);
232: /* fill in default values */
233: cf.version = 0;
234: cf.scanline = 2048;
235: cf.width = 1152;
236: cf.height = 900;
237: } else {
238: getprop(node, "configuration", &cf, cflen);
239: printf(", revision %d", cf.version);
240: }
241:
242: /*
243: * Map registers
244: */
245: sc->sc_ramdac = (u_int8_t *)
246: mapiodev(ca->ca_ra.ra_reg, RFX_RAMDAC_ADDR, RFX_RAMDAC_SIZE);
247: sc->sc_ctrl = (u_int32_t *)
248: mapiodev(ca->ca_ra.ra_reg, RFX_CONTROL_ADDR, RFX_CONTROL_SIZE);
249: sc->sc_phys = ca->ca_ra.ra_reg[0];
250:
251: #if 0 /* not yet */
252: sc->sc_ih.ih_fun = rfx_intr;
253: sc->sc_ih.ih_arg = sc;
254: intr_establish(pri, &sc->sc_ih, IPL_FB, self->dv_xname);
255: #endif
256:
257: /*
258: * The following is an equivalent for
259: * fb_setsize(&sc->sc_sunfb, 8, cf.width, cf.height,
260: * node, ca->ca_bustype);
261: * forcing the correct scan line value. Since the usual frame buffer
262: * properties are missing on this card, no need to go through
263: * fb_setsize()...
264: */
265: sc->sc_sunfb.sf_depth = 8;
266: sc->sc_sunfb.sf_width = cf.width;
267: sc->sc_sunfb.sf_height = cf.height;
268: sc->sc_sunfb.sf_linebytes = cf.scanline;
269: sc->sc_sunfb.sf_fbsize = cf.height * cf.scanline;
270:
271: printf(", %dx%d\n", sc->sc_sunfb.sf_width, sc->sc_sunfb.sf_height);
272:
273: sc->sc_sunfb.sf_ro.ri_bits = mapiodev(ca->ca_ra.ra_reg,
274: RFX_VRAM_ADDR, round_page(sc->sc_sunfb.sf_fbsize));
275: sc->sc_sunfb.sf_ro.ri_hw = sc;
276:
277: /*
278: * If we are not the console, the frame buffer has not been
279: * initalized by the PROM - do this ourselves.
280: */
281: if (!isconsole)
282: rfx_initialize(sc, &cf);
283:
284: fbwscons_init(&sc->sc_sunfb, isconsole ? 0 : RI_CLEAR);
285:
286: bzero(&sc->sc_cmap, sizeof(sc->sc_cmap));
287: fbwscons_setcolormap(&sc->sc_sunfb, rfx_setcolor);
288:
289: if (isconsole) {
290: fbwscons_console_init(&sc->sc_sunfb, -1);
291: }
292:
293: /* enable video */
294: rfx_burner(sc, 1, 0);
295:
296: fbwscons_attach(&sc->sc_sunfb, &rfx_accessops, isconsole);
297: }
298:
299: /*
300: * Common wsdisplay operations
301: */
302:
303: int
304: rfx_ioctl(void *v, u_long cmd, caddr_t data, int flags, struct proc *p)
305: {
306: struct rfx_softc *sc = v;
307: struct wsdisplay_cmap *cm;
308: struct wsdisplay_fbinfo *wdf;
309: int error;
310:
311: switch (cmd) {
312: case WSDISPLAYIO_GTYPE:
313: *(u_int *)data = WSDISPLAY_TYPE_RFLEX;
314: break;
315: case WSDISPLAYIO_GINFO:
316: wdf = (struct wsdisplay_fbinfo *)data;
317: wdf->height = sc->sc_sunfb.sf_height;
318: wdf->width = sc->sc_sunfb.sf_width;
319: wdf->depth = sc->sc_sunfb.sf_depth;
320: wdf->cmsize = 256;
321: break;
322: case WSDISPLAYIO_LINEBYTES:
323: *(u_int *)data = sc->sc_sunfb.sf_linebytes;
324: break;
325:
326: case WSDISPLAYIO_GETCMAP:
327: cm = (struct wsdisplay_cmap *)data;
328: error = rfx_getcmap(&sc->sc_cmap, cm);
329: if (error != 0)
330: return (error);
331: break;
332: case WSDISPLAYIO_PUTCMAP:
333: cm = (struct wsdisplay_cmap *)data;
334: error = rfx_putcmap(&sc->sc_cmap, cm);
335: if (error != 0)
336: return (error);
337: rfx_loadcmap(sc, cm->index, cm->count);
338: break;
339:
340: case WSDISPLAYIO_SVIDEO:
341: case WSDISPLAYIO_GVIDEO:
342: break;
343:
344: default:
345: return (-1);
346: }
347:
348: return (0);
349: }
350:
351: paddr_t
352: rfx_mmap(void *v, off_t offset, int prot)
353: {
354: struct rfx_softc *sc = v;
355:
356: if (offset & PGOFSET)
357: return (-1);
358:
359: if (offset >= 0 && offset < sc->sc_sunfb.sf_fbsize) {
360: return (REG2PHYS(&sc->sc_phys, RFX_VRAM_ADDR + offset) |
361: PMAP_NC);
362: }
363:
364: return (-1);
365: }
366:
367: void
368: rfx_burner(void *v, u_int on, u_int flags)
369: {
370: struct rfx_softc *sc = v;
371:
372: if (on) {
373: sc->sc_ctrl[RFX_VIDCTRL_REG] &= ~RFX_VIDEO_DISABLE;
374: sc->sc_ctrl[RFX_VIDCTRL_REG] |= RFX_VSYNC_ENABLE;
375: } else {
376: sc->sc_ctrl[RFX_VIDCTRL_REG] |= RFX_VIDEO_DISABLE;
377: if (flags & WSDISPLAY_BURN_VBLANK)
378: sc->sc_ctrl[RFX_VIDCTRL_REG] &= ~RFX_VSYNC_ENABLE;
379: }
380: }
381:
382: /*
383: * Colormap helper functions
384: */
385:
386: void
387: rfx_setcolor(void *v, u_int index, u_int8_t r, u_int8_t g, u_int8_t b)
388: {
389: struct rfx_softc *sc = v;
390:
391: sc->sc_cmap.red[index] = r;
392: sc->sc_cmap.green[index] = g;
393: sc->sc_cmap.blue[index] = b;
394:
395: rfx_loadcmap(sc, index, 1);
396: }
397:
398: int
399: rfx_getcmap(struct rfx_cmap *cm, struct wsdisplay_cmap *rcm)
400: {
401: u_int index = rcm->index, count = rcm->count;
402: int error;
403:
404: if (index >= 256 || count > 256 - index)
405: return (EINVAL);
406:
407: if ((error = copyout(cm->red + index, rcm->red, count)) != 0)
408: return (error);
409: if ((error = copyout(cm->green + index, rcm->green, count)) != 0)
410: return (error);
411: if ((error = copyout(cm->blue + index, rcm->blue, count)) != 0)
412: return (error);
413:
414: return (0);
415: }
416:
417: int
418: rfx_putcmap(struct rfx_cmap *cm, struct wsdisplay_cmap *rcm)
419: {
420: u_int index = rcm->index, count = rcm->count;
421: u_int8_t red[256], green[256], blue[256];
422: int error;
423:
424: if (index >= 256 || count > 256 - index)
425: return (EINVAL);
426:
427: if ((error = copyin(rcm->red, red, count)) != 0)
428: return (error);
429: if ((error = copyin(rcm->green, green, count)) != 0)
430: return (error);
431: if ((error = copyin(rcm->blue, blue, count)) != 0)
432: return (error);
433:
434: bcopy(red, cm->red + index, count);
435: bcopy(green, cm->green + index, count);
436: bcopy(blue, cm->blue + index, count);
437:
438: return (0);
439: }
440:
441: void
442: rfx_loadcmap(struct rfx_softc *sc, int start, int ncolors)
443: {
444: u_int8_t *r, *g, *b;
445:
446: r = sc->sc_cmap.red + start;
447: g = sc->sc_cmap.green + start;
448: b = sc->sc_cmap.blue + start;
449:
450: start += BT463_IREG_CPALETTE_RAM;
451: sc->sc_ramdac[BT463_REG_ADDR_LOW] = start & 0xff;
452: sc->sc_ramdac[BT463_REG_ADDR_HIGH] = (start >> 8) & 0xff;
453:
454: while (ncolors-- != 0) {
455: sc->sc_ramdac[BT463_REG_CMAP_DATA] = *r++;
456: sc->sc_ramdac[BT463_REG_CMAP_DATA] = *g++;
457: sc->sc_ramdac[BT463_REG_CMAP_DATA] = *b++;
458: }
459: }
460:
461: /*
462: * Initialization code parser
463: */
464:
465: void
466: rfx_initialize(struct rfx_softc *sc, struct rfx_config *cf)
467: {
468: u_int32_t *data, offset, value;
469: size_t cnt;
470:
471: /*
472: * Map the initialization data - this is a waste as we won't be
473: * able to reclaim this mapping...
474: */
475: data = (u_int32_t *)
476: mapiodev(&sc->sc_phys, RFX_INIT_ADDR, RFX_INIT_SIZE);
477:
478: /*
479: * Skip copyright notice
480: */
481: data += RFX_INIT_OFFSET / sizeof(u_int32_t);
482: cnt = (RFX_INIT_SIZE - RFX_INIT_OFFSET) / sizeof(u_int32_t);
483: cnt >>= 1;
484:
485: /*
486: * Parse and apply settings
487: */
488: while (cnt != 0) {
489: offset = *data++;
490: value = *data++;
491:
492: if (offset == (u_int32_t)-1 && value == (u_int32_t)-1)
493: break;
494:
495: /* Old PROM are little-endian */
496: if (cf->version <= 1) {
497: offset = letoh32(offset);
498: value = letoh32(offset);
499: }
500:
501: if (offset & (1 << 31)) {
502: offset = (offset & ~(1 << 31)) - RFX_RAMDAC_ADDR;
503: if (offset < RFX_RAMDAC_SIZE)
504: sc->sc_ramdac[offset] = value >> 24;
505: } else {
506: offset -= RFX_CONTROL_ADDR;
507: if (offset < RFX_CONTROL_SIZE)
508: sc->sc_ctrl[offset >> 2] = value;
509: }
510:
511: cnt--;
512: }
513: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rfx.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc / dev