/*      $NetBSD: uthum.c,v 1.23 2022/03/28 12:44:17 riastradh Exp $   */
/*      $OpenBSD: uthum.c,v 1.6 2010/01/03 18:43:02 deraadt Exp $   */

/*
* Copyright (c) 2009 Yojiro UO <[email protected]>
*
* 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 DISCAIMS 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.
*/

/*
* Driver for TEMPer and TEMPerHUM HID
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: uthum.c,v 1.23 2022/03/28 12:44:17 riastradh Exp $");

#ifdef _KERNEL_OPT
#include "opt_usb.h"
#endif

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

#include <dev/sysmon/sysmonvar.h>

#include <dev/usb/usb.h>
#include <dev/usb/usbhid.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdi_util.h>
#include <dev/usb/usbdevs.h>
#include <dev/usb/uhidev.h>
#include <dev/hid/hid.h>

#ifdef UTHUM_DEBUG
int     uthumdebug = 0;
#define DPRINTFN(n, x)  do { if (uthumdebug > (n)) printf x; } while (0)
#else
#define DPRINTFN(n, x)
#endif

#define DPRINTF(x) DPRINTFN(0, x)


/* TEMPerHUM */
#define CMD_DEVTYPE 0x52 /* XXX */
#define CMD_GETDATA 0x48 /* XXX */
#define CMD_GETTEMP 0x54 /* XXX */
static const uint8_t cmd_start[8] =
       { 0x0a, 0x0b, 0x0c, 0x0d, 0x00, 0x00, 0x02, 0x00 };
static const uint8_t cmd_end[8] =
       { 0x0a, 0x0b, 0x0c, 0x0d, 0x00, 0x00, 0x01, 0x00 };

/* sensors */
#define UTHUM_TEMP              0
#define UTHUM_HUMIDITY          1
#define UTHUM_MAX_SENSORS       2

#define UTHUM_TYPE_UNKNOWN      0
#define UTHUM_TYPE_SHT1x        1
#define UTHUM_TYPE_TEMPER       2

struct uthum_softc {
       device_t                 sc_dev;
       struct uhidev *          sc_hdev;
       struct usbd_device *     sc_udev;
       u_char                   sc_dying;
       uint16_t                 sc_flag;
       int                      sc_sensortype;

       /* uhidev parameters */
       size_t                   sc_flen;       /* feature report length */
       size_t                   sc_olen;       /* output report length */

       /* sensor framework */
       struct sysmon_envsys             *sc_sme;
       envsys_data_t                    sc_sensor[UTHUM_MAX_SENSORS];

       uint8_t                  sc_num_sensors;
};


static const struct usb_devno uthum_devs[] = {
       /* XXX: various TEMPer variants using same VID/PID */
       { USB_VENDOR_TENX, USB_PRODUCT_TENX_TEMPER},
};
#define uthum_lookup(v, p) usb_lookup(uthum_devs, v, p)

static int uthum_match(device_t, cfdata_t, void *);
static void uthum_attach(device_t, device_t, void *);
static int uthum_detach(device_t, int);
static int uthum_activate(device_t, enum devact);

static int uthum_read_data(struct uthum_softc *, uint8_t, uint8_t *, size_t, int);
static int uthum_check_sensortype(struct uthum_softc *);
static int uthum_temper_temp(uint8_t, uint8_t);
static int uthum_sht1x_temp(uint8_t, uint8_t);
static int uthum_sht1x_rh(unsigned int, int);

static void uthum_refresh(struct sysmon_envsys *, envsys_data_t *);


CFATTACH_DECL_NEW(uthum, sizeof(struct uthum_softc), uthum_match, uthum_attach,
   uthum_detach, uthum_activate);

static int
uthum_match(device_t parent, cfdata_t match, void *aux)
{
       struct uhidev_attach_arg *uha = aux;

       return uthum_lookup(uha->uiaa->uiaa_vendor, uha->uiaa->uiaa_product)
           != NULL ? UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
}

static void
uthum_attach(device_t parent, device_t self, void *aux)
{
       struct uthum_softc *sc = device_private(self);
       struct uhidev_attach_arg *uha = aux;
       struct usbd_device *dev = uha->uiaa->uiaa_device;
       int size, repid;
       void *desc;

       sc->sc_dev = self;
       sc->sc_hdev = uha->parent;
       sc->sc_udev = dev;
       sc->sc_num_sensors = 0;

       aprint_normal("\n");
       aprint_naive("\n");

       uhidev_get_report_desc(uha->parent, &desc, &size);
       repid = uha->reportid;
       sc->sc_olen = hid_report_size(desc, size, hid_output, repid);
       sc->sc_flen = hid_report_size(desc, size, hid_feature, repid);

       usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);

       if (sc->sc_flen < 32) {
               /* not sensor interface, just attach */
               return;
       }

       sc->sc_sensortype = uthum_check_sensortype(sc);

       /* attach sensor */
       sc->sc_sme = sysmon_envsys_create();
       sc->sc_sme->sme_name = device_xname(self);

       switch (sc->sc_sensortype) {
       case UTHUM_TYPE_SHT1x:
               (void)strlcpy(sc->sc_sensor[UTHUM_TEMP].desc, "temp",
                   sizeof(sc->sc_sensor[UTHUM_TEMP].desc));
               sc->sc_sensor[UTHUM_TEMP].units = ENVSYS_STEMP;
               sc->sc_sensor[UTHUM_TEMP].state = ENVSYS_SINVALID;

               (void)strlcpy(sc->sc_sensor[UTHUM_HUMIDITY].desc,
                   "relative humidity",
                   sizeof(sc->sc_sensor[UTHUM_HUMIDITY].desc));
               sc->sc_sensor[UTHUM_HUMIDITY].units = ENVSYS_INTEGER;
               sc->sc_sensor[UTHUM_HUMIDITY].value_cur = 0;
               sc->sc_sensor[UTHUM_HUMIDITY].state = ENVSYS_SINVALID;

               sysmon_envsys_sensor_attach(sc->sc_sme,
                   &sc->sc_sensor[UTHUM_TEMP]);
               sysmon_envsys_sensor_attach(sc->sc_sme,
                   &sc->sc_sensor[UTHUM_HUMIDITY]);
               sc->sc_num_sensors = 2;
               DPRINTF(("sensor type: SHT1x\n"));
               break;
       case UTHUM_TYPE_TEMPER:
               (void)strlcpy(sc->sc_sensor[UTHUM_TEMP].desc, "temp",
                   sizeof(sc->sc_sensor[UTHUM_TEMP].desc));
               sc->sc_sensor[UTHUM_TEMP].units = ENVSYS_STEMP;
               sc->sc_sensor[UTHUM_TEMP].state = ENVSYS_SINVALID;

               sysmon_envsys_sensor_attach(sc->sc_sme,
                   &sc->sc_sensor[UTHUM_TEMP]);
               sc->sc_num_sensors = 1;
               DPRINTF(("sensor type: TEMPer\n"));
               break;
       case UTHUM_TYPE_UNKNOWN:
               DPRINTF(("sensor type: unknown, give up to attach sensors\n"));
       default:
               break;
       }

       if (sc->sc_num_sensors > 0) {
               sc->sc_sme->sme_cookie = sc;
               sc->sc_sme->sme_refresh = uthum_refresh;

               if (sysmon_envsys_register(sc->sc_sme)) {
                       sysmon_envsys_destroy(sc->sc_sme);
                       sc->sc_sme = NULL;
                       aprint_error_dev(self,
                           "unable to register with sysmon\n");
               }
       } else {
               sysmon_envsys_destroy(sc->sc_sme);
               sc->sc_sme = NULL;
       }

       DPRINTF(("uthum_attach: complete\n"));
}

static int
uthum_detach(device_t self, int flags)
{
       struct uthum_softc *sc = device_private(self);
       int rv = 0;

       sc->sc_dying = 1;

       if (sc->sc_sme != NULL)
               sysmon_envsys_unregister(sc->sc_sme);

       usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev);

       return rv;
}

static int
uthum_activate(device_t self, enum devact act)
{
       struct uthum_softc *sc = device_private(self);

       switch (act) {
       case DVACT_DEACTIVATE:
               sc->sc_dying = 1;
               break;
       }
       return 0;
}

static int
uthum_read_data(struct uthum_softc *sc, uint8_t target_cmd, uint8_t *buf,
       size_t len, int need_delay)
{
       int i;
       uint8_t cmdbuf[32], report[256];
       size_t olen, flen;

       /* if return buffer is null, do nothing */
       if ((buf == NULL) || len == 0)
               return 0;

       olen = uimin(sc->sc_olen, sizeof(cmdbuf));

       /* issue query */
       memset(cmdbuf, 0, sizeof(cmdbuf));
       memcpy(cmdbuf, cmd_start, sizeof(cmd_start));
       if (uhidev_set_report(sc->sc_hdev, UHID_OUTPUT_REPORT,
           cmdbuf, olen))
               return EIO;

       memset(cmdbuf, 0, sizeof(cmdbuf));
       cmdbuf[0] = target_cmd;
       if (uhidev_set_report(sc->sc_hdev, UHID_OUTPUT_REPORT,
           cmdbuf, olen))
               return EIO;

       memset(cmdbuf, 0, sizeof(cmdbuf));
       for (i = 0; i < 7; i++) {
               if (uhidev_set_report(sc->sc_hdev, UHID_OUTPUT_REPORT,
                   cmdbuf, olen))
                       return EIO;
       }
       memcpy(cmdbuf, cmd_end, sizeof(cmd_end));
       if (uhidev_set_report(sc->sc_hdev, UHID_OUTPUT_REPORT,
           cmdbuf, olen))
               return EIO;

       /* wait if required */
       if (need_delay > 1)
               kpause("uthum", false, (need_delay*hz+999)/1000 + 1, NULL);

       /* get answer */
       flen = uimin(sc->sc_flen, sizeof(report));
       if (uhidev_get_report(sc->sc_hdev, UHID_FEATURE_REPORT,
           report, flen))
               return EIO;
       memcpy(buf, report, len);
       return 0;
}

static int
uthum_check_sensortype(struct uthum_softc *sc)
{
       uint8_t buf[8];
       static uint8_t sht1x_sig0[] =
           { 0x57, 0x5a, 0x13, 0x00, 0x14, 0x00, 0x53, 0x00 };
       static uint8_t sht1x_sig1[] =
           { 0x57, 0x5a, 0x14, 0x00, 0x14, 0x00, 0x53, 0x00 };
       static uint8_t temper_sig[] =
           { 0x57, 0x58, 0x14, 0x00, 0x14, 0x00, 0x53, 0x00 };

       if (uthum_read_data(sc, CMD_DEVTYPE, buf, sizeof(buf), 0) != 0) {
               DPRINTF(("uthum: read fail\n"));
               return UTHUM_TYPE_UNKNOWN;
       }

       /*
        * currently we have not enough information about the return value,
        * therefore, compare full bytes.
        * TEMPerHUM HID (SHT1x version) will return:
        *   { 0x57, 0x5a, 0x13, 0x00, 0x14, 0x00, 0x53, 0x00 }
        *   { 0x57, 0x5a, 0x14, 0x00, 0x14, 0x00, 0x53, 0x00 }
        * TEMPer HID (TEMPer version) will return:
        *   { 0x57, 0x58, 0x14, 0x00, 0x14, 0x00, 0x53, 0x00 }
        */
       DPRINTF(("uthum: device signature: "
           "0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x\n",
           buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]));
       if (0 == memcmp(buf, sht1x_sig0, sizeof(sht1x_sig0)))
               return UTHUM_TYPE_SHT1x;
       if (0 == memcmp(buf, sht1x_sig1, sizeof(sht1x_sig1)))
               return UTHUM_TYPE_SHT1x;
       if (0 == memcmp(buf, temper_sig, sizeof(temper_sig)))
               return UTHUM_TYPE_TEMPER;

       return UTHUM_TYPE_UNKNOWN;
}


static void
uthum_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
{
       struct uthum_softc *sc = sme->sme_cookie;
       uint8_t buf[8];
       unsigned int humidity_tick;
       int temp, rh;

       switch (sc->sc_sensortype) {
       case UTHUM_TYPE_SHT1x:
               if (uthum_read_data(sc, CMD_GETDATA, buf, sizeof(buf), 1000)
                   != 0) {
                       DPRINTF(("uthum: data read fail\n"));
                       sc->sc_sensor[UTHUM_TEMP].state = ENVSYS_SINVALID;
                       sc->sc_sensor[UTHUM_HUMIDITY].state = ENVSYS_SINVALID;
                       return;
               }
               DPRINTF(("%s: read SHT1x data "
                   "0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x\n",
                   sc->sc_sme->sme_name, buf[0], buf[1], buf[2], buf[3],
                   buf[4], buf[5], buf[6], buf[7]));

               humidity_tick = (buf[2] * 256 + buf[3]) & 0x0fff;

               temp = uthum_sht1x_temp(buf[0], buf[1]);
               rh = uthum_sht1x_rh(humidity_tick, temp);

               sc->sc_sensor[UTHUM_HUMIDITY].value_cur = rh / 1000;
               sc->sc_sensor[UTHUM_HUMIDITY].state = ENVSYS_SVALID;
               break;
       case UTHUM_TYPE_TEMPER:
               if (uthum_read_data(sc, CMD_GETTEMP, buf, sizeof(buf), 0) != 0) {
                       DPRINTF(("uthum: data read fail\n"));
                       sc->sc_sensor[UTHUM_TEMP].state = ENVSYS_SINVALID;
                       return;
               }
               DPRINTF(("%s: read TEMPER data "
                   "0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x\n",
                   sc->sc_sme->sme_name, buf[0], buf[1], buf[2], buf[3],
                   buf[4], buf[5], buf[6], buf[7]));
               temp = uthum_temper_temp(buf[0], buf[1]);
               break;
       default:
               /* do nothing */
               return;
       }

       sc->sc_sensor[UTHUM_TEMP].value_cur = (temp * 10000) + 273150000;
       sc->sc_sensor[UTHUM_TEMP].state = ENVSYS_SVALID;
}

/* return C-degree * 100 value */
static int
uthum_temper_temp(uint8_t msb, uint8_t lsb)
{
       int val;

       val = (msb << 8) | lsb;
       if (val >= 32768) {
               val = val - 65536;
       }
       val = (val * 100) >> 8;
       return val;
}

/* return C-degree * 100 value */
static int
uthum_sht1x_temp(uint8_t msb, uint8_t lsb)
{
       int val;

       val = ((msb << 8) + lsb) - 4096;
       return val;
}

/* return %RH * 1000 */
static int
uthum_sht1x_rh(unsigned int ticks, int temp)
{
       int rh_l, rh;

       rh_l = (-40000 + 405 * ticks) - ((7 * ticks * ticks) / 250);
       rh = ((temp - 2500) * (1 + (ticks >> 7)) + rh_l) / 10;
       return rh;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.