Annotation of sys/arch/sparc64/dev/creator.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: creator.c,v 1.39 2007/03/06 23:10:26 kettenis Exp $ */
2:
3: /*
4: * Copyright (c) 2002 Jason L. Wright (jason@thought.net)
5: * All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: *
16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
20: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
24: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
25: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26: * POSSIBILITY OF SUCH DAMAGE.
27: */
28:
29: #include <sys/types.h>
30: #include <sys/param.h>
31: #include <sys/systm.h>
32: #include <sys/kernel.h>
33: #include <sys/device.h>
34: #include <sys/conf.h>
35: #include <sys/timeout.h>
36:
37: #include <machine/bus.h>
38: #include <machine/autoconf.h>
39: #include <machine/openfirm.h>
40:
41: #include <dev/wscons/wsconsio.h>
42: #include <dev/wscons/wsdisplayvar.h>
43: #include <dev/rasops/rasops.h>
44: #include <machine/fbvar.h>
45:
46: #include <sparc64/dev/creatorreg.h>
47: #include <sparc64/dev/creatorvar.h>
48:
49: int creator_match(struct device *, void *, void *);
50: void creator_attach(struct device *, struct device *, void *);
51: int creator_ioctl(void *, u_long, caddr_t, int, struct proc *);
52: int creator_alloc_screen(void *, const struct wsscreen_descr *, void **,
53: int *, int *, long *);
54: void creator_free_screen(void *, void *);
55: int creator_show_screen(void *, void *, int, void (*cb)(void *, int, int),
56: void *);
57: paddr_t creator_mmap(void *, off_t, int);
58: void creator_ras_fifo_wait(struct creator_softc *, int);
59: void creator_ras_wait(struct creator_softc *);
60: void creator_ras_init(struct creator_softc *);
61: void creator_ras_copyrows(void *, int, int, int);
62: void creator_ras_erasecols(void *, int, int, int, long int);
63: void creator_ras_eraserows(void *, int, int, long int);
64: void creator_ras_fill(struct creator_softc *);
65: void creator_ras_setfg(struct creator_softc *, int32_t);
66: int creator_setcursor(struct creator_softc *, struct wsdisplay_cursor *);
67: int creator_updatecursor(struct creator_softc *, u_int);
68: void creator_curs_enable(struct creator_softc *, u_int);
69:
70: struct wsdisplay_accessops creator_accessops = {
71: creator_ioctl,
72: creator_mmap,
73: creator_alloc_screen,
74: creator_free_screen,
75: creator_show_screen,
76: NULL, /* load font */
77: NULL, /* scrollback */
78: NULL, /* getchar */
79: NULL, /* burner */
80: };
81:
82: struct cfdriver creator_cd = {
83: NULL, "creator", DV_DULL
84: };
85:
86: struct cfattach creator_ca = {
87: sizeof(struct creator_softc), creator_match, creator_attach
88: };
89:
90: int
91: creator_match(parent, match, aux)
92: struct device *parent;
93: void *match, *aux;
94: {
95: struct mainbus_attach_args *ma = aux;
96:
97: if (strcmp(ma->ma_name, "SUNW,ffb") == 0 ||
98: strcmp(ma->ma_name, "SUNW,afb") == 0)
99: return (1);
100: return (0);
101: }
102:
103: void
104: creator_attach(parent, self, aux)
105: struct device *parent, *self;
106: void *aux;
107: {
108: struct creator_softc *sc = (struct creator_softc *)self;
109: struct mainbus_attach_args *ma = aux;
110: extern int fbnode;
111: int i, nregs;
112: char *model;
113: int btype;
114:
115: sc->sc_bt = ma->ma_bustag;
116:
117: nregs = min(ma->ma_nreg, FFB_NREGS);
118:
119: if (nregs <= FFB_REG_DFB24) {
120: printf(": no dfb24 regs found\n");
121: return;
122: }
123:
124: if (bus_space_map(sc->sc_bt, ma->ma_reg[FFB_REG_DFB24].ur_paddr,
125: ma->ma_reg[FFB_REG_DFB24].ur_len, BUS_SPACE_MAP_LINEAR,
126: &sc->sc_pixel_h)) {
127: printf(": failed to map dfb24\n");
128: return;
129: }
130:
131: if (bus_space_map(sc->sc_bt, ma->ma_reg[FFB_REG_FBC].ur_paddr,
132: ma->ma_reg[FFB_REG_FBC].ur_len, 0, &sc->sc_fbc_h)) {
133: printf(": failed to map fbc\n");
134: goto unmap_dfb24;
135: }
136:
137: if (bus_space_map(sc->sc_bt, ma->ma_reg[FFB_REG_DAC].ur_paddr,
138: ma->ma_reg[FFB_REG_DAC].ur_len, 0, &sc->sc_dac_h)) {
139: printf(": failed to map dac\n");
140: goto unmap_fbc;
141: }
142:
143: for (i = 0; i < nregs; i++) {
144: sc->sc_addrs[i] = ma->ma_reg[i].ur_paddr;
145: sc->sc_sizes[i] = ma->ma_reg[i].ur_len;
146: }
147: sc->sc_nreg = nregs;
148:
149: sc->sc_console = (fbnode == ma->ma_node);
150: sc->sc_node = ma->ma_node;
151:
152: if (strcmp(ma->ma_name, "SUNW,afb") == 0)
153: sc->sc_type = FFB_AFB;
154:
155: /*
156: * Prom reports only the length of the fcode header, we need
157: * the whole thing.
158: */
159: sc->sc_sizes[0] = 0x00400000;
160:
161: if (sc->sc_type == FFB_CREATOR) {
162: btype = getpropint(sc->sc_node, "board_type", 0);
163: if ((btype & 7) == 3)
164: printf(": Creator3D");
165: else
166: printf(": Creator");
167: } else
168: printf(": Elite3D");
169:
170: model = getpropstring(sc->sc_node, "model");
171: if (model == NULL || strlen(model) == 0)
172: model = "unknown";
173:
174: DAC_WRITE(sc, FFB_DAC_TYPE, DAC_TYPE_GETREV);
175: sc->sc_dacrev = DAC_READ(sc, FFB_DAC_VALUE) >> 28;
176:
177: printf(", model %s, dac %u\n", model, sc->sc_dacrev);
178:
179: if (sc->sc_type == FFB_AFB)
180: sc->sc_dacrev = 10;
181:
182: fb_setsize(&sc->sc_sunfb, 32, 1152, 900, sc->sc_node, 0);
183: /* linesize has a fixed value, compensate */
184: sc->sc_sunfb.sf_linebytes = 8192;
185: sc->sc_sunfb.sf_fbsize = sc->sc_sunfb.sf_height * 8192;
186:
187: sc->sc_sunfb.sf_ro.ri_bits = (void *)bus_space_vaddr(sc->sc_bt,
188: sc->sc_pixel_h);
189: sc->sc_sunfb.sf_ro.ri_hw = sc;
190: fbwscons_init(&sc->sc_sunfb, sc->sc_console ? 0 : RI_CLEAR);
191:
192: if ((sc->sc_sunfb.sf_dev.dv_cfdata->cf_flags & CREATOR_CFFLAG_NOACCEL)
193: == 0) {
194: sc->sc_sunfb.sf_ro.ri_ops.eraserows = creator_ras_eraserows;
195: sc->sc_sunfb.sf_ro.ri_ops.erasecols = creator_ras_erasecols;
196: sc->sc_sunfb.sf_ro.ri_ops.copyrows = creator_ras_copyrows;
197: creator_ras_init(sc);
198: }
199:
200: if (sc->sc_console) {
201: fbwscons_console_init(&sc->sc_sunfb, -1);
202: }
203:
204: fbwscons_attach(&sc->sc_sunfb, &creator_accessops, sc->sc_console);
205: return;
206:
207: unmap_fbc:
208: bus_space_unmap(sc->sc_bt, sc->sc_fbc_h,
209: ma->ma_reg[FFB_REG_FBC].ur_len);
210: unmap_dfb24:
211: bus_space_unmap(sc->sc_bt, sc->sc_pixel_h,
212: ma->ma_reg[FFB_REG_DFB24].ur_len);
213: }
214:
215: int
216: creator_ioctl(v, cmd, data, flags, p)
217: void *v;
218: u_long cmd;
219: caddr_t data;
220: int flags;
221: struct proc *p;
222: {
223: struct creator_softc *sc = v;
224: struct wsdisplay_cursor *curs;
225: struct wsdisplay_fbinfo *wdf;
226: struct wsdisplay_curpos *pos;
227: u_char r[2], g[2], b[2];
228: int error;
229:
230: switch (cmd) {
231: case WSDISPLAYIO_GTYPE:
232: *(u_int *)data = WSDISPLAY_TYPE_SUNFFB;
233: break;
234: case WSDISPLAYIO_SMODE:
235: sc->sc_mode = *(u_int *)data;
236: break;
237: case WSDISPLAYIO_GINFO:
238: wdf = (void *)data;
239: wdf->height = sc->sc_sunfb.sf_height;
240: wdf->width = sc->sc_sunfb.sf_width;
241: wdf->depth = 32;
242: wdf->cmsize = 0;
243: break;
244: case WSDISPLAYIO_GETSUPPORTEDDEPTH:
245: *(u_int *)data = WSDISPLAYIO_DEPTH_24_32;
246: break;
247: case WSDISPLAYIO_LINEBYTES:
248: *(u_int *)data = sc->sc_sunfb.sf_linebytes;
249: break;
250: case WSDISPLAYIO_GCURSOR:
251: curs = (struct wsdisplay_cursor *)data;
252: if (curs->which & WSDISPLAY_CURSOR_DOCUR)
253: curs->enable = sc->sc_curs_enabled;
254: if (curs->which & WSDISPLAY_CURSOR_DOPOS) {
255: curs->pos.x = sc->sc_curs_pos.x;
256: curs->pos.y = sc->sc_curs_pos.y;
257: }
258: if (curs->which & WSDISPLAY_CURSOR_DOHOT) {
259: curs->hot.x = sc->sc_curs_hot.x;
260: curs->hot.y = sc->sc_curs_hot.y;
261: }
262: if (curs->which & WSDISPLAY_CURSOR_DOCMAP) {
263: curs->cmap.index = 0;
264: curs->cmap.count = 2;
265: r[0] = sc->sc_curs_fg >> 0;
266: g[0] = sc->sc_curs_fg >> 8;
267: b[0] = sc->sc_curs_fg >> 16;
268: r[1] = sc->sc_curs_bg >> 0;
269: g[1] = sc->sc_curs_bg >> 8;
270: b[1] = sc->sc_curs_bg >> 16;
271: error = copyout(r, curs->cmap.red, sizeof(r));
272: if (error)
273: return (error);
274: error = copyout(g, curs->cmap.green, sizeof(g));
275: if (error)
276: return (error);
277: error = copyout(b, curs->cmap.blue, sizeof(b));
278: if (error)
279: return (error);
280: }
281: if (curs->which & WSDISPLAY_CURSOR_DOSHAPE) {
282: size_t l;
283:
284: curs->size.x = sc->sc_curs_size.x;
285: curs->size.y = sc->sc_curs_size.y;
286: l = (sc->sc_curs_size.x * sc->sc_curs_size.y) / NBBY;
287: error = copyout(sc->sc_curs_image, curs->image, l);
288: if (error)
289: return (error);
290: error = copyout(sc->sc_curs_mask, curs->mask, l);
291: if (error)
292: return (error);
293: }
294: break;
295: case WSDISPLAYIO_SCURPOS:
296: pos = (struct wsdisplay_curpos *)data;
297: sc->sc_curs_pos.x = pos->x;
298: sc->sc_curs_pos.y = pos->y;
299: creator_updatecursor(sc, WSDISPLAY_CURSOR_DOPOS);
300: break;
301: case WSDISPLAYIO_GCURPOS:
302: pos = (struct wsdisplay_curpos *)data;
303: pos->x = sc->sc_curs_pos.x;
304: pos->y = sc->sc_curs_pos.y;
305: break;
306: case WSDISPLAYIO_SCURSOR:
307: curs = (struct wsdisplay_cursor *)data;
308: return (creator_setcursor(sc, curs));
309: case WSDISPLAYIO_GCURMAX:
310: pos = (struct wsdisplay_curpos *)data;
311: pos->x = CREATOR_CURS_MAX;
312: pos->y = CREATOR_CURS_MAX;
313: break;
314: case WSDISPLAYIO_SVIDEO:
315: case WSDISPLAYIO_GVIDEO:
316: break;
317:
318: case WSDISPLAYIO_GETCMAP:
319: case WSDISPLAYIO_PUTCMAP:
320: default:
321: return -1; /* not supported yet */
322: }
323:
324: return (0);
325: }
326:
327: int
328: creator_setcursor(struct creator_softc *sc, struct wsdisplay_cursor *curs)
329: {
330: u_int8_t r[2], g[2], b[2], image[128], mask[128];
331: int error;
332: size_t imcount;
333:
334: /*
335: * Do stuff that can generate errors first, then we'll blast it
336: * all at once.
337: */
338: if (curs->which & WSDISPLAY_CURSOR_DOCMAP) {
339: if (curs->cmap.count < 2)
340: return (EINVAL);
341: error = copyin(curs->cmap.red, r, sizeof(r));
342: if (error)
343: return (error);
344: error = copyin(curs->cmap.green, g, sizeof(g));
345: if (error)
346: return (error);
347: error = copyin(curs->cmap.blue, b, sizeof(b));
348: if (error)
349: return (error);
350: }
351:
352: if (curs->which & WSDISPLAY_CURSOR_DOSHAPE) {
353: if (curs->size.x > CREATOR_CURS_MAX ||
354: curs->size.y > CREATOR_CURS_MAX)
355: return (EINVAL);
356: imcount = (curs->size.x * curs->size.y) / NBBY;
357: error = copyin(curs->image, image, imcount);
358: if (error)
359: return (error);
360: error = copyin(curs->mask, mask, imcount);
361: if (error)
362: return (error);
363: }
364:
365: /*
366: * Ok, everything is in kernel space and sane, update state.
367: */
368:
369: if (curs->which & WSDISPLAY_CURSOR_DOCUR)
370: sc->sc_curs_enabled = curs->enable;
371: if (curs->which & WSDISPLAY_CURSOR_DOPOS) {
372: sc->sc_curs_pos.x = curs->pos.x;
373: sc->sc_curs_pos.y = curs->pos.y;
374: }
375: if (curs->which & WSDISPLAY_CURSOR_DOHOT) {
376: sc->sc_curs_hot.x = curs->hot.x;
377: sc->sc_curs_hot.y = curs->hot.y;
378: }
379: if (curs->which & WSDISPLAY_CURSOR_DOCMAP) {
380: sc->sc_curs_fg = ((r[0] << 0) | (g[0] << 8) | (b[0] << 16));
381: sc->sc_curs_bg = ((r[1] << 0) | (g[1] << 8) | (b[1] << 16));
382: }
383: if (curs->which & WSDISPLAY_CURSOR_DOSHAPE) {
384: sc->sc_curs_size.x = curs->size.x;
385: sc->sc_curs_size.y = curs->size.y;
386: bcopy(image, sc->sc_curs_image, imcount);
387: bcopy(mask, sc->sc_curs_mask, imcount);
388: }
389:
390: creator_updatecursor(sc, curs->which);
391:
392: return (0);
393: }
394:
395: void
396: creator_curs_enable(struct creator_softc *sc, u_int ena)
397: {
398: u_int32_t v;
399:
400: DAC_WRITE(sc, FFB_DAC_TYPE2, DAC_TYPE2_CURSENAB);
401: if (sc->sc_dacrev <= 2)
402: v = ena ? 3 : 0;
403: else
404: v = ena ? 0 : 3;
405: DAC_WRITE(sc, FFB_DAC_VALUE2, v);
406: }
407:
408: int
409: creator_updatecursor(struct creator_softc *sc, u_int which)
410: {
411: creator_curs_enable(sc, 0);
412:
413: if (which & WSDISPLAY_CURSOR_DOCMAP) {
414: DAC_WRITE(sc, FFB_DAC_TYPE2, DAC_TYPE2_CURSCMAP);
415: DAC_WRITE(sc, FFB_DAC_VALUE2, sc->sc_curs_fg);
416: DAC_WRITE(sc, FFB_DAC_VALUE2, sc->sc_curs_bg);
417: }
418:
419: if (which & (WSDISPLAY_CURSOR_DOPOS | WSDISPLAY_CURSOR_DOHOT)) {
420: u_int32_t x, y;
421:
422: x = sc->sc_curs_pos.x + CREATOR_CURS_MAX - sc->sc_curs_hot.x;
423: y = sc->sc_curs_pos.y + CREATOR_CURS_MAX - sc->sc_curs_hot.y;
424: DAC_WRITE(sc, FFB_DAC_TYPE2, DAC_TYPE2_CURSPOS);
425: DAC_WRITE(sc, FFB_DAC_VALUE2,
426: ((x & 0xffff) << 16) | (y & 0xffff));
427: }
428:
429: if (which & WSDISPLAY_CURSOR_DOCUR)
430: creator_curs_enable(sc, sc->sc_curs_enabled);
431:
432: return (0);
433: }
434:
435: int
436: creator_alloc_screen(v, type, cookiep, curxp, curyp, attrp)
437: void *v;
438: const struct wsscreen_descr *type;
439: void **cookiep;
440: int *curxp, *curyp;
441: long *attrp;
442: {
443: struct creator_softc *sc = v;
444:
445: if (sc->sc_nscreens > 0)
446: return (ENOMEM);
447:
448: *cookiep = &sc->sc_sunfb.sf_ro;
449: *curyp = 0;
450: *curxp = 0;
451: sc->sc_sunfb.sf_ro.ri_ops.alloc_attr(&sc->sc_sunfb.sf_ro,
452: WSCOL_BLACK, WSCOL_WHITE, WSATTR_WSCOLORS, attrp);
453: sc->sc_nscreens++;
454: return (0);
455: }
456:
457: void
458: creator_free_screen(v, cookie)
459: void *v;
460: void *cookie;
461: {
462: struct creator_softc *sc = v;
463:
464: sc->sc_nscreens--;
465: }
466:
467: int
468: creator_show_screen(v, cookie, waitok, cb, cbarg)
469: void *v;
470: void *cookie;
471: int waitok;
472: void (*cb)(void *, int, int);
473: void *cbarg;
474: {
475: return (0);
476: }
477:
478: const struct creator_mappings {
479: bus_addr_t uoff;
480: bus_addr_t poff;
481: bus_size_t ulen;
482: } creator_map[] = {
483: { FFB_VOFF_SFB8R, FFB_POFF_SFB8R, FFB_VLEN_SFB8R },
484: { FFB_VOFF_SFB8G, FFB_POFF_SFB8G, FFB_VLEN_SFB8G },
485: { FFB_VOFF_SFB8B, FFB_POFF_SFB8B, FFB_VLEN_SFB8B },
486: { FFB_VOFF_SFB8X, FFB_POFF_SFB8X, FFB_VLEN_SFB8X },
487: { FFB_VOFF_SFB32, FFB_POFF_SFB32, FFB_VLEN_SFB32 },
488: { FFB_VOFF_SFB64, FFB_POFF_SFB64, FFB_VLEN_SFB64 },
489: { FFB_VOFF_FBC_REGS, FFB_POFF_FBC_REGS, FFB_VLEN_FBC_REGS },
490: { FFB_VOFF_BM_FBC_REGS, FFB_POFF_BM_FBC_REGS, FFB_VLEN_BM_FBC_REGS },
491: { FFB_VOFF_DFB8R, FFB_POFF_DFB8R, FFB_VLEN_DFB8R },
492: { FFB_VOFF_DFB8G, FFB_POFF_DFB8G, FFB_VLEN_DFB8G },
493: { FFB_VOFF_DFB8B, FFB_POFF_DFB8B, FFB_VLEN_DFB8B },
494: { FFB_VOFF_DFB8X, FFB_POFF_DFB8X, FFB_VLEN_DFB8X },
495: { FFB_VOFF_DFB24, FFB_POFF_DFB24, FFB_VLEN_DFB24 },
496: { FFB_VOFF_DFB32, FFB_POFF_DFB32, FFB_VLEN_DFB32 },
497: { FFB_VOFF_DFB422A, FFB_POFF_DFB422A, FFB_VLEN_DFB422A },
498: { FFB_VOFF_DFB422AD, FFB_POFF_DFB422AD, FFB_VLEN_DFB422AD },
499: { FFB_VOFF_DFB24B, FFB_POFF_DFB24B, FFB_VLEN_DFB24B },
500: { FFB_VOFF_DFB422B, FFB_POFF_DFB422B, FFB_VLEN_DFB422B },
501: { FFB_VOFF_DFB422BD, FFB_POFF_DFB422BD, FFB_VLEN_DFB422BD },
502: { FFB_VOFF_SFB16Z, FFB_POFF_SFB16Z, FFB_VLEN_SFB16Z },
503: { FFB_VOFF_SFB8Z, FFB_POFF_SFB8Z, FFB_VLEN_SFB8Z },
504: { FFB_VOFF_SFB422, FFB_POFF_SFB422, FFB_VLEN_SFB422 },
505: { FFB_VOFF_SFB422D, FFB_POFF_SFB422D, FFB_VLEN_SFB422D },
506: { FFB_VOFF_FBC_KREGS, FFB_POFF_FBC_KREGS, FFB_VLEN_FBC_KREGS },
507: { FFB_VOFF_DAC, FFB_POFF_DAC, FFB_VLEN_DAC },
508: { FFB_VOFF_PROM, FFB_POFF_PROM, FFB_VLEN_PROM },
509: { FFB_VOFF_EXP, FFB_POFF_EXP, FFB_VLEN_EXP },
510: };
511: #define CREATOR_NMAPPINGS (sizeof(creator_map)/sizeof(creator_map[0]))
512:
513: paddr_t
514: creator_mmap(vsc, off, prot)
515: void *vsc;
516: off_t off;
517: int prot;
518: {
519: paddr_t x;
520: struct creator_softc *sc = vsc;
521: int i;
522:
523: switch (sc->sc_mode) {
524: case WSDISPLAYIO_MODE_MAPPED:
525: /* Turn virtual offset into physical offset */
526: for (i = 0; i < CREATOR_NMAPPINGS; i++) {
527: if (off >= creator_map[i].uoff &&
528: off < (creator_map[i].uoff + creator_map[i].ulen))
529: break;
530: }
531: if (i == CREATOR_NMAPPINGS)
532: break;
533:
534: off -= creator_map[i].uoff;
535: off += creator_map[i].poff;
536: off += sc->sc_addrs[0];
537:
538: /* Map based on physical offset */
539: for (i = 0; i < sc->sc_nreg; i++) {
540: /* Before this set? */
541: if (off < sc->sc_addrs[i])
542: continue;
543: /* After this set? */
544: if (off >= (sc->sc_addrs[i] + sc->sc_sizes[i]))
545: continue;
546:
547: x = bus_space_mmap(sc->sc_bt, 0, off, prot,
548: BUS_SPACE_MAP_LINEAR);
549: return (x);
550: }
551: break;
552: case WSDISPLAYIO_MODE_DUMBFB:
553: if (sc->sc_nreg <= FFB_REG_DFB24)
554: break;
555: if (off >= 0 && off < sc->sc_sizes[FFB_REG_DFB24])
556: return (bus_space_mmap(sc->sc_bt,
557: sc->sc_addrs[FFB_REG_DFB24], off, prot,
558: BUS_SPACE_MAP_LINEAR));
559: break;
560: }
561:
562: return (-1);
563: }
564:
565: void
566: creator_ras_fifo_wait(sc, n)
567: struct creator_softc *sc;
568: int n;
569: {
570: int32_t cache = sc->sc_fifo_cache;
571:
572: if (cache < n) {
573: do {
574: cache = FBC_READ(sc, FFB_FBC_UCSR);
575: cache = (cache & FBC_UCSR_FIFO_MASK) - 8;
576: } while (cache < n);
577: }
578: sc->sc_fifo_cache = cache - n;
579: }
580:
581: void
582: creator_ras_wait(sc)
583: struct creator_softc *sc;
584: {
585: u_int32_t ucsr, r;
586:
587: while (1) {
588: ucsr = FBC_READ(sc, FFB_FBC_UCSR);
589: if ((ucsr & (FBC_UCSR_FB_BUSY|FBC_UCSR_RP_BUSY)) == 0)
590: break;
591: r = ucsr & (FBC_UCSR_READ_ERR | FBC_UCSR_FIFO_OVFL);
592: if (r != 0)
593: FBC_WRITE(sc, FFB_FBC_UCSR, r);
594: }
595: }
596:
597: void
598: creator_ras_init(sc)
599: struct creator_softc *sc;
600: {
601: creator_ras_fifo_wait(sc, 7);
602: FBC_WRITE(sc, FFB_FBC_PPC,
603: FBC_PPC_VCE_DIS | FBC_PPC_TBE_OPAQUE |
604: FBC_PPC_APE_DIS | FBC_PPC_CS_CONST);
605: FBC_WRITE(sc, FFB_FBC_FBC,
606: FFB_FBC_WB_A | FFB_FBC_RB_A | FFB_FBC_SB_BOTH |
607: FFB_FBC_XE_OFF | FFB_FBC_RGBE_MASK);
608: FBC_WRITE(sc, FFB_FBC_ROP, FBC_ROP_NEW);
609: FBC_WRITE(sc, FFB_FBC_DRAWOP, FBC_DRAWOP_RECTANGLE);
610: FBC_WRITE(sc, FFB_FBC_PMASK, 0xffffffff);
611: FBC_WRITE(sc, FFB_FBC_FONTINC, 0x10000);
612: sc->sc_fg_cache = 0;
613: FBC_WRITE(sc, FFB_FBC_FG, sc->sc_fg_cache);
614: creator_ras_wait(sc);
615: }
616:
617: void
618: creator_ras_eraserows(cookie, row, n, attr)
619: void *cookie;
620: int row, n;
621: long int attr;
622: {
623: struct rasops_info *ri = cookie;
624: struct creator_softc *sc = ri->ri_hw;
625: int bg, fg;
626:
627: if (row < 0) {
628: n += row;
629: row = 0;
630: }
631: if (row + n > ri->ri_rows)
632: n = ri->ri_rows - row;
633: if (n <= 0)
634: return;
635:
636: ri->ri_ops.unpack_attr(cookie, attr, &fg, &bg, NULL);
637: creator_ras_fill(sc);
638: creator_ras_setfg(sc, ri->ri_devcmap[bg]);
639: creator_ras_fifo_wait(sc, 4);
640: if ((n == ri->ri_rows) && (ri->ri_flg & RI_FULLCLEAR)) {
641: FBC_WRITE(sc, FFB_FBC_BY, 0);
642: FBC_WRITE(sc, FFB_FBC_BX, 0);
643: FBC_WRITE(sc, FFB_FBC_BH, ri->ri_height);
644: FBC_WRITE(sc, FFB_FBC_BW, ri->ri_width);
645: } else {
646: row *= ri->ri_font->fontheight;
647: FBC_WRITE(sc, FFB_FBC_BY, ri->ri_yorigin + row);
648: FBC_WRITE(sc, FFB_FBC_BX, ri->ri_xorigin);
649: FBC_WRITE(sc, FFB_FBC_BH, n * ri->ri_font->fontheight);
650: FBC_WRITE(sc, FFB_FBC_BW, ri->ri_emuwidth);
651: }
652: creator_ras_wait(sc);
653: }
654:
655: void
656: creator_ras_erasecols(cookie, row, col, n, attr)
657: void *cookie;
658: int row, col, n;
659: long int attr;
660: {
661: struct rasops_info *ri = cookie;
662: struct creator_softc *sc = ri->ri_hw;
663: int fg, bg;
664:
665: if ((row < 0) || (row >= ri->ri_rows))
666: return;
667: if (col < 0) {
668: n += col;
669: col = 0;
670: }
671: if (col + n > ri->ri_cols)
672: n = ri->ri_cols - col;
673: if (n <= 0)
674: return;
675: n *= ri->ri_font->fontwidth;
676: col *= ri->ri_font->fontwidth;
677: row *= ri->ri_font->fontheight;
678:
679: ri->ri_ops.unpack_attr(cookie, attr, &fg, &bg, NULL);
680: creator_ras_fill(sc);
681: creator_ras_setfg(sc, ri->ri_devcmap[bg]);
682: creator_ras_fifo_wait(sc, 4);
683: FBC_WRITE(sc, FFB_FBC_BY, ri->ri_yorigin + row);
684: FBC_WRITE(sc, FFB_FBC_BX, ri->ri_xorigin + col);
685: FBC_WRITE(sc, FFB_FBC_BH, ri->ri_font->fontheight);
686: FBC_WRITE(sc, FFB_FBC_BW, n - 1);
687: creator_ras_wait(sc);
688: }
689:
690: void
691: creator_ras_fill(sc)
692: struct creator_softc *sc;
693: {
694: creator_ras_fifo_wait(sc, 2);
695: FBC_WRITE(sc, FFB_FBC_ROP, FBC_ROP_NEW);
696: FBC_WRITE(sc, FFB_FBC_DRAWOP, FBC_DRAWOP_RECTANGLE);
697: creator_ras_wait(sc);
698: }
699:
700: void
701: creator_ras_copyrows(cookie, src, dst, n)
702: void *cookie;
703: int src, dst, n;
704: {
705: struct rasops_info *ri = cookie;
706: struct creator_softc *sc = ri->ri_hw;
707:
708: if (dst == src)
709: return;
710: if (src < 0) {
711: n += src;
712: src = 0;
713: }
714: if ((src + n) > ri->ri_rows)
715: n = ri->ri_rows - src;
716: if (dst < 0) {
717: n += dst;
718: dst = 0;
719: }
720: if ((dst + n) > ri->ri_rows)
721: n = ri->ri_rows - dst;
722: if (n <= 0)
723: return;
724: n *= ri->ri_font->fontheight;
725: src *= ri->ri_font->fontheight;
726: dst *= ri->ri_font->fontheight;
727:
728: creator_ras_fifo_wait(sc, 8);
729: FBC_WRITE(sc, FFB_FBC_ROP, FBC_ROP_OLD | (FBC_ROP_OLD << 8));
730: FBC_WRITE(sc, FFB_FBC_DRAWOP, FBC_DRAWOP_VSCROLL);
731: FBC_WRITE(sc, FFB_FBC_BY, ri->ri_yorigin + src);
732: FBC_WRITE(sc, FFB_FBC_BX, ri->ri_xorigin);
733: FBC_WRITE(sc, FFB_FBC_DY, ri->ri_yorigin + dst);
734: FBC_WRITE(sc, FFB_FBC_DX, ri->ri_xorigin);
735: FBC_WRITE(sc, FFB_FBC_BH, n);
736: FBC_WRITE(sc, FFB_FBC_BW, ri->ri_emuwidth);
737: creator_ras_wait(sc);
738: }
739:
740: void
741: creator_ras_setfg(sc, fg)
742: struct creator_softc *sc;
743: int32_t fg;
744: {
745: creator_ras_fifo_wait(sc, 1);
746: if (fg == sc->sc_fg_cache)
747: return;
748: sc->sc_fg_cache = fg;
749: FBC_WRITE(sc, FFB_FBC_FG, fg);
750: creator_ras_wait(sc);
751: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to creator.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc64 / dev