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