/*      $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 <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: j6x0lcd.c,v 1.14 2009/04/05 02:23:00 uwe Exp $");

#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/systm.h>

#include <machine/platid.h>
#include <machine/platid_mask.h>

#include <machine/config_hook.h>

#include <sh3/dacreg.h>
#include <hpcsh/dev/hd64461/hd64461var.h> /* XXX: for hd64461_reg_read_2 &c */
#include <hpcsh/dev/hd64461/hd64461reg.h>
#include <hpcsh/dev/hd64461/hd64461gpioreg.h>

#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);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.