/*      $NetBSD: wbsio.c,v 1.1 2010/02/21 05:16:29 cnst Exp $   */
/*      $OpenBSD: wbsio.c,v 1.5 2009/03/29 21:53:52 sthen Exp $ */
/*
 * Copyright (c) 2008 Mark Kettenis <kettenis@openbsd.org>
 * Copyright (c) 2010 Constantine A. Murenin <cnst++@dragonflybsd.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.
 */

/*
 * Winbond LPC Super I/O driver.
 */

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/rman.h>
#include <sys/systm.h>

#include <bus/isa/isavar.h>
#include <bus/isa/isa_common.h>

#include "wbsioreg.h"
#include "wbsiovar.h"

static void     wbsio_identify(driver_t *, device_t);
static int      wbsio_probe(device_t);
static int      wbsio_attach(device_t);
static int      wbsio_detach(device_t);

static device_method_t wbsio_methods[] = {
        /* Device interface */
        DEVMETHOD(device_identify,      wbsio_identify),
        DEVMETHOD(device_probe,         wbsio_probe),
        DEVMETHOD(device_attach,        wbsio_attach),
        DEVMETHOD(device_detach,        wbsio_detach),

        /* Bus interface */
        DEVMETHOD(bus_add_child,        bus_generic_add_child),
        DEVMETHOD(bus_set_resource,     bus_generic_set_resource),
        DEVMETHOD(bus_alloc_resource,   isa_alloc_resource),
        DEVMETHOD(bus_release_resource, isa_release_resource),
        DEVMETHOD(bus_activate_resource,        bus_generic_activate_resource),
        DEVMETHOD(bus_deactivate_resource,      bus_generic_deactivate_resource),

        DEVMETHOD_END
};

static driver_t wbsio_driver = {
        "wbsio",
        wbsio_methods,
        sizeof(struct wbsio_softc)
};

static devclass_t wbsio_devclass;

DRIVER_MODULE(wbsio, isa, wbsio_driver, wbsio_devclass, NULL, NULL);


static __inline void
wbsio_conf_enable(bus_space_tag_t iot, bus_space_handle_t ioh)
{
        bus_space_write_1(iot, ioh, WBSIO_INDEX, WBSIO_CONF_EN_MAGIC);
        bus_space_write_1(iot, ioh, WBSIO_INDEX, WBSIO_CONF_EN_MAGIC);
}

static __inline void
wbsio_conf_disable(bus_space_tag_t iot, bus_space_handle_t ioh)
{
        bus_space_write_1(iot, ioh, WBSIO_INDEX, WBSIO_CONF_DS_MAGIC);
}

static __inline u_int8_t
wbsio_conf_read(bus_space_tag_t iot, bus_space_handle_t ioh, u_int8_t index)
{
        bus_space_write_1(iot, ioh, WBSIO_INDEX, index);
        return (bus_space_read_1(iot, ioh, WBSIO_DATA));
}

static __inline void
wbsio_conf_write(bus_space_tag_t iot, bus_space_handle_t ioh, u_int8_t index,
    u_int8_t data)
{
        bus_space_write_1(iot, ioh, WBSIO_INDEX, index);
        bus_space_write_1(iot, ioh, WBSIO_DATA, data);
}

static void
wbsio_identify(driver_t *driver, device_t parent)
{
#ifdef KLD_MODULE
        device_t child[2];
        const int port[2] = { 0x2e, 0x4e };

        for (int i = 0; i < 2; i++) {
                child[i] = device_find_child(parent, driver->name, i);
                if (child[i] == NULL) {
                        child[i] = BUS_ADD_CHILD(parent, parent, ISA_ORDER_PNP,
                            driver->name, i);
                        if (child[i] == NULL) {
                                kprintf("%s: cannot add child[%i]\n",
                                    __func__, i);
                                continue;
                        }
                } else
                        continue;
                if (bus_set_resource(child[i], SYS_RES_IOPORT, 0,
                        port[i], WBSIO_IOSIZE, -1))
                        kprintf("%s: cannot set resource for child[%i]\n",
                            __func__, i);
        }
#endif
}

static int
wbsio_probe(device_t dev)
{
        struct resource *iores;
        int iorid = 0;
        bus_space_tag_t iot;
        bus_space_handle_t ioh;
        uint8_t reg_id, reg_rev;
        const char *desc = NULL;
        char fulldesc[64];

        /* Match by device ID */

        iores = bus_alloc_resource(dev, SYS_RES_IOPORT, &iorid,
            0ul, ~0ul, WBSIO_IOSIZE,
            RF_ACTIVE);
        if (iores == NULL)
                return ENXIO;
        iot = rman_get_bustag(iores);
        ioh = rman_get_bushandle(iores);

        wbsio_conf_enable(iot, ioh);
        /* Read device ID */
        reg_id = wbsio_conf_read(iot, ioh, WBSIO_ID);
        /* Read device revision */
        reg_rev = wbsio_conf_read(iot, ioh, WBSIO_REV);
        wbsio_conf_disable(iot, ioh);
        bus_release_resource(dev, SYS_RES_IOPORT, iorid, iores);

        switch (reg_id) {
        case WBSIO_ID_W83627HF:
                desc = "W83627HF";
                break;
        case WBSIO_ID_W83627THF:
                desc = "W83627THF";
                break;
        case WBSIO_ID_W83627EHF:
                desc = "W83627EHF";
                break;
        case WBSIO_ID_W83627DHG:
                desc = "W83627DHG";
                break;
        case WBSIO_ID_W83627DHGP:
                desc = "W83627DHG-P";
                break;
        case WBSIO_ID_W83627UHG:
                desc = "W83627UHG";
                break;
        case WBSIO_ID_W83637HF:
                desc = "W83637HF";
                break;
        case WBSIO_ID_W83667HG:
                desc = "W83667HG";
                break;
        case WBSIO_ID_W83687THF:
                desc = "W83687THF";
                break;
        case WBSIO_ID_W83697HF:
                desc = "W83697HF";
                break;
        case WBSIO_ID_NCT6776F:
                desc = "NCT6776F";
                break;
        }

        if (desc == NULL) {
#ifndef KLD_MODULE
                if (bootverbose)
#endif
                        if (!(reg_id == 0xff && reg_rev == 0xff))
                                device_printf(dev, "%s port 0x%02x: "
                                    "Device ID 0x%02x, Rev 0x%02x\n",
                                    __func__, isa_get_port(dev),
                                    reg_id, reg_rev);
                return ENXIO;
        }

        ksnprintf(fulldesc, sizeof(fulldesc),
            "Winbond LPC Super I/O %s rev 0x%02x", desc, reg_rev);
        device_set_desc_copy(dev, fulldesc);
        return 0;
}

static int
wbsio_attach(device_t dev)
{
        struct wbsio_softc *sc = device_get_softc(dev);
        uint8_t reg0, reg1;
        uint16_t iobase;
        device_t child;

        /* Map ISA I/O space */
        sc->sc_iores = bus_alloc_resource(dev, SYS_RES_IOPORT, &sc->sc_iorid,
            0ul, ~0ul, WBSIO_IOSIZE,
            RF_ACTIVE);
        if (sc->sc_iores == NULL) {
                device_printf(dev, "can't map i/o space\n");
                return ENXIO;
        }
        sc->sc_iot = rman_get_bustag(sc->sc_iores);
        sc->sc_ioh = rman_get_bushandle(sc->sc_iores);

        /* Enter configuration mode */
        wbsio_conf_enable(sc->sc_iot, sc->sc_ioh);

        /* Read device ID */
        sc->sc_devid = wbsio_conf_read(sc->sc_iot, sc->sc_ioh, WBSIO_ID);

        /* Select HM logical device */
        wbsio_conf_write(sc->sc_iot, sc->sc_ioh, WBSIO_LDN, WBSIO_LDN_HM);

        /*
         * The address should be 8-byte aligned, but it seems some
         * BIOSes ignore this.  They get away with it, because
         * Apparently the hardware simply ignores the lower three
         * bits.  We do the same here.
         */
        reg0 = wbsio_conf_read(sc->sc_iot, sc->sc_ioh, WBSIO_HM_ADDR_LSB);
        reg1 = wbsio_conf_read(sc->sc_iot, sc->sc_ioh, WBSIO_HM_ADDR_MSB);
        iobase = (reg1 << 8) | (reg0 & ~0x7);
        device_printf(dev, "hardware monitor iobase is 0x%x\n", iobase);

        /* Escape from configuration mode */
        wbsio_conf_disable(sc->sc_iot, sc->sc_ioh);

        if (iobase == 0) {
                device_printf(dev, "no hardware monitor configured\n");
                return 0;
        }

        child = BUS_ADD_CHILD(dev, dev, 0, "lm", -1);
        if (child == NULL) {
                device_printf(dev, "cannot add child\n");
                return ENXIO;
        }
        if (bus_set_resource(child, SYS_RES_IOPORT, 0, iobase, 8, -1)) {
                device_printf(dev, "cannot set resource\n");
                return ENXIO;
        }
        return device_probe_and_attach(child);
}

static int
wbsio_detach(device_t dev)
{
        struct wbsio_softc *sc = device_get_softc(dev);

        return bus_release_resource(dev, SYS_RES_IOPORT,
            sc->sc_iorid, sc->sc_iores);
}