Annotation of sys/arch/vax/vsa/gpx.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: gpx.c,v 1.16 2006/11/29 19:08:22 miod Exp $ */
2: /*
3: * Copyright (c) 2006 Miodrag Vallat.
4: *
5: * Permission to use, copy, modify, and distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice, this permission notice, and the disclaimer below
8: * appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18: /*-
19: * Copyright (c) 1988 Regents of the University of California.
20: * All rights reserved.
21: *
22: * Redistribution and use in source and binary forms, with or without
23: * modification, are permitted provided that the following conditions
24: * are met:
25: * 1. Redistributions of source code must retain the above copyright
26: * notice, this list of conditions and the following disclaimer.
27: * 2. Redistributions in binary form must reproduce the above copyright
28: * notice, this list of conditions and the following disclaimer in the
29: * documentation and/or other materials provided with the distribution.
30: * 3. Neither the name of the University nor the names of its contributors
31: * may be used to endorse or promote products derived from this software
32: * without specific prior written permission.
33: *
34: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
35: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44: * SUCH DAMAGE.
45: *
46: * @(#)qd.c 7.1 (Berkeley) 6/28/91
47: */
48:
49: /************************************************************************
50: * *
51: * Copyright (c) 1985-1988 by *
52: * Digital Equipment Corporation, Maynard, MA *
53: * All rights reserved. *
54: * *
55: * This software is furnished under a license and may be used and *
56: * copied only in accordance with the terms of such license and *
57: * with the inclusion of the above copyright notice. This *
58: * software or any other copies thereof may not be provided or *
59: * otherwise made available to any other person. No title to and *
60: * ownership of the software is hereby transferred. *
61: * *
62: * The information in this software is subject to change without *
63: * notice and should not be construed as a commitment by Digital *
64: * Equipment Corporation. *
65: * *
66: * Digital assumes no responsibility for the use or reliability *
67: * of its software on equipment which is not supplied by Digital. *
68: * *
69: *************************************************************************/
70:
71: /*
72: * Driver for the GPX color option on VAXstation 3100, based on the
73: * MicroVAX II qdss driver.
74: *
75: * The frame buffer memory itself is not directly accessible (unlike
76: * the on-board monochrome smg frame buffer), and writes through the
77: * Dragon chip can only happen in multiples of 16 pixels, horizontally.
78: *
79: * Because of this limitation, the font image is copied to offscreen
80: * memory (which there is plenty of), and screen to screen blt operations
81: * are done for everything.
82: */
83:
84: #include <sys/param.h>
85: #include <sys/device.h>
86: #include <sys/systm.h>
87: #include <sys/malloc.h>
88: #include <sys/conf.h>
89: #include <sys/kernel.h>
90:
91: #include <machine/sid.h>
92: #include <machine/cpu.h>
93: #include <machine/ka420.h>
94: #include <machine/scb.h>
95: #include <machine/vsbus.h>
96:
97: #include <uvm/uvm_extern.h>
98:
99: #include <dev/cons.h>
100:
101: #include <dev/wscons/wsconsio.h>
102: #include <dev/wscons/wsdisplayvar.h>
103: #include <dev/rasops/rasops.h>
104: #include <dev/wsfont/wsfont.h>
105:
106: #include <dev/ic/bt458reg.h>
107: #if 0
108: #include <dev/ic/dc503reg.h>
109: #endif
110: #include <vax/qbus/qdreg.h>
111:
112: #define GPXADDR 0x3c000000 /* base address on VAXstation 3100 */
113:
114: #define GPX_ADDER_OFFSET 0x0000
115: #define GPX_VDAC_OFFSET 0x0300
116: #define GPX_CURSOR_OFFSET 0x0400 /* DC503 */
117: #define GPX_READBACK_OFFSET 0x0500
118:
119: #define GPX_WIDTH 1024
120: #define GPX_VISHEIGHT 864
121: #define GPX_HEIGHT 2048
122:
123: /* 4 plane option RAMDAC */
124: struct ramdac4 {
125: u_int16_t colormap[16];
126: u_int8_t unknown[0x20];
127: u_int16_t cursormap[4];
128: u_int8_t unknown2[0x18];
129: u_int16_t control;
130: #define RAMDAC4_INIT 0x0047
131: #define RAMDAC4_ENABLE 0x0002
132: };
133:
134: /* 8 plane option RAMDAC - Bt458 or compatible */
135: struct ramdac8 {
136: u_int16_t address;
137: u_int16_t cmapdata;
138: u_int16_t control;
139: u_int16_t omapdata;
140: };
141:
142: int gpx_match(struct device *, void *, void *);
143: void gpx_attach(struct device *, struct device *, void *);
144:
145: struct gpx_screen {
146: struct rasops_info ss_ri;
147: int ss_console;
148: u_int ss_depth;
149: u_int ss_gpr; /* font glyphs per row */
150: struct adder *ss_adder;
151: void *ss_vdac;
152: u_int8_t ss_cmap[256 * 3];
153: #if 0
154: struct dc503reg *ss_cursor;
155: u_int16_t ss_curcmd;
156: #endif
157: };
158:
159: /* for console */
160: struct gpx_screen gpx_consscr;
161:
162: struct gpx_softc {
163: struct device sc_dev;
164: struct gpx_screen *sc_scr;
165: int sc_nscreens;
166: };
167:
168: struct cfattach gpx_ca = {
169: sizeof(struct gpx_softc), gpx_match, gpx_attach,
170: };
171:
172: struct cfdriver gpx_cd = {
173: NULL, "gpx", DV_DULL
174: };
175:
176: struct wsscreen_descr gpx_stdscreen = {
177: "std",
178: };
179:
180: const struct wsscreen_descr *_gpx_scrlist[] = {
181: &gpx_stdscreen,
182: };
183:
184: const struct wsscreen_list gpx_screenlist = {
185: sizeof(_gpx_scrlist) / sizeof(struct wsscreen_descr *),
186: _gpx_scrlist,
187: };
188:
189: int gpx_ioctl(void *, u_long, caddr_t, int, struct proc *);
190: paddr_t gpx_mmap(void *, off_t, int);
191: int gpx_alloc_screen(void *, const struct wsscreen_descr *,
192: void **, int *, int *, long *);
193: void gpx_free_screen(void *, void *);
194: int gpx_show_screen(void *, void *, int,
195: void (*) (void *, int, int), void *);
196: void gpx_burner(void *, u_int, u_int);
197:
198: const struct wsdisplay_accessops gpx_accessops = {
199: gpx_ioctl,
200: gpx_mmap,
201: gpx_alloc_screen,
202: gpx_free_screen,
203: gpx_show_screen,
204: NULL, /* load_font */
205: NULL, /* scrollback */
206: NULL, /* getchar */
207: gpx_burner
208: };
209:
210: void gpx_clear_screen(struct gpx_screen *);
211: void gpx_copyrect(struct gpx_screen *, int, int, int, int, int, int);
212: void gpx_fillrect(struct gpx_screen *, int, int, int, int, long, u_int);
213: int gpx_getcmap(struct gpx_screen *, struct wsdisplay_cmap *);
214: void gpx_loadcmap(struct gpx_screen *, int, int);
215: int gpx_putcmap(struct gpx_screen *, struct wsdisplay_cmap *);
216: void gpx_resetcmap(struct gpx_screen *);
217: void gpx_reset_viper(struct gpx_screen *);
218: int gpx_setup_screen(struct gpx_screen *);
219: void gpx_upload_font(struct gpx_screen *);
220: int gpx_viper_write(struct gpx_screen *, u_int, u_int16_t);
221: int gpx_wait(struct gpx_screen *, int);
222:
223: void gpx_copycols(void *, int, int, int, int);
224: void gpx_copyrows(void *, int, int, int);
225: void gpx_do_cursor(struct rasops_info *);
226: void gpx_erasecols(void *, int, int, int, long);
227: void gpx_eraserows(void *, int, int, long);
228: void gpx_putchar(void *, int, int, u_int, long);
229:
230: /*
231: * Autoconf glue
232: */
233:
234: int
235: gpx_match(struct device *parent, void *vcf, void *aux)
236: {
237: struct vsbus_attach_args *va = aux;
238: struct adder *adder;
239: vaddr_t tmp;
240: u_int depth;
241: extern struct consdev wsdisplay_cons;
242: extern int oldvsbus;
243:
244: switch (vax_boardtype) {
245: default:
246: return (0);
247:
248: case VAX_BTYP_410:
249: case VAX_BTYP_420:
250: case VAX_BTYP_43:
251: if (va->va_paddr != GPXADDR)
252: return (0);
253:
254: /* not present on microvaxes */
255: if ((vax_confdata & KA420_CFG_MULTU) != 0)
256: return (0);
257:
258: if ((vax_confdata & KA420_CFG_VIDOPT) == 0)
259: return (0);
260: break;
261: }
262:
263: /* Check for a recognized color depth */
264: tmp = vax_map_physmem(va->va_paddr + GPX_READBACK_OFFSET, 1);
265: if (tmp == 0L)
266: return (0);
267: depth = (*(u_int16_t *)tmp) & 0x00f0;
268: vax_unmap_physmem(tmp, 1);
269: if (depth != 0x00f0 && depth != 0x0080)
270: return (0);
271:
272: /* when already running as console, always fake things */
273: if ((vax_confdata & KA420_CFG_L3CON) == 0 &&
274: cn_tab == &wsdisplay_cons) {
275: struct vsbus_softc *sc = (void *)parent;
276: sc->sc_mask = 0x08;
277: scb_fake(0x44, oldvsbus ? 0x14 : 0x15);
278: } else {
279: adder = (struct adder *)vax_map_physmem(va->va_paddr +
280: GPX_ADDER_OFFSET, 1);
281: if (adder == NULL)
282: return (0);
283: adder->interrupt_enable = FRAME_SYNC;
284: DELAY(100000); /* enough to get a retrace interrupt */
285: adder->interrupt_enable = 0;
286: vax_unmap_physmem((vaddr_t)adder, 1);
287: }
288: return (20);
289: }
290:
291: void
292: gpx_attach(struct device *parent, struct device *self, void *aux)
293: {
294: struct gpx_softc *sc = (struct gpx_softc *)self;
295: struct vsbus_attach_args *va = aux;
296: struct gpx_screen *scr;
297: struct wsemuldisplaydev_attach_args aa;
298: int console;
299: vaddr_t tmp;
300: extern struct consdev wsdisplay_cons;
301:
302: console = (vax_confdata & KA420_CFG_L3CON) == 0 &&
303: cn_tab == &wsdisplay_cons;
304: if (console) {
305: scr = &gpx_consscr;
306: sc->sc_nscreens = 1;
307: } else {
308: scr = malloc(sizeof(struct gpx_screen), M_DEVBUF, M_NOWAIT);
309: if (scr == NULL) {
310: printf(": can not allocate memory\n");
311: return;
312: }
313:
314: tmp = vax_map_physmem(va->va_paddr + GPX_READBACK_OFFSET, 1);
315: if (tmp == 0L) {
316: printf(": can not probe depth\n");
317: goto bad1;
318: }
319: scr->ss_depth = (*(u_int16_t *)tmp & 0x00f0) == 0x00f0 ? 4 : 8;
320: vax_unmap_physmem(tmp, 1);
321:
322: scr->ss_adder = (struct adder *)vax_map_physmem(va->va_paddr +
323: GPX_ADDER_OFFSET, 1);
324: if (scr->ss_adder == NULL) {
325: printf(": can not map frame buffer registers\n");
326: goto bad1;
327: }
328:
329: scr->ss_vdac = (void *)vax_map_physmem(va->va_paddr +
330: GPX_VDAC_OFFSET, 1);
331: if (scr->ss_vdac == NULL) {
332: printf(": can not map RAMDAC\n");
333: goto bad2;
334: }
335:
336: #if 0
337: scr->ss_cursor =
338: (struct dc503reg *)vax_map_physmem(va->va_paddr +
339: GPX_CURSOR_OFFSET, 1);
340: if (scr->ss_cursor == NULL) {
341: printf(": can not map cursor chip\n");
342: goto bad3;
343: }
344: #endif
345:
346: if (gpx_setup_screen(scr) != 0) {
347: printf(": initialization failed\n");
348: goto bad4;
349: }
350: }
351: sc->sc_scr = scr;
352:
353: printf("\n%s: %dx%d %d plane color framebuffer\n",
354: self->dv_xname, GPX_WIDTH, GPX_VISHEIGHT, scr->ss_depth);
355:
356: aa.console = console;
357: aa.scrdata = &gpx_screenlist;
358: aa.accessops = &gpx_accessops;
359: aa.accesscookie = sc;
360: aa.defaultscreens = 0;
361:
362: config_found(self, &aa, wsemuldisplaydevprint);
363:
364: return;
365:
366: bad4:
367: #if 0
368: vax_unmap_physmem((vaddr_t)scr->ss_cursor, 1);
369: bad3:
370: #endif
371: vax_unmap_physmem((vaddr_t)scr->ss_vdac, 1);
372: bad2:
373: vax_unmap_physmem((vaddr_t)scr->ss_adder, 1);
374: bad1:
375: free(scr, M_DEVBUF);
376: }
377:
378: /*
379: * wsdisplay accessops
380: */
381:
382: int
383: gpx_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
384: {
385: struct gpx_softc *sc = v;
386: struct gpx_screen *ss = sc->sc_scr;
387: struct wsdisplay_fbinfo *wdf;
388: struct wsdisplay_cmap *cm;
389: int error;
390:
391: switch (cmd) {
392: case WSDISPLAYIO_GTYPE:
393: *(u_int *)data = WSDISPLAY_TYPE_GPX;
394: break;
395:
396: case WSDISPLAYIO_GINFO:
397: wdf = (struct wsdisplay_fbinfo *)data;
398: wdf->height = ss->ss_ri.ri_height;
399: wdf->width = ss->ss_ri.ri_width;
400: wdf->depth = ss->ss_depth;
401: wdf->cmsize = 1 << ss->ss_depth;
402: break;
403:
404: case WSDISPLAYIO_GETCMAP:
405: cm = (struct wsdisplay_cmap *)data;
406: error = gpx_getcmap(ss, cm);
407: if (error != 0)
408: return (error);
409: break;
410: case WSDISPLAYIO_PUTCMAP:
411: cm = (struct wsdisplay_cmap *)data;
412: error = gpx_putcmap(ss, cm);
413: if (error != 0)
414: return (error);
415: gpx_loadcmap(ss, cm->index, cm->count);
416: break;
417:
418: case WSDISPLAYIO_GVIDEO:
419: case WSDISPLAYIO_SVIDEO:
420: break;
421:
422: case WSDISPLAYIO_LINEBYTES: /* no linear mapping */
423: default:
424: return (-1);
425: }
426:
427: return (0);
428: }
429:
430: paddr_t
431: gpx_mmap(void *v, off_t offset, int prot)
432: {
433: return (-1);
434: }
435:
436: int
437: gpx_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep,
438: int *curxp, int *curyp, long *defattrp)
439: {
440: struct gpx_softc *sc = v;
441: struct gpx_screen *ss = sc->sc_scr;
442: struct rasops_info *ri = &ss->ss_ri;
443:
444: if (sc->sc_nscreens > 0)
445: return (ENOMEM);
446:
447: *cookiep = ri;
448: *curxp = *curyp = 0;
449: ri->ri_ops.alloc_attr(ri, 0, 0, 0, defattrp);
450: sc->sc_nscreens++;
451:
452: return (0);
453: }
454:
455: void
456: gpx_free_screen(void *v, void *cookie)
457: {
458: struct gpx_softc *sc = v;
459:
460: sc->sc_nscreens--;
461: }
462:
463: int
464: gpx_show_screen(void *v, void *cookie, int waitok,
465: void (*cb)(void *, int, int), void *cbarg)
466: {
467: return (0);
468: }
469:
470: void
471: gpx_burner(void *v, u_int on, u_int flags)
472: {
473: struct gpx_softc *sc = v;
474: struct gpx_screen *ss = sc->sc_scr;
475:
476: if (ss->ss_depth == 8) {
477: struct ramdac8 *rd = ss->ss_vdac;
478: rd->address = BT_CR;
479: if (on)
480: rd->control = BTCR_RAMENA | BTCR_BLINK_1648 |
481: BTCR_MPLX_4;
482: else
483: /* fade colormap to black as well? */
484: rd->control = BTCR_BLINK_1648 | BTCR_MPLX_4;
485: } else {
486: struct ramdac4 *rd = ss->ss_vdac;
487: if (on)
488: rd->control = RAMDAC4_INIT;
489: else
490: rd->control = RAMDAC4_INIT & ~RAMDAC4_ENABLE;
491: }
492: }
493:
494: /*
495: * wsdisplay emulops
496: */
497:
498: void
499: gpx_putchar(void *v, int row, int col, u_int uc, long attr)
500: {
501: struct rasops_info *ri = v;
502: struct gpx_screen *ss = ri->ri_hw;
503: struct wsdisplay_font *font = ri->ri_font;
504: int dx, dy, sx, sy, fg, bg, ul;
505:
506: ri->ri_ops.unpack_attr(v, attr, &fg, &bg, &ul);
507:
508: /* find where to output the glyph... */
509: dx = col * font->fontwidth + ri->ri_xorigin;
510: dy = row * font->fontheight + ri->ri_yorigin;
511: /* ... and where to pick it from */
512: uc -= font->firstchar;
513: sx = (uc % ss->ss_gpr) * font->stride * NBBY;
514: sy = GPX_HEIGHT - (1 + uc / ss->ss_gpr) * font->fontheight;
515:
516: /* setup VIPER operand control registers */
517: while (gpx_viper_write(ss, CS_UPDATE_MASK, 0x00ff));
518: gpx_viper_write(ss, SRC1_OCR_B,
519: EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY);
520: gpx_viper_write(ss, DST_OCR_B,
521: EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
522: gpx_viper_write(ss, MASK_1, 0xffff);
523: gpx_viper_write(ss, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, fg);
524: gpx_viper_write(ss, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, bg);
525: ss->ss_adder->x_clip_min = 0;
526: ss->ss_adder->x_clip_max = GPX_WIDTH;
527: ss->ss_adder->y_clip_min = 0;
528: ss->ss_adder->y_clip_max = GPX_VISHEIGHT;
529: /* load DESTINATION origin and vectors */
530: ss->ss_adder->fast_dest_dy = 0;
531: ss->ss_adder->slow_dest_dx = 0;
532: ss->ss_adder->error_1 = 0;
533: ss->ss_adder->error_2 = 0;
534: ss->ss_adder->rasterop_mode = DST_WRITE_ENABLE | NORMAL;
535: gpx_wait(ss, RASTEROP_COMPLETE);
536: ss->ss_adder->destination_x = dx;
537: ss->ss_adder->fast_dest_dx = font->fontwidth;
538: ss->ss_adder->destination_y = dy;
539: ss->ss_adder->slow_dest_dy = font->fontheight;
540: /* load SOURCE origin and vectors */
541: ss->ss_adder->source_1_x = sx;
542: ss->ss_adder->source_1_y = sy;
543: ss->ss_adder->source_1_dx = font->fontwidth;
544: ss->ss_adder->source_1_dy = font->fontheight;
545: ss->ss_adder->cmd = RASTEROP | OCRB | S1E | DTE | LF_R1;
546:
547: if (ul != 0) {
548: gpx_fillrect(ss, dx, dy + font->fontheight - 2, font->fontwidth,
549: 1, attr, LF_R3); /* fg fill */
550: }
551: }
552:
553: void
554: gpx_copycols(void *v, int row, int src, int dst, int cnt)
555: {
556: struct rasops_info *ri = v;
557: struct gpx_screen *ss = ri->ri_hw;
558: struct wsdisplay_font *font = ri->ri_font;
559: int sx, y, dx, w, h;
560:
561: sx = ri->ri_xorigin + src * font->fontwidth;
562: dx = ri->ri_xorigin + dst * font->fontwidth;
563: w = cnt * font->fontwidth;
564: y = ri->ri_yorigin + row * font->fontheight;
565: h = font->fontheight;
566:
567: gpx_copyrect(ss, sx, y, dx, y, w, h);
568: }
569:
570: void
571: gpx_erasecols(void *v, int row, int col, int cnt, long attr)
572: {
573: struct rasops_info *ri = v;
574: struct gpx_screen *ss = ri->ri_hw;
575: struct wsdisplay_font *font = ri->ri_font;
576: int x, y, dx, dy;
577:
578: x = ri->ri_xorigin + col * font->fontwidth;
579: dx = cnt * font->fontwidth;
580: y = ri->ri_yorigin + row * font->fontheight;
581: dy = font->fontheight;
582:
583: gpx_fillrect(ss, x, y, dx, dy, attr, LF_R2); /* bg fill */
584: }
585:
586: void
587: gpx_copyrows(void *v, int src, int dst, int cnt)
588: {
589: struct rasops_info *ri = v;
590: struct gpx_screen *ss = ri->ri_hw;
591: struct wsdisplay_font *font = ri->ri_font;
592: int x, sy, dy, w, h;
593:
594: x = ri->ri_xorigin;
595: w = ri->ri_emustride;
596: sy = ri->ri_yorigin + src * font->fontheight;
597: dy = ri->ri_yorigin + dst * font->fontheight;
598: h = cnt * font->fontheight;
599:
600: gpx_copyrect(ss, x, sy, x, dy, w, h);
601: }
602:
603: void
604: gpx_eraserows(void *v, int row, int cnt, long attr)
605: {
606: struct rasops_info *ri = v;
607: struct gpx_screen *ss = ri->ri_hw;
608: struct wsdisplay_font *font = ri->ri_font;
609: int x, y, dx, dy;
610:
611: x = ri->ri_xorigin;
612: dx = ri->ri_emustride;
613: y = ri->ri_yorigin + row * font->fontheight;
614: dy = cnt * font->fontheight;
615:
616: gpx_fillrect(ss, x, y, dx, dy, attr, LF_R2); /* bg fill */
617: }
618:
619: void
620: gpx_do_cursor(struct rasops_info *ri)
621: {
622: struct gpx_screen *ss = ri->ri_hw;
623: int x, y, w, h;
624:
625: x = ri->ri_ccol * ri->ri_font->fontwidth + ri->ri_xorigin;
626: y = ri->ri_crow * ri->ri_font->fontheight + ri->ri_yorigin;
627: w = ri->ri_font->fontwidth;
628: h = ri->ri_font->fontheight;
629:
630: gpx_fillrect(ss, x, y, w, h, WSCOL_WHITE << 24, LF_R4); /* invert */
631: }
632:
633: /*
634: * low-level programming routines
635: */
636:
637: int
638: gpx_wait(struct gpx_screen *ss, int bits)
639: {
640: int i;
641:
642: ss->ss_adder->status = 0;
643: for (i = 100000; i != 0; i--) {
644: if ((ss->ss_adder->status & bits) == bits)
645: break;
646: DELAY(1);
647: }
648:
649: return (i == 0);
650: }
651:
652: int
653: gpx_viper_write(struct gpx_screen *ss, u_int reg, u_int16_t val)
654: {
655: if (gpx_wait(ss, ADDRESS_COMPLETE) == 0 &&
656: gpx_wait(ss, TX_READY) == 0) {
657: ss->ss_adder->id_data = val;
658: ss->ss_adder->command = ID_LOAD | reg;
659: return (0);
660: }
661: #ifdef DEBUG
662: if (ss->ss_console == 0) /* don't make things worse! */
663: printf("gpx_viper_write failure, reg %x val %x\n", reg, val);
664: #endif
665: return (1);
666: }
667:
668: /* Initialize the damned beast. Straight from qdss. */
669: void
670: gpx_reset_viper(struct gpx_screen *ss)
671: {
672: int i;
673:
674: ss->ss_adder->interrupt_enable = 0;
675: ss->ss_adder->command = CANCEL;
676: /* set monitor timing */
677: ss->ss_adder->x_scan_count_0 = 0x2800;
678: ss->ss_adder->x_scan_count_1 = 0x1020;
679: ss->ss_adder->x_scan_count_2 = 0x003a;
680: ss->ss_adder->x_scan_count_3 = 0x38f0;
681: ss->ss_adder->x_scan_count_4 = 0x6128;
682: ss->ss_adder->x_scan_count_5 = 0x093a;
683: ss->ss_adder->x_scan_count_6 = 0x313c;
684: ss->ss_adder->sync_phase_adj = 0x0100;
685: ss->ss_adder->x_scan_conf = 0x00c8;
686: /*
687: * got a bug in secound pass ADDER! lets take care of it...
688: *
689: * normally, just use the code in the following bug fix code, but to
690: * make repeated demos look pretty, load the registers as if there was
691: * no bug and then test to see if we are getting sync
692: */
693: ss->ss_adder->y_scan_count_0 = 0x135f;
694: ss->ss_adder->y_scan_count_1 = 0x3363;
695: ss->ss_adder->y_scan_count_2 = 0x2366;
696: ss->ss_adder->y_scan_count_3 = 0x0388;
697: /*
698: * if no sync, do the bug fix code
699: */
700: if (gpx_wait(ss, FRAME_SYNC) != 0) {
701: /*
702: * First load all Y scan registers with very short frame and
703: * wait for scroll service. This guarantees at least one SYNC
704: * to fix the pass 2 Adder initialization bug (synchronizes
705: * XCINCH with DMSEEDH)
706: */
707: ss->ss_adder->y_scan_count_0 = 0x01;
708: ss->ss_adder->y_scan_count_1 = 0x01;
709: ss->ss_adder->y_scan_count_2 = 0x01;
710: ss->ss_adder->y_scan_count_3 = 0x01;
711: /* delay at least 1 full frame time */
712: gpx_wait(ss, FRAME_SYNC);
713: gpx_wait(ss, FRAME_SYNC);
714: /*
715: * now load the REAL sync values (in reverse order just to
716: * be safe).
717: */
718: ss->ss_adder->y_scan_count_3 = 0x0388;
719: ss->ss_adder->y_scan_count_2 = 0x2366;
720: ss->ss_adder->y_scan_count_1 = 0x3363;
721: ss->ss_adder->y_scan_count_0 = 0x135f;
722: }
723: /* zero the index registers */
724: ss->ss_adder->x_index_pending = 0;
725: ss->ss_adder->y_index_pending = 0;
726: ss->ss_adder->x_index_new = 0;
727: ss->ss_adder->y_index_new = 0;
728: ss->ss_adder->x_index_old = 0;
729: ss->ss_adder->y_index_old = 0;
730: ss->ss_adder->pause = 0;
731: /* set rasterop mode to normal pen down */
732: ss->ss_adder->rasterop_mode =
733: DST_WRITE_ENABLE | DST_INDEX_ENABLE | NORMAL;
734: /* set the rasterop registers to default values */
735: ss->ss_adder->source_1_dx = 1;
736: ss->ss_adder->source_1_dy = 1;
737: ss->ss_adder->source_1_x = 0;
738: ss->ss_adder->source_1_y = 0;
739: ss->ss_adder->destination_x = 0;
740: ss->ss_adder->destination_y = 0;
741: ss->ss_adder->fast_dest_dx = 1;
742: ss->ss_adder->fast_dest_dy = 0;
743: ss->ss_adder->slow_dest_dx = 0;
744: ss->ss_adder->slow_dest_dy = 1;
745: ss->ss_adder->error_1 = 0;
746: ss->ss_adder->error_2 = 0;
747: /* scale factor = UNITY */
748: ss->ss_adder->fast_scale = UNITY;
749: ss->ss_adder->slow_scale = UNITY;
750: /* set the source 2 parameters */
751: ss->ss_adder->source_2_x = 0;
752: ss->ss_adder->source_2_y = 0;
753: ss->ss_adder->source_2_size = 0x0022;
754: /* initialize plane addresses for eight vipers */
755: for (i = 0; i < 8; i++) {
756: gpx_viper_write(ss, CS_UPDATE_MASK, 1 << i);
757: gpx_viper_write(ss, PLANE_ADDRESS, i);
758: }
759: /* initialize the external registers. */
760: gpx_viper_write(ss, CS_UPDATE_MASK, 0x00ff);
761: gpx_viper_write(ss, CS_SCROLL_MASK, 0x00ff);
762: /* initialize resolution mode */
763: gpx_viper_write(ss, MEMORY_BUS_WIDTH, 0x000c); /* bus width = 16 */
764: gpx_viper_write(ss, RESOLUTION_MODE, 0x0000); /* one bit/pixel */
765: /* initialize viper registers */
766: gpx_viper_write(ss, SCROLL_CONSTANT,
767: SCROLL_ENABLE | VIPER_LEFT | VIPER_UP);
768: gpx_viper_write(ss, SCROLL_FILL, 0x0000);
769: /* set clipping and scrolling limits to full screen */
770: gpx_wait(ss, ADDRESS_COMPLETE);
771: ss->ss_adder->x_clip_min = 0;
772: ss->ss_adder->x_clip_max = GPX_WIDTH;
773: ss->ss_adder->y_clip_min = 0;
774: ss->ss_adder->y_clip_max = GPX_HEIGHT;
775: ss->ss_adder->scroll_x_min = 0;
776: ss->ss_adder->scroll_x_max = GPX_WIDTH;
777: ss->ss_adder->scroll_y_min = 0;
778: ss->ss_adder->scroll_y_max = GPX_HEIGHT;
779: gpx_wait(ss, FRAME_SYNC); /* wait at LEAST 1 full frame */
780: gpx_wait(ss, FRAME_SYNC);
781: ss->ss_adder->x_index_pending = 0;
782: ss->ss_adder->y_index_pending = 0;
783: ss->ss_adder->x_index_new = 0;
784: ss->ss_adder->y_index_new = 0;
785: ss->ss_adder->x_index_old = 0;
786: ss->ss_adder->y_index_old = 0;
787: gpx_wait(ss, ADDRESS_COMPLETE);
788: gpx_viper_write(ss, LEFT_SCROLL_MASK, 0x0000);
789: gpx_viper_write(ss, RIGHT_SCROLL_MASK, 0x0000);
790: /* set source and the mask register to all ones */
791: gpx_viper_write(ss, SOURCE, 0xffff);
792: gpx_viper_write(ss, MASK_1, 0xffff);
793: gpx_viper_write(ss, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
794: gpx_viper_write(ss, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
795: /* initialize Operand Control Register banks for fill command */
796: gpx_viper_write(ss, SRC1_OCR_A, EXT_NONE | INT_M1_M2 | NO_ID | WAIT);
797: gpx_viper_write(ss, SRC2_OCR_A, EXT_NONE | INT_SOURCE | NO_ID | NO_WAIT);
798: gpx_viper_write(ss, DST_OCR_A, EXT_NONE | INT_NONE | NO_ID | NO_WAIT);
799: gpx_viper_write(ss, SRC1_OCR_B, EXT_NONE | INT_SOURCE | NO_ID | WAIT);
800: gpx_viper_write(ss, SRC2_OCR_B, EXT_NONE | INT_M1_M2 | NO_ID | NO_WAIT);
801: gpx_viper_write(ss, DST_OCR_B, EXT_NONE | INT_NONE | NO_ID | NO_WAIT);
802:
803: /*
804: * Init Logic Unit Function registers.
805: */
806: /* putchar */
807: gpx_viper_write(ss, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE);
808: /* erase{cols,rows} */
809: gpx_viper_write(ss, LU_FUNCTION_R2, FULL_SRC_RESOLUTION | LF_ZEROS);
810: /* underline */
811: gpx_viper_write(ss, LU_FUNCTION_R3, FULL_SRC_RESOLUTION | LF_ONES);
812: /* cursor */
813: gpx_viper_write(ss, LU_FUNCTION_R4, FULL_SRC_RESOLUTION | LF_NOT_D);
814: }
815:
816: /* Clear the whole screen. Straight from qdss. */
817: void
818: gpx_clear_screen(struct gpx_screen *ss)
819: {
820: ss->ss_adder->x_limit = GPX_WIDTH;
821: ss->ss_adder->y_limit = GPX_HEIGHT;
822: ss->ss_adder->y_offset_pending = 0;
823: gpx_wait(ss, FRAME_SYNC); /* wait at LEAST 1 full frame */
824: gpx_wait(ss, FRAME_SYNC);
825: ss->ss_adder->y_scroll_constant = SCROLL_ERASE;
826: gpx_wait(ss, FRAME_SYNC);
827: gpx_wait(ss, FRAME_SYNC);
828: ss->ss_adder->y_offset_pending = GPX_VISHEIGHT;
829: gpx_wait(ss, FRAME_SYNC);
830: gpx_wait(ss, FRAME_SYNC);
831: ss->ss_adder->y_scroll_constant = SCROLL_ERASE;
832: gpx_wait(ss, FRAME_SYNC);
833: gpx_wait(ss, FRAME_SYNC);
834: ss->ss_adder->y_offset_pending = 2 * GPX_VISHEIGHT;
835: gpx_wait(ss, FRAME_SYNC);
836: gpx_wait(ss, FRAME_SYNC);
837: ss->ss_adder->y_scroll_constant = SCROLL_ERASE;
838: gpx_wait(ss, FRAME_SYNC);
839: gpx_wait(ss, FRAME_SYNC);
840: ss->ss_adder->y_offset_pending = 0; /* back to normal */
841: gpx_wait(ss, FRAME_SYNC);
842: gpx_wait(ss, FRAME_SYNC);
843: ss->ss_adder->x_limit = GPX_WIDTH;
844: ss->ss_adder->y_limit = GPX_VISHEIGHT;
845: }
846:
847: int
848: gpx_setup_screen(struct gpx_screen *ss)
849: {
850: struct rasops_info *ri = &ss->ss_ri;
851: int cookie;
852:
853: bzero(ri, sizeof(*ri));
854: ri->ri_depth = 8; /* masquerade as a 8 bit device for rasops */
855: ri->ri_width = GPX_WIDTH;
856: ri->ri_height = GPX_VISHEIGHT;
857: ri->ri_stride = GPX_WIDTH;
858: ri->ri_flg = RI_CENTER; /* no RI_CLEAR as ri_bits is NULL! */
859: ri->ri_hw = ss;
860:
861: /*
862: * We can not let rasops select our font, because we need to use
863: * a font with right-to-left bit order on this frame buffer.
864: */
865: wsfont_init();
866: cookie = wsfont_find(NULL, 12, 0, 0);
867: if (cookie <= 0)
868: cookie = wsfont_find(NULL, 8, 0, 0);
869: if (cookie <= 0)
870: cookie = wsfont_find(NULL, 0, 0, 0);
871: if (cookie <= 0)
872: return (-1);
873: if (wsfont_lock(cookie, &ri->ri_font,
874: WSDISPLAY_FONTORDER_R2L, WSDISPLAY_FONTORDER_L2R) <= 0)
875: return (-1);
876: ri->ri_wsfcookie = cookie;
877:
878: /*
879: * Ask for an unholy big display, rasops will trim this to more
880: * reasonable values.
881: */
882: if (rasops_init(ri, 160, 160) != 0)
883: return (-1);
884:
885: /*
886: * Override the rasops emulops.
887: */
888: ri->ri_ops.copyrows = gpx_copyrows;
889: ri->ri_ops.copycols = gpx_copycols;
890: ri->ri_ops.eraserows = gpx_eraserows;
891: ri->ri_ops.erasecols = gpx_erasecols;
892: ri->ri_ops.putchar = gpx_putchar;
893: ri->ri_do_cursor = gpx_do_cursor;
894:
895: gpx_stdscreen.ncols = ri->ri_cols;
896: gpx_stdscreen.nrows = ri->ri_rows;
897: gpx_stdscreen.textops = &ri->ri_ops;
898: gpx_stdscreen.fontwidth = ri->ri_font->fontwidth;
899: gpx_stdscreen.fontheight = ri->ri_font->fontheight;
900: gpx_stdscreen.capabilities = ri->ri_caps;
901:
902: /*
903: * Initialize RAMDAC.
904: */
905: if (ss->ss_depth == 8) {
906: struct ramdac8 *rd = ss->ss_vdac;
907: rd->address = BT_CR;
908: rd->control = BTCR_RAMENA | BTCR_BLINK_1648 | BTCR_MPLX_4;
909: } else {
910: struct ramdac4 *rd = ss->ss_vdac;
911: rd->control = RAMDAC4_INIT;
912: }
913:
914: /*
915: * Put the ADDER and VIPER in a good state.
916: */
917: gpx_reset_viper(ss);
918:
919: /*
920: * Initialize colormap.
921: */
922: gpx_resetcmap(ss);
923:
924: /*
925: * Clear display (including non-visible area), in 864 lines chunks.
926: */
927: gpx_clear_screen(ss);
928:
929: /*
930: * Copy our font to the offscreen area.
931: */
932: gpx_upload_font(ss);
933:
934: #if 0
935: ss->ss_cursor->cmdr = ss->ss_curcmd = PCCCMD_HSHI;
936: #endif
937:
938: return (0);
939: }
940:
941: /*
942: * Copy the selected wsfont to non-visible frame buffer area.
943: * This is necessary since the only way to send data to the frame buffer
944: * is through the ID interface, which is slow and needs 16 bit wide data.
945: * Adapted from qdss.
946: */
947: void
948: gpx_upload_font(struct gpx_screen *ss)
949: {
950: struct rasops_info *ri = &ss->ss_ri;
951: struct wsdisplay_font *font = ri->ri_font;
952: u_int8_t *fontbits, *fb;
953: u_int remaining, nchars, row;
954: u_int i, j;
955: u_int16_t data;
956:
957: /* setup VIPER operand control registers */
958:
959: gpx_viper_write(ss, MASK_1, 0xffff);
960: gpx_viper_write(ss, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
961: gpx_viper_write(ss, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
962:
963: gpx_viper_write(ss, SRC1_OCR_B,
964: EXT_NONE | INT_NONE | ID | BAR_SHIFT_DELAY);
965: gpx_viper_write(ss, SRC2_OCR_B,
966: EXT_NONE | INT_NONE | ID | BAR_SHIFT_DELAY);
967: gpx_viper_write(ss, DST_OCR_B,
968: EXT_SOURCE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
969:
970: ss->ss_adder->rasterop_mode =
971: DST_WRITE_ENABLE | DST_INDEX_ENABLE | NORMAL;
972: gpx_wait(ss, RASTEROP_COMPLETE);
973:
974: /*
975: * Load font data. The font is uploaded in 8 or 16 bit wide cells, on
976: * as many ``lines'' as necessary at the end of the display.
977: */
978: ss->ss_gpr = MIN(GPX_WIDTH / (NBBY * font->stride), font->numchars);
979: if (ss->ss_gpr & 1)
980: ss->ss_gpr--;
981: fontbits = font->data;
982: for (row = 1, remaining = font->numchars; remaining != 0;
983: row++, remaining -= nchars) {
984: nchars = MIN(ss->ss_gpr, remaining);
985:
986: ss->ss_adder->destination_x = 0;
987: ss->ss_adder->destination_y =
988: GPX_HEIGHT - row * font->fontheight;
989: ss->ss_adder->fast_dest_dx = nchars * 16;
990: ss->ss_adder->slow_dest_dy = font->fontheight;
991:
992: /* setup for processor to bitmap xfer */
993: gpx_viper_write(ss, CS_UPDATE_MASK, 0x00ff);
994: ss->ss_adder->cmd = PBT | OCRB | DTE | LF_R1 | 2; /*XXX why 2?*/
995:
996: /* iteratively do the processor to bitmap xfer */
997: for (i = font->fontheight; i != 0; i--) {
998: fb = fontbits;
999: fontbits += font->stride;
1000: /* PTOB a scan line */
1001: for (j = nchars; j != 0; j--) {
1002: /* PTOB one scan of a char cell */
1003: if (font->stride == 1) {
1004: data = *fb;
1005: fb += font->fontheight;
1006: /*
1007: * Do not access past font memory if
1008: * it has an odd number of characters
1009: * and this is the last pair.
1010: */
1011: if (j != 1 || (nchars & 1) == 0 ||
1012: remaining != nchars) {
1013: data |= ((u_int16_t)*fb) << 8;
1014: fb += font->fontheight;
1015: }
1016: } else {
1017: data =
1018: fb[0] | (((u_int16_t)fb[1]) << 8);
1019: fb += font->fontheight * font->stride;
1020: }
1021:
1022: gpx_wait(ss, TX_READY);
1023: ss->ss_adder->id_data = data;
1024: }
1025: }
1026: fontbits += (nchars - 1) * font->stride * font->fontheight;
1027: }
1028: }
1029:
1030: void
1031: gpx_copyrect(struct gpx_screen *ss,
1032: int sx, int sy, int dx, int dy, int w, int h)
1033: {
1034: while (gpx_viper_write(ss, CS_UPDATE_MASK, 0x00ff));
1035: gpx_viper_write(ss, MASK_1, 0xffff);
1036: gpx_viper_write(ss, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
1037: gpx_viper_write(ss, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
1038: gpx_viper_write(ss, SRC1_OCR_B,
1039: EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY);
1040: gpx_viper_write(ss, DST_OCR_B,
1041: EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
1042: ss->ss_adder->fast_dest_dy = 0;
1043: ss->ss_adder->slow_dest_dx = 0;
1044: ss->ss_adder->error_1 = 0;
1045: ss->ss_adder->error_2 = 0;
1046: ss->ss_adder->rasterop_mode = DST_WRITE_ENABLE | NORMAL;
1047: gpx_wait(ss, RASTEROP_COMPLETE);
1048: ss->ss_adder->destination_x = dx;
1049: ss->ss_adder->fast_dest_dx = w;
1050: ss->ss_adder->destination_y = dy;
1051: ss->ss_adder->slow_dest_dy = h;
1052: ss->ss_adder->source_1_x = sx;
1053: ss->ss_adder->source_1_dx = w;
1054: ss->ss_adder->source_1_y = sy;
1055: ss->ss_adder->source_1_dy = h;
1056: ss->ss_adder->cmd = RASTEROP | OCRB | S1E | DTE | LF_R1;
1057: }
1058:
1059: /*
1060: * Fill a rectangle with the given attribute and function (i.e. rop).
1061: */
1062: void
1063: gpx_fillrect(struct gpx_screen *ss, int x, int y, int dx, int dy, long attr,
1064: u_int function)
1065: {
1066: struct rasops_info *ri = &ss->ss_ri;
1067: int fg, bg;
1068:
1069: ri->ri_ops.unpack_attr(ri, attr, &fg, &bg, NULL);
1070:
1071: while (gpx_viper_write(ss, CS_UPDATE_MASK, 0x00ff));
1072: gpx_viper_write(ss, MASK_1, 0xffff);
1073: gpx_viper_write(ss, SOURCE, 0xffff);
1074: gpx_viper_write(ss, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, fg);
1075: gpx_viper_write(ss, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, bg);
1076: gpx_viper_write(ss, SRC1_OCR_B,
1077: EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY);
1078: gpx_viper_write(ss, DST_OCR_B,
1079: EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
1080: ss->ss_adder->fast_dest_dx = 0;
1081: ss->ss_adder->fast_dest_dy = 0;
1082: ss->ss_adder->slow_dest_dx = 0;
1083: ss->ss_adder->error_1 = 0;
1084: ss->ss_adder->error_2 = 0;
1085: ss->ss_adder->rasterop_mode = DST_WRITE_ENABLE | NORMAL;
1086: gpx_wait(ss, RASTEROP_COMPLETE);
1087: ss->ss_adder->destination_x = x;
1088: ss->ss_adder->fast_dest_dx = dx;
1089: ss->ss_adder->destination_y = y;
1090: ss->ss_adder->slow_dest_dy = dy;
1091: ss->ss_adder->source_1_x = x;
1092: ss->ss_adder->source_1_dx = dx;
1093: ss->ss_adder->source_1_y = y;
1094: ss->ss_adder->source_1_dy = dy;
1095: ss->ss_adder->cmd = RASTEROP | OCRB | S1E | DTE | function;
1096: }
1097:
1098: /*
1099: * Colormap handling routines
1100: */
1101:
1102: int
1103: gpx_getcmap(struct gpx_screen *ss, struct wsdisplay_cmap *cm)
1104: {
1105: u_int index = cm->index, count = cm->count, i;
1106: u_int colcount = 1 << ss->ss_depth;
1107: int error;
1108: u_int8_t ramp[256], *c, *r;
1109:
1110: if (index >= colcount || count > colcount - index)
1111: return (EINVAL);
1112:
1113: /* extract reds */
1114: c = ss->ss_cmap + 0 + index * 3;
1115: for (i = count, r = ramp; i != 0; i--)
1116: *r++ = *c << (8 - ss->ss_depth), c += 3;
1117: if ((error = copyout(ramp, cm->red, count)) != 0)
1118: return (error);
1119:
1120: /* extract greens */
1121: c = ss->ss_cmap + 1 + index * 3;
1122: for (i = count, r = ramp; i != 0; i--)
1123: *r++ = *c << (8 - ss->ss_depth), c += 3;
1124: if ((error = copyout(ramp, cm->green, count)) != 0)
1125: return (error);
1126:
1127: /* extract blues */
1128: c = ss->ss_cmap + 2 + index * 3;
1129: for (i = count, r = ramp; i != 0; i--)
1130: *r++ = *c << (8 - ss->ss_depth), c += 3;
1131: if ((error = copyout(ramp, cm->blue, count)) != 0)
1132: return (error);
1133:
1134: return (0);
1135: }
1136:
1137: int
1138: gpx_putcmap(struct gpx_screen *ss, struct wsdisplay_cmap *cm)
1139: {
1140: u_int index = cm->index, count = cm->count;
1141: u_int colcount = 1 << ss->ss_depth;
1142: int i, error;
1143: u_int8_t r[256], g[256], b[256], *nr, *ng, *nb, *c;
1144:
1145: if (index >= colcount || count > colcount - index)
1146: return (EINVAL);
1147:
1148: if ((error = copyin(cm->red, r, count)) != 0)
1149: return (error);
1150: if ((error = copyin(cm->green, g, count)) != 0)
1151: return (error);
1152: if ((error = copyin(cm->blue, b, count)) != 0)
1153: return (error);
1154:
1155: nr = r, ng = g, nb = b;
1156: c = ss->ss_cmap + index * 3;
1157: for (i = count; i != 0; i--) {
1158: *c++ = *nr++ >> (8 - ss->ss_depth);
1159: *c++ = *ng++ >> (8 - ss->ss_depth);
1160: *c++ = *nb++ >> (8 - ss->ss_depth);
1161: }
1162:
1163: return (0);
1164: }
1165:
1166: void
1167: gpx_loadcmap(struct gpx_screen *ss, int from, int count)
1168: {
1169: u_int8_t *cmap = ss->ss_cmap;
1170: int i, color12;
1171:
1172: gpx_wait(ss, FRAME_SYNC);
1173: if (ss->ss_depth == 8) {
1174: struct ramdac8 *rd = ss->ss_vdac;
1175:
1176: cmap += from * 3;
1177: rd->address = from;
1178: for (i = 0; i < count * 3; i++)
1179: rd->cmapdata = *cmap++;
1180: } else {
1181: struct ramdac4 *rd = ss->ss_vdac;
1182:
1183: cmap = ss->ss_cmap + from;
1184: for (i = from; i < from + count; i++) {
1185: color12 = (*cmap++ >> 4) << 0;
1186: color12 |= (*cmap++ >> 4) << 8;
1187: color12 |= (*cmap++ >> 4) << 4;
1188: rd->colormap[i] = color12;
1189: }
1190: }
1191: }
1192:
1193: void
1194: gpx_resetcmap(struct gpx_screen *ss)
1195: {
1196: if (ss->ss_depth == 8)
1197: bcopy(rasops_cmap, ss->ss_cmap, sizeof(ss->ss_cmap));
1198: else {
1199: bcopy(rasops_cmap, ss->ss_cmap, 8 * 3);
1200: bcopy(rasops_cmap + 0xf8 * 3, ss->ss_cmap + 8 * 3, 8 * 3);
1201: }
1202: gpx_loadcmap(ss, 0, 1 << ss->ss_depth);
1203:
1204: /*
1205: * On the 4bit RAMDAC, make the hardware cursor black on black
1206: */
1207: if (ss->ss_depth != 8) {
1208: struct ramdac4 *rd = ss->ss_vdac;
1209:
1210: rd->cursormap[0] = rd->cursormap[1] =
1211: rd->cursormap[2] = rd->cursormap[3] = 0x0000;
1212: }
1213: }
1214:
1215: /*
1216: * Console support code
1217: */
1218:
1219: int gpxcnprobe(void);
1220: void gpxcninit(void);
1221:
1222: int
1223: gpxcnprobe()
1224: {
1225: extern vaddr_t virtual_avail;
1226: vaddr_t tmp;
1227: int depth;
1228:
1229: switch (vax_boardtype) {
1230: case VAX_BTYP_410:
1231: case VAX_BTYP_420:
1232: case VAX_BTYP_43:
1233: if ((vax_confdata & (KA420_CFG_L3CON | KA420_CFG_MULTU)) != 0)
1234: break; /* doesn't use graphics console */
1235:
1236: if ((vax_confdata & KA420_CFG_VIDOPT) == 0)
1237: break; /* no color option */
1238:
1239: /* Check for a recognized color depth */
1240: tmp = virtual_avail;
1241: ioaccess(tmp, vax_trunc_page(GPXADDR + GPX_READBACK_OFFSET), 1);
1242: depth = *(u_int16_t *)
1243: (tmp + (GPX_READBACK_OFFSET & VAX_PGOFSET)) & 0x00f0;
1244: if (depth == 0x00f0 || depth == 0x0080)
1245: return (1);
1246:
1247: break;
1248:
1249: default:
1250: break;
1251: }
1252:
1253: return (0);
1254: }
1255:
1256: /*
1257: * Called very early to setup the glass tty as console.
1258: * Because it's called before the VM system is initialized, virtual memory
1259: * for the framebuffer can be stolen directly without disturbing anything.
1260: */
1261: void
1262: gpxcninit()
1263: {
1264: struct gpx_screen *ss = &gpx_consscr;
1265: extern vaddr_t virtual_avail;
1266: vaddr_t tmp;
1267: long defattr;
1268: struct rasops_info *ri;
1269:
1270: tmp = virtual_avail;
1271: ioaccess(tmp, vax_trunc_page(GPXADDR + GPX_READBACK_OFFSET), 1);
1272: ss->ss_depth = (0x00f0 & *(u_int16_t *)
1273: (tmp + (GPX_READBACK_OFFSET & VAX_PGOFSET))) == 0x00f0 ? 4 : 8;
1274:
1275: ioaccess(virtual_avail, GPXADDR + GPX_ADDER_OFFSET, 1);
1276: ss->ss_adder = (struct adder *)virtual_avail;
1277: virtual_avail += VAX_NBPG;
1278:
1279: ioaccess(virtual_avail, vax_trunc_page(GPXADDR + GPX_VDAC_OFFSET), 1);
1280: ss->ss_vdac = (void *)(virtual_avail + (GPX_VDAC_OFFSET & VAX_PGOFSET));
1281: virtual_avail += VAX_NBPG;
1282:
1283: #if 0
1284: ioaccess(virtual_avail, GPXADDR + GPX_CURSOR_OFFSET, 1);
1285: ss->ss_cursor = (struct dc503reg *)virtual_avail;
1286: virtual_avail += VAX_NBPG;
1287: #endif
1288:
1289: virtual_avail = round_page(virtual_avail);
1290:
1291: /* this had better not fail as we can't recover there */
1292: if (gpx_setup_screen(ss) != 0)
1293: panic(__func__);
1294:
1295: ri = &ss->ss_ri;
1296: ri->ri_ops.alloc_attr(ri, 0, 0, 0, &defattr);
1297: wsdisplay_cnattach(&gpx_stdscreen, ri, 0, 0, defattr);
1298: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to gpx.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / vax / vsa