Annotation of sys/arch/vax/vsa/lcg.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: lcg.c,v 1.10 2006/11/29 12:13:54 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) 2003, 2004 Blaz Antonic
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. All advertising materials mentioning features or use of this software
31: * must display the abovementioned copyrights
32: * 4. The name of the author may not be used to endorse or promote products
33: * derived from this software without specific prior written permission
34: *
35: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
36: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
37: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
38: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
39: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
40: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
41: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
42: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
43: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
44: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
45: */
46:
47: #include <sys/param.h>
48: #include <sys/device.h>
49: #include <sys/systm.h>
50: #include <sys/malloc.h>
51: #include <sys/conf.h>
52: #include <sys/kernel.h>
53:
54: #include <machine/vsbus.h>
55: #include <machine/scb.h>
56: #include <machine/sid.h>
57: #include <machine/cpu.h>
58:
59: #include <uvm/uvm_extern.h>
60:
61: #include <dev/cons.h>
62:
63: #include <dev/wscons/wsconsio.h>
64: #include <dev/wscons/wsdisplayvar.h>
65: #include <dev/rasops/rasops.h>
66:
67: #include <vax/vsa/lcgreg.h>
68:
69: #define LCG_CONFIG_ADDR 0x200f0010 /* configuration register */
70: #define LCG_REG_ADDR 0x20100000 /* registers */
71: #define LCG_REG_SIZE 0x4000
72: #define LCG_LUT_ADDR 0x21800000 /* colormap */
73: #define LCG_LUT_OFFSET 0x0800
74: #define LCG_LUT_SIZE 0x0800
75: #define LCG_FB_ADDR 0x21801000 /* frame buffer */
76:
77: int lcg_match(struct device *, void *, void *);
78: void lcg_attach(struct device *, struct device *, void *);
79:
80: struct lcg_screen {
81: struct rasops_info ss_ri;
82: u_int32_t ss_cfg;
83: u_int ss_width, ss_height, ss_depth;
84: u_int ss_fbsize; /* visible part only */
85: caddr_t ss_addr; /* frame buffer address */
86: vaddr_t ss_reg;
87: volatile u_int8_t *ss_lut;
88: u_int8_t ss_cmap[256 * 3];
89: };
90:
91: /* for console */
92: struct lcg_screen lcg_consscr;
93:
94: struct lcg_softc {
95: struct device sc_dev;
96: struct lcg_screen *sc_scr;
97: int sc_nscreens;
98: };
99:
100: struct cfattach lcg_ca = {
101: sizeof(struct lcg_softc), lcg_match, lcg_attach,
102: };
103:
104: struct cfdriver lcg_cd = {
105: NULL, "lcg", DV_DULL
106: };
107:
108: struct wsscreen_descr lcg_stdscreen = {
109: "std",
110: };
111:
112: const struct wsscreen_descr *_lcg_scrlist[] = {
113: &lcg_stdscreen,
114: };
115:
116: const struct wsscreen_list lcg_screenlist = {
117: sizeof(_lcg_scrlist) / sizeof(struct wsscreen_descr *),
118: _lcg_scrlist,
119: };
120:
121: int lcg_ioctl(void *, u_long, caddr_t, int, struct proc *);
122: paddr_t lcg_mmap(void *, off_t, int);
123: int lcg_alloc_screen(void *, const struct wsscreen_descr *,
124: void **, int *, int *, long *);
125: void lcg_free_screen(void *, void *);
126: int lcg_show_screen(void *, void *, int,
127: void (*) (void *, int, int), void *);
128: void lcg_burner(void *, u_int, u_int);
129:
130: const struct wsdisplay_accessops lcg_accessops = {
131: lcg_ioctl,
132: lcg_mmap,
133: lcg_alloc_screen,
134: lcg_free_screen,
135: lcg_show_screen,
136: NULL, /* load_font */
137: NULL, /* scrollback */
138: NULL, /* getchar */
139: lcg_burner
140: };
141:
142: int lcg_alloc_attr(void *, int, int, int, long *);
143: int lcg_getcmap(struct lcg_screen *, struct wsdisplay_cmap *);
144: void lcg_loadcmap(struct lcg_screen *, int, int);
145: int lcg_probe_screen(u_int32_t, u_int *, u_int *);
146: int lcg_putcmap(struct lcg_screen *, struct wsdisplay_cmap *);
147: void lcg_resetcmap(struct lcg_screen *);
148: int lcg_setup_screen(struct lcg_screen *);
149:
150: #define lcg_read_reg(ss, regno) \
151: *(volatile u_int32_t *)((ss)->ss_reg + (regno))
152: #define lcg_write_reg(ss, regno, val) \
153: *(volatile u_int32_t *)((ss)->ss_reg + (regno)) = (val)
154:
155: int
156: lcg_match(struct device *parent, void *vcf, void *aux)
157: {
158: struct vsbus_softc *sc = (void *)parent;
159: struct vsbus_attach_args *va = aux;
160: vaddr_t cfgreg;
161: int depth, missing;
162: volatile u_int8_t *ch;
163:
164: switch (vax_boardtype) {
165: default:
166: return (0);
167:
168: case VAX_BTYP_46:
169: case VAX_BTYP_48:
170: if (va->va_paddr != LCG_REG_ADDR)
171: return (0);
172:
173: break;
174: }
175:
176: /*
177: * Check the configuration register.
178: * This is done to sort out empty frame buffer slots, since the video
179: * memory test sometimes passes!
180: */
181: cfgreg = vax_map_physmem(LCG_CONFIG_ADDR, 1);
182: depth = lcg_probe_screen(*(volatile u_int32_t *)cfgreg, NULL, NULL);
183: vax_unmap_physmem(cfgreg, 1);
184: if (depth < 0) /* no frame buffer */
185: return (0);
186:
187: /*
188: * Check for video memory.
189: * We can not use badaddr() on these models.
190: */
191: missing = 0;
192: ch = (volatile u_int8_t *)vax_map_physmem(LCG_FB_ADDR, 1);
193: *ch = 0x01;
194: if ((*ch & 0x01) == 0)
195: missing = 1;
196: else {
197: *ch = 0x00;
198: if ((*ch & 0x01) != 0)
199: missing = 1;
200: }
201: vax_unmap_physmem((vaddr_t)ch, 1);
202: if (missing != 0)
203: return (0);
204:
205: sc->sc_mask = 0x04; /* XXX - should be generated */
206: scb_fake(0x120, 0x15);
207: return (20);
208: }
209:
210: void
211: lcg_attach(struct device *parent, struct device *self, void *aux)
212: {
213: struct lcg_softc *sc = (struct lcg_softc *)self;
214: struct lcg_screen *ss;
215: struct wsemuldisplaydev_attach_args aa;
216: vaddr_t tmp;
217: u_int32_t cfg;
218: int console;
219: extern struct consdev wsdisplay_cons;
220:
221: console = (vax_confdata & 0x100) == 0 && cn_tab == &wsdisplay_cons;
222:
223: /*
224: * Check for a recognized configuration register.
225: * If we do not recognize it, print it and do not attach - so that
226: * this gets noticed...
227: */
228: if (!console) {
229: tmp = vax_map_physmem(LCG_CONFIG_ADDR, 1);
230: if (tmp == NULL) {
231: printf("\n%s: can not map configuration register\n",
232: self->dv_xname);
233: return;
234: }
235: cfg = *(volatile u_int32_t *)tmp;
236: vax_unmap_physmem(tmp, 1);
237:
238: if (lcg_probe_screen(cfg, NULL, NULL) <= 0) {
239: printf("\n%s:"
240: " unrecognized configuration register %08x\n",
241: self->dv_xname, cfg);
242: return;
243: }
244: }
245:
246: if (console) {
247: ss = &lcg_consscr;
248: sc->sc_nscreens = 1;
249: } else {
250: ss = malloc(sizeof(struct lcg_screen), M_DEVBUF, M_NOWAIT);
251: if (ss == NULL) {
252: printf(": can not allocate memory\n");
253: return;
254: }
255: bzero(ss, sizeof(struct lcg_screen));
256:
257: ss->ss_cfg = cfg;
258: ss->ss_depth = lcg_probe_screen(ss->ss_cfg,
259: &ss->ss_width, &ss->ss_height);
260: ss->ss_fbsize =
261: roundup(ss->ss_width * ss->ss_height, PAGE_SIZE);
262:
263: ss->ss_addr = (caddr_t)vax_map_physmem(LCG_FB_ADDR,
264: ss->ss_fbsize / VAX_NBPG);
265: if (ss->ss_addr == NULL) {
266: printf(": can not map frame buffer\n");
267: goto fail1;
268: }
269:
270: ss->ss_reg = vax_map_physmem(LCG_REG_ADDR,
271: LCG_REG_SIZE / VAX_NBPG);
272: if (ss->ss_reg == 0L) {
273: printf(": can not map registers\n");
274: goto fail2;
275: }
276:
277: ss->ss_lut = (volatile u_int8_t *)vax_map_physmem(LCG_LUT_ADDR +
278: LCG_LUT_OFFSET, LCG_LUT_SIZE / VAX_NBPG);
279: if (ss->ss_lut == NULL) {
280: printf(": can not map color LUT\n");
281: goto fail3;
282: }
283:
284: if (lcg_setup_screen(ss) != 0) {
285: printf(": initialization failed\n");
286: goto fail4;
287: }
288: }
289: sc->sc_scr = ss;
290:
291: printf(": %dx%dx%d frame buffer\n",
292: ss->ss_width, ss->ss_height, ss->ss_depth);
293:
294: aa.console = console;
295: aa.scrdata = &lcg_screenlist;
296: aa.accessops = &lcg_accessops;
297: aa.accesscookie = sc;
298: aa.defaultscreens = 0;
299:
300: config_found(self, &aa, wsemuldisplaydevprint);
301: return;
302:
303: fail4:
304: vax_unmap_physmem((vaddr_t)ss->ss_lut, LCG_LUT_SIZE / VAX_NBPG);
305: fail3:
306: vax_unmap_physmem(ss->ss_reg, LCG_REG_SIZE / VAX_NBPG);
307: fail2:
308: vax_unmap_physmem((vaddr_t)ss->ss_addr, ss->ss_fbsize / VAX_NBPG);
309: fail1:
310: free(ss, M_DEVBUF);
311: }
312:
313: /*
314: * Determine if we have a recognized frame buffer, its resolution and
315: * color depth.
316: */
317: int
318: lcg_probe_screen(u_int32_t cfg, u_int *width, u_int *height)
319: {
320: u_int w, h, d = 8;
321:
322: switch (vax_boardtype) {
323: case VAX_BTYP_46:
324: switch (cfg & 0xf0) {
325: case 0x00:
326: return (-1); /* no hardware */
327: case 0x20:
328: case 0x60:
329: w = 1024; h = 864;
330: break;
331: case 0x40:
332: w = 1024; h = 768;
333: break;
334: case 0x80:
335: d = 4;
336: /* FALLTHROUGH */
337: case 0x90:
338: case 0xb0:
339: w = 1280; h = 1024;
340: break;
341: default:
342: return (0); /* unknown configuration, please help */
343: }
344: break;
345: case VAX_BTYP_48:
346: switch (cfg & 0x07) {
347: case 0x00:
348: return (-1); /* no hardware */
349: case 0x05:
350: w = 1280; h = 1024;
351: break;
352: case 0x06:
353: if (vax_confdata & 0x80) {
354: w = 1024; h = 768;
355: } else {
356: w = 640; h = 480;
357: }
358: break;
359: case 0x07:
360: if (vax_confdata & 0x80) {
361: w = 1024; h = 864;
362: } else {
363: w = 1024; h = 768;
364: }
365: break;
366: default:
367: return (0); /* unknown configuration, please help */
368: }
369: break;
370: }
371:
372: if (width != NULL)
373: *width = w;
374: if (height != NULL)
375: *height = h;
376:
377: return (d);
378: }
379:
380: /*
381: * Initialize anything necessary for an emulating wsdisplay to work (i.e.
382: * pick a font, initialize a rasops structure, setup the accessops callbacks.)
383: */
384: int
385: lcg_setup_screen(struct lcg_screen *ss)
386: {
387: struct rasops_info *ri = &ss->ss_ri;
388:
389: bzero(ri, sizeof(*ri));
390: /*
391: * Since the frame buffer memory is byte addressed, even in low-bpp
392: * mode, initialize a 8bpp rasops engine. We will report a shorter
393: * colormap if necessary, which will allow X to do TRT.
394: */
395: ri->ri_depth = 8;
396: ri->ri_width = ss->ss_width;
397: ri->ri_height = ss->ss_height;
398: ri->ri_stride = ss->ss_width;
399: ri->ri_flg = RI_CLEAR | RI_CENTER;
400: ri->ri_bits = (void *)ss->ss_addr;
401: ri->ri_hw = ss;
402:
403: /*
404: * Ask for an unholy big display, rasops will trim this to more
405: * reasonable values.
406: */
407: if (rasops_init(ri, 160, 160) != 0)
408: return (-1);
409:
410: if (ss->ss_depth < 8) {
411: ri->ri_ops.alloc_attr = lcg_alloc_attr;
412: ri->ri_caps &= ~WSSCREEN_HILIT;
413: }
414:
415: lcg_stdscreen.ncols = ri->ri_cols;
416: lcg_stdscreen.nrows = ri->ri_rows;
417: lcg_stdscreen.textops = &ri->ri_ops;
418: lcg_stdscreen.fontwidth = ri->ri_font->fontwidth;
419: lcg_stdscreen.fontheight = ri->ri_font->fontheight;
420: lcg_stdscreen.capabilities = ri->ri_caps;
421:
422: lcg_resetcmap(ss);
423:
424: return (0);
425: }
426:
427: int
428: lcg_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
429: {
430: struct lcg_softc *sc = v;
431: struct lcg_screen *ss = sc->sc_scr;
432: struct wsdisplay_fbinfo *wdf;
433: struct wsdisplay_cmap *cm;
434: int error;
435:
436: switch (cmd) {
437: case WSDISPLAYIO_GTYPE:
438: *(u_int *)data = WSDISPLAY_TYPE_LCG;
439: break;
440:
441: case WSDISPLAYIO_GINFO:
442: wdf = (struct wsdisplay_fbinfo *)data;
443: wdf->height = ss->ss_height;
444: wdf->width = ss->ss_width;
445: wdf->depth = 8;
446: wdf->cmsize = 1 << ss->ss_depth;
447: break;
448:
449: case WSDISPLAYIO_LINEBYTES:
450: *(u_int *)data = ss->ss_ri.ri_stride;
451: break;
452:
453: case WSDISPLAYIO_GETCMAP:
454: cm = (struct wsdisplay_cmap *)data;
455: error = lcg_getcmap(ss, cm);
456: if (error != 0)
457: return (error);
458: break;
459: case WSDISPLAYIO_PUTCMAP:
460: cm = (struct wsdisplay_cmap *)data;
461: error = lcg_putcmap(ss, cm);
462: if (error != 0)
463: return (error);
464: lcg_loadcmap(ss, cm->index, cm->count);
465: break;
466:
467: case WSDISPLAYIO_GVIDEO:
468: case WSDISPLAYIO_SVIDEO:
469: break;
470:
471: default:
472: return (-1);
473: }
474:
475: return (0);
476: }
477:
478: paddr_t
479: lcg_mmap(void *v, off_t offset, int prot)
480: {
481: struct lcg_softc *sc = v;
482: struct lcg_screen *ss = sc->sc_scr;
483:
484: if (offset >= ss->ss_fbsize || offset < 0)
485: return (-1);
486:
487: return (LCG_FB_ADDR + offset) >> PGSHIFT;
488: }
489:
490: int
491: lcg_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep,
492: int *curxp, int *curyp, long *defattrp)
493: {
494: struct lcg_softc *sc = v;
495: struct lcg_screen *ss = sc->sc_scr;
496: struct rasops_info *ri = &ss->ss_ri;
497:
498: if (sc->sc_nscreens > 0)
499: return (ENOMEM);
500:
501: *cookiep = ri;
502: *curxp = *curyp = 0;
503: ri->ri_ops.alloc_attr(ri, 0, 0, 0, defattrp);
504: sc->sc_nscreens++;
505:
506: return (0);
507: }
508:
509: void
510: lcg_free_screen(void *v, void *cookie)
511: {
512: struct lcg_softc *sc = v;
513:
514: sc->sc_nscreens--;
515: }
516:
517: int
518: lcg_show_screen(void *v, void *cookie, int waitok,
519: void (*cb)(void *, int, int), void *cbarg)
520: {
521: return (0);
522: }
523:
524: void
525: lcg_burner(void *v, u_int on, u_int flags)
526: {
527: struct lcg_softc *sc = v;
528: struct lcg_screen *ss = sc->sc_scr;
529: u_int32_t vidcfg;
530:
531: vidcfg = lcg_read_reg(ss, LCG_REG_VIDEO_CONFIG);
532: if (on)
533: vidcfg |= VIDEO_ENABLE_VIDEO | VIDEO_SYNC_ENABLE;
534: else {
535: vidcfg &= ~VIDEO_ENABLE_VIDEO;
536: if (flags & WSDISPLAY_BURN_VBLANK)
537: vidcfg &= ~VIDEO_SYNC_ENABLE;
538: }
539: lcg_write_reg(ss, LCG_REG_VIDEO_CONFIG, vidcfg);
540: }
541:
542: /*
543: * Attribute allocator for 4bpp frame buffers.
544: * In such modes, highlighting is not available.
545: */
546: int
547: lcg_alloc_attr(void *cookie, int fg, int bg, int flg, long *attr)
548: {
549: extern int rasops_alloc_cattr(void *, int, int, int, long *);
550:
551: if ((flg & (WSATTR_BLINK | WSATTR_HILIT)) != 0)
552: return (EINVAL);
553:
554: return (rasops_alloc_cattr(cookie, fg, bg, flg, attr));
555: }
556:
557: /*
558: * Colormap handling routines
559: */
560:
561: int
562: lcg_getcmap(struct lcg_screen *ss, struct wsdisplay_cmap *cm)
563: {
564: u_int index = cm->index, count = cm->count, i;
565: u_int colcount = 1 << ss->ss_depth;
566: int error;
567: u_int8_t ramp[256], *c, *r;
568:
569: if (index >= colcount || count > colcount - index)
570: return (EINVAL);
571:
572: /* extract reds */
573: c = ss->ss_cmap + 0 + index * 3;
574: for (i = count, r = ramp; i != 0; i--)
575: *r++ = *c, c += 3;
576: if ((error = copyout(ramp, cm->red, count)) != 0)
577: return (error);
578:
579: /* extract greens */
580: c = ss->ss_cmap + 1 + index * 3;
581: for (i = count, r = ramp; i != 0; i--)
582: *r++ = *c, c += 3;
583: if ((error = copyout(ramp, cm->green, count)) != 0)
584: return (error);
585:
586: /* extract blues */
587: c = ss->ss_cmap + 2 + index * 3;
588: for (i = count, r = ramp; i != 0; i--)
589: *r++ = *c, c += 3;
590: if ((error = copyout(ramp, cm->blue, count)) != 0)
591: return (error);
592:
593: return (0);
594: }
595:
596: int
597: lcg_putcmap(struct lcg_screen *ss, struct wsdisplay_cmap *cm)
598: {
599: u_int index = cm->index, count = cm->count;
600: u_int colcount = 1 << ss->ss_depth;
601: int i, error;
602: u_int8_t r[256], g[256], b[256], *nr, *ng, *nb, *c;
603:
604: if (index >= colcount || count > colcount - index)
605: return (EINVAL);
606:
607: if ((error = copyin(cm->red, r, count)) != 0)
608: return (error);
609: if ((error = copyin(cm->green, g, count)) != 0)
610: return (error);
611: if ((error = copyin(cm->blue, b, count)) != 0)
612: return (error);
613:
614: nr = r, ng = g, nb = b;
615: c = ss->ss_cmap + index * 3;
616: for (i = count; i != 0; i--) {
617: *c++ = *nr++;
618: *c++ = *ng++;
619: *c++ = *nb++;
620: }
621:
622: return (0);
623: }
624:
625: /* Fill the given colormap (LUT) entry. */
626: #define lcg_set_lut_entry(lutptr, cmap, idx, shift) \
627: do { \
628: *(lutptr)++ = LUT_ADRS_REG; \
629: *(lutptr)++ = (idx); \
630: *(lutptr)++ = LUT_COLOR_AUTOINC; \
631: *(lutptr)++ = (*(cmap)++) >> (shift); \
632: *(lutptr)++ = LUT_COLOR_AUTOINC; \
633: *(lutptr)++ = (*(cmap)++) >> (shift); \
634: *(lutptr)++ = LUT_COLOR_AUTOINC; \
635: *(lutptr)++ = (*(cmap)++) >> (shift); \
636: } while (0)
637:
638: void
639: lcg_loadcmap(struct lcg_screen *ss, int from, int count)
640: {
641: const u_int8_t *cmap;
642: u_int i;
643: volatile u_int8_t *lutptr;
644: u_int32_t vidcfg;
645:
646: /* partial updates ignored for now */
647: cmap = ss->ss_cmap;
648: lutptr = ss->ss_lut;
649: if (ss->ss_depth == 8) {
650: for (i = 0; i < 256; i++) {
651: lcg_set_lut_entry(lutptr, cmap, i, 0);
652: }
653: } else {
654: for (i = 0; i < 16; i++) {
655: lcg_set_lut_entry(lutptr, cmap, i, 4);
656: }
657: }
658:
659: /*
660: * Wait for retrace
661: */
662: while (((vidcfg = lcg_read_reg(ss, LCG_REG_VIDEO_CONFIG)) &
663: VIDEO_VSTATE) != VIDEO_VSYNC)
664: DELAY(1);
665:
666: vidcfg &= ~(VIDEO_SHIFT_SEL | VIDEO_MEM_REFRESH_SEL_MASK |
667: VIDEO_LUT_SHIFT_SEL);
668: /* Do full loads if width is 1024 or 2048, split loads otherwise. */
669: if (ss->ss_width == 1024 || ss->ss_width == 2048)
670: vidcfg |= VIDEO_SHIFT_SEL | (1 << VIDEO_MEM_REFRESH_SEL_SHIFT) |
671: VIDEO_LUT_SHIFT_SEL;
672: else
673: vidcfg |= (2 << VIDEO_MEM_REFRESH_SEL_SHIFT);
674: vidcfg |= VIDEO_LUT_LOAD_SIZE; /* 2KB lut */
675: lcg_write_reg(ss, LCG_REG_VIDEO_CONFIG, vidcfg);
676: lcg_write_reg(ss, LCG_REG_LUT_CONSOLE_SEL, LUT_SEL_COLOR);
677: lcg_write_reg(ss, LCG_REG_LUT_COLOR_BASE_W, LCG_LUT_OFFSET);
678: /* Wait for end of retrace */
679: while (((vidcfg = lcg_read_reg(ss, LCG_REG_VIDEO_CONFIG)) &
680: VIDEO_VSTATE) == VIDEO_VSYNC)
681: DELAY(1);
682: lcg_write_reg(ss, LCG_REG_LUT_CONSOLE_SEL, LUT_SEL_CONSOLE);
683: }
684:
685: void
686: lcg_resetcmap(struct lcg_screen *ss)
687: {
688: if (ss->ss_depth == 8)
689: bcopy(rasops_cmap, ss->ss_cmap, sizeof(ss->ss_cmap));
690: else {
691: bcopy(rasops_cmap, ss->ss_cmap, 8 * 3);
692: bcopy(rasops_cmap + 0xf8 * 3, ss->ss_cmap + 8 * 3, 8 * 3);
693: }
694: lcg_loadcmap(ss, 0, 1 << ss->ss_depth);
695: }
696:
697: /*
698: * Console support code
699: */
700:
701: int lcgcnprobe(void);
702: void lcgcninit(void);
703:
704: int
705: lcgcnprobe()
706: {
707: extern vaddr_t virtual_avail;
708: u_int32_t cfg;
709: vaddr_t tmp;
710: volatile u_int8_t *ch;
711:
712: switch (vax_boardtype) {
713: case VAX_BTYP_46:
714: case VAX_BTYP_48:
715: if ((vax_confdata & 0x100) != 0)
716: break; /* doesn't use graphics console */
717:
718: tmp = virtual_avail;
719: ioaccess(tmp, vax_trunc_page(LCG_CONFIG_ADDR), 1);
720: cfg = *(volatile u_int32_t *)
721: (tmp + (LCG_CONFIG_ADDR & VAX_PGOFSET));
722:
723: if (lcg_probe_screen(cfg, NULL, NULL) <= 0)
724: break; /* unsupported configuration */
725:
726: /*
727: * Check for video memory.
728: * We can not use badaddr() on these models.
729: */
730: ioaccess(tmp, LCG_FB_ADDR, 1);
731: ch = (volatile u_int8_t *)tmp;
732: *ch = 0x01;
733: if ((*ch & 0x01) == 0)
734: break;
735: *ch = 0x00;
736: if ((*ch & 0x01) != 0)
737: break;
738:
739: return (1);
740:
741: default:
742: break;
743: }
744:
745: return (0);
746: }
747:
748: /*
749: * Called very early to setup the glass tty as console.
750: * Because it's called before the VM system is initialized, virtual memory
751: * for the framebuffer can be stolen directly without disturbing anything.
752: */
753: void
754: lcgcninit()
755: {
756: struct lcg_screen *ss = &lcg_consscr;
757: extern vaddr_t virtual_avail;
758: vaddr_t tmp;
759: long defattr;
760: struct rasops_info *ri;
761:
762: tmp = virtual_avail;
763: ioaccess(tmp, vax_trunc_page(LCG_CONFIG_ADDR), 1);
764: ss->ss_cfg = *(volatile u_int32_t *)
765: (tmp + (LCG_CONFIG_ADDR & VAX_PGOFSET));
766:
767: ss->ss_depth = lcg_probe_screen(ss->ss_cfg,
768: &ss->ss_width, &ss->ss_height);
769:
770: ss->ss_fbsize = roundup(ss->ss_width * ss->ss_height, PAGE_SIZE);
771:
772: ss->ss_addr = (caddr_t)virtual_avail;
773: virtual_avail += ss->ss_fbsize;
774: ioaccess((vaddr_t)ss->ss_addr, LCG_FB_ADDR, ss->ss_fbsize / VAX_NBPG);
775:
776: ss->ss_reg = virtual_avail;
777: virtual_avail += LCG_REG_SIZE;
778: ioaccess(ss->ss_reg, LCG_REG_ADDR, LCG_REG_SIZE / VAX_NBPG);
779:
780: ss->ss_lut = (volatile u_int8_t *)virtual_avail;
781: virtual_avail += LCG_LUT_SIZE;
782: ioaccess((vaddr_t)ss->ss_lut, LCG_LUT_ADDR + LCG_LUT_OFFSET,
783: LCG_LUT_SIZE / VAX_NBPG);
784:
785: virtual_avail = round_page(virtual_avail);
786:
787: /* this had better not fail as we can't recover there */
788: if (lcg_setup_screen(ss) != 0)
789: panic(__func__);
790:
791: ri = &ss->ss_ri;
792: ri->ri_ops.alloc_attr(ri, 0, 0, 0, &defattr);
793: wsdisplay_cnattach(&lcg_stdscreen, ri, 0, 0, defattr);
794: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to lcg.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / vax / vsa