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