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