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