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