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