/*      $NetBSD: ioexp.c,v 1.2 2018/06/16 21:22:13 thorpej Exp $        */

/*-
 * Copyright (c) 2011 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by NONAKA Kimihiro.
 *
 * 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 NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``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 FOUNDATION OR CONTRIBUTORS
 * 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: ioexp.c,v 1.2 2018/06/16 21:22:13 thorpej Exp $");

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

#include <dev/i2c/i2cvar.h>

#include <arm/xscale/pxa2x0reg.h>
#include <arm/xscale/pxa2x0var.h>
#include <arm/xscale/pxa2x0_i2c.h>

#include <zaurus/zaurus/zaurus_var.h>
#include <zaurus/dev/ioexpreg.h>
#include <zaurus/dev/ioexpvar.h>

#include "ioconf.h"

struct ioexp_softc {
        device_t        sc_dev;
        i2c_tag_t       sc_i2c;

        uint8_t         sc_output;
        uint8_t         sc_direction;

        int             sc_inited;
};

static int ioexp_match(device_t, cfdata_t, void *);
static void ioexp_attach(device_t, device_t, void *);

CFATTACH_DECL_NEW(ioexp, sizeof(struct ioexp_softc), 
    ioexp_match, ioexp_attach, NULL, NULL);

static uint8_t output_init_value = IOEXP_IR_ON | IOEXP_AKIN_PULLUP;
static uint8_t direction_init_value = 0;

static __inline int
ioexp_write(struct ioexp_softc *sc, uint8_t reg, uint8_t val)
{
        uint8_t cmd;
        uint8_t data;
        int error;

        cmd = reg;
        data = val;
        error = iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP, IOEXP_ADDRESS,
            &cmd, 1, &data, 1, 0);
        return error;
}

static int
ioexp_match(device_t parent, cfdata_t cf, void *aux)
{
        struct i2c_attach_args *ia = aux;
        int match_result;

        /* only for SL-C1000 */
        if (!ZAURUS_ISC1000)
                return 0;

        if (iic_use_direct_match(ia, cf, NULL, &match_result))
                return match_result;
        
        /* indirect config - check typical address */
        if (ia->ia_addr == IOEXP_ADDRESS)
                return I2C_MATCH_ADDRESS_ONLY;

        return 0;
}

static void
ioexp_attach(device_t parent, device_t self, void *aux)
{
        struct ioexp_softc *sc = device_private(self);
        struct i2c_attach_args *ia = aux;

        sc->sc_dev = self;
        sc->sc_i2c = ia->ia_tag;

        aprint_normal(": GPIO controller\n");
        aprint_naive("\n");

        sc->sc_output = output_init_value;
        sc->sc_direction = direction_init_value;

        iic_acquire_bus(sc->sc_i2c, 0);
        ioexp_write(sc, IOEXP_POLARITY, 0);
        ioexp_write(sc, IOEXP_OUTPUT, sc->sc_output);
        ioexp_write(sc, IOEXP_DIRECTION, sc->sc_direction);
        iic_release_bus(sc->sc_i2c, 0);

        sc->sc_inited = 1;
}

#if 0
static void
ioexp_gpio_pin_ctl(struct ioexp_softc *sc, uint8_t bit, int flags,
    bool acquire_bus)
{
        int error;

        if (acquire_bus) {
                error = iic_acquire_bus(sc->sc_i2c, 0);
                if (error) {
                        aprint_error_dev(sc->sc_dev,
                            "unable to acquire bus. error=%d\n", error);
                        return;
                }
        }

        switch (flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) {
        case GPIO_PIN_INPUT:
                sc->sc_direction |= bit;
                break;
        case GPIO_PIN_OUTPUT:
                sc->sc_direction &= ~bit;
                break;
        }
        error = ioexp_write(sc, IOEXP_DIRECTION, sc->sc_direction);
        if (error)
                aprint_error_dev(sc->sc_dev,
                    "direction write failed. error=%d\n", error);

        if (acquire_bus)
                iic_release_bus(sc->sc_i2c, 0);
}
#endif

static void
ioexp_gpio_pin_write(struct ioexp_softc *sc, uint8_t bit, int level,
    bool acquire_bus)
{
        int error;

        if (acquire_bus) {
                error = iic_acquire_bus(sc->sc_i2c, 0);
                if (error) {
                        aprint_error_dev(sc->sc_dev,
                            "unable to acquire bus. error=%d\n", error);
                        return;
                }
        }

        if (level == GPIO_PIN_LOW)
                sc->sc_output &= ~bit;
        else
                sc->sc_output |= bit;
        error = ioexp_write(sc, IOEXP_OUTPUT, sc->sc_output);
        if (error)
                aprint_error_dev(sc->sc_dev,
                    "output write failed. error=%d\n", error);

        if (acquire_bus)
                iic_release_bus(sc->sc_i2c, 0);
}

static __inline uint8_t
ioexp_gpio_pin_get(struct ioexp_softc *sc, uint8_t bit)
{

        return sc->sc_output & bit;
}

/*
 * Turn the LCD background light and contrast signal on or off.
 */
void
ioexp_set_backlight(int onoff, int cont)
{
        struct ioexp_softc *sc = device_lookup_private(&ioexp_cd, 0);

        if (sc == NULL || !sc->sc_inited) {
#ifdef DEBUG
                aprint_error("ioexp: %s: not attached or not inited\n",
                    __func__);
#endif
                if (onoff)
                        output_init_value |= IOEXP_BACKLIGHT_ON;
                else
                        output_init_value &= ~IOEXP_BACKLIGHT_ON;
                /* BACKLIGHT_CONT is inverted */
                if (cont)
                        output_init_value &= ~IOEXP_BACKLIGHT_CONT;
                else
                        output_init_value |= IOEXP_BACKLIGHT_CONT;
                return;
        }

        if (sc != NULL) {
                uint8_t bkreg = ioexp_gpio_pin_get(sc, IOEXP_BACKLIGHT_ON);
                uint8_t contreg = ioexp_gpio_pin_get(sc, IOEXP_BACKLIGHT_CONT);

                if (onoff && !bkreg) {
                        ioexp_gpio_pin_write(sc, IOEXP_BACKLIGHT_ON,
                            GPIO_PIN_HIGH, true);
                } else if (!onoff && bkreg) {
                        ioexp_gpio_pin_write(sc, IOEXP_BACKLIGHT_ON,
                            GPIO_PIN_LOW, true);
                }

                /* BACKLIGHT_CONT is inverted */
                if (cont && contreg) {
                        ioexp_gpio_pin_write(sc, IOEXP_BACKLIGHT_CONT,
                            GPIO_PIN_LOW, true);
                } else if (!cont && !contreg) {
                        ioexp_gpio_pin_write(sc, IOEXP_BACKLIGHT_CONT,
                            GPIO_PIN_HIGH, true);
                }
        }
}

/*
 * Turn the infrared LED on or off (must be on while transmitting).
 */
void
ioexp_set_irled(int onoff)
{
        struct ioexp_softc *sc = device_lookup_private(&ioexp_cd, 0);

        if (sc == NULL || !sc->sc_inited) {
#ifdef DEBUG
                aprint_error("ioexp: %s: not attached or not inited\n",
                    __func__);
#endif
                /* IR_ON is inverted */
                if (onoff)
                        output_init_value &= ~IOEXP_IR_ON;
                else
                        output_init_value |= IOEXP_IR_ON;
                return;
        }

        if (sc != NULL) {
                /* IR_ON is inverted */
                uint8_t reg = ioexp_gpio_pin_get(sc, IOEXP_IR_ON);
                if (onoff && reg) {
                        ioexp_gpio_pin_write(sc, IOEXP_IR_ON, GPIO_PIN_LOW,
                            true);
                } else if (!onoff && !reg) {
                        ioexp_gpio_pin_write(sc, IOEXP_IR_ON, GPIO_PIN_HIGH,
                            true);
                }
        }
}

/*
 * Enable or disable the mic bias
 */
void
ioexp_set_mic_bias(int onoff)
{
        struct ioexp_softc *sc = device_lookup_private(&ioexp_cd, 0);

        if (sc == NULL || !sc->sc_inited) {
#ifdef DEBUG
                aprint_error("ioexp: %s: not attached or not inited\n",
                    __func__);
#endif
                if (onoff)
                        output_init_value |= IOEXP_MIC_BIAS;
                else
                        output_init_value &= ~IOEXP_MIC_BIAS;
                return;
        }

        if (sc != NULL) {
                uint8_t reg = ioexp_gpio_pin_get(sc, IOEXP_MIC_BIAS);
                if (onoff && !reg) {
                        ioexp_gpio_pin_write(sc, IOEXP_MIC_BIAS, GPIO_PIN_HIGH,
                            false);
                } else if (!onoff && reg) {
                        ioexp_gpio_pin_write(sc, IOEXP_MIC_BIAS, GPIO_PIN_LOW,
                            false);
                }
        }
}

/*
 * Turn on pullup resistor while not reading the remote control.
 */
void
ioexp_akin_pullup(int onoff)
{
        struct ioexp_softc *sc = device_lookup_private(&ioexp_cd, 0);

        if (sc == NULL || !sc->sc_inited) {
#ifdef DEBUG
                aprint_error("ioexp: %s: not attached or not inited\n",
                    __func__);
#endif
                if (onoff)
                        output_init_value |= IOEXP_AKIN_PULLUP;
                else
                        output_init_value &= ~IOEXP_AKIN_PULLUP;
                return;
        }

        if (sc != NULL) {
                uint8_t reg = ioexp_gpio_pin_get(sc, IOEXP_AKIN_PULLUP);
                if (onoff && !reg) {
                        ioexp_gpio_pin_write(sc, IOEXP_AKIN_PULLUP,
                            GPIO_PIN_HIGH, true);
                } else if (!onoff && reg) {
                        ioexp_gpio_pin_write(sc, IOEXP_AKIN_PULLUP,
                            GPIO_PIN_LOW, true);
                }
        }
}