475 lines
14 KiB
C
475 lines
14 KiB
C
/* $NetBSD: lm87.c,v 1.16 2022/07/02 16:28:39 andvar Exp $ */
|
|
/* $OpenBSD: lm87.c,v 1.20 2008/11/10 05:19:48 cnst Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 2005 Mark Kettenis
|
|
*
|
|
* 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: lm87.c,v 1.16 2022/07/02 16:28:39 andvar Exp $");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/device.h>
|
|
#include <dev/sysmon/sysmonvar.h>
|
|
|
|
#include <dev/i2c/i2cvar.h>
|
|
|
|
/* LM87 registers */
|
|
#define LM87_INT_HHIGH_L 0x13 /* Hardware int high limit (lockable) */
|
|
#define LM87_EXT_HHIGH_L 0x14 /* Hardware ext high limit (lockable) */
|
|
#define LM87_TEST 0x15
|
|
#define LM87_CHANNEL 0x16 /* Dual purpose pin and scaling */
|
|
#define LM87_INT_HHIGH 0x17 /* Hardware int temp high limit */
|
|
#define LM87_EXT_HHIGH 0x18 /* Hardware ext temp high limit */
|
|
#define LM87_DAC_DATA 0x19 /* DAC output scaling */
|
|
#define LM87_AIN1_LOW 0x1a /* Analog in 1 low limit */
|
|
#define LM87_AIN2_LOW 0x1b /* Analog in 2 low limit */
|
|
#define LM87_2_5V 0x20 /* +2.5V or ext temp 2 reading */
|
|
#define LM87_VCCP1 0x21 /* Vccp1 reading */
|
|
#define LM87_VCC 0x22 /* +Vcc reading */
|
|
#define LM87_5V 0x23 /* +5V reading */
|
|
#define LM87_12V 0x24 /* +12V reading */
|
|
#define LM87_VCCP2 0x25 /* Vccp2 reading */
|
|
#define LM87_EXT_TEMP 0x26 /* External temperature 1 reading */
|
|
#define LM87_INT_TEMP 0x27 /* Internal temperature reading */
|
|
#define LM87_FAN1 0x28 /* Fan1 or AIN1 reading */
|
|
#define LM87_FAN2 0x29 /* Fan2 or AIN2 reading */
|
|
#define LM87_2_5V_HIGH 0x2b /* +2.5V or ext temp 2 high limit */
|
|
#define LM87_2_5V_LOW 0x2c /* +2.5V or ext temp 2 low limit */
|
|
#define LM87_VCCP1_HIGH 0x2d /* Vccp1 high limit */
|
|
#define LM87_VCCP1_LOW 0x2e /* Vccp1 low limit */
|
|
#define LM87_VCC_HIGH 0x2f /* +3.3V (Vcc) high limit */
|
|
#define LM87_VCC_LOW 0x30 /* +3.3V (Vcc) low limit */
|
|
#define LM87_5V_HIGH 0x31 /* +5V high limit */
|
|
#define LM87_5V_LOW 0x32 /* +5V low limit */
|
|
#define LM87_12V_HIGH 0x33 /* +12V high limit */
|
|
#define LM87_12V_LOW 0x34 /* +12V low limit */
|
|
#define LM87_VCCP2_HIGH 0x35 /* Vccp2 high limit */
|
|
#define LM87_VCCP2_LOW 0x36 /* Vccp2 low limit */
|
|
#define LM87_EXT_HIGH 0x37 /* External temperature 1 high limit */
|
|
#define LM87_EXT_LOW 0x38 /* External temperature low limit */
|
|
#define LM87_INT_HIGH 0x39 /* Internal temperature 1 high limit */
|
|
#define LM87_INT_LOW 0x3a /* Internal temperature low limit */
|
|
#define LM87_FAN1_HIGH 0x3b /* Fan 1 count or AIN1 high limit */
|
|
#define LM87_FAN2_HIGH 0x3c /* Fan 2 count or AIN2 high limit */
|
|
#define LM87_COMPANY_ID 0x3e /* Company ID */
|
|
#define LM87_REVISION 0x3f /* Revision */
|
|
#define LM87_CONFIG1 0x40 /* Configuration 1 */
|
|
#define LM87_INT_STAT1 0x41 /* Interrupt status 1 */
|
|
#define LM87_INT_STAT2 0x42 /* Interrupt status 2 */
|
|
#define LM87_INT_MASK1 0x43 /* Interrupt mask 1 */
|
|
#define LM87_INT_MASK2 0x44 /* Interrupt mask 2 */
|
|
#define LM87_CI_CLEAR 0x46 /* Chassis intrusion */
|
|
#define LM87_FANDIV 0x47 /* Fan divisor + VID 0-3 */
|
|
#define LM87_VID4 0x48 /* VID4 */
|
|
#define LM87_CONFIG2 0x4a /* Configuration 2 */
|
|
#define LM87_INT_MIRR1 0x4c /* Interrupt status 1 mirror */
|
|
#define LM87_INT_MIRR2 0x4d /* Interrupt status 2 mirror */
|
|
#define LM87_ALERT 0x80 /* SMB Alert enable */
|
|
|
|
/* Register contents */
|
|
#define LM87_CONFIG1_START 0x01
|
|
#define LM87_CONFIG1_INTCLR 0x08
|
|
|
|
#define LM87_CHANNEL_AIN1 0x01
|
|
#define LM87_CHANNEL_AIN2 0x02
|
|
#define LM87_CHANNEL_TEMP2 0x04
|
|
#define LM87_CHANNEL_VCC5 0x08
|
|
|
|
struct lmenv_id {
|
|
u_int8_t id, family;
|
|
const char *name;
|
|
};
|
|
|
|
static const struct lmenv_id lmenv_ids[] = {
|
|
{ 0x01, 81, "LM81" },
|
|
{ 0x02, 87, "LM87" }, /* LM87 or LM87CIMT */
|
|
{ 0x23, 81, "ADM9240" },
|
|
{ 0xda, 81, "DSL780" },
|
|
{ 0x00, 0, NULL }
|
|
};
|
|
|
|
/* Sensors */
|
|
#define LMENV_2_5V 0
|
|
#define LMENV_VCCP1 1
|
|
#define LMENV_VCC 2
|
|
#define LMENV_5V 3
|
|
#define LMENV_12V 4
|
|
#define LMENV_VCCP2 5
|
|
#define LMENV_EXT_TEMP 6
|
|
#define LMENV_INT_TEMP 7
|
|
#define LMENV_FAN1 8
|
|
#define LMENV_FAN2 9
|
|
#define LMENV_NUM_SENSORS 10
|
|
|
|
struct lmenv_softc {
|
|
i2c_tag_t sc_tag;
|
|
i2c_addr_t sc_addr;
|
|
|
|
int sc_fan1_div, sc_fan2_div;
|
|
int sc_family;
|
|
uint8_t sc_channel;
|
|
|
|
struct sysmon_envsys *sc_sme;
|
|
envsys_data_t sc_sensor[LMENV_NUM_SENSORS];
|
|
};
|
|
|
|
int lmenv_match(device_t, cfdata_t, void *);
|
|
void lmenv_attach(device_t, device_t, void *);
|
|
|
|
void lmenv_refresh(struct sysmon_envsys *, envsys_data_t *);
|
|
|
|
CFATTACH_DECL_NEW(lmenv, sizeof(struct lmenv_softc),
|
|
lmenv_match, lmenv_attach, NULL, NULL);
|
|
|
|
static const struct device_compatible_entry compat_data[] = {
|
|
{ .compat = "lm87" },
|
|
{ .compat = "lm87cimt" },
|
|
{ .compat = "adm9240" },
|
|
{ .compat = "lm81" },
|
|
{ .compat = "ds1780" },
|
|
DEVICE_COMPAT_EOL
|
|
};
|
|
|
|
int
|
|
lmenv_match(device_t parent, cfdata_t match, void *aux)
|
|
{
|
|
struct i2c_attach_args *ia = aux;
|
|
u_int8_t cmd, val;
|
|
int error, i, match_result;
|
|
|
|
if (iic_use_direct_match(ia, match, compat_data, &match_result))
|
|
return match_result;
|
|
|
|
/*
|
|
* Indirect config - not much we can do!
|
|
* Check typical addresses and read the Company ID register
|
|
*/
|
|
if ((ia->ia_addr < 0x2c) || (ia->ia_addr > 0x2f))
|
|
return 0;
|
|
|
|
cmd = LM87_COMPANY_ID;
|
|
if (iic_acquire_bus(ia->ia_tag, 0))
|
|
return 0;
|
|
error = iic_exec(ia->ia_tag, I2C_OP_READ_WITH_STOP, ia->ia_addr,
|
|
&cmd, 1, &val, 1, 0);
|
|
iic_release_bus(ia->ia_tag, 0);
|
|
|
|
if (error)
|
|
return 0;
|
|
|
|
for (i = 0; lmenv_ids[i].id != 0; i++)
|
|
if (lmenv_ids[i].id == val)
|
|
return I2C_MATCH_ADDRESS_AND_PROBE;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
lmenv_attach(device_t parent, device_t self, void *aux)
|
|
{
|
|
struct lmenv_softc *sc = device_private(self);
|
|
struct i2c_attach_args *ia = aux;
|
|
u_int8_t cmd, data, data2;
|
|
int i;
|
|
|
|
sc->sc_tag = ia->ia_tag;
|
|
sc->sc_addr = ia->ia_addr;
|
|
|
|
iic_acquire_bus(sc->sc_tag, 0);
|
|
|
|
cmd = LM87_COMPANY_ID;
|
|
if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
|
|
sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
|
|
iic_release_bus(sc->sc_tag, 0);
|
|
printf(": cannot read ID register\n");
|
|
return;
|
|
}
|
|
for (i = 0; lmenv_ids[i].id != 0; i++)
|
|
if (lmenv_ids[i].id == data)
|
|
break;
|
|
|
|
cmd = LM87_REVISION;
|
|
if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
|
|
sc->sc_addr, &cmd, sizeof cmd, &data2, sizeof data, 0)) {
|
|
iic_release_bus(sc->sc_tag, 0);
|
|
printf(": cannot read revision register\n");
|
|
return;
|
|
}
|
|
printf(": %s rev %x\n", lmenv_ids[i].name, data2);
|
|
sc->sc_family = lmenv_ids[i].family;
|
|
|
|
cmd = LM87_FANDIV;
|
|
if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
|
|
sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
|
|
iic_release_bus(sc->sc_tag, 0);
|
|
printf(", cannot read Fan Divisor register\n");
|
|
return;
|
|
}
|
|
sc->sc_fan1_div = 1 << ((data >> 4) & 0x03);
|
|
sc->sc_fan2_div = 1 << ((data >> 6) & 0x03);
|
|
|
|
if (sc->sc_family == 87) {
|
|
cmd = LM87_CHANNEL;
|
|
if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
|
|
sc->sc_addr, &cmd, sizeof cmd, &sc->sc_channel,
|
|
sizeof sc->sc_channel, 0)) {
|
|
iic_release_bus(sc->sc_tag, 0);
|
|
printf(", cannot read Channel register\n");
|
|
return;
|
|
}
|
|
} else
|
|
sc->sc_channel = 0;
|
|
|
|
cmd = LM87_CONFIG1;
|
|
if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
|
|
sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
|
|
iic_release_bus(sc->sc_tag, 0);
|
|
printf(", cannot read Configuration Register 1\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* if chip is not running, try to start it.
|
|
* if it is stalled doing an interrupt, unstall it
|
|
*/
|
|
data2 = (data | LM87_CONFIG1_START);
|
|
data2 = data2 & ~LM87_CONFIG1_INTCLR;
|
|
|
|
if (data != data2) {
|
|
if (iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP,
|
|
sc->sc_addr, &cmd, sizeof cmd, &data2, sizeof data2, 0)) {
|
|
iic_release_bus(sc->sc_tag, 0);
|
|
printf(", cannot write Configuration Register 1\n");
|
|
return;
|
|
}
|
|
}
|
|
iic_release_bus(sc->sc_tag, 0);
|
|
|
|
/* Initialize sensor data. */
|
|
sc->sc_sensor[LMENV_2_5V].state = ENVSYS_SINVALID;
|
|
if (sc->sc_channel & LM87_CHANNEL_TEMP2) {
|
|
sc->sc_sensor[LMENV_INT_TEMP].units = ENVSYS_STEMP;
|
|
strlcpy(sc->sc_sensor[LMENV_2_5V].desc, "External 2",
|
|
sizeof(sc->sc_sensor[LMENV_2_5V].desc));
|
|
} else {
|
|
sc->sc_sensor[LMENV_2_5V].units = ENVSYS_SVOLTS_DC;
|
|
strlcpy(sc->sc_sensor[LMENV_2_5V].desc, "+2.5Vin",
|
|
sizeof(sc->sc_sensor[LMENV_2_5V].desc));
|
|
}
|
|
|
|
sc->sc_sensor[LMENV_VCCP1].state = ENVSYS_SINVALID;
|
|
sc->sc_sensor[LMENV_VCCP1].units = ENVSYS_SVOLTS_DC;
|
|
strlcpy(sc->sc_sensor[LMENV_VCCP1].desc, "Vccp1",
|
|
sizeof(sc->sc_sensor[LMENV_VCCP1].desc));
|
|
|
|
sc->sc_sensor[LMENV_VCC].state = ENVSYS_SINVALID;
|
|
sc->sc_sensor[LMENV_VCC].units = ENVSYS_SVOLTS_DC;
|
|
strlcpy(sc->sc_sensor[LMENV_VCC].desc, "+Vcc",
|
|
sizeof(sc->sc_sensor[LMENV_VCC].desc));
|
|
|
|
sc->sc_sensor[LMENV_5V].state = ENVSYS_SINVALID;
|
|
sc->sc_sensor[LMENV_5V].units = ENVSYS_SVOLTS_DC;
|
|
strlcpy(sc->sc_sensor[LMENV_5V].desc, "+5Vin/Vcc",
|
|
sizeof(sc->sc_sensor[LMENV_5V].desc));
|
|
|
|
sc->sc_sensor[LMENV_12V].state = ENVSYS_SINVALID;
|
|
sc->sc_sensor[LMENV_12V].units = ENVSYS_SVOLTS_DC;
|
|
strlcpy(sc->sc_sensor[LMENV_12V].desc, "+12Vin",
|
|
sizeof(sc->sc_sensor[LMENV_12V].desc));
|
|
|
|
sc->sc_sensor[LMENV_VCCP2].state = ENVSYS_SINVALID;
|
|
if (!(sc->sc_channel & LM87_CHANNEL_TEMP2)) {
|
|
sc->sc_sensor[LMENV_VCCP2].units = ENVSYS_SVOLTS_DC;
|
|
strlcpy(sc->sc_sensor[LMENV_VCCP2].desc, "Vccp2",
|
|
sizeof(sc->sc_sensor[LMENV_VCCP2].desc));
|
|
}
|
|
|
|
sc->sc_sensor[LMENV_EXT_TEMP].state = ENVSYS_SINVALID;
|
|
sc->sc_sensor[LMENV_EXT_TEMP].units = ENVSYS_STEMP;
|
|
if (sc->sc_channel & LM87_CHANNEL_TEMP2)
|
|
strlcpy(sc->sc_sensor[LMENV_EXT_TEMP].desc, "External 1",
|
|
sizeof(sc->sc_sensor[LMENV_EXT_TEMP].desc));
|
|
else
|
|
strlcpy(sc->sc_sensor[LMENV_EXT_TEMP].desc, "External",
|
|
sizeof(sc->sc_sensor[LMENV_EXT_TEMP].desc));
|
|
|
|
sc->sc_sensor[LMENV_INT_TEMP].state = ENVSYS_SINVALID;
|
|
sc->sc_sensor[LMENV_INT_TEMP].units = ENVSYS_STEMP;
|
|
strlcpy(sc->sc_sensor[LMENV_INT_TEMP].desc, "Internal",
|
|
sizeof(sc->sc_sensor[LMENV_INT_TEMP].desc));
|
|
|
|
sc->sc_sensor[LMENV_FAN1].state = ENVSYS_SINVALID;
|
|
if (sc->sc_channel & LM87_CHANNEL_AIN1) {
|
|
sc->sc_sensor[LMENV_FAN1].units = ENVSYS_SVOLTS_DC;
|
|
strlcpy(sc->sc_sensor[LMENV_FAN1].desc, "AIN1",
|
|
sizeof(sc->sc_sensor[LMENV_FAN1].desc));
|
|
} else {
|
|
sc->sc_sensor[LMENV_FAN1].units = ENVSYS_SFANRPM;
|
|
strlcpy(sc->sc_sensor[LMENV_FAN1].desc, "FAN1",
|
|
sizeof(sc->sc_sensor[LMENV_FAN1].desc));
|
|
}
|
|
|
|
sc->sc_sensor[LMENV_FAN2].state = ENVSYS_SINVALID;
|
|
if (sc->sc_channel & LM87_CHANNEL_AIN2) {
|
|
sc->sc_sensor[LMENV_FAN2].units = ENVSYS_SVOLTS_DC;
|
|
strlcpy(sc->sc_sensor[LMENV_FAN2].desc, "AIN2",
|
|
sizeof(sc->sc_sensor[LMENV_FAN2].desc));
|
|
} else {
|
|
sc->sc_sensor[LMENV_FAN2].units = ENVSYS_SFANRPM;
|
|
strlcpy(sc->sc_sensor[LMENV_FAN2].desc, "FAN2",
|
|
sizeof(sc->sc_sensor[LMENV_FAN2].desc));
|
|
}
|
|
|
|
sc->sc_sme = sysmon_envsys_create();
|
|
for (i = 0; i < LMENV_NUM_SENSORS; i++)
|
|
if (sysmon_envsys_sensor_attach(sc->sc_sme,
|
|
&sc->sc_sensor[i])) {
|
|
sysmon_envsys_destroy(sc->sc_sme);
|
|
aprint_error_dev(self,
|
|
"unable to attach sensor %d at sysmon\n", i);
|
|
return;
|
|
}
|
|
sc->sc_sme->sme_name = device_xname(self);
|
|
sc->sc_sme->sme_cookie = sc;
|
|
sc->sc_sme->sme_refresh = lmenv_refresh;
|
|
if (sysmon_envsys_register(sc->sc_sme)) {
|
|
aprint_error_dev(self,
|
|
"unable to register with sysmon\n");
|
|
sysmon_envsys_destroy(sc->sc_sme);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void
|
|
lmenv_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
|
|
{
|
|
struct lmenv_softc *sc = sme->sme_cookie;
|
|
u_int8_t cmd, data;
|
|
u_int tmp;
|
|
|
|
iic_acquire_bus(sc->sc_tag, 0);
|
|
|
|
cmd = LM87_2_5V + edata->sensor;
|
|
if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
|
|
sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
|
|
edata->state = ENVSYS_SINVALID;
|
|
return;
|
|
}
|
|
|
|
switch (edata->sensor) {
|
|
case LMENV_2_5V:
|
|
/* Might be external temperature 2 */
|
|
if (sc->sc_channel & LM87_CHANNEL_TEMP2) {
|
|
if (data == 0x80)
|
|
edata->state = ENVSYS_SINVALID;
|
|
else {
|
|
edata->value_cur =
|
|
(int8_t)data * 1000000 + 273150000;
|
|
edata->state = ENVSYS_SVALID;
|
|
}
|
|
break;
|
|
}
|
|
edata->value_cur = 2500000 * data / 192;
|
|
edata->state = ENVSYS_SVALID;
|
|
break;
|
|
case LMENV_5V:
|
|
edata->value_cur = 5000000 * data / 192;
|
|
edata->state = ENVSYS_SVALID;
|
|
break;
|
|
case LMENV_12V:
|
|
edata->value_cur = 12000000 * data / 192;
|
|
edata->state = ENVSYS_SVALID;
|
|
break;
|
|
case LMENV_VCCP1:
|
|
edata->value_cur = 2700000 * data / 192;
|
|
edata->state = ENVSYS_SVALID;
|
|
break;
|
|
case LMENV_VCCP2:
|
|
/* If monitoring external temperature 2, this isn't monitored */
|
|
if (sc->sc_channel & LM87_CHANNEL_TEMP2) {
|
|
edata->state = ENVSYS_SINVALID;
|
|
break;
|
|
}
|
|
edata->value_cur = 2700000 * data / 192;
|
|
edata->state = ENVSYS_SVALID;
|
|
break;
|
|
case LMENV_VCC:
|
|
/* Voltage scale selectable (5V or 3.3V) */
|
|
edata->value_cur =
|
|
(LM87_CHANNEL_VCC5 ? 5000000 : 3300000) * data / 192;
|
|
edata->state = ENVSYS_SVALID;
|
|
break;
|
|
case LMENV_EXT_TEMP:
|
|
if (sc->sc_family == 81) {
|
|
edata->state = ENVSYS_SINVALID;
|
|
break; /* missing on LM81 */
|
|
}
|
|
/* FALLTHROUGH */
|
|
case LMENV_INT_TEMP:
|
|
if (data == 0x80)
|
|
edata->state = ENVSYS_SINVALID;
|
|
else {
|
|
edata->value_cur = (int8_t)data * 1000000 + 273150000;
|
|
edata->state = ENVSYS_SVALID;
|
|
}
|
|
break;
|
|
case LMENV_FAN1:
|
|
/* Might be analogue input 1 */
|
|
if (sc->sc_channel & LM87_CHANNEL_AIN1) {
|
|
edata->value_cur = 1870000 * data / 192;
|
|
edata->state = ENVSYS_SVALID;
|
|
break;
|
|
}
|
|
if (data == 0xff) {
|
|
edata->state = ENVSYS_SINVALID;
|
|
break;
|
|
}
|
|
tmp = data * sc->sc_fan1_div;
|
|
if (tmp == 0)
|
|
edata->state = ENVSYS_SINVALID;
|
|
else {
|
|
edata->value_cur = 1350000 / tmp;
|
|
edata->state = ENVSYS_SVALID;
|
|
}
|
|
break;
|
|
case LMENV_FAN2:
|
|
/* Might be analogue input 2 */
|
|
if (sc->sc_channel & LM87_CHANNEL_AIN2) {
|
|
edata->value_cur = 1870000 * data / 192;
|
|
edata->state = ENVSYS_SVALID;
|
|
break;
|
|
}
|
|
if (data == 0xff) {
|
|
edata->state = ENVSYS_SINVALID;
|
|
break;
|
|
}
|
|
tmp = data * sc->sc_fan2_div;
|
|
if (tmp == 0)
|
|
edata->state = ENVSYS_SINVALID;
|
|
else {
|
|
edata->value_cur = 1350000 / tmp;
|
|
edata->state = ENVSYS_SVALID;
|
|
}
|
|
break;
|
|
default:
|
|
edata->state = ENVSYS_SINVALID;
|
|
break;
|
|
}
|
|
|
|
iic_release_bus(sc->sc_tag, 0);
|
|
}
|