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