src/sys/dev/isa/gscsio.c

439 lines
11 KiB
C

/* $OpenBSD: gscsio.c,v 1.14 2022/04/06 18:59:28 naddy Exp $ */
/*
* Copyright (c) 2004 Alexander Yurchenko <grange@openbsd.org>
*
* 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.
*/
/*
* National Semiconductor Geode SC1100 Super I/O.
* Only ACCESS.bus logical device is supported.
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/kernel.h>
#include <sys/rwlock.h>
#include <machine/bus.h>
#include <dev/i2c/i2cvar.h>
#include <dev/isa/isareg.h>
#include <dev/isa/isavar.h>
#include <dev/isa/gscsioreg.h>
struct gscsio_softc {
struct device sc_dev;
bus_space_tag_t sc_iot;
bus_space_handle_t sc_ioh;
int sc_ld_en[GSCSIO_LDN_LAST + 1];
bus_space_handle_t sc_ld_ioh0[GSCSIO_LDN_LAST + 1];
bus_space_handle_t sc_ld_ioh1[GSCSIO_LDN_LAST + 1];
/* ACCESS.bus */
struct gscsio_acb {
void *sc;
bus_space_handle_t ioh;
struct rwlock buslock;
} sc_acb[2];
struct i2c_controller sc_acb1_tag;
struct i2c_controller sc_acb2_tag;
};
/* Supported logical devices description */
static const struct {
const char *ld_name;
int ld_num;
int ld_iosize0;
int ld_iosize1;
} gscsio_ld[] = {
{ "ACB1", GSCSIO_LDN_ACB1, 6, 0 },
{ "ACB2", GSCSIO_LDN_ACB2, 6, 0 },
};
int gscsio_probe(struct device *, void *, void *);
void gscsio_attach(struct device *, struct device *, void *);
void gscsio_acb_init(struct gscsio_acb *, i2c_tag_t);
int gscsio_acb_wait(struct gscsio_acb *, int, int);
void gscsio_acb_reset(struct gscsio_acb *acb);
int gscsio_acb_acquire_bus(void *, int);
void gscsio_acb_release_bus(void *, int);
int gscsio_acb_send_start(void *, int);
int gscsio_acb_send_stop(void *, int);
int gscsio_acb_initiate_xfer(void *, i2c_addr_t, int);
int gscsio_acb_read_byte(void *, uint8_t *, int);
int gscsio_acb_write_byte(void *, uint8_t, int);
const struct cfattach gscsio_ca = {
sizeof(struct gscsio_softc),
gscsio_probe,
gscsio_attach
};
struct cfdriver gscsio_cd = {
NULL, "gscsio", DV_DULL
};
#define ACB_READ(reg) \
bus_space_read_1(sc->sc_iot, acb->ioh, (reg))
#define ACB_WRITE(reg, val) \
bus_space_write_1(sc->sc_iot, acb->ioh, (reg), (val))
static __inline u_int8_t
idxread(bus_space_tag_t iot, bus_space_handle_t ioh, int idx)
{
bus_space_write_1(iot, ioh, GSCSIO_IDX, idx);
return (bus_space_read_1(iot, ioh, GSCSIO_DAT));
}
static __inline void
idxwrite(bus_space_tag_t iot, bus_space_handle_t ioh, int idx, u_int8_t data)
{
bus_space_write_1(iot, ioh, GSCSIO_IDX, idx);
bus_space_write_1(iot, ioh, GSCSIO_DAT, data);
}
int
gscsio_probe(struct device *parent, void *match, void *aux)
{
struct isa_attach_args *ia = aux;
bus_space_tag_t iot;
bus_space_handle_t ioh;
int iobase;
int rv = 0;
iot = ia->ia_iot;
iobase = ia->ipa_io[0].base;
if (bus_space_map(iot, iobase, GSCSIO_IOSIZE, 0, &ioh))
return (0);
if (idxread(iot, ioh, GSCSIO_ID) == GSCSIO_ID_SC1100)
rv = 1;
bus_space_unmap(iot, ioh, GSCSIO_IOSIZE);
if (rv) {
ia->ipa_nio = 1;
ia->ipa_io[0].length = GSCSIO_IOSIZE;
ia->ipa_nmem = 0;
ia->ipa_nirq = 0;
ia->ipa_ndrq = 0;
}
return (rv);
}
void
gscsio_attach(struct device *parent, struct device *self, void *aux)
{
struct gscsio_softc *sc = (void *)self;
struct isa_attach_args *ia = aux;
int i;
int iobase;
sc->sc_iot = ia->ia_iot;
if (bus_space_map(sc->sc_iot, ia->ipa_io[0].base, GSCSIO_IOSIZE,
0, &sc->sc_ioh)) {
printf(": can't map i/o space\n");
return;
}
printf(": SC1100 SIO rev %d:",
idxread(sc->sc_iot, sc->sc_ioh, GSCSIO_REV));
/* Configure all supported logical devices */
for (i = 0; i < sizeof (gscsio_ld) / sizeof(gscsio_ld[0]); i++) {
sc->sc_ld_en[gscsio_ld[i].ld_num] = 0;
/* Select the device and check if it's activated */
idxwrite(sc->sc_iot, sc->sc_ioh, GSCSIO_LDN,
gscsio_ld[i].ld_num);
if ((idxread(sc->sc_iot, sc->sc_ioh, GSCSIO_ACT) &
GSCSIO_ACT_EN) == 0)
continue;
/* Map I/O space 0 if necessary */
if (gscsio_ld[i].ld_iosize0 != 0) {
iobase = idxread(sc->sc_iot, sc->sc_ioh,
GSCSIO_IO0_MSB);
iobase <<= 8;
iobase |= idxread(sc->sc_iot, sc->sc_ioh,
GSCSIO_IO0_LSB);
if (bus_space_map(sc->sc_iot, iobase,
gscsio_ld[i].ld_iosize0, 0,
&sc->sc_ld_ioh0[gscsio_ld[i].ld_num]))
continue;
}
/* Map I/O space 1 if necessary */
if (gscsio_ld[i].ld_iosize1 != 0) {
iobase = idxread(sc->sc_iot, sc->sc_ioh,
GSCSIO_IO1_MSB);
iobase <<= 8;
iobase |= idxread(sc->sc_iot, sc->sc_ioh,
GSCSIO_IO1_LSB);
if (bus_space_map(sc->sc_iot, iobase,
gscsio_ld[i].ld_iosize1, 0,
&sc->sc_ld_ioh0[gscsio_ld[i].ld_num])) {
bus_space_unmap(sc->sc_iot,
sc->sc_ld_ioh0[gscsio_ld[i].ld_num],
gscsio_ld[i].ld_iosize0);
continue;
}
}
sc->sc_ld_en[gscsio_ld[i].ld_num] = 1;
printf(" %s", gscsio_ld[i].ld_name);
}
printf("\n");
/* Initialize ACCESS.bus 1 */
if (sc->sc_ld_en[GSCSIO_LDN_ACB1]) {
sc->sc_acb[0].sc = sc;
sc->sc_acb[0].ioh = sc->sc_ld_ioh0[GSCSIO_LDN_ACB1];
rw_init(&sc->sc_acb[0].buslock, "iiclk");
gscsio_acb_init(&sc->sc_acb[0], &sc->sc_acb1_tag);
}
/* Initialize ACCESS.bus 2 */
if (sc->sc_ld_en[GSCSIO_LDN_ACB2]) {
sc->sc_acb[1].sc = sc;
sc->sc_acb[1].ioh = sc->sc_ld_ioh0[GSCSIO_LDN_ACB2];
rw_init(&sc->sc_acb[1].buslock, "iiclk");
gscsio_acb_init(&sc->sc_acb[1], &sc->sc_acb2_tag);
}
}
void
gscsio_acb_init(struct gscsio_acb *acb, i2c_tag_t tag)
{
struct gscsio_softc *sc = acb->sc;
struct i2cbus_attach_args iba;
/* Enable ACB and configure clock frequency */
ACB_WRITE(GSCSIO_ACB_CTL2, GSCSIO_ACB_CTL2_EN |
(GSCSIO_ACB_FREQ << GSCSIO_ACB_CTL2_FREQ_SHIFT));
/* Select polling mode */
ACB_WRITE(GSCSIO_ACB_CTL1, ACB_READ(GSCSIO_ACB_CTL1) &
~GSCSIO_ACB_CTL1_INTEN);
/* Disable slave address */
ACB_WRITE(GSCSIO_ACB_ADDR, ACB_READ(GSCSIO_ACB_ADDR) &
~GSCSIO_ACB_ADDR_SAEN);
/* Attach I2C framework */
tag->ic_cookie = acb;
tag->ic_acquire_bus = gscsio_acb_acquire_bus;
tag->ic_release_bus = gscsio_acb_release_bus;
tag->ic_send_start = gscsio_acb_send_start;
tag->ic_send_stop = gscsio_acb_send_stop;
tag->ic_initiate_xfer = gscsio_acb_initiate_xfer;
tag->ic_read_byte = gscsio_acb_read_byte;
tag->ic_write_byte = gscsio_acb_write_byte;
bzero(&iba, sizeof(iba));
iba.iba_name = "iic";
iba.iba_tag = tag;
config_found(&sc->sc_dev, &iba, iicbus_print);
}
int
gscsio_acb_wait(struct gscsio_acb *acb, int bits, int flags)
{
struct gscsio_softc *sc = acb->sc;
u_int8_t st;
int i;
for (i = 0; i < 100; i++) {
st = ACB_READ(GSCSIO_ACB_ST);
if (st & GSCSIO_ACB_ST_BER) {
printf("%s: bus error, flags=0x%x\n",
sc->sc_dev.dv_xname, flags);
gscsio_acb_reset(acb);
return (EIO);
}
if (st & GSCSIO_ACB_ST_NEGACK) {
#if 0
printf("%s: negative ack, flags=0x%x\n",
sc->sc_dev.dv_xname, flags);
#endif
gscsio_acb_reset(acb);
return (EIO);
}
if ((st & bits) == bits)
break;
delay(10);
}
if ((st & bits) != bits) {
printf("%s: timeout, flags=0x%x\n",
sc->sc_dev.dv_xname, flags);
gscsio_acb_reset(acb);
return (ETIMEDOUT);
}
return (0);
}
void
gscsio_acb_reset(struct gscsio_acb *acb)
{
struct gscsio_softc *sc = acb->sc;
u_int8_t st, ctl;
/* Clear MASTER, NEGACK and BER */
st = ACB_READ(GSCSIO_ACB_ST);
st |= GSCSIO_ACB_ST_MASTER | GSCSIO_ACB_ST_NEGACK | GSCSIO_ACB_ST_BER;
ACB_WRITE(GSCSIO_ACB_ST, st);
/* Disable and re-enable ACB */
ACB_WRITE(GSCSIO_ACB_CTL2, 0);
ACB_WRITE(GSCSIO_ACB_CTL2, GSCSIO_ACB_CTL2_EN |
(GSCSIO_ACB_FREQ << GSCSIO_ACB_CTL2_FREQ_SHIFT));
/* Send stop */
ctl = ACB_READ(GSCSIO_ACB_CTL1);
ctl |= GSCSIO_ACB_CTL1_STOP;
ACB_WRITE(GSCSIO_ACB_CTL1, ctl);
}
int
gscsio_acb_acquire_bus(void *cookie, int flags)
{
struct gscsio_acb *acb = cookie;
if (cold || flags & I2C_F_POLL)
return (0);
return (rw_enter(&acb->buslock, RW_WRITE | RW_INTR));
}
void
gscsio_acb_release_bus(void *cookie, int flags)
{
struct gscsio_acb *acb = cookie;
if (cold || flags & I2C_F_POLL)
return;
rw_exit(&acb->buslock);
}
int
gscsio_acb_send_start(void *cookie, int flags)
{
struct gscsio_acb *acb = cookie;
struct gscsio_softc *sc = acb->sc;
u_int8_t ctl;
ctl = ACB_READ(GSCSIO_ACB_CTL1);
ctl |= GSCSIO_ACB_CTL1_START;
ACB_WRITE(GSCSIO_ACB_CTL1, ctl);
return (0);
}
int
gscsio_acb_send_stop(void *cookie, int flags)
{
struct gscsio_acb *acb = cookie;
struct gscsio_softc *sc = acb->sc;
u_int8_t ctl;
ctl = ACB_READ(GSCSIO_ACB_CTL1);
ctl |= GSCSIO_ACB_CTL1_STOP;
ACB_WRITE(GSCSIO_ACB_CTL1, ctl);
return (0);
}
int
gscsio_acb_initiate_xfer(void *cookie, i2c_addr_t addr, int flags)
{
struct gscsio_acb *acb = cookie;
struct gscsio_softc *sc = acb->sc;
u_int8_t ctl;
int dir;
int error;
/* Issue start condition */
ctl = ACB_READ(GSCSIO_ACB_CTL1);
ctl |= GSCSIO_ACB_CTL1_START;
ACB_WRITE(GSCSIO_ACB_CTL1, ctl);
/* Wait for bus mastership */
if ((error = gscsio_acb_wait(acb,
GSCSIO_ACB_ST_MASTER | GSCSIO_ACB_ST_SDAST, flags)))
return (error);
/* Send address byte */
dir = (flags & I2C_F_READ ? 1 : 0);
ACB_WRITE(GSCSIO_ACB_SDA, (addr << 1) | dir);
return (0);
}
int
gscsio_acb_read_byte(void *cookie, uint8_t *bytep, int flags)
{
struct gscsio_acb *acb = cookie;
struct gscsio_softc *sc = acb->sc;
u_int8_t ctl;
int error;
/* Wait for the bus to be ready */
if ((error = gscsio_acb_wait(acb, GSCSIO_ACB_ST_SDAST, flags)))
return (error);
/* Acknowledge the last byte */
if (flags & I2C_F_LAST) {
ctl = ACB_READ(GSCSIO_ACB_CTL1);
ctl |= GSCSIO_ACB_CTL1_ACK;
ACB_WRITE(GSCSIO_ACB_CTL1, ctl);
}
/* Read data byte */
*bytep = ACB_READ(GSCSIO_ACB_SDA);
return (0);
}
int
gscsio_acb_write_byte(void *cookie, uint8_t byte, int flags)
{
struct gscsio_acb *acb = cookie;
struct gscsio_softc *sc = acb->sc;
u_int8_t ctl;
int error;
/* Wait for the bus to be ready */
if ((error = gscsio_acb_wait(acb, GSCSIO_ACB_ST_SDAST, flags)))
return (error);
/* Send stop after the last byte */
if (flags & I2C_F_STOP) {
ctl = ACB_READ(GSCSIO_ACB_CTL1);
ctl |= GSCSIO_ACB_CTL1_STOP;
ACB_WRITE(GSCSIO_ACB_CTL1, ctl);
}
/* Write data byte */
ACB_WRITE(GSCSIO_ACB_SDA, byte);
return (0);
}