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