1/* 2 adm1031.c - Part of lm_sensors, Linux kernel modules for hardware 3 monitoring 4 Based on lm75.c and lm85.c 5 Supports adm1030 / adm1031 6 Copyright (C) 2004 Alexandre d'Alton <alex@alexdalton.org> 7 Reworked by Jean Delvare <khali@linux-fr.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/* Following macros takes channel parameter starting from 0 to 2 */ 35#define ADM1031_REG_FAN_SPEED(nr) (0x08 + (nr)) 36#define ADM1031_REG_FAN_DIV(nr) (0x20 + (nr)) 37#define ADM1031_REG_PWM (0x22) 38#define ADM1031_REG_FAN_MIN(nr) (0x10 + (nr)) 39#define ADM1031_REG_FAN_FILTER (0x23) 40 41#define ADM1031_REG_TEMP_OFFSET(nr) (0x0d + (nr)) 42#define ADM1031_REG_TEMP_MAX(nr) (0x14 + 4 * (nr)) 43#define ADM1031_REG_TEMP_MIN(nr) (0x15 + 4 * (nr)) 44#define ADM1031_REG_TEMP_CRIT(nr) (0x16 + 4 * (nr)) 45 46#define ADM1031_REG_TEMP(nr) (0x0a + (nr)) 47#define ADM1031_REG_AUTO_TEMP(nr) (0x24 + (nr)) 48 49#define ADM1031_REG_STATUS(nr) (0x2 + (nr)) 50 51#define ADM1031_REG_CONF1 0x00 52#define ADM1031_REG_CONF2 0x01 53#define ADM1031_REG_EXT_TEMP 0x06 54 55#define ADM1031_CONF1_MONITOR_ENABLE 0x01 /* Monitoring enable */ 56#define ADM1031_CONF1_PWM_INVERT 0x08 /* PWM Invert */ 57#define ADM1031_CONF1_AUTO_MODE 0x80 /* Auto FAN */ 58 59#define ADM1031_CONF2_PWM1_ENABLE 0x01 60#define ADM1031_CONF2_PWM2_ENABLE 0x02 61#define ADM1031_CONF2_TACH1_ENABLE 0x04 62#define ADM1031_CONF2_TACH2_ENABLE 0x08 63#define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan)) 64 65#define ADM1031_UPDATE_RATE_MASK 0x1c 66#define ADM1031_UPDATE_RATE_SHIFT 2 67 68/* Addresses to scan */ 69static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END }; 70 71enum chips { adm1030, adm1031 }; 72 73typedef u8 auto_chan_table_t[8][2]; 74 75/* Each client has this additional data */ 76struct adm1031_data { 77 struct device *hwmon_dev; 78 struct mutex update_lock; 79 int chip_type; 80 char valid; /* !=0 if following fields are valid */ 81 unsigned long last_updated; /* In jiffies */ 82 unsigned int update_interval; /* In milliseconds */ 83 /* The chan_select_table contains the possible configurations for 84 * auto fan control. 85 */ 86 const auto_chan_table_t *chan_select_table; 87 u16 alarm; 88 u8 conf1; 89 u8 conf2; 90 u8 fan[2]; 91 u8 fan_div[2]; 92 u8 fan_min[2]; 93 u8 pwm[2]; 94 u8 old_pwm[2]; 95 s8 temp[3]; 96 u8 ext_temp[3]; 97 u8 auto_temp[3]; 98 u8 auto_temp_min[3]; 99 u8 auto_temp_off[3]; 100 u8 auto_temp_max[3]; 101 s8 temp_offset[3]; 102 s8 temp_min[3]; 103 s8 temp_max[3]; 104 s8 temp_crit[3]; 105}; 106 107static int adm1031_probe(struct i2c_client *client, 108 const struct i2c_device_id *id); 109static int adm1031_detect(struct i2c_client *client, 110 struct i2c_board_info *info); 111static void adm1031_init_client(struct i2c_client *client); 112static int adm1031_remove(struct i2c_client *client); 113static struct adm1031_data *adm1031_update_device(struct device *dev); 114 115static const struct i2c_device_id adm1031_id[] = { 116 { "adm1030", adm1030 }, 117 { "adm1031", adm1031 }, 118 { } 119}; 120MODULE_DEVICE_TABLE(i2c, adm1031_id); 121 122/* This is the driver that will be inserted */ 123static struct i2c_driver adm1031_driver = { 124 .class = I2C_CLASS_HWMON, 125 .driver = { 126 .name = "adm1031", 127 }, 128 .probe = adm1031_probe, 129 .remove = adm1031_remove, 130 .id_table = adm1031_id, 131 .detect = adm1031_detect, 132 .address_list = normal_i2c, 133}; 134 135static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg) 136{ 137 return i2c_smbus_read_byte_data(client, reg); 138} 139 140static inline int 141adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value) 142{ 143 return i2c_smbus_write_byte_data(client, reg, value); 144} 145 146 147#define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \ 148 ((val + 500) / 1000))) 149 150#define TEMP_FROM_REG(val) ((val) * 1000) 151 152#define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125) 153 154#define TEMP_OFFSET_TO_REG(val) (TEMP_TO_REG(val) & 0x8f) 155#define TEMP_OFFSET_FROM_REG(val) TEMP_FROM_REG((val) < 0 ? \ 156 (val) | 0x70 : (val)) 157 158#define FAN_FROM_REG(reg, div) ((reg) ? \ 159 (11250 * 60) / ((reg) * (div)) : 0) 160 161static int FAN_TO_REG(int reg, int div) 162{ 163 int tmp; 164 tmp = FAN_FROM_REG(SENSORS_LIMIT(reg, 0, 65535), div); 165 return tmp > 255 ? 255 : tmp; 166} 167 168#define FAN_DIV_FROM_REG(reg) (1<<(((reg)&0xc0)>>6)) 169 170#define PWM_TO_REG(val) (SENSORS_LIMIT((val), 0, 255) >> 4) 171#define PWM_FROM_REG(val) ((val) << 4) 172 173#define FAN_CHAN_FROM_REG(reg) (((reg) >> 5) & 7) 174#define FAN_CHAN_TO_REG(val, reg) \ 175 (((reg) & 0x1F) | (((val) << 5) & 0xe0)) 176 177#define AUTO_TEMP_MIN_TO_REG(val, reg) \ 178 ((((val) / 500) & 0xf8) | ((reg) & 0x7)) 179#define AUTO_TEMP_RANGE_FROM_REG(reg) (5000 * (1 << ((reg) & 0x7))) 180#define AUTO_TEMP_MIN_FROM_REG(reg) (1000 * ((((reg) >> 3) & 0x1f) << 2)) 181 182#define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2) 183 184#define AUTO_TEMP_OFF_FROM_REG(reg) \ 185 (AUTO_TEMP_MIN_FROM_REG(reg) - 5000) 186 187#define AUTO_TEMP_MAX_FROM_REG(reg) \ 188 (AUTO_TEMP_RANGE_FROM_REG(reg) + \ 189 AUTO_TEMP_MIN_FROM_REG(reg)) 190 191static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm) 192{ 193 int ret; 194 int range = val - AUTO_TEMP_MIN_FROM_REG(reg); 195 196 range = ((val - AUTO_TEMP_MIN_FROM_REG(reg))*10)/(16 - pwm); 197 ret = ((reg & 0xf8) | 198 (range < 10000 ? 0 : 199 range < 20000 ? 1 : 200 range < 40000 ? 2 : range < 80000 ? 3 : 4)); 201 return ret; 202} 203 204/* FAN auto control */ 205#define GET_FAN_AUTO_BITFIELD(data, idx) \ 206 (*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx % 2] 207 208/* The tables below contains the possible values for the auto fan 209 * control bitfields. the index in the table is the register value. 210 * MSb is the auto fan control enable bit, so the four first entries 211 * in the table disables auto fan control when both bitfields are zero. 212 */ 213static const auto_chan_table_t auto_channel_select_table_adm1031 = { 214 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, 215 { 2 /* 0b010 */ , 4 /* 0b100 */ }, 216 { 2 /* 0b010 */ , 2 /* 0b010 */ }, 217 { 4 /* 0b100 */ , 4 /* 0b100 */ }, 218 { 7 /* 0b111 */ , 7 /* 0b111 */ }, 219}; 220 221static const auto_chan_table_t auto_channel_select_table_adm1030 = { 222 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, 223 { 2 /* 0b10 */ , 0 }, 224 { 0xff /* invalid */ , 0 }, 225 { 0xff /* invalid */ , 0 }, 226 { 3 /* 0b11 */ , 0 }, 227}; 228 229/* That function checks if a bitfield is valid and returns the other bitfield 230 * nearest match if no exact match where found. 231 */ 232static int 233get_fan_auto_nearest(struct adm1031_data *data, 234 int chan, u8 val, u8 reg, u8 *new_reg) 235{ 236 int i; 237 int first_match = -1, exact_match = -1; 238 u8 other_reg_val = 239 (*data->chan_select_table)[FAN_CHAN_FROM_REG(reg)][chan ? 0 : 1]; 240 241 if (val == 0) { 242 *new_reg = 0; 243 return 0; 244 } 245 246 for (i = 0; i < 8; i++) { 247 if ((val == (*data->chan_select_table)[i][chan]) && 248 ((*data->chan_select_table)[i][chan ? 0 : 1] == 249 other_reg_val)) { 250 /* We found an exact match */ 251 exact_match = i; 252 break; 253 } else if (val == (*data->chan_select_table)[i][chan] && 254 first_match == -1) { 255 /* Save the first match in case of an exact match has 256 * not been found 257 */ 258 first_match = i; 259 } 260 } 261 262 if (exact_match >= 0) 263 *new_reg = exact_match; 264 else if (first_match >= 0) 265 *new_reg = first_match; 266 else 267 return -EINVAL; 268 269 return 0; 270} 271 272static ssize_t show_fan_auto_channel(struct device *dev, 273 struct device_attribute *attr, char *buf) 274{ 275 int nr = to_sensor_dev_attr(attr)->index; 276 struct adm1031_data *data = adm1031_update_device(dev); 277 return sprintf(buf, "%d\n", GET_FAN_AUTO_BITFIELD(data, nr)); 278} 279 280static ssize_t 281set_fan_auto_channel(struct device *dev, struct device_attribute *attr, 282 const char *buf, size_t count) 283{ 284 struct i2c_client *client = to_i2c_client(dev); 285 struct adm1031_data *data = i2c_get_clientdata(client); 286 int nr = to_sensor_dev_attr(attr)->index; 287 long val; 288 u8 reg; 289 int ret; 290 u8 old_fan_mode; 291 292 ret = kstrtol(buf, 10, &val); 293 if (ret) 294 return ret; 295 296 old_fan_mode = data->conf1; 297 298 mutex_lock(&data->update_lock); 299 300 ret = get_fan_auto_nearest(data, nr, val, data->conf1, ®); 301 if (ret) { 302 mutex_unlock(&data->update_lock); 303 return ret; 304 } 305 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1); 306 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) ^ 307 (old_fan_mode & ADM1031_CONF1_AUTO_MODE)) { 308 if (data->conf1 & ADM1031_CONF1_AUTO_MODE) { 309 /* Switch to Auto Fan Mode 310 * Save PWM registers 311 * Set PWM registers to 33% Both */ 312 data->old_pwm[0] = data->pwm[0]; 313 data->old_pwm[1] = data->pwm[1]; 314 adm1031_write_value(client, ADM1031_REG_PWM, 0x55); 315 } else { 316 /* Switch to Manual Mode */ 317 data->pwm[0] = data->old_pwm[0]; 318 data->pwm[1] = data->old_pwm[1]; 319 /* Restore PWM registers */ 320 adm1031_write_value(client, ADM1031_REG_PWM, 321 data->pwm[0] | (data->pwm[1] << 4)); 322 } 323 } 324 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1); 325 adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1); 326 mutex_unlock(&data->update_lock); 327 return count; 328} 329 330static SENSOR_DEVICE_ATTR(auto_fan1_channel, S_IRUGO | S_IWUSR, 331 show_fan_auto_channel, set_fan_auto_channel, 0); 332static SENSOR_DEVICE_ATTR(auto_fan2_channel, S_IRUGO | S_IWUSR, 333 show_fan_auto_channel, set_fan_auto_channel, 1); 334 335/* Auto Temps */ 336static ssize_t show_auto_temp_off(struct device *dev, 337 struct device_attribute *attr, char *buf) 338{ 339 int nr = to_sensor_dev_attr(attr)->index; 340 struct adm1031_data *data = adm1031_update_device(dev); 341 return sprintf(buf, "%d\n", 342 AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr])); 343} 344static ssize_t show_auto_temp_min(struct device *dev, 345 struct device_attribute *attr, char *buf) 346{ 347 int nr = to_sensor_dev_attr(attr)->index; 348 struct adm1031_data *data = adm1031_update_device(dev); 349 return sprintf(buf, "%d\n", 350 AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr])); 351} 352static ssize_t 353set_auto_temp_min(struct device *dev, struct device_attribute *attr, 354 const char *buf, size_t count) 355{ 356 struct i2c_client *client = to_i2c_client(dev); 357 struct adm1031_data *data = i2c_get_clientdata(client); 358 int nr = to_sensor_dev_attr(attr)->index; 359 long val; 360 int ret; 361 362 ret = kstrtol(buf, 10, &val); 363 if (ret) 364 return ret; 365 366 mutex_lock(&data->update_lock); 367 data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]); 368 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr), 369 data->auto_temp[nr]); 370 mutex_unlock(&data->update_lock); 371 return count; 372} 373static ssize_t show_auto_temp_max(struct device *dev, 374 struct device_attribute *attr, char *buf) 375{ 376 int nr = to_sensor_dev_attr(attr)->index; 377 struct adm1031_data *data = adm1031_update_device(dev); 378 return sprintf(buf, "%d\n", 379 AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr])); 380} 381static ssize_t 382set_auto_temp_max(struct device *dev, struct device_attribute *attr, 383 const char *buf, size_t count) 384{ 385 struct i2c_client *client = to_i2c_client(dev); 386 struct adm1031_data *data = i2c_get_clientdata(client); 387 int nr = to_sensor_dev_attr(attr)->index; 388 long val; 389 int ret; 390 391 ret = kstrtol(buf, 10, &val); 392 if (ret) 393 return ret; 394 395 mutex_lock(&data->update_lock); 396 data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr], 397 data->pwm[nr]); 398 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr), 399 data->temp_max[nr]); 400 mutex_unlock(&data->update_lock); 401 return count; 402} 403 404#define auto_temp_reg(offset) \ 405static SENSOR_DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO, \ 406 show_auto_temp_off, NULL, offset - 1); \ 407static SENSOR_DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR, \ 408 show_auto_temp_min, set_auto_temp_min, offset - 1); \ 409static SENSOR_DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR, \ 410 show_auto_temp_max, set_auto_temp_max, offset - 1) 411 412auto_temp_reg(1); 413auto_temp_reg(2); 414auto_temp_reg(3); 415 416/* pwm */ 417static ssize_t show_pwm(struct device *dev, 418 struct device_attribute *attr, char *buf) 419{ 420 int nr = to_sensor_dev_attr(attr)->index; 421 struct adm1031_data *data = adm1031_update_device(dev); 422 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr])); 423} 424static ssize_t set_pwm(struct device *dev, struct device_attribute *attr, 425 const char *buf, size_t count) 426{ 427 struct i2c_client *client = to_i2c_client(dev); 428 struct adm1031_data *data = i2c_get_clientdata(client); 429 int nr = to_sensor_dev_attr(attr)->index; 430 long val; 431 int ret, reg; 432 433 ret = kstrtol(buf, 10, &val); 434 if (ret) 435 return ret; 436 437 mutex_lock(&data->update_lock); 438 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) && 439 (((val>>4) & 0xf) != 5)) { 440 /* In automatic mode, the only PWM accepted is 33% */ 441 mutex_unlock(&data->update_lock); 442 return -EINVAL; 443 } 444 data->pwm[nr] = PWM_TO_REG(val); 445 reg = adm1031_read_value(client, ADM1031_REG_PWM); 446 adm1031_write_value(client, ADM1031_REG_PWM, 447 nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf) 448 : (data->pwm[nr] & 0xf) | (reg & 0xf0)); 449 mutex_unlock(&data->update_lock); 450 return count; 451} 452 453static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0); 454static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 1); 455static SENSOR_DEVICE_ATTR(auto_fan1_min_pwm, S_IRUGO | S_IWUSR, 456 show_pwm, set_pwm, 0); 457static SENSOR_DEVICE_ATTR(auto_fan2_min_pwm, S_IRUGO | S_IWUSR, 458 show_pwm, set_pwm, 1); 459 460/* Fans */ 461 462/* 463 * That function checks the cases where the fan reading is not 464 * relevant. It is used to provide 0 as fan reading when the fan is 465 * not supposed to run 466 */ 467static int trust_fan_readings(struct adm1031_data *data, int chan) 468{ 469 int res = 0; 470 471 if (data->conf1 & ADM1031_CONF1_AUTO_MODE) { 472 switch (data->conf1 & 0x60) { 473 case 0x00: 474 /* 475 * remote temp1 controls fan1, 476 * remote temp2 controls fan2 477 */ 478 res = data->temp[chan+1] >= 479 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]); 480 break; 481 case 0x20: /* remote temp1 controls both fans */ 482 res = 483 data->temp[1] >= 484 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]); 485 break; 486 case 0x40: /* remote temp2 controls both fans */ 487 res = 488 data->temp[2] >= 489 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]); 490 break; 491 case 0x60: /* max controls both fans */ 492 res = 493 data->temp[0] >= 494 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0]) 495 || data->temp[1] >= 496 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]) 497 || (data->chip_type == adm1031 498 && data->temp[2] >= 499 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2])); 500 break; 501 } 502 } else { 503 res = data->pwm[chan] > 0; 504 } 505 return res; 506} 507 508 509static ssize_t show_fan(struct device *dev, 510 struct device_attribute *attr, char *buf) 511{ 512 int nr = to_sensor_dev_attr(attr)->index; 513 struct adm1031_data *data = adm1031_update_device(dev); 514 int value; 515 516 value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr], 517 FAN_DIV_FROM_REG(data->fan_div[nr])) : 0; 518 return sprintf(buf, "%d\n", value); 519} 520 521static ssize_t show_fan_div(struct device *dev, 522 struct device_attribute *attr, char *buf) 523{ 524 int nr = to_sensor_dev_attr(attr)->index; 525 struct adm1031_data *data = adm1031_update_device(dev); 526 return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr])); 527} 528static ssize_t show_fan_min(struct device *dev, 529 struct device_attribute *attr, char *buf) 530{ 531 int nr = to_sensor_dev_attr(attr)->index; 532 struct adm1031_data *data = adm1031_update_device(dev); 533 return sprintf(buf, "%d\n", 534 FAN_FROM_REG(data->fan_min[nr], 535 FAN_DIV_FROM_REG(data->fan_div[nr]))); 536} 537static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, 538 const char *buf, size_t count) 539{ 540 struct i2c_client *client = to_i2c_client(dev); 541 struct adm1031_data *data = i2c_get_clientdata(client); 542 int nr = to_sensor_dev_attr(attr)->index; 543 long val; 544 int ret; 545 546 ret = kstrtol(buf, 10, &val); 547 if (ret) 548 return ret; 549 550 mutex_lock(&data->update_lock); 551 if (val) { 552 data->fan_min[nr] = 553 FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr])); 554 } else { 555 data->fan_min[nr] = 0xff; 556 } 557 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]); 558 mutex_unlock(&data->update_lock); 559 return count; 560} 561static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, 562 const char *buf, size_t count) 563{ 564 struct i2c_client *client = to_i2c_client(dev); 565 struct adm1031_data *data = i2c_get_clientdata(client); 566 int nr = to_sensor_dev_attr(attr)->index; 567 long val; 568 u8 tmp; 569 int old_div; 570 int new_min; 571 int ret; 572 573 ret = kstrtol(buf, 10, &val); 574 if (ret) 575 return ret; 576 577 tmp = val == 8 ? 0xc0 : 578 val == 4 ? 0x80 : 579 val == 2 ? 0x40 : 580 val == 1 ? 0x00 : 581 0xff; 582 if (tmp == 0xff) 583 return -EINVAL; 584 585 mutex_lock(&data->update_lock); 586 /* Get fresh readings */ 587 data->fan_div[nr] = adm1031_read_value(client, 588 ADM1031_REG_FAN_DIV(nr)); 589 data->fan_min[nr] = adm1031_read_value(client, 590 ADM1031_REG_FAN_MIN(nr)); 591 592 /* Write the new clock divider and fan min */ 593 old_div = FAN_DIV_FROM_REG(data->fan_div[nr]); 594 data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]); 595 new_min = data->fan_min[nr] * old_div / val; 596 data->fan_min[nr] = new_min > 0xff ? 0xff : new_min; 597 598 adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr), 599 data->fan_div[nr]); 600 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), 601 data->fan_min[nr]); 602 603 /* Invalidate the cache: fan speed is no longer valid */ 604 data->valid = 0; 605 mutex_unlock(&data->update_lock); 606 return count; 607} 608 609#define fan_offset(offset) \ 610static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \ 611 show_fan, NULL, offset - 1); \ 612static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 613 show_fan_min, set_fan_min, offset - 1); \ 614static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \ 615 show_fan_div, set_fan_div, offset - 1) 616 617fan_offset(1); 618fan_offset(2); 619 620 621/* Temps */ 622static ssize_t show_temp(struct device *dev, 623 struct device_attribute *attr, char *buf) 624{ 625 int nr = to_sensor_dev_attr(attr)->index; 626 struct adm1031_data *data = adm1031_update_device(dev); 627 int ext; 628 ext = nr == 0 ? 629 ((data->ext_temp[nr] >> 6) & 0x3) * 2 : 630 (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7)); 631 return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext)); 632} 633static ssize_t show_temp_offset(struct device *dev, 634 struct device_attribute *attr, char *buf) 635{ 636 int nr = to_sensor_dev_attr(attr)->index; 637 struct adm1031_data *data = adm1031_update_device(dev); 638 return sprintf(buf, "%d\n", 639 TEMP_OFFSET_FROM_REG(data->temp_offset[nr])); 640} 641static ssize_t show_temp_min(struct device *dev, 642 struct device_attribute *attr, char *buf) 643{ 644 int nr = to_sensor_dev_attr(attr)->index; 645 struct adm1031_data *data = adm1031_update_device(dev); 646 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr])); 647} 648static ssize_t show_temp_max(struct device *dev, 649 struct device_attribute *attr, char *buf) 650{ 651 int nr = to_sensor_dev_attr(attr)->index; 652 struct adm1031_data *data = adm1031_update_device(dev); 653 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr])); 654} 655static ssize_t show_temp_crit(struct device *dev, 656 struct device_attribute *attr, char *buf) 657{ 658 int nr = to_sensor_dev_attr(attr)->index; 659 struct adm1031_data *data = adm1031_update_device(dev); 660 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr])); 661} 662static ssize_t set_temp_offset(struct device *dev, 663 struct device_attribute *attr, const char *buf, 664 size_t count) 665{ 666 struct i2c_client *client = to_i2c_client(dev); 667 struct adm1031_data *data = i2c_get_clientdata(client); 668 int nr = to_sensor_dev_attr(attr)->index; 669 long val; 670 int ret; 671 672 ret = kstrtol(buf, 10, &val); 673 if (ret) 674 return ret; 675 676 val = SENSORS_LIMIT(val, -15000, 15000); 677 mutex_lock(&data->update_lock); 678 data->temp_offset[nr] = TEMP_OFFSET_TO_REG(val); 679 adm1031_write_value(client, ADM1031_REG_TEMP_OFFSET(nr), 680 data->temp_offset[nr]); 681 mutex_unlock(&data->update_lock); 682 return count; 683} 684static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr, 685 const char *buf, size_t count) 686{ 687 struct i2c_client *client = to_i2c_client(dev); 688 struct adm1031_data *data = i2c_get_clientdata(client); 689 int nr = to_sensor_dev_attr(attr)->index; 690 long val; 691 int ret; 692 693 ret = kstrtol(buf, 10, &val); 694 if (ret) 695 return ret; 696 697 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875); 698 mutex_lock(&data->update_lock); 699 data->temp_min[nr] = TEMP_TO_REG(val); 700 adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr), 701 data->temp_min[nr]); 702 mutex_unlock(&data->update_lock); 703 return count; 704} 705static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr, 706 const char *buf, size_t count) 707{ 708 struct i2c_client *client = to_i2c_client(dev); 709 struct adm1031_data *data = i2c_get_clientdata(client); 710 int nr = to_sensor_dev_attr(attr)->index; 711 long val; 712 int ret; 713 714 ret = kstrtol(buf, 10, &val); 715 if (ret) 716 return ret; 717 718 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875); 719 mutex_lock(&data->update_lock); 720 data->temp_max[nr] = TEMP_TO_REG(val); 721 adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr), 722 data->temp_max[nr]); 723 mutex_unlock(&data->update_lock); 724 return count; 725} 726static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr, 727 const char *buf, size_t count) 728{ 729 struct i2c_client *client = to_i2c_client(dev); 730 struct adm1031_data *data = i2c_get_clientdata(client); 731 int nr = to_sensor_dev_attr(attr)->index; 732 long val; 733 int ret; 734 735 ret = kstrtol(buf, 10, &val); 736 if (ret) 737 return ret; 738 739 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875); 740 mutex_lock(&data->update_lock); 741 data->temp_crit[nr] = TEMP_TO_REG(val); 742 adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr), 743 data->temp_crit[nr]); 744 mutex_unlock(&data->update_lock); 745 return count; 746} 747 748#define temp_reg(offset) \ 749static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \ 750 show_temp, NULL, offset - 1); \ 751static SENSOR_DEVICE_ATTR(temp##offset##_offset, S_IRUGO | S_IWUSR, \ 752 show_temp_offset, set_temp_offset, offset - 1); \ 753static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \ 754 show_temp_min, set_temp_min, offset - 1); \ 755static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \ 756 show_temp_max, set_temp_max, offset - 1); \ 757static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR, \ 758 show_temp_crit, set_temp_crit, offset - 1) 759 760temp_reg(1); 761temp_reg(2); 762temp_reg(3); 763 764/* Alarms */ 765static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, 766 char *buf) 767{ 768 struct adm1031_data *data = adm1031_update_device(dev); 769 return sprintf(buf, "%d\n", data->alarm); 770} 771 772static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 773 774static ssize_t show_alarm(struct device *dev, 775 struct device_attribute *attr, char *buf) 776{ 777 int bitnr = to_sensor_dev_attr(attr)->index; 778 struct adm1031_data *data = adm1031_update_device(dev); 779 return sprintf(buf, "%d\n", (data->alarm >> bitnr) & 1); 780} 781 782static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0); 783static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1); 784static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2); 785static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3); 786static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 4); 787static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 5); 788static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6); 789static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 7); 790static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 8); 791static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 9); 792static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 10); 793static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11); 794static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 12); 795static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 13); 796static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14); 797 798/* Update Interval */ 799static const unsigned int update_intervals[] = { 800 16000, 8000, 4000, 2000, 1000, 500, 250, 125, 801}; 802 803static ssize_t show_update_interval(struct device *dev, 804 struct device_attribute *attr, char *buf) 805{ 806 struct i2c_client *client = to_i2c_client(dev); 807 struct adm1031_data *data = i2c_get_clientdata(client); 808 809 return sprintf(buf, "%u\n", data->update_interval); 810} 811 812static ssize_t set_update_interval(struct device *dev, 813 struct device_attribute *attr, 814 const char *buf, size_t count) 815{ 816 struct i2c_client *client = to_i2c_client(dev); 817 struct adm1031_data *data = i2c_get_clientdata(client); 818 unsigned long val; 819 int i, err; 820 u8 reg; 821 822 err = kstrtoul(buf, 10, &val); 823 if (err) 824 return err; 825 826 /* 827 * Find the nearest update interval from the table. 828 * Use it to determine the matching update rate. 829 */ 830 for (i = 0; i < ARRAY_SIZE(update_intervals) - 1; i++) { 831 if (val >= update_intervals[i]) 832 break; 833 } 834 /* if not found, we point to the last entry (lowest update interval) */ 835 836 /* set the new update rate while preserving other settings */ 837 reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER); 838 reg &= ~ADM1031_UPDATE_RATE_MASK; 839 reg |= i << ADM1031_UPDATE_RATE_SHIFT; 840 adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg); 841 842 mutex_lock(&data->update_lock); 843 data->update_interval = update_intervals[i]; 844 mutex_unlock(&data->update_lock); 845 846 return count; 847} 848 849static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval, 850 set_update_interval); 851 852static struct attribute *adm1031_attributes[] = { 853 &sensor_dev_attr_fan1_input.dev_attr.attr, 854 &sensor_dev_attr_fan1_div.dev_attr.attr, 855 &sensor_dev_attr_fan1_min.dev_attr.attr, 856 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 857 &sensor_dev_attr_fan1_fault.dev_attr.attr, 858 &sensor_dev_attr_pwm1.dev_attr.attr, 859 &sensor_dev_attr_auto_fan1_channel.dev_attr.attr, 860 &sensor_dev_attr_temp1_input.dev_attr.attr, 861 &sensor_dev_attr_temp1_offset.dev_attr.attr, 862 &sensor_dev_attr_temp1_min.dev_attr.attr, 863 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 864 &sensor_dev_attr_temp1_max.dev_attr.attr, 865 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 866 &sensor_dev_attr_temp1_crit.dev_attr.attr, 867 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 868 &sensor_dev_attr_temp2_input.dev_attr.attr, 869 &sensor_dev_attr_temp2_offset.dev_attr.attr, 870 &sensor_dev_attr_temp2_min.dev_attr.attr, 871 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, 872 &sensor_dev_attr_temp2_max.dev_attr.attr, 873 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 874 &sensor_dev_attr_temp2_crit.dev_attr.attr, 875 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, 876 &sensor_dev_attr_temp2_fault.dev_attr.attr, 877 878 &sensor_dev_attr_auto_temp1_off.dev_attr.attr, 879 &sensor_dev_attr_auto_temp1_min.dev_attr.attr, 880 &sensor_dev_attr_auto_temp1_max.dev_attr.attr, 881 882 &sensor_dev_attr_auto_temp2_off.dev_attr.attr, 883 &sensor_dev_attr_auto_temp2_min.dev_attr.attr, 884 &sensor_dev_attr_auto_temp2_max.dev_attr.attr, 885 886 &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr, 887 888 &dev_attr_update_interval.attr, 889 &dev_attr_alarms.attr, 890 891 NULL 892}; 893 894static const struct attribute_group adm1031_group = { 895 .attrs = adm1031_attributes, 896}; 897 898static struct attribute *adm1031_attributes_opt[] = { 899 &sensor_dev_attr_fan2_input.dev_attr.attr, 900 &sensor_dev_attr_fan2_div.dev_attr.attr, 901 &sensor_dev_attr_fan2_min.dev_attr.attr, 902 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 903 &sensor_dev_attr_fan2_fault.dev_attr.attr, 904 &sensor_dev_attr_pwm2.dev_attr.attr, 905 &sensor_dev_attr_auto_fan2_channel.dev_attr.attr, 906 &sensor_dev_attr_temp3_input.dev_attr.attr, 907 &sensor_dev_attr_temp3_offset.dev_attr.attr, 908 &sensor_dev_attr_temp3_min.dev_attr.attr, 909 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr, 910 &sensor_dev_attr_temp3_max.dev_attr.attr, 911 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr, 912 &sensor_dev_attr_temp3_crit.dev_attr.attr, 913 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr, 914 &sensor_dev_attr_temp3_fault.dev_attr.attr, 915 &sensor_dev_attr_auto_temp3_off.dev_attr.attr, 916 &sensor_dev_attr_auto_temp3_min.dev_attr.attr, 917 &sensor_dev_attr_auto_temp3_max.dev_attr.attr, 918 &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr, 919 NULL 920}; 921 922static const struct attribute_group adm1031_group_opt = { 923 .attrs = adm1031_attributes_opt, 924}; 925 926/* Return 0 if detection is successful, -ENODEV otherwise */ 927static int adm1031_detect(struct i2c_client *client, 928 struct i2c_board_info *info) 929{ 930 struct i2c_adapter *adapter = client->adapter; 931 const char *name; 932 int id, co; 933 934 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 935 return -ENODEV; 936 937 id = i2c_smbus_read_byte_data(client, 0x3d); 938 co = i2c_smbus_read_byte_data(client, 0x3e); 939 940 if (!((id == 0x31 || id == 0x30) && co == 0x41)) 941 return -ENODEV; 942 name = (id == 0x30) ? "adm1030" : "adm1031"; 943 944 strlcpy(info->type, name, I2C_NAME_SIZE); 945 946 return 0; 947} 948 949static int adm1031_probe(struct i2c_client *client, 950 const struct i2c_device_id *id) 951{ 952 struct adm1031_data *data; 953 int err; 954 955 data = kzalloc(sizeof(struct adm1031_data), GFP_KERNEL); 956 if (!data) { 957 err = -ENOMEM; 958 goto exit; 959 } 960 961 i2c_set_clientdata(client, data); 962 data->chip_type = id->driver_data; 963 mutex_init(&data->update_lock); 964 965 if (data->chip_type == adm1030) 966 data->chan_select_table = &auto_channel_select_table_adm1030; 967 else 968 data->chan_select_table = &auto_channel_select_table_adm1031; 969 970 /* Initialize the ADM1031 chip */ 971 adm1031_init_client(client); 972 973 /* Register sysfs hooks */ 974 err = sysfs_create_group(&client->dev.kobj, &adm1031_group); 975 if (err) 976 goto exit_free; 977 978 if (data->chip_type == adm1031) { 979 err = sysfs_create_group(&client->dev.kobj, &adm1031_group_opt); 980 if (err) 981 goto exit_remove; 982 } 983 984 data->hwmon_dev = hwmon_device_register(&client->dev); 985 if (IS_ERR(data->hwmon_dev)) { 986 err = PTR_ERR(data->hwmon_dev); 987 goto exit_remove; 988 } 989 990 return 0; 991 992exit_remove: 993 sysfs_remove_group(&client->dev.kobj, &adm1031_group); 994 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt); 995exit_free: 996 kfree(data); 997exit: 998 return err; 999} 1000 1001static int adm1031_remove(struct i2c_client *client) 1002{ 1003 struct adm1031_data *data = i2c_get_clientdata(client); 1004 1005 hwmon_device_unregister(data->hwmon_dev); 1006 sysfs_remove_group(&client->dev.kobj, &adm1031_group); 1007 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt); 1008 kfree(data); 1009 return 0; 1010} 1011 1012static void adm1031_init_client(struct i2c_client *client) 1013{ 1014 unsigned int read_val; 1015 unsigned int mask; 1016 int i; 1017 struct adm1031_data *data = i2c_get_clientdata(client); 1018 1019 mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE); 1020 if (data->chip_type == adm1031) { 1021 mask |= (ADM1031_CONF2_PWM2_ENABLE | 1022 ADM1031_CONF2_TACH2_ENABLE); 1023 } 1024 /* Initialize the ADM1031 chip (enables fan speed reading ) */ 1025 read_val = adm1031_read_value(client, ADM1031_REG_CONF2); 1026 if ((read_val | mask) != read_val) 1027 adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask); 1028 1029 read_val = adm1031_read_value(client, ADM1031_REG_CONF1); 1030 if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) { 1031 adm1031_write_value(client, ADM1031_REG_CONF1, 1032 read_val | ADM1031_CONF1_MONITOR_ENABLE); 1033 } 1034 1035 /* Read the chip's update rate */ 1036 mask = ADM1031_UPDATE_RATE_MASK; 1037 read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER); 1038 i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT; 1039 /* Save it as update interval */ 1040 data->update_interval = update_intervals[i]; 1041} 1042 1043static struct adm1031_data *adm1031_update_device(struct device *dev) 1044{ 1045 struct i2c_client *client = to_i2c_client(dev); 1046 struct adm1031_data *data = i2c_get_clientdata(client); 1047 unsigned long next_update; 1048 int chan; 1049 1050 mutex_lock(&data->update_lock); 1051 1052 next_update = data->last_updated 1053 + msecs_to_jiffies(data->update_interval); 1054 if (time_after(jiffies, next_update) || !data->valid) { 1055 1056 dev_dbg(&client->dev, "Starting adm1031 update\n"); 1057 for (chan = 0; 1058 chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) { 1059 u8 oldh, newh; 1060 1061 oldh = 1062 adm1031_read_value(client, ADM1031_REG_TEMP(chan)); 1063 data->ext_temp[chan] = 1064 adm1031_read_value(client, ADM1031_REG_EXT_TEMP); 1065 newh = 1066 adm1031_read_value(client, ADM1031_REG_TEMP(chan)); 1067 if (newh != oldh) { 1068 data->ext_temp[chan] = 1069 adm1031_read_value(client, 1070 ADM1031_REG_EXT_TEMP); 1071#ifdef DEBUG 1072 oldh = 1073 adm1031_read_value(client, 1074 ADM1031_REG_TEMP(chan)); 1075 1076 /* oldh is actually newer */ 1077 if (newh != oldh) 1078 dev_warn(&client->dev, 1079 "Remote temperature may be wrong.\n"); 1080#endif 1081 } 1082 data->temp[chan] = newh; 1083 1084 data->temp_offset[chan] = 1085 adm1031_read_value(client, 1086 ADM1031_REG_TEMP_OFFSET(chan)); 1087 data->temp_min[chan] = 1088 adm1031_read_value(client, 1089 ADM1031_REG_TEMP_MIN(chan)); 1090 data->temp_max[chan] = 1091 adm1031_read_value(client, 1092 ADM1031_REG_TEMP_MAX(chan)); 1093 data->temp_crit[chan] = 1094 adm1031_read_value(client, 1095 ADM1031_REG_TEMP_CRIT(chan)); 1096 data->auto_temp[chan] = 1097 adm1031_read_value(client, 1098 ADM1031_REG_AUTO_TEMP(chan)); 1099 1100 } 1101 1102 data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1); 1103 data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2); 1104 1105 data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0)) 1106 | (adm1031_read_value(client, ADM1031_REG_STATUS(1)) << 8); 1107 if (data->chip_type == adm1030) 1108 data->alarm &= 0xc0ff; 1109 1110 for (chan = 0; chan < (data->chip_type == adm1030 ? 1 : 2); 1111 chan++) { 1112 data->fan_div[chan] = 1113 adm1031_read_value(client, 1114 ADM1031_REG_FAN_DIV(chan)); 1115 data->fan_min[chan] = 1116 adm1031_read_value(client, 1117 ADM1031_REG_FAN_MIN(chan)); 1118 data->fan[chan] = 1119 adm1031_read_value(client, 1120 ADM1031_REG_FAN_SPEED(chan)); 1121 data->pwm[chan] = 1122 (adm1031_read_value(client, 1123 ADM1031_REG_PWM) >> (4 * chan)) & 0x0f; 1124 } 1125 data->last_updated = jiffies; 1126 data->valid = 1; 1127 } 1128 1129 mutex_unlock(&data->update_lock); 1130 1131 return data; 1132} 1133 1134static int __init sensors_adm1031_init(void) 1135{ 1136 return i2c_add_driver(&adm1031_driver); 1137} 1138 1139static void __exit sensors_adm1031_exit(void) 1140{ 1141 i2c_del_driver(&adm1031_driver); 1142} 1143 1144MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>"); 1145MODULE_DESCRIPTION("ADM1031/ADM1030 driver"); 1146MODULE_LICENSE("GPL"); 1147 1148module_init(sensors_adm1031_init); 1149module_exit(sensors_adm1031_exit); 1150