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) (clamp_val(((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 = clamp_val(rpm, 1, 1000000); 83 return clamp_val((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) clamp_val((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 i2c_client *client; 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 struct lm80_data *lm80_update_device(struct device *dev); 144 static int lm80_read_value(struct i2c_client *client, u8 reg); 145 static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value); 146 147 /* 148 * Driver data (common to all clients) 149 */ 150 151 static const struct i2c_device_id lm80_id[] = { 152 { "lm80", 0 }, 153 { "lm96080", 1 }, 154 { } 155 }; 156 MODULE_DEVICE_TABLE(i2c, lm80_id); 157 158 static struct i2c_driver lm80_driver = { 159 .class = I2C_CLASS_HWMON, 160 .driver = { 161 .name = "lm80", 162 }, 163 .probe = lm80_probe, 164 .id_table = lm80_id, 165 .detect = lm80_detect, 166 .address_list = normal_i2c, 167 }; 168 169 /* 170 * Sysfs stuff 171 */ 172 173 #define show_in(suffix, value) \ 174 static ssize_t show_in_##suffix(struct device *dev, \ 175 struct device_attribute *attr, char *buf) \ 176 { \ 177 int nr = to_sensor_dev_attr(attr)->index; \ 178 struct lm80_data *data = lm80_update_device(dev); \ 179 if (IS_ERR(data)) \ 180 return PTR_ERR(data); \ 181 return sprintf(buf, "%d\n", IN_FROM_REG(data->value[nr])); \ 182 } 183 show_in(min, in_min) 184 show_in(max, in_max) 185 show_in(input, in) 186 187 #define set_in(suffix, value, reg) \ 188 static ssize_t set_in_##suffix(struct device *dev, \ 189 struct device_attribute *attr, const char *buf, size_t count) \ 190 { \ 191 int nr = to_sensor_dev_attr(attr)->index; \ 192 struct lm80_data *data = dev_get_drvdata(dev); \ 193 struct i2c_client *client = data->client; \ 194 long val; \ 195 int err = kstrtol(buf, 10, &val); \ 196 if (err < 0) \ 197 return err; \ 198 \ 199 mutex_lock(&data->update_lock);\ 200 data->value[nr] = IN_TO_REG(val); \ 201 lm80_write_value(client, reg(nr), data->value[nr]); \ 202 mutex_unlock(&data->update_lock);\ 203 return count; \ 204 } 205 set_in(min, in_min, LM80_REG_IN_MIN) 206 set_in(max, in_max, LM80_REG_IN_MAX) 207 208 #define show_fan(suffix, value) \ 209 static ssize_t show_fan_##suffix(struct device *dev, \ 210 struct device_attribute *attr, char *buf) \ 211 { \ 212 int nr = to_sensor_dev_attr(attr)->index; \ 213 struct lm80_data *data = lm80_update_device(dev); \ 214 if (IS_ERR(data)) \ 215 return PTR_ERR(data); \ 216 return sprintf(buf, "%d\n", FAN_FROM_REG(data->value[nr], \ 217 DIV_FROM_REG(data->fan_div[nr]))); \ 218 } 219 show_fan(min, fan_min) 220 show_fan(input, fan) 221 222 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr, 223 char *buf) 224 { 225 int nr = to_sensor_dev_attr(attr)->index; 226 struct lm80_data *data = lm80_update_device(dev); 227 if (IS_ERR(data)) 228 return PTR_ERR(data); 229 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr])); 230 } 231 232 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, 233 const char *buf, size_t count) 234 { 235 int nr = to_sensor_dev_attr(attr)->index; 236 struct lm80_data *data = dev_get_drvdata(dev); 237 struct i2c_client *client = data->client; 238 unsigned long val; 239 int err = kstrtoul(buf, 10, &val); 240 if (err < 0) 241 return err; 242 243 mutex_lock(&data->update_lock); 244 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); 245 lm80_write_value(client, LM80_REG_FAN_MIN(nr + 1), data->fan_min[nr]); 246 mutex_unlock(&data->update_lock); 247 return count; 248 } 249 250 /* 251 * Note: we save and restore the fan minimum here, because its value is 252 * determined in part by the fan divisor. This follows the principle of 253 * least surprise; the user doesn't expect the fan minimum to change just 254 * because the divisor changed. 255 */ 256 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, 257 const char *buf, size_t count) 258 { 259 int nr = to_sensor_dev_attr(attr)->index; 260 struct lm80_data *data = dev_get_drvdata(dev); 261 struct i2c_client *client = data->client; 262 unsigned long min, val; 263 u8 reg; 264 int err = kstrtoul(buf, 10, &val); 265 if (err < 0) 266 return err; 267 268 /* Save fan_min */ 269 mutex_lock(&data->update_lock); 270 min = FAN_FROM_REG(data->fan_min[nr], 271 DIV_FROM_REG(data->fan_div[nr])); 272 273 switch (val) { 274 case 1: 275 data->fan_div[nr] = 0; 276 break; 277 case 2: 278 data->fan_div[nr] = 1; 279 break; 280 case 4: 281 data->fan_div[nr] = 2; 282 break; 283 case 8: 284 data->fan_div[nr] = 3; 285 break; 286 default: 287 dev_err(dev, 288 "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n", 289 val); 290 mutex_unlock(&data->update_lock); 291 return -EINVAL; 292 } 293 294 reg = (lm80_read_value(client, LM80_REG_FANDIV) & ~(3 << (2 * (nr + 1)))) 295 | (data->fan_div[nr] << (2 * (nr + 1))); 296 lm80_write_value(client, LM80_REG_FANDIV, reg); 297 298 /* Restore fan_min */ 299 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr])); 300 lm80_write_value(client, LM80_REG_FAN_MIN(nr + 1), data->fan_min[nr]); 301 mutex_unlock(&data->update_lock); 302 303 return count; 304 } 305 306 static ssize_t show_temp_input1(struct device *dev, 307 struct device_attribute *attr, char *buf) 308 { 309 struct lm80_data *data = lm80_update_device(dev); 310 if (IS_ERR(data)) 311 return PTR_ERR(data); 312 return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp)); 313 } 314 315 #define show_temp(suffix, value) \ 316 static ssize_t show_temp_##suffix(struct device *dev, \ 317 struct device_attribute *attr, char *buf) \ 318 { \ 319 struct lm80_data *data = lm80_update_device(dev); \ 320 if (IS_ERR(data)) \ 321 return PTR_ERR(data); \ 322 return sprintf(buf, "%d\n", TEMP_LIMIT_FROM_REG(data->value)); \ 323 } 324 show_temp(hot_max, temp_hot_max); 325 show_temp(hot_hyst, temp_hot_hyst); 326 show_temp(os_max, temp_os_max); 327 show_temp(os_hyst, temp_os_hyst); 328 329 #define set_temp(suffix, value, reg) \ 330 static ssize_t set_temp_##suffix(struct device *dev, \ 331 struct device_attribute *attr, const char *buf, size_t count) \ 332 { \ 333 struct lm80_data *data = dev_get_drvdata(dev); \ 334 struct i2c_client *client = data->client; \ 335 long val; \ 336 int err = kstrtol(buf, 10, &val); \ 337 if (err < 0) \ 338 return err; \ 339 \ 340 mutex_lock(&data->update_lock); \ 341 data->value = TEMP_LIMIT_TO_REG(val); \ 342 lm80_write_value(client, reg, data->value); \ 343 mutex_unlock(&data->update_lock); \ 344 return count; \ 345 } 346 set_temp(hot_max, temp_hot_max, LM80_REG_TEMP_HOT_MAX); 347 set_temp(hot_hyst, temp_hot_hyst, LM80_REG_TEMP_HOT_HYST); 348 set_temp(os_max, temp_os_max, LM80_REG_TEMP_OS_MAX); 349 set_temp(os_hyst, temp_os_hyst, LM80_REG_TEMP_OS_HYST); 350 351 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, 352 char *buf) 353 { 354 struct lm80_data *data = lm80_update_device(dev); 355 if (IS_ERR(data)) 356 return PTR_ERR(data); 357 return sprintf(buf, "%u\n", data->alarms); 358 } 359 360 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, 361 char *buf) 362 { 363 int bitnr = to_sensor_dev_attr(attr)->index; 364 struct lm80_data *data = lm80_update_device(dev); 365 if (IS_ERR(data)) 366 return PTR_ERR(data); 367 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1); 368 } 369 370 static SENSOR_DEVICE_ATTR(in0_min, S_IWUSR | S_IRUGO, 371 show_in_min, set_in_min, 0); 372 static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO, 373 show_in_min, set_in_min, 1); 374 static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO, 375 show_in_min, set_in_min, 2); 376 static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO, 377 show_in_min, set_in_min, 3); 378 static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO, 379 show_in_min, set_in_min, 4); 380 static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO, 381 show_in_min, set_in_min, 5); 382 static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO, 383 show_in_min, set_in_min, 6); 384 static SENSOR_DEVICE_ATTR(in0_max, S_IWUSR | S_IRUGO, 385 show_in_max, set_in_max, 0); 386 static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO, 387 show_in_max, set_in_max, 1); 388 static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO, 389 show_in_max, set_in_max, 2); 390 static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO, 391 show_in_max, set_in_max, 3); 392 static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO, 393 show_in_max, set_in_max, 4); 394 static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO, 395 show_in_max, set_in_max, 5); 396 static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO, 397 show_in_max, set_in_max, 6); 398 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in_input, NULL, 0); 399 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in_input, NULL, 1); 400 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in_input, NULL, 2); 401 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in_input, NULL, 3); 402 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in_input, NULL, 4); 403 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_in_input, NULL, 5); 404 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_in_input, NULL, 6); 405 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, 406 show_fan_min, set_fan_min, 0); 407 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, 408 show_fan_min, set_fan_min, 1); 409 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0); 410 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1); 411 static SENSOR_DEVICE_ATTR(fan1_div, S_IWUSR | S_IRUGO, 412 show_fan_div, set_fan_div, 0); 413 static SENSOR_DEVICE_ATTR(fan2_div, S_IWUSR | S_IRUGO, 414 show_fan_div, set_fan_div, 1); 415 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input1, NULL); 416 static DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_hot_max, 417 set_temp_hot_max); 418 static DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, show_temp_hot_hyst, 419 set_temp_hot_hyst); 420 static DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp_os_max, 421 set_temp_os_max); 422 static DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temp_os_hyst, 423 set_temp_os_hyst); 424 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 425 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0); 426 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1); 427 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2); 428 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3); 429 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 4); 430 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 5); 431 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 6); 432 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 10); 433 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 11); 434 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 8); 435 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 13); 436 437 /* 438 * Real code 439 */ 440 441 static struct attribute *lm80_attrs[] = { 442 &sensor_dev_attr_in0_min.dev_attr.attr, 443 &sensor_dev_attr_in1_min.dev_attr.attr, 444 &sensor_dev_attr_in2_min.dev_attr.attr, 445 &sensor_dev_attr_in3_min.dev_attr.attr, 446 &sensor_dev_attr_in4_min.dev_attr.attr, 447 &sensor_dev_attr_in5_min.dev_attr.attr, 448 &sensor_dev_attr_in6_min.dev_attr.attr, 449 &sensor_dev_attr_in0_max.dev_attr.attr, 450 &sensor_dev_attr_in1_max.dev_attr.attr, 451 &sensor_dev_attr_in2_max.dev_attr.attr, 452 &sensor_dev_attr_in3_max.dev_attr.attr, 453 &sensor_dev_attr_in4_max.dev_attr.attr, 454 &sensor_dev_attr_in5_max.dev_attr.attr, 455 &sensor_dev_attr_in6_max.dev_attr.attr, 456 &sensor_dev_attr_in0_input.dev_attr.attr, 457 &sensor_dev_attr_in1_input.dev_attr.attr, 458 &sensor_dev_attr_in2_input.dev_attr.attr, 459 &sensor_dev_attr_in3_input.dev_attr.attr, 460 &sensor_dev_attr_in4_input.dev_attr.attr, 461 &sensor_dev_attr_in5_input.dev_attr.attr, 462 &sensor_dev_attr_in6_input.dev_attr.attr, 463 &sensor_dev_attr_fan1_min.dev_attr.attr, 464 &sensor_dev_attr_fan2_min.dev_attr.attr, 465 &sensor_dev_attr_fan1_input.dev_attr.attr, 466 &sensor_dev_attr_fan2_input.dev_attr.attr, 467 &sensor_dev_attr_fan1_div.dev_attr.attr, 468 &sensor_dev_attr_fan2_div.dev_attr.attr, 469 &dev_attr_temp1_input.attr, 470 &dev_attr_temp1_max.attr, 471 &dev_attr_temp1_max_hyst.attr, 472 &dev_attr_temp1_crit.attr, 473 &dev_attr_temp1_crit_hyst.attr, 474 &dev_attr_alarms.attr, 475 &sensor_dev_attr_in0_alarm.dev_attr.attr, 476 &sensor_dev_attr_in1_alarm.dev_attr.attr, 477 &sensor_dev_attr_in2_alarm.dev_attr.attr, 478 &sensor_dev_attr_in3_alarm.dev_attr.attr, 479 &sensor_dev_attr_in4_alarm.dev_attr.attr, 480 &sensor_dev_attr_in5_alarm.dev_attr.attr, 481 &sensor_dev_attr_in6_alarm.dev_attr.attr, 482 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 483 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 484 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 485 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 486 NULL 487 }; 488 ATTRIBUTE_GROUPS(lm80); 489 490 /* Return 0 if detection is successful, -ENODEV otherwise */ 491 static int lm80_detect(struct i2c_client *client, struct i2c_board_info *info) 492 { 493 struct i2c_adapter *adapter = client->adapter; 494 int i, cur, man_id, dev_id; 495 const char *name = NULL; 496 497 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 498 return -ENODEV; 499 500 /* First check for unused bits, common to both chip types */ 501 if ((lm80_read_value(client, LM80_REG_ALARM2) & 0xc0) 502 || (lm80_read_value(client, LM80_REG_CONFIG) & 0x80)) 503 return -ENODEV; 504 505 /* 506 * The LM96080 has manufacturer and stepping/die rev registers so we 507 * can just check that. The LM80 does not have such registers so we 508 * have to use a more expensive trick. 509 */ 510 man_id = lm80_read_value(client, LM96080_REG_MAN_ID); 511 dev_id = lm80_read_value(client, LM96080_REG_DEV_ID); 512 if (man_id == 0x01 && dev_id == 0x08) { 513 /* Check more unused bits for confirmation */ 514 if (lm80_read_value(client, LM96080_REG_CONV_RATE) & 0xfe) 515 return -ENODEV; 516 517 name = "lm96080"; 518 } else { 519 /* Check 6-bit addressing */ 520 for (i = 0x2a; i <= 0x3d; i++) { 521 cur = i2c_smbus_read_byte_data(client, i); 522 if ((i2c_smbus_read_byte_data(client, i + 0x40) != cur) 523 || (i2c_smbus_read_byte_data(client, i + 0x80) != cur) 524 || (i2c_smbus_read_byte_data(client, i + 0xc0) != cur)) 525 return -ENODEV; 526 } 527 528 name = "lm80"; 529 } 530 531 strlcpy(info->type, name, I2C_NAME_SIZE); 532 533 return 0; 534 } 535 536 static int lm80_probe(struct i2c_client *client, 537 const struct i2c_device_id *id) 538 { 539 struct device *dev = &client->dev; 540 struct device *hwmon_dev; 541 struct lm80_data *data; 542 543 data = devm_kzalloc(dev, sizeof(struct lm80_data), GFP_KERNEL); 544 if (!data) 545 return -ENOMEM; 546 547 data->client = client; 548 mutex_init(&data->update_lock); 549 550 /* Initialize the LM80 chip */ 551 lm80_init_client(client); 552 553 /* A few vars need to be filled upon startup */ 554 data->fan_min[0] = lm80_read_value(client, LM80_REG_FAN_MIN(1)); 555 data->fan_min[1] = lm80_read_value(client, LM80_REG_FAN_MIN(2)); 556 557 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 558 data, lm80_groups); 559 560 return PTR_ERR_OR_ZERO(hwmon_dev); 561 } 562 563 static int lm80_read_value(struct i2c_client *client, u8 reg) 564 { 565 return i2c_smbus_read_byte_data(client, reg); 566 } 567 568 static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value) 569 { 570 return i2c_smbus_write_byte_data(client, reg, value); 571 } 572 573 /* Called when we have found a new LM80. */ 574 static void lm80_init_client(struct i2c_client *client) 575 { 576 /* 577 * Reset all except Watchdog values and last conversion values 578 * This sets fan-divs to 2, among others. This makes most other 579 * initializations unnecessary 580 */ 581 lm80_write_value(client, LM80_REG_CONFIG, 0x80); 582 /* Set 11-bit temperature resolution */ 583 lm80_write_value(client, LM80_REG_RES, 0x08); 584 585 /* Start monitoring */ 586 lm80_write_value(client, LM80_REG_CONFIG, 0x01); 587 } 588 589 static struct lm80_data *lm80_update_device(struct device *dev) 590 { 591 struct lm80_data *data = dev_get_drvdata(dev); 592 struct i2c_client *client = data->client; 593 int i; 594 int rv; 595 int prev_rv; 596 struct lm80_data *ret = data; 597 598 mutex_lock(&data->update_lock); 599 600 if (data->error) 601 lm80_init_client(client); 602 603 if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) { 604 dev_dbg(dev, "Starting lm80 update\n"); 605 for (i = 0; i <= 6; i++) { 606 rv = lm80_read_value(client, LM80_REG_IN(i)); 607 if (rv < 0) 608 goto abort; 609 data->in[i] = rv; 610 611 rv = lm80_read_value(client, LM80_REG_IN_MIN(i)); 612 if (rv < 0) 613 goto abort; 614 data->in_min[i] = rv; 615 616 rv = lm80_read_value(client, LM80_REG_IN_MAX(i)); 617 if (rv < 0) 618 goto abort; 619 data->in_max[i] = rv; 620 } 621 622 rv = lm80_read_value(client, LM80_REG_FAN1); 623 if (rv < 0) 624 goto abort; 625 data->fan[0] = rv; 626 627 rv = lm80_read_value(client, LM80_REG_FAN_MIN(1)); 628 if (rv < 0) 629 goto abort; 630 data->fan_min[0] = rv; 631 632 rv = lm80_read_value(client, LM80_REG_FAN2); 633 if (rv < 0) 634 goto abort; 635 data->fan[1] = rv; 636 637 rv = lm80_read_value(client, LM80_REG_FAN_MIN(2)); 638 if (rv < 0) 639 goto abort; 640 data->fan_min[1] = rv; 641 642 prev_rv = rv = lm80_read_value(client, LM80_REG_TEMP); 643 if (rv < 0) 644 goto abort; 645 rv = lm80_read_value(client, LM80_REG_RES); 646 if (rv < 0) 647 goto abort; 648 data->temp = (prev_rv << 8) | (rv & 0xf0); 649 650 rv = lm80_read_value(client, LM80_REG_TEMP_OS_MAX); 651 if (rv < 0) 652 goto abort; 653 data->temp_os_max = rv; 654 655 rv = lm80_read_value(client, LM80_REG_TEMP_OS_HYST); 656 if (rv < 0) 657 goto abort; 658 data->temp_os_hyst = rv; 659 660 rv = lm80_read_value(client, LM80_REG_TEMP_HOT_MAX); 661 if (rv < 0) 662 goto abort; 663 data->temp_hot_max = rv; 664 665 rv = lm80_read_value(client, LM80_REG_TEMP_HOT_HYST); 666 if (rv < 0) 667 goto abort; 668 data->temp_hot_hyst = rv; 669 670 rv = lm80_read_value(client, LM80_REG_FANDIV); 671 if (rv < 0) 672 goto abort; 673 data->fan_div[0] = (rv >> 2) & 0x03; 674 data->fan_div[1] = (rv >> 4) & 0x03; 675 676 prev_rv = rv = lm80_read_value(client, LM80_REG_ALARM1); 677 if (rv < 0) 678 goto abort; 679 rv = lm80_read_value(client, LM80_REG_ALARM2); 680 if (rv < 0) 681 goto abort; 682 data->alarms = prev_rv + (rv << 8); 683 684 data->last_updated = jiffies; 685 data->valid = 1; 686 data->error = 0; 687 } 688 goto done; 689 690 abort: 691 ret = ERR_PTR(rv); 692 data->valid = 0; 693 data->error = 1; 694 695 done: 696 mutex_unlock(&data->update_lock); 697 698 return ret; 699 } 700 701 module_i2c_driver(lm80_driver); 702 703 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and " 704 "Philip Edelbrock <phil@netroedge.com>"); 705 MODULE_DESCRIPTION("LM80 driver"); 706 MODULE_LICENSE("GPL"); 707