blob: 825e8f72698fdf8d24bf021e88d7551f167749bb [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 smsc47m1.c - Part of lm_sensors, Linux kernel modules
3 for hardware monitoring
4
Jean Delvare0db97142005-09-06 21:21:54 +02005 Supports the SMSC LPC47B27x, LPC47M10x, LPC47M13x, LPC47M14x,
Jean Delvareb890a072005-10-26 22:21:24 +02006 LPC47M15x, LPC47M192 and LPC47M997 Super-I/O chips.
Linus Torvalds1da177e2005-04-16 15:20:36 -07007
8 Copyright (C) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
9 Copyright (C) 2004 Jean Delvare <khali@linux-fr.org>
10 Ported to Linux 2.6 by Gabriele Gorla <gorlik@yahoo.com>
11 and Jean Delvare
12
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26*/
27
28#include <linux/module.h>
29#include <linux/slab.h>
30#include <linux/ioport.h>
31#include <linux/jiffies.h>
32#include <linux/i2c.h>
Jean Delvarefde09502005-07-19 23:51:07 +020033#include <linux/i2c-isa.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040034#include <linux/hwmon.h>
35#include <linux/err.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <linux/init.h>
Ingo Molnar9a61bf62006-01-18 23:19:26 +010037#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <asm/io.h>
39
Linus Torvalds1da177e2005-04-16 15:20:36 -070040/* Address is autodetected, there is no default value */
Jean Delvare2d8672c2005-07-19 23:56:35 +020041static unsigned short address;
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43/* Super-I/0 registers and commands */
44
45#define REG 0x2e /* The register to read/write */
46#define VAL 0x2f /* The value to read/write */
47
48static inline void
49superio_outb(int reg, int val)
50{
51 outb(reg, REG);
52 outb(val, VAL);
53}
54
55static inline int
56superio_inb(int reg)
57{
58 outb(reg, REG);
59 return inb(VAL);
60}
61
62/* logical device for fans is 0x0A */
63#define superio_select() superio_outb(0x07, 0x0A)
64
65static inline void
66superio_enter(void)
67{
68 outb(0x55, REG);
69}
70
71static inline void
72superio_exit(void)
73{
74 outb(0xAA, REG);
75}
76
77#define SUPERIO_REG_ACT 0x30
78#define SUPERIO_REG_BASE 0x60
79#define SUPERIO_REG_DEVID 0x20
80
81/* Logical device registers */
82
83#define SMSC_EXTENT 0x80
84
85/* nr is 0 or 1 in the macros below */
86#define SMSC47M1_REG_ALARM 0x04
87#define SMSC47M1_REG_TPIN(nr) (0x34 - (nr))
88#define SMSC47M1_REG_PPIN(nr) (0x36 - (nr))
89#define SMSC47M1_REG_PWM(nr) (0x56 + (nr))
90#define SMSC47M1_REG_FANDIV 0x58
91#define SMSC47M1_REG_FAN(nr) (0x59 + (nr))
92#define SMSC47M1_REG_FAN_PRELOAD(nr) (0x5B + (nr))
93
94#define MIN_FROM_REG(reg,div) ((reg)>=192 ? 0 : \
95 983040/((192-(reg))*(div)))
96#define FAN_FROM_REG(reg,div,preload) ((reg)<=(preload) || (reg)==255 ? 0 : \
97 983040/(((reg)-(preload))*(div)))
98#define DIV_FROM_REG(reg) (1 << (reg))
99#define PWM_FROM_REG(reg) (((reg) & 0x7E) << 1)
100#define PWM_EN_FROM_REG(reg) ((~(reg)) & 0x01)
101#define PWM_TO_REG(reg) (((reg) >> 1) & 0x7E)
102
103struct smsc47m1_data {
104 struct i2c_client client;
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400105 struct class_device *class_dev;
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100106 struct mutex lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100108 struct mutex update_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 unsigned long last_updated; /* In jiffies */
110
111 u8 fan[2]; /* Register value */
112 u8 fan_preload[2]; /* Register value */
113 u8 fan_div[2]; /* Register encoding, shifted right */
114 u8 alarms; /* Register encoding */
115 u8 pwm[2]; /* Register value (bit 7 is enable) */
116};
117
118
Jean Delvare2d8672c2005-07-19 23:56:35 +0200119static int smsc47m1_detect(struct i2c_adapter *adapter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120static int smsc47m1_detach_client(struct i2c_client *client);
121
122static int smsc47m1_read_value(struct i2c_client *client, u8 reg);
123static void smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value);
124
125static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
126 int init);
127
128
129static struct i2c_driver smsc47m1_driver = {
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100130 .driver = {
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100131 .name = "smsc47m1",
132 },
Jean Delvare2d8672c2005-07-19 23:56:35 +0200133 .attach_adapter = smsc47m1_detect,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 .detach_client = smsc47m1_detach_client,
135};
136
137/* nr is 0 or 1 in the callback functions below */
138
139static ssize_t get_fan(struct device *dev, char *buf, int nr)
140{
141 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
142 /* This chip (stupidly) stops monitoring fan speed if PWM is
143 enabled and duty cycle is 0%. This is fine if the monitoring
144 and control concern the same fan, but troublesome if they are
145 not (which could as well happen). */
146 int rpm = (data->pwm[nr] & 0x7F) == 0x00 ? 0 :
147 FAN_FROM_REG(data->fan[nr],
148 DIV_FROM_REG(data->fan_div[nr]),
149 data->fan_preload[nr]);
150 return sprintf(buf, "%d\n", rpm);
151}
152
153static ssize_t get_fan_min(struct device *dev, char *buf, int nr)
154{
155 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
156 int rpm = MIN_FROM_REG(data->fan_preload[nr],
157 DIV_FROM_REG(data->fan_div[nr]));
158 return sprintf(buf, "%d\n", rpm);
159}
160
161static ssize_t get_fan_div(struct device *dev, char *buf, int nr)
162{
163 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
164 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
165}
166
167static ssize_t get_pwm(struct device *dev, char *buf, int nr)
168{
169 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
170 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
171}
172
173static ssize_t get_pwm_en(struct device *dev, char *buf, int nr)
174{
175 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
176 return sprintf(buf, "%d\n", PWM_EN_FROM_REG(data->pwm[nr]));
177}
178
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400179static ssize_t get_alarms(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180{
181 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
182 return sprintf(buf, "%d\n", data->alarms);
183}
184
185static ssize_t set_fan_min(struct device *dev, const char *buf,
186 size_t count, int nr)
187{
188 struct i2c_client *client = to_i2c_client(dev);
189 struct smsc47m1_data *data = i2c_get_clientdata(client);
190 long rpmdiv, val = simple_strtol(buf, NULL, 10);
191
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100192 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 rpmdiv = val * DIV_FROM_REG(data->fan_div[nr]);
194
195 if (983040 > 192 * rpmdiv || 2 * rpmdiv > 983040) {
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100196 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 return -EINVAL;
198 }
199
200 data->fan_preload[nr] = 192 - ((983040 + rpmdiv / 2) / rpmdiv);
201 smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr),
202 data->fan_preload[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100203 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
205 return count;
206}
207
208/* Note: we save and restore the fan minimum here, because its value is
209 determined in part by the fan clock divider. This follows the principle
Andreas Mohrd6e05ed2006-06-26 18:35:02 +0200210 of least surprise; the user doesn't expect the fan minimum to change just
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 because the divider changed. */
212static ssize_t set_fan_div(struct device *dev, const char *buf,
213 size_t count, int nr)
214{
215 struct i2c_client *client = to_i2c_client(dev);
216 struct smsc47m1_data *data = i2c_get_clientdata(client);
217
218 long new_div = simple_strtol(buf, NULL, 10), tmp;
219 u8 old_div = DIV_FROM_REG(data->fan_div[nr]);
220
221 if (new_div == old_div) /* No change */
222 return count;
223
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100224 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 switch (new_div) {
226 case 1: data->fan_div[nr] = 0; break;
227 case 2: data->fan_div[nr] = 1; break;
228 case 4: data->fan_div[nr] = 2; break;
229 case 8: data->fan_div[nr] = 3; break;
230 default:
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100231 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 return -EINVAL;
233 }
234
235 tmp = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV) & 0x0F;
236 tmp |= (data->fan_div[0] << 4) | (data->fan_div[1] << 6);
237 smsc47m1_write_value(client, SMSC47M1_REG_FANDIV, tmp);
238
239 /* Preserve fan min */
240 tmp = 192 - (old_div * (192 - data->fan_preload[nr])
241 + new_div / 2) / new_div;
242 data->fan_preload[nr] = SENSORS_LIMIT(tmp, 0, 191);
243 smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr),
244 data->fan_preload[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100245 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
247 return count;
248}
249
250static ssize_t set_pwm(struct device *dev, const char *buf,
251 size_t count, int nr)
252{
253 struct i2c_client *client = to_i2c_client(dev);
254 struct smsc47m1_data *data = i2c_get_clientdata(client);
255
256 long val = simple_strtol(buf, NULL, 10);
257
258 if (val < 0 || val > 255)
259 return -EINVAL;
260
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100261 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 data->pwm[nr] &= 0x81; /* Preserve additional bits */
263 data->pwm[nr] |= PWM_TO_REG(val);
264 smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr),
265 data->pwm[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100266 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
268 return count;
269}
270
271static ssize_t set_pwm_en(struct device *dev, const char *buf,
272 size_t count, int nr)
273{
274 struct i2c_client *client = to_i2c_client(dev);
275 struct smsc47m1_data *data = i2c_get_clientdata(client);
276
277 long val = simple_strtol(buf, NULL, 10);
278
279 if (val != 0 && val != 1)
280 return -EINVAL;
281
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100282 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 data->pwm[nr] &= 0xFE; /* preserve the other bits */
284 data->pwm[nr] |= !val;
285 smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr),
286 data->pwm[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100287 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
289 return count;
290}
291
292#define fan_present(offset) \
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400293static ssize_t get_fan##offset (struct device *dev, struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294{ \
295 return get_fan(dev, buf, offset - 1); \
296} \
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400297static ssize_t get_fan##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298{ \
299 return get_fan_min(dev, buf, offset - 1); \
300} \
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400301static ssize_t set_fan##offset##_min (struct device *dev, struct device_attribute *attr, \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 const char *buf, size_t count) \
303{ \
304 return set_fan_min(dev, buf, count, offset - 1); \
305} \
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400306static ssize_t get_fan##offset##_div (struct device *dev, struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307{ \
308 return get_fan_div(dev, buf, offset - 1); \
309} \
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400310static ssize_t set_fan##offset##_div (struct device *dev, struct device_attribute *attr, \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 const char *buf, size_t count) \
312{ \
313 return set_fan_div(dev, buf, count, offset - 1); \
314} \
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400315static ssize_t get_pwm##offset (struct device *dev, struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316{ \
317 return get_pwm(dev, buf, offset - 1); \
318} \
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400319static ssize_t set_pwm##offset (struct device *dev, struct device_attribute *attr, \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 const char *buf, size_t count) \
321{ \
322 return set_pwm(dev, buf, count, offset - 1); \
323} \
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400324static ssize_t get_pwm##offset##_en (struct device *dev, struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325{ \
326 return get_pwm_en(dev, buf, offset - 1); \
327} \
Yani Ioannoua5099cf2005-05-17 06:42:25 -0400328static ssize_t set_pwm##offset##_en (struct device *dev, struct device_attribute *attr, \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 const char *buf, size_t count) \
330{ \
331 return set_pwm_en(dev, buf, count, offset - 1); \
332} \
333static DEVICE_ATTR(fan##offset##_input, S_IRUGO, get_fan##offset, \
334 NULL); \
335static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
336 get_fan##offset##_min, set_fan##offset##_min); \
337static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
338 get_fan##offset##_div, set_fan##offset##_div); \
339static DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
340 get_pwm##offset, set_pwm##offset); \
341static DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
342 get_pwm##offset##_en, set_pwm##offset##_en);
343
344fan_present(1);
345fan_present(2);
346
347static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL);
348
Jean Delvaree6cfb3a2005-07-27 21:32:02 +0200349static int __init smsc47m1_find(unsigned short *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350{
351 u8 val;
352
353 superio_enter();
354 val = superio_inb(SUPERIO_REG_DEVID);
355
356 /*
357 * SMSC LPC47M10x/LPC47M13x (device id 0x59), LPC47M14x (device id
358 * 0x5F) and LPC47B27x (device id 0x51) have fan control.
359 * The LPC47M15x and LPC47M192 chips "with hardware monitoring block"
Jean Delvareec5ce552005-04-26 22:09:43 +0200360 * can do much more besides (device id 0x60).
Jean Delvareb890a072005-10-26 22:21:24 +0200361 * The LPC47M997 is undocumented, but seems to be compatible with
362 * the LPC47M192, and has the same device id.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 */
364 if (val == 0x51)
Jean Delvareec5ce552005-04-26 22:09:43 +0200365 printk(KERN_INFO "smsc47m1: Found SMSC LPC47B27x\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 else if (val == 0x59)
Jean Delvareec5ce552005-04-26 22:09:43 +0200367 printk(KERN_INFO "smsc47m1: Found SMSC LPC47M10x/LPC47M13x\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 else if (val == 0x5F)
Jean Delvareec5ce552005-04-26 22:09:43 +0200369 printk(KERN_INFO "smsc47m1: Found SMSC LPC47M14x\n");
370 else if (val == 0x60)
Jean Delvareb890a072005-10-26 22:21:24 +0200371 printk(KERN_INFO "smsc47m1: Found SMSC "
372 "LPC47M15x/LPC47M192/LPC47M997\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 else {
374 superio_exit();
375 return -ENODEV;
376 }
377
378 superio_select();
Jean Delvare2d8672c2005-07-19 23:56:35 +0200379 *addr = (superio_inb(SUPERIO_REG_BASE) << 8)
380 | superio_inb(SUPERIO_REG_BASE + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 val = superio_inb(SUPERIO_REG_ACT);
Jean Delvare2d8672c2005-07-19 23:56:35 +0200382 if (*addr == 0 || (val & 0x01) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 printk(KERN_INFO "smsc47m1: Device is disabled, will not use\n");
384 superio_exit();
385 return -ENODEV;
386 }
387
388 superio_exit();
389 return 0;
390}
391
Jean Delvare2d8672c2005-07-19 23:56:35 +0200392static int smsc47m1_detect(struct i2c_adapter *adapter)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393{
394 struct i2c_client *new_client;
395 struct smsc47m1_data *data;
396 int err = 0;
397 int fan1, fan2, pwm1, pwm2;
398
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100399 if (!request_region(address, SMSC_EXTENT, smsc47m1_driver.driver.name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 dev_err(&adapter->dev, "Region 0x%x already in use!\n", address);
401 return -EBUSY;
402 }
403
Deepak Saxenaba9c2e82005-10-17 23:08:32 +0200404 if (!(data = kzalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 err = -ENOMEM;
406 goto error_release;
407 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
409 new_client = &data->client;
410 i2c_set_clientdata(new_client, data);
411 new_client->addr = address;
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100412 mutex_init(&data->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 new_client->adapter = adapter;
414 new_client->driver = &smsc47m1_driver;
415 new_client->flags = 0;
416
417 strlcpy(new_client->name, "smsc47m1", I2C_NAME_SIZE);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100418 mutex_init(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
420 /* If no function is properly configured, there's no point in
421 actually registering the chip. */
422 fan1 = (smsc47m1_read_value(new_client, SMSC47M1_REG_TPIN(0)) & 0x05)
423 == 0x05;
424 fan2 = (smsc47m1_read_value(new_client, SMSC47M1_REG_TPIN(1)) & 0x05)
425 == 0x05;
426 pwm1 = (smsc47m1_read_value(new_client, SMSC47M1_REG_PPIN(0)) & 0x05)
427 == 0x04;
428 pwm2 = (smsc47m1_read_value(new_client, SMSC47M1_REG_PPIN(1)) & 0x05)
429 == 0x04;
430 if (!(fan1 || fan2 || pwm1 || pwm2)) {
431 dev_warn(&new_client->dev, "Device is not configured, will not use\n");
432 err = -ENODEV;
433 goto error_free;
434 }
435
436 if ((err = i2c_attach_client(new_client)))
437 goto error_free;
438
439 /* Some values (fan min, clock dividers, pwm registers) may be
440 needed before any update is triggered, so we better read them
441 at least once here. We don't usually do it that way, but in
442 this particular case, manually reading 5 registers out of 8
443 doesn't make much sense and we're better using the existing
444 function. */
445 smsc47m1_update_device(&new_client->dev, 1);
446
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400447 /* Register sysfs hooks */
448 data->class_dev = hwmon_device_register(&new_client->dev);
449 if (IS_ERR(data->class_dev)) {
450 err = PTR_ERR(data->class_dev);
451 goto error_detach;
452 }
453
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 if (fan1) {
455 device_create_file(&new_client->dev, &dev_attr_fan1_input);
456 device_create_file(&new_client->dev, &dev_attr_fan1_min);
457 device_create_file(&new_client->dev, &dev_attr_fan1_div);
458 } else
459 dev_dbg(&new_client->dev, "Fan 1 not enabled by hardware, "
460 "skipping\n");
461
462 if (fan2) {
463 device_create_file(&new_client->dev, &dev_attr_fan2_input);
464 device_create_file(&new_client->dev, &dev_attr_fan2_min);
465 device_create_file(&new_client->dev, &dev_attr_fan2_div);
466 } else
467 dev_dbg(&new_client->dev, "Fan 2 not enabled by hardware, "
468 "skipping\n");
469
470 if (pwm1) {
471 device_create_file(&new_client->dev, &dev_attr_pwm1);
472 device_create_file(&new_client->dev, &dev_attr_pwm1_enable);
473 } else
474 dev_dbg(&new_client->dev, "PWM 1 not enabled by hardware, "
475 "skipping\n");
476 if (pwm2) {
477 device_create_file(&new_client->dev, &dev_attr_pwm2);
478 device_create_file(&new_client->dev, &dev_attr_pwm2_enable);
479 } else
480 dev_dbg(&new_client->dev, "PWM 2 not enabled by hardware, "
481 "skipping\n");
482
483 device_create_file(&new_client->dev, &dev_attr_alarms);
484
485 return 0;
486
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400487error_detach:
488 i2c_detach_client(new_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489error_free:
Alexey Dobriyan1f57ff82005-08-26 01:49:14 +0400490 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491error_release:
492 release_region(address, SMSC_EXTENT);
493 return err;
494}
495
496static int smsc47m1_detach_client(struct i2c_client *client)
497{
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400498 struct smsc47m1_data *data = i2c_get_clientdata(client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 int err;
500
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400501 hwmon_device_unregister(data->class_dev);
502
Jean Delvare7bef5592005-07-27 22:14:49 +0200503 if ((err = i2c_detach_client(client)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
506 release_region(client->addr, SMSC_EXTENT);
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400507 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
509 return 0;
510}
511
512static int smsc47m1_read_value(struct i2c_client *client, u8 reg)
513{
514 int res;
515
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100516 mutex_lock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 res = inb_p(client->addr + reg);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100518 mutex_unlock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 return res;
520}
521
522static void smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value)
523{
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100524 mutex_lock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 outb_p(value, client->addr + reg);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100526 mutex_unlock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527}
528
529static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
530 int init)
531{
532 struct i2c_client *client = to_i2c_client(dev);
533 struct smsc47m1_data *data = i2c_get_clientdata(client);
534
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100535 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
537 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || init) {
538 int i;
539
540 for (i = 0; i < 2; i++) {
541 data->fan[i] = smsc47m1_read_value(client,
542 SMSC47M1_REG_FAN(i));
543 data->fan_preload[i] = smsc47m1_read_value(client,
544 SMSC47M1_REG_FAN_PRELOAD(i));
545 data->pwm[i] = smsc47m1_read_value(client,
546 SMSC47M1_REG_PWM(i));
547 }
548
549 i = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV);
550 data->fan_div[0] = (i >> 4) & 0x03;
551 data->fan_div[1] = i >> 6;
552
553 data->alarms = smsc47m1_read_value(client,
554 SMSC47M1_REG_ALARM) >> 6;
555 /* Clear alarms if needed */
556 if (data->alarms)
557 smsc47m1_write_value(client, SMSC47M1_REG_ALARM, 0xC0);
558
559 data->last_updated = jiffies;
560 }
561
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100562 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 return data;
564}
565
566static int __init sm_smsc47m1_init(void)
567{
Jean Delvare2d8672c2005-07-19 23:56:35 +0200568 if (smsc47m1_find(&address)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 return -ENODEV;
570 }
571
Jean Delvarefde09502005-07-19 23:51:07 +0200572 return i2c_isa_add_driver(&smsc47m1_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573}
574
575static void __exit sm_smsc47m1_exit(void)
576{
Jean Delvarefde09502005-07-19 23:51:07 +0200577 i2c_isa_del_driver(&smsc47m1_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578}
579
580MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
581MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver");
582MODULE_LICENSE("GPL");
583
584module_init(sm_smsc47m1_init);
585module_exit(sm_smsc47m1_exit);