hwmon/f71882fg: Set platform drvdata to NULL later
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / hwmon / smsc47m1.c
blob8ad50fdba00dbb4744227de6c5d2949b3090c143
1 /*
2 smsc47m1.c - Part of lm_sensors, Linux kernel modules
3 for hardware monitoring
5 Supports the SMSC LPC47B27x, LPC47M10x, LPC47M112, LPC47M13x,
6 LPC47M14x, LPC47M15x, LPC47M192, LPC47M292 and LPC47M997
7 Super-I/O chips.
9 Copyright (C) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
10 Copyright (C) 2004-2007 Jean Delvare <khali@linux-fr.org>
11 Ported to Linux 2.6 by Gabriele Gorla <gorlik@yahoo.com>
12 and Jean Delvare
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 #include <linux/module.h>
30 #include <linux/slab.h>
31 #include <linux/ioport.h>
32 #include <linux/jiffies.h>
33 #include <linux/platform_device.h>
34 #include <linux/hwmon.h>
35 #include <linux/hwmon-sysfs.h>
36 #include <linux/err.h>
37 #include <linux/init.h>
38 #include <linux/mutex.h>
39 #include <linux/sysfs.h>
40 #include <linux/acpi.h>
41 #include <linux/io.h>
43 static unsigned short force_id;
44 module_param(force_id, ushort, 0);
45 MODULE_PARM_DESC(force_id, "Override the detected device ID");
47 static struct platform_device *pdev;
49 #define DRVNAME "smsc47m1"
50 enum chips { smsc47m1, smsc47m2 };
52 /* Super-I/0 registers and commands */
54 #define REG 0x2e /* The register to read/write */
55 #define VAL 0x2f /* The value to read/write */
57 static inline void
58 superio_outb(int reg, int val)
60 outb(reg, REG);
61 outb(val, VAL);
64 static inline int
65 superio_inb(int reg)
67 outb(reg, REG);
68 return inb(VAL);
71 /* logical device for fans is 0x0A */
72 #define superio_select() superio_outb(0x07, 0x0A)
74 static inline void
75 superio_enter(void)
77 outb(0x55, REG);
80 static inline void
81 superio_exit(void)
83 outb(0xAA, REG);
86 #define SUPERIO_REG_ACT 0x30
87 #define SUPERIO_REG_BASE 0x60
88 #define SUPERIO_REG_DEVID 0x20
89 #define SUPERIO_REG_DEVREV 0x21
91 /* Logical device registers */
93 #define SMSC_EXTENT 0x80
95 /* nr is 0 or 1 in the macros below */
96 #define SMSC47M1_REG_ALARM 0x04
97 #define SMSC47M1_REG_TPIN(nr) (0x34 - (nr))
98 #define SMSC47M1_REG_PPIN(nr) (0x36 - (nr))
99 #define SMSC47M1_REG_FANDIV 0x58
101 static const u8 SMSC47M1_REG_FAN[3] = { 0x59, 0x5a, 0x6b };
102 static const u8 SMSC47M1_REG_FAN_PRELOAD[3] = { 0x5b, 0x5c, 0x6c };
103 static const u8 SMSC47M1_REG_PWM[3] = { 0x56, 0x57, 0x69 };
105 #define SMSC47M2_REG_ALARM6 0x09
106 #define SMSC47M2_REG_TPIN1 0x38
107 #define SMSC47M2_REG_TPIN2 0x37
108 #define SMSC47M2_REG_TPIN3 0x2d
109 #define SMSC47M2_REG_PPIN3 0x2c
110 #define SMSC47M2_REG_FANDIV3 0x6a
112 #define MIN_FROM_REG(reg,div) ((reg)>=192 ? 0 : \
113 983040/((192-(reg))*(div)))
114 #define FAN_FROM_REG(reg,div,preload) ((reg)<=(preload) || (reg)==255 ? 0 : \
115 983040/(((reg)-(preload))*(div)))
116 #define DIV_FROM_REG(reg) (1 << (reg))
117 #define PWM_FROM_REG(reg) (((reg) & 0x7E) << 1)
118 #define PWM_EN_FROM_REG(reg) ((~(reg)) & 0x01)
119 #define PWM_TO_REG(reg) (((reg) >> 1) & 0x7E)
121 struct smsc47m1_data {
122 unsigned short addr;
123 const char *name;
124 enum chips type;
125 struct device *hwmon_dev;
127 struct mutex update_lock;
128 unsigned long last_updated; /* In jiffies */
130 u8 fan[3]; /* Register value */
131 u8 fan_preload[3]; /* Register value */
132 u8 fan_div[3]; /* Register encoding, shifted right */
133 u8 alarms; /* Register encoding */
134 u8 pwm[3]; /* Register value (bit 0 is disable) */
137 struct smsc47m1_sio_data {
138 enum chips type;
142 static int smsc47m1_probe(struct platform_device *pdev);
143 static int __devexit smsc47m1_remove(struct platform_device *pdev);
144 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
145 int init);
147 static inline int smsc47m1_read_value(struct smsc47m1_data *data, u8 reg)
149 return inb_p(data->addr + reg);
152 static inline void smsc47m1_write_value(struct smsc47m1_data *data, u8 reg,
153 u8 value)
155 outb_p(value, data->addr + reg);
158 static struct platform_driver smsc47m1_driver = {
159 .driver = {
160 .owner = THIS_MODULE,
161 .name = DRVNAME,
163 .probe = smsc47m1_probe,
164 .remove = __devexit_p(smsc47m1_remove),
167 static ssize_t get_fan(struct device *dev, struct device_attribute
168 *devattr, char *buf)
170 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
171 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
172 int nr = attr->index;
173 /* This chip (stupidly) stops monitoring fan speed if PWM is
174 enabled and duty cycle is 0%. This is fine if the monitoring
175 and control concern the same fan, but troublesome if they are
176 not (which could as well happen). */
177 int rpm = (data->pwm[nr] & 0x7F) == 0x00 ? 0 :
178 FAN_FROM_REG(data->fan[nr],
179 DIV_FROM_REG(data->fan_div[nr]),
180 data->fan_preload[nr]);
181 return sprintf(buf, "%d\n", rpm);
184 static ssize_t get_fan_min(struct device *dev, struct device_attribute
185 *devattr, char *buf)
187 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
188 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
189 int nr = attr->index;
190 int rpm = MIN_FROM_REG(data->fan_preload[nr],
191 DIV_FROM_REG(data->fan_div[nr]));
192 return sprintf(buf, "%d\n", rpm);
195 static ssize_t get_fan_div(struct device *dev, struct device_attribute
196 *devattr, char *buf)
198 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
199 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
200 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
203 static ssize_t get_fan_alarm(struct device *dev, struct device_attribute
204 *devattr, char *buf)
206 int bitnr = to_sensor_dev_attr(devattr)->index;
207 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
208 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
211 static ssize_t get_pwm(struct device *dev, struct device_attribute
212 *devattr, char *buf)
214 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
215 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
216 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[attr->index]));
219 static ssize_t get_pwm_en(struct device *dev, struct device_attribute
220 *devattr, char *buf)
222 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
223 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
224 return sprintf(buf, "%d\n", PWM_EN_FROM_REG(data->pwm[attr->index]));
227 static ssize_t get_alarms(struct device *dev, struct device_attribute
228 *devattr, char *buf)
230 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
231 return sprintf(buf, "%d\n", data->alarms);
234 static ssize_t set_fan_min(struct device *dev, struct device_attribute
235 *devattr, const char *buf, size_t count)
237 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
238 struct smsc47m1_data *data = dev_get_drvdata(dev);
239 int nr = attr->index;
240 long rpmdiv, val = simple_strtol(buf, NULL, 10);
242 mutex_lock(&data->update_lock);
243 rpmdiv = val * DIV_FROM_REG(data->fan_div[nr]);
245 if (983040 > 192 * rpmdiv || 2 * rpmdiv > 983040) {
246 mutex_unlock(&data->update_lock);
247 return -EINVAL;
250 data->fan_preload[nr] = 192 - ((983040 + rpmdiv / 2) / rpmdiv);
251 smsc47m1_write_value(data, SMSC47M1_REG_FAN_PRELOAD[nr],
252 data->fan_preload[nr]);
253 mutex_unlock(&data->update_lock);
255 return count;
258 /* Note: we save and restore the fan minimum here, because its value is
259 determined in part by the fan clock divider. This follows the principle
260 of least surprise; the user doesn't expect the fan minimum to change just
261 because the divider changed. */
262 static ssize_t set_fan_div(struct device *dev, struct device_attribute
263 *devattr, const char *buf, size_t count)
265 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
266 struct smsc47m1_data *data = dev_get_drvdata(dev);
267 int nr = attr->index;
268 long new_div = simple_strtol(buf, NULL, 10), tmp;
269 u8 old_div = DIV_FROM_REG(data->fan_div[nr]);
271 if (new_div == old_div) /* No change */
272 return count;
274 mutex_lock(&data->update_lock);
275 switch (new_div) {
276 case 1: data->fan_div[nr] = 0; break;
277 case 2: data->fan_div[nr] = 1; break;
278 case 4: data->fan_div[nr] = 2; break;
279 case 8: data->fan_div[nr] = 3; break;
280 default:
281 mutex_unlock(&data->update_lock);
282 return -EINVAL;
285 switch (nr) {
286 case 0:
287 case 1:
288 tmp = smsc47m1_read_value(data, SMSC47M1_REG_FANDIV)
289 & ~(0x03 << (4 + 2 * nr));
290 tmp |= data->fan_div[nr] << (4 + 2 * nr);
291 smsc47m1_write_value(data, SMSC47M1_REG_FANDIV, tmp);
292 break;
293 case 2:
294 tmp = smsc47m1_read_value(data, SMSC47M2_REG_FANDIV3) & 0xCF;
295 tmp |= data->fan_div[2] << 4;
296 smsc47m1_write_value(data, SMSC47M2_REG_FANDIV3, tmp);
297 break;
300 /* Preserve fan min */
301 tmp = 192 - (old_div * (192 - data->fan_preload[nr])
302 + new_div / 2) / new_div;
303 data->fan_preload[nr] = SENSORS_LIMIT(tmp, 0, 191);
304 smsc47m1_write_value(data, SMSC47M1_REG_FAN_PRELOAD[nr],
305 data->fan_preload[nr]);
306 mutex_unlock(&data->update_lock);
308 return count;
311 static ssize_t set_pwm(struct device *dev, struct device_attribute
312 *devattr, const char *buf, size_t count)
314 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
315 struct smsc47m1_data *data = dev_get_drvdata(dev);
316 int nr = attr->index;
317 long val = simple_strtol(buf, NULL, 10);
319 if (val < 0 || val > 255)
320 return -EINVAL;
322 mutex_lock(&data->update_lock);
323 data->pwm[nr] &= 0x81; /* Preserve additional bits */
324 data->pwm[nr] |= PWM_TO_REG(val);
325 smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr],
326 data->pwm[nr]);
327 mutex_unlock(&data->update_lock);
329 return count;
332 static ssize_t set_pwm_en(struct device *dev, struct device_attribute
333 *devattr, const char *buf, size_t count)
335 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
336 struct smsc47m1_data *data = dev_get_drvdata(dev);
337 int nr = attr->index;
338 long val = simple_strtol(buf, NULL, 10);
340 if (val != 0 && val != 1)
341 return -EINVAL;
343 mutex_lock(&data->update_lock);
344 data->pwm[nr] &= 0xFE; /* preserve the other bits */
345 data->pwm[nr] |= !val;
346 smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr],
347 data->pwm[nr]);
348 mutex_unlock(&data->update_lock);
350 return count;
353 #define fan_present(offset) \
354 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, get_fan, \
355 NULL, offset - 1); \
356 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
357 get_fan_min, set_fan_min, offset - 1); \
358 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
359 get_fan_div, set_fan_div, offset - 1); \
360 static SENSOR_DEVICE_ATTR(fan##offset##_alarm, S_IRUGO, get_fan_alarm, \
361 NULL, offset - 1); \
362 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
363 get_pwm, set_pwm, offset - 1); \
364 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
365 get_pwm_en, set_pwm_en, offset - 1)
367 fan_present(1);
368 fan_present(2);
369 fan_present(3);
371 static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL);
373 static ssize_t show_name(struct device *dev, struct device_attribute
374 *devattr, char *buf)
376 struct smsc47m1_data *data = dev_get_drvdata(dev);
378 return sprintf(buf, "%s\n", data->name);
380 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
382 /* Almost all sysfs files may or may not be created depending on the chip
383 setup so we create them individually. It is still convenient to define a
384 group to remove them all at once. */
385 static struct attribute *smsc47m1_attributes[] = {
386 &sensor_dev_attr_fan1_input.dev_attr.attr,
387 &sensor_dev_attr_fan1_min.dev_attr.attr,
388 &sensor_dev_attr_fan1_div.dev_attr.attr,
389 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
390 &sensor_dev_attr_fan2_input.dev_attr.attr,
391 &sensor_dev_attr_fan2_min.dev_attr.attr,
392 &sensor_dev_attr_fan2_div.dev_attr.attr,
393 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
394 &sensor_dev_attr_fan3_input.dev_attr.attr,
395 &sensor_dev_attr_fan3_min.dev_attr.attr,
396 &sensor_dev_attr_fan3_div.dev_attr.attr,
397 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
399 &sensor_dev_attr_pwm1.dev_attr.attr,
400 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
401 &sensor_dev_attr_pwm2.dev_attr.attr,
402 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
403 &sensor_dev_attr_pwm3.dev_attr.attr,
404 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
406 &dev_attr_alarms.attr,
407 &dev_attr_name.attr,
408 NULL
411 static const struct attribute_group smsc47m1_group = {
412 .attrs = smsc47m1_attributes,
415 static int __init smsc47m1_find(unsigned short *addr,
416 struct smsc47m1_sio_data *sio_data)
418 u8 val;
420 superio_enter();
421 val = force_id ? force_id : superio_inb(SUPERIO_REG_DEVID);
424 * SMSC LPC47M10x/LPC47M112/LPC47M13x (device id 0x59), LPC47M14x
425 * (device id 0x5F) and LPC47B27x (device id 0x51) have fan control.
426 * The LPC47M15x and LPC47M192 chips "with hardware monitoring block"
427 * can do much more besides (device id 0x60).
428 * The LPC47M997 is undocumented, but seems to be compatible with
429 * the LPC47M192, and has the same device id.
430 * The LPC47M292 (device id 0x6B) is somewhat compatible, but it
431 * supports a 3rd fan, and the pin configuration registers are
432 * unfortunately different.
433 * The LPC47M233 has the same device id (0x6B) but is not compatible.
434 * We check the high bit of the device revision register to
435 * differentiate them.
437 switch (val) {
438 case 0x51:
439 pr_info(DRVNAME ": Found SMSC LPC47B27x\n");
440 sio_data->type = smsc47m1;
441 break;
442 case 0x59:
443 pr_info(DRVNAME ": Found SMSC LPC47M10x/LPC47M112/LPC47M13x\n");
444 sio_data->type = smsc47m1;
445 break;
446 case 0x5F:
447 pr_info(DRVNAME ": Found SMSC LPC47M14x\n");
448 sio_data->type = smsc47m1;
449 break;
450 case 0x60:
451 pr_info(DRVNAME ": Found SMSC LPC47M15x/LPC47M192/LPC47M997\n");
452 sio_data->type = smsc47m1;
453 break;
454 case 0x6B:
455 if (superio_inb(SUPERIO_REG_DEVREV) & 0x80) {
456 pr_debug(DRVNAME ": "
457 "Found SMSC LPC47M233, unsupported\n");
458 superio_exit();
459 return -ENODEV;
462 pr_info(DRVNAME ": Found SMSC LPC47M292\n");
463 sio_data->type = smsc47m2;
464 break;
465 default:
466 superio_exit();
467 return -ENODEV;
470 superio_select();
471 *addr = (superio_inb(SUPERIO_REG_BASE) << 8)
472 | superio_inb(SUPERIO_REG_BASE + 1);
473 val = superio_inb(SUPERIO_REG_ACT);
474 if (*addr == 0 || (val & 0x01) == 0) {
475 pr_info(DRVNAME ": Device is disabled, will not use\n");
476 superio_exit();
477 return -ENODEV;
480 superio_exit();
481 return 0;
484 static int __devinit smsc47m1_probe(struct platform_device *pdev)
486 struct device *dev = &pdev->dev;
487 struct smsc47m1_sio_data *sio_data = dev->platform_data;
488 struct smsc47m1_data *data;
489 struct resource *res;
490 int err = 0;
491 int fan1, fan2, fan3, pwm1, pwm2, pwm3;
493 static const char *names[] = {
494 "smsc47m1",
495 "smsc47m2",
498 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
499 if (!request_region(res->start, SMSC_EXTENT, DRVNAME)) {
500 dev_err(dev, "Region 0x%lx-0x%lx already in use!\n",
501 (unsigned long)res->start,
502 (unsigned long)res->end);
503 return -EBUSY;
506 if (!(data = kzalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) {
507 err = -ENOMEM;
508 goto error_release;
511 data->addr = res->start;
512 data->type = sio_data->type;
513 data->name = names[sio_data->type];
514 mutex_init(&data->update_lock);
515 platform_set_drvdata(pdev, data);
517 /* If no function is properly configured, there's no point in
518 actually registering the chip. */
519 pwm1 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(0)) & 0x05)
520 == 0x04;
521 pwm2 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(1)) & 0x05)
522 == 0x04;
523 if (data->type == smsc47m2) {
524 fan1 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN1)
525 & 0x0d) == 0x09;
526 fan2 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN2)
527 & 0x0d) == 0x09;
528 fan3 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN3)
529 & 0x0d) == 0x0d;
530 pwm3 = (smsc47m1_read_value(data, SMSC47M2_REG_PPIN3)
531 & 0x0d) == 0x08;
532 } else {
533 fan1 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(0))
534 & 0x05) == 0x05;
535 fan2 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(1))
536 & 0x05) == 0x05;
537 fan3 = 0;
538 pwm3 = 0;
540 if (!(fan1 || fan2 || fan3 || pwm1 || pwm2 || pwm3)) {
541 dev_warn(dev, "Device not configured, will not use\n");
542 err = -ENODEV;
543 goto error_free;
546 /* Some values (fan min, clock dividers, pwm registers) may be
547 needed before any update is triggered, so we better read them
548 at least once here. We don't usually do it that way, but in
549 this particular case, manually reading 5 registers out of 8
550 doesn't make much sense and we're better using the existing
551 function. */
552 smsc47m1_update_device(dev, 1);
554 /* Register sysfs hooks */
555 if (fan1) {
556 if ((err = device_create_file(dev,
557 &sensor_dev_attr_fan1_input.dev_attr))
558 || (err = device_create_file(dev,
559 &sensor_dev_attr_fan1_min.dev_attr))
560 || (err = device_create_file(dev,
561 &sensor_dev_attr_fan1_div.dev_attr))
562 || (err = device_create_file(dev,
563 &sensor_dev_attr_fan1_alarm.dev_attr)))
564 goto error_remove_files;
565 } else
566 dev_dbg(dev, "Fan 1 not enabled by hardware, skipping\n");
568 if (fan2) {
569 if ((err = device_create_file(dev,
570 &sensor_dev_attr_fan2_input.dev_attr))
571 || (err = device_create_file(dev,
572 &sensor_dev_attr_fan2_min.dev_attr))
573 || (err = device_create_file(dev,
574 &sensor_dev_attr_fan2_div.dev_attr))
575 || (err = device_create_file(dev,
576 &sensor_dev_attr_fan2_alarm.dev_attr)))
577 goto error_remove_files;
578 } else
579 dev_dbg(dev, "Fan 2 not enabled by hardware, skipping\n");
581 if (fan3) {
582 if ((err = device_create_file(dev,
583 &sensor_dev_attr_fan3_input.dev_attr))
584 || (err = device_create_file(dev,
585 &sensor_dev_attr_fan3_min.dev_attr))
586 || (err = device_create_file(dev,
587 &sensor_dev_attr_fan3_div.dev_attr))
588 || (err = device_create_file(dev,
589 &sensor_dev_attr_fan3_alarm.dev_attr)))
590 goto error_remove_files;
591 } else if (data->type == smsc47m2)
592 dev_dbg(dev, "Fan 3 not enabled by hardware, skipping\n");
594 if (pwm1) {
595 if ((err = device_create_file(dev,
596 &sensor_dev_attr_pwm1.dev_attr))
597 || (err = device_create_file(dev,
598 &sensor_dev_attr_pwm1_enable.dev_attr)))
599 goto error_remove_files;
600 } else
601 dev_dbg(dev, "PWM 1 not enabled by hardware, skipping\n");
603 if (pwm2) {
604 if ((err = device_create_file(dev,
605 &sensor_dev_attr_pwm2.dev_attr))
606 || (err = device_create_file(dev,
607 &sensor_dev_attr_pwm2_enable.dev_attr)))
608 goto error_remove_files;
609 } else
610 dev_dbg(dev, "PWM 2 not enabled by hardware, skipping\n");
612 if (pwm3) {
613 if ((err = device_create_file(dev,
614 &sensor_dev_attr_pwm3.dev_attr))
615 || (err = device_create_file(dev,
616 &sensor_dev_attr_pwm3_enable.dev_attr)))
617 goto error_remove_files;
618 } else if (data->type == smsc47m2)
619 dev_dbg(dev, "PWM 3 not enabled by hardware, skipping\n");
621 if ((err = device_create_file(dev, &dev_attr_alarms)))
622 goto error_remove_files;
623 if ((err = device_create_file(dev, &dev_attr_name)))
624 goto error_remove_files;
626 data->hwmon_dev = hwmon_device_register(dev);
627 if (IS_ERR(data->hwmon_dev)) {
628 err = PTR_ERR(data->hwmon_dev);
629 goto error_remove_files;
632 return 0;
634 error_remove_files:
635 sysfs_remove_group(&dev->kobj, &smsc47m1_group);
636 error_free:
637 platform_set_drvdata(pdev, NULL);
638 kfree(data);
639 error_release:
640 release_region(res->start, SMSC_EXTENT);
641 return err;
644 static int __devexit smsc47m1_remove(struct platform_device *pdev)
646 struct smsc47m1_data *data = platform_get_drvdata(pdev);
647 struct resource *res;
649 hwmon_device_unregister(data->hwmon_dev);
650 sysfs_remove_group(&pdev->dev.kobj, &smsc47m1_group);
652 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
653 release_region(res->start, SMSC_EXTENT);
654 platform_set_drvdata(pdev, NULL);
655 kfree(data);
657 return 0;
660 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
661 int init)
663 struct smsc47m1_data *data = dev_get_drvdata(dev);
665 mutex_lock(&data->update_lock);
667 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || init) {
668 int i, fan_nr;
669 fan_nr = data->type == smsc47m2 ? 3 : 2;
671 for (i = 0; i < fan_nr; i++) {
672 data->fan[i] = smsc47m1_read_value(data,
673 SMSC47M1_REG_FAN[i]);
674 data->fan_preload[i] = smsc47m1_read_value(data,
675 SMSC47M1_REG_FAN_PRELOAD[i]);
676 data->pwm[i] = smsc47m1_read_value(data,
677 SMSC47M1_REG_PWM[i]);
680 i = smsc47m1_read_value(data, SMSC47M1_REG_FANDIV);
681 data->fan_div[0] = (i >> 4) & 0x03;
682 data->fan_div[1] = i >> 6;
684 data->alarms = smsc47m1_read_value(data,
685 SMSC47M1_REG_ALARM) >> 6;
686 /* Clear alarms if needed */
687 if (data->alarms)
688 smsc47m1_write_value(data, SMSC47M1_REG_ALARM, 0xC0);
690 if (fan_nr >= 3) {
691 data->fan_div[2] = (smsc47m1_read_value(data,
692 SMSC47M2_REG_FANDIV3) >> 4) & 0x03;
693 data->alarms |= (smsc47m1_read_value(data,
694 SMSC47M2_REG_ALARM6) & 0x40) >> 4;
695 /* Clear alarm if needed */
696 if (data->alarms & 0x04)
697 smsc47m1_write_value(data,
698 SMSC47M2_REG_ALARM6,
699 0x40);
702 data->last_updated = jiffies;
705 mutex_unlock(&data->update_lock);
706 return data;
709 static int __init smsc47m1_device_add(unsigned short address,
710 const struct smsc47m1_sio_data *sio_data)
712 struct resource res = {
713 .start = address,
714 .end = address + SMSC_EXTENT - 1,
715 .name = DRVNAME,
716 .flags = IORESOURCE_IO,
718 int err;
720 err = acpi_check_resource_conflict(&res);
721 if (err)
722 goto exit;
724 pdev = platform_device_alloc(DRVNAME, address);
725 if (!pdev) {
726 err = -ENOMEM;
727 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
728 goto exit;
731 err = platform_device_add_resources(pdev, &res, 1);
732 if (err) {
733 printk(KERN_ERR DRVNAME ": Device resource addition failed "
734 "(%d)\n", err);
735 goto exit_device_put;
738 err = platform_device_add_data(pdev, sio_data,
739 sizeof(struct smsc47m1_sio_data));
740 if (err) {
741 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
742 goto exit_device_put;
745 err = platform_device_add(pdev);
746 if (err) {
747 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
748 err);
749 goto exit_device_put;
752 return 0;
754 exit_device_put:
755 platform_device_put(pdev);
756 exit:
757 return err;
760 static int __init sm_smsc47m1_init(void)
762 int err;
763 unsigned short address;
764 struct smsc47m1_sio_data sio_data;
766 if (smsc47m1_find(&address, &sio_data))
767 return -ENODEV;
769 err = platform_driver_register(&smsc47m1_driver);
770 if (err)
771 goto exit;
773 /* Sets global pdev as a side effect */
774 err = smsc47m1_device_add(address, &sio_data);
775 if (err)
776 goto exit_driver;
778 return 0;
780 exit_driver:
781 platform_driver_unregister(&smsc47m1_driver);
782 exit:
783 return err;
786 static void __exit sm_smsc47m1_exit(void)
788 platform_device_unregister(pdev);
789 platform_driver_unregister(&smsc47m1_driver);
792 MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
793 MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver");
794 MODULE_LICENSE("GPL");
796 module_init(sm_smsc47m1_init);
797 module_exit(sm_smsc47m1_exit);