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