1 /* $NetBSD: r128fb.c,v 1.45 2022/09/25 17:52:25 thorpej Exp $ */
2
3 /*
4 * Copyright (c) 2007, 2012 Michael Lorenz
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 WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 /*
29 * A console driver for ATI Rage 128 graphics controllers
30 * tested on macppc only so far
31 */
32
33 #include <sys/cdefs.h>
34 __KERNEL_RCSID(0, "$NetBSD: r128fb.c,v 1.45 2022/09/25 17:52:25 thorpej Exp $");
35
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/kernel.h>
39 #include <sys/device.h>
40 #include <sys/lwp.h>
41 #include <sys/kauth.h>
42
43 #include <dev/pci/pcivar.h>
44 #include <dev/pci/pcireg.h>
45 #include <dev/pci/pcidevs.h>
46 #include <dev/pci/pciio.h>
47 #include <dev/pci/r128fbreg.h>
48
49 #include <dev/wscons/wsdisplayvar.h>
50 #include <dev/wscons/wsconsio.h>
51 #include <dev/wsfont/wsfont.h>
52 #include <dev/rasops/rasops.h>
53 #include <dev/wscons/wsdisplay_vconsvar.h>
54 #include <dev/pci/wsdisplay_pci.h>
55 #include <dev/wscons/wsdisplay_glyphcachevar.h>
56
57 #include "opt_r128fb.h"
58 #include "opt_vcons.h"
59
60 #ifdef R128FB_DEBUG
61 #define DPRINTF printf
62 #else
63 #define DPRINTF while(0) printf
64 #endif
65
66 struct r128fb_softc {
67 device_t sc_dev;
68
69 pci_chipset_tag_t sc_pc;
70 pcitag_t sc_pcitag;
71
72 bus_space_tag_t sc_memt;
73 bus_space_tag_t sc_iot;
74
75 bus_space_handle_t sc_regh;
76 bus_addr_t sc_fb, sc_reg;
77 bus_size_t sc_fbsize, sc_regsize;
78
79 int sc_width, sc_height, sc_depth, sc_stride;
80 int sc_locked, sc_have_backlight, sc_bl_level, sc_bl_on;
81 struct vcons_screen sc_console_screen;
82 struct wsscreen_descr sc_defaultscreen_descr;
83 const struct wsscreen_descr *sc_screens[1];
84 struct wsscreen_list sc_screenlist;
85 struct vcons_data vd;
86 int sc_mode;
87 u_char sc_cmap_red[256];
88 u_char sc_cmap_green[256];
89 u_char sc_cmap_blue[256];
90 /* engine stuff */
91 uint32_t sc_master_cntl;
92 glyphcache sc_gc;
93 };
94
95 static int r128fb_match(device_t, cfdata_t, void *);
96 static void r128fb_attach(device_t, device_t, void *);
97
98 CFATTACH_DECL_NEW(r128fb, sizeof(struct r128fb_softc),
99 r128fb_match, r128fb_attach, NULL, NULL);
100
101 static int r128fb_ioctl(void *, void *, u_long, void *, int,
102 struct lwp *);
103 static paddr_t r128fb_mmap(void *, void *, off_t, int);
104 static void r128fb_init_screen(void *, struct vcons_screen *, int, long *);
105
106 static int r128fb_putcmap(struct r128fb_softc *, struct wsdisplay_cmap *);
107 static int r128fb_getcmap(struct r128fb_softc *, struct wsdisplay_cmap *);
108 static void r128fb_restore_palette(struct r128fb_softc *);
109 static int r128fb_putpalreg(struct r128fb_softc *, uint8_t, uint8_t,
110 uint8_t, uint8_t);
111
112 static void r128fb_init(struct r128fb_softc *);
113 static void r128fb_flush_engine(struct r128fb_softc *);
114 static void r128fb_rectfill(struct r128fb_softc *, int, int, int, int,
115 uint32_t);
116 static void r128fb_bitblt(void *, int, int, int, int, int,
117 int, int);
118
119 static void r128fb_cursor(void *, int, int, int);
120 static void r128fb_putchar(void *, int, int, u_int, long);
121 static void r128fb_putchar_aa(void *, int, int, u_int, long);
122 static void r128fb_copycols(void *, int, int, int, int);
123 static void r128fb_erasecols(void *, int, int, int, long);
124 static void r128fb_copyrows(void *, int, int, int);
125 static void r128fb_eraserows(void *, int, int, long);
126
127 static void r128fb_brightness_up(device_t);
128 static void r128fb_brightness_down(device_t);
129 /* set backlight level */
130 static void r128fb_set_backlight(struct r128fb_softc *, int);
131 /* turn backlight on and off without messing with the level */
132 static void r128fb_switch_backlight(struct r128fb_softc *, int);
133
134 struct wsdisplay_accessops r128fb_accessops = {
135 r128fb_ioctl,
136 r128fb_mmap,
137 NULL, /* alloc_screen */
138 NULL, /* free_screen */
139 NULL, /* show_screen */
140 NULL, /* load_font */
141 NULL, /* pollc */
142 NULL /* scroll */
143 };
144
145 static inline void
r128fb_wait(struct r128fb_softc * sc,int slots)146 r128fb_wait(struct r128fb_softc *sc, int slots)
147 {
148 uint32_t reg;
149
150 do {
151 reg = (bus_space_read_4(sc->sc_memt, sc->sc_regh,
152 R128_GUI_STAT) & R128_GUI_FIFOCNT_MASK);
153 } while (reg <= slots);
154 }
155
156 static void
r128fb_flush_engine(struct r128fb_softc * sc)157 r128fb_flush_engine(struct r128fb_softc *sc)
158 {
159 uint32_t reg;
160
161 reg = bus_space_read_4(sc->sc_memt, sc->sc_regh, R128_PC_NGUI_CTLSTAT);
162 reg |= R128_PC_FLUSH_ALL;
163 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_PC_NGUI_CTLSTAT, reg);
164 do {
165 reg = bus_space_read_4(sc->sc_memt, sc->sc_regh,
166 R128_PC_NGUI_CTLSTAT);
167 } while (reg & R128_PC_BUSY);
168 }
169
170 static int
r128fb_match(device_t parent,cfdata_t match,void * aux)171 r128fb_match(device_t parent, cfdata_t match, void *aux)
172 {
173 struct pci_attach_args *pa = (struct pci_attach_args *)aux;
174
175 if (PCI_CLASS(pa->pa_class) != PCI_CLASS_DISPLAY)
176 return 0;
177 if (PCI_VENDOR(pa->pa_id) != PCI_VENDOR_ATI)
178 return 0;
179
180 /* only cards tested on so far - likely need a list */
181 if ((PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_ATI_RAGE1AGP4XT) ||
182 (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_ATI_RAGE3AGP4XT) ||
183 (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_ATI_RAGEGLPCI) ||
184 (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_ATI_RAGE_MOB_M3_AGP))
185 return 100;
186 return (0);
187 }
188
189 static void
r128fb_attach(device_t parent,device_t self,void * aux)190 r128fb_attach(device_t parent, device_t self, void *aux)
191 {
192 struct r128fb_softc *sc = device_private(self);
193 struct pci_attach_args *pa = aux;
194 struct rasops_info *ri;
195 bus_space_tag_t tag;
196 struct wsemuldisplaydev_attach_args aa;
197 prop_dictionary_t dict;
198 unsigned long defattr;
199 bool is_console = FALSE;
200 int i, j;
201 uint32_t reg, flags;
202 uint8_t cmap[768];
203
204 sc->sc_pc = pa->pa_pc;
205 sc->sc_pcitag = pa->pa_tag;
206 sc->sc_memt = pa->pa_memt;
207 sc->sc_iot = pa->pa_iot;
208 sc->sc_dev = self;
209
210 pci_aprint_devinfo(pa, NULL);
211
212 /* fill in parameters from properties */
213 dict = device_properties(self);
214 if (!prop_dictionary_get_uint32(dict, "width", &sc->sc_width)) {
215 aprint_error("%s: no width property\n", device_xname(self));
216 return;
217 }
218 if (!prop_dictionary_get_uint32(dict, "height", &sc->sc_height)) {
219 aprint_error("%s: no height property\n", device_xname(self));
220 return;
221 }
222
223 #ifdef GLYPHCACHE_DEBUG
224 /* leave some visible VRAM unused so we can see the glyph cache */
225 sc->sc_height -= 200;
226 #endif
227
228 if (!prop_dictionary_get_uint32(dict, "depth", &sc->sc_depth)) {
229 aprint_error("%s: no depth property\n", device_xname(self));
230 return;
231 }
232 if (!prop_dictionary_get_uint32(dict, "linebytes", &sc->sc_stride)) {
233 aprint_error("%s: no linebytes property\n",
234 device_xname(self));
235 return;
236 }
237
238 prop_dictionary_get_bool(dict, "is_console", &is_console);
239
240 if (pci_mapreg_info(pa->pa_pc, pa->pa_tag, 0x10, PCI_MAPREG_TYPE_MEM,
241 &sc->sc_fb, &sc->sc_fbsize, &flags)) {
242 aprint_error("%s: failed to map the frame buffer.\n",
243 device_xname(sc->sc_dev));
244 }
245
246 if (pci_mapreg_map(pa, 0x18, PCI_MAPREG_TYPE_MEM, 0,
247 &tag, &sc->sc_regh, &sc->sc_reg, &sc->sc_regsize)) {
248 aprint_error("%s: failed to map registers.\n",
249 device_xname(sc->sc_dev));
250 }
251
252 aprint_normal("%s: %d MB aperture at 0x%08x\n", device_xname(self),
253 (int)(sc->sc_fbsize >> 20), (uint32_t)sc->sc_fb);
254
255 sc->sc_defaultscreen_descr = (struct wsscreen_descr){
256 "default",
257 0, 0,
258 NULL,
259 8, 16,
260 WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_UNDERLINE |
261 WSSCREEN_RESIZE,
262 NULL
263 };
264 sc->sc_screens[0] = &sc->sc_defaultscreen_descr;
265 sc->sc_screenlist = (struct wsscreen_list){1, sc->sc_screens};
266 sc->sc_mode = WSDISPLAYIO_MODE_EMUL;
267 sc->sc_locked = 0;
268
269 vcons_init(&sc->vd, sc, &sc->sc_defaultscreen_descr,
270 &r128fb_accessops);
271 sc->vd.init_screen = r128fb_init_screen;
272 sc->vd.show_screen_cookie = &sc->sc_gc;
273 sc->vd.show_screen_cb = glyphcache_adapt;
274
275 /* init engine here */
276 r128fb_init(sc);
277
278 ri = &sc->sc_console_screen.scr_ri;
279
280 sc->sc_gc.gc_bitblt = r128fb_bitblt;
281 sc->sc_gc.gc_blitcookie = sc;
282 sc->sc_gc.gc_rop = R128_ROP3_S;
283 if (is_console) {
284 vcons_init_screen(&sc->vd, &sc->sc_console_screen, 1,
285 &defattr);
286 sc->sc_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC;
287
288 r128fb_rectfill(sc, 0, 0, sc->sc_width, sc->sc_height,
289 ri->ri_devcmap[(defattr >> 16) & 0xff]);
290 sc->sc_defaultscreen_descr.textops = &ri->ri_ops;
291 sc->sc_defaultscreen_descr.capabilities = ri->ri_caps;
292 sc->sc_defaultscreen_descr.nrows = ri->ri_rows;
293 sc->sc_defaultscreen_descr.ncols = ri->ri_cols;
294 glyphcache_init(&sc->sc_gc, sc->sc_height + 5,
295 (0x800000 / sc->sc_stride) - sc->sc_height - 5,
296 sc->sc_width,
297 ri->ri_font->fontwidth,
298 ri->ri_font->fontheight,
299 defattr);
300 wsdisplay_cnattach(&sc->sc_defaultscreen_descr, ri, 0, 0,
301 defattr);
302 vcons_replay_msgbuf(&sc->sc_console_screen);
303 } else {
304 /*
305 * since we're not the console we can postpone the rest
306 * until someone actually allocates a screen for us
307 */
308 if (sc->sc_console_screen.scr_ri.ri_rows == 0) {
309 /* do some minimal setup to avoid weirdnesses later */
310 vcons_init_screen(&sc->vd, &sc->sc_console_screen, 1,
311 &defattr);
312 } else
313 (*ri->ri_ops.allocattr)(ri, 0, 0, 0, &defattr);
314 glyphcache_init(&sc->sc_gc, sc->sc_height + 5,
315 (0x800000 / sc->sc_stride) - sc->sc_height - 5,
316 sc->sc_width,
317 ri->ri_font->fontwidth,
318 ri->ri_font->fontheight,
319 defattr);
320 }
321
322 j = 0;
323 rasops_get_cmap(ri, cmap, sizeof(cmap));
324 for (i = 0; i < 256; i++) {
325 sc->sc_cmap_red[i] = cmap[j];
326 sc->sc_cmap_green[i] = cmap[j + 1];
327 sc->sc_cmap_blue[i] = cmap[j + 2];
328 r128fb_putpalreg(sc, i, cmap[j], cmap[j + 1], cmap[j + 2]);
329 j += 3;
330 }
331
332 /* no suspend/resume support yet */
333 if (!pmf_device_register(sc->sc_dev, NULL, NULL))
334 aprint_error_dev(sc->sc_dev,
335 "couldn't establish power handler\n");
336
337 reg = bus_space_read_4(sc->sc_memt, sc->sc_regh, R128_LVDS_GEN_CNTL);
338 DPRINTF("R128_LVDS_GEN_CNTL: %08x\n", reg);
339 if (reg & R128_LVDS_ON) {
340 sc->sc_have_backlight = 1;
341 sc->sc_bl_on = 1;
342 sc->sc_bl_level = 255 -
343 ((reg & R128_LEVEL_MASK) >> R128_LEVEL_SHIFT);
344 pmf_event_register(sc->sc_dev, PMFE_DISPLAY_BRIGHTNESS_UP,
345 r128fb_brightness_up, TRUE);
346 pmf_event_register(sc->sc_dev, PMFE_DISPLAY_BRIGHTNESS_DOWN,
347 r128fb_brightness_down, TRUE);
348 aprint_verbose("%s: LVDS output is active, enabling backlight"
349 " control\n", device_xname(self));
350 } else
351 sc->sc_have_backlight = 0;
352
353 aa.console = is_console;
354 aa.scrdata = &sc->sc_screenlist;
355 aa.accessops = &r128fb_accessops;
356 aa.accesscookie = &sc->vd;
357
358 config_found(sc->sc_dev, &aa, wsemuldisplaydevprint, CFARGS_NONE);
359 }
360
361 static int
r128fb_ioctl(void * v,void * vs,u_long cmd,void * data,int flag,struct lwp * l)362 r128fb_ioctl(void *v, void *vs, u_long cmd, void *data, int flag,
363 struct lwp *l)
364 {
365 struct vcons_data *vd = v;
366 struct r128fb_softc *sc = vd->cookie;
367 struct wsdisplay_fbinfo *wdf;
368 struct vcons_screen *ms = vd->active;
369 struct wsdisplay_param *param;
370
371 switch (cmd) {
372 case WSDISPLAYIO_GTYPE:
373 *(u_int *)data = WSDISPLAY_TYPE_PCIMISC;
374 return 0;
375
376 /* PCI config read/write passthrough. */
377 case PCI_IOC_CFGREAD:
378 case PCI_IOC_CFGWRITE:
379 return pci_devioctl(sc->sc_pc, sc->sc_pcitag,
380 cmd, data, flag, l);
381
382 case WSDISPLAYIO_GET_BUSID:
383 return wsdisplayio_busid_pci(sc->sc_dev, sc->sc_pc,
384 sc->sc_pcitag, data);
385
386 case WSDISPLAYIO_GINFO:
387 if (ms == NULL)
388 return ENODEV;
389 wdf = (void *)data;
390 wdf->height = ms->scr_ri.ri_height;
391 wdf->width = ms->scr_ri.ri_width;
392 wdf->depth = ms->scr_ri.ri_depth;
393 wdf->cmsize = 256;
394 return 0;
395
396 case WSDISPLAYIO_GETCMAP:
397 return r128fb_getcmap(sc,
398 (struct wsdisplay_cmap *)data);
399
400 case WSDISPLAYIO_PUTCMAP:
401 return r128fb_putcmap(sc,
402 (struct wsdisplay_cmap *)data);
403
404 case WSDISPLAYIO_LINEBYTES:
405 *(u_int *)data = sc->sc_stride;
406 return 0;
407
408 case WSDISPLAYIO_SMODE: {
409 int new_mode = *(int*)data;
410 if (new_mode != sc->sc_mode) {
411 sc->sc_mode = new_mode;
412 if(new_mode == WSDISPLAYIO_MODE_EMUL) {
413 r128fb_init(sc);
414 r128fb_restore_palette(sc);
415 glyphcache_wipe(&sc->sc_gc);
416 r128fb_rectfill(sc, 0, 0, sc->sc_width,
417 sc->sc_height, ms->scr_ri.ri_devcmap[
418 (ms->scr_defattr >> 16) & 0xff]);
419 vcons_redraw_screen(ms);
420 }
421 }
422 }
423 return 0;
424
425 case WSDISPLAYIO_GETPARAM:
426 param = (struct wsdisplay_param *)data;
427 if (sc->sc_have_backlight == 0)
428 return EPASSTHROUGH;
429 switch (param->param) {
430 case WSDISPLAYIO_PARAM_BRIGHTNESS:
431 param->min = 0;
432 param->max = 255;
433 param->curval = sc->sc_bl_level;
434 return 0;
435 case WSDISPLAYIO_PARAM_BACKLIGHT:
436 param->min = 0;
437 param->max = 1;
438 param->curval = sc->sc_bl_on;
439 return 0;
440 }
441 return EPASSTHROUGH;
442
443 case WSDISPLAYIO_SETPARAM:
444 param = (struct wsdisplay_param *)data;
445 if (sc->sc_have_backlight == 0)
446 return EPASSTHROUGH;
447 switch (param->param) {
448 case WSDISPLAYIO_PARAM_BRIGHTNESS:
449 r128fb_set_backlight(sc, param->curval);
450 return 0;
451 case WSDISPLAYIO_PARAM_BACKLIGHT:
452 r128fb_switch_backlight(sc, param->curval);
453 return 0;
454 }
455 return EPASSTHROUGH;
456
457 case WSDISPLAYIO_GET_EDID: {
458 struct wsdisplayio_edid_info *d = data;
459 return wsdisplayio_get_edid(sc->sc_dev, d);
460 }
461
462 case WSDISPLAYIO_GET_FBINFO:
463 {
464 struct wsdisplayio_fbinfo *fbi = data;
465
466 return wsdisplayio_get_fbinfo(&ms->scr_ri, fbi);
467 }
468 }
469 return EPASSTHROUGH;
470 }
471
472 static paddr_t
r128fb_mmap(void * v,void * vs,off_t offset,int prot)473 r128fb_mmap(void *v, void *vs, off_t offset, int prot)
474 {
475 struct vcons_data *vd = v;
476 struct r128fb_softc *sc = vd->cookie;
477 paddr_t pa;
478
479 /* 'regular' framebuffer mmap()ing */
480 if (offset < sc->sc_fbsize) {
481 pa = bus_space_mmap(sc->sc_memt, sc->sc_fb + offset, 0, prot,
482 BUS_SPACE_MAP_LINEAR);
483 return pa;
484 }
485
486 /*
487 * restrict all other mappings to processes with superuser privileges
488 * or the kernel itself
489 */
490 if (kauth_authorize_machdep(kauth_cred_get(), KAUTH_MACHDEP_UNMANAGEDMEM,
491 NULL, NULL, NULL, NULL) != 0) {
492 aprint_normal("%s: mmap() rejected.\n",
493 device_xname(sc->sc_dev));
494 return -1;
495 }
496
497 if ((offset >= sc->sc_fb) && (offset < (sc->sc_fb + sc->sc_fbsize))) {
498 pa = bus_space_mmap(sc->sc_memt, offset, 0, prot,
499 BUS_SPACE_MAP_LINEAR);
500 return pa;
501 }
502
503 if ((offset >= sc->sc_reg) &&
504 (offset < (sc->sc_reg + sc->sc_regsize))) {
505 pa = bus_space_mmap(sc->sc_memt, offset, 0, prot,
506 BUS_SPACE_MAP_LINEAR);
507 return pa;
508 }
509
510 #ifdef PCI_MAGIC_IO_RANGE
511 /* allow mapping of IO space */
512 if ((offset >= PCI_MAGIC_IO_RANGE) &&
513 (offset < PCI_MAGIC_IO_RANGE + 0x10000)) {
514 pa = bus_space_mmap(sc->sc_iot, offset - PCI_MAGIC_IO_RANGE,
515 0, prot, BUS_SPACE_MAP_LINEAR);
516 return pa;
517 }
518 #endif
519
520 #ifdef OFB_ALLOW_OTHERS
521 if (offset >= 0x80000000) {
522 pa = bus_space_mmap(sc->sc_memt, offset, 0, prot,
523 BUS_SPACE_MAP_LINEAR);
524 return pa;
525 }
526 #endif
527 return -1;
528 }
529
530 static void
r128fb_init_screen(void * cookie,struct vcons_screen * scr,int existing,long * defattr)531 r128fb_init_screen(void *cookie, struct vcons_screen *scr,
532 int existing, long *defattr)
533 {
534 struct r128fb_softc *sc = cookie;
535 struct rasops_info *ri = &scr->scr_ri;
536
537 ri->ri_depth = sc->sc_depth;
538 ri->ri_width = sc->sc_width;
539 ri->ri_height = sc->sc_height;
540 ri->ri_stride = sc->sc_stride;
541 ri->ri_flg = RI_CENTER;
542 if (sc->sc_depth == 8)
543 ri->ri_flg |= RI_8BIT_IS_RGB | RI_ENABLE_ALPHA |
544 RI_PREFER_ALPHA;
545
546 rasops_init(ri, 0, 0);
547 ri->ri_caps = WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_UNDERLINE |
548 WSSCREEN_RESIZE;
549 #ifdef VCONS_DRAW_INTR
550 scr->scr_flags |= VCONS_DONT_READ;
551 #endif
552 scr->scr_flags |= VCONS_LOADFONT;
553
554 rasops_reconfig(ri, sc->sc_height / ri->ri_font->fontheight,
555 sc->sc_width / ri->ri_font->fontwidth);
556
557 ri->ri_hw = scr;
558 ri->ri_ops.copyrows = r128fb_copyrows;
559 ri->ri_ops.copycols = r128fb_copycols;
560 ri->ri_ops.eraserows = r128fb_eraserows;
561 ri->ri_ops.erasecols = r128fb_erasecols;
562 ri->ri_ops.cursor = r128fb_cursor;
563 if (FONT_IS_ALPHA(ri->ri_font)) {
564 ri->ri_ops.putchar = r128fb_putchar_aa;
565 } else
566 ri->ri_ops.putchar = r128fb_putchar;
567 }
568
569 static int
r128fb_putcmap(struct r128fb_softc * sc,struct wsdisplay_cmap * cm)570 r128fb_putcmap(struct r128fb_softc *sc, struct wsdisplay_cmap *cm)
571 {
572 u_char *r, *g, *b;
573 u_int index = cm->index;
574 u_int count = cm->count;
575 int i, error;
576 u_char rbuf[256], gbuf[256], bbuf[256];
577
578 #ifdef R128FB_DEBUG
579 aprint_debug("putcmap: %d %d\n",index, count);
580 #endif
581 if (cm->index >= 256 || cm->count > 256 ||
582 (cm->index + cm->count) > 256)
583 return EINVAL;
584 error = copyin(cm->red, &rbuf[index], count);
585 if (error)
586 return error;
587 error = copyin(cm->green, &gbuf[index], count);
588 if (error)
589 return error;
590 error = copyin(cm->blue, &bbuf[index], count);
591 if (error)
592 return error;
593
594 memcpy(&sc->sc_cmap_red[index], &rbuf[index], count);
595 memcpy(&sc->sc_cmap_green[index], &gbuf[index], count);
596 memcpy(&sc->sc_cmap_blue[index], &bbuf[index], count);
597
598 r = &sc->sc_cmap_red[index];
599 g = &sc->sc_cmap_green[index];
600 b = &sc->sc_cmap_blue[index];
601
602 for (i = 0; i < count; i++) {
603 r128fb_putpalreg(sc, index, *r, *g, *b);
604 index++;
605 r++, g++, b++;
606 }
607 return 0;
608 }
609
610 static int
r128fb_getcmap(struct r128fb_softc * sc,struct wsdisplay_cmap * cm)611 r128fb_getcmap(struct r128fb_softc *sc, struct wsdisplay_cmap *cm)
612 {
613 u_int index = cm->index;
614 u_int count = cm->count;
615 int error;
616
617 if (index >= 255 || count > 256 || index + count > 256)
618 return EINVAL;
619
620 error = copyout(&sc->sc_cmap_red[index], cm->red, count);
621 if (error)
622 return error;
623 error = copyout(&sc->sc_cmap_green[index], cm->green, count);
624 if (error)
625 return error;
626 error = copyout(&sc->sc_cmap_blue[index], cm->blue, count);
627 if (error)
628 return error;
629
630 return 0;
631 }
632
633 static void
r128fb_restore_palette(struct r128fb_softc * sc)634 r128fb_restore_palette(struct r128fb_softc *sc)
635 {
636 int i;
637
638 for (i = 0; i < (1 << sc->sc_depth); i++) {
639 r128fb_putpalreg(sc, i, sc->sc_cmap_red[i],
640 sc->sc_cmap_green[i], sc->sc_cmap_blue[i]);
641 }
642 }
643
644 static int
r128fb_putpalreg(struct r128fb_softc * sc,uint8_t idx,uint8_t r,uint8_t g,uint8_t b)645 r128fb_putpalreg(struct r128fb_softc *sc, uint8_t idx, uint8_t r, uint8_t g,
646 uint8_t b)
647 {
648 uint32_t reg;
649
650 /* whack the DAC */
651 reg = (r << 16) | (g << 8) | b;
652 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_PALETTE_INDEX, idx);
653 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_PALETTE_DATA, reg);
654 return 0;
655 }
656
657 static void
r128fb_init(struct r128fb_softc * sc)658 r128fb_init(struct r128fb_softc *sc)
659 {
660 uint32_t datatype, d, reg;
661
662 r128fb_flush_engine(sc);
663
664 r128fb_wait(sc, 9);
665 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_CRTC_OFFSET, 0);
666 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DEFAULT_OFFSET, 0);
667 /* pitch is in units of 8 pixels */
668 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DEFAULT_PITCH,
669 sc->sc_width >> 3);
670 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_AUX_SC_CNTL, 0);
671 bus_space_write_4(sc->sc_memt, sc->sc_regh,
672 R128_DEFAULT_SC_BOTTOM_RIGHT,
673 R128_DEFAULT_SC_RIGHT_MAX | R128_DEFAULT_SC_BOTTOM_MAX);
674 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_SC_TOP_LEFT, 0);
675 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_SC_BOTTOM_RIGHT,
676 R128_DEFAULT_SC_RIGHT_MAX | R128_DEFAULT_SC_BOTTOM_MAX);
677 bus_space_write_4(sc->sc_memt, sc->sc_regh,
678 R128_DEFAULT_SC_BOTTOM_RIGHT,
679 R128_DEFAULT_SC_RIGHT_MAX | R128_DEFAULT_SC_BOTTOM_MAX);
680
681 #if 0
682 #if BYTE_ORDER == BIG_ENDIAN
683 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DP_DATATYPE,
684 R128_HOST_BIG_ENDIAN_EN);
685 #else
686 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DP_DATATYPE, 0);
687 #endif
688 #endif
689 r128fb_wait(sc, 7);
690 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_SRC_PITCH,
691 sc->sc_width >> 3);
692 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DST_PITCH,
693 sc->sc_width >> 3);
694 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_SRC_OFFSET, 0);
695 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DST_OFFSET, 0);
696 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DP_WRITE_MASK,
697 0xffffffff);
698
699 switch (sc->sc_depth) {
700 case 8:
701 datatype = R128_GMC_DST_8BPP_CI;
702 d = R128_CRTC_COLOR_8BIT;
703 break;
704 case 15:
705 datatype = R128_GMC_DST_15BPP;
706 d = R128_CRTC_COLOR_15BIT;
707 break;
708 case 16:
709 datatype = R128_GMC_DST_16BPP;
710 d = R128_CRTC_COLOR_16BIT;
711 break;
712 case 24:
713 datatype = R128_GMC_DST_24BPP;
714 d = R128_CRTC_COLOR_24BIT;
715 break;
716 case 32:
717 datatype = R128_GMC_DST_32BPP;
718 d = R128_CRTC_COLOR_32BIT;
719 break;
720 default:
721 aprint_error("%s: unsupported depth %d\n",
722 device_xname(sc->sc_dev), sc->sc_depth);
723 return;
724 }
725 sc->sc_master_cntl = R128_GMC_CLR_CMP_CNTL_DIS |
726 R128_GMC_AUX_CLIP_DIS | datatype;
727 reg = bus_space_read_4(sc->sc_memt, sc->sc_regh, R128_CRTC_GEN_CNTL);
728 DPRINTF("depth: %d\n", reg & R128_CRTC_PIX_WIDTH);
729 reg &= ~R128_CRTC_PIX_WIDTH;
730 reg |= d;
731 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_CRTC_GEN_CNTL, reg);
732 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_CRTC_PITCH, sc->sc_width >> 3);
733 r128fb_flush_engine(sc);
734 }
735
736 static void
r128fb_rectfill(struct r128fb_softc * sc,int x,int y,int wi,int he,uint32_t colour)737 r128fb_rectfill(struct r128fb_softc *sc, int x, int y, int wi, int he,
738 uint32_t colour)
739 {
740
741 r128fb_wait(sc, 5);
742 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DP_GUI_MASTER_CNTL,
743 R128_GMC_BRUSH_SOLID_COLOR |
744 R128_GMC_SRC_DATATYPE_COLOR |
745 R128_ROP3_P |
746 sc->sc_master_cntl);
747
748 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DP_BRUSH_FRGD_CLR,
749 colour);
750 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DP_CNTL,
751 R128_DST_X_LEFT_TO_RIGHT | R128_DST_Y_TOP_TO_BOTTOM);
752 /* now feed it coordinates */
753 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DST_X_Y,
754 (x << 16) | y);
755 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DST_WIDTH_HEIGHT,
756 (wi << 16) | he);
757 }
758
759 static void
r128fb_bitblt(void * cookie,int xs,int ys,int xd,int yd,int wi,int he,int rop)760 r128fb_bitblt(void *cookie, int xs, int ys, int xd, int yd,
761 int wi, int he, int rop)
762 {
763 struct r128fb_softc *sc = cookie;
764 uint32_t dp_cntl = 0;
765
766 r128fb_wait(sc, 5);
767 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DP_GUI_MASTER_CNTL,
768 R128_GMC_BRUSH_SOLID_COLOR |
769 R128_GMC_SRC_DATATYPE_COLOR |
770 rop |
771 R128_DP_SRC_SOURCE_MEMORY |
772 sc->sc_master_cntl);
773
774 if (yd <= ys) {
775 dp_cntl = R128_DST_Y_TOP_TO_BOTTOM;
776 } else {
777 ys += he - 1;
778 yd += he - 1;
779 }
780 if (xd <= xs) {
781 dp_cntl |= R128_DST_X_LEFT_TO_RIGHT;
782 } else {
783 xs += wi - 1;
784 xd += wi - 1;
785 }
786 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DP_CNTL, dp_cntl);
787
788 /* now feed it coordinates */
789 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_SRC_X_Y,
790 (xs << 16) | ys);
791 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DST_X_Y,
792 (xd << 16) | yd);
793 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DST_WIDTH_HEIGHT,
794 (wi << 16) | he);
795 }
796
797 static void
r128fb_cursor(void * cookie,int on,int row,int col)798 r128fb_cursor(void *cookie, int on, int row, int col)
799 {
800 struct rasops_info *ri = cookie;
801 struct vcons_screen *scr = ri->ri_hw;
802 struct r128fb_softc *sc = scr->scr_cookie;
803 int x, y, wi, he;
804
805 wi = ri->ri_font->fontwidth;
806 he = ri->ri_font->fontheight;
807
808 if (sc->sc_mode == WSDISPLAYIO_MODE_EMUL) {
809 if (ri->ri_flg & RI_CURSOR) {
810 x = ri->ri_ccol * wi + ri->ri_xorigin;
811 y = ri->ri_crow * he + ri->ri_yorigin;
812 r128fb_bitblt(sc, x, y, x, y, wi, he, R128_ROP3_Dn);
813 ri->ri_flg &= ~RI_CURSOR;
814 }
815 ri->ri_crow = row;
816 ri->ri_ccol = col;
817 if (on) {
818 x = ri->ri_ccol * wi + ri->ri_xorigin;
819 y = ri->ri_crow * he + ri->ri_yorigin;
820 r128fb_bitblt(sc, x, y, x, y, wi, he, R128_ROP3_Dn);
821 ri->ri_flg |= RI_CURSOR;
822 }
823 } else {
824 scr->scr_ri.ri_crow = row;
825 scr->scr_ri.ri_ccol = col;
826 scr->scr_ri.ri_flg &= ~RI_CURSOR;
827 }
828
829 }
830
831 static void
r128fb_putchar(void * cookie,int row,int col,u_int c,long attr)832 r128fb_putchar(void *cookie, int row, int col, u_int c, long attr)
833 {
834 struct rasops_info *ri = cookie;
835 struct wsdisplay_font *font = PICK_FONT(ri, c);
836 struct vcons_screen *scr = ri->ri_hw;
837 struct r128fb_softc *sc = scr->scr_cookie;
838 void *data;
839 uint32_t fg, bg;
840 int i, x, y, wi, he, offset;
841
842 if (sc->sc_mode != WSDISPLAYIO_MODE_EMUL)
843 return;
844
845 if (!CHAR_IN_FONT(c, font))
846 return;
847
848 wi = font->fontwidth;
849 he = font->fontheight;
850
851 bg = ri->ri_devcmap[(attr >> 16) & 0xf];
852 fg = ri->ri_devcmap[(attr >> 24) & 0xf];
853 x = ri->ri_xorigin + col * wi;
854 y = ri->ri_yorigin + row * he;
855
856 if (c == 0x20) {
857 r128fb_rectfill(sc, x, y, wi, he, bg);
858 return;
859 }
860
861 data = WSFONT_GLYPH(c, font);
862
863 r128fb_wait(sc, 8);
864
865 bus_space_write_4(sc->sc_memt, sc->sc_regh,
866 R128_DP_GUI_MASTER_CNTL,
867 R128_GMC_BRUSH_SOLID_COLOR |
868 R128_GMC_SRC_DATATYPE_MONO_FG_BG |
869 R128_ROP3_S |
870 R128_DP_SRC_SOURCE_HOST_DATA |
871 R128_GMC_DST_CLIPPING |
872 sc->sc_master_cntl);
873
874 bus_space_write_4(sc->sc_memt, sc->sc_regh,
875 R128_DP_CNTL,
876 R128_DST_Y_TOP_TO_BOTTOM |
877 R128_DST_X_LEFT_TO_RIGHT);
878
879 bus_space_write_4(sc->sc_memt, sc->sc_regh,
880 R128_DP_SRC_FRGD_CLR, fg);
881 bus_space_write_4(sc->sc_memt, sc->sc_regh,
882 R128_DP_SRC_BKGD_CLR, bg);
883
884 /*
885 * The Rage 128 doesn't have anything to skip pixels
886 * when colour expanding but all coordinates
887 * are signed so we just clip the leading bytes and
888 * trailing bits away
889 */
890 bus_space_write_4(sc->sc_memt, sc->sc_regh,
891 R128_SC_RIGHT, x + wi - 1);
892 bus_space_write_4(sc->sc_memt, sc->sc_regh,
893 R128_SC_LEFT, x);
894
895 /* needed? */
896 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_SRC_X_Y, 0);
897
898 offset = 32 - (font->stride << 3);
899 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DST_X_Y,
900 ((x - offset) << 16) | y);
901 bus_space_write_4(sc->sc_memt, sc->sc_regh,
902 R128_DST_WIDTH_HEIGHT, (32 << 16) | he);
903
904 r128fb_wait(sc, he);
905 switch (font->stride) {
906 case 1: {
907 uint8_t *data8 = data;
908 uint32_t reg;
909 for (i = 0; i < he; i++) {
910 reg = *data8;
911 bus_space_write_stream_4(sc->sc_memt,
912 sc->sc_regh, R128_HOST_DATA0, reg);
913 data8++;
914 }
915 break;
916 }
917 case 2: {
918 uint16_t *data16 = data;
919 uint32_t reg;
920 for (i = 0; i < he; i++) {
921 reg = *data16;
922 bus_space_write_stream_4(sc->sc_memt,
923 sc->sc_regh, R128_HOST_DATA0, reg);
924 data16++;
925 }
926 break;
927 }
928 }
929 }
930
931 static void
r128fb_putchar_aa(void * cookie,int row,int col,u_int c,long attr)932 r128fb_putchar_aa(void *cookie, int row, int col, u_int c, long attr)
933 {
934 struct rasops_info *ri = cookie;
935 struct wsdisplay_font *font = PICK_FONT(ri, c);
936 struct vcons_screen *scr = ri->ri_hw;
937 struct r128fb_softc *sc = scr->scr_cookie;
938 uint32_t bg, latch = 0, bg8, fg8, pixel;
939 int i, x, y, wi, he, r, g, b, aval;
940 int r1, g1, b1, r0, g0, b0, fgo, bgo;
941 uint8_t *data8;
942 int rv, cnt = 0;
943
944 if (sc->sc_mode != WSDISPLAYIO_MODE_EMUL)
945 return;
946
947 if (!CHAR_IN_FONT(c, font))
948 return;
949
950 wi = font->fontwidth;
951 he = font->fontheight;
952
953 bg = ri->ri_devcmap[(attr >> 16) & 0xf];
954 x = ri->ri_xorigin + col * wi;
955 y = ri->ri_yorigin + row * he;
956 if (c == 0x20) {
957 r128fb_rectfill(sc, x, y, wi, he, bg);
958 return;
959 }
960
961 rv = glyphcache_try(&sc->sc_gc, c, x, y, attr);
962 if (rv == GC_OK)
963 return;
964
965 data8 = WSFONT_GLYPH(c, font);
966
967 r128fb_wait(sc, 5);
968 bus_space_write_4(sc->sc_memt, sc->sc_regh,
969 R128_DP_GUI_MASTER_CNTL,
970 R128_GMC_BRUSH_SOLID_COLOR |
971 R128_GMC_SRC_DATATYPE_COLOR |
972 R128_ROP3_S |
973 R128_DP_SRC_SOURCE_HOST_DATA |
974 sc->sc_master_cntl);
975
976 bus_space_write_4(sc->sc_memt, sc->sc_regh,
977 R128_DP_CNTL,
978 R128_DST_Y_TOP_TO_BOTTOM |
979 R128_DST_X_LEFT_TO_RIGHT);
980
981 /* needed? */
982 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_SRC_X_Y, 0);
983 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DST_X_Y,
984 (x << 16) | y);
985 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_DST_WIDTH_HEIGHT,
986 (wi << 16) | he);
987
988 /*
989 * we need the RGB colours here, so get offsets into rasops_cmap
990 */
991 fgo = ((attr >> 24) & 0xf) * 3;
992 bgo = ((attr >> 16) & 0xf) * 3;
993
994 r0 = rasops_cmap[bgo];
995 r1 = rasops_cmap[fgo];
996 g0 = rasops_cmap[bgo + 1];
997 g1 = rasops_cmap[fgo + 1];
998 b0 = rasops_cmap[bgo + 2];
999 b1 = rasops_cmap[fgo + 2];
1000 #define R3G3B2(r, g, b) ((r & 0xe0) | ((g >> 3) & 0x1c) | (b >> 6))
1001 bg8 = R3G3B2(r0, g0, b0);
1002 fg8 = R3G3B2(r1, g1, b1);
1003
1004 r128fb_wait(sc, 16);
1005
1006 for (i = 0; i < ri->ri_fontscale; i++) {
1007 aval = *data8;
1008 if (aval == 0) {
1009 pixel = bg8;
1010 } else if (aval == 255) {
1011 pixel = fg8;
1012 } else {
1013 r = aval * r1 + (255 - aval) * r0;
1014 g = aval * g1 + (255 - aval) * g0;
1015 b = aval * b1 + (255 - aval) * b0;
1016 pixel = ((r & 0xe000) >> 8) |
1017 ((g & 0xe000) >> 11) |
1018 ((b & 0xc000) >> 14);
1019 }
1020 latch = (latch << 8) | pixel;
1021 /* write in 32bit chunks */
1022 if ((i & 3) == 3) {
1023 bus_space_write_stream_4(sc->sc_memt, sc->sc_regh,
1024 R128_HOST_DATA0, latch);
1025 /*
1026 * not strictly necessary, old data should be shifted
1027 * out
1028 */
1029 latch = 0;
1030 cnt++;
1031 if (cnt > 15) {
1032 r128fb_wait(sc, 16);
1033 cnt = 0;
1034 }
1035 }
1036 data8++;
1037 }
1038 /* if we have pixels left in latch write them out */
1039 if ((i & 3) != 0) {
1040 latch = latch << ((4 - (i & 3)) << 3);
1041 bus_space_write_stream_4(sc->sc_memt, sc->sc_regh,
1042 R128_HOST_DATA0, latch);
1043 }
1044 if (rv == GC_ADD) {
1045 glyphcache_add(&sc->sc_gc, c, x, y);
1046 }
1047 }
1048
1049 static void
r128fb_copycols(void * cookie,int row,int srccol,int dstcol,int ncols)1050 r128fb_copycols(void *cookie, int row, int srccol, int dstcol, int ncols)
1051 {
1052 struct rasops_info *ri = cookie;
1053 struct vcons_screen *scr = ri->ri_hw;
1054 struct r128fb_softc *sc = scr->scr_cookie;
1055 int32_t xs, xd, y, width, height;
1056
1057 if ((sc->sc_locked == 0) && (sc->sc_mode == WSDISPLAYIO_MODE_EMUL)) {
1058 xs = ri->ri_xorigin + ri->ri_font->fontwidth * srccol;
1059 xd = ri->ri_xorigin + ri->ri_font->fontwidth * dstcol;
1060 y = ri->ri_yorigin + ri->ri_font->fontheight * row;
1061 width = ri->ri_font->fontwidth * ncols;
1062 height = ri->ri_font->fontheight;
1063 r128fb_bitblt(sc, xs, y, xd, y, width, height, R128_ROP3_S);
1064 }
1065 }
1066
1067 static void
r128fb_erasecols(void * cookie,int row,int startcol,int ncols,long fillattr)1068 r128fb_erasecols(void *cookie, int row, int startcol, int ncols, long fillattr)
1069 {
1070 struct rasops_info *ri = cookie;
1071 struct vcons_screen *scr = ri->ri_hw;
1072 struct r128fb_softc *sc = scr->scr_cookie;
1073 int32_t x, y, width, height, fg, bg, ul;
1074
1075 if ((sc->sc_locked == 0) && (sc->sc_mode == WSDISPLAYIO_MODE_EMUL)) {
1076 x = ri->ri_xorigin + ri->ri_font->fontwidth * startcol;
1077 y = ri->ri_yorigin + ri->ri_font->fontheight * row;
1078 width = ri->ri_font->fontwidth * ncols;
1079 height = ri->ri_font->fontheight;
1080 rasops_unpack_attr(fillattr, &fg, &bg, &ul);
1081
1082 r128fb_rectfill(sc, x, y, width, height, ri->ri_devcmap[bg]);
1083 }
1084 }
1085
1086 static void
r128fb_copyrows(void * cookie,int srcrow,int dstrow,int nrows)1087 r128fb_copyrows(void *cookie, int srcrow, int dstrow, int nrows)
1088 {
1089 struct rasops_info *ri = cookie;
1090 struct vcons_screen *scr = ri->ri_hw;
1091 struct r128fb_softc *sc = scr->scr_cookie;
1092 int32_t x, ys, yd, width, height;
1093
1094 if ((sc->sc_locked == 0) && (sc->sc_mode == WSDISPLAYIO_MODE_EMUL)) {
1095 x = ri->ri_xorigin;
1096 ys = ri->ri_yorigin + ri->ri_font->fontheight * srcrow;
1097 yd = ri->ri_yorigin + ri->ri_font->fontheight * dstrow;
1098 width = ri->ri_emuwidth;
1099 height = ri->ri_font->fontheight * nrows;
1100 r128fb_bitblt(sc, x, ys, x, yd, width, height, R128_ROP3_S);
1101 }
1102 }
1103
1104 static void
r128fb_eraserows(void * cookie,int row,int nrows,long fillattr)1105 r128fb_eraserows(void *cookie, int row, int nrows, long fillattr)
1106 {
1107 struct rasops_info *ri = cookie;
1108 struct vcons_screen *scr = ri->ri_hw;
1109 struct r128fb_softc *sc = scr->scr_cookie;
1110 int32_t x, y, width, height, fg, bg, ul;
1111
1112 if ((sc->sc_locked == 0) && (sc->sc_mode == WSDISPLAYIO_MODE_EMUL)) {
1113 x = ri->ri_xorigin;
1114 y = ri->ri_yorigin + ri->ri_font->fontheight * row;
1115 width = ri->ri_emuwidth;
1116 height = ri->ri_font->fontheight * nrows;
1117 rasops_unpack_attr(fillattr, &fg, &bg, &ul);
1118
1119 r128fb_rectfill(sc, x, y, width, height, ri->ri_devcmap[bg]);
1120 }
1121 }
1122
1123 static void
r128fb_set_backlight(struct r128fb_softc * sc,int level)1124 r128fb_set_backlight(struct r128fb_softc *sc, int level)
1125 {
1126 uint32_t reg;
1127
1128 /*
1129 * should we do nothing when backlight is off, should we just store the
1130 * level and use it when turning back on or should we just flip sc_bl_on
1131 * and turn the backlight on?
1132 * For now turn it on so a crashed screensaver can't get the user stuck
1133 * with a dark screen as long as hotkeys work
1134 */
1135 if (level > 255) level = 255;
1136 if (level < 0) level = 0;
1137 if (level == sc->sc_bl_level)
1138 return;
1139 sc->sc_bl_level = level;
1140 if (sc->sc_bl_on == 0)
1141 sc->sc_bl_on = 1;
1142 level = 255 - level;
1143 reg = bus_space_read_4(sc->sc_memt, sc->sc_regh, R128_LVDS_GEN_CNTL);
1144 reg &= ~R128_LEVEL_MASK;
1145 reg |= (level << R128_LEVEL_SHIFT);
1146 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_LVDS_GEN_CNTL, reg);
1147 DPRINTF("backlight level: %d reg %08x\n", level, reg);
1148 }
1149
1150 static void
r128fb_switch_backlight(struct r128fb_softc * sc,int on)1151 r128fb_switch_backlight(struct r128fb_softc *sc, int on)
1152 {
1153 uint32_t reg;
1154 int level;
1155
1156 if (on == sc->sc_bl_on)
1157 return;
1158 sc->sc_bl_on = on;
1159 reg = bus_space_read_4(sc->sc_memt, sc->sc_regh, R128_LVDS_GEN_CNTL);
1160 reg &= ~R128_LEVEL_MASK;
1161 level = on ? 255 - sc->sc_bl_level : 255;
1162 reg |= level << R128_LEVEL_SHIFT;
1163 bus_space_write_4(sc->sc_memt, sc->sc_regh, R128_LVDS_GEN_CNTL, reg);
1164 DPRINTF("backlight state: %d reg %08x\n", on, reg);
1165 }
1166
1167
1168 static void
r128fb_brightness_up(device_t dev)1169 r128fb_brightness_up(device_t dev)
1170 {
1171 struct r128fb_softc *sc = device_private(dev);
1172
1173 r128fb_set_backlight(sc, sc->sc_bl_level + 8);
1174 }
1175
1176 static void
r128fb_brightness_down(device_t dev)1177 r128fb_brightness_down(device_t dev)
1178 {
1179 struct r128fb_softc *sc = device_private(dev);
1180
1181 r128fb_set_backlight(sc, sc->sc_bl_level - 8);
1182 }
1183