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