1 /* 2 * lm80.c - From lm_sensors, Linux kernel modules for hardware 3 * monitoring 4 * Copyright (C) 1998, 1999 Frodo Looijaard <frodol@dds.nl> 5 * and Philip Edelbrock <phil@netroedge.com> 6 * 7 * Ported to Linux 2.6 by Tiago Sousa <mirage@kaotik.org> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 */ 23 24 #include <linux/module.h> 25 #include <linux/init.h> 26 #include <linux/slab.h> 27 #include <linux/jiffies.h> 28 #include <linux/i2c.h> 29 #include <linux/hwmon.h> 30 #include <linux/hwmon-sysfs.h> 31 #include <linux/err.h> 32 #include <linux/mutex.h> 33 34 /* Addresses to scan */ 35 static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 36 0x2e, 0x2f, I2C_CLIENT_END }; 37 38 /* Many LM80 constants specified below */ 39 40 /* The LM80 registers */ 41 #define LM80_REG_IN_MAX(nr) (0x2a + (nr) * 2) 42 #define LM80_REG_IN_MIN(nr) (0x2b + (nr) * 2) 43 #define LM80_REG_IN(nr) (0x20 + (nr)) 44 45 #define LM80_REG_FAN1 0x28 46 #define LM80_REG_FAN2 0x29 47 #define LM80_REG_FAN_MIN(nr) (0x3b + (nr)) 48 49 #define LM80_REG_TEMP 0x27 50 #define LM80_REG_TEMP_HOT_MAX 0x38 51 #define LM80_REG_TEMP_HOT_HYST 0x39 52 #define LM80_REG_TEMP_OS_MAX 0x3a 53 #define LM80_REG_TEMP_OS_HYST 0x3b 54 55 #define LM80_REG_CONFIG 0x00 56 #define LM80_REG_ALARM1 0x01 57 #define LM80_REG_ALARM2 0x02 58 #define LM80_REG_MASK1 0x03 59 #define LM80_REG_MASK2 0x04 60 #define LM80_REG_FANDIV 0x05 61 #define LM80_REG_RES 0x06 62 63 #define LM96080_REG_CONV_RATE 0x07 64 #define LM96080_REG_MAN_ID 0x3e 65 #define LM96080_REG_DEV_ID 0x3f 66 67 68 /* 69 * Conversions. Rounding and limit checking is only done on the TO_REG 70 * variants. Note that you should be a bit careful with which arguments 71 * these macros are called: arguments may be evaluated more than once. 72 * Fixing this is just not worth it. 73 */ 74 75 #define IN_TO_REG(val) (SENSORS_LIMIT(((val) + 5) / 10, 0, 255)) 76 #define IN_FROM_REG(val) ((val) * 10) 77 78 static inline unsigned char FAN_TO_REG(unsigned rpm, unsigned div) 79 { 80 if (rpm == 0) 81 return 255; 82 rpm = SENSORS_LIMIT(rpm, 1, 1000000); 83 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254); 84 } 85 86 #define FAN_FROM_REG(val, div) ((val) == 0 ? -1 : \ 87 (val) == 255 ? 0 : 1350000/((div) * (val))) 88 89 static inline long TEMP_FROM_REG(u16 temp) 90 { 91 long res; 92 93 temp >>= 4; 94 if (temp < 0x0800) 95 res = 625 * (long) temp; 96 else 97 res = ((long) temp - 0x01000) * 625; 98 99 return res / 10; 100 } 101 102 #define TEMP_LIMIT_FROM_REG(val) (((val) > 0x80 ? \ 103 (val) - 0x100 : (val)) * 1000) 104 105 #define TEMP_LIMIT_TO_REG(val) SENSORS_LIMIT((val) < 0 ? \ 106 ((val) - 500) / 1000 : ((val) + 500) / 1000, 0, 255) 107 108 #define DIV_FROM_REG(val) (1 << (val)) 109 110 /* 111 * Client data (each client gets its own) 112 */ 113 114 struct lm80_data { 115 struct device *hwmon_dev; 116 struct mutex update_lock; 117 char error; /* !=0 if error occurred during last update */ 118 char valid; /* !=0 if following fields are valid */ 119 unsigned long last_updated; /* In jiffies */ 120 121 u8 in[7]; /* Register value */ 122 u8 in_max[7]; /* Register value */ 123 u8 in_min[7]; /* Register value */ 124 u8 fan[2]; /* Register value */ 125 u8 fan_min[2]; /* Register value */ 126 u8 fan_div[2]; /* Register encoding, shifted right */ 127 u16 temp; /* Register values, shifted right */ 128 u8 temp_hot_max; /* Register value */ 129 u8 temp_hot_hyst; /* Register value */ 130 u8 temp_os_max; /* Register value */ 131 u8 temp_os_hyst; /* Register value */ 132 u16 alarms; /* Register encoding, combined */ 133 }; 134 135 /* 136 * Functions declaration 137 */ 138 139 static int lm80_probe(struct i2c_client *client, 140 const struct i2c_device_id *id); 141 static int lm80_detect(struct i2c_client *client, struct i2c_board_info *info); 142 static void lm80_init_client(struct i2c_client *client); 143 static int lm80_remove(struct i2c_client *client); 144 static struct lm80_data *lm80_update_device(struct device *dev); 145 static int lm80_read_value(struct i2c_client *client, u8 reg); 146 static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value); 147 148 /* 149 * Driver data (common to all clients) 150 */ 151 152 static const struct i2c_device_id lm80_id[] = { 153 { "lm80", 0 }, 154 { "lm96080", 1 }, 155 { } 156 }; 157 MODULE_DEVICE_TABLE(i2c, lm80_id); 158 159 static struct i2c_driver lm80_driver = { 160 .class = I2C_CLASS_HWMON, 161 .driver = { 162 .name = "lm80", 163 }, 164 .probe = lm80_probe, 165 .remove = lm80_remove, 166 .id_table = lm80_id, 167 .detect = lm80_detect, 168 .address_list = normal_i2c, 169 }; 170 171 /* 172 * Sysfs stuff 173 */ 174 175 #define show_in(suffix, value) \ 176 static ssize_t show_in_##suffix(struct device *dev, \ 177 struct device_attribute *attr, char *buf) \ 178 { \ 179 int nr = to_sensor_dev_attr(attr)->index; \ 180 struct lm80_data *data = lm80_update_device(dev); \ 181 if (IS_ERR(data)) \ 182 return PTR_ERR(data); \ 183 return sprintf(buf, "%d\n", IN_FROM_REG(data->value[nr])); \ 184 } 185 show_in(min, in_min) 186 show_in(max, in_max) 187 show_in(input, in) 188 189 #define set_in(suffix, value, reg) \ 190 static ssize_t set_in_##suffix(struct device *dev, \ 191 struct device_attribute *attr, const char *buf, size_t count) \ 192 { \ 193 int nr = to_sensor_dev_attr(attr)->index; \ 194 struct i2c_client *client = to_i2c_client(dev); \ 195 struct lm80_data *data = i2c_get_clientdata(client); \ 196 long val; \ 197 int err = kstrtol(buf, 10, &val); \ 198 if (err < 0) \ 199 return err; \ 200 \ 201 mutex_lock(&data->update_lock);\ 202 data->value[nr] = IN_TO_REG(val); \ 203 lm80_write_value(client, reg(nr), data->value[nr]); \ 204 mutex_unlock(&data->update_lock);\ 205 return count; \ 206 } 207 set_in(min, in_min, LM80_REG_IN_MIN) 208 set_in(max, in_max, LM80_REG_IN_MAX) 209 210 #define show_fan(suffix, value) \ 211 static ssize_t show_fan_##suffix(struct device *dev, \ 212 struct device_attribute *attr, char *buf) \ 213 { \ 214 int nr = to_sensor_dev_attr(attr)->index; \ 215 struct lm80_data *data = lm80_update_device(dev); \ 216 if (IS_ERR(data)) \ 217 return PTR_ERR(data); \ 218 return sprintf(buf, "%d\n", FAN_FROM_REG(data->value[nr], \ 219 DIV_FROM_REG(data->fan_div[nr]))); \ 220 } 221 show_fan(min, fan_min) 222 show_fan(input, fan) 223 224 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr, 225 char *buf) 226 { 227 int nr = to_sensor_dev_attr(attr)->index; 228 struct lm80_data *data = lm80_update_device(dev); 229 if (IS_ERR(data)) 230 return PTR_ERR(data); 231 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr])); 232 } 233 234 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, 235 const char *buf, size_t count) 236 { 237 int nr = to_sensor_dev_attr(attr)->index; 238 struct i2c_client *client = to_i2c_client(dev); 239 struct lm80_data *data = i2c_get_clientdata(client); 240 unsigned long val; 241 int err = kstrtoul(buf, 10, &val); 242 if (err < 0) 243 return err; 244 245 mutex_lock(&data->update_lock); 246 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); 247 lm80_write_value(client, LM80_REG_FAN_MIN(nr + 1), data->fan_min[nr]); 248 mutex_unlock(&data->update_lock); 249 return count; 250 } 251 252 /* 253 * Note: we save and restore the fan minimum here, because its value is 254 * determined in part by the fan divisor. This follows the principle of 255 * least surprise; the user doesn't expect the fan minimum to change just 256 * because the divisor changed. 257 */ 258 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, 259 const char *buf, size_t count) 260 { 261 int nr = to_sensor_dev_attr(attr)->index; 262 struct i2c_client *client = to_i2c_client(dev); 263 struct lm80_data *data = i2c_get_clientdata(client); 264 unsigned long min, val; 265 u8 reg; 266 int err = kstrtoul(buf, 10, &val); 267 if (err < 0) 268 return err; 269 270 /* Save fan_min */ 271 mutex_lock(&data->update_lock); 272 min = FAN_FROM_REG(data->fan_min[nr], 273 DIV_FROM_REG(data->fan_div[nr])); 274 275 switch (val) { 276 case 1: 277 data->fan_div[nr] = 0; 278 break; 279 case 2: 280 data->fan_div[nr] = 1; 281 break; 282 case 4: 283 data->fan_div[nr] = 2; 284 break; 285 case 8: 286 data->fan_div[nr] = 3; 287 break; 288 default: 289 dev_err(&client->dev, "fan_div value %ld not " 290 "supported. Choose one of 1, 2, 4 or 8!\n", val); 291 mutex_unlock(&data->update_lock); 292 return -EINVAL; 293 } 294 295 reg = (lm80_read_value(client, LM80_REG_FANDIV) & ~(3 << (2 * (nr + 1)))) 296 | (data->fan_div[nr] << (2 * (nr + 1))); 297 lm80_write_value(client, LM80_REG_FANDIV, reg); 298 299 /* Restore fan_min */ 300 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr])); 301 lm80_write_value(client, LM80_REG_FAN_MIN(nr + 1), data->fan_min[nr]); 302 mutex_unlock(&data->update_lock); 303 304 return count; 305 } 306 307 static ssize_t show_temp_input1(struct device *dev, 308 struct device_attribute *attr, char *buf) 309 { 310 struct lm80_data *data = lm80_update_device(dev); 311 if (IS_ERR(data)) 312 return PTR_ERR(data); 313 return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp)); 314 } 315 316 #define show_temp(suffix, value) \ 317 static ssize_t show_temp_##suffix(struct device *dev, \ 318 struct device_attribute *attr, char *buf) \ 319 { \ 320 struct lm80_data *data = lm80_update_device(dev); \ 321 if (IS_ERR(data)) \ 322 return PTR_ERR(data); \ 323 return sprintf(buf, "%d\n", TEMP_LIMIT_FROM_REG(data->value)); \ 324 } 325 show_temp(hot_max, temp_hot_max); 326 show_temp(hot_hyst, temp_hot_hyst); 327 show_temp(os_max, temp_os_max); 328 show_temp(os_hyst, temp_os_hyst); 329 330 #define set_temp(suffix, value, reg) \ 331 static ssize_t set_temp_##suffix(struct device *dev, \ 332 struct device_attribute *attr, const char *buf, size_t count) \ 333 { \ 334 struct i2c_client *client = to_i2c_client(dev); \ 335 struct lm80_data *data = i2c_get_clientdata(client); \ 336 long val; \ 337 int err = kstrtol(buf, 10, &val); \ 338 if (err < 0) \ 339 return err; \ 340 \ 341 mutex_lock(&data->update_lock); \ 342 data->value = TEMP_LIMIT_TO_REG(val); \ 343 lm80_write_value(client, reg, data->value); \ 344 mutex_unlock(&data->update_lock); \ 345 return count; \ 346 } 347 set_temp(hot_max, temp_hot_max, LM80_REG_TEMP_HOT_MAX); 348 set_temp(hot_hyst, temp_hot_hyst, LM80_REG_TEMP_HOT_HYST); 349 set_temp(os_max, temp_os_max, LM80_REG_TEMP_OS_MAX); 350 set_temp(os_hyst, temp_os_hyst, LM80_REG_TEMP_OS_HYST); 351 352 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, 353 char *buf) 354 { 355 struct lm80_data *data = lm80_update_device(dev); 356 if (IS_ERR(data)) 357 return PTR_ERR(data); 358 return sprintf(buf, "%u\n", data->alarms); 359 } 360 361 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, 362 char *buf) 363 { 364 int bitnr = to_sensor_dev_attr(attr)->index; 365 struct lm80_data *data = lm80_update_device(dev); 366 if (IS_ERR(data)) 367 return PTR_ERR(data); 368 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1); 369 } 370 371 static SENSOR_DEVICE_ATTR(in0_min, S_IWUSR | S_IRUGO, 372 show_in_min, set_in_min, 0); 373 static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO, 374 show_in_min, set_in_min, 1); 375 static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO, 376 show_in_min, set_in_min, 2); 377 static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO, 378 show_in_min, set_in_min, 3); 379 static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO, 380 show_in_min, set_in_min, 4); 381 static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO, 382 show_in_min, set_in_min, 5); 383 static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO, 384 show_in_min, set_in_min, 6); 385 static SENSOR_DEVICE_ATTR(in0_max, S_IWUSR | S_IRUGO, 386 show_in_max, set_in_max, 0); 387 static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO, 388 show_in_max, set_in_max, 1); 389 static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO, 390 show_in_max, set_in_max, 2); 391 static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO, 392 show_in_max, set_in_max, 3); 393 static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO, 394 show_in_max, set_in_max, 4); 395 static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO, 396 show_in_max, set_in_max, 5); 397 static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO, 398 show_in_max, set_in_max, 6); 399 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in_input, NULL, 0); 400 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in_input, NULL, 1); 401 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in_input, NULL, 2); 402 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in_input, NULL, 3); 403 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in_input, NULL, 4); 404 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_in_input, NULL, 5); 405 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_in_input, NULL, 6); 406 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, 407 show_fan_min, set_fan_min, 0); 408 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, 409 show_fan_min, set_fan_min, 1); 410 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0); 411 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1); 412 static SENSOR_DEVICE_ATTR(fan1_div, S_IWUSR | S_IRUGO, 413 show_fan_div, set_fan_div, 0); 414 static SENSOR_DEVICE_ATTR(fan2_div, S_IWUSR | S_IRUGO, 415 show_fan_div, set_fan_div, 1); 416 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input1, NULL); 417 static DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_hot_max, 418 set_temp_hot_max); 419 static DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, show_temp_hot_hyst, 420 set_temp_hot_hyst); 421 static DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp_os_max, 422 set_temp_os_max); 423 static DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temp_os_hyst, 424 set_temp_os_hyst); 425 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 426 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0); 427 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1); 428 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2); 429 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3); 430 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 4); 431 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 5); 432 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 6); 433 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 10); 434 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 11); 435 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 8); 436 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 13); 437 438 /* 439 * Real code 440 */ 441 442 static struct attribute *lm80_attributes[] = { 443 &sensor_dev_attr_in0_min.dev_attr.attr, 444 &sensor_dev_attr_in1_min.dev_attr.attr, 445 &sensor_dev_attr_in2_min.dev_attr.attr, 446 &sensor_dev_attr_in3_min.dev_attr.attr, 447 &sensor_dev_attr_in4_min.dev_attr.attr, 448 &sensor_dev_attr_in5_min.dev_attr.attr, 449 &sensor_dev_attr_in6_min.dev_attr.attr, 450 &sensor_dev_attr_in0_max.dev_attr.attr, 451 &sensor_dev_attr_in1_max.dev_attr.attr, 452 &sensor_dev_attr_in2_max.dev_attr.attr, 453 &sensor_dev_attr_in3_max.dev_attr.attr, 454 &sensor_dev_attr_in4_max.dev_attr.attr, 455 &sensor_dev_attr_in5_max.dev_attr.attr, 456 &sensor_dev_attr_in6_max.dev_attr.attr, 457 &sensor_dev_attr_in0_input.dev_attr.attr, 458 &sensor_dev_attr_in1_input.dev_attr.attr, 459 &sensor_dev_attr_in2_input.dev_attr.attr, 460 &sensor_dev_attr_in3_input.dev_attr.attr, 461 &sensor_dev_attr_in4_input.dev_attr.attr, 462 &sensor_dev_attr_in5_input.dev_attr.attr, 463 &sensor_dev_attr_in6_input.dev_attr.attr, 464 &sensor_dev_attr_fan1_min.dev_attr.attr, 465 &sensor_dev_attr_fan2_min.dev_attr.attr, 466 &sensor_dev_attr_fan1_input.dev_attr.attr, 467 &sensor_dev_attr_fan2_input.dev_attr.attr, 468 &sensor_dev_attr_fan1_div.dev_attr.attr, 469 &sensor_dev_attr_fan2_div.dev_attr.attr, 470 &dev_attr_temp1_input.attr, 471 &dev_attr_temp1_max.attr, 472 &dev_attr_temp1_max_hyst.attr, 473 &dev_attr_temp1_crit.attr, 474 &dev_attr_temp1_crit_hyst.attr, 475 &dev_attr_alarms.attr, 476 &sensor_dev_attr_in0_alarm.dev_attr.attr, 477 &sensor_dev_attr_in1_alarm.dev_attr.attr, 478 &sensor_dev_attr_in2_alarm.dev_attr.attr, 479 &sensor_dev_attr_in3_alarm.dev_attr.attr, 480 &sensor_dev_attr_in4_alarm.dev_attr.attr, 481 &sensor_dev_attr_in5_alarm.dev_attr.attr, 482 &sensor_dev_attr_in6_alarm.dev_attr.attr, 483 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 484 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 485 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 486 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 487 NULL 488 }; 489 490 static const struct attribute_group lm80_group = { 491 .attrs = lm80_attributes, 492 }; 493 494 /* Return 0 if detection is successful, -ENODEV otherwise */ 495 static int lm80_detect(struct i2c_client *client, struct i2c_board_info *info) 496 { 497 struct i2c_adapter *adapter = client->adapter; 498 int i, cur, man_id, dev_id; 499 const char *name = NULL; 500 501 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 502 return -ENODEV; 503 504 /* First check for unused bits, common to both chip types */ 505 if ((lm80_read_value(client, LM80_REG_ALARM2) & 0xc0) 506 || (lm80_read_value(client, LM80_REG_CONFIG) & 0x80)) 507 return -ENODEV; 508 509 /* 510 * The LM96080 has manufacturer and stepping/die rev registers so we 511 * can just check that. The LM80 does not have such registers so we 512 * have to use a more expensive trick. 513 */ 514 man_id = lm80_read_value(client, LM96080_REG_MAN_ID); 515 dev_id = lm80_read_value(client, LM96080_REG_DEV_ID); 516 if (man_id == 0x01 && dev_id == 0x08) { 517 /* Check more unused bits for confirmation */ 518 if (lm80_read_value(client, LM96080_REG_CONV_RATE) & 0xfe) 519 return -ENODEV; 520 521 name = "lm96080"; 522 } else { 523 /* Check 6-bit addressing */ 524 for (i = 0x2a; i <= 0x3d; i++) { 525 cur = i2c_smbus_read_byte_data(client, i); 526 if ((i2c_smbus_read_byte_data(client, i + 0x40) != cur) 527 || (i2c_smbus_read_byte_data(client, i + 0x80) != cur) 528 || (i2c_smbus_read_byte_data(client, i + 0xc0) != cur)) 529 return -ENODEV; 530 } 531 532 name = "lm80"; 533 } 534 535 strlcpy(info->type, name, I2C_NAME_SIZE); 536 537 return 0; 538 } 539 540 static int lm80_probe(struct i2c_client *client, 541 const struct i2c_device_id *id) 542 { 543 struct lm80_data *data; 544 int err; 545 546 data = devm_kzalloc(&client->dev, sizeof(struct lm80_data), GFP_KERNEL); 547 if (!data) 548 return -ENOMEM; 549 550 i2c_set_clientdata(client, data); 551 mutex_init(&data->update_lock); 552 553 /* Initialize the LM80 chip */ 554 lm80_init_client(client); 555 556 /* A few vars need to be filled upon startup */ 557 data->fan_min[0] = lm80_read_value(client, LM80_REG_FAN_MIN(1)); 558 data->fan_min[1] = lm80_read_value(client, LM80_REG_FAN_MIN(2)); 559 560 /* Register sysfs hooks */ 561 err = sysfs_create_group(&client->dev.kobj, &lm80_group); 562 if (err) 563 return err; 564 565 data->hwmon_dev = hwmon_device_register(&client->dev); 566 if (IS_ERR(data->hwmon_dev)) { 567 err = PTR_ERR(data->hwmon_dev); 568 goto error_remove; 569 } 570 571 return 0; 572 573 error_remove: 574 sysfs_remove_group(&client->dev.kobj, &lm80_group); 575 return err; 576 } 577 578 static int lm80_remove(struct i2c_client *client) 579 { 580 struct lm80_data *data = i2c_get_clientdata(client); 581 582 hwmon_device_unregister(data->hwmon_dev); 583 sysfs_remove_group(&client->dev.kobj, &lm80_group); 584 585 return 0; 586 } 587 588 static int lm80_read_value(struct i2c_client *client, u8 reg) 589 { 590 return i2c_smbus_read_byte_data(client, reg); 591 } 592 593 static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value) 594 { 595 return i2c_smbus_write_byte_data(client, reg, value); 596 } 597 598 /* Called when we have found a new LM80. */ 599 static void lm80_init_client(struct i2c_client *client) 600 { 601 /* 602 * Reset all except Watchdog values and last conversion values 603 * This sets fan-divs to 2, among others. This makes most other 604 * initializations unnecessary 605 */ 606 lm80_write_value(client, LM80_REG_CONFIG, 0x80); 607 /* Set 11-bit temperature resolution */ 608 lm80_write_value(client, LM80_REG_RES, 0x08); 609 610 /* Start monitoring */ 611 lm80_write_value(client, LM80_REG_CONFIG, 0x01); 612 } 613 614 static struct lm80_data *lm80_update_device(struct device *dev) 615 { 616 struct i2c_client *client = to_i2c_client(dev); 617 struct lm80_data *data = i2c_get_clientdata(client); 618 int i; 619 int rv; 620 int prev_rv; 621 struct lm80_data *ret = data; 622 623 mutex_lock(&data->update_lock); 624 625 if (data->error) 626 lm80_init_client(client); 627 628 if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) { 629 dev_dbg(&client->dev, "Starting lm80 update\n"); 630 for (i = 0; i <= 6; i++) { 631 rv = lm80_read_value(client, LM80_REG_IN(i)); 632 if (rv < 0) 633 goto abort; 634 data->in[i] = rv; 635 636 rv = lm80_read_value(client, LM80_REG_IN_MIN(i)); 637 if (rv < 0) 638 goto abort; 639 data->in_min[i] = rv; 640 641 rv = lm80_read_value(client, LM80_REG_IN_MAX(i)); 642 if (rv < 0) 643 goto abort; 644 data->in_max[i] = rv; 645 } 646 647 rv = lm80_read_value(client, LM80_REG_FAN1); 648 if (rv < 0) 649 goto abort; 650 data->fan[0] = rv; 651 652 rv = lm80_read_value(client, LM80_REG_FAN_MIN(1)); 653 if (rv < 0) 654 goto abort; 655 data->fan_min[0] = rv; 656 657 rv = lm80_read_value(client, LM80_REG_FAN2); 658 if (rv < 0) 659 goto abort; 660 data->fan[1] = rv; 661 662 rv = lm80_read_value(client, LM80_REG_FAN_MIN(2)); 663 if (rv < 0) 664 goto abort; 665 data->fan_min[1] = rv; 666 667 prev_rv = rv = lm80_read_value(client, LM80_REG_TEMP); 668 if (rv < 0) 669 goto abort; 670 rv = lm80_read_value(client, LM80_REG_RES); 671 if (rv < 0) 672 goto abort; 673 data->temp = (prev_rv << 8) | (rv & 0xf0); 674 675 rv = lm80_read_value(client, LM80_REG_TEMP_OS_MAX); 676 if (rv < 0) 677 goto abort; 678 data->temp_os_max = rv; 679 680 rv = lm80_read_value(client, LM80_REG_TEMP_OS_HYST); 681 if (rv < 0) 682 goto abort; 683 data->temp_os_hyst = rv; 684 685 rv = lm80_read_value(client, LM80_REG_TEMP_HOT_MAX); 686 if (rv < 0) 687 goto abort; 688 data->temp_hot_max = rv; 689 690 rv = lm80_read_value(client, LM80_REG_TEMP_HOT_HYST); 691 if (rv < 0) 692 goto abort; 693 data->temp_hot_hyst = rv; 694 695 rv = lm80_read_value(client, LM80_REG_FANDIV); 696 if (rv < 0) 697 goto abort; 698 data->fan_div[0] = (rv >> 2) & 0x03; 699 data->fan_div[1] = (rv >> 4) & 0x03; 700 701 prev_rv = rv = lm80_read_value(client, LM80_REG_ALARM1); 702 if (rv < 0) 703 goto abort; 704 rv = lm80_read_value(client, LM80_REG_ALARM2); 705 if (rv < 0) 706 goto abort; 707 data->alarms = prev_rv + (rv << 8); 708 709 data->last_updated = jiffies; 710 data->valid = 1; 711 data->error = 0; 712 } 713 goto done; 714 715 abort: 716 ret = ERR_PTR(rv); 717 data->valid = 0; 718 data->error = 1; 719 720 done: 721 mutex_unlock(&data->update_lock); 722 723 return ret; 724 } 725 726 module_i2c_driver(lm80_driver); 727 728 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and " 729 "Philip Edelbrock <phil@netroedge.com>"); 730 MODULE_DESCRIPTION("LM80 driver"); 731 MODULE_LICENSE("GPL"); 732