drivers/hwmon/lm95241.c

   1 /*
   2  * Copyright (C) 2008, 2010 Davide Rizzo <elpa.rizzo@gmail.com>
   3  *
   4  * The LM95241 is a sensor chip made by National Semiconductors.
   5  * It reports up to three temperatures (its own plus up to two external ones).
   6  * Complete datasheet can be obtained from National's website at:
   7  *   http://www.national.com/ds.cgi/LM/LM95241.pdf
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include <linux/module.h>
  25 #include <linux/init.h>
  26 #include <linux/slab.h>
  27 #include <linux/jiffies.h>
  28 #include <linux/i2c.h>
  29 #include <linux/hwmon.h>
  30 #include <linux/hwmon-sysfs.h>
  31 #include <linux/err.h>
  32 #include <linux/mutex.h>
  33 #include <linux/sysfs.h>
  34
  35 #define DEVNAME "lm95241"
  36
  37 static const unsigned short normal_i2c[] = {
  38         0x19, 0x2a, 0x2b, I2C_CLIENT_END };
  39
  40 /* LM95241 registers */
  41 #define LM95241_REG_R_MAN_ID            0xFE
  42 #define LM95241_REG_R_CHIP_ID           0xFF
  43 #define LM95241_REG_R_STATUS            0x02
  44 #define LM95241_REG_RW_CONFIG           0x03
  45 #define LM95241_REG_RW_REM_FILTER       0x06
  46 #define LM95241_REG_RW_TRUTHERM         0x07
  47 #define LM95241_REG_W_ONE_SHOT          0x0F
  48 #define LM95241_REG_R_LOCAL_TEMPH       0x10
  49 #define LM95241_REG_R_REMOTE1_TEMPH     0x11
  50 #define LM95241_REG_R_REMOTE2_TEMPH     0x12
  51 #define LM95241_REG_R_LOCAL_TEMPL       0x20
  52 #define LM95241_REG_R_REMOTE1_TEMPL     0x21
  53 #define LM95241_REG_R_REMOTE2_TEMPL     0x22
  54 #define LM95241_REG_RW_REMOTE_MODEL     0x30
  55
  56 /* LM95241 specific bitfields */
  57 #define CFG_STOP 0x40
  58 #define CFG_CR0076 0x00
  59 #define CFG_CR0182 0x10
  60 #define CFG_CR1000 0x20
  61 #define CFG_CR2700 0x30
  62 #define R1MS_SHIFT 0
  63 #define R2MS_SHIFT 2
  64 #define R1MS_MASK (0x01 << (R1MS_SHIFT))
  65 #define R2MS_MASK (0x01 << (R2MS_SHIFT))
  66 #define R1DF_SHIFT 1
  67 #define R2DF_SHIFT 2
  68 #define R1DF_MASK (0x01 << (R1DF_SHIFT))
  69 #define R2DF_MASK (0x01 << (R2DF_SHIFT))
  70 #define R1FE_MASK 0x01
  71 #define R2FE_MASK 0x05
  72 #define TT1_SHIFT 0
  73 #define TT2_SHIFT 4
  74 #define TT_OFF 0
  75 #define TT_ON 1
  76 #define TT_MASK 7
  77 #define NATSEMI_MAN_ID  0x01
  78 #define LM95231_CHIP_ID 0xA1
  79 #define LM95241_CHIP_ID 0xA4
  80
  81 static const u8 lm95241_reg_address[] = {
  82         LM95241_REG_R_LOCAL_TEMPH,
  83         LM95241_REG_R_LOCAL_TEMPL,
  84         LM95241_REG_R_REMOTE1_TEMPH,
  85         LM95241_REG_R_REMOTE1_TEMPL,
  86         LM95241_REG_R_REMOTE2_TEMPH,
  87         LM95241_REG_R_REMOTE2_TEMPL
  88 };
  89
  90 /* Client data (each client gets its own) */
  91 struct lm95241_data {
  92         struct i2c_client *client;
  93         struct mutex update_lock;
  94         unsigned long last_updated, interval;   /* in jiffies */
  95         char valid;             /* zero until following fields are valid */
  96         /* registers values */
  97         u8 temp[ARRAY_SIZE(lm95241_reg_address)];
  98         u8 config, model, trutherm;
  99 };
 100
 101 /* Conversions */
 102 static int temp_from_reg_signed(u8 val_h, u8 val_l)
 103 {
 104         s16 val_hl = (val_h << 8) | val_l;
 105         return val_hl * 1000 / 256;
 106 }
 107
 108 static int temp_from_reg_unsigned(u8 val_h, u8 val_l)
 109 {
 110         u16 val_hl = (val_h << 8) | val_l;
 111         return val_hl * 1000 / 256;
 112 }
 113
 114 static struct lm95241_data *lm95241_update_device(struct device *dev)
 115 {
 116         struct lm95241_data *data = dev_get_drvdata(dev);
 117         struct i2c_client *client = data->client;
 118
 119         mutex_lock(&data->update_lock);
 120
 121         if (time_after(jiffies, data->last_updated + data->interval) ||
 122             !data->valid) {
 123                 int i;
 124
 125                 dev_dbg(dev, "Updating lm95241 data.\n");
 126                 for (i = 0; i < ARRAY_SIZE(lm95241_reg_address); i++)
 127                         data->temp[i]
 128                           = i2c_smbus_read_byte_data(client,
 129                                                      lm95241_reg_address[i]);
 130                 data->last_updated = jiffies;
 131                 data->valid = 1;
 132         }
 133
 134         mutex_unlock(&data->update_lock);
 135
 136         return data;
 137 }
 138
 139 /* Sysfs stuff */
 140 static ssize_t show_input(struct device *dev, struct device_attribute *attr,
 141                           char *buf)
 142 {
 143         struct lm95241_data *data = lm95241_update_device(dev);
 144         int index = to_sensor_dev_attr(attr)->index;
 145
 146         return snprintf(buf, PAGE_SIZE - 1, "%d\n",
 147                         index == 0 || (data->config & (1 << (index / 2))) ?
 148                 temp_from_reg_signed(data->temp[index], data->temp[index + 1]) :
 149                 temp_from_reg_unsigned(data->temp[index],
 150                                        data->temp[index + 1]));
 151 }
 152
 153 static ssize_t show_type(struct device *dev, struct device_attribute *attr,
 154                          char *buf)
 155 {
 156         struct lm95241_data *data = dev_get_drvdata(dev);
 157
 158         return snprintf(buf, PAGE_SIZE - 1,
 159                 data->model & to_sensor_dev_attr(attr)->index ? "1\n" : "2\n");
 160 }
 161
 162 static ssize_t set_type(struct device *dev, struct device_attribute *attr,
 163                         const char *buf, size_t count)
 164 {
 165         struct lm95241_data *data = dev_get_drvdata(dev);
 166         struct i2c_client *client = data->client;
 167         unsigned long val;
 168         int shift;
 169         u8 mask = to_sensor_dev_attr(attr)->index;
 170
 171         if (kstrtoul(buf, 10, &val) < 0)
 172                 return -EINVAL;
 173         if (val != 1 && val != 2)
 174                 return -EINVAL;
 175
 176         shift = mask == R1MS_MASK ? TT1_SHIFT : TT2_SHIFT;
 177
 178         mutex_lock(&data->update_lock);
 179
 180         data->trutherm &= ~(TT_MASK << shift);
 181         if (val == 1) {
 182                 data->model |= mask;
 183                 data->trutherm |= (TT_ON << shift);
 184         } else {
 185                 data->model &= ~mask;
 186                 data->trutherm |= (TT_OFF << shift);
 187         }
 188         data->valid = 0;
 189
 190         i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL,
 191                                   data->model);
 192         i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM,
 193                                   data->trutherm);
 194
 195         mutex_unlock(&data->update_lock);
 196
 197         return count;
 198 }
 199
 200 static ssize_t show_min(struct device *dev, struct device_attribute *attr,
 201                         char *buf)
 202 {
 203         struct lm95241_data *data = dev_get_drvdata(dev);
 204
 205         return snprintf(buf, PAGE_SIZE - 1,
 206                         data->config & to_sensor_dev_attr(attr)->index ?
 207                         "-127000\n" : "0\n");
 208 }
 209
 210 static ssize_t set_min(struct device *dev, struct device_attribute *attr,
 211                        const char *buf, size_t count)
 212 {
 213         struct lm95241_data *data = dev_get_drvdata(dev);
 214         long val;
 215
 216         if (kstrtol(buf, 10, &val) < 0)
 217                 return -EINVAL;
 218         if (val < -128000)
 219                 return -EINVAL;
 220
 221         mutex_lock(&data->update_lock);
 222
 223         if (val < 0)
 224                 data->config |= to_sensor_dev_attr(attr)->index;
 225         else
 226                 data->config &= ~to_sensor_dev_attr(attr)->index;
 227         data->valid = 0;
 228
 229         i2c_smbus_write_byte_data(data->client, LM95241_REG_RW_CONFIG,
 230                                   data->config);
 231
 232         mutex_unlock(&data->update_lock);
 233
 234         return count;
 235 }
 236
 237 static ssize_t show_max(struct device *dev, struct device_attribute *attr,
 238                         char *buf)
 239 {
 240         struct lm95241_data *data = dev_get_drvdata(dev);
 241
 242         return snprintf(buf, PAGE_SIZE - 1,
 243                         data->config & to_sensor_dev_attr(attr)->index ?
 244                         "127000\n" : "255000\n");
 245 }
 246
 247 static ssize_t set_max(struct device *dev, struct device_attribute *attr,
 248                        const char *buf, size_t count)
 249 {
 250         struct lm95241_data *data = dev_get_drvdata(dev);
 251         long val;
 252
 253         if (kstrtol(buf, 10, &val) < 0)
 254                 return -EINVAL;
 255         if (val >= 256000)
 256                 return -EINVAL;
 257
 258         mutex_lock(&data->update_lock);
 259
 260         if (val <= 127000)
 261                 data->config |= to_sensor_dev_attr(attr)->index;
 262         else
 263                 data->config &= ~to_sensor_dev_attr(attr)->index;
 264         data->valid = 0;
 265
 266         i2c_smbus_write_byte_data(data->client, LM95241_REG_RW_CONFIG,
 267                                   data->config);
 268
 269         mutex_unlock(&data->update_lock);
 270
 271         return count;
 272 }
 273
 274 static ssize_t show_interval(struct device *dev, struct device_attribute *attr,
 275                              char *buf)
 276 {
 277         struct lm95241_data *data = lm95241_update_device(dev);
 278
 279         return snprintf(buf, PAGE_SIZE - 1, "%lu\n", 1000 * data->interval
 280                         / HZ);
 281 }
 282
 283 static ssize_t set_interval(struct device *dev, struct device_attribute *attr,
 284                             const char *buf, size_t count)
 285 {
 286         struct lm95241_data *data = dev_get_drvdata(dev);
 287         unsigned long val;
 288
 289         if (kstrtoul(buf, 10, &val) < 0)
 290                 return -EINVAL;
 291
 292         data->interval = val * HZ / 1000;
 293
 294         return count;
 295 }
 296
 297 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_input, NULL, 0);
 298 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_input, NULL, 2);
 299 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_input, NULL, 4);
 300 static SENSOR_DEVICE_ATTR(temp2_type, S_IWUSR | S_IRUGO, show_type, set_type,
 301                           R1MS_MASK);
 302 static SENSOR_DEVICE_ATTR(temp3_type, S_IWUSR | S_IRUGO, show_type, set_type,
 303                           R2MS_MASK);
 304 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_min, set_min,
 305                           R1DF_MASK);
 306 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_min, set_min,
 307                           R2DF_MASK);
 308 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_max, set_max,
 309                           R1DF_MASK);
 310 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_max, set_max,
 311                           R2DF_MASK);
 312 static DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO, show_interval,
 313                    set_interval);
 314
 315 static struct attribute *lm95241_attrs[] = {
 316         &sensor_dev_attr_temp1_input.dev_attr.attr,
 317         &sensor_dev_attr_temp2_input.dev_attr.attr,
 318         &sensor_dev_attr_temp3_input.dev_attr.attr,
 319         &sensor_dev_attr_temp2_type.dev_attr.attr,
 320         &sensor_dev_attr_temp3_type.dev_attr.attr,
 321         &sensor_dev_attr_temp2_min.dev_attr.attr,
 322         &sensor_dev_attr_temp3_min.dev_attr.attr,
 323         &sensor_dev_attr_temp2_max.dev_attr.attr,
 324         &sensor_dev_attr_temp3_max.dev_attr.attr,
 325         &dev_attr_update_interval.attr,
 326         NULL
 327 };
 328 ATTRIBUTE_GROUPS(lm95241);
 329
 330 /* Return 0 if detection is successful, -ENODEV otherwise */
 331 static int lm95241_detect(struct i2c_client *new_client,
 332                           struct i2c_board_info *info)
 333 {
 334         struct i2c_adapter *adapter = new_client->adapter;
 335         const char *name;
 336         int mfg_id, chip_id;
 337
 338         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 339                 return -ENODEV;
 340
 341         mfg_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID);
 342         if (mfg_id != NATSEMI_MAN_ID)
 343                 return -ENODEV;
 344
 345         chip_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID);
 346         switch (chip_id) {
 347         case LM95231_CHIP_ID:
 348                 name = "lm95231";
 349                 break;
 350         case LM95241_CHIP_ID:
 351                 name = "lm95241";
 352                 break;
 353         default:
 354                 return -ENODEV;
 355         }
 356
 357         /* Fill the i2c board info */
 358         strlcpy(info->type, name, I2C_NAME_SIZE);
 359         return 0;
 360 }
 361
 362 static void lm95241_init_client(struct i2c_client *client,
 363                                 struct lm95241_data *data)
 364 {
 365         data->interval = HZ;    /* 1 sec default */
 366         data->config = CFG_CR0076;
 367         data->trutherm = (TT_OFF << TT1_SHIFT) | (TT_OFF << TT2_SHIFT);
 368
 369         i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config);
 370         i2c_smbus_write_byte_data(client, LM95241_REG_RW_REM_FILTER,
 371                                   R1FE_MASK | R2FE_MASK);
 372         i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM,
 373                                   data->trutherm);
 374         i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL,
 375                                   data->model);
 376 }
 377
 378 static int lm95241_probe(struct i2c_client *client,
 379                          const struct i2c_device_id *id)
 380 {
 381         struct device *dev = &client->dev;
 382         struct lm95241_data *data;
 383         struct device *hwmon_dev;
 384
 385         data = devm_kzalloc(dev, sizeof(struct lm95241_data), GFP_KERNEL);
 386         if (!data)
 387                 return -ENOMEM;
 388
 389         data->client = client;
 390         mutex_init(&data->update_lock);
 391
 392         /* Initialize the LM95241 chip */
 393         lm95241_init_client(client, data);
 394
 395         hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
 396                                                            data,
 397                                                            lm95241_groups);
 398         return PTR_ERR_OR_ZERO(hwmon_dev);
 399 }
 400
 401 /* Driver data (common to all clients) */
 402 static const struct i2c_device_id lm95241_id[] = {
 403         { "lm95231", 0 },
 404         { "lm95241", 0 },
 405         { }
 406 };
 407 MODULE_DEVICE_TABLE(i2c, lm95241_id);
 408
 409 static struct i2c_driver lm95241_driver = {
 410         .class          = I2C_CLASS_HWMON,
 411         .driver = {
 412                 .name   = DEVNAME,
 413         },
 414         .probe          = lm95241_probe,
 415         .id_table       = lm95241_id,
 416         .detect         = lm95241_detect,
 417         .address_list   = normal_i2c,
 418 };
 419
 420 module_i2c_driver(lm95241_driver);
 421
 422 MODULE_AUTHOR("Davide Rizzo <elpa.rizzo@gmail.com>");
 423 MODULE_DESCRIPTION("LM95241 sensor driver");
 424 MODULE_LICENSE("GPL");