projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
hwmon: (w83791d) add manual PWM support
[GitHub/mt8127/android_kernel_alcatel_ttab.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 */
290
9873964d
CS		 291 /* Misc */
292 u32 alarms; /* realtime status register encoding,combined */
293 u8 beep_enable; /* Global beep enable */
294 u32 beep_mask; /* Mask off specific beeps */
295 u8 vid; /* Register encoding, combined */
296 u8 vrm; /* hwmon-vid */
297};
298
cb0c1af3
JD		 299static int w83791d_probe(struct i2c_client *client,
300 const struct i2c_device_id *id);
301static int w83791d_detect(struct i2c_client *client, int kind,
302 struct i2c_board_info *info);
303static int w83791d_remove(struct i2c_client *client);
9873964d
CS		 304
305static int w83791d_read(struct i2c_client *client, u8 register);
306static int w83791d_write(struct i2c_client *client, u8 register, u8 value);
307static struct w83791d_data *w83791d_update_device(struct device *dev);
308
309#ifdef DEBUG
310static void w83791d_print_debug(struct w83791d_data *data, struct device *dev);
311#endif
312
313static void w83791d_init_client(struct i2c_client *client);
314
cb0c1af3
JD		 315static const struct i2c_device_id w83791d_id[] = {
316 { "w83791d", w83791d },
317 { }
318};
319MODULE_DEVICE_TABLE(i2c, w83791d_id);
320
9873964d 321static struct i2c_driver w83791d_driver = {
cb0c1af3 322 .class = I2C_CLASS_HWMON,
9873964d
CS		 323 .driver = {
324 .name = "w83791d",
325 },
cb0c1af3
JD		 326 .probe = w83791d_probe,
327 .remove = w83791d_remove,
328 .id_table = w83791d_id,
329 .detect = w83791d_detect,
330 .address_data = &addr_data,
9873964d
CS		 331};
332
333/* following are the sysfs callback functions */
334#define show_in_reg(reg) \
335static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
336 char *buf) \
337{ \
338 struct sensor_device_attribute *sensor_attr = \
339 to_sensor_dev_attr(attr); \
340 struct w83791d_data *data = w83791d_update_device(dev); \
341 int nr = sensor_attr->index; \
342 return sprintf(buf,"%d\n", IN_FROM_REG(data->reg[nr])); \
343}
344
345show_in_reg(in);
346show_in_reg(in_min);
347show_in_reg(in_max);
348
349#define store_in_reg(REG, reg) \
350static ssize_t store_in_##reg(struct device *dev, \
351 struct device_attribute *attr, \
352 const char *buf, size_t count) \
353{ \
354 struct sensor_device_attribute *sensor_attr = \
355 to_sensor_dev_attr(attr); \
356 struct i2c_client *client = to_i2c_client(dev); \
357 struct w83791d_data *data = i2c_get_clientdata(client); \
358 unsigned long val = simple_strtoul(buf, NULL, 10); \
359 int nr = sensor_attr->index; \
360 \
361 mutex_lock(&data->update_lock); \
362 data->in_##reg[nr] = IN_TO_REG(val); \
363 w83791d_write(client, W83791D_REG_IN_##REG[nr], data->in_##reg[nr]); \
364 mutex_unlock(&data->update_lock); \
365 \
366 return count; \
367}
368store_in_reg(MIN, min);
369store_in_reg(MAX, max);
370
371static struct sensor_device_attribute sda_in_input[] = {
372 SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
373 SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
374 SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
375 SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
376 SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
377 SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
378 SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
379 SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
380 SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
381 SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
382};
383
384static struct sensor_device_attribute sda_in_min[] = {
385 SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
386 SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
387 SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
388 SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
389 SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
390 SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
391 SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
392 SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
393 SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
394 SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
395};
396
397static struct sensor_device_attribute sda_in_max[] = {
398 SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
399 SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
400 SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
401 SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
402 SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
403 SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
404 SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
405 SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
406 SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
407 SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
408};
409
64383123
CS		 410
411static ssize_t show_beep(struct device *dev, struct device_attribute *attr,
412 char *buf)
413{
414 struct sensor_device_attribute *sensor_attr =
415 to_sensor_dev_attr(attr);
416 struct w83791d_data *data = w83791d_update_device(dev);
417 int bitnr = sensor_attr->index;
418
419 return sprintf(buf, "%d\n", (data->beep_mask >> bitnr) & 1);
420}
421
422static ssize_t store_beep(struct device *dev, struct device_attribute *attr,
423 const char *buf, size_t count)
424{
425 struct sensor_device_attribute *sensor_attr =
426 to_sensor_dev_attr(attr);
427 struct i2c_client *client = to_i2c_client(dev);
428 struct w83791d_data *data = i2c_get_clientdata(client);
429 int bitnr = sensor_attr->index;
430 int bytenr = bitnr / 8;
431 long val = simple_strtol(buf, NULL, 10) ? 1 : 0;
432
433 mutex_lock(&data->update_lock);
434
435 data->beep_mask &= ~(0xff << (bytenr * 8));
436 data->beep_mask |= w83791d_read(client, W83791D_REG_BEEP_CTRL[bytenr])
437 << (bytenr * 8);
438
439 data->beep_mask &= ~(1 << bitnr);
440 data->beep_mask |= val << bitnr;
441
442 w83791d_write(client, W83791D_REG_BEEP_CTRL[bytenr],
443 (data->beep_mask >> (bytenr * 8)) & 0xff);
444
445 mutex_unlock(&data->update_lock);
446
447 return count;
448}
449
450static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
451 char *buf)
452{
453 struct sensor_device_attribute *sensor_attr =
454 to_sensor_dev_attr(attr);
455 struct w83791d_data *data = w83791d_update_device(dev);
456 int bitnr = sensor_attr->index;
457
458 return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
459}
460
461/* Note: The bitmask for the beep enable/disable is different than
462 the bitmask for the alarm. */
463static struct sensor_device_attribute sda_in_beep[] = {
464 SENSOR_ATTR(in0_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 0),
465 SENSOR_ATTR(in1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 13),
466 SENSOR_ATTR(in2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 2),
467 SENSOR_ATTR(in3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 3),
468 SENSOR_ATTR(in4_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 8),
469 SENSOR_ATTR(in5_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 9),
470 SENSOR_ATTR(in6_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 10),
471 SENSOR_ATTR(in7_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 16),
472 SENSOR_ATTR(in8_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 17),
473 SENSOR_ATTR(in9_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 14),
474};
475
476static struct sensor_device_attribute sda_in_alarm[] = {
477 SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0),
478 SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1),
479 SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2),
480 SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3),
481 SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8),
482 SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9),
483 SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10),
484 SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 19),
485 SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 20),
486 SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 14),
487};
488
9873964d
CS		 489#define show_fan_reg(reg) \
490static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
491 char *buf) \
492{ \
493 struct sensor_device_attribute *sensor_attr = \
494 to_sensor_dev_attr(attr); \
495 struct w83791d_data *data = w83791d_update_device(dev); \
496 int nr = sensor_attr->index; \
497 return sprintf(buf,"%d\n", \
498 FAN_FROM_REG(data->reg[nr], DIV_FROM_REG(data->fan_div[nr]))); \
499}
500
501show_fan_reg(fan);
502show_fan_reg(fan_min);
503
504static ssize_t store_fan_min(struct device *dev, struct device_attribute *attr,
505 const char *buf, size_t count)
506{
507 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
508 struct i2c_client *client = to_i2c_client(dev);
509 struct w83791d_data *data = i2c_get_clientdata(client);
510 unsigned long val = simple_strtoul(buf, NULL, 10);
511 int nr = sensor_attr->index;
512
513 mutex_lock(&data->update_lock);
514 data->fan_min[nr] = fan_to_reg(val, DIV_FROM_REG(data->fan_div[nr]));
515 w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
516 mutex_unlock(&data->update_lock);
517
518 return count;
519}
520
521static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
522 char *buf)
523{
524 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
525 int nr = sensor_attr->index;
526 struct w83791d_data *data = w83791d_update_device(dev);
527 return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr]));
528}
529
530/* Note: we save and restore the fan minimum here, because its value is
531 determined in part by the fan divisor. This follows the principle of
532 least suprise; the user doesn't expect the fan minimum to change just
533 because the divisor changed. */
534static ssize_t store_fan_div(struct device *dev, struct device_attribute *attr,
535 const char *buf, size_t count)
536{
537 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
538 struct i2c_client *client = to_i2c_client(dev);
539 struct w83791d_data *data = i2c_get_clientdata(client);
540 int nr = sensor_attr->index;
541 unsigned long min;
542 u8 tmp_fan_div;
543 u8 fan_div_reg;
ad02ad85 544 u8 vbat_reg;
9873964d
CS		 545 int indx = 0;
546 u8 keep_mask = 0;
547 u8 new_shift = 0;
548
549 /* Save fan_min */
550 min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
551
552 mutex_lock(&data->update_lock);
553 data->fan_div[nr] = div_to_reg(nr, simple_strtoul(buf, NULL, 10));
554
555 switch (nr) {
556 case 0:
557 indx = 0;
558 keep_mask = 0xcf;
559 new_shift = 4;
560 break;
561 case 1:
562 indx = 0;
563 keep_mask = 0x3f;
564 new_shift = 6;
565 break;
566 case 2:
567 indx = 1;
568 keep_mask = 0x3f;
569 new_shift = 6;
570 break;
571 case 3:
572 indx = 2;
573 keep_mask = 0xf8;
574 new_shift = 0;
575 break;
576 case 4:
577 indx = 2;
578 keep_mask = 0x8f;
579 new_shift = 4;
580 break;
581#ifdef DEBUG
582 default:
583 dev_warn(dev, "store_fan_div: Unexpected nr seen: %d\n", nr);
584 count = -EINVAL;
585 goto err_exit;
586#endif
587 }
588
589 fan_div_reg = w83791d_read(client, W83791D_REG_FAN_DIV[indx])
590 & keep_mask;
591 tmp_fan_div = (data->fan_div[nr] << new_shift) & ~keep_mask;
592
593 w83791d_write(client, W83791D_REG_FAN_DIV[indx],
594 fan_div_reg | tmp_fan_div);
595
ad02ad85
MH		 596 /* Bit 2 of fans 0-2 is stored in the vbat register (bits 5-7) */
597 if (nr < 3) {
598 keep_mask = ~(1 << (nr + 5));
599 vbat_reg = w83791d_read(client, W83791D_REG_VBAT)
600 & keep_mask;
601 tmp_fan_div = (data->fan_div[nr] << (3 + nr)) & ~keep_mask;
602 w83791d_write(client, W83791D_REG_VBAT,
603 vbat_reg | tmp_fan_div);
604 }
605
9873964d
CS		 606 /* Restore fan_min */
607 data->fan_min[nr] = fan_to_reg(min, DIV_FROM_REG(data->fan_div[nr]));
608 w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
609
610#ifdef DEBUG
611err_exit:
612#endif
613 mutex_unlock(&data->update_lock);
614
615 return count;
616}
617
618static struct sensor_device_attribute sda_fan_input[] = {
619 SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
620 SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
621 SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
622 SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
623 SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
624};
625
626static struct sensor_device_attribute sda_fan_min[] = {
627 SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO,
628 show_fan_min, store_fan_min, 0),
629 SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO,
630 show_fan_min, store_fan_min, 1),
631 SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO,
632 show_fan_min, store_fan_min, 2),
633 SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO,
634 show_fan_min, store_fan_min, 3),
635 SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO,
636 show_fan_min, store_fan_min, 4),
637};
638
639static struct sensor_device_attribute sda_fan_div[] = {
640 SENSOR_ATTR(fan1_div, S_IWUSR | S_IRUGO,
641 show_fan_div, store_fan_div, 0),
642 SENSOR_ATTR(fan2_div, S_IWUSR | S_IRUGO,
643 show_fan_div, store_fan_div, 1),
644 SENSOR_ATTR(fan3_div, S_IWUSR | S_IRUGO,
645 show_fan_div, store_fan_div, 2),
646 SENSOR_ATTR(fan4_div, S_IWUSR | S_IRUGO,
647 show_fan_div, store_fan_div, 3),
648 SENSOR_ATTR(fan5_div, S_IWUSR | S_IRUGO,
649 show_fan_div, store_fan_div, 4),
650};
651
64383123
CS		 652static struct sensor_device_attribute sda_fan_beep[] = {
653 SENSOR_ATTR(fan1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 6),
654 SENSOR_ATTR(fan2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 7),
655 SENSOR_ATTR(fan3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 11),
656 SENSOR_ATTR(fan4_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 21),
657 SENSOR_ATTR(fan5_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 22),
658};
659
660static struct sensor_device_attribute sda_fan_alarm[] = {
661 SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
662 SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
663 SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
664 SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 21),
665 SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 22),
666};
667
6495ce18
MH		 668/* read/write PWMs */
669static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
670 char *buf)
671{
672 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
673 int nr = sensor_attr->index;
674 struct w83791d_data *data = w83791d_update_device(dev);
675 return sprintf(buf, "%u\n", data->pwm[nr]);
676}
677
678static ssize_t store_pwm(struct device *dev, struct device_attribute *attr,
679 const char *buf, size_t count)
680{
681 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
682 struct i2c_client *client = to_i2c_client(dev);
683 struct w83791d_data *data = i2c_get_clientdata(client);
684 int nr = sensor_attr->index;
685 unsigned long val;
686
687 if (strict_strtoul(buf, 10, &val))
688 return -EINVAL;
689
690 mutex_lock(&data->update_lock);
691 data->pwm[nr] = SENSORS_LIMIT(val, 0, 255);
692 w83791d_write(client, W83791D_REG_PWM[nr], data->pwm[nr]);
693 mutex_unlock(&data->update_lock);
694 return count;
695}
696
697static struct sensor_device_attribute sda_pwm[] = {
698 SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO,
699 show_pwm, store_pwm, 0),
700 SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO,
701 show_pwm, store_pwm, 1),
702 SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO,
703 show_pwm, store_pwm, 2),
704 SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO,
705 show_pwm, store_pwm, 3),
706 SENSOR_ATTR(pwm5, S_IWUSR | S_IRUGO,
707 show_pwm, store_pwm, 4),
708};
709
9873964d
CS		 710/* read/write the temperature1, includes measured value and limits */
711static ssize_t show_temp1(struct device *dev, struct device_attribute *devattr,
712 char *buf)
713{
714 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
715 struct w83791d_data *data = w83791d_update_device(dev);
716 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp1[attr->index]));
717}
718
719static ssize_t store_temp1(struct device *dev, struct device_attribute *devattr,
720 const char *buf, size_t count)
721{
722 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
723 struct i2c_client *client = to_i2c_client(dev);
724 struct w83791d_data *data = i2c_get_clientdata(client);
725 long val = simple_strtol(buf, NULL, 10);
726 int nr = attr->index;
727
728 mutex_lock(&data->update_lock);
729 data->temp1[nr] = TEMP1_TO_REG(val);
730 w83791d_write(client, W83791D_REG_TEMP1[nr], data->temp1[nr]);
731 mutex_unlock(&data->update_lock);
732 return count;
733}
734
735/* read/write temperature2-3, includes measured value and limits */
736static ssize_t show_temp23(struct device *dev, struct device_attribute *devattr,
737 char *buf)
738{
739 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
740 struct w83791d_data *data = w83791d_update_device(dev);
741 int nr = attr->nr;
742 int index = attr->index;
743 return sprintf(buf, "%d\n", TEMP23_FROM_REG(data->temp_add[nr][index]));
744}
745
746static ssize_t store_temp23(struct device *dev,
747 struct device_attribute *devattr,
748 const char *buf, size_t count)
749{
750 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
751 struct i2c_client *client = to_i2c_client(dev);
752 struct w83791d_data *data = i2c_get_clientdata(client);
753 long val = simple_strtol(buf, NULL, 10);
754 int nr = attr->nr;
755 int index = attr->index;
756
757 mutex_lock(&data->update_lock);
758 data->temp_add[nr][index] = TEMP23_TO_REG(val);
759 w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2],
760 data->temp_add[nr][index] >> 8);
761 w83791d_write(client, W83791D_REG_TEMP_ADD[nr][index * 2 + 1],
762 data->temp_add[nr][index] & 0x80);
763 mutex_unlock(&data->update_lock);
764
765 return count;
766}
767
768static struct sensor_device_attribute_2 sda_temp_input[] = {
769 SENSOR_ATTR_2(temp1_input, S_IRUGO, show_temp1, NULL, 0, 0),
770 SENSOR_ATTR_2(temp2_input, S_IRUGO, show_temp23, NULL, 0, 0),
771 SENSOR_ATTR_2(temp3_input, S_IRUGO, show_temp23, NULL, 1, 0),
772};
773
774static struct sensor_device_attribute_2 sda_temp_max[] = {
775 SENSOR_ATTR_2(temp1_max, S_IRUGO | S_IWUSR,
776 show_temp1, store_temp1, 0, 1),
777 SENSOR_ATTR_2(temp2_max, S_IRUGO | S_IWUSR,
778 show_temp23, store_temp23, 0, 1),
779 SENSOR_ATTR_2(temp3_max, S_IRUGO | S_IWUSR,
780 show_temp23, store_temp23, 1, 1),
781};
782
783static struct sensor_device_attribute_2 sda_temp_max_hyst[] = {
784 SENSOR_ATTR_2(temp1_max_hyst, S_IRUGO | S_IWUSR,
785 show_temp1, store_temp1, 0, 2),
786 SENSOR_ATTR_2(temp2_max_hyst, S_IRUGO | S_IWUSR,
787 show_temp23, store_temp23, 0, 2),
788 SENSOR_ATTR_2(temp3_max_hyst, S_IRUGO | S_IWUSR,
789 show_temp23, store_temp23, 1, 2),
790};
791
64383123
CS		 792/* Note: The bitmask for the beep enable/disable is different than
793 the bitmask for the alarm. */
794static struct sensor_device_attribute sda_temp_beep[] = {
795 SENSOR_ATTR(temp1_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 4),
796 SENSOR_ATTR(temp2_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 5),
797 SENSOR_ATTR(temp3_beep, S_IWUSR | S_IRUGO, show_beep, store_beep, 1),
798};
799
800static struct sensor_device_attribute sda_temp_alarm[] = {
801 SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
802 SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
803 SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
804};
9873964d
CS		 805
806/* get reatime status of all sensors items: voltage, temp, fan */
807static ssize_t show_alarms_reg(struct device *dev,
808 struct device_attribute *attr, char *buf)
809{
810 struct w83791d_data *data = w83791d_update_device(dev);
811 return sprintf(buf, "%u\n", data->alarms);
812}
813
814static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
815
816/* Beep control */
817
818#define GLOBAL_BEEP_ENABLE_SHIFT 15
819#define GLOBAL_BEEP_ENABLE_MASK (1 << GLOBAL_BEEP_ENABLE_SHIFT)
820
821static ssize_t show_beep_enable(struct device *dev,
822 struct device_attribute *attr, char *buf)
823{
824 struct w83791d_data *data = w83791d_update_device(dev);
825 return sprintf(buf, "%d\n", data->beep_enable);
826}
827
828static ssize_t show_beep_mask(struct device *dev,
829 struct device_attribute *attr, char *buf)
830{
831 struct w83791d_data *data = w83791d_update_device(dev);
832 return sprintf(buf, "%d\n", BEEP_MASK_FROM_REG(data->beep_mask));
833}
834
835
836static ssize_t store_beep_mask(struct device *dev,
837 struct device_attribute *attr,
838 const char *buf, size_t count)
839{
840 struct i2c_client *client = to_i2c_client(dev);
841 struct w83791d_data *data = i2c_get_clientdata(client);
842 long val = simple_strtol(buf, NULL, 10);
843 int i;
844
845 mutex_lock(&data->update_lock);
846
847 /* The beep_enable state overrides any enabling request from
848 the masks */
849 data->beep_mask = BEEP_MASK_TO_REG(val) & ~GLOBAL_BEEP_ENABLE_MASK;
850 data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT);
851
852 val = data->beep_mask;
853
854 for (i = 0; i < 3; i++) {
855 w83791d_write(client, W83791D_REG_BEEP_CTRL[i], (val & 0xff));
856 val >>= 8;
857 }
858
859 mutex_unlock(&data->update_lock);
860
861 return count;
862}
863
864static ssize_t store_beep_enable(struct device *dev,
865 struct device_attribute *attr,
866 const char *buf, size_t count)
867{
868 struct i2c_client *client = to_i2c_client(dev);
869 struct w83791d_data *data = i2c_get_clientdata(client);
870 long val = simple_strtol(buf, NULL, 10);
871
872 mutex_lock(&data->update_lock);
873
874 data->beep_enable = val ? 1 : 0;
875
876 /* Keep the full mask value in sync with the current enable */
877 data->beep_mask &= ~GLOBAL_BEEP_ENABLE_MASK;
878 data->beep_mask |= (data->beep_enable << GLOBAL_BEEP_ENABLE_SHIFT);
879
880 /* The global control is in the second beep control register
881 so only need to update that register */
882 val = (data->beep_mask >> 8) & 0xff;
883
884 w83791d_write(client, W83791D_REG_BEEP_CTRL[1], val);
885
886 mutex_unlock(&data->update_lock);
887
888 return count;
889}
890
891static struct sensor_device_attribute sda_beep_ctrl[] = {
892 SENSOR_ATTR(beep_enable, S_IRUGO | S_IWUSR,
893 show_beep_enable, store_beep_enable, 0),
894 SENSOR_ATTR(beep_mask, S_IRUGO | S_IWUSR,
895 show_beep_mask, store_beep_mask, 1)
896};
897
898/* cpu voltage regulation information */
899static ssize_t show_vid_reg(struct device *dev,
900 struct device_attribute *attr, char *buf)
901{
902 struct w83791d_data *data = w83791d_update_device(dev);
903 return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
904}
905
906static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
907
908static ssize_t show_vrm_reg(struct device *dev,
909 struct device_attribute *attr, char *buf)
910{
90d6619a 911 struct w83791d_data *data = dev_get_drvdata(dev);
9873964d
CS		 912 return sprintf(buf, "%d\n", data->vrm);
913}
914
915static ssize_t store_vrm_reg(struct device *dev,
916 struct device_attribute *attr,
917 const char *buf, size_t count)
918{
8f74efe8 919 struct w83791d_data *data = dev_get_drvdata(dev);
9873964d
CS		 920
921 /* No lock needed as vrm is internal to the driver
922 (not read from a chip register) and so is not
923 updated in w83791d_update_device() */
8f74efe8 924 data->vrm = simple_strtoul(buf, NULL, 10);
9873964d
CS		 925
926 return count;
927}
928
929static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
930
34fc921a
JC		 931#define IN_UNIT_ATTRS(X) \
932 &sda_in_input[X].dev_attr.attr, \
933 &sda_in_min[X].dev_attr.attr, \
64383123
CS		 934 &sda_in_max[X].dev_attr.attr, \
935 &sda_in_beep[X].dev_attr.attr, \
936 &sda_in_alarm[X].dev_attr.attr
34fc921a
JC		 937
938#define FAN_UNIT_ATTRS(X) \
939 &sda_fan_input[X].dev_attr.attr, \
940 &sda_fan_min[X].dev_attr.attr, \
64383123
CS		 941 &sda_fan_div[X].dev_attr.attr, \
942 &sda_fan_beep[X].dev_attr.attr, \
943 &sda_fan_alarm[X].dev_attr.attr
34fc921a
JC		 944
945#define TEMP_UNIT_ATTRS(X) \
946 &sda_temp_input[X].dev_attr.attr, \
947 &sda_temp_max[X].dev_attr.attr, \
64383123
CS		 948 &sda_temp_max_hyst[X].dev_attr.attr, \
949 &sda_temp_beep[X].dev_attr.attr, \
950 &sda_temp_alarm[X].dev_attr.attr
34fc921a
JC		 951
952static struct attribute *w83791d_attributes[] = {
953 IN_UNIT_ATTRS(0),
954 IN_UNIT_ATTRS(1),
955 IN_UNIT_ATTRS(2),
956 IN_UNIT_ATTRS(3),
957 IN_UNIT_ATTRS(4),
958 IN_UNIT_ATTRS(5),
959 IN_UNIT_ATTRS(6),
960 IN_UNIT_ATTRS(7),
961 IN_UNIT_ATTRS(8),
962 IN_UNIT_ATTRS(9),
963 FAN_UNIT_ATTRS(0),
964 FAN_UNIT_ATTRS(1),
965 FAN_UNIT_ATTRS(2),
34fc921a
JC		 966 TEMP_UNIT_ATTRS(0),
967 TEMP_UNIT_ATTRS(1),
968 TEMP_UNIT_ATTRS(2),
969 &dev_attr_alarms.attr,
970 &sda_beep_ctrl[0].dev_attr.attr,
971 &sda_beep_ctrl[1].dev_attr.attr,
972 &dev_attr_cpu0_vid.attr,
973 &dev_attr_vrm.attr,
6495ce18
MH		 974 &sda_pwm[0].dev_attr.attr,
975 &sda_pwm[1].dev_attr.attr,
976 &sda_pwm[2].dev_attr.attr,
34fc921a
JC		 977 NULL
978};
979
980static const struct attribute_group w83791d_group = {
981 .attrs = w83791d_attributes,
982};
983
6e1ecd9b
MH		 984/* Separate group of attributes for fan/pwm 4-5. Their pins can also be
985 in use for GPIO in which case their sysfs-interface should not be made
986 available */
987static struct attribute *w83791d_attributes_fanpwm45[] = {
988 FAN_UNIT_ATTRS(3),
989 FAN_UNIT_ATTRS(4),
6495ce18
MH		 990 &sda_pwm[3].dev_attr.attr,
991 &sda_pwm[4].dev_attr.attr,
6e1ecd9b
MH		 992 NULL
993};
994
995static const struct attribute_group w83791d_group_fanpwm45 = {
996 .attrs = w83791d_attributes_fanpwm45,
997};
9873964d 998
cb0c1af3 999static int w83791d_detect_subclients(struct i2c_client *client)
9873964d 1000{
cb0c1af3 1001 struct i2c_adapter *adapter = client->adapter;
9873964d 1002 struct w83791d_data *data = i2c_get_clientdata(client);
cb0c1af3 1003 int address = client->addr;
9873964d
CS		 1004 int i, id, err;
1005 u8 val;
1006
1007 id = i2c_adapter_id(adapter);
1008 if (force_subclients[0] == id && force_subclients[1] == address) {
1009 for (i = 2; i <= 3; i++) {
1010 if (force_subclients[i] < 0x48 ||
1011 force_subclients[i] > 0x4f) {
1012 dev_err(&client->dev,
1013 "invalid subclient "
1014 "address %d; must be 0x48-0x4f\n",
1015 force_subclients[i]);
1016 err = -ENODEV;
1017 goto error_sc_0;
1018 }
1019 }
1020 w83791d_write(client, W83791D_REG_I2C_SUBADDR,
1021 (force_subclients[2] & 0x07) |
1022 ((force_subclients[3] & 0x07) << 4));
1023 }
1024
1025 val = w83791d_read(client, W83791D_REG_I2C_SUBADDR);
1026 if (!(val & 0x08)) {
cb0c1af3 1027 data->lm75[0] = i2c_new_dummy(adapter, 0x48 + (val & 0x7));
9873964d
CS		 1028 }
1029 if (!(val & 0x80)) {
1030 if ((data->lm75[0] != NULL) &&
1031 ((val & 0x7) == ((val >> 4) & 0x7))) {
1032 dev_err(&client->dev,
1033 "duplicate addresses 0x%x, "
1034 "use force_subclient\n",
1035 data->lm75[0]->addr);
1036 err = -ENODEV;
1037 goto error_sc_1;
1038 }
cb0c1af3
JD		 1039 data->lm75[1] = i2c_new_dummy(adapter,
1040 0x48 + ((val >> 4) & 0x7));
9873964d
CS		 1041 }
1042
1043 return 0;
1044
1045/* Undo inits in case of errors */
1046
1047error_sc_1:
cb0c1af3
JD		 1048 if (data->lm75[0] != NULL)
1049 i2c_unregister_device(data->lm75[0]);
9873964d
CS		 1050error_sc_0:
1051 return err;
1052}
1053
1054
cb0c1af3
JD		 1055/* Return 0 if detection is successful, -ENODEV otherwise */
1056static int w83791d_detect(struct i2c_client *client, int kind,
1057 struct i2c_board_info *info)
9873964d 1058{
cb0c1af3
JD		 1059 struct i2c_adapter *adapter = client->adapter;
1060 int val1, val2;
1061 unsigned short address = client->addr;
9873964d
CS		 1062
1063 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
cb0c1af3 1064 return -ENODEV;
9873964d
CS		 1065 }
1066
9873964d
CS		 1067 /* The w83791d may be stuck in some other bank than bank 0. This may
1068 make reading other information impossible. Specify a force=...
1069 parameter, and the Winbond will be reset to the right bank. */
1070 if (kind < 0) {
1071 if (w83791d_read(client, W83791D_REG_CONFIG) & 0x80) {
cb0c1af3 1072 return -ENODEV;
9873964d
CS		 1073 }
1074 val1 = w83791d_read(client, W83791D_REG_BANK);
1075 val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
1076 /* Check for Winbond ID if in bank 0 */
1077 if (!(val1 & 0x07)) {
1078 /* yes it is Bank0 */
1079 if (((!(val1 & 0x80)) && (val2 != 0xa3)) ||
1080 ((val1 & 0x80) && (val2 != 0x5c))) {
cb0c1af3 1081 return -ENODEV;
9873964d
CS		 1082 }
1083 }
1084 /* If Winbond chip, address of chip and W83791D_REG_I2C_ADDR
1085 should match */
1086 if (w83791d_read(client, W83791D_REG_I2C_ADDR) != address) {
cb0c1af3 1087 return -ENODEV;
9873964d
CS		 1088 }
1089 }
1090
1091 /* We either have a force parameter or we have reason to
1092 believe it is a Winbond chip. Either way, we want bank 0 and
1093 Vendor ID high byte */
1094 val1 = w83791d_read(client, W83791D_REG_BANK) & 0x78;
1095 w83791d_write(client, W83791D_REG_BANK, val1 | 0x80);
1096
1097 /* Verify it is a Winbond w83791d */
1098 if (kind <= 0) {
1099 /* get vendor ID */
1100 val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
1101 if (val2 != 0x5c) { /* the vendor is NOT Winbond */
cb0c1af3 1102 return -ENODEV;
9873964d
CS		 1103 }
1104 val1 = w83791d_read(client, W83791D_REG_WCHIPID);
1105 if (val1 == 0x71) {
1106 kind = w83791d;
1107 } else {
1108 if (kind == 0)
cb0c1af3 1109 dev_warn(&adapter->dev,
9873964d
CS		 1110 "w83791d: Ignoring 'force' parameter "
1111 "for unknown chip at adapter %d, "
1112 "address 0x%02x\n",
1113 i2c_adapter_id(adapter), address);
cb0c1af3 1114 return -ENODEV;
9873964d
CS		 1115 }
1116 }
1117
cb0c1af3
JD		 1118 strlcpy(info->type, "w83791d", I2C_NAME_SIZE);
1119
1120 return 0;
1121}
1122
1123static int w83791d_probe(struct i2c_client *client,
1124 const struct i2c_device_id *id)
1125{
1126 struct w83791d_data *data;
1127 struct device *dev = &client->dev;
16a515fd 1128 int i, err;
6e1ecd9b 1129 u8 has_fanpwm45;
9873964d
CS		 1130
1131#ifdef DEBUG
16a515fd 1132 int val1;
9873964d
CS		 1133 val1 = w83791d_read(client, W83791D_REG_DID_VID4);
1134 dev_dbg(dev, "Device ID version: %d.%d (0x%02x)\n",
1135 (val1 >> 5) & 0x07, (val1 >> 1) & 0x0f, val1);
1136#endif
1137
cb0c1af3
JD		 1138 data = kzalloc(sizeof(struct w83791d_data), GFP_KERNEL);
1139 if (!data) {
1140 err = -ENOMEM;
1141 goto error0;
1142 }
9873964d 1143
cb0c1af3
JD		 1144 i2c_set_clientdata(client, data);
1145 mutex_init(&data->update_lock);
9873964d 1146
cb0c1af3
JD		 1147 err = w83791d_detect_subclients(client);
1148 if (err)
1149 goto error1;
9873964d
CS		 1150
1151 /* Initialize the chip */
1152 w83791d_init_client(client);
1153
1154 /* If the fan_div is changed, make sure there is a rational
1155 fan_min in place */
1156 for (i = 0; i < NUMBER_OF_FANIN; i++) {
1157 data->fan_min[i] = w83791d_read(client, W83791D_REG_FAN_MIN[i]);
1158 }
1159
1160 /* Register sysfs hooks */
34fc921a
JC		 1161 if ((err = sysfs_create_group(&client->dev.kobj, &w83791d_group)))
1162 goto error3;
1163
6e1ecd9b
MH		 1164 /* Check if pins of fan/pwm 4-5 are in use as GPIO */
1165 has_fanpwm45 = w83791d_read(client, W83791D_REG_GPIO) & 0x10;
1166 if (has_fanpwm45) {
1167 err = sysfs_create_group(&client->dev.kobj,
1168 &w83791d_group_fanpwm45);
1169 if (err)
1170 goto error4;
1171 }
1172
34fc921a 1173 /* Everything is ready, now register the working device */
1beeffe4
TJ		 1174 data->hwmon_dev = hwmon_device_register(dev);
1175 if (IS_ERR(data->hwmon_dev)) {
1176 err = PTR_ERR(data->hwmon_dev);
6e1ecd9b 1177 goto error5;
9873964d
CS		 1178 }
1179
9873964d
CS		 1180 return 0;
1181
6e1ecd9b
MH		 1182error5:
1183 if (has_fanpwm45)
1184 sysfs_remove_group(&client->dev.kobj, &w83791d_group_fanpwm45);
34fc921a
JC		 1185error4:
1186 sysfs_remove_group(&client->dev.kobj, &w83791d_group);
9873964d 1187error3:
cb0c1af3
JD		 1188 if (data->lm75[0] != NULL)
1189 i2c_unregister_device(data->lm75[0]);
1190 if (data->lm75[1] != NULL)
1191 i2c_unregister_device(data->lm75[1]);
9873964d
CS		 1192error1:
1193 kfree(data);
1194error0:
1195 return err;
1196}
1197
cb0c1af3 1198static int w83791d_remove(struct i2c_client *client)
9873964d
CS		 1199{
1200 struct w83791d_data *data = i2c_get_clientdata(client);
9873964d 1201
cb0c1af3
JD		 1202 hwmon_device_unregister(data->hwmon_dev);
1203 sysfs_remove_group(&client->dev.kobj, &w83791d_group);
9873964d 1204
cb0c1af3
JD		 1205 if (data->lm75[0] != NULL)
1206 i2c_unregister_device(data->lm75[0]);
1207 if (data->lm75[1] != NULL)
1208 i2c_unregister_device(data->lm75[1]);
9873964d 1209
cb0c1af3 1210 kfree(data);
9873964d
CS		 1211 return 0;
1212}
1213
1214static void w83791d_init_client(struct i2c_client *client)
1215{
1216 struct w83791d_data *data = i2c_get_clientdata(client);
1217 u8 tmp;
1218 u8 old_beep;
1219
1220 /* The difference between reset and init is that reset
1221 does a hard reset of the chip via index 0x40, bit 7,
1222 but init simply forces certain registers to have "sane"
1223 values. The hope is that the BIOS has done the right
1224 thing (which is why the default is reset=0, init=0),
1225 but if not, reset is the hard hammer and init
1226 is the soft mallet both of which are trying to whack
1227 things into place...
1228 NOTE: The data sheet makes a distinction between
1229 "power on defaults" and "reset by MR". As far as I can tell,
1230 the hard reset puts everything into a power-on state so I'm
1231 not sure what "reset by MR" means or how it can happen.
1232 */
1233 if (reset || init) {
1234 /* keep some BIOS settings when we... */
1235 old_beep = w83791d_read(client, W83791D_REG_BEEP_CONFIG);
1236
1237 if (reset) {
1238 /* ... reset the chip and ... */
1239 w83791d_write(client, W83791D_REG_CONFIG, 0x80);
1240 }
1241
1242 /* ... disable power-on abnormal beep */
1243 w83791d_write(client, W83791D_REG_BEEP_CONFIG, old_beep | 0x80);
1244
1245 /* disable the global beep (not done by hard reset) */
1246 tmp = w83791d_read(client, W83791D_REG_BEEP_CTRL[1]);
1247 w83791d_write(client, W83791D_REG_BEEP_CTRL[1], tmp & 0xef);
1248
1249 if (init) {
1250 /* Make sure monitoring is turned on for add-ons */
1251 tmp = w83791d_read(client, W83791D_REG_TEMP2_CONFIG);
1252 if (tmp & 1) {
1253 w83791d_write(client, W83791D_REG_TEMP2_CONFIG,
1254 tmp & 0xfe);
1255 }
1256
1257 tmp = w83791d_read(client, W83791D_REG_TEMP3_CONFIG);
1258 if (tmp & 1) {
1259 w83791d_write(client, W83791D_REG_TEMP3_CONFIG,
1260 tmp & 0xfe);
1261 }
1262
1263 /* Start monitoring */
1264 tmp = w83791d_read(client, W83791D_REG_CONFIG) & 0xf7;
1265 w83791d_write(client, W83791D_REG_CONFIG, tmp | 0x01);
1266 }
1267 }
1268
1269 data->vrm = vid_which_vrm();
1270}
1271
1272static struct w83791d_data *w83791d_update_device(struct device *dev)
1273{
1274 struct i2c_client *client = to_i2c_client(dev);
1275 struct w83791d_data *data = i2c_get_clientdata(client);
1276 int i, j;
1277 u8 reg_array_tmp[3];
ad02ad85 1278 u8 vbat_reg;
9873964d
CS		 1279
1280 mutex_lock(&data->update_lock);
1281
1282 if (time_after(jiffies, data->last_updated + (HZ * 3))
1283 || !data->valid) {
1284 dev_dbg(dev, "Starting w83791d device update\n");
1285
1286 /* Update the voltages measured value and limits */
1287 for (i = 0; i < NUMBER_OF_VIN; i++) {
1288 data->in[i] = w83791d_read(client,
1289 W83791D_REG_IN[i]);
1290 data->in_max[i] = w83791d_read(client,
1291 W83791D_REG_IN_MAX[i]);
1292 data->in_min[i] = w83791d_read(client,
1293 W83791D_REG_IN_MIN[i]);
1294 }
1295
1296 /* Update the fan counts and limits */
1297 for (i = 0; i < NUMBER_OF_FANIN; i++) {
1298 /* Update the Fan measured value and limits */
1299 data->fan[i] = w83791d_read(client,
1300 W83791D_REG_FAN[i]);
1301 data->fan_min[i] = w83791d_read(client,
1302 W83791D_REG_FAN_MIN[i]);
1303 }
1304
1305 /* Update the fan divisor */
1306 for (i = 0; i < 3; i++) {
1307 reg_array_tmp[i] = w83791d_read(client,
1308 W83791D_REG_FAN_DIV[i]);
1309 }
1310 data->fan_div[0] = (reg_array_tmp[0] >> 4) & 0x03;
1311 data->fan_div[1] = (reg_array_tmp[0] >> 6) & 0x03;
1312 data->fan_div[2] = (reg_array_tmp[1] >> 6) & 0x03;
1313 data->fan_div[3] = reg_array_tmp[2] & 0x07;
1314 data->fan_div[4] = (reg_array_tmp[2] >> 4) & 0x07;
1315
ad02ad85
MH		 1316 /* The fan divisor for fans 0-2 get bit 2 from
1317 bits 5-7 respectively of vbat register */
1318 vbat_reg = w83791d_read(client, W83791D_REG_VBAT);
1319 for (i = 0; i < 3; i++)
1320 data->fan_div[i] |= (vbat_reg >> (3 + i)) & 0x04;
1321
6495ce18
MH		 1322 /* Update PWM duty cycle */
1323 for (i = 0; i < NUMBER_OF_PWM; i++) {
1324 data->pwm[i] = w83791d_read(client,
1325 W83791D_REG_PWM[i]);
1326 }
1327
9873964d
CS		 1328 /* Update the first temperature sensor */
1329 for (i = 0; i < 3; i++) {
1330 data->temp1[i] = w83791d_read(client,
1331 W83791D_REG_TEMP1[i]);
1332 }
1333
1334 /* Update the rest of the temperature sensors */
1335 for (i = 0; i < 2; i++) {
1336 for (j = 0; j < 3; j++) {
1337 data->temp_add[i][j] =
1338 (w83791d_read(client,
1339 W83791D_REG_TEMP_ADD[i][j * 2]) << 8) |
1340 w83791d_read(client,
1341 W83791D_REG_TEMP_ADD[i][j * 2 + 1]);
1342 }
1343 }
1344
1345 /* Update the realtime status */
1346 data->alarms =
1347 w83791d_read(client, W83791D_REG_ALARM1) +
1348 (w83791d_read(client, W83791D_REG_ALARM2) << 8) +
1349 (w83791d_read(client, W83791D_REG_ALARM3) << 16);
1350
1351 /* Update the beep configuration information */
1352 data->beep_mask =
1353 w83791d_read(client, W83791D_REG_BEEP_CTRL[0]) +
1354 (w83791d_read(client, W83791D_REG_BEEP_CTRL[1]) << 8) +
1355 (w83791d_read(client, W83791D_REG_BEEP_CTRL[2]) << 16);
1356
125751cb 1357 /* Extract global beep enable flag */
9873964d
CS		 1358 data->beep_enable =
1359 (data->beep_mask >> GLOBAL_BEEP_ENABLE_SHIFT) & 0x01;
1360
1361 /* Update the cpu voltage information */
1362 i = w83791d_read(client, W83791D_REG_VID_FANDIV);
1363 data->vid = i & 0x0f;
1364 data->vid |= (w83791d_read(client, W83791D_REG_DID_VID4) & 0x01)
1365 << 4;
1366
1367 data->last_updated = jiffies;
1368 data->valid = 1;
1369 }
1370
1371 mutex_unlock(&data->update_lock);
1372
1373#ifdef DEBUG
1374 w83791d_print_debug(data, dev);
1375#endif
1376
1377 return data;
1378}
1379
1380#ifdef DEBUG
1381static void w83791d_print_debug(struct w83791d_data *data, struct device *dev)
1382{
1383 int i = 0, j = 0;
1384
1385 dev_dbg(dev, "======Start of w83791d debug values======\n");
1386 dev_dbg(dev, "%d set of Voltages: ===>\n", NUMBER_OF_VIN);
1387 for (i = 0; i < NUMBER_OF_VIN; i++) {
1388 dev_dbg(dev, "vin[%d] is: 0x%02x\n", i, data->in[i]);
1389 dev_dbg(dev, "vin[%d] min is: 0x%02x\n", i, data->in_min[i]);
1390 dev_dbg(dev, "vin[%d] max is: 0x%02x\n", i, data->in_max[i]);
1391 }
1392 dev_dbg(dev, "%d set of Fan Counts/Divisors: ===>\n", NUMBER_OF_FANIN);
1393 for (i = 0; i < NUMBER_OF_FANIN; i++) {
1394 dev_dbg(dev, "fan[%d] is: 0x%02x\n", i, data->fan[i]);
1395 dev_dbg(dev, "fan[%d] min is: 0x%02x\n", i, data->fan_min[i]);
1396 dev_dbg(dev, "fan_div[%d] is: 0x%02x\n", i, data->fan_div[i]);
1397 }
1398
1399 /* temperature math is signed, but only print out the
1400 bits that matter */
1401 dev_dbg(dev, "%d set of Temperatures: ===>\n", NUMBER_OF_TEMPIN);
1402 for (i = 0; i < 3; i++) {
1403 dev_dbg(dev, "temp1[%d] is: 0x%02x\n", i, (u8) data->temp1[i]);
1404 }
1405 for (i = 0; i < 2; i++) {
1406 for (j = 0; j < 3; j++) {
1407 dev_dbg(dev, "temp_add[%d][%d] is: 0x%04x\n", i, j,
1408 (u16) data->temp_add[i][j]);
1409 }
1410 }
1411
1412 dev_dbg(dev, "Misc Information: ===>\n");
1413 dev_dbg(dev, "alarm is: 0x%08x\n", data->alarms);
1414 dev_dbg(dev, "beep_mask is: 0x%08x\n", data->beep_mask);
1415 dev_dbg(dev, "beep_enable is: %d\n", data->beep_enable);
1416 dev_dbg(dev, "vid is: 0x%02x\n", data->vid);
1417 dev_dbg(dev, "vrm is: 0x%02x\n", data->vrm);
1418 dev_dbg(dev, "=======End of w83791d debug values========\n");
1419 dev_dbg(dev, "\n");
1420}
1421#endif
1422
1423static int __init sensors_w83791d_init(void)
1424{
1425 return i2c_add_driver(&w83791d_driver);
1426}
1427
1428static void __exit sensors_w83791d_exit(void)
1429{
1430 i2c_del_driver(&w83791d_driver);
1431}
1432
1433MODULE_AUTHOR("Charles Spirakis <bezaur@gmail.com>");
1434MODULE_DESCRIPTION("W83791D driver");
1435MODULE_LICENSE("GPL");
1436
1437module_init(sensors_w83791d_init);
1438module_exit(sensors_w83791d_exit);
kernel source for telekom puls (alcatel/mediatek)