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 64 /* Conversions. Rounding and limit checking is only done on the TO_REG 65 variants. Note that you should be a bit careful with which arguments 66 these macros are called: arguments may be evaluated more than once. 67 Fixing this is just not worth it. */ 68 69 #define IN_TO_REG(val) (SENSORS_LIMIT(((val) + 5) / 10, 0, 255)) 70 #define IN_FROM_REG(val) ((val) * 10) 71 72 static inline unsigned char FAN_TO_REG(unsigned rpm, unsigned div) 73 { 74 if (rpm == 0) 75 return 255; 76 rpm = SENSORS_LIMIT(rpm, 1, 1000000); 77 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254); 78 } 79 80 #define FAN_FROM_REG(val, div) ((val) == 0 ? -1 : \ 81 (val) == 255 ? 0 : 1350000/((div) * (val))) 82 83 static inline long TEMP_FROM_REG(u16 temp) 84 { 85 long res; 86 87 temp >>= 4; 88 if (temp < 0x0800) 89 res = 625 * (long) temp; 90 else 91 res = ((long) temp - 0x01000) * 625; 92 93 return res / 10; 94 } 95 96 #define TEMP_LIMIT_FROM_REG(val) (((val) > 0x80 ? \ 97 (val) - 0x100 : (val)) * 1000) 98 99 #define TEMP_LIMIT_TO_REG(val) SENSORS_LIMIT((val) < 0 ? \ 100 ((val) - 500) / 1000 : ((val) + 500) / 1000, 0, 255) 101 102 #define DIV_FROM_REG(val) (1 << (val)) 103 104 /* 105 * Client data (each client gets its own) 106 */ 107 108 struct lm80_data { 109 struct device *hwmon_dev; 110 struct mutex update_lock; 111 char valid; /* !=0 if following fields are valid */ 112 unsigned long last_updated; /* In jiffies */ 113 114 u8 in[7]; /* Register value */ 115 u8 in_max[7]; /* Register value */ 116 u8 in_min[7]; /* Register value */ 117 u8 fan[2]; /* Register value */ 118 u8 fan_min[2]; /* Register value */ 119 u8 fan_div[2]; /* Register encoding, shifted right */ 120 u16 temp; /* Register values, shifted right */ 121 u8 temp_hot_max; /* Register value */ 122 u8 temp_hot_hyst; /* Register value */ 123 u8 temp_os_max; /* Register value */ 124 u8 temp_os_hyst; /* Register value */ 125 u16 alarms; /* Register encoding, combined */ 126 }; 127 128 /* 129 * Functions declaration 130 */ 131 132 static int lm80_probe(struct i2c_client *client, 133 const struct i2c_device_id *id); 134 static int lm80_detect(struct i2c_client *client, struct i2c_board_info *info); 135 static void lm80_init_client(struct i2c_client *client); 136 static int lm80_remove(struct i2c_client *client); 137 static struct lm80_data *lm80_update_device(struct device *dev); 138 static int lm80_read_value(struct i2c_client *client, u8 reg); 139 static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value); 140 141 /* 142 * Driver data (common to all clients) 143 */ 144 145 static const struct i2c_device_id lm80_id[] = { 146 { "lm80", 0 }, 147 { } 148 }; 149 MODULE_DEVICE_TABLE(i2c, lm80_id); 150 151 static struct i2c_driver lm80_driver = { 152 .class = I2C_CLASS_HWMON, 153 .driver = { 154 .name = "lm80", 155 }, 156 .probe = lm80_probe, 157 .remove = lm80_remove, 158 .id_table = lm80_id, 159 .detect = lm80_detect, 160 .address_list = normal_i2c, 161 }; 162 163 /* 164 * Sysfs stuff 165 */ 166 167 #define show_in(suffix, value) \ 168 static ssize_t show_in_##suffix(struct device *dev, \ 169 struct device_attribute *attr, char *buf) \ 170 { \ 171 int nr = to_sensor_dev_attr(attr)->index; \ 172 struct lm80_data *data = lm80_update_device(dev); \ 173 return sprintf(buf, "%d\n", IN_FROM_REG(data->value[nr])); \ 174 } 175 show_in(min, in_min) 176 show_in(max, in_max) 177 show_in(input, in) 178 179 #define set_in(suffix, value, reg) \ 180 static ssize_t set_in_##suffix(struct device *dev, \ 181 struct device_attribute *attr, const char *buf, size_t count) \ 182 { \ 183 int nr = to_sensor_dev_attr(attr)->index; \ 184 struct i2c_client *client = to_i2c_client(dev); \ 185 struct lm80_data *data = i2c_get_clientdata(client); \ 186 long val = simple_strtol(buf, NULL, 10); \ 187 \ 188 mutex_lock(&data->update_lock);\ 189 data->value[nr] = IN_TO_REG(val); \ 190 lm80_write_value(client, reg(nr), data->value[nr]); \ 191 mutex_unlock(&data->update_lock);\ 192 return count; \ 193 } 194 set_in(min, in_min, LM80_REG_IN_MIN) 195 set_in(max, in_max, LM80_REG_IN_MAX) 196 197 #define show_fan(suffix, value) \ 198 static ssize_t show_fan_##suffix(struct device *dev, \ 199 struct device_attribute *attr, char *buf) \ 200 { \ 201 int nr = to_sensor_dev_attr(attr)->index; \ 202 struct lm80_data *data = lm80_update_device(dev); \ 203 return sprintf(buf, "%d\n", FAN_FROM_REG(data->value[nr], \ 204 DIV_FROM_REG(data->fan_div[nr]))); \ 205 } 206 show_fan(min, fan_min) 207 show_fan(input, fan) 208 209 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr, 210 char *buf) 211 { 212 int nr = to_sensor_dev_attr(attr)->index; 213 struct lm80_data *data = lm80_update_device(dev); 214 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr])); 215 } 216 217 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, 218 const char *buf, size_t count) 219 { 220 int nr = to_sensor_dev_attr(attr)->index; 221 struct i2c_client *client = to_i2c_client(dev); 222 struct lm80_data *data = i2c_get_clientdata(client); 223 long val = simple_strtoul(buf, NULL, 10); 224 225 mutex_lock(&data->update_lock); 226 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); 227 lm80_write_value(client, LM80_REG_FAN_MIN(nr + 1), data->fan_min[nr]); 228 mutex_unlock(&data->update_lock); 229 return count; 230 } 231 232 /* Note: we save and restore the fan minimum here, because its value is 233 determined in part by the fan divisor. This follows the principle of 234 least surprise; the user doesn't expect the fan minimum to change just 235 because the divisor changed. */ 236 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, 237 const char *buf, size_t count) 238 { 239 int nr = to_sensor_dev_attr(attr)->index; 240 struct i2c_client *client = to_i2c_client(dev); 241 struct lm80_data *data = i2c_get_clientdata(client); 242 unsigned long min, val = simple_strtoul(buf, NULL, 10); 243 u8 reg; 244 245 /* Save fan_min */ 246 mutex_lock(&data->update_lock); 247 min = FAN_FROM_REG(data->fan_min[nr], 248 DIV_FROM_REG(data->fan_div[nr])); 249 250 switch (val) { 251 case 1: 252 data->fan_div[nr] = 0; 253 break; 254 case 2: 255 data->fan_div[nr] = 1; 256 break; 257 case 4: 258 data->fan_div[nr] = 2; 259 break; 260 case 8: 261 data->fan_div[nr] = 3; 262 break; 263 default: 264 dev_err(&client->dev, "fan_div value %ld not " 265 "supported. Choose one of 1, 2, 4 or 8!\n", val); 266 mutex_unlock(&data->update_lock); 267 return -EINVAL; 268 } 269 270 reg = (lm80_read_value(client, LM80_REG_FANDIV) & ~(3 << (2 * (nr + 1)))) 271 | (data->fan_div[nr] << (2 * (nr + 1))); 272 lm80_write_value(client, LM80_REG_FANDIV, reg); 273 274 /* Restore fan_min */ 275 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr])); 276 lm80_write_value(client, LM80_REG_FAN_MIN(nr + 1), data->fan_min[nr]); 277 mutex_unlock(&data->update_lock); 278 279 return count; 280 } 281 282 static ssize_t show_temp_input1(struct device *dev, 283 struct device_attribute *attr, char *buf) 284 { 285 struct lm80_data *data = lm80_update_device(dev); 286 return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp)); 287 } 288 289 #define show_temp(suffix, value) \ 290 static ssize_t show_temp_##suffix(struct device *dev, \ 291 struct device_attribute *attr, char *buf) \ 292 { \ 293 struct lm80_data *data = lm80_update_device(dev); \ 294 return sprintf(buf, "%d\n", TEMP_LIMIT_FROM_REG(data->value)); \ 295 } 296 show_temp(hot_max, temp_hot_max); 297 show_temp(hot_hyst, temp_hot_hyst); 298 show_temp(os_max, temp_os_max); 299 show_temp(os_hyst, temp_os_hyst); 300 301 #define set_temp(suffix, value, reg) \ 302 static ssize_t set_temp_##suffix(struct device *dev, \ 303 struct device_attribute *attr, const char *buf, size_t count) \ 304 { \ 305 struct i2c_client *client = to_i2c_client(dev); \ 306 struct lm80_data *data = i2c_get_clientdata(client); \ 307 long val = simple_strtoul(buf, NULL, 10); \ 308 \ 309 mutex_lock(&data->update_lock); \ 310 data->value = TEMP_LIMIT_TO_REG(val); \ 311 lm80_write_value(client, reg, data->value); \ 312 mutex_unlock(&data->update_lock); \ 313 return count; \ 314 } 315 set_temp(hot_max, temp_hot_max, LM80_REG_TEMP_HOT_MAX); 316 set_temp(hot_hyst, temp_hot_hyst, LM80_REG_TEMP_HOT_HYST); 317 set_temp(os_max, temp_os_max, LM80_REG_TEMP_OS_MAX); 318 set_temp(os_hyst, temp_os_hyst, LM80_REG_TEMP_OS_HYST); 319 320 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, 321 char *buf) 322 { 323 struct lm80_data *data = lm80_update_device(dev); 324 return sprintf(buf, "%u\n", data->alarms); 325 } 326 327 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, 328 char *buf) 329 { 330 int bitnr = to_sensor_dev_attr(attr)->index; 331 struct lm80_data *data = lm80_update_device(dev); 332 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1); 333 } 334 335 static SENSOR_DEVICE_ATTR(in0_min, S_IWUSR | S_IRUGO, 336 show_in_min, set_in_min, 0); 337 static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO, 338 show_in_min, set_in_min, 1); 339 static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO, 340 show_in_min, set_in_min, 2); 341 static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO, 342 show_in_min, set_in_min, 3); 343 static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO, 344 show_in_min, set_in_min, 4); 345 static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO, 346 show_in_min, set_in_min, 5); 347 static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO, 348 show_in_min, set_in_min, 6); 349 static SENSOR_DEVICE_ATTR(in0_max, S_IWUSR | S_IRUGO, 350 show_in_max, set_in_max, 0); 351 static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO, 352 show_in_max, set_in_max, 1); 353 static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO, 354 show_in_max, set_in_max, 2); 355 static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO, 356 show_in_max, set_in_max, 3); 357 static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO, 358 show_in_max, set_in_max, 4); 359 static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO, 360 show_in_max, set_in_max, 5); 361 static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO, 362 show_in_max, set_in_max, 6); 363 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in_input, NULL, 0); 364 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in_input, NULL, 1); 365 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in_input, NULL, 2); 366 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in_input, NULL, 3); 367 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in_input, NULL, 4); 368 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_in_input, NULL, 5); 369 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_in_input, NULL, 6); 370 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, 371 show_fan_min, set_fan_min, 0); 372 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, 373 show_fan_min, set_fan_min, 1); 374 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0); 375 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1); 376 static SENSOR_DEVICE_ATTR(fan1_div, S_IWUSR | S_IRUGO, 377 show_fan_div, set_fan_div, 0); 378 static SENSOR_DEVICE_ATTR(fan2_div, S_IWUSR | S_IRUGO, 379 show_fan_div, set_fan_div, 1); 380 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input1, NULL); 381 static DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_hot_max, 382 set_temp_hot_max); 383 static DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, show_temp_hot_hyst, 384 set_temp_hot_hyst); 385 static DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp_os_max, 386 set_temp_os_max); 387 static DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temp_os_hyst, 388 set_temp_os_hyst); 389 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 390 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0); 391 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1); 392 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2); 393 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3); 394 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 4); 395 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 5); 396 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 6); 397 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 10); 398 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 11); 399 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 8); 400 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 13); 401 402 /* 403 * Real code 404 */ 405 406 static struct attribute *lm80_attributes[] = { 407 &sensor_dev_attr_in0_min.dev_attr.attr, 408 &sensor_dev_attr_in1_min.dev_attr.attr, 409 &sensor_dev_attr_in2_min.dev_attr.attr, 410 &sensor_dev_attr_in3_min.dev_attr.attr, 411 &sensor_dev_attr_in4_min.dev_attr.attr, 412 &sensor_dev_attr_in5_min.dev_attr.attr, 413 &sensor_dev_attr_in6_min.dev_attr.attr, 414 &sensor_dev_attr_in0_max.dev_attr.attr, 415 &sensor_dev_attr_in1_max.dev_attr.attr, 416 &sensor_dev_attr_in2_max.dev_attr.attr, 417 &sensor_dev_attr_in3_max.dev_attr.attr, 418 &sensor_dev_attr_in4_max.dev_attr.attr, 419 &sensor_dev_attr_in5_max.dev_attr.attr, 420 &sensor_dev_attr_in6_max.dev_attr.attr, 421 &sensor_dev_attr_in0_input.dev_attr.attr, 422 &sensor_dev_attr_in1_input.dev_attr.attr, 423 &sensor_dev_attr_in2_input.dev_attr.attr, 424 &sensor_dev_attr_in3_input.dev_attr.attr, 425 &sensor_dev_attr_in4_input.dev_attr.attr, 426 &sensor_dev_attr_in5_input.dev_attr.attr, 427 &sensor_dev_attr_in6_input.dev_attr.attr, 428 &sensor_dev_attr_fan1_min.dev_attr.attr, 429 &sensor_dev_attr_fan2_min.dev_attr.attr, 430 &sensor_dev_attr_fan1_input.dev_attr.attr, 431 &sensor_dev_attr_fan2_input.dev_attr.attr, 432 &sensor_dev_attr_fan1_div.dev_attr.attr, 433 &sensor_dev_attr_fan2_div.dev_attr.attr, 434 &dev_attr_temp1_input.attr, 435 &dev_attr_temp1_max.attr, 436 &dev_attr_temp1_max_hyst.attr, 437 &dev_attr_temp1_crit.attr, 438 &dev_attr_temp1_crit_hyst.attr, 439 &dev_attr_alarms.attr, 440 &sensor_dev_attr_in0_alarm.dev_attr.attr, 441 &sensor_dev_attr_in1_alarm.dev_attr.attr, 442 &sensor_dev_attr_in2_alarm.dev_attr.attr, 443 &sensor_dev_attr_in3_alarm.dev_attr.attr, 444 &sensor_dev_attr_in4_alarm.dev_attr.attr, 445 &sensor_dev_attr_in5_alarm.dev_attr.attr, 446 &sensor_dev_attr_in6_alarm.dev_attr.attr, 447 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 448 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 449 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 450 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 451 NULL 452 }; 453 454 static const struct attribute_group lm80_group = { 455 .attrs = lm80_attributes, 456 }; 457 458 /* Return 0 if detection is successful, -ENODEV otherwise */ 459 static int lm80_detect(struct i2c_client *client, struct i2c_board_info *info) 460 { 461 struct i2c_adapter *adapter = client->adapter; 462 int i, cur; 463 464 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 465 return -ENODEV; 466 467 /* Now, we do the remaining detection. It is lousy. */ 468 if (lm80_read_value(client, LM80_REG_ALARM2) & 0xc0) 469 return -ENODEV; 470 for (i = 0x2a; i <= 0x3d; i++) { 471 cur = i2c_smbus_read_byte_data(client, i); 472 if ((i2c_smbus_read_byte_data(client, i + 0x40) != cur) 473 || (i2c_smbus_read_byte_data(client, i + 0x80) != cur) 474 || (i2c_smbus_read_byte_data(client, i + 0xc0) != cur)) 475 return -ENODEV; 476 } 477 478 strlcpy(info->type, "lm80", I2C_NAME_SIZE); 479 480 return 0; 481 } 482 483 static int lm80_probe(struct i2c_client *client, 484 const struct i2c_device_id *id) 485 { 486 struct lm80_data *data; 487 int err; 488 489 data = kzalloc(sizeof(struct lm80_data), GFP_KERNEL); 490 if (!data) { 491 err = -ENOMEM; 492 goto exit; 493 } 494 495 i2c_set_clientdata(client, data); 496 mutex_init(&data->update_lock); 497 498 /* Initialize the LM80 chip */ 499 lm80_init_client(client); 500 501 /* A few vars need to be filled upon startup */ 502 data->fan_min[0] = lm80_read_value(client, LM80_REG_FAN_MIN(1)); 503 data->fan_min[1] = lm80_read_value(client, LM80_REG_FAN_MIN(2)); 504 505 /* Register sysfs hooks */ 506 err = sysfs_create_group(&client->dev.kobj, &lm80_group); 507 if (err) 508 goto error_free; 509 510 data->hwmon_dev = hwmon_device_register(&client->dev); 511 if (IS_ERR(data->hwmon_dev)) { 512 err = PTR_ERR(data->hwmon_dev); 513 goto error_remove; 514 } 515 516 return 0; 517 518 error_remove: 519 sysfs_remove_group(&client->dev.kobj, &lm80_group); 520 error_free: 521 kfree(data); 522 exit: 523 return err; 524 } 525 526 static int lm80_remove(struct i2c_client *client) 527 { 528 struct lm80_data *data = i2c_get_clientdata(client); 529 530 hwmon_device_unregister(data->hwmon_dev); 531 sysfs_remove_group(&client->dev.kobj, &lm80_group); 532 533 kfree(data); 534 return 0; 535 } 536 537 static int lm80_read_value(struct i2c_client *client, u8 reg) 538 { 539 return i2c_smbus_read_byte_data(client, reg); 540 } 541 542 static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value) 543 { 544 return i2c_smbus_write_byte_data(client, reg, value); 545 } 546 547 /* Called when we have found a new LM80. */ 548 static void lm80_init_client(struct i2c_client *client) 549 { 550 /* Reset all except Watchdog values and last conversion values 551 This sets fan-divs to 2, among others. This makes most other 552 initializations unnecessary */ 553 lm80_write_value(client, LM80_REG_CONFIG, 0x80); 554 /* Set 11-bit temperature resolution */ 555 lm80_write_value(client, LM80_REG_RES, 0x08); 556 557 /* Start monitoring */ 558 lm80_write_value(client, LM80_REG_CONFIG, 0x01); 559 } 560 561 static struct lm80_data *lm80_update_device(struct device *dev) 562 { 563 struct i2c_client *client = to_i2c_client(dev); 564 struct lm80_data *data = i2c_get_clientdata(client); 565 int i; 566 567 mutex_lock(&data->update_lock); 568 569 if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) { 570 dev_dbg(&client->dev, "Starting lm80 update\n"); 571 for (i = 0; i <= 6; i++) { 572 data->in[i] = 573 lm80_read_value(client, LM80_REG_IN(i)); 574 data->in_min[i] = 575 lm80_read_value(client, LM80_REG_IN_MIN(i)); 576 data->in_max[i] = 577 lm80_read_value(client, LM80_REG_IN_MAX(i)); 578 } 579 data->fan[0] = lm80_read_value(client, LM80_REG_FAN1); 580 data->fan_min[0] = 581 lm80_read_value(client, LM80_REG_FAN_MIN(1)); 582 data->fan[1] = lm80_read_value(client, LM80_REG_FAN2); 583 data->fan_min[1] = 584 lm80_read_value(client, LM80_REG_FAN_MIN(2)); 585 586 data->temp = 587 (lm80_read_value(client, LM80_REG_TEMP) << 8) | 588 (lm80_read_value(client, LM80_REG_RES) & 0xf0); 589 data->temp_os_max = 590 lm80_read_value(client, LM80_REG_TEMP_OS_MAX); 591 data->temp_os_hyst = 592 lm80_read_value(client, LM80_REG_TEMP_OS_HYST); 593 data->temp_hot_max = 594 lm80_read_value(client, LM80_REG_TEMP_HOT_MAX); 595 data->temp_hot_hyst = 596 lm80_read_value(client, LM80_REG_TEMP_HOT_HYST); 597 598 i = lm80_read_value(client, LM80_REG_FANDIV); 599 data->fan_div[0] = (i >> 2) & 0x03; 600 data->fan_div[1] = (i >> 4) & 0x03; 601 data->alarms = lm80_read_value(client, LM80_REG_ALARM1) + 602 (lm80_read_value(client, LM80_REG_ALARM2) << 8); 603 data->last_updated = jiffies; 604 data->valid = 1; 605 } 606 607 mutex_unlock(&data->update_lock); 608 609 return data; 610 } 611 612 static int __init sensors_lm80_init(void) 613 { 614 return i2c_add_driver(&lm80_driver); 615 } 616 617 static void __exit sensors_lm80_exit(void) 618 { 619 i2c_del_driver(&lm80_driver); 620 } 621 622 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and " 623 "Philip Edelbrock <phil@netroedge.com>"); 624 MODULE_DESCRIPTION("LM80 driver"); 625 MODULE_LICENSE("GPL"); 626 627 module_init(sensors_lm80_init); 628 module_exit(sensors_lm80_exit); 629