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