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