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