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