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