1 /* 2 w83793.c - Linux kernel driver for hardware monitoring 3 Copyright (C) 2006 Winbond Electronics Corp. 4 Yuan Mu 5 Rudolf Marek <r.marek@assembler.cz> 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation - version 2. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19 02110-1301 USA. 20 */ 21 22 /* 23 Supports following chips: 24 25 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA 26 w83793 10 12 8 6 0x7b 0x5ca3 yes no 27 */ 28 29 #include <linux/module.h> 30 #include <linux/init.h> 31 #include <linux/slab.h> 32 #include <linux/i2c.h> 33 #include <linux/hwmon.h> 34 #include <linux/hwmon-vid.h> 35 #include <linux/hwmon-sysfs.h> 36 #include <linux/err.h> 37 #include <linux/mutex.h> 38 39 /* Addresses to scan */ 40 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END }; 41 42 /* Insmod parameters */ 43 I2C_CLIENT_INSMOD_1(w83793); 44 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: " 45 "{bus, clientaddr, subclientaddr1, subclientaddr2}"); 46 47 static int reset; 48 module_param(reset, bool, 0); 49 MODULE_PARM_DESC(reset, "Set to 1 to reset chip, not recommended"); 50 51 /* 52 Address 0x00, 0x0d, 0x0e, 0x0f in all three banks are reserved 53 as ID, Bank Select registers 54 */ 55 #define W83793_REG_BANKSEL 0x00 56 #define W83793_REG_VENDORID 0x0d 57 #define W83793_REG_CHIPID 0x0e 58 #define W83793_REG_DEVICEID 0x0f 59 60 #define W83793_REG_CONFIG 0x40 61 #define W83793_REG_MFC 0x58 62 #define W83793_REG_FANIN_CTRL 0x5c 63 #define W83793_REG_FANIN_SEL 0x5d 64 #define W83793_REG_I2C_ADDR 0x0b 65 #define W83793_REG_I2C_SUBADDR 0x0c 66 #define W83793_REG_VID_INA 0x05 67 #define W83793_REG_VID_INB 0x06 68 #define W83793_REG_VID_LATCHA 0x07 69 #define W83793_REG_VID_LATCHB 0x08 70 #define W83793_REG_VID_CTRL 0x59 71 72 static u16 W83793_REG_TEMP_MODE[2] = { 0x5e, 0x5f }; 73 74 #define TEMP_READ 0 75 #define TEMP_CRIT 1 76 #define TEMP_CRIT_HYST 2 77 #define TEMP_WARN 3 78 #define TEMP_WARN_HYST 4 79 /* only crit and crit_hyst affect real-time alarm status 80 current crit crit_hyst warn warn_hyst */ 81 static u16 W83793_REG_TEMP[][5] = { 82 {0x1c, 0x78, 0x79, 0x7a, 0x7b}, 83 {0x1d, 0x7c, 0x7d, 0x7e, 0x7f}, 84 {0x1e, 0x80, 0x81, 0x82, 0x83}, 85 {0x1f, 0x84, 0x85, 0x86, 0x87}, 86 {0x20, 0x88, 0x89, 0x8a, 0x8b}, 87 {0x21, 0x8c, 0x8d, 0x8e, 0x8f}, 88 }; 89 90 #define W83793_REG_TEMP_LOW_BITS 0x22 91 92 #define W83793_REG_BEEP(index) (0x53 + (index)) 93 #define W83793_REG_ALARM(index) (0x4b + (index)) 94 95 #define W83793_REG_CLR_CHASSIS 0x4a /* SMI MASK4 */ 96 #define W83793_REG_IRQ_CTRL 0x50 97 #define W83793_REG_OVT_CTRL 0x51 98 #define W83793_REG_OVT_BEEP 0x52 99 100 #define IN_READ 0 101 #define IN_MAX 1 102 #define IN_LOW 2 103 static const u16 W83793_REG_IN[][3] = { 104 /* Current, High, Low */ 105 {0x10, 0x60, 0x61}, /* Vcore A */ 106 {0x11, 0x62, 0x63}, /* Vcore B */ 107 {0x12, 0x64, 0x65}, /* Vtt */ 108 {0x14, 0x6a, 0x6b}, /* VSEN1 */ 109 {0x15, 0x6c, 0x6d}, /* VSEN2 */ 110 {0x16, 0x6e, 0x6f}, /* +3VSEN */ 111 {0x17, 0x70, 0x71}, /* +12VSEN */ 112 {0x18, 0x72, 0x73}, /* 5VDD */ 113 {0x19, 0x74, 0x75}, /* 5VSB */ 114 {0x1a, 0x76, 0x77}, /* VBAT */ 115 }; 116 117 /* Low Bits of Vcore A/B Vtt Read/High/Low */ 118 static const u16 W83793_REG_IN_LOW_BITS[] = { 0x1b, 0x68, 0x69 }; 119 static u8 scale_in[] = { 2, 2, 2, 16, 16, 16, 8, 24, 24, 16 }; 120 static u8 scale_in_add[] = { 0, 0, 0, 0, 0, 0, 0, 150, 150, 0 }; 121 122 #define W83793_REG_FAN(index) (0x23 + 2 * (index)) /* High byte */ 123 #define W83793_REG_FAN_MIN(index) (0x90 + 2 * (index)) /* High byte */ 124 125 #define W83793_REG_PWM_DEFAULT 0xb2 126 #define W83793_REG_PWM_ENABLE 0x207 127 #define W83793_REG_PWM_UPTIME 0xc3 /* Unit in 0.1 second */ 128 #define W83793_REG_PWM_DOWNTIME 0xc4 /* Unit in 0.1 second */ 129 #define W83793_REG_TEMP_CRITICAL 0xc5 130 131 #define PWM_DUTY 0 132 #define PWM_START 1 133 #define PWM_NONSTOP 2 134 #define W83793_REG_PWM(index, nr) (((nr) == 0 ? 0xb3 : \ 135 (nr) == 1 ? 0x220 : 0x218) + (index)) 136 137 /* bit field, fan1 is bit0, fan2 is bit1 ... */ 138 #define W83793_REG_TEMP_FAN_MAP(index) (0x201 + (index)) 139 #define W83793_REG_TEMP_TOL(index) (0x208 + (index)) 140 #define W83793_REG_TEMP_CRUISE(index) (0x210 + (index)) 141 #define W83793_REG_PWM_STOP_TIME(index) (0x228 + (index)) 142 #define W83793_REG_SF2_TEMP(index, nr) (0x230 + ((index) << 4) + (nr)) 143 #define W83793_REG_SF2_PWM(index, nr) (0x238 + ((index) << 4) + (nr)) 144 145 static inline unsigned long FAN_FROM_REG(u16 val) 146 { 147 if ((val >= 0xfff) || (val == 0)) 148 return 0; 149 return (1350000UL / val); 150 } 151 152 static inline u16 FAN_TO_REG(long rpm) 153 { 154 if (rpm <= 0) 155 return 0x0fff; 156 return SENSORS_LIMIT((1350000 + (rpm >> 1)) / rpm, 1, 0xffe); 157 } 158 159 static inline unsigned long TIME_FROM_REG(u8 reg) 160 { 161 return (reg * 100); 162 } 163 164 static inline u8 TIME_TO_REG(unsigned long val) 165 { 166 return SENSORS_LIMIT((val + 50) / 100, 0, 0xff); 167 } 168 169 static inline long TEMP_FROM_REG(s8 reg) 170 { 171 return (reg * 1000); 172 } 173 174 static inline s8 TEMP_TO_REG(long val, s8 min, s8 max) 175 { 176 return SENSORS_LIMIT((val + (val < 0 ? -500 : 500)) / 1000, min, max); 177 } 178 179 struct w83793_data { 180 struct i2c_client client; 181 struct i2c_client *lm75[2]; 182 struct device *hwmon_dev; 183 struct mutex update_lock; 184 char valid; /* !=0 if following fields are valid */ 185 unsigned long last_updated; /* In jiffies */ 186 unsigned long last_nonvolatile; /* In jiffies, last time we update the 187 nonvolatile registers */ 188 189 u8 bank; 190 u8 vrm; 191 u8 vid[2]; 192 u8 in[10][3]; /* Register value, read/high/low */ 193 u8 in_low_bits[3]; /* Additional resolution for VCore A/B Vtt */ 194 195 u16 has_fan; /* Only fan1- fan5 has own pins */ 196 u16 fan[12]; /* Register value combine */ 197 u16 fan_min[12]; /* Register value combine */ 198 199 s8 temp[6][5]; /* current, crit, crit_hyst,warn, warn_hyst */ 200 u8 temp_low_bits; /* Additional resolution TD1-TD4 */ 201 u8 temp_mode[2]; /* byte 0: Temp D1-D4 mode each has 2 bits 202 byte 1: Temp R1,R2 mode, each has 1 bit */ 203 u8 temp_critical; /* If reached all fan will be at full speed */ 204 u8 temp_fan_map[6]; /* Temp controls which pwm fan, bit field */ 205 206 u8 has_pwm; 207 u8 has_temp; 208 u8 has_vid; 209 u8 pwm_enable; /* Register value, each Temp has 1 bit */ 210 u8 pwm_uptime; /* Register value */ 211 u8 pwm_downtime; /* Register value */ 212 u8 pwm_default; /* All fan default pwm, next poweron valid */ 213 u8 pwm[8][3]; /* Register value */ 214 u8 pwm_stop_time[8]; 215 u8 temp_cruise[6]; 216 217 u8 alarms[5]; /* realtime status registers */ 218 u8 beeps[5]; 219 u8 beep_enable; 220 u8 tolerance[3]; /* Temp tolerance(Smart Fan I/II) */ 221 u8 sf2_pwm[6][7]; /* Smart FanII: Fan duty cycle */ 222 u8 sf2_temp[6][7]; /* Smart FanII: Temp level point */ 223 }; 224 225 static u8 w83793_read_value(struct i2c_client *client, u16 reg); 226 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value); 227 static int w83793_attach_adapter(struct i2c_adapter *adapter); 228 static int w83793_detect(struct i2c_adapter *adapter, int address, int kind); 229 static int w83793_detach_client(struct i2c_client *client); 230 static void w83793_init_client(struct i2c_client *client); 231 static void w83793_update_nonvolatile(struct device *dev); 232 static struct w83793_data *w83793_update_device(struct device *dev); 233 234 static struct i2c_driver w83793_driver = { 235 .driver = { 236 .name = "w83793", 237 }, 238 .attach_adapter = w83793_attach_adapter, 239 .detach_client = w83793_detach_client, 240 }; 241 242 static ssize_t 243 show_vrm(struct device *dev, struct device_attribute *attr, char *buf) 244 { 245 struct i2c_client *client = to_i2c_client(dev); 246 struct w83793_data *data = i2c_get_clientdata(client); 247 248 return sprintf(buf, "%d\n", data->vrm); 249 } 250 251 static ssize_t 252 show_vid(struct device *dev, struct device_attribute *attr, char *buf) 253 { 254 struct w83793_data *data = w83793_update_device(dev); 255 struct sensor_device_attribute_2 *sensor_attr = 256 to_sensor_dev_attr_2(attr); 257 int index = sensor_attr->index; 258 259 return sprintf(buf, "%d\n", vid_from_reg(data->vid[index], data->vrm)); 260 } 261 262 static ssize_t 263 store_vrm(struct device *dev, struct device_attribute *attr, 264 const char *buf, size_t count) 265 { 266 struct i2c_client *client = to_i2c_client(dev); 267 struct w83793_data *data = i2c_get_clientdata(client); 268 269 data->vrm = simple_strtoul(buf, NULL, 10); 270 return count; 271 } 272 273 #define ALARM_STATUS 0 274 #define BEEP_ENABLE 1 275 static ssize_t 276 show_alarm_beep(struct device *dev, struct device_attribute *attr, char *buf) 277 { 278 struct w83793_data *data = w83793_update_device(dev); 279 struct sensor_device_attribute_2 *sensor_attr = 280 to_sensor_dev_attr_2(attr); 281 int nr = sensor_attr->nr; 282 int index = sensor_attr->index >> 3; 283 int bit = sensor_attr->index & 0x07; 284 u8 val; 285 286 if (ALARM_STATUS == nr) { 287 val = (data->alarms[index] >> (bit)) & 1; 288 } else { /* BEEP_ENABLE */ 289 val = (data->beeps[index] >> (bit)) & 1; 290 } 291 292 return sprintf(buf, "%u\n", val); 293 } 294 295 static ssize_t 296 store_beep(struct device *dev, struct device_attribute *attr, 297 const char *buf, size_t count) 298 { 299 struct i2c_client *client = to_i2c_client(dev); 300 struct w83793_data *data = i2c_get_clientdata(client); 301 struct sensor_device_attribute_2 *sensor_attr = 302 to_sensor_dev_attr_2(attr); 303 int index = sensor_attr->index >> 3; 304 int shift = sensor_attr->index & 0x07; 305 u8 beep_bit = 1 << shift; 306 u8 val; 307 308 val = simple_strtoul(buf, NULL, 10); 309 if (val != 0 && val != 1) 310 return -EINVAL; 311 312 mutex_lock(&data->update_lock); 313 data->beeps[index] = w83793_read_value(client, W83793_REG_BEEP(index)); 314 data->beeps[index] &= ~beep_bit; 315 data->beeps[index] |= val << shift; 316 w83793_write_value(client, W83793_REG_BEEP(index), data->beeps[index]); 317 mutex_unlock(&data->update_lock); 318 319 return count; 320 } 321 322 static ssize_t 323 show_beep_enable(struct device *dev, struct device_attribute *attr, char *buf) 324 { 325 struct w83793_data *data = w83793_update_device(dev); 326 return sprintf(buf, "%u\n", (data->beep_enable >> 1) & 0x01); 327 } 328 329 static ssize_t 330 store_beep_enable(struct device *dev, struct device_attribute *attr, 331 const char *buf, size_t count) 332 { 333 struct i2c_client *client = to_i2c_client(dev); 334 struct w83793_data *data = i2c_get_clientdata(client); 335 u8 val = simple_strtoul(buf, NULL, 10); 336 337 if (val != 0 && val != 1) 338 return -EINVAL; 339 340 mutex_lock(&data->update_lock); 341 data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP) 342 & 0xfd; 343 data->beep_enable |= val << 1; 344 w83793_write_value(client, W83793_REG_OVT_BEEP, data->beep_enable); 345 mutex_unlock(&data->update_lock); 346 347 return count; 348 } 349 350 /* Write any value to clear chassis alarm */ 351 static ssize_t 352 store_chassis_clear(struct device *dev, 353 struct device_attribute *attr, const char *buf, 354 size_t count) 355 { 356 struct i2c_client *client = to_i2c_client(dev); 357 struct w83793_data *data = i2c_get_clientdata(client); 358 u8 val; 359 360 mutex_lock(&data->update_lock); 361 val = w83793_read_value(client, W83793_REG_CLR_CHASSIS); 362 val |= 0x80; 363 w83793_write_value(client, W83793_REG_CLR_CHASSIS, val); 364 mutex_unlock(&data->update_lock); 365 return count; 366 } 367 368 #define FAN_INPUT 0 369 #define FAN_MIN 1 370 static ssize_t 371 show_fan(struct device *dev, struct device_attribute *attr, char *buf) 372 { 373 struct sensor_device_attribute_2 *sensor_attr = 374 to_sensor_dev_attr_2(attr); 375 int nr = sensor_attr->nr; 376 int index = sensor_attr->index; 377 struct w83793_data *data = w83793_update_device(dev); 378 u16 val; 379 380 if (FAN_INPUT == nr) { 381 val = data->fan[index] & 0x0fff; 382 } else { 383 val = data->fan_min[index] & 0x0fff; 384 } 385 386 return sprintf(buf, "%lu\n", FAN_FROM_REG(val)); 387 } 388 389 static ssize_t 390 store_fan_min(struct device *dev, struct device_attribute *attr, 391 const char *buf, size_t count) 392 { 393 struct sensor_device_attribute_2 *sensor_attr = 394 to_sensor_dev_attr_2(attr); 395 int index = sensor_attr->index; 396 struct i2c_client *client = to_i2c_client(dev); 397 struct w83793_data *data = i2c_get_clientdata(client); 398 u16 val = FAN_TO_REG(simple_strtoul(buf, NULL, 10)); 399 400 mutex_lock(&data->update_lock); 401 data->fan_min[index] = val; 402 w83793_write_value(client, W83793_REG_FAN_MIN(index), 403 (val >> 8) & 0xff); 404 w83793_write_value(client, W83793_REG_FAN_MIN(index) + 1, val & 0xff); 405 mutex_unlock(&data->update_lock); 406 407 return count; 408 } 409 410 #define PWM_DUTY 0 411 #define PWM_START 1 412 #define PWM_NONSTOP 2 413 #define PWM_STOP_TIME 3 414 static ssize_t 415 show_pwm(struct device *dev, struct device_attribute *attr, char *buf) 416 { 417 struct sensor_device_attribute_2 *sensor_attr = 418 to_sensor_dev_attr_2(attr); 419 struct w83793_data *data = w83793_update_device(dev); 420 u16 val; 421 int nr = sensor_attr->nr; 422 int index = sensor_attr->index; 423 424 if (PWM_STOP_TIME == nr) 425 val = TIME_FROM_REG(data->pwm_stop_time[index]); 426 else 427 val = (data->pwm[index][nr] & 0x3f) << 2; 428 429 return sprintf(buf, "%d\n", val); 430 } 431 432 static ssize_t 433 store_pwm(struct device *dev, struct device_attribute *attr, 434 const char *buf, size_t count) 435 { 436 struct i2c_client *client = to_i2c_client(dev); 437 struct w83793_data *data = i2c_get_clientdata(client); 438 struct sensor_device_attribute_2 *sensor_attr = 439 to_sensor_dev_attr_2(attr); 440 int nr = sensor_attr->nr; 441 int index = sensor_attr->index; 442 u8 val; 443 444 mutex_lock(&data->update_lock); 445 if (PWM_STOP_TIME == nr) { 446 val = TIME_TO_REG(simple_strtoul(buf, NULL, 10)); 447 data->pwm_stop_time[index] = val; 448 w83793_write_value(client, W83793_REG_PWM_STOP_TIME(index), 449 val); 450 } else { 451 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 0xff) 452 >> 2; 453 data->pwm[index][nr] = 454 w83793_read_value(client, W83793_REG_PWM(index, nr)) & 0xc0; 455 data->pwm[index][nr] |= val; 456 w83793_write_value(client, W83793_REG_PWM(index, nr), 457 data->pwm[index][nr]); 458 } 459 460 mutex_unlock(&data->update_lock); 461 return count; 462 } 463 464 static ssize_t 465 show_temp(struct device *dev, struct device_attribute *attr, char *buf) 466 { 467 struct sensor_device_attribute_2 *sensor_attr = 468 to_sensor_dev_attr_2(attr); 469 int nr = sensor_attr->nr; 470 int index = sensor_attr->index; 471 struct w83793_data *data = w83793_update_device(dev); 472 long temp = TEMP_FROM_REG(data->temp[index][nr]); 473 474 if (TEMP_READ == nr && index < 4) { /* Only TD1-TD4 have low bits */ 475 int low = ((data->temp_low_bits >> (index * 2)) & 0x03) * 250; 476 temp += temp > 0 ? low : -low; 477 } 478 return sprintf(buf, "%ld\n", temp); 479 } 480 481 static ssize_t 482 store_temp(struct device *dev, struct device_attribute *attr, 483 const char *buf, size_t count) 484 { 485 struct sensor_device_attribute_2 *sensor_attr = 486 to_sensor_dev_attr_2(attr); 487 int nr = sensor_attr->nr; 488 int index = sensor_attr->index; 489 struct i2c_client *client = to_i2c_client(dev); 490 struct w83793_data *data = i2c_get_clientdata(client); 491 long tmp = simple_strtol(buf, NULL, 10); 492 493 mutex_lock(&data->update_lock); 494 data->temp[index][nr] = TEMP_TO_REG(tmp, -128, 127); 495 w83793_write_value(client, W83793_REG_TEMP[index][nr], 496 data->temp[index][nr]); 497 mutex_unlock(&data->update_lock); 498 return count; 499 } 500 501 /* 502 TD1-TD4 503 each has 4 mode:(2 bits) 504 0: Stop monitor 505 1: Use internal temp sensor(default) 506 2: Reserved 507 3: Use sensor in Intel CPU and get result by PECI 508 509 TR1-TR2 510 each has 2 mode:(1 bit) 511 0: Disable temp sensor monitor 512 1: To enable temp sensors monitor 513 */ 514 515 /* 0 disable, 6 PECI */ 516 static u8 TO_TEMP_MODE[] = { 0, 0, 0, 6 }; 517 518 static ssize_t 519 show_temp_mode(struct device *dev, struct device_attribute *attr, char *buf) 520 { 521 struct w83793_data *data = w83793_update_device(dev); 522 struct sensor_device_attribute_2 *sensor_attr = 523 to_sensor_dev_attr_2(attr); 524 int index = sensor_attr->index; 525 u8 mask = (index < 4) ? 0x03 : 0x01; 526 u8 shift = (index < 4) ? (2 * index) : (index - 4); 527 u8 tmp; 528 index = (index < 4) ? 0 : 1; 529 530 tmp = (data->temp_mode[index] >> shift) & mask; 531 532 /* for the internal sensor, found out if diode or thermistor */ 533 if (tmp == 1) { 534 tmp = index == 0 ? 3 : 4; 535 } else { 536 tmp = TO_TEMP_MODE[tmp]; 537 } 538 539 return sprintf(buf, "%d\n", tmp); 540 } 541 542 static ssize_t 543 store_temp_mode(struct device *dev, struct device_attribute *attr, 544 const char *buf, size_t count) 545 { 546 struct i2c_client *client = to_i2c_client(dev); 547 struct w83793_data *data = i2c_get_clientdata(client); 548 struct sensor_device_attribute_2 *sensor_attr = 549 to_sensor_dev_attr_2(attr); 550 int index = sensor_attr->index; 551 u8 mask = (index < 4) ? 0x03 : 0x01; 552 u8 shift = (index < 4) ? (2 * index) : (index - 4); 553 u8 val = simple_strtoul(buf, NULL, 10); 554 555 /* transform the sysfs interface values into table above */ 556 if ((val == 6) && (index < 4)) { 557 val -= 3; 558 } else if ((val == 3 && index < 4) 559 || (val == 4 && index >= 4)) { 560 /* transform diode or thermistor into internal enable */ 561 val = !!val; 562 } else { 563 return -EINVAL; 564 } 565 566 index = (index < 4) ? 0 : 1; 567 mutex_lock(&data->update_lock); 568 data->temp_mode[index] = 569 w83793_read_value(client, W83793_REG_TEMP_MODE[index]); 570 data->temp_mode[index] &= ~(mask << shift); 571 data->temp_mode[index] |= val << shift; 572 w83793_write_value(client, W83793_REG_TEMP_MODE[index], 573 data->temp_mode[index]); 574 mutex_unlock(&data->update_lock); 575 576 return count; 577 } 578 579 #define SETUP_PWM_DEFAULT 0 580 #define SETUP_PWM_UPTIME 1 /* Unit in 0.1s */ 581 #define SETUP_PWM_DOWNTIME 2 /* Unit in 0.1s */ 582 #define SETUP_TEMP_CRITICAL 3 583 static ssize_t 584 show_sf_setup(struct device *dev, struct device_attribute *attr, char *buf) 585 { 586 struct sensor_device_attribute_2 *sensor_attr = 587 to_sensor_dev_attr_2(attr); 588 int nr = sensor_attr->nr; 589 struct w83793_data *data = w83793_update_device(dev); 590 u32 val = 0; 591 592 if (SETUP_PWM_DEFAULT == nr) { 593 val = (data->pwm_default & 0x3f) << 2; 594 } else if (SETUP_PWM_UPTIME == nr) { 595 val = TIME_FROM_REG(data->pwm_uptime); 596 } else if (SETUP_PWM_DOWNTIME == nr) { 597 val = TIME_FROM_REG(data->pwm_downtime); 598 } else if (SETUP_TEMP_CRITICAL == nr) { 599 val = TEMP_FROM_REG(data->temp_critical & 0x7f); 600 } 601 602 return sprintf(buf, "%d\n", val); 603 } 604 605 static ssize_t 606 store_sf_setup(struct device *dev, struct device_attribute *attr, 607 const char *buf, size_t count) 608 { 609 struct sensor_device_attribute_2 *sensor_attr = 610 to_sensor_dev_attr_2(attr); 611 int nr = sensor_attr->nr; 612 struct i2c_client *client = to_i2c_client(dev); 613 struct w83793_data *data = i2c_get_clientdata(client); 614 615 mutex_lock(&data->update_lock); 616 if (SETUP_PWM_DEFAULT == nr) { 617 data->pwm_default = 618 w83793_read_value(client, W83793_REG_PWM_DEFAULT) & 0xc0; 619 data->pwm_default |= SENSORS_LIMIT(simple_strtoul(buf, NULL, 620 10), 621 0, 0xff) >> 2; 622 w83793_write_value(client, W83793_REG_PWM_DEFAULT, 623 data->pwm_default); 624 } else if (SETUP_PWM_UPTIME == nr) { 625 data->pwm_uptime = TIME_TO_REG(simple_strtoul(buf, NULL, 10)); 626 data->pwm_uptime += data->pwm_uptime == 0 ? 1 : 0; 627 w83793_write_value(client, W83793_REG_PWM_UPTIME, 628 data->pwm_uptime); 629 } else if (SETUP_PWM_DOWNTIME == nr) { 630 data->pwm_downtime = TIME_TO_REG(simple_strtoul(buf, NULL, 10)); 631 data->pwm_downtime += data->pwm_downtime == 0 ? 1 : 0; 632 w83793_write_value(client, W83793_REG_PWM_DOWNTIME, 633 data->pwm_downtime); 634 } else { /* SETUP_TEMP_CRITICAL */ 635 data->temp_critical = 636 w83793_read_value(client, W83793_REG_TEMP_CRITICAL) & 0x80; 637 data->temp_critical |= TEMP_TO_REG(simple_strtol(buf, NULL, 10), 638 0, 0x7f); 639 w83793_write_value(client, W83793_REG_TEMP_CRITICAL, 640 data->temp_critical); 641 } 642 643 mutex_unlock(&data->update_lock); 644 return count; 645 } 646 647 /* 648 Temp SmartFan control 649 TEMP_FAN_MAP 650 Temp channel control which pwm fan, bitfield, bit 0 indicate pwm1... 651 It's possible two or more temp channels control the same fan, w83793 652 always prefers to pick the most critical request and applies it to 653 the related Fan. 654 It's possible one fan is not in any mapping of 6 temp channels, this 655 means the fan is manual mode 656 657 TEMP_PWM_ENABLE 658 Each temp channel has its own SmartFan mode, and temp channel 659 control fans that are set by TEMP_FAN_MAP 660 0: SmartFanII mode 661 1: Thermal Cruise Mode 662 663 TEMP_CRUISE 664 Target temperature in thermal cruise mode, w83793 will try to turn 665 fan speed to keep the temperature of target device around this 666 temperature. 667 668 TEMP_TOLERANCE 669 If Temp higher or lower than target with this tolerance, w83793 670 will take actions to speed up or slow down the fan to keep the 671 temperature within the tolerance range. 672 */ 673 674 #define TEMP_FAN_MAP 0 675 #define TEMP_PWM_ENABLE 1 676 #define TEMP_CRUISE 2 677 #define TEMP_TOLERANCE 3 678 static ssize_t 679 show_sf_ctrl(struct device *dev, struct device_attribute *attr, char *buf) 680 { 681 struct sensor_device_attribute_2 *sensor_attr = 682 to_sensor_dev_attr_2(attr); 683 int nr = sensor_attr->nr; 684 int index = sensor_attr->index; 685 struct w83793_data *data = w83793_update_device(dev); 686 u32 val; 687 688 if (TEMP_FAN_MAP == nr) { 689 val = data->temp_fan_map[index]; 690 } else if (TEMP_PWM_ENABLE == nr) { 691 /* +2 to transfrom into 2 and 3 to conform with sysfs intf */ 692 val = ((data->pwm_enable >> index) & 0x01) + 2; 693 } else if (TEMP_CRUISE == nr) { 694 val = TEMP_FROM_REG(data->temp_cruise[index] & 0x7f); 695 } else { /* TEMP_TOLERANCE */ 696 val = data->tolerance[index >> 1] >> ((index & 0x01) ? 4 : 0); 697 val = TEMP_FROM_REG(val & 0x0f); 698 } 699 return sprintf(buf, "%d\n", val); 700 } 701 702 static ssize_t 703 store_sf_ctrl(struct device *dev, struct device_attribute *attr, 704 const char *buf, size_t count) 705 { 706 struct sensor_device_attribute_2 *sensor_attr = 707 to_sensor_dev_attr_2(attr); 708 int nr = sensor_attr->nr; 709 int index = sensor_attr->index; 710 struct i2c_client *client = to_i2c_client(dev); 711 struct w83793_data *data = i2c_get_clientdata(client); 712 u32 val; 713 714 mutex_lock(&data->update_lock); 715 if (TEMP_FAN_MAP == nr) { 716 val = simple_strtoul(buf, NULL, 10) & 0xff; 717 w83793_write_value(client, W83793_REG_TEMP_FAN_MAP(index), val); 718 data->temp_fan_map[index] = val; 719 } else if (TEMP_PWM_ENABLE == nr) { 720 val = simple_strtoul(buf, NULL, 10); 721 if (2 == val || 3 == val) { 722 data->pwm_enable = 723 w83793_read_value(client, W83793_REG_PWM_ENABLE); 724 if (val - 2) 725 data->pwm_enable |= 1 << index; 726 else 727 data->pwm_enable &= ~(1 << index); 728 w83793_write_value(client, W83793_REG_PWM_ENABLE, 729 data->pwm_enable); 730 } else { 731 mutex_unlock(&data->update_lock); 732 return -EINVAL; 733 } 734 } else if (TEMP_CRUISE == nr) { 735 data->temp_cruise[index] = 736 w83793_read_value(client, W83793_REG_TEMP_CRUISE(index)); 737 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x7f); 738 data->temp_cruise[index] &= 0x80; 739 data->temp_cruise[index] |= val; 740 741 w83793_write_value(client, W83793_REG_TEMP_CRUISE(index), 742 data->temp_cruise[index]); 743 } else { /* TEMP_TOLERANCE */ 744 int i = index >> 1; 745 u8 shift = (index & 0x01) ? 4 : 0; 746 data->tolerance[i] = 747 w83793_read_value(client, W83793_REG_TEMP_TOL(i)); 748 749 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x0f); 750 data->tolerance[i] &= ~(0x0f << shift); 751 data->tolerance[i] |= val << shift; 752 w83793_write_value(client, W83793_REG_TEMP_TOL(i), 753 data->tolerance[i]); 754 } 755 756 mutex_unlock(&data->update_lock); 757 return count; 758 } 759 760 static ssize_t 761 show_sf2_pwm(struct device *dev, struct device_attribute *attr, char *buf) 762 { 763 struct sensor_device_attribute_2 *sensor_attr = 764 to_sensor_dev_attr_2(attr); 765 int nr = sensor_attr->nr; 766 int index = sensor_attr->index; 767 struct w83793_data *data = w83793_update_device(dev); 768 769 return sprintf(buf, "%d\n", (data->sf2_pwm[index][nr] & 0x3f) << 2); 770 } 771 772 static ssize_t 773 store_sf2_pwm(struct device *dev, struct device_attribute *attr, 774 const char *buf, size_t count) 775 { 776 struct i2c_client *client = to_i2c_client(dev); 777 struct w83793_data *data = i2c_get_clientdata(client); 778 struct sensor_device_attribute_2 *sensor_attr = 779 to_sensor_dev_attr_2(attr); 780 int nr = sensor_attr->nr; 781 int index = sensor_attr->index; 782 u8 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 0xff) >> 2; 783 784 mutex_lock(&data->update_lock); 785 data->sf2_pwm[index][nr] = 786 w83793_read_value(client, W83793_REG_SF2_PWM(index, nr)) & 0xc0; 787 data->sf2_pwm[index][nr] |= val; 788 w83793_write_value(client, W83793_REG_SF2_PWM(index, nr), 789 data->sf2_pwm[index][nr]); 790 mutex_unlock(&data->update_lock); 791 return count; 792 } 793 794 static ssize_t 795 show_sf2_temp(struct device *dev, struct device_attribute *attr, char *buf) 796 { 797 struct sensor_device_attribute_2 *sensor_attr = 798 to_sensor_dev_attr_2(attr); 799 int nr = sensor_attr->nr; 800 int index = sensor_attr->index; 801 struct w83793_data *data = w83793_update_device(dev); 802 803 return sprintf(buf, "%ld\n", 804 TEMP_FROM_REG(data->sf2_temp[index][nr] & 0x7f)); 805 } 806 807 static ssize_t 808 store_sf2_temp(struct device *dev, struct device_attribute *attr, 809 const char *buf, size_t count) 810 { 811 struct i2c_client *client = to_i2c_client(dev); 812 struct w83793_data *data = i2c_get_clientdata(client); 813 struct sensor_device_attribute_2 *sensor_attr = 814 to_sensor_dev_attr_2(attr); 815 int nr = sensor_attr->nr; 816 int index = sensor_attr->index; 817 u8 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x7f); 818 819 mutex_lock(&data->update_lock); 820 data->sf2_temp[index][nr] = 821 w83793_read_value(client, W83793_REG_SF2_TEMP(index, nr)) & 0x80; 822 data->sf2_temp[index][nr] |= val; 823 w83793_write_value(client, W83793_REG_SF2_TEMP(index, nr), 824 data->sf2_temp[index][nr]); 825 mutex_unlock(&data->update_lock); 826 return count; 827 } 828 829 /* only Vcore A/B and Vtt have additional 2 bits precision */ 830 static ssize_t 831 show_in(struct device *dev, struct device_attribute *attr, char *buf) 832 { 833 struct sensor_device_attribute_2 *sensor_attr = 834 to_sensor_dev_attr_2(attr); 835 int nr = sensor_attr->nr; 836 int index = sensor_attr->index; 837 struct w83793_data *data = w83793_update_device(dev); 838 u16 val = data->in[index][nr]; 839 840 if (index < 3) { 841 val <<= 2; 842 val += (data->in_low_bits[nr] >> (index * 2)) & 0x3; 843 } 844 /* voltage inputs 5VDD and 5VSB needs 150mV offset */ 845 val = val * scale_in[index] + scale_in_add[index]; 846 return sprintf(buf, "%d\n", val); 847 } 848 849 static ssize_t 850 store_in(struct device *dev, struct device_attribute *attr, 851 const char *buf, size_t count) 852 { 853 struct sensor_device_attribute_2 *sensor_attr = 854 to_sensor_dev_attr_2(attr); 855 int nr = sensor_attr->nr; 856 int index = sensor_attr->index; 857 struct i2c_client *client = to_i2c_client(dev); 858 struct w83793_data *data = i2c_get_clientdata(client); 859 u32 val; 860 861 val = 862 (simple_strtoul(buf, NULL, 10) + 863 scale_in[index] / 2) / scale_in[index]; 864 mutex_lock(&data->update_lock); 865 if (index > 2) { 866 /* fix the limit values of 5VDD and 5VSB to ALARM mechanism */ 867 if (1 == nr || 2 == nr) { 868 val -= scale_in_add[index] / scale_in[index]; 869 } 870 val = SENSORS_LIMIT(val, 0, 255); 871 } else { 872 val = SENSORS_LIMIT(val, 0, 0x3FF); 873 data->in_low_bits[nr] = 874 w83793_read_value(client, W83793_REG_IN_LOW_BITS[nr]); 875 data->in_low_bits[nr] &= ~(0x03 << (2 * index)); 876 data->in_low_bits[nr] |= (val & 0x03) << (2 * index); 877 w83793_write_value(client, W83793_REG_IN_LOW_BITS[nr], 878 data->in_low_bits[nr]); 879 val >>= 2; 880 } 881 data->in[index][nr] = val; 882 w83793_write_value(client, W83793_REG_IN[index][nr], 883 data->in[index][nr]); 884 mutex_unlock(&data->update_lock); 885 return count; 886 } 887 888 #define NOT_USED -1 889 890 #define SENSOR_ATTR_IN(index) \ 891 SENSOR_ATTR_2(in##index##_input, S_IRUGO, show_in, NULL, \ 892 IN_READ, index), \ 893 SENSOR_ATTR_2(in##index##_max, S_IRUGO | S_IWUSR, show_in, \ 894 store_in, IN_MAX, index), \ 895 SENSOR_ATTR_2(in##index##_min, S_IRUGO | S_IWUSR, show_in, \ 896 store_in, IN_LOW, index), \ 897 SENSOR_ATTR_2(in##index##_alarm, S_IRUGO, show_alarm_beep, \ 898 NULL, ALARM_STATUS, index + ((index > 2) ? 1 : 0)), \ 899 SENSOR_ATTR_2(in##index##_beep, S_IWUSR | S_IRUGO, \ 900 show_alarm_beep, store_beep, BEEP_ENABLE, \ 901 index + ((index > 2) ? 1 : 0)) 902 903 #define SENSOR_ATTR_FAN(index) \ 904 SENSOR_ATTR_2(fan##index##_alarm, S_IRUGO, show_alarm_beep, \ 905 NULL, ALARM_STATUS, index + 17), \ 906 SENSOR_ATTR_2(fan##index##_beep, S_IWUSR | S_IRUGO, \ 907 show_alarm_beep, store_beep, BEEP_ENABLE, index + 17), \ 908 SENSOR_ATTR_2(fan##index##_input, S_IRUGO, show_fan, \ 909 NULL, FAN_INPUT, index - 1), \ 910 SENSOR_ATTR_2(fan##index##_min, S_IWUSR | S_IRUGO, \ 911 show_fan, store_fan_min, FAN_MIN, index - 1) 912 913 #define SENSOR_ATTR_PWM(index) \ 914 SENSOR_ATTR_2(pwm##index, S_IWUSR | S_IRUGO, show_pwm, \ 915 store_pwm, PWM_DUTY, index - 1), \ 916 SENSOR_ATTR_2(pwm##index##_nonstop, S_IWUSR | S_IRUGO, \ 917 show_pwm, store_pwm, PWM_NONSTOP, index - 1), \ 918 SENSOR_ATTR_2(pwm##index##_start, S_IWUSR | S_IRUGO, \ 919 show_pwm, store_pwm, PWM_START, index - 1), \ 920 SENSOR_ATTR_2(pwm##index##_stop_time, S_IWUSR | S_IRUGO, \ 921 show_pwm, store_pwm, PWM_STOP_TIME, index - 1) 922 923 #define SENSOR_ATTR_TEMP(index) \ 924 SENSOR_ATTR_2(temp##index##_type, S_IRUGO | S_IWUSR, \ 925 show_temp_mode, store_temp_mode, NOT_USED, index - 1), \ 926 SENSOR_ATTR_2(temp##index##_input, S_IRUGO, show_temp, \ 927 NULL, TEMP_READ, index - 1), \ 928 SENSOR_ATTR_2(temp##index##_max, S_IRUGO | S_IWUSR, show_temp, \ 929 store_temp, TEMP_CRIT, index - 1), \ 930 SENSOR_ATTR_2(temp##index##_max_hyst, S_IRUGO | S_IWUSR, \ 931 show_temp, store_temp, TEMP_CRIT_HYST, index - 1), \ 932 SENSOR_ATTR_2(temp##index##_warn, S_IRUGO | S_IWUSR, show_temp, \ 933 store_temp, TEMP_WARN, index - 1), \ 934 SENSOR_ATTR_2(temp##index##_warn_hyst, S_IRUGO | S_IWUSR, \ 935 show_temp, store_temp, TEMP_WARN_HYST, index - 1), \ 936 SENSOR_ATTR_2(temp##index##_alarm, S_IRUGO, \ 937 show_alarm_beep, NULL, ALARM_STATUS, index + 11), \ 938 SENSOR_ATTR_2(temp##index##_beep, S_IWUSR | S_IRUGO, \ 939 show_alarm_beep, store_beep, BEEP_ENABLE, index + 11), \ 940 SENSOR_ATTR_2(temp##index##_auto_channels_pwm, \ 941 S_IRUGO | S_IWUSR, show_sf_ctrl, store_sf_ctrl, \ 942 TEMP_FAN_MAP, index - 1), \ 943 SENSOR_ATTR_2(temp##index##_pwm_enable, S_IWUSR | S_IRUGO, \ 944 show_sf_ctrl, store_sf_ctrl, TEMP_PWM_ENABLE, \ 945 index - 1), \ 946 SENSOR_ATTR_2(thermal_cruise##index, S_IRUGO | S_IWUSR, \ 947 show_sf_ctrl, store_sf_ctrl, TEMP_CRUISE, index - 1), \ 948 SENSOR_ATTR_2(tolerance##index, S_IRUGO | S_IWUSR, show_sf_ctrl,\ 949 store_sf_ctrl, TEMP_TOLERANCE, index - 1), \ 950 SENSOR_ATTR_2(temp##index##_auto_point1_pwm, S_IRUGO | S_IWUSR, \ 951 show_sf2_pwm, store_sf2_pwm, 0, index - 1), \ 952 SENSOR_ATTR_2(temp##index##_auto_point2_pwm, S_IRUGO | S_IWUSR, \ 953 show_sf2_pwm, store_sf2_pwm, 1, index - 1), \ 954 SENSOR_ATTR_2(temp##index##_auto_point3_pwm, S_IRUGO | S_IWUSR, \ 955 show_sf2_pwm, store_sf2_pwm, 2, index - 1), \ 956 SENSOR_ATTR_2(temp##index##_auto_point4_pwm, S_IRUGO | S_IWUSR, \ 957 show_sf2_pwm, store_sf2_pwm, 3, index - 1), \ 958 SENSOR_ATTR_2(temp##index##_auto_point5_pwm, S_IRUGO | S_IWUSR, \ 959 show_sf2_pwm, store_sf2_pwm, 4, index - 1), \ 960 SENSOR_ATTR_2(temp##index##_auto_point6_pwm, S_IRUGO | S_IWUSR, \ 961 show_sf2_pwm, store_sf2_pwm, 5, index - 1), \ 962 SENSOR_ATTR_2(temp##index##_auto_point7_pwm, S_IRUGO | S_IWUSR, \ 963 show_sf2_pwm, store_sf2_pwm, 6, index - 1), \ 964 SENSOR_ATTR_2(temp##index##_auto_point1_temp, S_IRUGO | S_IWUSR,\ 965 show_sf2_temp, store_sf2_temp, 0, index - 1), \ 966 SENSOR_ATTR_2(temp##index##_auto_point2_temp, S_IRUGO | S_IWUSR,\ 967 show_sf2_temp, store_sf2_temp, 1, index - 1), \ 968 SENSOR_ATTR_2(temp##index##_auto_point3_temp, S_IRUGO | S_IWUSR,\ 969 show_sf2_temp, store_sf2_temp, 2, index - 1), \ 970 SENSOR_ATTR_2(temp##index##_auto_point4_temp, S_IRUGO | S_IWUSR,\ 971 show_sf2_temp, store_sf2_temp, 3, index - 1), \ 972 SENSOR_ATTR_2(temp##index##_auto_point5_temp, S_IRUGO | S_IWUSR,\ 973 show_sf2_temp, store_sf2_temp, 4, index - 1), \ 974 SENSOR_ATTR_2(temp##index##_auto_point6_temp, S_IRUGO | S_IWUSR,\ 975 show_sf2_temp, store_sf2_temp, 5, index - 1), \ 976 SENSOR_ATTR_2(temp##index##_auto_point7_temp, S_IRUGO | S_IWUSR,\ 977 show_sf2_temp, store_sf2_temp, 6, index - 1) 978 979 static struct sensor_device_attribute_2 w83793_sensor_attr_2[] = { 980 SENSOR_ATTR_IN(0), 981 SENSOR_ATTR_IN(1), 982 SENSOR_ATTR_IN(2), 983 SENSOR_ATTR_IN(3), 984 SENSOR_ATTR_IN(4), 985 SENSOR_ATTR_IN(5), 986 SENSOR_ATTR_IN(6), 987 SENSOR_ATTR_IN(7), 988 SENSOR_ATTR_IN(8), 989 SENSOR_ATTR_IN(9), 990 SENSOR_ATTR_FAN(1), 991 SENSOR_ATTR_FAN(2), 992 SENSOR_ATTR_FAN(3), 993 SENSOR_ATTR_FAN(4), 994 SENSOR_ATTR_FAN(5), 995 SENSOR_ATTR_PWM(1), 996 SENSOR_ATTR_PWM(2), 997 SENSOR_ATTR_PWM(3), 998 }; 999 1000 static struct sensor_device_attribute_2 w83793_temp[] = { 1001 SENSOR_ATTR_TEMP(1), 1002 SENSOR_ATTR_TEMP(2), 1003 SENSOR_ATTR_TEMP(3), 1004 SENSOR_ATTR_TEMP(4), 1005 SENSOR_ATTR_TEMP(5), 1006 SENSOR_ATTR_TEMP(6), 1007 }; 1008 1009 /* Fan6-Fan12 */ 1010 static struct sensor_device_attribute_2 w83793_left_fan[] = { 1011 SENSOR_ATTR_FAN(6), 1012 SENSOR_ATTR_FAN(7), 1013 SENSOR_ATTR_FAN(8), 1014 SENSOR_ATTR_FAN(9), 1015 SENSOR_ATTR_FAN(10), 1016 SENSOR_ATTR_FAN(11), 1017 SENSOR_ATTR_FAN(12), 1018 }; 1019 1020 /* Pwm4-Pwm8 */ 1021 static struct sensor_device_attribute_2 w83793_left_pwm[] = { 1022 SENSOR_ATTR_PWM(4), 1023 SENSOR_ATTR_PWM(5), 1024 SENSOR_ATTR_PWM(6), 1025 SENSOR_ATTR_PWM(7), 1026 SENSOR_ATTR_PWM(8), 1027 }; 1028 1029 static struct sensor_device_attribute_2 w83793_vid[] = { 1030 SENSOR_ATTR_2(cpu0_vid, S_IRUGO, show_vid, NULL, NOT_USED, 0), 1031 SENSOR_ATTR_2(cpu1_vid, S_IRUGO, show_vid, NULL, NOT_USED, 1), 1032 }; 1033 1034 static struct sensor_device_attribute_2 sda_single_files[] = { 1035 SENSOR_ATTR_2(vrm, S_IWUSR | S_IRUGO, show_vrm, store_vrm, 1036 NOT_USED, NOT_USED), 1037 SENSOR_ATTR_2(chassis, S_IWUSR | S_IRUGO, show_alarm_beep, 1038 store_chassis_clear, ALARM_STATUS, 30), 1039 SENSOR_ATTR_2(beep_enable, S_IWUSR | S_IRUGO, show_beep_enable, 1040 store_beep_enable, NOT_USED, NOT_USED), 1041 SENSOR_ATTR_2(pwm_default, S_IWUSR | S_IRUGO, show_sf_setup, 1042 store_sf_setup, SETUP_PWM_DEFAULT, NOT_USED), 1043 SENSOR_ATTR_2(pwm_uptime, S_IWUSR | S_IRUGO, show_sf_setup, 1044 store_sf_setup, SETUP_PWM_UPTIME, NOT_USED), 1045 SENSOR_ATTR_2(pwm_downtime, S_IWUSR | S_IRUGO, show_sf_setup, 1046 store_sf_setup, SETUP_PWM_DOWNTIME, NOT_USED), 1047 SENSOR_ATTR_2(temp_critical, S_IWUSR | S_IRUGO, show_sf_setup, 1048 store_sf_setup, SETUP_TEMP_CRITICAL, NOT_USED), 1049 }; 1050 1051 static void w83793_init_client(struct i2c_client *client) 1052 { 1053 if (reset) { 1054 w83793_write_value(client, W83793_REG_CONFIG, 0x80); 1055 } 1056 1057 /* Start monitoring */ 1058 w83793_write_value(client, W83793_REG_CONFIG, 1059 w83793_read_value(client, W83793_REG_CONFIG) | 0x01); 1060 1061 } 1062 1063 static int w83793_attach_adapter(struct i2c_adapter *adapter) 1064 { 1065 if (!(adapter->class & I2C_CLASS_HWMON)) 1066 return 0; 1067 return i2c_probe(adapter, &addr_data, w83793_detect); 1068 } 1069 1070 static int w83793_detach_client(struct i2c_client *client) 1071 { 1072 struct w83793_data *data = i2c_get_clientdata(client); 1073 struct device *dev = &client->dev; 1074 int err, i; 1075 1076 /* main client */ 1077 if (data) { 1078 hwmon_device_unregister(data->hwmon_dev); 1079 1080 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++) 1081 device_remove_file(dev, 1082 &w83793_sensor_attr_2[i].dev_attr); 1083 1084 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++) 1085 device_remove_file(dev, &sda_single_files[i].dev_attr); 1086 1087 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++) 1088 device_remove_file(dev, &w83793_vid[i].dev_attr); 1089 1090 for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++) 1091 device_remove_file(dev, &w83793_left_fan[i].dev_attr); 1092 1093 for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++) 1094 device_remove_file(dev, &w83793_left_pwm[i].dev_attr); 1095 1096 for (i = 0; i < ARRAY_SIZE(w83793_temp); i++) 1097 device_remove_file(dev, &w83793_temp[i].dev_attr); 1098 } 1099 1100 if ((err = i2c_detach_client(client))) 1101 return err; 1102 1103 /* main client */ 1104 if (data) 1105 kfree(data); 1106 /* subclient */ 1107 else 1108 kfree(client); 1109 1110 return 0; 1111 } 1112 1113 static int 1114 w83793_create_subclient(struct i2c_adapter *adapter, 1115 struct i2c_client *client, int addr, 1116 struct i2c_client **sub_cli) 1117 { 1118 int err = 0; 1119 struct i2c_client *sub_client; 1120 1121 (*sub_cli) = sub_client = 1122 kzalloc(sizeof(struct i2c_client), GFP_KERNEL); 1123 if (!(sub_client)) { 1124 return -ENOMEM; 1125 } 1126 sub_client->addr = 0x48 + addr; 1127 i2c_set_clientdata(sub_client, NULL); 1128 sub_client->adapter = adapter; 1129 sub_client->driver = &w83793_driver; 1130 strlcpy(sub_client->name, "w83793 subclient", I2C_NAME_SIZE); 1131 if ((err = i2c_attach_client(sub_client))) { 1132 dev_err(&client->dev, "subclient registration " 1133 "at address 0x%x failed\n", sub_client->addr); 1134 kfree(sub_client); 1135 } 1136 return err; 1137 } 1138 1139 static int 1140 w83793_detect_subclients(struct i2c_adapter *adapter, int address, 1141 int kind, struct i2c_client *client) 1142 { 1143 int i, id, err; 1144 u8 tmp; 1145 struct w83793_data *data = i2c_get_clientdata(client); 1146 1147 id = i2c_adapter_id(adapter); 1148 if (force_subclients[0] == id && force_subclients[1] == address) { 1149 for (i = 2; i <= 3; i++) { 1150 if (force_subclients[i] < 0x48 1151 || force_subclients[i] > 0x4f) { 1152 dev_err(&client->dev, 1153 "invalid subclient " 1154 "address %d; must be 0x48-0x4f\n", 1155 force_subclients[i]); 1156 err = -EINVAL; 1157 goto ERROR_SC_0; 1158 } 1159 } 1160 w83793_write_value(client, W83793_REG_I2C_SUBADDR, 1161 (force_subclients[2] & 0x07) | 1162 ((force_subclients[3] & 0x07) << 4)); 1163 } 1164 1165 tmp = w83793_read_value(client, W83793_REG_I2C_SUBADDR); 1166 if (!(tmp & 0x08)) { 1167 err = 1168 w83793_create_subclient(adapter, client, tmp & 0x7, 1169 &data->lm75[0]); 1170 if (err < 0) 1171 goto ERROR_SC_0; 1172 } 1173 if (!(tmp & 0x80)) { 1174 if ((data->lm75[0] != NULL) 1175 && ((tmp & 0x7) == ((tmp >> 4) & 0x7))) { 1176 dev_err(&client->dev, 1177 "duplicate addresses 0x%x, " 1178 "use force_subclients\n", data->lm75[0]->addr); 1179 err = -ENODEV; 1180 goto ERROR_SC_1; 1181 } 1182 err = w83793_create_subclient(adapter, client, 1183 (tmp >> 4) & 0x7, &data->lm75[1]); 1184 if (err < 0) 1185 goto ERROR_SC_1; 1186 } 1187 1188 return 0; 1189 1190 /* Undo inits in case of errors */ 1191 1192 ERROR_SC_1: 1193 if (data->lm75[0] != NULL) { 1194 i2c_detach_client(data->lm75[0]); 1195 kfree(data->lm75[0]); 1196 } 1197 ERROR_SC_0: 1198 return err; 1199 } 1200 1201 static int w83793_detect(struct i2c_adapter *adapter, int address, int kind) 1202 { 1203 int i; 1204 u8 tmp, val; 1205 struct i2c_client *client; 1206 struct device *dev; 1207 struct w83793_data *data; 1208 int files_fan = ARRAY_SIZE(w83793_left_fan) / 7; 1209 int files_pwm = ARRAY_SIZE(w83793_left_pwm) / 5; 1210 int files_temp = ARRAY_SIZE(w83793_temp) / 6; 1211 int err = 0; 1212 1213 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 1214 goto exit; 1215 } 1216 1217 /* OK. For now, we presume we have a valid client. We now create the 1218 client structure, even though we cannot fill it completely yet. 1219 But it allows us to access w83793_{read,write}_value. */ 1220 1221 if (!(data = kzalloc(sizeof(struct w83793_data), GFP_KERNEL))) { 1222 err = -ENOMEM; 1223 goto exit; 1224 } 1225 1226 client = &data->client; 1227 dev = &client->dev; 1228 i2c_set_clientdata(client, data); 1229 client->addr = address; 1230 client->adapter = adapter; 1231 client->driver = &w83793_driver; 1232 1233 data->bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL); 1234 1235 /* Now, we do the remaining detection. */ 1236 if (kind < 0) { 1237 tmp = data->bank & 0x80 ? 0x5c : 0xa3; 1238 /* Check Winbond vendor ID */ 1239 if (tmp != i2c_smbus_read_byte_data(client, 1240 W83793_REG_VENDORID)) { 1241 pr_debug("w83793: Detection failed at check " 1242 "vendor id\n"); 1243 err = -ENODEV; 1244 goto free_mem; 1245 } 1246 1247 /* If Winbond chip, address of chip and W83793_REG_I2C_ADDR 1248 should match */ 1249 if ((data->bank & 0x07) == 0 1250 && i2c_smbus_read_byte_data(client, W83793_REG_I2C_ADDR) != 1251 (address << 1)) { 1252 pr_debug("w83793: Detection failed at check " 1253 "i2c addr\n"); 1254 err = -ENODEV; 1255 goto free_mem; 1256 } 1257 1258 } 1259 1260 /* We have either had a force parameter, or we have already detected the 1261 Winbond. Determine the chip type now */ 1262 1263 if (kind <= 0) { 1264 if (0x7b == w83793_read_value(client, W83793_REG_CHIPID)) { 1265 kind = w83793; 1266 } else { 1267 if (kind == 0) 1268 dev_warn(&adapter->dev, "w83793: Ignoring " 1269 "'force' parameter for unknown chip " 1270 "at address 0x%02x\n", address); 1271 err = -ENODEV; 1272 goto free_mem; 1273 } 1274 } 1275 1276 /* Fill in the remaining client fields and put into the global list */ 1277 strlcpy(client->name, "w83793", I2C_NAME_SIZE); 1278 1279 mutex_init(&data->update_lock); 1280 1281 /* Tell the I2C layer a new client has arrived */ 1282 if ((err = i2c_attach_client(client))) 1283 goto free_mem; 1284 1285 if ((err = w83793_detect_subclients(adapter, address, kind, client))) 1286 goto detach_client; 1287 1288 /* Initialize the chip */ 1289 w83793_init_client(client); 1290 1291 data->vrm = vid_which_vrm(); 1292 /* 1293 Only fan 1-5 has their own input pins, 1294 Pwm 1-3 has their own pins 1295 */ 1296 data->has_fan = 0x1f; 1297 data->has_pwm = 0x07; 1298 tmp = w83793_read_value(client, W83793_REG_MFC); 1299 val = w83793_read_value(client, W83793_REG_FANIN_CTRL); 1300 1301 /* check the function of pins 49-56 */ 1302 if (!(tmp & 0x80)) { 1303 data->has_pwm |= 0x18; /* pwm 4,5 */ 1304 if (val & 0x01) { /* fan 6 */ 1305 data->has_fan |= 0x20; 1306 data->has_pwm |= 0x20; 1307 } 1308 if (val & 0x02) { /* fan 7 */ 1309 data->has_fan |= 0x40; 1310 data->has_pwm |= 0x40; 1311 } 1312 if (!(tmp & 0x40) && (val & 0x04)) { /* fan 8 */ 1313 data->has_fan |= 0x80; 1314 data->has_pwm |= 0x80; 1315 } 1316 } 1317 1318 if (0x08 == (tmp & 0x0c)) { 1319 if (val & 0x08) /* fan 9 */ 1320 data->has_fan |= 0x100; 1321 if (val & 0x10) /* fan 10 */ 1322 data->has_fan |= 0x200; 1323 } 1324 1325 if (0x20 == (tmp & 0x30)) { 1326 if (val & 0x20) /* fan 11 */ 1327 data->has_fan |= 0x400; 1328 if (val & 0x40) /* fan 12 */ 1329 data->has_fan |= 0x800; 1330 } 1331 1332 if ((tmp & 0x01) && (val & 0x04)) { /* fan 8, second location */ 1333 data->has_fan |= 0x80; 1334 data->has_pwm |= 0x80; 1335 } 1336 1337 tmp = w83793_read_value(client, W83793_REG_FANIN_SEL); 1338 if ((tmp & 0x01) && (val & 0x08)) { /* fan 9, second location */ 1339 data->has_fan |= 0x100; 1340 } 1341 if ((tmp & 0x02) && (val & 0x10)) { /* fan 10, second location */ 1342 data->has_fan |= 0x200; 1343 } 1344 if ((tmp & 0x04) && (val & 0x20)) { /* fan 11, second location */ 1345 data->has_fan |= 0x400; 1346 } 1347 if ((tmp & 0x08) && (val & 0x40)) { /* fan 12, second location */ 1348 data->has_fan |= 0x800; 1349 } 1350 1351 /* check the temp1-6 mode, ignore former AMDSI selected inputs */ 1352 tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[0]); 1353 if (tmp & 0x01) 1354 data->has_temp |= 0x01; 1355 if (tmp & 0x04) 1356 data->has_temp |= 0x02; 1357 if (tmp & 0x10) 1358 data->has_temp |= 0x04; 1359 if (tmp & 0x40) 1360 data->has_temp |= 0x08; 1361 1362 tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[1]); 1363 if (tmp & 0x01) 1364 data->has_temp |= 0x10; 1365 if (tmp & 0x02) 1366 data->has_temp |= 0x20; 1367 1368 /* Detect the VID usage and ignore unused input */ 1369 tmp = w83793_read_value(client, W83793_REG_MFC); 1370 if (!(tmp & 0x29)) 1371 data->has_vid |= 0x1; /* has VIDA */ 1372 if (tmp & 0x80) 1373 data->has_vid |= 0x2; /* has VIDB */ 1374 1375 /* Register sysfs hooks */ 1376 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++) { 1377 err = device_create_file(dev, 1378 &w83793_sensor_attr_2[i].dev_attr); 1379 if (err) 1380 goto exit_remove; 1381 } 1382 1383 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++) { 1384 if (!(data->has_vid & (1 << i))) 1385 continue; 1386 err = device_create_file(dev, &w83793_vid[i].dev_attr); 1387 if (err) 1388 goto exit_remove; 1389 } 1390 1391 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++) { 1392 err = device_create_file(dev, &sda_single_files[i].dev_attr); 1393 if (err) 1394 goto exit_remove; 1395 1396 } 1397 1398 for (i = 0; i < 6; i++) { 1399 int j; 1400 if (!(data->has_temp & (1 << i))) 1401 continue; 1402 for (j = 0; j < files_temp; j++) { 1403 err = device_create_file(dev, 1404 &w83793_temp[(i) * files_temp 1405 + j].dev_attr); 1406 if (err) 1407 goto exit_remove; 1408 } 1409 } 1410 1411 for (i = 5; i < 12; i++) { 1412 int j; 1413 if (!(data->has_fan & (1 << i))) 1414 continue; 1415 for (j = 0; j < files_fan; j++) { 1416 err = device_create_file(dev, 1417 &w83793_left_fan[(i - 5) * files_fan 1418 + j].dev_attr); 1419 if (err) 1420 goto exit_remove; 1421 } 1422 } 1423 1424 for (i = 3; i < 8; i++) { 1425 int j; 1426 if (!(data->has_pwm & (1 << i))) 1427 continue; 1428 for (j = 0; j < files_pwm; j++) { 1429 err = device_create_file(dev, 1430 &w83793_left_pwm[(i - 3) * files_pwm 1431 + j].dev_attr); 1432 if (err) 1433 goto exit_remove; 1434 } 1435 } 1436 1437 data->hwmon_dev = hwmon_device_register(dev); 1438 if (IS_ERR(data->hwmon_dev)) { 1439 err = PTR_ERR(data->hwmon_dev); 1440 goto exit_remove; 1441 } 1442 1443 return 0; 1444 1445 /* Unregister sysfs hooks */ 1446 1447 exit_remove: 1448 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++) 1449 device_remove_file(dev, &w83793_sensor_attr_2[i].dev_attr); 1450 1451 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++) 1452 device_remove_file(dev, &sda_single_files[i].dev_attr); 1453 1454 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++) 1455 device_remove_file(dev, &w83793_vid[i].dev_attr); 1456 1457 for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++) 1458 device_remove_file(dev, &w83793_left_fan[i].dev_attr); 1459 1460 for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++) 1461 device_remove_file(dev, &w83793_left_pwm[i].dev_attr); 1462 1463 for (i = 0; i < ARRAY_SIZE(w83793_temp); i++) 1464 device_remove_file(dev, &w83793_temp[i].dev_attr); 1465 1466 if (data->lm75[0] != NULL) { 1467 i2c_detach_client(data->lm75[0]); 1468 kfree(data->lm75[0]); 1469 } 1470 if (data->lm75[1] != NULL) { 1471 i2c_detach_client(data->lm75[1]); 1472 kfree(data->lm75[1]); 1473 } 1474 detach_client: 1475 i2c_detach_client(client); 1476 free_mem: 1477 kfree(data); 1478 exit: 1479 return err; 1480 } 1481 1482 static void w83793_update_nonvolatile(struct device *dev) 1483 { 1484 struct i2c_client *client = to_i2c_client(dev); 1485 struct w83793_data *data = i2c_get_clientdata(client); 1486 int i, j; 1487 /* 1488 They are somewhat "stable" registers, and to update them everytime 1489 takes so much time, it's just not worthy. Update them in a long 1490 interval to avoid exception. 1491 */ 1492 if (!(time_after(jiffies, data->last_nonvolatile + HZ * 300) 1493 || !data->valid)) 1494 return; 1495 /* update voltage limits */ 1496 for (i = 1; i < 3; i++) { 1497 for (j = 0; j < ARRAY_SIZE(data->in); j++) { 1498 data->in[j][i] = 1499 w83793_read_value(client, W83793_REG_IN[j][i]); 1500 } 1501 data->in_low_bits[i] = 1502 w83793_read_value(client, W83793_REG_IN_LOW_BITS[i]); 1503 } 1504 1505 for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) { 1506 /* Update the Fan measured value and limits */ 1507 if (!(data->has_fan & (1 << i))) { 1508 continue; 1509 } 1510 data->fan_min[i] = 1511 w83793_read_value(client, W83793_REG_FAN_MIN(i)) << 8; 1512 data->fan_min[i] |= 1513 w83793_read_value(client, W83793_REG_FAN_MIN(i) + 1); 1514 } 1515 1516 for (i = 0; i < ARRAY_SIZE(data->temp_fan_map); i++) { 1517 if (!(data->has_temp & (1 << i))) 1518 continue; 1519 data->temp_fan_map[i] = 1520 w83793_read_value(client, W83793_REG_TEMP_FAN_MAP(i)); 1521 for (j = 1; j < 5; j++) { 1522 data->temp[i][j] = 1523 w83793_read_value(client, W83793_REG_TEMP[i][j]); 1524 } 1525 data->temp_cruise[i] = 1526 w83793_read_value(client, W83793_REG_TEMP_CRUISE(i)); 1527 for (j = 0; j < 7; j++) { 1528 data->sf2_pwm[i][j] = 1529 w83793_read_value(client, W83793_REG_SF2_PWM(i, j)); 1530 data->sf2_temp[i][j] = 1531 w83793_read_value(client, 1532 W83793_REG_SF2_TEMP(i, j)); 1533 } 1534 } 1535 1536 for (i = 0; i < ARRAY_SIZE(data->temp_mode); i++) 1537 data->temp_mode[i] = 1538 w83793_read_value(client, W83793_REG_TEMP_MODE[i]); 1539 1540 for (i = 0; i < ARRAY_SIZE(data->tolerance); i++) { 1541 data->tolerance[i] = 1542 w83793_read_value(client, W83793_REG_TEMP_TOL(i)); 1543 } 1544 1545 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) { 1546 if (!(data->has_pwm & (1 << i))) 1547 continue; 1548 data->pwm[i][PWM_NONSTOP] = 1549 w83793_read_value(client, W83793_REG_PWM(i, PWM_NONSTOP)); 1550 data->pwm[i][PWM_START] = 1551 w83793_read_value(client, W83793_REG_PWM(i, PWM_START)); 1552 data->pwm_stop_time[i] = 1553 w83793_read_value(client, W83793_REG_PWM_STOP_TIME(i)); 1554 } 1555 1556 data->pwm_default = w83793_read_value(client, W83793_REG_PWM_DEFAULT); 1557 data->pwm_enable = w83793_read_value(client, W83793_REG_PWM_ENABLE); 1558 data->pwm_uptime = w83793_read_value(client, W83793_REG_PWM_UPTIME); 1559 data->pwm_downtime = w83793_read_value(client, W83793_REG_PWM_DOWNTIME); 1560 data->temp_critical = 1561 w83793_read_value(client, W83793_REG_TEMP_CRITICAL); 1562 data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP); 1563 1564 for (i = 0; i < ARRAY_SIZE(data->beeps); i++) { 1565 data->beeps[i] = w83793_read_value(client, W83793_REG_BEEP(i)); 1566 } 1567 1568 data->last_nonvolatile = jiffies; 1569 } 1570 1571 static struct w83793_data *w83793_update_device(struct device *dev) 1572 { 1573 struct i2c_client *client = to_i2c_client(dev); 1574 struct w83793_data *data = i2c_get_clientdata(client); 1575 int i; 1576 1577 mutex_lock(&data->update_lock); 1578 1579 if (!(time_after(jiffies, data->last_updated + HZ * 2) 1580 || !data->valid)) 1581 goto END; 1582 1583 /* Update the voltages measured value and limits */ 1584 for (i = 0; i < ARRAY_SIZE(data->in); i++) 1585 data->in[i][IN_READ] = 1586 w83793_read_value(client, W83793_REG_IN[i][IN_READ]); 1587 1588 data->in_low_bits[IN_READ] = 1589 w83793_read_value(client, W83793_REG_IN_LOW_BITS[IN_READ]); 1590 1591 for (i = 0; i < ARRAY_SIZE(data->fan); i++) { 1592 if (!(data->has_fan & (1 << i))) { 1593 continue; 1594 } 1595 data->fan[i] = 1596 w83793_read_value(client, W83793_REG_FAN(i)) << 8; 1597 data->fan[i] |= 1598 w83793_read_value(client, W83793_REG_FAN(i) + 1); 1599 } 1600 1601 for (i = 0; i < ARRAY_SIZE(data->temp); i++) { 1602 if (!(data->has_temp & (1 << i))) 1603 continue; 1604 data->temp[i][TEMP_READ] = 1605 w83793_read_value(client, W83793_REG_TEMP[i][TEMP_READ]); 1606 } 1607 1608 data->temp_low_bits = 1609 w83793_read_value(client, W83793_REG_TEMP_LOW_BITS); 1610 1611 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) { 1612 if (data->has_pwm & (1 << i)) 1613 data->pwm[i][PWM_DUTY] = 1614 w83793_read_value(client, 1615 W83793_REG_PWM(i, PWM_DUTY)); 1616 } 1617 1618 for (i = 0; i < ARRAY_SIZE(data->alarms); i++) 1619 data->alarms[i] = 1620 w83793_read_value(client, W83793_REG_ALARM(i)); 1621 if (data->has_vid & 0x01) 1622 data->vid[0] = w83793_read_value(client, W83793_REG_VID_INA); 1623 if (data->has_vid & 0x02) 1624 data->vid[1] = w83793_read_value(client, W83793_REG_VID_INB); 1625 w83793_update_nonvolatile(dev); 1626 data->last_updated = jiffies; 1627 data->valid = 1; 1628 1629 END: 1630 mutex_unlock(&data->update_lock); 1631 return data; 1632 } 1633 1634 /* Ignore the possibility that somebody change bank outside the driver 1635 Must be called with data->update_lock held, except during initialization */ 1636 static u8 w83793_read_value(struct i2c_client *client, u16 reg) 1637 { 1638 struct w83793_data *data = i2c_get_clientdata(client); 1639 u8 res = 0xff; 1640 u8 new_bank = reg >> 8; 1641 1642 new_bank |= data->bank & 0xfc; 1643 if (data->bank != new_bank) { 1644 if (i2c_smbus_write_byte_data 1645 (client, W83793_REG_BANKSEL, new_bank) >= 0) 1646 data->bank = new_bank; 1647 else { 1648 dev_err(&client->dev, 1649 "set bank to %d failed, fall back " 1650 "to bank %d, read reg 0x%x error\n", 1651 new_bank, data->bank, reg); 1652 res = 0x0; /* read 0x0 from the chip */ 1653 goto END; 1654 } 1655 } 1656 res = i2c_smbus_read_byte_data(client, reg & 0xff); 1657 END: 1658 return res; 1659 } 1660 1661 /* Must be called with data->update_lock held, except during initialization */ 1662 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value) 1663 { 1664 struct w83793_data *data = i2c_get_clientdata(client); 1665 int res; 1666 u8 new_bank = reg >> 8; 1667 1668 new_bank |= data->bank & 0xfc; 1669 if (data->bank != new_bank) { 1670 if ((res = i2c_smbus_write_byte_data 1671 (client, W83793_REG_BANKSEL, new_bank)) >= 0) 1672 data->bank = new_bank; 1673 else { 1674 dev_err(&client->dev, 1675 "set bank to %d failed, fall back " 1676 "to bank %d, write reg 0x%x error\n", 1677 new_bank, data->bank, reg); 1678 goto END; 1679 } 1680 } 1681 1682 res = i2c_smbus_write_byte_data(client, reg & 0xff, value); 1683 END: 1684 return res; 1685 } 1686 1687 static int __init sensors_w83793_init(void) 1688 { 1689 return i2c_add_driver(&w83793_driver); 1690 } 1691 1692 static void __exit sensors_w83793_exit(void) 1693 { 1694 i2c_del_driver(&w83793_driver); 1695 } 1696 1697 MODULE_AUTHOR("Yuan Mu"); 1698 MODULE_DESCRIPTION("w83793 driver"); 1699 MODULE_LICENSE("GPL"); 1700 1701 module_init(sensors_w83793_init); 1702 module_exit(sensors_w83793_exit); 1703