2 w83791d.c - Part of lm_sensors, Linux kernel modules for hardware
5 Copyright (C) 2006-2007 Charles Spirakis <bezaur@gmail.com>
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.
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.
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.
23 Supports following chips:
25 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
26 w83791d 10 5 5 3 0x71 0x5ca3 yes no
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
32 The w83791g chip is the same as the w83791d but lead-free.
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>
45 #define NUMBER_OF_VIN 10
46 #define NUMBER_OF_FANIN 5
47 #define NUMBER_OF_TEMPIN 3
48 #define NUMBER_OF_PWM 5
50 /* Addresses to scan */
51 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
54 /* Insmod parameters */
55 I2C_CLIENT_INSMOD_1(w83791d);
56 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: "
57 "{bus, clientaddr, subclientaddr1, subclientaddr2}");
60 module_param(reset, bool, 0);
61 MODULE_PARM_DESC(reset, "Set to one to force a hardware chip reset");
64 module_param(init, bool, 0);
65 MODULE_PARM_DESC(init, "Set to one to force extra software initialization");
67 /* The W83791D registers */
68 static const u8 W83791D_REG_IN[NUMBER_OF_VIN] = {
69 0x20, /* VCOREA in DataSheet */
70 0x21, /* VINR0 in DataSheet */
71 0x22, /* +3.3VIN in DataSheet */
72 0x23, /* VDD5V in DataSheet */
73 0x24, /* +12VIN in DataSheet */
74 0x25, /* -12VIN in DataSheet */
75 0x26, /* -5VIN in DataSheet */
76 0xB0, /* 5VSB in DataSheet */
77 0xB1, /* VBAT in DataSheet */
78 0xB2 /* VINR1 in DataSheet */
81 static const u8 W83791D_REG_IN_MAX[NUMBER_OF_VIN] = {
82 0x2B, /* VCOREA High Limit in DataSheet */
83 0x2D, /* VINR0 High Limit in DataSheet */
84 0x2F, /* +3.3VIN High Limit in DataSheet */
85 0x31, /* VDD5V High Limit in DataSheet */
86 0x33, /* +12VIN High Limit in DataSheet */
87 0x35, /* -12VIN High Limit in DataSheet */
88 0x37, /* -5VIN High Limit in DataSheet */
89 0xB4, /* 5VSB High Limit in DataSheet */
90 0xB6, /* VBAT High Limit in DataSheet */
91 0xB8 /* VINR1 High Limit in DataSheet */
93 static const u8 W83791D_REG_IN_MIN[NUMBER_OF_VIN] = {
94 0x2C, /* VCOREA Low Limit in DataSheet */
95 0x2E, /* VINR0 Low Limit in DataSheet */
96 0x30, /* +3.3VIN Low Limit in DataSheet */
97 0x32, /* VDD5V Low Limit in DataSheet */
98 0x34, /* +12VIN Low Limit in DataSheet */
99 0x36, /* -12VIN Low Limit in DataSheet */
100 0x38, /* -5VIN Low Limit in DataSheet */
101 0xB5, /* 5VSB Low Limit in DataSheet */
102 0xB7, /* VBAT Low Limit in DataSheet */
103 0xB9 /* VINR1 Low Limit in DataSheet */
105 static const u8 W83791D_REG_FAN[NUMBER_OF_FANIN] = {
106 0x28, /* FAN 1 Count in DataSheet */
107 0x29, /* FAN 2 Count in DataSheet */
108 0x2A, /* FAN 3 Count in DataSheet */
109 0xBA, /* FAN 4 Count in DataSheet */
110 0xBB, /* FAN 5 Count in DataSheet */
112 static const u8 W83791D_REG_FAN_MIN[NUMBER_OF_FANIN] = {
113 0x3B, /* FAN 1 Count Low Limit in DataSheet */
114 0x3C, /* FAN 2 Count Low Limit in DataSheet */
115 0x3D, /* FAN 3 Count Low Limit in DataSheet */
116 0xBC, /* FAN 4 Count Low Limit in DataSheet */
117 0xBD, /* FAN 5 Count Low Limit in DataSheet */
120 static const u8 W83791D_REG_PWM[NUMBER_OF_PWM] = {
121 0x81, /* PWM 1 duty cycle register in DataSheet */
122 0x83, /* PWM 2 duty cycle register in DataSheet */
123 0x94, /* PWM 3 duty cycle register in DataSheet */
124 0xA0, /* PWM 4 duty cycle register in DataSheet */
125 0xA1, /* PWM 5 duty cycle register in DataSheet */
128 static const u8 W83791D_REG_FAN_CFG[2] = {
129 0x84, /* FAN 1/2 configuration */
130 0x95, /* FAN 3 configuration */
133 static const u8 W83791D_REG_FAN_DIV[3] = {
134 0x47, /* contains FAN1 and FAN2 Divisor */
135 0x4b, /* contains FAN3 Divisor */
136 0x5C, /* contains FAN4 and FAN5 Divisor */
139 #define W83791D_REG_BANK 0x4E
140 #define W83791D_REG_TEMP2_CONFIG 0xC2
141 #define W83791D_REG_TEMP3_CONFIG 0xCA
143 static const u8 W83791D_REG_TEMP1[3] = {
144 0x27, /* TEMP 1 in DataSheet */
145 0x39, /* TEMP 1 Over in DataSheet */
146 0x3A, /* TEMP 1 Hyst in DataSheet */
149 static const u8 W83791D_REG_TEMP_ADD[2][6] = {
150 {0xC0, /* TEMP 2 in DataSheet */
151 0xC1, /* TEMP 2(0.5 deg) in DataSheet */
152 0xC5, /* TEMP 2 Over High part in DataSheet */
153 0xC6, /* TEMP 2 Over Low part in DataSheet */
154 0xC3, /* TEMP 2 Thyst High part in DataSheet */
155 0xC4}, /* TEMP 2 Thyst Low part in DataSheet */
156 {0xC8, /* TEMP 3 in DataSheet */
157 0xC9, /* TEMP 3(0.5 deg) in DataSheet */
158 0xCD, /* TEMP 3 Over High part in DataSheet */
159 0xCE, /* TEMP 3 Over Low part in DataSheet */
160 0xCB, /* TEMP 3 Thyst High part in DataSheet */
161 0xCC} /* TEMP 3 Thyst Low part in DataSheet */
164 #define W83791D_REG_BEEP_CONFIG 0x4D
166 static const u8 W83791D_REG_BEEP_CTRL[3] = {
167 0x56, /* BEEP Control Register 1 */
168 0x57, /* BEEP Control Register 2 */
169 0xA3, /* BEEP Control Register 3 */
172 #define W83791D_REG_GPIO 0x15
173 #define W83791D_REG_CONFIG 0x40
174 #define W83791D_REG_VID_FANDIV 0x47
175 #define W83791D_REG_DID_VID4 0x49
176 #define W83791D_REG_WCHIPID 0x58
177 #define W83791D_REG_CHIPMAN 0x4F
178 #define W83791D_REG_PIN 0x4B
179 #define W83791D_REG_I2C_SUBADDR 0x4A
181 #define W83791D_REG_ALARM1 0xA9 /* realtime status register1 */
182 #define W83791D_REG_ALARM2 0xAA /* realtime status register2 */
183 #define W83791D_REG_ALARM3 0xAB /* realtime status register3 */
185 #define W83791D_REG_VBAT 0x5D
186 #define W83791D_REG_I2C_ADDR 0x48
188 /* The SMBus locks itself. The Winbond W83791D has a bank select register
189 (index 0x4e), but the driver only accesses registers in bank 0. Since
190 we don't switch banks, we don't need any special code to handle
191 locking access between bank switches */
192 static inline int w83791d_read(struct i2c_client *client, u8 reg)
194 return i2c_smbus_read_byte_data(client, reg);
197 static inline int w83791d_write(struct i2c_client *client, u8 reg, u8 value)
199 return i2c_smbus_write_byte_data(client, reg, value);
202 /* The analog voltage inputs have 16mV LSB. Since the sysfs output is
203 in mV as would be measured on the chip input pin, need to just
204 multiply/divide by 16 to translate from/to register values. */
205 #define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8) / 16), 0, 255))
206 #define IN_FROM_REG(val) ((val) * 16)
208 static u8 fan_to_reg(long rpm, int div)
212 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
213 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
216 #define FAN_FROM_REG(val,div) ((val) == 0 ? -1 : \
217 ((val) == 255 ? 0 : \
218 1350000 / ((val) * (div))))
220 /* for temp1 which is 8-bit resolution, LSB = 1 degree Celsius */
221 #define TEMP1_FROM_REG(val) ((val) * 1000)
222 #define TEMP1_TO_REG(val) ((val) <= -128000 ? -128 : \
223 (val) >= 127000 ? 127 : \
224 (val) < 0 ? ((val) - 500) / 1000 : \
225 ((val) + 500) / 1000)
227 /* for temp2 and temp3 which are 9-bit resolution, LSB = 0.5 degree Celsius
228 Assumes the top 8 bits are the integral amount and the bottom 8 bits
229 are the fractional amount. Since we only have 0.5 degree resolution,
230 the bottom 7 bits will always be zero */
231 #define TEMP23_FROM_REG(val) ((val) / 128 * 500)
232 #define TEMP23_TO_REG(val) ((val) <= -128000 ? 0x8000 : \
233 (val) >= 127500 ? 0x7F80 : \
234 (val) < 0 ? ((val) - 250) / 500 * 128 : \
235 ((val) + 250) / 500 * 128)
238 #define BEEP_MASK_TO_REG(val) ((val) & 0xffffff)
239 #define BEEP_MASK_FROM_REG(val) ((val) & 0xffffff)
241 #define DIV_FROM_REG(val) (1 << (val))
243 static u8 div_to_reg(int nr, long val)
247 /* fan divisors max out at 128 */
248 val = SENSORS_LIMIT(val, 1, 128) >> 1;
249 for (i = 0; i < 7; i++) {
257 struct w83791d_data {
258 struct device *hwmon_dev;
259 struct mutex update_lock;
261 char valid; /* !=0 if following fields are valid */
262 unsigned long last_updated; /* In jiffies */
264 /* array of 2 pointers to subclients */
265 struct i2c_client *lm75[2];
268 u8 in[NUMBER_OF_VIN]; /* Register value */
269 u8 in_max[NUMBER_OF_VIN]; /* Register value */
270 u8 in_min[NUMBER_OF_VIN]; /* Register value */
273 u8 fan[NUMBER_OF_FANIN]; /* Register value */
274 u8 fan_min[NUMBER_OF_FANIN]; /* Register value */
275 u8 fan_div[NUMBER_OF_FANIN]; /* Register encoding, shifted right */
277 /* Temperature sensors */
279 s8 temp1[3]; /* current, over, thyst */
280 s16 temp_add[2][3]; /* fixed point value. Top 8 bits are the
281 integral part, bottom 8 bits are the
282 fractional part. We only use the top
283 9 bits as the resolution is only
284 to the 0.5 degree C...
285 two sensors with three values
289 u8 pwm[5]; /* pwm duty cycle */
290 u8 pwm_enable[3]; /* pwm enable status for fan 1-3
291 (fan 4-5 only support manual mode) */
294 u32 alarms; /* realtime status register encoding,combined */
295 u8 beep_enable; /* Global beep enable */
296 u32 beep_mask; /* Mask off specific beeps */
297 u8 vid; /* Register encoding, combined */
298 u8 vrm; /* hwmon-vid */
301 static int w83791d_probe(struct i2c_client *client,
302 const struct i2c_device_id *id);
303 static int w83791d_detect(struct i2c_client *client, int kind,
304 struct i2c_board_info *info);
305 static int w83791d_remove(struct i2c_client *client);
307 static int w83791d_read(struct i2c_client *client, u8 register);
308 static int w83791d_write(struct i2c_client *client, u8 register, u8 value);
309 static struct w83791d_data *w83791d_update_device(struct device *dev);
312 static void w83791d_print_debug(struct w83791d_data *data, struct device *dev);
315 static void w83791d_init_client(struct i2c_client *client);
317 static const struct i2c_device_id w83791d_id[] = {
318 { "w83791d", w83791d },
321 MODULE_DEVICE_TABLE(i2c, w83791d_id);
323 static struct i2c_driver w83791d_driver = {
324 .class = I2C_CLASS_HWMON,
328 .probe = w83791d_probe,
329 .remove = w83791d_remove,
330 .id_table = w83791d_id,
331 .detect = w83791d_detect,
332 .address_data = &addr_data,
335 /* following are the sysfs callback functions */
336 #define show_in_reg(reg) \
337 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
340 struct sensor_device_attribute *sensor_attr = \
341 to_sensor_dev_attr(attr); \
342 struct w83791d_data *data = w83791d_update_device(dev); \
343 int nr = sensor_attr->index; \
344 return sprintf(buf,"%d\n", IN_FROM_REG(data->reg[nr])); \
351 #define store_in_reg(REG, reg) \
352 static ssize_t store_in_##reg(struct device *dev, \
353 struct device_attribute *attr, \
354 const char *buf, size_t count) \
356 struct sensor_device_attribute *sensor_attr = \
357 to_sensor_dev_attr(attr); \
358 struct i2c_client *client = to_i2c_client(dev); \
359 struct w83791d_data *data = i2c_get_clientdata(client); \
360 unsigned long val = simple_strtoul(buf, NULL, 10); \
361 int nr = sensor_attr->index; \
363 mutex_lock(&data->update_lock); \
364 data->in_##reg[nr] = IN_TO_REG(val); \
365 w83791d_write(client, W83791D_REG_IN_##REG[nr], data->in_##reg[nr]); \
366 mutex_unlock(&data->update_lock); \
370 store_in_reg(MIN, min);
371 store_in_reg(MAX, max);
373 static struct sensor_device_attribute sda_in_input[] = {
374 SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
375 SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
376 SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
377 SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
378 SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
379 SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
380 SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
381 SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
382 SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
383 SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
386 static struct sensor_device_attribute sda_in_min[] = {
387 SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
388 SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
389 SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
390 SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
391 SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
392 SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
393 SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
394 SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
395 SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
396 SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
399 static struct sensor_device_attribute sda_in_max[] = {
400 SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
401 SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
402 SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
403 SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
404 SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
405 SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
406 SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
407 SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
408 SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
409 SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
413 static ssize_t show_beep(struct device *dev, struct device_attribute *attr,
416 struct sensor_device_attribute *sensor_attr =
417 to_sensor_dev_attr(attr);
418 struct w83791d_data *data = w83791d_update_device(dev);
419 int bitnr = sensor_attr->index;
421 return sprintf(buf, "%d\n", (data->beep_mask >> bitnr) & 1);
424 static ssize_t store_beep(struct device *dev, struct device_attribute *attr,
425 const char *buf, size_t count)
427 struct sensor_device_attribute *sensor_attr =
428 to_sensor_dev_attr(attr);
429 struct i2c_client *client = to_i2c_client(dev);
430 struct w83791d_data *data = i2c_get_clientdata(client);
431 int bitnr = sensor_attr->index;
432 int bytenr = bitnr / 8;
433 long val = simple_strtol(buf, NULL, 10) ? 1 : 0;
435 mutex_lock(&data->update_lock);
437 data->beep_mask &= ~(0xff << (bytenr * 8));
438 data->beep_mask |= w83791d_read(client, W83791D_REG_BEEP_CTRL[bytenr])
441 data->beep_mask &= ~(1 << bitnr);
442 data->beep_mask |= val << bitnr;
444 w83791d_write(client, W83791D_REG_BEEP_CTRL[bytenr],
445 (data->beep_mask >> (bytenr * 8)) & 0xff);
447 mutex_unlock(&data->update_lock);
452 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
455 struct sensor_device_attribute *sensor_attr =
456 to_sensor_dev_attr(attr);
457 struct w83791d_data *data = w83791d_update_device(dev);
458 int bitnr = sensor_attr->index;
460 return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
463 /* Note: The bitmask for the beep enable/disable is different than
464 the bitmask for the alarm. */
465 static struct sensor_device_attribute sda_in_beep[] = {
466 SENSOR_ATTR(in0_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 0),
467 SENSOR_ATTR(in1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 13),
468 SENSOR_ATTR(in2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 2),
469 SENSOR_ATTR(in3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 3),
470 SENSOR_ATTR(in4_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 8),
471 SENSOR_ATTR(in5_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 9),
472 SENSOR_ATTR(in6_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 10),
473 SENSOR_ATTR(in7_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 16),
474 SENSOR_ATTR(in8_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 17),
475 SENSOR_ATTR(in9_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 14),
478 static struct sensor_device_attribute sda_in_alarm[] = {
479 SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0),
480 SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1),
481 SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2),
482 SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3),
483 SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8),
484 SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9),
485 SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10),
486 SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 19),
487 SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 20),
488 SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 14),
491 #define show_fan_reg(reg) \
492 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
495 struct sensor_device_attribute *sensor_attr = \
496 to_sensor_dev_attr(attr); \
497 struct w83791d_data *data = w83791d_update_device(dev); \
498 int nr = sensor_attr->index; \
499 return sprintf(buf,"%d\n", \
500 FAN_FROM_REG(data->reg[nr], DIV_FROM_REG(data->fan_div[nr]))); \
504 show_fan_reg(fan_min);
506 static ssize_t store_fan_min(struct device *dev, struct device_attribute *attr,
507 const char *buf, size_t count)
509 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
510 struct i2c_client *client = to_i2c_client(dev);
511 struct w83791d_data *data = i2c_get_clientdata(client);
512 unsigned long val = simple_strtoul(buf, NULL, 10);
513 int nr = sensor_attr->index;
515 mutex_lock(&data->update_lock);
516 data->fan_min[nr] = fan_to_reg(val, DIV_FROM_REG(data->fan_div[nr]));
517 w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
518 mutex_unlock(&data->update_lock);
523 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
526 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
527 int nr = sensor_attr->index;
528 struct w83791d_data *data = w83791d_update_device(dev);
529 return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr]));
532 /* Note: we save and restore the fan minimum here, because its value is
533 determined in part by the fan divisor. This follows the principle of
534 least suprise; the user doesn't expect the fan minimum to change just
535 because the divisor changed. */
536 static ssize_t store_fan_div(struct device *dev, struct device_attribute *attr,
537 const char *buf, size_t count)
539 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
540 struct i2c_client *client = to_i2c_client(dev);
541 struct w83791d_data *data = i2c_get_clientdata(client);
542 int nr = sensor_attr->index;
552 min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
554 mutex_lock(&data->update_lock);
555 data->fan_div[nr] = div_to_reg(nr, simple_strtoul(buf, NULL, 10));
585 dev_warn(dev, "store_fan_div: Unexpected nr seen: %d\n", nr);
591 fan_div_reg = w83791d_read(client, W83791D_REG_FAN_DIV[indx])
593 tmp_fan_div = (data->fan_div[nr] << new_shift) & ~keep_mask;
595 w83791d_write(client, W83791D_REG_FAN_DIV[indx],
596 fan_div_reg | tmp_fan_div);
598 /* Bit 2 of fans 0-2 is stored in the vbat register (bits 5-7) */
600 keep_mask = ~(1 << (nr + 5));
601 vbat_reg = w83791d_read(client, W83791D_REG_VBAT)
603 tmp_fan_div = (data->fan_div[nr] << (3 + nr)) & ~keep_mask;
604 w83791d_write(client, W83791D_REG_VBAT,
605 vbat_reg | tmp_fan_div);
608 /* Restore fan_min */
609 data->fan_min[nr] = fan_to_reg(min, DIV_FROM_REG(data->fan_div[nr]));
610 w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
615 mutex_unlock(&data->update_lock);
620 static struct sensor_device_attribute sda_fan_input[] = {
621 SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
622 SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
623 SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
624 SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
625 SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
628 static struct sensor_device_attribute sda_fan_min[] = {
629 SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO,
630 show_fan_min, store_fan_min, 0),
631 SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO,
632 show_fan_min, store_fan_min, 1),
633 SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO,
634 show_fan_min, store_fan_min, 2),
635 SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO,
636 show_fan_min, store_fan_min, 3),
637 SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO,
638 show_fan_min, store_fan_min, 4),
641 static struct sensor_device_attribute sda_fan_div[] = {
642 SENSOR_ATTR(fan1_div, S_IWUSR | S_IRUGO,
643 show_fan_div, store_fan_div, 0),
644 SENSOR_ATTR(fan2_div, S_IWUSR | S_IRUGO,
645 show_fan_div, store_fan_div, 1),
646 SENSOR_ATTR(fan3_div, S_IWUSR | S_IRUGO,
647 show_fan_div, store_fan_div, 2),
648 SENSOR_ATTR(fan4_div, S_IWUSR | S_IRUGO,
649 show_fan_div, store_fan_div, 3),
650 SENSOR_ATTR(fan5_div, S_IWUSR | S_IRUGO,
651 show_fan_div, store_fan_div, 4),
654 static struct sensor_device_attribute sda_fan_beep[] = {
655 SENSOR_ATTR(fan1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 6),
656 SENSOR_ATTR(fan2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 7),
657 SENSOR_ATTR(fan3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 11),
658 SENSOR_ATTR(fan4_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 21),
659 SENSOR_ATTR(fan5_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 22),
662 static struct sensor_device_attribute sda_fan_alarm[] = {
663 SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
664 SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
665 SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
666 SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 21),
667 SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 22),
670 /* read/write PWMs */
671 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
674 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
675 int nr = sensor_attr->index;
676 struct w83791d_data *data = w83791d_update_device(dev);
677 return sprintf(buf, "%u\n", data->pwm[nr]);
680 static ssize_t store_pwm(struct device *dev, struct device_attribute *attr,
681 const char *buf, size_t count)
683 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
684 struct i2c_client *client = to_i2c_client(dev);
685 struct w83791d_data *data = i2c_get_clientdata(client);
686 int nr = sensor_attr->index;
689 if (strict_strtoul(buf, 10, &val))
692 mutex_lock(&data->update_lock);
693 data->pwm[nr] = SENSORS_LIMIT(val, 0, 255);
694 w83791d_write(client, W83791D_REG_PWM[nr], data->pwm[nr]);
695 mutex_unlock(&data->update_lock);
699 static struct sensor_device_attribute sda_pwm[] = {
700 SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO,
701 show_pwm, store_pwm, 0),
702 SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO,
703 show_pwm, store_pwm, 1),
704 SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO,
705 show_pwm, store_pwm, 2),
706 SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO,
707 show_pwm, store_pwm, 3),
708 SENSOR_ATTR(pwm5, S_IWUSR | S_IRUGO,
709 show_pwm, store_pwm, 4),
712 static ssize_t show_pwmenable(struct device *dev, struct device_attribute *attr,
715 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
716 int nr = sensor_attr->index;
717 struct w83791d_data *data = w83791d_update_device(dev);
718 return sprintf(buf, "%u\n", data->pwm_enable[nr] + 1);
721 static ssize_t store_pwmenable(struct device *dev,
722 struct device_attribute *attr, const char *buf, size_t count)
724 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
725 struct i2c_client *client = to_i2c_client(dev);
726 struct w83791d_data *data = i2c_get_clientdata(client);
727 int nr = sensor_attr->index;
734 int ret = strict_strtoul(buf, 10, &val);
736 if (ret || val < 1 || val > 3)
739 mutex_lock(&data->update_lock);
740 data->pwm_enable[nr] = val - 1;
759 reg_cfg_tmp = w83791d_read(client, W83791D_REG_FAN_CFG[reg_idx]);
760 reg_cfg_tmp = (reg_cfg_tmp & keep_mask) |
761 data->pwm_enable[nr] << val_shift;
763 w83791d_write(client, W83791D_REG_FAN_CFG[reg_idx], reg_cfg_tmp);
764 mutex_unlock(&data->update_lock);
768 static struct sensor_device_attribute sda_pwmenable[] = {
769 SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
770 show_pwmenable, store_pwmenable, 0),
771 SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO,
772 show_pwmenable, store_pwmenable, 1),
773 SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO,
774 show_pwmenable, store_pwmenable, 2),
777 /* read/write the temperature1, includes measured value and limits */
778 static ssize_t show_temp1(struct device *dev, struct device_attribute *devattr,
781 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
782 struct w83791d_data *data = w83791d_update_device(dev);
783 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp1[attr->index]));
786 static ssize_t store_temp1(struct device *dev, struct device_attribute *devattr,
787 const char *buf, size_t count)
789 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
790 struct i2c_client *client = to_i2c_client(dev);
791 struct w83791d_data *data = i2c_get_clientdata(client);
792 long val = simple_strtol(buf, NULL, 10);
793 int nr = attr->index;
795 mutex_lock(&data->update_lock);
796 data->temp1[nr] = TEMP1_TO_REG(val);
797 w83791d_write(client, W83791D_REG_TEMP1[nr], data->temp1[nr]);
798 mutex_unlock(&data->update_lock);
802 /* read/write temperature2-3, includes measured value and limits */
803 static ssize_t show_temp23(struct device *dev, struct device_attribute *devattr,
806 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
807 struct w83791d_data *data = w83791d_update_device(dev);
809 int index = attr->index;
810 return sprintf(buf, "%d\n", TEMP23_FROM_REG(data->temp_add[nr][index]));
813 static ssize_t store_temp23(struct device *dev,
814 struct device_attribute *devattr,
815 const char *buf, size_t count)
817 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
818 struct i2c_client *client = to_i2c_client(dev);
819 struct w83791d_data *data = i2c_get_clientdata(client);
820 long val = simple_strtol(buf, NULL, 10);
822 int index = attr->index;
824 mutex_lock(&data->update_lock);
825 data->temp_add[nr][index] = TEMP23_TO_REG(val);
826 w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2],
827 data->temp_add[nr][index] >> 8);
828 w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2 + 1],
829 data->temp_add[nr][index] & 0x80);
830 mutex_unlock(&data->update_lock);
835 static struct sensor_device_attribute_2 sda_temp_input[] = {
836 SENSOR_ATTR_2(temp1_input, S_IRUGO, show_temp1, NULL, 0, 0),
837 SENSOR_ATTR_2(temp2_input, S_IRUGO, show_temp23, NULL, 0, 0),
838 SENSOR_ATTR_2(temp3_input, S_IRUGO, show_temp23, NULL, 1, 0),
841 static struct sensor_device_attribute_2 sda_temp_max[] = {
842 SENSOR_ATTR_2(temp1_max, S_IRUGO | S_IWUSR,
843 show_temp1, store_temp1, 0, 1),
844 SENSOR_ATTR_2(temp2_max, S_IRUGO | S_IWUSR,
845 show_temp23, store_temp23, 0, 1),
846 SENSOR_ATTR_2(temp3_max, S_IRUGO | S_IWUSR,
847 show_temp23, store_temp23, 1, 1),
850 static struct sensor_device_attribute_2 sda_temp_max_hyst[] = {
851 SENSOR_ATTR_2(temp1_max_hyst, S_IRUGO | S_IWUSR,
852 show_temp1, store_temp1, 0, 2),
853 SENSOR_ATTR_2(temp2_max_hyst, S_IRUGO | S_IWUSR,
854 show_temp23, store_temp23, 0, 2),
855 SENSOR_ATTR_2(temp3_max_hyst, S_IRUGO | S_IWUSR,
856 show_temp23, store_temp23, 1, 2),
859 /* Note: The bitmask for the beep enable/disable is different than
860 the bitmask for the alarm. */
861 static struct sensor_device_attribute sda_temp_beep[] = {
862 SENSOR_ATTR(temp1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 4),
863 SENSOR_ATTR(temp2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 5),
864 SENSOR_ATTR(temp3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 1),
867 static struct sensor_device_attribute sda_temp_alarm[] = {
868 SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
869 SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
870 SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
873 /* get reatime status of all sensors items: voltage, temp, fan */
874 static ssize_t show_alarms_reg(struct device *dev,
875 struct device_attribute *attr, char *buf)
877 struct w83791d_data *data = w83791d_update_device(dev);
878 return sprintf(buf, "%u\n", data->alarms);
881 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
885 #define GLOBAL_BEEP_ENABLE_SHIFT 15
886 #define GLOBAL_BEEP_ENABLE_MASK (1 << GLOBAL_BEEP_ENABLE_SHIFT)
888 static ssize_t show_beep_enable(struct device *dev,
889 struct device_attribute *attr, char *buf)
891 struct w83791d_data *data = w83791d_update_device(dev);
892 return sprintf(buf, "%d\n", data->beep_enable);
895 static ssize_t show_beep_mask(struct device *dev,
896 struct device_attribute *attr, char *buf)
898 struct w83791d_data *data = w83791d_update_device(dev);
899 return sprintf(buf, "%d\n", BEEP_MASK_FROM_REG(data->beep_mask));
903 static ssize_t store_beep_mask(struct device *dev,
904 struct device_attribute *attr,
905 const char *buf, size_t count)
907 struct i2c_client *client = to_i2c_client(dev);
908 struct w83791d_data *data = i2c_get_clientdata(client);
909 long val = simple_strtol(buf, NULL, 10);
912 mutex_lock(&data->update_lock);
914 /* The beep_enable state overrides any enabling request from
916 data->beep_mask = BEEP_MASK_TO_REG(val) & ~GLOBAL_BEEP_ENABLE_MASK;
917 data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT);
919 val = data->beep_mask;
921 for (i = 0; i < 3; i++) {
922 w83791d_write(client, W83791D_REG_BEEP_CTRL[i], (val & 0xff));
926 mutex_unlock(&data->update_lock);
931 static ssize_t store_beep_enable(struct device *dev,
932 struct device_attribute *attr,
933 const char *buf, size_t count)
935 struct i2c_client *client = to_i2c_client(dev);
936 struct w83791d_data *data = i2c_get_clientdata(client);
937 long val = simple_strtol(buf, NULL, 10);
939 mutex_lock(&data->update_lock);
941 data->beep_enable = val ? 1 : 0;
943 /* Keep the full mask value in sync with the current enable */
944 data->beep_mask &= ~GLOBAL_BEEP_ENABLE_MASK;
945 data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT);
947 /* The global control is in the second beep control register
948 so only need to update that register */
949 val = (data->beep_mask >> 8) & 0xff;
951 w83791d_write(client, W83791D_REG_BEEP_CTRL[1], val);
953 mutex_unlock(&data->update_lock);
958 static struct sensor_device_attribute sda_beep_ctrl[] = {
959 SENSOR_ATTR(beep_enable, S_IRUGO | S_IWUSR,
960 show_beep_enable, store_beep_enable, 0),
961 SENSOR_ATTR(beep_mask, S_IRUGO | S_IWUSR,
962 show_beep_mask, store_beep_mask, 1)
965 /* cpu voltage regulation information */
966 static ssize_t show_vid_reg(struct device *dev,
967 struct device_attribute *attr, char *buf)
969 struct w83791d_data *data = w83791d_update_device(dev);
970 return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
973 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
975 static ssize_t show_vrm_reg(struct device *dev,
976 struct device_attribute *attr, char *buf)
978 struct w83791d_data *data = dev_get_drvdata(dev);
979 return sprintf(buf, "%d\n", data->vrm);
982 static ssize_t store_vrm_reg(struct device *dev,
983 struct device_attribute *attr,
984 const char *buf, size_t count)
986 struct w83791d_data *data = dev_get_drvdata(dev);
988 /* No lock needed as vrm is internal to the driver
989 (not read from a chip register) and so is not
990 updated in w83791d_update_device() */
991 data->vrm = simple_strtoul(buf, NULL, 10);
996 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
998 #define IN_UNIT_ATTRS(X) \
999 &sda_in_input[X].dev_attr.attr, \
1000 &sda_in_min[X].dev_attr.attr, \
1001 &sda_in_max[X].dev_attr.attr, \
1002 &sda_in_beep[X].dev_attr.attr, \
1003 &sda_in_alarm[X].dev_attr.attr
1005 #define FAN_UNIT_ATTRS(X) \
1006 &sda_fan_input[X].dev_attr.attr, \
1007 &sda_fan_min[X].dev_attr.attr, \
1008 &sda_fan_div[X].dev_attr.attr, \
1009 &sda_fan_beep[X].dev_attr.attr, \
1010 &sda_fan_alarm[X].dev_attr.attr
1012 #define TEMP_UNIT_ATTRS(X) \
1013 &sda_temp_input[X].dev_attr.attr, \
1014 &sda_temp_max[X].dev_attr.attr, \
1015 &sda_temp_max_hyst[X].dev_attr.attr, \
1016 &sda_temp_beep[X].dev_attr.attr, \
1017 &sda_temp_alarm[X].dev_attr.attr
1019 static struct attribute *w83791d_attributes[] = {
1036 &dev_attr_alarms.attr,
1037 &sda_beep_ctrl[0].dev_attr.attr,
1038 &sda_beep_ctrl[1].dev_attr.attr,
1039 &dev_attr_cpu0_vid.attr,
1041 &sda_pwm[0].dev_attr.attr,
1042 &sda_pwm[1].dev_attr.attr,
1043 &sda_pwm[2].dev_attr.attr,
1044 &sda_pwmenable[0].dev_attr.attr,
1045 &sda_pwmenable[1].dev_attr.attr,
1046 &sda_pwmenable[2].dev_attr.attr,
1050 static const struct attribute_group w83791d_group = {
1051 .attrs = w83791d_attributes,
1054 /* Separate group of attributes for fan/pwm 4-5. Their pins can also be
1055 in use for GPIO in which case their sysfs-interface should not be made
1057 static struct attribute *w83791d_attributes_fanpwm45[] = {
1060 &sda_pwm[3].dev_attr.attr,
1061 &sda_pwm[4].dev_attr.attr,
1065 static const struct attribute_group w83791d_group_fanpwm45 = {
1066 .attrs = w83791d_attributes_fanpwm45,
1069 static int w83791d_detect_subclients(struct i2c_client *client)
1071 struct i2c_adapter *adapter = client->adapter;
1072 struct w83791d_data *data = i2c_get_clientdata(client);
1073 int address = client->addr;
1077 id = i2c_adapter_id(adapter);
1078 if (force_subclients[0] == id && force_subclients[1] == address) {
1079 for (i = 2; i <= 3; i++) {
1080 if (force_subclients[i] < 0x48 ||
1081 force_subclients[i] > 0x4f) {
1082 dev_err(&client->dev,
1083 "invalid subclient "
1084 "address %d; must be 0x48-0x4f\n",
1085 force_subclients[i]);
1090 w83791d_write(client, W83791D_REG_I2C_SUBADDR,
1091 (force_subclients[2] & 0x07) |
1092 ((force_subclients[3] & 0x07) << 4));
1095 val = w83791d_read(client, W83791D_REG_I2C_SUBADDR);
1096 if (!(val & 0x08)) {
1097 data->lm75[0] = i2c_new_dummy(adapter, 0x48 + (val & 0x7));
1099 if (!(val & 0x80)) {
1100 if ((data->lm75[0] != NULL) &&
1101 ((val & 0x7) == ((val >> 4) & 0x7))) {
1102 dev_err(&client->dev,
1103 "duplicate addresses 0x%x, "
1104 "use force_subclient\n",
1105 data->lm75[0]->addr);
1109 data->lm75[1] = i2c_new_dummy(adapter,
1110 0x48 + ((val >> 4) & 0x7));
1115 /* Undo inits in case of errors */
1118 if (data->lm75[0] != NULL)
1119 i2c_unregister_device(data->lm75[0]);
1125 /* Return 0 if detection is successful, -ENODEV otherwise */
1126 static int w83791d_detect(struct i2c_client *client, int kind,
1127 struct i2c_board_info *info)
1129 struct i2c_adapter *adapter = client->adapter;
1131 unsigned short address = client->addr;
1133 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1137 /* The w83791d may be stuck in some other bank than bank 0. This may
1138 make reading other information impossible. Specify a force=...
1139 parameter, and the Winbond will be reset to the right bank. */
1141 if (w83791d_read(client, W83791D_REG_CONFIG) & 0x80) {
1144 val1 = w83791d_read(client, W83791D_REG_BANK);
1145 val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
1146 /* Check for Winbond ID if in bank 0 */
1147 if (!(val1 & 0x07)) {
1148 /* yes it is Bank0 */
1149 if (((!(val1 & 0x80)) && (val2 != 0xa3)) ||
1150 ((val1 & 0x80) && (val2 != 0x5c))) {
1154 /* If Winbond chip, address of chip and W83791D_REG_I2C_ADDR
1156 if (w83791d_read(client, W83791D_REG_I2C_ADDR) != address) {
1161 /* We either have a force parameter or we have reason to
1162 believe it is a Winbond chip. Either way, we want bank 0 and
1163 Vendor ID high byte */
1164 val1 = w83791d_read(client, W83791D_REG_BANK) & 0x78;
1165 w83791d_write(client, W83791D_REG_BANK, val1 | 0x80);
1167 /* Verify it is a Winbond w83791d */
1170 val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
1171 if (val2 != 0x5c) { /* the vendor is NOT Winbond */
1174 val1 = w83791d_read(client, W83791D_REG_WCHIPID);
1179 dev_warn(&adapter->dev,
1180 "w83791d: Ignoring 'force' parameter "
1181 "for unknown chip at adapter %d, "
1183 i2c_adapter_id(adapter), address);
1188 strlcpy(info->type, "w83791d", I2C_NAME_SIZE);
1193 static int w83791d_probe(struct i2c_client *client,
1194 const struct i2c_device_id *id)
1196 struct w83791d_data *data;
1197 struct device *dev = &client->dev;
1203 val1 = w83791d_read(client, W83791D_REG_DID_VID4);
1204 dev_dbg(dev, "Device ID version: %d.%d (0x%02x)\n",
1205 (val1 >> 5) & 0x07, (val1 >> 1) & 0x0f, val1);
1208 data = kzalloc(sizeof(struct w83791d_data), GFP_KERNEL);
1214 i2c_set_clientdata(client, data);
1215 mutex_init(&data->update_lock);
1217 err = w83791d_detect_subclients(client);
1221 /* Initialize the chip */
1222 w83791d_init_client(client);
1224 /* If the fan_div is changed, make sure there is a rational
1226 for (i = 0; i < NUMBER_OF_FANIN; i++) {
1227 data->fan_min[i] = w83791d_read(client, W83791D_REG_FAN_MIN[i]);
1230 /* Register sysfs hooks */
1231 if ((err = sysfs_create_group(&client->dev.kobj, &w83791d_group)))
1234 /* Check if pins of fan/pwm 4-5 are in use as GPIO */
1235 has_fanpwm45 = w83791d_read(client, W83791D_REG_GPIO) & 0x10;
1237 err = sysfs_create_group(&client->dev.kobj,
1238 &w83791d_group_fanpwm45);
1243 /* Everything is ready, now register the working device */
1244 data->hwmon_dev = hwmon_device_register(dev);
1245 if (IS_ERR(data->hwmon_dev)) {
1246 err = PTR_ERR(data->hwmon_dev);
1254 sysfs_remove_group(&client->dev.kobj, &w83791d_group_fanpwm45);
1256 sysfs_remove_group(&client->dev.kobj, &w83791d_group);
1258 if (data->lm75[0] != NULL)
1259 i2c_unregister_device(data->lm75[0]);
1260 if (data->lm75[1] != NULL)
1261 i2c_unregister_device(data->lm75[1]);
1268 static int w83791d_remove(struct i2c_client *client)
1270 struct w83791d_data *data = i2c_get_clientdata(client);
1272 hwmon_device_unregister(data->hwmon_dev);
1273 sysfs_remove_group(&client->dev.kobj, &w83791d_group);
1275 if (data->lm75[0] != NULL)
1276 i2c_unregister_device(data->lm75[0]);
1277 if (data->lm75[1] != NULL)
1278 i2c_unregister_device(data->lm75[1]);
1284 static void w83791d_init_client(struct i2c_client *client)
1286 struct w83791d_data *data = i2c_get_clientdata(client);
1290 /* The difference between reset and init is that reset
1291 does a hard reset of the chip via index 0x40, bit 7,
1292 but init simply forces certain registers to have "sane"
1293 values. The hope is that the BIOS has done the right
1294 thing (which is why the default is reset=0, init=0),
1295 but if not, reset is the hard hammer and init
1296 is the soft mallet both of which are trying to whack
1297 things into place...
1298 NOTE: The data sheet makes a distinction between
1299 "power on defaults" and "reset by MR". As far as I can tell,
1300 the hard reset puts everything into a power-on state so I'm
1301 not sure what "reset by MR" means or how it can happen.
1303 if (reset || init) {
1304 /* keep some BIOS settings when we... */
1305 old_beep = w83791d_read(client, W83791D_REG_BEEP_CONFIG);
1308 /* ... reset the chip and ... */
1309 w83791d_write(client, W83791D_REG_CONFIG, 0x80);
1312 /* ... disable power-on abnormal beep */
1313 w83791d_write(client, W83791D_REG_BEEP_CONFIG, old_beep | 0x80);
1315 /* disable the global beep (not done by hard reset) */
1316 tmp = w83791d_read(client, W83791D_REG_BEEP_CTRL[1]);
1317 w83791d_write(client, W83791D_REG_BEEP_CTRL[1], tmp & 0xef);
1320 /* Make sure monitoring is turned on for add-ons */
1321 tmp = w83791d_read(client, W83791D_REG_TEMP2_CONFIG);
1323 w83791d_write(client, W83791D_REG_TEMP2_CONFIG,
1327 tmp = w83791d_read(client, W83791D_REG_TEMP3_CONFIG);
1329 w83791d_write(client, W83791D_REG_TEMP3_CONFIG,
1333 /* Start monitoring */
1334 tmp = w83791d_read(client, W83791D_REG_CONFIG) & 0xf7;
1335 w83791d_write(client, W83791D_REG_CONFIG, tmp | 0x01);
1339 data->vrm = vid_which_vrm();
1342 static struct w83791d_data *w83791d_update_device(struct device *dev)
1344 struct i2c_client *client = to_i2c_client(dev);
1345 struct w83791d_data *data = i2c_get_clientdata(client);
1347 u8 reg_array_tmp[3];
1350 mutex_lock(&data->update_lock);
1352 if (time_after(jiffies, data->last_updated + (HZ * 3))
1354 dev_dbg(dev, "Starting w83791d device update\n");
1356 /* Update the voltages measured value and limits */
1357 for (i = 0; i < NUMBER_OF_VIN; i++) {
1358 data->in[i] = w83791d_read(client,
1360 data->in_max[i] = w83791d_read(client,
1361 W83791D_REG_IN_MAX[i]);
1362 data->in_min[i] = w83791d_read(client,
1363 W83791D_REG_IN_MIN[i]);
1366 /* Update the fan counts and limits */
1367 for (i = 0; i < NUMBER_OF_FANIN; i++) {
1368 /* Update the Fan measured value and limits */
1369 data->fan[i] = w83791d_read(client,
1370 W83791D_REG_FAN[i]);
1371 data->fan_min[i] = w83791d_read(client,
1372 W83791D_REG_FAN_MIN[i]);
1375 /* Update the fan divisor */
1376 for (i = 0; i < 3; i++) {
1377 reg_array_tmp[i] = w83791d_read(client,
1378 W83791D_REG_FAN_DIV[i]);
1380 data->fan_div[0] = (reg_array_tmp[0] >> 4) & 0x03;
1381 data->fan_div[1] = (reg_array_tmp[0] >> 6) & 0x03;
1382 data->fan_div[2] = (reg_array_tmp[1] >> 6) & 0x03;
1383 data->fan_div[3] = reg_array_tmp[2] & 0x07;
1384 data->fan_div[4] = (reg_array_tmp[2] >> 4) & 0x07;
1386 /* The fan divisor for fans 0-2 get bit 2 from
1387 bits 5-7 respectively of vbat register */
1388 vbat_reg = w83791d_read(client, W83791D_REG_VBAT);
1389 for (i = 0; i < 3; i++)
1390 data->fan_div[i] |= (vbat_reg >> (3 + i)) & 0x04;
1392 /* Update PWM duty cycle */
1393 for (i = 0; i < NUMBER_OF_PWM; i++) {
1394 data->pwm[i] = w83791d_read(client,
1395 W83791D_REG_PWM[i]);
1398 /* Update PWM enable status */
1399 for (i = 0; i < 2; i++) {
1400 reg_array_tmp[i] = w83791d_read(client,
1401 W83791D_REG_FAN_CFG[i]);
1403 data->pwm_enable[0] = (reg_array_tmp[0] >> 2) & 0x03;
1404 data->pwm_enable[1] = (reg_array_tmp[0] >> 4) & 0x03;
1405 data->pwm_enable[2] = (reg_array_tmp[1] >> 2) & 0x03;
1407 /* Update the first temperature sensor */
1408 for (i = 0; i < 3; i++) {
1409 data->temp1[i] = w83791d_read(client,
1410 W83791D_REG_TEMP1[i]);
1413 /* Update the rest of the temperature sensors */
1414 for (i = 0; i < 2; i++) {
1415 for (j = 0; j < 3; j++) {
1416 data->temp_add[i][j] =
1417 (w83791d_read(client,
1418 W83791D_REG_TEMP_ADD[i][j * 2]) << 8) |
1419 w83791d_read(client,
1420 W83791D_REG_TEMP_ADD[i][j * 2 + 1]);
1424 /* Update the realtime status */
1426 w83791d_read(client, W83791D_REG_ALARM1) +
1427 (w83791d_read(client, W83791D_REG_ALARM2) << 8) +
1428 (w83791d_read(client, W83791D_REG_ALARM3) << 16);
1430 /* Update the beep configuration information */
1432 w83791d_read(client, W83791D_REG_BEEP_CTRL[0]) +
1433 (w83791d_read(client, W83791D_REG_BEEP_CTRL[1]) << 8) +
1434 (w83791d_read(client, W83791D_REG_BEEP_CTRL[2]) << 16);
1436 /* Extract global beep enable flag */
1438 (data->beep_mask >> GLOBAL_BEEP_ENABLE_SHIFT) & 0x01;
1440 /* Update the cpu voltage information */
1441 i = w83791d_read(client, W83791D_REG_VID_FANDIV);
1442 data->vid = i & 0x0f;
1443 data->vid |= (w83791d_read(client, W83791D_REG_DID_VID4) & 0x01)
1446 data->last_updated = jiffies;
1450 mutex_unlock(&data->update_lock);
1453 w83791d_print_debug(data, dev);
1460 static void w83791d_print_debug(struct w83791d_data *data, struct device *dev)
1464 dev_dbg(dev, "======Start of w83791d debug values======\n");
1465 dev_dbg(dev, "%d set of Voltages: ===>\n", NUMBER_OF_VIN);
1466 for (i = 0; i < NUMBER_OF_VIN; i++) {
1467 dev_dbg(dev, "vin[%d] is: 0x%02x\n", i, data->in[i]);
1468 dev_dbg(dev, "vin[%d] min is: 0x%02x\n", i, data->in_min[i]);
1469 dev_dbg(dev, "vin[%d] max is: 0x%02x\n", i, data->in_max[i]);
1471 dev_dbg(dev, "%d set of Fan Counts/Divisors: ===>\n", NUMBER_OF_FANIN);
1472 for (i = 0; i < NUMBER_OF_FANIN; i++) {
1473 dev_dbg(dev, "fan[%d] is: 0x%02x\n", i, data->fan[i]);
1474 dev_dbg(dev, "fan[%d] min is: 0x%02x\n", i, data->fan_min[i]);
1475 dev_dbg(dev, "fan_div[%d] is: 0x%02x\n", i, data->fan_div[i]);
1478 /* temperature math is signed, but only print out the
1480 dev_dbg(dev, "%d set of Temperatures: ===>\n", NUMBER_OF_TEMPIN);
1481 for (i = 0; i < 3; i++) {
1482 dev_dbg(dev, "temp1[%d] is: 0x%02x\n", i, (u8) data->temp1[i]);
1484 for (i = 0; i < 2; i++) {
1485 for (j = 0; j < 3; j++) {
1486 dev_dbg(dev, "temp_add[%d][%d] is: 0x%04x\n", i, j,
1487 (u16) data->temp_add[i][j]);
1491 dev_dbg(dev, "Misc Information: ===>\n");
1492 dev_dbg(dev, "alarm is: 0x%08x\n", data->alarms);
1493 dev_dbg(dev, "beep_mask is: 0x%08x\n", data->beep_mask);
1494 dev_dbg(dev, "beep_enable is: %d\n", data->beep_enable);
1495 dev_dbg(dev, "vid is: 0x%02x\n", data->vid);
1496 dev_dbg(dev, "vrm is: 0x%02x\n", data->vrm);
1497 dev_dbg(dev, "=======End of w83791d debug values========\n");
1502 static int __init sensors_w83791d_init(void)
1504 return i2c_add_driver(&w83791d_driver);
1507 static void __exit sensors_w83791d_exit(void)
1509 i2c_del_driver(&w83791d_driver);
1512 MODULE_AUTHOR("Charles Spirakis <bezaur@gmail.com>");
1513 MODULE_DESCRIPTION("W83791D driver");
1514 MODULE_LICENSE("GPL");
1516 module_init(sensors_w83791d_init);
1517 module_exit(sensors_w83791d_exit);