/*      $NetBSD: lcdctl.c,v 1.3 2012/01/29 10:12:41 tsutsui Exp $       */

/*-
 * Copyright (C) 2012 NONAKA Kimihiro <nonaka@netbsd.org>
 * 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.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lcdctl.c,v 1.3 2012/01/29 10:12:41 tsutsui Exp $");

#include "ioexp.h"

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

#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wsdisplayvar.h>

#include <zaurus/zaurus/zaurus_var.h>
#include <zaurus/dev/lcdctlvar.h>
#include <zaurus/dev/zsspvar.h>
#include <zaurus/dev/scoopvar.h>
#include <zaurus/dev/ioexpvar.h>

struct lcdctl_backlight {
        int     duty;           /* LZ9JG18 DAC value */
        int     cont;           /* BACKLIGHT_CONT signal */
        int     on;             /* BACKLIGHT_ON signal */
};

struct lcdctl_softc {
        device_t        sc_dev;

        int             sc_brightness;
        int             sc_brightnesscurval;
        bool            sc_islit;
        bool            sc_isblank;

        int             sc_nbacklighttbl;
        const struct lcdctl_backlight *sc_backlighttbl;
};

/* for SL-C1000/SL-C3x00 */
static const struct lcdctl_backlight lcdctl_backlight_c3000[] = {
        { 0x00, 0,  0 },        /* 0:  Off */
        { 0x00, 0,  1 },        /* 1:   0% */
        { 0x01, 0,  1 },        /* 2:  20% */
        { 0x07, 0,  1 },        /* 3:  40% */
        { 0x01, 1,  1 },        /* 4:  60% */
        { 0x07, 1,  1 },        /* 5:  80% */
        { 0x11, 1,  1 }         /* 6: 100% */
};

static int      lcdctl_match(device_t, cfdata_t, void *);
static void     lcdctl_attach(device_t, device_t, void *);

CFATTACH_DECL_NEW(lcdctl, sizeof(struct lcdctl_softc),
        lcdctl_match, lcdctl_attach, NULL, NULL);

static void lcdctl_brightness_up(device_t);
static void lcdctl_brightness_down(device_t);
static void lcdctl_display_on(device_t);
static void lcdctl_display_off(device_t);

static void lcdctl_set_brightness(struct lcdctl_softc *, int);
static void lcdctl_set_blank(struct lcdctl_softc *, bool);
static void lcdctl_set_backlight(struct lcdctl_softc *, bool);

static struct lcdctl_softc *lcdctl_sc;

static int
lcdctl_match(device_t parent, cfdata_t cf, void *aux)
{
        struct zssp_attach_args *aa = aux;

        if (strcmp("lcdctl", aa->zaa_name))
                return 0;

        return 1;
}

static void
lcdctl_attach(device_t parent, device_t self, void *aux)
{
        struct lcdctl_softc *sc = device_private(self);

        sc->sc_dev = self;

        aprint_normal("\n");
        aprint_naive("\n");

        sc->sc_brightness = sc->sc_brightnesscurval = 1;
        sc->sc_islit = true;
        sc->sc_isblank = false;

        if (ZAURUS_ISC1000 || ZAURUS_ISC3000) {
                sc->sc_nbacklighttbl = __arraycount(lcdctl_backlight_c3000);
                sc->sc_backlighttbl = lcdctl_backlight_c3000;
        } else {
                /* XXX: Is this okay for C7x0/860? */
                sc->sc_nbacklighttbl = __arraycount(lcdctl_backlight_c3000);
                sc->sc_backlighttbl = lcdctl_backlight_c3000;
        }

        /* Start with approximately 40% of full brightness. */
        lcdctl_set_brightness(sc, 3);

        lcdctl_sc = sc;

        if (!pmf_event_register(self, PMFE_DISPLAY_BRIGHTNESS_UP,
            lcdctl_brightness_up, true))
                aprint_error_dev(self, "couldn't register event handler\n");
        if (!pmf_event_register(self, PMFE_DISPLAY_BRIGHTNESS_DOWN,
            lcdctl_brightness_down, true))
                aprint_error_dev(self, "couldn't register event handler\n");
        if (!pmf_event_register(self, PMFE_DISPLAY_ON,
            lcdctl_display_on, true))
                aprint_error_dev(self, "couldn't register event handler\n");
        if (!pmf_event_register(self, PMFE_DISPLAY_OFF,
            lcdctl_display_off, true))
                aprint_error_dev(self, "couldn't register event handler\n");
}

static void
lcdctl_brightness_up(device_t dv)
{
        struct lcdctl_softc *sc = device_private(dv);

        lcdctl_set_brightness(sc, sc->sc_brightness + 1);
}

static void
lcdctl_brightness_down(device_t dv)
{
        struct lcdctl_softc *sc = device_private(dv);

        lcdctl_set_brightness(sc, sc->sc_brightness - 1);
}

static void
lcdctl_display_on(device_t dv)
{
        struct lcdctl_softc *sc = device_private(dv);

        lcdctl_set_blank(sc, false);
        lcdctl_set_backlight(sc, true);
}

static void
lcdctl_display_off(device_t dv)
{
        struct lcdctl_softc *sc = device_private(dv);

        lcdctl_set_backlight(sc, false);
        lcdctl_set_blank(sc, true);
}

static __inline void
set_backlight(const struct lcdctl_backlight *bl)
{

        (void) zssp_ic_send(ZSSP_IC_LZ9JG18, bl->duty);
        if (ZAURUS_ISC1000)
                ioexp_set_backlight(bl->on, bl->cont);
        else
                scoop_set_backlight(bl->on, bl->cont);
}

static void
lcdctl_set_brightness_internal(struct lcdctl_softc *sc, int newval)
{
        int i;

        /*
         * It appears that the C3000 backlight can draw too much power if we
         * switch it from a low to a high brightness.  Increasing brightness
         * in steps avoids this issue.
         */
        if (newval > sc->sc_brightnesscurval) {
                for (i = sc->sc_brightnesscurval + 1; i <= newval; i++) {
                        set_backlight(&sc->sc_backlighttbl[i]);
                        delay(5000);
                }
        } else
                set_backlight(&sc->sc_backlighttbl[newval]);

        sc->sc_brightnesscurval = newval;
}

static void
lcdctl_set_brightness(struct lcdctl_softc *sc, int newval)
{
        int maxval = sc->sc_nbacklighttbl - 1;

        if (newval < 0)
                newval = 0;
        else if (newval > maxval)
                newval = maxval;

        if (sc->sc_islit && !sc->sc_isblank)
                lcdctl_set_brightness_internal(sc, newval);

        if (newval > 0)
                sc->sc_brightness = newval;
}

static void
lcdctl_set_backlight(struct lcdctl_softc *sc, bool onoff)
{

        if (!onoff) {
                lcdctl_set_brightness(sc, 0);
                sc->sc_islit = false;
        } else {
                sc->sc_islit = true;
                lcdctl_set_brightness(sc, sc->sc_brightness);
        }
}

static void
lcdctl_set_blank(struct lcdctl_softc *sc, bool isblank)
{

        if (isblank) {
                lcdctl_set_brightness(sc, 0);
                sc->sc_isblank = true;
        } else {
                sc->sc_isblank = false;
                lcdctl_set_brightness(sc, sc->sc_brightness);
        }
}

static void
lcdctl_set_onoff(struct lcdctl_softc *sc, bool onoff)
{

        if (!onoff) {
                lcdctl_set_brightness(sc, 0);
        } else {
                lcdctl_set_brightness(sc, sc->sc_brightness);
        }
}

static int
lcdctl_param_ioctl(struct lcdctl_softc *sc, u_long cmd, struct wsdisplay_param *dp)
{
        int rv = EINVAL;

        switch (dp->param) {
        case WSDISPLAYIO_PARAM_BACKLIGHT:
                if (cmd == WSDISPLAYIO_GETPARAM) {
                        dp->min = 0;
                        dp->max = 1;
                        dp->curval = sc->sc_islit ? 1 : 0;
                        rv = 0;
                } else if (cmd == WSDISPLAYIO_SETPARAM) {
                        lcdctl_set_backlight(sc, dp->curval != 0);
                        rv = 0;
                }
                break;

        case WSDISPLAYIO_PARAM_CONTRAST:
                /* unsupported */
                rv = ENOTTY;
                break;

        case WSDISPLAYIO_PARAM_BRIGHTNESS:
                if (cmd == WSDISPLAYIO_GETPARAM) {
                        dp->min = 1;
                        dp->max = sc->sc_nbacklighttbl - 1;
                        dp->curval = sc->sc_brightness;
                        rv = 0;
                } else if (cmd == WSDISPLAYIO_SETPARAM) {
                        lcdctl_set_brightness(sc, dp->curval);
                        rv = 0;
                }
                break;
        }
        return rv;
}

void
lcdctl_brightness(int newval)
{

        if (__predict_true(lcdctl_sc != NULL))
                lcdctl_set_brightness(lcdctl_sc, newval);
}

void
lcdctl_blank(bool isblank)
{

        if (__predict_true(lcdctl_sc != NULL))
                lcdctl_set_blank(lcdctl_sc, isblank);
}

void
lcdctl_onoff(bool onoff)
{

        if (__predict_true(lcdctl_sc != NULL))
                lcdctl_set_onoff(lcdctl_sc, onoff);
}

int
lcdctl_param(u_long cmd, struct wsdisplay_param *dp)
{

        if (__predict_true(lcdctl_sc != NULL))
                return lcdctl_param_ioctl(lcdctl_sc, cmd, dp);
        return ENOTTY;  /* unsupported */
}