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