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