Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/hwmon/smsc47m1.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us