dev/i2c/g760a.c

/*        $NetBSD: g760a.c,v 1.6 2020/11/26 12:53:03 skrll Exp $      */

/*-
 * Copyright (C) 2008 A.Leo.
 *
 * 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.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 */

/*
 * The driver for the G760A FAN Speed PWM controller.
 */

#include <sys/cdefs.h>

__KERNEL_RCSID(0, "$NetBSD: g760a.c,v 1.6 2020/11/26 12:53:03 skrll Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/kernel.h>
#include <sys/conf.h>
#include <sys/sysctl.h>

#include <dev/sysmon/sysmonvar.h>

#include <dev/i2c/i2cvar.h>
#include <dev/i2c/g760areg.h>


struct g760a_softc {
          device_t sc_dev;
          struct sysmon_envsys *sc_sme;

          envsys_data_t sc_sensor;
          i2c_tag_t sc_tag;
          int sc_addr;
};

static int g760a_match(device_t, struct cfdata*, void*);
static void g760a_attach(device_t, device_t, void*);
static void g760a_setup(struct g760a_softc*);
static uint8_t g760a_readreg(struct g760a_softc*, uint8_t);
static void g760a_writereg(struct g760a_softc*, uint8_t, uint8_t);

static int g760a_reg2rpm(int);

static void g760a_refresh(struct sysmon_envsys*, envsys_data_t*);
static int sysctl_g760a_rpm(SYSCTLFN_PROTO);

CFATTACH_DECL_NEW(g760a, sizeof(struct g760a_softc),
                    g760a_match, g760a_attach, NULL, NULL);

static int
g760a_match(device_t parent, struct cfdata* cf, void* arg)
{
          struct i2c_attach_args* ia = arg;

          if (ia->ia_addr == G760A_ADDR) {
                    /*
                     * TODO: set up minimal speed?
                     */
                    return I2C_MATCH_ADDRESS_ONLY;
          }

          return 0;
}


static void
g760a_attach(device_t parent, device_t self, void* arg)
{
          struct i2c_attach_args* ia = arg;
          struct g760a_softc* sc = device_private(self);

          aprint_normal(": G760A Fan Controller\n");

          sc->sc_dev = self;
          sc->sc_tag = ia->ia_tag;
          sc->sc_addr = ia->ia_addr;

          g760a_setup(sc);
}


static int
g760a_reg2rpm(int n)
{
          if(n == 255)
                    return 0;

          if(n == 0)
                    return 255;

          return G760A_N2RPM(n);
}


static uint8_t
g760a_readreg(struct g760a_softc* sc, uint8_t reg)
{
          uint8_t data;

          if (iic_acquire_bus(sc->sc_tag, 0)) {
                    aprint_error_dev(sc->sc_dev, "unable to acquire the iic bus\n");
                    return 0;
          }

          iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr, &reg, 1,
              &data, 1, 0);
          iic_release_bus(sc->sc_tag, 0);

          return data;
}


static void
g760a_writereg(struct g760a_softc* sc, uint8_t reg, uint8_t data)
{

          if (iic_acquire_bus(sc->sc_tag, 0)) {
                    aprint_error_dev(sc->sc_dev, "unable to acquire the iic bus\n");
                    return;
          }

          iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_addr, &reg, 1,
              &data, 1, 0);
          iic_release_bus(sc->sc_tag, 0);
}


SYSCTL_SETUP(sysctl_g760a_setup, "sysctl g760a subtree setup")
{

          sysctl_createv(NULL, 0, NULL, NULL,
                              CTLFLAG_PERMANENT,
                              CTLTYPE_NODE, "machdep", NULL,
                              NULL, 0, NULL, 0,
                              CTL_MACHDEP, CTL_EOL);
}


/*ARGUSED*/
static int
sysctl_g760a_rpm(SYSCTLFN_ARGS)
{
          int error, t;
          struct sysctlnode node;
          struct g760a_softc* sc;

          node = *rnode;
          sc = node.sysctl_data;

          t = g760a_readreg(sc, G760A_REG_SET_CNT);
          t = g760a_reg2rpm(t);

          node.sysctl_data = &t;

          error = sysctl_lookup(SYSCTLFN_CALL(&node));

          if (error || newp == NULL)
                    return error;

          if (t > 20000 || t < G760A_N2RPM(254))
                    return EINVAL;

          t = g760a_reg2rpm(t);

          g760a_writereg(sc, G760A_REG_SET_CNT, t);

          return 0;
}


static void
g760a_refresh(struct sysmon_envsys* sme, envsys_data_t* edata)
{
          struct g760a_softc* sc = sme->sme_cookie;

          switch (edata->units) {
                    case ENVSYS_SFANRPM:
                              {
                                        uint8_t n;

                                        n = g760a_readreg(sc, G760A_REG_ACT_CNT);
                                        edata->value_cur = g760a_reg2rpm(n);
                              }
                              break;
                    default:
                              aprint_error_dev(sc->sc_dev, "oops\n");
          }

          edata->state = ENVSYS_SVALID;
}


static void
g760a_setup(struct g760a_softc* sc)
{
          int error;
          int ret;
          const struct sysctlnode *me, *node;

          sc->sc_sme = sysmon_envsys_create();

          ret = sysctl_createv(NULL, 0, NULL, &me,
                              CTLFLAG_READWRITE,
                              CTLTYPE_NODE, device_xname(sc->sc_dev), NULL,
                              NULL, 0, NULL, 0,
                              CTL_MACHDEP, CTL_CREATE, CTL_EOL);
          if (ret)
                    goto sysctl_failed;

          (void)strlcpy(sc->sc_sensor.desc, "sysfan rpm",
                              sizeof(sc->sc_sensor.desc));
          sc->sc_sensor.units = ENVSYS_SFANRPM;
          sc->sc_sensor.state = ENVSYS_SINVALID;

          if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor))
                    goto out;

          ret = sysctl_createv(NULL, 0, NULL, &node,
                              CTLFLAG_READWRITE,
                              CTLTYPE_INT, "rpm", sc->sc_sensor.desc,
                              sysctl_g760a_rpm, 0x42, (void*)sc, 0,
                              CTL_MACHDEP, me->sysctl_num, CTL_CREATE, CTL_EOL);

          if (ret)
                    goto sysctl_failed;

          sc->sc_sme->sme_name = device_xname(sc->sc_dev);
          sc->sc_sme->sme_cookie = sc;
          sc->sc_sme->sme_refresh = g760a_refresh;

          error = sysmon_envsys_register(sc->sc_sme);

          if (error) {
                    aprint_error_dev(sc->sc_dev,
                        "unable to register with sysmon. errorcode %i\n", error);
                    goto out;
          }

          return;

sysctl_failed:
          aprint_error_dev(sc->sc_dev,
              "couldn't create sysctl nodes (%d)\n", ret);

out:
          sysmon_envsys_destroy(sc->sc_sme);
}