mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-05 10:04:12 +08:00
c942fddf87
Based on 3 normalized pattern(s): this program is free software you can redistribute it and or modify it under the terms of the gnu general public license as published by the free software foundation either version 2 of the license or at your option any later version this program is distributed in the hope that it will be useful but without any warranty without even the implied warranty of merchantability or fitness for a particular purpose see the gnu general public license for more details this program is free software you can redistribute it and or modify it under the terms of the gnu general public license as published by the free software foundation either version 2 of the license or at your option any later version [author] [kishon] [vijay] [abraham] [i] [kishon]@[ti] [com] this program is distributed in the hope that it will be useful but without any warranty without even the implied warranty of merchantability or fitness for a particular purpose see the gnu general public license for more details this program is free software you can redistribute it and or modify it under the terms of the gnu general public license as published by the free software foundation either version 2 of the license or at your option any later version [author] [graeme] [gregory] [gg]@[slimlogic] [co] [uk] [author] [kishon] [vijay] [abraham] [i] [kishon]@[ti] [com] [based] [on] [twl6030]_[usb] [c] [author] [hema] [hk] [hemahk]@[ti] [com] this program is distributed in the hope that it will be useful but without any warranty without even the implied warranty of merchantability or fitness for a particular purpose see the gnu general public license for more details extracted by the scancode license scanner the SPDX license identifier GPL-2.0-or-later has been chosen to replace the boilerplate/reference in 1105 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Reviewed-by: Richard Fontana <rfontana@redhat.com> Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190527070033.202006027@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
612 lines
15 KiB
C
612 lines
15 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* Copyright (C) 2011 Alexander Stein <alexander.stein@systec-electronic.com>
|
|
*
|
|
* The LM95245 is a sensor chip made by TI / National Semiconductor.
|
|
* It reports up to two temperatures (its own plus an external one).
|
|
*
|
|
* This driver is based on lm95241.c
|
|
*/
|
|
|
|
#include <linux/err.h>
|
|
#include <linux/init.h>
|
|
#include <linux/hwmon.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/module.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/regmap.h>
|
|
#include <linux/slab.h>
|
|
|
|
static const unsigned short normal_i2c[] = {
|
|
0x18, 0x19, 0x29, 0x4c, 0x4d, I2C_CLIENT_END };
|
|
|
|
/* LM95245 registers */
|
|
/* general registers */
|
|
#define LM95245_REG_RW_CONFIG1 0x03
|
|
#define LM95245_REG_RW_CONVERS_RATE 0x04
|
|
#define LM95245_REG_W_ONE_SHOT 0x0F
|
|
|
|
/* diode configuration */
|
|
#define LM95245_REG_RW_CONFIG2 0xBF
|
|
#define LM95245_REG_RW_REMOTE_OFFH 0x11
|
|
#define LM95245_REG_RW_REMOTE_OFFL 0x12
|
|
|
|
/* status registers */
|
|
#define LM95245_REG_R_STATUS1 0x02
|
|
#define LM95245_REG_R_STATUS2 0x33
|
|
|
|
/* limit registers */
|
|
#define LM95245_REG_RW_REMOTE_OS_LIMIT 0x07
|
|
#define LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT 0x20
|
|
#define LM95245_REG_RW_REMOTE_TCRIT_LIMIT 0x19
|
|
#define LM95245_REG_RW_COMMON_HYSTERESIS 0x21
|
|
|
|
/* temperature signed */
|
|
#define LM95245_REG_R_LOCAL_TEMPH_S 0x00
|
|
#define LM95245_REG_R_LOCAL_TEMPL_S 0x30
|
|
#define LM95245_REG_R_REMOTE_TEMPH_S 0x01
|
|
#define LM95245_REG_R_REMOTE_TEMPL_S 0x10
|
|
/* temperature unsigned */
|
|
#define LM95245_REG_R_REMOTE_TEMPH_U 0x31
|
|
#define LM95245_REG_R_REMOTE_TEMPL_U 0x32
|
|
|
|
/* id registers */
|
|
#define LM95245_REG_R_MAN_ID 0xFE
|
|
#define LM95245_REG_R_CHIP_ID 0xFF
|
|
|
|
/* LM95245 specific bitfields */
|
|
#define CFG_STOP 0x40
|
|
#define CFG_REMOTE_TCRIT_MASK 0x10
|
|
#define CFG_REMOTE_OS_MASK 0x08
|
|
#define CFG_LOCAL_TCRIT_MASK 0x04
|
|
#define CFG_LOCAL_OS_MASK 0x02
|
|
|
|
#define CFG2_OS_A0 0x40
|
|
#define CFG2_DIODE_FAULT_OS 0x20
|
|
#define CFG2_DIODE_FAULT_TCRIT 0x10
|
|
#define CFG2_REMOTE_TT 0x08
|
|
#define CFG2_REMOTE_FILTER_DIS 0x00
|
|
#define CFG2_REMOTE_FILTER_EN 0x06
|
|
|
|
/* conversation rate in ms */
|
|
#define RATE_CR0063 0x00
|
|
#define RATE_CR0364 0x01
|
|
#define RATE_CR1000 0x02
|
|
#define RATE_CR2500 0x03
|
|
|
|
#define STATUS1_ROS 0x10
|
|
#define STATUS1_DIODE_FAULT 0x04
|
|
#define STATUS1_RTCRIT 0x02
|
|
#define STATUS1_LOC 0x01
|
|
|
|
#define MANUFACTURER_ID 0x01
|
|
#define LM95235_REVISION 0xB1
|
|
#define LM95245_REVISION 0xB3
|
|
|
|
/* Client data (each client gets its own) */
|
|
struct lm95245_data {
|
|
struct regmap *regmap;
|
|
struct mutex update_lock;
|
|
int interval; /* in msecs */
|
|
};
|
|
|
|
/* Conversions */
|
|
static int temp_from_reg_unsigned(u8 val_h, u8 val_l)
|
|
{
|
|
return val_h * 1000 + val_l * 1000 / 256;
|
|
}
|
|
|
|
static int temp_from_reg_signed(u8 val_h, u8 val_l)
|
|
{
|
|
if (val_h & 0x80)
|
|
return (val_h - 0x100) * 1000;
|
|
return temp_from_reg_unsigned(val_h, val_l);
|
|
}
|
|
|
|
static int lm95245_read_conversion_rate(struct lm95245_data *data)
|
|
{
|
|
unsigned int rate;
|
|
int ret;
|
|
|
|
ret = regmap_read(data->regmap, LM95245_REG_RW_CONVERS_RATE, &rate);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
switch (rate) {
|
|
case RATE_CR0063:
|
|
data->interval = 63;
|
|
break;
|
|
case RATE_CR0364:
|
|
data->interval = 364;
|
|
break;
|
|
case RATE_CR1000:
|
|
data->interval = 1000;
|
|
break;
|
|
case RATE_CR2500:
|
|
default:
|
|
data->interval = 2500;
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int lm95245_set_conversion_rate(struct lm95245_data *data, long interval)
|
|
{
|
|
int ret, rate;
|
|
|
|
if (interval <= 63) {
|
|
interval = 63;
|
|
rate = RATE_CR0063;
|
|
} else if (interval <= 364) {
|
|
interval = 364;
|
|
rate = RATE_CR0364;
|
|
} else if (interval <= 1000) {
|
|
interval = 1000;
|
|
rate = RATE_CR1000;
|
|
} else {
|
|
interval = 2500;
|
|
rate = RATE_CR2500;
|
|
}
|
|
|
|
ret = regmap_write(data->regmap, LM95245_REG_RW_CONVERS_RATE, rate);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
data->interval = interval;
|
|
return 0;
|
|
}
|
|
|
|
static int lm95245_read_temp(struct device *dev, u32 attr, int channel,
|
|
long *val)
|
|
{
|
|
struct lm95245_data *data = dev_get_drvdata(dev);
|
|
struct regmap *regmap = data->regmap;
|
|
int ret, regl, regh, regvall, regvalh;
|
|
|
|
switch (attr) {
|
|
case hwmon_temp_input:
|
|
regl = channel ? LM95245_REG_R_REMOTE_TEMPL_S :
|
|
LM95245_REG_R_LOCAL_TEMPL_S;
|
|
regh = channel ? LM95245_REG_R_REMOTE_TEMPH_S :
|
|
LM95245_REG_R_LOCAL_TEMPH_S;
|
|
ret = regmap_read(regmap, regl, ®vall);
|
|
if (ret < 0)
|
|
return ret;
|
|
ret = regmap_read(regmap, regh, ®valh);
|
|
if (ret < 0)
|
|
return ret;
|
|
/*
|
|
* Local temp is always signed.
|
|
* Remote temp has both signed and unsigned data.
|
|
* Use signed calculation for remote if signed bit is set
|
|
* or if reported temperature is below signed limit.
|
|
*/
|
|
if (!channel || (regvalh & 0x80) || regvalh < 0x7f) {
|
|
*val = temp_from_reg_signed(regvalh, regvall);
|
|
return 0;
|
|
}
|
|
ret = regmap_read(regmap, LM95245_REG_R_REMOTE_TEMPL_U,
|
|
®vall);
|
|
if (ret < 0)
|
|
return ret;
|
|
ret = regmap_read(regmap, LM95245_REG_R_REMOTE_TEMPH_U,
|
|
®valh);
|
|
if (ret < 0)
|
|
return ret;
|
|
*val = temp_from_reg_unsigned(regvalh, regvall);
|
|
return 0;
|
|
case hwmon_temp_max:
|
|
ret = regmap_read(regmap, LM95245_REG_RW_REMOTE_OS_LIMIT,
|
|
®valh);
|
|
if (ret < 0)
|
|
return ret;
|
|
*val = regvalh * 1000;
|
|
return 0;
|
|
case hwmon_temp_crit:
|
|
regh = channel ? LM95245_REG_RW_REMOTE_TCRIT_LIMIT :
|
|
LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT;
|
|
ret = regmap_read(regmap, regh, ®valh);
|
|
if (ret < 0)
|
|
return ret;
|
|
*val = regvalh * 1000;
|
|
return 0;
|
|
case hwmon_temp_max_hyst:
|
|
ret = regmap_read(regmap, LM95245_REG_RW_REMOTE_OS_LIMIT,
|
|
®valh);
|
|
if (ret < 0)
|
|
return ret;
|
|
ret = regmap_read(regmap, LM95245_REG_RW_COMMON_HYSTERESIS,
|
|
®vall);
|
|
if (ret < 0)
|
|
return ret;
|
|
*val = (regvalh - regvall) * 1000;
|
|
return 0;
|
|
case hwmon_temp_crit_hyst:
|
|
regh = channel ? LM95245_REG_RW_REMOTE_TCRIT_LIMIT :
|
|
LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT;
|
|
ret = regmap_read(regmap, regh, ®valh);
|
|
if (ret < 0)
|
|
return ret;
|
|
ret = regmap_read(regmap, LM95245_REG_RW_COMMON_HYSTERESIS,
|
|
®vall);
|
|
if (ret < 0)
|
|
return ret;
|
|
*val = (regvalh - regvall) * 1000;
|
|
return 0;
|
|
case hwmon_temp_type:
|
|
ret = regmap_read(regmap, LM95245_REG_RW_CONFIG2, ®valh);
|
|
if (ret < 0)
|
|
return ret;
|
|
*val = (regvalh & CFG2_REMOTE_TT) ? 1 : 2;
|
|
return 0;
|
|
case hwmon_temp_offset:
|
|
ret = regmap_read(regmap, LM95245_REG_RW_REMOTE_OFFL,
|
|
®vall);
|
|
if (ret < 0)
|
|
return ret;
|
|
ret = regmap_read(regmap, LM95245_REG_RW_REMOTE_OFFH,
|
|
®valh);
|
|
if (ret < 0)
|
|
return ret;
|
|
*val = temp_from_reg_signed(regvalh, regvall);
|
|
return 0;
|
|
case hwmon_temp_max_alarm:
|
|
ret = regmap_read(regmap, LM95245_REG_R_STATUS1, ®valh);
|
|
if (ret < 0)
|
|
return ret;
|
|
*val = !!(regvalh & STATUS1_ROS);
|
|
return 0;
|
|
case hwmon_temp_crit_alarm:
|
|
ret = regmap_read(regmap, LM95245_REG_R_STATUS1, ®valh);
|
|
if (ret < 0)
|
|
return ret;
|
|
*val = !!(regvalh & (channel ? STATUS1_RTCRIT : STATUS1_LOC));
|
|
return 0;
|
|
case hwmon_temp_fault:
|
|
ret = regmap_read(regmap, LM95245_REG_R_STATUS1, ®valh);
|
|
if (ret < 0)
|
|
return ret;
|
|
*val = !!(regvalh & STATUS1_DIODE_FAULT);
|
|
return 0;
|
|
default:
|
|
return -EOPNOTSUPP;
|
|
}
|
|
}
|
|
|
|
static int lm95245_write_temp(struct device *dev, u32 attr, int channel,
|
|
long val)
|
|
{
|
|
struct lm95245_data *data = dev_get_drvdata(dev);
|
|
struct regmap *regmap = data->regmap;
|
|
unsigned int regval;
|
|
int ret, reg;
|
|
|
|
switch (attr) {
|
|
case hwmon_temp_max:
|
|
val = clamp_val(val / 1000, 0, 255);
|
|
ret = regmap_write(regmap, LM95245_REG_RW_REMOTE_OS_LIMIT, val);
|
|
return ret;
|
|
case hwmon_temp_crit:
|
|
reg = channel ? LM95245_REG_RW_REMOTE_TCRIT_LIMIT :
|
|
LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT;
|
|
val = clamp_val(val / 1000, 0, channel ? 255 : 127);
|
|
ret = regmap_write(regmap, reg, val);
|
|
return ret;
|
|
case hwmon_temp_crit_hyst:
|
|
mutex_lock(&data->update_lock);
|
|
ret = regmap_read(regmap, LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT,
|
|
®val);
|
|
if (ret < 0) {
|
|
mutex_unlock(&data->update_lock);
|
|
return ret;
|
|
}
|
|
/* Clamp to reasonable range to prevent overflow */
|
|
val = clamp_val(val, -1000000, 1000000);
|
|
val = regval - val / 1000;
|
|
val = clamp_val(val, 0, 31);
|
|
ret = regmap_write(regmap, LM95245_REG_RW_COMMON_HYSTERESIS,
|
|
val);
|
|
mutex_unlock(&data->update_lock);
|
|
return ret;
|
|
case hwmon_temp_offset:
|
|
val = clamp_val(val, -128000, 127875);
|
|
val = val * 256 / 1000;
|
|
mutex_lock(&data->update_lock);
|
|
ret = regmap_write(regmap, LM95245_REG_RW_REMOTE_OFFL,
|
|
val & 0xe0);
|
|
if (ret < 0) {
|
|
mutex_unlock(&data->update_lock);
|
|
return ret;
|
|
}
|
|
ret = regmap_write(regmap, LM95245_REG_RW_REMOTE_OFFH,
|
|
(val >> 8) & 0xff);
|
|
mutex_unlock(&data->update_lock);
|
|
return ret;
|
|
case hwmon_temp_type:
|
|
if (val != 1 && val != 2)
|
|
return -EINVAL;
|
|
ret = regmap_update_bits(regmap, LM95245_REG_RW_CONFIG2,
|
|
CFG2_REMOTE_TT,
|
|
val == 1 ? CFG2_REMOTE_TT : 0);
|
|
return ret;
|
|
default:
|
|
return -EOPNOTSUPP;
|
|
}
|
|
}
|
|
|
|
static int lm95245_read_chip(struct device *dev, u32 attr, int channel,
|
|
long *val)
|
|
{
|
|
struct lm95245_data *data = dev_get_drvdata(dev);
|
|
|
|
switch (attr) {
|
|
case hwmon_chip_update_interval:
|
|
*val = data->interval;
|
|
return 0;
|
|
default:
|
|
return -EOPNOTSUPP;
|
|
}
|
|
}
|
|
|
|
static int lm95245_write_chip(struct device *dev, u32 attr, int channel,
|
|
long val)
|
|
{
|
|
struct lm95245_data *data = dev_get_drvdata(dev);
|
|
int ret;
|
|
|
|
switch (attr) {
|
|
case hwmon_chip_update_interval:
|
|
mutex_lock(&data->update_lock);
|
|
ret = lm95245_set_conversion_rate(data, val);
|
|
mutex_unlock(&data->update_lock);
|
|
return ret;
|
|
default:
|
|
return -EOPNOTSUPP;
|
|
}
|
|
}
|
|
|
|
static int lm95245_read(struct device *dev, enum hwmon_sensor_types type,
|
|
u32 attr, int channel, long *val)
|
|
{
|
|
switch (type) {
|
|
case hwmon_chip:
|
|
return lm95245_read_chip(dev, attr, channel, val);
|
|
case hwmon_temp:
|
|
return lm95245_read_temp(dev, attr, channel, val);
|
|
default:
|
|
return -EOPNOTSUPP;
|
|
}
|
|
}
|
|
|
|
static int lm95245_write(struct device *dev, enum hwmon_sensor_types type,
|
|
u32 attr, int channel, long val)
|
|
{
|
|
switch (type) {
|
|
case hwmon_chip:
|
|
return lm95245_write_chip(dev, attr, channel, val);
|
|
case hwmon_temp:
|
|
return lm95245_write_temp(dev, attr, channel, val);
|
|
default:
|
|
return -EOPNOTSUPP;
|
|
}
|
|
}
|
|
|
|
static umode_t lm95245_temp_is_visible(const void *data, u32 attr, int channel)
|
|
{
|
|
switch (attr) {
|
|
case hwmon_temp_input:
|
|
case hwmon_temp_max_alarm:
|
|
case hwmon_temp_max_hyst:
|
|
case hwmon_temp_crit_alarm:
|
|
case hwmon_temp_fault:
|
|
return 0444;
|
|
case hwmon_temp_type:
|
|
case hwmon_temp_max:
|
|
case hwmon_temp_crit:
|
|
case hwmon_temp_offset:
|
|
return 0644;
|
|
case hwmon_temp_crit_hyst:
|
|
return (channel == 0) ? 0644 : 0444;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static umode_t lm95245_is_visible(const void *data,
|
|
enum hwmon_sensor_types type,
|
|
u32 attr, int channel)
|
|
{
|
|
switch (type) {
|
|
case hwmon_chip:
|
|
switch (attr) {
|
|
case hwmon_chip_update_interval:
|
|
return 0644;
|
|
default:
|
|
return 0;
|
|
}
|
|
case hwmon_temp:
|
|
return lm95245_temp_is_visible(data, attr, channel);
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* Return 0 if detection is successful, -ENODEV otherwise */
|
|
static int lm95245_detect(struct i2c_client *new_client,
|
|
struct i2c_board_info *info)
|
|
{
|
|
struct i2c_adapter *adapter = new_client->adapter;
|
|
int address = new_client->addr;
|
|
const char *name;
|
|
int rev, id;
|
|
|
|
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
|
|
return -ENODEV;
|
|
|
|
id = i2c_smbus_read_byte_data(new_client, LM95245_REG_R_MAN_ID);
|
|
if (id != MANUFACTURER_ID)
|
|
return -ENODEV;
|
|
|
|
rev = i2c_smbus_read_byte_data(new_client, LM95245_REG_R_CHIP_ID);
|
|
switch (rev) {
|
|
case LM95235_REVISION:
|
|
if (address != 0x18 && address != 0x29 && address != 0x4c)
|
|
return -ENODEV;
|
|
name = "lm95235";
|
|
break;
|
|
case LM95245_REVISION:
|
|
name = "lm95245";
|
|
break;
|
|
default:
|
|
return -ENODEV;
|
|
}
|
|
|
|
strlcpy(info->type, name, I2C_NAME_SIZE);
|
|
return 0;
|
|
}
|
|
|
|
static int lm95245_init_client(struct lm95245_data *data)
|
|
{
|
|
int ret;
|
|
|
|
ret = lm95245_read_conversion_rate(data);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
return regmap_update_bits(data->regmap, LM95245_REG_RW_CONFIG1,
|
|
CFG_STOP, 0);
|
|
}
|
|
|
|
static bool lm95245_is_writeable_reg(struct device *dev, unsigned int reg)
|
|
{
|
|
switch (reg) {
|
|
case LM95245_REG_RW_CONFIG1:
|
|
case LM95245_REG_RW_CONVERS_RATE:
|
|
case LM95245_REG_W_ONE_SHOT:
|
|
case LM95245_REG_RW_CONFIG2:
|
|
case LM95245_REG_RW_REMOTE_OFFH:
|
|
case LM95245_REG_RW_REMOTE_OFFL:
|
|
case LM95245_REG_RW_REMOTE_OS_LIMIT:
|
|
case LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT:
|
|
case LM95245_REG_RW_REMOTE_TCRIT_LIMIT:
|
|
case LM95245_REG_RW_COMMON_HYSTERESIS:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static bool lm95245_is_volatile_reg(struct device *dev, unsigned int reg)
|
|
{
|
|
switch (reg) {
|
|
case LM95245_REG_R_STATUS1:
|
|
case LM95245_REG_R_STATUS2:
|
|
case LM95245_REG_R_LOCAL_TEMPH_S:
|
|
case LM95245_REG_R_LOCAL_TEMPL_S:
|
|
case LM95245_REG_R_REMOTE_TEMPH_S:
|
|
case LM95245_REG_R_REMOTE_TEMPL_S:
|
|
case LM95245_REG_R_REMOTE_TEMPH_U:
|
|
case LM95245_REG_R_REMOTE_TEMPL_U:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static const struct regmap_config lm95245_regmap_config = {
|
|
.reg_bits = 8,
|
|
.val_bits = 8,
|
|
.writeable_reg = lm95245_is_writeable_reg,
|
|
.volatile_reg = lm95245_is_volatile_reg,
|
|
.cache_type = REGCACHE_RBTREE,
|
|
.use_single_read = true,
|
|
.use_single_write = true,
|
|
};
|
|
|
|
static const struct hwmon_channel_info *lm95245_info[] = {
|
|
HWMON_CHANNEL_INFO(chip,
|
|
HWMON_C_UPDATE_INTERVAL),
|
|
HWMON_CHANNEL_INFO(temp,
|
|
HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_HYST |
|
|
HWMON_T_CRIT_ALARM,
|
|
HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST |
|
|
HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_FAULT |
|
|
HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM |
|
|
HWMON_T_TYPE | HWMON_T_OFFSET),
|
|
NULL
|
|
};
|
|
|
|
static const struct hwmon_ops lm95245_hwmon_ops = {
|
|
.is_visible = lm95245_is_visible,
|
|
.read = lm95245_read,
|
|
.write = lm95245_write,
|
|
};
|
|
|
|
static const struct hwmon_chip_info lm95245_chip_info = {
|
|
.ops = &lm95245_hwmon_ops,
|
|
.info = lm95245_info,
|
|
};
|
|
|
|
static int lm95245_probe(struct i2c_client *client,
|
|
const struct i2c_device_id *id)
|
|
{
|
|
struct device *dev = &client->dev;
|
|
struct lm95245_data *data;
|
|
struct device *hwmon_dev;
|
|
int ret;
|
|
|
|
data = devm_kzalloc(dev, sizeof(struct lm95245_data), GFP_KERNEL);
|
|
if (!data)
|
|
return -ENOMEM;
|
|
|
|
data->regmap = devm_regmap_init_i2c(client, &lm95245_regmap_config);
|
|
if (IS_ERR(data->regmap))
|
|
return PTR_ERR(data->regmap);
|
|
|
|
mutex_init(&data->update_lock);
|
|
|
|
/* Initialize the LM95245 chip */
|
|
ret = lm95245_init_client(data);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
|
|
data,
|
|
&lm95245_chip_info,
|
|
NULL);
|
|
return PTR_ERR_OR_ZERO(hwmon_dev);
|
|
}
|
|
|
|
/* Driver data (common to all clients) */
|
|
static const struct i2c_device_id lm95245_id[] = {
|
|
{ "lm95235", 0 },
|
|
{ "lm95245", 0 },
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(i2c, lm95245_id);
|
|
|
|
static const struct of_device_id __maybe_unused lm95245_of_match[] = {
|
|
{ .compatible = "national,lm95235" },
|
|
{ .compatible = "national,lm95245" },
|
|
{ },
|
|
};
|
|
MODULE_DEVICE_TABLE(of, lm95245_of_match);
|
|
|
|
static struct i2c_driver lm95245_driver = {
|
|
.class = I2C_CLASS_HWMON,
|
|
.driver = {
|
|
.name = "lm95245",
|
|
.of_match_table = of_match_ptr(lm95245_of_match),
|
|
},
|
|
.probe = lm95245_probe,
|
|
.id_table = lm95245_id,
|
|
.detect = lm95245_detect,
|
|
.address_list = normal_i2c,
|
|
};
|
|
|
|
module_i2c_driver(lm95245_driver);
|
|
|
|
MODULE_AUTHOR("Alexander Stein <alexander.stein@systec-electronic.com>");
|
|
MODULE_DESCRIPTION("LM95235/LM95245 sensor driver");
|
|
MODULE_LICENSE("GPL");
|