1 /* 2 w83627ehf - Driver for the hardware monitoring functionality of 3 the Winbond W83627EHF Super-I/O chip 4 Copyright (C) 2005 Jean Delvare <khali@linux-fr.org> 5 Copyright (C) 2006 Yuan Mu (Winbond), 6 Rudolf Marek <r.marek@assembler.cz> 7 David Hubbard <david.c.hubbard@gmail.com> 8 Daniel J Blueman <daniel.blueman@gmail.com> 9 10 Shamelessly ripped from the w83627hf driver 11 Copyright (C) 2003 Mark Studebaker 12 13 Thanks to Leon Moonen, Steve Cliffe and Grant Coady for their help 14 in testing and debugging this driver. 15 16 This driver also supports the W83627EHG, which is the lead-free 17 version of the W83627EHF. 18 19 This program is free software; you can redistribute it and/or modify 20 it under the terms of the GNU General Public License as published by 21 the Free Software Foundation; either version 2 of the License, or 22 (at your option) any later version. 23 24 This program is distributed in the hope that it will be useful, 25 but WITHOUT ANY WARRANTY; without even the implied warranty of 26 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 27 GNU General Public License for more details. 28 29 You should have received a copy of the GNU General Public License 30 along with this program; if not, write to the Free Software 31 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 32 33 34 Supports the following chips: 35 36 Chip #vin #fan #pwm #temp chip IDs man ID 37 w83627ehf 10 5 4 3 0x8850 0x88 0x5ca3 38 0x8860 0xa1 39 w83627dhg 9 5 4 3 0xa020 0xc1 0x5ca3 40 w83627dhg-p 9 5 4 3 0xb070 0xc1 0x5ca3 41 w83667hg 9 5 3 3 0xa510 0xc1 0x5ca3 42 */ 43 44 #include <linux/module.h> 45 #include <linux/init.h> 46 #include <linux/slab.h> 47 #include <linux/jiffies.h> 48 #include <linux/platform_device.h> 49 #include <linux/hwmon.h> 50 #include <linux/hwmon-sysfs.h> 51 #include <linux/hwmon-vid.h> 52 #include <linux/err.h> 53 #include <linux/mutex.h> 54 #include <linux/acpi.h> 55 #include <linux/io.h> 56 #include "lm75.h" 57 58 enum kinds { w83627ehf, w83627dhg, w83627dhg_p, w83667hg }; 59 60 /* used to set data->name = w83627ehf_device_names[data->sio_kind] */ 61 static const char * w83627ehf_device_names[] = { 62 "w83627ehf", 63 "w83627dhg", 64 "w83627dhg", 65 "w83667hg", 66 }; 67 68 static unsigned short force_id; 69 module_param(force_id, ushort, 0); 70 MODULE_PARM_DESC(force_id, "Override the detected device ID"); 71 72 #define DRVNAME "w83627ehf" 73 74 /* 75 * Super-I/O constants and functions 76 */ 77 78 #define W83627EHF_LD_HWM 0x0b 79 #define W83667HG_LD_VID 0x0d 80 81 #define SIO_REG_LDSEL 0x07 /* Logical device select */ 82 #define SIO_REG_DEVID 0x20 /* Device ID (2 bytes) */ 83 #define SIO_REG_EN_VRM10 0x2C /* GPIO3, GPIO4 selection */ 84 #define SIO_REG_ENABLE 0x30 /* Logical device enable */ 85 #define SIO_REG_ADDR 0x60 /* Logical device address (2 bytes) */ 86 #define SIO_REG_VID_CTRL 0xF0 /* VID control */ 87 #define SIO_REG_VID_DATA 0xF1 /* VID data */ 88 89 #define SIO_W83627EHF_ID 0x8850 90 #define SIO_W83627EHG_ID 0x8860 91 #define SIO_W83627DHG_ID 0xa020 92 #define SIO_W83627DHG_P_ID 0xb070 93 #define SIO_W83667HG_ID 0xa510 94 #define SIO_ID_MASK 0xFFF0 95 96 static inline void 97 superio_outb(int ioreg, int reg, int val) 98 { 99 outb(reg, ioreg); 100 outb(val, ioreg + 1); 101 } 102 103 static inline int 104 superio_inb(int ioreg, int reg) 105 { 106 outb(reg, ioreg); 107 return inb(ioreg + 1); 108 } 109 110 static inline void 111 superio_select(int ioreg, int ld) 112 { 113 outb(SIO_REG_LDSEL, ioreg); 114 outb(ld, ioreg + 1); 115 } 116 117 static inline void 118 superio_enter(int ioreg) 119 { 120 outb(0x87, ioreg); 121 outb(0x87, ioreg); 122 } 123 124 static inline void 125 superio_exit(int ioreg) 126 { 127 outb(0x02, ioreg); 128 outb(0x02, ioreg + 1); 129 } 130 131 /* 132 * ISA constants 133 */ 134 135 #define IOREGION_ALIGNMENT ~7 136 #define IOREGION_OFFSET 5 137 #define IOREGION_LENGTH 2 138 #define ADDR_REG_OFFSET 0 139 #define DATA_REG_OFFSET 1 140 141 #define W83627EHF_REG_BANK 0x4E 142 #define W83627EHF_REG_CONFIG 0x40 143 144 /* Not currently used: 145 * REG_MAN_ID has the value 0x5ca3 for all supported chips. 146 * REG_CHIP_ID == 0x88/0xa1/0xc1 depending on chip model. 147 * REG_MAN_ID is at port 0x4f 148 * REG_CHIP_ID is at port 0x58 */ 149 150 static const u16 W83627EHF_REG_FAN[] = { 0x28, 0x29, 0x2a, 0x3f, 0x553 }; 151 static const u16 W83627EHF_REG_FAN_MIN[] = { 0x3b, 0x3c, 0x3d, 0x3e, 0x55c }; 152 153 /* The W83627EHF registers for nr=7,8,9 are in bank 5 */ 154 #define W83627EHF_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \ 155 (0x554 + (((nr) - 7) * 2))) 156 #define W83627EHF_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \ 157 (0x555 + (((nr) - 7) * 2))) 158 #define W83627EHF_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \ 159 (0x550 + (nr) - 7)) 160 161 #define W83627EHF_REG_TEMP1 0x27 162 #define W83627EHF_REG_TEMP1_HYST 0x3a 163 #define W83627EHF_REG_TEMP1_OVER 0x39 164 static const u16 W83627EHF_REG_TEMP[] = { 0x150, 0x250 }; 165 static const u16 W83627EHF_REG_TEMP_HYST[] = { 0x153, 0x253 }; 166 static const u16 W83627EHF_REG_TEMP_OVER[] = { 0x155, 0x255 }; 167 static const u16 W83627EHF_REG_TEMP_CONFIG[] = { 0x152, 0x252 }; 168 169 /* Fan clock dividers are spread over the following five registers */ 170 #define W83627EHF_REG_FANDIV1 0x47 171 #define W83627EHF_REG_FANDIV2 0x4B 172 #define W83627EHF_REG_VBAT 0x5D 173 #define W83627EHF_REG_DIODE 0x59 174 #define W83627EHF_REG_SMI_OVT 0x4C 175 176 #define W83627EHF_REG_ALARM1 0x459 177 #define W83627EHF_REG_ALARM2 0x45A 178 #define W83627EHF_REG_ALARM3 0x45B 179 180 /* SmartFan registers */ 181 #define W83627EHF_REG_FAN_STEPUP_TIME 0x0f 182 #define W83627EHF_REG_FAN_STEPDOWN_TIME 0x0e 183 184 /* DC or PWM output fan configuration */ 185 static const u8 W83627EHF_REG_PWM_ENABLE[] = { 186 0x04, /* SYS FAN0 output mode and PWM mode */ 187 0x04, /* CPU FAN0 output mode and PWM mode */ 188 0x12, /* AUX FAN mode */ 189 0x62, /* CPU FAN1 mode */ 190 }; 191 192 static const u8 W83627EHF_PWM_MODE_SHIFT[] = { 0, 1, 0, 6 }; 193 static const u8 W83627EHF_PWM_ENABLE_SHIFT[] = { 2, 4, 1, 4 }; 194 195 /* FAN Duty Cycle, be used to control */ 196 static const u8 W83627EHF_REG_PWM[] = { 0x01, 0x03, 0x11, 0x61 }; 197 static const u8 W83627EHF_REG_TARGET[] = { 0x05, 0x06, 0x13, 0x63 }; 198 static const u8 W83627EHF_REG_TOLERANCE[] = { 0x07, 0x07, 0x14, 0x62 }; 199 200 /* Advanced Fan control, some values are common for all fans */ 201 static const u8 W83627EHF_REG_FAN_START_OUTPUT[] = { 0x0a, 0x0b, 0x16, 0x65 }; 202 static const u8 W83627EHF_REG_FAN_STOP_OUTPUT[] = { 0x08, 0x09, 0x15, 0x64 }; 203 static const u8 W83627EHF_REG_FAN_STOP_TIME[] = { 0x0c, 0x0d, 0x17, 0x66 }; 204 static const u8 W83627EHF_REG_FAN_MAX_OUTPUT[] = { 0xff, 0x67, 0xff, 0x69 }; 205 static const u8 W83627EHF_REG_FAN_STEP_OUTPUT[] = { 0xff, 0x68, 0xff, 0x6a }; 206 207 /* 208 * Conversions 209 */ 210 211 /* 1 is PWM mode, output in ms */ 212 static inline unsigned int step_time_from_reg(u8 reg, u8 mode) 213 { 214 return mode ? 100 * reg : 400 * reg; 215 } 216 217 static inline u8 step_time_to_reg(unsigned int msec, u8 mode) 218 { 219 return SENSORS_LIMIT((mode ? (msec + 50) / 100 : 220 (msec + 200) / 400), 1, 255); 221 } 222 223 static inline unsigned int 224 fan_from_reg(u8 reg, unsigned int div) 225 { 226 if (reg == 0 || reg == 255) 227 return 0; 228 return 1350000U / (reg * div); 229 } 230 231 static inline unsigned int 232 div_from_reg(u8 reg) 233 { 234 return 1 << reg; 235 } 236 237 static inline int 238 temp1_from_reg(s8 reg) 239 { 240 return reg * 1000; 241 } 242 243 static inline s8 244 temp1_to_reg(long temp, int min, int max) 245 { 246 if (temp <= min) 247 return min / 1000; 248 if (temp >= max) 249 return max / 1000; 250 if (temp < 0) 251 return (temp - 500) / 1000; 252 return (temp + 500) / 1000; 253 } 254 255 /* Some of analog inputs have internal scaling (2x), 8mV is ADC LSB */ 256 257 static u8 scale_in[10] = { 8, 8, 16, 16, 8, 8, 8, 16, 16, 8 }; 258 259 static inline long in_from_reg(u8 reg, u8 nr) 260 { 261 return reg * scale_in[nr]; 262 } 263 264 static inline u8 in_to_reg(u32 val, u8 nr) 265 { 266 return SENSORS_LIMIT(((val + (scale_in[nr] / 2)) / scale_in[nr]), 0, 255); 267 } 268 269 /* 270 * Data structures and manipulation thereof 271 */ 272 273 struct w83627ehf_data { 274 int addr; /* IO base of hw monitor block */ 275 const char *name; 276 277 struct device *hwmon_dev; 278 struct mutex lock; 279 280 struct mutex update_lock; 281 char valid; /* !=0 if following fields are valid */ 282 unsigned long last_updated; /* In jiffies */ 283 284 /* Register values */ 285 u8 in_num; /* number of in inputs we have */ 286 u8 in[10]; /* Register value */ 287 u8 in_max[10]; /* Register value */ 288 u8 in_min[10]; /* Register value */ 289 u8 fan[5]; 290 u8 fan_min[5]; 291 u8 fan_div[5]; 292 u8 has_fan; /* some fan inputs can be disabled */ 293 u8 temp_type[3]; 294 s8 temp1; 295 s8 temp1_max; 296 s8 temp1_max_hyst; 297 s16 temp[2]; 298 s16 temp_max[2]; 299 s16 temp_max_hyst[2]; 300 u32 alarms; 301 302 u8 pwm_mode[4]; /* 0->DC variable voltage, 1->PWM variable duty cycle */ 303 u8 pwm_enable[4]; /* 1->manual 304 2->thermal cruise mode (also called SmartFan I) 305 3->fan speed cruise mode 306 4->variable thermal cruise (also called SmartFan III) */ 307 u8 pwm_num; /* number of pwm */ 308 u8 pwm[4]; 309 u8 target_temp[4]; 310 u8 tolerance[4]; 311 312 u8 fan_start_output[4]; /* minimum fan speed when spinning up */ 313 u8 fan_stop_output[4]; /* minimum fan speed when spinning down */ 314 u8 fan_stop_time[4]; /* time at minimum before disabling fan */ 315 u8 fan_max_output[4]; /* maximum fan speed */ 316 u8 fan_step_output[4]; /* rate of change output value */ 317 318 u8 vid; 319 u8 vrm; 320 321 u8 temp3_disable; 322 u8 in6_skip; 323 }; 324 325 struct w83627ehf_sio_data { 326 int sioreg; 327 enum kinds kind; 328 }; 329 330 static inline int is_word_sized(u16 reg) 331 { 332 return (((reg & 0xff00) == 0x100 333 || (reg & 0xff00) == 0x200) 334 && ((reg & 0x00ff) == 0x50 335 || (reg & 0x00ff) == 0x53 336 || (reg & 0x00ff) == 0x55)); 337 } 338 339 /* Registers 0x50-0x5f are banked */ 340 static inline void w83627ehf_set_bank(struct w83627ehf_data *data, u16 reg) 341 { 342 if ((reg & 0x00f0) == 0x50) { 343 outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET); 344 outb_p(reg >> 8, data->addr + DATA_REG_OFFSET); 345 } 346 } 347 348 /* Not strictly necessary, but play it safe for now */ 349 static inline void w83627ehf_reset_bank(struct w83627ehf_data *data, u16 reg) 350 { 351 if (reg & 0xff00) { 352 outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET); 353 outb_p(0, data->addr + DATA_REG_OFFSET); 354 } 355 } 356 357 static u16 w83627ehf_read_value(struct w83627ehf_data *data, u16 reg) 358 { 359 int res, word_sized = is_word_sized(reg); 360 361 mutex_lock(&data->lock); 362 363 w83627ehf_set_bank(data, reg); 364 outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET); 365 res = inb_p(data->addr + DATA_REG_OFFSET); 366 if (word_sized) { 367 outb_p((reg & 0xff) + 1, 368 data->addr + ADDR_REG_OFFSET); 369 res = (res << 8) + inb_p(data->addr + DATA_REG_OFFSET); 370 } 371 w83627ehf_reset_bank(data, reg); 372 373 mutex_unlock(&data->lock); 374 375 return res; 376 } 377 378 static int w83627ehf_write_value(struct w83627ehf_data *data, u16 reg, u16 value) 379 { 380 int word_sized = is_word_sized(reg); 381 382 mutex_lock(&data->lock); 383 384 w83627ehf_set_bank(data, reg); 385 outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET); 386 if (word_sized) { 387 outb_p(value >> 8, data->addr + DATA_REG_OFFSET); 388 outb_p((reg & 0xff) + 1, 389 data->addr + ADDR_REG_OFFSET); 390 } 391 outb_p(value & 0xff, data->addr + DATA_REG_OFFSET); 392 w83627ehf_reset_bank(data, reg); 393 394 mutex_unlock(&data->lock); 395 return 0; 396 } 397 398 /* This function assumes that the caller holds data->update_lock */ 399 static void w83627ehf_write_fan_div(struct w83627ehf_data *data, int nr) 400 { 401 u8 reg; 402 403 switch (nr) { 404 case 0: 405 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0xcf) 406 | ((data->fan_div[0] & 0x03) << 4); 407 /* fan5 input control bit is write only, compute the value */ 408 reg |= (data->has_fan & (1 << 4)) ? 1 : 0; 409 w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg); 410 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xdf) 411 | ((data->fan_div[0] & 0x04) << 3); 412 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg); 413 break; 414 case 1: 415 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0x3f) 416 | ((data->fan_div[1] & 0x03) << 6); 417 /* fan5 input control bit is write only, compute the value */ 418 reg |= (data->has_fan & (1 << 4)) ? 1 : 0; 419 w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg); 420 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xbf) 421 | ((data->fan_div[1] & 0x04) << 4); 422 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg); 423 break; 424 case 2: 425 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV2) & 0x3f) 426 | ((data->fan_div[2] & 0x03) << 6); 427 w83627ehf_write_value(data, W83627EHF_REG_FANDIV2, reg); 428 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0x7f) 429 | ((data->fan_div[2] & 0x04) << 5); 430 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg); 431 break; 432 case 3: 433 reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0xfc) 434 | (data->fan_div[3] & 0x03); 435 w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg); 436 reg = (w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT) & 0x7f) 437 | ((data->fan_div[3] & 0x04) << 5); 438 w83627ehf_write_value(data, W83627EHF_REG_SMI_OVT, reg); 439 break; 440 case 4: 441 reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0x73) 442 | ((data->fan_div[4] & 0x03) << 2) 443 | ((data->fan_div[4] & 0x04) << 5); 444 w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg); 445 break; 446 } 447 } 448 449 static void w83627ehf_update_fan_div(struct w83627ehf_data *data) 450 { 451 int i; 452 453 i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1); 454 data->fan_div[0] = (i >> 4) & 0x03; 455 data->fan_div[1] = (i >> 6) & 0x03; 456 i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV2); 457 data->fan_div[2] = (i >> 6) & 0x03; 458 i = w83627ehf_read_value(data, W83627EHF_REG_VBAT); 459 data->fan_div[0] |= (i >> 3) & 0x04; 460 data->fan_div[1] |= (i >> 4) & 0x04; 461 data->fan_div[2] |= (i >> 5) & 0x04; 462 if (data->has_fan & ((1 << 3) | (1 << 4))) { 463 i = w83627ehf_read_value(data, W83627EHF_REG_DIODE); 464 data->fan_div[3] = i & 0x03; 465 data->fan_div[4] = ((i >> 2) & 0x03) 466 | ((i >> 5) & 0x04); 467 } 468 if (data->has_fan & (1 << 3)) { 469 i = w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT); 470 data->fan_div[3] |= (i >> 5) & 0x04; 471 } 472 } 473 474 static struct w83627ehf_data *w83627ehf_update_device(struct device *dev) 475 { 476 struct w83627ehf_data *data = dev_get_drvdata(dev); 477 int pwmcfg = 0, tolerance = 0; /* shut up the compiler */ 478 int i; 479 480 mutex_lock(&data->update_lock); 481 482 if (time_after(jiffies, data->last_updated + HZ + HZ/2) 483 || !data->valid) { 484 /* Fan clock dividers */ 485 w83627ehf_update_fan_div(data); 486 487 /* Measured voltages and limits */ 488 for (i = 0; i < data->in_num; i++) { 489 data->in[i] = w83627ehf_read_value(data, 490 W83627EHF_REG_IN(i)); 491 data->in_min[i] = w83627ehf_read_value(data, 492 W83627EHF_REG_IN_MIN(i)); 493 data->in_max[i] = w83627ehf_read_value(data, 494 W83627EHF_REG_IN_MAX(i)); 495 } 496 497 /* Measured fan speeds and limits */ 498 for (i = 0; i < 5; i++) { 499 if (!(data->has_fan & (1 << i))) 500 continue; 501 502 data->fan[i] = w83627ehf_read_value(data, 503 W83627EHF_REG_FAN[i]); 504 data->fan_min[i] = w83627ehf_read_value(data, 505 W83627EHF_REG_FAN_MIN[i]); 506 507 /* If we failed to measure the fan speed and clock 508 divider can be increased, let's try that for next 509 time */ 510 if (data->fan[i] == 0xff 511 && data->fan_div[i] < 0x07) { 512 dev_dbg(dev, "Increasing fan%d " 513 "clock divider from %u to %u\n", 514 i + 1, div_from_reg(data->fan_div[i]), 515 div_from_reg(data->fan_div[i] + 1)); 516 data->fan_div[i]++; 517 w83627ehf_write_fan_div(data, i); 518 /* Preserve min limit if possible */ 519 if (data->fan_min[i] >= 2 520 && data->fan_min[i] != 255) 521 w83627ehf_write_value(data, 522 W83627EHF_REG_FAN_MIN[i], 523 (data->fan_min[i] /= 2)); 524 } 525 } 526 527 for (i = 0; i < 4; i++) { 528 /* pwmcfg, tolerance mapped for i=0, i=1 to same reg */ 529 if (i != 1) { 530 pwmcfg = w83627ehf_read_value(data, 531 W83627EHF_REG_PWM_ENABLE[i]); 532 tolerance = w83627ehf_read_value(data, 533 W83627EHF_REG_TOLERANCE[i]); 534 } 535 data->pwm_mode[i] = 536 ((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1) 537 ? 0 : 1; 538 data->pwm_enable[i] = 539 ((pwmcfg >> W83627EHF_PWM_ENABLE_SHIFT[i]) 540 & 3) + 1; 541 data->pwm[i] = w83627ehf_read_value(data, 542 W83627EHF_REG_PWM[i]); 543 data->fan_start_output[i] = w83627ehf_read_value(data, 544 W83627EHF_REG_FAN_START_OUTPUT[i]); 545 data->fan_stop_output[i] = w83627ehf_read_value(data, 546 W83627EHF_REG_FAN_STOP_OUTPUT[i]); 547 data->fan_stop_time[i] = w83627ehf_read_value(data, 548 W83627EHF_REG_FAN_STOP_TIME[i]); 549 data->target_temp[i] = 550 w83627ehf_read_value(data, 551 W83627EHF_REG_TARGET[i]) & 552 (data->pwm_mode[i] == 1 ? 0x7f : 0xff); 553 data->tolerance[i] = (tolerance >> (i == 1 ? 4 : 0)) 554 & 0x0f; 555 } 556 557 /* Measured temperatures and limits */ 558 data->temp1 = w83627ehf_read_value(data, 559 W83627EHF_REG_TEMP1); 560 data->temp1_max = w83627ehf_read_value(data, 561 W83627EHF_REG_TEMP1_OVER); 562 data->temp1_max_hyst = w83627ehf_read_value(data, 563 W83627EHF_REG_TEMP1_HYST); 564 for (i = 0; i < 2; i++) { 565 data->temp[i] = w83627ehf_read_value(data, 566 W83627EHF_REG_TEMP[i]); 567 data->temp_max[i] = w83627ehf_read_value(data, 568 W83627EHF_REG_TEMP_OVER[i]); 569 data->temp_max_hyst[i] = w83627ehf_read_value(data, 570 W83627EHF_REG_TEMP_HYST[i]); 571 } 572 573 data->alarms = w83627ehf_read_value(data, 574 W83627EHF_REG_ALARM1) | 575 (w83627ehf_read_value(data, 576 W83627EHF_REG_ALARM2) << 8) | 577 (w83627ehf_read_value(data, 578 W83627EHF_REG_ALARM3) << 16); 579 580 data->last_updated = jiffies; 581 data->valid = 1; 582 } 583 584 mutex_unlock(&data->update_lock); 585 return data; 586 } 587 588 /* 589 * Sysfs callback functions 590 */ 591 #define show_in_reg(reg) \ 592 static ssize_t \ 593 show_##reg(struct device *dev, struct device_attribute *attr, \ 594 char *buf) \ 595 { \ 596 struct w83627ehf_data *data = w83627ehf_update_device(dev); \ 597 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \ 598 int nr = sensor_attr->index; \ 599 return sprintf(buf, "%ld\n", in_from_reg(data->reg[nr], nr)); \ 600 } 601 show_in_reg(in) 602 show_in_reg(in_min) 603 show_in_reg(in_max) 604 605 #define store_in_reg(REG, reg) \ 606 static ssize_t \ 607 store_in_##reg (struct device *dev, struct device_attribute *attr, \ 608 const char *buf, size_t count) \ 609 { \ 610 struct w83627ehf_data *data = dev_get_drvdata(dev); \ 611 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \ 612 int nr = sensor_attr->index; \ 613 u32 val = simple_strtoul(buf, NULL, 10); \ 614 \ 615 mutex_lock(&data->update_lock); \ 616 data->in_##reg[nr] = in_to_reg(val, nr); \ 617 w83627ehf_write_value(data, W83627EHF_REG_IN_##REG(nr), \ 618 data->in_##reg[nr]); \ 619 mutex_unlock(&data->update_lock); \ 620 return count; \ 621 } 622 623 store_in_reg(MIN, min) 624 store_in_reg(MAX, max) 625 626 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, char *buf) 627 { 628 struct w83627ehf_data *data = w83627ehf_update_device(dev); 629 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 630 int nr = sensor_attr->index; 631 return sprintf(buf, "%u\n", (data->alarms >> nr) & 0x01); 632 } 633 634 static struct sensor_device_attribute sda_in_input[] = { 635 SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0), 636 SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1), 637 SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2), 638 SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3), 639 SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4), 640 SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5), 641 SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6), 642 SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7), 643 SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8), 644 SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9), 645 }; 646 647 static struct sensor_device_attribute sda_in_alarm[] = { 648 SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0), 649 SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1), 650 SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2), 651 SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3), 652 SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8), 653 SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 21), 654 SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 20), 655 SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16), 656 SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17), 657 SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 19), 658 }; 659 660 static struct sensor_device_attribute sda_in_min[] = { 661 SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0), 662 SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1), 663 SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2), 664 SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3), 665 SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4), 666 SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5), 667 SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6), 668 SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7), 669 SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8), 670 SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9), 671 }; 672 673 static struct sensor_device_attribute sda_in_max[] = { 674 SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0), 675 SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1), 676 SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2), 677 SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3), 678 SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4), 679 SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5), 680 SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6), 681 SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7), 682 SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8), 683 SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9), 684 }; 685 686 #define show_fan_reg(reg) \ 687 static ssize_t \ 688 show_##reg(struct device *dev, struct device_attribute *attr, \ 689 char *buf) \ 690 { \ 691 struct w83627ehf_data *data = w83627ehf_update_device(dev); \ 692 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \ 693 int nr = sensor_attr->index; \ 694 return sprintf(buf, "%d\n", \ 695 fan_from_reg(data->reg[nr], \ 696 div_from_reg(data->fan_div[nr]))); \ 697 } 698 show_fan_reg(fan); 699 show_fan_reg(fan_min); 700 701 static ssize_t 702 show_fan_div(struct device *dev, struct device_attribute *attr, 703 char *buf) 704 { 705 struct w83627ehf_data *data = w83627ehf_update_device(dev); 706 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 707 int nr = sensor_attr->index; 708 return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr])); 709 } 710 711 static ssize_t 712 store_fan_min(struct device *dev, struct device_attribute *attr, 713 const char *buf, size_t count) 714 { 715 struct w83627ehf_data *data = dev_get_drvdata(dev); 716 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 717 int nr = sensor_attr->index; 718 unsigned int val = simple_strtoul(buf, NULL, 10); 719 unsigned int reg; 720 u8 new_div; 721 722 mutex_lock(&data->update_lock); 723 if (!val) { 724 /* No min limit, alarm disabled */ 725 data->fan_min[nr] = 255; 726 new_div = data->fan_div[nr]; /* No change */ 727 dev_info(dev, "fan%u low limit and alarm disabled\n", nr + 1); 728 } else if ((reg = 1350000U / val) >= 128 * 255) { 729 /* Speed below this value cannot possibly be represented, 730 even with the highest divider (128) */ 731 data->fan_min[nr] = 254; 732 new_div = 7; /* 128 == (1 << 7) */ 733 dev_warn(dev, "fan%u low limit %u below minimum %u, set to " 734 "minimum\n", nr + 1, val, fan_from_reg(254, 128)); 735 } else if (!reg) { 736 /* Speed above this value cannot possibly be represented, 737 even with the lowest divider (1) */ 738 data->fan_min[nr] = 1; 739 new_div = 0; /* 1 == (1 << 0) */ 740 dev_warn(dev, "fan%u low limit %u above maximum %u, set to " 741 "maximum\n", nr + 1, val, fan_from_reg(1, 1)); 742 } else { 743 /* Automatically pick the best divider, i.e. the one such 744 that the min limit will correspond to a register value 745 in the 96..192 range */ 746 new_div = 0; 747 while (reg > 192 && new_div < 7) { 748 reg >>= 1; 749 new_div++; 750 } 751 data->fan_min[nr] = reg; 752 } 753 754 /* Write both the fan clock divider (if it changed) and the new 755 fan min (unconditionally) */ 756 if (new_div != data->fan_div[nr]) { 757 /* Preserve the fan speed reading */ 758 if (data->fan[nr] != 0xff) { 759 if (new_div > data->fan_div[nr]) 760 data->fan[nr] >>= new_div - data->fan_div[nr]; 761 else if (data->fan[nr] & 0x80) 762 data->fan[nr] = 0xff; 763 else 764 data->fan[nr] <<= data->fan_div[nr] - new_div; 765 } 766 767 dev_dbg(dev, "fan%u clock divider changed from %u to %u\n", 768 nr + 1, div_from_reg(data->fan_div[nr]), 769 div_from_reg(new_div)); 770 data->fan_div[nr] = new_div; 771 w83627ehf_write_fan_div(data, nr); 772 /* Give the chip time to sample a new speed value */ 773 data->last_updated = jiffies; 774 } 775 w83627ehf_write_value(data, W83627EHF_REG_FAN_MIN[nr], 776 data->fan_min[nr]); 777 mutex_unlock(&data->update_lock); 778 779 return count; 780 } 781 782 static struct sensor_device_attribute sda_fan_input[] = { 783 SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0), 784 SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1), 785 SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2), 786 SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3), 787 SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4), 788 }; 789 790 static struct sensor_device_attribute sda_fan_alarm[] = { 791 SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6), 792 SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7), 793 SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11), 794 SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 10), 795 SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 23), 796 }; 797 798 static struct sensor_device_attribute sda_fan_min[] = { 799 SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min, 800 store_fan_min, 0), 801 SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min, 802 store_fan_min, 1), 803 SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min, 804 store_fan_min, 2), 805 SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min, 806 store_fan_min, 3), 807 SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min, 808 store_fan_min, 4), 809 }; 810 811 static struct sensor_device_attribute sda_fan_div[] = { 812 SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0), 813 SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1), 814 SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2), 815 SENSOR_ATTR(fan4_div, S_IRUGO, show_fan_div, NULL, 3), 816 SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4), 817 }; 818 819 #define show_temp1_reg(reg) \ 820 static ssize_t \ 821 show_##reg(struct device *dev, struct device_attribute *attr, \ 822 char *buf) \ 823 { \ 824 struct w83627ehf_data *data = w83627ehf_update_device(dev); \ 825 return sprintf(buf, "%d\n", temp1_from_reg(data->reg)); \ 826 } 827 show_temp1_reg(temp1); 828 show_temp1_reg(temp1_max); 829 show_temp1_reg(temp1_max_hyst); 830 831 #define store_temp1_reg(REG, reg) \ 832 static ssize_t \ 833 store_temp1_##reg(struct device *dev, struct device_attribute *attr, \ 834 const char *buf, size_t count) \ 835 { \ 836 struct w83627ehf_data *data = dev_get_drvdata(dev); \ 837 long val = simple_strtol(buf, NULL, 10); \ 838 \ 839 mutex_lock(&data->update_lock); \ 840 data->temp1_##reg = temp1_to_reg(val, -128000, 127000); \ 841 w83627ehf_write_value(data, W83627EHF_REG_TEMP1_##REG, \ 842 data->temp1_##reg); \ 843 mutex_unlock(&data->update_lock); \ 844 return count; \ 845 } 846 store_temp1_reg(OVER, max); 847 store_temp1_reg(HYST, max_hyst); 848 849 #define show_temp_reg(reg) \ 850 static ssize_t \ 851 show_##reg(struct device *dev, struct device_attribute *attr, \ 852 char *buf) \ 853 { \ 854 struct w83627ehf_data *data = w83627ehf_update_device(dev); \ 855 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \ 856 int nr = sensor_attr->index; \ 857 return sprintf(buf, "%d\n", \ 858 LM75_TEMP_FROM_REG(data->reg[nr])); \ 859 } 860 show_temp_reg(temp); 861 show_temp_reg(temp_max); 862 show_temp_reg(temp_max_hyst); 863 864 #define store_temp_reg(REG, reg) \ 865 static ssize_t \ 866 store_##reg(struct device *dev, struct device_attribute *attr, \ 867 const char *buf, size_t count) \ 868 { \ 869 struct w83627ehf_data *data = dev_get_drvdata(dev); \ 870 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \ 871 int nr = sensor_attr->index; \ 872 long val = simple_strtol(buf, NULL, 10); \ 873 \ 874 mutex_lock(&data->update_lock); \ 875 data->reg[nr] = LM75_TEMP_TO_REG(val); \ 876 w83627ehf_write_value(data, W83627EHF_REG_TEMP_##REG[nr], \ 877 data->reg[nr]); \ 878 mutex_unlock(&data->update_lock); \ 879 return count; \ 880 } 881 store_temp_reg(OVER, temp_max); 882 store_temp_reg(HYST, temp_max_hyst); 883 884 static ssize_t 885 show_temp_type(struct device *dev, struct device_attribute *attr, char *buf) 886 { 887 struct w83627ehf_data *data = w83627ehf_update_device(dev); 888 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 889 int nr = sensor_attr->index; 890 return sprintf(buf, "%d\n", (int)data->temp_type[nr]); 891 } 892 893 static struct sensor_device_attribute sda_temp_input[] = { 894 SENSOR_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0), 895 SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0), 896 SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 1), 897 }; 898 899 static struct sensor_device_attribute sda_temp_max[] = { 900 SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1_max, 901 store_temp1_max, 0), 902 SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max, 903 store_temp_max, 0), 904 SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max, 905 store_temp_max, 1), 906 }; 907 908 static struct sensor_device_attribute sda_temp_max_hyst[] = { 909 SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1_max_hyst, 910 store_temp1_max_hyst, 0), 911 SENSOR_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst, 912 store_temp_max_hyst, 0), 913 SENSOR_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst, 914 store_temp_max_hyst, 1), 915 }; 916 917 static struct sensor_device_attribute sda_temp_alarm[] = { 918 SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4), 919 SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5), 920 SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13), 921 }; 922 923 static struct sensor_device_attribute sda_temp_type[] = { 924 SENSOR_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0), 925 SENSOR_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1), 926 SENSOR_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2), 927 }; 928 929 #define show_pwm_reg(reg) \ 930 static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \ 931 char *buf) \ 932 { \ 933 struct w83627ehf_data *data = w83627ehf_update_device(dev); \ 934 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \ 935 int nr = sensor_attr->index; \ 936 return sprintf(buf, "%d\n", data->reg[nr]); \ 937 } 938 939 show_pwm_reg(pwm_mode) 940 show_pwm_reg(pwm_enable) 941 show_pwm_reg(pwm) 942 943 static ssize_t 944 store_pwm_mode(struct device *dev, struct device_attribute *attr, 945 const char *buf, size_t count) 946 { 947 struct w83627ehf_data *data = dev_get_drvdata(dev); 948 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 949 int nr = sensor_attr->index; 950 u32 val = simple_strtoul(buf, NULL, 10); 951 u16 reg; 952 953 if (val > 1) 954 return -EINVAL; 955 mutex_lock(&data->update_lock); 956 reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]); 957 data->pwm_mode[nr] = val; 958 reg &= ~(1 << W83627EHF_PWM_MODE_SHIFT[nr]); 959 if (!val) 960 reg |= 1 << W83627EHF_PWM_MODE_SHIFT[nr]; 961 w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg); 962 mutex_unlock(&data->update_lock); 963 return count; 964 } 965 966 static ssize_t 967 store_pwm(struct device *dev, struct device_attribute *attr, 968 const char *buf, size_t count) 969 { 970 struct w83627ehf_data *data = dev_get_drvdata(dev); 971 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 972 int nr = sensor_attr->index; 973 u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 255); 974 975 mutex_lock(&data->update_lock); 976 data->pwm[nr] = val; 977 w83627ehf_write_value(data, W83627EHF_REG_PWM[nr], val); 978 mutex_unlock(&data->update_lock); 979 return count; 980 } 981 982 static ssize_t 983 store_pwm_enable(struct device *dev, struct device_attribute *attr, 984 const char *buf, size_t count) 985 { 986 struct w83627ehf_data *data = dev_get_drvdata(dev); 987 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 988 int nr = sensor_attr->index; 989 u32 val = simple_strtoul(buf, NULL, 10); 990 u16 reg; 991 992 if (!val || (val > 4)) 993 return -EINVAL; 994 mutex_lock(&data->update_lock); 995 reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]); 996 data->pwm_enable[nr] = val; 997 reg &= ~(0x03 << W83627EHF_PWM_ENABLE_SHIFT[nr]); 998 reg |= (val - 1) << W83627EHF_PWM_ENABLE_SHIFT[nr]; 999 w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg); 1000 mutex_unlock(&data->update_lock); 1001 return count; 1002 } 1003 1004 1005 #define show_tol_temp(reg) \ 1006 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \ 1007 char *buf) \ 1008 { \ 1009 struct w83627ehf_data *data = w83627ehf_update_device(dev); \ 1010 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \ 1011 int nr = sensor_attr->index; \ 1012 return sprintf(buf, "%d\n", temp1_from_reg(data->reg[nr])); \ 1013 } 1014 1015 show_tol_temp(tolerance) 1016 show_tol_temp(target_temp) 1017 1018 static ssize_t 1019 store_target_temp(struct device *dev, struct device_attribute *attr, 1020 const char *buf, size_t count) 1021 { 1022 struct w83627ehf_data *data = dev_get_drvdata(dev); 1023 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 1024 int nr = sensor_attr->index; 1025 u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 127000); 1026 1027 mutex_lock(&data->update_lock); 1028 data->target_temp[nr] = val; 1029 w83627ehf_write_value(data, W83627EHF_REG_TARGET[nr], val); 1030 mutex_unlock(&data->update_lock); 1031 return count; 1032 } 1033 1034 static ssize_t 1035 store_tolerance(struct device *dev, struct device_attribute *attr, 1036 const char *buf, size_t count) 1037 { 1038 struct w83627ehf_data *data = dev_get_drvdata(dev); 1039 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 1040 int nr = sensor_attr->index; 1041 u16 reg; 1042 /* Limit the temp to 0C - 15C */ 1043 u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 15000); 1044 1045 mutex_lock(&data->update_lock); 1046 reg = w83627ehf_read_value(data, W83627EHF_REG_TOLERANCE[nr]); 1047 data->tolerance[nr] = val; 1048 if (nr == 1) 1049 reg = (reg & 0x0f) | (val << 4); 1050 else 1051 reg = (reg & 0xf0) | val; 1052 w83627ehf_write_value(data, W83627EHF_REG_TOLERANCE[nr], reg); 1053 mutex_unlock(&data->update_lock); 1054 return count; 1055 } 1056 1057 static struct sensor_device_attribute sda_pwm[] = { 1058 SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0), 1059 SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1), 1060 SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2), 1061 SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 3), 1062 }; 1063 1064 static struct sensor_device_attribute sda_pwm_mode[] = { 1065 SENSOR_ATTR(pwm1_mode, S_IWUSR | S_IRUGO, show_pwm_mode, 1066 store_pwm_mode, 0), 1067 SENSOR_ATTR(pwm2_mode, S_IWUSR | S_IRUGO, show_pwm_mode, 1068 store_pwm_mode, 1), 1069 SENSOR_ATTR(pwm3_mode, S_IWUSR | S_IRUGO, show_pwm_mode, 1070 store_pwm_mode, 2), 1071 SENSOR_ATTR(pwm4_mode, S_IWUSR | S_IRUGO, show_pwm_mode, 1072 store_pwm_mode, 3), 1073 }; 1074 1075 static struct sensor_device_attribute sda_pwm_enable[] = { 1076 SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_enable, 1077 store_pwm_enable, 0), 1078 SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_enable, 1079 store_pwm_enable, 1), 1080 SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_enable, 1081 store_pwm_enable, 2), 1082 SENSOR_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_enable, 1083 store_pwm_enable, 3), 1084 }; 1085 1086 static struct sensor_device_attribute sda_target_temp[] = { 1087 SENSOR_ATTR(pwm1_target, S_IWUSR | S_IRUGO, show_target_temp, 1088 store_target_temp, 0), 1089 SENSOR_ATTR(pwm2_target, S_IWUSR | S_IRUGO, show_target_temp, 1090 store_target_temp, 1), 1091 SENSOR_ATTR(pwm3_target, S_IWUSR | S_IRUGO, show_target_temp, 1092 store_target_temp, 2), 1093 SENSOR_ATTR(pwm4_target, S_IWUSR | S_IRUGO, show_target_temp, 1094 store_target_temp, 3), 1095 }; 1096 1097 static struct sensor_device_attribute sda_tolerance[] = { 1098 SENSOR_ATTR(pwm1_tolerance, S_IWUSR | S_IRUGO, show_tolerance, 1099 store_tolerance, 0), 1100 SENSOR_ATTR(pwm2_tolerance, S_IWUSR | S_IRUGO, show_tolerance, 1101 store_tolerance, 1), 1102 SENSOR_ATTR(pwm3_tolerance, S_IWUSR | S_IRUGO, show_tolerance, 1103 store_tolerance, 2), 1104 SENSOR_ATTR(pwm4_tolerance, S_IWUSR | S_IRUGO, show_tolerance, 1105 store_tolerance, 3), 1106 }; 1107 1108 /* Smart Fan registers */ 1109 1110 #define fan_functions(reg, REG) \ 1111 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \ 1112 char *buf) \ 1113 { \ 1114 struct w83627ehf_data *data = w83627ehf_update_device(dev); \ 1115 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \ 1116 int nr = sensor_attr->index; \ 1117 return sprintf(buf, "%d\n", data->reg[nr]); \ 1118 }\ 1119 static ssize_t \ 1120 store_##reg(struct device *dev, struct device_attribute *attr, \ 1121 const char *buf, size_t count) \ 1122 {\ 1123 struct w83627ehf_data *data = dev_get_drvdata(dev); \ 1124 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \ 1125 int nr = sensor_attr->index; \ 1126 u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 1, 255); \ 1127 mutex_lock(&data->update_lock); \ 1128 data->reg[nr] = val; \ 1129 w83627ehf_write_value(data, W83627EHF_REG_##REG[nr], val); \ 1130 mutex_unlock(&data->update_lock); \ 1131 return count; \ 1132 } 1133 1134 fan_functions(fan_start_output, FAN_START_OUTPUT) 1135 fan_functions(fan_stop_output, FAN_STOP_OUTPUT) 1136 fan_functions(fan_max_output, FAN_MAX_OUTPUT) 1137 fan_functions(fan_step_output, FAN_STEP_OUTPUT) 1138 1139 #define fan_time_functions(reg, REG) \ 1140 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \ 1141 char *buf) \ 1142 { \ 1143 struct w83627ehf_data *data = w83627ehf_update_device(dev); \ 1144 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \ 1145 int nr = sensor_attr->index; \ 1146 return sprintf(buf, "%d\n", \ 1147 step_time_from_reg(data->reg[nr], data->pwm_mode[nr])); \ 1148 } \ 1149 \ 1150 static ssize_t \ 1151 store_##reg(struct device *dev, struct device_attribute *attr, \ 1152 const char *buf, size_t count) \ 1153 { \ 1154 struct w83627ehf_data *data = dev_get_drvdata(dev); \ 1155 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \ 1156 int nr = sensor_attr->index; \ 1157 u8 val = step_time_to_reg(simple_strtoul(buf, NULL, 10), \ 1158 data->pwm_mode[nr]); \ 1159 mutex_lock(&data->update_lock); \ 1160 data->reg[nr] = val; \ 1161 w83627ehf_write_value(data, W83627EHF_REG_##REG[nr], val); \ 1162 mutex_unlock(&data->update_lock); \ 1163 return count; \ 1164 } \ 1165 1166 fan_time_functions(fan_stop_time, FAN_STOP_TIME) 1167 1168 static ssize_t show_name(struct device *dev, struct device_attribute *attr, 1169 char *buf) 1170 { 1171 struct w83627ehf_data *data = dev_get_drvdata(dev); 1172 1173 return sprintf(buf, "%s\n", data->name); 1174 } 1175 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); 1176 1177 static struct sensor_device_attribute sda_sf3_arrays_fan4[] = { 1178 SENSOR_ATTR(pwm4_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time, 1179 store_fan_stop_time, 3), 1180 SENSOR_ATTR(pwm4_start_output, S_IWUSR | S_IRUGO, show_fan_start_output, 1181 store_fan_start_output, 3), 1182 SENSOR_ATTR(pwm4_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output, 1183 store_fan_stop_output, 3), 1184 SENSOR_ATTR(pwm4_max_output, S_IWUSR | S_IRUGO, show_fan_max_output, 1185 store_fan_max_output, 3), 1186 SENSOR_ATTR(pwm4_step_output, S_IWUSR | S_IRUGO, show_fan_step_output, 1187 store_fan_step_output, 3), 1188 }; 1189 1190 static struct sensor_device_attribute sda_sf3_arrays[] = { 1191 SENSOR_ATTR(pwm1_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time, 1192 store_fan_stop_time, 0), 1193 SENSOR_ATTR(pwm2_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time, 1194 store_fan_stop_time, 1), 1195 SENSOR_ATTR(pwm3_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time, 1196 store_fan_stop_time, 2), 1197 SENSOR_ATTR(pwm1_start_output, S_IWUSR | S_IRUGO, show_fan_start_output, 1198 store_fan_start_output, 0), 1199 SENSOR_ATTR(pwm2_start_output, S_IWUSR | S_IRUGO, show_fan_start_output, 1200 store_fan_start_output, 1), 1201 SENSOR_ATTR(pwm3_start_output, S_IWUSR | S_IRUGO, show_fan_start_output, 1202 store_fan_start_output, 2), 1203 SENSOR_ATTR(pwm1_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output, 1204 store_fan_stop_output, 0), 1205 SENSOR_ATTR(pwm2_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output, 1206 store_fan_stop_output, 1), 1207 SENSOR_ATTR(pwm3_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output, 1208 store_fan_stop_output, 2), 1209 1210 /* pwm1 and pwm3 don't support max and step settings */ 1211 SENSOR_ATTR(pwm2_max_output, S_IWUSR | S_IRUGO, show_fan_max_output, 1212 store_fan_max_output, 1), 1213 SENSOR_ATTR(pwm2_step_output, S_IWUSR | S_IRUGO, show_fan_step_output, 1214 store_fan_step_output, 1), 1215 }; 1216 1217 static ssize_t 1218 show_vid(struct device *dev, struct device_attribute *attr, char *buf) 1219 { 1220 struct w83627ehf_data *data = dev_get_drvdata(dev); 1221 return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm)); 1222 } 1223 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL); 1224 1225 /* 1226 * Driver and device management 1227 */ 1228 1229 static void w83627ehf_device_remove_files(struct device *dev) 1230 { 1231 /* some entries in the following arrays may not have been used in 1232 * device_create_file(), but device_remove_file() will ignore them */ 1233 int i; 1234 struct w83627ehf_data *data = dev_get_drvdata(dev); 1235 1236 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++) 1237 device_remove_file(dev, &sda_sf3_arrays[i].dev_attr); 1238 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++) 1239 device_remove_file(dev, &sda_sf3_arrays_fan4[i].dev_attr); 1240 for (i = 0; i < data->in_num; i++) { 1241 if ((i == 6) && data->in6_skip) 1242 continue; 1243 device_remove_file(dev, &sda_in_input[i].dev_attr); 1244 device_remove_file(dev, &sda_in_alarm[i].dev_attr); 1245 device_remove_file(dev, &sda_in_min[i].dev_attr); 1246 device_remove_file(dev, &sda_in_max[i].dev_attr); 1247 } 1248 for (i = 0; i < 5; i++) { 1249 device_remove_file(dev, &sda_fan_input[i].dev_attr); 1250 device_remove_file(dev, &sda_fan_alarm[i].dev_attr); 1251 device_remove_file(dev, &sda_fan_div[i].dev_attr); 1252 device_remove_file(dev, &sda_fan_min[i].dev_attr); 1253 } 1254 for (i = 0; i < data->pwm_num; i++) { 1255 device_remove_file(dev, &sda_pwm[i].dev_attr); 1256 device_remove_file(dev, &sda_pwm_mode[i].dev_attr); 1257 device_remove_file(dev, &sda_pwm_enable[i].dev_attr); 1258 device_remove_file(dev, &sda_target_temp[i].dev_attr); 1259 device_remove_file(dev, &sda_tolerance[i].dev_attr); 1260 } 1261 for (i = 0; i < 3; i++) { 1262 if ((i == 2) && data->temp3_disable) 1263 continue; 1264 device_remove_file(dev, &sda_temp_input[i].dev_attr); 1265 device_remove_file(dev, &sda_temp_max[i].dev_attr); 1266 device_remove_file(dev, &sda_temp_max_hyst[i].dev_attr); 1267 device_remove_file(dev, &sda_temp_alarm[i].dev_attr); 1268 device_remove_file(dev, &sda_temp_type[i].dev_attr); 1269 } 1270 1271 device_remove_file(dev, &dev_attr_name); 1272 device_remove_file(dev, &dev_attr_cpu0_vid); 1273 } 1274 1275 /* Get the monitoring functions started */ 1276 static inline void __devinit w83627ehf_init_device(struct w83627ehf_data *data) 1277 { 1278 int i; 1279 u8 tmp, diode; 1280 1281 /* Start monitoring is needed */ 1282 tmp = w83627ehf_read_value(data, W83627EHF_REG_CONFIG); 1283 if (!(tmp & 0x01)) 1284 w83627ehf_write_value(data, W83627EHF_REG_CONFIG, 1285 tmp | 0x01); 1286 1287 /* Enable temp2 and temp3 if needed */ 1288 for (i = 0; i < 2; i++) { 1289 tmp = w83627ehf_read_value(data, 1290 W83627EHF_REG_TEMP_CONFIG[i]); 1291 if ((i == 1) && data->temp3_disable) 1292 continue; 1293 if (tmp & 0x01) 1294 w83627ehf_write_value(data, 1295 W83627EHF_REG_TEMP_CONFIG[i], 1296 tmp & 0xfe); 1297 } 1298 1299 /* Enable VBAT monitoring if needed */ 1300 tmp = w83627ehf_read_value(data, W83627EHF_REG_VBAT); 1301 if (!(tmp & 0x01)) 1302 w83627ehf_write_value(data, W83627EHF_REG_VBAT, tmp | 0x01); 1303 1304 /* Get thermal sensor types */ 1305 diode = w83627ehf_read_value(data, W83627EHF_REG_DIODE); 1306 for (i = 0; i < 3; i++) { 1307 if ((tmp & (0x02 << i))) 1308 data->temp_type[i] = (diode & (0x10 << i)) ? 1 : 2; 1309 else 1310 data->temp_type[i] = 4; /* thermistor */ 1311 } 1312 } 1313 1314 static int __devinit w83627ehf_probe(struct platform_device *pdev) 1315 { 1316 struct device *dev = &pdev->dev; 1317 struct w83627ehf_sio_data *sio_data = dev->platform_data; 1318 struct w83627ehf_data *data; 1319 struct resource *res; 1320 u8 fan4pin, fan5pin, en_vrm10; 1321 int i, err = 0; 1322 1323 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 1324 if (!request_region(res->start, IOREGION_LENGTH, DRVNAME)) { 1325 err = -EBUSY; 1326 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n", 1327 (unsigned long)res->start, 1328 (unsigned long)res->start + IOREGION_LENGTH - 1); 1329 goto exit; 1330 } 1331 1332 if (!(data = kzalloc(sizeof(struct w83627ehf_data), GFP_KERNEL))) { 1333 err = -ENOMEM; 1334 goto exit_release; 1335 } 1336 1337 data->addr = res->start; 1338 mutex_init(&data->lock); 1339 mutex_init(&data->update_lock); 1340 data->name = w83627ehf_device_names[sio_data->kind]; 1341 platform_set_drvdata(pdev, data); 1342 1343 /* 627EHG and 627EHF have 10 voltage inputs; 627DHG and 667HG have 9 */ 1344 data->in_num = (sio_data->kind == w83627ehf) ? 10 : 9; 1345 /* 667HG has 3 pwms */ 1346 data->pwm_num = (sio_data->kind == w83667hg) ? 3 : 4; 1347 1348 /* Check temp3 configuration bit for 667HG */ 1349 if (sio_data->kind == w83667hg) { 1350 data->temp3_disable = w83627ehf_read_value(data, 1351 W83627EHF_REG_TEMP_CONFIG[1]) & 0x01; 1352 data->in6_skip = !data->temp3_disable; 1353 } 1354 1355 /* Initialize the chip */ 1356 w83627ehf_init_device(data); 1357 1358 data->vrm = vid_which_vrm(); 1359 superio_enter(sio_data->sioreg); 1360 /* Read VID value */ 1361 if (sio_data->kind == w83667hg) { 1362 /* W83667HG has different pins for VID input and output, so 1363 we can get the VID input values directly at logical device D 1364 0xe3. */ 1365 superio_select(sio_data->sioreg, W83667HG_LD_VID); 1366 data->vid = superio_inb(sio_data->sioreg, 0xe3); 1367 err = device_create_file(dev, &dev_attr_cpu0_vid); 1368 if (err) 1369 goto exit_release; 1370 } else { 1371 superio_select(sio_data->sioreg, W83627EHF_LD_HWM); 1372 if (superio_inb(sio_data->sioreg, SIO_REG_VID_CTRL) & 0x80) { 1373 /* Set VID input sensibility if needed. In theory the 1374 BIOS should have set it, but in practice it's not 1375 always the case. We only do it for the W83627EHF/EHG 1376 because the W83627DHG is more complex in this 1377 respect. */ 1378 if (sio_data->kind == w83627ehf) { 1379 en_vrm10 = superio_inb(sio_data->sioreg, 1380 SIO_REG_EN_VRM10); 1381 if ((en_vrm10 & 0x08) && data->vrm == 90) { 1382 dev_warn(dev, "Setting VID input " 1383 "voltage to TTL\n"); 1384 superio_outb(sio_data->sioreg, 1385 SIO_REG_EN_VRM10, 1386 en_vrm10 & ~0x08); 1387 } else if (!(en_vrm10 & 0x08) 1388 && data->vrm == 100) { 1389 dev_warn(dev, "Setting VID input " 1390 "voltage to VRM10\n"); 1391 superio_outb(sio_data->sioreg, 1392 SIO_REG_EN_VRM10, 1393 en_vrm10 | 0x08); 1394 } 1395 } 1396 1397 data->vid = superio_inb(sio_data->sioreg, 1398 SIO_REG_VID_DATA); 1399 if (sio_data->kind == w83627ehf) /* 6 VID pins only */ 1400 data->vid &= 0x3f; 1401 1402 err = device_create_file(dev, &dev_attr_cpu0_vid); 1403 if (err) 1404 goto exit_release; 1405 } else { 1406 dev_info(dev, "VID pins in output mode, CPU VID not " 1407 "available\n"); 1408 } 1409 } 1410 1411 /* fan4 and fan5 share some pins with the GPIO and serial flash */ 1412 if (sio_data->kind == w83667hg) { 1413 fan5pin = superio_inb(sio_data->sioreg, 0x27) & 0x20; 1414 fan4pin = superio_inb(sio_data->sioreg, 0x27) & 0x40; 1415 } else { 1416 fan5pin = !(superio_inb(sio_data->sioreg, 0x24) & 0x02); 1417 fan4pin = !(superio_inb(sio_data->sioreg, 0x29) & 0x06); 1418 } 1419 superio_exit(sio_data->sioreg); 1420 1421 /* It looks like fan4 and fan5 pins can be alternatively used 1422 as fan on/off switches, but fan5 control is write only :/ 1423 We assume that if the serial interface is disabled, designers 1424 connected fan5 as input unless they are emitting log 1, which 1425 is not the default. */ 1426 1427 data->has_fan = 0x07; /* fan1, fan2 and fan3 */ 1428 i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1); 1429 if ((i & (1 << 2)) && fan4pin) 1430 data->has_fan |= (1 << 3); 1431 if (!(i & (1 << 1)) && fan5pin) 1432 data->has_fan |= (1 << 4); 1433 1434 /* Read fan clock dividers immediately */ 1435 w83627ehf_update_fan_div(data); 1436 1437 /* Register sysfs hooks */ 1438 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++) 1439 if ((err = device_create_file(dev, 1440 &sda_sf3_arrays[i].dev_attr))) 1441 goto exit_remove; 1442 1443 /* if fan4 is enabled create the sf3 files for it */ 1444 if ((data->has_fan & (1 << 3)) && data->pwm_num >= 4) 1445 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++) { 1446 if ((err = device_create_file(dev, 1447 &sda_sf3_arrays_fan4[i].dev_attr))) 1448 goto exit_remove; 1449 } 1450 1451 for (i = 0; i < data->in_num; i++) { 1452 if ((i == 6) && data->in6_skip) 1453 continue; 1454 if ((err = device_create_file(dev, &sda_in_input[i].dev_attr)) 1455 || (err = device_create_file(dev, 1456 &sda_in_alarm[i].dev_attr)) 1457 || (err = device_create_file(dev, 1458 &sda_in_min[i].dev_attr)) 1459 || (err = device_create_file(dev, 1460 &sda_in_max[i].dev_attr))) 1461 goto exit_remove; 1462 } 1463 1464 for (i = 0; i < 5; i++) { 1465 if (data->has_fan & (1 << i)) { 1466 if ((err = device_create_file(dev, 1467 &sda_fan_input[i].dev_attr)) 1468 || (err = device_create_file(dev, 1469 &sda_fan_alarm[i].dev_attr)) 1470 || (err = device_create_file(dev, 1471 &sda_fan_div[i].dev_attr)) 1472 || (err = device_create_file(dev, 1473 &sda_fan_min[i].dev_attr))) 1474 goto exit_remove; 1475 if (i < data->pwm_num && 1476 ((err = device_create_file(dev, 1477 &sda_pwm[i].dev_attr)) 1478 || (err = device_create_file(dev, 1479 &sda_pwm_mode[i].dev_attr)) 1480 || (err = device_create_file(dev, 1481 &sda_pwm_enable[i].dev_attr)) 1482 || (err = device_create_file(dev, 1483 &sda_target_temp[i].dev_attr)) 1484 || (err = device_create_file(dev, 1485 &sda_tolerance[i].dev_attr)))) 1486 goto exit_remove; 1487 } 1488 } 1489 1490 for (i = 0; i < 3; i++) { 1491 if ((i == 2) && data->temp3_disable) 1492 continue; 1493 if ((err = device_create_file(dev, 1494 &sda_temp_input[i].dev_attr)) 1495 || (err = device_create_file(dev, 1496 &sda_temp_max[i].dev_attr)) 1497 || (err = device_create_file(dev, 1498 &sda_temp_max_hyst[i].dev_attr)) 1499 || (err = device_create_file(dev, 1500 &sda_temp_alarm[i].dev_attr)) 1501 || (err = device_create_file(dev, 1502 &sda_temp_type[i].dev_attr))) 1503 goto exit_remove; 1504 } 1505 1506 err = device_create_file(dev, &dev_attr_name); 1507 if (err) 1508 goto exit_remove; 1509 1510 data->hwmon_dev = hwmon_device_register(dev); 1511 if (IS_ERR(data->hwmon_dev)) { 1512 err = PTR_ERR(data->hwmon_dev); 1513 goto exit_remove; 1514 } 1515 1516 return 0; 1517 1518 exit_remove: 1519 w83627ehf_device_remove_files(dev); 1520 kfree(data); 1521 platform_set_drvdata(pdev, NULL); 1522 exit_release: 1523 release_region(res->start, IOREGION_LENGTH); 1524 exit: 1525 return err; 1526 } 1527 1528 static int __devexit w83627ehf_remove(struct platform_device *pdev) 1529 { 1530 struct w83627ehf_data *data = platform_get_drvdata(pdev); 1531 1532 hwmon_device_unregister(data->hwmon_dev); 1533 w83627ehf_device_remove_files(&pdev->dev); 1534 release_region(data->addr, IOREGION_LENGTH); 1535 platform_set_drvdata(pdev, NULL); 1536 kfree(data); 1537 1538 return 0; 1539 } 1540 1541 static struct platform_driver w83627ehf_driver = { 1542 .driver = { 1543 .owner = THIS_MODULE, 1544 .name = DRVNAME, 1545 }, 1546 .probe = w83627ehf_probe, 1547 .remove = __devexit_p(w83627ehf_remove), 1548 }; 1549 1550 /* w83627ehf_find() looks for a '627 in the Super-I/O config space */ 1551 static int __init w83627ehf_find(int sioaddr, unsigned short *addr, 1552 struct w83627ehf_sio_data *sio_data) 1553 { 1554 static const char __initdata sio_name_W83627EHF[] = "W83627EHF"; 1555 static const char __initdata sio_name_W83627EHG[] = "W83627EHG"; 1556 static const char __initdata sio_name_W83627DHG[] = "W83627DHG"; 1557 static const char __initdata sio_name_W83627DHG_P[] = "W83627DHG-P"; 1558 static const char __initdata sio_name_W83667HG[] = "W83667HG"; 1559 1560 u16 val; 1561 const char *sio_name; 1562 1563 superio_enter(sioaddr); 1564 1565 if (force_id) 1566 val = force_id; 1567 else 1568 val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8) 1569 | superio_inb(sioaddr, SIO_REG_DEVID + 1); 1570 switch (val & SIO_ID_MASK) { 1571 case SIO_W83627EHF_ID: 1572 sio_data->kind = w83627ehf; 1573 sio_name = sio_name_W83627EHF; 1574 break; 1575 case SIO_W83627EHG_ID: 1576 sio_data->kind = w83627ehf; 1577 sio_name = sio_name_W83627EHG; 1578 break; 1579 case SIO_W83627DHG_ID: 1580 sio_data->kind = w83627dhg; 1581 sio_name = sio_name_W83627DHG; 1582 break; 1583 case SIO_W83627DHG_P_ID: 1584 sio_data->kind = w83627dhg_p; 1585 sio_name = sio_name_W83627DHG_P; 1586 break; 1587 case SIO_W83667HG_ID: 1588 sio_data->kind = w83667hg; 1589 sio_name = sio_name_W83667HG; 1590 break; 1591 default: 1592 if (val != 0xffff) 1593 pr_debug(DRVNAME ": unsupported chip ID: 0x%04x\n", 1594 val); 1595 superio_exit(sioaddr); 1596 return -ENODEV; 1597 } 1598 1599 /* We have a known chip, find the HWM I/O address */ 1600 superio_select(sioaddr, W83627EHF_LD_HWM); 1601 val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8) 1602 | superio_inb(sioaddr, SIO_REG_ADDR + 1); 1603 *addr = val & IOREGION_ALIGNMENT; 1604 if (*addr == 0) { 1605 printk(KERN_ERR DRVNAME ": Refusing to enable a Super-I/O " 1606 "device with a base I/O port 0.\n"); 1607 superio_exit(sioaddr); 1608 return -ENODEV; 1609 } 1610 1611 /* Activate logical device if needed */ 1612 val = superio_inb(sioaddr, SIO_REG_ENABLE); 1613 if (!(val & 0x01)) { 1614 printk(KERN_WARNING DRVNAME ": Forcibly enabling Super-I/O. " 1615 "Sensor is probably unusable.\n"); 1616 superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01); 1617 } 1618 1619 superio_exit(sioaddr); 1620 pr_info(DRVNAME ": Found %s chip at %#x\n", sio_name, *addr); 1621 sio_data->sioreg = sioaddr; 1622 1623 return 0; 1624 } 1625 1626 /* when Super-I/O functions move to a separate file, the Super-I/O 1627 * bus will manage the lifetime of the device and this module will only keep 1628 * track of the w83627ehf driver. But since we platform_device_alloc(), we 1629 * must keep track of the device */ 1630 static struct platform_device *pdev; 1631 1632 static int __init sensors_w83627ehf_init(void) 1633 { 1634 int err; 1635 unsigned short address; 1636 struct resource res; 1637 struct w83627ehf_sio_data sio_data; 1638 1639 /* initialize sio_data->kind and sio_data->sioreg. 1640 * 1641 * when Super-I/O functions move to a separate file, the Super-I/O 1642 * driver will probe 0x2e and 0x4e and auto-detect the presence of a 1643 * w83627ehf hardware monitor, and call probe() */ 1644 if (w83627ehf_find(0x2e, &address, &sio_data) && 1645 w83627ehf_find(0x4e, &address, &sio_data)) 1646 return -ENODEV; 1647 1648 err = platform_driver_register(&w83627ehf_driver); 1649 if (err) 1650 goto exit; 1651 1652 if (!(pdev = platform_device_alloc(DRVNAME, address))) { 1653 err = -ENOMEM; 1654 printk(KERN_ERR DRVNAME ": Device allocation failed\n"); 1655 goto exit_unregister; 1656 } 1657 1658 err = platform_device_add_data(pdev, &sio_data, 1659 sizeof(struct w83627ehf_sio_data)); 1660 if (err) { 1661 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n"); 1662 goto exit_device_put; 1663 } 1664 1665 memset(&res, 0, sizeof(res)); 1666 res.name = DRVNAME; 1667 res.start = address + IOREGION_OFFSET; 1668 res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1; 1669 res.flags = IORESOURCE_IO; 1670 1671 err = acpi_check_resource_conflict(&res); 1672 if (err) 1673 goto exit_device_put; 1674 1675 err = platform_device_add_resources(pdev, &res, 1); 1676 if (err) { 1677 printk(KERN_ERR DRVNAME ": Device resource addition failed " 1678 "(%d)\n", err); 1679 goto exit_device_put; 1680 } 1681 1682 /* platform_device_add calls probe() */ 1683 err = platform_device_add(pdev); 1684 if (err) { 1685 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n", 1686 err); 1687 goto exit_device_put; 1688 } 1689 1690 return 0; 1691 1692 exit_device_put: 1693 platform_device_put(pdev); 1694 exit_unregister: 1695 platform_driver_unregister(&w83627ehf_driver); 1696 exit: 1697 return err; 1698 } 1699 1700 static void __exit sensors_w83627ehf_exit(void) 1701 { 1702 platform_device_unregister(pdev); 1703 platform_driver_unregister(&w83627ehf_driver); 1704 } 1705 1706 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>"); 1707 MODULE_DESCRIPTION("W83627EHF driver"); 1708 MODULE_LICENSE("GPL"); 1709 1710 module_init(sensors_w83627ehf_init); 1711 module_exit(sensors_w83627ehf_exit); 1712