blob: 30a76404f0af31f965d4f48387b64e744ea73f27 [file] [log] [blame]
Jean Delvare08e7e272005-04-25 22:43:25 +02001/*
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>
Jean Delvare3379cee2006-09-24 21:25:52 +02005 Copyright (C) 2006 Yuan Mu (Winbond),
Jean Delvare7188cc62006-12-12 18:18:30 +01006 Rudolf Marek <r.marek@assembler.cz>
David Hubbardc18beb52006-09-24 21:04:38 +02007 David Hubbard <david.c.hubbard@gmail.com>
Jean Delvare08e7e272005-04-25 22:43:25 +02008
9 Shamelessly ripped from the w83627hf driver
10 Copyright (C) 2003 Mark Studebaker
11
12 Thanks to Leon Moonen, Steve Cliffe and Grant Coady for their help
13 in testing and debugging this driver.
14
Jean Delvare8dd2d2c2005-07-27 21:33:15 +020015 This driver also supports the W83627EHG, which is the lead-free
16 version of the W83627EHF.
17
Jean Delvare08e7e272005-04-25 22:43:25 +020018 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 2 of the License, or
21 (at your option) any later version.
22
23 This program is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 GNU General Public License for more details.
27
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
31
32
33 Supports the following chips:
34
David Hubbard657c93b2007-02-14 21:15:04 +010035 Chip #vin #fan #pwm #temp chip IDs man ID
36 w83627ehf 10 5 4 3 0x8850 0x88 0x5ca3
37 0x8860 0xa1
38 w83627dhg 9 5 4 3 0xa020 0xc1 0x5ca3
Jean Delvare08e7e272005-04-25 22:43:25 +020039*/
40
41#include <linux/module.h>
42#include <linux/init.h>
43#include <linux/slab.h>
44#include <linux/i2c.h>
Jean Delvarefde09502005-07-19 23:51:07 +020045#include <linux/i2c-isa.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040046#include <linux/hwmon.h>
Yuan Mu412fec82006-02-05 23:24:16 +010047#include <linux/hwmon-sysfs.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040048#include <linux/err.h>
Ingo Molnar9a61bf62006-01-18 23:19:26 +010049#include <linux/mutex.h>
Jean Delvare08e7e272005-04-25 22:43:25 +020050#include <asm/io.h>
51#include "lm75.h"
52
Jean Delvare2d8672c2005-07-19 23:56:35 +020053/* The actual ISA address is read from Super-I/O configuration space */
54static unsigned short address;
Jean Delvare08e7e272005-04-25 22:43:25 +020055
56/*
57 * Super-I/O constants and functions
58 */
59
David Hubbard657c93b2007-02-14 21:15:04 +010060/*
61 * The three following globals are initialized in w83627ehf_find(), before
62 * the i2c-isa device is created. Otherwise, they could be stored in
63 * w83627ehf_data. This is ugly, but necessary, and when the driver is next
64 * updated to become a platform driver, the globals will disappear.
65 */
Jean Delvare08e7e272005-04-25 22:43:25 +020066static int REG; /* The register to read/write */
67static int VAL; /* The value to read/write */
David Hubbard657c93b2007-02-14 21:15:04 +010068/* The w83627ehf/ehg have 10 voltage inputs, but the w83627dhg has 9. This
69 * value is also used in w83627ehf_detect() to export a device name in sysfs
70 * (e.g. w83627ehf or w83627dhg) */
71static int w83627ehf_num_in;
Jean Delvare08e7e272005-04-25 22:43:25 +020072
73#define W83627EHF_LD_HWM 0x0b
74
75#define SIO_REG_LDSEL 0x07 /* Logical device select */
76#define SIO_REG_DEVID 0x20 /* Device ID (2 bytes) */
77#define SIO_REG_ENABLE 0x30 /* Logical device enable */
78#define SIO_REG_ADDR 0x60 /* Logical device address (2 bytes) */
79
David Hubbard657c93b2007-02-14 21:15:04 +010080#define SIO_W83627EHF_ID 0x8850
81#define SIO_W83627EHG_ID 0x8860
82#define SIO_W83627DHG_ID 0xa020
83#define SIO_ID_MASK 0xFFF0
Jean Delvare08e7e272005-04-25 22:43:25 +020084
85static inline void
86superio_outb(int reg, int val)
87{
88 outb(reg, REG);
89 outb(val, VAL);
90}
91
92static inline int
93superio_inb(int reg)
94{
95 outb(reg, REG);
96 return inb(VAL);
97}
98
99static inline void
100superio_select(int ld)
101{
102 outb(SIO_REG_LDSEL, REG);
103 outb(ld, VAL);
104}
105
106static inline void
107superio_enter(void)
108{
109 outb(0x87, REG);
110 outb(0x87, REG);
111}
112
113static inline void
114superio_exit(void)
115{
116 outb(0x02, REG);
117 outb(0x02, VAL);
118}
119
120/*
121 * ISA constants
122 */
123
Jean Delvare1a641fc2007-04-23 14:41:16 -0700124#define IOREGION_ALIGNMENT ~7
125#define IOREGION_OFFSET 5
126#define IOREGION_LENGTH 2
Jean Delvare08e7e272005-04-25 22:43:25 +0200127#define ADDR_REG_OFFSET 5
128#define DATA_REG_OFFSET 6
129
130#define W83627EHF_REG_BANK 0x4E
131#define W83627EHF_REG_CONFIG 0x40
David Hubbard657c93b2007-02-14 21:15:04 +0100132
133/* Not currently used:
134 * REG_MAN_ID has the value 0x5ca3 for all supported chips.
135 * REG_CHIP_ID == 0x88/0xa1/0xc1 depending on chip model.
136 * REG_MAN_ID is at port 0x4f
137 * REG_CHIP_ID is at port 0x58 */
Jean Delvare08e7e272005-04-25 22:43:25 +0200138
139static const u16 W83627EHF_REG_FAN[] = { 0x28, 0x29, 0x2a, 0x3f, 0x553 };
140static const u16 W83627EHF_REG_FAN_MIN[] = { 0x3b, 0x3c, 0x3d, 0x3e, 0x55c };
141
Rudolf Marekcf0676f2006-03-23 16:25:22 +0100142/* The W83627EHF registers for nr=7,8,9 are in bank 5 */
143#define W83627EHF_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
144 (0x554 + (((nr) - 7) * 2)))
145#define W83627EHF_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
146 (0x555 + (((nr) - 7) * 2)))
147#define W83627EHF_REG_IN(nr) ((nr < 7) ? (0x20 + (nr)) : \
148 (0x550 + (nr) - 7))
149
Jean Delvare08e7e272005-04-25 22:43:25 +0200150#define W83627EHF_REG_TEMP1 0x27
151#define W83627EHF_REG_TEMP1_HYST 0x3a
152#define W83627EHF_REG_TEMP1_OVER 0x39
153static const u16 W83627EHF_REG_TEMP[] = { 0x150, 0x250 };
154static const u16 W83627EHF_REG_TEMP_HYST[] = { 0x153, 0x253 };
155static const u16 W83627EHF_REG_TEMP_OVER[] = { 0x155, 0x255 };
156static const u16 W83627EHF_REG_TEMP_CONFIG[] = { 0x152, 0x252 };
157
158/* Fan clock dividers are spread over the following five registers */
159#define W83627EHF_REG_FANDIV1 0x47
160#define W83627EHF_REG_FANDIV2 0x4B
161#define W83627EHF_REG_VBAT 0x5D
162#define W83627EHF_REG_DIODE 0x59
163#define W83627EHF_REG_SMI_OVT 0x4C
164
Jean Delvarea4589db2006-03-23 16:30:29 +0100165#define W83627EHF_REG_ALARM1 0x459
166#define W83627EHF_REG_ALARM2 0x45A
167#define W83627EHF_REG_ALARM3 0x45B
168
Rudolf Marek08c79952006-07-05 18:14:31 +0200169/* SmartFan registers */
170/* DC or PWM output fan configuration */
171static const u8 W83627EHF_REG_PWM_ENABLE[] = {
172 0x04, /* SYS FAN0 output mode and PWM mode */
173 0x04, /* CPU FAN0 output mode and PWM mode */
174 0x12, /* AUX FAN mode */
175 0x62, /* CPU fan1 mode */
176};
177
178static const u8 W83627EHF_PWM_MODE_SHIFT[] = { 0, 1, 0, 6 };
179static const u8 W83627EHF_PWM_ENABLE_SHIFT[] = { 2, 4, 1, 4 };
180
181/* FAN Duty Cycle, be used to control */
182static const u8 W83627EHF_REG_PWM[] = { 0x01, 0x03, 0x11, 0x61 };
183static const u8 W83627EHF_REG_TARGET[] = { 0x05, 0x06, 0x13, 0x63 };
184static const u8 W83627EHF_REG_TOLERANCE[] = { 0x07, 0x07, 0x14, 0x62 };
185
186
187/* Advanced Fan control, some values are common for all fans */
188static const u8 W83627EHF_REG_FAN_MIN_OUTPUT[] = { 0x08, 0x09, 0x15, 0x64 };
189static const u8 W83627EHF_REG_FAN_STOP_TIME[] = { 0x0C, 0x0D, 0x17, 0x66 };
190
Jean Delvare08e7e272005-04-25 22:43:25 +0200191/*
192 * Conversions
193 */
194
Rudolf Marek08c79952006-07-05 18:14:31 +0200195/* 1 is PWM mode, output in ms */
196static inline unsigned int step_time_from_reg(u8 reg, u8 mode)
197{
198 return mode ? 100 * reg : 400 * reg;
199}
200
201static inline u8 step_time_to_reg(unsigned int msec, u8 mode)
202{
203 return SENSORS_LIMIT((mode ? (msec + 50) / 100 :
204 (msec + 200) / 400), 1, 255);
205}
206
Jean Delvare08e7e272005-04-25 22:43:25 +0200207static inline unsigned int
208fan_from_reg(u8 reg, unsigned int div)
209{
210 if (reg == 0 || reg == 255)
211 return 0;
212 return 1350000U / (reg * div);
213}
214
215static inline unsigned int
216div_from_reg(u8 reg)
217{
218 return 1 << reg;
219}
220
221static inline int
222temp1_from_reg(s8 reg)
223{
224 return reg * 1000;
225}
226
227static inline s8
Rudolf Marek08c79952006-07-05 18:14:31 +0200228temp1_to_reg(int temp, int min, int max)
Jean Delvare08e7e272005-04-25 22:43:25 +0200229{
Rudolf Marek08c79952006-07-05 18:14:31 +0200230 if (temp <= min)
231 return min / 1000;
232 if (temp >= max)
233 return max / 1000;
Jean Delvare08e7e272005-04-25 22:43:25 +0200234 if (temp < 0)
235 return (temp - 500) / 1000;
236 return (temp + 500) / 1000;
237}
238
Rudolf Marekcf0676f2006-03-23 16:25:22 +0100239/* Some of analog inputs have internal scaling (2x), 8mV is ADC LSB */
240
241static u8 scale_in[10] = { 8, 8, 16, 16, 8, 8, 8, 16, 16, 8 };
242
243static inline long in_from_reg(u8 reg, u8 nr)
244{
245 return reg * scale_in[nr];
246}
247
248static inline u8 in_to_reg(u32 val, u8 nr)
249{
250 return SENSORS_LIMIT(((val + (scale_in[nr] / 2)) / scale_in[nr]), 0, 255);
251}
252
Jean Delvare08e7e272005-04-25 22:43:25 +0200253/*
254 * Data structures and manipulation thereof
255 */
256
257struct w83627ehf_data {
258 struct i2c_client client;
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400259 struct class_device *class_dev;
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100260 struct mutex lock;
Jean Delvare08e7e272005-04-25 22:43:25 +0200261
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100262 struct mutex update_lock;
Jean Delvare08e7e272005-04-25 22:43:25 +0200263 char valid; /* !=0 if following fields are valid */
264 unsigned long last_updated; /* In jiffies */
265
266 /* Register values */
Rudolf Marekcf0676f2006-03-23 16:25:22 +0100267 u8 in[10]; /* Register value */
268 u8 in_max[10]; /* Register value */
269 u8 in_min[10]; /* Register value */
Jean Delvare08e7e272005-04-25 22:43:25 +0200270 u8 fan[5];
271 u8 fan_min[5];
272 u8 fan_div[5];
273 u8 has_fan; /* some fan inputs can be disabled */
274 s8 temp1;
275 s8 temp1_max;
276 s8 temp1_max_hyst;
277 s16 temp[2];
278 s16 temp_max[2];
279 s16 temp_max_hyst[2];
Jean Delvarea4589db2006-03-23 16:30:29 +0100280 u32 alarms;
Rudolf Marek08c79952006-07-05 18:14:31 +0200281
282 u8 pwm_mode[4]; /* 0->DC variable voltage, 1->PWM variable duty cycle */
283 u8 pwm_enable[4]; /* 1->manual
284 2->thermal cruise (also called SmartFan I) */
285 u8 pwm[4];
286 u8 target_temp[4];
287 u8 tolerance[4];
288
289 u8 fan_min_output[4]; /* minimum fan speed */
290 u8 fan_stop_time[4];
Jean Delvare08e7e272005-04-25 22:43:25 +0200291};
292
293static inline int is_word_sized(u16 reg)
294{
295 return (((reg & 0xff00) == 0x100
296 || (reg & 0xff00) == 0x200)
297 && ((reg & 0x00ff) == 0x50
298 || (reg & 0x00ff) == 0x53
299 || (reg & 0x00ff) == 0x55));
300}
301
302/* We assume that the default bank is 0, thus the following two functions do
303 nothing for registers which live in bank 0. For others, they respectively
304 set the bank register to the correct value (before the register is
305 accessed), and back to 0 (afterwards). */
306static inline void w83627ehf_set_bank(struct i2c_client *client, u16 reg)
307{
308 if (reg & 0xff00) {
309 outb_p(W83627EHF_REG_BANK, client->addr + ADDR_REG_OFFSET);
310 outb_p(reg >> 8, client->addr + DATA_REG_OFFSET);
311 }
312}
313
314static inline void w83627ehf_reset_bank(struct i2c_client *client, u16 reg)
315{
316 if (reg & 0xff00) {
317 outb_p(W83627EHF_REG_BANK, client->addr + ADDR_REG_OFFSET);
318 outb_p(0, client->addr + DATA_REG_OFFSET);
319 }
320}
321
322static u16 w83627ehf_read_value(struct i2c_client *client, u16 reg)
323{
324 struct w83627ehf_data *data = i2c_get_clientdata(client);
325 int res, word_sized = is_word_sized(reg);
326
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100327 mutex_lock(&data->lock);
Jean Delvare08e7e272005-04-25 22:43:25 +0200328
329 w83627ehf_set_bank(client, reg);
330 outb_p(reg & 0xff, client->addr + ADDR_REG_OFFSET);
331 res = inb_p(client->addr + DATA_REG_OFFSET);
332 if (word_sized) {
333 outb_p((reg & 0xff) + 1,
334 client->addr + ADDR_REG_OFFSET);
335 res = (res << 8) + inb_p(client->addr + DATA_REG_OFFSET);
336 }
337 w83627ehf_reset_bank(client, reg);
338
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100339 mutex_unlock(&data->lock);
Jean Delvare08e7e272005-04-25 22:43:25 +0200340
341 return res;
342}
343
344static int w83627ehf_write_value(struct i2c_client *client, u16 reg, u16 value)
345{
346 struct w83627ehf_data *data = i2c_get_clientdata(client);
347 int word_sized = is_word_sized(reg);
348
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100349 mutex_lock(&data->lock);
Jean Delvare08e7e272005-04-25 22:43:25 +0200350
351 w83627ehf_set_bank(client, reg);
352 outb_p(reg & 0xff, client->addr + ADDR_REG_OFFSET);
353 if (word_sized) {
354 outb_p(value >> 8, client->addr + DATA_REG_OFFSET);
355 outb_p((reg & 0xff) + 1,
356 client->addr + ADDR_REG_OFFSET);
357 }
358 outb_p(value & 0xff, client->addr + DATA_REG_OFFSET);
359 w83627ehf_reset_bank(client, reg);
360
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100361 mutex_unlock(&data->lock);
Jean Delvare08e7e272005-04-25 22:43:25 +0200362 return 0;
363}
364
365/* This function assumes that the caller holds data->update_lock */
366static void w83627ehf_write_fan_div(struct i2c_client *client, int nr)
367{
368 struct w83627ehf_data *data = i2c_get_clientdata(client);
369 u8 reg;
370
371 switch (nr) {
372 case 0:
373 reg = (w83627ehf_read_value(client, W83627EHF_REG_FANDIV1) & 0xcf)
374 | ((data->fan_div[0] & 0x03) << 4);
Rudolf Marek14992c72006-10-08 22:02:09 +0200375 /* fan5 input control bit is write only, compute the value */
376 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
Jean Delvare08e7e272005-04-25 22:43:25 +0200377 w83627ehf_write_value(client, W83627EHF_REG_FANDIV1, reg);
378 reg = (w83627ehf_read_value(client, W83627EHF_REG_VBAT) & 0xdf)
379 | ((data->fan_div[0] & 0x04) << 3);
380 w83627ehf_write_value(client, W83627EHF_REG_VBAT, reg);
381 break;
382 case 1:
383 reg = (w83627ehf_read_value(client, W83627EHF_REG_FANDIV1) & 0x3f)
384 | ((data->fan_div[1] & 0x03) << 6);
Rudolf Marek14992c72006-10-08 22:02:09 +0200385 /* fan5 input control bit is write only, compute the value */
386 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
Jean Delvare08e7e272005-04-25 22:43:25 +0200387 w83627ehf_write_value(client, W83627EHF_REG_FANDIV1, reg);
388 reg = (w83627ehf_read_value(client, W83627EHF_REG_VBAT) & 0xbf)
389 | ((data->fan_div[1] & 0x04) << 4);
390 w83627ehf_write_value(client, W83627EHF_REG_VBAT, reg);
391 break;
392 case 2:
393 reg = (w83627ehf_read_value(client, W83627EHF_REG_FANDIV2) & 0x3f)
394 | ((data->fan_div[2] & 0x03) << 6);
395 w83627ehf_write_value(client, W83627EHF_REG_FANDIV2, reg);
396 reg = (w83627ehf_read_value(client, W83627EHF_REG_VBAT) & 0x7f)
397 | ((data->fan_div[2] & 0x04) << 5);
398 w83627ehf_write_value(client, W83627EHF_REG_VBAT, reg);
399 break;
400 case 3:
401 reg = (w83627ehf_read_value(client, W83627EHF_REG_DIODE) & 0xfc)
402 | (data->fan_div[3] & 0x03);
403 w83627ehf_write_value(client, W83627EHF_REG_DIODE, reg);
404 reg = (w83627ehf_read_value(client, W83627EHF_REG_SMI_OVT) & 0x7f)
405 | ((data->fan_div[3] & 0x04) << 5);
406 w83627ehf_write_value(client, W83627EHF_REG_SMI_OVT, reg);
407 break;
408 case 4:
409 reg = (w83627ehf_read_value(client, W83627EHF_REG_DIODE) & 0x73)
Jean Delvare33725ad2007-04-17 00:32:27 -0700410 | ((data->fan_div[4] & 0x03) << 2)
Jean Delvare08e7e272005-04-25 22:43:25 +0200411 | ((data->fan_div[4] & 0x04) << 5);
412 w83627ehf_write_value(client, W83627EHF_REG_DIODE, reg);
413 break;
414 }
415}
416
417static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
418{
419 struct i2c_client *client = to_i2c_client(dev);
420 struct w83627ehf_data *data = i2c_get_clientdata(client);
Rudolf Marek08c79952006-07-05 18:14:31 +0200421 int pwmcfg = 0, tolerance = 0; /* shut up the compiler */
Jean Delvare08e7e272005-04-25 22:43:25 +0200422 int i;
423
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100424 mutex_lock(&data->update_lock);
Jean Delvare08e7e272005-04-25 22:43:25 +0200425
426 if (time_after(jiffies, data->last_updated + HZ)
427 || !data->valid) {
428 /* Fan clock dividers */
429 i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV1);
430 data->fan_div[0] = (i >> 4) & 0x03;
431 data->fan_div[1] = (i >> 6) & 0x03;
432 i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV2);
433 data->fan_div[2] = (i >> 6) & 0x03;
434 i = w83627ehf_read_value(client, W83627EHF_REG_VBAT);
435 data->fan_div[0] |= (i >> 3) & 0x04;
436 data->fan_div[1] |= (i >> 4) & 0x04;
437 data->fan_div[2] |= (i >> 5) & 0x04;
438 if (data->has_fan & ((1 << 3) | (1 << 4))) {
439 i = w83627ehf_read_value(client, W83627EHF_REG_DIODE);
440 data->fan_div[3] = i & 0x03;
441 data->fan_div[4] = ((i >> 2) & 0x03)
442 | ((i >> 5) & 0x04);
443 }
444 if (data->has_fan & (1 << 3)) {
445 i = w83627ehf_read_value(client, W83627EHF_REG_SMI_OVT);
446 data->fan_div[3] |= (i >> 5) & 0x04;
447 }
448
Rudolf Marekcf0676f2006-03-23 16:25:22 +0100449 /* Measured voltages and limits */
David Hubbard657c93b2007-02-14 21:15:04 +0100450 for (i = 0; i < w83627ehf_num_in; i++) {
Rudolf Marekcf0676f2006-03-23 16:25:22 +0100451 data->in[i] = w83627ehf_read_value(client,
452 W83627EHF_REG_IN(i));
453 data->in_min[i] = w83627ehf_read_value(client,
454 W83627EHF_REG_IN_MIN(i));
455 data->in_max[i] = w83627ehf_read_value(client,
456 W83627EHF_REG_IN_MAX(i));
457 }
458
Jean Delvare08e7e272005-04-25 22:43:25 +0200459 /* Measured fan speeds and limits */
460 for (i = 0; i < 5; i++) {
461 if (!(data->has_fan & (1 << i)))
462 continue;
463
464 data->fan[i] = w83627ehf_read_value(client,
465 W83627EHF_REG_FAN[i]);
466 data->fan_min[i] = w83627ehf_read_value(client,
467 W83627EHF_REG_FAN_MIN[i]);
468
469 /* If we failed to measure the fan speed and clock
470 divider can be increased, let's try that for next
471 time */
472 if (data->fan[i] == 0xff
473 && data->fan_div[i] < 0x07) {
Jean Delvare33725ad2007-04-17 00:32:27 -0700474 dev_dbg(&client->dev, "Increasing fan%d "
Jean Delvare08e7e272005-04-25 22:43:25 +0200475 "clock divider from %u to %u\n",
Jean Delvare33725ad2007-04-17 00:32:27 -0700476 i + 1, div_from_reg(data->fan_div[i]),
Jean Delvare08e7e272005-04-25 22:43:25 +0200477 div_from_reg(data->fan_div[i] + 1));
478 data->fan_div[i]++;
479 w83627ehf_write_fan_div(client, i);
480 /* Preserve min limit if possible */
481 if (data->fan_min[i] >= 2
482 && data->fan_min[i] != 255)
483 w83627ehf_write_value(client,
484 W83627EHF_REG_FAN_MIN[i],
485 (data->fan_min[i] /= 2));
486 }
487 }
488
Rudolf Marek08c79952006-07-05 18:14:31 +0200489 for (i = 0; i < 4; i++) {
490 /* pwmcfg, tolarance mapped for i=0, i=1 to same reg */
491 if (i != 1) {
492 pwmcfg = w83627ehf_read_value(client,
493 W83627EHF_REG_PWM_ENABLE[i]);
494 tolerance = w83627ehf_read_value(client,
495 W83627EHF_REG_TOLERANCE[i]);
496 }
497 data->pwm_mode[i] =
498 ((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1)
499 ? 0 : 1;
500 data->pwm_enable[i] =
501 ((pwmcfg >> W83627EHF_PWM_ENABLE_SHIFT[i])
502 & 3) + 1;
503 data->pwm[i] = w83627ehf_read_value(client,
504 W83627EHF_REG_PWM[i]);
505 data->fan_min_output[i] = w83627ehf_read_value(client,
506 W83627EHF_REG_FAN_MIN_OUTPUT[i]);
507 data->fan_stop_time[i] = w83627ehf_read_value(client,
508 W83627EHF_REG_FAN_STOP_TIME[i]);
509 data->target_temp[i] =
510 w83627ehf_read_value(client,
511 W83627EHF_REG_TARGET[i]) &
512 (data->pwm_mode[i] == 1 ? 0x7f : 0xff);
513 data->tolerance[i] = (tolerance >> (i == 1 ? 4 : 0))
514 & 0x0f;
515 }
516
Jean Delvare08e7e272005-04-25 22:43:25 +0200517 /* Measured temperatures and limits */
518 data->temp1 = w83627ehf_read_value(client,
519 W83627EHF_REG_TEMP1);
520 data->temp1_max = w83627ehf_read_value(client,
521 W83627EHF_REG_TEMP1_OVER);
522 data->temp1_max_hyst = w83627ehf_read_value(client,
523 W83627EHF_REG_TEMP1_HYST);
524 for (i = 0; i < 2; i++) {
525 data->temp[i] = w83627ehf_read_value(client,
526 W83627EHF_REG_TEMP[i]);
527 data->temp_max[i] = w83627ehf_read_value(client,
528 W83627EHF_REG_TEMP_OVER[i]);
529 data->temp_max_hyst[i] = w83627ehf_read_value(client,
530 W83627EHF_REG_TEMP_HYST[i]);
531 }
532
Jean Delvarea4589db2006-03-23 16:30:29 +0100533 data->alarms = w83627ehf_read_value(client,
534 W83627EHF_REG_ALARM1) |
535 (w83627ehf_read_value(client,
536 W83627EHF_REG_ALARM2) << 8) |
537 (w83627ehf_read_value(client,
538 W83627EHF_REG_ALARM3) << 16);
539
Jean Delvare08e7e272005-04-25 22:43:25 +0200540 data->last_updated = jiffies;
541 data->valid = 1;
542 }
543
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100544 mutex_unlock(&data->update_lock);
Jean Delvare08e7e272005-04-25 22:43:25 +0200545 return data;
546}
547
548/*
549 * Sysfs callback functions
550 */
Rudolf Marekcf0676f2006-03-23 16:25:22 +0100551#define show_in_reg(reg) \
552static ssize_t \
553show_##reg(struct device *dev, struct device_attribute *attr, \
554 char *buf) \
555{ \
556 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
557 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
558 int nr = sensor_attr->index; \
559 return sprintf(buf, "%ld\n", in_from_reg(data->reg[nr], nr)); \
560}
561show_in_reg(in)
562show_in_reg(in_min)
563show_in_reg(in_max)
564
565#define store_in_reg(REG, reg) \
566static ssize_t \
567store_in_##reg (struct device *dev, struct device_attribute *attr, \
568 const char *buf, size_t count) \
569{ \
570 struct i2c_client *client = to_i2c_client(dev); \
571 struct w83627ehf_data *data = i2c_get_clientdata(client); \
572 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
573 int nr = sensor_attr->index; \
574 u32 val = simple_strtoul(buf, NULL, 10); \
575 \
576 mutex_lock(&data->update_lock); \
577 data->in_##reg[nr] = in_to_reg(val, nr); \
578 w83627ehf_write_value(client, W83627EHF_REG_IN_##REG(nr), \
579 data->in_##reg[nr]); \
580 mutex_unlock(&data->update_lock); \
581 return count; \
582}
583
584store_in_reg(MIN, min)
585store_in_reg(MAX, max)
586
Jean Delvarea4589db2006-03-23 16:30:29 +0100587static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, char *buf)
588{
589 struct w83627ehf_data *data = w83627ehf_update_device(dev);
590 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
591 int nr = sensor_attr->index;
592 return sprintf(buf, "%u\n", (data->alarms >> nr) & 0x01);
593}
594
Rudolf Marekcf0676f2006-03-23 16:25:22 +0100595static struct sensor_device_attribute sda_in_input[] = {
596 SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
597 SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
598 SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
599 SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
600 SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
601 SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
602 SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
603 SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
604 SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
605 SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
606};
607
Jean Delvarea4589db2006-03-23 16:30:29 +0100608static struct sensor_device_attribute sda_in_alarm[] = {
609 SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0),
610 SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1),
611 SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2),
612 SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3),
613 SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8),
614 SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 21),
615 SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 20),
616 SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16),
617 SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17),
618 SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 19),
619};
620
Rudolf Marekcf0676f2006-03-23 16:25:22 +0100621static struct sensor_device_attribute sda_in_min[] = {
622 SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
623 SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
624 SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
625 SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
626 SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
627 SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
628 SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
629 SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
630 SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
631 SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
632};
633
634static struct sensor_device_attribute sda_in_max[] = {
635 SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
636 SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
637 SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
638 SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
639 SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
640 SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
641 SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
642 SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
643 SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
644 SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
645};
646
Jean Delvare08e7e272005-04-25 22:43:25 +0200647#define show_fan_reg(reg) \
648static ssize_t \
Yuan Mu412fec82006-02-05 23:24:16 +0100649show_##reg(struct device *dev, struct device_attribute *attr, \
650 char *buf) \
Jean Delvare08e7e272005-04-25 22:43:25 +0200651{ \
652 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
Yuan Mu412fec82006-02-05 23:24:16 +0100653 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
654 int nr = sensor_attr->index; \
Jean Delvare08e7e272005-04-25 22:43:25 +0200655 return sprintf(buf, "%d\n", \
656 fan_from_reg(data->reg[nr], \
657 div_from_reg(data->fan_div[nr]))); \
658}
659show_fan_reg(fan);
660show_fan_reg(fan_min);
661
662static ssize_t
Yuan Mu412fec82006-02-05 23:24:16 +0100663show_fan_div(struct device *dev, struct device_attribute *attr,
664 char *buf)
Jean Delvare08e7e272005-04-25 22:43:25 +0200665{
666 struct w83627ehf_data *data = w83627ehf_update_device(dev);
Yuan Mu412fec82006-02-05 23:24:16 +0100667 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
668 int nr = sensor_attr->index;
669 return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
Jean Delvare08e7e272005-04-25 22:43:25 +0200670}
671
672static ssize_t
Yuan Mu412fec82006-02-05 23:24:16 +0100673store_fan_min(struct device *dev, struct device_attribute *attr,
674 const char *buf, size_t count)
Jean Delvare08e7e272005-04-25 22:43:25 +0200675{
676 struct i2c_client *client = to_i2c_client(dev);
677 struct w83627ehf_data *data = i2c_get_clientdata(client);
Yuan Mu412fec82006-02-05 23:24:16 +0100678 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
679 int nr = sensor_attr->index;
Jean Delvare08e7e272005-04-25 22:43:25 +0200680 unsigned int val = simple_strtoul(buf, NULL, 10);
681 unsigned int reg;
682 u8 new_div;
683
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100684 mutex_lock(&data->update_lock);
Jean Delvare08e7e272005-04-25 22:43:25 +0200685 if (!val) {
686 /* No min limit, alarm disabled */
687 data->fan_min[nr] = 255;
688 new_div = data->fan_div[nr]; /* No change */
689 dev_info(dev, "fan%u low limit and alarm disabled\n", nr + 1);
690 } else if ((reg = 1350000U / val) >= 128 * 255) {
691 /* Speed below this value cannot possibly be represented,
692 even with the highest divider (128) */
693 data->fan_min[nr] = 254;
694 new_div = 7; /* 128 == (1 << 7) */
695 dev_warn(dev, "fan%u low limit %u below minimum %u, set to "
696 "minimum\n", nr + 1, val, fan_from_reg(254, 128));
697 } else if (!reg) {
698 /* Speed above this value cannot possibly be represented,
699 even with the lowest divider (1) */
700 data->fan_min[nr] = 1;
701 new_div = 0; /* 1 == (1 << 0) */
702 dev_warn(dev, "fan%u low limit %u above maximum %u, set to "
Jean Delvareb9110b12005-05-02 23:08:22 +0200703 "maximum\n", nr + 1, val, fan_from_reg(1, 1));
Jean Delvare08e7e272005-04-25 22:43:25 +0200704 } else {
705 /* Automatically pick the best divider, i.e. the one such
706 that the min limit will correspond to a register value
707 in the 96..192 range */
708 new_div = 0;
709 while (reg > 192 && new_div < 7) {
710 reg >>= 1;
711 new_div++;
712 }
713 data->fan_min[nr] = reg;
714 }
715
716 /* Write both the fan clock divider (if it changed) and the new
717 fan min (unconditionally) */
718 if (new_div != data->fan_div[nr]) {
719 if (new_div > data->fan_div[nr])
720 data->fan[nr] >>= (data->fan_div[nr] - new_div);
721 else
722 data->fan[nr] <<= (new_div - data->fan_div[nr]);
723
724 dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
725 nr + 1, div_from_reg(data->fan_div[nr]),
726 div_from_reg(new_div));
727 data->fan_div[nr] = new_div;
728 w83627ehf_write_fan_div(client, nr);
729 }
730 w83627ehf_write_value(client, W83627EHF_REG_FAN_MIN[nr],
731 data->fan_min[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100732 mutex_unlock(&data->update_lock);
Jean Delvare08e7e272005-04-25 22:43:25 +0200733
734 return count;
735}
736
Yuan Mu412fec82006-02-05 23:24:16 +0100737static struct sensor_device_attribute sda_fan_input[] = {
738 SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
739 SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
740 SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
741 SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
742 SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
743};
Jean Delvare08e7e272005-04-25 22:43:25 +0200744
Jean Delvarea4589db2006-03-23 16:30:29 +0100745static struct sensor_device_attribute sda_fan_alarm[] = {
746 SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
747 SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
748 SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
749 SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 10),
750 SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 23),
751};
752
Yuan Mu412fec82006-02-05 23:24:16 +0100753static struct sensor_device_attribute sda_fan_min[] = {
754 SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
755 store_fan_min, 0),
756 SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
757 store_fan_min, 1),
758 SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
759 store_fan_min, 2),
760 SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
761 store_fan_min, 3),
762 SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
763 store_fan_min, 4),
764};
Jean Delvare08e7e272005-04-25 22:43:25 +0200765
Yuan Mu412fec82006-02-05 23:24:16 +0100766static struct sensor_device_attribute sda_fan_div[] = {
767 SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
768 SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
769 SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
770 SENSOR_ATTR(fan4_div, S_IRUGO, show_fan_div, NULL, 3),
771 SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4),
772};
Jean Delvare08e7e272005-04-25 22:43:25 +0200773
Jean Delvare08e7e272005-04-25 22:43:25 +0200774#define show_temp1_reg(reg) \
775static ssize_t \
Greg Kroah-Hartman6f637a62005-06-21 21:01:59 -0700776show_##reg(struct device *dev, struct device_attribute *attr, \
777 char *buf) \
Jean Delvare08e7e272005-04-25 22:43:25 +0200778{ \
779 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
780 return sprintf(buf, "%d\n", temp1_from_reg(data->reg)); \
781}
782show_temp1_reg(temp1);
783show_temp1_reg(temp1_max);
784show_temp1_reg(temp1_max_hyst);
785
786#define store_temp1_reg(REG, reg) \
787static ssize_t \
Greg Kroah-Hartman6f637a62005-06-21 21:01:59 -0700788store_temp1_##reg(struct device *dev, struct device_attribute *attr, \
789 const char *buf, size_t count) \
Jean Delvare08e7e272005-04-25 22:43:25 +0200790{ \
791 struct i2c_client *client = to_i2c_client(dev); \
792 struct w83627ehf_data *data = i2c_get_clientdata(client); \
793 u32 val = simple_strtoul(buf, NULL, 10); \
794 \
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100795 mutex_lock(&data->update_lock); \
Rudolf Marek08c79952006-07-05 18:14:31 +0200796 data->temp1_##reg = temp1_to_reg(val, -128000, 127000); \
Jean Delvare08e7e272005-04-25 22:43:25 +0200797 w83627ehf_write_value(client, W83627EHF_REG_TEMP1_##REG, \
798 data->temp1_##reg); \
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100799 mutex_unlock(&data->update_lock); \
Jean Delvare08e7e272005-04-25 22:43:25 +0200800 return count; \
801}
802store_temp1_reg(OVER, max);
803store_temp1_reg(HYST, max_hyst);
804
Jean Delvare08e7e272005-04-25 22:43:25 +0200805#define show_temp_reg(reg) \
806static ssize_t \
Yuan Mu412fec82006-02-05 23:24:16 +0100807show_##reg(struct device *dev, struct device_attribute *attr, \
808 char *buf) \
Jean Delvare08e7e272005-04-25 22:43:25 +0200809{ \
810 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
Yuan Mu412fec82006-02-05 23:24:16 +0100811 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
812 int nr = sensor_attr->index; \
Jean Delvare08e7e272005-04-25 22:43:25 +0200813 return sprintf(buf, "%d\n", \
814 LM75_TEMP_FROM_REG(data->reg[nr])); \
815}
816show_temp_reg(temp);
817show_temp_reg(temp_max);
818show_temp_reg(temp_max_hyst);
819
820#define store_temp_reg(REG, reg) \
821static ssize_t \
Yuan Mu412fec82006-02-05 23:24:16 +0100822store_##reg(struct device *dev, struct device_attribute *attr, \
823 const char *buf, size_t count) \
Jean Delvare08e7e272005-04-25 22:43:25 +0200824{ \
825 struct i2c_client *client = to_i2c_client(dev); \
826 struct w83627ehf_data *data = i2c_get_clientdata(client); \
Yuan Mu412fec82006-02-05 23:24:16 +0100827 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
828 int nr = sensor_attr->index; \
Jean Delvare08e7e272005-04-25 22:43:25 +0200829 u32 val = simple_strtoul(buf, NULL, 10); \
830 \
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100831 mutex_lock(&data->update_lock); \
Jean Delvare08e7e272005-04-25 22:43:25 +0200832 data->reg[nr] = LM75_TEMP_TO_REG(val); \
833 w83627ehf_write_value(client, W83627EHF_REG_TEMP_##REG[nr], \
834 data->reg[nr]); \
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100835 mutex_unlock(&data->update_lock); \
Jean Delvare08e7e272005-04-25 22:43:25 +0200836 return count; \
837}
838store_temp_reg(OVER, temp_max);
839store_temp_reg(HYST, temp_max_hyst);
840
Yuan Mu412fec82006-02-05 23:24:16 +0100841static struct sensor_device_attribute sda_temp[] = {
842 SENSOR_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0),
843 SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0),
844 SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 1),
845 SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1_max,
846 store_temp1_max, 0),
847 SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
848 store_temp_max, 0),
849 SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
850 store_temp_max, 1),
851 SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1_max_hyst,
852 store_temp1_max_hyst, 0),
853 SENSOR_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
854 store_temp_max_hyst, 0),
855 SENSOR_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
856 store_temp_max_hyst, 1),
Jean Delvarea4589db2006-03-23 16:30:29 +0100857 SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
858 SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
859 SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
Yuan Mu412fec82006-02-05 23:24:16 +0100860};
Jean Delvare08e7e272005-04-25 22:43:25 +0200861
Rudolf Marek08c79952006-07-05 18:14:31 +0200862#define show_pwm_reg(reg) \
863static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \
864 char *buf) \
865{ \
866 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
867 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
868 int nr = sensor_attr->index; \
869 return sprintf(buf, "%d\n", data->reg[nr]); \
870}
871
872show_pwm_reg(pwm_mode)
873show_pwm_reg(pwm_enable)
874show_pwm_reg(pwm)
875
876static ssize_t
877store_pwm_mode(struct device *dev, struct device_attribute *attr,
878 const char *buf, size_t count)
879{
880 struct i2c_client *client = to_i2c_client(dev);
881 struct w83627ehf_data *data = i2c_get_clientdata(client);
882 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
883 int nr = sensor_attr->index;
884 u32 val = simple_strtoul(buf, NULL, 10);
885 u16 reg;
886
887 if (val > 1)
888 return -EINVAL;
889 mutex_lock(&data->update_lock);
890 reg = w83627ehf_read_value(client, W83627EHF_REG_PWM_ENABLE[nr]);
891 data->pwm_mode[nr] = val;
892 reg &= ~(1 << W83627EHF_PWM_MODE_SHIFT[nr]);
893 if (!val)
894 reg |= 1 << W83627EHF_PWM_MODE_SHIFT[nr];
895 w83627ehf_write_value(client, W83627EHF_REG_PWM_ENABLE[nr], reg);
896 mutex_unlock(&data->update_lock);
897 return count;
898}
899
900static ssize_t
901store_pwm(struct device *dev, struct device_attribute *attr,
902 const char *buf, size_t count)
903{
904 struct i2c_client *client = to_i2c_client(dev);
905 struct w83627ehf_data *data = i2c_get_clientdata(client);
906 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
907 int nr = sensor_attr->index;
908 u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 255);
909
910 mutex_lock(&data->update_lock);
911 data->pwm[nr] = val;
912 w83627ehf_write_value(client, W83627EHF_REG_PWM[nr], val);
913 mutex_unlock(&data->update_lock);
914 return count;
915}
916
917static ssize_t
918store_pwm_enable(struct device *dev, struct device_attribute *attr,
919 const char *buf, size_t count)
920{
921 struct i2c_client *client = to_i2c_client(dev);
922 struct w83627ehf_data *data = i2c_get_clientdata(client);
923 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
924 int nr = sensor_attr->index;
925 u32 val = simple_strtoul(buf, NULL, 10);
926 u16 reg;
927
928 if (!val || (val > 2)) /* only modes 1 and 2 are supported */
929 return -EINVAL;
930 mutex_lock(&data->update_lock);
931 reg = w83627ehf_read_value(client, W83627EHF_REG_PWM_ENABLE[nr]);
932 data->pwm_enable[nr] = val;
933 reg &= ~(0x03 << W83627EHF_PWM_ENABLE_SHIFT[nr]);
934 reg |= (val - 1) << W83627EHF_PWM_ENABLE_SHIFT[nr];
935 w83627ehf_write_value(client, W83627EHF_REG_PWM_ENABLE[nr], reg);
936 mutex_unlock(&data->update_lock);
937 return count;
938}
939
940
941#define show_tol_temp(reg) \
942static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
943 char *buf) \
944{ \
945 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
946 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
947 int nr = sensor_attr->index; \
948 return sprintf(buf, "%d\n", temp1_from_reg(data->reg[nr])); \
949}
950
951show_tol_temp(tolerance)
952show_tol_temp(target_temp)
953
954static ssize_t
955store_target_temp(struct device *dev, struct device_attribute *attr,
956 const char *buf, size_t count)
957{
958 struct i2c_client *client = to_i2c_client(dev);
959 struct w83627ehf_data *data = i2c_get_clientdata(client);
960 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
961 int nr = sensor_attr->index;
962 u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 127000);
963
964 mutex_lock(&data->update_lock);
965 data->target_temp[nr] = val;
966 w83627ehf_write_value(client, W83627EHF_REG_TARGET[nr], val);
967 mutex_unlock(&data->update_lock);
968 return count;
969}
970
971static ssize_t
972store_tolerance(struct device *dev, struct device_attribute *attr,
973 const char *buf, size_t count)
974{
975 struct i2c_client *client = to_i2c_client(dev);
976 struct w83627ehf_data *data = i2c_get_clientdata(client);
977 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
978 int nr = sensor_attr->index;
979 u16 reg;
980 /* Limit the temp to 0C - 15C */
981 u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 15000);
982
983 mutex_lock(&data->update_lock);
984 reg = w83627ehf_read_value(client, W83627EHF_REG_TOLERANCE[nr]);
985 data->tolerance[nr] = val;
986 if (nr == 1)
987 reg = (reg & 0x0f) | (val << 4);
988 else
989 reg = (reg & 0xf0) | val;
990 w83627ehf_write_value(client, W83627EHF_REG_TOLERANCE[nr], reg);
991 mutex_unlock(&data->update_lock);
992 return count;
993}
994
995static struct sensor_device_attribute sda_pwm[] = {
996 SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0),
997 SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1),
998 SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2),
999 SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 3),
1000};
1001
1002static struct sensor_device_attribute sda_pwm_mode[] = {
1003 SENSOR_ATTR(pwm1_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1004 store_pwm_mode, 0),
1005 SENSOR_ATTR(pwm2_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1006 store_pwm_mode, 1),
1007 SENSOR_ATTR(pwm3_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1008 store_pwm_mode, 2),
1009 SENSOR_ATTR(pwm4_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1010 store_pwm_mode, 3),
1011};
1012
1013static struct sensor_device_attribute sda_pwm_enable[] = {
1014 SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1015 store_pwm_enable, 0),
1016 SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1017 store_pwm_enable, 1),
1018 SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1019 store_pwm_enable, 2),
1020 SENSOR_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1021 store_pwm_enable, 3),
1022};
1023
1024static struct sensor_device_attribute sda_target_temp[] = {
1025 SENSOR_ATTR(pwm1_target, S_IWUSR | S_IRUGO, show_target_temp,
1026 store_target_temp, 0),
1027 SENSOR_ATTR(pwm2_target, S_IWUSR | S_IRUGO, show_target_temp,
1028 store_target_temp, 1),
1029 SENSOR_ATTR(pwm3_target, S_IWUSR | S_IRUGO, show_target_temp,
1030 store_target_temp, 2),
1031 SENSOR_ATTR(pwm4_target, S_IWUSR | S_IRUGO, show_target_temp,
1032 store_target_temp, 3),
1033};
1034
1035static struct sensor_device_attribute sda_tolerance[] = {
1036 SENSOR_ATTR(pwm1_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1037 store_tolerance, 0),
1038 SENSOR_ATTR(pwm2_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1039 store_tolerance, 1),
1040 SENSOR_ATTR(pwm3_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1041 store_tolerance, 2),
1042 SENSOR_ATTR(pwm4_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1043 store_tolerance, 3),
1044};
1045
Rudolf Marek08c79952006-07-05 18:14:31 +02001046/* Smart Fan registers */
1047
1048#define fan_functions(reg, REG) \
1049static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1050 char *buf) \
1051{ \
1052 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1053 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1054 int nr = sensor_attr->index; \
1055 return sprintf(buf, "%d\n", data->reg[nr]); \
1056}\
1057static ssize_t \
1058store_##reg(struct device *dev, struct device_attribute *attr, \
1059 const char *buf, size_t count) \
1060{\
1061 struct i2c_client *client = to_i2c_client(dev); \
1062 struct w83627ehf_data *data = i2c_get_clientdata(client); \
1063 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1064 int nr = sensor_attr->index; \
1065 u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 1, 255); \
1066 mutex_lock(&data->update_lock); \
1067 data->reg[nr] = val; \
1068 w83627ehf_write_value(client, W83627EHF_REG_##REG[nr], val); \
1069 mutex_unlock(&data->update_lock); \
1070 return count; \
1071}
1072
1073fan_functions(fan_min_output, FAN_MIN_OUTPUT)
1074
1075#define fan_time_functions(reg, REG) \
1076static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1077 char *buf) \
1078{ \
1079 struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1080 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1081 int nr = sensor_attr->index; \
1082 return sprintf(buf, "%d\n", \
1083 step_time_from_reg(data->reg[nr], data->pwm_mode[nr])); \
1084} \
1085\
1086static ssize_t \
1087store_##reg(struct device *dev, struct device_attribute *attr, \
1088 const char *buf, size_t count) \
1089{ \
1090 struct i2c_client *client = to_i2c_client(dev); \
1091 struct w83627ehf_data *data = i2c_get_clientdata(client); \
1092 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1093 int nr = sensor_attr->index; \
1094 u8 val = step_time_to_reg(simple_strtoul(buf, NULL, 10), \
1095 data->pwm_mode[nr]); \
1096 mutex_lock(&data->update_lock); \
1097 data->reg[nr] = val; \
1098 w83627ehf_write_value(client, W83627EHF_REG_##REG[nr], val); \
1099 mutex_unlock(&data->update_lock); \
1100 return count; \
1101} \
1102
1103fan_time_functions(fan_stop_time, FAN_STOP_TIME)
1104
1105
1106static struct sensor_device_attribute sda_sf3_arrays_fan4[] = {
1107 SENSOR_ATTR(pwm4_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1108 store_fan_stop_time, 3),
1109 SENSOR_ATTR(pwm4_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1110 store_fan_min_output, 3),
1111};
1112
1113static struct sensor_device_attribute sda_sf3_arrays[] = {
1114 SENSOR_ATTR(pwm1_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1115 store_fan_stop_time, 0),
1116 SENSOR_ATTR(pwm2_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1117 store_fan_stop_time, 1),
1118 SENSOR_ATTR(pwm3_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1119 store_fan_stop_time, 2),
1120 SENSOR_ATTR(pwm1_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1121 store_fan_min_output, 0),
1122 SENSOR_ATTR(pwm2_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1123 store_fan_min_output, 1),
1124 SENSOR_ATTR(pwm3_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1125 store_fan_min_output, 2),
1126};
1127
Jean Delvare08e7e272005-04-25 22:43:25 +02001128/*
1129 * Driver and client management
1130 */
1131
David Hubbardc18beb52006-09-24 21:04:38 +02001132static void w83627ehf_device_remove_files(struct device *dev)
1133{
1134 /* some entries in the following arrays may not have been used in
1135 * device_create_file(), but device_remove_file() will ignore them */
1136 int i;
1137
1138 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
1139 device_remove_file(dev, &sda_sf3_arrays[i].dev_attr);
1140 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++)
1141 device_remove_file(dev, &sda_sf3_arrays_fan4[i].dev_attr);
David Hubbard657c93b2007-02-14 21:15:04 +01001142 for (i = 0; i < w83627ehf_num_in; i++) {
David Hubbardc18beb52006-09-24 21:04:38 +02001143 device_remove_file(dev, &sda_in_input[i].dev_attr);
1144 device_remove_file(dev, &sda_in_alarm[i].dev_attr);
1145 device_remove_file(dev, &sda_in_min[i].dev_attr);
1146 device_remove_file(dev, &sda_in_max[i].dev_attr);
1147 }
1148 for (i = 0; i < 5; i++) {
1149 device_remove_file(dev, &sda_fan_input[i].dev_attr);
1150 device_remove_file(dev, &sda_fan_alarm[i].dev_attr);
1151 device_remove_file(dev, &sda_fan_div[i].dev_attr);
1152 device_remove_file(dev, &sda_fan_min[i].dev_attr);
1153 }
1154 for (i = 0; i < 4; i++) {
1155 device_remove_file(dev, &sda_pwm[i].dev_attr);
1156 device_remove_file(dev, &sda_pwm_mode[i].dev_attr);
1157 device_remove_file(dev, &sda_pwm_enable[i].dev_attr);
1158 device_remove_file(dev, &sda_target_temp[i].dev_attr);
1159 device_remove_file(dev, &sda_tolerance[i].dev_attr);
1160 }
1161 for (i = 0; i < ARRAY_SIZE(sda_temp); i++)
1162 device_remove_file(dev, &sda_temp[i].dev_attr);
1163}
1164
Jean Delvare08e7e272005-04-25 22:43:25 +02001165static struct i2c_driver w83627ehf_driver;
1166
1167static void w83627ehf_init_client(struct i2c_client *client)
1168{
1169 int i;
1170 u8 tmp;
1171
1172 /* Start monitoring is needed */
1173 tmp = w83627ehf_read_value(client, W83627EHF_REG_CONFIG);
1174 if (!(tmp & 0x01))
1175 w83627ehf_write_value(client, W83627EHF_REG_CONFIG,
1176 tmp | 0x01);
1177
1178 /* Enable temp2 and temp3 if needed */
1179 for (i = 0; i < 2; i++) {
1180 tmp = w83627ehf_read_value(client,
1181 W83627EHF_REG_TEMP_CONFIG[i]);
1182 if (tmp & 0x01)
1183 w83627ehf_write_value(client,
1184 W83627EHF_REG_TEMP_CONFIG[i],
1185 tmp & 0xfe);
1186 }
1187}
1188
Jean Delvare2d8672c2005-07-19 23:56:35 +02001189static int w83627ehf_detect(struct i2c_adapter *adapter)
Jean Delvare08e7e272005-04-25 22:43:25 +02001190{
1191 struct i2c_client *client;
1192 struct w83627ehf_data *data;
Yuan Mu412fec82006-02-05 23:24:16 +01001193 struct device *dev;
Rudolf Marek08c79952006-07-05 18:14:31 +02001194 u8 fan4pin, fan5pin;
Jean Delvare08e7e272005-04-25 22:43:25 +02001195 int i, err = 0;
1196
Jean Delvare1a641fc2007-04-23 14:41:16 -07001197 if (!request_region(address + IOREGION_OFFSET, IOREGION_LENGTH,
Laurent Riffardcdaf7932005-11-26 20:37:41 +01001198 w83627ehf_driver.driver.name)) {
Jean Delvare08e7e272005-04-25 22:43:25 +02001199 err = -EBUSY;
1200 goto exit;
1201 }
1202
Deepak Saxenaba9c2e82005-10-17 23:08:32 +02001203 if (!(data = kzalloc(sizeof(struct w83627ehf_data), GFP_KERNEL))) {
Jean Delvare08e7e272005-04-25 22:43:25 +02001204 err = -ENOMEM;
1205 goto exit_release;
1206 }
Jean Delvare08e7e272005-04-25 22:43:25 +02001207
1208 client = &data->client;
1209 i2c_set_clientdata(client, data);
1210 client->addr = address;
Ingo Molnar9a61bf62006-01-18 23:19:26 +01001211 mutex_init(&data->lock);
Jean Delvare08e7e272005-04-25 22:43:25 +02001212 client->adapter = adapter;
1213 client->driver = &w83627ehf_driver;
1214 client->flags = 0;
Yuan Mu412fec82006-02-05 23:24:16 +01001215 dev = &client->dev;
Jean Delvare08e7e272005-04-25 22:43:25 +02001216
David Hubbard657c93b2007-02-14 21:15:04 +01001217 if (w83627ehf_num_in == 9)
1218 strlcpy(client->name, "w83627dhg", I2C_NAME_SIZE);
1219 else /* just say ehf. 627EHG is 627EHF in lead-free packaging. */
1220 strlcpy(client->name, "w83627ehf", I2C_NAME_SIZE);
1221
Jean Delvare08e7e272005-04-25 22:43:25 +02001222 data->valid = 0;
Ingo Molnar9a61bf62006-01-18 23:19:26 +01001223 mutex_init(&data->update_lock);
Jean Delvare08e7e272005-04-25 22:43:25 +02001224
1225 /* Tell the i2c layer a new client has arrived */
1226 if ((err = i2c_attach_client(client)))
1227 goto exit_free;
1228
1229 /* Initialize the chip */
1230 w83627ehf_init_client(client);
1231
1232 /* A few vars need to be filled upon startup */
1233 for (i = 0; i < 5; i++)
1234 data->fan_min[i] = w83627ehf_read_value(client,
1235 W83627EHF_REG_FAN_MIN[i]);
1236
Rudolf Marek08c79952006-07-05 18:14:31 +02001237 /* fan4 and fan5 share some pins with the GPIO and serial flash */
1238
1239 superio_enter();
1240 fan5pin = superio_inb(0x24) & 0x2;
1241 fan4pin = superio_inb(0x29) & 0x6;
1242 superio_exit();
1243
Jean Delvare08e7e272005-04-25 22:43:25 +02001244 /* It looks like fan4 and fan5 pins can be alternatively used
Rudolf Marek14992c72006-10-08 22:02:09 +02001245 as fan on/off switches, but fan5 control is write only :/
1246 We assume that if the serial interface is disabled, designers
1247 connected fan5 as input unless they are emitting log 1, which
1248 is not the default. */
Rudolf Marek08c79952006-07-05 18:14:31 +02001249
Jean Delvare08e7e272005-04-25 22:43:25 +02001250 data->has_fan = 0x07; /* fan1, fan2 and fan3 */
1251 i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV1);
Rudolf Marek08c79952006-07-05 18:14:31 +02001252 if ((i & (1 << 2)) && (!fan4pin))
Jean Delvare08e7e272005-04-25 22:43:25 +02001253 data->has_fan |= (1 << 3);
Rudolf Marek14992c72006-10-08 22:02:09 +02001254 if (!(i & (1 << 1)) && (!fan5pin))
Jean Delvare08e7e272005-04-25 22:43:25 +02001255 data->has_fan |= (1 << 4);
1256
1257 /* Register sysfs hooks */
Rudolf Marek08c79952006-07-05 18:14:31 +02001258 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
David Hubbardc18beb52006-09-24 21:04:38 +02001259 if ((err = device_create_file(dev,
1260 &sda_sf3_arrays[i].dev_attr)))
1261 goto exit_remove;
Rudolf Marek08c79952006-07-05 18:14:31 +02001262
1263 /* if fan4 is enabled create the sf3 files for it */
1264 if (data->has_fan & (1 << 3))
David Hubbardc18beb52006-09-24 21:04:38 +02001265 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++) {
1266 if ((err = device_create_file(dev,
1267 &sda_sf3_arrays_fan4[i].dev_attr)))
1268 goto exit_remove;
1269 }
Rudolf Marek08c79952006-07-05 18:14:31 +02001270
David Hubbard657c93b2007-02-14 21:15:04 +01001271 for (i = 0; i < w83627ehf_num_in; i++)
David Hubbardc18beb52006-09-24 21:04:38 +02001272 if ((err = device_create_file(dev, &sda_in_input[i].dev_attr))
1273 || (err = device_create_file(dev,
1274 &sda_in_alarm[i].dev_attr))
1275 || (err = device_create_file(dev,
1276 &sda_in_min[i].dev_attr))
1277 || (err = device_create_file(dev,
1278 &sda_in_max[i].dev_attr)))
1279 goto exit_remove;
Rudolf Marekcf0676f2006-03-23 16:25:22 +01001280
Yuan Mu412fec82006-02-05 23:24:16 +01001281 for (i = 0; i < 5; i++) {
Rudolf Marek08c79952006-07-05 18:14:31 +02001282 if (data->has_fan & (1 << i)) {
David Hubbardc18beb52006-09-24 21:04:38 +02001283 if ((err = device_create_file(dev,
1284 &sda_fan_input[i].dev_attr))
1285 || (err = device_create_file(dev,
1286 &sda_fan_alarm[i].dev_attr))
1287 || (err = device_create_file(dev,
1288 &sda_fan_div[i].dev_attr))
1289 || (err = device_create_file(dev,
1290 &sda_fan_min[i].dev_attr)))
1291 goto exit_remove;
1292 if (i < 4 && /* w83627ehf only has 4 pwm */
1293 ((err = device_create_file(dev,
1294 &sda_pwm[i].dev_attr))
1295 || (err = device_create_file(dev,
1296 &sda_pwm_mode[i].dev_attr))
1297 || (err = device_create_file(dev,
1298 &sda_pwm_enable[i].dev_attr))
1299 || (err = device_create_file(dev,
1300 &sda_target_temp[i].dev_attr))
1301 || (err = device_create_file(dev,
1302 &sda_tolerance[i].dev_attr))))
1303 goto exit_remove;
Rudolf Marek08c79952006-07-05 18:14:31 +02001304 }
Jean Delvare08e7e272005-04-25 22:43:25 +02001305 }
Rudolf Marek08c79952006-07-05 18:14:31 +02001306
Yuan Mu412fec82006-02-05 23:24:16 +01001307 for (i = 0; i < ARRAY_SIZE(sda_temp); i++)
David Hubbardc18beb52006-09-24 21:04:38 +02001308 if ((err = device_create_file(dev, &sda_temp[i].dev_attr)))
1309 goto exit_remove;
1310
1311 data->class_dev = hwmon_device_register(dev);
1312 if (IS_ERR(data->class_dev)) {
1313 err = PTR_ERR(data->class_dev);
1314 goto exit_remove;
1315 }
Jean Delvare08e7e272005-04-25 22:43:25 +02001316
1317 return 0;
1318
David Hubbardc18beb52006-09-24 21:04:38 +02001319exit_remove:
1320 w83627ehf_device_remove_files(dev);
Mark M. Hoffman943b0832005-07-15 21:39:18 -04001321 i2c_detach_client(client);
Jean Delvare08e7e272005-04-25 22:43:25 +02001322exit_free:
1323 kfree(data);
1324exit_release:
Jean Delvare1a641fc2007-04-23 14:41:16 -07001325 release_region(address + IOREGION_OFFSET, IOREGION_LENGTH);
Jean Delvare08e7e272005-04-25 22:43:25 +02001326exit:
1327 return err;
1328}
1329
Jean Delvare08e7e272005-04-25 22:43:25 +02001330static int w83627ehf_detach_client(struct i2c_client *client)
1331{
Mark M. Hoffman943b0832005-07-15 21:39:18 -04001332 struct w83627ehf_data *data = i2c_get_clientdata(client);
Jean Delvare08e7e272005-04-25 22:43:25 +02001333 int err;
1334
Mark M. Hoffman943b0832005-07-15 21:39:18 -04001335 hwmon_device_unregister(data->class_dev);
David Hubbardc18beb52006-09-24 21:04:38 +02001336 w83627ehf_device_remove_files(&client->dev);
Mark M. Hoffman943b0832005-07-15 21:39:18 -04001337
Jean Delvare7bef5592005-07-27 22:14:49 +02001338 if ((err = i2c_detach_client(client)))
Jean Delvare08e7e272005-04-25 22:43:25 +02001339 return err;
Jean Delvare1a641fc2007-04-23 14:41:16 -07001340 release_region(client->addr + IOREGION_OFFSET, IOREGION_LENGTH);
Mark M. Hoffman943b0832005-07-15 21:39:18 -04001341 kfree(data);
Jean Delvare08e7e272005-04-25 22:43:25 +02001342
1343 return 0;
1344}
1345
1346static struct i2c_driver w83627ehf_driver = {
Laurent Riffardcdaf7932005-11-26 20:37:41 +01001347 .driver = {
Jean Delvare87218842006-09-03 22:36:14 +02001348 .owner = THIS_MODULE,
Laurent Riffardcdaf7932005-11-26 20:37:41 +01001349 .name = "w83627ehf",
1350 },
Jean Delvare2d8672c2005-07-19 23:56:35 +02001351 .attach_adapter = w83627ehf_detect,
Jean Delvare08e7e272005-04-25 22:43:25 +02001352 .detach_client = w83627ehf_detach_client,
1353};
1354
Jean Delvare2d8672c2005-07-19 23:56:35 +02001355static int __init w83627ehf_find(int sioaddr, unsigned short *addr)
Jean Delvare08e7e272005-04-25 22:43:25 +02001356{
1357 u16 val;
1358
1359 REG = sioaddr;
1360 VAL = sioaddr + 1;
1361 superio_enter();
1362
1363 val = (superio_inb(SIO_REG_DEVID) << 8)
1364 | superio_inb(SIO_REG_DEVID + 1);
David Hubbard657c93b2007-02-14 21:15:04 +01001365 switch (val & SIO_ID_MASK) {
1366 case SIO_W83627DHG_ID:
1367 w83627ehf_num_in = 9;
1368 break;
1369 case SIO_W83627EHF_ID:
1370 case SIO_W83627EHG_ID:
1371 w83627ehf_num_in = 10;
1372 break;
1373 default:
1374 printk(KERN_WARNING "w83627ehf: unsupported chip ID: 0x%04x\n",
1375 val);
Jean Delvare08e7e272005-04-25 22:43:25 +02001376 superio_exit();
1377 return -ENODEV;
1378 }
1379
1380 superio_select(W83627EHF_LD_HWM);
1381 val = (superio_inb(SIO_REG_ADDR) << 8)
1382 | superio_inb(SIO_REG_ADDR + 1);
Jean Delvare1a641fc2007-04-23 14:41:16 -07001383 *addr = val & IOREGION_ALIGNMENT;
Jean Delvare2d8672c2005-07-19 23:56:35 +02001384 if (*addr == 0) {
Jean Delvare08e7e272005-04-25 22:43:25 +02001385 superio_exit();
1386 return -ENODEV;
1387 }
1388
1389 /* Activate logical device if needed */
1390 val = superio_inb(SIO_REG_ENABLE);
1391 if (!(val & 0x01))
1392 superio_outb(SIO_REG_ENABLE, val | 0x01);
1393
1394 superio_exit();
1395 return 0;
1396}
1397
1398static int __init sensors_w83627ehf_init(void)
1399{
Jean Delvare2d8672c2005-07-19 23:56:35 +02001400 if (w83627ehf_find(0x2e, &address)
1401 && w83627ehf_find(0x4e, &address))
Jean Delvare08e7e272005-04-25 22:43:25 +02001402 return -ENODEV;
1403
Jean Delvarefde09502005-07-19 23:51:07 +02001404 return i2c_isa_add_driver(&w83627ehf_driver);
Jean Delvare08e7e272005-04-25 22:43:25 +02001405}
1406
1407static void __exit sensors_w83627ehf_exit(void)
1408{
Jean Delvarefde09502005-07-19 23:51:07 +02001409 i2c_isa_del_driver(&w83627ehf_driver);
Jean Delvare08e7e272005-04-25 22:43:25 +02001410}
1411
1412MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
1413MODULE_DESCRIPTION("W83627EHF driver");
1414MODULE_LICENSE("GPL");
1415
1416module_init(sensors_w83627ehf_init);
1417module_exit(sensors_w83627ehf_exit);