/*      $NetBSD: teliosio.c,v 1.4 2012/10/27 17:17:53 chs Exp $ */

/*
* Copyright (c) 2005 Takeshi Nakayama.
* 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.
*
* 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.
*/

/*
* Sharp Telios machine dependent I/O (LCD backlight/Battery unit) driver
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: teliosio.c,v 1.4 2012/10/27 17:17:53 chs Exp $");

#include "apmdev.h"

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

#include <machine/bus.h>
#include <machine/config_hook.h>

#include <hpcmips/tx/tx39var.h>
#include <hpcmips/tx/txcsbusvar.h>

#if NAPMDEV > 0
#include <dev/apm/apmbios.h>
#define __TX39IO_PRIVATE
#include <hpcmips/tx/tx39ioreg.h>
#include <hpcmips/tx/tx39timerreg.h>
#endif

#include <hpcmips/dev/teliosioreg.h>

struct teliosio_softc {
       tx_chipset_tag_t sc_tc;
       bus_space_tag_t sc_regt;
       bus_space_handle_t sc_regh;

       int sc_backlight;
       int sc_brightness;
#define MAX_BRIGHTNESS 9
#define BRIGHTNESSVAL(n) \
       ((n) <= 0 ? 0 : ((n) <= MAX_BRIGHTNESS ? (n) : MAX_BRIGHTNESS) * 9 - 1)
};

static int teliosio_match(device_t, cfdata_t, void *);
static void teliosio_attach(device_t, device_t, void *);
static int teliosio_event(void *, int, long, void *);

/* LCD backlight control */
static void teliosio_backlight(struct teliosio_softc *, int);
static void teliosio_brightness(struct teliosio_softc *, int);

/* Battery unit control */
#if NAPMDEV > 0
static int teliosio_ac_state(struct teliosio_softc *);
static int teliosio_mbu_state(struct teliosio_softc *);
static void teliosio_mbu_write(tx_chipset_tag_t, int);
static int teliosio_mbu_read(tx_chipset_tag_t);
#endif

CFATTACH_DECL_NEW(teliosio, sizeof(struct teliosio_softc),
             teliosio_match, teliosio_attach, NULL, NULL);

static int
teliosio_match(device_t parent, cfdata_t cf, void *aux)
{

       return 2;       /* attach before plumvideo */
}

static void
teliosio_attach(device_t parent, device_t self, void *aux)
{
       struct cs_attach_args *ca = aux;
       struct teliosio_softc *sc = device_private(self);

       sc->sc_tc = ca->ca_tc;
       sc->sc_regt = ca->ca_csreg.cstag;

       if (bus_space_map(sc->sc_regt, TELIOSIO_REGBASE, TELIOSIO_REGSIZE,
                         0, &sc->sc_regh)) {
               printf(": register map failed\n");
               return;
       }
       printf("\n");

       sc->sc_backlight = 1;
       sc->sc_brightness = MAX_BRIGHTNESS;

       config_hook(CONFIG_HOOK_SET, CONFIG_HOOK_POWER_LCDLIGHT,
                   CONFIG_HOOK_SHARE, teliosio_event, sc);
       config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_POWER_LCDLIGHT,
                   CONFIG_HOOK_SHARE, teliosio_event, sc);
       config_hook(CONFIG_HOOK_SET, CONFIG_HOOK_BRIGHTNESS,
                   CONFIG_HOOK_SHARE, teliosio_event, sc);
       config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_BRIGHTNESS,
                   CONFIG_HOOK_SHARE, teliosio_event, sc);
       config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_BRIGHTNESS_MAX,
                   CONFIG_HOOK_SHARE, teliosio_event, sc);
#if NAPMDEV > 0
       config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_ACADAPTER,
                   CONFIG_HOOK_SHARE, teliosio_event, sc);
       config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_BATTERYVAL,
                   CONFIG_HOOK_SHARE, teliosio_event, sc);
#endif
}

static int
teliosio_event(void *ctx, int type, long id, void *msg)
{
       struct teliosio_softc *sc = ctx;

       switch (type) {
       case CONFIG_HOOK_SET:
               switch (id) {
               case CONFIG_HOOK_POWER_LCDLIGHT:
                       teliosio_backlight(sc, (int)msg);
                       break;
               case CONFIG_HOOK_BRIGHTNESS:
                       teliosio_brightness(sc, *(int *)msg + 1);
                       break;
               default:
                       return 1;
               }
               break;
       case CONFIG_HOOK_GET:
               switch (id) {
               case CONFIG_HOOK_POWER_LCDLIGHT:
                       *(int *)msg = sc->sc_backlight;
                       break;
               case CONFIG_HOOK_BRIGHTNESS:
                       *(int *)msg = sc->sc_brightness - 1;
                       break;
               case CONFIG_HOOK_BRIGHTNESS_MAX:
                       *(int *)msg = MAX_BRIGHTNESS - 1;
                       break;
#if NAPMDEV > 0
               case CONFIG_HOOK_ACADAPTER:
                       *(int *)msg = teliosio_ac_state(sc);
                       break;
               case CONFIG_HOOK_BATTERYVAL:
                       *(int *)msg = teliosio_mbu_state(sc) / 2;
                       break;
#endif
               default:
                       return 1;
               }
               break;
       default:
               return 1;
       }

       return 0;
}

/*
* LCD backlight control
*/
static void
teliosio_backlight(struct teliosio_softc *sc, int on)
{
       int brightness;

       sc->sc_backlight = on;
       if (on) {
               teliosio_brightness(sc, sc->sc_brightness);
       } else {
               brightness = sc->sc_brightness;
               teliosio_brightness(sc, 0);
               sc->sc_brightness = brightness;
       }
}

static void
teliosio_brightness(struct teliosio_softc *sc, int val)
{
       bus_space_tag_t regt = sc->sc_regt;
       bus_space_handle_t regh = sc->sc_regh;
       u_int16_t period;

       if (val < 0)
               val = 0;
       else if (val > MAX_BRIGHTNESS)
               val = MAX_BRIGHTNESS;
       sc->sc_brightness = val;

       period = bus_space_read_2(regt, regh, TELIOSIO_BACKLIGHT_PERIOD);
       if (val)
               period |= TELIOSIO_BACKLIGHT_PERIOD_EN;
       else
               period &= ~TELIOSIO_BACKLIGHT_PERIOD_EN;
       bus_space_write_2(regt, regh, TELIOSIO_BACKLIGHT_PERIOD, period);
       bus_space_write_2(regt, regh, TELIOSIO_BACKLIGHT_RESET,
                         BRIGHTNESSVAL(val));
}

/*
* Battery unit control
*/
#if NAPMDEV > 0
static int
teliosio_ac_state(struct teliosio_softc *sc)
{
       tx_chipset_tag_t tc = sc->sc_tc;
       txreg_t reg;

       reg = tx_conf_read(tc, TX392X_IODATAINOUT_REG);
       return (reg & TELIOSIO_AC_STATE) ? APM_AC_OFF : APM_AC_ON;
}

static int
teliosio_mbu_state(struct teliosio_softc *sc)
{
       tx_chipset_tag_t tc = sc->sc_tc;
       int val;

       teliosio_mbu_write(tc, 0x00);
       delay(7000);
       val = teliosio_mbu_read(tc);
       delay(7000);

       return val;
}

#define WAIT (1000000 / TELIOSIO_BMU_CLOCK_FREQ / 2)

static void
teliosio_mbu_write(tx_chipset_tag_t tc, int val)
{
       txreg_t reg;
       int s;
       int mask;

       for (mask = 0x80; mask != 0; mask >>= 1) {
               s = splhigh();
               reg = tx_conf_read(tc, TX392X_IODATAINOUT_REG);
               reg |= TELIOSIO_BMU_CLOCK;
               if (val & mask)
                       reg |= TELIOSIO_BMU_DATAOUT;
               else
                       reg &= ~TELIOSIO_BMU_DATAOUT;
               tx_conf_write(tc, TX392X_IODATAINOUT_REG, reg);
               splx(s);
               delay(WAIT);

               s = splhigh();
               reg = tx_conf_read(tc, TX392X_IODATAINOUT_REG);
               reg &= ~TELIOSIO_BMU_CLOCK;
               tx_conf_write(tc, TX392X_IODATAINOUT_REG, reg);
               splx(s);
               delay(WAIT);
       }
}

static int
teliosio_mbu_read(tx_chipset_tag_t tc)
{
       txreg_t reg;
       int s;
       int mask, val;

       val = 0;
       for (mask = 0x80; mask != 0; mask >>= 1) {
               s = splhigh();
               reg = tx_conf_read(tc, TX392X_IODATAINOUT_REG);
               reg |= TELIOSIO_BMU_CLOCK;
               tx_conf_write(tc, TX392X_IODATAINOUT_REG, reg);
               splx(s);
               delay(WAIT);

               s = splhigh();
               reg = tx_conf_read(tc, TX392X_IODATAINOUT_REG);
               if (!(reg & TELIOSIO_BMU_DATAIN))
                       val |= mask;
               reg &= ~TELIOSIO_BMU_CLOCK;
               tx_conf_write(tc, TX392X_IODATAINOUT_REG, reg);
               splx(s);
               delay(WAIT);
       }

       return val;
}
#endif /* NAPMDEV */

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.