cgtwelve.c revision 1.3
1 /* $NetBSD: cgtwelve.c,v 1.3 2010/04/14 04:37:11 macallan Exp $ */ 2 3 /*- 4 * Copyright (c) 2010 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 NETBSD FOUNDATION, INC. AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 /* a console driver for the Sun CG12 / Matrox SG3 graphics board */ 30 31 #include <sys/cdefs.h> 32 __KERNEL_RCSID(0, "$NetBSD: cgtwelve.c,v 1.3 2010/04/14 04:37:11 macallan Exp $"); 33 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 #include <sys/buf.h> 37 #include <sys/device.h> 38 #include <sys/ioctl.h> 39 #include <sys/conf.h> 40 #include <sys/kmem.h> 41 42 #include <sys/bus.h> 43 #include <machine/autoconf.h> 44 45 #include <dev/sbus/sbusvar.h> 46 #include <dev/sun/fbio.h> 47 #include <dev/sun/fbvar.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 54 #include <dev/wscons/wsdisplay_vconsvar.h> 55 56 #include <dev/sbus/cgtwelvereg.h> 57 58 #include "opt_wsemul.h" 59 #include "opt_cgtwelve.h" 60 61 62 struct cgtwelve_softc { 63 device_t sc_dev; 64 bus_space_tag_t sc_tag; 65 bus_space_handle_t sc_regh; 66 bus_addr_t sc_paddr; 67 void *sc_fbaddr; 68 void *sc_shadow; 69 uint8_t *sc_wids; 70 void *sc_int; 71 int sc_width; 72 int sc_height; 73 int sc_stride; 74 int sc_fbsize; 75 int sc_mode; 76 struct vcons_data vd; 77 }; 78 79 static int cgtwelve_match(device_t, cfdata_t, void *); 80 static void cgtwelve_attach(device_t, device_t, void *); 81 static int cgtwelve_ioctl(void *, void *, u_long, void *, int, 82 struct lwp*); 83 static paddr_t cgtwelve_mmap(void *, void *, off_t, int); 84 static void cgtwelve_init_screen(void *, struct vcons_screen *, int, 85 long *); 86 static void cgtwelve_write_wid(struct cgtwelve_softc *, int, uint8_t); 87 static void cgtwelve_select_ovl(struct cgtwelve_softc *, int); 88 #define CG12_SEL_OVL 0 89 #define CG12_SEL_ENABLE 1 90 #define CG12_SEL_8BIT 2 91 #define CG12_SEL_24BIT 3 92 #define CG12_SEL_WID 4 93 static void cgtwelve_write_dac(struct cgtwelve_softc *, int, int, int, int); 94 static void cgtwelve_setup(struct cgtwelve_softc *, int); 95 96 CFATTACH_DECL_NEW(cgtwelve, sizeof(struct cgtwelve_softc), 97 cgtwelve_match, cgtwelve_attach, NULL, NULL); 98 99 struct wsscreen_descr cgtwelve_defscreendesc = { 100 "default", 101 0, 0, 102 NULL, 103 8, 16, 104 0, 105 }; 106 107 static struct vcons_screen cgtwelve_console_screen; 108 109 const struct wsscreen_descr *_cgtwelve_scrlist[] = { 110 &cgtwelve_defscreendesc, 111 /* XXX other formats, graphics screen? */ 112 }; 113 114 struct wsscreen_list cgtwelve_screenlist = { 115 sizeof(_cgtwelve_scrlist) / sizeof(struct wsscreen_descr *), 116 _cgtwelve_scrlist 117 }; 118 119 struct wsdisplay_accessops cgtwelve_accessops = { 120 cgtwelve_ioctl, 121 cgtwelve_mmap, 122 NULL, /* vcons_alloc_screen */ 123 NULL, /* vcons_free_screen */ 124 NULL, /* vcons_show_screen */ 125 NULL, /* load_font */ 126 NULL, /* polls */ 127 NULL, /* scroll */ 128 }; 129 130 static int 131 cgtwelve_match(device_t parent, cfdata_t cf, void *aux) 132 { 133 struct sbus_attach_args *sa = aux; 134 135 if (strcmp("cgtwelve", sa->sa_name) == 0) 136 return 100; 137 return 0; 138 } 139 140 /* 141 * Attach a display. We need to notice if it is the console, too. 142 */ 143 static void 144 cgtwelve_attach(device_t parent, device_t self, void *args) 145 { 146 struct cgtwelve_softc *sc = device_private(self); 147 struct sbus_attach_args *sa = args; 148 struct wsemuldisplaydev_attach_args aa; 149 struct rasops_info *ri; 150 unsigned long defattr; 151 bus_space_handle_t bh; 152 int node = sa->sa_node; 153 int isconsole; 154 155 aprint_normal("\n"); 156 sc->sc_dev = self; 157 sc->sc_tag = sa->sa_bustag; 158 159 sc->sc_paddr = sbus_bus_addr(sa->sa_bustag, sa->sa_slot, sa->sa_offset); 160 161 /* read geometry information from the device tree */ 162 sc->sc_width = prom_getpropint(sa->sa_node, "width", 1152); 163 sc->sc_height = prom_getpropint(sa->sa_node, "height", 900); 164 sc->sc_stride = (sc->sc_width + 7) >> 3; 165 166 sc->sc_fbsize = sc->sc_height * sc->sc_stride; 167 sc->sc_fbaddr = (void *)prom_getpropint(sa->sa_node, "address", 0); 168 if (sc->sc_fbaddr == NULL) { 169 if (sbus_bus_map(sa->sa_bustag, 170 sa->sa_slot, 171 sa->sa_offset + CG12_FB_MONO, 172 sc->sc_fbsize, 173 BUS_SPACE_MAP_LINEAR, &bh) != 0) { 174 aprint_error_dev(self, "cannot map framebuffer\n"); 175 return; 176 } 177 sc->sc_fbaddr = bus_space_vaddr(sa->sa_bustag, bh); 178 } 179 180 aprint_normal_dev(self, "%d x %d\n", sc->sc_width, sc->sc_height); 181 182 183 if (sbus_bus_map(sa->sa_bustag, 184 sa->sa_slot, 185 sa->sa_offset + CG12_OFF_REGISTERS, 186 0xc0000, 0, &sc->sc_regh) != 0) { 187 aprint_error("%s: couldn't map registers\n", 188 device_xname(sc->sc_dev)); 189 return; 190 } 191 192 if (sbus_bus_map(sa->sa_bustag, 193 sa->sa_slot, 194 sa->sa_offset + CG12_OFF_WID, 0x100000, 195 BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_LARGE, 196 &bh) != 0) { 197 aprint_error("%s: couldn't map WID\n", 198 device_xname(sc->sc_dev)); 199 return; 200 } 201 sc->sc_wids = bus_space_vaddr(sa->sa_bustag, bh); 202 203 if (sbus_bus_map(sa->sa_bustag, 204 sa->sa_slot, 205 sa->sa_offset + CG12_OFF_INTEN, 0x400000, 206 BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_LARGE, 207 &bh) != 0) { 208 aprint_error("%s: couldn't map colour fb\n", 209 device_xname(sc->sc_dev)); 210 return; 211 } 212 sc->sc_int = bus_space_vaddr(sa->sa_bustag, bh); 213 214 cgtwelve_setup(sc, 1); 215 216 sc->sc_shadow = kmem_alloc(sc->sc_fbsize, KM_SLEEP); 217 isconsole = fb_is_console(node); 218 219 sc->sc_mode = WSDISPLAYIO_MODE_EMUL; 220 wsfont_init(); 221 222 vcons_init(&sc->vd, sc, &cgtwelve_defscreendesc, &cgtwelve_accessops); 223 sc->vd.init_screen = cgtwelve_init_screen; 224 225 vcons_init_screen(&sc->vd, &cgtwelve_console_screen, 1, &defattr); 226 cgtwelve_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC; 227 228 ri = &cgtwelve_console_screen.scr_ri; 229 230 cgtwelve_defscreendesc.nrows = ri->ri_rows; 231 cgtwelve_defscreendesc.ncols = ri->ri_cols; 232 cgtwelve_defscreendesc.textops = &ri->ri_ops; 233 cgtwelve_defscreendesc.capabilities = ri->ri_caps; 234 235 if(isconsole) { 236 wsdisplay_cnattach(&cgtwelve_defscreendesc, ri, 0, 0, defattr); 237 vcons_replay_msgbuf(&cgtwelve_console_screen); 238 } 239 240 aa.console = isconsole; 241 aa.scrdata = &cgtwelve_screenlist; 242 aa.accessops = &cgtwelve_accessops; 243 aa.accesscookie = &sc->vd; 244 245 config_found(self, &aa, wsemuldisplaydevprint); 246 #if 0 247 { 248 bus_space_handle_r bh = sc->sc_regh; 249 int i, j; 250 251 bus_space_write_4(sa->sa_bustag, bh, CG12_EIC_RESET, 0); 252 253 bus_space_write_4(sa->sa_bustag, bh, 254 CG12DPU_PLN_RDMSK_HOST, CG12_PLN_RD_ENABLE); 255 bus_space_write_4(sa->sa_bustag, bh, 256 CG12DPU_PLN_WRMSK_HOST, CG12_PLN_WR_ENABLE); 257 bus_space_write_4(sa->sa_bustag, bh, 258 CG12DPU_PLN_SL_HOST, CG12_PLN_SL_ENABLE); 259 bus_space_write_4(sa->sa_bustag, bh, 260 CG12APU_HPAGE, CG12_HPAGE_ENABLE); 261 bus_space_write_4(sa->sa_bustag, bh, 262 CG12APU_HACCESS, CG12_HACCESS_ENABLE); 263 memset(sc->sc_fbaddr, 0, 0x10000); 264 265 bus_space_write_4(sa->sa_bustag, bh, 266 CG12DPU_PLN_RDMSK_LOC, 0xffffffff); 267 bus_space_write_4(sa->sa_bustag, bh, 268 CG12DPU_PLN_WRMSK_LOC, 0xffffffff); 269 bus_space_write_4(sa->sa_bustag, bh, 270 CG12APU_LACCESS, CG12_HACCESS_24BIT); 271 bus_space_write_4(sa->sa_bustag, bh, 272 CG12APU_LPAGE, CG12_HPAGE_24BIT); 273 bus_space_write_4(sa->sa_bustag, bh, 274 CG12DPU_PLN_SL_LOCAL0, CG12_PLN_SL_24BIT); 275 bus_space_write_4(sa->sa_bustag, bh, 276 CG12APU_DWG_CTL, DWGCTL_BITBLT | 0x00f30000); 277 bus_space_write_4(sa->sa_bustag, bh, 278 CG12APU_F_XLEFT, 10); 279 bus_space_write_4(sa->sa_bustag, bh, 280 CG12APU_F_XRIGHT, 1010); 281 bus_space_write_4(sa->sa_bustag, bh, 282 CG12APU_Y_DST, 10); 283 bus_space_write_4(sa->sa_bustag, bh, 284 CG12DPU_COLOUR0, 0xffffffff); 285 #if 1 286 bus_space_write_4(sa->sa_bustag, bh, 287 CG12APU_LENGTH | 0x1000, 800); 288 #endif 289 bus_space_write_4(sa->sa_bustag, bh, 290 CG12DPU_PLN_RDMSK_HOST, CG12_PLN_RD_OVERLAY); 291 bus_space_write_4(sa->sa_bustag, bh, 292 CG12DPU_PLN_WRMSK_HOST, CG12_PLN_WR_OVERLAY); 293 bus_space_write_4(sa->sa_bustag, bh, 294 CG12DPU_PLN_SL_HOST, CG12_PLN_SL_OVERLAY); 295 bus_space_write_4(sa->sa_bustag, bh, 296 CG12APU_HPAGE, CG12_HPAGE_OVERLAY); 297 bus_space_write_4(sa->sa_bustag, bh, 298 CG12APU_HACCESS, CG12_HACCESS_OVERLAY); 299 300 for (i = 0x100; i < 0x300; i += 32) { 301 printf("%04x:", i); 302 for (j = 0; j < 32; j += 4) { 303 printf(" %08x", bus_space_read_4(sa->sa_bustag, 304 bh, i + j)); 305 } 306 printf("\n"); 307 } 308 } 309 panic("poof"); 310 #endif 311 } 312 313 /* 0 - overlay plane, 1 - enable plane, 2 - 8bit fb, 3 - 24bit fb, 4 - WIDs */ 314 static void 315 cgtwelve_select_ovl(struct cgtwelve_softc *sc, int which) 316 { 317 switch(which) { 318 case 0: 319 bus_space_write_4(sc->sc_tag, sc->sc_regh, 320 CG12DPU_PLN_RDMSK_HOST, CG12_PLN_RD_OVERLAY); 321 bus_space_write_4(sc->sc_tag, sc->sc_regh, 322 CG12DPU_PLN_WRMSK_HOST, CG12_PLN_WR_OVERLAY); 323 bus_space_write_4(sc->sc_tag, sc->sc_regh, 324 CG12DPU_PLN_SL_HOST, CG12_PLN_SL_OVERLAY); 325 bus_space_write_4(sc->sc_tag, sc->sc_regh, 326 CG12APU_HPAGE, CG12_HPAGE_OVERLAY); 327 bus_space_write_4(sc->sc_tag, sc->sc_regh, 328 CG12APU_HACCESS, CG12_HACCESS_OVERLAY); 329 break; 330 case 1: 331 bus_space_write_4(sc->sc_tag, sc->sc_regh, 332 CG12DPU_PLN_RDMSK_HOST, CG12_PLN_RD_ENABLE); 333 bus_space_write_4(sc->sc_tag, sc->sc_regh, 334 CG12DPU_PLN_WRMSK_HOST, CG12_PLN_WR_ENABLE); 335 bus_space_write_4(sc->sc_tag, sc->sc_regh, 336 CG12DPU_PLN_SL_HOST, CG12_PLN_SL_ENABLE); 337 bus_space_write_4(sc->sc_tag, sc->sc_regh, 338 CG12APU_HPAGE, CG12_HPAGE_ENABLE); 339 bus_space_write_4(sc->sc_tag, sc->sc_regh, 340 CG12APU_HACCESS, CG12_HACCESS_ENABLE); 341 break; 342 case 2: 343 bus_space_write_4(sc->sc_tag, sc->sc_regh, 344 CG12DPU_PLN_RDMSK_HOST, CG12_PLN_RD_8BIT); 345 bus_space_write_4(sc->sc_tag, sc->sc_regh, 346 CG12DPU_PLN_WRMSK_HOST, CG12_PLN_WR_8BIT); 347 bus_space_write_4(sc->sc_tag, sc->sc_regh, 348 CG12DPU_PLN_SL_HOST, CG12_PLN_SL_8BIT); 349 bus_space_write_4(sc->sc_tag, sc->sc_regh, 350 CG12APU_HPAGE, CG12_HPAGE_8BIT); 351 bus_space_write_4(sc->sc_tag, sc->sc_regh, 352 CG12APU_HACCESS, CG12_HACCESS_8BIT); 353 break; 354 case 3: 355 bus_space_write_4(sc->sc_tag, sc->sc_regh, 356 CG12DPU_PLN_RDMSK_HOST, CG12_PLN_RD_24BIT); 357 bus_space_write_4(sc->sc_tag, sc->sc_regh, 358 CG12DPU_PLN_WRMSK_HOST, CG12_PLN_WR_24BIT); 359 bus_space_write_4(sc->sc_tag, sc->sc_regh, 360 CG12DPU_PLN_SL_HOST, CG12_PLN_SL_24BIT); 361 bus_space_write_4(sc->sc_tag, sc->sc_regh, 362 CG12APU_HPAGE, CG12_HPAGE_24BIT); 363 bus_space_write_4(sc->sc_tag, sc->sc_regh, 364 CG12APU_HACCESS, CG12_HACCESS_24BIT); 365 break; 366 case 4: 367 bus_space_write_4(sc->sc_tag, sc->sc_regh, 368 CG12DPU_PLN_RDMSK_HOST, CG12_PLN_RD_WID); 369 bus_space_write_4(sc->sc_tag, sc->sc_regh, 370 CG12DPU_PLN_WRMSK_HOST, CG12_PLN_WR_WID); 371 bus_space_write_4(sc->sc_tag, sc->sc_regh, 372 CG12DPU_PLN_SL_HOST, CG12_PLN_SL_WID); 373 bus_space_write_4(sc->sc_tag, sc->sc_regh, 374 CG12APU_HPAGE, CG12_HPAGE_WID); 375 bus_space_write_4(sc->sc_tag, sc->sc_regh, 376 CG12APU_HACCESS, CG12_HACCESS_WID); 377 break; 378 } 379 } 380 381 static void 382 cgtwelve_write_wid(struct cgtwelve_softc *sc, int idx, uint8_t wid) 383 { 384 bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12_WSC_ADDR, idx << 16); 385 bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12_WSC_DATA, 386 ((uint32_t)wid) << 16); 387 } 388 389 static void 390 cgtwelve_write_dac(struct cgtwelve_softc *sc, int idx, int r, int g, int b) 391 { 392 uint32_t lo = (idx & 0xff); 393 uint32_t hi = (idx >> 8) & 0xff; 394 395 lo |= lo << 8 | lo << 16; 396 hi |= hi << 8 | hi << 16; 397 bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DAC_ADDR0, lo); 398 bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DAC_ADDR1, hi); 399 bus_space_write_4(sc->sc_tag, sc->sc_regh, CG12DAC_DATA, 400 b << 16 | g << 8 | r); 401 } 402 403 static void 404 cgtwelve_setup(struct cgtwelve_softc *sc, int depth) 405 { 406 int i; 407 408 /* first let's put some stuff into the WID table */ 409 cgtwelve_write_wid(sc, 0, CG12_WID_8_BIT); 410 cgtwelve_write_wid(sc, 1, CG12_WID_24_BIT); 411 412 /* a linear ramp for the gamma table */ 413 for (i = 0; i < 256; i++) 414 cgtwelve_write_dac(sc, i + 0x100, i, i, i); 415 416 switch(depth) { 417 case 1: 418 /* setup the console */ 419 420 /* first, make the overlay all opaque */ 421 cgtwelve_select_ovl(sc, CG12_SEL_ENABLE); 422 memset(sc->sc_fbaddr, 0xff, 0x20000); 423 424 /* now write the right thing into the WID plane */ 425 cgtwelve_select_ovl(sc, CG12_SEL_WID); 426 memset(sc->sc_wids, 0, 0x100000); 427 428 /* now clean the plane */ 429 cgtwelve_select_ovl(sc, CG12_SEL_OVL); 430 memset(sc->sc_fbaddr, 0, 0x20000); 431 break; 432 case 24: 433 case 32: 434 /* setup the 24bit fb for X */ 435 /* 436 * first clean the 24bit fb - for aesthetic reasons do it while 437 * it's still not visible ( we hope... ) 438 */ 439 cgtwelve_select_ovl(sc, CG12_SEL_24BIT); 440 memset(sc->sc_int, 0x80, 0x400000); 441 442 /* now write the right thing into the WID plane */ 443 cgtwelve_select_ovl(sc, CG12_SEL_WID); 444 memset(sc->sc_wids, 1, 0x100000); 445 446 /* hide the overlay */ 447 cgtwelve_select_ovl(sc, CG12_SEL_ENABLE); 448 memset(sc->sc_fbaddr, 0, 0x20000); 449 450 /* now clean the plane */ 451 cgtwelve_select_ovl(sc, CG12_SEL_OVL); 452 memset(sc->sc_fbaddr, 0, 0x20000); 453 454 /* and make sure we can write the 24bit fb */ 455 cgtwelve_select_ovl(sc, CG12_SEL_24BIT); 456 break; 457 } 458 } 459 460 static void 461 cgtwelve_init_screen(void *cookie, struct vcons_screen *scr, 462 int existing, long *defattr) 463 { 464 struct cgtwelve_softc *sc = cookie; 465 struct rasops_info *ri = &scr->scr_ri; 466 467 ri->ri_depth = 1; 468 ri->ri_width = sc->sc_width; 469 ri->ri_height = sc->sc_height; 470 ri->ri_stride = sc->sc_stride; 471 ri->ri_flg = RI_CENTER; 472 473 if (sc->sc_shadow == NULL) { 474 ri->ri_bits = sc->sc_fbaddr; 475 } else { 476 ri->ri_hwbits = sc->sc_fbaddr; 477 ri->ri_bits = sc->sc_shadow; 478 } 479 480 rasops_init(ri, ri->ri_height/8, ri->ri_width/8); 481 ri->ri_caps = WSSCREEN_REVERSE; 482 rasops_reconfig(ri, ri->ri_height / ri->ri_font->fontheight, 483 ri->ri_width / ri->ri_font->fontwidth); 484 } 485 486 static int 487 cgtwelve_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, 488 struct lwp *l) 489 { 490 struct vcons_data *vd = v; 491 struct cgtwelve_softc *sc = vd->cookie; 492 struct wsdisplay_fbinfo *wdf; 493 struct vcons_screen *ms = vd->active; 494 495 switch (cmd) { 496 case WSDISPLAYIO_GTYPE: 497 *(u_int *)data = WSDISPLAY_TYPE_SUNCG12; 498 return 0; 499 500 case WSDISPLAYIO_GINFO: 501 wdf = (void *)data; 502 wdf->height = sc->sc_height; 503 wdf->width = sc->sc_width; 504 wdf->depth = 32; 505 wdf->cmsize = 256; 506 return 0; 507 508 case FBIOGVIDEO: 509 case WSDISPLAYIO_GVIDEO: 510 *(int *)data = 1; 511 return 0; 512 513 case WSDISPLAYIO_SVIDEO: 514 case FBIOSVIDEO: 515 /* when we figure out how to do this... */ 516 /*cgtwelve_set_video(sc, *(int *)data);*/ 517 return 0; 518 519 case WSDISPLAYIO_LINEBYTES: 520 { 521 int *ret = (int *)data; 522 *ret = sc->sc_width << 2; 523 } 524 return 0; 525 526 case WSDISPLAYIO_SMODE: 527 { 528 int new_mode = *(int*)data; 529 if (new_mode != sc->sc_mode) 530 { 531 sc->sc_mode = new_mode; 532 if (new_mode == WSDISPLAYIO_MODE_EMUL) 533 { 534 cgtwelve_setup(sc, 1); 535 vcons_redraw_screen(ms); 536 } else { 537 cgtwelve_setup(sc, 32); 538 } 539 } 540 } 541 } 542 543 return EPASSTHROUGH; 544 } 545 546 static paddr_t 547 cgtwelve_mmap(void *v, void *vs, off_t offset, int prot) 548 { 549 struct vcons_data *vd = v; 550 struct cgtwelve_softc *sc = vd->cookie; 551 552 /* regular fb mapping at 0 */ 553 if ((offset >= 0) && (offset < 0x400000)) { 554 return bus_space_mmap(sc->sc_tag, sc->sc_paddr + CG12_OFF_INTEN, 555 offset, prot, BUS_SPACE_MAP_LINEAR); 556 } 557 558 return -1; 559 } 560
Indexes created Wed Sep 24 15:09:51 GMT 2025