drivers/hwmon/smsc47m192.c

   1 /*
   2  * smsc47m192.c - Support for hardware monitoring block of
   3  *                SMSC LPC47M192 and compatible Super I/O chips
   4  *
   5  * Copyright (C) 2006  Hartmut Rick <linux@rick.claranet.de>
   6  *
   7  * Derived from lm78.c and other chip drivers.
   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/hwmon-vid.h>
  32 #include <linux/err.h>
  33 #include <linux/sysfs.h>
  34 #include <linux/mutex.h>
  35
  36 /* Addresses to scan */
  37 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END };
  38
  39 /* SMSC47M192 registers */
  40 #define SMSC47M192_REG_IN(nr)           ((nr) < 6 ? (0x20 + (nr)) : \
  41                                         (0x50 + (nr) - 6))
  42 #define SMSC47M192_REG_IN_MAX(nr)       ((nr) < 6 ? (0x2b + (nr) * 2) : \
  43                                         (0x54 + (((nr) - 6) * 2)))
  44 #define SMSC47M192_REG_IN_MIN(nr)       ((nr) < 6 ? (0x2c + (nr) * 2) : \
  45                                         (0x55 + (((nr) - 6) * 2)))
  46 static u8 SMSC47M192_REG_TEMP[3] =      { 0x27, 0x26, 0x52 };
  47 static u8 SMSC47M192_REG_TEMP_MAX[3] =  { 0x39, 0x37, 0x58 };
  48 static u8 SMSC47M192_REG_TEMP_MIN[3] =  { 0x3A, 0x38, 0x59 };
  49 #define SMSC47M192_REG_TEMP_OFFSET(nr)  ((nr) == 2 ? 0x1e : 0x1f)
  50 #define SMSC47M192_REG_ALARM1           0x41
  51 #define SMSC47M192_REG_ALARM2           0x42
  52 #define SMSC47M192_REG_VID              0x47
  53 #define SMSC47M192_REG_VID4             0x49
  54 #define SMSC47M192_REG_CONFIG           0x40
  55 #define SMSC47M192_REG_SFR              0x4f
  56 #define SMSC47M192_REG_COMPANY_ID       0x3e
  57 #define SMSC47M192_REG_VERSION          0x3f
  58
  59 /* generalised scaling with integer rounding */
  60 static inline int SCALE(long val, int mul, int div)
  61 {
  62         if (val < 0)
  63                 return (val * mul - div / 2) / div;
  64         else
  65                 return (val * mul + div / 2) / div;
  66 }
  67
  68 /* Conversions */
  69
  70 /* smsc47m192 internally scales voltage measurements */
  71 static const u16 nom_mv[] = { 2500, 2250, 3300, 5000, 12000, 3300, 1500, 1800 };
  72
  73 static inline unsigned int IN_FROM_REG(u8 reg, int n)
  74 {
  75         return SCALE(reg, nom_mv[n], 192);
  76 }
  77
  78 static inline u8 IN_TO_REG(unsigned long val, int n)
  79 {
  80         return clamp_val(SCALE(val, 192, nom_mv[n]), 0, 255);
  81 }
  82
  83 /*
  84  * TEMP: 0.001 degC units (-128C to +127C)
  85  * REG: 1C/bit, two's complement
  86  */
  87 static inline s8 TEMP_TO_REG(int val)
  88 {
  89         return SCALE(clamp_val(val, -128000, 127000), 1, 1000);
  90 }
  91
  92 static inline int TEMP_FROM_REG(s8 val)
  93 {
  94         return val * 1000;
  95 }
  96
  97 struct smsc47m192_data {
  98         struct device *hwmon_dev;
  99         struct mutex update_lock;
 100         char valid;             /* !=0 if following fields are valid */
 101         unsigned long last_updated;     /* In jiffies */
 102
 103         u8 in[8];               /* Register value */
 104         u8 in_max[8];           /* Register value */
 105         u8 in_min[8];           /* Register value */
 106         s8 temp[3];             /* Register value */
 107         s8 temp_max[3];         /* Register value */
 108         s8 temp_min[3];         /* Register value */
 109         s8 temp_offset[3];      /* Register value */
 110         u16 alarms;             /* Register encoding, combined */
 111         u8 vid;                 /* Register encoding, combined */
 112         u8 vrm;
 113 };
 114
 115 static struct smsc47m192_data *smsc47m192_update_device(struct device *dev)
 116 {
 117         struct i2c_client *client = to_i2c_client(dev);
 118         struct smsc47m192_data *data = i2c_get_clientdata(client);
 119         int i, config;
 120
 121         mutex_lock(&data->update_lock);
 122
 123         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 124          || !data->valid) {
 125                 u8 sfr = i2c_smbus_read_byte_data(client, SMSC47M192_REG_SFR);
 126
 127                 dev_dbg(&client->dev, "Starting smsc47m192 update\n");
 128
 129                 for (i = 0; i <= 7; i++) {
 130                         data->in[i] = i2c_smbus_read_byte_data(client,
 131                                                 SMSC47M192_REG_IN(i));
 132                         data->in_min[i] = i2c_smbus_read_byte_data(client,
 133                                                 SMSC47M192_REG_IN_MIN(i));
 134                         data->in_max[i] = i2c_smbus_read_byte_data(client,
 135                                                 SMSC47M192_REG_IN_MAX(i));
 136                 }
 137                 for (i = 0; i < 3; i++) {
 138                         data->temp[i] = i2c_smbus_read_byte_data(client,
 139                                                 SMSC47M192_REG_TEMP[i]);
 140                         data->temp_max[i] = i2c_smbus_read_byte_data(client,
 141                                                 SMSC47M192_REG_TEMP_MAX[i]);
 142                         data->temp_min[i] = i2c_smbus_read_byte_data(client,
 143                                                 SMSC47M192_REG_TEMP_MIN[i]);
 144                 }
 145                 for (i = 1; i < 3; i++)
 146                         data->temp_offset[i] = i2c_smbus_read_byte_data(client,
 147                                                 SMSC47M192_REG_TEMP_OFFSET(i));
 148                 /*
 149                  * first offset is temp_offset[0] if SFR bit 4 is set,
 150                  * temp_offset[1] otherwise
 151                  */
 152                 if (sfr & 0x10) {
 153                         data->temp_offset[0] = data->temp_offset[1];
 154                         data->temp_offset[1] = 0;
 155                 } else
 156                         data->temp_offset[0] = 0;
 157
 158                 data->vid = i2c_smbus_read_byte_data(client, SMSC47M192_REG_VID)
 159                             & 0x0f;
 160                 config = i2c_smbus_read_byte_data(client,
 161                                                   SMSC47M192_REG_CONFIG);
 162                 if (config & 0x20)
 163                         data->vid |= (i2c_smbus_read_byte_data(client,
 164                                         SMSC47M192_REG_VID4) & 0x01) << 4;
 165                 data->alarms = i2c_smbus_read_byte_data(client,
 166                                                 SMSC47M192_REG_ALARM1) |
 167                                (i2c_smbus_read_byte_data(client,
 168                                                 SMSC47M192_REG_ALARM2) << 8);
 169
 170                 data->last_updated = jiffies;
 171                 data->valid = 1;
 172         }
 173
 174         mutex_unlock(&data->update_lock);
 175
 176         return data;
 177 }
 178
 179 /* Voltages */
 180 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
 181                 char *buf)
 182 {
 183         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 184         int nr = sensor_attr->index;
 185         struct smsc47m192_data *data = smsc47m192_update_device(dev);
 186         return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr], nr));
 187 }
 188
 189 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
 190                 char *buf)
 191 {
 192         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 193         int nr = sensor_attr->index;
 194         struct smsc47m192_data *data = smsc47m192_update_device(dev);
 195         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr], nr));
 196 }
 197
 198 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
 199                 char *buf)
 200 {
 201         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 202         int nr = sensor_attr->index;
 203         struct smsc47m192_data *data = smsc47m192_update_device(dev);
 204         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr], nr));
 205 }
 206
 207 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
 208                 const char *buf, size_t count)
 209 {
 210         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 211         int nr = sensor_attr->index;
 212         struct i2c_client *client = to_i2c_client(dev);
 213         struct smsc47m192_data *data = i2c_get_clientdata(client);
 214         unsigned long val;
 215         int err;
 216
 217         err = kstrtoul(buf, 10, &val);
 218         if (err)
 219                 return err;
 220
 221         mutex_lock(&data->update_lock);
 222         data->in_min[nr] = IN_TO_REG(val, nr);
 223         i2c_smbus_write_byte_data(client, SMSC47M192_REG_IN_MIN(nr),
 224                                                         data->in_min[nr]);
 225         mutex_unlock(&data->update_lock);
 226         return count;
 227 }
 228
 229 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
 230                 const char *buf, size_t count)
 231 {
 232         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 233         int nr = sensor_attr->index;
 234         struct i2c_client *client = to_i2c_client(dev);
 235         struct smsc47m192_data *data = i2c_get_clientdata(client);
 236         unsigned long val;
 237         int err;
 238
 239         err = kstrtoul(buf, 10, &val);
 240         if (err)
 241                 return err;
 242
 243         mutex_lock(&data->update_lock);
 244         data->in_max[nr] = IN_TO_REG(val, nr);
 245         i2c_smbus_write_byte_data(client, SMSC47M192_REG_IN_MAX(nr),
 246                                                         data->in_max[nr]);
 247         mutex_unlock(&data->update_lock);
 248         return count;
 249 }
 250
 251 #define show_in_offset(offset)                                  \
 252 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,          \
 253                 show_in, NULL, offset);                         \
 254 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,  \
 255                 show_in_min, set_in_min, offset);               \
 256 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,  \
 257                 show_in_max, set_in_max, offset);
 258
 259 show_in_offset(0)
 260 show_in_offset(1)
 261 show_in_offset(2)
 262 show_in_offset(3)
 263 show_in_offset(4)
 264 show_in_offset(5)
 265 show_in_offset(6)
 266 show_in_offset(7)
 267
 268 /* Temperatures */
 269 static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
 270                 char *buf)
 271 {
 272         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 273         int nr = sensor_attr->index;
 274         struct smsc47m192_data *data = smsc47m192_update_device(dev);
 275         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
 276 }
 277
 278 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
 279                 char *buf)
 280 {
 281         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 282         int nr = sensor_attr->index;
 283         struct smsc47m192_data *data = smsc47m192_update_device(dev);
 284         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
 285 }
 286
 287 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
 288                 char *buf)
 289 {
 290         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 291         int nr = sensor_attr->index;
 292         struct smsc47m192_data *data = smsc47m192_update_device(dev);
 293         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
 294 }
 295
 296 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
 297                 const char *buf, size_t count)
 298 {
 299         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 300         int nr = sensor_attr->index;
 301         struct i2c_client *client = to_i2c_client(dev);
 302         struct smsc47m192_data *data = i2c_get_clientdata(client);
 303         long val;
 304         int err;
 305
 306         err = kstrtol(buf, 10, &val);
 307         if (err)
 308                 return err;
 309
 310         mutex_lock(&data->update_lock);
 311         data->temp_min[nr] = TEMP_TO_REG(val);
 312         i2c_smbus_write_byte_data(client, SMSC47M192_REG_TEMP_MIN[nr],
 313                                                 data->temp_min[nr]);
 314         mutex_unlock(&data->update_lock);
 315         return count;
 316 }
 317
 318 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
 319                 const char *buf, size_t count)
 320 {
 321         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 322         int nr = sensor_attr->index;
 323         struct i2c_client *client = to_i2c_client(dev);
 324         struct smsc47m192_data *data = i2c_get_clientdata(client);
 325         long val;
 326         int err;
 327
 328         err = kstrtol(buf, 10, &val);
 329         if (err)
 330                 return err;
 331
 332         mutex_lock(&data->update_lock);
 333         data->temp_max[nr] = TEMP_TO_REG(val);
 334         i2c_smbus_write_byte_data(client, SMSC47M192_REG_TEMP_MAX[nr],
 335                                                 data->temp_max[nr]);
 336         mutex_unlock(&data->update_lock);
 337         return count;
 338 }
 339
 340 static ssize_t show_temp_offset(struct device *dev, struct device_attribute
 341                 *attr, char *buf)
 342 {
 343         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 344         int nr = sensor_attr->index;
 345         struct smsc47m192_data *data = smsc47m192_update_device(dev);
 346         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_offset[nr]));
 347 }
 348
 349 static ssize_t set_temp_offset(struct device *dev, struct device_attribute
 350                 *attr, const char *buf, size_t count)
 351 {
 352         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 353         int nr = sensor_attr->index;
 354         struct i2c_client *client = to_i2c_client(dev);
 355         struct smsc47m192_data *data = i2c_get_clientdata(client);
 356         u8 sfr = i2c_smbus_read_byte_data(client, SMSC47M192_REG_SFR);
 357         long val;
 358         int err;
 359
 360         err = kstrtol(buf, 10, &val);
 361         if (err)
 362                 return err;
 363
 364         mutex_lock(&data->update_lock);
 365         data->temp_offset[nr] = TEMP_TO_REG(val);
 366         if (nr > 1)
 367                 i2c_smbus_write_byte_data(client,
 368                         SMSC47M192_REG_TEMP_OFFSET(nr), data->temp_offset[nr]);
 369         else if (data->temp_offset[nr] != 0) {
 370                 /*
 371                  * offset[0] and offset[1] share the same register,
 372                  * SFR bit 4 activates offset[0]
 373                  */
 374                 i2c_smbus_write_byte_data(client, SMSC47M192_REG_SFR,
 375                                         (sfr & 0xef) | (nr == 0 ? 0x10 : 0));
 376                 data->temp_offset[1-nr] = 0;
 377                 i2c_smbus_write_byte_data(client,
 378                         SMSC47M192_REG_TEMP_OFFSET(nr), data->temp_offset[nr]);
 379         } else if ((sfr & 0x10) == (nr == 0 ? 0x10 : 0))
 380                 i2c_smbus_write_byte_data(client,
 381                                         SMSC47M192_REG_TEMP_OFFSET(nr), 0);
 382         mutex_unlock(&data->update_lock);
 383         return count;
 384 }
 385
 386 #define show_temp_index(index)                                          \
 387 static SENSOR_DEVICE_ATTR(temp##index##_input, S_IRUGO,                 \
 388                 show_temp, NULL, index-1);                              \
 389 static SENSOR_DEVICE_ATTR(temp##index##_min, S_IRUGO | S_IWUSR,         \
 390                 show_temp_min, set_temp_min, index-1);                  \
 391 static SENSOR_DEVICE_ATTR(temp##index##_max, S_IRUGO | S_IWUSR,         \
 392                 show_temp_max, set_temp_max, index-1);                  \
 393 static SENSOR_DEVICE_ATTR(temp##index##_offset, S_IRUGO | S_IWUSR,      \
 394                 show_temp_offset, set_temp_offset, index-1);
 395
 396 show_temp_index(1)
 397 show_temp_index(2)
 398 show_temp_index(3)
 399
 400 /* VID */
 401 static ssize_t show_vid(struct device *dev, struct device_attribute *attr,
 402                 char *buf)
 403 {
 404         struct smsc47m192_data *data = smsc47m192_update_device(dev);
 405         return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
 406 }
 407 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
 408
 409 static ssize_t show_vrm(struct device *dev, struct device_attribute *attr,
 410                 char *buf)
 411 {
 412         struct smsc47m192_data *data = dev_get_drvdata(dev);
 413         return sprintf(buf, "%d\n", data->vrm);
 414 }
 415
 416 static ssize_t set_vrm(struct device *dev, struct device_attribute *attr,
 417                 const char *buf, size_t count)
 418 {
 419         struct smsc47m192_data *data = dev_get_drvdata(dev);
 420         unsigned long val;
 421         int err;
 422
 423         err = kstrtoul(buf, 10, &val);
 424         if (err)
 425                 return err;
 426         if (val > 255)
 427                 return -EINVAL;
 428
 429         data->vrm = val;
 430         return count;
 431 }
 432 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm, set_vrm);
 433
 434 /* Alarms */
 435 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
 436                 char *buf)
 437 {
 438         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 439         int nr = sensor_attr->index;
 440         struct smsc47m192_data *data = smsc47m192_update_device(dev);
 441         return sprintf(buf, "%u\n", (data->alarms & nr) ? 1 : 0);
 442 }
 443
 444 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 0x0010);
 445 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 0x0020);
 446 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 0x0040);
 447 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 0x4000);
 448 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 0x8000);
 449 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0x0001);
 450 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 0x0002);
 451 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 0x0004);
 452 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 0x0008);
 453 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 0x0100);
 454 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 0x0200);
 455 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 0x0400);
 456 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 0x0800);
 457
 458 static struct attribute *smsc47m192_attributes[] = {
 459         &sensor_dev_attr_in0_input.dev_attr.attr,
 460         &sensor_dev_attr_in0_min.dev_attr.attr,
 461         &sensor_dev_attr_in0_max.dev_attr.attr,
 462         &sensor_dev_attr_in0_alarm.dev_attr.attr,
 463         &sensor_dev_attr_in1_input.dev_attr.attr,
 464         &sensor_dev_attr_in1_min.dev_attr.attr,
 465         &sensor_dev_attr_in1_max.dev_attr.attr,
 466         &sensor_dev_attr_in1_alarm.dev_attr.attr,
 467         &sensor_dev_attr_in2_input.dev_attr.attr,
 468         &sensor_dev_attr_in2_min.dev_attr.attr,
 469         &sensor_dev_attr_in2_max.dev_attr.attr,
 470         &sensor_dev_attr_in2_alarm.dev_attr.attr,
 471         &sensor_dev_attr_in3_input.dev_attr.attr,
 472         &sensor_dev_attr_in3_min.dev_attr.attr,
 473         &sensor_dev_attr_in3_max.dev_attr.attr,
 474         &sensor_dev_attr_in3_alarm.dev_attr.attr,
 475         &sensor_dev_attr_in5_input.dev_attr.attr,
 476         &sensor_dev_attr_in5_min.dev_attr.attr,
 477         &sensor_dev_attr_in5_max.dev_attr.attr,
 478         &sensor_dev_attr_in5_alarm.dev_attr.attr,
 479         &sensor_dev_attr_in6_input.dev_attr.attr,
 480         &sensor_dev_attr_in6_min.dev_attr.attr,
 481         &sensor_dev_attr_in6_max.dev_attr.attr,
 482         &sensor_dev_attr_in6_alarm.dev_attr.attr,
 483         &sensor_dev_attr_in7_input.dev_attr.attr,
 484         &sensor_dev_attr_in7_min.dev_attr.attr,
 485         &sensor_dev_attr_in7_max.dev_attr.attr,
 486         &sensor_dev_attr_in7_alarm.dev_attr.attr,
 487
 488         &sensor_dev_attr_temp1_input.dev_attr.attr,
 489         &sensor_dev_attr_temp1_max.dev_attr.attr,
 490         &sensor_dev_attr_temp1_min.dev_attr.attr,
 491         &sensor_dev_attr_temp1_offset.dev_attr.attr,
 492         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
 493         &sensor_dev_attr_temp2_input.dev_attr.attr,
 494         &sensor_dev_attr_temp2_max.dev_attr.attr,
 495         &sensor_dev_attr_temp2_min.dev_attr.attr,
 496         &sensor_dev_attr_temp2_offset.dev_attr.attr,
 497         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
 498         &sensor_dev_attr_temp2_fault.dev_attr.attr,
 499         &sensor_dev_attr_temp3_input.dev_attr.attr,
 500         &sensor_dev_attr_temp3_max.dev_attr.attr,
 501         &sensor_dev_attr_temp3_min.dev_attr.attr,
 502         &sensor_dev_attr_temp3_offset.dev_attr.attr,
 503         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
 504         &sensor_dev_attr_temp3_fault.dev_attr.attr,
 505
 506         &dev_attr_cpu0_vid.attr,
 507         &dev_attr_vrm.attr,
 508         NULL
 509 };
 510
 511 static const struct attribute_group smsc47m192_group = {
 512         .attrs = smsc47m192_attributes,
 513 };
 514
 515 static struct attribute *smsc47m192_attributes_in4[] = {
 516         &sensor_dev_attr_in4_input.dev_attr.attr,
 517         &sensor_dev_attr_in4_min.dev_attr.attr,
 518         &sensor_dev_attr_in4_max.dev_attr.attr,
 519         &sensor_dev_attr_in4_alarm.dev_attr.attr,
 520         NULL
 521 };
 522
 523 static const struct attribute_group smsc47m192_group_in4 = {
 524         .attrs = smsc47m192_attributes_in4,
 525 };
 526
 527 static void smsc47m192_init_client(struct i2c_client *client)
 528 {
 529         int i;
 530         u8 config = i2c_smbus_read_byte_data(client, SMSC47M192_REG_CONFIG);
 531         u8 sfr = i2c_smbus_read_byte_data(client, SMSC47M192_REG_SFR);
 532
 533         /* select cycle mode (pause 1 sec between updates) */
 534         i2c_smbus_write_byte_data(client, SMSC47M192_REG_SFR,
 535                                                 (sfr & 0xfd) | 0x02);
 536         if (!(config & 0x01)) {
 537                 /* initialize alarm limits */
 538                 for (i = 0; i < 8; i++) {
 539                         i2c_smbus_write_byte_data(client,
 540                                 SMSC47M192_REG_IN_MIN(i), 0);
 541                         i2c_smbus_write_byte_data(client,
 542                                 SMSC47M192_REG_IN_MAX(i), 0xff);
 543                 }
 544                 for (i = 0; i < 3; i++) {
 545                         i2c_smbus_write_byte_data(client,
 546                                 SMSC47M192_REG_TEMP_MIN[i], 0x80);
 547                         i2c_smbus_write_byte_data(client,
 548                                 SMSC47M192_REG_TEMP_MAX[i], 0x7f);
 549                 }
 550
 551                 /* start monitoring */
 552                 i2c_smbus_write_byte_data(client, SMSC47M192_REG_CONFIG,
 553                                                 (config & 0xf7) | 0x01);
 554         }
 555 }
 556
 557 /* Return 0 if detection is successful, -ENODEV otherwise */
 558 static int smsc47m192_detect(struct i2c_client *client,
 559                              struct i2c_board_info *info)
 560 {
 561         struct i2c_adapter *adapter = client->adapter;
 562         int version;
 563
 564         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 565                 return -ENODEV;
 566
 567         /* Detection criteria from sensors_detect script */
 568         version = i2c_smbus_read_byte_data(client, SMSC47M192_REG_VERSION);
 569         if (i2c_smbus_read_byte_data(client,
 570                                 SMSC47M192_REG_COMPANY_ID) == 0x55
 571          && (version & 0xf0) == 0x20
 572          && (i2c_smbus_read_byte_data(client,
 573                                 SMSC47M192_REG_VID) & 0x70) == 0x00
 574          && (i2c_smbus_read_byte_data(client,
 575                                 SMSC47M192_REG_VID4) & 0xfe) == 0x80) {
 576                 dev_info(&adapter->dev,
 577                          "found SMSC47M192 or compatible, "
 578                          "version 2, stepping A%d\n", version & 0x0f);
 579         } else {
 580                 dev_dbg(&adapter->dev,
 581                         "SMSC47M192 detection failed at 0x%02x\n",
 582                         client->addr);
 583                 return -ENODEV;
 584         }
 585
 586         strlcpy(info->type, "smsc47m192", I2C_NAME_SIZE);
 587
 588         return 0;
 589 }
 590
 591 static int smsc47m192_probe(struct i2c_client *client,
 592                             const struct i2c_device_id *id)
 593 {
 594         struct smsc47m192_data *data;
 595         int config;
 596         int err;
 597
 598         data = devm_kzalloc(&client->dev, sizeof(struct smsc47m192_data),
 599                             GFP_KERNEL);
 600         if (!data)
 601                 return -ENOMEM;
 602
 603         i2c_set_clientdata(client, data);
 604         data->vrm = vid_which_vrm();
 605         mutex_init(&data->update_lock);
 606
 607         /* Initialize the SMSC47M192 chip */
 608         smsc47m192_init_client(client);
 609
 610         /* Register sysfs hooks */
 611         err = sysfs_create_group(&client->dev.kobj, &smsc47m192_group);
 612         if (err)
 613                 return err;
 614
 615         /* Pin 110 is either in4 (+12V) or VID4 */
 616         config = i2c_smbus_read_byte_data(client, SMSC47M192_REG_CONFIG);
 617         if (!(config & 0x20)) {
 618                 err = sysfs_create_group(&client->dev.kobj,
 619                                          &smsc47m192_group_in4);
 620                 if (err)
 621                         goto exit_remove_files;
 622         }
 623
 624         data->hwmon_dev = hwmon_device_register(&client->dev);
 625         if (IS_ERR(data->hwmon_dev)) {
 626                 err = PTR_ERR(data->hwmon_dev);
 627                 goto exit_remove_files;
 628         }
 629
 630         return 0;
 631
 632 exit_remove_files:
 633         sysfs_remove_group(&client->dev.kobj, &smsc47m192_group);
 634         sysfs_remove_group(&client->dev.kobj, &smsc47m192_group_in4);
 635         return err;
 636 }
 637
 638 static int smsc47m192_remove(struct i2c_client *client)
 639 {
 640         struct smsc47m192_data *data = i2c_get_clientdata(client);
 641
 642         hwmon_device_unregister(data->hwmon_dev);
 643         sysfs_remove_group(&client->dev.kobj, &smsc47m192_group);
 644         sysfs_remove_group(&client->dev.kobj, &smsc47m192_group_in4);
 645
 646         return 0;
 647 }
 648
 649 static const struct i2c_device_id smsc47m192_id[] = {
 650         { "smsc47m192", 0 },
 651         { }
 652 };
 653 MODULE_DEVICE_TABLE(i2c, smsc47m192_id);
 654
 655 static struct i2c_driver smsc47m192_driver = {
 656         .class          = I2C_CLASS_HWMON,
 657         .driver = {
 658                 .name   = "smsc47m192",
 659         },
 660         .probe          = smsc47m192_probe,
 661         .remove         = smsc47m192_remove,
 662         .id_table       = smsc47m192_id,
 663         .detect         = smsc47m192_detect,
 664         .address_list   = normal_i2c,
 665 };
 666
 667 module_i2c_driver(smsc47m192_driver);
 668
 669 MODULE_AUTHOR("Hartmut Rick <linux@rick.claranet.de>");
 670 MODULE_DESCRIPTION("SMSC47M192 driver");
 671 MODULE_LICENSE("GPL");