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