linux/drivers/hwmon/lm80.c
<<
>>
Prefs
   1/*
   2 * lm80.c - From lm_sensors, Linux kernel modules for hardware
   3 *          monitoring
   4 * Copyright (C) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
   5 *                           and Philip Edelbrock <phil@netroedge.com>
   6 *
   7 * Ported to Linux 2.6 by Tiago Sousa <mirage@kaotik.org>
   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
  34/* Addresses to scan */
  35static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
  36                                                0x2e, 0x2f, I2C_CLIENT_END };
  37
  38/* Many LM80 constants specified below */
  39
  40/* The LM80 registers */
  41#define LM80_REG_IN_MAX(nr)             (0x2a + (nr) * 2)
  42#define LM80_REG_IN_MIN(nr)             (0x2b + (nr) * 2)
  43#define LM80_REG_IN(nr)                 (0x20 + (nr))
  44
  45#define LM80_REG_FAN1                   0x28
  46#define LM80_REG_FAN2                   0x29
  47#define LM80_REG_FAN_MIN(nr)            (0x3b + (nr))
  48
  49#define LM80_REG_TEMP                   0x27
  50#define LM80_REG_TEMP_HOT_MAX           0x38
  51#define LM80_REG_TEMP_HOT_HYST          0x39
  52#define LM80_REG_TEMP_OS_MAX            0x3a
  53#define LM80_REG_TEMP_OS_HYST           0x3b
  54
  55#define LM80_REG_CONFIG                 0x00
  56#define LM80_REG_ALARM1                 0x01
  57#define LM80_REG_ALARM2                 0x02
  58#define LM80_REG_MASK1                  0x03
  59#define LM80_REG_MASK2                  0x04
  60#define LM80_REG_FANDIV                 0x05
  61#define LM80_REG_RES                    0x06
  62
  63#define LM96080_REG_CONV_RATE           0x07
  64#define LM96080_REG_MAN_ID              0x3e
  65#define LM96080_REG_DEV_ID              0x3f
  66
  67
  68/*
  69 * Conversions. Rounding and limit checking is only done on the TO_REG
  70 * variants. Note that you should be a bit careful with which arguments
  71 * these macros are called: arguments may be evaluated more than once.
  72 * Fixing this is just not worth it.
  73 */
  74
  75#define IN_TO_REG(val)          (SENSORS_LIMIT(((val) + 5) / 10, 0, 255))
  76#define IN_FROM_REG(val)        ((val) * 10)
  77
  78static inline unsigned char FAN_TO_REG(unsigned rpm, unsigned div)
  79{
  80        if (rpm == 0)
  81                return 255;
  82        rpm = SENSORS_LIMIT(rpm, 1, 1000000);
  83        return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
  84}
  85
  86#define FAN_FROM_REG(val, div)  ((val) == 0 ? -1 : \
  87                                (val) == 255 ? 0 : 1350000/((div) * (val)))
  88
  89static inline long TEMP_FROM_REG(u16 temp)
  90{
  91        long res;
  92
  93        temp >>= 4;
  94        if (temp < 0x0800)
  95                res = 625 * (long) temp;
  96        else
  97                res = ((long) temp - 0x01000) * 625;
  98
  99        return res / 10;
 100}
 101
 102#define TEMP_LIMIT_FROM_REG(val)        (((val) > 0x80 ? \
 103        (val) - 0x100 : (val)) * 1000)
 104
 105#define TEMP_LIMIT_TO_REG(val)          SENSORS_LIMIT((val) < 0 ? \
 106        ((val) - 500) / 1000 : ((val) + 500) / 1000, 0, 255)
 107
 108#define DIV_FROM_REG(val)               (1 << (val))
 109
 110/*
 111 * Client data (each client gets its own)
 112 */
 113
 114struct lm80_data {
 115        struct device *hwmon_dev;
 116        struct mutex update_lock;
 117        char error;             /* !=0 if error occurred during last update */
 118        char valid;             /* !=0 if following fields are valid */
 119        unsigned long last_updated;     /* In jiffies */
 120
 121        u8 in[7];               /* Register value */
 122        u8 in_max[7];           /* Register value */
 123        u8 in_min[7];           /* Register value */
 124        u8 fan[2];              /* Register value */
 125        u8 fan_min[2];          /* Register value */
 126        u8 fan_div[2];          /* Register encoding, shifted right */
 127        u16 temp;               /* Register values, shifted right */
 128        u8 temp_hot_max;        /* Register value */
 129        u8 temp_hot_hyst;       /* Register value */
 130        u8 temp_os_max;         /* Register value */
 131        u8 temp_os_hyst;        /* Register value */
 132        u16 alarms;             /* Register encoding, combined */
 133};
 134
 135/*
 136 * Functions declaration
 137 */
 138
 139static int lm80_probe(struct i2c_client *client,
 140                      const struct i2c_device_id *id);
 141static int lm80_detect(struct i2c_client *client, struct i2c_board_info *info);
 142static void lm80_init_client(struct i2c_client *client);
 143static int lm80_remove(struct i2c_client *client);
 144static struct lm80_data *lm80_update_device(struct device *dev);
 145static int lm80_read_value(struct i2c_client *client, u8 reg);
 146static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value);
 147
 148/*
 149 * Driver data (common to all clients)
 150 */
 151
 152static const struct i2c_device_id lm80_id[] = {
 153        { "lm80", 0 },
 154        { "lm96080", 1 },
 155        { }
 156};
 157MODULE_DEVICE_TABLE(i2c, lm80_id);
 158
 159static struct i2c_driver lm80_driver = {
 160        .class          = I2C_CLASS_HWMON,
 161        .driver = {
 162                .name   = "lm80",
 163        },
 164        .probe          = lm80_probe,
 165        .remove         = lm80_remove,
 166        .id_table       = lm80_id,
 167        .detect         = lm80_detect,
 168        .address_list   = normal_i2c,
 169};
 170
 171/*
 172 * Sysfs stuff
 173 */
 174
 175#define show_in(suffix, value) \
 176static ssize_t show_in_##suffix(struct device *dev, \
 177        struct device_attribute *attr, char *buf) \
 178{ \
 179        int nr = to_sensor_dev_attr(attr)->index; \
 180        struct lm80_data *data = lm80_update_device(dev); \
 181        if (IS_ERR(data)) \
 182                return PTR_ERR(data); \
 183        return sprintf(buf, "%d\n", IN_FROM_REG(data->value[nr])); \
 184}
 185show_in(min, in_min)
 186show_in(max, in_max)
 187show_in(input, in)
 188
 189#define set_in(suffix, value, reg) \
 190static ssize_t set_in_##suffix(struct device *dev, \
 191        struct device_attribute *attr, const char *buf, size_t count) \
 192{ \
 193        int nr = to_sensor_dev_attr(attr)->index; \
 194        struct i2c_client *client = to_i2c_client(dev); \
 195        struct lm80_data *data = i2c_get_clientdata(client); \
 196        long val; \
 197        int err = kstrtol(buf, 10, &val); \
 198        if (err < 0) \
 199                return err; \
 200\
 201        mutex_lock(&data->update_lock);\
 202        data->value[nr] = IN_TO_REG(val); \
 203        lm80_write_value(client, reg(nr), data->value[nr]); \
 204        mutex_unlock(&data->update_lock);\
 205        return count; \
 206}
 207set_in(min, in_min, LM80_REG_IN_MIN)
 208set_in(max, in_max, LM80_REG_IN_MAX)
 209
 210#define show_fan(suffix, value) \
 211static ssize_t show_fan_##suffix(struct device *dev, \
 212        struct device_attribute *attr, char *buf) \
 213{ \
 214        int nr = to_sensor_dev_attr(attr)->index; \
 215        struct lm80_data *data = lm80_update_device(dev); \
 216        if (IS_ERR(data)) \
 217                return PTR_ERR(data); \
 218        return sprintf(buf, "%d\n", FAN_FROM_REG(data->value[nr], \
 219                       DIV_FROM_REG(data->fan_div[nr]))); \
 220}
 221show_fan(min, fan_min)
 222show_fan(input, fan)
 223
 224static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
 225        char *buf)
 226{
 227        int nr = to_sensor_dev_attr(attr)->index;
 228        struct lm80_data *data = lm80_update_device(dev);
 229        if (IS_ERR(data))
 230                return PTR_ERR(data);
 231        return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
 232}
 233
 234static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
 235        const char *buf, size_t count)
 236{
 237        int nr = to_sensor_dev_attr(attr)->index;
 238        struct i2c_client *client = to_i2c_client(dev);
 239        struct lm80_data *data = i2c_get_clientdata(client);
 240        unsigned long val;
 241        int err = kstrtoul(buf, 10, &val);
 242        if (err < 0)
 243                return err;
 244
 245        mutex_lock(&data->update_lock);
 246        data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 247        lm80_write_value(client, LM80_REG_FAN_MIN(nr + 1), data->fan_min[nr]);
 248        mutex_unlock(&data->update_lock);
 249        return count;
 250}
 251
 252/*
 253 * Note: we save and restore the fan minimum here, because its value is
 254 * determined in part by the fan divisor.  This follows the principle of
 255 * least surprise; the user doesn't expect the fan minimum to change just
 256 * because the divisor changed.
 257 */
 258static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
 259        const char *buf, size_t count)
 260{
 261        int nr = to_sensor_dev_attr(attr)->index;
 262        struct i2c_client *client = to_i2c_client(dev);
 263        struct lm80_data *data = i2c_get_clientdata(client);
 264        unsigned long min, val;
 265        u8 reg;
 266        int err = kstrtoul(buf, 10, &val);
 267        if (err < 0)
 268                return err;
 269
 270        /* Save fan_min */
 271        mutex_lock(&data->update_lock);
 272        min = FAN_FROM_REG(data->fan_min[nr],
 273                           DIV_FROM_REG(data->fan_div[nr]));
 274
 275        switch (val) {
 276        case 1:
 277                data->fan_div[nr] = 0;
 278                break;
 279        case 2:
 280                data->fan_div[nr] = 1;
 281                break;
 282        case 4:
 283                data->fan_div[nr] = 2;
 284                break;
 285        case 8:
 286                data->fan_div[nr] = 3;
 287                break;
 288        default:
 289                dev_err(&client->dev, "fan_div value %ld not "
 290                        "supported. Choose one of 1, 2, 4 or 8!\n", val);
 291                mutex_unlock(&data->update_lock);
 292                return -EINVAL;
 293        }
 294
 295        reg = (lm80_read_value(client, LM80_REG_FANDIV) & ~(3 << (2 * (nr + 1))))
 296            | (data->fan_div[nr] << (2 * (nr + 1)));
 297        lm80_write_value(client, LM80_REG_FANDIV, reg);
 298
 299        /* Restore fan_min */
 300        data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 301        lm80_write_value(client, LM80_REG_FAN_MIN(nr + 1), data->fan_min[nr]);
 302        mutex_unlock(&data->update_lock);
 303
 304        return count;
 305}
 306
 307static ssize_t show_temp_input1(struct device *dev,
 308        struct device_attribute *attr, char *buf)
 309{
 310        struct lm80_data *data = lm80_update_device(dev);
 311        if (IS_ERR(data))
 312                return PTR_ERR(data);
 313        return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp));
 314}
 315
 316#define show_temp(suffix, value) \
 317static ssize_t show_temp_##suffix(struct device *dev, \
 318        struct device_attribute *attr, char *buf) \
 319{ \
 320        struct lm80_data *data = lm80_update_device(dev); \
 321        if (IS_ERR(data)) \
 322                return PTR_ERR(data); \
 323        return sprintf(buf, "%d\n", TEMP_LIMIT_FROM_REG(data->value)); \
 324}
 325show_temp(hot_max, temp_hot_max);
 326show_temp(hot_hyst, temp_hot_hyst);
 327show_temp(os_max, temp_os_max);
 328show_temp(os_hyst, temp_os_hyst);
 329
 330#define set_temp(suffix, value, reg) \
 331static ssize_t set_temp_##suffix(struct device *dev, \
 332        struct device_attribute *attr, const char *buf, size_t count) \
 333{ \
 334        struct i2c_client *client = to_i2c_client(dev); \
 335        struct lm80_data *data = i2c_get_clientdata(client); \
 336        long val; \
 337        int err = kstrtol(buf, 10, &val); \
 338        if (err < 0) \
 339                return err; \
 340\
 341        mutex_lock(&data->update_lock); \
 342        data->value = TEMP_LIMIT_TO_REG(val); \
 343        lm80_write_value(client, reg, data->value); \
 344        mutex_unlock(&data->update_lock); \
 345        return count; \
 346}
 347set_temp(hot_max, temp_hot_max, LM80_REG_TEMP_HOT_MAX);
 348set_temp(hot_hyst, temp_hot_hyst, LM80_REG_TEMP_HOT_HYST);
 349set_temp(os_max, temp_os_max, LM80_REG_TEMP_OS_MAX);
 350set_temp(os_hyst, temp_os_hyst, LM80_REG_TEMP_OS_HYST);
 351
 352static ssize_t show_alarms(struct device *dev, struct device_attribute *attr,
 353                           char *buf)
 354{
 355        struct lm80_data *data = lm80_update_device(dev);
 356        if (IS_ERR(data))
 357                return PTR_ERR(data);
 358        return sprintf(buf, "%u\n", data->alarms);
 359}
 360
 361static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
 362                          char *buf)
 363{
 364        int bitnr = to_sensor_dev_attr(attr)->index;
 365        struct lm80_data *data = lm80_update_device(dev);
 366        if (IS_ERR(data))
 367                return PTR_ERR(data);
 368        return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
 369}
 370
 371static SENSOR_DEVICE_ATTR(in0_min, S_IWUSR | S_IRUGO,
 372                show_in_min, set_in_min, 0);
 373static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO,
 374                show_in_min, set_in_min, 1);
 375static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO,
 376                show_in_min, set_in_min, 2);
 377static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO,
 378                show_in_min, set_in_min, 3);
 379static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO,
 380                show_in_min, set_in_min, 4);
 381static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO,
 382                show_in_min, set_in_min, 5);
 383static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO,
 384                show_in_min, set_in_min, 6);
 385static SENSOR_DEVICE_ATTR(in0_max, S_IWUSR | S_IRUGO,
 386                show_in_max, set_in_max, 0);
 387static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO,
 388                show_in_max, set_in_max, 1);
 389static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO,
 390                show_in_max, set_in_max, 2);
 391static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO,
 392                show_in_max, set_in_max, 3);
 393static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO,
 394                show_in_max, set_in_max, 4);
 395static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO,
 396                show_in_max, set_in_max, 5);
 397static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO,
 398                show_in_max, set_in_max, 6);
 399static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in_input, NULL, 0);
 400static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in_input, NULL, 1);
 401static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in_input, NULL, 2);
 402static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in_input, NULL, 3);
 403static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in_input, NULL, 4);
 404static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_in_input, NULL, 5);
 405static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_in_input, NULL, 6);
 406static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO,
 407                show_fan_min, set_fan_min, 0);
 408static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO,
 409                show_fan_min, set_fan_min, 1);
 410static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0);
 411static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1);
 412static SENSOR_DEVICE_ATTR(fan1_div, S_IWUSR | S_IRUGO,
 413                show_fan_div, set_fan_div, 0);
 414static SENSOR_DEVICE_ATTR(fan2_div, S_IWUSR | S_IRUGO,
 415                show_fan_div, set_fan_div, 1);
 416static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input1, NULL);
 417static DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_hot_max,
 418        set_temp_hot_max);
 419static DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, show_temp_hot_hyst,
 420        set_temp_hot_hyst);
 421static DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp_os_max,
 422        set_temp_os_max);
 423static DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temp_os_hyst,
 424        set_temp_os_hyst);
 425static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 426static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
 427static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
 428static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
 429static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
 430static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 4);
 431static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 5);
 432static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 6);
 433static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 10);
 434static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 11);
 435static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 8);
 436static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 13);
 437
 438/*
 439 * Real code
 440 */
 441
 442static struct attribute *lm80_attributes[] = {
 443        &sensor_dev_attr_in0_min.dev_attr.attr,
 444        &sensor_dev_attr_in1_min.dev_attr.attr,
 445        &sensor_dev_attr_in2_min.dev_attr.attr,
 446        &sensor_dev_attr_in3_min.dev_attr.attr,
 447        &sensor_dev_attr_in4_min.dev_attr.attr,
 448        &sensor_dev_attr_in5_min.dev_attr.attr,
 449        &sensor_dev_attr_in6_min.dev_attr.attr,
 450        &sensor_dev_attr_in0_max.dev_attr.attr,
 451        &sensor_dev_attr_in1_max.dev_attr.attr,
 452        &sensor_dev_attr_in2_max.dev_attr.attr,
 453        &sensor_dev_attr_in3_max.dev_attr.attr,
 454        &sensor_dev_attr_in4_max.dev_attr.attr,
 455        &sensor_dev_attr_in5_max.dev_attr.attr,
 456        &sensor_dev_attr_in6_max.dev_attr.attr,
 457        &sensor_dev_attr_in0_input.dev_attr.attr,
 458        &sensor_dev_attr_in1_input.dev_attr.attr,
 459        &sensor_dev_attr_in2_input.dev_attr.attr,
 460        &sensor_dev_attr_in3_input.dev_attr.attr,
 461        &sensor_dev_attr_in4_input.dev_attr.attr,
 462        &sensor_dev_attr_in5_input.dev_attr.attr,
 463        &sensor_dev_attr_in6_input.dev_attr.attr,
 464        &sensor_dev_attr_fan1_min.dev_attr.attr,
 465        &sensor_dev_attr_fan2_min.dev_attr.attr,
 466        &sensor_dev_attr_fan1_input.dev_attr.attr,
 467        &sensor_dev_attr_fan2_input.dev_attr.attr,
 468        &sensor_dev_attr_fan1_div.dev_attr.attr,
 469        &sensor_dev_attr_fan2_div.dev_attr.attr,
 470        &dev_attr_temp1_input.attr,
 471        &dev_attr_temp1_max.attr,
 472        &dev_attr_temp1_max_hyst.attr,
 473        &dev_attr_temp1_crit.attr,
 474        &dev_attr_temp1_crit_hyst.attr,
 475        &dev_attr_alarms.attr,
 476        &sensor_dev_attr_in0_alarm.dev_attr.attr,
 477        &sensor_dev_attr_in1_alarm.dev_attr.attr,
 478        &sensor_dev_attr_in2_alarm.dev_attr.attr,
 479        &sensor_dev_attr_in3_alarm.dev_attr.attr,
 480        &sensor_dev_attr_in4_alarm.dev_attr.attr,
 481        &sensor_dev_attr_in5_alarm.dev_attr.attr,
 482        &sensor_dev_attr_in6_alarm.dev_attr.attr,
 483        &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 484        &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 485        &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 486        &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
 487        NULL
 488};
 489
 490static const struct attribute_group lm80_group = {
 491        .attrs = lm80_attributes,
 492};
 493
 494/* Return 0 if detection is successful, -ENODEV otherwise */
 495static int lm80_detect(struct i2c_client *client, struct i2c_board_info *info)
 496{
 497        struct i2c_adapter *adapter = client->adapter;
 498        int i, cur, man_id, dev_id;
 499        const char *name = NULL;
 500
 501        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 502                return -ENODEV;
 503
 504        /* First check for unused bits, common to both chip types */
 505        if ((lm80_read_value(client, LM80_REG_ALARM2) & 0xc0)
 506         || (lm80_read_value(client, LM80_REG_CONFIG) & 0x80))
 507                return -ENODEV;
 508
 509        /*
 510         * The LM96080 has manufacturer and stepping/die rev registers so we
 511         * can just check that. The LM80 does not have such registers so we
 512         * have to use a more expensive trick.
 513         */
 514        man_id = lm80_read_value(client, LM96080_REG_MAN_ID);
 515        dev_id = lm80_read_value(client, LM96080_REG_DEV_ID);
 516        if (man_id == 0x01 && dev_id == 0x08) {
 517                /* Check more unused bits for confirmation */
 518                if (lm80_read_value(client, LM96080_REG_CONV_RATE) & 0xfe)
 519                        return -ENODEV;
 520
 521                name = "lm96080";
 522        } else {
 523                /* Check 6-bit addressing */
 524                for (i = 0x2a; i <= 0x3d; i++) {
 525                        cur = i2c_smbus_read_byte_data(client, i);
 526                        if ((i2c_smbus_read_byte_data(client, i + 0x40) != cur)
 527                         || (i2c_smbus_read_byte_data(client, i + 0x80) != cur)
 528                         || (i2c_smbus_read_byte_data(client, i + 0xc0) != cur))
 529                                return -ENODEV;
 530                }
 531
 532                name = "lm80";
 533        }
 534
 535        strlcpy(info->type, name, I2C_NAME_SIZE);
 536
 537        return 0;
 538}
 539
 540static int lm80_probe(struct i2c_client *client,
 541                      const struct i2c_device_id *id)
 542{
 543        struct lm80_data *data;
 544        int err;
 545
 546        data = devm_kzalloc(&client->dev, sizeof(struct lm80_data), GFP_KERNEL);
 547        if (!data)
 548                return -ENOMEM;
 549
 550        i2c_set_clientdata(client, data);
 551        mutex_init(&data->update_lock);
 552
 553        /* Initialize the LM80 chip */
 554        lm80_init_client(client);
 555
 556        /* A few vars need to be filled upon startup */
 557        data->fan_min[0] = lm80_read_value(client, LM80_REG_FAN_MIN(1));
 558        data->fan_min[1] = lm80_read_value(client, LM80_REG_FAN_MIN(2));
 559
 560        /* Register sysfs hooks */
 561        err = sysfs_create_group(&client->dev.kobj, &lm80_group);
 562        if (err)
 563                return err;
 564
 565        data->hwmon_dev = hwmon_device_register(&client->dev);
 566        if (IS_ERR(data->hwmon_dev)) {
 567                err = PTR_ERR(data->hwmon_dev);
 568                goto error_remove;
 569        }
 570
 571        return 0;
 572
 573error_remove:
 574        sysfs_remove_group(&client->dev.kobj, &lm80_group);
 575        return err;
 576}
 577
 578static int lm80_remove(struct i2c_client *client)
 579{
 580        struct lm80_data *data = i2c_get_clientdata(client);
 581
 582        hwmon_device_unregister(data->hwmon_dev);
 583        sysfs_remove_group(&client->dev.kobj, &lm80_group);
 584
 585        return 0;
 586}
 587
 588static int lm80_read_value(struct i2c_client *client, u8 reg)
 589{
 590        return i2c_smbus_read_byte_data(client, reg);
 591}
 592
 593static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value)
 594{
 595        return i2c_smbus_write_byte_data(client, reg, value);
 596}
 597
 598/* Called when we have found a new LM80. */
 599static void lm80_init_client(struct i2c_client *client)
 600{
 601        /*
 602         * Reset all except Watchdog values and last conversion values
 603         * This sets fan-divs to 2, among others. This makes most other
 604         * initializations unnecessary
 605         */
 606        lm80_write_value(client, LM80_REG_CONFIG, 0x80);
 607        /* Set 11-bit temperature resolution */
 608        lm80_write_value(client, LM80_REG_RES, 0x08);
 609
 610        /* Start monitoring */
 611        lm80_write_value(client, LM80_REG_CONFIG, 0x01);
 612}
 613
 614static struct lm80_data *lm80_update_device(struct device *dev)
 615{
 616        struct i2c_client *client = to_i2c_client(dev);
 617        struct lm80_data *data = i2c_get_clientdata(client);
 618        int i;
 619        int rv;
 620        int prev_rv;
 621        struct lm80_data *ret = data;
 622
 623        mutex_lock(&data->update_lock);
 624
 625        if (data->error)
 626                lm80_init_client(client);
 627
 628        if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
 629                dev_dbg(&client->dev, "Starting lm80 update\n");
 630                for (i = 0; i <= 6; i++) {
 631                        rv = lm80_read_value(client, LM80_REG_IN(i));
 632                        if (rv < 0)
 633                                goto abort;
 634                        data->in[i] = rv;
 635
 636                        rv = lm80_read_value(client, LM80_REG_IN_MIN(i));
 637                        if (rv < 0)
 638                                goto abort;
 639                        data->in_min[i] = rv;
 640
 641                        rv = lm80_read_value(client, LM80_REG_IN_MAX(i));
 642                        if (rv < 0)
 643                                goto abort;
 644                        data->in_max[i] = rv;
 645                }
 646
 647                rv = lm80_read_value(client, LM80_REG_FAN1);
 648                if (rv < 0)
 649                        goto abort;
 650                data->fan[0] = rv;
 651
 652                rv = lm80_read_value(client, LM80_REG_FAN_MIN(1));
 653                if (rv < 0)
 654                        goto abort;
 655                data->fan_min[0] = rv;
 656
 657                rv = lm80_read_value(client, LM80_REG_FAN2);
 658                if (rv < 0)
 659                        goto abort;
 660                data->fan[1] = rv;
 661
 662                rv = lm80_read_value(client, LM80_REG_FAN_MIN(2));
 663                if (rv < 0)
 664                        goto abort;
 665                data->fan_min[1] = rv;
 666
 667                prev_rv = rv = lm80_read_value(client, LM80_REG_TEMP);
 668                if (rv < 0)
 669                        goto abort;
 670                rv = lm80_read_value(client, LM80_REG_RES);
 671                if (rv < 0)
 672                        goto abort;
 673                data->temp = (prev_rv << 8) | (rv & 0xf0);
 674
 675                rv = lm80_read_value(client, LM80_REG_TEMP_OS_MAX);
 676                if (rv < 0)
 677                        goto abort;
 678                data->temp_os_max = rv;
 679
 680                rv = lm80_read_value(client, LM80_REG_TEMP_OS_HYST);
 681                if (rv < 0)
 682                        goto abort;
 683                data->temp_os_hyst = rv;
 684
 685                rv = lm80_read_value(client, LM80_REG_TEMP_HOT_MAX);
 686                if (rv < 0)
 687                        goto abort;
 688                data->temp_hot_max = rv;
 689
 690                rv = lm80_read_value(client, LM80_REG_TEMP_HOT_HYST);
 691                if (rv < 0)
 692                        goto abort;
 693                data->temp_hot_hyst = rv;
 694
 695                rv = lm80_read_value(client, LM80_REG_FANDIV);
 696                if (rv < 0)
 697                        goto abort;
 698                data->fan_div[0] = (rv >> 2) & 0x03;
 699                data->fan_div[1] = (rv >> 4) & 0x03;
 700
 701                prev_rv = rv = lm80_read_value(client, LM80_REG_ALARM1);
 702                if (rv < 0)
 703                        goto abort;
 704                rv = lm80_read_value(client, LM80_REG_ALARM2);
 705                if (rv < 0)
 706                        goto abort;
 707                data->alarms = prev_rv + (rv << 8);
 708
 709                data->last_updated = jiffies;
 710                data->valid = 1;
 711                data->error = 0;
 712        }
 713        goto done;
 714
 715abort:
 716        ret = ERR_PTR(rv);
 717        data->valid = 0;
 718        data->error = 1;
 719
 720done:
 721        mutex_unlock(&data->update_lock);
 722
 723        return ret;
 724}
 725
 726module_i2c_driver(lm80_driver);
 727
 728MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
 729        "Philip Edelbrock <phil@netroedge.com>");
 730MODULE_DESCRIPTION("LM80 driver");
 731MODULE_LICENSE("GPL");
 732
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.