1 /* 2 w83791d.c - Part of lm_sensors, Linux kernel modules for hardware 3 monitoring 4 5 Copyright (C) 2006-2007 Charles Spirakis <bezaur@gmail.com> 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 /* 23 Supports following chips: 24 25 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA 26 w83791d 10 5 5 3 0x71 0x5ca3 yes no 27 28 The w83791d chip appears to be part way between the 83781d and the 29 83792d. Thus, this file is derived from both the w83792d.c and 30 w83781d.c files. 31 32 The w83791g chip is the same as the w83791d but lead-free. 33 */ 34 35 #include <linux/module.h> 36 #include <linux/init.h> 37 #include <linux/slab.h> 38 #include <linux/i2c.h> 39 #include <linux/hwmon.h> 40 #include <linux/hwmon-vid.h> 41 #include <linux/hwmon-sysfs.h> 42 #include <linux/err.h> 43 #include <linux/mutex.h> 44 45 #define NUMBER_OF_VIN 10 46 #define NUMBER_OF_FANIN 5 47 #define NUMBER_OF_TEMPIN 3 48 #define NUMBER_OF_PWM 5 49 50 /* Addresses to scan */ 51 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, 52 I2C_CLIENT_END }; 53 54 /* Insmod parameters */ 55 I2C_CLIENT_INSMOD_1(w83791d); 56 57 static unsigned short force_subclients[4]; 58 module_param_array(force_subclients, short, NULL, 0); 59 MODULE_PARM_DESC(force_subclients, "List of subclient addresses: " 60 "{bus, clientaddr, subclientaddr1, subclientaddr2}"); 61 62 static int reset; 63 module_param(reset, bool, 0); 64 MODULE_PARM_DESC(reset, "Set to one to force a hardware chip reset"); 65 66 static int init; 67 module_param(init, bool, 0); 68 MODULE_PARM_DESC(init, "Set to one to force extra software initialization"); 69 70 /* The W83791D registers */ 71 static const u8 W83791D_REG_IN[NUMBER_OF_VIN] = { 72 0x20, /* VCOREA in DataSheet */ 73 0x21, /* VINR0 in DataSheet */ 74 0x22, /* +3.3VIN in DataSheet */ 75 0x23, /* VDD5V in DataSheet */ 76 0x24, /* +12VIN in DataSheet */ 77 0x25, /* -12VIN in DataSheet */ 78 0x26, /* -5VIN in DataSheet */ 79 0xB0, /* 5VSB in DataSheet */ 80 0xB1, /* VBAT in DataSheet */ 81 0xB2 /* VINR1 in DataSheet */ 82 }; 83 84 static const u8 W83791D_REG_IN_MAX[NUMBER_OF_VIN] = { 85 0x2B, /* VCOREA High Limit in DataSheet */ 86 0x2D, /* VINR0 High Limit in DataSheet */ 87 0x2F, /* +3.3VIN High Limit in DataSheet */ 88 0x31, /* VDD5V High Limit in DataSheet */ 89 0x33, /* +12VIN High Limit in DataSheet */ 90 0x35, /* -12VIN High Limit in DataSheet */ 91 0x37, /* -5VIN High Limit in DataSheet */ 92 0xB4, /* 5VSB High Limit in DataSheet */ 93 0xB6, /* VBAT High Limit in DataSheet */ 94 0xB8 /* VINR1 High Limit in DataSheet */ 95 }; 96 static const u8 W83791D_REG_IN_MIN[NUMBER_OF_VIN] = { 97 0x2C, /* VCOREA Low Limit in DataSheet */ 98 0x2E, /* VINR0 Low Limit in DataSheet */ 99 0x30, /* +3.3VIN Low Limit in DataSheet */ 100 0x32, /* VDD5V Low Limit in DataSheet */ 101 0x34, /* +12VIN Low Limit in DataSheet */ 102 0x36, /* -12VIN Low Limit in DataSheet */ 103 0x38, /* -5VIN Low Limit in DataSheet */ 104 0xB5, /* 5VSB Low Limit in DataSheet */ 105 0xB7, /* VBAT Low Limit in DataSheet */ 106 0xB9 /* VINR1 Low Limit in DataSheet */ 107 }; 108 static const u8 W83791D_REG_FAN[NUMBER_OF_FANIN] = { 109 0x28, /* FAN 1 Count in DataSheet */ 110 0x29, /* FAN 2 Count in DataSheet */ 111 0x2A, /* FAN 3 Count in DataSheet */ 112 0xBA, /* FAN 4 Count in DataSheet */ 113 0xBB, /* FAN 5 Count in DataSheet */ 114 }; 115 static const u8 W83791D_REG_FAN_MIN[NUMBER_OF_FANIN] = { 116 0x3B, /* FAN 1 Count Low Limit in DataSheet */ 117 0x3C, /* FAN 2 Count Low Limit in DataSheet */ 118 0x3D, /* FAN 3 Count Low Limit in DataSheet */ 119 0xBC, /* FAN 4 Count Low Limit in DataSheet */ 120 0xBD, /* FAN 5 Count Low Limit in DataSheet */ 121 }; 122 123 static const u8 W83791D_REG_PWM[NUMBER_OF_PWM] = { 124 0x81, /* PWM 1 duty cycle register in DataSheet */ 125 0x83, /* PWM 2 duty cycle register in DataSheet */ 126 0x94, /* PWM 3 duty cycle register in DataSheet */ 127 0xA0, /* PWM 4 duty cycle register in DataSheet */ 128 0xA1, /* PWM 5 duty cycle register in DataSheet */ 129 }; 130 131 static const u8 W83791D_REG_TEMP_TARGET[3] = { 132 0x85, /* PWM 1 target temperature for temp 1 */ 133 0x86, /* PWM 2 target temperature for temp 2 */ 134 0x96, /* PWM 3 target temperature for temp 3 */ 135 }; 136 137 static const u8 W83791D_REG_TEMP_TOL[2] = { 138 0x87, /* PWM 1/2 temperature tolerance */ 139 0x97, /* PWM 3 temperature tolerance */ 140 }; 141 142 static const u8 W83791D_REG_FAN_CFG[2] = { 143 0x84, /* FAN 1/2 configuration */ 144 0x95, /* FAN 3 configuration */ 145 }; 146 147 static const u8 W83791D_REG_FAN_DIV[3] = { 148 0x47, /* contains FAN1 and FAN2 Divisor */ 149 0x4b, /* contains FAN3 Divisor */ 150 0x5C, /* contains FAN4 and FAN5 Divisor */ 151 }; 152 153 #define W83791D_REG_BANK 0x4E 154 #define W83791D_REG_TEMP2_CONFIG 0xC2 155 #define W83791D_REG_TEMP3_CONFIG 0xCA 156 157 static const u8 W83791D_REG_TEMP1[3] = { 158 0x27, /* TEMP 1 in DataSheet */ 159 0x39, /* TEMP 1 Over in DataSheet */ 160 0x3A, /* TEMP 1 Hyst in DataSheet */ 161 }; 162 163 static const u8 W83791D_REG_TEMP_ADD[2][6] = { 164 {0xC0, /* TEMP 2 in DataSheet */ 165 0xC1, /* TEMP 2(0.5 deg) in DataSheet */ 166 0xC5, /* TEMP 2 Over High part in DataSheet */ 167 0xC6, /* TEMP 2 Over Low part in DataSheet */ 168 0xC3, /* TEMP 2 Thyst High part in DataSheet */ 169 0xC4}, /* TEMP 2 Thyst Low part in DataSheet */ 170 {0xC8, /* TEMP 3 in DataSheet */ 171 0xC9, /* TEMP 3(0.5 deg) in DataSheet */ 172 0xCD, /* TEMP 3 Over High part in DataSheet */ 173 0xCE, /* TEMP 3 Over Low part in DataSheet */ 174 0xCB, /* TEMP 3 Thyst High part in DataSheet */ 175 0xCC} /* TEMP 3 Thyst Low part in DataSheet */ 176 }; 177 178 #define W83791D_REG_BEEP_CONFIG 0x4D 179 180 static const u8 W83791D_REG_BEEP_CTRL[3] = { 181 0x56, /* BEEP Control Register 1 */ 182 0x57, /* BEEP Control Register 2 */ 183 0xA3, /* BEEP Control Register 3 */ 184 }; 185 186 #define W83791D_REG_GPIO 0x15 187 #define W83791D_REG_CONFIG 0x40 188 #define W83791D_REG_VID_FANDIV 0x47 189 #define W83791D_REG_DID_VID4 0x49 190 #define W83791D_REG_WCHIPID 0x58 191 #define W83791D_REG_CHIPMAN 0x4F 192 #define W83791D_REG_PIN 0x4B 193 #define W83791D_REG_I2C_SUBADDR 0x4A 194 195 #define W83791D_REG_ALARM1 0xA9 /* realtime status register1 */ 196 #define W83791D_REG_ALARM2 0xAA /* realtime status register2 */ 197 #define W83791D_REG_ALARM3 0xAB /* realtime status register3 */ 198 199 #define W83791D_REG_VBAT 0x5D 200 #define W83791D_REG_I2C_ADDR 0x48 201 202 /* The SMBus locks itself. The Winbond W83791D has a bank select register 203 (index 0x4e), but the driver only accesses registers in bank 0. Since 204 we don't switch banks, we don't need any special code to handle 205 locking access between bank switches */ 206 static inline int w83791d_read(struct i2c_client *client, u8 reg) 207 { 208 return i2c_smbus_read_byte_data(client, reg); 209 } 210 211 static inline int w83791d_write(struct i2c_client *client, u8 reg, u8 value) 212 { 213 return i2c_smbus_write_byte_data(client, reg, value); 214 } 215 216 /* The analog voltage inputs have 16mV LSB. Since the sysfs output is 217 in mV as would be measured on the chip input pin, need to just 218 multiply/divide by 16 to translate from/to register values. */ 219 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8) / 16), 0, 255)) 220 #define IN_FROM_REG(val) ((val) * 16) 221 222 static u8 fan_to_reg(long rpm, int div) 223 { 224 if (rpm == 0) 225 return 255; 226 rpm = SENSORS_LIMIT(rpm, 1, 1000000); 227 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254); 228 } 229 230 #define FAN_FROM_REG(val,div) ((val) == 0 ? -1 : \ 231 ((val) == 255 ? 0 : \ 232 1350000 / ((val) * (div)))) 233 234 /* for temp1 which is 8-bit resolution, LSB = 1 degree Celsius */ 235 #define TEMP1_FROM_REG(val) ((val) * 1000) 236 #define TEMP1_TO_REG(val) ((val) <= -128000 ? -128 : \ 237 (val) >= 127000 ? 127 : \ 238 (val) < 0 ? ((val) - 500) / 1000 : \ 239 ((val) + 500) / 1000) 240 241 /* for temp2 and temp3 which are 9-bit resolution, LSB = 0.5 degree Celsius 242 Assumes the top 8 bits are the integral amount and the bottom 8 bits 243 are the fractional amount. Since we only have 0.5 degree resolution, 244 the bottom 7 bits will always be zero */ 245 #define TEMP23_FROM_REG(val) ((val) / 128 * 500) 246 #define TEMP23_TO_REG(val) ((val) <= -128000 ? 0x8000 : \ 247 (val) >= 127500 ? 0x7F80 : \ 248 (val) < 0 ? ((val) - 250) / 500 * 128 : \ 249 ((val) + 250) / 500 * 128) 250 251 /* for thermal cruise target temp, 7-bits, LSB = 1 degree Celsius */ 252 #define TARGET_TEMP_TO_REG(val) ((val) < 0 ? 0 : \ 253 (val) >= 127000 ? 127 : \ 254 ((val) + 500) / 1000) 255 256 /* for thermal cruise temp tolerance, 4-bits, LSB = 1 degree Celsius */ 257 #define TOL_TEMP_TO_REG(val) ((val) < 0 ? 0 : \ 258 (val) >= 15000 ? 15 : \ 259 ((val) + 500) / 1000) 260 261 #define BEEP_MASK_TO_REG(val) ((val) & 0xffffff) 262 #define BEEP_MASK_FROM_REG(val) ((val) & 0xffffff) 263 264 #define DIV_FROM_REG(val) (1 << (val)) 265 266 static u8 div_to_reg(int nr, long val) 267 { 268 int i; 269 270 /* fan divisors max out at 128 */ 271 val = SENSORS_LIMIT(val, 1, 128) >> 1; 272 for (i = 0; i < 7; i++) { 273 if (val == 0) 274 break; 275 val >>= 1; 276 } 277 return (u8) i; 278 } 279 280 struct w83791d_data { 281 struct device *hwmon_dev; 282 struct mutex update_lock; 283 284 char valid; /* !=0 if following fields are valid */ 285 unsigned long last_updated; /* In jiffies */ 286 287 /* array of 2 pointers to subclients */ 288 struct i2c_client *lm75[2]; 289 290 /* volts */ 291 u8 in[NUMBER_OF_VIN]; /* Register value */ 292 u8 in_max[NUMBER_OF_VIN]; /* Register value */ 293 u8 in_min[NUMBER_OF_VIN]; /* Register value */ 294 295 /* fans */ 296 u8 fan[NUMBER_OF_FANIN]; /* Register value */ 297 u8 fan_min[NUMBER_OF_FANIN]; /* Register value */ 298 u8 fan_div[NUMBER_OF_FANIN]; /* Register encoding, shifted right */ 299 300 /* Temperature sensors */ 301 302 s8 temp1[3]; /* current, over, thyst */ 303 s16 temp_add[2][3]; /* fixed point value. Top 8 bits are the 304 integral part, bottom 8 bits are the 305 fractional part. We only use the top 306 9 bits as the resolution is only 307 to the 0.5 degree C... 308 two sensors with three values 309 (cur, over, hyst) */ 310 311 /* PWMs */ 312 u8 pwm[5]; /* pwm duty cycle */ 313 u8 pwm_enable[3]; /* pwm enable status for fan 1-3 314 (fan 4-5 only support manual mode) */ 315 316 u8 temp_target[3]; /* pwm 1-3 target temperature */ 317 u8 temp_tolerance[3]; /* pwm 1-3 temperature tolerance */ 318 319 /* Misc */ 320 u32 alarms; /* realtime status register encoding,combined */ 321 u8 beep_enable; /* Global beep enable */ 322 u32 beep_mask; /* Mask off specific beeps */ 323 u8 vid; /* Register encoding, combined */ 324 u8 vrm; /* hwmon-vid */ 325 }; 326 327 static int w83791d_probe(struct i2c_client *client, 328 const struct i2c_device_id *id); 329 static int w83791d_detect(struct i2c_client *client, int kind, 330 struct i2c_board_info *info); 331 static int w83791d_remove(struct i2c_client *client); 332 333 static int w83791d_read(struct i2c_client *client, u8 register); 334 static int w83791d_write(struct i2c_client *client, u8 register, u8 value); 335 static struct w83791d_data *w83791d_update_device(struct device *dev); 336 337 #ifdef DEBUG 338 static void w83791d_print_debug(struct w83791d_data *data, struct device *dev); 339 #endif 340 341 static void w83791d_init_client(struct i2c_client *client); 342 343 static const struct i2c_device_id w83791d_id[] = { 344 { "w83791d", w83791d }, 345 { } 346 }; 347 MODULE_DEVICE_TABLE(i2c, w83791d_id); 348 349 static struct i2c_driver w83791d_driver = { 350 .class = I2C_CLASS_HWMON, 351 .driver = { 352 .name = "w83791d", 353 }, 354 .probe = w83791d_probe, 355 .remove = w83791d_remove, 356 .id_table = w83791d_id, 357 .detect = w83791d_detect, 358 .address_data = &addr_data, 359 }; 360 361 /* following are the sysfs callback functions */ 362 #define show_in_reg(reg) \ 363 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \ 364 char *buf) \ 365 { \ 366 struct sensor_device_attribute *sensor_attr = \ 367 to_sensor_dev_attr(attr); \ 368 struct w83791d_data *data = w83791d_update_device(dev); \ 369 int nr = sensor_attr->index; \ 370 return sprintf(buf,"%d\n", IN_FROM_REG(data->reg[nr])); \ 371 } 372 373 show_in_reg(in); 374 show_in_reg(in_min); 375 show_in_reg(in_max); 376 377 #define store_in_reg(REG, reg) \ 378 static ssize_t store_in_##reg(struct device *dev, \ 379 struct device_attribute *attr, \ 380 const char *buf, size_t count) \ 381 { \ 382 struct sensor_device_attribute *sensor_attr = \ 383 to_sensor_dev_attr(attr); \ 384 struct i2c_client *client = to_i2c_client(dev); \ 385 struct w83791d_data *data = i2c_get_clientdata(client); \ 386 unsigned long val = simple_strtoul(buf, NULL, 10); \ 387 int nr = sensor_attr->index; \ 388 \ 389 mutex_lock(&data->update_lock); \ 390 data->in_##reg[nr] = IN_TO_REG(val); \ 391 w83791d_write(client, W83791D_REG_IN_##REG[nr], data->in_##reg[nr]); \ 392 mutex_unlock(&data->update_lock); \ 393 \ 394 return count; \ 395 } 396 store_in_reg(MIN, min); 397 store_in_reg(MAX, max); 398 399 static struct sensor_device_attribute sda_in_input[] = { 400 SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0), 401 SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1), 402 SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2), 403 SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3), 404 SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4), 405 SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5), 406 SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6), 407 SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7), 408 SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8), 409 SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9), 410 }; 411 412 static struct sensor_device_attribute sda_in_min[] = { 413 SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0), 414 SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1), 415 SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2), 416 SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3), 417 SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4), 418 SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5), 419 SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6), 420 SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7), 421 SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8), 422 SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9), 423 }; 424 425 static struct sensor_device_attribute sda_in_max[] = { 426 SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0), 427 SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1), 428 SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2), 429 SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3), 430 SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4), 431 SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5), 432 SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6), 433 SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7), 434 SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8), 435 SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9), 436 }; 437 438 439 static ssize_t show_beep(struct device *dev, struct device_attribute *attr, 440 char *buf) 441 { 442 struct sensor_device_attribute *sensor_attr = 443 to_sensor_dev_attr(attr); 444 struct w83791d_data *data = w83791d_update_device(dev); 445 int bitnr = sensor_attr->index; 446 447 return sprintf(buf, "%d\n", (data->beep_mask >> bitnr) & 1); 448 } 449 450 static ssize_t store_beep(struct device *dev, struct device_attribute *attr, 451 const char *buf, size_t count) 452 { 453 struct sensor_device_attribute *sensor_attr = 454 to_sensor_dev_attr(attr); 455 struct i2c_client *client = to_i2c_client(dev); 456 struct w83791d_data *data = i2c_get_clientdata(client); 457 int bitnr = sensor_attr->index; 458 int bytenr = bitnr / 8; 459 long val = simple_strtol(buf, NULL, 10) ? 1 : 0; 460 461 mutex_lock(&data->update_lock); 462 463 data->beep_mask &= ~(0xff << (bytenr * 8)); 464 data->beep_mask |= w83791d_read(client, W83791D_REG_BEEP_CTRL[bytenr]) 465 << (bytenr * 8); 466 467 data->beep_mask &= ~(1 << bitnr); 468 data->beep_mask |= val << bitnr; 469 470 w83791d_write(client, W83791D_REG_BEEP_CTRL[bytenr], 471 (data->beep_mask >> (bytenr * 8)) & 0xff); 472 473 mutex_unlock(&data->update_lock); 474 475 return count; 476 } 477 478 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, 479 char *buf) 480 { 481 struct sensor_device_attribute *sensor_attr = 482 to_sensor_dev_attr(attr); 483 struct w83791d_data *data = w83791d_update_device(dev); 484 int bitnr = sensor_attr->index; 485 486 return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1); 487 } 488 489 /* Note: The bitmask for the beep enable/disable is different than 490 the bitmask for the alarm. */ 491 static struct sensor_device_attribute sda_in_beep[] = { 492 SENSOR_ATTR(in0_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 0), 493 SENSOR_ATTR(in1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 13), 494 SENSOR_ATTR(in2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 2), 495 SENSOR_ATTR(in3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 3), 496 SENSOR_ATTR(in4_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 8), 497 SENSOR_ATTR(in5_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 9), 498 SENSOR_ATTR(in6_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 10), 499 SENSOR_ATTR(in7_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 16), 500 SENSOR_ATTR(in8_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 17), 501 SENSOR_ATTR(in9_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 14), 502 }; 503 504 static struct sensor_device_attribute sda_in_alarm[] = { 505 SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0), 506 SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1), 507 SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2), 508 SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3), 509 SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8), 510 SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9), 511 SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10), 512 SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 19), 513 SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 20), 514 SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 14), 515 }; 516 517 #define show_fan_reg(reg) \ 518 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \ 519 char *buf) \ 520 { \ 521 struct sensor_device_attribute *sensor_attr = \ 522 to_sensor_dev_attr(attr); \ 523 struct w83791d_data *data = w83791d_update_device(dev); \ 524 int nr = sensor_attr->index; \ 525 return sprintf(buf,"%d\n", \ 526 FAN_FROM_REG(data->reg[nr], DIV_FROM_REG(data->fan_div[nr]))); \ 527 } 528 529 show_fan_reg(fan); 530 show_fan_reg(fan_min); 531 532 static ssize_t store_fan_min(struct device *dev, struct device_attribute *attr, 533 const char *buf, size_t count) 534 { 535 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 536 struct i2c_client *client = to_i2c_client(dev); 537 struct w83791d_data *data = i2c_get_clientdata(client); 538 unsigned long val = simple_strtoul(buf, NULL, 10); 539 int nr = sensor_attr->index; 540 541 mutex_lock(&data->update_lock); 542 data->fan_min[nr] = fan_to_reg(val, DIV_FROM_REG(data->fan_div[nr])); 543 w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]); 544 mutex_unlock(&data->update_lock); 545 546 return count; 547 } 548 549 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr, 550 char *buf) 551 { 552 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 553 int nr = sensor_attr->index; 554 struct w83791d_data *data = w83791d_update_device(dev); 555 return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr])); 556 } 557 558 /* Note: we save and restore the fan minimum here, because its value is 559 determined in part by the fan divisor. This follows the principle of 560 least suprise; the user doesn't expect the fan minimum to change just 561 because the divisor changed. */ 562 static ssize_t store_fan_div(struct device *dev, struct device_attribute *attr, 563 const char *buf, size_t count) 564 { 565 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 566 struct i2c_client *client = to_i2c_client(dev); 567 struct w83791d_data *data = i2c_get_clientdata(client); 568 int nr = sensor_attr->index; 569 unsigned long min; 570 u8 tmp_fan_div; 571 u8 fan_div_reg; 572 u8 vbat_reg; 573 int indx = 0; 574 u8 keep_mask = 0; 575 u8 new_shift = 0; 576 577 /* Save fan_min */ 578 min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])); 579 580 mutex_lock(&data->update_lock); 581 data->fan_div[nr] = div_to_reg(nr, simple_strtoul(buf, NULL, 10)); 582 583 switch (nr) { 584 case 0: 585 indx = 0; 586 keep_mask = 0xcf; 587 new_shift = 4; 588 break; 589 case 1: 590 indx = 0; 591 keep_mask = 0x3f; 592 new_shift = 6; 593 break; 594 case 2: 595 indx = 1; 596 keep_mask = 0x3f; 597 new_shift = 6; 598 break; 599 case 3: 600 indx = 2; 601 keep_mask = 0xf8; 602 new_shift = 0; 603 break; 604 case 4: 605 indx = 2; 606 keep_mask = 0x8f; 607 new_shift = 4; 608 break; 609 #ifdef DEBUG 610 default: 611 dev_warn(dev, "store_fan_div: Unexpected nr seen: %d\n", nr); 612 count = -EINVAL; 613 goto err_exit; 614 #endif 615 } 616 617 fan_div_reg = w83791d_read(client, W83791D_REG_FAN_DIV[indx]) 618 & keep_mask; 619 tmp_fan_div = (data->fan_div[nr] << new_shift) & ~keep_mask; 620 621 w83791d_write(client, W83791D_REG_FAN_DIV[indx], 622 fan_div_reg | tmp_fan_div); 623 624 /* Bit 2 of fans 0-2 is stored in the vbat register (bits 5-7) */ 625 if (nr < 3) { 626 keep_mask = ~(1 << (nr + 5)); 627 vbat_reg = w83791d_read(client, W83791D_REG_VBAT) 628 & keep_mask; 629 tmp_fan_div = (data->fan_div[nr] << (3 + nr)) & ~keep_mask; 630 w83791d_write(client, W83791D_REG_VBAT, 631 vbat_reg | tmp_fan_div); 632 } 633 634 /* Restore fan_min */ 635 data->fan_min[nr] = fan_to_reg(min, DIV_FROM_REG(data->fan_div[nr])); 636 w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]); 637 638 #ifdef DEBUG 639 err_exit: 640 #endif 641 mutex_unlock(&data->update_lock); 642 643 return count; 644 } 645 646 static struct sensor_device_attribute sda_fan_input[] = { 647 SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0), 648 SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1), 649 SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2), 650 SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3), 651 SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4), 652 }; 653 654 static struct sensor_device_attribute sda_fan_min[] = { 655 SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, 656 show_fan_min, store_fan_min, 0), 657 SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, 658 show_fan_min, store_fan_min, 1), 659 SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, 660 show_fan_min, store_fan_min, 2), 661 SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, 662 show_fan_min, store_fan_min, 3), 663 SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, 664 show_fan_min, store_fan_min, 4), 665 }; 666 667 static struct sensor_device_attribute sda_fan_div[] = { 668 SENSOR_ATTR(fan1_div, S_IWUSR | S_IRUGO, 669 show_fan_div, store_fan_div, 0), 670 SENSOR_ATTR(fan2_div, S_IWUSR | S_IRUGO, 671 show_fan_div, store_fan_div, 1), 672 SENSOR_ATTR(fan3_div, S_IWUSR | S_IRUGO, 673 show_fan_div, store_fan_div, 2), 674 SENSOR_ATTR(fan4_div, S_IWUSR | S_IRUGO, 675 show_fan_div, store_fan_div, 3), 676 SENSOR_ATTR(fan5_div, S_IWUSR | S_IRUGO, 677 show_fan_div, store_fan_div, 4), 678 }; 679 680 static struct sensor_device_attribute sda_fan_beep[] = { 681 SENSOR_ATTR(fan1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 6), 682 SENSOR_ATTR(fan2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 7), 683 SENSOR_ATTR(fan3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 11), 684 SENSOR_ATTR(fan4_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 21), 685 SENSOR_ATTR(fan5_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 22), 686 }; 687 688 static struct sensor_device_attribute sda_fan_alarm[] = { 689 SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6), 690 SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7), 691 SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11), 692 SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 21), 693 SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 22), 694 }; 695 696 /* read/write PWMs */ 697 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr, 698 char *buf) 699 { 700 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 701 int nr = sensor_attr->index; 702 struct w83791d_data *data = w83791d_update_device(dev); 703 return sprintf(buf, "%u\n", data->pwm[nr]); 704 } 705 706 static ssize_t store_pwm(struct device *dev, struct device_attribute *attr, 707 const char *buf, size_t count) 708 { 709 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 710 struct i2c_client *client = to_i2c_client(dev); 711 struct w83791d_data *data = i2c_get_clientdata(client); 712 int nr = sensor_attr->index; 713 unsigned long val; 714 715 if (strict_strtoul(buf, 10, &val)) 716 return -EINVAL; 717 718 mutex_lock(&data->update_lock); 719 data->pwm[nr] = SENSORS_LIMIT(val, 0, 255); 720 w83791d_write(client, W83791D_REG_PWM[nr], data->pwm[nr]); 721 mutex_unlock(&data->update_lock); 722 return count; 723 } 724 725 static struct sensor_device_attribute sda_pwm[] = { 726 SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, 727 show_pwm, store_pwm, 0), 728 SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, 729 show_pwm, store_pwm, 1), 730 SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO, 731 show_pwm, store_pwm, 2), 732 SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO, 733 show_pwm, store_pwm, 3), 734 SENSOR_ATTR(pwm5, S_IWUSR | S_IRUGO, 735 show_pwm, store_pwm, 4), 736 }; 737 738 static ssize_t show_pwmenable(struct device *dev, struct device_attribute *attr, 739 char *buf) 740 { 741 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 742 int nr = sensor_attr->index; 743 struct w83791d_data *data = w83791d_update_device(dev); 744 return sprintf(buf, "%u\n", data->pwm_enable[nr] + 1); 745 } 746 747 static ssize_t store_pwmenable(struct device *dev, 748 struct device_attribute *attr, const char *buf, size_t count) 749 { 750 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 751 struct i2c_client *client = to_i2c_client(dev); 752 struct w83791d_data *data = i2c_get_clientdata(client); 753 int nr = sensor_attr->index; 754 unsigned long val; 755 u8 reg_cfg_tmp; 756 u8 reg_idx = 0; 757 u8 val_shift = 0; 758 u8 keep_mask = 0; 759 760 int ret = strict_strtoul(buf, 10, &val); 761 762 if (ret || val < 1 || val > 3) 763 return -EINVAL; 764 765 mutex_lock(&data->update_lock); 766 data->pwm_enable[nr] = val - 1; 767 switch (nr) { 768 case 0: 769 reg_idx = 0; 770 val_shift = 2; 771 keep_mask = 0xf3; 772 break; 773 case 1: 774 reg_idx = 0; 775 val_shift = 4; 776 keep_mask = 0xcf; 777 break; 778 case 2: 779 reg_idx = 1; 780 val_shift = 2; 781 keep_mask = 0xf3; 782 break; 783 } 784 785 reg_cfg_tmp = w83791d_read(client, W83791D_REG_FAN_CFG[reg_idx]); 786 reg_cfg_tmp = (reg_cfg_tmp & keep_mask) | 787 data->pwm_enable[nr] << val_shift; 788 789 w83791d_write(client, W83791D_REG_FAN_CFG[reg_idx], reg_cfg_tmp); 790 mutex_unlock(&data->update_lock); 791 792 return count; 793 } 794 static struct sensor_device_attribute sda_pwmenable[] = { 795 SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, 796 show_pwmenable, store_pwmenable, 0), 797 SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, 798 show_pwmenable, store_pwmenable, 1), 799 SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, 800 show_pwmenable, store_pwmenable, 2), 801 }; 802 803 /* For Smart Fan I / Thermal Cruise */ 804 static ssize_t show_temp_target(struct device *dev, 805 struct device_attribute *attr, char *buf) 806 { 807 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 808 struct w83791d_data *data = w83791d_update_device(dev); 809 int nr = sensor_attr->index; 810 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp_target[nr])); 811 } 812 813 static ssize_t store_temp_target(struct device *dev, 814 struct device_attribute *attr, const char *buf, size_t count) 815 { 816 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 817 struct i2c_client *client = to_i2c_client(dev); 818 struct w83791d_data *data = i2c_get_clientdata(client); 819 int nr = sensor_attr->index; 820 unsigned long val; 821 u8 target_mask; 822 823 if (strict_strtoul(buf, 10, &val)) 824 return -EINVAL; 825 826 mutex_lock(&data->update_lock); 827 data->temp_target[nr] = TARGET_TEMP_TO_REG(val); 828 target_mask = w83791d_read(client, 829 W83791D_REG_TEMP_TARGET[nr]) & 0x80; 830 w83791d_write(client, W83791D_REG_TEMP_TARGET[nr], 831 data->temp_target[nr] | target_mask); 832 mutex_unlock(&data->update_lock); 833 return count; 834 } 835 836 static struct sensor_device_attribute sda_temp_target[] = { 837 SENSOR_ATTR(temp1_target, S_IWUSR | S_IRUGO, 838 show_temp_target, store_temp_target, 0), 839 SENSOR_ATTR(temp2_target, S_IWUSR | S_IRUGO, 840 show_temp_target, store_temp_target, 1), 841 SENSOR_ATTR(temp3_target, S_IWUSR | S_IRUGO, 842 show_temp_target, store_temp_target, 2), 843 }; 844 845 static ssize_t show_temp_tolerance(struct device *dev, 846 struct device_attribute *attr, char *buf) 847 { 848 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 849 struct w83791d_data *data = w83791d_update_device(dev); 850 int nr = sensor_attr->index; 851 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp_tolerance[nr])); 852 } 853 854 static ssize_t store_temp_tolerance(struct device *dev, 855 struct device_attribute *attr, const char *buf, size_t count) 856 { 857 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 858 struct i2c_client *client = to_i2c_client(dev); 859 struct w83791d_data *data = i2c_get_clientdata(client); 860 int nr = sensor_attr->index; 861 unsigned long val; 862 u8 target_mask; 863 u8 reg_idx = 0; 864 u8 val_shift = 0; 865 u8 keep_mask = 0; 866 867 if (strict_strtoul(buf, 10, &val)) 868 return -EINVAL; 869 870 switch (nr) { 871 case 0: 872 reg_idx = 0; 873 val_shift = 0; 874 keep_mask = 0xf0; 875 break; 876 case 1: 877 reg_idx = 0; 878 val_shift = 4; 879 keep_mask = 0x0f; 880 break; 881 case 2: 882 reg_idx = 1; 883 val_shift = 0; 884 keep_mask = 0xf0; 885 break; 886 } 887 888 mutex_lock(&data->update_lock); 889 data->temp_tolerance[nr] = TOL_TEMP_TO_REG(val); 890 target_mask = w83791d_read(client, 891 W83791D_REG_TEMP_TOL[reg_idx]) & keep_mask; 892 w83791d_write(client, W83791D_REG_TEMP_TOL[reg_idx], 893 (data->temp_tolerance[nr] << val_shift) | target_mask); 894 mutex_unlock(&data->update_lock); 895 return count; 896 } 897 898 static struct sensor_device_attribute sda_temp_tolerance[] = { 899 SENSOR_ATTR(temp1_tolerance, S_IWUSR | S_IRUGO, 900 show_temp_tolerance, store_temp_tolerance, 0), 901 SENSOR_ATTR(temp2_tolerance, S_IWUSR | S_IRUGO, 902 show_temp_tolerance, store_temp_tolerance, 1), 903 SENSOR_ATTR(temp3_tolerance, S_IWUSR | S_IRUGO, 904 show_temp_tolerance, store_temp_tolerance, 2), 905 }; 906 907 /* read/write the temperature1, includes measured value and limits */ 908 static ssize_t show_temp1(struct device *dev, struct device_attribute *devattr, 909 char *buf) 910 { 911 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 912 struct w83791d_data *data = w83791d_update_device(dev); 913 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp1[attr->index])); 914 } 915 916 static ssize_t store_temp1(struct device *dev, struct device_attribute *devattr, 917 const char *buf, size_t count) 918 { 919 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 920 struct i2c_client *client = to_i2c_client(dev); 921 struct w83791d_data *data = i2c_get_clientdata(client); 922 long val = simple_strtol(buf, NULL, 10); 923 int nr = attr->index; 924 925 mutex_lock(&data->update_lock); 926 data->temp1[nr] = TEMP1_TO_REG(val); 927 w83791d_write(client, W83791D_REG_TEMP1[nr], data->temp1[nr]); 928 mutex_unlock(&data->update_lock); 929 return count; 930 } 931 932 /* read/write temperature2-3, includes measured value and limits */ 933 static ssize_t show_temp23(struct device *dev, struct device_attribute *devattr, 934 char *buf) 935 { 936 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); 937 struct w83791d_data *data = w83791d_update_device(dev); 938 int nr = attr->nr; 939 int index = attr->index; 940 return sprintf(buf, "%d\n", TEMP23_FROM_REG(data->temp_add[nr][index])); 941 } 942 943 static ssize_t store_temp23(struct device *dev, 944 struct device_attribute *devattr, 945 const char *buf, size_t count) 946 { 947 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); 948 struct i2c_client *client = to_i2c_client(dev); 949 struct w83791d_data *data = i2c_get_clientdata(client); 950 long val = simple_strtol(buf, NULL, 10); 951 int nr = attr->nr; 952 int index = attr->index; 953 954 mutex_lock(&data->update_lock); 955 data->temp_add[nr][index] = TEMP23_TO_REG(val); 956 w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2], 957 data->temp_add[nr][index] >> 8); 958 w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2 + 1], 959 data->temp_add[nr][index] & 0x80); 960 mutex_unlock(&data->update_lock); 961 962 return count; 963 } 964 965 static struct sensor_device_attribute_2 sda_temp_input[] = { 966 SENSOR_ATTR_2(temp1_input, S_IRUGO, show_temp1, NULL, 0, 0), 967 SENSOR_ATTR_2(temp2_input, S_IRUGO, show_temp23, NULL, 0, 0), 968 SENSOR_ATTR_2(temp3_input, S_IRUGO, show_temp23, NULL, 1, 0), 969 }; 970 971 static struct sensor_device_attribute_2 sda_temp_max[] = { 972 SENSOR_ATTR_2(temp1_max, S_IRUGO | S_IWUSR, 973 show_temp1, store_temp1, 0, 1), 974 SENSOR_ATTR_2(temp2_max, S_IRUGO | S_IWUSR, 975 show_temp23, store_temp23, 0, 1), 976 SENSOR_ATTR_2(temp3_max, S_IRUGO | S_IWUSR, 977 show_temp23, store_temp23, 1, 1), 978 }; 979 980 static struct sensor_device_attribute_2 sda_temp_max_hyst[] = { 981 SENSOR_ATTR_2(temp1_max_hyst, S_IRUGO | S_IWUSR, 982 show_temp1, store_temp1, 0, 2), 983 SENSOR_ATTR_2(temp2_max_hyst, S_IRUGO | S_IWUSR, 984 show_temp23, store_temp23, 0, 2), 985 SENSOR_ATTR_2(temp3_max_hyst, S_IRUGO | S_IWUSR, 986 show_temp23, store_temp23, 1, 2), 987 }; 988 989 /* Note: The bitmask for the beep enable/disable is different than 990 the bitmask for the alarm. */ 991 static struct sensor_device_attribute sda_temp_beep[] = { 992 SENSOR_ATTR(temp1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 4), 993 SENSOR_ATTR(temp2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 5), 994 SENSOR_ATTR(temp3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 1), 995 }; 996 997 static struct sensor_device_attribute sda_temp_alarm[] = { 998 SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4), 999 SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5), 1000 SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13), 1001 }; 1002 1003 /* get reatime status of all sensors items: voltage, temp, fan */ 1004 static ssize_t show_alarms_reg(struct device *dev, 1005 struct device_attribute *attr, char *buf) 1006 { 1007 struct w83791d_data *data = w83791d_update_device(dev); 1008 return sprintf(buf, "%u\n", data->alarms); 1009 } 1010 1011 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL); 1012 1013 /* Beep control */ 1014 1015 #define GLOBAL_BEEP_ENABLE_SHIFT 15 1016 #define GLOBAL_BEEP_ENABLE_MASK (1 << GLOBAL_BEEP_ENABLE_SHIFT) 1017 1018 static ssize_t show_beep_enable(struct device *dev, 1019 struct device_attribute *attr, char *buf) 1020 { 1021 struct w83791d_data *data = w83791d_update_device(dev); 1022 return sprintf(buf, "%d\n", data->beep_enable); 1023 } 1024 1025 static ssize_t show_beep_mask(struct device *dev, 1026 struct device_attribute *attr, char *buf) 1027 { 1028 struct w83791d_data *data = w83791d_update_device(dev); 1029 return sprintf(buf, "%d\n", BEEP_MASK_FROM_REG(data->beep_mask)); 1030 } 1031 1032 1033 static ssize_t store_beep_mask(struct device *dev, 1034 struct device_attribute *attr, 1035 const char *buf, size_t count) 1036 { 1037 struct i2c_client *client = to_i2c_client(dev); 1038 struct w83791d_data *data = i2c_get_clientdata(client); 1039 long val = simple_strtol(buf, NULL, 10); 1040 int i; 1041 1042 mutex_lock(&data->update_lock); 1043 1044 /* The beep_enable state overrides any enabling request from 1045 the masks */ 1046 data->beep_mask = BEEP_MASK_TO_REG(val) & ~GLOBAL_BEEP_ENABLE_MASK; 1047 data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT); 1048 1049 val = data->beep_mask; 1050 1051 for (i = 0; i < 3; i++) { 1052 w83791d_write(client, W83791D_REG_BEEP_CTRL[i], (val & 0xff)); 1053 val >>= 8; 1054 } 1055 1056 mutex_unlock(&data->update_lock); 1057 1058 return count; 1059 } 1060 1061 static ssize_t store_beep_enable(struct device *dev, 1062 struct device_attribute *attr, 1063 const char *buf, size_t count) 1064 { 1065 struct i2c_client *client = to_i2c_client(dev); 1066 struct w83791d_data *data = i2c_get_clientdata(client); 1067 long val = simple_strtol(buf, NULL, 10); 1068 1069 mutex_lock(&data->update_lock); 1070 1071 data->beep_enable = val ? 1 : 0; 1072 1073 /* Keep the full mask value in sync with the current enable */ 1074 data->beep_mask &= ~GLOBAL_BEEP_ENABLE_MASK; 1075 data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT); 1076 1077 /* The global control is in the second beep control register 1078 so only need to update that register */ 1079 val = (data->beep_mask >> 8) & 0xff; 1080 1081 w83791d_write(client, W83791D_REG_BEEP_CTRL[1], val); 1082 1083 mutex_unlock(&data->update_lock); 1084 1085 return count; 1086 } 1087 1088 static struct sensor_device_attribute sda_beep_ctrl[] = { 1089 SENSOR_ATTR(beep_enable, S_IRUGO | S_IWUSR, 1090 show_beep_enable, store_beep_enable, 0), 1091 SENSOR_ATTR(beep_mask, S_IRUGO | S_IWUSR, 1092 show_beep_mask, store_beep_mask, 1) 1093 }; 1094 1095 /* cpu voltage regulation information */ 1096 static ssize_t show_vid_reg(struct device *dev, 1097 struct device_attribute *attr, char *buf) 1098 { 1099 struct w83791d_data *data = w83791d_update_device(dev); 1100 return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm)); 1101 } 1102 1103 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL); 1104 1105 static ssize_t show_vrm_reg(struct device *dev, 1106 struct device_attribute *attr, char *buf) 1107 { 1108 struct w83791d_data *data = dev_get_drvdata(dev); 1109 return sprintf(buf, "%d\n", data->vrm); 1110 } 1111 1112 static ssize_t store_vrm_reg(struct device *dev, 1113 struct device_attribute *attr, 1114 const char *buf, size_t count) 1115 { 1116 struct w83791d_data *data = dev_get_drvdata(dev); 1117 1118 /* No lock needed as vrm is internal to the driver 1119 (not read from a chip register) and so is not 1120 updated in w83791d_update_device() */ 1121 data->vrm = simple_strtoul(buf, NULL, 10); 1122 1123 return count; 1124 } 1125 1126 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg); 1127 1128 #define IN_UNIT_ATTRS(X) \ 1129 &sda_in_input[X].dev_attr.attr, \ 1130 &sda_in_min[X].dev_attr.attr, \ 1131 &sda_in_max[X].dev_attr.attr, \ 1132 &sda_in_beep[X].dev_attr.attr, \ 1133 &sda_in_alarm[X].dev_attr.attr 1134 1135 #define FAN_UNIT_ATTRS(X) \ 1136 &sda_fan_input[X].dev_attr.attr, \ 1137 &sda_fan_min[X].dev_attr.attr, \ 1138 &sda_fan_div[X].dev_attr.attr, \ 1139 &sda_fan_beep[X].dev_attr.attr, \ 1140 &sda_fan_alarm[X].dev_attr.attr 1141 1142 #define TEMP_UNIT_ATTRS(X) \ 1143 &sda_temp_input[X].dev_attr.attr, \ 1144 &sda_temp_max[X].dev_attr.attr, \ 1145 &sda_temp_max_hyst[X].dev_attr.attr, \ 1146 &sda_temp_beep[X].dev_attr.attr, \ 1147 &sda_temp_alarm[X].dev_attr.attr 1148 1149 static struct attribute *w83791d_attributes[] = { 1150 IN_UNIT_ATTRS(0), 1151 IN_UNIT_ATTRS(1), 1152 IN_UNIT_ATTRS(2), 1153 IN_UNIT_ATTRS(3), 1154 IN_UNIT_ATTRS(4), 1155 IN_UNIT_ATTRS(5), 1156 IN_UNIT_ATTRS(6), 1157 IN_UNIT_ATTRS(7), 1158 IN_UNIT_ATTRS(8), 1159 IN_UNIT_ATTRS(9), 1160 FAN_UNIT_ATTRS(0), 1161 FAN_UNIT_ATTRS(1), 1162 FAN_UNIT_ATTRS(2), 1163 TEMP_UNIT_ATTRS(0), 1164 TEMP_UNIT_ATTRS(1), 1165 TEMP_UNIT_ATTRS(2), 1166 &dev_attr_alarms.attr, 1167 &sda_beep_ctrl[0].dev_attr.attr, 1168 &sda_beep_ctrl[1].dev_attr.attr, 1169 &dev_attr_cpu0_vid.attr, 1170 &dev_attr_vrm.attr, 1171 &sda_pwm[0].dev_attr.attr, 1172 &sda_pwm[1].dev_attr.attr, 1173 &sda_pwm[2].dev_attr.attr, 1174 &sda_pwmenable[0].dev_attr.attr, 1175 &sda_pwmenable[1].dev_attr.attr, 1176 &sda_pwmenable[2].dev_attr.attr, 1177 &sda_temp_target[0].dev_attr.attr, 1178 &sda_temp_target[1].dev_attr.attr, 1179 &sda_temp_target[2].dev_attr.attr, 1180 &sda_temp_tolerance[0].dev_attr.attr, 1181 &sda_temp_tolerance[1].dev_attr.attr, 1182 &sda_temp_tolerance[2].dev_attr.attr, 1183 NULL 1184 }; 1185 1186 static const struct attribute_group w83791d_group = { 1187 .attrs = w83791d_attributes, 1188 }; 1189 1190 /* Separate group of attributes for fan/pwm 4-5. Their pins can also be 1191 in use for GPIO in which case their sysfs-interface should not be made 1192 available */ 1193 static struct attribute *w83791d_attributes_fanpwm45[] = { 1194 FAN_UNIT_ATTRS(3), 1195 FAN_UNIT_ATTRS(4), 1196 &sda_pwm[3].dev_attr.attr, 1197 &sda_pwm[4].dev_attr.attr, 1198 NULL 1199 }; 1200 1201 static const struct attribute_group w83791d_group_fanpwm45 = { 1202 .attrs = w83791d_attributes_fanpwm45, 1203 }; 1204 1205 static int w83791d_detect_subclients(struct i2c_client *client) 1206 { 1207 struct i2c_adapter *adapter = client->adapter; 1208 struct w83791d_data *data = i2c_get_clientdata(client); 1209 int address = client->addr; 1210 int i, id, err; 1211 u8 val; 1212 1213 id = i2c_adapter_id(adapter); 1214 if (force_subclients[0] == id && force_subclients[1] == address) { 1215 for (i = 2; i <= 3; i++) { 1216 if (force_subclients[i] < 0x48 || 1217 force_subclients[i] > 0x4f) { 1218 dev_err(&client->dev, 1219 "invalid subclient " 1220 "address %d; must be 0x48-0x4f\n", 1221 force_subclients[i]); 1222 err = -ENODEV; 1223 goto error_sc_0; 1224 } 1225 } 1226 w83791d_write(client, W83791D_REG_I2C_SUBADDR, 1227 (force_subclients[2] & 0x07) | 1228 ((force_subclients[3] & 0x07) << 4)); 1229 } 1230 1231 val = w83791d_read(client, W83791D_REG_I2C_SUBADDR); 1232 if (!(val & 0x08)) { 1233 data->lm75[0] = i2c_new_dummy(adapter, 0x48 + (val & 0x7)); 1234 } 1235 if (!(val & 0x80)) { 1236 if ((data->lm75[0] != NULL) && 1237 ((val & 0x7) == ((val >> 4) & 0x7))) { 1238 dev_err(&client->dev, 1239 "duplicate addresses 0x%x, " 1240 "use force_subclient\n", 1241 data->lm75[0]->addr); 1242 err = -ENODEV; 1243 goto error_sc_1; 1244 } 1245 data->lm75[1] = i2c_new_dummy(adapter, 1246 0x48 + ((val >> 4) & 0x7)); 1247 } 1248 1249 return 0; 1250 1251 /* Undo inits in case of errors */ 1252 1253 error_sc_1: 1254 if (data->lm75[0] != NULL) 1255 i2c_unregister_device(data->lm75[0]); 1256 error_sc_0: 1257 return err; 1258 } 1259 1260 1261 /* Return 0 if detection is successful, -ENODEV otherwise */ 1262 static int w83791d_detect(struct i2c_client *client, int kind, 1263 struct i2c_board_info *info) 1264 { 1265 struct i2c_adapter *adapter = client->adapter; 1266 int val1, val2; 1267 unsigned short address = client->addr; 1268 1269 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 1270 return -ENODEV; 1271 } 1272 1273 /* The w83791d may be stuck in some other bank than bank 0. This may 1274 make reading other information impossible. Specify a force=... 1275 parameter, and the Winbond will be reset to the right bank. */ 1276 if (kind < 0) { 1277 if (w83791d_read(client, W83791D_REG_CONFIG) & 0x80) { 1278 return -ENODEV; 1279 } 1280 val1 = w83791d_read(client, W83791D_REG_BANK); 1281 val2 = w83791d_read(client, W83791D_REG_CHIPMAN); 1282 /* Check for Winbond ID if in bank 0 */ 1283 if (!(val1 & 0x07)) { 1284 /* yes it is Bank0 */ 1285 if (((!(val1 & 0x80)) && (val2 != 0xa3)) || 1286 ((val1 & 0x80) && (val2 != 0x5c))) { 1287 return -ENODEV; 1288 } 1289 } 1290 /* If Winbond chip, address of chip and W83791D_REG_I2C_ADDR 1291 should match */ 1292 if (w83791d_read(client, W83791D_REG_I2C_ADDR) != address) { 1293 return -ENODEV; 1294 } 1295 } 1296 1297 /* We either have a force parameter or we have reason to 1298 believe it is a Winbond chip. Either way, we want bank 0 and 1299 Vendor ID high byte */ 1300 val1 = w83791d_read(client, W83791D_REG_BANK) & 0x78; 1301 w83791d_write(client, W83791D_REG_BANK, val1 | 0x80); 1302 1303 /* Verify it is a Winbond w83791d */ 1304 if (kind <= 0) { 1305 /* get vendor ID */ 1306 val2 = w83791d_read(client, W83791D_REG_CHIPMAN); 1307 if (val2 != 0x5c) { /* the vendor is NOT Winbond */ 1308 return -ENODEV; 1309 } 1310 val1 = w83791d_read(client, W83791D_REG_WCHIPID); 1311 if (val1 == 0x71) { 1312 kind = w83791d; 1313 } else { 1314 if (kind == 0) 1315 dev_warn(&adapter->dev, 1316 "w83791d: Ignoring 'force' parameter " 1317 "for unknown chip at adapter %d, " 1318 "address 0x%02x\n", 1319 i2c_adapter_id(adapter), address); 1320 return -ENODEV; 1321 } 1322 } 1323 1324 strlcpy(info->type, "w83791d", I2C_NAME_SIZE); 1325 1326 return 0; 1327 } 1328 1329 static int w83791d_probe(struct i2c_client *client, 1330 const struct i2c_device_id *id) 1331 { 1332 struct w83791d_data *data; 1333 struct device *dev = &client->dev; 1334 int i, err; 1335 u8 has_fanpwm45; 1336 1337 #ifdef DEBUG 1338 int val1; 1339 val1 = w83791d_read(client, W83791D_REG_DID_VID4); 1340 dev_dbg(dev, "Device ID version: %d.%d (0x%02x)\n", 1341 (val1 >> 5) & 0x07, (val1 >> 1) & 0x0f, val1); 1342 #endif 1343 1344 data = kzalloc(sizeof(struct w83791d_data), GFP_KERNEL); 1345 if (!data) { 1346 err = -ENOMEM; 1347 goto error0; 1348 } 1349 1350 i2c_set_clientdata(client, data); 1351 mutex_init(&data->update_lock); 1352 1353 err = w83791d_detect_subclients(client); 1354 if (err) 1355 goto error1; 1356 1357 /* Initialize the chip */ 1358 w83791d_init_client(client); 1359 1360 /* If the fan_div is changed, make sure there is a rational 1361 fan_min in place */ 1362 for (i = 0; i < NUMBER_OF_FANIN; i++) { 1363 data->fan_min[i] = w83791d_read(client, W83791D_REG_FAN_MIN[i]); 1364 } 1365 1366 /* Register sysfs hooks */ 1367 if ((err = sysfs_create_group(&client->dev.kobj, &w83791d_group))) 1368 goto error3; 1369 1370 /* Check if pins of fan/pwm 4-5 are in use as GPIO */ 1371 has_fanpwm45 = w83791d_read(client, W83791D_REG_GPIO) & 0x10; 1372 if (has_fanpwm45) { 1373 err = sysfs_create_group(&client->dev.kobj, 1374 &w83791d_group_fanpwm45); 1375 if (err) 1376 goto error4; 1377 } 1378 1379 /* Everything is ready, now register the working device */ 1380 data->hwmon_dev = hwmon_device_register(dev); 1381 if (IS_ERR(data->hwmon_dev)) { 1382 err = PTR_ERR(data->hwmon_dev); 1383 goto error5; 1384 } 1385 1386 return 0; 1387 1388 error5: 1389 if (has_fanpwm45) 1390 sysfs_remove_group(&client->dev.kobj, &w83791d_group_fanpwm45); 1391 error4: 1392 sysfs_remove_group(&client->dev.kobj, &w83791d_group); 1393 error3: 1394 if (data->lm75[0] != NULL) 1395 i2c_unregister_device(data->lm75[0]); 1396 if (data->lm75[1] != NULL) 1397 i2c_unregister_device(data->lm75[1]); 1398 error1: 1399 kfree(data); 1400 error0: 1401 return err; 1402 } 1403 1404 static int w83791d_remove(struct i2c_client *client) 1405 { 1406 struct w83791d_data *data = i2c_get_clientdata(client); 1407 1408 hwmon_device_unregister(data->hwmon_dev); 1409 sysfs_remove_group(&client->dev.kobj, &w83791d_group); 1410 1411 if (data->lm75[0] != NULL) 1412 i2c_unregister_device(data->lm75[0]); 1413 if (data->lm75[1] != NULL) 1414 i2c_unregister_device(data->lm75[1]); 1415 1416 kfree(data); 1417 return 0; 1418 } 1419 1420 static void w83791d_init_client(struct i2c_client *client) 1421 { 1422 struct w83791d_data *data = i2c_get_clientdata(client); 1423 u8 tmp; 1424 u8 old_beep; 1425 1426 /* The difference between reset and init is that reset 1427 does a hard reset of the chip via index 0x40, bit 7, 1428 but init simply forces certain registers to have "sane" 1429 values. The hope is that the BIOS has done the right 1430 thing (which is why the default is reset=0, init=0), 1431 but if not, reset is the hard hammer and init 1432 is the soft mallet both of which are trying to whack 1433 things into place... 1434 NOTE: The data sheet makes a distinction between 1435 "power on defaults" and "reset by MR". As far as I can tell, 1436 the hard reset puts everything into a power-on state so I'm 1437 not sure what "reset by MR" means or how it can happen. 1438 */ 1439 if (reset || init) { 1440 /* keep some BIOS settings when we... */ 1441 old_beep = w83791d_read(client, W83791D_REG_BEEP_CONFIG); 1442 1443 if (reset) { 1444 /* ... reset the chip and ... */ 1445 w83791d_write(client, W83791D_REG_CONFIG, 0x80); 1446 } 1447 1448 /* ... disable power-on abnormal beep */ 1449 w83791d_write(client, W83791D_REG_BEEP_CONFIG, old_beep | 0x80); 1450 1451 /* disable the global beep (not done by hard reset) */ 1452 tmp = w83791d_read(client, W83791D_REG_BEEP_CTRL[1]); 1453 w83791d_write(client, W83791D_REG_BEEP_CTRL[1], tmp & 0xef); 1454 1455 if (init) { 1456 /* Make sure monitoring is turned on for add-ons */ 1457 tmp = w83791d_read(client, W83791D_REG_TEMP2_CONFIG); 1458 if (tmp & 1) { 1459 w83791d_write(client, W83791D_REG_TEMP2_CONFIG, 1460 tmp & 0xfe); 1461 } 1462 1463 tmp = w83791d_read(client, W83791D_REG_TEMP3_CONFIG); 1464 if (tmp & 1) { 1465 w83791d_write(client, W83791D_REG_TEMP3_CONFIG, 1466 tmp & 0xfe); 1467 } 1468 1469 /* Start monitoring */ 1470 tmp = w83791d_read(client, W83791D_REG_CONFIG) & 0xf7; 1471 w83791d_write(client, W83791D_REG_CONFIG, tmp | 0x01); 1472 } 1473 } 1474 1475 data->vrm = vid_which_vrm(); 1476 } 1477 1478 static struct w83791d_data *w83791d_update_device(struct device *dev) 1479 { 1480 struct i2c_client *client = to_i2c_client(dev); 1481 struct w83791d_data *data = i2c_get_clientdata(client); 1482 int i, j; 1483 u8 reg_array_tmp[3]; 1484 u8 vbat_reg; 1485 1486 mutex_lock(&data->update_lock); 1487 1488 if (time_after(jiffies, data->last_updated + (HZ * 3)) 1489 || !data->valid) { 1490 dev_dbg(dev, "Starting w83791d device update\n"); 1491 1492 /* Update the voltages measured value and limits */ 1493 for (i = 0; i < NUMBER_OF_VIN; i++) { 1494 data->in[i] = w83791d_read(client, 1495 W83791D_REG_IN[i]); 1496 data->in_max[i] = w83791d_read(client, 1497 W83791D_REG_IN_MAX[i]); 1498 data->in_min[i] = w83791d_read(client, 1499 W83791D_REG_IN_MIN[i]); 1500 } 1501 1502 /* Update the fan counts and limits */ 1503 for (i = 0; i < NUMBER_OF_FANIN; i++) { 1504 /* Update the Fan measured value and limits */ 1505 data->fan[i] = w83791d_read(client, 1506 W83791D_REG_FAN[i]); 1507 data->fan_min[i] = w83791d_read(client, 1508 W83791D_REG_FAN_MIN[i]); 1509 } 1510 1511 /* Update the fan divisor */ 1512 for (i = 0; i < 3; i++) { 1513 reg_array_tmp[i] = w83791d_read(client, 1514 W83791D_REG_FAN_DIV[i]); 1515 } 1516 data->fan_div[0] = (reg_array_tmp[0] >> 4) & 0x03; 1517 data->fan_div[1] = (reg_array_tmp[0] >> 6) & 0x03; 1518 data->fan_div[2] = (reg_array_tmp[1] >> 6) & 0x03; 1519 data->fan_div[3] = reg_array_tmp[2] & 0x07; 1520 data->fan_div[4] = (reg_array_tmp[2] >> 4) & 0x07; 1521 1522 /* The fan divisor for fans 0-2 get bit 2 from 1523 bits 5-7 respectively of vbat register */ 1524 vbat_reg = w83791d_read(client, W83791D_REG_VBAT); 1525 for (i = 0; i < 3; i++) 1526 data->fan_div[i] |= (vbat_reg >> (3 + i)) & 0x04; 1527 1528 /* Update PWM duty cycle */ 1529 for (i = 0; i < NUMBER_OF_PWM; i++) { 1530 data->pwm[i] = w83791d_read(client, 1531 W83791D_REG_PWM[i]); 1532 } 1533 1534 /* Update PWM enable status */ 1535 for (i = 0; i < 2; i++) { 1536 reg_array_tmp[i] = w83791d_read(client, 1537 W83791D_REG_FAN_CFG[i]); 1538 } 1539 data->pwm_enable[0] = (reg_array_tmp[0] >> 2) & 0x03; 1540 data->pwm_enable[1] = (reg_array_tmp[0] >> 4) & 0x03; 1541 data->pwm_enable[2] = (reg_array_tmp[1] >> 2) & 0x03; 1542 1543 /* Update PWM target temperature */ 1544 for (i = 0; i < 3; i++) { 1545 data->temp_target[i] = w83791d_read(client, 1546 W83791D_REG_TEMP_TARGET[i]) & 0x7f; 1547 } 1548 1549 /* Update PWM temperature tolerance */ 1550 for (i = 0; i < 2; i++) { 1551 reg_array_tmp[i] = w83791d_read(client, 1552 W83791D_REG_TEMP_TOL[i]); 1553 } 1554 data->temp_tolerance[0] = reg_array_tmp[0] & 0x0f; 1555 data->temp_tolerance[1] = (reg_array_tmp[0] >> 4) & 0x0f; 1556 data->temp_tolerance[2] = reg_array_tmp[1] & 0x0f; 1557 1558 /* Update the first temperature sensor */ 1559 for (i = 0; i < 3; i++) { 1560 data->temp1[i] = w83791d_read(client, 1561 W83791D_REG_TEMP1[i]); 1562 } 1563 1564 /* Update the rest of the temperature sensors */ 1565 for (i = 0; i < 2; i++) { 1566 for (j = 0; j < 3; j++) { 1567 data->temp_add[i][j] = 1568 (w83791d_read(client, 1569 W83791D_REG_TEMP_ADD[i][j * 2]) << 8) | 1570 w83791d_read(client, 1571 W83791D_REG_TEMP_ADD[i][j * 2 + 1]); 1572 } 1573 } 1574 1575 /* Update the realtime status */ 1576 data->alarms = 1577 w83791d_read(client, W83791D_REG_ALARM1) + 1578 (w83791d_read(client, W83791D_REG_ALARM2) << 8) + 1579 (w83791d_read(client, W83791D_REG_ALARM3) << 16); 1580 1581 /* Update the beep configuration information */ 1582 data->beep_mask = 1583 w83791d_read(client, W83791D_REG_BEEP_CTRL[0]) + 1584 (w83791d_read(client, W83791D_REG_BEEP_CTRL[1]) << 8) + 1585 (w83791d_read(client, W83791D_REG_BEEP_CTRL[2]) << 16); 1586 1587 /* Extract global beep enable flag */ 1588 data->beep_enable = 1589 (data->beep_mask >> GLOBAL_BEEP_ENABLE_SHIFT) & 0x01; 1590 1591 /* Update the cpu voltage information */ 1592 i = w83791d_read(client, W83791D_REG_VID_FANDIV); 1593 data->vid = i & 0x0f; 1594 data->vid |= (w83791d_read(client, W83791D_REG_DID_VID4) & 0x01) 1595 << 4; 1596 1597 data->last_updated = jiffies; 1598 data->valid = 1; 1599 } 1600 1601 mutex_unlock(&data->update_lock); 1602 1603 #ifdef DEBUG 1604 w83791d_print_debug(data, dev); 1605 #endif 1606 1607 return data; 1608 } 1609 1610 #ifdef DEBUG 1611 static void w83791d_print_debug(struct w83791d_data *data, struct device *dev) 1612 { 1613 int i = 0, j = 0; 1614 1615 dev_dbg(dev, "======Start of w83791d debug values======\n"); 1616 dev_dbg(dev, "%d set of Voltages: ===>\n", NUMBER_OF_VIN); 1617 for (i = 0; i < NUMBER_OF_VIN; i++) { 1618 dev_dbg(dev, "vin[%d] is: 0x%02x\n", i, data->in[i]); 1619 dev_dbg(dev, "vin[%d] min is: 0x%02x\n", i, data->in_min[i]); 1620 dev_dbg(dev, "vin[%d] max is: 0x%02x\n", i, data->in_max[i]); 1621 } 1622 dev_dbg(dev, "%d set of Fan Counts/Divisors: ===>\n", NUMBER_OF_FANIN); 1623 for (i = 0; i < NUMBER_OF_FANIN; i++) { 1624 dev_dbg(dev, "fan[%d] is: 0x%02x\n", i, data->fan[i]); 1625 dev_dbg(dev, "fan[%d] min is: 0x%02x\n", i, data->fan_min[i]); 1626 dev_dbg(dev, "fan_div[%d] is: 0x%02x\n", i, data->fan_div[i]); 1627 } 1628 1629 /* temperature math is signed, but only print out the 1630 bits that matter */ 1631 dev_dbg(dev, "%d set of Temperatures: ===>\n", NUMBER_OF_TEMPIN); 1632 for (i = 0; i < 3; i++) { 1633 dev_dbg(dev, "temp1[%d] is: 0x%02x\n", i, (u8) data->temp1[i]); 1634 } 1635 for (i = 0; i < 2; i++) { 1636 for (j = 0; j < 3; j++) { 1637 dev_dbg(dev, "temp_add[%d][%d] is: 0x%04x\n", i, j, 1638 (u16) data->temp_add[i][j]); 1639 } 1640 } 1641 1642 dev_dbg(dev, "Misc Information: ===>\n"); 1643 dev_dbg(dev, "alarm is: 0x%08x\n", data->alarms); 1644 dev_dbg(dev, "beep_mask is: 0x%08x\n", data->beep_mask); 1645 dev_dbg(dev, "beep_enable is: %d\n", data->beep_enable); 1646 dev_dbg(dev, "vid is: 0x%02x\n", data->vid); 1647 dev_dbg(dev, "vrm is: 0x%02x\n", data->vrm); 1648 dev_dbg(dev, "=======End of w83791d debug values========\n"); 1649 dev_dbg(dev, "\n"); 1650 } 1651 #endif 1652 1653 static int __init sensors_w83791d_init(void) 1654 { 1655 return i2c_add_driver(&w83791d_driver); 1656 } 1657 1658 static void __exit sensors_w83791d_exit(void) 1659 { 1660 i2c_del_driver(&w83791d_driver); 1661 } 1662 1663 MODULE_AUTHOR("Charles Spirakis <bezaur@gmail.com>"); 1664 MODULE_DESCRIPTION("W83791D driver"); 1665 MODULE_LICENSE("GPL"); 1666 1667 module_init(sensors_w83791d_init); 1668 module_exit(sensors_w83791d_exit); 1669