/* $NetBSD: j6x0lcd.c,v 1.14 2009/04/05 02:23:00 uwe Exp $ */ /* * Copyright (c) 2004, 2005 Valeriy E. Ushakov * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include __KERNEL_RCSID(0, "$NetBSD: j6x0lcd.c,v 1.14 2009/04/05 02:23:00 uwe Exp $"); #include #include #include #include #include #include #include #include #include /* XXX: for hd64461_reg_read_2 &c */ #include #include #define arraysize(ary) (sizeof(ary) / sizeof(ary[0])) /* * LCD power: controlled by pin 0 in HD64461 GPIO port B. * 0 - power on * 1 - power off */ #define HD64461_GPBDR_J6X0_LCD_OFF 0x01 #define HD64461_GPBCR_J6X0_LCD_OFF_MASK 0xfffc #define HD64461_GPBCR_J6X0_LCD_OFF_BITS 0x0001 /* * LCD brightness: controlled by DAC channel 0. Larger channel values * mean dimmer. Values smaller (i.e. brighter) then 0x5e seems to * result in no visible changes. */ #define J6X0LCD_BRIGHTNESS_DA_MAX 0x5e #define J6X0LCD_BRIGHTNESS_DA_MIN 0xff #define J6X0LCD_DA_TO_BRIGHTNESS(da) \ (J6X0LCD_BRIGHTNESS_DA_MIN - (da)) #define J6X0LCD_BRIGHTNESS_TO_DA(br) \ (J6X0LCD_BRIGHTNESS_DA_MIN - (br)) #define J6X0LCD_BRIGHTNESS_MAX \ J6X0LCD_DA_TO_BRIGHTNESS(J6X0LCD_BRIGHTNESS_DA_MAX) /* convenience macro to accesses DAC registers */ #define DAC_(x) (*((volatile uint8_t *)SH7709_DA ## x)) /* * LCD contrast in 680 is controlled by pins 6..3 of HD64461 GPIO * port B. 6th pin is the least significant bit, 3rd pin is the most * significant. The bits are inverted: 0 = .1111...; 1 = .0111...; * etc. Larger values mean "blacker". * * The contrast value is programmed by setting bits in the data * register to all ones, and changing the mode of the pins in the * control register, setting logical "ones" to GPIO output mode (1), * and switching "zeroes" to input mode (3). */ #define HD64461_GPBDR_J680_CONTRAST_BITS 0x78 /* set */ #define HD64461_GPBCR_J680_CONTRAST_MASK 0xc03f static const uint8_t j6x0lcd_contrast680_pins[] = { 6, 5, 4, 3 }; static const uint16_t j6x0lcd_contrast680_control_bits[] = { 0x1540, 0x3540, 0x1d40, 0x3d40, 0x1740, 0x3740, 0x1f40, 0x3f40, 0x15c0, 0x35c0, 0x1dc0, 0x3dc0, 0x17c0, 0x37c0, 0x1fc0, 0x3fc0 }; /* * LCD contrast in 620lx is controlled by pins 7,6,3,4,5 of HD64461 * GPIO port B (in the order from the least significant to the most * significant). The bits are inverted: 0 = 11111...; 5 = 01110...; * etc. Larger values mean "whiter". * * The contrast value is programmed by setting bits in the data * register to all zeroes, and changing the mode of the pins in the * control register, setting logical "ones" to GPIO output mode (1), * and switching "zeroes" to input mode (3). */ #define HD64461_GPBDR_J620LX_CONTRAST_BITS 0xf8 /* clear */ #define HD64461_GPBCR_J620LX_CONTRAST_MASK 0x003f static const uint8_t j6x0lcd_contrast620lx_pins[] = { 7, 6, 3, 4, 5 }; static const uint16_t j6x0lcd_contrast620lx_control_bits[] = { 0xffc0, 0x7fc0, 0xdfc0, 0x5fc0, 0xff40, 0x7f40, 0xdf40, 0x5f40, 0xfdc0, 0x7dc0, 0xddc0, 0x5dc0, 0xfd40, 0x7d40, 0xdd40, 0x5d40, 0xf7c0, 0x77c0, 0xd7c0, 0x57c0, 0xf740, 0x7740, 0xd740, 0x5740, 0xf5c0, 0x75c0, 0xd5c0, 0x55c0, 0xf540, 0x7540, 0xd540, 0x5540 }; struct j6x0lcd_softc { device_t sc_dev; int sc_brightness; int sc_contrast; int sc_contrast_max; uint16_t sc_contrast_mask; const uint16_t *sc_contrast_control_bits; }; static int j6x0lcd_match(device_t, cfdata_t, void *); static void j6x0lcd_attach(device_t, device_t, void *); CFATTACH_DECL_NEW(j6x0lcd, sizeof(struct j6x0lcd_softc), j6x0lcd_match, j6x0lcd_attach, NULL, NULL); static int j6x0lcd_param(void *, int, long, void *); static int j6x0lcd_power(void *, int, long, void *); static int j6x0lcd_contrast_raw(uint16_t, int, const uint8_t *); static void j6x0lcd_contrast_set(struct j6x0lcd_softc *, int); static int j6x0lcd_match(device_t parent, cfdata_t cf, void *aux) { /* * XXX: platid_mask_MACH_HP_LX also matches 360LX. It's not * confirmed whether touch panel in 360LX is connected this * way. We may need to regroup platid masks. */ if (!platid_match(&platid, &platid_mask_MACH_HP_JORNADA_6XX) && !platid_match(&platid, &platid_mask_MACH_HP_LX)) return (0); if (strcmp(cf->cf_name, "j6x0lcd") != 0) return (0); return (1); } static void j6x0lcd_attach(device_t parent, device_t self, void *aux) { struct j6x0lcd_softc *sc; uint16_t bcr, bdr; uint8_t dcr, ddr; aprint_naive("\n"); sc = device_private(self); sc->sc_dev = self; /* * Brightness is controlled by DAC channel 0. */ dcr = DAC_(CR); dcr &= ~SH7709_DACR_DAE; /* want to control each channel separately */ dcr |= SH7709_DACR_DAOE0; /* enable channel 0 */ DAC_(CR) = dcr; ddr = DAC_(DR0); sc->sc_brightness = J6X0LCD_DA_TO_BRIGHTNESS(ddr); /* * Contrast and power are controlled by HD64461 GPIO port B. */ bcr = hd64461_reg_read_2(HD64461_GPBCR_REG16); bdr = hd64461_reg_read_2(HD64461_GPBDR_REG16); /* * Make sure LCD is turned on. */ bcr &= HD64461_GPBCR_J6X0_LCD_OFF_MASK; bcr |= HD64461_GPBCR_J6X0_LCD_OFF_BITS; /* output mode */ bdr &= ~HD64461_GPBDR_J6X0_LCD_OFF; /* * 620LX and 680 have different contrast control. */ if (platid_match(&platid, &platid_mask_MACH_HP_JORNADA_6XX)) { bdr |= HD64461_GPBDR_J680_CONTRAST_BITS; sc->sc_contrast_mask = HD64461_GPBCR_J680_CONTRAST_MASK; sc->sc_contrast_control_bits = j6x0lcd_contrast680_control_bits; sc->sc_contrast_max = arraysize(j6x0lcd_contrast680_control_bits) - 1; sc->sc_contrast = sc->sc_contrast_max - j6x0lcd_contrast_raw(bcr, arraysize(j6x0lcd_contrast680_pins), j6x0lcd_contrast680_pins); } else { bdr &= ~HD64461_GPBDR_J620LX_CONTRAST_BITS; sc->sc_contrast_mask = HD64461_GPBCR_J620LX_CONTRAST_MASK; sc->sc_contrast_control_bits = j6x0lcd_contrast620lx_control_bits; sc->sc_contrast_max = arraysize(j6x0lcd_contrast620lx_control_bits) - 1; sc->sc_contrast = j6x0lcd_contrast_raw(bcr, arraysize(j6x0lcd_contrast620lx_pins), j6x0lcd_contrast620lx_pins); } hd64461_reg_write_2(HD64461_GPBCR_REG16, bcr); hd64461_reg_write_2(HD64461_GPBDR_REG16, bdr); aprint_normal(": brightness %d, contrast %d\n", sc->sc_brightness, sc->sc_contrast); /* LCD brightness hooks */ config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_BRIGHTNESS_MAX, CONFIG_HOOK_SHARE, j6x0lcd_param, sc); config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_BRIGHTNESS, CONFIG_HOOK_SHARE, j6x0lcd_param, sc); config_hook(CONFIG_HOOK_SET, CONFIG_HOOK_BRIGHTNESS, CONFIG_HOOK_SHARE, j6x0lcd_param, sc); /* LCD contrast hooks */ config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_CONTRAST_MAX, CONFIG_HOOK_SHARE, j6x0lcd_param, sc); config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_CONTRAST, CONFIG_HOOK_SHARE, j6x0lcd_param, sc); config_hook(CONFIG_HOOK_SET, CONFIG_HOOK_CONTRAST, CONFIG_HOOK_SHARE, j6x0lcd_param, sc); /* LCD on/off hook */ config_hook(CONFIG_HOOK_POWERCONTROL, CONFIG_HOOK_POWERCONTROL_LCD, CONFIG_HOOK_SHARE, j6x0lcd_power, sc); /* XXX: TODO: don't rely on CONFIG_HOOK_POWERCONTROL_LCD */ if (!pmf_device_register(self, NULL, NULL)) aprint_error_dev(self, "unable to establish power handler\n"); } /* * Get raw contrast value programmed in GPIO port B control register. * Used only at attach time to get initial contrast. */ static int j6x0lcd_contrast_raw(uint16_t bcr, int width, const uint8_t *pin) { int contrast; int bit; contrast = 0; for (bit = 0; bit < width; ++bit) { unsigned int c; c = (bcr >> (pin[bit] << 1)) & 0x3; if (c == 1) /* pin in output mode? */ contrast |= (1 << bit); } return contrast; } /* * Set contrast by programming GPIO port B control register. * Data register has been initialized at attach time. */ static void j6x0lcd_contrast_set(struct j6x0lcd_softc *sc, int contrast) { uint16_t bcr; sc->sc_contrast = contrast; bcr = hd64461_reg_read_2(HD64461_GPBCR_REG16); bcr &= sc->sc_contrast_mask; bcr |= sc->sc_contrast_control_bits[contrast]; hd64461_reg_write_2(HD64461_GPBCR_REG16, bcr); } static int j6x0lcd_param(void *ctx, int type, long id, void *msg) { struct j6x0lcd_softc *sc = ctx; int value; uint8_t dr; switch (type) { case CONFIG_HOOK_GET: switch (id) { case CONFIG_HOOK_CONTRAST: *(int *)msg = sc->sc_contrast; return (0); case CONFIG_HOOK_CONTRAST_MAX: *(int *)msg = sc->sc_contrast_max; return (0); case CONFIG_HOOK_BRIGHTNESS: *(int *)msg = sc->sc_brightness; return (0); case CONFIG_HOOK_BRIGHTNESS_MAX: *(int *)msg = J6X0LCD_BRIGHTNESS_MAX; return (0); } break; case CONFIG_HOOK_SET: value = *(int *)msg; if (value < 0) value = 0; switch (id) { case CONFIG_HOOK_CONTRAST: if (value > sc->sc_contrast_max) value = sc->sc_contrast_max; j6x0lcd_contrast_set(sc, value); return (0); case CONFIG_HOOK_BRIGHTNESS: if (value > J6X0LCD_BRIGHTNESS_MAX) value = J6X0LCD_BRIGHTNESS_MAX; sc->sc_brightness = value; dr = J6X0LCD_BRIGHTNESS_TO_DA(value); DAC_(DR0) = dr; return (0); } break; } return (EINVAL); } static int j6x0lcd_power(void *ctx, int type, long id, void *msg) { int on; uint16_t r; if (type != CONFIG_HOOK_POWERCONTROL || id != CONFIG_HOOK_POWERCONTROL_LCD) return (EINVAL); on = (int)msg; r = hd64461_reg_read_2(HD64461_GPBDR_REG16); if (on) r &= ~HD64461_GPBDR_J6X0_LCD_OFF; else r |= HD64461_GPBDR_J6X0_LCD_OFF; hd64461_reg_write_2(HD64461_GPBDR_REG16, r); return (0); }