1/* 2 * adm9240.c Part of lm_sensors, Linux kernel modules for hardware 3 * monitoring 4 * 5 * Copyright (C) 1999 Frodo Looijaard <frodol@dds.nl> 6 * Philip Edelbrock <phil@netroedge.com> 7 * Copyright (C) 2003 Michiel Rook <michiel@grendelproject.nl> 8 * Copyright (C) 2005 Grant Coady <gcoady.lk@gmail.com> with valuable 9 * guidance from Jean Delvare 10 * 11 * Driver supports Analog Devices ADM9240 12 * Dallas Semiconductor DS1780 13 * National Semiconductor LM81 14 * 15 * ADM9240 is the reference, DS1780 and LM81 are register compatibles 16 * 17 * Voltage Six inputs are scaled by chip, VID also reported 18 * Temperature Chip temperature to 0.5'C, maximum and max_hysteris 19 * Fans 2 fans, low speed alarm, automatic fan clock divider 20 * Alarms 16-bit map of active alarms 21 * Analog Out 0..1250 mV output 22 * 23 * Chassis Intrusion: clear CI latch with 'echo 1 > chassis_clear' 24 * 25 * Test hardware: Intel SE440BX-2 desktop motherboard --Grant 26 * 27 * LM81 extended temp reading not implemented 28 * 29 * This program is free software; you can redistribute it and/or modify 30 * it under the terms of the GNU General Public License as published by 31 * the Free Software Foundation; either version 2 of the License, or 32 * (at your option) any later version. 33 * 34 * This program is distributed in the hope that it will be useful, 35 * but WITHOUT ANY WARRANTY; without even the implied warranty of 36 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 37 * GNU General Public License for more details. 38 * 39 * You should have received a copy of the GNU General Public License 40 * along with this program; if not, write to the Free Software 41 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 42 */ 43 44#include <linux/init.h> 45#include <linux/module.h> 46#include <linux/slab.h> 47#include <linux/i2c.h> 48#include <linux/hwmon-sysfs.h> 49#include <linux/hwmon.h> 50#include <linux/hwmon-vid.h> 51#include <linux/err.h> 52#include <linux/mutex.h> 53 54/* Addresses to scan */ 55static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, 56 I2C_CLIENT_END }; 57 58enum chips { adm9240, ds1780, lm81 }; 59 60/* ADM9240 registers */ 61#define ADM9240_REG_MAN_ID 0x3e 62#define ADM9240_REG_DIE_REV 0x3f 63#define ADM9240_REG_CONFIG 0x40 64 65#define ADM9240_REG_IN(nr) (0x20 + (nr)) /* 0..5 */ 66#define ADM9240_REG_IN_MAX(nr) (0x2b + (nr) * 2) 67#define ADM9240_REG_IN_MIN(nr) (0x2c + (nr) * 2) 68#define ADM9240_REG_FAN(nr) (0x28 + (nr)) /* 0..1 */ 69#define ADM9240_REG_FAN_MIN(nr) (0x3b + (nr)) 70#define ADM9240_REG_INT(nr) (0x41 + (nr)) 71#define ADM9240_REG_INT_MASK(nr) (0x43 + (nr)) 72#define ADM9240_REG_TEMP 0x27 73#define ADM9240_REG_TEMP_MAX(nr) (0x39 + (nr)) /* 0, 1 = high, hyst */ 74#define ADM9240_REG_ANALOG_OUT 0x19 75#define ADM9240_REG_CHASSIS_CLEAR 0x46 76#define ADM9240_REG_VID_FAN_DIV 0x47 77#define ADM9240_REG_I2C_ADDR 0x48 78#define ADM9240_REG_VID4 0x49 79#define ADM9240_REG_TEMP_CONF 0x4b 80 81/* generalised scaling with integer rounding */ 82static inline int SCALE(long val, int mul, int div) 83{ 84 if (val < 0) 85 return (val * mul - div / 2) / div; 86 else 87 return (val * mul + div / 2) / div; 88} 89 90/* adm9240 internally scales voltage measurements */ 91static const u16 nom_mv[] = { 2500, 2700, 3300, 5000, 12000, 2700 }; 92 93static inline unsigned int IN_FROM_REG(u8 reg, int n) 94{ 95 return SCALE(reg, nom_mv[n], 192); 96} 97 98static inline u8 IN_TO_REG(unsigned long val, int n) 99{ 100 return SENSORS_LIMIT(SCALE(val, 192, nom_mv[n]), 0, 255); 101} 102 103/* temperature range: -40..125, 127 disables temperature alarm */ 104static inline s8 TEMP_TO_REG(long val) 105{ 106 return SENSORS_LIMIT(SCALE(val, 1, 1000), -40, 127); 107} 108 109/* two fans, each with low fan speed limit */ 110static inline unsigned int FAN_FROM_REG(u8 reg, u8 div) 111{ 112 if (!reg) /* error */ 113 return -1; 114 115 if (reg == 255) 116 return 0; 117 118 return SCALE(1350000, 1, reg * div); 119} 120 121/* analog out 0..1250mV */ 122static inline u8 AOUT_TO_REG(unsigned long val) 123{ 124 return SENSORS_LIMIT(SCALE(val, 255, 1250), 0, 255); 125} 126 127static inline unsigned int AOUT_FROM_REG(u8 reg) 128{ 129 return SCALE(reg, 1250, 255); 130} 131 132static int adm9240_probe(struct i2c_client *client, 133 const struct i2c_device_id *id); 134static int adm9240_detect(struct i2c_client *client, 135 struct i2c_board_info *info); 136static void adm9240_init_client(struct i2c_client *client); 137static int adm9240_remove(struct i2c_client *client); 138static struct adm9240_data *adm9240_update_device(struct device *dev); 139 140/* driver data */ 141static const struct i2c_device_id adm9240_id[] = { 142 { "adm9240", adm9240 }, 143 { "ds1780", ds1780 }, 144 { "lm81", lm81 }, 145 { } 146}; 147MODULE_DEVICE_TABLE(i2c, adm9240_id); 148 149static struct i2c_driver adm9240_driver = { 150 .class = I2C_CLASS_HWMON, 151 .driver = { 152 .name = "adm9240", 153 }, 154 .probe = adm9240_probe, 155 .remove = adm9240_remove, 156 .id_table = adm9240_id, 157 .detect = adm9240_detect, 158 .address_list = normal_i2c, 159}; 160 161/* per client data */ 162struct adm9240_data { 163 struct device *hwmon_dev; 164 struct mutex update_lock; 165 char valid; 166 unsigned long last_updated_measure; 167 unsigned long last_updated_config; 168 169 u8 in[6]; /* ro in0_input */ 170 u8 in_max[6]; /* rw in0_max */ 171 u8 in_min[6]; /* rw in0_min */ 172 u8 fan[2]; /* ro fan1_input */ 173 u8 fan_min[2]; /* rw fan1_min */ 174 u8 fan_div[2]; /* rw fan1_div, read-only accessor */ 175 s16 temp; /* ro temp1_input, 9-bit sign-extended */ 176 s8 temp_max[2]; /* rw 0 -> temp_max, 1 -> temp_max_hyst */ 177 u16 alarms; /* ro alarms */ 178 u8 aout; /* rw aout_output */ 179 u8 vid; /* ro vid */ 180 u8 vrm; /* -- vrm set on startup, no accessor */ 181}; 182 183/*** sysfs accessors ***/ 184 185/* temperature */ 186static ssize_t show_temp(struct device *dev, struct device_attribute *dummy, 187 char *buf) 188{ 189 struct adm9240_data *data = adm9240_update_device(dev); 190 return sprintf(buf, "%d\n", data->temp * 500); /* 9-bit value */ 191} 192 193static ssize_t show_max(struct device *dev, struct device_attribute *devattr, 194 char *buf) 195{ 196 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 197 struct adm9240_data *data = adm9240_update_device(dev); 198 return sprintf(buf, "%d\n", data->temp_max[attr->index] * 1000); 199} 200 201static ssize_t set_max(struct device *dev, struct device_attribute *devattr, 202 const char *buf, size_t count) 203{ 204 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 205 struct i2c_client *client = to_i2c_client(dev); 206 struct adm9240_data *data = i2c_get_clientdata(client); 207 long val = simple_strtol(buf, NULL, 10); 208 209 mutex_lock(&data->update_lock); 210 data->temp_max[attr->index] = TEMP_TO_REG(val); 211 i2c_smbus_write_byte_data(client, ADM9240_REG_TEMP_MAX(attr->index), 212 data->temp_max[attr->index]); 213 mutex_unlock(&data->update_lock); 214 return count; 215} 216 217static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL); 218static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, 219 show_max, set_max, 0); 220static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, 221 show_max, set_max, 1); 222 223/* voltage */ 224static ssize_t show_in(struct device *dev, struct device_attribute *devattr, 225 char *buf) 226{ 227 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 228 struct adm9240_data *data = adm9240_update_device(dev); 229 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index], 230 attr->index)); 231} 232 233static ssize_t show_in_min(struct device *dev, 234 struct device_attribute *devattr, char *buf) 235{ 236 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 237 struct adm9240_data *data = adm9240_update_device(dev); 238 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index], 239 attr->index)); 240} 241 242static ssize_t show_in_max(struct device *dev, 243 struct device_attribute *devattr, char *buf) 244{ 245 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 246 struct adm9240_data *data = adm9240_update_device(dev); 247 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index], 248 attr->index)); 249} 250 251static ssize_t set_in_min(struct device *dev, 252 struct device_attribute *devattr, 253 const char *buf, size_t count) 254{ 255 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 256 struct i2c_client *client = to_i2c_client(dev); 257 struct adm9240_data *data = i2c_get_clientdata(client); 258 unsigned long val = simple_strtoul(buf, NULL, 10); 259 260 mutex_lock(&data->update_lock); 261 data->in_min[attr->index] = IN_TO_REG(val, attr->index); 262 i2c_smbus_write_byte_data(client, ADM9240_REG_IN_MIN(attr->index), 263 data->in_min[attr->index]); 264 mutex_unlock(&data->update_lock); 265 return count; 266} 267 268static ssize_t set_in_max(struct device *dev, 269 struct device_attribute *devattr, 270 const char *buf, size_t count) 271{ 272 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 273 struct i2c_client *client = to_i2c_client(dev); 274 struct adm9240_data *data = i2c_get_clientdata(client); 275 unsigned long val = simple_strtoul(buf, NULL, 10); 276 277 mutex_lock(&data->update_lock); 278 data->in_max[attr->index] = IN_TO_REG(val, attr->index); 279 i2c_smbus_write_byte_data(client, ADM9240_REG_IN_MAX(attr->index), 280 data->in_max[attr->index]); 281 mutex_unlock(&data->update_lock); 282 return count; 283} 284 285#define vin(nr) \ 286static SENSOR_DEVICE_ATTR(in##nr##_input, S_IRUGO, \ 287 show_in, NULL, nr); \ 288static SENSOR_DEVICE_ATTR(in##nr##_min, S_IRUGO | S_IWUSR, \ 289 show_in_min, set_in_min, nr); \ 290static SENSOR_DEVICE_ATTR(in##nr##_max, S_IRUGO | S_IWUSR, \ 291 show_in_max, set_in_max, nr); 292 293vin(0); 294vin(1); 295vin(2); 296vin(3); 297vin(4); 298vin(5); 299 300/* fans */ 301static ssize_t show_fan(struct device *dev, 302 struct device_attribute *devattr, char *buf) 303{ 304 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 305 struct adm9240_data *data = adm9240_update_device(dev); 306 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[attr->index], 307 1 << data->fan_div[attr->index])); 308} 309 310static ssize_t show_fan_min(struct device *dev, 311 struct device_attribute *devattr, char *buf) 312{ 313 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 314 struct adm9240_data *data = adm9240_update_device(dev); 315 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[attr->index], 316 1 << data->fan_div[attr->index])); 317} 318 319static ssize_t show_fan_div(struct device *dev, 320 struct device_attribute *devattr, char *buf) 321{ 322 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 323 struct adm9240_data *data = adm9240_update_device(dev); 324 return sprintf(buf, "%d\n", 1 << data->fan_div[attr->index]); 325} 326 327/* write new fan div, callers must hold data->update_lock */ 328static void adm9240_write_fan_div(struct i2c_client *client, int nr, 329 u8 fan_div) 330{ 331 u8 reg, old, shift = (nr + 2) * 2; 332 333 reg = i2c_smbus_read_byte_data(client, ADM9240_REG_VID_FAN_DIV); 334 old = (reg >> shift) & 3; 335 reg &= ~(3 << shift); 336 reg |= (fan_div << shift); 337 i2c_smbus_write_byte_data(client, ADM9240_REG_VID_FAN_DIV, reg); 338 dev_dbg(&client->dev, "fan%d clock divider changed from %u " 339 "to %u\n", nr + 1, 1 << old, 1 << fan_div); 340} 341 342/* 343 * set fan speed low limit: 344 * 345 * - value is zero: disable fan speed low limit alarm 346 * 347 * - value is below fan speed measurement range: enable fan speed low 348 * limit alarm to be asserted while fan speed too slow to measure 349 * 350 * - otherwise: select fan clock divider to suit fan speed low limit, 351 * measurement code may adjust registers to ensure fan speed reading 352 */ 353static ssize_t set_fan_min(struct device *dev, 354 struct device_attribute *devattr, 355 const char *buf, size_t count) 356{ 357 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 358 struct i2c_client *client = to_i2c_client(dev); 359 struct adm9240_data *data = i2c_get_clientdata(client); 360 unsigned long val = simple_strtoul(buf, NULL, 10); 361 int nr = attr->index; 362 u8 new_div; 363 364 mutex_lock(&data->update_lock); 365 366 if (!val) { 367 data->fan_min[nr] = 255; 368 new_div = data->fan_div[nr]; 369 370 dev_dbg(&client->dev, "fan%u low limit set disabled\n", 371 nr + 1); 372 373 } else if (val < 1350000 / (8 * 254)) { 374 new_div = 3; 375 data->fan_min[nr] = 254; 376 377 dev_dbg(&client->dev, "fan%u low limit set minimum %u\n", 378 nr + 1, FAN_FROM_REG(254, 1 << new_div)); 379 380 } else { 381 unsigned int new_min = 1350000 / val; 382 383 new_div = 0; 384 while (new_min > 192 && new_div < 3) { 385 new_div++; 386 new_min /= 2; 387 } 388 if (!new_min) /* keep > 0 */ 389 new_min++; 390 391 data->fan_min[nr] = new_min; 392 393 dev_dbg(&client->dev, "fan%u low limit set fan speed %u\n", 394 nr + 1, FAN_FROM_REG(new_min, 1 << new_div)); 395 } 396 397 if (new_div != data->fan_div[nr]) { 398 data->fan_div[nr] = new_div; 399 adm9240_write_fan_div(client, nr, new_div); 400 } 401 i2c_smbus_write_byte_data(client, ADM9240_REG_FAN_MIN(nr), 402 data->fan_min[nr]); 403 404 mutex_unlock(&data->update_lock); 405 return count; 406} 407 408#define fan(nr) \ 409static SENSOR_DEVICE_ATTR(fan##nr##_input, S_IRUGO, \ 410 show_fan, NULL, nr - 1); \ 411static SENSOR_DEVICE_ATTR(fan##nr##_div, S_IRUGO, \ 412 show_fan_div, NULL, nr - 1); \ 413static SENSOR_DEVICE_ATTR(fan##nr##_min, S_IRUGO | S_IWUSR, \ 414 show_fan_min, set_fan_min, nr - 1); 415 416fan(1); 417fan(2); 418 419/* alarms */ 420static ssize_t show_alarms(struct device *dev, 421 struct device_attribute *attr, char *buf) 422{ 423 struct adm9240_data *data = adm9240_update_device(dev); 424 return sprintf(buf, "%u\n", data->alarms); 425} 426static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 427 428static ssize_t show_alarm(struct device *dev, 429 struct device_attribute *attr, char *buf) 430{ 431 int bitnr = to_sensor_dev_attr(attr)->index; 432 struct adm9240_data *data = adm9240_update_device(dev); 433 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1); 434} 435static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0); 436static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1); 437static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2); 438static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3); 439static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8); 440static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9); 441static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4); 442static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6); 443static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7); 444 445/* vid */ 446static ssize_t show_vid(struct device *dev, 447 struct device_attribute *attr, char *buf) 448{ 449 struct adm9240_data *data = adm9240_update_device(dev); 450 return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm)); 451} 452static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL); 453 454/* analog output */ 455static ssize_t show_aout(struct device *dev, 456 struct device_attribute *attr, char *buf) 457{ 458 struct adm9240_data *data = adm9240_update_device(dev); 459 return sprintf(buf, "%d\n", AOUT_FROM_REG(data->aout)); 460} 461 462static ssize_t set_aout(struct device *dev, 463 struct device_attribute *attr, 464 const char *buf, size_t count) 465{ 466 struct i2c_client *client = to_i2c_client(dev); 467 struct adm9240_data *data = i2c_get_clientdata(client); 468 unsigned long val = simple_strtol(buf, NULL, 10); 469 470 mutex_lock(&data->update_lock); 471 data->aout = AOUT_TO_REG(val); 472 i2c_smbus_write_byte_data(client, ADM9240_REG_ANALOG_OUT, data->aout); 473 mutex_unlock(&data->update_lock); 474 return count; 475} 476static DEVICE_ATTR(aout_output, S_IRUGO | S_IWUSR, show_aout, set_aout); 477 478/* chassis_clear */ 479static ssize_t chassis_clear(struct device *dev, 480 struct device_attribute *attr, 481 const char *buf, size_t count) 482{ 483 struct i2c_client *client = to_i2c_client(dev); 484 unsigned long val = simple_strtol(buf, NULL, 10); 485 486 if (val == 1) { 487 i2c_smbus_write_byte_data(client, 488 ADM9240_REG_CHASSIS_CLEAR, 0x80); 489 dev_dbg(&client->dev, "chassis intrusion latch cleared\n"); 490 } 491 return count; 492} 493static DEVICE_ATTR(chassis_clear, S_IWUSR, NULL, chassis_clear); 494 495static struct attribute *adm9240_attributes[] = { 496 &sensor_dev_attr_in0_input.dev_attr.attr, 497 &sensor_dev_attr_in0_min.dev_attr.attr, 498 &sensor_dev_attr_in0_max.dev_attr.attr, 499 &sensor_dev_attr_in0_alarm.dev_attr.attr, 500 &sensor_dev_attr_in1_input.dev_attr.attr, 501 &sensor_dev_attr_in1_min.dev_attr.attr, 502 &sensor_dev_attr_in1_max.dev_attr.attr, 503 &sensor_dev_attr_in1_alarm.dev_attr.attr, 504 &sensor_dev_attr_in2_input.dev_attr.attr, 505 &sensor_dev_attr_in2_min.dev_attr.attr, 506 &sensor_dev_attr_in2_max.dev_attr.attr, 507 &sensor_dev_attr_in2_alarm.dev_attr.attr, 508 &sensor_dev_attr_in3_input.dev_attr.attr, 509 &sensor_dev_attr_in3_min.dev_attr.attr, 510 &sensor_dev_attr_in3_max.dev_attr.attr, 511 &sensor_dev_attr_in3_alarm.dev_attr.attr, 512 &sensor_dev_attr_in4_input.dev_attr.attr, 513 &sensor_dev_attr_in4_min.dev_attr.attr, 514 &sensor_dev_attr_in4_max.dev_attr.attr, 515 &sensor_dev_attr_in4_alarm.dev_attr.attr, 516 &sensor_dev_attr_in5_input.dev_attr.attr, 517 &sensor_dev_attr_in5_min.dev_attr.attr, 518 &sensor_dev_attr_in5_max.dev_attr.attr, 519 &sensor_dev_attr_in5_alarm.dev_attr.attr, 520 &dev_attr_temp1_input.attr, 521 &sensor_dev_attr_temp1_max.dev_attr.attr, 522 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, 523 &sensor_dev_attr_temp1_alarm.dev_attr.attr, 524 &sensor_dev_attr_fan1_input.dev_attr.attr, 525 &sensor_dev_attr_fan1_div.dev_attr.attr, 526 &sensor_dev_attr_fan1_min.dev_attr.attr, 527 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 528 &sensor_dev_attr_fan2_input.dev_attr.attr, 529 &sensor_dev_attr_fan2_div.dev_attr.attr, 530 &sensor_dev_attr_fan2_min.dev_attr.attr, 531 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 532 &dev_attr_alarms.attr, 533 &dev_attr_aout_output.attr, 534 &dev_attr_chassis_clear.attr, 535 &dev_attr_cpu0_vid.attr, 536 NULL 537}; 538 539static const struct attribute_group adm9240_group = { 540 .attrs = adm9240_attributes, 541}; 542 543 544/*** sensor chip detect and driver install ***/ 545 546/* Return 0 if detection is successful, -ENODEV otherwise */ 547static int adm9240_detect(struct i2c_client *new_client, 548 struct i2c_board_info *info) 549{ 550 struct i2c_adapter *adapter = new_client->adapter; 551 const char *name = ""; 552 int address = new_client->addr; 553 u8 man_id, die_rev; 554 555 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 556 return -ENODEV; 557 558 /* verify chip: reg address should match i2c address */ 559 if (i2c_smbus_read_byte_data(new_client, ADM9240_REG_I2C_ADDR) 560 != address) { 561 dev_err(&adapter->dev, "detect fail: address match, 0x%02x\n", 562 address); 563 return -ENODEV; 564 } 565 566 /* check known chip manufacturer */ 567 man_id = i2c_smbus_read_byte_data(new_client, ADM9240_REG_MAN_ID); 568 if (man_id == 0x23) { 569 name = "adm9240"; 570 } else if (man_id == 0xda) { 571 name = "ds1780"; 572 } else if (man_id == 0x01) { 573 name = "lm81"; 574 } else { 575 dev_err(&adapter->dev, "detect fail: unknown manuf, 0x%02x\n", 576 man_id); 577 return -ENODEV; 578 } 579 580 /* successful detect, print chip info */ 581 die_rev = i2c_smbus_read_byte_data(new_client, ADM9240_REG_DIE_REV); 582 dev_info(&adapter->dev, "found %s revision %u\n", 583 man_id == 0x23 ? "ADM9240" : 584 man_id == 0xda ? "DS1780" : "LM81", die_rev); 585 586 strlcpy(info->type, name, I2C_NAME_SIZE); 587 588 return 0; 589} 590 591static int adm9240_probe(struct i2c_client *new_client, 592 const struct i2c_device_id *id) 593{ 594 struct adm9240_data *data; 595 int err; 596 597 data = kzalloc(sizeof(*data), GFP_KERNEL); 598 if (!data) { 599 err = -ENOMEM; 600 goto exit; 601 } 602 603 i2c_set_clientdata(new_client, data); 604 mutex_init(&data->update_lock); 605 606 adm9240_init_client(new_client); 607 608 /* populate sysfs filesystem */ 609 if ((err = sysfs_create_group(&new_client->dev.kobj, &adm9240_group))) 610 goto exit_free; 611 612 data->hwmon_dev = hwmon_device_register(&new_client->dev); 613 if (IS_ERR(data->hwmon_dev)) { 614 err = PTR_ERR(data->hwmon_dev); 615 goto exit_remove; 616 } 617 618 return 0; 619 620exit_remove: 621 sysfs_remove_group(&new_client->dev.kobj, &adm9240_group); 622exit_free: 623 kfree(data); 624exit: 625 return err; 626} 627 628static int adm9240_remove(struct i2c_client *client) 629{ 630 struct adm9240_data *data = i2c_get_clientdata(client); 631 632 hwmon_device_unregister(data->hwmon_dev); 633 sysfs_remove_group(&client->dev.kobj, &adm9240_group); 634 635 kfree(data); 636 return 0; 637} 638 639static void adm9240_init_client(struct i2c_client *client) 640{ 641 struct adm9240_data *data = i2c_get_clientdata(client); 642 u8 conf = i2c_smbus_read_byte_data(client, ADM9240_REG_CONFIG); 643 u8 mode = i2c_smbus_read_byte_data(client, ADM9240_REG_TEMP_CONF) & 3; 644 645 data->vrm = vid_which_vrm(); /* need this to report vid as mV */ 646 647 dev_info(&client->dev, "Using VRM: %d.%d\n", data->vrm / 10, 648 data->vrm % 10); 649 650 if (conf & 1) { /* measurement cycle running: report state */ 651 652 dev_info(&client->dev, "status: config 0x%02x mode %u\n", 653 conf, mode); 654 655 } else { /* cold start: open limits before starting chip */ 656 int i; 657 658 for (i = 0; i < 6; i++) 659 { 660 i2c_smbus_write_byte_data(client, 661 ADM9240_REG_IN_MIN(i), 0); 662 i2c_smbus_write_byte_data(client, 663 ADM9240_REG_IN_MAX(i), 255); 664 } 665 i2c_smbus_write_byte_data(client, 666 ADM9240_REG_FAN_MIN(0), 255); 667 i2c_smbus_write_byte_data(client, 668 ADM9240_REG_FAN_MIN(1), 255); 669 i2c_smbus_write_byte_data(client, 670 ADM9240_REG_TEMP_MAX(0), 127); 671 i2c_smbus_write_byte_data(client, 672 ADM9240_REG_TEMP_MAX(1), 127); 673 674 /* start measurement cycle */ 675 i2c_smbus_write_byte_data(client, ADM9240_REG_CONFIG, 1); 676 677 dev_info(&client->dev, "cold start: config was 0x%02x " 678 "mode %u\n", conf, mode); 679 } 680} 681 682static struct adm9240_data *adm9240_update_device(struct device *dev) 683{ 684 struct i2c_client *client = to_i2c_client(dev); 685 struct adm9240_data *data = i2c_get_clientdata(client); 686 int i; 687 688 mutex_lock(&data->update_lock); 689 690 /* minimum measurement cycle: 1.75 seconds */ 691 if (time_after(jiffies, data->last_updated_measure + (HZ * 7 / 4)) 692 || !data->valid) { 693 694 for (i = 0; i < 6; i++) /* read voltages */ 695 { 696 data->in[i] = i2c_smbus_read_byte_data(client, 697 ADM9240_REG_IN(i)); 698 } 699 data->alarms = i2c_smbus_read_byte_data(client, 700 ADM9240_REG_INT(0)) | 701 i2c_smbus_read_byte_data(client, 702 ADM9240_REG_INT(1)) << 8; 703 704 /* read temperature: assume temperature changes less than 705 * 0.5'C per two measurement cycles thus ignore possible 706 * but unlikely aliasing error on lsb reading. --Grant */ 707 data->temp = ((i2c_smbus_read_byte_data(client, 708 ADM9240_REG_TEMP) << 8) | 709 i2c_smbus_read_byte_data(client, 710 ADM9240_REG_TEMP_CONF)) / 128; 711 712 for (i = 0; i < 2; i++) /* read fans */ 713 { 714 data->fan[i] = i2c_smbus_read_byte_data(client, 715 ADM9240_REG_FAN(i)); 716 717 /* adjust fan clock divider on overflow */ 718 if (data->valid && data->fan[i] == 255 && 719 data->fan_div[i] < 3) { 720 721 adm9240_write_fan_div(client, i, 722 ++data->fan_div[i]); 723 724 /* adjust fan_min if active, but not to 0 */ 725 if (data->fan_min[i] < 255 && 726 data->fan_min[i] >= 2) 727 data->fan_min[i] /= 2; 728 } 729 } 730 data->last_updated_measure = jiffies; 731 } 732 733 /* minimum config reading cycle: 300 seconds */ 734 if (time_after(jiffies, data->last_updated_config + (HZ * 300)) 735 || !data->valid) { 736 737 for (i = 0; i < 6; i++) 738 { 739 data->in_min[i] = i2c_smbus_read_byte_data(client, 740 ADM9240_REG_IN_MIN(i)); 741 data->in_max[i] = i2c_smbus_read_byte_data(client, 742 ADM9240_REG_IN_MAX(i)); 743 } 744 for (i = 0; i < 2; i++) 745 { 746 data->fan_min[i] = i2c_smbus_read_byte_data(client, 747 ADM9240_REG_FAN_MIN(i)); 748 } 749 data->temp_max[0] = i2c_smbus_read_byte_data(client, 750 ADM9240_REG_TEMP_MAX(0)); 751 data->temp_max[1] = i2c_smbus_read_byte_data(client, 752 ADM9240_REG_TEMP_MAX(1)); 753 754 /* read fan divs and 5-bit VID */ 755 i = i2c_smbus_read_byte_data(client, ADM9240_REG_VID_FAN_DIV); 756 data->fan_div[0] = (i >> 4) & 3; 757 data->fan_div[1] = (i >> 6) & 3; 758 data->vid = i & 0x0f; 759 data->vid |= (i2c_smbus_read_byte_data(client, 760 ADM9240_REG_VID4) & 1) << 4; 761 /* read analog out */ 762 data->aout = i2c_smbus_read_byte_data(client, 763 ADM9240_REG_ANALOG_OUT); 764 765 data->last_updated_config = jiffies; 766 data->valid = 1; 767 } 768 mutex_unlock(&data->update_lock); 769 return data; 770} 771 772static int __init sensors_adm9240_init(void) 773{ 774 return i2c_add_driver(&adm9240_driver); 775} 776 777static void __exit sensors_adm9240_exit(void) 778{ 779 i2c_del_driver(&adm9240_driver); 780} 781 782MODULE_AUTHOR("Michiel Rook <michiel@grendelproject.nl>, " 783 "Grant Coady <gcoady.lk@gmail.com> and others"); 784MODULE_DESCRIPTION("ADM9240/DS1780/LM81 driver"); 785MODULE_LICENSE("GPL"); 786 787module_init(sensors_adm9240_init); 788module_exit(sensors_adm9240_exit); 789