mq200.c revision 1.13
1 /* $NetBSD: mq200.c,v 1.13 2001/03/25 13:06:53 takemura Exp $ */ 2 3 /*- 4 * Copyright (c) 2000, 2001 TAKEMURA Shin 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 * 3. The name of the author may not be used to endorse or promote products 16 * derived from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 * 30 */ 31 32 #include <sys/param.h> 33 #include <sys/kernel.h> 34 #include <sys/device.h> 35 #include <sys/systm.h> 36 #include <sys/reboot.h> 37 38 #include <uvm/uvm_extern.h> 39 40 #include <dev/wscons/wsconsio.h> 41 42 #include <machine/bootinfo.h> 43 #include <machine/bus.h> 44 #include <machine/autoconf.h> 45 #include <machine/config_hook.h> 46 #include <machine/platid.h> 47 #include <machine/platid_mask.h> 48 49 #include "opt_mq200.h" 50 #include <hpcmips/dev/mq200reg.h> 51 #include <hpcmips/dev/mq200var.h> 52 #include <hpcmips/dev/mq200priv.h> 53 54 #include "bivideo.h" 55 #if NBIVIDEO > 0 56 #include <dev/hpc/bivideovar.h> 57 #endif 58 59 /* 60 * function prototypes 61 */ 62 static void mq200_power __P((int, void *)); 63 static int mq200_hardpower __P((void *, int, long, void *)); 64 static int mq200_fbinit __P((struct hpcfb_fbconf *)); 65 static int mq200_ioctl __P((void *, u_long, caddr_t, int, struct proc *)); 66 static paddr_t mq200_mmap __P((void *, off_t offset, int)); 67 static void mq200_update_powerstate __P((struct mq200_softc *, int)); 68 void mq200_get_backlight __P((struct mq200_softc *)); 69 void mq200_init_brightness __P((struct mq200_softc *)); 70 void mq200_init_contrast __P((struct mq200_softc *)); 71 void mq200_set_brightness __P((struct mq200_softc *, int)); 72 void mq200_set_contrast __P((struct mq200_softc *, int)); 73 74 /* 75 * static variables 76 */ 77 struct hpcfb_accessops mq200_ha = { 78 mq200_ioctl, mq200_mmap 79 }; 80 81 #ifdef MQ200_DEBUG 82 int mq200_debug = MQ200DEBUG_CONF; 83 #endif 84 85 int 86 mq200_probe(iot, ioh) 87 bus_space_tag_t iot; 88 bus_space_handle_t ioh; 89 { 90 unsigned long regval; 91 92 #if NBIVIDEO > 0 93 if (bivideo_dont_attach) /* some video driver already attached */ 94 return (0); 95 #endif /* NBIVIDEO > 0 */ 96 97 regval = bus_space_read_4(iot, ioh, MQ200_PC00R); 98 VPRINTF("probe: vendor id=%04lx product id=%04lx\n", 99 regval & 0xffff, (regval >> 16) & 0xffff); 100 if (regval != ((MQ200_PRODUCT_ID << 16) | MQ200_VENDOR_ID)) 101 return (0); 102 103 return (1); 104 } 105 106 void 107 mq200_attach(sc) 108 struct mq200_softc *sc; 109 { 110 unsigned long regval; 111 struct hpcfb_attach_args ha; 112 int console = (bootinfo->bi_cnuse & BI_CNUSE_SERIAL) ? 0 : 1; 113 114 printf(": "); 115 if (mq200_fbinit(&sc->sc_fbconf) != 0) { 116 /* just return so that hpcfb will not be attached */ 117 return; 118 } 119 120 sc->sc_fbconf.hf_baseaddr = (u_long)bootinfo->fb_addr; 121 sc->sc_fbconf.hf_offset = (u_long)sc->sc_fbconf.hf_baseaddr - 122 MIPS_PHYS_TO_KSEG1(mips_ptob(mips_btop(sc->sc_baseaddr))); 123 DPRINTF("hf_baseaddr=%lx\n", sc->sc_fbconf.hf_baseaddr); 124 DPRINTF("hf_offset=%lx\n", sc->sc_fbconf.hf_offset); 125 126 regval = mq200_read(sc, MQ200_PC08R); 127 printf("MQ200 Rev.%02lx video controller", regval & 0xff); 128 if (console) { 129 printf(", console"); 130 } 131 printf("\n"); 132 printf("%s: framebuffer address: 0x%08lx\n", 133 sc->sc_dev.dv_xname, (u_long)bootinfo->fb_addr); 134 135 /* 136 * setup registers 137 */ 138 sc->sc_flags = 0; 139 sc->sc_baseclock = 12288; /* 12.288 MHz */ 140 #ifdef MQ200_DEBUG 141 if (bootverbose) { 142 /* dump current setting */ 143 mq200_dump_all(sc); 144 mq200_dump_pll(sc); 145 } 146 #endif 147 mq200_setup_regctx(sc); 148 mq200_mdsetup(sc); 149 if (sc->sc_md) { 150 if (sc->sc_md->md_flags & MQ200_MD_HAVEFP) { 151 sc->sc_flags |= MQ200_SC_GC2_ENABLE; /* FP */ 152 } 153 #if MQ200_USECRT 154 if (sc->sc_md->md_flags & MQ200_MD_HAVECRT) { 155 int i; 156 sc->sc_flags |= MQ200_SC_GC1_ENABLE; /* CRT */ 157 for (i = 0; i < mq200_crt_nparams; i++) { 158 sc->sc_crt = &mq200_crt_params[i]; 159 if (sc->sc_md->md_fp_width <= 160 mq200_crt_params[i].width && 161 sc->sc_md->md_fp_height <= 162 mq200_crt_params[i].height) 163 break; 164 } 165 } 166 #endif 167 mq200_setup(sc); 168 169 if (sc->sc_flags & MQ200_SC_GC2_ENABLE) /* FP */ 170 mq200_win_enable(sc, MQ200_GC2, MQ200_GCC_16BPP_DIRECT, 171 0x00080100, 172 sc->sc_md->md_fp_width, sc->sc_md->md_fp_height, 173 1280); 174 if (sc->sc_flags & MQ200_SC_GC1_ENABLE) /* CRT */ 175 mq200_win_enable(sc, MQ200_GC1, MQ200_GCC_16BPP_DIRECT, 176 0x00080100, 177 sc->sc_md->md_fp_width, sc->sc_md->md_fp_height, 178 1280); 179 } 180 #ifdef MQ200_DEBUG 181 if (sc->sc_md == NULL || bootverbose) { 182 mq200_dump_pll(sc); 183 } 184 #endif 185 186 /* Add a power hook to power saving */ 187 sc->sc_mq200pwstate = MQ200_POWERSTATE_D0; 188 sc->sc_powerhook = powerhook_establish(mq200_power, sc); 189 if (sc->sc_powerhook == NULL) 190 printf("%s: WARNING: unable to establish power hook\n", 191 sc->sc_dev.dv_xname); 192 193 /* Add a hard power hook to power saving */ 194 sc->sc_hardpowerhook = config_hook(CONFIG_HOOK_PMEVENT, 195 CONFIG_HOOK_PMEVENT_HARDPOWER, 196 CONFIG_HOOK_SHARE, 197 mq200_hardpower, sc); 198 if (sc->sc_hardpowerhook == NULL) 199 printf("%s: WARNING: unable to establish hard power hook\n", 200 sc->sc_dev.dv_xname); 201 202 /* initialize backlight brightness and lcd contrast */ 203 sc->sc_brightness = sc->sc_contrast = 204 sc->sc_max_brightness = sc->sc_max_contrast = -1; 205 mq200_init_brightness(sc); 206 mq200_init_contrast(sc); 207 mq200_get_backlight(sc); 208 209 if (console && hpcfb_cnattach(&sc->sc_fbconf) != 0) { 210 panic("mq200_attach: can't init fb console"); 211 } 212 213 ha.ha_console = console; 214 ha.ha_accessops = &mq200_ha; 215 ha.ha_accessctx = sc; 216 ha.ha_curfbconf = 0; 217 ha.ha_nfbconf = 1; 218 ha.ha_fbconflist = &sc->sc_fbconf; 219 ha.ha_curdspconf = 0; 220 ha.ha_ndspconf = 1; 221 ha.ha_dspconflist = &sc->sc_dspconf; 222 223 config_found(&sc->sc_dev, &ha, hpcfbprint); 224 225 #if NBIVIDEO > 0 226 /* 227 * bivideo is no longer need 228 */ 229 bivideo_dont_attach = 1; 230 #endif /* NBIVIDEO > 0 */ 231 } 232 233 static void 234 mq200_update_powerstate(sc, updates) 235 struct mq200_softc *sc; 236 int updates; 237 { 238 239 if (updates & PWRSTAT_LCD) 240 config_hook_call(CONFIG_HOOK_POWERCONTROL, 241 CONFIG_HOOK_POWERCONTROL_LCD, 242 (void*)!(sc->sc_powerstate & 243 (PWRSTAT_VIDEOOFF|PWRSTAT_SUSPEND))); 244 245 if (updates & PWRSTAT_BACKLIGHT) 246 config_hook_call(CONFIG_HOOK_POWERCONTROL, 247 CONFIG_HOOK_POWERCONTROL_LCDLIGHT, 248 (void*)(!(sc->sc_powerstate & 249 (PWRSTAT_VIDEOOFF|PWRSTAT_SUSPEND)) && 250 (sc->sc_powerstate & PWRSTAT_BACKLIGHT))); 251 } 252 253 static void 254 mq200_power(why, arg) 255 int why; 256 void *arg; 257 { 258 struct mq200_softc *sc = arg; 259 260 switch (why) { 261 case PWR_SUSPEND: 262 sc->sc_powerstate |= PWRSTAT_SUSPEND; 263 mq200_update_powerstate(sc, PWRSTAT_ALL); 264 break; 265 case PWR_STANDBY: 266 sc->sc_powerstate |= PWRSTAT_SUSPEND; 267 mq200_update_powerstate(sc, PWRSTAT_ALL); 268 break; 269 case PWR_RESUME: 270 sc->sc_powerstate &= ~PWRSTAT_SUSPEND; 271 mq200_update_powerstate(sc, PWRSTAT_ALL); 272 break; 273 } 274 } 275 276 static int 277 mq200_hardpower(ctx, type, id, msg) 278 void *ctx; 279 int type; 280 long id; 281 void *msg; 282 { 283 struct mq200_softc *sc = ctx; 284 int why = (int)msg; 285 286 switch (why) { 287 case PWR_SUSPEND: 288 sc->sc_mq200pwstate = MQ200_POWERSTATE_D2; 289 break; 290 case PWR_STANDBY: 291 sc->sc_mq200pwstate = MQ200_POWERSTATE_D3; 292 break; 293 case PWR_RESUME: 294 sc->sc_mq200pwstate = MQ200_POWERSTATE_D0; 295 break; 296 } 297 298 bus_space_write_4(sc->sc_iot, sc->sc_ioh, 299 MQ200_PMCSR, sc->sc_mq200pwstate); 300 301 /* 302 * you should wait until the 303 * power state transit sequence will end. 304 */ 305 { 306 unsigned long tmp; 307 do { 308 tmp = bus_space_read_4(sc->sc_iot, sc->sc_ioh, 309 MQ200_PMCSR); 310 } while ((tmp & 0x3) != (sc->sc_mq200pwstate & 0x3)); 311 delay(100000); /* XXX */ 312 } 313 314 return (0); 315 } 316 317 318 static int 319 mq200_fbinit(fb) 320 struct hpcfb_fbconf *fb; 321 { 322 323 /* 324 * get fb settings from bootinfo 325 */ 326 if (bootinfo == NULL || 327 bootinfo->fb_addr == 0 || 328 bootinfo->fb_line_bytes == 0 || 329 bootinfo->fb_width == 0 || 330 bootinfo->fb_height == 0) { 331 printf("no frame buffer infomation.\n"); 332 return (-1); 333 } 334 335 /* zero fill */ 336 bzero(fb, sizeof(*fb)); 337 338 fb->hf_conf_index = 0; /* configuration index */ 339 fb->hf_nconfs = 1; /* how many configurations */ 340 strcpy(fb->hf_name, "built-in video"); 341 /* frame buffer name */ 342 strcpy(fb->hf_conf_name, "default"); 343 /* configuration name */ 344 fb->hf_height = bootinfo->fb_height; 345 fb->hf_width = bootinfo->fb_width; 346 fb->hf_baseaddr = mips_ptob(mips_btop(bootinfo->fb_addr)); 347 fb->hf_offset = (u_long)bootinfo->fb_addr - fb->hf_baseaddr; 348 /* frame buffer start offset */ 349 fb->hf_bytes_per_line = bootinfo->fb_line_bytes; 350 fb->hf_nplanes = 1; 351 fb->hf_bytes_per_plane = bootinfo->fb_height * 352 bootinfo->fb_line_bytes; 353 354 fb->hf_access_flags |= HPCFB_ACCESS_BYTE; 355 fb->hf_access_flags |= HPCFB_ACCESS_WORD; 356 fb->hf_access_flags |= HPCFB_ACCESS_DWORD; 357 358 switch (bootinfo->fb_type) { 359 /* 360 * gray scale 361 */ 362 case BIFB_D2_M2L_3: 363 case BIFB_D2_M2L_3x2: 364 fb->hf_access_flags |= HPCFB_ACCESS_REVERSE; 365 /* fall through */ 366 case BIFB_D2_M2L_0: 367 case BIFB_D2_M2L_0x2: 368 fb->hf_class = HPCFB_CLASS_GRAYSCALE; 369 fb->hf_access_flags |= HPCFB_ACCESS_STATIC; 370 fb->hf_pack_width = 8; 371 fb->hf_pixels_per_pack = 4; 372 fb->hf_pixel_width = 2; 373 fb->hf_class_data_length = sizeof(struct hf_gray_tag); 374 fb->hf_u.hf_gray.hf_flags = 0; /* reserved for future use */ 375 break; 376 377 case BIFB_D4_M2L_F: 378 case BIFB_D4_M2L_Fx2: 379 fb->hf_access_flags |= HPCFB_ACCESS_REVERSE; 380 /* fall through */ 381 case BIFB_D4_M2L_0: 382 case BIFB_D4_M2L_0x2: 383 fb->hf_class = HPCFB_CLASS_GRAYSCALE; 384 fb->hf_access_flags |= HPCFB_ACCESS_STATIC; 385 fb->hf_pack_width = 8; 386 fb->hf_pixels_per_pack = 2; 387 fb->hf_pixel_width = 4; 388 fb->hf_class_data_length = sizeof(struct hf_gray_tag); 389 fb->hf_u.hf_gray.hf_flags = 0; /* reserved for future use */ 390 break; 391 392 /* 393 * indexed color 394 */ 395 case BIFB_D8_FF: 396 fb->hf_access_flags |= HPCFB_ACCESS_REVERSE; 397 /* fall through */ 398 case BIFB_D8_00: 399 fb->hf_class = HPCFB_CLASS_INDEXCOLOR; 400 fb->hf_access_flags |= HPCFB_ACCESS_STATIC; 401 fb->hf_pack_width = 8; 402 fb->hf_pixels_per_pack = 1; 403 fb->hf_pixel_width = 8; 404 fb->hf_class_data_length = sizeof(struct hf_indexed_tag); 405 fb->hf_u.hf_indexed.hf_flags = 0; /* reserved for future use */ 406 break; 407 408 /* 409 * RGB color 410 */ 411 case BIFB_D16_FFFF: 412 fb->hf_access_flags |= HPCFB_ACCESS_REVERSE; 413 /* fall through */ 414 case BIFB_D16_0000: 415 fb->hf_class = HPCFB_CLASS_RGBCOLOR; 416 fb->hf_access_flags |= HPCFB_ACCESS_STATIC; 417 #if BYTE_ORDER == LITTLE_ENDIAN 418 fb->hf_swap_flags = HPCFB_SWAP_BYTE; 419 #endif 420 fb->hf_pack_width = 16; 421 fb->hf_pixels_per_pack = 1; 422 fb->hf_pixel_width = 16; 423 424 fb->hf_class_data_length = sizeof(struct hf_rgb_tag); 425 fb->hf_u.hf_rgb.hf_flags = 0; /* reserved for future use */ 426 427 fb->hf_u.hf_rgb.hf_red_width = 5; 428 fb->hf_u.hf_rgb.hf_red_shift = 11; 429 fb->hf_u.hf_rgb.hf_green_width = 6; 430 fb->hf_u.hf_rgb.hf_green_shift = 5; 431 fb->hf_u.hf_rgb.hf_blue_width = 5; 432 fb->hf_u.hf_rgb.hf_blue_shift = 0; 433 fb->hf_u.hf_rgb.hf_alpha_width = 0; 434 fb->hf_u.hf_rgb.hf_alpha_shift = 0; 435 break; 436 437 default: 438 printf("unknown type (=%d).\n", bootinfo->fb_type); 439 return (-1); 440 break; 441 } 442 443 return (0); /* no error */ 444 } 445 446 int 447 mq200_ioctl(v, cmd, data, flag, p) 448 void *v; 449 u_long cmd; 450 caddr_t data; 451 int flag; 452 struct proc *p; 453 { 454 struct mq200_softc *sc = (struct mq200_softc *)v; 455 struct hpcfb_fbconf *fbconf; 456 struct hpcfb_dspconf *dspconf; 457 struct wsdisplay_cmap *cmap; 458 struct wsdisplay_param *dispparam; 459 460 switch (cmd) { 461 case WSDISPLAYIO_GETCMAP: 462 cmap = (struct wsdisplay_cmap*)data; 463 464 if (sc->sc_fbconf.hf_class != HPCFB_CLASS_INDEXCOLOR || 465 sc->sc_fbconf.hf_pack_width != 8 || 466 256 <= cmap->index || 467 256 < (cmap->index + cmap->count)) 468 return (EINVAL); 469 470 #if 0 471 if (!uvm_useracc(cmap->red, cmap->count, B_WRITE) || 472 !uvm_useracc(cmap->green, cmap->count, B_WRITE) || 473 !uvm_useracc(cmap->blue, cmap->count, B_WRITE)) 474 return (EFAULT); 475 476 copyout(&bivideo_cmap_r[cmap->index], cmap->red, cmap->count); 477 copyout(&bivideo_cmap_g[cmap->index], cmap->green,cmap->count); 478 copyout(&bivideo_cmap_b[cmap->index], cmap->blue, cmap->count); 479 #endif 480 481 return (0); 482 483 case WSDISPLAYIO_PUTCMAP: 484 /* 485 * This driver can't set color map. 486 */ 487 return (EINVAL); 488 489 case WSDISPLAYIO_SVIDEO: 490 if (*(int *)data == WSDISPLAYIO_VIDEO_OFF) 491 sc->sc_powerstate |= PWRSTAT_VIDEOOFF; 492 else 493 sc->sc_powerstate &= ~PWRSTAT_VIDEOOFF; 494 mq200_update_powerstate(sc, PWRSTAT_ALL); 495 return 0; 496 497 case WSDISPLAYIO_GVIDEO: 498 *(int *)data = (sc->sc_powerstate&PWRSTAT_VIDEOOFF) ? 499 WSDISPLAYIO_VIDEO_OFF:WSDISPLAYIO_VIDEO_ON; 500 return 0; 501 502 case WSDISPLAYIO_GETPARAM: 503 dispparam = (struct wsdisplay_param*)data; 504 switch (dispparam->param) { 505 case WSDISPLAYIO_PARAM_BACKLIGHT: 506 VPRINTF("ioctl: GETPARAM:BACKLIGHT call\n"); 507 if (sc->sc_max_brightness == -1) 508 mq200_init_brightness(sc); 509 mq200_get_backlight(sc); 510 dispparam->min = 0; 511 dispparam->max = 1; 512 if (sc->sc_max_brightness > 0) 513 dispparam->curval = sc->sc_brightness > 0? 1: 0; 514 else 515 dispparam->curval = 516 (sc->sc_powerstate&PWRSTAT_BACKLIGHT) ? 1 : 0; 517 VPRINTF("ioctl: GETPARAM:BACKLIGHT:%d\n", 518 dispparam->curval); 519 return 0; 520 break; 521 case WSDISPLAYIO_PARAM_CONTRAST: 522 VPRINTF("ioctl: GETPARAM:CONTRAST call\n"); 523 if (sc->sc_max_contrast == -1) 524 mq200_init_contrast(sc); 525 if (sc->sc_max_contrast > 0) { 526 dispparam->min = 0; 527 dispparam->max = sc->sc_max_contrast; 528 dispparam->curval = sc->sc_contrast; 529 VPRINTF("ioctl: GETPARAM:CONTRAST max=%d, current=%d\n", sc->sc_max_contrast, sc->sc_contrast); 530 return 0; 531 } else { 532 VPRINTF("ioctl: GETPARAM:CONTRAST ret\n"); 533 return (EINVAL); 534 } 535 break; 536 case WSDISPLAYIO_PARAM_BRIGHTNESS: 537 VPRINTF("ioctl: GETPARAM:BRIGHTNESS call\n"); 538 if (sc->sc_max_brightness == -1) 539 mq200_init_brightness(sc); 540 if (sc->sc_max_brightness > 0) { 541 dispparam->min = 0; 542 dispparam->max = sc->sc_max_brightness; 543 dispparam->curval = sc->sc_brightness; 544 VPRINTF("ioctl: GETPARAM:BRIGHTNESS max=%d, current=%d\n", sc->sc_max_brightness, sc->sc_brightness); 545 return 0; 546 } else { 547 VPRINTF("ioctl: GETPARAM:BRIGHTNESS ret\n"); 548 return (EINVAL); 549 } 550 return (EINVAL); 551 default: 552 return (EINVAL); 553 } 554 return (0); 555 556 case WSDISPLAYIO_SETPARAM: 557 dispparam = (struct wsdisplay_param*)data; 558 switch (dispparam->param) { 559 case WSDISPLAYIO_PARAM_BACKLIGHT: 560 VPRINTF("ioctl: SETPARAM:BACKLIGHT call\n"); 561 if (dispparam->curval < 0 || 562 1 < dispparam->curval) 563 return (EINVAL); 564 if (sc->sc_max_brightness == -1) 565 mq200_init_brightness(sc); 566 VPRINTF("ioctl: SETPARAM:max brightness=%d\n", sc->sc_max_brightness); 567 if (sc->sc_max_brightness > 0) { /* dimmer */ 568 if (dispparam->curval == 0){ 569 sc->sc_brightness_save = sc->sc_brightness; 570 mq200_set_brightness(sc, 0); /* min */ 571 } else { 572 if (sc->sc_brightness_save == 0) 573 sc->sc_brightness_save = sc->sc_max_brightness; 574 mq200_set_brightness(sc, sc->sc_brightness_save); 575 } 576 VPRINTF("ioctl: SETPARAM:BACKLIGHT: brightness=%d\n", sc->sc_brightness); 577 } else { /* off */ 578 if (dispparam->curval == 0) 579 sc->sc_powerstate &= ~PWRSTAT_BACKLIGHT; 580 else 581 sc->sc_powerstate |= PWRSTAT_BACKLIGHT; 582 VPRINTF("ioctl: SETPARAM:BACKLIGHT: powerstate %d\n", 583 (sc->sc_powerstate & PWRSTAT_BACKLIGHT)?1:0); 584 mq200_update_powerstate(sc, PWRSTAT_BACKLIGHT); 585 VPRINTF("ioctl: SETPARAM:BACKLIGHT:%d\n", 586 (sc->sc_powerstate & PWRSTAT_BACKLIGHT)?1:0); 587 } 588 return 0; 589 break; 590 case WSDISPLAYIO_PARAM_CONTRAST: 591 VPRINTF("ioctl: SETPARAM:CONTRAST call\n"); 592 if (sc->sc_max_contrast == -1) 593 mq200_init_contrast(sc); 594 if (dispparam->curval < 0 || 595 sc->sc_max_contrast < dispparam->curval) 596 return (EINVAL); 597 if (sc->sc_max_contrast > 0) { 598 int org = sc->sc_contrast; 599 mq200_set_contrast(sc, dispparam->curval); 600 VPRINTF("ioctl: SETPARAM:CONTRAST org=%d, current=%d\n", org, sc->sc_contrast); 601 return 0; 602 } else { 603 VPRINTF("ioctl: SETPARAM:CONTRAST ret\n"); 604 return (EINVAL); 605 } 606 break; 607 case WSDISPLAYIO_PARAM_BRIGHTNESS: 608 VPRINTF("ioctl: SETPARAM:BRIGHTNESS call\n"); 609 if (sc->sc_max_brightness == -1) 610 mq200_init_brightness(sc); 611 if (dispparam->curval < 0 || 612 sc->sc_max_brightness < dispparam->curval) 613 return (EINVAL); 614 if (sc->sc_max_brightness > 0) { 615 int org = sc->sc_brightness; 616 mq200_set_brightness(sc, dispparam->curval); 617 VPRINTF("ioctl: SETPARAM:BRIGHTNESS org=%d, current=%d\n", org, sc->sc_brightness); 618 return 0; 619 } else { 620 VPRINTF("ioctl: SETPARAM:BRIGHTNESS ret\n"); 621 return (EINVAL); 622 } 623 break; 624 default: 625 return (EINVAL); 626 } 627 return (0); 628 629 case HPCFBIO_GCONF: 630 fbconf = (struct hpcfb_fbconf *)data; 631 if (fbconf->hf_conf_index != 0 && 632 fbconf->hf_conf_index != HPCFB_CURRENT_CONFIG) { 633 return (EINVAL); 634 } 635 *fbconf = sc->sc_fbconf; /* structure assignment */ 636 return (0); 637 case HPCFBIO_SCONF: 638 fbconf = (struct hpcfb_fbconf *)data; 639 if (fbconf->hf_conf_index != 0 && 640 fbconf->hf_conf_index != HPCFB_CURRENT_CONFIG) { 641 return (EINVAL); 642 } 643 /* 644 * nothing to do because we have only one configration 645 */ 646 return (0); 647 case HPCFBIO_GDSPCONF: 648 dspconf = (struct hpcfb_dspconf *)data; 649 if ((dspconf->hd_unit_index != 0 && 650 dspconf->hd_unit_index != HPCFB_CURRENT_UNIT) || 651 (dspconf->hd_conf_index != 0 && 652 dspconf->hd_conf_index != HPCFB_CURRENT_CONFIG)) { 653 return (EINVAL); 654 } 655 *dspconf = sc->sc_dspconf; /* structure assignment */ 656 return (0); 657 case HPCFBIO_SDSPCONF: 658 dspconf = (struct hpcfb_dspconf *)data; 659 if ((dspconf->hd_unit_index != 0 && 660 dspconf->hd_unit_index != HPCFB_CURRENT_UNIT) || 661 (dspconf->hd_conf_index != 0 && 662 dspconf->hd_conf_index != HPCFB_CURRENT_CONFIG)) { 663 return (EINVAL); 664 } 665 /* 666 * nothing to do 667 * because we have only one unit and one configration 668 */ 669 return (0); 670 case HPCFBIO_GOP: 671 case HPCFBIO_SOP: 672 /* 673 * curently not implemented... 674 */ 675 return (EINVAL); 676 } 677 678 return (ENOTTY); 679 } 680 681 paddr_t 682 mq200_mmap(ctx, offset, prot) 683 void *ctx; 684 off_t offset; 685 int prot; 686 { 687 struct mq200_softc *sc = (struct mq200_softc *)ctx; 688 689 if (offset < 0 || MQ200_MAPSIZE <= offset) 690 return -1; 691 692 return mips_btop(sc->sc_baseaddr + offset); 693 } 694 695 696 void 697 mq200_get_backlight(sc) 698 struct mq200_softc *sc; 699 { 700 int val = -1; 701 702 if (config_hook_call(CONFIG_HOOK_GET, 703 CONFIG_HOOK_POWER_LCDLIGHT, &val) != -1) { 704 if (val == 0) 705 sc->sc_powerstate &= ~PWRSTAT_BACKLIGHT; 706 else 707 sc->sc_powerstate |= PWRSTAT_BACKLIGHT; 708 } else /* assume backlight is on */ 709 sc->sc_powerstate |= PWRSTAT_BACKLIGHT; 710 } 711 712 void 713 mq200_init_brightness(sc) 714 struct mq200_softc *sc; 715 { 716 int val = -1; 717 718 VPRINTF("init_brightness\n"); 719 if (config_hook_call(CONFIG_HOOK_GET, 720 CONFIG_HOOK_BRIGHTNESS, &val) != -1) { 721 sc->sc_brightness_save = sc->sc_brightness = val; 722 } 723 val = -1; 724 if (config_hook_call(CONFIG_HOOK_GET, 725 CONFIG_HOOK_BRIGHTNESS_MAX, &val) != -1) { 726 sc->sc_max_brightness = val; 727 } 728 return; 729 } 730 731 732 void 733 mq200_init_contrast(sc) 734 struct mq200_softc *sc; 735 { 736 int val = -1; 737 738 VPRINTF("init_contrast\n"); 739 if (config_hook_call(CONFIG_HOOK_GET, 740 CONFIG_HOOK_CONTRAST, &val) != -1) { 741 sc->sc_contrast = val; 742 } 743 val = -1; 744 if (config_hook_call(CONFIG_HOOK_GET, 745 CONFIG_HOOK_CONTRAST_MAX, &val) != -1) { 746 sc->sc_max_contrast = val; 747 } 748 return; 749 } 750 751 void 752 mq200_set_brightness(sc, val) 753 struct mq200_softc *sc; 754 int val; 755 { 756 sc->sc_brightness = val; 757 758 config_hook_call(CONFIG_HOOK_SET, CONFIG_HOOK_BRIGHTNESS, &val); 759 if (config_hook_call(CONFIG_HOOK_GET, 760 CONFIG_HOOK_BRIGHTNESS, &val) != -1) { 761 sc->sc_brightness = val; 762 } 763 } 764 765 void 766 mq200_set_contrast(sc, val) 767 struct mq200_softc *sc; 768 int val; 769 { 770 sc->sc_contrast = val; 771 772 config_hook_call(CONFIG_HOOK_SET, CONFIG_HOOK_CONTRAST, &val); 773 if (config_hook_call(CONFIG_HOOK_GET, 774 CONFIG_HOOK_CONTRAST, &val) != -1) { 775 sc->sc_contrast = val; 776 } 777 } 778
Indexes created Tue Oct 07 21:09:53 GMT 2025