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