1 /* 2 w83781d.c - Part of lm_sensors, Linux kernel modules for hardware 3 monitoring 4 Copyright (c) 1998 - 2001 Frodo Looijaard <frodol@dds.nl>, 5 Philip Edelbrock <phil@netroedge.com>, 6 and Mark Studebaker <mdsxyz123@yahoo.com> 7 Copyright (c) 2007 - 2008 Jean Delvare <khali@linux-fr.org> 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 */ 23 24 /* 25 Supports following chips: 26 27 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA 28 as99127f 7 3 0 3 0x31 0x12c3 yes no 29 as99127f rev.2 (type_name = as99127f) 0x31 0x5ca3 yes no 30 w83781d 7 3 0 3 0x10-1 0x5ca3 yes yes 31 w83782d 9 3 2-4 3 0x30 0x5ca3 yes yes 32 w83783s 5-6 3 2 1-2 0x40 0x5ca3 yes no 33 34 */ 35 36 #include <linux/module.h> 37 #include <linux/init.h> 38 #include <linux/slab.h> 39 #include <linux/jiffies.h> 40 #include <linux/i2c.h> 41 #include <linux/hwmon.h> 42 #include <linux/hwmon-vid.h> 43 #include <linux/hwmon-sysfs.h> 44 #include <linux/sysfs.h> 45 #include <linux/err.h> 46 #include <linux/mutex.h> 47 48 #ifdef CONFIG_ISA 49 #include <linux/platform_device.h> 50 #include <linux/ioport.h> 51 #include <asm/io.h> 52 #endif 53 54 #include "lm75.h" 55 56 /* Addresses to scan */ 57 static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 58 0x2e, 0x2f, I2C_CLIENT_END }; 59 /* Insmod parameters */ 60 I2C_CLIENT_INSMOD_4(w83781d, w83782d, w83783s, as99127f); 61 62 static unsigned short force_subclients[4]; 63 module_param_array(force_subclients, short, NULL, 0); 64 MODULE_PARM_DESC(force_subclients, "List of subclient addresses: " 65 "{bus, clientaddr, subclientaddr1, subclientaddr2}"); 66 67 static int reset; 68 module_param(reset, bool, 0); 69 MODULE_PARM_DESC(reset, "Set to one to reset chip on load"); 70 71 static int init = 1; 72 module_param(init, bool, 0); 73 MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization"); 74 75 /* Constants specified below */ 76 77 /* Length of ISA address segment */ 78 #define W83781D_EXTENT 8 79 80 /* Where are the ISA address/data registers relative to the base address */ 81 #define W83781D_ADDR_REG_OFFSET 5 82 #define W83781D_DATA_REG_OFFSET 6 83 84 /* The device registers */ 85 /* in nr from 0 to 8 */ 86 #define W83781D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \ 87 (0x554 + (((nr) - 7) * 2))) 88 #define W83781D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \ 89 (0x555 + (((nr) - 7) * 2))) 90 #define W83781D_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \ 91 (0x550 + (nr) - 7)) 92 93 /* fan nr from 0 to 2 */ 94 #define W83781D_REG_FAN_MIN(nr) (0x3b + (nr)) 95 #define W83781D_REG_FAN(nr) (0x28 + (nr)) 96 97 #define W83781D_REG_BANK 0x4E 98 #define W83781D_REG_TEMP2_CONFIG 0x152 99 #define W83781D_REG_TEMP3_CONFIG 0x252 100 /* temp nr from 1 to 3 */ 101 #define W83781D_REG_TEMP(nr) ((nr == 3) ? (0x0250) : \ 102 ((nr == 2) ? (0x0150) : \ 103 (0x27))) 104 #define W83781D_REG_TEMP_HYST(nr) ((nr == 3) ? (0x253) : \ 105 ((nr == 2) ? (0x153) : \ 106 (0x3A))) 107 #define W83781D_REG_TEMP_OVER(nr) ((nr == 3) ? (0x255) : \ 108 ((nr == 2) ? (0x155) : \ 109 (0x39))) 110 111 #define W83781D_REG_CONFIG 0x40 112 113 /* Interrupt status (W83781D, AS99127F) */ 114 #define W83781D_REG_ALARM1 0x41 115 #define W83781D_REG_ALARM2 0x42 116 117 /* Real-time status (W83782D, W83783S) */ 118 #define W83782D_REG_ALARM1 0x459 119 #define W83782D_REG_ALARM2 0x45A 120 #define W83782D_REG_ALARM3 0x45B 121 122 #define W83781D_REG_BEEP_CONFIG 0x4D 123 #define W83781D_REG_BEEP_INTS1 0x56 124 #define W83781D_REG_BEEP_INTS2 0x57 125 #define W83781D_REG_BEEP_INTS3 0x453 /* not on W83781D */ 126 127 #define W83781D_REG_VID_FANDIV 0x47 128 129 #define W83781D_REG_CHIPID 0x49 130 #define W83781D_REG_WCHIPID 0x58 131 #define W83781D_REG_CHIPMAN 0x4F 132 #define W83781D_REG_PIN 0x4B 133 134 /* 782D/783S only */ 135 #define W83781D_REG_VBAT 0x5D 136 137 /* PWM 782D (1-4) and 783S (1-2) only */ 138 static const u8 W83781D_REG_PWM[] = { 0x5B, 0x5A, 0x5E, 0x5F }; 139 #define W83781D_REG_PWMCLK12 0x5C 140 #define W83781D_REG_PWMCLK34 0x45C 141 142 #define W83781D_REG_I2C_ADDR 0x48 143 #define W83781D_REG_I2C_SUBADDR 0x4A 144 145 /* The following are undocumented in the data sheets however we 146 received the information in an email from Winbond tech support */ 147 /* Sensor selection - not on 781d */ 148 #define W83781D_REG_SCFG1 0x5D 149 static const u8 BIT_SCFG1[] = { 0x02, 0x04, 0x08 }; 150 151 #define W83781D_REG_SCFG2 0x59 152 static const u8 BIT_SCFG2[] = { 0x10, 0x20, 0x40 }; 153 154 #define W83781D_DEFAULT_BETA 3435 155 156 /* Conversions */ 157 #define IN_TO_REG(val) SENSORS_LIMIT(((val) + 8) / 16, 0, 255) 158 #define IN_FROM_REG(val) ((val) * 16) 159 160 static inline u8 161 FAN_TO_REG(long rpm, int div) 162 { 163 if (rpm == 0) 164 return 255; 165 rpm = SENSORS_LIMIT(rpm, 1, 1000000); 166 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254); 167 } 168 169 static inline long 170 FAN_FROM_REG(u8 val, int div) 171 { 172 if (val == 0) 173 return -1; 174 if (val == 255) 175 return 0; 176 return 1350000 / (val * div); 177 } 178 179 #define TEMP_TO_REG(val) SENSORS_LIMIT((val) / 1000, -127, 128) 180 #define TEMP_FROM_REG(val) ((val) * 1000) 181 182 #define BEEP_MASK_FROM_REG(val,type) ((type) == as99127f ? \ 183 (~(val)) & 0x7fff : (val) & 0xff7fff) 184 #define BEEP_MASK_TO_REG(val,type) ((type) == as99127f ? \ 185 (~(val)) & 0x7fff : (val) & 0xff7fff) 186 187 #define DIV_FROM_REG(val) (1 << (val)) 188 189 static inline u8 190 DIV_TO_REG(long val, enum chips type) 191 { 192 int i; 193 val = SENSORS_LIMIT(val, 1, 194 ((type == w83781d 195 || type == as99127f) ? 8 : 128)) >> 1; 196 for (i = 0; i < 7; i++) { 197 if (val == 0) 198 break; 199 val >>= 1; 200 } 201 return i; 202 } 203 204 struct w83781d_data { 205 struct i2c_client *client; 206 struct device *hwmon_dev; 207 struct mutex lock; 208 enum chips type; 209 210 /* For ISA device only */ 211 const char *name; 212 int isa_addr; 213 214 struct mutex update_lock; 215 char valid; /* !=0 if following fields are valid */ 216 unsigned long last_updated; /* In jiffies */ 217 218 struct i2c_client *lm75[2]; /* for secondary I2C addresses */ 219 /* array of 2 pointers to subclients */ 220 221 u8 in[9]; /* Register value - 8 & 9 for 782D only */ 222 u8 in_max[9]; /* Register value - 8 & 9 for 782D only */ 223 u8 in_min[9]; /* Register value - 8 & 9 for 782D only */ 224 u8 fan[3]; /* Register value */ 225 u8 fan_min[3]; /* Register value */ 226 s8 temp; /* Register value */ 227 s8 temp_max; /* Register value */ 228 s8 temp_max_hyst; /* Register value */ 229 u16 temp_add[2]; /* Register value */ 230 u16 temp_max_add[2]; /* Register value */ 231 u16 temp_max_hyst_add[2]; /* Register value */ 232 u8 fan_div[3]; /* Register encoding, shifted right */ 233 u8 vid; /* Register encoding, combined */ 234 u32 alarms; /* Register encoding, combined */ 235 u32 beep_mask; /* Register encoding, combined */ 236 u8 pwm[4]; /* Register value */ 237 u8 pwm2_enable; /* Boolean */ 238 u16 sens[3]; /* 782D/783S only. 239 1 = pentium diode; 2 = 3904 diode; 240 4 = thermistor */ 241 u8 vrm; 242 }; 243 244 static struct w83781d_data *w83781d_data_if_isa(void); 245 static int w83781d_alias_detect(struct i2c_client *client, u8 chipid); 246 247 static int w83781d_read_value(struct w83781d_data *data, u16 reg); 248 static int w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value); 249 static struct w83781d_data *w83781d_update_device(struct device *dev); 250 static void w83781d_init_device(struct device *dev); 251 252 /* following are the sysfs callback functions */ 253 #define show_in_reg(reg) \ 254 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \ 255 char *buf) \ 256 { \ 257 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \ 258 struct w83781d_data *data = w83781d_update_device(dev); \ 259 return sprintf(buf, "%ld\n", \ 260 (long)IN_FROM_REG(data->reg[attr->index])); \ 261 } 262 show_in_reg(in); 263 show_in_reg(in_min); 264 show_in_reg(in_max); 265 266 #define store_in_reg(REG, reg) \ 267 static ssize_t store_in_##reg (struct device *dev, struct device_attribute \ 268 *da, const char *buf, size_t count) \ 269 { \ 270 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \ 271 struct w83781d_data *data = dev_get_drvdata(dev); \ 272 int nr = attr->index; \ 273 u32 val; \ 274 \ 275 val = simple_strtoul(buf, NULL, 10); \ 276 \ 277 mutex_lock(&data->update_lock); \ 278 data->in_##reg[nr] = IN_TO_REG(val); \ 279 w83781d_write_value(data, W83781D_REG_IN_##REG(nr), data->in_##reg[nr]); \ 280 \ 281 mutex_unlock(&data->update_lock); \ 282 return count; \ 283 } 284 store_in_reg(MIN, min); 285 store_in_reg(MAX, max); 286 287 #define sysfs_in_offsets(offset) \ 288 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \ 289 show_in, NULL, offset); \ 290 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \ 291 show_in_min, store_in_min, offset); \ 292 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \ 293 show_in_max, store_in_max, offset) 294 295 sysfs_in_offsets(0); 296 sysfs_in_offsets(1); 297 sysfs_in_offsets(2); 298 sysfs_in_offsets(3); 299 sysfs_in_offsets(4); 300 sysfs_in_offsets(5); 301 sysfs_in_offsets(6); 302 sysfs_in_offsets(7); 303 sysfs_in_offsets(8); 304 305 #define show_fan_reg(reg) \ 306 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \ 307 char *buf) \ 308 { \ 309 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \ 310 struct w83781d_data *data = w83781d_update_device(dev); \ 311 return sprintf(buf,"%ld\n", \ 312 FAN_FROM_REG(data->reg[attr->index], \ 313 DIV_FROM_REG(data->fan_div[attr->index]))); \ 314 } 315 show_fan_reg(fan); 316 show_fan_reg(fan_min); 317 318 static ssize_t 319 store_fan_min(struct device *dev, struct device_attribute *da, 320 const char *buf, size_t count) 321 { 322 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 323 struct w83781d_data *data = dev_get_drvdata(dev); 324 int nr = attr->index; 325 u32 val; 326 327 val = simple_strtoul(buf, NULL, 10); 328 329 mutex_lock(&data->update_lock); 330 data->fan_min[nr] = 331 FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); 332 w83781d_write_value(data, W83781D_REG_FAN_MIN(nr), 333 data->fan_min[nr]); 334 335 mutex_unlock(&data->update_lock); 336 return count; 337 } 338 339 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0); 340 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR, 341 show_fan_min, store_fan_min, 0); 342 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1); 343 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR, 344 show_fan_min, store_fan_min, 1); 345 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2); 346 static SENSOR_DEVICE_ATTR(fan3_min, S_IRUGO | S_IWUSR, 347 show_fan_min, store_fan_min, 2); 348 349 #define show_temp_reg(reg) \ 350 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \ 351 char *buf) \ 352 { \ 353 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \ 354 struct w83781d_data *data = w83781d_update_device(dev); \ 355 int nr = attr->index; \ 356 if (nr >= 2) { /* TEMP2 and TEMP3 */ \ 357 return sprintf(buf,"%d\n", \ 358 LM75_TEMP_FROM_REG(data->reg##_add[nr-2])); \ 359 } else { /* TEMP1 */ \ 360 return sprintf(buf,"%ld\n", (long)TEMP_FROM_REG(data->reg)); \ 361 } \ 362 } 363 show_temp_reg(temp); 364 show_temp_reg(temp_max); 365 show_temp_reg(temp_max_hyst); 366 367 #define store_temp_reg(REG, reg) \ 368 static ssize_t store_temp_##reg (struct device *dev, \ 369 struct device_attribute *da, const char *buf, size_t count) \ 370 { \ 371 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \ 372 struct w83781d_data *data = dev_get_drvdata(dev); \ 373 int nr = attr->index; \ 374 long val; \ 375 \ 376 val = simple_strtol(buf, NULL, 10); \ 377 \ 378 mutex_lock(&data->update_lock); \ 379 \ 380 if (nr >= 2) { /* TEMP2 and TEMP3 */ \ 381 data->temp_##reg##_add[nr-2] = LM75_TEMP_TO_REG(val); \ 382 w83781d_write_value(data, W83781D_REG_TEMP_##REG(nr), \ 383 data->temp_##reg##_add[nr-2]); \ 384 } else { /* TEMP1 */ \ 385 data->temp_##reg = TEMP_TO_REG(val); \ 386 w83781d_write_value(data, W83781D_REG_TEMP_##REG(nr), \ 387 data->temp_##reg); \ 388 } \ 389 \ 390 mutex_unlock(&data->update_lock); \ 391 return count; \ 392 } 393 store_temp_reg(OVER, max); 394 store_temp_reg(HYST, max_hyst); 395 396 #define sysfs_temp_offsets(offset) \ 397 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \ 398 show_temp, NULL, offset); \ 399 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \ 400 show_temp_max, store_temp_max, offset); \ 401 static SENSOR_DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR, \ 402 show_temp_max_hyst, store_temp_max_hyst, offset); 403 404 sysfs_temp_offsets(1); 405 sysfs_temp_offsets(2); 406 sysfs_temp_offsets(3); 407 408 static ssize_t 409 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf) 410 { 411 struct w83781d_data *data = w83781d_update_device(dev); 412 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm)); 413 } 414 415 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL); 416 417 static ssize_t 418 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf) 419 { 420 struct w83781d_data *data = dev_get_drvdata(dev); 421 return sprintf(buf, "%ld\n", (long) data->vrm); 422 } 423 424 static ssize_t 425 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 426 { 427 struct w83781d_data *data = dev_get_drvdata(dev); 428 u32 val; 429 430 val = simple_strtoul(buf, NULL, 10); 431 data->vrm = val; 432 433 return count; 434 } 435 436 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg); 437 438 static ssize_t 439 show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf) 440 { 441 struct w83781d_data *data = w83781d_update_device(dev); 442 return sprintf(buf, "%u\n", data->alarms); 443 } 444 445 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL); 446 447 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, 448 char *buf) 449 { 450 struct w83781d_data *data = w83781d_update_device(dev); 451 int bitnr = to_sensor_dev_attr(attr)->index; 452 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1); 453 } 454 455 /* The W83781D has a single alarm bit for temp2 and temp3 */ 456 static ssize_t show_temp3_alarm(struct device *dev, 457 struct device_attribute *attr, char *buf) 458 { 459 struct w83781d_data *data = w83781d_update_device(dev); 460 int bitnr = (data->type == w83781d) ? 5 : 13; 461 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1); 462 } 463 464 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0); 465 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1); 466 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2); 467 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3); 468 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8); 469 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9); 470 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10); 471 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16); 472 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17); 473 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6); 474 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7); 475 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11); 476 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4); 477 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5); 478 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_temp3_alarm, NULL, 0); 479 480 static ssize_t show_beep_mask (struct device *dev, struct device_attribute *attr, char *buf) 481 { 482 struct w83781d_data *data = w83781d_update_device(dev); 483 return sprintf(buf, "%ld\n", 484 (long)BEEP_MASK_FROM_REG(data->beep_mask, data->type)); 485 } 486 487 static ssize_t 488 store_beep_mask(struct device *dev, struct device_attribute *attr, 489 const char *buf, size_t count) 490 { 491 struct w83781d_data *data = dev_get_drvdata(dev); 492 u32 val; 493 494 val = simple_strtoul(buf, NULL, 10); 495 496 mutex_lock(&data->update_lock); 497 data->beep_mask &= 0x8000; /* preserve beep enable */ 498 data->beep_mask |= BEEP_MASK_TO_REG(val, data->type); 499 w83781d_write_value(data, W83781D_REG_BEEP_INTS1, 500 data->beep_mask & 0xff); 501 w83781d_write_value(data, W83781D_REG_BEEP_INTS2, 502 (data->beep_mask >> 8) & 0xff); 503 if (data->type != w83781d && data->type != as99127f) { 504 w83781d_write_value(data, W83781D_REG_BEEP_INTS3, 505 ((data->beep_mask) >> 16) & 0xff); 506 } 507 mutex_unlock(&data->update_lock); 508 509 return count; 510 } 511 512 static DEVICE_ATTR(beep_mask, S_IRUGO | S_IWUSR, 513 show_beep_mask, store_beep_mask); 514 515 static ssize_t show_beep(struct device *dev, struct device_attribute *attr, 516 char *buf) 517 { 518 struct w83781d_data *data = w83781d_update_device(dev); 519 int bitnr = to_sensor_dev_attr(attr)->index; 520 return sprintf(buf, "%u\n", (data->beep_mask >> bitnr) & 1); 521 } 522 523 static ssize_t 524 store_beep(struct device *dev, struct device_attribute *attr, 525 const char *buf, size_t count) 526 { 527 struct w83781d_data *data = dev_get_drvdata(dev); 528 int bitnr = to_sensor_dev_attr(attr)->index; 529 unsigned long bit; 530 u8 reg; 531 532 bit = simple_strtoul(buf, NULL, 10); 533 if (bit & ~1) 534 return -EINVAL; 535 536 mutex_lock(&data->update_lock); 537 if (bit) 538 data->beep_mask |= (1 << bitnr); 539 else 540 data->beep_mask &= ~(1 << bitnr); 541 542 if (bitnr < 8) { 543 reg = w83781d_read_value(data, W83781D_REG_BEEP_INTS1); 544 if (bit) 545 reg |= (1 << bitnr); 546 else 547 reg &= ~(1 << bitnr); 548 w83781d_write_value(data, W83781D_REG_BEEP_INTS1, reg); 549 } else if (bitnr < 16) { 550 reg = w83781d_read_value(data, W83781D_REG_BEEP_INTS2); 551 if (bit) 552 reg |= (1 << (bitnr - 8)); 553 else 554 reg &= ~(1 << (bitnr - 8)); 555 w83781d_write_value(data, W83781D_REG_BEEP_INTS2, reg); 556 } else { 557 reg = w83781d_read_value(data, W83781D_REG_BEEP_INTS3); 558 if (bit) 559 reg |= (1 << (bitnr - 16)); 560 else 561 reg &= ~(1 << (bitnr - 16)); 562 w83781d_write_value(data, W83781D_REG_BEEP_INTS3, reg); 563 } 564 mutex_unlock(&data->update_lock); 565 566 return count; 567 } 568 569 /* The W83781D has a single beep bit for temp2 and temp3 */ 570 static ssize_t show_temp3_beep(struct device *dev, 571 struct device_attribute *attr, char *buf) 572 { 573 struct w83781d_data *data = w83781d_update_device(dev); 574 int bitnr = (data->type == w83781d) ? 5 : 13; 575 return sprintf(buf, "%u\n", (data->beep_mask >> bitnr) & 1); 576 } 577 578 static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | S_IWUSR, 579 show_beep, store_beep, 0); 580 static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO | S_IWUSR, 581 show_beep, store_beep, 1); 582 static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO | S_IWUSR, 583 show_beep, store_beep, 2); 584 static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO | S_IWUSR, 585 show_beep, store_beep, 3); 586 static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO | S_IWUSR, 587 show_beep, store_beep, 8); 588 static SENSOR_DEVICE_ATTR(in5_beep, S_IRUGO | S_IWUSR, 589 show_beep, store_beep, 9); 590 static SENSOR_DEVICE_ATTR(in6_beep, S_IRUGO | S_IWUSR, 591 show_beep, store_beep, 10); 592 static SENSOR_DEVICE_ATTR(in7_beep, S_IRUGO | S_IWUSR, 593 show_beep, store_beep, 16); 594 static SENSOR_DEVICE_ATTR(in8_beep, S_IRUGO | S_IWUSR, 595 show_beep, store_beep, 17); 596 static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO | S_IWUSR, 597 show_beep, store_beep, 6); 598 static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO | S_IWUSR, 599 show_beep, store_beep, 7); 600 static SENSOR_DEVICE_ATTR(fan3_beep, S_IRUGO | S_IWUSR, 601 show_beep, store_beep, 11); 602 static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO | S_IWUSR, 603 show_beep, store_beep, 4); 604 static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO | S_IWUSR, 605 show_beep, store_beep, 5); 606 static SENSOR_DEVICE_ATTR(temp3_beep, S_IRUGO, 607 show_temp3_beep, store_beep, 13); 608 static SENSOR_DEVICE_ATTR(beep_enable, S_IRUGO | S_IWUSR, 609 show_beep, store_beep, 15); 610 611 static ssize_t 612 show_fan_div(struct device *dev, struct device_attribute *da, char *buf) 613 { 614 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 615 struct w83781d_data *data = w83781d_update_device(dev); 616 return sprintf(buf, "%ld\n", 617 (long) DIV_FROM_REG(data->fan_div[attr->index])); 618 } 619 620 /* Note: we save and restore the fan minimum here, because its value is 621 determined in part by the fan divisor. This follows the principle of 622 least surprise; the user doesn't expect the fan minimum to change just 623 because the divisor changed. */ 624 static ssize_t 625 store_fan_div(struct device *dev, struct device_attribute *da, 626 const char *buf, size_t count) 627 { 628 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 629 struct w83781d_data *data = dev_get_drvdata(dev); 630 unsigned long min; 631 int nr = attr->index; 632 u8 reg; 633 unsigned long val = simple_strtoul(buf, NULL, 10); 634 635 mutex_lock(&data->update_lock); 636 637 /* Save fan_min */ 638 min = FAN_FROM_REG(data->fan_min[nr], 639 DIV_FROM_REG(data->fan_div[nr])); 640 641 data->fan_div[nr] = DIV_TO_REG(val, data->type); 642 643 reg = (w83781d_read_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV) 644 & (nr==0 ? 0xcf : 0x3f)) 645 | ((data->fan_div[nr] & 0x03) << (nr==0 ? 4 : 6)); 646 w83781d_write_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV, reg); 647 648 /* w83781d and as99127f don't have extended divisor bits */ 649 if (data->type != w83781d && data->type != as99127f) { 650 reg = (w83781d_read_value(data, W83781D_REG_VBAT) 651 & ~(1 << (5 + nr))) 652 | ((data->fan_div[nr] & 0x04) << (3 + nr)); 653 w83781d_write_value(data, W83781D_REG_VBAT, reg); 654 } 655 656 /* Restore fan_min */ 657 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr])); 658 w83781d_write_value(data, W83781D_REG_FAN_MIN(nr), data->fan_min[nr]); 659 660 mutex_unlock(&data->update_lock); 661 return count; 662 } 663 664 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR, 665 show_fan_div, store_fan_div, 0); 666 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR, 667 show_fan_div, store_fan_div, 1); 668 static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO | S_IWUSR, 669 show_fan_div, store_fan_div, 2); 670 671 static ssize_t 672 show_pwm(struct device *dev, struct device_attribute *da, char *buf) 673 { 674 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 675 struct w83781d_data *data = w83781d_update_device(dev); 676 return sprintf(buf, "%d\n", (int)data->pwm[attr->index]); 677 } 678 679 static ssize_t 680 show_pwm2_enable(struct device *dev, struct device_attribute *da, char *buf) 681 { 682 struct w83781d_data *data = w83781d_update_device(dev); 683 return sprintf(buf, "%d\n", (int)data->pwm2_enable); 684 } 685 686 static ssize_t 687 store_pwm(struct device *dev, struct device_attribute *da, const char *buf, 688 size_t count) 689 { 690 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 691 struct w83781d_data *data = dev_get_drvdata(dev); 692 int nr = attr->index; 693 u32 val; 694 695 val = simple_strtoul(buf, NULL, 10); 696 697 mutex_lock(&data->update_lock); 698 data->pwm[nr] = SENSORS_LIMIT(val, 0, 255); 699 w83781d_write_value(data, W83781D_REG_PWM[nr], data->pwm[nr]); 700 mutex_unlock(&data->update_lock); 701 return count; 702 } 703 704 static ssize_t 705 store_pwm2_enable(struct device *dev, struct device_attribute *da, 706 const char *buf, size_t count) 707 { 708 struct w83781d_data *data = dev_get_drvdata(dev); 709 u32 val, reg; 710 711 val = simple_strtoul(buf, NULL, 10); 712 713 mutex_lock(&data->update_lock); 714 715 switch (val) { 716 case 0: 717 case 1: 718 reg = w83781d_read_value(data, W83781D_REG_PWMCLK12); 719 w83781d_write_value(data, W83781D_REG_PWMCLK12, 720 (reg & 0xf7) | (val << 3)); 721 722 reg = w83781d_read_value(data, W83781D_REG_BEEP_CONFIG); 723 w83781d_write_value(data, W83781D_REG_BEEP_CONFIG, 724 (reg & 0xef) | (!val << 4)); 725 726 data->pwm2_enable = val; 727 break; 728 729 default: 730 mutex_unlock(&data->update_lock); 731 return -EINVAL; 732 } 733 734 mutex_unlock(&data->update_lock); 735 return count; 736 } 737 738 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 0); 739 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 1); 740 static SENSOR_DEVICE_ATTR(pwm3, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 2); 741 static SENSOR_DEVICE_ATTR(pwm4, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 3); 742 /* only PWM2 can be enabled/disabled */ 743 static DEVICE_ATTR(pwm2_enable, S_IRUGO | S_IWUSR, 744 show_pwm2_enable, store_pwm2_enable); 745 746 static ssize_t 747 show_sensor(struct device *dev, struct device_attribute *da, char *buf) 748 { 749 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 750 struct w83781d_data *data = w83781d_update_device(dev); 751 return sprintf(buf, "%d\n", (int)data->sens[attr->index]); 752 } 753 754 static ssize_t 755 store_sensor(struct device *dev, struct device_attribute *da, 756 const char *buf, size_t count) 757 { 758 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 759 struct w83781d_data *data = dev_get_drvdata(dev); 760 int nr = attr->index; 761 u32 val, tmp; 762 763 val = simple_strtoul(buf, NULL, 10); 764 765 mutex_lock(&data->update_lock); 766 767 switch (val) { 768 case 1: /* PII/Celeron diode */ 769 tmp = w83781d_read_value(data, W83781D_REG_SCFG1); 770 w83781d_write_value(data, W83781D_REG_SCFG1, 771 tmp | BIT_SCFG1[nr]); 772 tmp = w83781d_read_value(data, W83781D_REG_SCFG2); 773 w83781d_write_value(data, W83781D_REG_SCFG2, 774 tmp | BIT_SCFG2[nr]); 775 data->sens[nr] = val; 776 break; 777 case 2: /* 3904 */ 778 tmp = w83781d_read_value(data, W83781D_REG_SCFG1); 779 w83781d_write_value(data, W83781D_REG_SCFG1, 780 tmp | BIT_SCFG1[nr]); 781 tmp = w83781d_read_value(data, W83781D_REG_SCFG2); 782 w83781d_write_value(data, W83781D_REG_SCFG2, 783 tmp & ~BIT_SCFG2[nr]); 784 data->sens[nr] = val; 785 break; 786 case W83781D_DEFAULT_BETA: 787 dev_warn(dev, "Sensor type %d is deprecated, please use 4 " 788 "instead\n", W83781D_DEFAULT_BETA); 789 /* fall through */ 790 case 4: /* thermistor */ 791 tmp = w83781d_read_value(data, W83781D_REG_SCFG1); 792 w83781d_write_value(data, W83781D_REG_SCFG1, 793 tmp & ~BIT_SCFG1[nr]); 794 data->sens[nr] = val; 795 break; 796 default: 797 dev_err(dev, "Invalid sensor type %ld; must be 1, 2, or 4\n", 798 (long) val); 799 break; 800 } 801 802 mutex_unlock(&data->update_lock); 803 return count; 804 } 805 806 static SENSOR_DEVICE_ATTR(temp1_type, S_IRUGO | S_IWUSR, 807 show_sensor, store_sensor, 0); 808 static SENSOR_DEVICE_ATTR(temp2_type, S_IRUGO | S_IWUSR, 809 show_sensor, store_sensor, 1); 810 static SENSOR_DEVICE_ATTR(temp3_type, S_IRUGO | S_IWUSR, 811 show_sensor, store_sensor, 2); 812 813 /* Assumes that adapter is of I2C, not ISA variety. 814 * OTHERWISE DON'T CALL THIS 815 */ 816 static int 817 w83781d_detect_subclients(struct i2c_client *new_client) 818 { 819 int i, val1 = 0, id; 820 int err; 821 int address = new_client->addr; 822 unsigned short sc_addr[2]; 823 struct i2c_adapter *adapter = new_client->adapter; 824 struct w83781d_data *data = i2c_get_clientdata(new_client); 825 enum chips kind = data->type; 826 827 id = i2c_adapter_id(adapter); 828 829 if (force_subclients[0] == id && force_subclients[1] == address) { 830 for (i = 2; i <= 3; i++) { 831 if (force_subclients[i] < 0x48 || 832 force_subclients[i] > 0x4f) { 833 dev_err(&new_client->dev, "Invalid subclient " 834 "address %d; must be 0x48-0x4f\n", 835 force_subclients[i]); 836 err = -EINVAL; 837 goto ERROR_SC_1; 838 } 839 } 840 w83781d_write_value(data, W83781D_REG_I2C_SUBADDR, 841 (force_subclients[2] & 0x07) | 842 ((force_subclients[3] & 0x07) << 4)); 843 sc_addr[0] = force_subclients[2]; 844 } else { 845 val1 = w83781d_read_value(data, W83781D_REG_I2C_SUBADDR); 846 sc_addr[0] = 0x48 + (val1 & 0x07); 847 } 848 849 if (kind != w83783s) { 850 if (force_subclients[0] == id && 851 force_subclients[1] == address) { 852 sc_addr[1] = force_subclients[3]; 853 } else { 854 sc_addr[1] = 0x48 + ((val1 >> 4) & 0x07); 855 } 856 if (sc_addr[0] == sc_addr[1]) { 857 dev_err(&new_client->dev, 858 "Duplicate addresses 0x%x for subclients.\n", 859 sc_addr[0]); 860 err = -EBUSY; 861 goto ERROR_SC_2; 862 } 863 } 864 865 for (i = 0; i <= 1; i++) { 866 data->lm75[i] = i2c_new_dummy(adapter, sc_addr[i]); 867 if (!data->lm75[i]) { 868 dev_err(&new_client->dev, "Subclient %d " 869 "registration at address 0x%x " 870 "failed.\n", i, sc_addr[i]); 871 err = -ENOMEM; 872 if (i == 1) 873 goto ERROR_SC_3; 874 goto ERROR_SC_2; 875 } 876 if (kind == w83783s) 877 break; 878 } 879 880 return 0; 881 882 /* Undo inits in case of errors */ 883 ERROR_SC_3: 884 i2c_unregister_device(data->lm75[0]); 885 ERROR_SC_2: 886 ERROR_SC_1: 887 return err; 888 } 889 890 #define IN_UNIT_ATTRS(X) \ 891 &sensor_dev_attr_in##X##_input.dev_attr.attr, \ 892 &sensor_dev_attr_in##X##_min.dev_attr.attr, \ 893 &sensor_dev_attr_in##X##_max.dev_attr.attr, \ 894 &sensor_dev_attr_in##X##_alarm.dev_attr.attr, \ 895 &sensor_dev_attr_in##X##_beep.dev_attr.attr 896 897 #define FAN_UNIT_ATTRS(X) \ 898 &sensor_dev_attr_fan##X##_input.dev_attr.attr, \ 899 &sensor_dev_attr_fan##X##_min.dev_attr.attr, \ 900 &sensor_dev_attr_fan##X##_div.dev_attr.attr, \ 901 &sensor_dev_attr_fan##X##_alarm.dev_attr.attr, \ 902 &sensor_dev_attr_fan##X##_beep.dev_attr.attr 903 904 #define TEMP_UNIT_ATTRS(X) \ 905 &sensor_dev_attr_temp##X##_input.dev_attr.attr, \ 906 &sensor_dev_attr_temp##X##_max.dev_attr.attr, \ 907 &sensor_dev_attr_temp##X##_max_hyst.dev_attr.attr, \ 908 &sensor_dev_attr_temp##X##_alarm.dev_attr.attr, \ 909 &sensor_dev_attr_temp##X##_beep.dev_attr.attr 910 911 static struct attribute* w83781d_attributes[] = { 912 IN_UNIT_ATTRS(0), 913 IN_UNIT_ATTRS(2), 914 IN_UNIT_ATTRS(3), 915 IN_UNIT_ATTRS(4), 916 IN_UNIT_ATTRS(5), 917 IN_UNIT_ATTRS(6), 918 FAN_UNIT_ATTRS(1), 919 FAN_UNIT_ATTRS(2), 920 FAN_UNIT_ATTRS(3), 921 TEMP_UNIT_ATTRS(1), 922 TEMP_UNIT_ATTRS(2), 923 &dev_attr_cpu0_vid.attr, 924 &dev_attr_vrm.attr, 925 &dev_attr_alarms.attr, 926 &dev_attr_beep_mask.attr, 927 &sensor_dev_attr_beep_enable.dev_attr.attr, 928 NULL 929 }; 930 static const struct attribute_group w83781d_group = { 931 .attrs = w83781d_attributes, 932 }; 933 934 static struct attribute *w83781d_attributes_opt[] = { 935 IN_UNIT_ATTRS(1), 936 IN_UNIT_ATTRS(7), 937 IN_UNIT_ATTRS(8), 938 TEMP_UNIT_ATTRS(3), 939 &sensor_dev_attr_pwm1.dev_attr.attr, 940 &sensor_dev_attr_pwm2.dev_attr.attr, 941 &sensor_dev_attr_pwm3.dev_attr.attr, 942 &sensor_dev_attr_pwm4.dev_attr.attr, 943 &dev_attr_pwm2_enable.attr, 944 &sensor_dev_attr_temp1_type.dev_attr.attr, 945 &sensor_dev_attr_temp2_type.dev_attr.attr, 946 &sensor_dev_attr_temp3_type.dev_attr.attr, 947 NULL 948 }; 949 static const struct attribute_group w83781d_group_opt = { 950 .attrs = w83781d_attributes_opt, 951 }; 952 953 /* No clean up is done on error, it's up to the caller */ 954 static int 955 w83781d_create_files(struct device *dev, int kind, int is_isa) 956 { 957 int err; 958 959 if ((err = sysfs_create_group(&dev->kobj, &w83781d_group))) 960 return err; 961 962 if (kind != w83783s) { 963 if ((err = device_create_file(dev, 964 &sensor_dev_attr_in1_input.dev_attr)) 965 || (err = device_create_file(dev, 966 &sensor_dev_attr_in1_min.dev_attr)) 967 || (err = device_create_file(dev, 968 &sensor_dev_attr_in1_max.dev_attr)) 969 || (err = device_create_file(dev, 970 &sensor_dev_attr_in1_alarm.dev_attr)) 971 || (err = device_create_file(dev, 972 &sensor_dev_attr_in1_beep.dev_attr))) 973 return err; 974 } 975 if (kind != as99127f && kind != w83781d && kind != w83783s) { 976 if ((err = device_create_file(dev, 977 &sensor_dev_attr_in7_input.dev_attr)) 978 || (err = device_create_file(dev, 979 &sensor_dev_attr_in7_min.dev_attr)) 980 || (err = device_create_file(dev, 981 &sensor_dev_attr_in7_max.dev_attr)) 982 || (err = device_create_file(dev, 983 &sensor_dev_attr_in7_alarm.dev_attr)) 984 || (err = device_create_file(dev, 985 &sensor_dev_attr_in7_beep.dev_attr)) 986 || (err = device_create_file(dev, 987 &sensor_dev_attr_in8_input.dev_attr)) 988 || (err = device_create_file(dev, 989 &sensor_dev_attr_in8_min.dev_attr)) 990 || (err = device_create_file(dev, 991 &sensor_dev_attr_in8_max.dev_attr)) 992 || (err = device_create_file(dev, 993 &sensor_dev_attr_in8_alarm.dev_attr)) 994 || (err = device_create_file(dev, 995 &sensor_dev_attr_in8_beep.dev_attr))) 996 return err; 997 } 998 if (kind != w83783s) { 999 if ((err = device_create_file(dev, 1000 &sensor_dev_attr_temp3_input.dev_attr)) 1001 || (err = device_create_file(dev, 1002 &sensor_dev_attr_temp3_max.dev_attr)) 1003 || (err = device_create_file(dev, 1004 &sensor_dev_attr_temp3_max_hyst.dev_attr)) 1005 || (err = device_create_file(dev, 1006 &sensor_dev_attr_temp3_alarm.dev_attr)) 1007 || (err = device_create_file(dev, 1008 &sensor_dev_attr_temp3_beep.dev_attr))) 1009 return err; 1010 1011 if (kind != w83781d) { 1012 err = sysfs_chmod_file(&dev->kobj, 1013 &sensor_dev_attr_temp3_alarm.dev_attr.attr, 1014 S_IRUGO | S_IWUSR); 1015 if (err) 1016 return err; 1017 } 1018 } 1019 1020 if (kind != w83781d && kind != as99127f) { 1021 if ((err = device_create_file(dev, 1022 &sensor_dev_attr_pwm1.dev_attr)) 1023 || (err = device_create_file(dev, 1024 &sensor_dev_attr_pwm2.dev_attr)) 1025 || (err = device_create_file(dev, &dev_attr_pwm2_enable))) 1026 return err; 1027 } 1028 if (kind == w83782d && !is_isa) { 1029 if ((err = device_create_file(dev, 1030 &sensor_dev_attr_pwm3.dev_attr)) 1031 || (err = device_create_file(dev, 1032 &sensor_dev_attr_pwm4.dev_attr))) 1033 return err; 1034 } 1035 1036 if (kind != as99127f && kind != w83781d) { 1037 if ((err = device_create_file(dev, 1038 &sensor_dev_attr_temp1_type.dev_attr)) 1039 || (err = device_create_file(dev, 1040 &sensor_dev_attr_temp2_type.dev_attr))) 1041 return err; 1042 if (kind != w83783s) { 1043 if ((err = device_create_file(dev, 1044 &sensor_dev_attr_temp3_type.dev_attr))) 1045 return err; 1046 } 1047 } 1048 1049 return 0; 1050 } 1051 1052 /* Return 0 if detection is successful, -ENODEV otherwise */ 1053 static int 1054 w83781d_detect(struct i2c_client *client, int kind, 1055 struct i2c_board_info *info) 1056 { 1057 int val1 = 0, val2; 1058 struct w83781d_data *isa = w83781d_data_if_isa(); 1059 struct i2c_adapter *adapter = client->adapter; 1060 int address = client->addr; 1061 const char *client_name = ""; 1062 enum vendor { winbond, asus } vendid; 1063 1064 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 1065 return -ENODEV; 1066 1067 /* We block updates of the ISA device to minimize the risk of 1068 concurrent access to the same W83781D chip through different 1069 interfaces. */ 1070 if (isa) 1071 mutex_lock(&isa->update_lock); 1072 1073 /* The w8378?d may be stuck in some other bank than bank 0. This may 1074 make reading other information impossible. Specify a force=... or 1075 force_*=... parameter, and the Winbond will be reset to the right 1076 bank. */ 1077 if (kind < 0) { 1078 if (i2c_smbus_read_byte_data 1079 (client, W83781D_REG_CONFIG) & 0x80) { 1080 dev_dbg(&adapter->dev, "Detection of w83781d chip " 1081 "failed at step 3\n"); 1082 goto err_nodev; 1083 } 1084 val1 = i2c_smbus_read_byte_data(client, W83781D_REG_BANK); 1085 val2 = i2c_smbus_read_byte_data(client, W83781D_REG_CHIPMAN); 1086 /* Check for Winbond or Asus ID if in bank 0 */ 1087 if ((!(val1 & 0x07)) && 1088 (((!(val1 & 0x80)) && (val2 != 0xa3) && (val2 != 0xc3)) 1089 || ((val1 & 0x80) && (val2 != 0x5c) && (val2 != 0x12)))) { 1090 dev_dbg(&adapter->dev, "Detection of w83781d chip " 1091 "failed at step 4\n"); 1092 goto err_nodev; 1093 } 1094 /* If Winbond SMBus, check address at 0x48. 1095 Asus doesn't support, except for as99127f rev.2 */ 1096 if ((!(val1 & 0x80) && (val2 == 0xa3)) || 1097 ((val1 & 0x80) && (val2 == 0x5c))) { 1098 if (i2c_smbus_read_byte_data 1099 (client, W83781D_REG_I2C_ADDR) != address) { 1100 dev_dbg(&adapter->dev, "Detection of w83781d " 1101 "chip failed at step 5\n"); 1102 goto err_nodev; 1103 } 1104 } 1105 } 1106 1107 /* We have either had a force parameter, or we have already detected the 1108 Winbond. Put it now into bank 0 and Vendor ID High Byte */ 1109 i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 1110 (i2c_smbus_read_byte_data(client, W83781D_REG_BANK) 1111 & 0x78) | 0x80); 1112 1113 /* Determine the chip type. */ 1114 if (kind <= 0) { 1115 /* get vendor ID */ 1116 val2 = i2c_smbus_read_byte_data(client, W83781D_REG_CHIPMAN); 1117 if (val2 == 0x5c) 1118 vendid = winbond; 1119 else if (val2 == 0x12) 1120 vendid = asus; 1121 else { 1122 dev_dbg(&adapter->dev, "w83781d chip vendor is " 1123 "neither Winbond nor Asus\n"); 1124 goto err_nodev; 1125 } 1126 1127 val1 = i2c_smbus_read_byte_data(client, W83781D_REG_WCHIPID); 1128 if ((val1 == 0x10 || val1 == 0x11) && vendid == winbond) 1129 kind = w83781d; 1130 else if (val1 == 0x30 && vendid == winbond) 1131 kind = w83782d; 1132 else if (val1 == 0x40 && vendid == winbond && address == 0x2d) 1133 kind = w83783s; 1134 else if (val1 == 0x31) 1135 kind = as99127f; 1136 else { 1137 if (kind == 0) 1138 dev_warn(&adapter->dev, "Ignoring 'force' " 1139 "parameter for unknown chip at " 1140 "address 0x%02x\n", address); 1141 goto err_nodev; 1142 } 1143 1144 if ((kind == w83781d || kind == w83782d) 1145 && w83781d_alias_detect(client, val1)) { 1146 dev_dbg(&adapter->dev, "Device at 0x%02x appears to " 1147 "be the same as ISA device\n", address); 1148 goto err_nodev; 1149 } 1150 } 1151 1152 if (isa) 1153 mutex_unlock(&isa->update_lock); 1154 1155 if (kind == w83781d) { 1156 client_name = "w83781d"; 1157 } else if (kind == w83782d) { 1158 client_name = "w83782d"; 1159 } else if (kind == w83783s) { 1160 client_name = "w83783s"; 1161 } else if (kind == as99127f) { 1162 client_name = "as99127f"; 1163 } 1164 1165 strlcpy(info->type, client_name, I2C_NAME_SIZE); 1166 1167 return 0; 1168 1169 err_nodev: 1170 if (isa) 1171 mutex_unlock(&isa->update_lock); 1172 return -ENODEV; 1173 } 1174 1175 static int 1176 w83781d_probe(struct i2c_client *client, const struct i2c_device_id *id) 1177 { 1178 struct device *dev = &client->dev; 1179 struct w83781d_data *data; 1180 int err; 1181 1182 data = kzalloc(sizeof(struct w83781d_data), GFP_KERNEL); 1183 if (!data) { 1184 err = -ENOMEM; 1185 goto ERROR1; 1186 } 1187 1188 i2c_set_clientdata(client, data); 1189 mutex_init(&data->lock); 1190 mutex_init(&data->update_lock); 1191 1192 data->type = id->driver_data; 1193 data->client = client; 1194 1195 /* attach secondary i2c lm75-like clients */ 1196 err = w83781d_detect_subclients(client); 1197 if (err) 1198 goto ERROR3; 1199 1200 /* Initialize the chip */ 1201 w83781d_init_device(dev); 1202 1203 /* Register sysfs hooks */ 1204 err = w83781d_create_files(dev, data->type, 0); 1205 if (err) 1206 goto ERROR4; 1207 1208 data->hwmon_dev = hwmon_device_register(dev); 1209 if (IS_ERR(data->hwmon_dev)) { 1210 err = PTR_ERR(data->hwmon_dev); 1211 goto ERROR4; 1212 } 1213 1214 return 0; 1215 1216 ERROR4: 1217 sysfs_remove_group(&dev->kobj, &w83781d_group); 1218 sysfs_remove_group(&dev->kobj, &w83781d_group_opt); 1219 1220 if (data->lm75[0]) 1221 i2c_unregister_device(data->lm75[0]); 1222 if (data->lm75[1]) 1223 i2c_unregister_device(data->lm75[1]); 1224 ERROR3: 1225 i2c_set_clientdata(client, NULL); 1226 kfree(data); 1227 ERROR1: 1228 return err; 1229 } 1230 1231 static int 1232 w83781d_remove(struct i2c_client *client) 1233 { 1234 struct w83781d_data *data = i2c_get_clientdata(client); 1235 struct device *dev = &client->dev; 1236 1237 hwmon_device_unregister(data->hwmon_dev); 1238 1239 sysfs_remove_group(&dev->kobj, &w83781d_group); 1240 sysfs_remove_group(&dev->kobj, &w83781d_group_opt); 1241 1242 if (data->lm75[0]) 1243 i2c_unregister_device(data->lm75[0]); 1244 if (data->lm75[1]) 1245 i2c_unregister_device(data->lm75[1]); 1246 1247 i2c_set_clientdata(client, NULL); 1248 kfree(data); 1249 1250 return 0; 1251 } 1252 1253 static int 1254 w83781d_read_value_i2c(struct w83781d_data *data, u16 reg) 1255 { 1256 struct i2c_client *client = data->client; 1257 int res, bank; 1258 struct i2c_client *cl; 1259 1260 bank = (reg >> 8) & 0x0f; 1261 if (bank > 2) 1262 /* switch banks */ 1263 i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 1264 bank); 1265 if (bank == 0 || bank > 2) { 1266 res = i2c_smbus_read_byte_data(client, reg & 0xff); 1267 } else { 1268 /* switch to subclient */ 1269 cl = data->lm75[bank - 1]; 1270 /* convert from ISA to LM75 I2C addresses */ 1271 switch (reg & 0xff) { 1272 case 0x50: /* TEMP */ 1273 res = swab16(i2c_smbus_read_word_data(cl, 0)); 1274 break; 1275 case 0x52: /* CONFIG */ 1276 res = i2c_smbus_read_byte_data(cl, 1); 1277 break; 1278 case 0x53: /* HYST */ 1279 res = swab16(i2c_smbus_read_word_data(cl, 2)); 1280 break; 1281 case 0x55: /* OVER */ 1282 default: 1283 res = swab16(i2c_smbus_read_word_data(cl, 3)); 1284 break; 1285 } 1286 } 1287 if (bank > 2) 1288 i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0); 1289 1290 return res; 1291 } 1292 1293 static int 1294 w83781d_write_value_i2c(struct w83781d_data *data, u16 reg, u16 value) 1295 { 1296 struct i2c_client *client = data->client; 1297 int bank; 1298 struct i2c_client *cl; 1299 1300 bank = (reg >> 8) & 0x0f; 1301 if (bank > 2) 1302 /* switch banks */ 1303 i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 1304 bank); 1305 if (bank == 0 || bank > 2) { 1306 i2c_smbus_write_byte_data(client, reg & 0xff, 1307 value & 0xff); 1308 } else { 1309 /* switch to subclient */ 1310 cl = data->lm75[bank - 1]; 1311 /* convert from ISA to LM75 I2C addresses */ 1312 switch (reg & 0xff) { 1313 case 0x52: /* CONFIG */ 1314 i2c_smbus_write_byte_data(cl, 1, value & 0xff); 1315 break; 1316 case 0x53: /* HYST */ 1317 i2c_smbus_write_word_data(cl, 2, swab16(value)); 1318 break; 1319 case 0x55: /* OVER */ 1320 i2c_smbus_write_word_data(cl, 3, swab16(value)); 1321 break; 1322 } 1323 } 1324 if (bank > 2) 1325 i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0); 1326 1327 return 0; 1328 } 1329 1330 static void 1331 w83781d_init_device(struct device *dev) 1332 { 1333 struct w83781d_data *data = dev_get_drvdata(dev); 1334 int i, p; 1335 int type = data->type; 1336 u8 tmp; 1337 1338 if (reset && type != as99127f) { /* this resets registers we don't have 1339 documentation for on the as99127f */ 1340 /* Resetting the chip has been the default for a long time, 1341 but it causes the BIOS initializations (fan clock dividers, 1342 thermal sensor types...) to be lost, so it is now optional. 1343 It might even go away if nobody reports it as being useful, 1344 as I see very little reason why this would be needed at 1345 all. */ 1346 dev_info(dev, "If reset=1 solved a problem you were " 1347 "having, please report!\n"); 1348 1349 /* save these registers */ 1350 i = w83781d_read_value(data, W83781D_REG_BEEP_CONFIG); 1351 p = w83781d_read_value(data, W83781D_REG_PWMCLK12); 1352 /* Reset all except Watchdog values and last conversion values 1353 This sets fan-divs to 2, among others */ 1354 w83781d_write_value(data, W83781D_REG_CONFIG, 0x80); 1355 /* Restore the registers and disable power-on abnormal beep. 1356 This saves FAN 1/2/3 input/output values set by BIOS. */ 1357 w83781d_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80); 1358 w83781d_write_value(data, W83781D_REG_PWMCLK12, p); 1359 /* Disable master beep-enable (reset turns it on). 1360 Individual beep_mask should be reset to off but for some reason 1361 disabling this bit helps some people not get beeped */ 1362 w83781d_write_value(data, W83781D_REG_BEEP_INTS2, 0); 1363 } 1364 1365 /* Disable power-on abnormal beep, as advised by the datasheet. 1366 Already done if reset=1. */ 1367 if (init && !reset && type != as99127f) { 1368 i = w83781d_read_value(data, W83781D_REG_BEEP_CONFIG); 1369 w83781d_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80); 1370 } 1371 1372 data->vrm = vid_which_vrm(); 1373 1374 if ((type != w83781d) && (type != as99127f)) { 1375 tmp = w83781d_read_value(data, W83781D_REG_SCFG1); 1376 for (i = 1; i <= 3; i++) { 1377 if (!(tmp & BIT_SCFG1[i - 1])) { 1378 data->sens[i - 1] = 4; 1379 } else { 1380 if (w83781d_read_value 1381 (data, 1382 W83781D_REG_SCFG2) & BIT_SCFG2[i - 1]) 1383 data->sens[i - 1] = 1; 1384 else 1385 data->sens[i - 1] = 2; 1386 } 1387 if (type == w83783s && i == 2) 1388 break; 1389 } 1390 } 1391 1392 if (init && type != as99127f) { 1393 /* Enable temp2 */ 1394 tmp = w83781d_read_value(data, W83781D_REG_TEMP2_CONFIG); 1395 if (tmp & 0x01) { 1396 dev_warn(dev, "Enabling temp2, readings " 1397 "might not make sense\n"); 1398 w83781d_write_value(data, W83781D_REG_TEMP2_CONFIG, 1399 tmp & 0xfe); 1400 } 1401 1402 /* Enable temp3 */ 1403 if (type != w83783s) { 1404 tmp = w83781d_read_value(data, 1405 W83781D_REG_TEMP3_CONFIG); 1406 if (tmp & 0x01) { 1407 dev_warn(dev, "Enabling temp3, " 1408 "readings might not make sense\n"); 1409 w83781d_write_value(data, 1410 W83781D_REG_TEMP3_CONFIG, tmp & 0xfe); 1411 } 1412 } 1413 } 1414 1415 /* Start monitoring */ 1416 w83781d_write_value(data, W83781D_REG_CONFIG, 1417 (w83781d_read_value(data, 1418 W83781D_REG_CONFIG) & 0xf7) 1419 | 0x01); 1420 1421 /* A few vars need to be filled upon startup */ 1422 for (i = 0; i < 3; i++) { 1423 data->fan_min[i] = w83781d_read_value(data, 1424 W83781D_REG_FAN_MIN(i)); 1425 } 1426 1427 mutex_init(&data->update_lock); 1428 } 1429 1430 static struct w83781d_data *w83781d_update_device(struct device *dev) 1431 { 1432 struct w83781d_data *data = dev_get_drvdata(dev); 1433 struct i2c_client *client = data->client; 1434 int i; 1435 1436 mutex_lock(&data->update_lock); 1437 1438 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 1439 || !data->valid) { 1440 dev_dbg(dev, "Starting device update\n"); 1441 1442 for (i = 0; i <= 8; i++) { 1443 if (data->type == w83783s && i == 1) 1444 continue; /* 783S has no in1 */ 1445 data->in[i] = 1446 w83781d_read_value(data, W83781D_REG_IN(i)); 1447 data->in_min[i] = 1448 w83781d_read_value(data, W83781D_REG_IN_MIN(i)); 1449 data->in_max[i] = 1450 w83781d_read_value(data, W83781D_REG_IN_MAX(i)); 1451 if ((data->type != w83782d) && (i == 6)) 1452 break; 1453 } 1454 for (i = 0; i < 3; i++) { 1455 data->fan[i] = 1456 w83781d_read_value(data, W83781D_REG_FAN(i)); 1457 data->fan_min[i] = 1458 w83781d_read_value(data, W83781D_REG_FAN_MIN(i)); 1459 } 1460 if (data->type != w83781d && data->type != as99127f) { 1461 for (i = 0; i < 4; i++) { 1462 data->pwm[i] = 1463 w83781d_read_value(data, 1464 W83781D_REG_PWM[i]); 1465 if ((data->type != w83782d || !client->driver) 1466 && i == 1) 1467 break; 1468 } 1469 /* Only PWM2 can be disabled */ 1470 data->pwm2_enable = (w83781d_read_value(data, 1471 W83781D_REG_PWMCLK12) & 0x08) >> 3; 1472 } 1473 1474 data->temp = w83781d_read_value(data, W83781D_REG_TEMP(1)); 1475 data->temp_max = 1476 w83781d_read_value(data, W83781D_REG_TEMP_OVER(1)); 1477 data->temp_max_hyst = 1478 w83781d_read_value(data, W83781D_REG_TEMP_HYST(1)); 1479 data->temp_add[0] = 1480 w83781d_read_value(data, W83781D_REG_TEMP(2)); 1481 data->temp_max_add[0] = 1482 w83781d_read_value(data, W83781D_REG_TEMP_OVER(2)); 1483 data->temp_max_hyst_add[0] = 1484 w83781d_read_value(data, W83781D_REG_TEMP_HYST(2)); 1485 if (data->type != w83783s) { 1486 data->temp_add[1] = 1487 w83781d_read_value(data, W83781D_REG_TEMP(3)); 1488 data->temp_max_add[1] = 1489 w83781d_read_value(data, 1490 W83781D_REG_TEMP_OVER(3)); 1491 data->temp_max_hyst_add[1] = 1492 w83781d_read_value(data, 1493 W83781D_REG_TEMP_HYST(3)); 1494 } 1495 i = w83781d_read_value(data, W83781D_REG_VID_FANDIV); 1496 data->vid = i & 0x0f; 1497 data->vid |= (w83781d_read_value(data, 1498 W83781D_REG_CHIPID) & 0x01) << 4; 1499 data->fan_div[0] = (i >> 4) & 0x03; 1500 data->fan_div[1] = (i >> 6) & 0x03; 1501 data->fan_div[2] = (w83781d_read_value(data, 1502 W83781D_REG_PIN) >> 6) & 0x03; 1503 if ((data->type != w83781d) && (data->type != as99127f)) { 1504 i = w83781d_read_value(data, W83781D_REG_VBAT); 1505 data->fan_div[0] |= (i >> 3) & 0x04; 1506 data->fan_div[1] |= (i >> 4) & 0x04; 1507 data->fan_div[2] |= (i >> 5) & 0x04; 1508 } 1509 if (data->type == w83782d) { 1510 data->alarms = w83781d_read_value(data, 1511 W83782D_REG_ALARM1) 1512 | (w83781d_read_value(data, 1513 W83782D_REG_ALARM2) << 8) 1514 | (w83781d_read_value(data, 1515 W83782D_REG_ALARM3) << 16); 1516 } else if (data->type == w83783s) { 1517 data->alarms = w83781d_read_value(data, 1518 W83782D_REG_ALARM1) 1519 | (w83781d_read_value(data, 1520 W83782D_REG_ALARM2) << 8); 1521 } else { 1522 /* No real-time status registers, fall back to 1523 interrupt status registers */ 1524 data->alarms = w83781d_read_value(data, 1525 W83781D_REG_ALARM1) 1526 | (w83781d_read_value(data, 1527 W83781D_REG_ALARM2) << 8); 1528 } 1529 i = w83781d_read_value(data, W83781D_REG_BEEP_INTS2); 1530 data->beep_mask = (i << 8) + 1531 w83781d_read_value(data, W83781D_REG_BEEP_INTS1); 1532 if ((data->type != w83781d) && (data->type != as99127f)) { 1533 data->beep_mask |= 1534 w83781d_read_value(data, 1535 W83781D_REG_BEEP_INTS3) << 16; 1536 } 1537 data->last_updated = jiffies; 1538 data->valid = 1; 1539 } 1540 1541 mutex_unlock(&data->update_lock); 1542 1543 return data; 1544 } 1545 1546 static const struct i2c_device_id w83781d_ids[] = { 1547 { "w83781d", w83781d, }, 1548 { "w83782d", w83782d, }, 1549 { "w83783s", w83783s, }, 1550 { "as99127f", as99127f }, 1551 { /* LIST END */ } 1552 }; 1553 MODULE_DEVICE_TABLE(i2c, w83781d_ids); 1554 1555 static struct i2c_driver w83781d_driver = { 1556 .class = I2C_CLASS_HWMON, 1557 .driver = { 1558 .name = "w83781d", 1559 }, 1560 .probe = w83781d_probe, 1561 .remove = w83781d_remove, 1562 .id_table = w83781d_ids, 1563 .detect = w83781d_detect, 1564 .address_data = &addr_data, 1565 }; 1566 1567 /* 1568 * ISA related code 1569 */ 1570 #ifdef CONFIG_ISA 1571 1572 /* ISA device, if found */ 1573 static struct platform_device *pdev; 1574 1575 static unsigned short isa_address = 0x290; 1576 1577 /* I2C devices get this name attribute automatically, but for ISA devices 1578 we must create it by ourselves. */ 1579 static ssize_t 1580 show_name(struct device *dev, struct device_attribute *devattr, char *buf) 1581 { 1582 struct w83781d_data *data = dev_get_drvdata(dev); 1583 return sprintf(buf, "%s\n", data->name); 1584 } 1585 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); 1586 1587 static struct w83781d_data *w83781d_data_if_isa(void) 1588 { 1589 return pdev ? platform_get_drvdata(pdev) : NULL; 1590 } 1591 1592 /* Returns 1 if the I2C chip appears to be an alias of the ISA chip */ 1593 static int w83781d_alias_detect(struct i2c_client *client, u8 chipid) 1594 { 1595 struct w83781d_data *isa; 1596 int i; 1597 1598 if (!pdev) /* No ISA chip */ 1599 return 0; 1600 1601 isa = platform_get_drvdata(pdev); 1602 1603 if (w83781d_read_value(isa, W83781D_REG_I2C_ADDR) != client->addr) 1604 return 0; /* Address doesn't match */ 1605 if (w83781d_read_value(isa, W83781D_REG_WCHIPID) != chipid) 1606 return 0; /* Chip type doesn't match */ 1607 1608 /* We compare all the limit registers, the config register and the 1609 * interrupt mask registers */ 1610 for (i = 0x2b; i <= 0x3d; i++) { 1611 if (w83781d_read_value(isa, i) != 1612 i2c_smbus_read_byte_data(client, i)) 1613 return 0; 1614 } 1615 if (w83781d_read_value(isa, W83781D_REG_CONFIG) != 1616 i2c_smbus_read_byte_data(client, W83781D_REG_CONFIG)) 1617 return 0; 1618 for (i = 0x43; i <= 0x46; i++) { 1619 if (w83781d_read_value(isa, i) != 1620 i2c_smbus_read_byte_data(client, i)) 1621 return 0; 1622 } 1623 1624 return 1; 1625 } 1626 1627 static int 1628 w83781d_read_value_isa(struct w83781d_data *data, u16 reg) 1629 { 1630 int word_sized, res; 1631 1632 word_sized = (((reg & 0xff00) == 0x100) 1633 || ((reg & 0xff00) == 0x200)) 1634 && (((reg & 0x00ff) == 0x50) 1635 || ((reg & 0x00ff) == 0x53) 1636 || ((reg & 0x00ff) == 0x55)); 1637 if (reg & 0xff00) { 1638 outb_p(W83781D_REG_BANK, 1639 data->isa_addr + W83781D_ADDR_REG_OFFSET); 1640 outb_p(reg >> 8, 1641 data->isa_addr + W83781D_DATA_REG_OFFSET); 1642 } 1643 outb_p(reg & 0xff, data->isa_addr + W83781D_ADDR_REG_OFFSET); 1644 res = inb_p(data->isa_addr + W83781D_DATA_REG_OFFSET); 1645 if (word_sized) { 1646 outb_p((reg & 0xff) + 1, 1647 data->isa_addr + W83781D_ADDR_REG_OFFSET); 1648 res = 1649 (res << 8) + inb_p(data->isa_addr + 1650 W83781D_DATA_REG_OFFSET); 1651 } 1652 if (reg & 0xff00) { 1653 outb_p(W83781D_REG_BANK, 1654 data->isa_addr + W83781D_ADDR_REG_OFFSET); 1655 outb_p(0, data->isa_addr + W83781D_DATA_REG_OFFSET); 1656 } 1657 return res; 1658 } 1659 1660 static void 1661 w83781d_write_value_isa(struct w83781d_data *data, u16 reg, u16 value) 1662 { 1663 int word_sized; 1664 1665 word_sized = (((reg & 0xff00) == 0x100) 1666 || ((reg & 0xff00) == 0x200)) 1667 && (((reg & 0x00ff) == 0x53) 1668 || ((reg & 0x00ff) == 0x55)); 1669 if (reg & 0xff00) { 1670 outb_p(W83781D_REG_BANK, 1671 data->isa_addr + W83781D_ADDR_REG_OFFSET); 1672 outb_p(reg >> 8, 1673 data->isa_addr + W83781D_DATA_REG_OFFSET); 1674 } 1675 outb_p(reg & 0xff, data->isa_addr + W83781D_ADDR_REG_OFFSET); 1676 if (word_sized) { 1677 outb_p(value >> 8, 1678 data->isa_addr + W83781D_DATA_REG_OFFSET); 1679 outb_p((reg & 0xff) + 1, 1680 data->isa_addr + W83781D_ADDR_REG_OFFSET); 1681 } 1682 outb_p(value & 0xff, data->isa_addr + W83781D_DATA_REG_OFFSET); 1683 if (reg & 0xff00) { 1684 outb_p(W83781D_REG_BANK, 1685 data->isa_addr + W83781D_ADDR_REG_OFFSET); 1686 outb_p(0, data->isa_addr + W83781D_DATA_REG_OFFSET); 1687 } 1688 } 1689 1690 /* The SMBus locks itself, usually, but nothing may access the Winbond between 1691 bank switches. ISA access must always be locked explicitly! 1692 We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks, 1693 would slow down the W83781D access and should not be necessary. 1694 There are some ugly typecasts here, but the good news is - they should 1695 nowhere else be necessary! */ 1696 static int 1697 w83781d_read_value(struct w83781d_data *data, u16 reg) 1698 { 1699 struct i2c_client *client = data->client; 1700 int res; 1701 1702 mutex_lock(&data->lock); 1703 if (client) 1704 res = w83781d_read_value_i2c(data, reg); 1705 else 1706 res = w83781d_read_value_isa(data, reg); 1707 mutex_unlock(&data->lock); 1708 return res; 1709 } 1710 1711 static int 1712 w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value) 1713 { 1714 struct i2c_client *client = data->client; 1715 1716 mutex_lock(&data->lock); 1717 if (client) 1718 w83781d_write_value_i2c(data, reg, value); 1719 else 1720 w83781d_write_value_isa(data, reg, value); 1721 mutex_unlock(&data->lock); 1722 return 0; 1723 } 1724 1725 static int __devinit 1726 w83781d_isa_probe(struct platform_device *pdev) 1727 { 1728 int err, reg; 1729 struct w83781d_data *data; 1730 struct resource *res; 1731 1732 /* Reserve the ISA region */ 1733 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 1734 if (!request_region(res->start + W83781D_ADDR_REG_OFFSET, 2, 1735 "w83781d")) { 1736 err = -EBUSY; 1737 goto exit; 1738 } 1739 1740 data = kzalloc(sizeof(struct w83781d_data), GFP_KERNEL); 1741 if (!data) { 1742 err = -ENOMEM; 1743 goto exit_release_region; 1744 } 1745 mutex_init(&data->lock); 1746 data->isa_addr = res->start; 1747 platform_set_drvdata(pdev, data); 1748 1749 reg = w83781d_read_value(data, W83781D_REG_WCHIPID); 1750 switch (reg) { 1751 case 0x30: 1752 data->type = w83782d; 1753 data->name = "w83782d"; 1754 break; 1755 default: 1756 data->type = w83781d; 1757 data->name = "w83781d"; 1758 } 1759 1760 /* Initialize the W83781D chip */ 1761 w83781d_init_device(&pdev->dev); 1762 1763 /* Register sysfs hooks */ 1764 err = w83781d_create_files(&pdev->dev, data->type, 1); 1765 if (err) 1766 goto exit_remove_files; 1767 1768 err = device_create_file(&pdev->dev, &dev_attr_name); 1769 if (err) 1770 goto exit_remove_files; 1771 1772 data->hwmon_dev = hwmon_device_register(&pdev->dev); 1773 if (IS_ERR(data->hwmon_dev)) { 1774 err = PTR_ERR(data->hwmon_dev); 1775 goto exit_remove_files; 1776 } 1777 1778 return 0; 1779 1780 exit_remove_files: 1781 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group); 1782 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group_opt); 1783 device_remove_file(&pdev->dev, &dev_attr_name); 1784 kfree(data); 1785 exit_release_region: 1786 release_region(res->start + W83781D_ADDR_REG_OFFSET, 2); 1787 exit: 1788 return err; 1789 } 1790 1791 static int __devexit 1792 w83781d_isa_remove(struct platform_device *pdev) 1793 { 1794 struct w83781d_data *data = platform_get_drvdata(pdev); 1795 1796 hwmon_device_unregister(data->hwmon_dev); 1797 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group); 1798 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group_opt); 1799 device_remove_file(&pdev->dev, &dev_attr_name); 1800 release_region(data->isa_addr + W83781D_ADDR_REG_OFFSET, 2); 1801 kfree(data); 1802 1803 return 0; 1804 } 1805 1806 static struct platform_driver w83781d_isa_driver = { 1807 .driver = { 1808 .owner = THIS_MODULE, 1809 .name = "w83781d", 1810 }, 1811 .probe = w83781d_isa_probe, 1812 .remove = __devexit_p(w83781d_isa_remove), 1813 }; 1814 1815 /* return 1 if a supported chip is found, 0 otherwise */ 1816 static int __init 1817 w83781d_isa_found(unsigned short address) 1818 { 1819 int val, save, found = 0; 1820 1821 /* We have to request the region in two parts because some 1822 boards declare base+4 to base+7 as a PNP device */ 1823 if (!request_region(address, 4, "w83781d")) { 1824 pr_debug("w83781d: Failed to request low part of region\n"); 1825 return 0; 1826 } 1827 if (!request_region(address + 4, 4, "w83781d")) { 1828 pr_debug("w83781d: Failed to request high part of region\n"); 1829 release_region(address, 4); 1830 return 0; 1831 } 1832 1833 #define REALLY_SLOW_IO 1834 /* We need the timeouts for at least some W83781D-like 1835 chips. But only if we read 'undefined' registers. */ 1836 val = inb_p(address + 1); 1837 if (inb_p(address + 2) != val 1838 || inb_p(address + 3) != val 1839 || inb_p(address + 7) != val) { 1840 pr_debug("w83781d: Detection failed at step 1\n"); 1841 goto release; 1842 } 1843 #undef REALLY_SLOW_IO 1844 1845 /* We should be able to change the 7 LSB of the address port. The 1846 MSB (busy flag) should be clear initially, set after the write. */ 1847 save = inb_p(address + W83781D_ADDR_REG_OFFSET); 1848 if (save & 0x80) { 1849 pr_debug("w83781d: Detection failed at step 2\n"); 1850 goto release; 1851 } 1852 val = ~save & 0x7f; 1853 outb_p(val, address + W83781D_ADDR_REG_OFFSET); 1854 if (inb_p(address + W83781D_ADDR_REG_OFFSET) != (val | 0x80)) { 1855 outb_p(save, address + W83781D_ADDR_REG_OFFSET); 1856 pr_debug("w83781d: Detection failed at step 3\n"); 1857 goto release; 1858 } 1859 1860 /* We found a device, now see if it could be a W83781D */ 1861 outb_p(W83781D_REG_CONFIG, address + W83781D_ADDR_REG_OFFSET); 1862 val = inb_p(address + W83781D_DATA_REG_OFFSET); 1863 if (val & 0x80) { 1864 pr_debug("w83781d: Detection failed at step 4\n"); 1865 goto release; 1866 } 1867 outb_p(W83781D_REG_BANK, address + W83781D_ADDR_REG_OFFSET); 1868 save = inb_p(address + W83781D_DATA_REG_OFFSET); 1869 outb_p(W83781D_REG_CHIPMAN, address + W83781D_ADDR_REG_OFFSET); 1870 val = inb_p(address + W83781D_DATA_REG_OFFSET); 1871 if ((!(save & 0x80) && (val != 0xa3)) 1872 || ((save & 0x80) && (val != 0x5c))) { 1873 pr_debug("w83781d: Detection failed at step 5\n"); 1874 goto release; 1875 } 1876 outb_p(W83781D_REG_I2C_ADDR, address + W83781D_ADDR_REG_OFFSET); 1877 val = inb_p(address + W83781D_DATA_REG_OFFSET); 1878 if (val < 0x03 || val > 0x77) { /* Not a valid I2C address */ 1879 pr_debug("w83781d: Detection failed at step 6\n"); 1880 goto release; 1881 } 1882 1883 /* The busy flag should be clear again */ 1884 if (inb_p(address + W83781D_ADDR_REG_OFFSET) & 0x80) { 1885 pr_debug("w83781d: Detection failed at step 7\n"); 1886 goto release; 1887 } 1888 1889 /* Determine the chip type */ 1890 outb_p(W83781D_REG_BANK, address + W83781D_ADDR_REG_OFFSET); 1891 save = inb_p(address + W83781D_DATA_REG_OFFSET); 1892 outb_p(save & 0xf8, address + W83781D_DATA_REG_OFFSET); 1893 outb_p(W83781D_REG_WCHIPID, address + W83781D_ADDR_REG_OFFSET); 1894 val = inb_p(address + W83781D_DATA_REG_OFFSET); 1895 if ((val & 0xfe) == 0x10 /* W83781D */ 1896 || val == 0x30) /* W83782D */ 1897 found = 1; 1898 1899 if (found) 1900 pr_info("w83781d: Found a %s chip at %#x\n", 1901 val == 0x30 ? "W83782D" : "W83781D", (int)address); 1902 1903 release: 1904 release_region(address + 4, 4); 1905 release_region(address, 4); 1906 return found; 1907 } 1908 1909 static int __init 1910 w83781d_isa_device_add(unsigned short address) 1911 { 1912 struct resource res = { 1913 .start = address, 1914 .end = address + W83781D_EXTENT - 1, 1915 .name = "w83781d", 1916 .flags = IORESOURCE_IO, 1917 }; 1918 int err; 1919 1920 pdev = platform_device_alloc("w83781d", address); 1921 if (!pdev) { 1922 err = -ENOMEM; 1923 printk(KERN_ERR "w83781d: Device allocation failed\n"); 1924 goto exit; 1925 } 1926 1927 err = platform_device_add_resources(pdev, &res, 1); 1928 if (err) { 1929 printk(KERN_ERR "w83781d: Device resource addition failed " 1930 "(%d)\n", err); 1931 goto exit_device_put; 1932 } 1933 1934 err = platform_device_add(pdev); 1935 if (err) { 1936 printk(KERN_ERR "w83781d: Device addition failed (%d)\n", 1937 err); 1938 goto exit_device_put; 1939 } 1940 1941 return 0; 1942 1943 exit_device_put: 1944 platform_device_put(pdev); 1945 exit: 1946 pdev = NULL; 1947 return err; 1948 } 1949 1950 static int __init 1951 w83781d_isa_register(void) 1952 { 1953 int res; 1954 1955 if (w83781d_isa_found(isa_address)) { 1956 res = platform_driver_register(&w83781d_isa_driver); 1957 if (res) 1958 goto exit; 1959 1960 /* Sets global pdev as a side effect */ 1961 res = w83781d_isa_device_add(isa_address); 1962 if (res) 1963 goto exit_unreg_isa_driver; 1964 } 1965 1966 return 0; 1967 1968 exit_unreg_isa_driver: 1969 platform_driver_unregister(&w83781d_isa_driver); 1970 exit: 1971 return res; 1972 } 1973 1974 static void 1975 w83781d_isa_unregister(void) 1976 { 1977 if (pdev) { 1978 platform_device_unregister(pdev); 1979 platform_driver_unregister(&w83781d_isa_driver); 1980 } 1981 } 1982 #else /* !CONFIG_ISA */ 1983 1984 static struct w83781d_data *w83781d_data_if_isa(void) 1985 { 1986 return NULL; 1987 } 1988 1989 static int 1990 w83781d_alias_detect(struct i2c_client *client, u8 chipid) 1991 { 1992 return 0; 1993 } 1994 1995 static int 1996 w83781d_read_value(struct w83781d_data *data, u16 reg) 1997 { 1998 int res; 1999 2000 mutex_lock(&data->lock); 2001 res = w83781d_read_value_i2c(data, reg); 2002 mutex_unlock(&data->lock); 2003 2004 return res; 2005 } 2006 2007 static int 2008 w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value) 2009 { 2010 mutex_lock(&data->lock); 2011 w83781d_write_value_i2c(data, reg, value); 2012 mutex_unlock(&data->lock); 2013 2014 return 0; 2015 } 2016 2017 static int __init 2018 w83781d_isa_register(void) 2019 { 2020 return 0; 2021 } 2022 2023 static void 2024 w83781d_isa_unregister(void) 2025 { 2026 } 2027 #endif /* CONFIG_ISA */ 2028 2029 static int __init 2030 sensors_w83781d_init(void) 2031 { 2032 int res; 2033 2034 /* We register the ISA device first, so that we can skip the 2035 * registration of an I2C interface to the same device. */ 2036 res = w83781d_isa_register(); 2037 if (res) 2038 goto exit; 2039 2040 res = i2c_add_driver(&w83781d_driver); 2041 if (res) 2042 goto exit_unreg_isa; 2043 2044 return 0; 2045 2046 exit_unreg_isa: 2047 w83781d_isa_unregister(); 2048 exit: 2049 return res; 2050 } 2051 2052 static void __exit 2053 sensors_w83781d_exit(void) 2054 { 2055 w83781d_isa_unregister(); 2056 i2c_del_driver(&w83781d_driver); 2057 } 2058 2059 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, " 2060 "Philip Edelbrock <phil@netroedge.com>, " 2061 "and Mark Studebaker <mdsxyz123@yahoo.com>"); 2062 MODULE_DESCRIPTION("W83781D driver"); 2063 MODULE_LICENSE("GPL"); 2064 2065 module_init(sensors_w83781d_init); 2066 module_exit(sensors_w83781d_exit); 2067