?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
NFSv4: Ensure nfs4_lock_expired() caches delegated locks
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / hwmon / w83627ehf.c
blob40301bc6ce186e5a1c92c7a7d9964e945807dac7
1 /*
2 w83627ehf - Driver for the hardware monitoring functionality of
3 the Winbond W83627EHF Super-I/O chip
4 Copyright (C) 2005 Jean Delvare <khali@linux-fr.org>
5
6 Shamelessly ripped from the w83627hf driver
7 Copyright (C) 2003 Mark Studebaker
8
9 Thanks to Leon Moonen, Steve Cliffe and Grant Coady for their help
10 in testing and debugging this driver.
11
12 This driver also supports the W83627EHG, which is the lead-free
13 version of the W83627EHF.
14
15 This program is free software; you can redistribute it and/or modify
16 it under the terms of the GNU General Public License as published by
17 the Free Software Foundation; either version 2 of the License, or
18 (at your option) any later version.
19
20 This program is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 GNU General Public License for more details.
24
25 You should have received a copy of the GNU General Public License
26 along with this program; if not, write to the Free Software
27 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28
29
30 Supports the following chips:
31
32 Chip #vin #fan #pwm #temp chip_id man_id
33 w83627ehf 10 5 - 3 0x88 0x5ca3
34 */
35
36 #include <linux/module.h>
37 #include <linux/init.h>
38 #include <linux/slab.h>
39 #include <linux/i2c.h>
40 #include <linux/i2c-isa.h>
41 #include <linux/hwmon.h>
42 #include <linux/hwmon-sysfs.h>
43 #include <linux/err.h>
44 #include <linux/mutex.h>
45 #include <asm/io.h>
46 #include "lm75.h"
47
48 /* The actual ISA address is read from Super-I/O configuration space */
49 static unsigned short address;
50
51 /*
52 * Super-I/O constants and functions
53 */
54
55 static int REG; /* The register to read/write */
56 static int VAL; /* The value to read/write */
57
58 #define W83627EHF_LD_HWM 0x0b
59
60 #define SIO_REG_LDSEL 0x07 /* Logical device select */
61 #define SIO_REG_DEVID 0x20 /* Device ID (2 bytes) */
62 #define SIO_REG_ENABLE 0x30 /* Logical device enable */
63 #define SIO_REG_ADDR 0x60 /* Logical device address (2 bytes) */
64
65 #define SIO_W83627EHF_ID 0x8840
66 #define SIO_ID_MASK 0xFFC0
67
68 static inline void
69 superio_outb(int reg, int val)
70 {
71 outb(reg, REG);
72 outb(val, VAL);
73 }
74
75 static inline int
76 superio_inb(int reg)
77 {
78 outb(reg, REG);
79 return inb(VAL);
80 }
81
82 static inline void
83 superio_select(int ld)
84 {
85 outb(SIO_REG_LDSEL, REG);
86 outb(ld, VAL);
87 }
88
89 static inline void
90 superio_enter(void)
91 {
92 outb(0x87, REG);
93 outb(0x87, REG);
94 }
95
96 static inline void
97 superio_exit(void)
98 {
99 outb(0x02, REG);
100 outb(0x02, VAL);
101 }
102
103 /*
104 * ISA constants
105 */
106
107 #define REGION_ALIGNMENT ~7
108 #define REGION_OFFSET 5
109 #define REGION_LENGTH 2
110 #define ADDR_REG_OFFSET 5
111 #define DATA_REG_OFFSET 6
112
113 #define W83627EHF_REG_BANK 0x4E
114 #define W83627EHF_REG_CONFIG 0x40
115 #define W83627EHF_REG_CHIP_ID 0x49
116 #define W83627EHF_REG_MAN_ID 0x4F
117
118 static const u16 W83627EHF_REG_FAN[] = { 0x28, 0x29, 0x2a, 0x3f, 0x553 };
119 static const u16 W83627EHF_REG_FAN_MIN[] = { 0x3b, 0x3c, 0x3d, 0x3e, 0x55c };
120
121 /* The W83627EHF registers for nr=7,8,9 are in bank 5 */
122 #define W83627EHF_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
123 (0x554 + (((nr) - 7) * 2)))
124 #define W83627EHF_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
125 (0x555 + (((nr) - 7) * 2)))
126 #define W83627EHF_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \
127 (0x550 + (nr) - 7))
128
129 #define W83627EHF_REG_TEMP1 0x27
130 #define W83627EHF_REG_TEMP1_HYST 0x3a
131 #define W83627EHF_REG_TEMP1_OVER 0x39
132 static const u16 W83627EHF_REG_TEMP[] = { 0x150, 0x250 };
133 static const u16 W83627EHF_REG_TEMP_HYST[] = { 0x153, 0x253 };
134 static const u16 W83627EHF_REG_TEMP_OVER[] = { 0x155, 0x255 };
135 static const u16 W83627EHF_REG_TEMP_CONFIG[] = { 0x152, 0x252 };
136
137 /* Fan clock dividers are spread over the following five registers */
138 #define W83627EHF_REG_FANDIV1 0x47
139 #define W83627EHF_REG_FANDIV2 0x4B
140 #define W83627EHF_REG_VBAT 0x5D
141 #define W83627EHF_REG_DIODE 0x59
142 #define W83627EHF_REG_SMI_OVT 0x4C
143
144 #define W83627EHF_REG_ALARM1 0x459
145 #define W83627EHF_REG_ALARM2 0x45A
146 #define W83627EHF_REG_ALARM3 0x45B
147
148 /*
149 * Conversions
150 */
151
152 static inline unsigned int
153 fan_from_reg(u8 reg, unsigned int div)
154 {
155 if (reg == 0 || reg == 255)
156 return 0;
157 return 1350000U / (reg * div);
158 }
159
160 static inline unsigned int
161 div_from_reg(u8 reg)
162 {
163 return 1 << reg;
164 }
165
166 static inline int
167 temp1_from_reg(s8 reg)
168 {
169 return reg * 1000;
170 }
171
172 static inline s8
173 temp1_to_reg(int temp)
174 {
175 if (temp <= -128000)
176 return -128;
177 if (temp >= 127000)
178 return 127;
179 if (temp < 0)
180 return (temp - 500) / 1000;
181 return (temp + 500) / 1000;
182 }
183
184 /* Some of analog inputs have internal scaling (2x), 8mV is ADC LSB */
185
186 static u8 scale_in[10] = { 8, 8, 16, 16, 8, 8, 8, 16, 16, 8 };
187
188 static inline long in_from_reg(u8 reg, u8 nr)
189 {
190 return reg * scale_in[nr];
191 }
192
193 static inline u8 in_to_reg(u32 val, u8 nr)
194 {
195 return SENSORS_LIMIT(((val + (scale_in[nr] / 2)) / scale_in[nr]), 0, 255);
196 }
197
198 /*
199 * Data structures and manipulation thereof
200 */
201
202 struct w83627ehf_data {
203 struct i2c_client client;
204 struct class_device *class_dev;
205 struct mutex lock;
206
207 struct mutex update_lock;
208 char valid; /* !=0 if following fields are valid */
209 unsigned long last_updated; /* In jiffies */
210
211 /* Register values */
212 u8 in[10]; /* Register value */
213 u8 in_max[10]; /* Register value */
214 u8 in_min[10]; /* Register value */
215 u8 fan[5];
216 u8 fan_min[5];
217 u8 fan_div[5];
218 u8 has_fan; /* some fan inputs can be disabled */
219 s8 temp1;
220 s8 temp1_max;
221 s8 temp1_max_hyst;
222 s16 temp[2];
223 s16 temp_max[2];
224 s16 temp_max_hyst[2];
225 u32 alarms;
226 };
227
228 static inline int is_word_sized(u16 reg)
229 {
230 return (((reg & 0xff00) == 0x100
231 || (reg & 0xff00) == 0x200)
232 && ((reg & 0x00ff) == 0x50
233 || (reg & 0x00ff) == 0x53
234 || (reg & 0x00ff) == 0x55));
235 }
236
237 /* We assume that the default bank is 0, thus the following two functions do
238 nothing for registers which live in bank 0. For others, they respectively
239 set the bank register to the correct value (before the register is
240 accessed), and back to 0 (afterwards). */
241 static inline void w83627ehf_set_bank(struct i2c_client *client, u16 reg)
242 {
243 if (reg & 0xff00) {
244 outb_p(W83627EHF_REG_BANK, client->addr + ADDR_REG_OFFSET);
245 outb_p(reg >> 8, client->addr + DATA_REG_OFFSET);
246 }
247 }
248
249 static inline void w83627ehf_reset_bank(struct i2c_client *client, u16 reg)
250 {
251 if (reg & 0xff00) {
252 outb_p(W83627EHF_REG_BANK, client->addr + ADDR_REG_OFFSET);
253 outb_p(0, client->addr + DATA_REG_OFFSET);
254 }
255 }
256
257 static u16 w83627ehf_read_value(struct i2c_client *client, u16 reg)
258 {
259 struct w83627ehf_data *data = i2c_get_clientdata(client);
260 int res, word_sized = is_word_sized(reg);
261
262 mutex_lock(&data->lock);
263
264 w83627ehf_set_bank(client, reg);
265 outb_p(reg & 0xff, client->addr + ADDR_REG_OFFSET);
266 res = inb_p(client->addr + DATA_REG_OFFSET);
267 if (word_sized) {
268 outb_p((reg & 0xff) + 1,
269 client->addr + ADDR_REG_OFFSET);
270 res = (res << 8) + inb_p(client->addr + DATA_REG_OFFSET);
271 }
272 w83627ehf_reset_bank(client, reg);
273
274 mutex_unlock(&data->lock);
275
276 return res;
277 }
278
279 static int w83627ehf_write_value(struct i2c_client *client, u16 reg, u16 value)
280 {
281 struct w83627ehf_data *data = i2c_get_clientdata(client);
282 int word_sized = is_word_sized(reg);
283
284 mutex_lock(&data->lock);
285
286 w83627ehf_set_bank(client, reg);
287 outb_p(reg & 0xff, client->addr + ADDR_REG_OFFSET);
288 if (word_sized) {
289 outb_p(value >> 8, client->addr + DATA_REG_OFFSET);
290 outb_p((reg & 0xff) + 1,
291 client->addr + ADDR_REG_OFFSET);
292 }
293 outb_p(value & 0xff, client->addr + DATA_REG_OFFSET);
294 w83627ehf_reset_bank(client, reg);
295
296 mutex_unlock(&data->lock);
297 return 0;
298 }
299
300 /* This function assumes that the caller holds data->update_lock */
301 static void w83627ehf_write_fan_div(struct i2c_client *client, int nr)
302 {
303 struct w83627ehf_data *data = i2c_get_clientdata(client);
304 u8 reg;
305
306 switch (nr) {
307 case 0:
308 reg = (w83627ehf_read_value(client, W83627EHF_REG_FANDIV1) & 0xcf)
309 | ((data->fan_div[0] & 0x03) << 4);
310 w83627ehf_write_value(client, W83627EHF_REG_FANDIV1, reg);
311 reg = (w83627ehf_read_value(client, W83627EHF_REG_VBAT) & 0xdf)
312 | ((data->fan_div[0] & 0x04) << 3);
313 w83627ehf_write_value(client, W83627EHF_REG_VBAT, reg);
314 break;
315 case 1:
316 reg = (w83627ehf_read_value(client, W83627EHF_REG_FANDIV1) & 0x3f)
317 | ((data->fan_div[1] & 0x03) << 6);
318 w83627ehf_write_value(client, W83627EHF_REG_FANDIV1, reg);
319 reg = (w83627ehf_read_value(client, W83627EHF_REG_VBAT) & 0xbf)
320 | ((data->fan_div[1] & 0x04) << 4);
321 w83627ehf_write_value(client, W83627EHF_REG_VBAT, reg);
322 break;
323 case 2:
324 reg = (w83627ehf_read_value(client, W83627EHF_REG_FANDIV2) & 0x3f)
325 | ((data->fan_div[2] & 0x03) << 6);
326 w83627ehf_write_value(client, W83627EHF_REG_FANDIV2, reg);
327 reg = (w83627ehf_read_value(client, W83627EHF_REG_VBAT) & 0x7f)
328 | ((data->fan_div[2] & 0x04) << 5);
329 w83627ehf_write_value(client, W83627EHF_REG_VBAT, reg);
330 break;
331 case 3:
332 reg = (w83627ehf_read_value(client, W83627EHF_REG_DIODE) & 0xfc)
333 | (data->fan_div[3] & 0x03);
334 w83627ehf_write_value(client, W83627EHF_REG_DIODE, reg);
335 reg = (w83627ehf_read_value(client, W83627EHF_REG_SMI_OVT) & 0x7f)
336 | ((data->fan_div[3] & 0x04) << 5);
337 w83627ehf_write_value(client, W83627EHF_REG_SMI_OVT, reg);
338 break;
339 case 4:
340 reg = (w83627ehf_read_value(client, W83627EHF_REG_DIODE) & 0x73)
341 | ((data->fan_div[4] & 0x03) << 3)
342 | ((data->fan_div[4] & 0x04) << 5);
343 w83627ehf_write_value(client, W83627EHF_REG_DIODE, reg);
344 break;
345 }
346 }
347
348 static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
349 {
350 struct i2c_client *client = to_i2c_client(dev);
351 struct w83627ehf_data *data = i2c_get_clientdata(client);
352 int i;
353
354 mutex_lock(&data->update_lock);
355
356 if (time_after(jiffies, data->last_updated + HZ)
357 || !data->valid) {
358 /* Fan clock dividers */
359 i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV1);
360 data->fan_div[0] = (i >> 4) & 0x03;
361 data->fan_div[1] = (i >> 6) & 0x03;
362 i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV2);
363 data->fan_div[2] = (i >> 6) & 0x03;
364 i = w83627ehf_read_value(client, W83627EHF_REG_VBAT);
365 data->fan_div[0] |= (i >> 3) & 0x04;
366 data->fan_div[1] |= (i >> 4) & 0x04;
367 data->fan_div[2] |= (i >> 5) & 0x04;
368 if (data->has_fan & ((1 << 3) | (1 << 4))) {
369 i = w83627ehf_read_value(client, W83627EHF_REG_DIODE);
370 data->fan_div[3] = i & 0x03;
371 data->fan_div[4] = ((i >> 2) & 0x03)
372 | ((i >> 5) & 0x04);
373 }
374 if (data->has_fan & (1 << 3)) {
375 i = w83627ehf_read_value(client, W83627EHF_REG_SMI_OVT);
376 data->fan_div[3] |= (i >> 5) & 0x04;
377 }
378
379 /* Measured voltages and limits */
380 for (i = 0; i < 10; i++) {
381 data->in[i] = w83627ehf_read_value(client,
382 W83627EHF_REG_IN(i));
383 data->in_min[i] = w83627ehf_read_value(client,
384 W83627EHF_REG_IN_MIN(i));
385 data->in_max[i] = w83627ehf_read_value(client,
386 W83627EHF_REG_IN_MAX(i));
387 }
388
389 /* Measured fan speeds and limits */
390 for (i = 0; i < 5; i++) {
391 if (!(data->has_fan & (1 << i)))
392 continue;
393
394 data->fan[i] = w83627ehf_read_value(client,
395 W83627EHF_REG_FAN[i]);
396 data->fan_min[i] = w83627ehf_read_value(client,
397 W83627EHF_REG_FAN_MIN[i]);
398
399 /* If we failed to measure the fan speed and clock
400 divider can be increased, let's try that for next
401 time */
402 if (data->fan[i] == 0xff
403 && data->fan_div[i] < 0x07) {
404 dev_dbg(&client->dev, "Increasing fan %d "
405 "clock divider from %u to %u\n",
406 i, div_from_reg(data->fan_div[i]),
407 div_from_reg(data->fan_div[i] + 1));
408 data->fan_div[i]++;
409 w83627ehf_write_fan_div(client, i);
410 /* Preserve min limit if possible */
411 if (data->fan_min[i] >= 2
412 && data->fan_min[i] != 255)
413 w83627ehf_write_value(client,
414 W83627EHF_REG_FAN_MIN[i],
415 (data->fan_min[i] /= 2));
416 }
417 }
418
419 /* Measured temperatures and limits */
420 data->temp1 = w83627ehf_read_value(client,
421 W83627EHF_REG_TEMP1);
422 data->temp1_max = w83627ehf_read_value(client,
423 W83627EHF_REG_TEMP1_OVER);
424 data->temp1_max_hyst = w83627ehf_read_value(client,
425 W83627EHF_REG_TEMP1_HYST);
426 for (i = 0; i < 2; i++) {
427 data->temp[i] = w83627ehf_read_value(client,
428 W83627EHF_REG_TEMP[i]);
429 data->temp_max[i] = w83627ehf_read_value(client,
430 W83627EHF_REG_TEMP_OVER[i]);
431 data->temp_max_hyst[i] = w83627ehf_read_value(client,
432 W83627EHF_REG_TEMP_HYST[i]);
433 }
434
435 data->alarms = w83627ehf_read_value(client,
436 W83627EHF_REG_ALARM1) |
437 (w83627ehf_read_value(client,
438 W83627EHF_REG_ALARM2) << 8) |
439 (w83627ehf_read_value(client,
440 W83627EHF_REG_ALARM3) << 16);
441
442 data->last_updated = jiffies;
443 data->valid = 1;
444 }
445
446 mutex_unlock(&data->update_lock);
447 return data;
448 }
449
450 /*
451 * Sysfs callback functions
452 */
453 #define show_in_reg(reg) \
454 static ssize_t \
455 show_##reg(struct device *dev, struct device_attribute *attr, \
456 char *buf) \
457 { \
458 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
459 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
460 int nr = sensor_attr->index; \
461 return sprintf(buf, "%ld\n", in_from_reg(data->reg[nr], nr)); \
462 }
463 show_in_reg(in)
464 show_in_reg(in_min)
465 show_in_reg(in_max)
466
467 #define store_in_reg(REG, reg) \
468 static ssize_t \
469 store_in_##reg (struct device *dev, struct device_attribute *attr, \
470 const char *buf, size_t count) \
471 { \
472 struct i2c_client *client = to_i2c_client(dev); \
473 struct w83627ehf_data *data = i2c_get_clientdata(client); \
474 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
475 int nr = sensor_attr->index; \
476 u32 val = simple_strtoul(buf, NULL, 10); \
477 \
478 mutex_lock(&data->update_lock); \
479 data->in_##reg[nr] = in_to_reg(val, nr); \
480 w83627ehf_write_value(client, W83627EHF_REG_IN_##REG(nr), \
481 data->in_##reg[nr]); \
482 mutex_unlock(&data->update_lock); \
483 return count; \
484 }
485
486 store_in_reg(MIN, min)
487 store_in_reg(MAX, max)
488
489 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, char *buf)
490 {
491 struct w83627ehf_data *data = w83627ehf_update_device(dev);
492 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
493 int nr = sensor_attr->index;
494 return sprintf(buf, "%u\n", (data->alarms >> nr) & 0x01);
495 }
496
497 static struct sensor_device_attribute sda_in_input[] = {
498 SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
499 SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
500 SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
501 SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
502 SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
503 SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
504 SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
505 SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
506 SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
507 SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
508 };
509
510 static struct sensor_device_attribute sda_in_alarm[] = {
511 SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0),
512 SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1),
513 SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2),
514 SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3),
515 SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8),
516 SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 21),
517 SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 20),
518 SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16),
519 SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17),
520 SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 19),
521 };
522
523 static struct sensor_device_attribute sda_in_min[] = {
524 SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
525 SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
526 SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
527 SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
528 SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
529 SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
530 SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
531 SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
532 SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
533 SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
534 };
535
536 static struct sensor_device_attribute sda_in_max[] = {
537 SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
538 SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
539 SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
540 SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
541 SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
542 SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
543 SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
544 SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
545 SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
546 SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
547 };
548
549 static void device_create_file_in(struct device *dev, int i)
550 {
551 device_create_file(dev, &sda_in_input[i].dev_attr);
552 device_create_file(dev, &sda_in_alarm[i].dev_attr);
553 device_create_file(dev, &sda_in_min[i].dev_attr);
554 device_create_file(dev, &sda_in_max[i].dev_attr);
555 }
556
557 #define show_fan_reg(reg) \
558 static ssize_t \
559 show_##reg(struct device *dev, struct device_attribute *attr, \
560 char *buf) \
561 { \
562 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
563 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
564 int nr = sensor_attr->index; \
565 return sprintf(buf, "%d\n", \
566 fan_from_reg(data->reg[nr], \
567 div_from_reg(data->fan_div[nr]))); \
568 }
569 show_fan_reg(fan);
570 show_fan_reg(fan_min);
571
572 static ssize_t
573 show_fan_div(struct device *dev, struct device_attribute *attr,
574 char *buf)
575 {
576 struct w83627ehf_data *data = w83627ehf_update_device(dev);
577 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
578 int nr = sensor_attr->index;
579 return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
580 }
581
582 static ssize_t
583 store_fan_min(struct device *dev, struct device_attribute *attr,
584 const char *buf, size_t count)
585 {
586 struct i2c_client *client = to_i2c_client(dev);
587 struct w83627ehf_data *data = i2c_get_clientdata(client);
588 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
589 int nr = sensor_attr->index;
590 unsigned int val = simple_strtoul(buf, NULL, 10);
591 unsigned int reg;
592 u8 new_div;
593
594 mutex_lock(&data->update_lock);
595 if (!val) {
596 /* No min limit, alarm disabled */
597 data->fan_min[nr] = 255;
598 new_div = data->fan_div[nr]; /* No change */
599 dev_info(dev, "fan%u low limit and alarm disabled\n", nr + 1);
600 } else if ((reg = 1350000U / val) >= 128 * 255) {
601 /* Speed below this value cannot possibly be represented,
602 even with the highest divider (128) */
603 data->fan_min[nr] = 254;
604 new_div = 7; /* 128 == (1 << 7) */
605 dev_warn(dev, "fan%u low limit %u below minimum %u, set to "
606 "minimum\n", nr + 1, val, fan_from_reg(254, 128));
607 } else if (!reg) {
608 /* Speed above this value cannot possibly be represented,
609 even with the lowest divider (1) */
610 data->fan_min[nr] = 1;
611 new_div = 0; /* 1 == (1 << 0) */
612 dev_warn(dev, "fan%u low limit %u above maximum %u, set to "
613 "maximum\n", nr + 1, val, fan_from_reg(1, 1));
614 } else {
615 /* Automatically pick the best divider, i.e. the one such
616 that the min limit will correspond to a register value
617 in the 96..192 range */
618 new_div = 0;
619 while (reg > 192 && new_div < 7) {
620 reg >>= 1;
621 new_div++;
622 }
623 data->fan_min[nr] = reg;
624 }
625
626 /* Write both the fan clock divider (if it changed) and the new
627 fan min (unconditionally) */
628 if (new_div != data->fan_div[nr]) {
629 if (new_div > data->fan_div[nr])
630 data->fan[nr] >>= (data->fan_div[nr] - new_div);
631 else
632 data->fan[nr] <<= (new_div - data->fan_div[nr]);
633
634 dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
635 nr + 1, div_from_reg(data->fan_div[nr]),
636 div_from_reg(new_div));
637 data->fan_div[nr] = new_div;
638 w83627ehf_write_fan_div(client, nr);
639 }
640 w83627ehf_write_value(client, W83627EHF_REG_FAN_MIN[nr],
641 data->fan_min[nr]);
642 mutex_unlock(&data->update_lock);
643
644 return count;
645 }
646
647 static struct sensor_device_attribute sda_fan_input[] = {
648 SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
649 SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
650 SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
651 SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
652 SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
653 };
654
655 static struct sensor_device_attribute sda_fan_alarm[] = {
656 SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
657 SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
658 SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
659 SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 10),
660 SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 23),
661 };
662
663 static struct sensor_device_attribute sda_fan_min[] = {
664 SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
665 store_fan_min, 0),
666 SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
667 store_fan_min, 1),
668 SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
669 store_fan_min, 2),
670 SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
671 store_fan_min, 3),
672 SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
673 store_fan_min, 4),
674 };
675
676 static struct sensor_device_attribute sda_fan_div[] = {
677 SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
678 SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
679 SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
680 SENSOR_ATTR(fan4_div, S_IRUGO, show_fan_div, NULL, 3),
681 SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4),
682 };
683
684 static void device_create_file_fan(struct device *dev, int i)
685 {
686 device_create_file(dev, &sda_fan_input[i].dev_attr);
687 device_create_file(dev, &sda_fan_alarm[i].dev_attr);
688 device_create_file(dev, &sda_fan_div[i].dev_attr);
689 device_create_file(dev, &sda_fan_min[i].dev_attr);
690 }
691
692 #define show_temp1_reg(reg) \
693 static ssize_t \
694 show_##reg(struct device *dev, struct device_attribute *attr, \
695 char *buf) \
696 { \
697 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
698 return sprintf(buf, "%d\n", temp1_from_reg(data->reg)); \
699 }
700 show_temp1_reg(temp1);
701 show_temp1_reg(temp1_max);
702 show_temp1_reg(temp1_max_hyst);
703
704 #define store_temp1_reg(REG, reg) \
705 static ssize_t \
706 store_temp1_##reg(struct device *dev, struct device_attribute *attr, \
707 const char *buf, size_t count) \
708 { \
709 struct i2c_client *client = to_i2c_client(dev); \
710 struct w83627ehf_data *data = i2c_get_clientdata(client); \
711 u32 val = simple_strtoul(buf, NULL, 10); \
712 \
713 mutex_lock(&data->update_lock); \
714 data->temp1_##reg = temp1_to_reg(val); \
715 w83627ehf_write_value(client, W83627EHF_REG_TEMP1_##REG, \
716 data->temp1_##reg); \
717 mutex_unlock(&data->update_lock); \
718 return count; \
719 }
720 store_temp1_reg(OVER, max);
721 store_temp1_reg(HYST, max_hyst);
722
723 #define show_temp_reg(reg) \
724 static ssize_t \
725 show_##reg(struct device *dev, struct device_attribute *attr, \
726 char *buf) \
727 { \
728 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
729 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
730 int nr = sensor_attr->index; \
731 return sprintf(buf, "%d\n", \
732 LM75_TEMP_FROM_REG(data->reg[nr])); \
733 }
734 show_temp_reg(temp);
735 show_temp_reg(temp_max);
736 show_temp_reg(temp_max_hyst);
737
738 #define store_temp_reg(REG, reg) \
739 static ssize_t \
740 store_##reg(struct device *dev, struct device_attribute *attr, \
741 const char *buf, size_t count) \
742 { \
743 struct i2c_client *client = to_i2c_client(dev); \
744 struct w83627ehf_data *data = i2c_get_clientdata(client); \
745 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
746 int nr = sensor_attr->index; \
747 u32 val = simple_strtoul(buf, NULL, 10); \
748 \
749 mutex_lock(&data->update_lock); \
750 data->reg[nr] = LM75_TEMP_TO_REG(val); \
751 w83627ehf_write_value(client, W83627EHF_REG_TEMP_##REG[nr], \
752 data->reg[nr]); \
753 mutex_unlock(&data->update_lock); \
754 return count; \
755 }
756 store_temp_reg(OVER, temp_max);
757 store_temp_reg(HYST, temp_max_hyst);
758
759 static struct sensor_device_attribute sda_temp[] = {
760 SENSOR_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0),
761 SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0),
762 SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 1),
763 SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1_max,
764 store_temp1_max, 0),
765 SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
766 store_temp_max, 0),
767 SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
768 store_temp_max, 1),
769 SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1_max_hyst,
770 store_temp1_max_hyst, 0),
771 SENSOR_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
772 store_temp_max_hyst, 0),
773 SENSOR_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
774 store_temp_max_hyst, 1),
775 SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
776 SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
777 SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
778 };
779
780 /*
781 * Driver and client management
782 */
783
784 static struct i2c_driver w83627ehf_driver;
785
786 static void w83627ehf_init_client(struct i2c_client *client)
787 {
788 int i;
789 u8 tmp;
790
791 /* Start monitoring is needed */
792 tmp = w83627ehf_read_value(client, W83627EHF_REG_CONFIG);
793 if (!(tmp & 0x01))
794 w83627ehf_write_value(client, W83627EHF_REG_CONFIG,
795 tmp | 0x01);
796
797 /* Enable temp2 and temp3 if needed */
798 for (i = 0; i < 2; i++) {
799 tmp = w83627ehf_read_value(client,
800 W83627EHF_REG_TEMP_CONFIG[i]);
801 if (tmp & 0x01)
802 w83627ehf_write_value(client,
803 W83627EHF_REG_TEMP_CONFIG[i],
804 tmp & 0xfe);
805 }
806 }
807
808 static int w83627ehf_detect(struct i2c_adapter *adapter)
809 {
810 struct i2c_client *client;
811 struct w83627ehf_data *data;
812 struct device *dev;
813 int i, err = 0;
814
815 if (!request_region(address + REGION_OFFSET, REGION_LENGTH,
816 w83627ehf_driver.driver.name)) {
817 err = -EBUSY;
818 goto exit;
819 }
820
821 if (!(data = kzalloc(sizeof(struct w83627ehf_data), GFP_KERNEL))) {
822 err = -ENOMEM;
823 goto exit_release;
824 }
825
826 client = &data->client;
827 i2c_set_clientdata(client, data);
828 client->addr = address;
829 mutex_init(&data->lock);
830 client->adapter = adapter;
831 client->driver = &w83627ehf_driver;
832 client->flags = 0;
833 dev = &client->dev;
834
835 strlcpy(client->name, "w83627ehf", I2C_NAME_SIZE);
836 data->valid = 0;
837 mutex_init(&data->update_lock);
838
839 /* Tell the i2c layer a new client has arrived */
840 if ((err = i2c_attach_client(client)))
841 goto exit_free;
842
843 /* Initialize the chip */
844 w83627ehf_init_client(client);
845
846 /* A few vars need to be filled upon startup */
847 for (i = 0; i < 5; i++)
848 data->fan_min[i] = w83627ehf_read_value(client,
849 W83627EHF_REG_FAN_MIN[i]);
850
851 /* It looks like fan4 and fan5 pins can be alternatively used
852 as fan on/off switches */
853 data->has_fan = 0x07; /* fan1, fan2 and fan3 */
854 i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV1);
855 if (i & (1 << 2))
856 data->has_fan |= (1 << 3);
857 if (i & (1 << 0))
858 data->has_fan |= (1 << 4);
859
860 /* Register sysfs hooks */
861 data->class_dev = hwmon_device_register(dev);
862 if (IS_ERR(data->class_dev)) {
863 err = PTR_ERR(data->class_dev);
864 goto exit_detach;
865 }
866
867 for (i = 0; i < 10; i++)
868 device_create_file_in(dev, i);
869
870 for (i = 0; i < 5; i++) {
871 if (data->has_fan & (1 << i))
872 device_create_file_fan(dev, i);
873 }
874 for (i = 0; i < ARRAY_SIZE(sda_temp); i++)
875 device_create_file(dev, &sda_temp[i].dev_attr);
876
877 return 0;
878
879 exit_detach:
880 i2c_detach_client(client);
881 exit_free:
882 kfree(data);
883 exit_release:
884 release_region(address + REGION_OFFSET, REGION_LENGTH);
885 exit:
886 return err;
887 }
888
889 static int w83627ehf_detach_client(struct i2c_client *client)
890 {
891 struct w83627ehf_data *data = i2c_get_clientdata(client);
892 int err;
893
894 hwmon_device_unregister(data->class_dev);
895
896 if ((err = i2c_detach_client(client)))
897 return err;
898 release_region(client->addr + REGION_OFFSET, REGION_LENGTH);
899 kfree(data);
900
901 return 0;
902 }
903
904 static struct i2c_driver w83627ehf_driver = {
905 .driver = {
906 .name = "w83627ehf",
907 },
908 .attach_adapter = w83627ehf_detect,
909 .detach_client = w83627ehf_detach_client,
910 };
911
912 static int __init w83627ehf_find(int sioaddr, unsigned short *addr)
913 {
914 u16 val;
915
916 REG = sioaddr;
917 VAL = sioaddr + 1;
918 superio_enter();
919
920 val = (superio_inb(SIO_REG_DEVID) << 8)
921 | superio_inb(SIO_REG_DEVID + 1);
922 if ((val & SIO_ID_MASK) != SIO_W83627EHF_ID) {
923 superio_exit();
924 return -ENODEV;
925 }
926
927 superio_select(W83627EHF_LD_HWM);
928 val = (superio_inb(SIO_REG_ADDR) << 8)
929 | superio_inb(SIO_REG_ADDR + 1);
930 *addr = val & REGION_ALIGNMENT;
931 if (*addr == 0) {
932 superio_exit();
933 return -ENODEV;
934 }
935
936 /* Activate logical device if needed */
937 val = superio_inb(SIO_REG_ENABLE);
938 if (!(val & 0x01))
939 superio_outb(SIO_REG_ENABLE, val | 0x01);
940
941 superio_exit();
942 return 0;
943 }
944
945 static int __init sensors_w83627ehf_init(void)
946 {
947 if (w83627ehf_find(0x2e, &address)
948 && w83627ehf_find(0x4e, &address))
949 return -ENODEV;
950
951 return i2c_isa_add_driver(&w83627ehf_driver);
952 }
953
954 static void __exit sensors_w83627ehf_exit(void)
955 {
956 i2c_isa_del_driver(&w83627ehf_driver);
957 }
958
959 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
960 MODULE_DESCRIPTION("W83627EHF driver");
961 MODULE_LICENSE("GPL");
962
963 module_init(sensors_w83627ehf_init);
964 module_exit(sensors_w83627ehf_exit);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree