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
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>
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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
31 #include <linux/module.h>
32 #include <linux/slab.h>
33 #include <linux/ioport.h>
34 #include <linux/jiffies.h>
35 #include <linux/platform_device.h>
36 #include <linux/hwmon.h>
37 #include <linux/hwmon-sysfs.h>
38 #include <linux/err.h>
39 #include <linux/init.h>
40 #include <linux/mutex.h>
41 #include <linux/sysfs.h>
42 #include <linux/acpi.h>
45 static unsigned short force_id;
46 module_param(force_id, ushort, 0);
47 MODULE_PARM_DESC(force_id, "Override the detected device ID");
49 static struct platform_device *pdev;
51 #define DRVNAME "smsc47m1"
52 enum chips { smsc47m1, smsc47m2 };
54 /* Super-I/0 registers and commands */
56 #define REG 0x2e /* The register to read/write */
57 #define VAL 0x2f /* The value to read/write */
60 superio_outb(int reg, int val)
73 /* logical device for fans is 0x0A */
74 #define superio_select() superio_outb(0x07, 0x0A)
88 #define SUPERIO_REG_ACT 0x30
89 #define SUPERIO_REG_BASE 0x60
90 #define SUPERIO_REG_DEVID 0x20
91 #define SUPERIO_REG_DEVREV 0x21
93 /* Logical device registers */
95 #define SMSC_EXTENT 0x80
97 /* nr is 0 or 1 in the macros below */
98 #define SMSC47M1_REG_ALARM 0x04
99 #define SMSC47M1_REG_TPIN(nr) (0x34 - (nr))
100 #define SMSC47M1_REG_PPIN(nr) (0x36 - (nr))
101 #define SMSC47M1_REG_FANDIV 0x58
103 static const u8 SMSC47M1_REG_FAN[3] = { 0x59, 0x5a, 0x6b };
104 static const u8 SMSC47M1_REG_FAN_PRELOAD[3] = { 0x5b, 0x5c, 0x6c };
105 static const u8 SMSC47M1_REG_PWM[3] = { 0x56, 0x57, 0x69 };
107 #define SMSC47M2_REG_ALARM6 0x09
108 #define SMSC47M2_REG_TPIN1 0x38
109 #define SMSC47M2_REG_TPIN2 0x37
110 #define SMSC47M2_REG_TPIN3 0x2d
111 #define SMSC47M2_REG_PPIN3 0x2c
112 #define SMSC47M2_REG_FANDIV3 0x6a
114 #define MIN_FROM_REG(reg,div) ((reg)>=192 ? 0 : \
115 983040/((192-(reg))*(div)))
116 #define FAN_FROM_REG(reg,div,preload) ((reg)<=(preload) || (reg)==255 ? 0 : \
117 983040/(((reg)-(preload))*(div)))
118 #define DIV_FROM_REG(reg) (1 << (reg))
119 #define PWM_FROM_REG(reg) (((reg) & 0x7E) << 1)
120 #define PWM_EN_FROM_REG(reg) ((~(reg)) & 0x01)
121 #define PWM_TO_REG(reg) (((reg) >> 1) & 0x7E)
123 struct smsc47m1_data {
127 struct device *hwmon_dev;
129 struct mutex update_lock;
130 unsigned long last_updated; /* In jiffies */
132 u8 fan[3]; /* Register value */
133 u8 fan_preload[3]; /* Register value */
134 u8 fan_div[3]; /* Register encoding, shifted right */
135 u8 alarms; /* Register encoding */
136 u8 pwm[3]; /* Register value (bit 0 is disable) */
139 struct smsc47m1_sio_data {
141 u8 activate; /* Remember initial device state */
145 static int __exit smsc47m1_remove(struct platform_device *pdev);
146 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
149 static inline int smsc47m1_read_value(struct smsc47m1_data *data, u8 reg)
151 return inb_p(data->addr + reg);
154 static inline void smsc47m1_write_value(struct smsc47m1_data *data, u8 reg,
157 outb_p(value, data->addr + reg);
160 static struct platform_driver smsc47m1_driver = {
162 .owner = THIS_MODULE,
165 .remove = __exit_p(smsc47m1_remove),
168 static ssize_t get_fan(struct device *dev, struct device_attribute
171 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
172 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
173 int nr = attr->index;
174 /* This chip (stupidly) stops monitoring fan speed if PWM is
175 enabled and duty cycle is 0%. This is fine if the monitoring
176 and control concern the same fan, but troublesome if they are
177 not (which could as well happen). */
178 int rpm = (data->pwm[nr] & 0x7F) == 0x00 ? 0 :
179 FAN_FROM_REG(data->fan[nr],
180 DIV_FROM_REG(data->fan_div[nr]),
181 data->fan_preload[nr]);
182 return sprintf(buf, "%d\n", rpm);
185 static ssize_t get_fan_min(struct device *dev, struct device_attribute
188 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
189 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
190 int nr = attr->index;
191 int rpm = MIN_FROM_REG(data->fan_preload[nr],
192 DIV_FROM_REG(data->fan_div[nr]));
193 return sprintf(buf, "%d\n", rpm);
196 static ssize_t get_fan_div(struct device *dev, struct device_attribute
199 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
200 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
201 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
204 static ssize_t get_fan_alarm(struct device *dev, struct device_attribute
207 int bitnr = to_sensor_dev_attr(devattr)->index;
208 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
209 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
212 static ssize_t get_pwm(struct device *dev, struct device_attribute
215 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
216 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
217 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[attr->index]));
220 static ssize_t get_pwm_en(struct device *dev, struct device_attribute
223 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
224 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
225 return sprintf(buf, "%d\n", PWM_EN_FROM_REG(data->pwm[attr->index]));
228 static ssize_t get_alarms(struct device *dev, struct device_attribute
231 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
232 return sprintf(buf, "%d\n", data->alarms);
235 static ssize_t set_fan_min(struct device *dev, struct device_attribute
236 *devattr, const char *buf, size_t count)
238 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
239 struct smsc47m1_data *data = dev_get_drvdata(dev);
240 int nr = attr->index;
241 long rpmdiv, val = simple_strtol(buf, NULL, 10);
243 mutex_lock(&data->update_lock);
244 rpmdiv = val * DIV_FROM_REG(data->fan_div[nr]);
246 if (983040 > 192 * rpmdiv || 2 * rpmdiv > 983040) {
247 mutex_unlock(&data->update_lock);
251 data->fan_preload[nr] = 192 - ((983040 + rpmdiv / 2) / rpmdiv);
252 smsc47m1_write_value(data, SMSC47M1_REG_FAN_PRELOAD[nr],
253 data->fan_preload[nr]);
254 mutex_unlock(&data->update_lock);
259 /* Note: we save and restore the fan minimum here, because its value is
260 determined in part by the fan clock divider. This follows the principle
261 of least surprise; the user doesn't expect the fan minimum to change just
262 because the divider changed. */
263 static ssize_t set_fan_div(struct device *dev, struct device_attribute
264 *devattr, const char *buf, size_t count)
266 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
267 struct smsc47m1_data *data = dev_get_drvdata(dev);
268 int nr = attr->index;
269 long new_div = simple_strtol(buf, NULL, 10), tmp;
270 u8 old_div = DIV_FROM_REG(data->fan_div[nr]);
272 if (new_div == old_div) /* No change */
275 mutex_lock(&data->update_lock);
277 case 1: data->fan_div[nr] = 0; break;
278 case 2: data->fan_div[nr] = 1; break;
279 case 4: data->fan_div[nr] = 2; break;
280 case 8: data->fan_div[nr] = 3; break;
282 mutex_unlock(&data->update_lock);
289 tmp = smsc47m1_read_value(data, SMSC47M1_REG_FANDIV)
290 & ~(0x03 << (4 + 2 * nr));
291 tmp |= data->fan_div[nr] << (4 + 2 * nr);
292 smsc47m1_write_value(data, SMSC47M1_REG_FANDIV, tmp);
295 tmp = smsc47m1_read_value(data, SMSC47M2_REG_FANDIV3) & 0xCF;
296 tmp |= data->fan_div[2] << 4;
297 smsc47m1_write_value(data, SMSC47M2_REG_FANDIV3, tmp);
301 /* Preserve fan min */
302 tmp = 192 - (old_div * (192 - data->fan_preload[nr])
303 + new_div / 2) / new_div;
304 data->fan_preload[nr] = SENSORS_LIMIT(tmp, 0, 191);
305 smsc47m1_write_value(data, SMSC47M1_REG_FAN_PRELOAD[nr],
306 data->fan_preload[nr]);
307 mutex_unlock(&data->update_lock);
312 static ssize_t set_pwm(struct device *dev, struct device_attribute
313 *devattr, const char *buf, size_t count)
315 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
316 struct smsc47m1_data *data = dev_get_drvdata(dev);
317 int nr = attr->index;
318 long val = simple_strtol(buf, NULL, 10);
320 if (val < 0 || val > 255)
323 mutex_lock(&data->update_lock);
324 data->pwm[nr] &= 0x81; /* Preserve additional bits */
325 data->pwm[nr] |= PWM_TO_REG(val);
326 smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr],
328 mutex_unlock(&data->update_lock);
333 static ssize_t set_pwm_en(struct device *dev, struct device_attribute
334 *devattr, const char *buf, size_t count)
336 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
337 struct smsc47m1_data *data = dev_get_drvdata(dev);
338 int nr = attr->index;
339 long val = simple_strtol(buf, NULL, 10);
341 if (val != 0 && val != 1)
344 mutex_lock(&data->update_lock);
345 data->pwm[nr] &= 0xFE; /* preserve the other bits */
346 data->pwm[nr] |= !val;
347 smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr],
349 mutex_unlock(&data->update_lock);
354 #define fan_present(offset) \
355 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, get_fan, \
357 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
358 get_fan_min, set_fan_min, offset - 1); \
359 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
360 get_fan_div, set_fan_div, offset - 1); \
361 static SENSOR_DEVICE_ATTR(fan##offset##_alarm, S_IRUGO, get_fan_alarm, \
363 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
364 get_pwm, set_pwm, offset - 1); \
365 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
366 get_pwm_en, set_pwm_en, offset - 1)
372 static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL);
374 static ssize_t show_name(struct device *dev, struct device_attribute
377 struct smsc47m1_data *data = dev_get_drvdata(dev);
379 return sprintf(buf, "%s\n", data->name);
381 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
383 /* Almost all sysfs files may or may not be created depending on the chip
384 setup so we create them individually. It is still convenient to define a
385 group to remove them all at once. */
386 static struct attribute *smsc47m1_attributes[] = {
387 &sensor_dev_attr_fan1_input.dev_attr.attr,
388 &sensor_dev_attr_fan1_min.dev_attr.attr,
389 &sensor_dev_attr_fan1_div.dev_attr.attr,
390 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
391 &sensor_dev_attr_fan2_input.dev_attr.attr,
392 &sensor_dev_attr_fan2_min.dev_attr.attr,
393 &sensor_dev_attr_fan2_div.dev_attr.attr,
394 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
395 &sensor_dev_attr_fan3_input.dev_attr.attr,
396 &sensor_dev_attr_fan3_min.dev_attr.attr,
397 &sensor_dev_attr_fan3_div.dev_attr.attr,
398 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
400 &sensor_dev_attr_pwm1.dev_attr.attr,
401 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
402 &sensor_dev_attr_pwm2.dev_attr.attr,
403 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
404 &sensor_dev_attr_pwm3.dev_attr.attr,
405 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
407 &dev_attr_alarms.attr,
412 static const struct attribute_group smsc47m1_group = {
413 .attrs = smsc47m1_attributes,
416 static int __init smsc47m1_find(unsigned short *addr,
417 struct smsc47m1_sio_data *sio_data)
422 val = force_id ? force_id : superio_inb(SUPERIO_REG_DEVID);
425 * SMSC LPC47M10x/LPC47M112/LPC47M13x (device id 0x59), LPC47M14x
426 * (device id 0x5F) and LPC47B27x (device id 0x51) have fan control.
427 * The LPC47M15x and LPC47M192 chips "with hardware monitoring block"
428 * can do much more besides (device id 0x60).
429 * The LPC47M997 is undocumented, but seems to be compatible with
430 * the LPC47M192, and has the same device id.
431 * The LPC47M292 (device id 0x6B) is somewhat compatible, but it
432 * supports a 3rd fan, and the pin configuration registers are
433 * unfortunately different.
434 * The LPC47M233 has the same device id (0x6B) but is not compatible.
435 * We check the high bit of the device revision register to
436 * differentiate them.
440 pr_info("Found SMSC LPC47B27x\n");
441 sio_data->type = smsc47m1;
444 pr_info("Found SMSC LPC47M10x/LPC47M112/LPC47M13x\n");
445 sio_data->type = smsc47m1;
448 pr_info("Found SMSC LPC47M14x\n");
449 sio_data->type = smsc47m1;
452 pr_info("Found SMSC LPC47M15x/LPC47M192/LPC47M997\n");
453 sio_data->type = smsc47m1;
456 if (superio_inb(SUPERIO_REG_DEVREV) & 0x80) {
457 pr_debug("Found SMSC LPC47M233, unsupported\n");
462 pr_info("Found SMSC LPC47M292\n");
463 sio_data->type = smsc47m2;
471 *addr = (superio_inb(SUPERIO_REG_BASE) << 8)
472 | superio_inb(SUPERIO_REG_BASE + 1);
474 pr_info("Device address not set, will not use\n");
479 /* Enable only if address is set (needed at least on the
480 * Compaq Presario S4000NX) */
481 sio_data->activate = superio_inb(SUPERIO_REG_ACT);
482 if ((sio_data->activate & 0x01) == 0) {
483 pr_info("Enabling device\n");
484 superio_outb(SUPERIO_REG_ACT, sio_data->activate | 0x01);
491 /* Restore device to its initial state */
492 static void smsc47m1_restore(const struct smsc47m1_sio_data *sio_data)
494 if ((sio_data->activate & 0x01) == 0) {
498 pr_info("Disabling device\n");
499 superio_outb(SUPERIO_REG_ACT, sio_data->activate);
510 * This function can be used to:
511 * - test for resource conflicts with ACPI
512 * - request the resources
513 * - release the resources
514 * We only allocate the I/O ports we really need, to minimize the risk of
515 * conflicts with ACPI or with other drivers.
517 static int smsc47m1_handle_resources(unsigned short address, enum chips type,
518 int action, struct device *dev)
520 static const u8 ports_m1[] = {
521 /* register, region length */
527 static const u8 ports_m2[] = {
528 /* register, region length */
537 int i, ports_size, err;
544 ports_size = ARRAY_SIZE(ports_m1);
548 ports_size = ARRAY_SIZE(ports_m2);
552 for (i = 0; i + 1 < ports_size; i += 2) {
553 unsigned short start = address + ports[i];
554 unsigned short len = ports[i + 1];
558 /* Only check for conflicts */
559 err = acpi_check_region(start, len, DRVNAME);
564 /* Request the resources */
565 if (!request_region(start, len, DRVNAME)) {
566 dev_err(dev, "Region 0x%hx-0x%hx already in "
567 "use!\n", start, start + len);
569 /* Undo all requests */
570 for (i -= 2; i >= 0; i -= 2)
571 release_region(address + ports[i],
577 /* Release the resources */
578 release_region(start, len);
586 static int __init smsc47m1_probe(struct platform_device *pdev)
588 struct device *dev = &pdev->dev;
589 struct smsc47m1_sio_data *sio_data = dev->platform_data;
590 struct smsc47m1_data *data;
591 struct resource *res;
593 int fan1, fan2, fan3, pwm1, pwm2, pwm3;
595 static const char *names[] = {
600 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
601 err = smsc47m1_handle_resources(res->start, sio_data->type,
606 if (!(data = kzalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) {
611 data->addr = res->start;
612 data->type = sio_data->type;
613 data->name = names[sio_data->type];
614 mutex_init(&data->update_lock);
615 platform_set_drvdata(pdev, data);
617 /* If no function is properly configured, there's no point in
618 actually registering the chip. */
619 pwm1 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(0)) & 0x05)
621 pwm2 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(1)) & 0x05)
623 if (data->type == smsc47m2) {
624 fan1 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN1)
626 fan2 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN2)
628 fan3 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN3)
630 pwm3 = (smsc47m1_read_value(data, SMSC47M2_REG_PPIN3)
633 fan1 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(0))
635 fan2 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(1))
640 if (!(fan1 || fan2 || fan3 || pwm1 || pwm2 || pwm3)) {
641 dev_warn(dev, "Device not configured, will not use\n");
646 /* Some values (fan min, clock dividers, pwm registers) may be
647 needed before any update is triggered, so we better read them
648 at least once here. We don't usually do it that way, but in
649 this particular case, manually reading 5 registers out of 8
650 doesn't make much sense and we're better using the existing
652 smsc47m1_update_device(dev, 1);
654 /* Register sysfs hooks */
656 if ((err = device_create_file(dev,
657 &sensor_dev_attr_fan1_input.dev_attr))
658 || (err = device_create_file(dev,
659 &sensor_dev_attr_fan1_min.dev_attr))
660 || (err = device_create_file(dev,
661 &sensor_dev_attr_fan1_div.dev_attr))
662 || (err = device_create_file(dev,
663 &sensor_dev_attr_fan1_alarm.dev_attr)))
664 goto error_remove_files;
666 dev_dbg(dev, "Fan 1 not enabled by hardware, skipping\n");
669 if ((err = device_create_file(dev,
670 &sensor_dev_attr_fan2_input.dev_attr))
671 || (err = device_create_file(dev,
672 &sensor_dev_attr_fan2_min.dev_attr))
673 || (err = device_create_file(dev,
674 &sensor_dev_attr_fan2_div.dev_attr))
675 || (err = device_create_file(dev,
676 &sensor_dev_attr_fan2_alarm.dev_attr)))
677 goto error_remove_files;
679 dev_dbg(dev, "Fan 2 not enabled by hardware, skipping\n");
682 if ((err = device_create_file(dev,
683 &sensor_dev_attr_fan3_input.dev_attr))
684 || (err = device_create_file(dev,
685 &sensor_dev_attr_fan3_min.dev_attr))
686 || (err = device_create_file(dev,
687 &sensor_dev_attr_fan3_div.dev_attr))
688 || (err = device_create_file(dev,
689 &sensor_dev_attr_fan3_alarm.dev_attr)))
690 goto error_remove_files;
691 } else if (data->type == smsc47m2)
692 dev_dbg(dev, "Fan 3 not enabled by hardware, skipping\n");
695 if ((err = device_create_file(dev,
696 &sensor_dev_attr_pwm1.dev_attr))
697 || (err = device_create_file(dev,
698 &sensor_dev_attr_pwm1_enable.dev_attr)))
699 goto error_remove_files;
701 dev_dbg(dev, "PWM 1 not enabled by hardware, skipping\n");
704 if ((err = device_create_file(dev,
705 &sensor_dev_attr_pwm2.dev_attr))
706 || (err = device_create_file(dev,
707 &sensor_dev_attr_pwm2_enable.dev_attr)))
708 goto error_remove_files;
710 dev_dbg(dev, "PWM 2 not enabled by hardware, skipping\n");
713 if ((err = device_create_file(dev,
714 &sensor_dev_attr_pwm3.dev_attr))
715 || (err = device_create_file(dev,
716 &sensor_dev_attr_pwm3_enable.dev_attr)))
717 goto error_remove_files;
718 } else if (data->type == smsc47m2)
719 dev_dbg(dev, "PWM 3 not enabled by hardware, skipping\n");
721 if ((err = device_create_file(dev, &dev_attr_alarms)))
722 goto error_remove_files;
723 if ((err = device_create_file(dev, &dev_attr_name)))
724 goto error_remove_files;
726 data->hwmon_dev = hwmon_device_register(dev);
727 if (IS_ERR(data->hwmon_dev)) {
728 err = PTR_ERR(data->hwmon_dev);
729 goto error_remove_files;
735 sysfs_remove_group(&dev->kobj, &smsc47m1_group);
737 platform_set_drvdata(pdev, NULL);
740 smsc47m1_handle_resources(res->start, sio_data->type, RELEASE, dev);
744 static int __exit smsc47m1_remove(struct platform_device *pdev)
746 struct smsc47m1_data *data = platform_get_drvdata(pdev);
747 struct resource *res;
749 hwmon_device_unregister(data->hwmon_dev);
750 sysfs_remove_group(&pdev->dev.kobj, &smsc47m1_group);
752 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
753 smsc47m1_handle_resources(res->start, data->type, RELEASE, &pdev->dev);
754 platform_set_drvdata(pdev, NULL);
760 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
763 struct smsc47m1_data *data = dev_get_drvdata(dev);
765 mutex_lock(&data->update_lock);
767 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || init) {
769 fan_nr = data->type == smsc47m2 ? 3 : 2;
771 for (i = 0; i < fan_nr; i++) {
772 data->fan[i] = smsc47m1_read_value(data,
773 SMSC47M1_REG_FAN[i]);
774 data->fan_preload[i] = smsc47m1_read_value(data,
775 SMSC47M1_REG_FAN_PRELOAD[i]);
776 data->pwm[i] = smsc47m1_read_value(data,
777 SMSC47M1_REG_PWM[i]);
780 i = smsc47m1_read_value(data, SMSC47M1_REG_FANDIV);
781 data->fan_div[0] = (i >> 4) & 0x03;
782 data->fan_div[1] = i >> 6;
784 data->alarms = smsc47m1_read_value(data,
785 SMSC47M1_REG_ALARM) >> 6;
786 /* Clear alarms if needed */
788 smsc47m1_write_value(data, SMSC47M1_REG_ALARM, 0xC0);
791 data->fan_div[2] = (smsc47m1_read_value(data,
792 SMSC47M2_REG_FANDIV3) >> 4) & 0x03;
793 data->alarms |= (smsc47m1_read_value(data,
794 SMSC47M2_REG_ALARM6) & 0x40) >> 4;
795 /* Clear alarm if needed */
796 if (data->alarms & 0x04)
797 smsc47m1_write_value(data,
802 data->last_updated = jiffies;
805 mutex_unlock(&data->update_lock);
809 static int __init smsc47m1_device_add(unsigned short address,
810 const struct smsc47m1_sio_data *sio_data)
812 struct resource res = {
814 .end = address + SMSC_EXTENT - 1,
816 .flags = IORESOURCE_IO,
820 err = smsc47m1_handle_resources(address, sio_data->type, CHECK, NULL);
824 pdev = platform_device_alloc(DRVNAME, address);
827 pr_err("Device allocation failed\n");
831 err = platform_device_add_resources(pdev, &res, 1);
833 pr_err("Device resource addition failed (%d)\n", err);
834 goto exit_device_put;
837 err = platform_device_add_data(pdev, sio_data,
838 sizeof(struct smsc47m1_sio_data));
840 pr_err("Platform data allocation failed\n");
841 goto exit_device_put;
844 err = platform_device_add(pdev);
846 pr_err("Device addition failed (%d)\n", err);
847 goto exit_device_put;
853 platform_device_put(pdev);
858 static int __init sm_smsc47m1_init(void)
861 unsigned short address;
862 struct smsc47m1_sio_data sio_data;
864 if (smsc47m1_find(&address, &sio_data))
867 /* Sets global pdev as a side effect */
868 err = smsc47m1_device_add(address, &sio_data);
872 err = platform_driver_probe(&smsc47m1_driver, smsc47m1_probe);
879 platform_device_unregister(pdev);
880 smsc47m1_restore(&sio_data);
885 static void __exit sm_smsc47m1_exit(void)
887 platform_driver_unregister(&smsc47m1_driver);
888 smsc47m1_restore(pdev->dev.platform_data);
889 platform_device_unregister(pdev);
892 MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
893 MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver");
894 MODULE_LICENSE("GPL");
896 module_init(sm_smsc47m1_init);
897 module_exit(sm_smsc47m1_exit);