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