/*      $NetBSD: ds2482ow.c,v 1.2 2024/11/06 15:49:36 riastradh Exp $   */

/*
 * Copyright (c) 2024 Brad Spencer <brad@anduin.eldar.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.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ds2482ow.c,v 1.2 2024/11/06 15:49:36 riastradh Exp $");

/*
 * Driver for the DS2482-100 and DS2482-800 I2C to Onewire bridge
 */

#include <sys/param.h>

#include <sys/device.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/mutex.h>
#include <sys/sysctl.h>
#include <sys/systm.h>

#include <dev/i2c/ds2482owreg.h>
#include <dev/i2c/ds2482owvar.h>
#include <dev/i2c/i2cvar.h>
#include <dev/onewire/onewirevar.h>

#define DS2482_ONEWIRE_SINGLE_BIT_READ  0xF7 /* Artifical */
#define DS2482_ONEWIRE_SINGLE_BIT_WRITE 0xF8 /* Artifical */

static int      ds2482_poke(i2c_tag_t, i2c_addr_t, bool);
static int      ds2482_match(device_t, cfdata_t, void *);
static void     ds2482_attach(device_t, device_t, void *);
static int      ds2482_detach(device_t, int);
static int      ds2482_verify_sysctl(SYSCTLFN_ARGS);

static int      ds2482_ow_reset(void *);
static int      ds2482_ow_read_bit(void *);
static void     ds2482_ow_write_bit(void *, int);
static int      ds2482_ow_read_byte(void *);
static void     ds2482_ow_write_byte(void *, int);
static int      ds2482_ow_triplet(void *, int);

#define DS2482_DEBUG

#ifdef DS2482_DEBUG
#define DPRINTF(s, l, x)                                                      \
        do {                                                                  \
                if (l <= s->sc_ds2482debug)                                   \
                        aprint_normal x;                                      \
        } while (/*CONSTCOND*/0)
#else
#define DPRINTF(s, l, x)        __nothing
#endif

#ifdef DS2482_DEBUG
#define DPRINTF2(dl, l, x)                                                    \
        do {                                                                  \
                if (l <= dl)                                                  \
                        aprint_normal x;                                      \
        } while (/*CONSTCOND*/0)
#else
#define DPRINTF2(dl, l, x)      __nothing
#endif

CFATTACH_DECL_NEW(ds2482ow, sizeof(struct ds2482ow_sc),
    ds2482_match, ds2482_attach, ds2482_detach, NULL);

#define DS2482_QUICK_DELAY 18
#define DS2482_SLOW_DELAY 35

int
ds2482_verify_sysctl(SYSCTLFN_ARGS)
{
        int error, t;
        struct sysctlnode node;

        node = *rnode;
        t = *(int *)rnode->sysctl_data;
        node.sysctl_data = &t;
        error = sysctl_lookup(SYSCTLFN_CALL(&node));
        if (error || newp == NULL)
                return error;

        if (t < 0)
                return EINVAL;

        *(int *)rnode->sysctl_data = t;

        return 0;
}

static int
ds2482_set_pullup(i2c_tag_t tag, i2c_addr_t addr, bool activepullup,
    bool strongpullup, int debuglevel)
{
        int error;
        uint8_t cmd = DS2482_WRITE_CONFIG;
        uint8_t pu = 0;
        uint8_t pux;

        if (activepullup)
                pu = pu | DS2482_CONFIG_APU;
        if (strongpullup)
                pu = pu | DS2482_CONFIG_SPU;

        /*
         * The Write Config command wants the top bits of the config
         * buffer to be the ones complement of the lower bits.
         */

        pux = ~(pu << 4);
        pux = pux & 0xf0;
        pu = pu | pux;

        error = iic_exec(tag, I2C_OP_WRITE_WITH_STOP, addr, &cmd, 1, &pu, 1,
            0);
        DPRINTF2(debuglevel, 4, ("ds2482_set_pullup: pu: %02x; error: %x %d\n",
            pu, error, error));

        return error;
}

static int
ds2482_wait_with_status(i2c_tag_t tag, i2c_addr_t addr, uint8_t *status,
    unsigned int d, bool set_pointer, int debuglevel)
{
        int error = 0;
        uint8_t xcmd, xbuf;

        DPRINTF2(debuglevel, 5, ("ds2482_wait_with_status: start\n"));

        xcmd = DS2482_SET_READ_POINTER;
        xbuf = DS2482_REGISTER_STATUS;
        if (set_pointer) {
                error = iic_exec(tag, I2C_OP_WRITE_WITH_STOP, addr, &xcmd, 1,
                    &xbuf, 1, 0);
        }
        if (!error) {
                error = iic_exec(tag, I2C_OP_READ, addr, NULL, 0, status, 1,
                    0);
                if ((*status & DS2482_STATUS_1WB) && !error) {
                        do {
                                delay(d);
                                error = iic_exec(tag, I2C_OP_READ, addr,
                                    NULL, 0, status, 1, 0);
                        } while ((*status & DS2482_STATUS_1WB) && !error);
                }
        }

        DPRINTF2(debuglevel, 5,
            ("ds2482_wait_with_status: end ; status: %02x %d ; error: %x %d\n",
            *status, *status, error, error));

        return error;
}

static int
ds2482_cmd(i2c_tag_t tag, i2c_addr_t addr, uint8_t *cmd,
    uint8_t *cmdarg, uint8_t *obuf, size_t obuflen, bool activepullup,
    bool strongpullup, int debuglevel)
{
        int error;
        uint8_t xcmd;
        uint8_t xbuf;

        switch (*cmd) {
                /*
                 * The datasheet says that none of these are effected
                 * by what sort of pullup is set and only the Write
                 * Config command needs to happen when idle.
                 */
        case DS2482_SET_READ_POINTER:
        case DS2482_WRITE_CONFIG:
        case DS2482_SELECT_CHANNEL:
                KASSERT(cmdarg != NULL);

                error = 0;
                if (*cmd == DS2482_WRITE_CONFIG) {
                        error = ds2482_wait_with_status(tag, addr, &xbuf,
                            DS2482_QUICK_DELAY, /*set_pointer*/true,
                            debuglevel);
                }
                if (!error) {
                        error = iic_exec(tag, I2C_OP_WRITE_WITH_STOP, addr,
                            cmd, 1, cmdarg, 1, 0);
                }
                DPRINTF2(debuglevel, 4,
                    ("ds2482_cmd: cmd: %02x ; error: %x %d\n",
                    *cmd, error, error));
                break;

        case DS2482_DEVICE_RESET:
        case DS2482_ONEWIRE_RESET:
                /*
                 * Device reset resets everything, including pullup
                 * configuration settings, but that doesn't matter as
                 * we will always set the config before doing anything
                 * that actions on the 1-Wire bus.
                 *
                 * The data sheet warns about using the strong pull up
                 * feature with a 1-Wire reset, so we will simply not
                 * allow that combination.
                 *
                 * The data sheet does not mention if the 1-Wire reset
                 * effects just a single channel all channels.  It
                 * seems likely that it is the currently active
                 * channel, and the driver works on that assumption.
                 */
                error = 0;
                if (*cmd == DS2482_ONEWIRE_RESET) {
                        error = ds2482_wait_with_status(tag, addr, &xbuf,
                            DS2482_QUICK_DELAY, /*set_pointer*/true,
                            debuglevel);
                        if (!error) {
                                error = ds2482_set_pullup(tag, addr,
                                    activepullup, /*strongpullup*/false,
                                    debuglevel);
                        }
                }
                if (!error) {
                        error = iic_exec(tag, I2C_OP_WRITE_WITH_STOP, addr,
                            cmd, 1, NULL, 0, 0);
                }
                DPRINTF2(debuglevel, 4,
                    ("ds2482_cmd: cmd: %02x ; error: %x %d\n",
                    *cmd, error, error));
                if (*cmd == DS2482_DEVICE_RESET)
                        delay(1);
                if (*cmd == DS2482_ONEWIRE_RESET)
                        delay(1300);
                break;

        case DS2482_ONEWIRE_SINGLE_BIT_WRITE:
                KASSERT(cmdarg != NULL);

                DPRINTF2(debuglevel, 4,
                    ("ds2482_cmd: DS2482_ONEWIRE_SINGLE_BIT_WRITE:"
                    " cmdarg: %02x %d\n", *cmdarg, *cmdarg));

                xcmd = DS2482_SET_READ_POINTER;
                xbuf = DS2482_REGISTER_STATUS;
                error = iic_exec(tag, I2C_OP_WRITE_WITH_STOP, addr, &xcmd, 1,
                    &xbuf, 1, 0);
                if (!error) {
                        error = ds2482_wait_with_status(tag, addr, &xbuf,
                            DS2482_QUICK_DELAY, /*set_pointer*/false,
                            debuglevel);
                }
                if (!error) {
                        xcmd = DS2482_ONEWIRE_SINGLE_BIT;
                        xbuf = DS2482_ONEWIRE_BIT_ZERO;
                        if (*cmdarg & 0x01)
                                xbuf = DS2482_ONEWIRE_BIT_ONE;
                        error = ds2482_set_pullup(tag, addr,
                            activepullup, strongpullup, debuglevel);
                        if (!error) {
                                error = iic_exec(tag, I2C_OP_WRITE, addr,
                                    &xcmd, 1, &xbuf, 1, 0);
                        }
                        if (!error) {
                                xbuf = 0xff;
                                error = ds2482_wait_with_status(tag, addr,
                                    &xbuf, DS2482_SLOW_DELAY,
                                    /*set_pointer*/false, debuglevel);
                        }
                }
                break;

        case DS2482_ONEWIRE_SINGLE_BIT_READ:
                KASSERT(obuf != NULL);
                KASSERT(obuflen == 1);

                DPRINTF2(debuglevel, 4,
                    ("ds2482_cmd: DS2482_ONEWIRE_SINGLE_BIT_READ\n"));

                xcmd = DS2482_SET_READ_POINTER;
                xbuf = DS2482_REGISTER_STATUS;
                error = iic_exec(tag, I2C_OP_WRITE_WITH_STOP, addr, &xcmd, 1,
                    &xbuf, 1, 0);
                if (!error) {
                        error = ds2482_wait_with_status(tag, addr, &xbuf,
                            DS2482_QUICK_DELAY, /*set_pointer*/false,
                            debuglevel);
                }
                if (!error) {
                        xcmd = DS2482_ONEWIRE_SINGLE_BIT;
                        xbuf = DS2482_ONEWIRE_BIT_ONE;
                        error = ds2482_set_pullup(tag, addr,
                            activepullup, strongpullup, debuglevel);
                        if (!error) {
                                error = iic_exec(tag, I2C_OP_WRITE, addr,
                                    &xcmd, 1, &xbuf, 1, 0);
                        }
                        if (!error) {
                                xbuf = 0xff;
                                error = ds2482_wait_with_status(tag, addr,
                                    &xbuf, DS2482_SLOW_DELAY,
                                    /*set_pointer*/false, debuglevel);
                                if (!error) {
                                        *obuf = (xbuf & DS2482_STATUS_SBR) >>
                                            DS2482_STATUS_SBR_SHIFT;
                                }
                        }
                }
                break;

        case DS2482_ONEWIRE_WRITE_BYTE:
                KASSERT(cmdarg != NULL);

                DPRINTF2(debuglevel, 4,
                    ("ds2482_cmd: DS2482_ONEWIRE_WRITE_BYTE:"
                    " cmdarg: %02x %d\n", *cmdarg, *cmdarg));

                xcmd = DS2482_SET_READ_POINTER;
                xbuf = DS2482_REGISTER_STATUS;
                error = iic_exec(tag, I2C_OP_WRITE_WITH_STOP, addr, &xcmd, 1,
                    &xbuf, 1, 0);
                if (!error) {
                        error = ds2482_wait_with_status(tag, addr, &xbuf,
                            DS2482_QUICK_DELAY, /*set_pointer*/false,
                            debuglevel);
                }
                if (!error) {
                        error = ds2482_set_pullup(tag, addr,
                            activepullup, strongpullup, debuglevel);
                        if (!error) {
                                error = iic_exec(tag, I2C_OP_WRITE, addr,
                                    cmd, 1, cmdarg, 1, 0);
                        }
                        if (!error) {
                                xbuf = 0xff;
                                error = ds2482_wait_with_status(tag, addr,
                                    &xbuf, DS2482_SLOW_DELAY,
                                    /*set_pointer*/false, debuglevel);
                        }
                }
                break;

        case DS2482_ONEWIRE_READ_BYTE:
                KASSERT(obuf != NULL);
                KASSERT(obuflen == 1);

                DPRINTF2(debuglevel, 4,
                    ("ds2482_cmd: DS2482_ONEWIRE_READ_BYTE\n"));

                xcmd = DS2482_SET_READ_POINTER;
                xbuf = DS2482_REGISTER_STATUS;
                error = iic_exec(tag, I2C_OP_WRITE_WITH_STOP, addr, &xcmd, 1,
                    &xbuf, 1, 0);
                if (!error) {
                        error = ds2482_wait_with_status(tag, addr, &xbuf,
                            DS2482_QUICK_DELAY, /*set_pointer*/false,
                            debuglevel);
                }
                if (!error) {
                        error = ds2482_set_pullup(tag, addr,
                            activepullup, strongpullup, debuglevel);
                        if (!error) {
                                error = iic_exec(tag, I2C_OP_WRITE, addr,
                                    cmd, 1, NULL, 0, 0);
                        }
                        if (!error) {
                                xbuf = 0xff;
                                error = ds2482_wait_with_status(tag, addr,
                                    &xbuf, DS2482_SLOW_DELAY,
                                    /*set_pointer*/false, debuglevel);
                                if (!error) {
                                        xcmd = DS2482_SET_READ_POINTER;
                                        xbuf = DS2482_REGISTER_DATA;
                                        error = iic_exec(tag,
                                            I2C_OP_WRITE_WITH_STOP, addr,
                                            &xcmd, 1, &xbuf, 1, 0);
                                        if (!error) {
                                                xbuf = 0xff;
                                                error = iic_exec(tag,
                                                    I2C_OP_READ_WITH_STOP,
                                                    addr, NULL, 0,
                                                    &xbuf, 1, 0);
                                                if (!error) {
                                                        *obuf = xbuf;
                                                }
                                        }
                                }
                        }
                }
                break;

        case DS2482_ONEWIRE_TRIPLET:
                KASSERT(cmdarg != NULL);
                KASSERT(obuf != NULL);
                KASSERT(obuflen == 1);

                DPRINTF2(debuglevel, 4,
                    ("ds2482_cmd: DS2482_ONEWIRE_TRIPLET: cmdarg: %02x %d\n",
                    *cmdarg, *cmdarg));

                xcmd = DS2482_SET_READ_POINTER;
                xbuf = DS2482_REGISTER_STATUS;
                error = iic_exec(tag, I2C_OP_WRITE_WITH_STOP, addr, &xcmd, 1,
                    &xbuf, 1, 0);
                if (!error) {
                        error = ds2482_wait_with_status(tag, addr, &xbuf,
                            DS2482_QUICK_DELAY, /*set_pointer*/false,
                            debuglevel);
                }
                if (!error) {
                        xbuf = DS2482_TRIPLET_DIR_ZERO;
                        if (*cmdarg & 0x01) {
                                xbuf = DS2482_TRIPLET_DIR_ONE;
                        }
                        error = ds2482_set_pullup(tag, addr,
                            activepullup, strongpullup, debuglevel);
                        if (!error) {
                                error = iic_exec(tag, I2C_OP_WRITE, addr,
                                    cmd, 1, &xbuf, 1, 0);
                        }
                        if (!error) {
                                xbuf = 0xff;
                                error = ds2482_wait_with_status(tag, addr,
                                    &xbuf, DS2482_SLOW_DELAY,
                                    /*set_pointer*/false, debuglevel);
                                if (!error) {
                                        /*
                                         * This is undocumented
                                         * anywhere I could find, but
                                         * what has to be returned is
                                         * 0x01 is the triplet path was
                                         * taken, 0x02 is the
                                         * Not-triplet path was taken,
                                         * and 0x00 is neither was
                                         * taken.  The DIR bit in the
                                         * status of the DS2482 may
                                         * help with this some, but
                                         * what is below seems to work.
                                         */
                                        *obuf = 0;
                                        if (xbuf & DS2482_STATUS_TSB) {
                                                *obuf = 0x01;
                                        } else {
                                                if (xbuf & DS2482_STATUS_SBR) {
                                                        *obuf = 0x02;
                                                }
                                        }
                                }
                        }
                }
                break;

        default:
                error = EINVAL;
                break;
        }

        return error;
}

static int
ds2482_cmdr(struct ds2482ow_sc *sc, uint8_t cmd, uint8_t cmdarg,
    uint8_t *buf, size_t blen)
{

        DPRINTF(sc, 3, ("%s: ds2482_cmdr: cmd: %02x\n",
            device_xname(sc->sc_dev), cmd));
        return ds2482_cmd(sc->sc_tag, sc->sc_addr, &cmd, &cmdarg, buf, blen,
            sc->sc_activepullup, sc->sc_strongpullup, sc->sc_ds2482debug);
}

static const uint8_t ds2482_channels[] = {
        DS2482_CHANNEL_IO0,
        DS2482_CHANNEL_IO1,
        DS2482_CHANNEL_IO2,
        DS2482_CHANNEL_IO3,
        DS2482_CHANNEL_IO4,
        DS2482_CHANNEL_IO5,
        DS2482_CHANNEL_IO6,
        DS2482_CHANNEL_IO7
};

static int
ds2482_set_channel(struct ds2482ow_sc *sc, int channel)
{
        int error = 0;

        KASSERT(channel >= 0 && channel < DS2482_NUM_INSTANCES);

        if (sc->sc_is_800) {
                error = ds2482_cmdr(sc, DS2482_SELECT_CHANNEL,
                    ds2482_channels[channel], NULL, 0);
        }

        return error;
}

static int
ds2482_poke(i2c_tag_t tag, i2c_addr_t addr, bool matchdebug)
{
        uint8_t reg = DS2482_SET_READ_POINTER;
        uint8_t rbuf = DS2482_REGISTER_STATUS;
        uint8_t obuf;
        int error;

        error = ds2482_cmd(tag, addr, &reg, &rbuf, &obuf, 1,
            /*activepullup*/false, /*strongpullup*/false, 0);
        if (matchdebug) {
                printf("poke X 1: %d\n", error);
        }
        return error;
}

static int
ds2482_match(device_t parent, cfdata_t match, void *aux)
{
        struct i2c_attach_args *ia = aux;
        int error, match_result;
        const bool matchdebug = false;

        if (iic_use_direct_match(ia, match, NULL, &match_result))
                return match_result;

        /* indirect config - check for configured address */
        if (!(ia->ia_addr >= DS2482_LOWEST_ADDR &&
            ia->ia_addr <= DS2482_HIGHEST_ADDR))
                return 0;

        /*
         * Check to see if something is really at this i2c address. This will
         * keep phantom devices from appearing
         */
        if (iic_acquire_bus(ia->ia_tag, 0) != 0) {
                if (matchdebug)
                        printf("in match acquire bus failed\n");
                return 0;
        }

        error = ds2482_poke(ia->ia_tag, ia->ia_addr, matchdebug);
        iic_release_bus(ia->ia_tag, 0);

        return error == 0 ? I2C_MATCH_ADDRESS_AND_PROBE : 0;
}

static void
ds2482_attach(device_t parent, device_t self, void *aux)
{
        struct ds2482ow_sc *sc;
        struct i2c_attach_args *ia;
        int error, i, num_channels = 1;
        struct onewirebus_attach_args oba;
        const struct sysctlnode *cnode;
        int sysctlroot_num, pullup_num;

        ia = aux;
        sc = device_private(self);

        sc->sc_dev = self;
        sc->sc_tag = ia->ia_tag;
        sc->sc_addr = ia->ia_addr;
        sc->sc_ds2482debug = 0;
        sc->sc_activepullup = false;
        sc->sc_strongpullup = false;
        sc->sc_is_800 = false;

        aprint_normal("\n");

        mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_NONE);

        if ((error = sysctl_createv(&sc->sc_ds2482log, 0, NULL, &cnode,
            0, CTLTYPE_NODE, device_xname(sc->sc_dev),
            SYSCTL_DESCR("DS2482 controls"), NULL, 0, NULL, 0, CTL_HW,
            CTL_CREATE, CTL_EOL)) != 0)
                goto out;

        sysctlroot_num = cnode->sysctl_num;

#ifdef DS2482_DEBUG
        if ((error = sysctl_createv(&sc->sc_ds2482log, 0, NULL, &cnode,
            CTLFLAG_READWRITE, CTLTYPE_INT, "debug",
            SYSCTL_DESCR("Debug level"), ds2482_verify_sysctl, 0,
            &sc->sc_ds2482debug, 0, CTL_HW, sysctlroot_num, CTL_CREATE,
            CTL_EOL)) != 0)
                goto out;
#endif

        if ((error = sysctl_createv(&sc->sc_ds2482log, 0, NULL, &cnode,
            0, CTLTYPE_NODE, "pullup",
            SYSCTL_DESCR("Pullup controls"), NULL, 0, NULL, 0, CTL_HW,
            sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
                goto out;

        pullup_num = cnode->sysctl_num;

        if ((error = sysctl_createv(&sc->sc_ds2482log, 0, NULL, &cnode,
            CTLFLAG_READWRITE, CTLTYPE_BOOL, "active",
            SYSCTL_DESCR("Active pullup"), NULL, 0, &sc->sc_activepullup,
            0, CTL_HW, sysctlroot_num, pullup_num, CTL_CREATE, CTL_EOL)) != 0)
                goto out;

        if ((error = sysctl_createv(&sc->sc_ds2482log, 0, NULL, &cnode,
            CTLFLAG_READWRITE, CTLTYPE_BOOL, "strong",
            SYSCTL_DESCR("Strong pullup"), NULL, 0, &sc->sc_strongpullup,
            0, CTL_HW, sysctlroot_num, pullup_num, CTL_CREATE, CTL_EOL)) != 0)
                goto out;

        error = iic_acquire_bus(sc->sc_tag, 0);
        if (error) {
                aprint_error_dev(self, "Could not acquire iic bus: %d\n",
                    error);
                goto out;
        }

        error = ds2482_cmdr(sc, DS2482_DEVICE_RESET, 0, NULL, 0);
        if (error != 0)
                aprint_error_dev(self, "Reset failed: %d\n", error);

        if (!error) {
                int xerror;
                xerror = ds2482_cmdr(sc, DS2482_SELECT_CHANNEL,
                    DS2482_CHANNEL_IO0, NULL, 0);
                if (!xerror)
                        sc->sc_is_800 = true;
        }

        iic_release_bus(sc->sc_tag, 0);

        if (error != 0) {
                aprint_error_dev(self, "Unable to setup device\n");
                goto out;
        }

        if (sc->sc_is_800) {
                num_channels = DS2482_NUM_INSTANCES;
        }

        aprint_normal_dev(self, "Maxim DS2482-%s I2C to 1-Wire bridge,"
            " Channels available: %d\n",
            sc->sc_is_800 ? "800" : "100",
            num_channels);

        for (i = 0; i < num_channels; i++) {
                sc->sc_instances[i].sc_i_channel = i;
                sc->sc_instances[i].sc = sc;
                sc->sc_instances[i].sc_i_ow_bus.bus_cookie =
                    &sc->sc_instances[i];
                sc->sc_instances[i].sc_i_ow_bus.bus_reset = ds2482_ow_reset;
                sc->sc_instances[i].sc_i_ow_bus.bus_read_bit =
                    ds2482_ow_read_bit;
                sc->sc_instances[i].sc_i_ow_bus.bus_write_bit =
                    ds2482_ow_write_bit;
                sc->sc_instances[i].sc_i_ow_bus.bus_read_byte =
                    ds2482_ow_read_byte;
                sc->sc_instances[i].sc_i_ow_bus.bus_write_byte =
                    ds2482_ow_write_byte;
                sc->sc_instances[i].sc_i_ow_bus.bus_triplet =
                    ds2482_ow_triplet;

                memset(&oba, 0, sizeof(oba));
                oba.oba_bus = &sc->sc_instances[i].sc_i_ow_bus;
                sc->sc_instances[i].sc_i_ow_dev =
                    config_found(self, &oba, onewirebus_print, CFARGS_NONE);
        }

out:
        return;
}

/*
 * Hmmm...  except in the case of reset, there really doesn't seem to
 * be any way with the onewire(4) API to indicate an error condition.
 */

static int
ds2482_generic_action(struct ds2482_instance *sci, uint8_t cmd, uint8_t cmdarg,
    uint8_t *buf, size_t blen)
{
        struct ds2482ow_sc *sc = sci->sc;
        int rv;

        mutex_enter(&sc->sc_mutex);
        rv = iic_acquire_bus(sc->sc_tag, 0);
        if (!rv) {
                rv = ds2482_set_channel(sc, sci->sc_i_channel);
                if (!rv)
                        rv = ds2482_cmdr(sc, cmd, cmdarg, buf, blen);
        }
        iic_release_bus(sc->sc_tag, 0);
        mutex_exit(&sc->sc_mutex);

        return rv;
}

static int
ds2482_ow_reset(void *arg)
{
        struct ds2482_instance *sci = arg;
        struct ds2482ow_sc *sc = sci->sc;
        int rv;

        rv = ds2482_generic_action(sci, DS2482_ONEWIRE_RESET, 0, NULL, 0);

        DPRINTF(sc, 3, ("%s: ds2482_ow_reset: channel: %d ; rv: %x %d\n",
            device_xname(sc->sc_dev), sci->sc_i_channel, rv, rv));

        return rv;
}

static int
ds2482_ow_read_bit(void *arg)
{
        struct ds2482_instance *sci = arg;
        struct ds2482ow_sc *sc = sci->sc;
        int rv;
        uint8_t buf = 0x55;

        rv = ds2482_generic_action(sci, DS2482_ONEWIRE_SINGLE_BIT_READ, 0,
            &buf, 1);

        DPRINTF(sc, 3,
            ("%s: ds2482_read_bit: channel: %d ; rv: %x %d ; buf: %02x %d\n",
            device_xname(sc->sc_dev), sci->sc_i_channel, rv, rv, buf, buf));

        return (int)buf;
}

static void
ds2482_ow_write_bit(void *arg, int value)
{
        struct ds2482_instance *sci = arg;
        struct ds2482ow_sc *sc = sci->sc;
        int rv;

        rv = ds2482_generic_action(sci, DS2482_ONEWIRE_SINGLE_BIT_WRITE,
            (uint8_t)value, NULL, 0);

        DPRINTF(sc, 3, ("%s: ds2482_write_bit: channel: %d ;"
            " rv: %x %d ; value: %02x %d\n",
            device_xname(sc->sc_dev), sci->sc_i_channel,
            rv, rv, (uint8_t)value, (uint8_t)value));
}

static int
ds2482_ow_read_byte(void *arg)
{
        struct ds2482_instance *sci = arg;
        uint8_t buf = 0x55;
        struct ds2482ow_sc *sc = sci->sc;
        int rv;

        rv = ds2482_generic_action(sci, DS2482_ONEWIRE_READ_BYTE, 0, &buf, 1);

        DPRINTF(sc, 3,
            ("%s: ds2482_read_byte: channel: %d ; rv: %x %d ; buf: %02x %d\n",
            device_xname(sc->sc_dev), sci->sc_i_channel, rv, rv, buf, buf));

        return (int)buf;
}

static void
ds2482_ow_write_byte(void *arg, int value)
{
        struct ds2482_instance *sci = arg;
        struct ds2482ow_sc *sc = sci->sc;
        int rv;

        rv = ds2482_generic_action(sci, DS2482_ONEWIRE_WRITE_BYTE,
            (uint8_t)value, NULL, 0);

        DPRINTF(sc, 3, ("%s: ds2482_write_byte: channel: %d ;"
            " rv: %x %d ; value: %02x %d\n",
            device_xname(sc->sc_dev), sci->sc_i_channel,
            rv, rv, (uint8_t)value, (uint8_t)value));
}

static int
ds2482_ow_triplet(void *arg, int dir)
{
        struct ds2482_instance *sci = arg;
        uint8_t buf = 0x55;
        struct ds2482ow_sc *sc = sci->sc;
        int rv;

        rv = ds2482_generic_action(sci, DS2482_ONEWIRE_TRIPLET, (uint8_t)dir,
            &buf, 1);

        DPRINTF(sc, 3, ("%s: ds2482_triplet: channel: %d ;"
            " rv: %x %d ; dir: %x %d ; buf: %02x %d\n",
            device_xname(sc->sc_dev), sci->sc_i_channel, rv, rv,
            dir, dir, (uint8_t)buf, (uint8_t)buf));

        return (int)buf;
}

static int
ds2482_detach(device_t self, int flags)
{
        struct ds2482ow_sc *sc;

        sc = device_private(self);

        /* Remove the sysctl tree */
        sysctl_teardown(&sc->sc_ds2482log);

        /* Remove the mutex */
        mutex_destroy(&sc->sc_mutex);

        return 0;
}

MODULE(MODULE_CLASS_DRIVER, ds2482ow, "iic,onewire");

#ifdef _MODULE
#include "ioconf.c"
#endif

static int
ds2482ow_modcmd(modcmd_t cmd, void *opaque)
{

        switch (cmd) {
        case MODULE_CMD_INIT:
#ifdef _MODULE
                return config_init_component(cfdriver_ioconf_ds2482ow,
                    cfattach_ioconf_ds2482ow, cfdata_ioconf_ds2482ow);
#else
                return 0;
#endif
        case MODULE_CMD_FINI:
#ifdef _MODULE
                return config_fini_component(cfdriver_ioconf_ds2482ow,
                      cfattach_ioconf_ds2482ow, cfdata_ioconf_ds2482ow);
#else
                return 0;
#endif
        default:
                return ENOTTY;
        }
}