drivers/hwmon/emc2103.c

   1 /*
   2     emc2103.c - Support for SMSC EMC2103
   3     Copyright (c) 2010 SMSC
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #include <linux/module.h>
  21 #include <linux/init.h>
  22 #include <linux/slab.h>
  23 #include <linux/jiffies.h>
  24 #include <linux/i2c.h>
  25 #include <linux/hwmon.h>
  26 #include <linux/hwmon-sysfs.h>
  27 #include <linux/err.h>
  28 #include <linux/mutex.h>
  29
  30 /* Addresses scanned */
  31 static const unsigned short normal_i2c[] = { 0x2E, I2C_CLIENT_END };
  32
  33 static const u8 REG_TEMP[4] = { 0x00, 0x02, 0x04, 0x06 };
  34 static const u8 REG_TEMP_MIN[4] = { 0x3c, 0x38, 0x39, 0x3a };
  35 static const u8 REG_TEMP_MAX[4] = { 0x34, 0x30, 0x31, 0x32 };
  36
  37 #define REG_CONF1               0x20
  38 #define REG_TEMP_MAX_ALARM      0x24
  39 #define REG_TEMP_MIN_ALARM      0x25
  40 #define REG_FAN_CONF1           0x42
  41 #define REG_FAN_TARGET_LO       0x4c
  42 #define REG_FAN_TARGET_HI       0x4d
  43 #define REG_FAN_TACH_HI         0x4e
  44 #define REG_FAN_TACH_LO         0x4f
  45 #define REG_PRODUCT_ID          0xfd
  46 #define REG_MFG_ID              0xfe
  47
  48 /* equation 4 from datasheet: rpm = (3932160 * multipler) / count */
  49 #define FAN_RPM_FACTOR          3932160
  50
  51 /* 2103-2 and 2103-4's 3rd temperature sensor can be connected to two diodes
  52  * in anti-parallel mode, and in this configuration both can be read
  53  * independently (so we have 4 temperature inputs).  The device can't
  54  * detect if it's connected in this mode, so we have to manually enable
  55  * it.  Default is to leave the device in the state it's already in (-1).
  56  * This parameter allows APD mode to be optionally forced on or off */
  57 static int apd = -1;
  58 module_param(apd, bool, 0);
  59 MODULE_PARM_DESC(init, "Set to zero to disable anti-parallel diode mode");
  60
  61 struct temperature {
  62         s8      degrees;
  63         u8      fraction;       /* 0-7 multiples of 0.125 */
  64 };
  65
  66 struct emc2103_data {
  67         struct device           *hwmon_dev;
  68         struct mutex            update_lock;
  69         bool                    valid;          /* registers are valid */
  70         bool                    fan_rpm_control;
  71         int                     temp_count;     /* num of temp sensors */
  72         unsigned long           last_updated;   /* in jiffies */
  73         struct temperature      temp[4];        /* internal + 3 external */
  74         s8                      temp_min[4];    /* no fractional part */
  75         s8                      temp_max[4];    /* no fractional part */
  76         u8                      temp_min_alarm;
  77         u8                      temp_max_alarm;
  78         u8                      fan_multiplier;
  79         u16                     fan_tach;
  80         u16                     fan_target;
  81 };
  82
  83 static int read_u8_from_i2c(struct i2c_client *client, u8 i2c_reg, u8 *output)
  84 {
  85         int status = i2c_smbus_read_byte_data(client, i2c_reg);
  86         if (status < 0) {
  87                 dev_warn(&client->dev, "reg 0x%02x, err %d\n",
  88                         i2c_reg, status);
  89         } else {
  90                 *output = status;
  91         }
  92         return status;
  93 }
  94
  95 static void read_temp_from_i2c(struct i2c_client *client, u8 i2c_reg,
  96                                struct temperature *temp)
  97 {
  98         u8 degrees, fractional;
  99
 100         if (read_u8_from_i2c(client, i2c_reg, &degrees) < 0)
 101                 return;
 102
 103         if (read_u8_from_i2c(client, i2c_reg + 1, &fractional) < 0)
 104                 return;
 105
 106         temp->degrees = degrees;
 107         temp->fraction = (fractional & 0xe0) >> 5;
 108 }
 109
 110 static void read_fan_from_i2c(struct i2c_client *client, u16 *output,
 111                               u8 hi_addr, u8 lo_addr)
 112 {
 113         u8 high_byte, lo_byte;
 114
 115         if (read_u8_from_i2c(client, hi_addr, &high_byte) < 0)
 116                 return;
 117
 118         if (read_u8_from_i2c(client, lo_addr, &lo_byte) < 0)
 119                 return;
 120
 121         *output = ((u16)high_byte << 5) | (lo_byte >> 3);
 122 }
 123
 124 static void write_fan_target_to_i2c(struct i2c_client *client, u16 new_target)
 125 {
 126         u8 high_byte = (new_target & 0x1fe0) >> 5;
 127         u8 low_byte = (new_target & 0x001f) << 3;
 128         i2c_smbus_write_byte_data(client, REG_FAN_TARGET_LO, low_byte);
 129         i2c_smbus_write_byte_data(client, REG_FAN_TARGET_HI, high_byte);
 130 }
 131
 132 static void read_fan_config_from_i2c(struct i2c_client *client)
 133
 134 {
 135         struct emc2103_data *data = i2c_get_clientdata(client);
 136         u8 conf1;
 137
 138         if (read_u8_from_i2c(client, REG_FAN_CONF1, &conf1) < 0)
 139                 return;
 140
 141         data->fan_multiplier = 1 << ((conf1 & 0x60) >> 5);
 142         data->fan_rpm_control = (conf1 & 0x80) != 0;
 143 }
 144
 145 static struct emc2103_data *emc2103_update_device(struct device *dev)
 146 {
 147         struct i2c_client *client = to_i2c_client(dev);
 148         struct emc2103_data *data = i2c_get_clientdata(client);
 149
 150         mutex_lock(&data->update_lock);
 151
 152         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 153             || !data->valid) {
 154                 int i;
 155
 156                 for (i = 0; i < data->temp_count; i++) {
 157                         read_temp_from_i2c(client, REG_TEMP[i], &data->temp[i]);
 158                         read_u8_from_i2c(client, REG_TEMP_MIN[i],
 159                                 &data->temp_min[i]);
 160                         read_u8_from_i2c(client, REG_TEMP_MAX[i],
 161                                 &data->temp_max[i]);
 162                 }
 163
 164                 read_u8_from_i2c(client, REG_TEMP_MIN_ALARM,
 165                         &data->temp_min_alarm);
 166                 read_u8_from_i2c(client, REG_TEMP_MAX_ALARM,
 167                         &data->temp_max_alarm);
 168
 169                 read_fan_from_i2c(client, &data->fan_tach,
 170                         REG_FAN_TACH_HI, REG_FAN_TACH_LO);
 171                 read_fan_from_i2c(client, &data->fan_target,
 172                         REG_FAN_TARGET_HI, REG_FAN_TARGET_LO);
 173                 read_fan_config_from_i2c(client);
 174
 175                 data->last_updated = jiffies;
 176                 data->valid = true;
 177         }
 178
 179         mutex_unlock(&data->update_lock);
 180
 181         return data;
 182 }
 183
 184 static ssize_t
 185 show_temp(struct device *dev, struct device_attribute *da, char *buf)
 186 {
 187         int nr = to_sensor_dev_attr(da)->index;
 188         struct emc2103_data *data = emc2103_update_device(dev);
 189         int millidegrees = data->temp[nr].degrees * 1000
 190                 + data->temp[nr].fraction * 125;
 191         return sprintf(buf, "%d\n", millidegrees);
 192 }
 193
 194 static ssize_t
 195 show_temp_min(struct device *dev, struct device_attribute *da, char *buf)
 196 {
 197         int nr = to_sensor_dev_attr(da)->index;
 198         struct emc2103_data *data = emc2103_update_device(dev);
 199         int millidegrees = data->temp_min[nr] * 1000;
 200         return sprintf(buf, "%d\n", millidegrees);
 201 }
 202
 203 static ssize_t
 204 show_temp_max(struct device *dev, struct device_attribute *da, char *buf)
 205 {
 206         int nr = to_sensor_dev_attr(da)->index;
 207         struct emc2103_data *data = emc2103_update_device(dev);
 208         int millidegrees = data->temp_max[nr] * 1000;
 209         return sprintf(buf, "%d\n", millidegrees);
 210 }
 211
 212 static ssize_t
 213 show_temp_fault(struct device *dev, struct device_attribute *da, char *buf)
 214 {
 215         int nr = to_sensor_dev_attr(da)->index;
 216         struct emc2103_data *data = emc2103_update_device(dev);
 217         bool fault = (data->temp[nr].degrees == -128);
 218         return sprintf(buf, "%d\n", fault ? 1 : 0);
 219 }
 220
 221 static ssize_t
 222 show_temp_min_alarm(struct device *dev, struct device_attribute *da, char *buf)
 223 {
 224         int nr = to_sensor_dev_attr(da)->index;
 225         struct emc2103_data *data = emc2103_update_device(dev);
 226         bool alarm = data->temp_min_alarm & (1 << nr);
 227         return sprintf(buf, "%d\n", alarm ? 1 : 0);
 228 }
 229
 230 static ssize_t
 231 show_temp_max_alarm(struct device *dev, struct device_attribute *da, char *buf)
 232 {
 233         int nr = to_sensor_dev_attr(da)->index;
 234         struct emc2103_data *data = emc2103_update_device(dev);
 235         bool alarm = data->temp_max_alarm & (1 << nr);
 236         return sprintf(buf, "%d\n", alarm ? 1 : 0);
 237 }
 238
 239 static ssize_t set_temp_min(struct device *dev, struct device_attribute *da,
 240                             const char *buf, size_t count)
 241 {
 242         int nr = to_sensor_dev_attr(da)->index;
 243         struct i2c_client *client = to_i2c_client(dev);
 244         struct emc2103_data *data = i2c_get_clientdata(client);
 245         long val;
 246
 247         int result = strict_strtol(buf, 10, &val);
 248         if (result < 0)
 249                 return -EINVAL;
 250
 251         val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), -63, 127);
 252
 253         mutex_lock(&data->update_lock);
 254         data->temp_min[nr] = val;
 255         i2c_smbus_write_byte_data(client, REG_TEMP_MIN[nr], val);
 256         mutex_unlock(&data->update_lock);
 257
 258         return count;
 259 }
 260
 261 static ssize_t set_temp_max(struct device *dev, struct device_attribute *da,
 262                             const char *buf, size_t count)
 263 {
 264         int nr = to_sensor_dev_attr(da)->index;
 265         struct i2c_client *client = to_i2c_client(dev);
 266         struct emc2103_data *data = i2c_get_clientdata(client);
 267         long val;
 268
 269         int result = strict_strtol(buf, 10, &val);
 270         if (result < 0)
 271                 return -EINVAL;
 272
 273         val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), -63, 127);
 274
 275         mutex_lock(&data->update_lock);
 276         data->temp_max[nr] = val;
 277         i2c_smbus_write_byte_data(client, REG_TEMP_MAX[nr], val);
 278         mutex_unlock(&data->update_lock);
 279
 280         return count;
 281 }
 282
 283 static ssize_t
 284 show_fan(struct device *dev, struct device_attribute *da, char *buf)
 285 {
 286         struct emc2103_data *data = emc2103_update_device(dev);
 287         int rpm = 0;
 288         if (data->fan_tach != 0)
 289                 rpm = (FAN_RPM_FACTOR * data->fan_multiplier) / data->fan_tach;
 290         return sprintf(buf, "%d\n", rpm);
 291 }
 292
 293 static ssize_t
 294 show_fan_div(struct device *dev, struct device_attribute *da, char *buf)
 295 {
 296         struct emc2103_data *data = emc2103_update_device(dev);
 297         int fan_div = 8 / data->fan_multiplier;
 298         return sprintf(buf, "%d\n", fan_div);
 299 }
 300
 301 /* Note: we also update the fan target here, because its value is
 302    determined in part by the fan clock divider.  This follows the principle
 303    of least surprise; the user doesn't expect the fan target to change just
 304    because the divider changed. */
 305 static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
 306                            const char *buf, size_t count)
 307 {
 308         struct emc2103_data *data = emc2103_update_device(dev);
 309         struct i2c_client *client = to_i2c_client(dev);
 310         int new_range_bits, old_div = 8 / data->fan_multiplier;
 311         long new_div;
 312
 313         int status = strict_strtol(buf, 10, &new_div);
 314         if (status < 0)
 315                 return -EINVAL;
 316
 317         if (new_div == old_div) /* No change */
 318                 return count;
 319
 320         switch (new_div) {
 321         case 1:
 322                 new_range_bits = 3;
 323                 break;
 324         case 2:
 325                 new_range_bits = 2;
 326                 break;
 327         case 4:
 328                 new_range_bits = 1;
 329                 break;
 330         case 8:
 331                 new_range_bits = 0;
 332                 break;
 333         default:
 334                 return -EINVAL;
 335         }
 336
 337         mutex_lock(&data->update_lock);
 338
 339         status = i2c_smbus_read_byte_data(client, REG_FAN_CONF1);
 340         if (status < 0) {
 341                 dev_dbg(&client->dev, "reg 0x%02x, err %d\n",
 342                         REG_FAN_CONF1, status);
 343                 mutex_unlock(&data->update_lock);
 344                 return -EIO;
 345         }
 346         status &= 0x9F;
 347         status |= (new_range_bits << 5);
 348         i2c_smbus_write_byte_data(client, REG_FAN_CONF1, status);
 349
 350         data->fan_multiplier = 8 / new_div;
 351
 352         /* update fan target if high byte is not disabled */
 353         if ((data->fan_target & 0x1fe0) != 0x1fe0) {
 354                 u16 new_target = (data->fan_target * old_div) / new_div;
 355                 data->fan_target = min(new_target, (u16)0x1fff);
 356                 write_fan_target_to_i2c(client, data->fan_target);
 357         }
 358
 359         /* invalidate data to force re-read from hardware */
 360         data->valid = false;
 361
 362         mutex_unlock(&data->update_lock);
 363         return count;
 364 }
 365
 366 static ssize_t
 367 show_fan_target(struct device *dev, struct device_attribute *da, char *buf)
 368 {
 369         struct emc2103_data *data = emc2103_update_device(dev);
 370         int rpm = 0;
 371
 372         /* high byte of 0xff indicates disabled so return 0 */
 373         if ((data->fan_target != 0) && ((data->fan_target & 0x1fe0) != 0x1fe0))
 374                 rpm = (FAN_RPM_FACTOR * data->fan_multiplier)
 375                         / data->fan_target;
 376
 377         return sprintf(buf, "%d\n", rpm);
 378 }
 379
 380 static ssize_t set_fan_target(struct device *dev, struct device_attribute *da,
 381                               const char *buf, size_t count)
 382 {
 383         struct emc2103_data *data = emc2103_update_device(dev);
 384         struct i2c_client *client = to_i2c_client(dev);
 385         unsigned long rpm_target;
 386
 387         int result = kstrtoul(buf, 10, &rpm_target);
 388         if (result < 0)
 389                 return -EINVAL;
 390
 391         /* Datasheet states 16384 as maximum RPM target (table 3.2) */
 392         rpm_target = clamp_val(rpm_target, 0, 16384);
 393
 394         mutex_lock(&data->update_lock);
 395
 396         if (rpm_target == 0)
 397                 data->fan_target = 0x1fff;
 398         else
 399                 data->fan_target = SENSORS_LIMIT(
 400                         (FAN_RPM_FACTOR * data->fan_multiplier) / rpm_target,
 401                         0, 0x1fff);
 402
 403         write_fan_target_to_i2c(client, data->fan_target);
 404
 405         mutex_unlock(&data->update_lock);
 406         return count;
 407 }
 408
 409 static ssize_t
 410 show_fan_fault(struct device *dev, struct device_attribute *da, char *buf)
 411 {
 412         struct emc2103_data *data = emc2103_update_device(dev);
 413         bool fault = ((data->fan_tach & 0x1fe0) == 0x1fe0);
 414         return sprintf(buf, "%d\n", fault ? 1 : 0);
 415 }
 416
 417 static ssize_t
 418 show_pwm_enable(struct device *dev, struct device_attribute *da, char *buf)
 419 {
 420         struct emc2103_data *data = emc2103_update_device(dev);
 421         return sprintf(buf, "%d\n", data->fan_rpm_control ? 3 : 0);
 422 }
 423
 424 static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *da,
 425                               const char *buf, size_t count)
 426 {
 427         struct i2c_client *client = to_i2c_client(dev);
 428         struct emc2103_data *data = i2c_get_clientdata(client);
 429         long new_value;
 430         u8 conf_reg;
 431
 432         int result = strict_strtol(buf, 10, &new_value);
 433         if (result < 0)
 434                 return -EINVAL;
 435
 436         mutex_lock(&data->update_lock);
 437         switch (new_value) {
 438         case 0:
 439                 data->fan_rpm_control = false;
 440                 break;
 441         case 3:
 442                 data->fan_rpm_control = true;
 443                 break;
 444         default:
 445                 mutex_unlock(&data->update_lock);
 446                 return -EINVAL;
 447         }
 448
 449         read_u8_from_i2c(client, REG_FAN_CONF1, &conf_reg);
 450
 451         if (data->fan_rpm_control)
 452                 conf_reg |= 0x80;
 453         else
 454                 conf_reg &= ~0x80;
 455
 456         i2c_smbus_write_byte_data(client, REG_FAN_CONF1, conf_reg);
 457
 458         mutex_unlock(&data->update_lock);
 459         return count;
 460 }
 461
 462 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
 463 static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR, show_temp_min,
 464         set_temp_min, 0);
 465 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp_max,
 466         set_temp_max, 0);
 467 static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0);
 468 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_temp_min_alarm,
 469         NULL, 0);
 470 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_temp_max_alarm,
 471         NULL, 0);
 472
 473 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
 474 static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR, show_temp_min,
 475         set_temp_min, 1);
 476 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
 477         set_temp_max, 1);
 478 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1);
 479 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_temp_min_alarm,
 480         NULL, 1);
 481 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_temp_max_alarm,
 482         NULL, 1);
 483
 484 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
 485 static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO | S_IWUSR, show_temp_min,
 486         set_temp_min, 2);
 487 static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
 488         set_temp_max, 2);
 489 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_temp_fault, NULL, 2);
 490 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_temp_min_alarm,
 491         NULL, 2);
 492 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_temp_max_alarm,
 493         NULL, 2);
 494
 495 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
 496 static SENSOR_DEVICE_ATTR(temp4_min, S_IRUGO | S_IWUSR, show_temp_min,
 497         set_temp_min, 3);
 498 static SENSOR_DEVICE_ATTR(temp4_max, S_IRUGO | S_IWUSR, show_temp_max,
 499         set_temp_max, 3);
 500 static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_temp_fault, NULL, 3);
 501 static SENSOR_DEVICE_ATTR(temp4_min_alarm, S_IRUGO, show_temp_min_alarm,
 502         NULL, 3);
 503 static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_temp_max_alarm,
 504         NULL, 3);
 505
 506 static DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL);
 507 static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR, show_fan_div, set_fan_div);
 508 static DEVICE_ATTR(fan1_target, S_IRUGO | S_IWUSR, show_fan_target,
 509         set_fan_target);
 510 static DEVICE_ATTR(fan1_fault, S_IRUGO, show_fan_fault, NULL);
 511
 512 static DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, show_pwm_enable,
 513         set_pwm_enable);
 514
 515 /* sensors present on all models */
 516 static struct attribute *emc2103_attributes[] = {
 517         &sensor_dev_attr_temp1_input.dev_attr.attr,
 518         &sensor_dev_attr_temp1_min.dev_attr.attr,
 519         &sensor_dev_attr_temp1_max.dev_attr.attr,
 520         &sensor_dev_attr_temp1_fault.dev_attr.attr,
 521         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 522         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 523         &sensor_dev_attr_temp2_input.dev_attr.attr,
 524         &sensor_dev_attr_temp2_min.dev_attr.attr,
 525         &sensor_dev_attr_temp2_max.dev_attr.attr,
 526         &sensor_dev_attr_temp2_fault.dev_attr.attr,
 527         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
 528         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 529         &dev_attr_fan1_input.attr,
 530         &dev_attr_fan1_div.attr,
 531         &dev_attr_fan1_target.attr,
 532         &dev_attr_fan1_fault.attr,
 533         &dev_attr_pwm1_enable.attr,
 534         NULL
 535 };
 536
 537 /* extra temperature sensors only present on 2103-2 and 2103-4 */
 538 static struct attribute *emc2103_attributes_temp3[] = {
 539         &sensor_dev_attr_temp3_input.dev_attr.attr,
 540         &sensor_dev_attr_temp3_min.dev_attr.attr,
 541         &sensor_dev_attr_temp3_max.dev_attr.attr,
 542         &sensor_dev_attr_temp3_fault.dev_attr.attr,
 543         &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
 544         &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
 545         NULL
 546 };
 547
 548 /* extra temperature sensors only present on 2103-2 and 2103-4 in APD mode */
 549 static struct attribute *emc2103_attributes_temp4[] = {
 550         &sensor_dev_attr_temp4_input.dev_attr.attr,
 551         &sensor_dev_attr_temp4_min.dev_attr.attr,
 552         &sensor_dev_attr_temp4_max.dev_attr.attr,
 553         &sensor_dev_attr_temp4_fault.dev_attr.attr,
 554         &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
 555         &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
 556         NULL
 557 };
 558
 559 static const struct attribute_group emc2103_group = {
 560         .attrs = emc2103_attributes,
 561 };
 562
 563 static const struct attribute_group emc2103_temp3_group = {
 564         .attrs = emc2103_attributes_temp3,
 565 };
 566
 567 static const struct attribute_group emc2103_temp4_group = {
 568         .attrs = emc2103_attributes_temp4,
 569 };
 570
 571 static int
 572 emc2103_probe(struct i2c_client *client, const struct i2c_device_id *id)
 573 {
 574         struct emc2103_data *data;
 575         int status;
 576
 577         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 578                 return -EIO;
 579
 580         data = kzalloc(sizeof(struct emc2103_data), GFP_KERNEL);
 581         if (!data)
 582                 return -ENOMEM;
 583
 584         i2c_set_clientdata(client, data);
 585         mutex_init(&data->update_lock);
 586
 587         /* 2103-2 and 2103-4 have 3 external diodes, 2103-1 has 1 */
 588         status = i2c_smbus_read_byte_data(client, REG_PRODUCT_ID);
 589         if (status == 0x24) {
 590                 /* 2103-1 only has 1 external diode */
 591                 data->temp_count = 2;
 592         } else {
 593                 /* 2103-2 and 2103-4 have 3 or 4 external diodes */
 594                 status = i2c_smbus_read_byte_data(client, REG_CONF1);
 595                 if (status < 0) {
 596                         dev_dbg(&client->dev, "reg 0x%02x, err %d\n", REG_CONF1,
 597                                 status);
 598                         goto exit_free;
 599                 }
 600
 601                 /* detect current state of hardware */
 602                 data->temp_count = (status & 0x01) ? 4 : 3;
 603
 604                 /* force APD state if module parameter is set */
 605                 if (apd == 0) {
 606                         /* force APD mode off */
 607                         data->temp_count = 3;
 608                         status &= ~(0x01);
 609                         i2c_smbus_write_byte_data(client, REG_CONF1, status);
 610                 } else if (apd == 1) {
 611                         /* force APD mode on */
 612                         data->temp_count = 4;
 613                         status |= 0x01;
 614                         i2c_smbus_write_byte_data(client, REG_CONF1, status);
 615                 }
 616         }
 617
 618         /* Register sysfs hooks */
 619         status = sysfs_create_group(&client->dev.kobj, &emc2103_group);
 620         if (status)
 621                 goto exit_free;
 622
 623         if (data->temp_count >= 3) {
 624                 status = sysfs_create_group(&client->dev.kobj,
 625                         &emc2103_temp3_group);
 626                 if (status)
 627                         goto exit_remove;
 628         }
 629
 630         if (data->temp_count == 4) {
 631                 status = sysfs_create_group(&client->dev.kobj,
 632                         &emc2103_temp4_group);
 633                 if (status)
 634                         goto exit_remove_temp3;
 635         }
 636
 637         data->hwmon_dev = hwmon_device_register(&client->dev);
 638         if (IS_ERR(data->hwmon_dev)) {
 639                 status = PTR_ERR(data->hwmon_dev);
 640                 goto exit_remove_temp4;
 641         }
 642
 643         dev_info(&client->dev, "%s: sensor '%s'\n",
 644                  dev_name(data->hwmon_dev), client->name);
 645
 646         return 0;
 647
 648 exit_remove_temp4:
 649         if (data->temp_count == 4)
 650                 sysfs_remove_group(&client->dev.kobj, &emc2103_temp4_group);
 651 exit_remove_temp3:
 652         if (data->temp_count >= 3)
 653                 sysfs_remove_group(&client->dev.kobj, &emc2103_temp3_group);
 654 exit_remove:
 655         sysfs_remove_group(&client->dev.kobj, &emc2103_group);
 656 exit_free:
 657         kfree(data);
 658         return status;
 659 }
 660
 661 static int emc2103_remove(struct i2c_client *client)
 662 {
 663         struct emc2103_data *data = i2c_get_clientdata(client);
 664
 665         hwmon_device_unregister(data->hwmon_dev);
 666
 667         if (data->temp_count == 4)
 668                 sysfs_remove_group(&client->dev.kobj, &emc2103_temp4_group);
 669
 670         if (data->temp_count >= 3)
 671                 sysfs_remove_group(&client->dev.kobj, &emc2103_temp3_group);
 672
 673         sysfs_remove_group(&client->dev.kobj, &emc2103_group);
 674
 675         kfree(data);
 676         return 0;
 677 }
 678
 679 static const struct i2c_device_id emc2103_ids[] = {
 680         { "emc2103", 0, },
 681         { /* LIST END */ }
 682 };
 683 MODULE_DEVICE_TABLE(i2c, emc2103_ids);
 684
 685 /* Return 0 if detection is successful, -ENODEV otherwise */
 686 static int
 687 emc2103_detect(struct i2c_client *new_client, struct i2c_board_info *info)
 688 {
 689         struct i2c_adapter *adapter = new_client->adapter;
 690         int manufacturer, product;
 691
 692         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 693                 return -ENODEV;
 694
 695         manufacturer = i2c_smbus_read_byte_data(new_client, REG_MFG_ID);
 696         if (manufacturer != 0x5D)
 697                 return -ENODEV;
 698
 699         product = i2c_smbus_read_byte_data(new_client, REG_PRODUCT_ID);
 700         if ((product != 0x24) && (product != 0x26))
 701                 return -ENODEV;
 702
 703         strlcpy(info->type, "emc2103", I2C_NAME_SIZE);
 704
 705         return 0;
 706 }
 707
 708 static struct i2c_driver emc2103_driver = {
 709         .class          = I2C_CLASS_HWMON,
 710         .driver = {
 711                 .name   = "emc2103",
 712         },
 713         .probe          = emc2103_probe,
 714         .remove         = emc2103_remove,
 715         .id_table       = emc2103_ids,
 716         .detect         = emc2103_detect,
 717         .address_list   = normal_i2c,
 718 };
 719
 720 static int __init sensors_emc2103_init(void)
 721 {
 722         return i2c_add_driver(&emc2103_driver);
 723 }
 724
 725 static void __exit sensors_emc2103_exit(void)
 726 {
 727         i2c_del_driver(&emc2103_driver);
 728 }
 729
 730 MODULE_AUTHOR("Steve Glendinning <steve.glendinning@smsc.com>");
 731 MODULE_DESCRIPTION("SMSC EMC2103 hwmon driver");
 732 MODULE_LICENSE("GPL");
 733
 734 module_init(sensors_emc2103_init);
 735 module_exit(sensors_emc2103_exit);