349 lines
9.0 KiB
C
349 lines
9.0 KiB
C
/* $NetBSD: pcagpio.c,v 1.12 2022/02/12 03:24:35 riastradh Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2020 Michael Lorenz
|
|
* 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 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.
|
|
*/
|
|
|
|
/*
|
|
* a driver for Philips Semiconductor PCA9555 GPIO controllers
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__KERNEL_RCSID(0, "$NetBSD: pcagpio.c,v 1.12 2022/02/12 03:24:35 riastradh Exp $");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/device.h>
|
|
#ifdef PCAGPIO_DEBUG
|
|
#include <sys/kernel.h>
|
|
#endif
|
|
#include <sys/conf.h>
|
|
#include <sys/bus.h>
|
|
|
|
#include <dev/i2c/i2cvar.h>
|
|
#include <dev/led.h>
|
|
|
|
#ifdef PCAGPIO_DEBUG
|
|
#define DPRINTF printf
|
|
#else
|
|
#define DPRINTF if (0) printf
|
|
#endif
|
|
|
|
/* commands */
|
|
#define PCAGPIO_INPUT 0x00 /* line status */
|
|
#define PCAGPIO_OUTPUT 0x01 /* output status */
|
|
#define PCAGPIO_REVERT 0x02 /* revert input if set */
|
|
#define PCAGPIO_CONFIG 0x03 /* input if set, output if not */
|
|
|
|
static int pcagpio_match(device_t, cfdata_t, void *);
|
|
static void pcagpio_attach(device_t, device_t, void *);
|
|
static int pcagpio_detach(device_t, int);
|
|
#ifdef PCAGPIO_DEBUG
|
|
static void pcagpio_timeout(void *);
|
|
#endif
|
|
|
|
/* we can only pass one cookie to led_attach() but we need several values... */
|
|
struct pcagpio_led {
|
|
void *cookie;
|
|
struct led_device *led;
|
|
uint32_t mask, v_on, v_off;
|
|
};
|
|
|
|
struct pcagpio_softc {
|
|
device_t sc_dev;
|
|
i2c_tag_t sc_i2c;
|
|
i2c_addr_t sc_addr;
|
|
|
|
int sc_is_16bit;
|
|
uint32_t sc_state;
|
|
struct pcagpio_led sc_leds[16];
|
|
int sc_nleds;
|
|
|
|
#ifdef PCAGPIO_DEBUG
|
|
uint32_t sc_dir, sc_in;
|
|
callout_t sc_timer;
|
|
#endif
|
|
};
|
|
|
|
|
|
static void pcagpio_writereg(struct pcagpio_softc *, int, uint32_t);
|
|
static uint32_t pcagpio_readreg(struct pcagpio_softc *, int);
|
|
static void pcagpio_attach_led(
|
|
struct pcagpio_softc *, char *, int, int, int);
|
|
static int pcagpio_get(void *);
|
|
static void pcagpio_set(void *, int);
|
|
|
|
CFATTACH_DECL_NEW(pcagpio, sizeof(struct pcagpio_softc),
|
|
pcagpio_match, pcagpio_attach, pcagpio_detach, NULL);
|
|
|
|
static const struct device_compatible_entry compat_data[] = {
|
|
{ .compat = "i2c-pca9555", .value = 1 },
|
|
{ .compat = "pca9555", .value = 1 },
|
|
{ .compat = "i2c-pca9556", .value = 0 },
|
|
{ .compat = "pca9556", .value = 0 },
|
|
DEVICE_COMPAT_EOL
|
|
};
|
|
|
|
static int
|
|
pcagpio_match(device_t parent, cfdata_t match, void *aux)
|
|
{
|
|
struct i2c_attach_args *ia = aux;
|
|
int match_result;
|
|
|
|
if (iic_use_direct_match(ia, match, compat_data, &match_result))
|
|
return match_result;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef PCAGPIO_DEBUG
|
|
static void
|
|
printdir(char* name, uint32_t val, uint32_t mask, char letter)
|
|
{
|
|
char flags[17], bits[17];
|
|
uint32_t bit = 0x8000;
|
|
int i;
|
|
|
|
val &= mask;
|
|
for (i = 0; i < 16; i++) {
|
|
flags[i] = (mask & bit) ? letter : '-';
|
|
bits[i] = (val & bit) ? 'X' : ' ';
|
|
bit = bit >> 1;
|
|
}
|
|
flags[16] = 0;
|
|
bits[16] = 0;
|
|
printf("%s: dir: %s\n", name, flags);
|
|
printf("%s: lvl: %s\n", name, bits);
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
pcagpio_attach(device_t parent, device_t self, void *aux)
|
|
{
|
|
struct pcagpio_softc *sc = device_private(self);
|
|
struct i2c_attach_args *ia = aux;
|
|
const struct device_compatible_entry *dce;
|
|
prop_dictionary_t dict = device_properties(self);
|
|
prop_array_t pins;
|
|
prop_dictionary_t pin;
|
|
|
|
sc->sc_dev = self;
|
|
sc->sc_i2c = ia->ia_tag;
|
|
sc->sc_addr = ia->ia_addr;
|
|
sc->sc_nleds = 0;
|
|
|
|
aprint_naive("\n");
|
|
sc->sc_is_16bit = 0;
|
|
if ((dce = iic_compatible_lookup(ia, compat_data)) != NULL)
|
|
sc->sc_is_16bit = dce->value;
|
|
|
|
aprint_normal(": %s\n", sc->sc_is_16bit ? "PCA9555" : "PCA9556");
|
|
|
|
sc->sc_state = pcagpio_readreg(sc, PCAGPIO_OUTPUT);
|
|
|
|
#ifdef PCAGPIO_DEBUG
|
|
uint32_t in, out;
|
|
sc->sc_dir = pcagpio_readreg(sc, PCAGPIO_CONFIG);
|
|
sc->sc_in = pcagpio_readreg(sc, PCAGPIO_INPUT);
|
|
in = sc-> sc_in;
|
|
out = sc->sc_state;
|
|
|
|
out &= ~sc->sc_dir;
|
|
in &= sc->sc_dir;
|
|
|
|
printdir(device_xname(sc->sc_dev), in, sc->sc_dir, 'I');
|
|
printdir(device_xname(sc->sc_dev), out, ~sc->sc_dir, 'O');
|
|
|
|
callout_init(&sc->sc_timer, CALLOUT_MPSAFE);
|
|
callout_reset(&sc->sc_timer, hz*20, pcagpio_timeout, sc);
|
|
|
|
#endif
|
|
|
|
pins = prop_dictionary_get(dict, "pins");
|
|
if (pins != NULL) {
|
|
int i, num, def;
|
|
char name[32];
|
|
const char *spptr, *nptr;
|
|
bool ok = TRUE, act;
|
|
|
|
for (i = 0; i < prop_array_count(pins); i++) {
|
|
nptr = NULL;
|
|
pin = prop_array_get(pins, i);
|
|
ok &= prop_dictionary_get_string(pin, "name",
|
|
&nptr);
|
|
ok &= prop_dictionary_get_uint32(pin, "pin", &num);
|
|
ok &= prop_dictionary_get_bool( pin, "active_high",
|
|
&act);
|
|
/* optional default state */
|
|
def = -1;
|
|
prop_dictionary_get_int32(pin, "default_state", &def);
|
|
if (!ok)
|
|
continue;
|
|
/* Extract pin type from the name */
|
|
spptr = strstr(nptr, " ");
|
|
if (spptr == NULL)
|
|
continue;
|
|
spptr += 1;
|
|
strncpy(name, spptr, 31);
|
|
if (!strncmp(nptr, "LED ", 4))
|
|
pcagpio_attach_led(sc, name, num, act, def);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int
|
|
pcagpio_detach(device_t self, int flags)
|
|
{
|
|
struct pcagpio_softc *sc = device_private(self);
|
|
int i;
|
|
|
|
for (i = 0; i < sc->sc_nleds; i++)
|
|
led_detach(sc->sc_leds[i].led);
|
|
|
|
#ifdef PCAGPIO_DEBUG
|
|
callout_halt(&sc->sc_timer, NULL);
|
|
callout_destroy(&sc->sc_timer);
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef PCAGPIO_DEBUG
|
|
static void
|
|
pcagpio_timeout(void *v)
|
|
{
|
|
struct pcagpio_softc *sc = v;
|
|
uint32_t out, dir, in, o_out, o_in;
|
|
|
|
out = pcagpio_readreg(sc, PCAGPIO_OUTPUT);
|
|
dir = pcagpio_readreg(sc, PCAGPIO_CONFIG);
|
|
in = pcagpio_readreg(sc, PCAGPIO_INPUT);
|
|
if (out != sc->sc_state || dir != sc->sc_dir || in != sc->sc_in) {
|
|
aprint_normal_dev(sc->sc_dev, "status change\n");
|
|
o_out = sc->sc_state;
|
|
o_in = sc->sc_in;
|
|
o_out &= ~sc->sc_dir;
|
|
o_in &= sc->sc_dir;
|
|
printdir(device_xname(sc->sc_dev), o_in, sc->sc_dir, 'I');
|
|
printdir(device_xname(sc->sc_dev), o_out, ~sc->sc_dir, 'O');
|
|
sc->sc_state = out;
|
|
sc->sc_dir = dir;
|
|
sc->sc_in = in;
|
|
out &= ~sc->sc_dir;
|
|
in &= sc->sc_dir;
|
|
printdir(device_xname(sc->sc_dev), in, sc->sc_dir, 'I');
|
|
printdir(device_xname(sc->sc_dev), out, ~sc->sc_dir, 'O');
|
|
}
|
|
callout_reset(&sc->sc_timer, hz*60, pcagpio_timeout, sc);
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
pcagpio_writereg(struct pcagpio_softc *sc, int reg, uint32_t val)
|
|
{
|
|
uint8_t cmd;
|
|
|
|
iic_acquire_bus(sc->sc_i2c, 0);
|
|
if (sc->sc_is_16bit) {
|
|
uint16_t creg;
|
|
cmd = reg << 1;
|
|
creg = htole16(val);
|
|
iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP,
|
|
sc->sc_addr, &cmd, 1, &creg, 2, 0);
|
|
} else {
|
|
uint8_t creg;
|
|
cmd = reg;
|
|
creg = (uint8_t)val;
|
|
iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP,
|
|
sc->sc_addr, &cmd, 1, &creg, 1, 0);
|
|
}
|
|
if (reg == PCAGPIO_OUTPUT) sc->sc_state = val;
|
|
iic_release_bus(sc->sc_i2c, 0);
|
|
}
|
|
|
|
static uint32_t pcagpio_readreg(struct pcagpio_softc *sc, int reg)
|
|
{
|
|
uint8_t cmd;
|
|
uint32_t ret;
|
|
|
|
iic_acquire_bus(sc->sc_i2c, 0);
|
|
if (sc->sc_is_16bit) {
|
|
uint16_t creg;
|
|
cmd = reg << 1;
|
|
iic_exec(sc->sc_i2c, I2C_OP_READ_WITH_STOP,
|
|
sc->sc_addr, &cmd, 1, &creg, 2, 0);
|
|
ret = le16toh(creg);
|
|
} else {
|
|
uint8_t creg;
|
|
cmd = reg;
|
|
iic_exec(sc->sc_i2c, I2C_OP_READ_WITH_STOP,
|
|
sc->sc_addr, &cmd, 1, &creg, 1, 0);
|
|
ret = creg;
|
|
}
|
|
iic_release_bus(sc->sc_i2c, 0);
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
pcagpio_attach_led(struct pcagpio_softc *sc, char *n, int pin, int act, int def)
|
|
{
|
|
struct pcagpio_led *l;
|
|
|
|
l = &sc->sc_leds[sc->sc_nleds];
|
|
l->cookie = sc;
|
|
l->mask = 1 << pin;
|
|
l->v_on = act ? l->mask : 0;
|
|
l->v_off = act ? 0 : l->mask;
|
|
l->led = led_attach(n, l, pcagpio_get, pcagpio_set);
|
|
if (def != -1) pcagpio_set(l, def);
|
|
DPRINTF("%s: %04x %04x %04x def %d\n",
|
|
__func__, l->mask, l->v_on, l->v_off, def);
|
|
sc->sc_nleds++;
|
|
}
|
|
|
|
static int
|
|
pcagpio_get(void *cookie)
|
|
{
|
|
struct pcagpio_led *l = cookie;
|
|
struct pcagpio_softc *sc = l->cookie;
|
|
|
|
return ((sc->sc_state & l->mask) == l->v_on);
|
|
}
|
|
|
|
static void
|
|
pcagpio_set(void *cookie, int val)
|
|
{
|
|
struct pcagpio_led *l = cookie;
|
|
struct pcagpio_softc *sc = l->cookie;
|
|
uint32_t newstate;
|
|
|
|
newstate = sc->sc_state & ~l->mask;
|
|
newstate |= val ? l->v_on : l->v_off;
|
|
DPRINTF("%s: %04x -> %04x, %04x %04x %04x\n", __func__,
|
|
sc->sc_state, newstate, l->mask, l->v_on, l->v_off);
|
|
if (newstate != sc->sc_state)
|
|
pcagpio_writereg(sc, PCAGPIO_OUTPUT, newstate);
|
|
}
|