Annotation of sys/arch/sparc/dev/cgfourteen.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: cgfourteen.c,v 1.35 2007/03/13 19:40:48 miod Exp $ */
2: /* $NetBSD: cgfourteen.c,v 1.7 1997/05/24 20:16:08 pk Exp $ */
3:
4: /*
5: * Copyright (c) 2002, 2003, 2005 Miodrag Vallat.
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) 1996
30: * The President and Fellows of Harvard College. All rights reserved.
31: * Copyright (c) 1992, 1993
32: * The Regents of the University of California. All rights reserved.
33: *
34: * This software was developed by the Computer Systems Engineering group
35: * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
36: * contributed to Berkeley.
37: *
38: * All advertising materials mentioning features or use of this software
39: * must display the following acknowledgement:
40: * This product includes software developed by Harvard University.
41: * This product includes software developed by the University of
42: * California, Lawrence Berkeley Laboratory.
43: *
44: * Redistribution and use in source and binary forms, with or without
45: * modification, are permitted provided that the following conditions
46: * are met:
47: * 1. Redistributions of source code must retain the above copyright
48: * notice, this list of conditions and the following disclaimer.
49: * 2. Redistributions in binary form must reproduce the above copyright
50: * notice, this list of conditions and the following disclaimer in the
51: * documentation and/or other materials provided with the distribution.
52: * 3. All advertising materials mentioning features or use of this software
53: * must display the following acknowledgement:
54: * This product includes software developed by the University of
55: * California, Berkeley and its contributors.
56: * This product includes software developed by Harvard University and
57: * its contributors.
58: * 4. Neither the name of the University nor the names of its contributors
59: * may be used to endorse or promote products derived from this software
60: * without specific prior written permission.
61: *
62: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
63: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
64: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
65: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
66: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
67: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
68: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
69: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
70: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
71: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
72: * SUCH DAMAGE.
73: *
74: * Based on:
75: * NetBSD: cgthree.c,v 1.28 1996/05/31 09:59:22 pk Exp
76: * NetBSD: cgsix.c,v 1.25 1996/04/01 17:30:00 christos Exp
77: */
78:
79: /*
80: * Driver for Campus-II on-board mbus-based video (cgfourteen).
81: *
82: * XXX should bring hardware cursor code back
83: */
84:
85: #include <sys/param.h>
86: #include <sys/systm.h>
87: #include <sys/buf.h>
88: #include <sys/device.h>
89: #include <sys/ioctl.h>
90: #include <sys/malloc.h>
91: #include <sys/mman.h>
92: #include <sys/tty.h>
93: #include <sys/conf.h>
94:
95: #include <uvm/uvm_extern.h>
96:
97: #include <machine/autoconf.h>
98: #include <machine/pmap.h>
99: #include <machine/cpu.h>
100: #include <machine/conf.h>
101:
102: #include <dev/wscons/wsconsio.h>
103: #include <dev/wscons/wsdisplayvar.h>
104: #include <dev/rasops/rasops.h>
105: #include <machine/fbvar.h>
106:
107: #include <sparc/dev/cgfourteenreg.h>
108:
109: #include <dev/cons.h> /* for prom console hook */
110:
111: /*
112: * Per-display variables/state
113: */
114:
115: union cgfourteen_cmap {
116: u_char cm_map[256][4]; /* 256 R/G/B/A entries (B is high)*/
117: u_int32_t cm_chip[256]; /* the way the chip gets loaded */
118: };
119:
120: struct cgfourteen_softc {
121: struct sunfb sc_sunfb; /* common base part */
122:
123: struct rom_reg sc_phys; /* phys address of frame buffer */
124: union cgfourteen_cmap sc_cmap; /* current colormap */
125: u_int sc_cmap_start, sc_cmap_count; /* deferred cmap range */
126:
127: /* registers mappings */
128: struct cg14ctl *sc_ctl;
129: struct cg14curs *sc_hwc;
130: struct cg14dac *sc_dac;
131: struct cg14xlut *sc_xlut;
132: struct cg14clut *sc_clut1;
133: struct cg14clut *sc_clut2;
134: struct cg14clut *sc_clut3;
135: u_int32_t *sc_autoincr;
136:
137: int sc_rev; /* VSIMM revision */
138: int sc_32; /* can do 32bit at this resolution */
139: size_t sc_vramsize; /* total video memory size */
140:
141: struct intrhand sc_ih;
142: };
143:
144: int cgfourteen_ioctl(void *, u_long, caddr_t, int, struct proc *);
145: paddr_t cgfourteen_mmap(void *, off_t, int);
146: void cgfourteen_reset(struct cgfourteen_softc *, int);
147: void cgfourteen_burner(void *, u_int, u_int);
148:
149: int cgfourteen_getcmap(union cgfourteen_cmap *, struct wsdisplay_cmap *);
150: int cgfourteen_intr(void *);
151: void cgfourteen_loadcmap_deferred(struct cgfourteen_softc *, u_int, u_int);
152: void cgfourteen_loadcmap_immediate(struct cgfourteen_softc *, u_int, u_int);
153: void cgfourteen_prom(void *);
154: int cgfourteen_putcmap(union cgfourteen_cmap *, struct wsdisplay_cmap *);
155: void cgfourteen_setcolor(void *, u_int, u_int8_t, u_int8_t, u_int8_t);
156:
157: struct wsdisplay_accessops cgfourteen_accessops = {
158: cgfourteen_ioctl,
159: cgfourteen_mmap,
160: NULL, /* alloc_screen */
161: NULL, /* free_screen */
162: NULL, /* show_screen */
163: NULL, /* load_font */
164: NULL, /* scrollback */
165: NULL, /* getchar */
166: cgfourteen_burner,
167: NULL /* pollc */
168: };
169:
170: void cgfourteenattach(struct device *, struct device *, void *);
171: int cgfourteenmatch(struct device *, void *, void *);
172:
173: struct cfattach cgfourteen_ca = {
174: sizeof(struct cgfourteen_softc), cgfourteenmatch, cgfourteenattach
175: };
176:
177: struct cfdriver cgfourteen_cd = {
178: NULL, "cgfourteen", DV_DULL
179: };
180:
181: /*
182: * Match a cgfourteen.
183: */
184: int
185: cgfourteenmatch(struct device *parent, void *vcf, void *aux)
186: {
187: struct cfdata *cf = vcf;
188: struct confargs *ca = aux;
189: struct romaux *ra = &ca->ca_ra;
190:
191: if (strcmp(cf->cf_driver->cd_name, ra->ra_name))
192: return (0);
193:
194: /*
195: * This driver should not be attached without an "addr" locator,
196: * as this is the only way to differentiate the main and secondary
197: * VSIMM.
198: */
199: if (cf->cf_loc[0] != -1 && cf->cf_loc[0] != (int)ra->ra_paddr)
200: return (0);
201:
202: /*
203: * The cgfourteen is a local-bus video adaptor, accessed directly
204: * via the processor, and not through device space or an external
205: * bus. Thus we look _only_ at the obio bus.
206: * Additionally, these things exist only on the Sun4m.
207: */
208: if (CPU_ISSUN4M && ca->ca_bustype == BUS_OBIO)
209: return (1);
210:
211: return (0);
212: }
213:
214: /*
215: * Attach a display.
216: */
217: void
218: cgfourteenattach(struct device *parent, struct device *self, void *args)
219: {
220: struct cgfourteen_softc *sc = (struct cgfourteen_softc *)self;
221: struct confargs *ca = args;
222: int node, pri, i;
223: u_int32_t *lut;
224: int isconsole;
225: char *nam;
226:
227: pri = ca->ca_ra.ra_intr[0].int_pri;
228: printf(" pri %d: ", pri);
229:
230: /*
231: * Sanity checks
232: */
233: if (ca->ca_ra.ra_len < 0x10000) {
234: printf("expected %x bytes of control registers, got %x\n",
235: 0x10000, ca->ca_ra.ra_len);
236: return;
237: }
238: if (ca->ca_ra.ra_nreg < CG14_NREG) {
239: printf("expected %d registers, got %d\n",
240: CG14_NREG, ca->ca_ra.ra_nreg);
241: return;
242: }
243: if (ca->ca_ra.ra_nintr != 1) {
244: printf("expected 1 interrupt, got %d\n", ca->ca_ra.ra_nintr);
245: return;
246: }
247:
248: node = ca->ca_ra.ra_node;
249: nam = getpropstring(node, "model");
250: if (*nam != '\0')
251: printf("%s, ", nam);
252:
253: isconsole = node == fbnode;
254:
255: /*
256: * Map in the 8 useful pages of registers
257: */
258: sc->sc_ctl = (struct cg14ctl *) mapiodev(
259: &ca->ca_ra.ra_reg[CG14_REG_CONTROL], 0, ca->ca_ra.ra_len);
260:
261: sc->sc_hwc = (struct cg14curs *) ((u_int)sc->sc_ctl +
262: CG14_OFFSET_CURS);
263: sc->sc_dac = (struct cg14dac *) ((u_int)sc->sc_ctl +
264: CG14_OFFSET_DAC);
265: sc->sc_xlut = (struct cg14xlut *) ((u_int)sc->sc_ctl +
266: CG14_OFFSET_XLUT);
267: sc->sc_clut1 = (struct cg14clut *) ((u_int)sc->sc_ctl +
268: CG14_OFFSET_CLUT1);
269: sc->sc_clut2 = (struct cg14clut *) ((u_int)sc->sc_ctl +
270: CG14_OFFSET_CLUT2);
271: sc->sc_clut3 = (struct cg14clut *) ((u_int)sc->sc_ctl +
272: CG14_OFFSET_CLUT3);
273: sc->sc_autoincr = (u_int32_t *) ((u_int)sc->sc_ctl +
274: CG14_OFFSET_AUTOINCR);
275:
276: sc->sc_rev =
277: (sc->sc_ctl->ctl_rsr & CG14_RSR_REVMASK) >> CG14_RSR_REVSHIFT;
278:
279: printf("%dMB, rev %d.%d", ca->ca_ra.ra_reg[CG14_REG_VRAM].rr_len >> 20,
280: sc->sc_rev, sc->sc_ctl->ctl_rsr & CG14_RSR_IMPLMASK);
281:
282: sc->sc_phys = ca->ca_ra.ra_reg[CG14_REG_VRAM];
283:
284: fb_setsize(&sc->sc_sunfb, 8, 1152, 900, node, ca->ca_bustype);
285:
286: /*
287: * The prom will report depth == 8, since this is the mode it will
288: * get initialized in.
289: * Check if we will be able to use 32 bit mode later (i.e. if it will
290: * fit in the video memory. Note that, if this is not the case, the
291: * VSIMM will usually not appear in the OBP device tree!
292: */
293: sc->sc_vramsize = ca->ca_ra.ra_reg[CG14_REG_VRAM].rr_len;
294: sc->sc_32 = sc->sc_sunfb.sf_fbsize * 4 <= sc->sc_vramsize;
295:
296: sc->sc_sunfb.sf_ro.ri_bits = mapiodev(&ca->ca_ra.ra_reg[CG14_REG_VRAM],
297: 0, /* CHUNKY_XBGR */
298: sc->sc_vramsize);
299:
300: printf(", %dx%d\n", sc->sc_sunfb.sf_width, sc->sc_sunfb.sf_height);
301:
302: sc->sc_ih.ih_fun = cgfourteen_intr;
303: sc->sc_ih.ih_arg = sc;
304: intr_establish(pri, &sc->sc_ih, IPL_FB, self->dv_xname);
305:
306: /*
307: * Reset frame buffer controls
308: */
309: sc->sc_sunfb.sf_depth = 0; /* force action */
310: cgfourteen_reset(sc, 8);
311:
312: /*
313: * Grab the initial colormap
314: */
315: lut = (u_int32_t *)sc->sc_clut1->clut_lut;
316: for (i = 0; i < CG14_CLUT_SIZE; i++)
317: sc->sc_cmap.cm_chip[i] = lut[i];
318:
319: /*
320: * Enable the video.
321: */
322: cgfourteen_burner(sc, 1, 0);
323:
324: sc->sc_sunfb.sf_ro.ri_hw = sc;
325: fbwscons_init(&sc->sc_sunfb, isconsole ? 0 : RI_CLEAR);
326: fbwscons_setcolormap(&sc->sc_sunfb, cgfourteen_setcolor);
327:
328: if (isconsole) {
329: fbwscons_console_init(&sc->sc_sunfb, -1);
330: shutdownhook_establish(cgfourteen_prom, sc);
331: }
332:
333: fbwscons_attach(&sc->sc_sunfb, &cgfourteen_accessops, isconsole);
334: }
335:
336: int
337: cgfourteen_ioctl(void *dev, u_long cmd, caddr_t data, int flags, struct proc *p)
338: {
339: struct cgfourteen_softc *sc = dev;
340: struct wsdisplay_cmap *cm;
341: struct wsdisplay_fbinfo *wdf;
342: int error;
343:
344: /*
345: * Note that, although the emulation (text) mode is running in a
346: * 8-bit plane, we advertize the frame buffer as 32-bit if it can
347: * support this mode.
348: */
349: switch (cmd) {
350: case WSDISPLAYIO_GTYPE:
351: *(u_int *)data = WSDISPLAY_TYPE_SUNCG14;
352: break;
353: case WSDISPLAYIO_GINFO:
354: wdf = (struct wsdisplay_fbinfo *)data;
355: wdf->height = sc->sc_sunfb.sf_height;
356: wdf->width = sc->sc_sunfb.sf_width;
357: wdf->depth = sc->sc_32 ? 32 : 8;
358: wdf->cmsize = sc->sc_32 ? 0 : 256;
359: break;
360: case WSDISPLAYIO_GETSUPPORTEDDEPTH:
361: if (sc->sc_32)
362: *(u_int *)data = WSDISPLAYIO_DEPTH_24_32;
363: else
364: return (-1);
365: break;
366: case WSDISPLAYIO_LINEBYTES:
367: if (sc->sc_32)
368: *(u_int *)data = sc->sc_sunfb.sf_linebytes * 4;
369: else
370: *(u_int *)data = sc->sc_sunfb.sf_linebytes;
371: break;
372:
373: case WSDISPLAYIO_GETCMAP:
374: if (sc->sc_32 == 0) {
375: cm = (struct wsdisplay_cmap *)data;
376: error = cgfourteen_getcmap(&sc->sc_cmap, cm);
377: if (error)
378: return (error);
379: }
380: break;
381: case WSDISPLAYIO_PUTCMAP:
382: if (sc->sc_32 == 0) {
383: cm = (struct wsdisplay_cmap *)data;
384: error = cgfourteen_putcmap(&sc->sc_cmap, cm);
385: if (error)
386: return (error);
387: cgfourteen_loadcmap_deferred(sc, cm->index, cm->count);
388: }
389: break;
390:
391: case WSDISPLAYIO_SMODE:
392: if (*(int *)data == WSDISPLAYIO_MODE_EMUL) {
393: /* Back from X11 to text mode */
394: cgfourteen_reset(sc, 8);
395: } else {
396: /* Starting X11, try to switch to 32 bit mode */
397: if (sc->sc_32)
398: cgfourteen_reset(sc, 32);
399: }
400: break;
401:
402: case WSDISPLAYIO_GVIDEO:
403: case WSDISPLAYIO_SVIDEO:
404: break;
405:
406: default:
407: return (-1); /* not supported yet */
408: }
409: return (0);
410: }
411:
412: /*
413: * Return the address that would map the given device at the given
414: * offset, allowing for the given protection, or return -1 for error.
415: */
416: paddr_t
417: cgfourteen_mmap(void *v, off_t offset, int prot)
418: {
419: struct cgfourteen_softc *sc = v;
420:
421: if (offset & PGOFSET || offset < 0)
422: return (-1);
423:
424: /* Allow mapping as a dumb framebuffer from offset 0 */
425: if (offset < sc->sc_sunfb.sf_fbsize * (sc->sc_32 ? 4 : 1)) {
426: return (REG2PHYS(&sc->sc_phys, offset) | PMAP_NC);
427: }
428:
429: return (-1);
430: }
431:
432: /* Initialize the framebuffer, storing away useful state for later reset */
433: void
434: cgfourteen_reset(struct cgfourteen_softc *sc, int depth)
435: {
436: u_int i;
437:
438: if (sc->sc_sunfb.sf_depth != depth) {
439: if (depth == 8) {
440: /*
441: * Enable the video and put it in 8 bit mode
442: */
443: if (sc->sc_rev == 0)
444: sc->sc_ctl->ctl_mctl = CG14_MCTL_R0_ENABLEHW |
445: CG14_MCTL_PIXMODE_8;
446: else
447: sc->sc_ctl->ctl_mctl = CG14_MCTL_R1_ENABLEHW |
448: CG14_MCTL_R1_ENABLEVID |
449: CG14_MCTL_PIXMODE_8;
450:
451: fbwscons_setcolormap(&sc->sc_sunfb,
452: cgfourteen_setcolor);
453: } else {
454: /*
455: * Clear the screen to black
456: */
457: bzero(sc->sc_sunfb.sf_ro.ri_bits,
458: sc->sc_sunfb.sf_fbsize);
459:
460: /*
461: * Enable the video, and put in 32 bit mode
462: */
463: if (sc->sc_rev == 0)
464: sc->sc_ctl->ctl_mctl = CG14_MCTL_R0_ENABLEHW |
465: CG14_MCTL_PIXMODE_32;
466: else
467: sc->sc_ctl->ctl_mctl = CG14_MCTL_R1_ENABLEHW |
468: CG14_MCTL_R1_ENABLEVID |
469: CG14_MCTL_PIXMODE_32;
470:
471: /*
472: * Zero the xlut to enable direct-color mode
473: */
474: sc->sc_xlut->xlut_lutinc[0] = 0;
475: for (i = CG14_CLUT_SIZE; i; i--)
476: *sc->sc_autoincr = 0;
477: }
478: }
479:
480: sc->sc_cmap_count = 0;
481: sc->sc_sunfb.sf_depth = depth;
482: }
483:
484: void
485: cgfourteen_prom(void *v)
486: {
487: struct cgfourteen_softc *sc = v;
488: extern struct consdev consdev_prom;
489:
490: if (sc->sc_sunfb.sf_depth != 8) {
491: /*
492: * Go back to 8-bit mode.
493: */
494: cgfourteen_reset(sc, 8);
495:
496: /*
497: * Go back to prom output for the last few messages, so they
498: * will be displayed correctly.
499: */
500: cn_tab = &consdev_prom;
501: }
502: }
503:
504: void
505: cgfourteen_burner(void *v, u_int on, u_int flags)
506: {
507: struct cgfourteen_softc *sc = v;
508: u_int bits;
509:
510: /*
511: * We can only use DPMS to power down the display if the chip revision
512: * is greater than 0.
513: */
514: if (sc->sc_rev == 0)
515: bits = CG14_MCTL_R0_ENABLEHW;
516: else
517: bits = CG14_MCTL_R1_ENABLEHW | CG14_MCTL_R1_ENABLEVID;
518:
519: if (on) {
520: sc->sc_ctl->ctl_mctl |= bits;
521: } else {
522: sc->sc_ctl->ctl_mctl &= ~bits;
523: }
524: }
525:
526: /* Read the software shadow colormap */
527: int
528: cgfourteen_getcmap(union cgfourteen_cmap *cm, struct wsdisplay_cmap *rcm)
529: {
530: u_int index = rcm->index, count = rcm->count, i;
531: int error;
532:
533: if (index >= CG14_CLUT_SIZE || count > CG14_CLUT_SIZE - index)
534: return (EINVAL);
535:
536: for (i = 0; i < count; i++) {
537: if ((error = copyout(&cm->cm_map[index + i][3],
538: &rcm->red[i], 1)) != 0)
539: return (error);
540: if ((error = copyout(&cm->cm_map[index + i][2],
541: &rcm->green[i], 1)) != 0)
542: return (error);
543: if ((error = copyout(&cm->cm_map[index + i][1],
544: &rcm->blue[i], 1)) != 0)
545: return (error);
546: }
547: return (0);
548: }
549:
550: /* Write the software shadow colormap */
551: int
552: cgfourteen_putcmap(union cgfourteen_cmap *cm, struct wsdisplay_cmap *rcm)
553: {
554: u_int index = rcm->index, count = rcm->count, i;
555: int error;
556:
557: if (index >= CG14_CLUT_SIZE || count > CG14_CLUT_SIZE - index)
558: return (EINVAL);
559:
560: for (i = 0; i < count; i++) {
561: if ((error = copyin(&rcm->red[i],
562: &cm->cm_map[index + i][3], 1)) != 0)
563: return (error);
564: if ((error = copyin(&rcm->green[i],
565: &cm->cm_map[index + i][2], 1)) != 0)
566: return (error);
567: if ((error = copyin(&rcm->blue[i],
568: &cm->cm_map[index + i][1], 1)) != 0)
569: return (error);
570: cm->cm_map[index +i][0] = 0; /* no alpha channel */
571: }
572: return (0);
573: }
574:
575: void
576: cgfourteen_loadcmap_deferred(struct cgfourteen_softc *sc, u_int start,
577: u_int ncolors)
578: {
579: u_int end;
580:
581: /* Grow the deferred colormap update range if necessary */
582: if (sc->sc_cmap_count == 0) {
583: sc->sc_cmap_start = start;
584: sc->sc_cmap_count = ncolors;
585: } else {
586: end = MAX(start + ncolors,
587: sc->sc_cmap_start + sc->sc_cmap_count);
588: sc->sc_cmap_start = min(sc->sc_cmap_start, start);
589: sc->sc_cmap_count = end - sc->sc_cmap_start;
590: }
591:
592: /* Enable interrupts */
593: sc->sc_ctl->ctl_mctl |= CG14_MCTL_ENABLEINTR;
594: }
595:
596: void
597: cgfourteen_loadcmap_immediate(struct cgfourteen_softc *sc, u_int start,
598: u_int ncolors)
599: {
600: u_int32_t *colp = &sc->sc_cmap.cm_chip[start];
601:
602: sc->sc_clut1->clut_lutinc[start] = 0;
603: while (ncolors-- != 0)
604: *sc->sc_autoincr = *colp++;
605: }
606:
607: void
608: cgfourteen_setcolor(void *v, u_int index, u_int8_t r, u_int8_t g, u_int8_t b)
609: {
610: struct cgfourteen_softc *sc = v;
611:
612: sc->sc_cmap.cm_map[index][3] = r;
613: sc->sc_cmap.cm_map[index][2] = g;
614: sc->sc_cmap.cm_map[index][1] = b;
615: sc->sc_cmap.cm_map[index][0] = 0; /* no alpha channel */
616:
617: cgfourteen_loadcmap_immediate(sc, index, 1);
618: }
619:
620: int
621: cgfourteen_intr(void *v)
622: {
623: struct cgfourteen_softc *sc = v;
624: u_int msr;
625: int claim = 0;
626:
627: msr = sc->sc_ctl->ctl_msr;
628:
629: /* check that the interrupt is ours */
630: if (!ISSET(msr, CG14_MSR_PENDING) ||
631: !ISSET(sc->sc_ctl->ctl_mctl, CG14_MCTL_ENABLEINTR)) {
632: return (0);
633: }
634:
635: /* vertical retrace interrupt */
636: if (ISSET(msr, CG14_MSR_VRETRACE)) {
637: /* acknowledge by writing to the (read only) msr */
638: sc->sc_ctl->ctl_msr = 0;
639:
640: /* disable interrupts until next colormap change */
641: sc->sc_ctl->ctl_mctl &= ~CG14_MCTL_ENABLEINTR;
642:
643: cgfourteen_loadcmap_immediate(sc,
644: sc->sc_cmap_start, sc->sc_cmap_count);
645:
646: claim = 1;
647: }
648:
649: /* engine fault */
650: if (ISSET(msr, CG14_MSR_FAULT)) {
651: /* acknowledge by reading the fault status register */
652: claim = 1 | sc->sc_ctl->ctl_fsr;
653: }
654:
655: if (claim == 0) {
656: #ifdef DEBUG
657: printf("%s: unknown interrupt cause, msr=%x\n",
658: sc->sc_sunfb.sf_dev.dv_xname, msr);
659: #endif
660: claim = 1; /* claim anyway */
661: }
662:
663: return (claim & 1);
664: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to cgfourteen.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc / dev