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