/*      $NetBSD: scoop.c,v 1.13 2014/09/23 14:49:46 nonaka Exp $        */
/*      $OpenBSD: zaurus_scoop.c,v 1.12 2005/11/17 05:26:31 uwe Exp $   */

/*
* Copyright (c) 2005 Uwe Stuehler <[email protected]>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: scoop.c,v 1.13 2014/09/23 14:49:46 nonaka Exp $");

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

#include <arm/xscale/pxa2x0var.h>

#include <zaurus/zaurus/zaurus_reg.h>
#include <zaurus/zaurus/zaurus_var.h>

#include <zaurus/dev/scoopreg.h>
#include <zaurus/dev/scoopvar.h>

#include "ioconf.h"

struct scoop_softc {
       device_t                sc_dev;

       bus_space_tag_t         sc_iot;
       bus_space_handle_t      sc_ioh;

       uint16_t                sc_gpwr;        /* GPIO state before suspend */
};

static int      scoopmatch(device_t, cfdata_t, void *);
static void     scoopattach(device_t, device_t, void *);

CFATTACH_DECL_NEW(scoop, sizeof(struct scoop_softc),
   scoopmatch, scoopattach, NULL, NULL);

#if 0
static int      scoop_gpio_pin_read(struct scoop_softc *, int);
#endif
static void     scoop_gpio_pin_write(struct scoop_softc *, int, int);
static void     scoop_gpio_pin_ctl(struct scoop_softc *, int, int);

static struct scoop_softc *backlight_sc;
static uint8_t backlight_on_init = 1;
static uint8_t backlight_cont_init = 0;

enum scoop_card {
       SD_CARD,
       CF_CARD         /* socket 0 (external) */
};

static void     scoop0_set_card_power(enum scoop_card card, int new_cpr);

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

       /*
        * Only C3000-like models are known to have two SCOOPs.
        */
       if (ZAURUS_ISC3000)
               return (cf->cf_unit < 2);
       return (cf->cf_unit == 0);
}

static void
scoopattach(device_t parent, device_t self, void *aux)
{
       struct scoop_softc *sc = device_private(self);
       struct pxaip_attach_args *pxa = aux;
       bus_addr_t addr;
       bus_size_t size;

       sc->sc_dev = self;
       sc->sc_iot = pxa->pxa_iot;

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

       if (pxa->pxa_addr != -1)
               addr = pxa->pxa_addr;
       else if (device_unit(sc->sc_dev) == 0)
               addr = C3000_SCOOP0_BASE;
       else
               addr = C3000_SCOOP1_BASE;

       size = pxa->pxa_size < SCOOP_SIZE ? SCOOP_SIZE : pxa->pxa_size;

       if (bus_space_map(sc->sc_iot, addr, size, 0, &sc->sc_ioh) != 0) {
               aprint_error_dev(sc->sc_dev, "couldn't map registers\n");
               return;
       }

       if (ZAURUS_ISC3000 && device_unit(sc->sc_dev) == 1) {
               scoop_gpio_pin_ctl(sc, SCOOP1_AKIN_PULLUP, GPIO_PIN_OUTPUT);
               scoop_gpio_pin_write(sc, SCOOP1_AKIN_PULLUP, GPIO_PIN_LOW);
               backlight_sc = sc;
               scoop_set_backlight(backlight_on_init, backlight_cont_init);
       } else if (ZAURUS_ISC860) {
               scoop_gpio_pin_ctl(sc, SCOOP0_AKIN_PULLUP, GPIO_PIN_OUTPUT);
               scoop_gpio_pin_write(sc, SCOOP0_AKIN_PULLUP, GPIO_PIN_LOW);
               backlight_sc = sc;
               scoop_set_backlight(backlight_on_init, backlight_cont_init);
       }
}

#if 0
static int
scoop_gpio_pin_read(struct scoop_softc *sc, int pin)
{
       uint16_t bit = (1 << pin);
       uint16_t rv;

       rv = bus_space_read_2(sc->sc_iot, sc->sc_ioh, SCOOP_GPWR);
       return (rv & bit) ? 1 : 0;
}
#endif

static void
scoop_gpio_pin_write(struct scoop_softc *sc, int pin, int level)
{
       uint16_t bit = (1 << pin);
       uint16_t rv;

       rv = bus_space_read_2(sc->sc_iot, sc->sc_ioh, SCOOP_GPWR);
       bus_space_write_2(sc->sc_iot, sc->sc_ioh, SCOOP_GPWR,
           (level == GPIO_PIN_LOW) ? (rv & ~bit) : (rv | bit));
}

static void
scoop_gpio_pin_ctl(struct scoop_softc *sc, int pin, int flags)
{
       uint16_t bit = (1 << pin);
       uint16_t rv;

       rv = bus_space_read_2(sc->sc_iot, sc->sc_ioh, SCOOP_GPCR);
       switch (flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) {
       case GPIO_PIN_INPUT:
               rv &= ~bit;
               break;
       case GPIO_PIN_OUTPUT:
               rv |= bit;
               break;
       }
       bus_space_write_2(sc->sc_iot, sc->sc_ioh, SCOOP_GPCR, rv);
}

/*
* Turn the LCD background light and contrast signal on or off.
*/
void
scoop_set_backlight(int on, int cont)
{
       struct scoop_softc *sc = backlight_sc;

       if (sc == NULL) {
               backlight_cont_init = cont;
               backlight_on_init = on;
       } else {
               if (ZAURUS_ISC3000) {
                       scoop_gpio_pin_write(sc, SCOOP1_BACKLIGHT_CONT, !cont);
                       scoop_gpio_pin_write(sc, SCOOP1_BACKLIGHT_ON, on);
               } else if (ZAURUS_ISC860) {
                       scoop_gpio_pin_write(sc, SCOOP0_BACKLIGHT_CONT, cont);
               }
       }
}

/*
* Turn the infrared LED on or off (must be on while transmitting).
*/
void
scoop_set_irled(int on)
{
       struct scoop_softc *sc;

       sc = device_lookup_private(&scoop_cd, 1);
       if (sc != NULL) {
               /* IR_ON is inverted */
               scoop_gpio_pin_write(sc, SCOOP1_IR_ON, !on);
       }
}

/*
* Turn the green and orange LEDs on or off.  If the orange LED is on,
* then it is wired to indicate if A/C is connected.  The green LED has
* no such predefined function.
*/
void
scoop_led_set(int led, int on)
{
       struct scoop_softc *sc;

       sc = device_lookup_private(&scoop_cd, 0);
       if (sc != NULL) {
               if ((led & SCOOP_LED_GREEN) != 0) {
                       scoop_gpio_pin_write(sc, SCOOP0_LED_GREEN, on);
               }
               if (scoop_cd.cd_ndevs > 1 && (led & SCOOP_LED_ORANGE) != 0) {
                       scoop_gpio_pin_write(sc, SCOOP0_LED_ORANGE_C3000, on);
               }
       }
}

/*
* Enable or disable the headphone output connection.
*/
void
scoop_set_headphone(int on)
{
       struct scoop_softc *sc;

       sc = device_lookup_private(&scoop_cd, 0);
       if (sc == NULL)
               return;

       scoop_gpio_pin_ctl(sc, SCOOP0_MUTE_L, GPIO_PIN_OUTPUT);
       scoop_gpio_pin_ctl(sc, SCOOP0_MUTE_R, GPIO_PIN_OUTPUT);

       if (on) {
               scoop_gpio_pin_write(sc, SCOOP0_MUTE_L, GPIO_PIN_HIGH);
               scoop_gpio_pin_write(sc, SCOOP0_MUTE_R, GPIO_PIN_HIGH);
       } else {
               scoop_gpio_pin_write(sc, SCOOP0_MUTE_L, GPIO_PIN_LOW);
               scoop_gpio_pin_write(sc, SCOOP0_MUTE_R, GPIO_PIN_LOW);
       }
}

/*
* Enable or disable the speaker output connection.
*/
void
scoop_set_speaker(int onoff)
{
       struct scoop_softc *sc;

       if (!ZAURUS_ISC860)
               return;

       sc = device_lookup_private(&scoop_cd, 0);
       if (sc == NULL)
               return;

       scoop_gpio_pin_ctl(sc, SCOOP0_AMP_ON, GPIO_PIN_OUTPUT);
       if (onoff) {
               scoop_gpio_pin_write(sc, SCOOP0_AMP_ON, GPIO_PIN_HIGH);
       } else {
               scoop_gpio_pin_write(sc, SCOOP0_AMP_ON, GPIO_PIN_LOW);
       }
}

/*
* Enable or disable the mic bias
*/
void
scoop_set_mic_bias(int onoff)
{
       struct scoop_softc *sc0;
       struct scoop_softc *sc1;

       sc0 = device_lookup_private(&scoop_cd, 0);
       sc1 = device_lookup_private(&scoop_cd, 1);

       if (sc1 != NULL) {
               scoop_gpio_pin_write(sc1, SCOOP1_MIC_BIAS, onoff);
       } else if (sc0 != NULL) {
               scoop_gpio_pin_write(sc0, SCOOP0_MIC_BIAS, onoff);
       }
}

/*
* Turn on pullup resistor while not reading the remote control.
*/
void
scoop_akin_pullup(int enable)
{
       struct scoop_softc *sc0;
       struct scoop_softc *sc1;

       sc0 = device_lookup_private(&scoop_cd, 0);
       sc1 = device_lookup_private(&scoop_cd, 1);

       if (sc1 != NULL) {
               scoop_gpio_pin_write(sc1, SCOOP1_AKIN_PULLUP, enable);
       } else if (sc0 != NULL) {
               scoop_gpio_pin_write(sc0, SCOOP0_AKIN_PULLUP, enable);
       }
}

void
scoop_battery_temp_adc(int enable)
{
       struct scoop_softc *sc;

       sc = device_lookup_private(&scoop_cd, 0);

       if (sc != NULL) {
               scoop_gpio_pin_write(sc, SCOOP0_ADC_TEMP_ON_C3000, enable);
       }
}

void
scoop_charge_battery(int enable, int voltage_high)
{
       struct scoop_softc *sc;

       if (ZAURUS_ISC860)
               return;

       sc = device_lookup_private(&scoop_cd, 0);

       if (sc != NULL) {
               scoop_gpio_pin_write(sc, SCOOP0_JK_B_C3000, voltage_high);
               scoop_gpio_pin_write(sc, SCOOP0_CHARGE_OFF_C3000, !enable);
       }
}

void
scoop_discharge_battery(int enable)
{
       struct scoop_softc *sc;

       if (ZAURUS_ISC860)
               return;

       sc = device_lookup_private(&scoop_cd, 0);

       if (sc != NULL) {
               scoop_gpio_pin_write(sc, SCOOP0_JK_A_C3000, enable);
       }
}

/*
* Enable or disable 3.3V power to the SD/MMC card slot.
*/
void
scoop_set_sdmmc_power(int on)
{

       scoop0_set_card_power(SD_CARD, on ? SCP_CPR_SD_3V : SCP_CPR_OFF);
}

/*
* The Card Power Register of the first SCOOP unit controls the power
* for the first CompactFlash slot and the SD/MMC card slot as well.
*/
void
scoop0_set_card_power(enum scoop_card card, int new_cpr)
{
       struct scoop_softc *sc;
       bus_space_tag_t iot;
       bus_space_handle_t ioh;
       uint16_t cpr;

       if (ZAURUS_ISC860)
               return;

       sc = device_lookup_private(&scoop_cd, 0);
       if (sc == NULL)
               return;

       iot = sc->sc_iot;
       ioh = sc->sc_ioh;

       cpr = bus_space_read_2(iot, ioh, SCOOP_CPR);
       if (new_cpr & SCP_CPR_VOLTAGE_MSK) {
               if (card == CF_CARD)
                       cpr |= SCP_CPR_5V;
               else if (card == SD_CARD)
                       cpr |= SCP_CPR_SD_3V;

               scoop_gpio_pin_write(sc, SCOOP0_CF_POWER_C3000, 1);
               if (!ISSET(cpr, SCP_CPR_5V) && !ISSET(cpr, SCP_CPR_SD_3V))
                       delay(5000);
               bus_space_write_2(iot, ioh, SCOOP_CPR, cpr | new_cpr);
       } else {
               if (card == CF_CARD)
                       cpr &= ~SCP_CPR_5V;
               else if (card == SD_CARD)
                       cpr &= ~SCP_CPR_SD_3V;

               if (!ISSET(cpr, SCP_CPR_5V) && !ISSET(cpr, SCP_CPR_SD_3V)) {
                       bus_space_write_2(iot, ioh, SCOOP_CPR, SCP_CPR_OFF);
                       delay(1000);
                       scoop_gpio_pin_write(sc, SCOOP0_CF_POWER_C3000, 0);
               } else
                       bus_space_write_2(iot, ioh, SCOOP_CPR, cpr | new_cpr);
       }
}

void
scoop_check_mcr(void)
{
       struct scoop_softc *sc0, *sc1, *sc;
       uint16_t v;

       sc0 = device_lookup_private(&scoop_cd, 0);
       sc1 = device_lookup_private(&scoop_cd, 1);

       /* C3000 */
       if (sc1 != NULL) {
               sc = sc0;
               v = bus_space_read_2(sc->sc_iot, sc->sc_ioh, SCOOP_MCR);
               if ((v & 0x100) == 0) {
                       bus_space_write_2(sc->sc_iot, sc->sc_ioh, SCOOP_MCR,
                           0x0101);
               }

               sc = sc1;
               v = bus_space_read_2(sc->sc_iot, sc->sc_ioh, SCOOP_MCR);
               if ((v & 0x100) == 0) {
                       bus_space_write_2(sc->sc_iot, sc->sc_ioh, SCOOP_MCR,
                           0x0101);
               }
       }
}

void
scoop_suspend(void)
{
       struct scoop_softc *sc, *sc0, *sc1;
       uint32_t rv;

       if (ZAURUS_ISC860)
               return;

       sc0 = device_lookup_private(&scoop_cd, 0);
       sc1 = device_lookup_private(&scoop_cd, 1);

       if (sc0 != NULL) {
               sc = sc0;
               sc->sc_gpwr = bus_space_read_2(sc->sc_iot, sc->sc_ioh,
                   SCOOP_GPWR);
               /* C3000 */
               bus_space_write_2(sc->sc_iot, sc->sc_ioh, SCOOP_GPWR,
                   sc->sc_gpwr & ~((1<<SCOOP0_MUTE_L) | (1<<SCOOP0_MUTE_R) |
                   (1<<SCOOP0_JK_A_C3000) | (1<<SCOOP0_ADC_TEMP_ON_C3000) |
                   (1<<SCOOP0_LED_GREEN)));
       }

       /* C3000 */
       if (sc1 != NULL) {
               sc = sc1;
               sc->sc_gpwr = bus_space_read_2(sc->sc_iot, sc->sc_ioh,
                   SCOOP_GPWR);
               bus_space_write_2(sc->sc_iot, sc->sc_ioh, SCOOP_GPWR,
                   sc->sc_gpwr & ~((1<<SCOOP1_RESERVED_4) |
                   (1<<SCOOP1_RESERVED_5) | (1<<SCOOP1_RESERVED_6) |
                   (1<<SCOOP1_BACKLIGHT_CONT) | (1<<SCOOP1_BACKLIGHT_ON) |
                   (1<<SCOOP1_MIC_BIAS)));
               rv = bus_space_read_2(sc->sc_iot, sc->sc_ioh, SCOOP_GPWR);
               bus_space_write_2(sc->sc_iot, sc->sc_ioh, SCOOP_GPWR,
                   rv | ((1<<SCOOP1_IR_ON) | (1<<SCOOP1_RESERVED_3)));
       }
}

void
scoop_resume(void)
{
       struct scoop_softc *sc, *sc0, *sc1;

       sc0 = device_lookup_private(&scoop_cd, 0);
       sc1 = device_lookup_private(&scoop_cd, 1);

       if (sc0 != NULL) {
               sc = sc0;
               bus_space_write_2(sc->sc_iot, sc->sc_ioh, SCOOP_GPWR,
                   sc->sc_gpwr);
       }

       if (sc1 != NULL) {
               sc = sc1;
               bus_space_write_2(sc->sc_iot, sc->sc_ioh, SCOOP_GPWR,
                   sc->sc_gpwr);
       }
}

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.