?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Char: moxa, fix and optimise empty timer
[linux-2.6/mini2440.git] / drivers / hwmon / w83781d.c
bloba6a1edfe76141e8a9fb5fb058a13014d90787ac9
1 /*
2 w83781d.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring
4 Copyright (c) 1998 - 2001 Frodo Looijaard <frodol@dds.nl>,
5 Philip Edelbrock <phil@netroedge.com>,
6 and Mark Studebaker <mdsxyz123@yahoo.com>
7 Copyright (c) 2007 Jean Delvare <khali@linux-fr.org>
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 /*
25 Supports following chips:
26
27 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
28 as99127f 7 3 0 3 0x31 0x12c3 yes no
29 as99127f rev.2 (type_name = as99127f) 0x31 0x5ca3 yes no
30 w83781d 7 3 0 3 0x10-1 0x5ca3 yes yes
31 w83627hf 9 3 2 3 0x21 0x5ca3 yes yes(LPC)
32 w83782d 9 3 2-4 3 0x30 0x5ca3 yes yes
33 w83783s 5-6 3 2 1-2 0x40 0x5ca3 yes no
34
35 */
36
37 #include <linux/module.h>
38 #include <linux/init.h>
39 #include <linux/slab.h>
40 #include <linux/jiffies.h>
41 #include <linux/i2c.h>
42 #include <linux/platform_device.h>
43 #include <linux/ioport.h>
44 #include <linux/hwmon.h>
45 #include <linux/hwmon-vid.h>
46 #include <linux/hwmon-sysfs.h>
47 #include <linux/sysfs.h>
48 #include <linux/err.h>
49 #include <linux/mutex.h>
50 #include <asm/io.h>
51 #include "lm75.h"
52
53 /* ISA device, if found */
54 static struct platform_device *pdev;
55
56 /* Addresses to scan */
57 static unsigned short normal_i2c[] = { 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
58 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
59 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END };
60 static unsigned short isa_address = 0x290;
61
62 /* Insmod parameters */
63 I2C_CLIENT_INSMOD_5(w83781d, w83782d, w83783s, w83627hf, as99127f);
64 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: "
65 "{bus, clientaddr, subclientaddr1, subclientaddr2}");
66
67 static int reset;
68 module_param(reset, bool, 0);
69 MODULE_PARM_DESC(reset, "Set to one to reset chip on load");
70
71 static int init = 1;
72 module_param(init, bool, 0);
73 MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization");
74
75 /* Constants specified below */
76
77 /* Length of ISA address segment */
78 #define W83781D_EXTENT 8
79
80 /* Where are the ISA address/data registers relative to the base address */
81 #define W83781D_ADDR_REG_OFFSET 5
82 #define W83781D_DATA_REG_OFFSET 6
83
84 /* The device registers */
85 /* in nr from 0 to 8 */
86 #define W83781D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
87 (0x554 + (((nr) - 7) * 2)))
88 #define W83781D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
89 (0x555 + (((nr) - 7) * 2)))
90 #define W83781D_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \
91 (0x550 + (nr) - 7))
92
93 /* fan nr from 0 to 2 */
94 #define W83781D_REG_FAN_MIN(nr) (0x3b + (nr))
95 #define W83781D_REG_FAN(nr) (0x28 + (nr))
96
97 #define W83781D_REG_BANK 0x4E
98 #define W83781D_REG_TEMP2_CONFIG 0x152
99 #define W83781D_REG_TEMP3_CONFIG 0x252
100 /* temp nr from 1 to 3 */
101 #define W83781D_REG_TEMP(nr) ((nr == 3) ? (0x0250) : \
102 ((nr == 2) ? (0x0150) : \
103 (0x27)))
104 #define W83781D_REG_TEMP_HYST(nr) ((nr == 3) ? (0x253) : \
105 ((nr == 2) ? (0x153) : \
106 (0x3A)))
107 #define W83781D_REG_TEMP_OVER(nr) ((nr == 3) ? (0x255) : \
108 ((nr == 2) ? (0x155) : \
109 (0x39)))
110
111 #define W83781D_REG_CONFIG 0x40
112
113 /* Interrupt status (W83781D, AS99127F) */
114 #define W83781D_REG_ALARM1 0x41
115 #define W83781D_REG_ALARM2 0x42
116
117 /* Real-time status (W83782D, W83783S, W83627HF) */
118 #define W83782D_REG_ALARM1 0x459
119 #define W83782D_REG_ALARM2 0x45A
120 #define W83782D_REG_ALARM3 0x45B
121
122 #define W83781D_REG_BEEP_CONFIG 0x4D
123 #define W83781D_REG_BEEP_INTS1 0x56
124 #define W83781D_REG_BEEP_INTS2 0x57
125 #define W83781D_REG_BEEP_INTS3 0x453 /* not on W83781D */
126
127 #define W83781D_REG_VID_FANDIV 0x47
128
129 #define W83781D_REG_CHIPID 0x49
130 #define W83781D_REG_WCHIPID 0x58
131 #define W83781D_REG_CHIPMAN 0x4F
132 #define W83781D_REG_PIN 0x4B
133
134 /* 782D/783S only */
135 #define W83781D_REG_VBAT 0x5D
136
137 /* PWM 782D (1-4) and 783S (1-2) only */
138 static const u8 W83781D_REG_PWM[] = { 0x5B, 0x5A, 0x5E, 0x5F };
139 #define W83781D_REG_PWMCLK12 0x5C
140 #define W83781D_REG_PWMCLK34 0x45C
141
142 #define W83781D_REG_I2C_ADDR 0x48
143 #define W83781D_REG_I2C_SUBADDR 0x4A
144
145 /* The following are undocumented in the data sheets however we
146 received the information in an email from Winbond tech support */
147 /* Sensor selection - not on 781d */
148 #define W83781D_REG_SCFG1 0x5D
149 static const u8 BIT_SCFG1[] = { 0x02, 0x04, 0x08 };
150
151 #define W83781D_REG_SCFG2 0x59
152 static const u8 BIT_SCFG2[] = { 0x10, 0x20, 0x40 };
153
154 #define W83781D_DEFAULT_BETA 3435
155
156 /* RT Table registers */
157 #define W83781D_REG_RT_IDX 0x50
158 #define W83781D_REG_RT_VAL 0x51
159
160 /* Conversions */
161 #define IN_TO_REG(val) SENSORS_LIMIT(((val) + 8) / 16, 0, 255)
162 #define IN_FROM_REG(val) ((val) * 16)
163
164 static inline u8
165 FAN_TO_REG(long rpm, int div)
166 {
167 if (rpm == 0)
168 return 255;
169 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
170 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
171 }
172
173 static inline long
174 FAN_FROM_REG(u8 val, int div)
175 {
176 if (val == 0)
177 return -1;
178 if (val == 255)
179 return 0;
180 return 1350000 / (val * div);
181 }
182
183 #define TEMP_TO_REG(val) SENSORS_LIMIT((val) / 1000, -127, 128)
184 #define TEMP_FROM_REG(val) ((val) * 1000)
185
186 #define BEEP_MASK_FROM_REG(val,type) ((type) == as99127f ? \
187 (val) ^ 0x7fff : (val))
188 #define BEEP_MASK_TO_REG(val,type) ((type) == as99127f ? \
189 (~(val)) & 0x7fff : (val) & 0xffffff)
190
191 #define DIV_FROM_REG(val) (1 << (val))
192
193 static inline u8
194 DIV_TO_REG(long val, enum chips type)
195 {
196 int i;
197 val = SENSORS_LIMIT(val, 1,
198 ((type == w83781d
199 || type == as99127f) ? 8 : 128)) >> 1;
200 for (i = 0; i < 7; i++) {
201 if (val == 0)
202 break;
203 val >>= 1;
204 }
205 return i;
206 }
207
208 /* There are some complications in a module like this. First off, W83781D chips
209 may be both present on the SMBus and the ISA bus, and we have to handle
210 those cases separately at some places. Second, there might be several
211 W83781D chips available (well, actually, that is probably never done; but
212 it is a clean illustration of how to handle a case like that). Finally,
213 a specific chip may be attached to *both* ISA and SMBus, and we would
214 not like to detect it double. Fortunately, in the case of the W83781D at
215 least, a register tells us what SMBus address we are on, so that helps
216 a bit - except if there could be more than one SMBus. Groan. No solution
217 for this yet. */
218
219 /* For ISA chips, we abuse the i2c_client addr and name fields. We also use
220 the driver field to differentiate between I2C and ISA chips. */
221 struct w83781d_data {
222 struct i2c_client client;
223 struct device *hwmon_dev;
224 struct mutex lock;
225 enum chips type;
226
227 struct mutex update_lock;
228 char valid; /* !=0 if following fields are valid */
229 unsigned long last_updated; /* In jiffies */
230
231 struct i2c_client *lm75[2]; /* for secondary I2C addresses */
232 /* array of 2 pointers to subclients */
233
234 u8 in[9]; /* Register value - 8 & 9 for 782D only */
235 u8 in_max[9]; /* Register value - 8 & 9 for 782D only */
236 u8 in_min[9]; /* Register value - 8 & 9 for 782D only */
237 u8 fan[3]; /* Register value */
238 u8 fan_min[3]; /* Register value */
239 s8 temp; /* Register value */
240 s8 temp_max; /* Register value */
241 s8 temp_max_hyst; /* Register value */
242 u16 temp_add[2]; /* Register value */
243 u16 temp_max_add[2]; /* Register value */
244 u16 temp_max_hyst_add[2]; /* Register value */
245 u8 fan_div[3]; /* Register encoding, shifted right */
246 u8 vid; /* Register encoding, combined */
247 u32 alarms; /* Register encoding, combined */
248 u32 beep_mask; /* Register encoding, combined */
249 u8 beep_enable; /* Boolean */
250 u8 pwm[4]; /* Register value */
251 u8 pwm2_enable; /* Boolean */
252 u16 sens[3]; /* 782D/783S only.
253 1 = pentium diode; 2 = 3904 diode;
254 4 = thermistor */
255 u8 vrm;
256 };
257
258 static int w83781d_attach_adapter(struct i2c_adapter *adapter);
259 static int w83781d_detect(struct i2c_adapter *adapter, int address, int kind);
260 static int w83781d_detach_client(struct i2c_client *client);
261
262 static int __devinit w83781d_isa_probe(struct platform_device *pdev);
263 static int __devexit w83781d_isa_remove(struct platform_device *pdev);
264
265 static int w83781d_read_value(struct w83781d_data *data, u16 reg);
266 static int w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value);
267 static struct w83781d_data *w83781d_update_device(struct device *dev);
268 static void w83781d_init_device(struct device *dev);
269
270 static struct i2c_driver w83781d_driver = {
271 .driver = {
272 .name = "w83781d",
273 },
274 .id = I2C_DRIVERID_W83781D,
275 .attach_adapter = w83781d_attach_adapter,
276 .detach_client = w83781d_detach_client,
277 };
278
279 static struct platform_driver w83781d_isa_driver = {
280 .driver = {
281 .owner = THIS_MODULE,
282 .name = "w83781d",
283 },
284 .probe = w83781d_isa_probe,
285 .remove = w83781d_isa_remove,
286 };
287
288
289 /* following are the sysfs callback functions */
290 #define show_in_reg(reg) \
291 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
292 char *buf) \
293 { \
294 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
295 struct w83781d_data *data = w83781d_update_device(dev); \
296 return sprintf(buf, "%ld\n", \
297 (long)IN_FROM_REG(data->reg[attr->index])); \
298 }
299 show_in_reg(in);
300 show_in_reg(in_min);
301 show_in_reg(in_max);
302
303 #define store_in_reg(REG, reg) \
304 static ssize_t store_in_##reg (struct device *dev, struct device_attribute \
305 *da, const char *buf, size_t count) \
306 { \
307 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
308 struct w83781d_data *data = dev_get_drvdata(dev); \
309 int nr = attr->index; \
310 u32 val; \
311 \
312 val = simple_strtoul(buf, NULL, 10); \
313 \
314 mutex_lock(&data->update_lock); \
315 data->in_##reg[nr] = IN_TO_REG(val); \
316 w83781d_write_value(data, W83781D_REG_IN_##REG(nr), data->in_##reg[nr]); \
317 \
318 mutex_unlock(&data->update_lock); \
319 return count; \
320 }
321 store_in_reg(MIN, min);
322 store_in_reg(MAX, max);
323
324 #define sysfs_in_offsets(offset) \
325 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
326 show_in, NULL, offset); \
327 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
328 show_in_min, store_in_min, offset); \
329 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
330 show_in_max, store_in_max, offset)
331
332 sysfs_in_offsets(0);
333 sysfs_in_offsets(1);
334 sysfs_in_offsets(2);
335 sysfs_in_offsets(3);
336 sysfs_in_offsets(4);
337 sysfs_in_offsets(5);
338 sysfs_in_offsets(6);
339 sysfs_in_offsets(7);
340 sysfs_in_offsets(8);
341
342 #define show_fan_reg(reg) \
343 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
344 char *buf) \
345 { \
346 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
347 struct w83781d_data *data = w83781d_update_device(dev); \
348 return sprintf(buf,"%ld\n", \
349 FAN_FROM_REG(data->reg[attr->index], \
350 DIV_FROM_REG(data->fan_div[attr->index]))); \
351 }
352 show_fan_reg(fan);
353 show_fan_reg(fan_min);
354
355 static ssize_t
356 store_fan_min(struct device *dev, struct device_attribute *da,
357 const char *buf, size_t count)
358 {
359 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
360 struct w83781d_data *data = dev_get_drvdata(dev);
361 int nr = attr->index;
362 u32 val;
363
364 val = simple_strtoul(buf, NULL, 10);
365
366 mutex_lock(&data->update_lock);
367 data->fan_min[nr] =
368 FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
369 w83781d_write_value(data, W83781D_REG_FAN_MIN(nr),
370 data->fan_min[nr]);
371
372 mutex_unlock(&data->update_lock);
373 return count;
374 }
375
376 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
377 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
378 show_fan_min, store_fan_min, 0);
379 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
380 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR,
381 show_fan_min, store_fan_min, 1);
382 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
383 static SENSOR_DEVICE_ATTR(fan3_min, S_IRUGO | S_IWUSR,
384 show_fan_min, store_fan_min, 2);
385
386 #define show_temp_reg(reg) \
387 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
388 char *buf) \
389 { \
390 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
391 struct w83781d_data *data = w83781d_update_device(dev); \
392 int nr = attr->index; \
393 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
394 return sprintf(buf,"%d\n", \
395 LM75_TEMP_FROM_REG(data->reg##_add[nr-2])); \
396 } else { /* TEMP1 */ \
397 return sprintf(buf,"%ld\n", (long)TEMP_FROM_REG(data->reg)); \
398 } \
399 }
400 show_temp_reg(temp);
401 show_temp_reg(temp_max);
402 show_temp_reg(temp_max_hyst);
403
404 #define store_temp_reg(REG, reg) \
405 static ssize_t store_temp_##reg (struct device *dev, \
406 struct device_attribute *da, const char *buf, size_t count) \
407 { \
408 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); \
409 struct w83781d_data *data = dev_get_drvdata(dev); \
410 int nr = attr->index; \
411 long val; \
412 \
413 val = simple_strtol(buf, NULL, 10); \
414 \
415 mutex_lock(&data->update_lock); \
416 \
417 if (nr >= 2) { /* TEMP2 and TEMP3 */ \
418 data->temp_##reg##_add[nr-2] = LM75_TEMP_TO_REG(val); \
419 w83781d_write_value(data, W83781D_REG_TEMP_##REG(nr), \
420 data->temp_##reg##_add[nr-2]); \
421 } else { /* TEMP1 */ \
422 data->temp_##reg = TEMP_TO_REG(val); \
423 w83781d_write_value(data, W83781D_REG_TEMP_##REG(nr), \
424 data->temp_##reg); \
425 } \
426 \
427 mutex_unlock(&data->update_lock); \
428 return count; \
429 }
430 store_temp_reg(OVER, max);
431 store_temp_reg(HYST, max_hyst);
432
433 #define sysfs_temp_offsets(offset) \
434 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
435 show_temp, NULL, offset); \
436 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
437 show_temp_max, store_temp_max, offset); \
438 static SENSOR_DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR, \
439 show_temp_max_hyst, store_temp_max_hyst, offset);
440
441 sysfs_temp_offsets(1);
442 sysfs_temp_offsets(2);
443 sysfs_temp_offsets(3);
444
445 static ssize_t
446 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
447 {
448 struct w83781d_data *data = w83781d_update_device(dev);
449 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
450 }
451
452 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
453
454 static ssize_t
455 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
456 {
457 struct w83781d_data *data = dev_get_drvdata(dev);
458 return sprintf(buf, "%ld\n", (long) data->vrm);
459 }
460
461 static ssize_t
462 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
463 {
464 struct w83781d_data *data = dev_get_drvdata(dev);
465 u32 val;
466
467 val = simple_strtoul(buf, NULL, 10);
468 data->vrm = val;
469
470 return count;
471 }
472
473 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
474
475 static ssize_t
476 show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
477 {
478 struct w83781d_data *data = w83781d_update_device(dev);
479 return sprintf(buf, "%u\n", data->alarms);
480 }
481
482 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
483
484 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
485 char *buf)
486 {
487 struct w83781d_data *data = w83781d_update_device(dev);
488 int bitnr = to_sensor_dev_attr(attr)->index;
489 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
490 }
491
492 /* The W83781D has a single alarm bit for temp2 and temp3 */
493 static ssize_t show_temp3_alarm(struct device *dev,
494 struct device_attribute *attr, char *buf)
495 {
496 struct w83781d_data *data = w83781d_update_device(dev);
497 int bitnr = (data->type == w83781d) ? 5 : 13;
498 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
499 }
500
501 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
502 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
503 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
504 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
505 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
506 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
507 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
508 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16);
509 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17);
510 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
511 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
512 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
513 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
514 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5);
515 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_temp3_alarm, NULL, 0);
516
517 static ssize_t show_beep_mask (struct device *dev, struct device_attribute *attr, char *buf)
518 {
519 struct w83781d_data *data = w83781d_update_device(dev);
520 return sprintf(buf, "%ld\n",
521 (long)BEEP_MASK_FROM_REG(data->beep_mask, data->type));
522 }
523 static ssize_t show_beep_enable (struct device *dev, struct device_attribute *attr, char *buf)
524 {
525 struct w83781d_data *data = w83781d_update_device(dev);
526 return sprintf(buf, "%ld\n", (long)data->beep_enable);
527 }
528
529 static ssize_t
530 store_beep_mask(struct device *dev, struct device_attribute *attr,
531 const char *buf, size_t count)
532 {
533 struct w83781d_data *data = dev_get_drvdata(dev);
534 u32 val;
535
536 val = simple_strtoul(buf, NULL, 10);
537
538 mutex_lock(&data->update_lock);
539 data->beep_mask = BEEP_MASK_TO_REG(val, data->type);
540 w83781d_write_value(data, W83781D_REG_BEEP_INTS1,
541 data->beep_mask & 0xff);
542 w83781d_write_value(data, W83781D_REG_BEEP_INTS2,
543 ((data->beep_mask >> 8) & 0x7f)
544 | data->beep_enable << 7);
545 if (data->type != w83781d && data->type != as99127f) {
546 w83781d_write_value(data, W83781D_REG_BEEP_INTS3,
547 ((data->beep_mask) >> 16) & 0xff);
548 }
549 mutex_unlock(&data->update_lock);
550
551 return count;
552 }
553
554 static ssize_t
555 store_beep_enable(struct device *dev, struct device_attribute *attr,
556 const char *buf, size_t count)
557 {
558 struct w83781d_data *data = dev_get_drvdata(dev);
559 u32 val;
560
561 val = simple_strtoul(buf, NULL, 10);
562 if (val != 0 && val != 1)
563 return -EINVAL;
564
565 mutex_lock(&data->update_lock);
566 data->beep_enable = val;
567 val = w83781d_read_value(data, W83781D_REG_BEEP_INTS2) & 0x7f;
568 val |= data->beep_enable << 7;
569 w83781d_write_value(data, W83781D_REG_BEEP_INTS2, val);
570 mutex_unlock(&data->update_lock);
571
572 return count;
573 }
574
575 static DEVICE_ATTR(beep_mask, S_IRUGO | S_IWUSR,
576 show_beep_mask, store_beep_mask);
577 static DEVICE_ATTR(beep_enable, S_IRUGO | S_IWUSR,
578 show_beep_enable, store_beep_enable);
579
580 static ssize_t show_beep(struct device *dev, struct device_attribute *attr,
581 char *buf)
582 {
583 struct w83781d_data *data = w83781d_update_device(dev);
584 int bitnr = to_sensor_dev_attr(attr)->index;
585 return sprintf(buf, "%u\n", (data->beep_mask >> bitnr) & 1);
586 }
587
588 static ssize_t
589 store_beep(struct device *dev, struct device_attribute *attr,
590 const char *buf, size_t count)
591 {
592 struct w83781d_data *data = dev_get_drvdata(dev);
593 int bitnr = to_sensor_dev_attr(attr)->index;
594 unsigned long bit;
595 u8 reg;
596
597 bit = simple_strtoul(buf, NULL, 10);
598 if (bit & ~1)
599 return -EINVAL;
600
601 mutex_lock(&data->update_lock);
602 if (bit)
603 data->beep_mask |= (1 << bitnr);
604 else
605 data->beep_mask &= ~(1 << bitnr);
606
607 if (bitnr < 8) {
608 reg = w83781d_read_value(data, W83781D_REG_BEEP_INTS1);
609 if (bit)
610 reg |= (1 << bitnr);
611 else
612 reg &= ~(1 << bitnr);
613 w83781d_write_value(data, W83781D_REG_BEEP_INTS1, reg);
614 } else if (bitnr < 16) {
615 reg = w83781d_read_value(data, W83781D_REG_BEEP_INTS2);
616 if (bit)
617 reg |= (1 << (bitnr - 8));
618 else
619 reg &= ~(1 << (bitnr - 8));
620 w83781d_write_value(data, W83781D_REG_BEEP_INTS2, reg);
621 } else {
622 reg = w83781d_read_value(data, W83781D_REG_BEEP_INTS3);
623 if (bit)
624 reg |= (1 << (bitnr - 16));
625 else
626 reg &= ~(1 << (bitnr - 16));
627 w83781d_write_value(data, W83781D_REG_BEEP_INTS3, reg);
628 }
629 mutex_unlock(&data->update_lock);
630
631 return count;
632 }
633
634 /* The W83781D has a single beep bit for temp2 and temp3 */
635 static ssize_t show_temp3_beep(struct device *dev,
636 struct device_attribute *attr, char *buf)
637 {
638 struct w83781d_data *data = w83781d_update_device(dev);
639 int bitnr = (data->type == w83781d) ? 5 : 13;
640 return sprintf(buf, "%u\n", (data->beep_mask >> bitnr) & 1);
641 }
642
643 static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | S_IWUSR,
644 show_beep, store_beep, 0);
645 static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO | S_IWUSR,
646 show_beep, store_beep, 1);
647 static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO | S_IWUSR,
648 show_beep, store_beep, 2);
649 static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO | S_IWUSR,
650 show_beep, store_beep, 3);
651 static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO | S_IWUSR,
652 show_beep, store_beep, 8);
653 static SENSOR_DEVICE_ATTR(in5_beep, S_IRUGO | S_IWUSR,
654 show_beep, store_beep, 9);
655 static SENSOR_DEVICE_ATTR(in6_beep, S_IRUGO | S_IWUSR,
656 show_beep, store_beep, 10);
657 static SENSOR_DEVICE_ATTR(in7_beep, S_IRUGO | S_IWUSR,
658 show_beep, store_beep, 16);
659 static SENSOR_DEVICE_ATTR(in8_beep, S_IRUGO | S_IWUSR,
660 show_beep, store_beep, 17);
661 static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO | S_IWUSR,
662 show_beep, store_beep, 6);
663 static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO | S_IWUSR,
664 show_beep, store_beep, 7);
665 static SENSOR_DEVICE_ATTR(fan3_beep, S_IRUGO | S_IWUSR,
666 show_beep, store_beep, 11);
667 static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO | S_IWUSR,
668 show_beep, store_beep, 4);
669 static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO | S_IWUSR,
670 show_beep, store_beep, 5);
671 static SENSOR_DEVICE_ATTR(temp3_beep, S_IRUGO,
672 show_temp3_beep, store_beep, 13);
673
674 static ssize_t
675 show_fan_div(struct device *dev, struct device_attribute *da, char *buf)
676 {
677 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
678 struct w83781d_data *data = w83781d_update_device(dev);
679 return sprintf(buf, "%ld\n",
680 (long) DIV_FROM_REG(data->fan_div[attr->index]));
681 }
682
683 /* Note: we save and restore the fan minimum here, because its value is
684 determined in part by the fan divisor. This follows the principle of
685 least surprise; the user doesn't expect the fan minimum to change just
686 because the divisor changed. */
687 static ssize_t
688 store_fan_div(struct device *dev, struct device_attribute *da,
689 const char *buf, size_t count)
690 {
691 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
692 struct w83781d_data *data = dev_get_drvdata(dev);
693 unsigned long min;
694 int nr = attr->index;
695 u8 reg;
696 unsigned long val = simple_strtoul(buf, NULL, 10);
697
698 mutex_lock(&data->update_lock);
699
700 /* Save fan_min */
701 min = FAN_FROM_REG(data->fan_min[nr],
702 DIV_FROM_REG(data->fan_div[nr]));
703
704 data->fan_div[nr] = DIV_TO_REG(val, data->type);
705
706 reg = (w83781d_read_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV)
707 & (nr==0 ? 0xcf : 0x3f))
708 | ((data->fan_div[nr] & 0x03) << (nr==0 ? 4 : 6));
709 w83781d_write_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV, reg);
710
711 /* w83781d and as99127f don't have extended divisor bits */
712 if (data->type != w83781d && data->type != as99127f) {
713 reg = (w83781d_read_value(data, W83781D_REG_VBAT)
714 & ~(1 << (5 + nr)))
715 | ((data->fan_div[nr] & 0x04) << (3 + nr));
716 w83781d_write_value(data, W83781D_REG_VBAT, reg);
717 }
718
719 /* Restore fan_min */
720 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
721 w83781d_write_value(data, W83781D_REG_FAN_MIN(nr), data->fan_min[nr]);
722
723 mutex_unlock(&data->update_lock);
724 return count;
725 }
726
727 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
728 show_fan_div, store_fan_div, 0);
729 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
730 show_fan_div, store_fan_div, 1);
731 static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO | S_IWUSR,
732 show_fan_div, store_fan_div, 2);
733
734 static ssize_t
735 show_pwm(struct device *dev, struct device_attribute *da, char *buf)
736 {
737 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
738 struct w83781d_data *data = w83781d_update_device(dev);
739 return sprintf(buf, "%d\n", (int)data->pwm[attr->index]);
740 }
741
742 static ssize_t
743 show_pwm2_enable(struct device *dev, struct device_attribute *da, char *buf)
744 {
745 struct w83781d_data *data = w83781d_update_device(dev);
746 return sprintf(buf, "%d\n", (int)data->pwm2_enable);
747 }
748
749 static ssize_t
750 store_pwm(struct device *dev, struct device_attribute *da, const char *buf,
751 size_t count)
752 {
753 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
754 struct w83781d_data *data = dev_get_drvdata(dev);
755 int nr = attr->index;
756 u32 val;
757
758 val = simple_strtoul(buf, NULL, 10);
759
760 mutex_lock(&data->update_lock);
761 data->pwm[nr] = SENSORS_LIMIT(val, 0, 255);
762 w83781d_write_value(data, W83781D_REG_PWM[nr], data->pwm[nr]);
763 mutex_unlock(&data->update_lock);
764 return count;
765 }
766
767 static ssize_t
768 store_pwm2_enable(struct device *dev, struct device_attribute *da,
769 const char *buf, size_t count)
770 {
771 struct w83781d_data *data = dev_get_drvdata(dev);
772 u32 val, reg;
773
774 val = simple_strtoul(buf, NULL, 10);
775
776 mutex_lock(&data->update_lock);
777
778 switch (val) {
779 case 0:
780 case 1:
781 reg = w83781d_read_value(data, W83781D_REG_PWMCLK12);
782 w83781d_write_value(data, W83781D_REG_PWMCLK12,
783 (reg & 0xf7) | (val << 3));
784
785 reg = w83781d_read_value(data, W83781D_REG_BEEP_CONFIG);
786 w83781d_write_value(data, W83781D_REG_BEEP_CONFIG,
787 (reg & 0xef) | (!val << 4));
788
789 data->pwm2_enable = val;
790 break;
791
792 default:
793 mutex_unlock(&data->update_lock);
794 return -EINVAL;
795 }
796
797 mutex_unlock(&data->update_lock);
798 return count;
799 }
800
801 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 0);
802 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 1);
803 static SENSOR_DEVICE_ATTR(pwm3, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 2);
804 static SENSOR_DEVICE_ATTR(pwm4, S_IRUGO | S_IWUSR, show_pwm, store_pwm, 3);
805 /* only PWM2 can be enabled/disabled */
806 static DEVICE_ATTR(pwm2_enable, S_IRUGO | S_IWUSR,
807 show_pwm2_enable, store_pwm2_enable);
808
809 static ssize_t
810 show_sensor(struct device *dev, struct device_attribute *da, char *buf)
811 {
812 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
813 struct w83781d_data *data = w83781d_update_device(dev);
814 return sprintf(buf, "%d\n", (int)data->sens[attr->index]);
815 }
816
817 static ssize_t
818 store_sensor(struct device *dev, struct device_attribute *da,
819 const char *buf, size_t count)
820 {
821 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
822 struct w83781d_data *data = dev_get_drvdata(dev);
823 int nr = attr->index;
824 u32 val, tmp;
825
826 val = simple_strtoul(buf, NULL, 10);
827
828 mutex_lock(&data->update_lock);
829
830 switch (val) {
831 case 1: /* PII/Celeron diode */
832 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
833 w83781d_write_value(data, W83781D_REG_SCFG1,
834 tmp | BIT_SCFG1[nr]);
835 tmp = w83781d_read_value(data, W83781D_REG_SCFG2);
836 w83781d_write_value(data, W83781D_REG_SCFG2,
837 tmp | BIT_SCFG2[nr]);
838 data->sens[nr] = val;
839 break;
840 case 2: /* 3904 */
841 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
842 w83781d_write_value(data, W83781D_REG_SCFG1,
843 tmp | BIT_SCFG1[nr]);
844 tmp = w83781d_read_value(data, W83781D_REG_SCFG2);
845 w83781d_write_value(data, W83781D_REG_SCFG2,
846 tmp & ~BIT_SCFG2[nr]);
847 data->sens[nr] = val;
848 break;
849 case W83781D_DEFAULT_BETA:
850 dev_warn(dev, "Sensor type %d is deprecated, please use 4 "
851 "instead\n", W83781D_DEFAULT_BETA);
852 /* fall through */
853 case 4: /* thermistor */
854 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
855 w83781d_write_value(data, W83781D_REG_SCFG1,
856 tmp & ~BIT_SCFG1[nr]);
857 data->sens[nr] = val;
858 break;
859 default:
860 dev_err(dev, "Invalid sensor type %ld; must be 1, 2, or 4\n",
861 (long) val);
862 break;
863 }
864
865 mutex_unlock(&data->update_lock);
866 return count;
867 }
868
869 static SENSOR_DEVICE_ATTR(temp1_type, S_IRUGO | S_IWUSR,
870 show_sensor, store_sensor, 0);
871 static SENSOR_DEVICE_ATTR(temp2_type, S_IRUGO | S_IWUSR,
872 show_sensor, store_sensor, 1);
873 static SENSOR_DEVICE_ATTR(temp3_type, S_IRUGO | S_IWUSR,
874 show_sensor, store_sensor, 2);
875
876 /* I2C devices get this name attribute automatically, but for ISA devices
877 we must create it by ourselves. */
878 static ssize_t
879 show_name(struct device *dev, struct device_attribute *devattr, char *buf)
880 {
881 struct w83781d_data *data = dev_get_drvdata(dev);
882 return sprintf(buf, "%s\n", data->client.name);
883 }
884 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
885
886 /* This function is called when:
887 * w83781d_driver is inserted (when this module is loaded), for each
888 available adapter
889 * when a new adapter is inserted (and w83781d_driver is still present) */
890 static int
891 w83781d_attach_adapter(struct i2c_adapter *adapter)
892 {
893 if (!(adapter->class & I2C_CLASS_HWMON))
894 return 0;
895 return i2c_probe(adapter, &addr_data, w83781d_detect);
896 }
897
898 /* Assumes that adapter is of I2C, not ISA variety.
899 * OTHERWISE DON'T CALL THIS
900 */
901 static int
902 w83781d_detect_subclients(struct i2c_adapter *adapter, int address, int kind,
903 struct i2c_client *new_client)
904 {
905 int i, val1 = 0, id;
906 int err;
907 const char *client_name = "";
908 struct w83781d_data *data = i2c_get_clientdata(new_client);
909
910 data->lm75[0] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
911 if (!(data->lm75[0])) {
912 err = -ENOMEM;
913 goto ERROR_SC_0;
914 }
915
916 id = i2c_adapter_id(adapter);
917
918 if (force_subclients[0] == id && force_subclients[1] == address) {
919 for (i = 2; i <= 3; i++) {
920 if (force_subclients[i] < 0x48 ||
921 force_subclients[i] > 0x4f) {
922 dev_err(&new_client->dev, "Invalid subclient "
923 "address %d; must be 0x48-0x4f\n",
924 force_subclients[i]);
925 err = -EINVAL;
926 goto ERROR_SC_1;
927 }
928 }
929 w83781d_write_value(data, W83781D_REG_I2C_SUBADDR,
930 (force_subclients[2] & 0x07) |
931 ((force_subclients[3] & 0x07) << 4));
932 data->lm75[0]->addr = force_subclients[2];
933 } else {
934 val1 = w83781d_read_value(data, W83781D_REG_I2C_SUBADDR);
935 data->lm75[0]->addr = 0x48 + (val1 & 0x07);
936 }
937
938 if (kind != w83783s) {
939 data->lm75[1] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
940 if (!(data->lm75[1])) {
941 err = -ENOMEM;
942 goto ERROR_SC_1;
943 }
944
945 if (force_subclients[0] == id &&
946 force_subclients[1] == address) {
947 data->lm75[1]->addr = force_subclients[3];
948 } else {
949 data->lm75[1]->addr = 0x48 + ((val1 >> 4) & 0x07);
950 }
951 if (data->lm75[0]->addr == data->lm75[1]->addr) {
952 dev_err(&new_client->dev,
953 "Duplicate addresses 0x%x for subclients.\n",
954 data->lm75[0]->addr);
955 err = -EBUSY;
956 goto ERROR_SC_2;
957 }
958 }
959
960 if (kind == w83781d)
961 client_name = "w83781d subclient";
962 else if (kind == w83782d)
963 client_name = "w83782d subclient";
964 else if (kind == w83783s)
965 client_name = "w83783s subclient";
966 else if (kind == w83627hf)
967 client_name = "w83627hf subclient";
968 else if (kind == as99127f)
969 client_name = "as99127f subclient";
970
971 for (i = 0; i <= 1; i++) {
972 /* store all data in w83781d */
973 i2c_set_clientdata(data->lm75[i], NULL);
974 data->lm75[i]->adapter = adapter;
975 data->lm75[i]->driver = &w83781d_driver;
976 data->lm75[i]->flags = 0;
977 strlcpy(data->lm75[i]->name, client_name,
978 I2C_NAME_SIZE);
979 if ((err = i2c_attach_client(data->lm75[i]))) {
980 dev_err(&new_client->dev, "Subclient %d "
981 "registration at address 0x%x "
982 "failed.\n", i, data->lm75[i]->addr);
983 if (i == 1)
984 goto ERROR_SC_3;
985 goto ERROR_SC_2;
986 }
987 if (kind == w83783s)
988 break;
989 }
990
991 return 0;
992
993 /* Undo inits in case of errors */
994 ERROR_SC_3:
995 i2c_detach_client(data->lm75[0]);
996 ERROR_SC_2:
997 kfree(data->lm75[1]);
998 ERROR_SC_1:
999 kfree(data->lm75[0]);
1000 ERROR_SC_0:
1001 return err;
1002 }
1003
1004 #define IN_UNIT_ATTRS(X) \
1005 &sensor_dev_attr_in##X##_input.dev_attr.attr, \
1006 &sensor_dev_attr_in##X##_min.dev_attr.attr, \
1007 &sensor_dev_attr_in##X##_max.dev_attr.attr, \
1008 &sensor_dev_attr_in##X##_alarm.dev_attr.attr, \
1009 &sensor_dev_attr_in##X##_beep.dev_attr.attr
1010
1011 #define FAN_UNIT_ATTRS(X) \
1012 &sensor_dev_attr_fan##X##_input.dev_attr.attr, \
1013 &sensor_dev_attr_fan##X##_min.dev_attr.attr, \
1014 &sensor_dev_attr_fan##X##_div.dev_attr.attr, \
1015 &sensor_dev_attr_fan##X##_alarm.dev_attr.attr, \
1016 &sensor_dev_attr_fan##X##_beep.dev_attr.attr
1017
1018 #define TEMP_UNIT_ATTRS(X) \
1019 &sensor_dev_attr_temp##X##_input.dev_attr.attr, \
1020 &sensor_dev_attr_temp##X##_max.dev_attr.attr, \
1021 &sensor_dev_attr_temp##X##_max_hyst.dev_attr.attr, \
1022 &sensor_dev_attr_temp##X##_alarm.dev_attr.attr, \
1023 &sensor_dev_attr_temp##X##_beep.dev_attr.attr
1024
1025 static struct attribute* w83781d_attributes[] = {
1026 IN_UNIT_ATTRS(0),
1027 IN_UNIT_ATTRS(2),
1028 IN_UNIT_ATTRS(3),
1029 IN_UNIT_ATTRS(4),
1030 IN_UNIT_ATTRS(5),
1031 IN_UNIT_ATTRS(6),
1032 FAN_UNIT_ATTRS(1),
1033 FAN_UNIT_ATTRS(2),
1034 FAN_UNIT_ATTRS(3),
1035 TEMP_UNIT_ATTRS(1),
1036 TEMP_UNIT_ATTRS(2),
1037 &dev_attr_cpu0_vid.attr,
1038 &dev_attr_vrm.attr,
1039 &dev_attr_alarms.attr,
1040 &dev_attr_beep_mask.attr,
1041 &dev_attr_beep_enable.attr,
1042 NULL
1043 };
1044 static const struct attribute_group w83781d_group = {
1045 .attrs = w83781d_attributes,
1046 };
1047
1048 static struct attribute *w83781d_attributes_opt[] = {
1049 IN_UNIT_ATTRS(1),
1050 IN_UNIT_ATTRS(7),
1051 IN_UNIT_ATTRS(8),
1052 TEMP_UNIT_ATTRS(3),
1053 &sensor_dev_attr_pwm1.dev_attr.attr,
1054 &sensor_dev_attr_pwm2.dev_attr.attr,
1055 &sensor_dev_attr_pwm3.dev_attr.attr,
1056 &sensor_dev_attr_pwm4.dev_attr.attr,
1057 &dev_attr_pwm2_enable.attr,
1058 &sensor_dev_attr_temp1_type.dev_attr.attr,
1059 &sensor_dev_attr_temp2_type.dev_attr.attr,
1060 &sensor_dev_attr_temp3_type.dev_attr.attr,
1061 NULL
1062 };
1063 static const struct attribute_group w83781d_group_opt = {
1064 .attrs = w83781d_attributes_opt,
1065 };
1066
1067 /* No clean up is done on error, it's up to the caller */
1068 static int
1069 w83781d_create_files(struct device *dev, int kind, int is_isa)
1070 {
1071 int err;
1072
1073 if ((err = sysfs_create_group(&dev->kobj, &w83781d_group)))
1074 return err;
1075
1076 if (kind != w83783s) {
1077 if ((err = device_create_file(dev,
1078 &sensor_dev_attr_in1_input.dev_attr))
1079 || (err = device_create_file(dev,
1080 &sensor_dev_attr_in1_min.dev_attr))
1081 || (err = device_create_file(dev,
1082 &sensor_dev_attr_in1_max.dev_attr))
1083 || (err = device_create_file(dev,
1084 &sensor_dev_attr_in1_alarm.dev_attr))
1085 || (err = device_create_file(dev,
1086 &sensor_dev_attr_in1_beep.dev_attr)))
1087 return err;
1088 }
1089 if (kind != as99127f && kind != w83781d && kind != w83783s) {
1090 if ((err = device_create_file(dev,
1091 &sensor_dev_attr_in7_input.dev_attr))
1092 || (err = device_create_file(dev,
1093 &sensor_dev_attr_in7_min.dev_attr))
1094 || (err = device_create_file(dev,
1095 &sensor_dev_attr_in7_max.dev_attr))
1096 || (err = device_create_file(dev,
1097 &sensor_dev_attr_in7_alarm.dev_attr))
1098 || (err = device_create_file(dev,
1099 &sensor_dev_attr_in7_beep.dev_attr))
1100 || (err = device_create_file(dev,
1101 &sensor_dev_attr_in8_input.dev_attr))
1102 || (err = device_create_file(dev,
1103 &sensor_dev_attr_in8_min.dev_attr))
1104 || (err = device_create_file(dev,
1105 &sensor_dev_attr_in8_max.dev_attr))
1106 || (err = device_create_file(dev,
1107 &sensor_dev_attr_in8_alarm.dev_attr))
1108 || (err = device_create_file(dev,
1109 &sensor_dev_attr_in8_beep.dev_attr)))
1110 return err;
1111 }
1112 if (kind != w83783s) {
1113 if ((err = device_create_file(dev,
1114 &sensor_dev_attr_temp3_input.dev_attr))
1115 || (err = device_create_file(dev,
1116 &sensor_dev_attr_temp3_max.dev_attr))
1117 || (err = device_create_file(dev,
1118 &sensor_dev_attr_temp3_max_hyst.dev_attr))
1119 || (err = device_create_file(dev,
1120 &sensor_dev_attr_temp3_alarm.dev_attr))
1121 || (err = device_create_file(dev,
1122 &sensor_dev_attr_temp3_beep.dev_attr)))
1123 return err;
1124
1125 if (kind != w83781d)
1126 err = sysfs_chmod_file(&dev->kobj,
1127 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1128 S_IRUGO | S_IWUSR);
1129 if (err)
1130 return err;
1131 }
1132
1133 if (kind != w83781d && kind != as99127f) {
1134 if ((err = device_create_file(dev,
1135 &sensor_dev_attr_pwm1.dev_attr))
1136 || (err = device_create_file(dev,
1137 &sensor_dev_attr_pwm2.dev_attr))
1138 || (err = device_create_file(dev, &dev_attr_pwm2_enable)))
1139 return err;
1140 }
1141 if (kind == w83782d && !is_isa) {
1142 if ((err = device_create_file(dev,
1143 &sensor_dev_attr_pwm3.dev_attr))
1144 || (err = device_create_file(dev,
1145 &sensor_dev_attr_pwm4.dev_attr)))
1146 return err;
1147 }
1148
1149 if (kind != as99127f && kind != w83781d) {
1150 if ((err = device_create_file(dev,
1151 &sensor_dev_attr_temp1_type.dev_attr))
1152 || (err = device_create_file(dev,
1153 &sensor_dev_attr_temp2_type.dev_attr)))
1154 return err;
1155 if (kind != w83783s) {
1156 if ((err = device_create_file(dev,
1157 &sensor_dev_attr_temp3_type.dev_attr)))
1158 return err;
1159 }
1160 }
1161
1162 if (is_isa) {
1163 err = device_create_file(&pdev->dev, &dev_attr_name);
1164 if (err)
1165 return err;
1166 }
1167
1168 return 0;
1169 }
1170
1171 static int
1172 w83781d_detect(struct i2c_adapter *adapter, int address, int kind)
1173 {
1174 int val1 = 0, val2;
1175 struct i2c_client *client;
1176 struct device *dev;
1177 struct w83781d_data *data;
1178 int err;
1179 const char *client_name = "";
1180 enum vendor { winbond, asus } vendid;
1181
1182 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1183 err = -EINVAL;
1184 goto ERROR1;
1185 }
1186
1187 /* OK. For now, we presume we have a valid client. We now create the
1188 client structure, even though we cannot fill it completely yet.
1189 But it allows us to access w83781d_{read,write}_value. */
1190
1191 if (!(data = kzalloc(sizeof(struct w83781d_data), GFP_KERNEL))) {
1192 err = -ENOMEM;
1193 goto ERROR1;
1194 }
1195
1196 client = &data->client;
1197 i2c_set_clientdata(client, data);
1198 client->addr = address;
1199 mutex_init(&data->lock);
1200 client->adapter = adapter;
1201 client->driver = &w83781d_driver;
1202 dev = &client->dev;
1203
1204 /* Now, we do the remaining detection. */
1205
1206 /* The w8378?d may be stuck in some other bank than bank 0. This may
1207 make reading other information impossible. Specify a force=... or
1208 force_*=... parameter, and the Winbond will be reset to the right
1209 bank. */
1210 if (kind < 0) {
1211 if (w83781d_read_value(data, W83781D_REG_CONFIG) & 0x80) {
1212 dev_dbg(&adapter->dev, "Detection of w83781d chip "
1213 "failed at step 3\n");
1214 err = -ENODEV;
1215 goto ERROR2;
1216 }
1217 val1 = w83781d_read_value(data, W83781D_REG_BANK);
1218 val2 = w83781d_read_value(data, W83781D_REG_CHIPMAN);
1219 /* Check for Winbond or Asus ID if in bank 0 */
1220 if ((!(val1 & 0x07)) &&
1221 (((!(val1 & 0x80)) && (val2 != 0xa3) && (val2 != 0xc3))
1222 || ((val1 & 0x80) && (val2 != 0x5c) && (val2 != 0x12)))) {
1223 dev_dbg(&adapter->dev, "Detection of w83781d chip "
1224 "failed at step 4\n");
1225 err = -ENODEV;
1226 goto ERROR2;
1227 }
1228 /* If Winbond SMBus, check address at 0x48.
1229 Asus doesn't support, except for as99127f rev.2 */
1230 if ((!(val1 & 0x80) && (val2 == 0xa3)) ||
1231 ((val1 & 0x80) && (val2 == 0x5c))) {
1232 if (w83781d_read_value
1233 (data, W83781D_REG_I2C_ADDR) != address) {
1234 dev_dbg(&adapter->dev, "Detection of w83781d "
1235 "chip failed at step 5\n");
1236 err = -ENODEV;
1237 goto ERROR2;
1238 }
1239 }
1240 }
1241
1242 /* We have either had a force parameter, or we have already detected the
1243 Winbond. Put it now into bank 0 and Vendor ID High Byte */
1244 w83781d_write_value(data, W83781D_REG_BANK,
1245 (w83781d_read_value(data, W83781D_REG_BANK)
1246 & 0x78) | 0x80);
1247
1248 /* Determine the chip type. */
1249 if (kind <= 0) {
1250 /* get vendor ID */
1251 val2 = w83781d_read_value(data, W83781D_REG_CHIPMAN);
1252 if (val2 == 0x5c)
1253 vendid = winbond;
1254 else if (val2 == 0x12)
1255 vendid = asus;
1256 else {
1257 dev_dbg(&adapter->dev, "w83781d chip vendor is "
1258 "neither Winbond nor Asus\n");
1259 err = -ENODEV;
1260 goto ERROR2;
1261 }
1262
1263 val1 = w83781d_read_value(data, W83781D_REG_WCHIPID);
1264 if ((val1 == 0x10 || val1 == 0x11) && vendid == winbond)
1265 kind = w83781d;
1266 else if (val1 == 0x30 && vendid == winbond)
1267 kind = w83782d;
1268 else if (val1 == 0x40 && vendid == winbond && address == 0x2d)
1269 kind = w83783s;
1270 else if (val1 == 0x21 && vendid == winbond)
1271 kind = w83627hf;
1272 else if (val1 == 0x31 && address >= 0x28)
1273 kind = as99127f;
1274 else {
1275 if (kind == 0)
1276 dev_warn(&adapter->dev, "Ignoring 'force' "
1277 "parameter for unknown chip at "
1278 "address 0x%02x\n", address);
1279 err = -EINVAL;
1280 goto ERROR2;
1281 }
1282 }
1283
1284 if (kind == w83781d) {
1285 client_name = "w83781d";
1286 } else if (kind == w83782d) {
1287 client_name = "w83782d";
1288 } else if (kind == w83783s) {
1289 client_name = "w83783s";
1290 } else if (kind == w83627hf) {
1291 client_name = "w83627hf";
1292 } else if (kind == as99127f) {
1293 client_name = "as99127f";
1294 }
1295
1296 /* Fill in the remaining client fields and put into the global list */
1297 strlcpy(client->name, client_name, I2C_NAME_SIZE);
1298 data->type = kind;
1299
1300 /* Tell the I2C layer a new client has arrived */
1301 if ((err = i2c_attach_client(client)))
1302 goto ERROR2;
1303
1304 /* attach secondary i2c lm75-like clients */
1305 if ((err = w83781d_detect_subclients(adapter, address,
1306 kind, client)))
1307 goto ERROR3;
1308
1309 /* Initialize the chip */
1310 w83781d_init_device(dev);
1311
1312 /* Register sysfs hooks */
1313 err = w83781d_create_files(dev, kind, 0);
1314 if (err)
1315 goto ERROR4;
1316
1317 data->hwmon_dev = hwmon_device_register(dev);
1318 if (IS_ERR(data->hwmon_dev)) {
1319 err = PTR_ERR(data->hwmon_dev);
1320 goto ERROR4;
1321 }
1322
1323 return 0;
1324
1325 ERROR4:
1326 sysfs_remove_group(&dev->kobj, &w83781d_group);
1327 sysfs_remove_group(&dev->kobj, &w83781d_group_opt);
1328
1329 if (data->lm75[1]) {
1330 i2c_detach_client(data->lm75[1]);
1331 kfree(data->lm75[1]);
1332 }
1333 if (data->lm75[0]) {
1334 i2c_detach_client(data->lm75[0]);
1335 kfree(data->lm75[0]);
1336 }
1337 ERROR3:
1338 i2c_detach_client(client);
1339 ERROR2:
1340 kfree(data);
1341 ERROR1:
1342 return err;
1343 }
1344
1345 static int
1346 w83781d_detach_client(struct i2c_client *client)
1347 {
1348 struct w83781d_data *data = i2c_get_clientdata(client);
1349 int err;
1350
1351 /* main client */
1352 if (data) {
1353 hwmon_device_unregister(data->hwmon_dev);
1354 sysfs_remove_group(&client->dev.kobj, &w83781d_group);
1355 sysfs_remove_group(&client->dev.kobj, &w83781d_group_opt);
1356 }
1357
1358 if ((err = i2c_detach_client(client)))
1359 return err;
1360
1361 /* main client */
1362 if (data)
1363 kfree(data);
1364
1365 /* subclient */
1366 else
1367 kfree(client);
1368
1369 return 0;
1370 }
1371
1372 static int __devinit
1373 w83781d_isa_probe(struct platform_device *pdev)
1374 {
1375 int err, reg;
1376 struct w83781d_data *data;
1377 struct resource *res;
1378 const char *name;
1379
1380 /* Reserve the ISA region */
1381 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1382 if (!request_region(res->start, W83781D_EXTENT, "w83781d")) {
1383 err = -EBUSY;
1384 goto exit;
1385 }
1386
1387 if (!(data = kzalloc(sizeof(struct w83781d_data), GFP_KERNEL))) {
1388 err = -ENOMEM;
1389 goto exit_release_region;
1390 }
1391 mutex_init(&data->lock);
1392 data->client.addr = res->start;
1393 i2c_set_clientdata(&data->client, data);
1394 platform_set_drvdata(pdev, data);
1395
1396 reg = w83781d_read_value(data, W83781D_REG_WCHIPID);
1397 switch (reg) {
1398 case 0x21:
1399 data->type = w83627hf;
1400 name = "w83627hf";
1401 break;
1402 case 0x30:
1403 data->type = w83782d;
1404 name = "w83782d";
1405 break;
1406 default:
1407 data->type = w83781d;
1408 name = "w83781d";
1409 }
1410 strlcpy(data->client.name, name, I2C_NAME_SIZE);
1411
1412 /* Initialize the W83781D chip */
1413 w83781d_init_device(&pdev->dev);
1414
1415 /* Register sysfs hooks */
1416 err = w83781d_create_files(&pdev->dev, data->type, 1);
1417 if (err)
1418 goto exit_remove_files;
1419
1420 data->hwmon_dev = hwmon_device_register(&pdev->dev);
1421 if (IS_ERR(data->hwmon_dev)) {
1422 err = PTR_ERR(data->hwmon_dev);
1423 goto exit_remove_files;
1424 }
1425
1426 return 0;
1427
1428 exit_remove_files:
1429 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group);
1430 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group_opt);
1431 device_remove_file(&pdev->dev, &dev_attr_name);
1432 kfree(data);
1433 exit_release_region:
1434 release_region(res->start, W83781D_EXTENT);
1435 exit:
1436 return err;
1437 }
1438
1439 static int __devexit
1440 w83781d_isa_remove(struct platform_device *pdev)
1441 {
1442 struct w83781d_data *data = platform_get_drvdata(pdev);
1443
1444 hwmon_device_unregister(data->hwmon_dev);
1445 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group);
1446 sysfs_remove_group(&pdev->dev.kobj, &w83781d_group_opt);
1447 device_remove_file(&pdev->dev, &dev_attr_name);
1448 release_region(data->client.addr, W83781D_EXTENT);
1449 kfree(data);
1450
1451 return 0;
1452 }
1453
1454 /* The SMBus locks itself, usually, but nothing may access the Winbond between
1455 bank switches. ISA access must always be locked explicitly!
1456 We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
1457 would slow down the W83781D access and should not be necessary.
1458 There are some ugly typecasts here, but the good news is - they should
1459 nowhere else be necessary! */
1460 static int
1461 w83781d_read_value(struct w83781d_data *data, u16 reg)
1462 {
1463 struct i2c_client *client = &data->client;
1464 int res, word_sized, bank;
1465 struct i2c_client *cl;
1466
1467 mutex_lock(&data->lock);
1468 if (!client->driver) { /* ISA device */
1469 word_sized = (((reg & 0xff00) == 0x100)
1470 || ((reg & 0xff00) == 0x200))
1471 && (((reg & 0x00ff) == 0x50)
1472 || ((reg & 0x00ff) == 0x53)
1473 || ((reg & 0x00ff) == 0x55));
1474 if (reg & 0xff00) {
1475 outb_p(W83781D_REG_BANK,
1476 client->addr + W83781D_ADDR_REG_OFFSET);
1477 outb_p(reg >> 8,
1478 client->addr + W83781D_DATA_REG_OFFSET);
1479 }
1480 outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
1481 res = inb_p(client->addr + W83781D_DATA_REG_OFFSET);
1482 if (word_sized) {
1483 outb_p((reg & 0xff) + 1,
1484 client->addr + W83781D_ADDR_REG_OFFSET);
1485 res =
1486 (res << 8) + inb_p(client->addr +
1487 W83781D_DATA_REG_OFFSET);
1488 }
1489 if (reg & 0xff00) {
1490 outb_p(W83781D_REG_BANK,
1491 client->addr + W83781D_ADDR_REG_OFFSET);
1492 outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
1493 }
1494 } else {
1495 bank = (reg >> 8) & 0x0f;
1496 if (bank > 2)
1497 /* switch banks */
1498 i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
1499 bank);
1500 if (bank == 0 || bank > 2) {
1501 res = i2c_smbus_read_byte_data(client, reg & 0xff);
1502 } else {
1503 /* switch to subclient */
1504 cl = data->lm75[bank - 1];
1505 /* convert from ISA to LM75 I2C addresses */
1506 switch (reg & 0xff) {
1507 case 0x50: /* TEMP */
1508 res = swab16(i2c_smbus_read_word_data(cl, 0));
1509 break;
1510 case 0x52: /* CONFIG */
1511 res = i2c_smbus_read_byte_data(cl, 1);
1512 break;
1513 case 0x53: /* HYST */
1514 res = swab16(i2c_smbus_read_word_data(cl, 2));
1515 break;
1516 case 0x55: /* OVER */
1517 default:
1518 res = swab16(i2c_smbus_read_word_data(cl, 3));
1519 break;
1520 }
1521 }
1522 if (bank > 2)
1523 i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
1524 }
1525 mutex_unlock(&data->lock);
1526 return res;
1527 }
1528
1529 static int
1530 w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value)
1531 {
1532 struct i2c_client *client = &data->client;
1533 int word_sized, bank;
1534 struct i2c_client *cl;
1535
1536 mutex_lock(&data->lock);
1537 if (!client->driver) { /* ISA device */
1538 word_sized = (((reg & 0xff00) == 0x100)
1539 || ((reg & 0xff00) == 0x200))
1540 && (((reg & 0x00ff) == 0x53)
1541 || ((reg & 0x00ff) == 0x55));
1542 if (reg & 0xff00) {
1543 outb_p(W83781D_REG_BANK,
1544 client->addr + W83781D_ADDR_REG_OFFSET);
1545 outb_p(reg >> 8,
1546 client->addr + W83781D_DATA_REG_OFFSET);
1547 }
1548 outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
1549 if (word_sized) {
1550 outb_p(value >> 8,
1551 client->addr + W83781D_DATA_REG_OFFSET);
1552 outb_p((reg & 0xff) + 1,
1553 client->addr + W83781D_ADDR_REG_OFFSET);
1554 }
1555 outb_p(value & 0xff, client->addr + W83781D_DATA_REG_OFFSET);
1556 if (reg & 0xff00) {
1557 outb_p(W83781D_REG_BANK,
1558 client->addr + W83781D_ADDR_REG_OFFSET);
1559 outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
1560 }
1561 } else {
1562 bank = (reg >> 8) & 0x0f;
1563 if (bank > 2)
1564 /* switch banks */
1565 i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
1566 bank);
1567 if (bank == 0 || bank > 2) {
1568 i2c_smbus_write_byte_data(client, reg & 0xff,
1569 value & 0xff);
1570 } else {
1571 /* switch to subclient */
1572 cl = data->lm75[bank - 1];
1573 /* convert from ISA to LM75 I2C addresses */
1574 switch (reg & 0xff) {
1575 case 0x52: /* CONFIG */
1576 i2c_smbus_write_byte_data(cl, 1, value & 0xff);
1577 break;
1578 case 0x53: /* HYST */
1579 i2c_smbus_write_word_data(cl, 2, swab16(value));
1580 break;
1581 case 0x55: /* OVER */
1582 i2c_smbus_write_word_data(cl, 3, swab16(value));
1583 break;
1584 }
1585 }
1586 if (bank > 2)
1587 i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
1588 }
1589 mutex_unlock(&data->lock);
1590 return 0;
1591 }
1592
1593 static void
1594 w83781d_init_device(struct device *dev)
1595 {
1596 struct w83781d_data *data = dev_get_drvdata(dev);
1597 int i, p;
1598 int type = data->type;
1599 u8 tmp;
1600
1601 if (type == w83627hf)
1602 dev_info(dev, "The W83627HF chip is better supported by the "
1603 "w83627hf driver, support will be dropped from the "
1604 "w83781d driver soon\n");
1605
1606 if (reset && type != as99127f) { /* this resets registers we don't have
1607 documentation for on the as99127f */
1608 /* Resetting the chip has been the default for a long time,
1609 but it causes the BIOS initializations (fan clock dividers,
1610 thermal sensor types...) to be lost, so it is now optional.
1611 It might even go away if nobody reports it as being useful,
1612 as I see very little reason why this would be needed at
1613 all. */
1614 dev_info(dev, "If reset=1 solved a problem you were "
1615 "having, please report!\n");
1616
1617 /* save these registers */
1618 i = w83781d_read_value(data, W83781D_REG_BEEP_CONFIG);
1619 p = w83781d_read_value(data, W83781D_REG_PWMCLK12);
1620 /* Reset all except Watchdog values and last conversion values
1621 This sets fan-divs to 2, among others */
1622 w83781d_write_value(data, W83781D_REG_CONFIG, 0x80);
1623 /* Restore the registers and disable power-on abnormal beep.
1624 This saves FAN 1/2/3 input/output values set by BIOS. */
1625 w83781d_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80);
1626 w83781d_write_value(data, W83781D_REG_PWMCLK12, p);
1627 /* Disable master beep-enable (reset turns it on).
1628 Individual beep_mask should be reset to off but for some reason
1629 disabling this bit helps some people not get beeped */
1630 w83781d_write_value(data, W83781D_REG_BEEP_INTS2, 0);
1631 }
1632
1633 /* Disable power-on abnormal beep, as advised by the datasheet.
1634 Already done if reset=1. */
1635 if (init && !reset && type != as99127f) {
1636 i = w83781d_read_value(data, W83781D_REG_BEEP_CONFIG);
1637 w83781d_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80);
1638 }
1639
1640 data->vrm = vid_which_vrm();
1641
1642 if ((type != w83781d) && (type != as99127f)) {
1643 tmp = w83781d_read_value(data, W83781D_REG_SCFG1);
1644 for (i = 1; i <= 3; i++) {
1645 if (!(tmp & BIT_SCFG1[i - 1])) {
1646 data->sens[i - 1] = 4;
1647 } else {
1648 if (w83781d_read_value
1649 (data,
1650 W83781D_REG_SCFG2) & BIT_SCFG2[i - 1])
1651 data->sens[i - 1] = 1;
1652 else
1653 data->sens[i - 1] = 2;
1654 }
1655 if (type == w83783s && i == 2)
1656 break;
1657 }
1658 }
1659
1660 if (init && type != as99127f) {
1661 /* Enable temp2 */
1662 tmp = w83781d_read_value(data, W83781D_REG_TEMP2_CONFIG);
1663 if (tmp & 0x01) {
1664 dev_warn(dev, "Enabling temp2, readings "
1665 "might not make sense\n");
1666 w83781d_write_value(data, W83781D_REG_TEMP2_CONFIG,
1667 tmp & 0xfe);
1668 }
1669
1670 /* Enable temp3 */
1671 if (type != w83783s) {
1672 tmp = w83781d_read_value(data,
1673 W83781D_REG_TEMP3_CONFIG);
1674 if (tmp & 0x01) {
1675 dev_warn(dev, "Enabling temp3, "
1676 "readings might not make sense\n");
1677 w83781d_write_value(data,
1678 W83781D_REG_TEMP3_CONFIG, tmp & 0xfe);
1679 }
1680 }
1681 }
1682
1683 /* Start monitoring */
1684 w83781d_write_value(data, W83781D_REG_CONFIG,
1685 (w83781d_read_value(data,
1686 W83781D_REG_CONFIG) & 0xf7)
1687 | 0x01);
1688
1689 /* A few vars need to be filled upon startup */
1690 for (i = 0; i < 3; i++) {
1691 data->fan_min[i] = w83781d_read_value(data,
1692 W83781D_REG_FAN_MIN(i));
1693 }
1694
1695 mutex_init(&data->update_lock);
1696 }
1697
1698 static struct w83781d_data *w83781d_update_device(struct device *dev)
1699 {
1700 struct w83781d_data *data = dev_get_drvdata(dev);
1701 struct i2c_client *client = &data->client;
1702 int i;
1703
1704 mutex_lock(&data->update_lock);
1705
1706 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1707 || !data->valid) {
1708 dev_dbg(dev, "Starting device update\n");
1709
1710 for (i = 0; i <= 8; i++) {
1711 if (data->type == w83783s && i == 1)
1712 continue; /* 783S has no in1 */
1713 data->in[i] =
1714 w83781d_read_value(data, W83781D_REG_IN(i));
1715 data->in_min[i] =
1716 w83781d_read_value(data, W83781D_REG_IN_MIN(i));
1717 data->in_max[i] =
1718 w83781d_read_value(data, W83781D_REG_IN_MAX(i));
1719 if ((data->type != w83782d)
1720 && (data->type != w83627hf) && (i == 6))
1721 break;
1722 }
1723 for (i = 0; i < 3; i++) {
1724 data->fan[i] =
1725 w83781d_read_value(data, W83781D_REG_FAN(i));
1726 data->fan_min[i] =
1727 w83781d_read_value(data, W83781D_REG_FAN_MIN(i));
1728 }
1729 if (data->type != w83781d && data->type != as99127f) {
1730 for (i = 0; i < 4; i++) {
1731 data->pwm[i] =
1732 w83781d_read_value(data,
1733 W83781D_REG_PWM[i]);
1734 if ((data->type != w83782d || !client->driver)
1735 && i == 1)
1736 break;
1737 }
1738 /* Only PWM2 can be disabled */
1739 data->pwm2_enable = (w83781d_read_value(data,
1740 W83781D_REG_PWMCLK12) & 0x08) >> 3;
1741 }
1742
1743 data->temp = w83781d_read_value(data, W83781D_REG_TEMP(1));
1744 data->temp_max =
1745 w83781d_read_value(data, W83781D_REG_TEMP_OVER(1));
1746 data->temp_max_hyst =
1747 w83781d_read_value(data, W83781D_REG_TEMP_HYST(1));
1748 data->temp_add[0] =
1749 w83781d_read_value(data, W83781D_REG_TEMP(2));
1750 data->temp_max_add[0] =
1751 w83781d_read_value(data, W83781D_REG_TEMP_OVER(2));
1752 data->temp_max_hyst_add[0] =
1753 w83781d_read_value(data, W83781D_REG_TEMP_HYST(2));
1754 if (data->type != w83783s) {
1755 data->temp_add[1] =
1756 w83781d_read_value(data, W83781D_REG_TEMP(3));
1757 data->temp_max_add[1] =
1758 w83781d_read_value(data,
1759 W83781D_REG_TEMP_OVER(3));
1760 data->temp_max_hyst_add[1] =
1761 w83781d_read_value(data,
1762 W83781D_REG_TEMP_HYST(3));
1763 }
1764 i = w83781d_read_value(data, W83781D_REG_VID_FANDIV);
1765 data->vid = i & 0x0f;
1766 data->vid |= (w83781d_read_value(data,
1767 W83781D_REG_CHIPID) & 0x01) << 4;
1768 data->fan_div[0] = (i >> 4) & 0x03;
1769 data->fan_div[1] = (i >> 6) & 0x03;
1770 data->fan_div[2] = (w83781d_read_value(data,
1771 W83781D_REG_PIN) >> 6) & 0x03;
1772 if ((data->type != w83781d) && (data->type != as99127f)) {
1773 i = w83781d_read_value(data, W83781D_REG_VBAT);
1774 data->fan_div[0] |= (i >> 3) & 0x04;
1775 data->fan_div[1] |= (i >> 4) & 0x04;
1776 data->fan_div[2] |= (i >> 5) & 0x04;
1777 }
1778 if ((data->type == w83782d) || (data->type == w83627hf)) {
1779 data->alarms = w83781d_read_value(data,
1780 W83782D_REG_ALARM1)
1781 | (w83781d_read_value(data,
1782 W83782D_REG_ALARM2) << 8)
1783 | (w83781d_read_value(data,
1784 W83782D_REG_ALARM3) << 16);
1785 } else if (data->type == w83783s) {
1786 data->alarms = w83781d_read_value(data,
1787 W83782D_REG_ALARM1)
1788 | (w83781d_read_value(data,
1789 W83782D_REG_ALARM2) << 8);
1790 } else {
1791 /* No real-time status registers, fall back to
1792 interrupt status registers */
1793 data->alarms = w83781d_read_value(data,
1794 W83781D_REG_ALARM1)
1795 | (w83781d_read_value(data,
1796 W83781D_REG_ALARM2) << 8);
1797 }
1798 i = w83781d_read_value(data, W83781D_REG_BEEP_INTS2);
1799 data->beep_enable = i >> 7;
1800 data->beep_mask = ((i & 0x7f) << 8) +
1801 w83781d_read_value(data, W83781D_REG_BEEP_INTS1);
1802 if ((data->type != w83781d) && (data->type != as99127f)) {
1803 data->beep_mask |=
1804 w83781d_read_value(data,
1805 W83781D_REG_BEEP_INTS3) << 16;
1806 }
1807 data->last_updated = jiffies;
1808 data->valid = 1;
1809 }
1810
1811 mutex_unlock(&data->update_lock);
1812
1813 return data;
1814 }
1815
1816 /* return 1 if a supported chip is found, 0 otherwise */
1817 static int __init
1818 w83781d_isa_found(unsigned short address)
1819 {
1820 int val, save, found = 0;
1821
1822 if (!request_region(address, W83781D_EXTENT, "w83781d"))
1823 return 0;
1824
1825 #define REALLY_SLOW_IO
1826 /* We need the timeouts for at least some W83781D-like
1827 chips. But only if we read 'undefined' registers. */
1828 val = inb_p(address + 1);
1829 if (inb_p(address + 2) != val
1830 || inb_p(address + 3) != val
1831 || inb_p(address + 7) != val) {
1832 pr_debug("w83781d: Detection failed at step 1\n");
1833 goto release;
1834 }
1835 #undef REALLY_SLOW_IO
1836
1837 /* We should be able to change the 7 LSB of the address port. The
1838 MSB (busy flag) should be clear initially, set after the write. */
1839 save = inb_p(address + W83781D_ADDR_REG_OFFSET);
1840 if (save & 0x80) {
1841 pr_debug("w83781d: Detection failed at step 2\n");
1842 goto release;
1843 }
1844 val = ~save & 0x7f;
1845 outb_p(val, address + W83781D_ADDR_REG_OFFSET);
1846 if (inb_p(address + W83781D_ADDR_REG_OFFSET) != (val | 0x80)) {
1847 outb_p(save, address + W83781D_ADDR_REG_OFFSET);
1848 pr_debug("w83781d: Detection failed at step 3\n");
1849 goto release;
1850 }
1851
1852 /* We found a device, now see if it could be a W83781D */
1853 outb_p(W83781D_REG_CONFIG, address + W83781D_ADDR_REG_OFFSET);
1854 val = inb_p(address + W83781D_DATA_REG_OFFSET);
1855 if (val & 0x80) {
1856 pr_debug("w83781d: Detection failed at step 4\n");
1857 goto release;
1858 }
1859 outb_p(W83781D_REG_BANK, address + W83781D_ADDR_REG_OFFSET);
1860 save = inb_p(address + W83781D_DATA_REG_OFFSET);
1861 outb_p(W83781D_REG_CHIPMAN, address + W83781D_ADDR_REG_OFFSET);
1862 val = inb_p(address + W83781D_DATA_REG_OFFSET);
1863 if ((!(save & 0x80) && (val != 0xa3))
1864 || ((save & 0x80) && (val != 0x5c))) {
1865 pr_debug("w83781d: Detection failed at step 5\n");
1866 goto release;
1867 }
1868 outb_p(W83781D_REG_I2C_ADDR, address + W83781D_ADDR_REG_OFFSET);
1869 val = inb_p(address + W83781D_DATA_REG_OFFSET);
1870 if (val < 0x03 || val > 0x77) { /* Not a valid I2C address */
1871 pr_debug("w83781d: Detection failed at step 6\n");
1872 goto release;
1873 }
1874
1875 /* The busy flag should be clear again */
1876 if (inb_p(address + W83781D_ADDR_REG_OFFSET) & 0x80) {
1877 pr_debug("w83781d: Detection failed at step 7\n");
1878 goto release;
1879 }
1880
1881 /* Determine the chip type */
1882 outb_p(W83781D_REG_BANK, address + W83781D_ADDR_REG_OFFSET);
1883 save = inb_p(address + W83781D_DATA_REG_OFFSET);
1884 outb_p(save & 0xf8, address + W83781D_DATA_REG_OFFSET);
1885 outb_p(W83781D_REG_WCHIPID, address + W83781D_ADDR_REG_OFFSET);
1886 val = inb_p(address + W83781D_DATA_REG_OFFSET);
1887 if ((val & 0xfe) == 0x10 /* W83781D */
1888 || val == 0x30 /* W83782D */
1889 || val == 0x21) /* W83627HF */
1890 found = 1;
1891
1892 if (found)
1893 pr_info("w83781d: Found a %s chip at %#x\n",
1894 val == 0x21 ? "W83627HF" :
1895 val == 0x30 ? "W83782D" : "W83781D", (int)address);
1896
1897 release:
1898 release_region(address, W83781D_EXTENT);
1899 return found;
1900 }
1901
1902 static int __init
1903 w83781d_isa_device_add(unsigned short address)
1904 {
1905 struct resource res = {
1906 .start = address,
1907 .end = address + W83781D_EXTENT - 1,
1908 .name = "w83781d",
1909 .flags = IORESOURCE_IO,
1910 };
1911 int err;
1912
1913 pdev = platform_device_alloc("w83781d", address);
1914 if (!pdev) {
1915 err = -ENOMEM;
1916 printk(KERN_ERR "w83781d: Device allocation failed\n");
1917 goto exit;
1918 }
1919
1920 err = platform_device_add_resources(pdev, &res, 1);
1921 if (err) {
1922 printk(KERN_ERR "w83781d: Device resource addition failed "
1923 "(%d)\n", err);
1924 goto exit_device_put;
1925 }
1926
1927 err = platform_device_add(pdev);
1928 if (err) {
1929 printk(KERN_ERR "w83781d: Device addition failed (%d)\n",
1930 err);
1931 goto exit_device_put;
1932 }
1933
1934 return 0;
1935
1936 exit_device_put:
1937 platform_device_put(pdev);
1938 exit:
1939 pdev = NULL;
1940 return err;
1941 }
1942
1943 static int __init
1944 sensors_w83781d_init(void)
1945 {
1946 int res;
1947
1948 res = i2c_add_driver(&w83781d_driver);
1949 if (res)
1950 goto exit;
1951
1952 if (w83781d_isa_found(isa_address)) {
1953 res = platform_driver_register(&w83781d_isa_driver);
1954 if (res)
1955 goto exit_unreg_i2c_driver;
1956
1957 /* Sets global pdev as a side effect */
1958 res = w83781d_isa_device_add(isa_address);
1959 if (res)
1960 goto exit_unreg_isa_driver;
1961 }
1962
1963 return 0;
1964
1965 exit_unreg_isa_driver:
1966 platform_driver_unregister(&w83781d_isa_driver);
1967 exit_unreg_i2c_driver:
1968 i2c_del_driver(&w83781d_driver);
1969 exit:
1970 return res;
1971 }
1972
1973 static void __exit
1974 sensors_w83781d_exit(void)
1975 {
1976 if (pdev) {
1977 platform_device_unregister(pdev);
1978 platform_driver_unregister(&w83781d_isa_driver);
1979 }
1980 i2c_del_driver(&w83781d_driver);
1981 }
1982
1983 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
1984 "Philip Edelbrock <phil@netroedge.com>, "
1985 "and Mark Studebaker <mdsxyz123@yahoo.com>");
1986 MODULE_DESCRIPTION("W83781D driver");
1987 MODULE_LICENSE("GPL");
1988
1989 module_init(sensors_w83781d_init);
1990 module_exit(sensors_w83781d_exit);
Support for the Chinese Samsung S3C2440 based development boards