/*      $NetBSD: owtemp.c,v 1.22 2023/12/11 13:30:33 mlelstv Exp $      */
/*      $OpenBSD: owtemp.c,v 1.1 2006/03/04 16:27:03 grange Exp $       */

/*-
* Copyright (c) 2019 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Andrew Doran.
*
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``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 FOUNDATION OR CONTRIBUTORS
* 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.
*/

/*
* Copyright (c) 2006 Alexander Yurchenko <[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 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.
*/

/*
* 1-Wire temperature family type device driver.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: owtemp.c,v 1.22 2023/12/11 13:30:33 mlelstv Exp $");

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

#include <dev/sysmon/sysmonvar.h>

#include <dev/onewire/onewiredevs.h>
#include <dev/onewire/onewirereg.h>
#include <dev/onewire/onewirevar.h>

#define DS_CMD_CONVERT          0x44
#define DS_CMD_READ_SCRATCHPAD  0xbe

struct owtemp_softc {
       device_t                        sc_dv;
       void                            *sc_onewire;
       u_int64_t                       sc_rom;
       const char                      *sc_chipname;

       envsys_data_t                   sc_sensor;
       struct sysmon_envsys            *sc_sme;

       uint32_t                        (*sc_owtemp_decode)(const uint8_t *);

       int                             sc_dying;

       struct evcnt                    sc_ev_update;
       struct evcnt                    sc_ev_rsterr;
       struct evcnt                    sc_ev_crcerr;
};

static int      owtemp_match(device_t, cfdata_t, void *);
static void     owtemp_attach(device_t, device_t, void *);
static int      owtemp_detach(device_t, int);
static int      owtemp_activate(device_t, enum devact);
static bool     owtemp_update(struct owtemp_softc *sc, uint32_t *temp);
static void     owtemp_refresh(struct sysmon_envsys *, envsys_data_t *);
static uint32_t owtemp_decode_ds18b20(const uint8_t *);
static uint32_t owtemp_decode_ds1920(const uint8_t *);

CFATTACH_DECL_NEW(owtemp, sizeof(struct owtemp_softc),
       owtemp_match, owtemp_attach, owtemp_detach, owtemp_activate);

extern struct cfdriver owtemp_cd;

static const struct onewire_matchfam owtemp_fams[] = {
       { ONEWIRE_FAMILY_DS1920 }, /* also DS1820 */
       { ONEWIRE_FAMILY_DS18B20 },
       { ONEWIRE_FAMILY_DS1822 },
};

int     owtemp_retries = 3;

static int
owtemp_match(device_t parent, cfdata_t match, void *aux)
{
       return (onewire_matchbyfam(aux, owtemp_fams,
           __arraycount(owtemp_fams)));
}

static void
owtemp_attach(device_t parent, device_t self, void *aux)
{
       struct owtemp_softc *sc = device_private(self);
       struct onewire_attach_args *oa = aux;

       aprint_naive("\n");

       sc->sc_dv = self;
       sc->sc_onewire = oa->oa_onewire;
       sc->sc_rom = oa->oa_rom;

       switch(ONEWIRE_ROM_FAMILY_TYPE(sc->sc_rom)) {
       case ONEWIRE_FAMILY_DS18B20:
               sc->sc_chipname = "DS18B20";
               sc->sc_owtemp_decode = owtemp_decode_ds18b20;
               break;
       case ONEWIRE_FAMILY_DS1822:
               sc->sc_chipname = "DS1822";
               sc->sc_owtemp_decode = owtemp_decode_ds18b20;
               break;
       case ONEWIRE_FAMILY_DS1920:
               sc->sc_chipname = "DS1920";
               sc->sc_owtemp_decode = owtemp_decode_ds1920;
               break;
       }

       evcnt_attach_dynamic(&sc->sc_ev_update, EVCNT_TYPE_MISC, NULL,
          device_xname(self), "update");
       evcnt_attach_dynamic(&sc->sc_ev_rsterr, EVCNT_TYPE_MISC, NULL,
          device_xname(self), "reset error");
       evcnt_attach_dynamic(&sc->sc_ev_crcerr, EVCNT_TYPE_MISC, NULL,
          device_xname(self), "crc error");

       sc->sc_sme = sysmon_envsys_create();

       /* Initialize sensor */
       sc->sc_sensor.units = ENVSYS_STEMP;
       sc->sc_sensor.state = ENVSYS_SINVALID;
       (void)strlcpy(sc->sc_sensor.desc,
           device_xname(self), sizeof(sc->sc_sensor.desc));
       (void)snprintf(sc->sc_sensor.desc, sizeof(sc->sc_sensor.desc),
           "%s S/N %012" PRIx64, sc->sc_chipname, ONEWIRE_ROM_SN(sc->sc_rom));
       if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor)) {
               sysmon_envsys_destroy(sc->sc_sme);
               sc->sc_sme = NULL;
               return;
       }

       /* Hook into system monitor. */
       sc->sc_sme->sme_name = device_xname(self);
       sc->sc_sme->sme_cookie = sc;
       sc->sc_sme->sme_refresh = owtemp_refresh;

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

       aprint_normal("\n");
}

static int
owtemp_detach(device_t self, int flags)
{
       struct owtemp_softc *sc = device_private(self);

       if (sc->sc_sme != NULL)
               sysmon_envsys_unregister(sc->sc_sme);
       evcnt_detach(&sc->sc_ev_rsterr);
       evcnt_detach(&sc->sc_ev_update);
       evcnt_detach(&sc->sc_ev_crcerr);

       return 0;
}

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

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

static bool
owtemp_update(struct owtemp_softc *sc, uint32_t *temp)
{
       u_int8_t data[9];

       sc->sc_ev_update.ev_count++;

       /*
        * Start temperature conversion. The conversion takes up to 750ms.
        * After sending the command, the data line must be held high for
        * at least 750ms to provide power during the conversion process.
        * As such, no other activity may take place on the 1-Wire bus for
        * at least this period.  Keep the parent bus locked while waiting.
        */
       if (onewire_reset(sc->sc_onewire) != 0) {
               sc->sc_ev_rsterr.ev_count++;
               return false;
       }
       onewire_matchrom(sc->sc_onewire, sc->sc_rom);
       onewire_write_byte(sc->sc_onewire, DS_CMD_CONVERT);
       (void)kpause("owtemp", false, mstohz(750 + 10), NULL);

       /*
        * The result of the temperature measurement is placed in the
        * first two bytes of the scratchpad.  Perform the caculation
        * only if the CRC is correct.
        */
       if (onewire_reset(sc->sc_onewire) != 0) {
               sc->sc_ev_rsterr.ev_count++;
               return false;
       }
       onewire_matchrom(sc->sc_onewire, sc->sc_rom);
       onewire_write_byte(sc->sc_onewire, DS_CMD_READ_SCRATCHPAD);
       onewire_read_block(sc->sc_onewire, data, 9);
       if (onewire_crc(data, 8) != data[8]) {
               sc->sc_ev_crcerr.ev_count++;
               return false;
       }
       *temp = sc->sc_owtemp_decode(data);
       return true;
}

static void
owtemp_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
{
       struct owtemp_softc *sc = sme->sme_cookie;
       uint32_t reading;
       int retry;

       onewire_lock(sc->sc_onewire);
       for (retry = 0; retry < owtemp_retries; retry++) {
               if (owtemp_update(sc, &reading)) {
                       onewire_unlock(sc->sc_onewire);
                       sc->sc_sensor.value_cur = reading;
                       sc->sc_sensor.state = ENVSYS_SVALID;
                       return;
               }
       }
       onewire_unlock(sc->sc_onewire);
       aprint_error_dev(sc->sc_dv,
           "update failed - use vmstat(8) to check event counters\n");
       sc->sc_sensor.state = ENVSYS_SINVALID;
}

static uint32_t
owtemp_decode_ds18b20(const uint8_t *buf)
{
       int temp;

       /*
        * Sign-extend the MSB byte, and add in the fractions of a
        * degree contained in the LSB (precision 1/16th DegC).
        */
       temp = (int8_t)buf[1];
       temp = (temp << 8) | buf[0];

       /*
        * Conversion to uK is simple.
        */
       return (temp * 62500 + 273150000);
}

static uint32_t
owtemp_decode_ds1920(const uint8_t *buf)
{
       int temp;

       /*
        * Sign-extend the MSB byte, and add in the fractions of a
        * degree contained in the LSB (precision 1/2 DegC).
        */
       temp = (int8_t)buf[1];
       temp = (temp << 8) | buf[0];

       if (buf[7] != 0) {
               /*
                * interpolate for higher precision using the count registers
                *
                * buf[7]: COUNT_PER_C(elsius)
                * buf[6]: COUNT_REMAIN
                *
                * T = TEMP - 0.25 + (COUNT_PER_C - COUNT_REMAIN) / COUNT_PER_C
                */
               temp &= ~1;
               temp += 500000 * temp + (500000 * (buf[7] - buf[6])) / buf[7] - 250000;
       } else {
               temp *= 500000;
       }

       /* convert to uK */
       return (temp + 273150000);
}

MODULE(MODULE_CLASS_DRIVER, owtemp, "onewire");

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

static int
owtemp_modcmd(modcmd_t cmd, void *opaque)
{
       int error;

       error = 0;
       switch (cmd) {
       case MODULE_CMD_INIT:
#ifdef _MODULE
               error = config_init_component(cfdriver_ioconf_owtemp,
                   cfattach_ioconf_owtemp, cfdata_ioconf_owtemp);
               if (error)
                       aprint_error("%s: unable to init component\n",
                           owtemp_cd.cd_name);
#endif
               break;
       case MODULE_CMD_FINI:
#ifdef _MODULE
               config_fini_component(cfdriver_ioconf_owtemp,
                   cfattach_ioconf_owtemp, cfdata_ioconf_owtemp);
#endif
               break;
       default:
               error = ENOTTY;
       }
       return error;
}

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.