1 /* 2 * A hwmon driver for the Analog Devices ADT7470 3 * Copyright (C) 2007 IBM 4 * 5 * Author: Darrick J. Wong <djwong@us.ibm.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 22 #include <linux/module.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 #include <linux/delay.h> 30 #include <linux/log2.h> 31 #include <linux/kthread.h> 32 33 /* Addresses to scan */ 34 static const unsigned short normal_i2c[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END }; 35 36 /* ADT7470 registers */ 37 #define ADT7470_REG_BASE_ADDR 0x20 38 #define ADT7470_REG_TEMP_BASE_ADDR 0x20 39 #define ADT7470_REG_TEMP_MAX_ADDR 0x29 40 #define ADT7470_REG_FAN_BASE_ADDR 0x2A 41 #define ADT7470_REG_FAN_MAX_ADDR 0x31 42 #define ADT7470_REG_PWM_BASE_ADDR 0x32 43 #define ADT7470_REG_PWM_MAX_ADDR 0x35 44 #define ADT7470_REG_PWM_MAX_BASE_ADDR 0x38 45 #define ADT7470_REG_PWM_MAX_MAX_ADDR 0x3B 46 #define ADT7470_REG_CFG 0x40 47 #define ADT7470_FSPD_MASK 0x04 48 #define ADT7470_REG_ALARM1 0x41 49 #define ADT7470_R1T_ALARM 0x01 50 #define ADT7470_R2T_ALARM 0x02 51 #define ADT7470_R3T_ALARM 0x04 52 #define ADT7470_R4T_ALARM 0x08 53 #define ADT7470_R5T_ALARM 0x10 54 #define ADT7470_R6T_ALARM 0x20 55 #define ADT7470_R7T_ALARM 0x40 56 #define ADT7470_OOL_ALARM 0x80 57 #define ADT7470_REG_ALARM2 0x42 58 #define ADT7470_R8T_ALARM 0x01 59 #define ADT7470_R9T_ALARM 0x02 60 #define ADT7470_R10T_ALARM 0x04 61 #define ADT7470_FAN1_ALARM 0x10 62 #define ADT7470_FAN2_ALARM 0x20 63 #define ADT7470_FAN3_ALARM 0x40 64 #define ADT7470_FAN4_ALARM 0x80 65 #define ADT7470_REG_TEMP_LIMITS_BASE_ADDR 0x44 66 #define ADT7470_REG_TEMP_LIMITS_MAX_ADDR 0x57 67 #define ADT7470_REG_FAN_MIN_BASE_ADDR 0x58 68 #define ADT7470_REG_FAN_MIN_MAX_ADDR 0x5F 69 #define ADT7470_REG_FAN_MAX_BASE_ADDR 0x60 70 #define ADT7470_REG_FAN_MAX_MAX_ADDR 0x67 71 #define ADT7470_REG_PWM_CFG_BASE_ADDR 0x68 72 #define ADT7470_REG_PWM12_CFG 0x68 73 #define ADT7470_PWM2_AUTO_MASK 0x40 74 #define ADT7470_PWM1_AUTO_MASK 0x80 75 #define ADT7470_PWM_AUTO_MASK 0xC0 76 #define ADT7470_REG_PWM34_CFG 0x69 77 #define ADT7470_PWM3_AUTO_MASK 0x40 78 #define ADT7470_PWM4_AUTO_MASK 0x80 79 #define ADT7470_REG_PWM_MIN_BASE_ADDR 0x6A 80 #define ADT7470_REG_PWM_MIN_MAX_ADDR 0x6D 81 #define ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR 0x6E 82 #define ADT7470_REG_PWM_TEMP_MIN_MAX_ADDR 0x71 83 #define ADT7470_REG_ACOUSTICS12 0x75 84 #define ADT7470_REG_ACOUSTICS34 0x76 85 #define ADT7470_REG_DEVICE 0x3D 86 #define ADT7470_REG_VENDOR 0x3E 87 #define ADT7470_REG_REVISION 0x3F 88 #define ADT7470_REG_ALARM1_MASK 0x72 89 #define ADT7470_REG_ALARM2_MASK 0x73 90 #define ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR 0x7C 91 #define ADT7470_REG_PWM_AUTO_TEMP_MAX_ADDR 0x7D 92 #define ADT7470_REG_MAX_ADDR 0x81 93 94 #define ADT7470_TEMP_COUNT 10 95 #define ADT7470_TEMP_REG(x) (ADT7470_REG_TEMP_BASE_ADDR + (x)) 96 #define ADT7470_TEMP_MIN_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + ((x) * 2)) 97 #define ADT7470_TEMP_MAX_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + \ 98 ((x) * 2) + 1) 99 100 #define ADT7470_FAN_COUNT 4 101 #define ADT7470_REG_FAN(x) (ADT7470_REG_FAN_BASE_ADDR + ((x) * 2)) 102 #define ADT7470_REG_FAN_MIN(x) (ADT7470_REG_FAN_MIN_BASE_ADDR + ((x) * 2)) 103 #define ADT7470_REG_FAN_MAX(x) (ADT7470_REG_FAN_MAX_BASE_ADDR + ((x) * 2)) 104 105 #define ADT7470_PWM_COUNT 4 106 #define ADT7470_REG_PWM(x) (ADT7470_REG_PWM_BASE_ADDR + (x)) 107 #define ADT7470_REG_PWM_MAX(x) (ADT7470_REG_PWM_MAX_BASE_ADDR + (x)) 108 #define ADT7470_REG_PWM_MIN(x) (ADT7470_REG_PWM_MIN_BASE_ADDR + (x)) 109 #define ADT7470_REG_PWM_TMIN(x) (ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR + (x)) 110 #define ADT7470_REG_PWM_CFG(x) (ADT7470_REG_PWM_CFG_BASE_ADDR + ((x) / 2)) 111 #define ADT7470_REG_PWM_AUTO_TEMP(x) (ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR + \ 112 ((x) / 2)) 113 114 #define ALARM2(x) ((x) << 8) 115 116 #define ADT7470_VENDOR 0x41 117 #define ADT7470_DEVICE 0x70 118 /* datasheet only mentions a revision 2 */ 119 #define ADT7470_REVISION 0x02 120 121 /* "all temps" according to hwmon sysfs interface spec */ 122 #define ADT7470_PWM_ALL_TEMPS 0x3FF 123 124 /* How often do we reread sensors values? (In jiffies) */ 125 #define SENSOR_REFRESH_INTERVAL (5 * HZ) 126 127 /* How often do we reread sensor limit values? (In jiffies) */ 128 #define LIMIT_REFRESH_INTERVAL (60 * HZ) 129 130 /* Wait at least 200ms per sensor for 10 sensors */ 131 #define TEMP_COLLECTION_TIME 2000 132 133 /* auto update thing won't fire more than every 2s */ 134 #define AUTO_UPDATE_INTERVAL 2000 135 136 /* datasheet says to divide this number by the fan reading to get fan rpm */ 137 #define FAN_PERIOD_TO_RPM(x) ((90000 * 60) / (x)) 138 #define FAN_RPM_TO_PERIOD FAN_PERIOD_TO_RPM 139 #define FAN_PERIOD_INVALID 65535 140 #define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID) 141 142 struct adt7470_data { 143 struct device *hwmon_dev; 144 struct attribute_group attrs; 145 struct mutex lock; 146 char sensors_valid; 147 char limits_valid; 148 unsigned long sensors_last_updated; /* In jiffies */ 149 unsigned long limits_last_updated; /* In jiffies */ 150 151 int num_temp_sensors; /* -1 = probe */ 152 int temperatures_probed; 153 154 s8 temp[ADT7470_TEMP_COUNT]; 155 s8 temp_min[ADT7470_TEMP_COUNT]; 156 s8 temp_max[ADT7470_TEMP_COUNT]; 157 u16 fan[ADT7470_FAN_COUNT]; 158 u16 fan_min[ADT7470_FAN_COUNT]; 159 u16 fan_max[ADT7470_FAN_COUNT]; 160 u16 alarm; 161 u16 alarms_mask; 162 u8 force_pwm_max; 163 u8 pwm[ADT7470_PWM_COUNT]; 164 u8 pwm_max[ADT7470_PWM_COUNT]; 165 u8 pwm_automatic[ADT7470_PWM_COUNT]; 166 u8 pwm_min[ADT7470_PWM_COUNT]; 167 s8 pwm_tmin[ADT7470_PWM_COUNT]; 168 u8 pwm_auto_temp[ADT7470_PWM_COUNT]; 169 170 struct task_struct *auto_update; 171 struct completion auto_update_stop; 172 unsigned int auto_update_interval; 173 }; 174 175 static int adt7470_probe(struct i2c_client *client, 176 const struct i2c_device_id *id); 177 static int adt7470_detect(struct i2c_client *client, 178 struct i2c_board_info *info); 179 static int adt7470_remove(struct i2c_client *client); 180 181 static const struct i2c_device_id adt7470_id[] = { 182 { "adt7470", 0 }, 183 { } 184 }; 185 MODULE_DEVICE_TABLE(i2c, adt7470_id); 186 187 static struct i2c_driver adt7470_driver = { 188 .class = I2C_CLASS_HWMON, 189 .driver = { 190 .name = "adt7470", 191 }, 192 .probe = adt7470_probe, 193 .remove = adt7470_remove, 194 .id_table = adt7470_id, 195 .detect = adt7470_detect, 196 .address_list = normal_i2c, 197 }; 198 199 /* 200 * 16-bit registers on the ADT7470 are low-byte first. The data sheet says 201 * that the low byte must be read before the high byte. 202 */ 203 static inline int adt7470_read_word_data(struct i2c_client *client, u8 reg) 204 { 205 u16 foo; 206 foo = i2c_smbus_read_byte_data(client, reg); 207 foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8); 208 return foo; 209 } 210 211 static inline int adt7470_write_word_data(struct i2c_client *client, u8 reg, 212 u16 value) 213 { 214 return i2c_smbus_write_byte_data(client, reg, value & 0xFF) 215 && i2c_smbus_write_byte_data(client, reg + 1, value >> 8); 216 } 217 218 static void adt7470_init_client(struct i2c_client *client) 219 { 220 int reg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG); 221 222 if (reg < 0) { 223 dev_err(&client->dev, "cannot read configuration register\n"); 224 } else { 225 /* start monitoring (and do a self-test) */ 226 i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, reg | 3); 227 } 228 } 229 230 /* Probe for temperature sensors. Assumes lock is held */ 231 static int adt7470_read_temperatures(struct i2c_client *client, 232 struct adt7470_data *data) 233 { 234 unsigned long res; 235 int i; 236 u8 cfg, pwm[4], pwm_cfg[2]; 237 238 /* save pwm[1-4] config register */ 239 pwm_cfg[0] = i2c_smbus_read_byte_data(client, ADT7470_REG_PWM_CFG(0)); 240 pwm_cfg[1] = i2c_smbus_read_byte_data(client, ADT7470_REG_PWM_CFG(2)); 241 242 /* set manual pwm to whatever it is set to now */ 243 for (i = 0; i < ADT7470_FAN_COUNT; i++) 244 pwm[i] = i2c_smbus_read_byte_data(client, ADT7470_REG_PWM(i)); 245 246 /* put pwm in manual mode */ 247 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(0), 248 pwm_cfg[0] & ~(ADT7470_PWM_AUTO_MASK)); 249 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(2), 250 pwm_cfg[1] & ~(ADT7470_PWM_AUTO_MASK)); 251 252 /* write pwm control to whatever it was */ 253 for (i = 0; i < ADT7470_FAN_COUNT; i++) 254 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM(i), pwm[i]); 255 256 /* start reading temperature sensors */ 257 cfg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG); 258 cfg |= 0x80; 259 i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, cfg); 260 261 /* Delay is 200ms * number of temp sensors. */ 262 res = msleep_interruptible((data->num_temp_sensors >= 0 ? 263 data->num_temp_sensors * 200 : 264 TEMP_COLLECTION_TIME)); 265 266 /* done reading temperature sensors */ 267 cfg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG); 268 cfg &= ~0x80; 269 i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, cfg); 270 271 /* restore pwm[1-4] config registers */ 272 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(0), pwm_cfg[0]); 273 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(2), pwm_cfg[1]); 274 275 if (res) { 276 printk(KERN_ERR "ha ha, interrupted"); 277 return -EAGAIN; 278 } 279 280 /* Only count fans if we have to */ 281 if (data->num_temp_sensors >= 0) 282 return 0; 283 284 for (i = 0; i < ADT7470_TEMP_COUNT; i++) { 285 data->temp[i] = i2c_smbus_read_byte_data(client, 286 ADT7470_TEMP_REG(i)); 287 if (data->temp[i]) 288 data->num_temp_sensors = i + 1; 289 } 290 data->temperatures_probed = 1; 291 return 0; 292 } 293 294 static int adt7470_update_thread(void *p) 295 { 296 struct i2c_client *client = p; 297 struct adt7470_data *data = i2c_get_clientdata(client); 298 299 while (!kthread_should_stop()) { 300 mutex_lock(&data->lock); 301 adt7470_read_temperatures(client, data); 302 mutex_unlock(&data->lock); 303 if (kthread_should_stop()) 304 break; 305 msleep_interruptible(data->auto_update_interval); 306 } 307 308 complete_all(&data->auto_update_stop); 309 return 0; 310 } 311 312 static struct adt7470_data *adt7470_update_device(struct device *dev) 313 { 314 struct i2c_client *client = to_i2c_client(dev); 315 struct adt7470_data *data = i2c_get_clientdata(client); 316 unsigned long local_jiffies = jiffies; 317 u8 cfg; 318 int i; 319 int need_sensors = 1; 320 int need_limits = 1; 321 322 /* 323 * Figure out if we need to update the shadow registers. 324 * Lockless means that we may occasionally report out of 325 * date data. 326 */ 327 if (time_before(local_jiffies, data->sensors_last_updated + 328 SENSOR_REFRESH_INTERVAL) && 329 data->sensors_valid) 330 need_sensors = 0; 331 332 if (time_before(local_jiffies, data->limits_last_updated + 333 LIMIT_REFRESH_INTERVAL) && 334 data->limits_valid) 335 need_limits = 0; 336 337 if (!need_sensors && !need_limits) 338 return data; 339 340 mutex_lock(&data->lock); 341 if (!need_sensors) 342 goto no_sensor_update; 343 344 if (!data->temperatures_probed) 345 adt7470_read_temperatures(client, data); 346 else 347 for (i = 0; i < ADT7470_TEMP_COUNT; i++) 348 data->temp[i] = i2c_smbus_read_byte_data(client, 349 ADT7470_TEMP_REG(i)); 350 351 for (i = 0; i < ADT7470_FAN_COUNT; i++) 352 data->fan[i] = adt7470_read_word_data(client, 353 ADT7470_REG_FAN(i)); 354 355 for (i = 0; i < ADT7470_PWM_COUNT; i++) { 356 int reg; 357 int reg_mask; 358 359 data->pwm[i] = i2c_smbus_read_byte_data(client, 360 ADT7470_REG_PWM(i)); 361 362 if (i % 2) 363 reg_mask = ADT7470_PWM2_AUTO_MASK; 364 else 365 reg_mask = ADT7470_PWM1_AUTO_MASK; 366 367 reg = ADT7470_REG_PWM_CFG(i); 368 if (i2c_smbus_read_byte_data(client, reg) & reg_mask) 369 data->pwm_automatic[i] = 1; 370 else 371 data->pwm_automatic[i] = 0; 372 373 reg = ADT7470_REG_PWM_AUTO_TEMP(i); 374 cfg = i2c_smbus_read_byte_data(client, reg); 375 if (!(i % 2)) 376 data->pwm_auto_temp[i] = cfg >> 4; 377 else 378 data->pwm_auto_temp[i] = cfg & 0xF; 379 } 380 381 if (i2c_smbus_read_byte_data(client, ADT7470_REG_CFG) & 382 ADT7470_FSPD_MASK) 383 data->force_pwm_max = 1; 384 else 385 data->force_pwm_max = 0; 386 387 data->alarm = i2c_smbus_read_byte_data(client, ADT7470_REG_ALARM1); 388 if (data->alarm & ADT7470_OOL_ALARM) 389 data->alarm |= ALARM2(i2c_smbus_read_byte_data(client, 390 ADT7470_REG_ALARM2)); 391 data->alarms_mask = adt7470_read_word_data(client, 392 ADT7470_REG_ALARM1_MASK); 393 394 data->sensors_last_updated = local_jiffies; 395 data->sensors_valid = 1; 396 397 no_sensor_update: 398 if (!need_limits) 399 goto out; 400 401 for (i = 0; i < ADT7470_TEMP_COUNT; i++) { 402 data->temp_min[i] = i2c_smbus_read_byte_data(client, 403 ADT7470_TEMP_MIN_REG(i)); 404 data->temp_max[i] = i2c_smbus_read_byte_data(client, 405 ADT7470_TEMP_MAX_REG(i)); 406 } 407 408 for (i = 0; i < ADT7470_FAN_COUNT; i++) { 409 data->fan_min[i] = adt7470_read_word_data(client, 410 ADT7470_REG_FAN_MIN(i)); 411 data->fan_max[i] = adt7470_read_word_data(client, 412 ADT7470_REG_FAN_MAX(i)); 413 } 414 415 for (i = 0; i < ADT7470_PWM_COUNT; i++) { 416 data->pwm_max[i] = i2c_smbus_read_byte_data(client, 417 ADT7470_REG_PWM_MAX(i)); 418 data->pwm_min[i] = i2c_smbus_read_byte_data(client, 419 ADT7470_REG_PWM_MIN(i)); 420 data->pwm_tmin[i] = i2c_smbus_read_byte_data(client, 421 ADT7470_REG_PWM_TMIN(i)); 422 } 423 424 data->limits_last_updated = local_jiffies; 425 data->limits_valid = 1; 426 427 out: 428 mutex_unlock(&data->lock); 429 return data; 430 } 431 432 static ssize_t show_auto_update_interval(struct device *dev, 433 struct device_attribute *devattr, 434 char *buf) 435 { 436 struct adt7470_data *data = adt7470_update_device(dev); 437 return sprintf(buf, "%d\n", data->auto_update_interval); 438 } 439 440 static ssize_t set_auto_update_interval(struct device *dev, 441 struct device_attribute *devattr, 442 const char *buf, 443 size_t count) 444 { 445 struct i2c_client *client = to_i2c_client(dev); 446 struct adt7470_data *data = i2c_get_clientdata(client); 447 long temp; 448 449 if (strict_strtol(buf, 10, &temp)) 450 return -EINVAL; 451 452 temp = SENSORS_LIMIT(temp, 0, 60000); 453 454 mutex_lock(&data->lock); 455 data->auto_update_interval = temp; 456 mutex_unlock(&data->lock); 457 458 return count; 459 } 460 461 static ssize_t show_num_temp_sensors(struct device *dev, 462 struct device_attribute *devattr, 463 char *buf) 464 { 465 struct adt7470_data *data = adt7470_update_device(dev); 466 return sprintf(buf, "%d\n", data->num_temp_sensors); 467 } 468 469 static ssize_t set_num_temp_sensors(struct device *dev, 470 struct device_attribute *devattr, 471 const char *buf, 472 size_t count) 473 { 474 struct i2c_client *client = to_i2c_client(dev); 475 struct adt7470_data *data = i2c_get_clientdata(client); 476 long temp; 477 478 if (strict_strtol(buf, 10, &temp)) 479 return -EINVAL; 480 481 temp = SENSORS_LIMIT(temp, -1, 10); 482 483 mutex_lock(&data->lock); 484 data->num_temp_sensors = temp; 485 if (temp < 0) 486 data->temperatures_probed = 0; 487 mutex_unlock(&data->lock); 488 489 return count; 490 } 491 492 static ssize_t show_temp_min(struct device *dev, 493 struct device_attribute *devattr, 494 char *buf) 495 { 496 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 497 struct adt7470_data *data = adt7470_update_device(dev); 498 return sprintf(buf, "%d\n", 1000 * data->temp_min[attr->index]); 499 } 500 501 static ssize_t set_temp_min(struct device *dev, 502 struct device_attribute *devattr, 503 const char *buf, 504 size_t count) 505 { 506 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 507 struct i2c_client *client = to_i2c_client(dev); 508 struct adt7470_data *data = i2c_get_clientdata(client); 509 long temp; 510 511 if (strict_strtol(buf, 10, &temp)) 512 return -EINVAL; 513 514 temp = DIV_ROUND_CLOSEST(temp, 1000); 515 temp = SENSORS_LIMIT(temp, 0, 255); 516 517 mutex_lock(&data->lock); 518 data->temp_min[attr->index] = temp; 519 i2c_smbus_write_byte_data(client, ADT7470_TEMP_MIN_REG(attr->index), 520 temp); 521 mutex_unlock(&data->lock); 522 523 return count; 524 } 525 526 static ssize_t show_temp_max(struct device *dev, 527 struct device_attribute *devattr, 528 char *buf) 529 { 530 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 531 struct adt7470_data *data = adt7470_update_device(dev); 532 return sprintf(buf, "%d\n", 1000 * data->temp_max[attr->index]); 533 } 534 535 static ssize_t set_temp_max(struct device *dev, 536 struct device_attribute *devattr, 537 const char *buf, 538 size_t count) 539 { 540 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 541 struct i2c_client *client = to_i2c_client(dev); 542 struct adt7470_data *data = i2c_get_clientdata(client); 543 long temp; 544 545 if (strict_strtol(buf, 10, &temp)) 546 return -EINVAL; 547 548 temp = DIV_ROUND_CLOSEST(temp, 1000); 549 temp = SENSORS_LIMIT(temp, 0, 255); 550 551 mutex_lock(&data->lock); 552 data->temp_max[attr->index] = temp; 553 i2c_smbus_write_byte_data(client, ADT7470_TEMP_MAX_REG(attr->index), 554 temp); 555 mutex_unlock(&data->lock); 556 557 return count; 558 } 559 560 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr, 561 char *buf) 562 { 563 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 564 struct adt7470_data *data = adt7470_update_device(dev); 565 return sprintf(buf, "%d\n", 1000 * data->temp[attr->index]); 566 } 567 568 static ssize_t show_alarm_mask(struct device *dev, 569 struct device_attribute *devattr, 570 char *buf) 571 { 572 struct adt7470_data *data = adt7470_update_device(dev); 573 574 return sprintf(buf, "%x\n", data->alarms_mask); 575 } 576 577 static ssize_t show_fan_max(struct device *dev, 578 struct device_attribute *devattr, 579 char *buf) 580 { 581 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 582 struct adt7470_data *data = adt7470_update_device(dev); 583 584 if (FAN_DATA_VALID(data->fan_max[attr->index])) 585 return sprintf(buf, "%d\n", 586 FAN_PERIOD_TO_RPM(data->fan_max[attr->index])); 587 else 588 return sprintf(buf, "0\n"); 589 } 590 591 static ssize_t set_fan_max(struct device *dev, 592 struct device_attribute *devattr, 593 const char *buf, size_t count) 594 { 595 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 596 struct i2c_client *client = to_i2c_client(dev); 597 struct adt7470_data *data = i2c_get_clientdata(client); 598 long temp; 599 600 if (strict_strtol(buf, 10, &temp) || !temp) 601 return -EINVAL; 602 603 temp = FAN_RPM_TO_PERIOD(temp); 604 temp = SENSORS_LIMIT(temp, 1, 65534); 605 606 mutex_lock(&data->lock); 607 data->fan_max[attr->index] = temp; 608 adt7470_write_word_data(client, ADT7470_REG_FAN_MAX(attr->index), temp); 609 mutex_unlock(&data->lock); 610 611 return count; 612 } 613 614 static ssize_t show_fan_min(struct device *dev, 615 struct device_attribute *devattr, 616 char *buf) 617 { 618 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 619 struct adt7470_data *data = adt7470_update_device(dev); 620 621 if (FAN_DATA_VALID(data->fan_min[attr->index])) 622 return sprintf(buf, "%d\n", 623 FAN_PERIOD_TO_RPM(data->fan_min[attr->index])); 624 else 625 return sprintf(buf, "0\n"); 626 } 627 628 static ssize_t set_fan_min(struct device *dev, 629 struct device_attribute *devattr, 630 const char *buf, size_t count) 631 { 632 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 633 struct i2c_client *client = to_i2c_client(dev); 634 struct adt7470_data *data = i2c_get_clientdata(client); 635 long temp; 636 637 if (strict_strtol(buf, 10, &temp) || !temp) 638 return -EINVAL; 639 640 temp = FAN_RPM_TO_PERIOD(temp); 641 temp = SENSORS_LIMIT(temp, 1, 65534); 642 643 mutex_lock(&data->lock); 644 data->fan_min[attr->index] = temp; 645 adt7470_write_word_data(client, ADT7470_REG_FAN_MIN(attr->index), temp); 646 mutex_unlock(&data->lock); 647 648 return count; 649 } 650 651 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr, 652 char *buf) 653 { 654 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 655 struct adt7470_data *data = adt7470_update_device(dev); 656 657 if (FAN_DATA_VALID(data->fan[attr->index])) 658 return sprintf(buf, "%d\n", 659 FAN_PERIOD_TO_RPM(data->fan[attr->index])); 660 else 661 return sprintf(buf, "0\n"); 662 } 663 664 static ssize_t show_force_pwm_max(struct device *dev, 665 struct device_attribute *devattr, 666 char *buf) 667 { 668 struct adt7470_data *data = adt7470_update_device(dev); 669 return sprintf(buf, "%d\n", data->force_pwm_max); 670 } 671 672 static ssize_t set_force_pwm_max(struct device *dev, 673 struct device_attribute *devattr, 674 const char *buf, 675 size_t count) 676 { 677 struct i2c_client *client = to_i2c_client(dev); 678 struct adt7470_data *data = i2c_get_clientdata(client); 679 long temp; 680 u8 reg; 681 682 if (strict_strtol(buf, 10, &temp)) 683 return -EINVAL; 684 685 mutex_lock(&data->lock); 686 data->force_pwm_max = temp; 687 reg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG); 688 if (temp) 689 reg |= ADT7470_FSPD_MASK; 690 else 691 reg &= ~ADT7470_FSPD_MASK; 692 i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, reg); 693 mutex_unlock(&data->lock); 694 695 return count; 696 } 697 698 static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr, 699 char *buf) 700 { 701 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 702 struct adt7470_data *data = adt7470_update_device(dev); 703 return sprintf(buf, "%d\n", data->pwm[attr->index]); 704 } 705 706 static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr, 707 const char *buf, size_t count) 708 { 709 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 710 struct i2c_client *client = to_i2c_client(dev); 711 struct adt7470_data *data = i2c_get_clientdata(client); 712 long temp; 713 714 if (strict_strtol(buf, 10, &temp)) 715 return -EINVAL; 716 717 temp = SENSORS_LIMIT(temp, 0, 255); 718 719 mutex_lock(&data->lock); 720 data->pwm[attr->index] = temp; 721 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM(attr->index), temp); 722 mutex_unlock(&data->lock); 723 724 return count; 725 } 726 727 static ssize_t show_pwm_max(struct device *dev, 728 struct device_attribute *devattr, 729 char *buf) 730 { 731 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 732 struct adt7470_data *data = adt7470_update_device(dev); 733 return sprintf(buf, "%d\n", data->pwm_max[attr->index]); 734 } 735 736 static ssize_t set_pwm_max(struct device *dev, 737 struct device_attribute *devattr, 738 const char *buf, 739 size_t count) 740 { 741 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 742 struct i2c_client *client = to_i2c_client(dev); 743 struct adt7470_data *data = i2c_get_clientdata(client); 744 long temp; 745 746 if (strict_strtol(buf, 10, &temp)) 747 return -EINVAL; 748 749 temp = SENSORS_LIMIT(temp, 0, 255); 750 751 mutex_lock(&data->lock); 752 data->pwm_max[attr->index] = temp; 753 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_MAX(attr->index), 754 temp); 755 mutex_unlock(&data->lock); 756 757 return count; 758 } 759 760 static ssize_t show_pwm_min(struct device *dev, 761 struct device_attribute *devattr, 762 char *buf) 763 { 764 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 765 struct adt7470_data *data = adt7470_update_device(dev); 766 return sprintf(buf, "%d\n", data->pwm_min[attr->index]); 767 } 768 769 static ssize_t set_pwm_min(struct device *dev, 770 struct device_attribute *devattr, 771 const char *buf, 772 size_t count) 773 { 774 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 775 struct i2c_client *client = to_i2c_client(dev); 776 struct adt7470_data *data = i2c_get_clientdata(client); 777 long temp; 778 779 if (strict_strtol(buf, 10, &temp)) 780 return -EINVAL; 781 782 temp = SENSORS_LIMIT(temp, 0, 255); 783 784 mutex_lock(&data->lock); 785 data->pwm_min[attr->index] = temp; 786 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_MIN(attr->index), 787 temp); 788 mutex_unlock(&data->lock); 789 790 return count; 791 } 792 793 static ssize_t show_pwm_tmax(struct device *dev, 794 struct device_attribute *devattr, 795 char *buf) 796 { 797 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 798 struct adt7470_data *data = adt7470_update_device(dev); 799 /* the datasheet says that tmax = tmin + 20C */ 800 return sprintf(buf, "%d\n", 1000 * (20 + data->pwm_tmin[attr->index])); 801 } 802 803 static ssize_t show_pwm_tmin(struct device *dev, 804 struct device_attribute *devattr, 805 char *buf) 806 { 807 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 808 struct adt7470_data *data = adt7470_update_device(dev); 809 return sprintf(buf, "%d\n", 1000 * data->pwm_tmin[attr->index]); 810 } 811 812 static ssize_t set_pwm_tmin(struct device *dev, 813 struct device_attribute *devattr, 814 const char *buf, 815 size_t count) 816 { 817 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 818 struct i2c_client *client = to_i2c_client(dev); 819 struct adt7470_data *data = i2c_get_clientdata(client); 820 long temp; 821 822 if (strict_strtol(buf, 10, &temp)) 823 return -EINVAL; 824 825 temp = DIV_ROUND_CLOSEST(temp, 1000); 826 temp = SENSORS_LIMIT(temp, 0, 255); 827 828 mutex_lock(&data->lock); 829 data->pwm_tmin[attr->index] = temp; 830 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_TMIN(attr->index), 831 temp); 832 mutex_unlock(&data->lock); 833 834 return count; 835 } 836 837 static ssize_t show_pwm_auto(struct device *dev, 838 struct device_attribute *devattr, 839 char *buf) 840 { 841 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 842 struct adt7470_data *data = adt7470_update_device(dev); 843 return sprintf(buf, "%d\n", 1 + data->pwm_automatic[attr->index]); 844 } 845 846 static ssize_t set_pwm_auto(struct device *dev, 847 struct device_attribute *devattr, 848 const char *buf, 849 size_t count) 850 { 851 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 852 struct i2c_client *client = to_i2c_client(dev); 853 struct adt7470_data *data = i2c_get_clientdata(client); 854 int pwm_auto_reg = ADT7470_REG_PWM_CFG(attr->index); 855 int pwm_auto_reg_mask; 856 long temp; 857 u8 reg; 858 859 if (strict_strtol(buf, 10, &temp)) 860 return -EINVAL; 861 862 if (attr->index % 2) 863 pwm_auto_reg_mask = ADT7470_PWM2_AUTO_MASK; 864 else 865 pwm_auto_reg_mask = ADT7470_PWM1_AUTO_MASK; 866 867 if (temp != 2 && temp != 1) 868 return -EINVAL; 869 temp--; 870 871 mutex_lock(&data->lock); 872 data->pwm_automatic[attr->index] = temp; 873 reg = i2c_smbus_read_byte_data(client, pwm_auto_reg); 874 if (temp) 875 reg |= pwm_auto_reg_mask; 876 else 877 reg &= ~pwm_auto_reg_mask; 878 i2c_smbus_write_byte_data(client, pwm_auto_reg, reg); 879 mutex_unlock(&data->lock); 880 881 return count; 882 } 883 884 static ssize_t show_pwm_auto_temp(struct device *dev, 885 struct device_attribute *devattr, 886 char *buf) 887 { 888 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 889 struct adt7470_data *data = adt7470_update_device(dev); 890 u8 ctrl = data->pwm_auto_temp[attr->index]; 891 892 if (ctrl) 893 return sprintf(buf, "%d\n", 1 << (ctrl - 1)); 894 else 895 return sprintf(buf, "%d\n", ADT7470_PWM_ALL_TEMPS); 896 } 897 898 static int cvt_auto_temp(int input) 899 { 900 if (input == ADT7470_PWM_ALL_TEMPS) 901 return 0; 902 if (input < 1 || !is_power_of_2(input)) 903 return -EINVAL; 904 return ilog2(input) + 1; 905 } 906 907 static ssize_t set_pwm_auto_temp(struct device *dev, 908 struct device_attribute *devattr, 909 const char *buf, 910 size_t count) 911 { 912 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 913 struct i2c_client *client = to_i2c_client(dev); 914 struct adt7470_data *data = i2c_get_clientdata(client); 915 int pwm_auto_reg = ADT7470_REG_PWM_AUTO_TEMP(attr->index); 916 long temp; 917 u8 reg; 918 919 if (strict_strtol(buf, 10, &temp)) 920 return -EINVAL; 921 922 temp = cvt_auto_temp(temp); 923 if (temp < 0) 924 return temp; 925 926 mutex_lock(&data->lock); 927 data->pwm_automatic[attr->index] = temp; 928 reg = i2c_smbus_read_byte_data(client, pwm_auto_reg); 929 930 if (!(attr->index % 2)) { 931 reg &= 0xF; 932 reg |= (temp << 4) & 0xF0; 933 } else { 934 reg &= 0xF0; 935 reg |= temp & 0xF; 936 } 937 938 i2c_smbus_write_byte_data(client, pwm_auto_reg, reg); 939 mutex_unlock(&data->lock); 940 941 return count; 942 } 943 944 static ssize_t show_alarm(struct device *dev, 945 struct device_attribute *devattr, 946 char *buf) 947 { 948 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 949 struct adt7470_data *data = adt7470_update_device(dev); 950 951 if (data->alarm & attr->index) 952 return sprintf(buf, "1\n"); 953 else 954 return sprintf(buf, "0\n"); 955 } 956 957 static DEVICE_ATTR(alarm_mask, S_IRUGO, show_alarm_mask, NULL); 958 static DEVICE_ATTR(num_temp_sensors, S_IWUSR | S_IRUGO, show_num_temp_sensors, 959 set_num_temp_sensors); 960 static DEVICE_ATTR(auto_update_interval, S_IWUSR | S_IRUGO, 961 show_auto_update_interval, set_auto_update_interval); 962 963 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max, 964 set_temp_max, 0); 965 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max, 966 set_temp_max, 1); 967 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_temp_max, 968 set_temp_max, 2); 969 static SENSOR_DEVICE_ATTR(temp4_max, S_IWUSR | S_IRUGO, show_temp_max, 970 set_temp_max, 3); 971 static SENSOR_DEVICE_ATTR(temp5_max, S_IWUSR | S_IRUGO, show_temp_max, 972 set_temp_max, 4); 973 static SENSOR_DEVICE_ATTR(temp6_max, S_IWUSR | S_IRUGO, show_temp_max, 974 set_temp_max, 5); 975 static SENSOR_DEVICE_ATTR(temp7_max, S_IWUSR | S_IRUGO, show_temp_max, 976 set_temp_max, 6); 977 static SENSOR_DEVICE_ATTR(temp8_max, S_IWUSR | S_IRUGO, show_temp_max, 978 set_temp_max, 7); 979 static SENSOR_DEVICE_ATTR(temp9_max, S_IWUSR | S_IRUGO, show_temp_max, 980 set_temp_max, 8); 981 static SENSOR_DEVICE_ATTR(temp10_max, S_IWUSR | S_IRUGO, show_temp_max, 982 set_temp_max, 9); 983 984 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min, 985 set_temp_min, 0); 986 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min, 987 set_temp_min, 1); 988 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_temp_min, 989 set_temp_min, 2); 990 static SENSOR_DEVICE_ATTR(temp4_min, S_IWUSR | S_IRUGO, show_temp_min, 991 set_temp_min, 3); 992 static SENSOR_DEVICE_ATTR(temp5_min, S_IWUSR | S_IRUGO, show_temp_min, 993 set_temp_min, 4); 994 static SENSOR_DEVICE_ATTR(temp6_min, S_IWUSR | S_IRUGO, show_temp_min, 995 set_temp_min, 5); 996 static SENSOR_DEVICE_ATTR(temp7_min, S_IWUSR | S_IRUGO, show_temp_min, 997 set_temp_min, 6); 998 static SENSOR_DEVICE_ATTR(temp8_min, S_IWUSR | S_IRUGO, show_temp_min, 999 set_temp_min, 7); 1000 static SENSOR_DEVICE_ATTR(temp9_min, S_IWUSR | S_IRUGO, show_temp_min, 1001 set_temp_min, 8); 1002 static SENSOR_DEVICE_ATTR(temp10_min, S_IWUSR | S_IRUGO, show_temp_min, 1003 set_temp_min, 9); 1004 1005 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0); 1006 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1); 1007 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2); 1008 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3); 1009 static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp, NULL, 4); 1010 static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO, show_temp, NULL, 5); 1011 static SENSOR_DEVICE_ATTR(temp7_input, S_IRUGO, show_temp, NULL, 6); 1012 static SENSOR_DEVICE_ATTR(temp8_input, S_IRUGO, show_temp, NULL, 7); 1013 static SENSOR_DEVICE_ATTR(temp9_input, S_IRUGO, show_temp, NULL, 8); 1014 static SENSOR_DEVICE_ATTR(temp10_input, S_IRUGO, show_temp, NULL, 9); 1015 1016 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 1017 ADT7470_R1T_ALARM); 1018 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 1019 ADT7470_R2T_ALARM); 1020 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 1021 ADT7470_R3T_ALARM); 1022 static SENSOR_DEVICE_ATTR(temp4_alarm, S_IRUGO, show_alarm, NULL, 1023 ADT7470_R4T_ALARM); 1024 static SENSOR_DEVICE_ATTR(temp5_alarm, S_IRUGO, show_alarm, NULL, 1025 ADT7470_R5T_ALARM); 1026 static SENSOR_DEVICE_ATTR(temp6_alarm, S_IRUGO, show_alarm, NULL, 1027 ADT7470_R6T_ALARM); 1028 static SENSOR_DEVICE_ATTR(temp7_alarm, S_IRUGO, show_alarm, NULL, 1029 ADT7470_R7T_ALARM); 1030 static SENSOR_DEVICE_ATTR(temp8_alarm, S_IRUGO, show_alarm, NULL, 1031 ALARM2(ADT7470_R8T_ALARM)); 1032 static SENSOR_DEVICE_ATTR(temp9_alarm, S_IRUGO, show_alarm, NULL, 1033 ALARM2(ADT7470_R9T_ALARM)); 1034 static SENSOR_DEVICE_ATTR(temp10_alarm, S_IRUGO, show_alarm, NULL, 1035 ALARM2(ADT7470_R10T_ALARM)); 1036 1037 static SENSOR_DEVICE_ATTR(fan1_max, S_IWUSR | S_IRUGO, show_fan_max, 1038 set_fan_max, 0); 1039 static SENSOR_DEVICE_ATTR(fan2_max, S_IWUSR | S_IRUGO, show_fan_max, 1040 set_fan_max, 1); 1041 static SENSOR_DEVICE_ATTR(fan3_max, S_IWUSR | S_IRUGO, show_fan_max, 1042 set_fan_max, 2); 1043 static SENSOR_DEVICE_ATTR(fan4_max, S_IWUSR | S_IRUGO, show_fan_max, 1044 set_fan_max, 3); 1045 1046 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min, 1047 set_fan_min, 0); 1048 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min, 1049 set_fan_min, 1); 1050 static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min, 1051 set_fan_min, 2); 1052 static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min, 1053 set_fan_min, 3); 1054 1055 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0); 1056 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1); 1057 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2); 1058 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3); 1059 1060 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 1061 ALARM2(ADT7470_FAN1_ALARM)); 1062 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 1063 ALARM2(ADT7470_FAN2_ALARM)); 1064 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 1065 ALARM2(ADT7470_FAN3_ALARM)); 1066 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 1067 ALARM2(ADT7470_FAN4_ALARM)); 1068 1069 static SENSOR_DEVICE_ATTR(force_pwm_max, S_IWUSR | S_IRUGO, 1070 show_force_pwm_max, set_force_pwm_max, 0); 1071 1072 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0); 1073 static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1); 1074 static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2); 1075 static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3); 1076 1077 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO, 1078 show_pwm_min, set_pwm_min, 0); 1079 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO, 1080 show_pwm_min, set_pwm_min, 1); 1081 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_pwm, S_IWUSR | S_IRUGO, 1082 show_pwm_min, set_pwm_min, 2); 1083 static SENSOR_DEVICE_ATTR(pwm4_auto_point1_pwm, S_IWUSR | S_IRUGO, 1084 show_pwm_min, set_pwm_min, 3); 1085 1086 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO, 1087 show_pwm_max, set_pwm_max, 0); 1088 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_pwm, S_IWUSR | S_IRUGO, 1089 show_pwm_max, set_pwm_max, 1); 1090 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_pwm, S_IWUSR | S_IRUGO, 1091 show_pwm_max, set_pwm_max, 2); 1092 static SENSOR_DEVICE_ATTR(pwm4_auto_point2_pwm, S_IWUSR | S_IRUGO, 1093 show_pwm_max, set_pwm_max, 3); 1094 1095 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_temp, S_IWUSR | S_IRUGO, 1096 show_pwm_tmin, set_pwm_tmin, 0); 1097 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_temp, S_IWUSR | S_IRUGO, 1098 show_pwm_tmin, set_pwm_tmin, 1); 1099 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_temp, S_IWUSR | S_IRUGO, 1100 show_pwm_tmin, set_pwm_tmin, 2); 1101 static SENSOR_DEVICE_ATTR(pwm4_auto_point1_temp, S_IWUSR | S_IRUGO, 1102 show_pwm_tmin, set_pwm_tmin, 3); 1103 1104 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_temp, S_IRUGO, show_pwm_tmax, 1105 NULL, 0); 1106 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_temp, S_IRUGO, show_pwm_tmax, 1107 NULL, 1); 1108 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_temp, S_IRUGO, show_pwm_tmax, 1109 NULL, 2); 1110 static SENSOR_DEVICE_ATTR(pwm4_auto_point2_temp, S_IRUGO, show_pwm_tmax, 1111 NULL, 3); 1112 1113 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_auto, 1114 set_pwm_auto, 0); 1115 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_auto, 1116 set_pwm_auto, 1); 1117 static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_auto, 1118 set_pwm_auto, 2); 1119 static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_auto, 1120 set_pwm_auto, 3); 1121 1122 static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IWUSR | S_IRUGO, 1123 show_pwm_auto_temp, set_pwm_auto_temp, 0); 1124 static SENSOR_DEVICE_ATTR(pwm2_auto_channels_temp, S_IWUSR | S_IRUGO, 1125 show_pwm_auto_temp, set_pwm_auto_temp, 1); 1126 static SENSOR_DEVICE_ATTR(pwm3_auto_channels_temp, S_IWUSR | S_IRUGO, 1127 show_pwm_auto_temp, set_pwm_auto_temp, 2); 1128 static SENSOR_DEVICE_ATTR(pwm4_auto_channels_temp, S_IWUSR | S_IRUGO, 1129 show_pwm_auto_temp, set_pwm_auto_temp, 3); 1130 1131 static struct attribute *adt7470_attr[] = 1132 { 1133 &dev_attr_alarm_mask.attr, 1134 &dev_attr_num_temp_sensors.attr, 1135 &dev_attr_auto_update_interval.attr, 1136 &sensor_dev_attr_temp1_max.dev_attr.attr, 1137 &sensor_dev_attr_temp2_max.dev_attr.attr, 1138 &sensor_dev_attr_temp3_max.dev_attr.attr, 1139 &sensor_dev_attr_temp4_max.dev_attr.attr, 1140 &sensor_dev_attr_temp5_max.dev_attr.attr, 1141 &sensor_dev_attr_temp6_max.dev_attr.attr, 1142 &sensor_dev_attr_temp7_max.dev_attr.attr, 1143 &sensor_dev_attr_temp8_max.dev_attr.attr, 1144 &sensor_dev_attr_temp9_max.dev_attr.attr, 1145 &sensor_dev_attr_temp10_max.dev_attr.attr, 1146 &sensor_dev_attr_temp1_min.dev_attr.attr, 1147 &sensor_dev_attr_temp2_min.dev_attr.attr, 1148 &sensor_dev_attr_temp3_min.dev_attr.attr, 1149 &sensor_dev_attr_temp4_min.dev_attr.attr, 1150 &sensor_dev_attr_temp5_min.dev_attr.attr, 1151 &sensor_dev_attr_temp6_min.dev_attr.attr, 1152 &sensor_dev_attr_temp7_min.dev_attr.attr, 1153 &sensor_dev_attr_temp8_min.dev_attr.attr, 1154 &sensor_dev_attr_temp9_min.dev_attr.attr, 1155 &sensor_dev_attr_temp10_min.dev_attr.attr, 1156 &sensor_dev_attr_temp1_input.dev_attr.attr, 1157 &sensor_dev_attr_temp2_input.dev_attr.attr, 1158 &sensor_dev_attr_temp3_input.dev_attr.attr, 1159 &sensor_dev_attr_temp4_input.dev_attr.attr, 1160 &sensor_dev_attr_temp5_input.dev_attr.attr, 1161 &sensor_dev_attr_temp6_input.dev_attr.attr, 1162 &sensor_dev_attr_temp7_input.dev_attr.attr, 1163 &sensor_dev_attr_temp8_input.dev_attr.attr, 1164 &sensor_dev_attr_temp9_input.dev_attr.attr, 1165 &sensor_dev_attr_temp10_input.dev_attr.attr, 1166 &sensor_dev_attr_temp1_alarm.dev_attr.attr, 1167 &sensor_dev_attr_temp2_alarm.dev_attr.attr, 1168 &sensor_dev_attr_temp3_alarm.dev_attr.attr, 1169 &sensor_dev_attr_temp4_alarm.dev_attr.attr, 1170 &sensor_dev_attr_temp5_alarm.dev_attr.attr, 1171 &sensor_dev_attr_temp6_alarm.dev_attr.attr, 1172 &sensor_dev_attr_temp7_alarm.dev_attr.attr, 1173 &sensor_dev_attr_temp8_alarm.dev_attr.attr, 1174 &sensor_dev_attr_temp9_alarm.dev_attr.attr, 1175 &sensor_dev_attr_temp10_alarm.dev_attr.attr, 1176 &sensor_dev_attr_fan1_max.dev_attr.attr, 1177 &sensor_dev_attr_fan2_max.dev_attr.attr, 1178 &sensor_dev_attr_fan3_max.dev_attr.attr, 1179 &sensor_dev_attr_fan4_max.dev_attr.attr, 1180 &sensor_dev_attr_fan1_min.dev_attr.attr, 1181 &sensor_dev_attr_fan2_min.dev_attr.attr, 1182 &sensor_dev_attr_fan3_min.dev_attr.attr, 1183 &sensor_dev_attr_fan4_min.dev_attr.attr, 1184 &sensor_dev_attr_fan1_input.dev_attr.attr, 1185 &sensor_dev_attr_fan2_input.dev_attr.attr, 1186 &sensor_dev_attr_fan3_input.dev_attr.attr, 1187 &sensor_dev_attr_fan4_input.dev_attr.attr, 1188 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 1189 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 1190 &sensor_dev_attr_fan3_alarm.dev_attr.attr, 1191 &sensor_dev_attr_fan4_alarm.dev_attr.attr, 1192 &sensor_dev_attr_force_pwm_max.dev_attr.attr, 1193 &sensor_dev_attr_pwm1.dev_attr.attr, 1194 &sensor_dev_attr_pwm2.dev_attr.attr, 1195 &sensor_dev_attr_pwm3.dev_attr.attr, 1196 &sensor_dev_attr_pwm4.dev_attr.attr, 1197 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr, 1198 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr, 1199 &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr, 1200 &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr, 1201 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr, 1202 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr, 1203 &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr, 1204 &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr, 1205 &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr, 1206 &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr, 1207 &sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr, 1208 &sensor_dev_attr_pwm4_auto_point1_temp.dev_attr.attr, 1209 &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr, 1210 &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr, 1211 &sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr, 1212 &sensor_dev_attr_pwm4_auto_point2_temp.dev_attr.attr, 1213 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 1214 &sensor_dev_attr_pwm2_enable.dev_attr.attr, 1215 &sensor_dev_attr_pwm3_enable.dev_attr.attr, 1216 &sensor_dev_attr_pwm4_enable.dev_attr.attr, 1217 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr, 1218 &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr, 1219 &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr, 1220 &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr, 1221 NULL 1222 }; 1223 1224 /* Return 0 if detection is successful, -ENODEV otherwise */ 1225 static int adt7470_detect(struct i2c_client *client, 1226 struct i2c_board_info *info) 1227 { 1228 struct i2c_adapter *adapter = client->adapter; 1229 int vendor, device, revision; 1230 1231 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 1232 return -ENODEV; 1233 1234 vendor = i2c_smbus_read_byte_data(client, ADT7470_REG_VENDOR); 1235 if (vendor != ADT7470_VENDOR) 1236 return -ENODEV; 1237 1238 device = i2c_smbus_read_byte_data(client, ADT7470_REG_DEVICE); 1239 if (device != ADT7470_DEVICE) 1240 return -ENODEV; 1241 1242 revision = i2c_smbus_read_byte_data(client, ADT7470_REG_REVISION); 1243 if (revision != ADT7470_REVISION) 1244 return -ENODEV; 1245 1246 strlcpy(info->type, "adt7470", I2C_NAME_SIZE); 1247 1248 return 0; 1249 } 1250 1251 static int adt7470_probe(struct i2c_client *client, 1252 const struct i2c_device_id *id) 1253 { 1254 struct adt7470_data *data; 1255 int err; 1256 1257 data = kzalloc(sizeof(struct adt7470_data), GFP_KERNEL); 1258 if (!data) { 1259 err = -ENOMEM; 1260 goto exit; 1261 } 1262 1263 data->num_temp_sensors = -1; 1264 data->auto_update_interval = AUTO_UPDATE_INTERVAL; 1265 1266 i2c_set_clientdata(client, data); 1267 mutex_init(&data->lock); 1268 1269 dev_info(&client->dev, "%s chip found\n", client->name); 1270 1271 /* Initialize the ADT7470 chip */ 1272 adt7470_init_client(client); 1273 1274 /* Register sysfs hooks */ 1275 data->attrs.attrs = adt7470_attr; 1276 if ((err = sysfs_create_group(&client->dev.kobj, &data->attrs))) 1277 goto exit_free; 1278 1279 data->hwmon_dev = hwmon_device_register(&client->dev); 1280 if (IS_ERR(data->hwmon_dev)) { 1281 err = PTR_ERR(data->hwmon_dev); 1282 goto exit_remove; 1283 } 1284 1285 init_completion(&data->auto_update_stop); 1286 data->auto_update = kthread_run(adt7470_update_thread, client, 1287 dev_name(data->hwmon_dev)); 1288 if (IS_ERR(data->auto_update)) 1289 goto exit_unregister; 1290 1291 return 0; 1292 1293 exit_unregister: 1294 hwmon_device_unregister(data->hwmon_dev); 1295 exit_remove: 1296 sysfs_remove_group(&client->dev.kobj, &data->attrs); 1297 exit_free: 1298 kfree(data); 1299 exit: 1300 return err; 1301 } 1302 1303 static int adt7470_remove(struct i2c_client *client) 1304 { 1305 struct adt7470_data *data = i2c_get_clientdata(client); 1306 1307 kthread_stop(data->auto_update); 1308 wait_for_completion(&data->auto_update_stop); 1309 hwmon_device_unregister(data->hwmon_dev); 1310 sysfs_remove_group(&client->dev.kobj, &data->attrs); 1311 kfree(data); 1312 return 0; 1313 } 1314 1315 static int __init adt7470_init(void) 1316 { 1317 return i2c_add_driver(&adt7470_driver); 1318 } 1319 1320 static void __exit adt7470_exit(void) 1321 { 1322 i2c_del_driver(&adt7470_driver); 1323 } 1324 1325 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>"); 1326 MODULE_DESCRIPTION("ADT7470 driver"); 1327 MODULE_LICENSE("GPL"); 1328 1329 module_init(adt7470_init); 1330 module_exit(adt7470_exit); 1331