smsc47m1.c revision 7bef559455fc71f66f8573cc1aafe1dd33966c1c 
1/*
2    smsc47m1.c - Part of lm_sensors, Linux kernel modules
3                 for hardware monitoring
4
5    Supports the SMSC LPC47B27x, LPC47M10x, LPC47M13x and LPC47M14x
6    Super-I/O chips.
7
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>
33#include <linux/i2c-isa.h>
34#include <linux/i2c-sensor.h>
35#include <linux/hwmon.h>
36#include <linux/err.h>
37#include <linux/init.h>
38#include <asm/io.h>
39
40/* Address is autodetected, there is no default value */
41static unsigned short address;
42
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;
105	struct class_device *class_dev;
106	struct semaphore lock;
107
108	struct semaphore update_lock;
109	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
119static int smsc47m1_detect(struct i2c_adapter *adapter);
120static 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 = {
130	.owner		= THIS_MODULE,
131	.name		= "smsc47m1",
132	.attach_adapter	= smsc47m1_detect,
133	.detach_client	= smsc47m1_detach_client,
134};
135
136/* nr is 0 or 1 in the callback functions below */
137
138static ssize_t get_fan(struct device *dev, char *buf, int nr)
139{
140	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
141	/* This chip (stupidly) stops monitoring fan speed if PWM is
142	   enabled and duty cycle is 0%. This is fine if the monitoring
143	   and control concern the same fan, but troublesome if they are
144	   not (which could as well happen). */
145	int rpm = (data->pwm[nr] & 0x7F) == 0x00 ? 0 :
146		  FAN_FROM_REG(data->fan[nr],
147			       DIV_FROM_REG(data->fan_div[nr]),
148			       data->fan_preload[nr]);
149	return sprintf(buf, "%d\n", rpm);
150}
151
152static ssize_t get_fan_min(struct device *dev, char *buf, int nr)
153{
154	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
155	int rpm = MIN_FROM_REG(data->fan_preload[nr],
156			       DIV_FROM_REG(data->fan_div[nr]));
157	return sprintf(buf, "%d\n", rpm);
158}
159
160static ssize_t get_fan_div(struct device *dev, char *buf, int nr)
161{
162	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
163	return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
164}
165
166static ssize_t get_pwm(struct device *dev, char *buf, int nr)
167{
168	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
169	return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
170}
171
172static ssize_t get_pwm_en(struct device *dev, char *buf, int nr)
173{
174	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
175	return sprintf(buf, "%d\n", PWM_EN_FROM_REG(data->pwm[nr]));
176}
177
178static ssize_t get_alarms(struct device *dev, struct device_attribute *attr, char *buf)
179{
180	struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
181	return sprintf(buf, "%d\n", data->alarms);
182}
183
184static ssize_t set_fan_min(struct device *dev, const char *buf,
185		size_t count, int nr)
186{
187	struct i2c_client *client = to_i2c_client(dev);
188	struct smsc47m1_data *data = i2c_get_clientdata(client);
189	long rpmdiv, val = simple_strtol(buf, NULL, 10);
190
191	down(&data->update_lock);
192	rpmdiv = val * DIV_FROM_REG(data->fan_div[nr]);
193
194	if (983040 > 192 * rpmdiv || 2 * rpmdiv > 983040) {
195		up(&data->update_lock);
196		return -EINVAL;
197	}
198
199	data->fan_preload[nr] = 192 - ((983040 + rpmdiv / 2) / rpmdiv);
200	smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr),
201			     data->fan_preload[nr]);
202	up(&data->update_lock);
203
204	return count;
205}
206
207/* Note: we save and restore the fan minimum here, because its value is
208   determined in part by the fan clock divider.  This follows the principle
209   of least suprise; the user doesn't expect the fan minimum to change just
210   because the divider changed. */
211static ssize_t set_fan_div(struct device *dev, const char *buf,
212		size_t count, int nr)
213{
214	struct i2c_client *client = to_i2c_client(dev);
215	struct smsc47m1_data *data = i2c_get_clientdata(client);
216
217	long new_div = simple_strtol(buf, NULL, 10), tmp;
218	u8 old_div = DIV_FROM_REG(data->fan_div[nr]);
219
220	if (new_div == old_div) /* No change */
221		return count;
222
223	down(&data->update_lock);
224	switch (new_div) {
225	case 1: data->fan_div[nr] = 0; break;
226	case 2: data->fan_div[nr] = 1; break;
227	case 4: data->fan_div[nr] = 2; break;
228	case 8: data->fan_div[nr] = 3; break;
229	default:
230		up(&data->update_lock);
231		return -EINVAL;
232	}
233
234	tmp = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV) & 0x0F;
235	tmp |= (data->fan_div[0] << 4) | (data->fan_div[1] << 6);
236	smsc47m1_write_value(client, SMSC47M1_REG_FANDIV, tmp);
237
238	/* Preserve fan min */
239	tmp = 192 - (old_div * (192 - data->fan_preload[nr])
240		     + new_div / 2) / new_div;
241	data->fan_preload[nr] = SENSORS_LIMIT(tmp, 0, 191);
242	smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr),
243			     data->fan_preload[nr]);
244	up(&data->update_lock);
245
246	return count;
247}
248
249static ssize_t set_pwm(struct device *dev, const char *buf,
250		size_t count, int nr)
251{
252	struct i2c_client *client = to_i2c_client(dev);
253	struct smsc47m1_data *data = i2c_get_clientdata(client);
254
255	long val = simple_strtol(buf, NULL, 10);
256
257	if (val < 0 || val > 255)
258		return -EINVAL;
259
260	down(&data->update_lock);
261	data->pwm[nr] &= 0x81; /* Preserve additional bits */
262	data->pwm[nr] |= PWM_TO_REG(val);
263	smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr),
264			     data->pwm[nr]);
265	up(&data->update_lock);
266
267	return count;
268}
269
270static ssize_t set_pwm_en(struct device *dev, const char *buf,
271		size_t count, int nr)
272{
273	struct i2c_client *client = to_i2c_client(dev);
274	struct smsc47m1_data *data = i2c_get_clientdata(client);
275
276	long val = simple_strtol(buf, NULL, 10);
277
278	if (val != 0 && val != 1)
279		return -EINVAL;
280
281	down(&data->update_lock);
282	data->pwm[nr] &= 0xFE; /* preserve the other bits */
283	data->pwm[nr] |= !val;
284	smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr),
285			     data->pwm[nr]);
286	up(&data->update_lock);
287
288	return count;
289}
290
291#define fan_present(offset)						\
292static ssize_t get_fan##offset (struct device *dev, struct device_attribute *attr, char *buf)		\
293{									\
294	return get_fan(dev, buf, offset - 1);				\
295}									\
296static ssize_t get_fan##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)	\
297{									\
298	return get_fan_min(dev, buf, offset - 1);			\
299}									\
300static ssize_t set_fan##offset##_min (struct device *dev, struct device_attribute *attr,		\
301		const char *buf, size_t count)				\
302{									\
303	return set_fan_min(dev, buf, count, offset - 1);		\
304}									\
305static ssize_t get_fan##offset##_div (struct device *dev, struct device_attribute *attr, char *buf)	\
306{									\
307	return get_fan_div(dev, buf, offset - 1);			\
308}									\
309static ssize_t set_fan##offset##_div (struct device *dev, struct device_attribute *attr,		\
310		const char *buf, size_t count)				\
311{									\
312	return set_fan_div(dev, buf, count, offset - 1);		\
313}									\
314static ssize_t get_pwm##offset (struct device *dev, struct device_attribute *attr, char *buf)		\
315{									\
316	return get_pwm(dev, buf, offset - 1);				\
317}									\
318static ssize_t set_pwm##offset (struct device *dev, struct device_attribute *attr,			\
319		const char *buf, size_t count)				\
320{									\
321	return set_pwm(dev, buf, count, offset - 1);			\
322}									\
323static ssize_t get_pwm##offset##_en (struct device *dev, struct device_attribute *attr, char *buf)	\
324{									\
325	return get_pwm_en(dev, buf, offset - 1);			\
326}									\
327static ssize_t set_pwm##offset##_en (struct device *dev, struct device_attribute *attr,		\
328		const char *buf, size_t count)				\
329{									\
330	return set_pwm_en(dev, buf, count, offset - 1);			\
331}									\
332static DEVICE_ATTR(fan##offset##_input, S_IRUGO, get_fan##offset,	\
333		NULL);							\
334static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,		\
335		get_fan##offset##_min, set_fan##offset##_min);		\
336static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,		\
337		get_fan##offset##_div, set_fan##offset##_div);		\
338static DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR,			\
339		get_pwm##offset, set_pwm##offset);			\
340static DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR,		\
341		get_pwm##offset##_en, set_pwm##offset##_en);
342
343fan_present(1);
344fan_present(2);
345
346static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL);
347
348static int smsc47m1_find(unsigned short *addr)
349{
350	u8 val;
351
352	superio_enter();
353	val = superio_inb(SUPERIO_REG_DEVID);
354
355	/*
356	 * SMSC LPC47M10x/LPC47M13x (device id 0x59), LPC47M14x (device id
357	 * 0x5F) and LPC47B27x (device id 0x51) have fan control.
358	 * The LPC47M15x and LPC47M192 chips "with hardware monitoring block"
359	 * can do much more besides (device id 0x60).
360	 */
361	if (val == 0x51)
362		printk(KERN_INFO "smsc47m1: Found SMSC LPC47B27x\n");
363	else if (val == 0x59)
364		printk(KERN_INFO "smsc47m1: Found SMSC LPC47M10x/LPC47M13x\n");
365	else if (val == 0x5F)
366		printk(KERN_INFO "smsc47m1: Found SMSC LPC47M14x\n");
367	else if (val == 0x60)
368		printk(KERN_INFO "smsc47m1: Found SMSC LPC47M15x/LPC47M192\n");
369	else {
370		superio_exit();
371		return -ENODEV;
372	}
373
374	superio_select();
375	*addr = (superio_inb(SUPERIO_REG_BASE) << 8)
376	      |  superio_inb(SUPERIO_REG_BASE + 1);
377	val = superio_inb(SUPERIO_REG_ACT);
378	if (*addr == 0 || (val & 0x01) == 0) {
379		printk(KERN_INFO "smsc47m1: Device is disabled, will not use\n");
380		superio_exit();
381		return -ENODEV;
382	}
383
384	superio_exit();
385	return 0;
386}
387
388static int smsc47m1_detect(struct i2c_adapter *adapter)
389{
390	struct i2c_client *new_client;
391	struct smsc47m1_data *data;
392	int err = 0;
393	int fan1, fan2, pwm1, pwm2;
394
395	if (!request_region(address, SMSC_EXTENT, smsc47m1_driver.name)) {
396		dev_err(&adapter->dev, "Region 0x%x already in use!\n", address);
397		return -EBUSY;
398	}
399
400	if (!(data = kmalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) {
401		err = -ENOMEM;
402		goto error_release;
403	}
404	memset(data, 0x00, sizeof(struct smsc47m1_data));
405
406	new_client = &data->client;
407	i2c_set_clientdata(new_client, data);
408	new_client->addr = address;
409	init_MUTEX(&data->lock);
410	new_client->adapter = adapter;
411	new_client->driver = &smsc47m1_driver;
412	new_client->flags = 0;
413
414	strlcpy(new_client->name, "smsc47m1", I2C_NAME_SIZE);
415	init_MUTEX(&data->update_lock);
416
417	/* If no function is properly configured, there's no point in
418	   actually registering the chip. */
419	fan1 = (smsc47m1_read_value(new_client, SMSC47M1_REG_TPIN(0)) & 0x05)
420	       == 0x05;
421	fan2 = (smsc47m1_read_value(new_client, SMSC47M1_REG_TPIN(1)) & 0x05)
422	       == 0x05;
423	pwm1 = (smsc47m1_read_value(new_client, SMSC47M1_REG_PPIN(0)) & 0x05)
424	       == 0x04;
425	pwm2 = (smsc47m1_read_value(new_client, SMSC47M1_REG_PPIN(1)) & 0x05)
426	       == 0x04;
427	if (!(fan1 || fan2 || pwm1 || pwm2)) {
428		dev_warn(&new_client->dev, "Device is not configured, will not use\n");
429		err = -ENODEV;
430		goto error_free;
431	}
432
433	if ((err = i2c_attach_client(new_client)))
434		goto error_free;
435
436	/* Some values (fan min, clock dividers, pwm registers) may be
437	   needed before any update is triggered, so we better read them
438	   at least once here. We don't usually do it that way, but in
439	   this particular case, manually reading 5 registers out of 8
440	   doesn't make much sense and we're better using the existing
441	   function. */
442	smsc47m1_update_device(&new_client->dev, 1);
443
444	/* Register sysfs hooks */
445	data->class_dev = hwmon_device_register(&new_client->dev);
446	if (IS_ERR(data->class_dev)) {
447		err = PTR_ERR(data->class_dev);
448		goto error_detach;
449	}
450
451	if (fan1) {
452		device_create_file(&new_client->dev, &dev_attr_fan1_input);
453		device_create_file(&new_client->dev, &dev_attr_fan1_min);
454		device_create_file(&new_client->dev, &dev_attr_fan1_div);
455	} else
456		dev_dbg(&new_client->dev, "Fan 1 not enabled by hardware, "
457			"skipping\n");
458
459	if (fan2) {
460		device_create_file(&new_client->dev, &dev_attr_fan2_input);
461		device_create_file(&new_client->dev, &dev_attr_fan2_min);
462		device_create_file(&new_client->dev, &dev_attr_fan2_div);
463	} else
464		dev_dbg(&new_client->dev, "Fan 2 not enabled by hardware, "
465			"skipping\n");
466
467	if (pwm1) {
468		device_create_file(&new_client->dev, &dev_attr_pwm1);
469		device_create_file(&new_client->dev, &dev_attr_pwm1_enable);
470	} else
471		dev_dbg(&new_client->dev, "PWM 1 not enabled by hardware, "
472			"skipping\n");
473	if (pwm2) {
474		device_create_file(&new_client->dev, &dev_attr_pwm2);
475		device_create_file(&new_client->dev, &dev_attr_pwm2_enable);
476	} else
477		dev_dbg(&new_client->dev, "PWM 2 not enabled by hardware, "
478			"skipping\n");
479
480	device_create_file(&new_client->dev, &dev_attr_alarms);
481
482	return 0;
483
484error_detach:
485	i2c_detach_client(new_client);
486error_free:
487	kfree(data);
488error_release:
489	release_region(address, SMSC_EXTENT);
490	return err;
491}
492
493static int smsc47m1_detach_client(struct i2c_client *client)
494{
495	struct smsc47m1_data *data = i2c_get_clientdata(client);
496	int err;
497
498	hwmon_device_unregister(data->class_dev);
499
500	if ((err = i2c_detach_client(client)))
501		return err;
502
503	release_region(client->addr, SMSC_EXTENT);
504	kfree(data);
505
506	return 0;
507}
508
509static int smsc47m1_read_value(struct i2c_client *client, u8 reg)
510{
511	int res;
512
513	down(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
514	res = inb_p(client->addr + reg);
515	up(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
516	return res;
517}
518
519static void smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value)
520{
521	down(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
522	outb_p(value, client->addr + reg);
523	up(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
524}
525
526static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
527		int init)
528{
529 	struct i2c_client *client = to_i2c_client(dev);
530	struct smsc47m1_data *data = i2c_get_clientdata(client);
531
532	down(&data->update_lock);
533
534	if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || init) {
535		int i;
536
537		for (i = 0; i < 2; i++) {
538			data->fan[i] = smsc47m1_read_value(client,
539				       SMSC47M1_REG_FAN(i));
540			data->fan_preload[i] = smsc47m1_read_value(client,
541					       SMSC47M1_REG_FAN_PRELOAD(i));
542			data->pwm[i] = smsc47m1_read_value(client,
543				       SMSC47M1_REG_PWM(i));
544		}
545
546		i = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV);
547		data->fan_div[0] = (i >> 4) & 0x03;
548		data->fan_div[1] = i >> 6;
549
550		data->alarms = smsc47m1_read_value(client,
551			       SMSC47M1_REG_ALARM) >> 6;
552		/* Clear alarms if needed */
553		if (data->alarms)
554			smsc47m1_write_value(client, SMSC47M1_REG_ALARM, 0xC0);
555
556		data->last_updated = jiffies;
557	}
558
559	up(&data->update_lock);
560	return data;
561}
562
563static int __init sm_smsc47m1_init(void)
564{
565	if (smsc47m1_find(&address)) {
566		return -ENODEV;
567	}
568
569	return i2c_isa_add_driver(&smsc47m1_driver);
570}
571
572static void __exit sm_smsc47m1_exit(void)
573{
574	i2c_isa_del_driver(&smsc47m1_driver);
575}
576
577MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
578MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver");
579MODULE_LICENSE("GPL");
580
581module_init(sm_smsc47m1_init);
582module_exit(sm_smsc47m1_exit);
583