1 /* 2 w83791d.c - Part of lm_sensors, Linux kernel modules for hardware 3 monitoring 4 5 Copyright (C) 2006 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 3 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 49 /* Addresses to scan */ 50 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END }; 51 52 /* Insmod parameters */ 53 I2C_CLIENT_INSMOD_1(w83791d); 54 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: " 55 "{bus, clientaddr, subclientaddr1, subclientaddr2}"); 56 57 static int reset; 58 module_param(reset, bool, 0); 59 MODULE_PARM_DESC(reset, "Set to one to force a hardware chip reset"); 60 61 static int init; 62 module_param(init, bool, 0); 63 MODULE_PARM_DESC(init, "Set to one to force extra software initialization"); 64 65 /* The W83791D registers */ 66 static const u8 W83791D_REG_IN[NUMBER_OF_VIN] = { 67 0x20, /* VCOREA in DataSheet */ 68 0x21, /* VINR0 in DataSheet */ 69 0x22, /* +3.3VIN in DataSheet */ 70 0x23, /* VDD5V in DataSheet */ 71 0x24, /* +12VIN in DataSheet */ 72 0x25, /* -12VIN in DataSheet */ 73 0x26, /* -5VIN in DataSheet */ 74 0xB0, /* 5VSB in DataSheet */ 75 0xB1, /* VBAT in DataSheet */ 76 0xB2 /* VINR1 in DataSheet */ 77 }; 78 79 static const u8 W83791D_REG_IN_MAX[NUMBER_OF_VIN] = { 80 0x2B, /* VCOREA High Limit in DataSheet */ 81 0x2D, /* VINR0 High Limit in DataSheet */ 82 0x2F, /* +3.3VIN High Limit in DataSheet */ 83 0x31, /* VDD5V High Limit in DataSheet */ 84 0x33, /* +12VIN High Limit in DataSheet */ 85 0x35, /* -12VIN High Limit in DataSheet */ 86 0x37, /* -5VIN High Limit in DataSheet */ 87 0xB4, /* 5VSB High Limit in DataSheet */ 88 0xB6, /* VBAT High Limit in DataSheet */ 89 0xB8 /* VINR1 High Limit in DataSheet */ 90 }; 91 static const u8 W83791D_REG_IN_MIN[NUMBER_OF_VIN] = { 92 0x2C, /* VCOREA Low Limit in DataSheet */ 93 0x2E, /* VINR0 Low Limit in DataSheet */ 94 0x30, /* +3.3VIN Low Limit in DataSheet */ 95 0x32, /* VDD5V Low Limit in DataSheet */ 96 0x34, /* +12VIN Low Limit in DataSheet */ 97 0x36, /* -12VIN Low Limit in DataSheet */ 98 0x38, /* -5VIN Low Limit in DataSheet */ 99 0xB5, /* 5VSB Low Limit in DataSheet */ 100 0xB7, /* VBAT Low Limit in DataSheet */ 101 0xB9 /* VINR1 Low Limit in DataSheet */ 102 }; 103 static const u8 W83791D_REG_FAN[NUMBER_OF_FANIN] = { 104 0x28, /* FAN 1 Count in DataSheet */ 105 0x29, /* FAN 2 Count in DataSheet */ 106 0x2A, /* FAN 3 Count in DataSheet */ 107 0xBA, /* FAN 4 Count in DataSheet */ 108 0xBB, /* FAN 5 Count in DataSheet */ 109 }; 110 static const u8 W83791D_REG_FAN_MIN[NUMBER_OF_FANIN] = { 111 0x3B, /* FAN 1 Count Low Limit in DataSheet */ 112 0x3C, /* FAN 2 Count Low Limit in DataSheet */ 113 0x3D, /* FAN 3 Count Low Limit in DataSheet */ 114 0xBC, /* FAN 4 Count Low Limit in DataSheet */ 115 0xBD, /* FAN 5 Count Low Limit in DataSheet */ 116 }; 117 118 static const u8 W83791D_REG_FAN_CFG[2] = { 119 0x84, /* FAN 1/2 configuration */ 120 0x95, /* FAN 3 configuration */ 121 }; 122 123 static const u8 W83791D_REG_FAN_DIV[3] = { 124 0x47, /* contains FAN1 and FAN2 Divisor */ 125 0x4b, /* contains FAN3 Divisor */ 126 0x5C, /* contains FAN4 and FAN5 Divisor */ 127 }; 128 129 #define W83791D_REG_BANK 0x4E 130 #define W83791D_REG_TEMP2_CONFIG 0xC2 131 #define W83791D_REG_TEMP3_CONFIG 0xCA 132 133 static const u8 W83791D_REG_TEMP1[3] = { 134 0x27, /* TEMP 1 in DataSheet */ 135 0x39, /* TEMP 1 Over in DataSheet */ 136 0x3A, /* TEMP 1 Hyst in DataSheet */ 137 }; 138 139 static const u8 W83791D_REG_TEMP_ADD[2][6] = { 140 {0xC0, /* TEMP 2 in DataSheet */ 141 0xC1, /* TEMP 2(0.5 deg) in DataSheet */ 142 0xC5, /* TEMP 2 Over High part in DataSheet */ 143 0xC6, /* TEMP 2 Over Low part in DataSheet */ 144 0xC3, /* TEMP 2 Thyst High part in DataSheet */ 145 0xC4}, /* TEMP 2 Thyst Low part in DataSheet */ 146 {0xC8, /* TEMP 3 in DataSheet */ 147 0xC9, /* TEMP 3(0.5 deg) in DataSheet */ 148 0xCD, /* TEMP 3 Over High part in DataSheet */ 149 0xCE, /* TEMP 3 Over Low part in DataSheet */ 150 0xCB, /* TEMP 3 Thyst High part in DataSheet */ 151 0xCC} /* TEMP 3 Thyst Low part in DataSheet */ 152 }; 153 154 #define W83791D_REG_BEEP_CONFIG 0x4D 155 156 static const u8 W83791D_REG_BEEP_CTRL[3] = { 157 0x56, /* BEEP Control Register 1 */ 158 0x57, /* BEEP Control Register 2 */ 159 0xA3, /* BEEP Control Register 3 */ 160 }; 161 162 #define W83791D_REG_CONFIG 0x40 163 #define W83791D_REG_VID_FANDIV 0x47 164 #define W83791D_REG_DID_VID4 0x49 165 #define W83791D_REG_WCHIPID 0x58 166 #define W83791D_REG_CHIPMAN 0x4F 167 #define W83791D_REG_PIN 0x4B 168 #define W83791D_REG_I2C_SUBADDR 0x4A 169 170 #define W83791D_REG_ALARM1 0xA9 /* realtime status register1 */ 171 #define W83791D_REG_ALARM2 0xAA /* realtime status register2 */ 172 #define W83791D_REG_ALARM3 0xAB /* realtime status register3 */ 173 174 #define W83791D_REG_VBAT 0x5D 175 #define W83791D_REG_I2C_ADDR 0x48 176 177 /* The SMBus locks itself. The Winbond W83791D has a bank select register 178 (index 0x4e), but the driver only accesses registers in bank 0. Since 179 we don't switch banks, we don't need any special code to handle 180 locking access between bank switches */ 181 static inline int w83791d_read(struct i2c_client *client, u8 reg) 182 { 183 return i2c_smbus_read_byte_data(client, reg); 184 } 185 186 static inline int w83791d_write(struct i2c_client *client, u8 reg, u8 value) 187 { 188 return i2c_smbus_write_byte_data(client, reg, value); 189 } 190 191 /* The analog voltage inputs have 16mV LSB. Since the sysfs output is 192 in mV as would be measured on the chip input pin, need to just 193 multiply/divide by 16 to translate from/to register values. */ 194 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8) / 16), 0, 255)) 195 #define IN_FROM_REG(val) ((val) * 16) 196 197 static u8 fan_to_reg(long rpm, int div) 198 { 199 if (rpm == 0) 200 return 255; 201 rpm = SENSORS_LIMIT(rpm, 1, 1000000); 202 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254); 203 } 204 205 #define FAN_FROM_REG(val,div) ((val) == 0 ? -1 : \ 206 ((val) == 255 ? 0 : \ 207 1350000 / ((val) * (div)))) 208 209 /* for temp1 which is 8-bit resolution, LSB = 1 degree Celsius */ 210 #define TEMP1_FROM_REG(val) ((val) * 1000) 211 #define TEMP1_TO_REG(val) ((val) <= -128000 ? -128 : \ 212 (val) >= 127000 ? 127 : \ 213 (val) < 0 ? ((val) - 500) / 1000 : \ 214 ((val) + 500) / 1000) 215 216 /* for temp2 and temp3 which are 9-bit resolution, LSB = 0.5 degree Celsius 217 Assumes the top 8 bits are the integral amount and the bottom 8 bits 218 are the fractional amount. Since we only have 0.5 degree resolution, 219 the bottom 7 bits will always be zero */ 220 #define TEMP23_FROM_REG(val) ((val) / 128 * 500) 221 #define TEMP23_TO_REG(val) ((val) <= -128000 ? 0x8000 : \ 222 (val) >= 127500 ? 0x7F80 : \ 223 (val) < 0 ? ((val) - 250) / 500 * 128 : \ 224 ((val) + 250) / 500 * 128) 225 226 227 #define BEEP_MASK_TO_REG(val) ((val) & 0xffffff) 228 #define BEEP_MASK_FROM_REG(val) ((val) & 0xffffff) 229 230 #define DIV_FROM_REG(val) (1 << (val)) 231 232 static u8 div_to_reg(int nr, long val) 233 { 234 int i; 235 int max; 236 237 /* first three fan's divisor max out at 8, rest max out at 128 */ 238 max = (nr < 3) ? 8 : 128; 239 val = SENSORS_LIMIT(val, 1, max) >> 1; 240 for (i = 0; i < 7; i++) { 241 if (val == 0) 242 break; 243 val >>= 1; 244 } 245 return (u8) i; 246 } 247 248 struct w83791d_data { 249 struct i2c_client client; 250 struct class_device *class_dev; 251 struct mutex update_lock; 252 253 char valid; /* !=0 if following fields are valid */ 254 unsigned long last_updated; /* In jiffies */ 255 256 /* array of 2 pointers to subclients */ 257 struct i2c_client *lm75[2]; 258 259 /* volts */ 260 u8 in[NUMBER_OF_VIN]; /* Register value */ 261 u8 in_max[NUMBER_OF_VIN]; /* Register value */ 262 u8 in_min[NUMBER_OF_VIN]; /* Register value */ 263 264 /* fans */ 265 u8 fan[NUMBER_OF_FANIN]; /* Register value */ 266 u8 fan_min[NUMBER_OF_FANIN]; /* Register value */ 267 u8 fan_div[NUMBER_OF_FANIN]; /* Register encoding, shifted right */ 268 269 /* Temperature sensors */ 270 271 s8 temp1[3]; /* current, over, thyst */ 272 s16 temp_add[2][3]; /* fixed point value. Top 8 bits are the 273 integral part, bottom 8 bits are the 274 fractional part. We only use the top 275 9 bits as the resolution is only 276 to the 0.5 degree C... 277 two sensors with three values 278 (cur, over, hyst) */ 279 280 /* Misc */ 281 u32 alarms; /* realtime status register encoding,combined */ 282 u8 beep_enable; /* Global beep enable */ 283 u32 beep_mask; /* Mask off specific beeps */ 284 u8 vid; /* Register encoding, combined */ 285 u8 vrm; /* hwmon-vid */ 286 }; 287 288 static int w83791d_attach_adapter(struct i2c_adapter *adapter); 289 static int w83791d_detect(struct i2c_adapter *adapter, int address, int kind); 290 static int w83791d_detach_client(struct i2c_client *client); 291 292 static int w83791d_read(struct i2c_client *client, u8 register); 293 static int w83791d_write(struct i2c_client *client, u8 register, u8 value); 294 static struct w83791d_data *w83791d_update_device(struct device *dev); 295 296 #ifdef DEBUG 297 static void w83791d_print_debug(struct w83791d_data *data, struct device *dev); 298 #endif 299 300 static void w83791d_init_client(struct i2c_client *client); 301 302 static struct i2c_driver w83791d_driver = { 303 .driver = { 304 .name = "w83791d", 305 }, 306 .attach_adapter = w83791d_attach_adapter, 307 .detach_client = w83791d_detach_client, 308 }; 309 310 /* following are the sysfs callback functions */ 311 #define show_in_reg(reg) \ 312 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \ 313 char *buf) \ 314 { \ 315 struct sensor_device_attribute *sensor_attr = \ 316 to_sensor_dev_attr(attr); \ 317 struct w83791d_data *data = w83791d_update_device(dev); \ 318 int nr = sensor_attr->index; \ 319 return sprintf(buf,"%d\n", IN_FROM_REG(data->reg[nr])); \ 320 } 321 322 show_in_reg(in); 323 show_in_reg(in_min); 324 show_in_reg(in_max); 325 326 #define store_in_reg(REG, reg) \ 327 static ssize_t store_in_##reg(struct device *dev, \ 328 struct device_attribute *attr, \ 329 const char *buf, size_t count) \ 330 { \ 331 struct sensor_device_attribute *sensor_attr = \ 332 to_sensor_dev_attr(attr); \ 333 struct i2c_client *client = to_i2c_client(dev); \ 334 struct w83791d_data *data = i2c_get_clientdata(client); \ 335 unsigned long val = simple_strtoul(buf, NULL, 10); \ 336 int nr = sensor_attr->index; \ 337 \ 338 mutex_lock(&data->update_lock); \ 339 data->in_##reg[nr] = IN_TO_REG(val); \ 340 w83791d_write(client, W83791D_REG_IN_##REG[nr], data->in_##reg[nr]); \ 341 mutex_unlock(&data->update_lock); \ 342 \ 343 return count; \ 344 } 345 store_in_reg(MIN, min); 346 store_in_reg(MAX, max); 347 348 static struct sensor_device_attribute sda_in_input[] = { 349 SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0), 350 SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1), 351 SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2), 352 SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3), 353 SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4), 354 SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5), 355 SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6), 356 SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7), 357 SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8), 358 SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9), 359 }; 360 361 static struct sensor_device_attribute sda_in_min[] = { 362 SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0), 363 SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1), 364 SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2), 365 SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3), 366 SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4), 367 SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5), 368 SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6), 369 SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7), 370 SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8), 371 SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9), 372 }; 373 374 static struct sensor_device_attribute sda_in_max[] = { 375 SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0), 376 SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1), 377 SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2), 378 SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3), 379 SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4), 380 SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5), 381 SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6), 382 SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7), 383 SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8), 384 SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9), 385 }; 386 387 #define show_fan_reg(reg) \ 388 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \ 389 char *buf) \ 390 { \ 391 struct sensor_device_attribute *sensor_attr = \ 392 to_sensor_dev_attr(attr); \ 393 struct w83791d_data *data = w83791d_update_device(dev); \ 394 int nr = sensor_attr->index; \ 395 return sprintf(buf,"%d\n", \ 396 FAN_FROM_REG(data->reg[nr], DIV_FROM_REG(data->fan_div[nr]))); \ 397 } 398 399 show_fan_reg(fan); 400 show_fan_reg(fan_min); 401 402 static ssize_t store_fan_min(struct device *dev, struct device_attribute *attr, 403 const char *buf, size_t count) 404 { 405 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 406 struct i2c_client *client = to_i2c_client(dev); 407 struct w83791d_data *data = i2c_get_clientdata(client); 408 unsigned long val = simple_strtoul(buf, NULL, 10); 409 int nr = sensor_attr->index; 410 411 mutex_lock(&data->update_lock); 412 data->fan_min[nr] = fan_to_reg(val, DIV_FROM_REG(data->fan_div[nr])); 413 w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]); 414 mutex_unlock(&data->update_lock); 415 416 return count; 417 } 418 419 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr, 420 char *buf) 421 { 422 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 423 int nr = sensor_attr->index; 424 struct w83791d_data *data = w83791d_update_device(dev); 425 return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr])); 426 } 427 428 /* Note: we save and restore the fan minimum here, because its value is 429 determined in part by the fan divisor. This follows the principle of 430 least suprise; the user doesn't expect the fan minimum to change just 431 because the divisor changed. */ 432 static ssize_t store_fan_div(struct device *dev, struct device_attribute *attr, 433 const char *buf, size_t count) 434 { 435 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 436 struct i2c_client *client = to_i2c_client(dev); 437 struct w83791d_data *data = i2c_get_clientdata(client); 438 int nr = sensor_attr->index; 439 unsigned long min; 440 u8 tmp_fan_div; 441 u8 fan_div_reg; 442 int indx = 0; 443 u8 keep_mask = 0; 444 u8 new_shift = 0; 445 446 /* Save fan_min */ 447 min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])); 448 449 mutex_lock(&data->update_lock); 450 data->fan_div[nr] = div_to_reg(nr, simple_strtoul(buf, NULL, 10)); 451 452 switch (nr) { 453 case 0: 454 indx = 0; 455 keep_mask = 0xcf; 456 new_shift = 4; 457 break; 458 case 1: 459 indx = 0; 460 keep_mask = 0x3f; 461 new_shift = 6; 462 break; 463 case 2: 464 indx = 1; 465 keep_mask = 0x3f; 466 new_shift = 6; 467 break; 468 case 3: 469 indx = 2; 470 keep_mask = 0xf8; 471 new_shift = 0; 472 break; 473 case 4: 474 indx = 2; 475 keep_mask = 0x8f; 476 new_shift = 4; 477 break; 478 #ifdef DEBUG 479 default: 480 dev_warn(dev, "store_fan_div: Unexpected nr seen: %d\n", nr); 481 count = -EINVAL; 482 goto err_exit; 483 #endif 484 } 485 486 fan_div_reg = w83791d_read(client, W83791D_REG_FAN_DIV[indx]) 487 & keep_mask; 488 tmp_fan_div = (data->fan_div[nr] << new_shift) & ~keep_mask; 489 490 w83791d_write(client, W83791D_REG_FAN_DIV[indx], 491 fan_div_reg | tmp_fan_div); 492 493 /* Restore fan_min */ 494 data->fan_min[nr] = fan_to_reg(min, DIV_FROM_REG(data->fan_div[nr])); 495 w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]); 496 497 #ifdef DEBUG 498 err_exit: 499 #endif 500 mutex_unlock(&data->update_lock); 501 502 return count; 503 } 504 505 static struct sensor_device_attribute sda_fan_input[] = { 506 SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0), 507 SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1), 508 SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2), 509 SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3), 510 SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4), 511 }; 512 513 static struct sensor_device_attribute sda_fan_min[] = { 514 SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, 515 show_fan_min, store_fan_min, 0), 516 SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, 517 show_fan_min, store_fan_min, 1), 518 SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, 519 show_fan_min, store_fan_min, 2), 520 SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, 521 show_fan_min, store_fan_min, 3), 522 SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, 523 show_fan_min, store_fan_min, 4), 524 }; 525 526 static struct sensor_device_attribute sda_fan_div[] = { 527 SENSOR_ATTR(fan1_div, S_IWUSR | S_IRUGO, 528 show_fan_div, store_fan_div, 0), 529 SENSOR_ATTR(fan2_div, S_IWUSR | S_IRUGO, 530 show_fan_div, store_fan_div, 1), 531 SENSOR_ATTR(fan3_div, S_IWUSR | S_IRUGO, 532 show_fan_div, store_fan_div, 2), 533 SENSOR_ATTR(fan4_div, S_IWUSR | S_IRUGO, 534 show_fan_div, store_fan_div, 3), 535 SENSOR_ATTR(fan5_div, S_IWUSR | S_IRUGO, 536 show_fan_div, store_fan_div, 4), 537 }; 538 539 /* read/write the temperature1, includes measured value and limits */ 540 static ssize_t show_temp1(struct device *dev, struct device_attribute *devattr, 541 char *buf) 542 { 543 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 544 struct w83791d_data *data = w83791d_update_device(dev); 545 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp1[attr->index])); 546 } 547 548 static ssize_t store_temp1(struct device *dev, struct device_attribute *devattr, 549 const char *buf, size_t count) 550 { 551 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 552 struct i2c_client *client = to_i2c_client(dev); 553 struct w83791d_data *data = i2c_get_clientdata(client); 554 long val = simple_strtol(buf, NULL, 10); 555 int nr = attr->index; 556 557 mutex_lock(&data->update_lock); 558 data->temp1[nr] = TEMP1_TO_REG(val); 559 w83791d_write(client, W83791D_REG_TEMP1[nr], data->temp1[nr]); 560 mutex_unlock(&data->update_lock); 561 return count; 562 } 563 564 /* read/write temperature2-3, includes measured value and limits */ 565 static ssize_t show_temp23(struct device *dev, struct device_attribute *devattr, 566 char *buf) 567 { 568 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); 569 struct w83791d_data *data = w83791d_update_device(dev); 570 int nr = attr->nr; 571 int index = attr->index; 572 return sprintf(buf, "%d\n", TEMP23_FROM_REG(data->temp_add[nr][index])); 573 } 574 575 static ssize_t store_temp23(struct device *dev, 576 struct device_attribute *devattr, 577 const char *buf, size_t count) 578 { 579 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); 580 struct i2c_client *client = to_i2c_client(dev); 581 struct w83791d_data *data = i2c_get_clientdata(client); 582 long val = simple_strtol(buf, NULL, 10); 583 int nr = attr->nr; 584 int index = attr->index; 585 586 mutex_lock(&data->update_lock); 587 data->temp_add[nr][index] = TEMP23_TO_REG(val); 588 w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2], 589 data->temp_add[nr][index] >> 8); 590 w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2 + 1], 591 data->temp_add[nr][index] & 0x80); 592 mutex_unlock(&data->update_lock); 593 594 return count; 595 } 596 597 static struct sensor_device_attribute_2 sda_temp_input[] = { 598 SENSOR_ATTR_2(temp1_input, S_IRUGO, show_temp1, NULL, 0, 0), 599 SENSOR_ATTR_2(temp2_input, S_IRUGO, show_temp23, NULL, 0, 0), 600 SENSOR_ATTR_2(temp3_input, S_IRUGO, show_temp23, NULL, 1, 0), 601 }; 602 603 static struct sensor_device_attribute_2 sda_temp_max[] = { 604 SENSOR_ATTR_2(temp1_max, S_IRUGO | S_IWUSR, 605 show_temp1, store_temp1, 0, 1), 606 SENSOR_ATTR_2(temp2_max, S_IRUGO | S_IWUSR, 607 show_temp23, store_temp23, 0, 1), 608 SENSOR_ATTR_2(temp3_max, S_IRUGO | S_IWUSR, 609 show_temp23, store_temp23, 1, 1), 610 }; 611 612 static struct sensor_device_attribute_2 sda_temp_max_hyst[] = { 613 SENSOR_ATTR_2(temp1_max_hyst, S_IRUGO | S_IWUSR, 614 show_temp1, store_temp1, 0, 2), 615 SENSOR_ATTR_2(temp2_max_hyst, S_IRUGO | S_IWUSR, 616 show_temp23, store_temp23, 0, 2), 617 SENSOR_ATTR_2(temp3_max_hyst, S_IRUGO | S_IWUSR, 618 show_temp23, store_temp23, 1, 2), 619 }; 620 621 622 /* get reatime status of all sensors items: voltage, temp, fan */ 623 static ssize_t show_alarms_reg(struct device *dev, 624 struct device_attribute *attr, char *buf) 625 { 626 struct w83791d_data *data = w83791d_update_device(dev); 627 return sprintf(buf, "%u\n", data->alarms); 628 } 629 630 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL); 631 632 /* Beep control */ 633 634 #define GLOBAL_BEEP_ENABLE_SHIFT 15 635 #define GLOBAL_BEEP_ENABLE_MASK (1 << GLOBAL_BEEP_ENABLE_SHIFT) 636 637 static ssize_t show_beep_enable(struct device *dev, 638 struct device_attribute *attr, char *buf) 639 { 640 struct w83791d_data *data = w83791d_update_device(dev); 641 return sprintf(buf, "%d\n", data->beep_enable); 642 } 643 644 static ssize_t show_beep_mask(struct device *dev, 645 struct device_attribute *attr, char *buf) 646 { 647 struct w83791d_data *data = w83791d_update_device(dev); 648 return sprintf(buf, "%d\n", BEEP_MASK_FROM_REG(data->beep_mask)); 649 } 650 651 652 static ssize_t store_beep_mask(struct device *dev, 653 struct device_attribute *attr, 654 const char *buf, size_t count) 655 { 656 struct i2c_client *client = to_i2c_client(dev); 657 struct w83791d_data *data = i2c_get_clientdata(client); 658 long val = simple_strtol(buf, NULL, 10); 659 int i; 660 661 mutex_lock(&data->update_lock); 662 663 /* The beep_enable state overrides any enabling request from 664 the masks */ 665 data->beep_mask = BEEP_MASK_TO_REG(val) & ~GLOBAL_BEEP_ENABLE_MASK; 666 data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT); 667 668 val = data->beep_mask; 669 670 for (i = 0; i < 3; i++) { 671 w83791d_write(client, W83791D_REG_BEEP_CTRL[i], (val & 0xff)); 672 val >>= 8; 673 } 674 675 mutex_unlock(&data->update_lock); 676 677 return count; 678 } 679 680 static ssize_t store_beep_enable(struct device *dev, 681 struct device_attribute *attr, 682 const char *buf, size_t count) 683 { 684 struct i2c_client *client = to_i2c_client(dev); 685 struct w83791d_data *data = i2c_get_clientdata(client); 686 long val = simple_strtol(buf, NULL, 10); 687 688 mutex_lock(&data->update_lock); 689 690 data->beep_enable = val ? 1 : 0; 691 692 /* Keep the full mask value in sync with the current enable */ 693 data->beep_mask &= ~GLOBAL_BEEP_ENABLE_MASK; 694 data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT); 695 696 /* The global control is in the second beep control register 697 so only need to update that register */ 698 val = (data->beep_mask >> 8) & 0xff; 699 700 w83791d_write(client, W83791D_REG_BEEP_CTRL[1], val); 701 702 mutex_unlock(&data->update_lock); 703 704 return count; 705 } 706 707 static struct sensor_device_attribute sda_beep_ctrl[] = { 708 SENSOR_ATTR(beep_enable, S_IRUGO | S_IWUSR, 709 show_beep_enable, store_beep_enable, 0), 710 SENSOR_ATTR(beep_mask, S_IRUGO | S_IWUSR, 711 show_beep_mask, store_beep_mask, 1) 712 }; 713 714 /* cpu voltage regulation information */ 715 static ssize_t show_vid_reg(struct device *dev, 716 struct device_attribute *attr, char *buf) 717 { 718 struct w83791d_data *data = w83791d_update_device(dev); 719 return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm)); 720 } 721 722 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL); 723 724 static ssize_t show_vrm_reg(struct device *dev, 725 struct device_attribute *attr, char *buf) 726 { 727 struct w83791d_data *data = w83791d_update_device(dev); 728 return sprintf(buf, "%d\n", data->vrm); 729 } 730 731 static ssize_t store_vrm_reg(struct device *dev, 732 struct device_attribute *attr, 733 const char *buf, size_t count) 734 { 735 struct i2c_client *client = to_i2c_client(dev); 736 struct w83791d_data *data = i2c_get_clientdata(client); 737 unsigned long val = simple_strtoul(buf, NULL, 10); 738 739 /* No lock needed as vrm is internal to the driver 740 (not read from a chip register) and so is not 741 updated in w83791d_update_device() */ 742 data->vrm = val; 743 744 return count; 745 } 746 747 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg); 748 749 #define IN_UNIT_ATTRS(X) \ 750 &sda_in_input[X].dev_attr.attr, \ 751 &sda_in_min[X].dev_attr.attr, \ 752 &sda_in_max[X].dev_attr.attr 753 754 #define FAN_UNIT_ATTRS(X) \ 755 &sda_fan_input[X].dev_attr.attr, \ 756 &sda_fan_min[X].dev_attr.attr, \ 757 &sda_fan_div[X].dev_attr.attr 758 759 #define TEMP_UNIT_ATTRS(X) \ 760 &sda_temp_input[X].dev_attr.attr, \ 761 &sda_temp_max[X].dev_attr.attr, \ 762 &sda_temp_max_hyst[X].dev_attr.attr 763 764 static struct attribute *w83791d_attributes[] = { 765 IN_UNIT_ATTRS(0), 766 IN_UNIT_ATTRS(1), 767 IN_UNIT_ATTRS(2), 768 IN_UNIT_ATTRS(3), 769 IN_UNIT_ATTRS(4), 770 IN_UNIT_ATTRS(5), 771 IN_UNIT_ATTRS(6), 772 IN_UNIT_ATTRS(7), 773 IN_UNIT_ATTRS(8), 774 IN_UNIT_ATTRS(9), 775 FAN_UNIT_ATTRS(0), 776 FAN_UNIT_ATTRS(1), 777 FAN_UNIT_ATTRS(2), 778 FAN_UNIT_ATTRS(3), 779 FAN_UNIT_ATTRS(4), 780 TEMP_UNIT_ATTRS(0), 781 TEMP_UNIT_ATTRS(1), 782 TEMP_UNIT_ATTRS(2), 783 &dev_attr_alarms.attr, 784 &sda_beep_ctrl[0].dev_attr.attr, 785 &sda_beep_ctrl[1].dev_attr.attr, 786 &dev_attr_cpu0_vid.attr, 787 &dev_attr_vrm.attr, 788 NULL 789 }; 790 791 static const struct attribute_group w83791d_group = { 792 .attrs = w83791d_attributes, 793 }; 794 795 /* This function is called when: 796 * w83791d_driver is inserted (when this module is loaded), for each 797 available adapter 798 * when a new adapter is inserted (and w83791d_driver is still present) */ 799 static int w83791d_attach_adapter(struct i2c_adapter *adapter) 800 { 801 if (!(adapter->class & I2C_CLASS_HWMON)) 802 return 0; 803 return i2c_probe(adapter, &addr_data, w83791d_detect); 804 } 805 806 807 static int w83791d_create_subclient(struct i2c_adapter *adapter, 808 struct i2c_client *client, int addr, 809 struct i2c_client **sub_cli) 810 { 811 int err; 812 struct i2c_client *sub_client; 813 814 (*sub_cli) = sub_client = 815 kzalloc(sizeof(struct i2c_client), GFP_KERNEL); 816 if (!(sub_client)) { 817 return -ENOMEM; 818 } 819 sub_client->addr = 0x48 + addr; 820 i2c_set_clientdata(sub_client, NULL); 821 sub_client->adapter = adapter; 822 sub_client->driver = &w83791d_driver; 823 strlcpy(sub_client->name, "w83791d subclient", I2C_NAME_SIZE); 824 if ((err = i2c_attach_client(sub_client))) { 825 dev_err(&client->dev, "subclient registration " 826 "at address 0x%x failed\n", sub_client->addr); 827 kfree(sub_client); 828 return err; 829 } 830 return 0; 831 } 832 833 834 static int w83791d_detect_subclients(struct i2c_adapter *adapter, int address, 835 int kind, struct i2c_client *client) 836 { 837 struct w83791d_data *data = i2c_get_clientdata(client); 838 int i, id, err; 839 u8 val; 840 841 id = i2c_adapter_id(adapter); 842 if (force_subclients[0] == id && force_subclients[1] == address) { 843 for (i = 2; i <= 3; i++) { 844 if (force_subclients[i] < 0x48 || 845 force_subclients[i] > 0x4f) { 846 dev_err(&client->dev, 847 "invalid subclient " 848 "address %d; must be 0x48-0x4f\n", 849 force_subclients[i]); 850 err = -ENODEV; 851 goto error_sc_0; 852 } 853 } 854 w83791d_write(client, W83791D_REG_I2C_SUBADDR, 855 (force_subclients[2] & 0x07) | 856 ((force_subclients[3] & 0x07) << 4)); 857 } 858 859 val = w83791d_read(client, W83791D_REG_I2C_SUBADDR); 860 if (!(val & 0x08)) { 861 err = w83791d_create_subclient(adapter, client, 862 val & 0x7, &data->lm75[0]); 863 if (err < 0) 864 goto error_sc_0; 865 } 866 if (!(val & 0x80)) { 867 if ((data->lm75[0] != NULL) && 868 ((val & 0x7) == ((val >> 4) & 0x7))) { 869 dev_err(&client->dev, 870 "duplicate addresses 0x%x, " 871 "use force_subclient\n", 872 data->lm75[0]->addr); 873 err = -ENODEV; 874 goto error_sc_1; 875 } 876 err = w83791d_create_subclient(adapter, client, 877 (val >> 4) & 0x7, &data->lm75[1]); 878 if (err < 0) 879 goto error_sc_1; 880 } 881 882 return 0; 883 884 /* Undo inits in case of errors */ 885 886 error_sc_1: 887 if (data->lm75[0] != NULL) { 888 i2c_detach_client(data->lm75[0]); 889 kfree(data->lm75[0]); 890 } 891 error_sc_0: 892 return err; 893 } 894 895 896 static int w83791d_detect(struct i2c_adapter *adapter, int address, int kind) 897 { 898 struct i2c_client *client; 899 struct device *dev; 900 struct w83791d_data *data; 901 int i, val1, val2; 902 int err = 0; 903 const char *client_name = ""; 904 905 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 906 goto error0; 907 } 908 909 /* OK. For now, we presume we have a valid client. We now create the 910 client structure, even though we cannot fill it completely yet. 911 But it allows us to access w83791d_{read,write}_value. */ 912 if (!(data = kzalloc(sizeof(struct w83791d_data), GFP_KERNEL))) { 913 err = -ENOMEM; 914 goto error0; 915 } 916 917 client = &data->client; 918 dev = &client->dev; 919 i2c_set_clientdata(client, data); 920 client->addr = address; 921 client->adapter = adapter; 922 client->driver = &w83791d_driver; 923 mutex_init(&data->update_lock); 924 925 /* Now, we do the remaining detection. */ 926 927 /* The w83791d may be stuck in some other bank than bank 0. This may 928 make reading other information impossible. Specify a force=... 929 parameter, and the Winbond will be reset to the right bank. */ 930 if (kind < 0) { 931 if (w83791d_read(client, W83791D_REG_CONFIG) & 0x80) { 932 dev_dbg(dev, "Detection failed at step 1\n"); 933 goto error1; 934 } 935 val1 = w83791d_read(client, W83791D_REG_BANK); 936 val2 = w83791d_read(client, W83791D_REG_CHIPMAN); 937 /* Check for Winbond ID if in bank 0 */ 938 if (!(val1 & 0x07)) { 939 /* yes it is Bank0 */ 940 if (((!(val1 & 0x80)) && (val2 != 0xa3)) || 941 ((val1 & 0x80) && (val2 != 0x5c))) { 942 dev_dbg(dev, "Detection failed at step 2\n"); 943 goto error1; 944 } 945 } 946 /* If Winbond chip, address of chip and W83791D_REG_I2C_ADDR 947 should match */ 948 if (w83791d_read(client, W83791D_REG_I2C_ADDR) != address) { 949 dev_dbg(dev, "Detection failed at step 3\n"); 950 goto error1; 951 } 952 } 953 954 /* We either have a force parameter or we have reason to 955 believe it is a Winbond chip. Either way, we want bank 0 and 956 Vendor ID high byte */ 957 val1 = w83791d_read(client, W83791D_REG_BANK) & 0x78; 958 w83791d_write(client, W83791D_REG_BANK, val1 | 0x80); 959 960 /* Verify it is a Winbond w83791d */ 961 if (kind <= 0) { 962 /* get vendor ID */ 963 val2 = w83791d_read(client, W83791D_REG_CHIPMAN); 964 if (val2 != 0x5c) { /* the vendor is NOT Winbond */ 965 dev_dbg(dev, "Detection failed at step 4\n"); 966 goto error1; 967 } 968 val1 = w83791d_read(client, W83791D_REG_WCHIPID); 969 if (val1 == 0x71) { 970 kind = w83791d; 971 } else { 972 if (kind == 0) 973 dev_warn(dev, 974 "w83791d: Ignoring 'force' parameter " 975 "for unknown chip at adapter %d, " 976 "address 0x%02x\n", 977 i2c_adapter_id(adapter), address); 978 goto error1; 979 } 980 } 981 982 if (kind == w83791d) { 983 client_name = "w83791d"; 984 } else { 985 dev_err(dev, "w83791d: Internal error: unknown kind (%d)?!?", 986 kind); 987 goto error1; 988 } 989 990 #ifdef DEBUG 991 val1 = w83791d_read(client, W83791D_REG_DID_VID4); 992 dev_dbg(dev, "Device ID version: %d.%d (0x%02x)\n", 993 (val1 >> 5) & 0x07, (val1 >> 1) & 0x0f, val1); 994 #endif 995 996 /* Fill in the remaining client fields and put into the global list */ 997 strlcpy(client->name, client_name, I2C_NAME_SIZE); 998 999 /* Tell the I2C layer a new client has arrived */ 1000 if ((err = i2c_attach_client(client))) 1001 goto error1; 1002 1003 if ((err = w83791d_detect_subclients(adapter, address, kind, client))) 1004 goto error2; 1005 1006 /* Initialize the chip */ 1007 w83791d_init_client(client); 1008 1009 /* If the fan_div is changed, make sure there is a rational 1010 fan_min in place */ 1011 for (i = 0; i < NUMBER_OF_FANIN; i++) { 1012 data->fan_min[i] = w83791d_read(client, W83791D_REG_FAN_MIN[i]); 1013 } 1014 1015 /* Register sysfs hooks */ 1016 if ((err = sysfs_create_group(&client->dev.kobj, &w83791d_group))) 1017 goto error3; 1018 1019 /* Everything is ready, now register the working device */ 1020 data->class_dev = hwmon_device_register(dev); 1021 if (IS_ERR(data->class_dev)) { 1022 err = PTR_ERR(data->class_dev); 1023 goto error4; 1024 } 1025 1026 return 0; 1027 1028 error4: 1029 sysfs_remove_group(&client->dev.kobj, &w83791d_group); 1030 error3: 1031 if (data->lm75[0] != NULL) { 1032 i2c_detach_client(data->lm75[0]); 1033 kfree(data->lm75[0]); 1034 } 1035 if (data->lm75[1] != NULL) { 1036 i2c_detach_client(data->lm75[1]); 1037 kfree(data->lm75[1]); 1038 } 1039 error2: 1040 i2c_detach_client(client); 1041 error1: 1042 kfree(data); 1043 error0: 1044 return err; 1045 } 1046 1047 static int w83791d_detach_client(struct i2c_client *client) 1048 { 1049 struct w83791d_data *data = i2c_get_clientdata(client); 1050 int err; 1051 1052 /* main client */ 1053 if (data) { 1054 hwmon_device_unregister(data->class_dev); 1055 sysfs_remove_group(&client->dev.kobj, &w83791d_group); 1056 } 1057 1058 if ((err = i2c_detach_client(client))) 1059 return err; 1060 1061 /* main client */ 1062 if (data) 1063 kfree(data); 1064 /* subclient */ 1065 else 1066 kfree(client); 1067 1068 return 0; 1069 } 1070 1071 static void w83791d_init_client(struct i2c_client *client) 1072 { 1073 struct w83791d_data *data = i2c_get_clientdata(client); 1074 u8 tmp; 1075 u8 old_beep; 1076 1077 /* The difference between reset and init is that reset 1078 does a hard reset of the chip via index 0x40, bit 7, 1079 but init simply forces certain registers to have "sane" 1080 values. The hope is that the BIOS has done the right 1081 thing (which is why the default is reset=0, init=0), 1082 but if not, reset is the hard hammer and init 1083 is the soft mallet both of which are trying to whack 1084 things into place... 1085 NOTE: The data sheet makes a distinction between 1086 "power on defaults" and "reset by MR". As far as I can tell, 1087 the hard reset puts everything into a power-on state so I'm 1088 not sure what "reset by MR" means or how it can happen. 1089 */ 1090 if (reset || init) { 1091 /* keep some BIOS settings when we... */ 1092 old_beep = w83791d_read(client, W83791D_REG_BEEP_CONFIG); 1093 1094 if (reset) { 1095 /* ... reset the chip and ... */ 1096 w83791d_write(client, W83791D_REG_CONFIG, 0x80); 1097 } 1098 1099 /* ... disable power-on abnormal beep */ 1100 w83791d_write(client, W83791D_REG_BEEP_CONFIG, old_beep | 0x80); 1101 1102 /* disable the global beep (not done by hard reset) */ 1103 tmp = w83791d_read(client, W83791D_REG_BEEP_CTRL[1]); 1104 w83791d_write(client, W83791D_REG_BEEP_CTRL[1], tmp & 0xef); 1105 1106 if (init) { 1107 /* Make sure monitoring is turned on for add-ons */ 1108 tmp = w83791d_read(client, W83791D_REG_TEMP2_CONFIG); 1109 if (tmp & 1) { 1110 w83791d_write(client, W83791D_REG_TEMP2_CONFIG, 1111 tmp & 0xfe); 1112 } 1113 1114 tmp = w83791d_read(client, W83791D_REG_TEMP3_CONFIG); 1115 if (tmp & 1) { 1116 w83791d_write(client, W83791D_REG_TEMP3_CONFIG, 1117 tmp & 0xfe); 1118 } 1119 1120 /* Start monitoring */ 1121 tmp = w83791d_read(client, W83791D_REG_CONFIG) & 0xf7; 1122 w83791d_write(client, W83791D_REG_CONFIG, tmp | 0x01); 1123 } 1124 } 1125 1126 data->vrm = vid_which_vrm(); 1127 } 1128 1129 static struct w83791d_data *w83791d_update_device(struct device *dev) 1130 { 1131 struct i2c_client *client = to_i2c_client(dev); 1132 struct w83791d_data *data = i2c_get_clientdata(client); 1133 int i, j; 1134 u8 reg_array_tmp[3]; 1135 1136 mutex_lock(&data->update_lock); 1137 1138 if (time_after(jiffies, data->last_updated + (HZ * 3)) 1139 || !data->valid) { 1140 dev_dbg(dev, "Starting w83791d device update\n"); 1141 1142 /* Update the voltages measured value and limits */ 1143 for (i = 0; i < NUMBER_OF_VIN; i++) { 1144 data->in[i] = w83791d_read(client, 1145 W83791D_REG_IN[i]); 1146 data->in_max[i] = w83791d_read(client, 1147 W83791D_REG_IN_MAX[i]); 1148 data->in_min[i] = w83791d_read(client, 1149 W83791D_REG_IN_MIN[i]); 1150 } 1151 1152 /* Update the fan counts and limits */ 1153 for (i = 0; i < NUMBER_OF_FANIN; i++) { 1154 /* Update the Fan measured value and limits */ 1155 data->fan[i] = w83791d_read(client, 1156 W83791D_REG_FAN[i]); 1157 data->fan_min[i] = w83791d_read(client, 1158 W83791D_REG_FAN_MIN[i]); 1159 } 1160 1161 /* Update the fan divisor */ 1162 for (i = 0; i < 3; i++) { 1163 reg_array_tmp[i] = w83791d_read(client, 1164 W83791D_REG_FAN_DIV[i]); 1165 } 1166 data->fan_div[0] = (reg_array_tmp[0] >> 4) & 0x03; 1167 data->fan_div[1] = (reg_array_tmp[0] >> 6) & 0x03; 1168 data->fan_div[2] = (reg_array_tmp[1] >> 6) & 0x03; 1169 data->fan_div[3] = reg_array_tmp[2] & 0x07; 1170 data->fan_div[4] = (reg_array_tmp[2] >> 4) & 0x07; 1171 1172 /* Update the first temperature sensor */ 1173 for (i = 0; i < 3; i++) { 1174 data->temp1[i] = w83791d_read(client, 1175 W83791D_REG_TEMP1[i]); 1176 } 1177 1178 /* Update the rest of the temperature sensors */ 1179 for (i = 0; i < 2; i++) { 1180 for (j = 0; j < 3; j++) { 1181 data->temp_add[i][j] = 1182 (w83791d_read(client, 1183 W83791D_REG_TEMP_ADD[i][j * 2]) << 8) | 1184 w83791d_read(client, 1185 W83791D_REG_TEMP_ADD[i][j * 2 + 1]); 1186 } 1187 } 1188 1189 /* Update the realtime status */ 1190 data->alarms = 1191 w83791d_read(client, W83791D_REG_ALARM1) + 1192 (w83791d_read(client, W83791D_REG_ALARM2) << 8) + 1193 (w83791d_read(client, W83791D_REG_ALARM3) << 16); 1194 1195 /* Update the beep configuration information */ 1196 data->beep_mask = 1197 w83791d_read(client, W83791D_REG_BEEP_CTRL[0]) + 1198 (w83791d_read(client, W83791D_REG_BEEP_CTRL[1]) << 8) + 1199 (w83791d_read(client, W83791D_REG_BEEP_CTRL[2]) << 16); 1200 1201 /* Extract global beep enable flag */ 1202 data->beep_enable = 1203 (data->beep_mask >> GLOBAL_BEEP_ENABLE_SHIFT) & 0x01; 1204 1205 /* Update the cpu voltage information */ 1206 i = w83791d_read(client, W83791D_REG_VID_FANDIV); 1207 data->vid = i & 0x0f; 1208 data->vid |= (w83791d_read(client, W83791D_REG_DID_VID4) & 0x01) 1209 << 4; 1210 1211 data->last_updated = jiffies; 1212 data->valid = 1; 1213 } 1214 1215 mutex_unlock(&data->update_lock); 1216 1217 #ifdef DEBUG 1218 w83791d_print_debug(data, dev); 1219 #endif 1220 1221 return data; 1222 } 1223 1224 #ifdef DEBUG 1225 static void w83791d_print_debug(struct w83791d_data *data, struct device *dev) 1226 { 1227 int i = 0, j = 0; 1228 1229 dev_dbg(dev, "======Start of w83791d debug values======\n"); 1230 dev_dbg(dev, "%d set of Voltages: ===>\n", NUMBER_OF_VIN); 1231 for (i = 0; i < NUMBER_OF_VIN; i++) { 1232 dev_dbg(dev, "vin[%d] is: 0x%02x\n", i, data->in[i]); 1233 dev_dbg(dev, "vin[%d] min is: 0x%02x\n", i, data->in_min[i]); 1234 dev_dbg(dev, "vin[%d] max is: 0x%02x\n", i, data->in_max[i]); 1235 } 1236 dev_dbg(dev, "%d set of Fan Counts/Divisors: ===>\n", NUMBER_OF_FANIN); 1237 for (i = 0; i < NUMBER_OF_FANIN; i++) { 1238 dev_dbg(dev, "fan[%d] is: 0x%02x\n", i, data->fan[i]); 1239 dev_dbg(dev, "fan[%d] min is: 0x%02x\n", i, data->fan_min[i]); 1240 dev_dbg(dev, "fan_div[%d] is: 0x%02x\n", i, data->fan_div[i]); 1241 } 1242 1243 /* temperature math is signed, but only print out the 1244 bits that matter */ 1245 dev_dbg(dev, "%d set of Temperatures: ===>\n", NUMBER_OF_TEMPIN); 1246 for (i = 0; i < 3; i++) { 1247 dev_dbg(dev, "temp1[%d] is: 0x%02x\n", i, (u8) data->temp1[i]); 1248 } 1249 for (i = 0; i < 2; i++) { 1250 for (j = 0; j < 3; j++) { 1251 dev_dbg(dev, "temp_add[%d][%d] is: 0x%04x\n", i, j, 1252 (u16) data->temp_add[i][j]); 1253 } 1254 } 1255 1256 dev_dbg(dev, "Misc Information: ===>\n"); 1257 dev_dbg(dev, "alarm is: 0x%08x\n", data->alarms); 1258 dev_dbg(dev, "beep_mask is: 0x%08x\n", data->beep_mask); 1259 dev_dbg(dev, "beep_enable is: %d\n", data->beep_enable); 1260 dev_dbg(dev, "vid is: 0x%02x\n", data->vid); 1261 dev_dbg(dev, "vrm is: 0x%02x\n", data->vrm); 1262 dev_dbg(dev, "=======End of w83791d debug values========\n"); 1263 dev_dbg(dev, "\n"); 1264 } 1265 #endif 1266 1267 static int __init sensors_w83791d_init(void) 1268 { 1269 return i2c_add_driver(&w83791d_driver); 1270 } 1271 1272 static void __exit sensors_w83791d_exit(void) 1273 { 1274 i2c_del_driver(&w83791d_driver); 1275 } 1276 1277 MODULE_AUTHOR("Charles Spirakis <bezaur@gmail.com>"); 1278 MODULE_DESCRIPTION("W83791D driver"); 1279 MODULE_LICENSE("GPL"); 1280 1281 module_init(sensors_w83791d_init); 1282 module_exit(sensors_w83791d_exit); 1283