xref: /openbmc/linux/drivers/hwmon/smsc47m1.c (revision 9d56dd3b083a3bec56e9da35ce07baca81030b03)
1 /*
2     smsc47m1.c - Part of lm_sensors, Linux kernel modules
3                  for hardware monitoring
4 
5     Supports the SMSC LPC47B27x, LPC47M10x, LPC47M112, LPC47M13x,
6     LPC47M14x, LPC47M15x, LPC47M192, LPC47M292 and LPC47M997
7     Super-I/O chips.
8 
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
13 
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.
18 
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.
23 
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.
27 */
28 
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>
42 
43 static unsigned short force_id;
44 module_param(force_id, ushort, 0);
45 MODULE_PARM_DESC(force_id, "Override the detected device ID");
46 
47 static struct platform_device *pdev;
48 
49 #define DRVNAME "smsc47m1"
50 enum chips { smsc47m1, smsc47m2 };
51 
52 /* Super-I/0 registers and commands */
53 
54 #define	REG	0x2e	/* The register to read/write */
55 #define	VAL	0x2f	/* The value to read/write */
56 
57 static inline void
58 superio_outb(int reg, int val)
59 {
60 	outb(reg, REG);
61 	outb(val, VAL);
62 }
63 
64 static inline int
65 superio_inb(int reg)
66 {
67 	outb(reg, REG);
68 	return inb(VAL);
69 }
70 
71 /* logical device for fans is 0x0A */
72 #define superio_select() superio_outb(0x07, 0x0A)
73 
74 static inline void
75 superio_enter(void)
76 {
77 	outb(0x55, REG);
78 }
79 
80 static inline void
81 superio_exit(void)
82 {
83 	outb(0xAA, REG);
84 }
85 
86 #define SUPERIO_REG_ACT		0x30
87 #define SUPERIO_REG_BASE	0x60
88 #define SUPERIO_REG_DEVID	0x20
89 #define SUPERIO_REG_DEVREV	0x21
90 
91 /* Logical device registers */
92 
93 #define SMSC_EXTENT		0x80
94 
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
100 
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 };
104 
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
111 
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)
120 
121 struct smsc47m1_data {
122 	unsigned short addr;
123 	const char *name;
124 	enum chips type;
125 	struct device *hwmon_dev;
126 
127 	struct mutex update_lock;
128 	unsigned long last_updated;	/* In jiffies */
129 
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) */
135 };
136 
137 struct smsc47m1_sio_data {
138 	enum chips type;
139 	u8 activate;		/* Remember initial device state */
140 };
141 
142 
143 static int __exit smsc47m1_remove(struct platform_device *pdev);
144 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
145 		int init);
146 
147 static inline int smsc47m1_read_value(struct smsc47m1_data *data, u8 reg)
148 {
149 	return inb_p(data->addr + reg);
150 }
151 
152 static inline void smsc47m1_write_value(struct smsc47m1_data *data, u8 reg,
153 		u8 value)
154 {
155 	outb_p(value, data->addr + reg);
156 }
157 
158 static struct platform_driver smsc47m1_driver = {
159 	.driver = {
160 		.owner	= THIS_MODULE,
161 		.name	= DRVNAME,
162 	},
163 	.remove		= __exit_p(smsc47m1_remove),
164 };
165 
166 static ssize_t get_fan(struct device *dev, struct device_attribute
167 		       *devattr, char *buf)
168 {
169 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
170 	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
171 	int nr = attr->index;
172 	/* This chip (stupidly) stops monitoring fan speed if PWM is
173 	   enabled and duty cycle is 0%. This is fine if the monitoring
174 	   and control concern the same fan, but troublesome if they are
175 	   not (which could as well happen). */
176 	int rpm = (data->pwm[nr] & 0x7F) == 0x00 ? 0 :
177 		  FAN_FROM_REG(data->fan[nr],
178 			       DIV_FROM_REG(data->fan_div[nr]),
179 			       data->fan_preload[nr]);
180 	return sprintf(buf, "%d\n", rpm);
181 }
182 
183 static ssize_t get_fan_min(struct device *dev, struct device_attribute
184 			   *devattr, char *buf)
185 {
186 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
187 	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
188 	int nr = attr->index;
189 	int rpm = MIN_FROM_REG(data->fan_preload[nr],
190 			       DIV_FROM_REG(data->fan_div[nr]));
191 	return sprintf(buf, "%d\n", rpm);
192 }
193 
194 static ssize_t get_fan_div(struct device *dev, struct device_attribute
195 			   *devattr, char *buf)
196 {
197 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
198 	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
199 	return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
200 }
201 
202 static ssize_t get_fan_alarm(struct device *dev, struct device_attribute
203 			     *devattr, char *buf)
204 {
205 	int bitnr = to_sensor_dev_attr(devattr)->index;
206 	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
207 	return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
208 }
209 
210 static ssize_t get_pwm(struct device *dev, struct device_attribute
211 		       *devattr, char *buf)
212 {
213 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
214 	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
215 	return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[attr->index]));
216 }
217 
218 static ssize_t get_pwm_en(struct device *dev, struct device_attribute
219 			  *devattr, char *buf)
220 {
221 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
222 	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
223 	return sprintf(buf, "%d\n", PWM_EN_FROM_REG(data->pwm[attr->index]));
224 }
225 
226 static ssize_t get_alarms(struct device *dev, struct device_attribute
227 			  *devattr, char *buf)
228 {
229 	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
230 	return sprintf(buf, "%d\n", data->alarms);
231 }
232 
233 static ssize_t set_fan_min(struct device *dev, struct device_attribute
234 			   *devattr, const char *buf, size_t count)
235 {
236 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
237 	struct smsc47m1_data *data = dev_get_drvdata(dev);
238 	int nr = attr->index;
239 	long rpmdiv, val = simple_strtol(buf, NULL, 10);
240 
241 	mutex_lock(&data->update_lock);
242 	rpmdiv = val * DIV_FROM_REG(data->fan_div[nr]);
243 
244 	if (983040 > 192 * rpmdiv || 2 * rpmdiv > 983040) {
245 		mutex_unlock(&data->update_lock);
246 		return -EINVAL;
247 	}
248 
249 	data->fan_preload[nr] = 192 - ((983040 + rpmdiv / 2) / rpmdiv);
250 	smsc47m1_write_value(data, SMSC47M1_REG_FAN_PRELOAD[nr],
251 			     data->fan_preload[nr]);
252 	mutex_unlock(&data->update_lock);
253 
254 	return count;
255 }
256 
257 /* Note: we save and restore the fan minimum here, because its value is
258    determined in part by the fan clock divider.  This follows the principle
259    of least surprise; the user doesn't expect the fan minimum to change just
260    because the divider changed. */
261 static ssize_t set_fan_div(struct device *dev, struct device_attribute
262 			   *devattr, const char *buf, size_t count)
263 {
264 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
265 	struct smsc47m1_data *data = dev_get_drvdata(dev);
266 	int nr = attr->index;
267 	long new_div = simple_strtol(buf, NULL, 10), tmp;
268 	u8 old_div = DIV_FROM_REG(data->fan_div[nr]);
269 
270 	if (new_div == old_div) /* No change */
271 		return count;
272 
273 	mutex_lock(&data->update_lock);
274 	switch (new_div) {
275 	case 1: data->fan_div[nr] = 0; break;
276 	case 2: data->fan_div[nr] = 1; break;
277 	case 4: data->fan_div[nr] = 2; break;
278 	case 8: data->fan_div[nr] = 3; break;
279 	default:
280 		mutex_unlock(&data->update_lock);
281 		return -EINVAL;
282 	}
283 
284 	switch (nr) {
285 	case 0:
286 	case 1:
287 		tmp = smsc47m1_read_value(data, SMSC47M1_REG_FANDIV)
288 		      & ~(0x03 << (4 + 2 * nr));
289 		tmp |= data->fan_div[nr] << (4 + 2 * nr);
290 		smsc47m1_write_value(data, SMSC47M1_REG_FANDIV, tmp);
291 		break;
292 	case 2:
293 		tmp = smsc47m1_read_value(data, SMSC47M2_REG_FANDIV3) & 0xCF;
294 		tmp |= data->fan_div[2] << 4;
295 		smsc47m1_write_value(data, SMSC47M2_REG_FANDIV3, tmp);
296 		break;
297 	}
298 
299 	/* Preserve fan min */
300 	tmp = 192 - (old_div * (192 - data->fan_preload[nr])
301 		     + new_div / 2) / new_div;
302 	data->fan_preload[nr] = SENSORS_LIMIT(tmp, 0, 191);
303 	smsc47m1_write_value(data, SMSC47M1_REG_FAN_PRELOAD[nr],
304 			     data->fan_preload[nr]);
305 	mutex_unlock(&data->update_lock);
306 
307 	return count;
308 }
309 
310 static ssize_t set_pwm(struct device *dev, struct device_attribute
311 		       *devattr, const char *buf, size_t count)
312 {
313 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
314 	struct smsc47m1_data *data = dev_get_drvdata(dev);
315 	int nr = attr->index;
316 	long val = simple_strtol(buf, NULL, 10);
317 
318 	if (val < 0 || val > 255)
319 		return -EINVAL;
320 
321 	mutex_lock(&data->update_lock);
322 	data->pwm[nr] &= 0x81; /* Preserve additional bits */
323 	data->pwm[nr] |= PWM_TO_REG(val);
324 	smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr],
325 			     data->pwm[nr]);
326 	mutex_unlock(&data->update_lock);
327 
328 	return count;
329 }
330 
331 static ssize_t set_pwm_en(struct device *dev, struct device_attribute
332 			  *devattr, const char *buf, size_t count)
333 {
334 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
335 	struct smsc47m1_data *data = dev_get_drvdata(dev);
336 	int nr = attr->index;
337 	long val = simple_strtol(buf, NULL, 10);
338 
339 	if (val != 0 && val != 1)
340 		return -EINVAL;
341 
342 	mutex_lock(&data->update_lock);
343 	data->pwm[nr] &= 0xFE; /* preserve the other bits */
344 	data->pwm[nr] |= !val;
345 	smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr],
346 			     data->pwm[nr]);
347 	mutex_unlock(&data->update_lock);
348 
349 	return count;
350 }
351 
352 #define fan_present(offset)						\
353 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, get_fan,	\
354 		NULL, offset - 1);					\
355 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,		\
356 		get_fan_min, set_fan_min, offset - 1);			\
357 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,		\
358 		get_fan_div, set_fan_div, offset - 1);			\
359 static SENSOR_DEVICE_ATTR(fan##offset##_alarm, S_IRUGO, get_fan_alarm,	\
360 		NULL, offset - 1);					\
361 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR,		\
362 		get_pwm, set_pwm, offset - 1);				\
363 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR,	\
364 		get_pwm_en, set_pwm_en, offset - 1)
365 
366 fan_present(1);
367 fan_present(2);
368 fan_present(3);
369 
370 static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL);
371 
372 static ssize_t show_name(struct device *dev, struct device_attribute
373 			 *devattr, char *buf)
374 {
375 	struct smsc47m1_data *data = dev_get_drvdata(dev);
376 
377 	return sprintf(buf, "%s\n", data->name);
378 }
379 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
380 
381 /* Almost all sysfs files may or may not be created depending on the chip
382    setup so we create them individually. It is still convenient to define a
383    group to remove them all at once. */
384 static struct attribute *smsc47m1_attributes[] = {
385 	&sensor_dev_attr_fan1_input.dev_attr.attr,
386 	&sensor_dev_attr_fan1_min.dev_attr.attr,
387 	&sensor_dev_attr_fan1_div.dev_attr.attr,
388 	&sensor_dev_attr_fan1_alarm.dev_attr.attr,
389 	&sensor_dev_attr_fan2_input.dev_attr.attr,
390 	&sensor_dev_attr_fan2_min.dev_attr.attr,
391 	&sensor_dev_attr_fan2_div.dev_attr.attr,
392 	&sensor_dev_attr_fan2_alarm.dev_attr.attr,
393 	&sensor_dev_attr_fan3_input.dev_attr.attr,
394 	&sensor_dev_attr_fan3_min.dev_attr.attr,
395 	&sensor_dev_attr_fan3_div.dev_attr.attr,
396 	&sensor_dev_attr_fan3_alarm.dev_attr.attr,
397 
398 	&sensor_dev_attr_pwm1.dev_attr.attr,
399 	&sensor_dev_attr_pwm1_enable.dev_attr.attr,
400 	&sensor_dev_attr_pwm2.dev_attr.attr,
401 	&sensor_dev_attr_pwm2_enable.dev_attr.attr,
402 	&sensor_dev_attr_pwm3.dev_attr.attr,
403 	&sensor_dev_attr_pwm3_enable.dev_attr.attr,
404 
405 	&dev_attr_alarms.attr,
406 	&dev_attr_name.attr,
407 	NULL
408 };
409 
410 static const struct attribute_group smsc47m1_group = {
411 	.attrs = smsc47m1_attributes,
412 };
413 
414 static int __init smsc47m1_find(unsigned short *addr,
415 				struct smsc47m1_sio_data *sio_data)
416 {
417 	u8 val;
418 
419 	superio_enter();
420 	val = force_id ? force_id : superio_inb(SUPERIO_REG_DEVID);
421 
422 	/*
423 	 * SMSC LPC47M10x/LPC47M112/LPC47M13x (device id 0x59), LPC47M14x
424 	 * (device id 0x5F) and LPC47B27x (device id 0x51) have fan control.
425 	 * The LPC47M15x and LPC47M192 chips "with hardware monitoring block"
426 	 * can do much more besides (device id 0x60).
427 	 * The LPC47M997 is undocumented, but seems to be compatible with
428 	 * the LPC47M192, and has the same device id.
429 	 * The LPC47M292 (device id 0x6B) is somewhat compatible, but it
430 	 * supports a 3rd fan, and the pin configuration registers are
431 	 * unfortunately different.
432 	 * The LPC47M233 has the same device id (0x6B) but is not compatible.
433 	 * We check the high bit of the device revision register to
434 	 * differentiate them.
435 	 */
436 	switch (val) {
437 	case 0x51:
438 		pr_info(DRVNAME ": Found SMSC LPC47B27x\n");
439 		sio_data->type = smsc47m1;
440 		break;
441 	case 0x59:
442 		pr_info(DRVNAME ": Found SMSC LPC47M10x/LPC47M112/LPC47M13x\n");
443 		sio_data->type = smsc47m1;
444 		break;
445 	case 0x5F:
446 		pr_info(DRVNAME ": Found SMSC LPC47M14x\n");
447 		sio_data->type = smsc47m1;
448 		break;
449 	case 0x60:
450 		pr_info(DRVNAME ": Found SMSC LPC47M15x/LPC47M192/LPC47M997\n");
451 		sio_data->type = smsc47m1;
452 		break;
453 	case 0x6B:
454 		if (superio_inb(SUPERIO_REG_DEVREV) & 0x80) {
455 			pr_debug(DRVNAME ": "
456 				 "Found SMSC LPC47M233, unsupported\n");
457 			superio_exit();
458 			return -ENODEV;
459 		}
460 
461 		pr_info(DRVNAME ": Found SMSC LPC47M292\n");
462 		sio_data->type = smsc47m2;
463 		break;
464 	default:
465 		superio_exit();
466 		return -ENODEV;
467 	}
468 
469 	superio_select();
470 	*addr = (superio_inb(SUPERIO_REG_BASE) << 8)
471 	      |  superio_inb(SUPERIO_REG_BASE + 1);
472 	if (*addr == 0) {
473 		pr_info(DRVNAME ": Device address not set, will not use\n");
474 		superio_exit();
475 		return -ENODEV;
476 	}
477 
478 	/* Enable only if address is set (needed at least on the
479 	 * Compaq Presario S4000NX) */
480 	sio_data->activate = superio_inb(SUPERIO_REG_ACT);
481 	if ((sio_data->activate & 0x01) == 0) {
482 		pr_info(DRVNAME ": Enabling device\n");
483 		superio_outb(SUPERIO_REG_ACT, sio_data->activate | 0x01);
484 	}
485 
486 	superio_exit();
487 	return 0;
488 }
489 
490 /* Restore device to its initial state */
491 static void __init smsc47m1_restore(const struct smsc47m1_sio_data *sio_data)
492 {
493 	if ((sio_data->activate & 0x01) == 0) {
494 		superio_enter();
495 		superio_select();
496 
497 		pr_info(DRVNAME ": Disabling device\n");
498 		superio_outb(SUPERIO_REG_ACT, sio_data->activate);
499 
500 		superio_exit();
501 	}
502 }
503 
504 #define CHECK		1
505 #define REQUEST		2
506 #define RELEASE		3
507 
508 /*
509  * This function can be used to:
510  *  - test for resource conflicts with ACPI
511  *  - request the resources
512  *  - release the resources
513  * We only allocate the I/O ports we really need, to minimize the risk of
514  * conflicts with ACPI or with other drivers.
515  */
516 static int smsc47m1_handle_resources(unsigned short address, enum chips type,
517 				     int action, struct device *dev)
518 {
519 	static const u8 ports_m1[] = {
520 		/* register, region length */
521 		0x04, 1,
522 		0x33, 4,
523 		0x56, 7,
524 	};
525 
526 	static const u8 ports_m2[] = {
527 		/* register, region length */
528 		0x04, 1,
529 		0x09, 1,
530 		0x2c, 2,
531 		0x35, 4,
532 		0x56, 7,
533 		0x69, 4,
534 	};
535 
536 	int i, ports_size, err;
537 	const u8 *ports;
538 
539 	switch (type) {
540 	case smsc47m1:
541 	default:
542 		ports = ports_m1;
543 		ports_size = ARRAY_SIZE(ports_m1);
544 		break;
545 	case smsc47m2:
546 		ports = ports_m2;
547 		ports_size = ARRAY_SIZE(ports_m2);
548 		break;
549 	}
550 
551 	for (i = 0; i + 1 < ports_size; i += 2) {
552 		unsigned short start = address + ports[i];
553 		unsigned short len = ports[i + 1];
554 
555 		switch (action) {
556 		case CHECK:
557 			/* Only check for conflicts */
558 			err = acpi_check_region(start, len, DRVNAME);
559 			if (err)
560 				return err;
561 			break;
562 		case REQUEST:
563 			/* Request the resources */
564 			if (!request_region(start, len, DRVNAME)) {
565 				dev_err(dev, "Region 0x%hx-0x%hx already in "
566 					"use!\n", start, start + len);
567 
568 				/* Undo all requests */
569 				for (i -= 2; i >= 0; i -= 2)
570 					release_region(address + ports[i],
571 						       ports[i + 1]);
572 				return -EBUSY;
573 			}
574 			break;
575 		case RELEASE:
576 			/* Release the resources */
577 			release_region(start, len);
578 			break;
579 		}
580 	}
581 
582 	return 0;
583 }
584 
585 static int __init smsc47m1_probe(struct platform_device *pdev)
586 {
587 	struct device *dev = &pdev->dev;
588 	struct smsc47m1_sio_data *sio_data = dev->platform_data;
589 	struct smsc47m1_data *data;
590 	struct resource *res;
591 	int err;
592 	int fan1, fan2, fan3, pwm1, pwm2, pwm3;
593 
594 	static const char *names[] = {
595 		"smsc47m1",
596 		"smsc47m2",
597 	};
598 
599 	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
600 	err = smsc47m1_handle_resources(res->start, sio_data->type,
601 					REQUEST, dev);
602 	if (err < 0)
603 		return err;
604 
605 	if (!(data = kzalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) {
606 		err = -ENOMEM;
607 		goto error_release;
608 	}
609 
610 	data->addr = res->start;
611 	data->type = sio_data->type;
612 	data->name = names[sio_data->type];
613 	mutex_init(&data->update_lock);
614 	platform_set_drvdata(pdev, data);
615 
616 	/* If no function is properly configured, there's no point in
617 	   actually registering the chip. */
618 	pwm1 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(0)) & 0x05)
619 	       == 0x04;
620 	pwm2 = (smsc47m1_read_value(data, SMSC47M1_REG_PPIN(1)) & 0x05)
621 	       == 0x04;
622 	if (data->type == smsc47m2) {
623 		fan1 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN1)
624 			& 0x0d) == 0x09;
625 		fan2 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN2)
626 			& 0x0d) == 0x09;
627 		fan3 = (smsc47m1_read_value(data, SMSC47M2_REG_TPIN3)
628 			& 0x0d) == 0x0d;
629 		pwm3 = (smsc47m1_read_value(data, SMSC47M2_REG_PPIN3)
630 			& 0x0d) == 0x08;
631 	} else {
632 		fan1 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(0))
633 			& 0x05) == 0x05;
634 		fan2 = (smsc47m1_read_value(data, SMSC47M1_REG_TPIN(1))
635 			& 0x05) == 0x05;
636 		fan3 = 0;
637 		pwm3 = 0;
638 	}
639 	if (!(fan1 || fan2 || fan3 || pwm1 || pwm2 || pwm3)) {
640 		dev_warn(dev, "Device not configured, will not use\n");
641 		err = -ENODEV;
642 		goto error_free;
643 	}
644 
645 	/* Some values (fan min, clock dividers, pwm registers) may be
646 	   needed before any update is triggered, so we better read them
647 	   at least once here. We don't usually do it that way, but in
648 	   this particular case, manually reading 5 registers out of 8
649 	   doesn't make much sense and we're better using the existing
650 	   function. */
651 	smsc47m1_update_device(dev, 1);
652 
653 	/* Register sysfs hooks */
654 	if (fan1) {
655 		if ((err = device_create_file(dev,
656 				&sensor_dev_attr_fan1_input.dev_attr))
657 		 || (err = device_create_file(dev,
658 				&sensor_dev_attr_fan1_min.dev_attr))
659 		 || (err = device_create_file(dev,
660 				&sensor_dev_attr_fan1_div.dev_attr))
661 		 || (err = device_create_file(dev,
662 				&sensor_dev_attr_fan1_alarm.dev_attr)))
663 			goto error_remove_files;
664 	} else
665 		dev_dbg(dev, "Fan 1 not enabled by hardware, skipping\n");
666 
667 	if (fan2) {
668 		if ((err = device_create_file(dev,
669 				&sensor_dev_attr_fan2_input.dev_attr))
670 		 || (err = device_create_file(dev,
671 				&sensor_dev_attr_fan2_min.dev_attr))
672 		 || (err = device_create_file(dev,
673 				&sensor_dev_attr_fan2_div.dev_attr))
674 		 || (err = device_create_file(dev,
675 				&sensor_dev_attr_fan2_alarm.dev_attr)))
676 			goto error_remove_files;
677 	} else
678 		dev_dbg(dev, "Fan 2 not enabled by hardware, skipping\n");
679 
680 	if (fan3) {
681 		if ((err = device_create_file(dev,
682 				&sensor_dev_attr_fan3_input.dev_attr))
683 		 || (err = device_create_file(dev,
684 				&sensor_dev_attr_fan3_min.dev_attr))
685 		 || (err = device_create_file(dev,
686 				&sensor_dev_attr_fan3_div.dev_attr))
687 		 || (err = device_create_file(dev,
688 				&sensor_dev_attr_fan3_alarm.dev_attr)))
689 			goto error_remove_files;
690 	} else if (data->type == smsc47m2)
691 		dev_dbg(dev, "Fan 3 not enabled by hardware, skipping\n");
692 
693 	if (pwm1) {
694 		if ((err = device_create_file(dev,
695 				&sensor_dev_attr_pwm1.dev_attr))
696 		 || (err = device_create_file(dev,
697 				&sensor_dev_attr_pwm1_enable.dev_attr)))
698 			goto error_remove_files;
699 	} else
700 		dev_dbg(dev, "PWM 1 not enabled by hardware, skipping\n");
701 
702 	if (pwm2) {
703 		if ((err = device_create_file(dev,
704 				&sensor_dev_attr_pwm2.dev_attr))
705 		 || (err = device_create_file(dev,
706 				&sensor_dev_attr_pwm2_enable.dev_attr)))
707 			goto error_remove_files;
708 	} else
709 		dev_dbg(dev, "PWM 2 not enabled by hardware, skipping\n");
710 
711 	if (pwm3) {
712 		if ((err = device_create_file(dev,
713 				&sensor_dev_attr_pwm3.dev_attr))
714 		 || (err = device_create_file(dev,
715 				&sensor_dev_attr_pwm3_enable.dev_attr)))
716 			goto error_remove_files;
717 	} else if (data->type == smsc47m2)
718 		dev_dbg(dev, "PWM 3 not enabled by hardware, skipping\n");
719 
720 	if ((err = device_create_file(dev, &dev_attr_alarms)))
721 		goto error_remove_files;
722 	if ((err = device_create_file(dev, &dev_attr_name)))
723 		goto error_remove_files;
724 
725 	data->hwmon_dev = hwmon_device_register(dev);
726 	if (IS_ERR(data->hwmon_dev)) {
727 		err = PTR_ERR(data->hwmon_dev);
728 		goto error_remove_files;
729 	}
730 
731 	return 0;
732 
733 error_remove_files:
734 	sysfs_remove_group(&dev->kobj, &smsc47m1_group);
735 error_free:
736 	platform_set_drvdata(pdev, NULL);
737 	kfree(data);
738 error_release:
739 	smsc47m1_handle_resources(res->start, sio_data->type, RELEASE, dev);
740 	return err;
741 }
742 
743 static int __exit smsc47m1_remove(struct platform_device *pdev)
744 {
745 	struct smsc47m1_data *data = platform_get_drvdata(pdev);
746 	struct resource *res;
747 
748 	hwmon_device_unregister(data->hwmon_dev);
749 	sysfs_remove_group(&pdev->dev.kobj, &smsc47m1_group);
750 
751 	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
752 	smsc47m1_handle_resources(res->start, data->type, RELEASE, &pdev->dev);
753 	platform_set_drvdata(pdev, NULL);
754 	kfree(data);
755 
756 	return 0;
757 }
758 
759 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
760 		int init)
761 {
762 	struct smsc47m1_data *data = dev_get_drvdata(dev);
763 
764 	mutex_lock(&data->update_lock);
765 
766 	if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || init) {
767 		int i, fan_nr;
768 		fan_nr = data->type == smsc47m2 ? 3 : 2;
769 
770 		for (i = 0; i < fan_nr; i++) {
771 			data->fan[i] = smsc47m1_read_value(data,
772 				       SMSC47M1_REG_FAN[i]);
773 			data->fan_preload[i] = smsc47m1_read_value(data,
774 					       SMSC47M1_REG_FAN_PRELOAD[i]);
775 			data->pwm[i] = smsc47m1_read_value(data,
776 				       SMSC47M1_REG_PWM[i]);
777 		}
778 
779 		i = smsc47m1_read_value(data, SMSC47M1_REG_FANDIV);
780 		data->fan_div[0] = (i >> 4) & 0x03;
781 		data->fan_div[1] = i >> 6;
782 
783 		data->alarms = smsc47m1_read_value(data,
784 			       SMSC47M1_REG_ALARM) >> 6;
785 		/* Clear alarms if needed */
786 		if (data->alarms)
787 			smsc47m1_write_value(data, SMSC47M1_REG_ALARM, 0xC0);
788 
789 		if (fan_nr >= 3) {
790 			data->fan_div[2] = (smsc47m1_read_value(data,
791 					    SMSC47M2_REG_FANDIV3) >> 4) & 0x03;
792 			data->alarms |= (smsc47m1_read_value(data,
793 					 SMSC47M2_REG_ALARM6) & 0x40) >> 4;
794 			/* Clear alarm if needed */
795 			if (data->alarms & 0x04)
796 				smsc47m1_write_value(data,
797 						     SMSC47M2_REG_ALARM6,
798 						     0x40);
799 		}
800 
801 		data->last_updated = jiffies;
802 	}
803 
804 	mutex_unlock(&data->update_lock);
805 	return data;
806 }
807 
808 static int __init smsc47m1_device_add(unsigned short address,
809 				      const struct smsc47m1_sio_data *sio_data)
810 {
811 	struct resource res = {
812 		.start	= address,
813 		.end	= address + SMSC_EXTENT - 1,
814 		.name	= DRVNAME,
815 		.flags	= IORESOURCE_IO,
816 	};
817 	int err;
818 
819 	err = smsc47m1_handle_resources(address, sio_data->type, CHECK, NULL);
820 	if (err)
821 		goto exit;
822 
823 	pdev = platform_device_alloc(DRVNAME, address);
824 	if (!pdev) {
825 		err = -ENOMEM;
826 		printk(KERN_ERR DRVNAME ": Device allocation failed\n");
827 		goto exit;
828 	}
829 
830 	err = platform_device_add_resources(pdev, &res, 1);
831 	if (err) {
832 		printk(KERN_ERR DRVNAME ": Device resource addition failed "
833 		       "(%d)\n", err);
834 		goto exit_device_put;
835 	}
836 
837 	err = platform_device_add_data(pdev, sio_data,
838 				       sizeof(struct smsc47m1_sio_data));
839 	if (err) {
840 		printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
841 		goto exit_device_put;
842 	}
843 
844 	err = platform_device_add(pdev);
845 	if (err) {
846 		printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
847 		       err);
848 		goto exit_device_put;
849 	}
850 
851 	return 0;
852 
853 exit_device_put:
854 	platform_device_put(pdev);
855 exit:
856 	return err;
857 }
858 
859 static int __init sm_smsc47m1_init(void)
860 {
861 	int err;
862 	unsigned short address;
863 	struct smsc47m1_sio_data sio_data;
864 
865 	if (smsc47m1_find(&address, &sio_data))
866 		return -ENODEV;
867 
868 	/* Sets global pdev as a side effect */
869 	err = smsc47m1_device_add(address, &sio_data);
870 	if (err)
871 		goto exit;
872 
873 	err = platform_driver_probe(&smsc47m1_driver, smsc47m1_probe);
874 	if (err)
875 		goto exit_device;
876 
877 	return 0;
878 
879 exit_device:
880 	platform_device_unregister(pdev);
881 	smsc47m1_restore(&sio_data);
882 exit:
883 	return err;
884 }
885 
886 static void __exit sm_smsc47m1_exit(void)
887 {
888 	platform_driver_unregister(&smsc47m1_driver);
889 	smsc47m1_restore(pdev->dev.platform_data);
890 	platform_device_unregister(pdev);
891 }
892 
893 MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
894 MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver");
895 MODULE_LICENSE("GPL");
896 
897 module_init(sm_smsc47m1_init);
898 module_exit(sm_smsc47m1_exit);
899