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