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