Annotation of sys/arch/sparc/dev/zx.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: zx.c,v 1.19 2007/03/13 19:40:48 miod Exp $ */
2: /* $NetBSD: zx.c,v 1.5 2002/10/02 16:52:46 thorpej Exp $ */
3:
4: /*
5: * Copyright (c) 2003, Miodrag Vallat.
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: *
17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
21: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
23: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
25: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
26: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27: * POSSIBILITY OF SUCH DAMAGE.
28: *
29: * Derived from NetBSD syssrc/sys/dev/sbus/zx.c under the following licence
30: * terms:
31: *
32: * Copyright (c) 2002 The NetBSD Foundation, Inc.
33: * All rights reserved.
34: *
35: * This code is derived from software contributed to The NetBSD Foundation
36: * by Andrew Doran.
37: *
38: * Redistribution and use in source and binary forms, with or without
39: * modification, are permitted provided that the following conditions
40: * are met:
41: * 1. Redistributions of source code must retain the above copyright
42: * notice, this list of conditions and the following disclaimer.
43: * 2. Redistributions in binary form must reproduce the above copyright
44: * notice, this list of conditions and the following disclaimer in the
45: * documentation and/or other materials provided with the distribution.
46: * 3. All advertising materials mentioning features or use of this software
47: * must display the following acknowledgement:
48: * This product includes software developed by the NetBSD
49: * Foundation, Inc. and its contributors.
50: * 4. Neither the name of The NetBSD Foundation nor the names of its
51: * contributors may be used to endorse or promote products derived
52: * from this software without specific prior written permission.
53: *
54: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
55: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
56: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
57: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
58: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
59: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
60: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
61: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
62: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
63: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
64: * POSSIBILITY OF SUCH DAMAGE.
65: */
66:
67: /*
68: * Driver for the Sun ZX display adapter. This would be called 'leo', but
69: * NetBSD/amiga already has a driver by that name. The XFree86 and Linux
70: * drivers were used as "living documentation" when writing this; thanks
71: * to the authors.
72: */
73:
74: #include <sys/param.h>
75: #include <sys/systm.h>
76: #include <sys/device.h>
77: #include <sys/ioctl.h>
78: #include <sys/malloc.h>
79: #include <sys/mman.h>
80: #include <sys/tty.h>
81: #include <sys/conf.h>
82:
83: #include <uvm/uvm_extern.h>
84:
85: #include <machine/autoconf.h>
86: #include <machine/cpu.h>
87: #include <machine/conf.h>
88:
89: #include <dev/wscons/wsconsio.h>
90: #include <dev/wscons/wsdisplayvar.h>
91: #include <dev/rasops/rasops.h>
92: #include <machine/fbvar.h>
93:
94: #include <dev/sbus/zxreg.h>
95: #include <sparc/dev/sbusvar.h>
96:
97: #include <dev/cons.h> /* for prom console hook */
98:
99: #define ZX_WID_SHARED_8 0
100: #define ZX_WID_SHARED_24 1
101: #define ZX_WID_DBL_8 2
102: #define ZX_WID_DBL_24 3
103:
104: /*
105: * Per-instance data.
106: */
107:
108: struct zx_cmap {
109: u_int8_t cm_red[256];
110: u_int8_t cm_green[256];
111: u_int8_t cm_blue[256];
112: };
113:
114: struct zx_softc {
115: struct sunfb sc_sunfb;
116: struct rom_reg sc_phys;
117:
118: struct zx_cmap sc_cmap; /* shadow color map for overlay plane */
119:
120: volatile struct zx_command *sc_zc;
121: volatile struct zx_cross *sc_zx;
122: volatile struct zx_draw *sc_zd_ss0;
123: volatile struct zx_draw_ss1 *sc_zd_ss1;
124: volatile struct zx_cursor *sc_zcu;
125:
126: int sc_mode;
127: };
128:
129: void zx_burner(void *, u_int, u_int);
130: int zx_ioctl(void *, u_long, caddr_t, int, struct proc *);
131: paddr_t zx_mmap(void *v, off_t offset, int prot);
132: void zx_prom(void *);
133: void zx_reset(struct zx_softc *, u_int);
134: void zx_setcolor(void *, u_int, u_int8_t, u_int8_t, u_int8_t);
135:
136: struct wsdisplay_accessops zx_accessops = {
137: zx_ioctl,
138: zx_mmap,
139: NULL, /* alloc_screen */
140: NULL, /* free_screen */
141: NULL, /* show_screen */
142: NULL, /* load_font */
143: NULL, /* scrollback */
144: NULL, /* getchar */
145: zx_burner,
146: NULL /* pollc */
147: };
148:
149: /* Force 32-bit writes. */
150: #define SETREG(r, v) (*((volatile u_int32_t *)&r) = (v))
151:
152: #define ZX_STD_ROP (ZX_ROP_NEW | ZX_ATTR_WE_ENABLE | \
153: ZX_ATTR_OE_ENABLE | ZX_ATTR_FORCE_WID)
154:
155: #define ZX_BWIDTH 13
156: #define ZX_WWIDTH 11 /* word width */
157:
158: #define ZX_COORDS(x, y) ((x) | ((y) << ZX_WWIDTH))
159:
160: void zx_attach(struct device *, struct device *, void *);
161: int zx_match(struct device *, void *, void *);
162:
163: void zx_copyrect(struct rasops_info *, int, int, int, int, int, int);
164: int zx_cross_loadwid(struct zx_softc *, u_int, u_int, u_int);
165: int zx_cross_wait(struct zx_softc *);
166: void zx_fillrect(struct rasops_info *, int, int, int, int, long, int);
167: int zx_intr(void *);
168: int zx_putcmap(struct zx_softc *);
169:
170: void zx_copycols(void *, int, int, int, int);
171: void zx_copyrows(void *, int, int, int);
172: void zx_do_cursor(struct rasops_info *);
173: void zx_erasecols(void *, int, int, int, long);
174: void zx_eraserows(void *, int, int, long);
175: void zx_putchar(void *, int, int, u_int, long);
176:
177: struct cfattach zx_ca = {
178: sizeof(struct zx_softc), zx_match, zx_attach
179: };
180:
181: struct cfdriver zx_cd = {
182: NULL, "zx", DV_DULL
183: };
184:
185: int
186: zx_match(struct device *parent, void *vcf, void *aux)
187: {
188: struct confargs *ca = aux;
189: struct romaux *ra = &ca->ca_ra;
190:
191: if (strcmp(ra->ra_name, "SUNW,leo") == 0)
192: return (1);
193:
194: return (0);
195: }
196:
197: void
198: zx_attach(struct device *parent, struct device *self, void *args)
199: {
200: struct zx_softc *sc = (struct zx_softc *)self;
201: struct confargs *ca = args;
202: struct rasops_info *ri;
203: int node, isconsole = 0;
204: const char *nam;
205:
206: ri = &sc->sc_sunfb.sf_ro;
207: node = ca->ca_ra.ra_node;
208:
209: /*
210: * Map the various parts of the card.
211: */
212: sc->sc_phys = ca->ca_ra.ra_reg[0];
213:
214: sc->sc_zc = (struct zx_command *)
215: mapiodev(ca->ca_ra.ra_reg, ZX_OFF_LC_SS0_USR,
216: sizeof(struct zx_command));
217: sc->sc_zd_ss0 = (struct zx_draw *)
218: mapiodev(ca->ca_ra.ra_reg, ZX_OFF_LD_SS0,
219: sizeof(struct zx_draw));
220: sc->sc_zd_ss1 = (struct zx_draw_ss1 *)
221: mapiodev(ca->ca_ra.ra_reg, ZX_OFF_LD_SS1,
222: sizeof(struct zx_draw_ss1));
223: sc->sc_zx = (struct zx_cross *)
224: mapiodev(ca->ca_ra.ra_reg, ZX_OFF_LX_CROSS,
225: sizeof(struct zx_cross));
226: sc->sc_zcu = (struct zx_cursor *)
227: mapiodev(ca->ca_ra.ra_reg, ZX_OFF_LX_CURSOR,
228: sizeof(struct zx_cursor));
229:
230: nam = getpropstring(node, "model");
231: if (*nam == '\0')
232: nam = ca->ca_ra.ra_name;
233: printf(": %s", nam);
234:
235: isconsole = node == fbnode;
236:
237: /*
238: * The console is using the 8-bit overlay plane, while the prom
239: * will correctly report 32 bit depth.
240: * The following is an equivalent for
241: * fb_setsize(&sc->sc_sunfb, 8, 1152, 900, node, ca->ca_bustype);
242: * forcing the depth value not to be overwritten.
243: * Furthermore, the linebytes value is in fact 8192 bytes.
244: */
245: sc->sc_sunfb.sf_depth = 8;
246: sc->sc_sunfb.sf_width = getpropint(node, "width", 1152);
247: sc->sc_sunfb.sf_height = getpropint(node, "height", 900);
248: sc->sc_sunfb.sf_linebytes = 1 << ZX_BWIDTH;
249: sc->sc_sunfb.sf_fbsize = sc->sc_sunfb.sf_height << ZX_BWIDTH;
250:
251: printf(", %dx%d\n", sc->sc_sunfb.sf_width, sc->sc_sunfb.sf_height);
252:
253: ri->ri_bits = mapiodev(ca->ca_ra.ra_reg,
254: ZX_OFF_SS0, round_page(sc->sc_sunfb.sf_fbsize));
255: ri->ri_hw = sc;
256:
257: fbwscons_init(&sc->sc_sunfb, isconsole ? 0 : RI_CLEAR);
258:
259: /*
260: * Watch out! rasops_init() invoked via fbwscons_init() did not
261: * compute ri_bits correctly when centering the display, because
262: * it has been tricked with the low depth value.
263: * Recompute now.
264: */
265: ri->ri_emustride = ri->ri_emuwidth * 4;
266: ri->ri_delta = ri->ri_stride - ri->ri_emustride;
267: ri->ri_pelbytes = 4;
268: ri->ri_xscale = ri->ri_font->fontwidth * 4;
269: ri->ri_bits = ri->ri_origbits;
270: ri->ri_bits += (((ri->ri_width * 4) - ri->ri_emustride) >> 1) & ~3;
271: ri->ri_bits += ((ri->ri_height - ri->ri_emuheight) >> 1) *
272: ri->ri_stride;
273: ri->ri_yorigin = (int)(ri->ri_bits - ri->ri_origbits)
274: / ri->ri_stride;
275: ri->ri_xorigin = (((int)(ri->ri_bits - ri->ri_origbits)
276: % ri->ri_stride) / 4);
277:
278: ri->ri_ops.copyrows = zx_copyrows;
279: ri->ri_ops.copycols = zx_copycols;
280: ri->ri_ops.eraserows = zx_eraserows;
281: ri->ri_ops.erasecols = zx_erasecols;
282: ri->ri_ops.putchar = zx_putchar;
283: ri->ri_do_cursor = zx_do_cursor;
284:
285: if (isconsole) {
286: /* zx_reset() below will clear screen, so restart at 1st row */
287: fbwscons_console_init(&sc->sc_sunfb, 0);
288: shutdownhook_establish(zx_prom, sc);
289: }
290:
291: /* reset cursor & frame buffer controls */
292: sc->sc_mode = ~WSDISPLAYIO_MODE_EMUL; /* force action */
293: zx_reset(sc, WSDISPLAYIO_MODE_EMUL);
294:
295: /* enable video */
296: zx_burner(sc, 1, 0);
297:
298: fbwscons_attach(&sc->sc_sunfb, &zx_accessops, isconsole);
299: }
300:
301: int
302: zx_ioctl(void *dev, u_long cmd, caddr_t data, int flags, struct proc *p)
303: {
304: struct zx_softc *sc = dev;
305: struct wsdisplay_fbinfo *wdf;
306:
307: /*
308: * Note that, although the emulation (text) mode is running in
309: * a 8-bit plane, we advertize the frame buffer as the full-blown
310: * 32-bit beast it is.
311: */
312: switch (cmd) {
313: case WSDISPLAYIO_GTYPE:
314: *(u_int *)data = WSDISPLAY_TYPE_SUN24;
315: break;
316: case WSDISPLAYIO_GINFO:
317: wdf = (struct wsdisplay_fbinfo *)data;
318: wdf->height = sc->sc_sunfb.sf_height;
319: wdf->width = sc->sc_sunfb.sf_width;
320: wdf->depth = 32;
321: wdf->cmsize = 0;
322: break;
323: case WSDISPLAYIO_GETSUPPORTEDDEPTH:
324: *(u_int *)data = WSDISPLAYIO_DEPTH_24_32;
325: break;
326: case WSDISPLAYIO_LINEBYTES:
327: *(u_int *)data = sc->sc_sunfb.sf_linebytes;
328: break;
329:
330: case WSDISPLAYIO_GETCMAP:
331: case WSDISPLAYIO_PUTCMAP:
332: break;
333:
334: case WSDISPLAYIO_SMODE:
335: zx_reset(sc, *(u_int *)data);
336: break;
337:
338: case WSDISPLAYIO_SVIDEO:
339: case WSDISPLAYIO_GVIDEO:
340: break;
341:
342: default:
343: return (-1);
344: }
345:
346: return (0);
347: }
348:
349: /*
350: * Return the address that would map the given device at the given
351: * offset, allowing for the given protection, or return -1 for error.
352: */
353: paddr_t
354: zx_mmap(void *v, off_t offset, int prot)
355: {
356: struct zx_softc *sc = v;
357:
358: if (offset & PGOFSET)
359: return (-1);
360:
361: /* Allow mapping as a dumb framebuffer from offset 0 */
362: if (offset >= 0 && offset < sc->sc_sunfb.sf_fbsize) {
363: return (REG2PHYS(&sc->sc_phys, ZX_OFF_SS0 + offset) | PMAP_NC);
364: }
365:
366: return (-1);
367: }
368:
369: void
370: zx_setcolor(void *v, u_int index, u_int8_t r, u_int8_t g, u_int8_t b)
371: {
372: struct zx_softc *sc = v;
373:
374: sc->sc_cmap.cm_red[index] = r;
375: sc->sc_cmap.cm_green[index] = g;
376: sc->sc_cmap.cm_blue[index] = b;
377: }
378:
379: void
380: zx_reset(struct zx_softc *sc, u_int mode)
381: {
382: volatile struct zx_draw *zd;
383: volatile struct zx_command *zc;
384: u_int32_t i;
385: const u_char *color;
386: u_int8_t *r, *g, *b;
387:
388: if (mode == sc->sc_mode)
389: return;
390:
391: zd = sc->sc_zd_ss0;
392: zc = sc->sc_zc;
393:
394: if (mode == WSDISPLAYIO_MODE_EMUL) {
395: /* Back from X11 to emulation mode, or first reset */
396: zx_cross_loadwid(sc, ZX_WID_DBL_8, 0, 0x2c0);
397: zx_cross_loadwid(sc, ZX_WID_DBL_8, 1, 0x30);
398: zx_cross_loadwid(sc, ZX_WID_DBL_8, 2, 0x20);
399: zx_cross_loadwid(sc, ZX_WID_DBL_24, 1, 0x30);
400:
401: i = sc->sc_zd_ss1->zd_misc;
402: i |= ZX_SS1_MISC_ENABLE;
403: SETREG(sc->sc_zd_ss1->zd_misc, i);
404:
405: /*
406: * XXX
407: * If zc_fill is not set to that value, there will be black
408: * bars left in the margins. But then with this value, the
409: * screen gets cleared. Go figure.
410: */
411: SETREG(zd->zd_wid, 0xffffffff);
412: SETREG(zd->zd_wmask, 0xffff);
413: SETREG(zd->zd_vclipmin, 0);
414: SETREG(zd->zd_vclipmax, (sc->sc_sunfb.sf_width - 1) |
415: ((sc->sc_sunfb.sf_height - 1) << 16));
416: SETREG(zd->zd_fg, 0);
417: SETREG(zd->zd_planemask, 0xff000000);
418: SETREG(zd->zd_rop, ZX_STD_ROP);
419: SETREG(zd->zd_widclip, 0);
420:
421: SETREG(zc->zc_extent, ZX_COORDS(sc->sc_sunfb.sf_width - 1,
422: sc->sc_sunfb.sf_height - 1));
423: SETREG(zc->zc_addrspace, ZX_ADDRSPC_FONT_OBGR);
424: SETREG(zc->zc_fill, ZX_COORDS(0, 0) | ZX_EXTENT_DIR_BACKWARDS);
425: SETREG(zc->zc_fontt, 0);
426:
427: while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
428: ;
429:
430: /*
431: * Initialize the 8-bit colormap
432: */
433: r = sc->sc_cmap.cm_red;
434: g = sc->sc_cmap.cm_green;
435: b = sc->sc_cmap.cm_blue;
436: color = rasops_cmap;
437: for (i = 0; i < 256; i++) {
438: *r++ = *color++;
439: *g++ = *color++;
440: *b++ = *color++;
441: }
442: fbwscons_setcolormap(&sc->sc_sunfb, zx_setcolor);
443: zx_putcmap(sc);
444: } else {
445: /* Starting X11 - switch to 24bit WID */
446: SETREG(zd->zd_wid, 1);
447: SETREG(zd->zd_widclip, 0);
448: SETREG(zd->zd_wmask, 0xffff);
449: SETREG(zd->zd_planemask, 0x00ffffff);
450: SETREG(zc->zc_extent, ZX_COORDS(sc->sc_sunfb.sf_width - 1,
451: sc->sc_sunfb.sf_height - 1));
452: SETREG(zc->zc_fill, 0);
453: while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
454: ;
455:
456: SETREG(zc->zc_addrspace, ZX_ADDRSPC_OBGR);
457: SETREG(zd->zd_rop, ZX_ATTR_RGBE_ENABLE |
458: ZX_ROP_NEW /* | ZX_ATTR_FORCE_WID */);
459: }
460:
461: sc->sc_mode = mode;
462: }
463:
464: int
465: zx_cross_wait(struct zx_softc *sc)
466: {
467: volatile struct zx_cross *zx;
468: int i;
469:
470: zx = sc->sc_zx;
471:
472: for (i = 300000; i != 0; i--) {
473: if ((zx->zx_csr & ZX_CROSS_CSR_PROGRESS) == 0)
474: break;
475: DELAY(1);
476: }
477:
478: if (i == 0)
479: printf("%s: zx_cross_wait: timed out\n",
480: sc->sc_sunfb.sf_dev.dv_xname);
481:
482: return (i);
483: }
484:
485: int
486: zx_cross_loadwid(struct zx_softc *sc, u_int type, u_int index, u_int value)
487: {
488: volatile struct zx_cross *zx;
489: u_int tmp;
490:
491: zx = sc->sc_zx;
492: SETREG(zx->zx_type, ZX_CROSS_TYPE_WID);
493:
494: if (!zx_cross_wait(sc))
495: return (1);
496:
497: if (type == ZX_WID_DBL_8)
498: tmp = (index & 0x0f) + 0x40;
499: else if (type == ZX_WID_DBL_24)
500: tmp = index & 0x3f;
501:
502: SETREG(zx->zx_type, 0x5800 + tmp);
503: SETREG(zx->zx_value, value);
504: SETREG(zx->zx_type, ZX_CROSS_TYPE_WID);
505: SETREG(zx->zx_csr, ZX_CROSS_CSR_UNK | ZX_CROSS_CSR_UNK2);
506:
507: return (0);
508: }
509:
510: int
511: zx_putcmap(struct zx_softc *sc)
512: {
513: volatile struct zx_cross *zx;
514: u_int32_t i;
515: u_int8_t *r, *g, *b;
516:
517: zx = sc->sc_zx;
518:
519: SETREG(zx->zx_type, ZX_CROSS_TYPE_CLUT0);
520: if (!zx_cross_wait(sc))
521: return (1);
522:
523: SETREG(zx->zx_type, ZX_CROSS_TYPE_CLUTDATA);
524:
525: r = sc->sc_cmap.cm_red;
526: g = sc->sc_cmap.cm_green;
527: b = sc->sc_cmap.cm_blue;
528: for (i = 0; i < 256; i++) {
529: SETREG(zx->zx_value, *r++ | (*g++ << 8) | (*b++ << 16));
530: }
531:
532: SETREG(zx->zx_type, ZX_CROSS_TYPE_CLUT0);
533: i = zx->zx_csr;
534: i = i | ZX_CROSS_CSR_UNK | ZX_CROSS_CSR_UNK2;
535: SETREG(zx->zx_csr, i);
536: return (0);
537: }
538:
539: void
540: zx_burner(void *v, u_int on, u_int flags)
541: {
542: struct zx_softc *sc = v;
543: volatile struct zx_cross *zx;
544: u_int32_t i;
545:
546: zx = sc->sc_zx;
547:
548: SETREG(zx->zx_type, ZX_CROSS_TYPE_VIDEO);
549: i = zx->zx_csr;
550: if (on) {
551: i |= ZX_CROSS_CSR_ENABLE;
552: } else {
553: i &= ~ZX_CROSS_CSR_ENABLE;
554: }
555: SETREG(zx->zx_csr, i);
556: }
557:
558: void
559: zx_fillrect(struct rasops_info *ri, int x, int y, int w, int h, long attr,
560: int rop)
561: {
562: struct zx_softc *sc;
563: volatile struct zx_command *zc;
564: volatile struct zx_draw *zd;
565: int fg, bg;
566:
567: sc = ri->ri_hw;
568: zc = sc->sc_zc;
569: zd = sc->sc_zd_ss0;
570:
571: ri->ri_ops.unpack_attr(ri, attr, &fg, &bg, NULL);
572: x = x * ri->ri_font->fontwidth + ri->ri_xorigin;
573: y = y * ri->ri_font->fontheight + ri->ri_yorigin;
574: w = ri->ri_font->fontwidth * w - 1;
575: h = ri->ri_font->fontheight * h - 1;
576:
577: while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
578: ;
579:
580: SETREG(zd->zd_rop, rop);
581: SETREG(zd->zd_fg, ri->ri_devcmap[bg] << 24);
582: SETREG(zc->zc_extent, ZX_COORDS(w, h));
583: SETREG(zc->zc_fill, ZX_COORDS(x, y) | ZX_EXTENT_DIR_BACKWARDS);
584: }
585:
586: void
587: zx_copyrect(struct rasops_info *ri, int sx, int sy, int dx, int dy, int w,
588: int h)
589: {
590: struct zx_softc *sc;
591: volatile struct zx_command *zc;
592: volatile struct zx_draw *zd;
593: int dir;
594:
595: sc = ri->ri_hw;
596: zc = sc->sc_zc;
597: zd = sc->sc_zd_ss0;
598:
599: sx = sx * ri->ri_font->fontwidth + ri->ri_xorigin;
600: sy = sy * ri->ri_font->fontheight + ri->ri_yorigin;
601: dx = dx * ri->ri_font->fontwidth + ri->ri_xorigin;
602: dy = dy * ri->ri_font->fontheight + ri->ri_yorigin;
603: w = w * ri->ri_font->fontwidth - 1;
604: h = h * ri->ri_font->fontheight - 1;
605:
606: if (sy < dy || sx < dx) {
607: dir = ZX_EXTENT_DIR_BACKWARDS;
608: sx += w;
609: sy += h;
610: dx += w;
611: dy += h;
612: } else
613: dir = ZX_EXTENT_DIR_FORWARDS;
614:
615: while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
616: ;
617:
618: SETREG(zd->zd_rop, ZX_STD_ROP);
619: SETREG(zc->zc_extent, ZX_COORDS(w, h) | dir);
620: SETREG(zc->zc_src, ZX_COORDS(sx, sy));
621: SETREG(zc->zc_copy, ZX_COORDS(dx, dy));
622: }
623:
624: void
625: zx_do_cursor(struct rasops_info *ri)
626: {
627:
628: zx_fillrect(ri, ri->ri_ccol, ri->ri_crow, 1, 1, WSCOL_BLACK << 16,
629: ZX_ROP_NEW_XOR_OLD | ZX_ATTR_WE_ENABLE | ZX_ATTR_OE_ENABLE |
630: ZX_ATTR_FORCE_WID);
631: }
632:
633: void
634: zx_erasecols(void *cookie, int row, int col, int num, long attr)
635: {
636: struct rasops_info *ri;
637:
638: ri = (struct rasops_info *)cookie;
639:
640: zx_fillrect(ri, col, row, num, 1, attr, ZX_STD_ROP);
641: }
642:
643: void
644: zx_eraserows(void *cookie, int row, int num, long attr)
645: {
646: struct rasops_info *ri;
647: struct zx_softc *sc;
648: volatile struct zx_command *zc;
649: volatile struct zx_draw *zd;
650: int fg, bg;
651:
652: ri = (struct rasops_info *)cookie;
653:
654: if (num == ri->ri_rows && (ri->ri_flg & RI_FULLCLEAR)) {
655: sc = ri->ri_hw;
656: zc = sc->sc_zc;
657: zd = sc->sc_zd_ss0;
658:
659: ri->ri_ops.unpack_attr(cookie, attr, &fg, &bg, NULL);
660:
661: while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
662: ;
663:
664: SETREG(zd->zd_rop, ZX_STD_ROP);
665: SETREG(zd->zd_fg, ri->ri_devcmap[bg] << 24);
666: SETREG(zc->zc_extent,
667: ZX_COORDS(ri->ri_width - 1, ri->ri_height - 1));
668: SETREG(zc->zc_fill, ZX_COORDS(0, 0) | ZX_EXTENT_DIR_BACKWARDS);
669: } else
670: zx_fillrect(ri, 0, row, ri->ri_cols, num, attr, ZX_STD_ROP);
671: }
672:
673: void
674: zx_copyrows(void *cookie, int src, int dst, int num)
675: {
676: struct rasops_info *ri;
677:
678: ri = (struct rasops_info *)cookie;
679:
680: zx_copyrect(ri, 0, src, 0, dst, ri->ri_cols, num);
681: }
682:
683: void
684: zx_copycols(void *cookie, int row, int src, int dst, int num)
685: {
686: struct rasops_info *ri;
687:
688: ri = (struct rasops_info *)cookie;
689:
690: zx_copyrect(ri, src, row, dst, row, num, 1);
691: }
692:
693: void
694: zx_putchar(void *cookie, int row, int col, u_int uc, long attr)
695: {
696: struct rasops_info *ri;
697: struct zx_softc *sc;
698: struct wsdisplay_font *font;
699: volatile struct zx_command *zc;
700: volatile struct zx_draw *zd;
701: volatile u_int32_t *dp;
702: u_int8_t *fb;
703: int fs, i, fg, bg, ul;
704:
705: ri = (struct rasops_info *)cookie;
706: font = ri->ri_font;
707: ri->ri_ops.unpack_attr(cookie, attr, &fg, &bg, &ul);
708: fg = ri->ri_devcmap[fg];
709: bg = ri->ri_devcmap[bg];
710:
711: dp = (volatile u_int32_t *)ri->ri_bits +
712: ZX_COORDS(col * font->fontwidth, row * font->fontheight);
713:
714: if (uc == ' ') {
715: zx_fillrect(ri, col, row, 1, 1, attr, ZX_STD_ROP);
716: if (ul == 0)
717: return;
718:
719: dp += font->fontheight << ZX_WWIDTH;
720:
721: while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
722: ;
723:
724: SETREG(zd->zd_rop, ZX_STD_ROP);
725: SETREG(zd->zd_fg, fg << 24);
726: SETREG(zd->zd_bg, bg << 24);
727: SETREG(zc->zc_fontmsk, 0xffffffff << (32 - font->fontwidth));
728: } else {
729: sc = ri->ri_hw;
730: zc = sc->sc_zc;
731: zd = sc->sc_zd_ss0;
732:
733: fb = (u_int8_t *)font->data + (uc - font->firstchar) *
734: ri->ri_fontscale;
735: fs = font->stride;
736:
737: while ((zc->zc_csr & ZX_CSR_BLT_BUSY) != 0)
738: ;
739:
740: SETREG(zd->zd_rop, ZX_STD_ROP);
741: SETREG(zd->zd_fg, fg << 24);
742: SETREG(zd->zd_bg, bg << 24);
743: SETREG(zc->zc_fontmsk, 0xffffffff << (32 - font->fontwidth));
744:
745: if (font->fontwidth <= 8) {
746: for (i = font->fontheight; i != 0;
747: i--, dp += 1 << ZX_WWIDTH) {
748: *dp = *fb << 24;
749: fb += fs;
750: }
751: } else {
752: for (i = font->fontheight; i != 0;
753: i--, dp += 1 << ZX_WWIDTH) {
754: *dp = *((u_int16_t *)fb) << 16;
755: fb += fs;
756: }
757: }
758: }
759:
760: /* underline */
761: if (ul) {
762: dp -= 2 << ZX_WWIDTH;
763: *dp = 0xffffffff;
764: }
765: }
766:
767: void
768: zx_prom(void *v)
769: {
770: struct zx_softc *sc = v;
771: extern struct consdev consdev_prom;
772:
773: if (sc->sc_mode != WSDISPLAYIO_MODE_EMUL) {
774: /*
775: * Select 8-bit mode.
776: */
777: zx_reset(sc, WSDISPLAYIO_MODE_EMUL);
778:
779: /*
780: * Go back to prom output for the last few messages, so they
781: * will be displayed correctly.
782: */
783: cn_tab = &consdev_prom;
784: }
785: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to zx.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc / dev