drivers/hwmon/lm73.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
temp_store
temp_show
convrate_store
convrate_show
maxmin_alarm_show
lm73_probe
lm73_detect
   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * LM73 Sensor driver
   4  * Based on LM75
   5  *
   6  * Copyright (C) 2007, CenoSYS (www.cenosys.com).
   7  * Copyright (C) 2009, Bollore telecom (www.bolloretelecom.eu).
   8  *
   9  * Guillaume Ligneul <guillaume.ligneul@gmail.com>
  10  * Adrien Demarez <adrien.demarez@bolloretelecom.eu>
  11  * Jeremy Laine <jeremy.laine@bolloretelecom.eu>
  12  * Chris Verges <kg4ysn@gmail.com>
  13  */
  14 
  15 #include <linux/module.h>
  16 #include <linux/init.h>
  17 #include <linux/i2c.h>
  18 #include <linux/hwmon.h>
  19 #include <linux/hwmon-sysfs.h>
  20 #include <linux/err.h>
  21 
  22 
  23 /* Addresses scanned */
  24 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4c,
  25                                         0x4d, 0x4e, I2C_CLIENT_END };
  26 
  27 /* LM73 registers */
  28 #define LM73_REG_INPUT          0x00
  29 #define LM73_REG_CONF           0x01
  30 #define LM73_REG_MAX            0x02
  31 #define LM73_REG_MIN            0x03
  32 #define LM73_REG_CTRL           0x04
  33 #define LM73_REG_ID             0x07
  34 
  35 #define LM73_ID                 0x9001  /* 0x0190, byte-swapped */
  36 #define DRVNAME                 "lm73"
  37 #define LM73_TEMP_MIN           (-256000 / 250)
  38 #define LM73_TEMP_MAX           (255750 / 250)
  39 
  40 #define LM73_CTRL_RES_SHIFT     5
  41 #define LM73_CTRL_RES_MASK      (BIT(5) | BIT(6))
  42 #define LM73_CTRL_TO_MASK       BIT(7)
  43 
  44 #define LM73_CTRL_HI_SHIFT      2
  45 #define LM73_CTRL_LO_SHIFT      1
  46 
  47 static const unsigned short lm73_convrates[] = {
  48         14,     /* 11-bits (0.25000 C/LSB): RES1 Bit = 0, RES0 Bit = 0 */
  49         28,     /* 12-bits (0.12500 C/LSB): RES1 Bit = 0, RES0 Bit = 1 */
  50         56,     /* 13-bits (0.06250 C/LSB): RES1 Bit = 1, RES0 Bit = 0 */
  51         112,    /* 14-bits (0.03125 C/LSB): RES1 Bit = 1, RES0 Bit = 1 */
  52 };
  53 
  54 struct lm73_data {
  55         struct i2c_client *client;
  56         struct mutex lock;
  57         u8 ctrl;                        /* control register value */
  58 };
  59 
  60 /*-----------------------------------------------------------------------*/
  61 
  62 static ssize_t temp_store(struct device *dev, struct device_attribute *da,
  63                           const char *buf, size_t count)
  64 {
  65         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
  66         struct lm73_data *data = dev_get_drvdata(dev);
  67         long temp;
  68         short value;
  69         s32 err;
  70 
  71         int status = kstrtol(buf, 10, &temp);
  72         if (status < 0)
  73                 return status;
  74 
  75         /* Write value */
  76         value = clamp_val(temp / 250, LM73_TEMP_MIN, LM73_TEMP_MAX) << 5;
  77         err = i2c_smbus_write_word_swapped(data->client, attr->index, value);
  78         return (err < 0) ? err : count;
  79 }
  80 
  81 static ssize_t temp_show(struct device *dev, struct device_attribute *da,
  82                          char *buf)
  83 {
  84         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
  85         struct lm73_data *data = dev_get_drvdata(dev);
  86         int temp;
  87 
  88         s32 err = i2c_smbus_read_word_swapped(data->client, attr->index);
  89         if (err < 0)
  90                 return err;
  91 
  92         /* use integer division instead of equivalent right shift to
  93            guarantee arithmetic shift and preserve the sign */
  94         temp = (((s16) err) * 250) / 32;
  95         return scnprintf(buf, PAGE_SIZE, "%d\n", temp);
  96 }
  97 
  98 static ssize_t convrate_store(struct device *dev, struct device_attribute *da,
  99                               const char *buf, size_t count)
 100 {
 101         struct lm73_data *data = dev_get_drvdata(dev);
 102         unsigned long convrate;
 103         s32 err;
 104         int res = 0;
 105 
 106         err = kstrtoul(buf, 10, &convrate);
 107         if (err < 0)
 108                 return err;
 109 
 110         /*
 111          * Convert the desired conversion rate into register bits.
 112          * res is already initialized, and everything past the second-to-last
 113          * value in the array is treated as belonging to the last value
 114          * in the array.
 115          */
 116         while (res < (ARRAY_SIZE(lm73_convrates) - 1) &&
 117                         convrate > lm73_convrates[res])
 118                 res++;
 119 
 120         mutex_lock(&data->lock);
 121         data->ctrl &= LM73_CTRL_TO_MASK;
 122         data->ctrl |= res << LM73_CTRL_RES_SHIFT;
 123         err = i2c_smbus_write_byte_data(data->client, LM73_REG_CTRL,
 124                                         data->ctrl);
 125         mutex_unlock(&data->lock);
 126 
 127         if (err < 0)
 128                 return err;
 129 
 130         return count;
 131 }
 132 
 133 static ssize_t convrate_show(struct device *dev, struct device_attribute *da,
 134                              char *buf)
 135 {
 136         struct lm73_data *data = dev_get_drvdata(dev);
 137         int res;
 138 
 139         res = (data->ctrl & LM73_CTRL_RES_MASK) >> LM73_CTRL_RES_SHIFT;
 140         return scnprintf(buf, PAGE_SIZE, "%hu\n", lm73_convrates[res]);
 141 }
 142 
 143 static ssize_t maxmin_alarm_show(struct device *dev,
 144                                  struct device_attribute *da, char *buf)
 145 {
 146         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 147         struct lm73_data *data = dev_get_drvdata(dev);
 148         s32 ctrl;
 149 
 150         mutex_lock(&data->lock);
 151         ctrl = i2c_smbus_read_byte_data(data->client, LM73_REG_CTRL);
 152         if (ctrl < 0)
 153                 goto abort;
 154         data->ctrl = ctrl;
 155         mutex_unlock(&data->lock);
 156 
 157         return scnprintf(buf, PAGE_SIZE, "%d\n", (ctrl >> attr->index) & 1);
 158 
 159 abort:
 160         mutex_unlock(&data->lock);
 161         return ctrl;
 162 }
 163 
 164 /*-----------------------------------------------------------------------*/
 165 
 166 /* sysfs attributes for hwmon */
 167 
 168 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp, LM73_REG_MAX);
 169 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp, LM73_REG_MIN);
 170 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, LM73_REG_INPUT);
 171 static SENSOR_DEVICE_ATTR_RW(update_interval, convrate, 0);
 172 static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, maxmin_alarm,
 173                              LM73_CTRL_HI_SHIFT);
 174 static SENSOR_DEVICE_ATTR_RO(temp1_min_alarm, maxmin_alarm,
 175                              LM73_CTRL_LO_SHIFT);
 176 
 177 static struct attribute *lm73_attrs[] = {
 178         &sensor_dev_attr_temp1_input.dev_attr.attr,
 179         &sensor_dev_attr_temp1_max.dev_attr.attr,
 180         &sensor_dev_attr_temp1_min.dev_attr.attr,
 181         &sensor_dev_attr_update_interval.dev_attr.attr,
 182         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 183         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 184         NULL
 185 };
 186 ATTRIBUTE_GROUPS(lm73);
 187 
 188 /*-----------------------------------------------------------------------*/
 189 
 190 /* device probe and removal */
 191 
 192 static int
 193 lm73_probe(struct i2c_client *client, const struct i2c_device_id *id)
 194 {
 195         struct device *dev = &client->dev;
 196         struct device *hwmon_dev;
 197         struct lm73_data *data;
 198         int ctrl;
 199 
 200         data = devm_kzalloc(dev, sizeof(struct lm73_data), GFP_KERNEL);
 201         if (!data)
 202                 return -ENOMEM;
 203 
 204         data->client = client;
 205         mutex_init(&data->lock);
 206 
 207         ctrl = i2c_smbus_read_byte_data(client, LM73_REG_CTRL);
 208         if (ctrl < 0)
 209                 return ctrl;
 210         data->ctrl = ctrl;
 211 
 212         hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
 213                                                            data, lm73_groups);
 214         if (IS_ERR(hwmon_dev))
 215                 return PTR_ERR(hwmon_dev);
 216 
 217         dev_info(dev, "sensor '%s'\n", client->name);
 218 
 219         return 0;
 220 }
 221 
 222 static const struct i2c_device_id lm73_ids[] = {
 223         { "lm73", 0 },
 224         { /* LIST END */ }
 225 };
 226 MODULE_DEVICE_TABLE(i2c, lm73_ids);
 227 
 228 /* Return 0 if detection is successful, -ENODEV otherwise */
 229 static int lm73_detect(struct i2c_client *new_client,
 230                         struct i2c_board_info *info)
 231 {
 232         struct i2c_adapter *adapter = new_client->adapter;
 233         int id, ctrl, conf;
 234 
 235         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
 236                                         I2C_FUNC_SMBUS_WORD_DATA))
 237                 return -ENODEV;
 238 
 239         /*
 240          * Do as much detection as possible with byte reads first, as word
 241          * reads can confuse other devices.
 242          */
 243         ctrl = i2c_smbus_read_byte_data(new_client, LM73_REG_CTRL);
 244         if (ctrl < 0 || (ctrl & 0x10))
 245                 return -ENODEV;
 246 
 247         conf = i2c_smbus_read_byte_data(new_client, LM73_REG_CONF);
 248         if (conf < 0 || (conf & 0x0c))
 249                 return -ENODEV;
 250 
 251         id = i2c_smbus_read_byte_data(new_client, LM73_REG_ID);
 252         if (id < 0 || id != (LM73_ID & 0xff))
 253                 return -ENODEV;
 254 
 255         /* Check device ID */
 256         id = i2c_smbus_read_word_data(new_client, LM73_REG_ID);
 257         if (id < 0 || id != LM73_ID)
 258                 return -ENODEV;
 259 
 260         strlcpy(info->type, "lm73", I2C_NAME_SIZE);
 261 
 262         return 0;
 263 }
 264 
 265 static struct i2c_driver lm73_driver = {
 266         .class          = I2C_CLASS_HWMON,
 267         .driver = {
 268                 .name   = "lm73",
 269         },
 270         .probe          = lm73_probe,
 271         .id_table       = lm73_ids,
 272         .detect         = lm73_detect,
 273         .address_list   = normal_i2c,
 274 };
 275 
 276 module_i2c_driver(lm73_driver);
 277 
 278 MODULE_AUTHOR("Guillaume Ligneul <guillaume.ligneul@gmail.com>");
 279 MODULE_DESCRIPTION("LM73 driver");
 280 MODULE_LICENSE("GPL");
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/hwmon/lm73.c

DEFINITIONS
