Annotation of sys/dev/sbus/rfx.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rfx.c,v 1.7 2006/12/17 22:18:16 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: #include <machine/openfirm.h>
52:
53: #include <dev/wscons/wsconsio.h>
54: #include <dev/wscons/wsdisplayvar.h>
55: #include <dev/rasops/rasops.h>
56: #include <machine/fbvar.h>
57:
58: #include <dev/sbus/sbusvar.h>
59:
60: #include <dev/ic/bt463reg.h>
61:
62: /*
63: * Configuration structure
64: */
65: struct rfx_config {
66: u_int16_t unknown;
67: u_int16_t version;
68: u_int32_t scanline;
69: u_int32_t maxwidth; /* unsure */
70: u_int32_t maxheight; /* unsure */
71: u_int32_t width;
72: u_int32_t height;
73: };
74:
75: /*
76: * In-memory offsets
77: */
78:
79: #define RFX_RAMDAC_ADDR 0x00020000
80: #define RFX_RAMDAC_SIZE 0x00000004
81:
82: #define RFX_CONTROL_ADDR 0x00040000
83: #define RFX_CONTROL_SIZE 0x000000e0
84:
85: #define RFX_INIT_ADDR 0x00018000
86: #define RFX_INIT_OFFSET 0x0000001c
87: #define RFX_INIT_SIZE 0x00008000
88:
89: #define RFX_VRAM_ADDR 0x00100000
90:
91: /*
92: * Control registers
93: */
94:
95: #define RFX_VIDCTRL_REG 0x10
96: #define RFX_VSYNC_ENABLE 0x00000001
97: #define RFX_VIDEO_DISABLE 0x00000002
98:
99: /*
100: * Shadow colormap
101: */
102: struct rfx_cmap {
103: u_int8_t red[256];
104: u_int8_t green[256];
105: u_int8_t blue[256];
106: };
107:
108: struct rfx_softc {
109: struct sunfb sc_sunfb;
110:
111: bus_space_tag_t sc_bustag;
112: bus_addr_t sc_paddr;
113:
114: struct intrhand sc_ih;
115:
116: struct rfx_cmap sc_cmap;
117: volatile u_int8_t *sc_ramdac;
118: volatile u_int32_t *sc_ctrl;
119:
120: int sc_nscreens;
121: };
122:
123: int rfx_alloc_screen(void *, const struct wsscreen_descr *, void **,
124: int *, int *, long *);
125: void rfx_burner(void *, u_int, u_int);
126: void rfx_free_screen(void *, void *);
127: int rfx_ioctl(void *, u_long, caddr_t, int, struct proc *);
128: int rfx_show_screen(void *, void *, int, void (*cb)(void *, int, int),
129: void *);
130: paddr_t rfx_mmap(void *, off_t, int);
131:
132: int rfx_getcmap(struct rfx_cmap *, struct wsdisplay_cmap *);
133: int rfx_initialize(struct rfx_softc *, struct sbus_attach_args *,
134: struct rfx_config *);
135: int rfx_intr(void *);
136: void rfx_loadcmap(struct rfx_softc *, int, int);
137: int rfx_putcmap(struct rfx_cmap *, struct wsdisplay_cmap *);
138: void rfx_setcolor(void *, u_int, u_int8_t, u_int8_t, u_int8_t);
139:
140: struct wsdisplay_accessops rfx_accessops = {
141: rfx_ioctl,
142: rfx_mmap,
143: rfx_alloc_screen,
144: rfx_free_screen,
145: rfx_show_screen,
146: NULL, /* load_font */
147: NULL, /* scrollback */
148: NULL, /* getchar */
149: rfx_burner,
150: };
151:
152: int rfxmatch(struct device *, void *, void *);
153: void rfxattach(struct device *, struct device *, void *);
154:
155: #if defined(OpenBSD)
156: struct cfattach rfx_ca = {
157: sizeof (struct rfx_softc), rfxmatch, rfxattach
158: };
159:
160: struct cfdriver rfx_cd = {
161: NULL, "rfx", DV_DULL
162: };
163: #else
164: CFATTACH_DECL(rfx, sizeof (struct rfx_softc), rfxmatch, rfxattach, NULL, NULL);
165: #endif
166:
167: /*
168: * Match a supported RasterFlex card.
169: */
170: int
171: rfxmatch(struct device *parent, void *vcf, void *aux)
172: {
173: struct sbus_attach_args *sa = aux;
174: const char *device = sa->sa_name;
175:
176: /* skip vendor name (could be CWARE, VITec, ...) */
177: while (*device != ',' && *device != '\0')
178: device++;
179: if (*device == '\0')
180: device = sa->sa_name;
181: else
182: device++;
183:
184: if (strncmp(device, "RasterFLEX", strlen("RasterFLEX")) != 0)
185: return (0);
186:
187: /* RasterVideo and RasterFlex-TV are frame grabbers */
188: if (strcmp(device, "RasterFLEX-TV") == 0)
189: return (0);
190:
191: return (1);
192: }
193:
194: /*
195: * Attach and initialize a rfx display, as well as a child wsdisplay.
196: */
197: void
198: rfxattach(struct device *parent, struct device *self, void *args)
199: {
200: struct rfx_softc *sc = (struct rfx_softc *)self;
201: struct sbus_attach_args *sa = args;
202: const char *device = sa->sa_name;
203: struct rfx_config cf;
204: bus_space_tag_t bt;
205: bus_space_handle_t bh;
206: int node, cflen, isconsole = 0;
207:
208: /* skip vendor name (could be CWARE, VITec, ...) */
209: while (*device != ',' && *device != '\0')
210: device++;
211: if (*device == '\0')
212: device = sa->sa_name;
213: else
214: device++;
215:
216: printf(": %s", device);
217:
218: if (sa->sa_nreg == 0) {
219: printf("\n%s: no SBus registers!\n", self->dv_xname);
220: return;
221: }
222:
223: bt = sa->sa_bustag;
224: node = sa->sa_node;
225: isconsole = node == fbnode;
226:
227: /*
228: * Parse configuration structure
229: */
230: cflen = getproplen(node, "configuration");
231: if (cflen != sizeof cf) {
232: printf(", unknown %d bytes conf. structure", cflen);
233: /* fill in default values */
234: cf.version = 0;
235: cf.scanline = 2048;
236: cf.width = 1152;
237: cf.height = 900;
238: } else {
239: OF_getprop(node, "configuration", &cf, cflen);
240: printf(", revision %d", cf.version);
241: }
242:
243: /*
244: * Map registers
245: */
246:
247: sc->sc_bustag = bt;
248: sc->sc_paddr = sbus_bus_addr(bt, sa->sa_slot, sa->sa_offset);
249:
250: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + RFX_RAMDAC_ADDR,
251: RFX_RAMDAC_SIZE, BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
252: printf("\n%s: couldn't map ramdac registers\n", self->dv_xname);
253: return;
254: }
255: sc->sc_ramdac = (u_int8_t *)bus_space_vaddr(bt, bh);
256:
257: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + RFX_CONTROL_ADDR,
258: RFX_CONTROL_SIZE, BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
259: printf("\n%s: couldn't map control registers\n", self->dv_xname);
260: return;
261: }
262: sc->sc_ctrl = (u_int32_t *)bus_space_vaddr(bt, bh);
263:
264: #if 0 /* not yet */
265: sc->sc_ih.ih_fun = rfx_intr;
266: sc->sc_ih.ih_arg = sc;
267: intr_establish(ca->ca_ra.ra_intr[0].int_pri, &sc->sc_ih, IPL_FB);
268: #endif
269:
270: /*
271: * The following is an equivalent for
272: * fb_setsize(&sc->sc_sunfb, 8, cf.width, cf.height,
273: * node, ca->ca_bustype);
274: * forcing the correct scan line value. Since the usual frame buffer
275: * properties are missing on this card, no need to go through
276: * fb_setsize()...
277: */
278: sc->sc_sunfb.sf_depth = 8;
279: sc->sc_sunfb.sf_width = cf.width;
280: sc->sc_sunfb.sf_height = cf.height;
281: sc->sc_sunfb.sf_linebytes = cf.scanline;
282: sc->sc_sunfb.sf_fbsize = cf.height * cf.scanline;
283:
284: printf(", %dx%d\n", sc->sc_sunfb.sf_width, sc->sc_sunfb.sf_height);
285:
286: if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + RFX_VRAM_ADDR,
287: round_page(sc->sc_sunfb.sf_fbsize), BUS_SPACE_MAP_LINEAR,
288: 0, &bh) != 0) {
289: printf("\n%s: couldn't map video memory\n", self->dv_xname);
290: return;
291: }
292: sc->sc_sunfb.sf_ro.ri_bits = bus_space_vaddr(bt, bh);
293: sc->sc_sunfb.sf_ro.ri_hw = sc;
294:
295: /*
296: * If we are not the console, the frame buffer has not been
297: * initalized by the PROM - do this ourselves.
298: */
299: if (!isconsole) {
300: if (rfx_initialize(sc, sa, &cf) != 0)
301: return;
302: }
303:
304: fbwscons_init(&sc->sc_sunfb, isconsole ? 0 : RI_CLEAR);
305:
306: bzero(&sc->sc_cmap, sizeof(sc->sc_cmap));
307: fbwscons_setcolormap(&sc->sc_sunfb, rfx_setcolor);
308:
309: if (isconsole) {
310: fbwscons_console_init(&sc->sc_sunfb, -1);
311: }
312:
313: /* enable video */
314: rfx_burner(sc, 1, 0);
315:
316: fbwscons_attach(&sc->sc_sunfb, &rfx_accessops, isconsole);
317: }
318:
319: /*
320: * Common wsdisplay operations
321: */
322:
323: int
324: rfx_ioctl(void *v, u_long cmd, caddr_t data, int flags, struct proc *p)
325: {
326: struct rfx_softc *sc = v;
327: struct wsdisplay_cmap *cm;
328: struct wsdisplay_fbinfo *wdf;
329: int error;
330:
331: switch (cmd) {
332: case WSDISPLAYIO_GTYPE:
333: *(u_int *)data = WSDISPLAY_TYPE_RFLEX;
334: break;
335: case WSDISPLAYIO_GINFO:
336: wdf = (struct wsdisplay_fbinfo *)data;
337: wdf->height = sc->sc_sunfb.sf_height;
338: wdf->width = sc->sc_sunfb.sf_width;
339: wdf->depth = sc->sc_sunfb.sf_depth;
340: wdf->cmsize = 256;
341: break;
342: case WSDISPLAYIO_LINEBYTES:
343: *(u_int *)data = sc->sc_sunfb.sf_linebytes;
344: break;
345:
346: case WSDISPLAYIO_GETCMAP:
347: cm = (struct wsdisplay_cmap *)data;
348: error = rfx_getcmap(&sc->sc_cmap, cm);
349: if (error != 0)
350: return (error);
351: break;
352: case WSDISPLAYIO_PUTCMAP:
353: cm = (struct wsdisplay_cmap *)data;
354: error = rfx_putcmap(&sc->sc_cmap, cm);
355: if (error != 0)
356: return (error);
357: rfx_loadcmap(sc, cm->index, cm->count);
358: break;
359:
360: case WSDISPLAYIO_SVIDEO:
361: case WSDISPLAYIO_GVIDEO:
362: break;
363:
364: default:
365: return (-1);
366: }
367:
368: return (0);
369: }
370:
371: paddr_t
372: rfx_mmap(void *v, off_t offset, int prot)
373: {
374: struct rfx_softc *sc = v;
375:
376: if (offset & PGOFSET)
377: return (-1);
378:
379: if (offset >= 0 && offset < sc->sc_sunfb.sf_fbsize) {
380: return (bus_space_mmap(sc->sc_bustag, sc->sc_paddr,
381: RFX_VRAM_ADDR + offset, prot, BUS_SPACE_MAP_LINEAR));
382: }
383:
384: return (-1);
385: }
386:
387: int
388: rfx_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep,
389: int *curxp, int *curyp, long *attrp)
390: {
391: struct rfx_softc *sc = v;
392:
393: if (sc->sc_nscreens > 0)
394: return (ENOMEM);
395:
396: *cookiep = &sc->sc_sunfb.sf_ro;
397: *curyp = 0;
398: *curxp = 0;
399: sc->sc_sunfb.sf_ro.ri_ops.alloc_attr(&sc->sc_sunfb.sf_ro,
400: WSCOL_BLACK, WSCOL_WHITE, WSATTR_WSCOLORS, attrp);
401: sc->sc_nscreens++;
402: return (0);
403: }
404:
405: void
406: rfx_free_screen(void *v, void *cookie)
407: {
408: struct rfx_softc *sc = v;
409:
410: sc->sc_nscreens--;
411: }
412:
413: int
414: rfx_show_screen(void *v, void *cookie, int waitok,
415: void (*cb)(void *, int, int), void *cbarg)
416: {
417: return (0);
418: }
419:
420: void
421: rfx_burner(void *v, u_int on, u_int flags)
422: {
423: struct rfx_softc *sc = v;
424:
425: if (on) {
426: sc->sc_ctrl[RFX_VIDCTRL_REG] &= ~RFX_VIDEO_DISABLE;
427: sc->sc_ctrl[RFX_VIDCTRL_REG] |= RFX_VSYNC_ENABLE;
428: } else {
429: sc->sc_ctrl[RFX_VIDCTRL_REG] |= RFX_VIDEO_DISABLE;
430: if (flags & WSDISPLAY_BURN_VBLANK)
431: sc->sc_ctrl[RFX_VIDCTRL_REG] &= ~RFX_VSYNC_ENABLE;
432: }
433: }
434:
435: /*
436: * Colormap helper functions
437: */
438:
439: void
440: rfx_setcolor(void *v, u_int index, u_int8_t r, u_int8_t g, u_int8_t b)
441: {
442: struct rfx_softc *sc = v;
443:
444: sc->sc_cmap.red[index] = r;
445: sc->sc_cmap.green[index] = g;
446: sc->sc_cmap.blue[index] = b;
447:
448: rfx_loadcmap(sc, index, 1);
449: }
450:
451: int
452: rfx_getcmap(struct rfx_cmap *cm, struct wsdisplay_cmap *rcm)
453: {
454: u_int index = rcm->index, count = rcm->count;
455: int error;
456:
457: if (index >= 256 || count > 256 - index)
458: return (EINVAL);
459:
460: if ((error = copyout(cm->red + index, rcm->red, count)) != 0)
461: return (error);
462: if ((error = copyout(cm->green + index, rcm->green, count)) != 0)
463: return (error);
464: if ((error = copyout(cm->blue + index, rcm->blue, count)) != 0)
465: return (error);
466:
467: return (0);
468: }
469:
470: int
471: rfx_putcmap(struct rfx_cmap *cm, struct wsdisplay_cmap *rcm)
472: {
473: u_int index = rcm->index, count = rcm->count;
474: u_int8_t red[256], green[256], blue[256];
475: int error;
476:
477: if (index >= 256 || count > 256 - index)
478: return (EINVAL);
479:
480: if ((error = copyin(rcm->red, red, count)) != 0)
481: return (error);
482: if ((error = copyin(rcm->green, green, count)) != 0)
483: return (error);
484: if ((error = copyin(rcm->blue, blue, count)) != 0)
485: return (error);
486:
487: bcopy(red, cm->red + index, count);
488: bcopy(green, cm->green + index, count);
489: bcopy(blue, cm->blue + index, count);
490:
491: return (0);
492: }
493:
494: void
495: rfx_loadcmap(struct rfx_softc *sc, int start, int ncolors)
496: {
497: u_int8_t *r, *g, *b;
498:
499: r = sc->sc_cmap.red + start;
500: g = sc->sc_cmap.green + start;
501: b = sc->sc_cmap.blue + start;
502:
503: start += BT463_IREG_CPALETTE_RAM;
504: sc->sc_ramdac[BT463_REG_ADDR_LOW] = start & 0xff;
505: sc->sc_ramdac[BT463_REG_ADDR_HIGH] = (start >> 8) & 0xff;
506:
507: while (ncolors-- != 0) {
508: sc->sc_ramdac[BT463_REG_CMAP_DATA] = *r++;
509: sc->sc_ramdac[BT463_REG_CMAP_DATA] = *g++;
510: sc->sc_ramdac[BT463_REG_CMAP_DATA] = *b++;
511: }
512: }
513:
514: /*
515: * Initialization code parser
516: */
517:
518: int
519: rfx_initialize(struct rfx_softc *sc, struct sbus_attach_args *sa,
520: struct rfx_config *cf)
521: {
522: u_int32_t *data, offset, value;
523: size_t cnt;
524: bus_space_handle_t bh;
525: int error;
526:
527: /*
528: * Map the initialization data
529: */
530: if ((error = sbus_bus_map(sa->sa_bustag, sa->sa_slot, sa->sa_offset +
531: RFX_INIT_ADDR, RFX_INIT_SIZE, BUS_SPACE_MAP_LINEAR, 0, &bh)) != 0) {
532: printf("\n%s: couldn't map initialization data\n",
533: sc->sc_sunfb.sf_dev.dv_xname);
534: return error;
535: }
536: data = (u_int32_t *)bus_space_vaddr(sa->sa_bustag, bh);
537:
538: /*
539: * Skip copyright notice
540: */
541: data += RFX_INIT_OFFSET / sizeof(u_int32_t);
542: cnt = (RFX_INIT_SIZE - RFX_INIT_OFFSET) / sizeof(u_int32_t);
543: cnt >>= 1;
544:
545: /*
546: * Parse and apply settings
547: */
548: while (cnt != 0) {
549: offset = *data++;
550: value = *data++;
551:
552: if (offset == (u_int32_t)-1 && value == (u_int32_t)-1)
553: break;
554:
555: /* Old PROM are little-endian */
556: if (cf->version <= 1) {
557: offset = letoh32(offset);
558: value = letoh32(offset);
559: }
560:
561: if (offset & (1 << 31)) {
562: offset = (offset & ~(1 << 31)) - RFX_RAMDAC_ADDR;
563: if (offset < RFX_RAMDAC_SIZE)
564: sc->sc_ramdac[offset] = value >> 24;
565: } else {
566: offset -= RFX_CONTROL_ADDR;
567: if (offset < RFX_CONTROL_SIZE)
568: sc->sc_ctrl[offset >> 2] = value;
569: }
570:
571: cnt--;
572: }
573:
574: #ifdef DEBUG
575: if (cnt != 0)
576: printf("%s: incoherent initialization data!\n");
577: #endif
578:
579: bus_space_unmap(sa->sa_bustag, bh, RFX_INIT_SIZE);
580:
581: return 0;
582: }
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 / dev / sbus