linux/drivers/hwmon/smsc47m1.c
<<
>>
Prefs
   1/*
   2 * smsc47m1.c - Part of lm_sensors, Linux kernel modules
   3 *              for hardware monitoring
   4 *
   5 * Supports the SMSC LPC47B27x, LPC47M10x, LPC47M112, LPC47M13x,
   6 * LPC47M14x, LPC47M15x, LPC47M192, LPC47M292 and LPC47M997
   7 * Super-I/O chips.
   8 *
   9 * Copyright (C) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
  10 * Copyright (C) 2004-2007 Jean Delvare <khali@linux-fr.org>
  11 * Ported to Linux 2.6 by Gabriele Gorla <gorlik@yahoo.com>
  12 *                      and Jean Delvare
  13 *
  14 * This program is free software; you can redistribute it and/or modify
  15 * it under the terms of the GNU General Public License as published by
  16 * the Free Software Foundation; either version 2 of the License, or
  17 * (at your option) any later version.
  18 *
  19 * This program is distributed in the hope that it will be useful,
  20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 * GNU General Public License for more details.
  23 *
  24 * You should have received a copy of the GNU General Public License
  25 * along with this program; if not, write to the Free Software
  26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  27 */
  28
  29#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  30
  31#include <linux/module.h>
  32#include <linux/slab.h>
  33#include <linux/ioport.h>
  34#include <linux/jiffies.h>
  35#include <linux/platform_device.h>
  36#include <linux/hwmon.h>
  37#include <linux/hwmon-sysfs.h>
  38#include <linux/err.h>
  39#include <linux/init.h>
  40#include <linux/mutex.h>
  41#include <linux/sysfs.h>
  42#include <linux/acpi.h>
  43#include <linux/io.h>
  44
  45static unsigned short force_id;
  46module_param(force_id, ushort, 0);
  47MODULE_PARM_DESC(force_id, "Override the detected device ID");
  48
  49static struct platform_device *pdev;
  50
  51#define DRVNAME "smsc47m1"
  52enum chips { smsc47m1, smsc47m2 };
  53
  54/* Super-I/0 registers and commands */
  55
  56#define REG     0x2e    /* The register to read/write */
  57#define VAL     0x2f    /* The value to read/write */
  58
  59static inline void
  60superio_outb(int reg, int val)
  61{
  62        outb(reg, REG);
  63        outb(val, VAL);
  64}
  65
  66static inline int
  67superio_inb(int reg)
  68{
  69        outb(reg, REG);
  70        return inb(VAL);
  71}
  72
  73/* logical device for fans is 0x0A */
  74#define superio_select() superio_outb(0x07, 0x0A)
  75
  76static inline void
  77superio_enter(void)
  78{
  79        outb(0x55, REG);
  80}
  81
  82static inline void
  83superio_exit(void)
  84{
  85        outb(0xAA, REG);
  86}
  87
  88#define SUPERIO_REG_ACT         0x30
  89#define SUPERIO_REG_BASE        0x60
  90#define SUPERIO_REG_DEVID       0x20
  91#define SUPERIO_REG_DEVREV      0x21
  92
  93/* Logical device registers */
  94
  95#define SMSC_EXTENT             0x80
  96
  97/* nr is 0 or 1 in the macros below */
  98#define SMSC47M1_REG_ALARM              0x04
  99#define SMSC47M1_REG_TPIN(nr)           (0x34 - (nr))
 100#define SMSC47M1_REG_PPIN(nr)           (0x36 - (nr))
 101#define SMSC47M1_REG_FANDIV             0x58
 102
 103static const u8 SMSC47M1_REG_FAN[3]             = { 0x59, 0x5a, 0x6b };
 104static const u8 SMSC47M1_REG_FAN_PRELOAD[3]     = { 0x5b, 0x5c, 0x6c };
 105static const u8 SMSC47M1_REG_PWM[3]             = { 0x56, 0x57, 0x69 };
 106
 107#define SMSC47M2_REG_ALARM6             0x09
 108#define SMSC47M2_REG_TPIN1              0x38
 109#define SMSC47M2_REG_TPIN2              0x37
 110#define SMSC47M2_REG_TPIN3              0x2d
 111#define SMSC47M2_REG_PPIN3              0x2c
 112#define SMSC47M2_REG_FANDIV3            0x6a
 113
 114#define MIN_FROM_REG(reg, div)          ((reg) >= 192 ? 0 : \
 115                                         983040 / ((192 - (reg)) * (div)))
 116#define FAN_FROM_REG(reg, div, preload) ((reg) <= (preload) || (reg) == 255 ? \
 117                                         0 : \
 118                                         983040 / (((reg) - (preload)) * (div)))
 119#define DIV_FROM_REG(reg)               (1 << (reg))
 120#define PWM_FROM_REG(reg)               (((reg) & 0x7E) << 1)
 121#define PWM_EN_FROM_REG(reg)            ((~(reg)) & 0x01)
 122#define PWM_TO_REG(reg)                 (((reg) >> 1) & 0x7E)
 123
 124struct smsc47m1_data {
 125        unsigned short addr;
 126        const char *name;
 127        enum chips type;
 128        struct device *hwmon_dev;
 129
 130        struct mutex update_lock;
 131        unsigned long last_updated;     /* In jiffies */
 132
 133        u8 fan[3];              /* Register value */
 134        u8 fan_preload[3];      /* Register value */
 135        u8 fan_div[3];          /* Register encoding, shifted right */
 136        u8 alarms;              /* Register encoding */
 137        u8 pwm[3];              /* Register value (bit 0 is disable) */
 138};
 139
 140struct smsc47m1_sio_data {
 141        enum chips type;
 142        u8 activate;            /* Remember initial device state */
 143};
 144
 145
 146static int __exit smsc47m1_remove(struct platform_device *pdev);
 147static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
 148                int init);
 149
 150static inline int smsc47m1_read_value(struct smsc47m1_data *data, u8 reg)
 151{
 152        return inb_p(data->addr + reg);
 153}
 154
 155static inline void smsc47m1_write_value(struct smsc47m1_data *data, u8 reg,
 156                u8 value)
 157{
 158        outb_p(value, data->addr + reg);
 159}
 160
 161static struct platform_driver smsc47m1_driver = {
 162        .driver = {
 163                .owner  = THIS_MODULE,
 164                .name   = DRVNAME,
 165        },
 166        .remove         = __exit_p(smsc47m1_remove),
 167};
 168
 169static ssize_t get_fan(struct device *dev, struct device_attribute
 170                       *devattr, char *buf)
 171{
 172        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 173        struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
 174        int nr = attr->index;
 175        /*
 176         * This chip (stupidly) stops monitoring fan speed if PWM is
 177         * enabled and duty cycle is 0%. This is fine if the monitoring
 178         * and control concern the same fan, but troublesome if they are
 179         * not (which could as well happen).
 180         */
 181        int rpm = (data->pwm[nr] & 0x7F) == 0x00 ? 0 :
 182                  FAN_FROM_REG(data->fan[nr],
 183                               DIV_FROM_REG(data->fan_div[nr]),
 184                               data->fan_preload[nr]);
 185        return sprintf(buf, "%d\n", rpm);
 186}
 187
 188static ssize_t get_fan_min(struct device *dev, struct device_attribute
 189                           *devattr, char *buf)
 190{
 191        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 192        struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
 193        int nr = attr->index;
 194        int rpm = MIN_FROM_REG(data->fan_preload[nr],
 195                               DIV_FROM_REG(data->fan_div[nr]));
 196        return sprintf(buf, "%d\n", rpm);
 197}
 198
 199static ssize_t get_fan_div(struct device *dev, struct device_attribute
 200                           *devattr, char *buf)
 201{
 202        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 203        struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
 204        return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
 205}
 206
 207static ssize_t get_fan_alarm(struct device *dev, struct device_attribute
 208                             *devattr, char *buf)
 209{
 210        int bitnr = to_sensor_dev_attr(devattr)->index;
 211        struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
 212        return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
 213}
 214
 215static ssize_t get_pwm(struct device *dev, struct device_attribute
 216                       *devattr, char *buf)
 217{
 218        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 219        struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
 220        return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[attr->index]));
 221}
 222
 223static ssize_t get_pwm_en(struct device *dev, struct device_attribute
 224                          *devattr, char *buf)
 225{
 226        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 227        struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
 228        return sprintf(buf, "%d\n", PWM_EN_FROM_REG(data->pwm[attr->index]));
 229}
 230
 231static ssize_t get_alarms(struct device *dev, struct device_attribute
 232                          *devattr, char *buf)
 233{
 234        struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
 235        return sprintf(buf, "%d\n", data->alarms);
 236}
 237
 238static ssize_t set_fan_min(struct device *dev, struct device_attribute
 239                           *devattr, const char *buf, size_t count)
 240{
 241        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 242        struct smsc47m1_data *data = dev_get_drvdata(dev);
 243        int nr = attr->index;
 244        long rpmdiv;
 245        long val;
 246        int err;
 247
 248        err = kstrtol(buf, 10, &val);
 249        if (err)
 250                return err;
 251
 252        mutex_lock(&data->update_lock);
 253        rpmdiv = val * DIV_FROM_REG(data->fan_div[nr]);
 254
 255        if (983040 > 192 * rpmdiv || 2 * rpmdiv > 983040) {
 256                mutex_unlock(&data->update_lock);
 257                return -EINVAL;
 258        }
 259
 260        data->fan_preload[nr] = 192 - ((983040 + rpmdiv / 2) / rpmdiv);
 261        smsc47m1_write_value(data, SMSC47M1_REG_FAN_PRELOAD[nr],
 262                             data->fan_preload[nr]);
 263        mutex_unlock(&data->update_lock);
 264
 265        return count;
 266}
 267
 268/*
 269 * Note: we save and restore the fan minimum here, because its value is
 270 * determined in part by the fan clock divider.  This follows the principle
 271 * of least surprise; the user doesn't expect the fan minimum to change just
 272 * because the divider changed.
 273 */
 274static ssize_t set_fan_div(struct device *dev, struct device_attribute
 275                           *devattr, const char *buf, size_t count)
 276{
 277        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 278        struct smsc47m1_data *data = dev_get_drvdata(dev);
 279        int nr = attr->index;
 280        long new_div;
 281        int err;
 282        long tmp;
 283        u8 old_div = DIV_FROM_REG(data->fan_div[nr]);
 284
 285        err = kstrtol(buf, 10, &new_div);
 286        if (err)
 287                return err;
 288
 289        if (new_div == old_div) /* No change */
 290                return count;
 291
 292        mutex_lock(&data->update_lock);
 293        switch (new_div) {
 294        case 1:
 295                data->fan_div[nr] = 0;
 296                break;
 297        case 2:
 298                data->fan_div[nr] = 1;
 299                break;
 300        case 4:
 301                data->fan_div[nr] = 2;
 302                break;
 303        case 8:
 304                data->fan_div[nr] = 3;
 305                break;
 306        default:
 307                mutex_unlock(&data->update_lock);
 308                return -EINVAL;
 309        }
 310
 311        switch (nr) {
 312        case 0:
 313        case 1:
 314                tmp = smsc47m1_read_value(data, SMSC47M1_REG_FANDIV)
 315                      & ~(0x03 << (4 + 2 * nr));
 316                tmp |= data->fan_div[nr] << (4 + 2 * nr);
 317                smsc47m1_write_value(data, SMSC47M1_REG_FANDIV, tmp);
 318                break;
 319        case 2:
 320                tmp = smsc47m1_read_value(data, SMSC47M2_REG_FANDIV3) & 0xCF;
 321                tmp |= data->fan_div[2] << 4;
 322                smsc47m1_write_value(data, SMSC47M2_REG_FANDIV3, tmp);
 323                break;
 324        }
 325
 326        /* Preserve fan min */
 327        tmp = 192 - (old_div * (192 - data->fan_preload[nr])
 328                     + new_div / 2) / new_div;
 329        data->fan_preload[nr] = SENSORS_LIMIT(tmp, 0, 191);
 330        smsc47m1_write_value(data, SMSC47M1_REG_FAN_PRELOAD[nr],
 331                             data->fan_preload[nr]);
 332        mutex_unlock(&data->update_lock);
 333
 334        return count;
 335}
 336
 337static ssize_t set_pwm(struct device *dev, struct device_attribute
 338                       *devattr, const char *buf, size_t count)
 339{
 340        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 341        struct smsc47m1_data *data = dev_get_drvdata(dev);
 342        int nr = attr->index;
 343        long val;
 344        int err;
 345
 346        err = kstrtol(buf, 10, &val);
 347        if (err)
 348                return err;
 349
 350        if (val < 0 || val > 255)
 351                return -EINVAL;
 352
 353        mutex_lock(&data->update_lock);
 354        data->pwm[nr] &= 0x81; /* Preserve additional bits */
 355        data->pwm[nr] |= PWM_TO_REG(val);
 356        smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr],
 357                             data->pwm[nr]);
 358        mutex_unlock(&data->update_lock);
 359
 360        return count;
 361}
 362
 363static ssize_t set_pwm_en(struct device *dev, struct device_attribute
 364                          *devattr, const char *buf, size_t count)
 365{
 366        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 367        struct smsc47m1_data *data = dev_get_drvdata(dev);
 368        int nr = attr->index;
 369        unsigned long val;
 370        int err;
 371
 372        err = kstrtoul(buf, 10, &val);
 373        if (err)
 374                return err;
 375
 376        if (val > 1)
 377                return -EINVAL;
 378
 379        mutex_lock(&data->update_lock);
 380        data->pwm[nr] &= 0xFE; /* preserve the other bits */
 381        data->pwm[nr] |= !val;
 382        smsc47m1_write_value(data, SMSC47M1_REG_PWM[nr],
 383                             data->pwm[nr]);
 384        mutex_unlock(&data->update_lock);
 385
 386        return count;
 387}
 388
 389#define fan_present(offset)                                             \
 390static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, get_fan,        \
 391                NULL, offset - 1);                                      \
 392static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,         \
 393                get_fan_min, set_fan_min, offset - 1);                  \
 394static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,         \
 395                get_fan_div, set_fan_div, offset - 1);                  \
 396static SENSOR_DEVICE_ATTR(fan##offset##_alarm, S_IRUGO, get_fan_alarm,  \
 397                NULL, offset - 1);                                      \
 398static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR,               \
 399                get_pwm, set_pwm, offset - 1);                          \
 400static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR,      \
 401                get_pwm_en, set_pwm_en, offset - 1)
 402
 403fan_present(1);
 404fan_present(2);
 405fan_present(3);
 406
 407static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL);
 408
 409static ssize_t show_name(struct device *dev, struct device_attribute
 410                         *devattr, char *buf)
 411{
 412        struct smsc47m1_data *data = dev_get_drvdata(dev);
 413
 414        return sprintf(buf, "%s\n", data->name);
 415}
 416static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 417
 418static struct attribute *smsc47m1_attributes_fan1[] = {
 419        &sensor_dev_attr_fan1_input.dev_attr.attr,
 420        &sensor_dev_attr_fan1_min.dev_attr.attr,
 421        &sensor_dev_attr_fan1_div.dev_attr.attr,
 422        &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 423        NULL
 424};
 425
 426static const struct attribute_group smsc47m1_group_fan1 = {
 427        .attrs = smsc47m1_attributes_fan1,
 428};
 429
 430static struct attribute *smsc47m1_attributes_fan2[] = {
 431        &sensor_dev_attr_fan2_input.dev_attr.attr,
 432        &sensor_dev_attr_fan2_min.dev_attr.attr,
 433        &sensor_dev_attr_fan2_div.dev_attr.attr,
 434        &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 435        NULL
 436};
 437
 438static const struct attribute_group smsc47m1_group_fan2 = {
 439        .attrs = smsc47m1_attributes_fan2,
 440};
 441
 442static struct attribute *smsc47m1_attributes_fan3[] = {
 443        &sensor_dev_attr_fan3_input.dev_attr.attr,
 444        &sensor_dev_attr_fan3_min.dev_attr.attr,
 445        &sensor_dev_attr_fan3_div.dev_attr.attr,
 446        &sensor_dev_attr_fan3_alarm.dev_attr.attr,
 447        NULL
 448};
 449
 450static const struct attribute_group smsc47m1_group_fan3 = {
 451        .attrs = smsc47m1_attributes_fan3,
 452};
 453
 454static struct attribute *smsc47m1_attributes_pwm1[] = {
 455        &sensor_dev_attr_pwm1.dev_attr.attr,
 456        &sensor_dev_attr_pwm1_enable.dev_attr.attr,
 457        NULL
 458};
 459
 460static const struct attribute_group smsc47m1_group_pwm1 = {
 461        .attrs = smsc47m1_attributes_pwm1,
 462};
 463
 464static struct attribute *smsc47m1_attributes_pwm2[] = {
 465        &sensor_dev_attr_pwm2.dev_attr.attr,
 466        &sensor_dev_attr_pwm2_enable.dev_attr.attr,
 467        NULL
 468};
 469
 470static const struct attribute_group smsc47m1_group_pwm2 = {
 471        .attrs = smsc47m1_attributes_pwm2,
 472};
 473
 474static struct attribute *smsc47m1_attributes_pwm3[] = {
 475        &sensor_dev_attr_pwm3.dev_attr.attr,
 476        &sensor_dev_attr_pwm3_enable.dev_attr.attr,
 477        NULL
 478};
 479
 480static const struct attribute_group smsc47m1_group_pwm3 = {
 481        .attrs = smsc47m1_attributes_pwm3,
 482};
 483
 484static struct attribute *smsc47m1_attributes[] = {
 485        &dev_attr_alarms.attr,
 486        &dev_attr_name.attr,
 487        NULL
 488};
 489
 490static const struct attribute_group smsc47m1_group = {
 491        .attrs = smsc47m1_attributes,
 492};
 493
 494static int __init smsc47m1_find(struct smsc47m1_sio_data *sio_data)
 495{
 496        u8 val;
 497        unsigned short addr;
 498
 499        superio_enter();
 500        val = force_id ? force_id : superio_inb(SUPERIO_REG_DEVID);
 501
 502        /*
 503         * SMSC LPC47M10x/LPC47M112/LPC47M13x (device id 0x59), LPC47M14x
 504         * (device id 0x5F) and LPC47B27x (device id 0x51) have fan control.
 505         * The LPC47M15x and LPC47M192 chips "with hardware monitoring block"
 506         * can do much more besides (device id 0x60).
 507         * The LPC47M997 is undocumented, but seems to be compatible with
 508         * the LPC47M192, and has the same device id.
 509         * The LPC47M292 (device id 0x6B) is somewhat compatible, but it
 510         * supports a 3rd fan, and the pin configuration registers are
 511         * unfortunately different.
 512         * The LPC47M233 has the same device id (0x6B) but is not compatible.
 513         * We check the high bit of the device revision register to
 514         * differentiate them.
 515         */
 516        switch (val) {
 517        case 0x51:
 518                pr_info("Found SMSC LPC47B27x\n");
 519                sio_data->type = smsc47m1;
 520                break;
 521        case 0x59:
 522                pr_info("Found SMSC LPC47M10x/LPC47M112/LPC47M13x\n");
 523                sio_data->type = smsc47m1;
 524                break;
 525        case 0x5F:
 526                pr_info("Found SMSC LPC47M14x\n");
 527                sio_data->type = smsc47m1;
 528                break;
 529        case 0x60:
 530                pr_info("Found SMSC LPC47M15x/LPC47M192/LPC47M997\n");
 531                sio_data->type = smsc47m1;
 532                break;
 533        case 0x6B:
 534                if (superio_inb(SUPERIO_REG_DEVREV) & 0x80) {
 535                        pr_debug("Found SMSC LPC47M233, unsupported\n");
 536                        superio_exit();
 537                        return -ENODEV;
 538                }
 539
 540                pr_info("Found SMSC LPC47M292\n");
 541                sio_data->type = smsc47m2;
 542                break;
 543        default:
 544                superio_exit();
 545                return -ENODEV;
 546        }
 547
 548        superio_select();
 549        addr = (superio_inb(SUPERIO_REG_BASE) << 8)
 550              |  superio_inb(SUPERIO_REG_BASE + 1);
 551        if (addr == 0) {
 552                pr_info("Device address not set, will not use\n");
 553                superio_exit();
 554                return -ENODEV;
 555        }
 556
 557        /*
 558         * Enable only if address is set (needed at least on the
 559         * Compaq Presario S4000NX)
 560         */
 561        sio_data->activate = superio_inb(SUPERIO_REG_ACT);
 562        if ((sio_data->activate & 0x01) == 0) {
 563                pr_info("Enabling device\n");
 564                superio_outb(SUPERIO_REG_ACT, sio_data->activate | 0x01);
 565        }
 566
 567        superio_exit();
 568        return addr;
 569}
 570
 571/* Restore device to its initial state */
 572static void smsc47m1_restore(const struct smsc47m1_sio_data *sio_data)
 573{
 574        if ((sio_data->activate & 0x01) == 0) {
 575                superio_enter();
 576                superio_select();
 577
 578                pr_info("Disabling device\n");
 579                superio_outb(SUPERIO_REG_ACT, sio_data->activate);
 580
 581                superio_exit();
 582        }
 583}
 584
 585#define CHECK           1
 586#define REQUEST         2
 587
 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 */
 595static 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
 657static 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
 668static int __init smsc47m1_probe(struct platform_device *pdev)
 669{
 670        struct device *dev = &pdev->dev;
 671        struct smsc47m1_sio_data *sio_data = dev->platform_data;
 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
 799error_remove_files:
 800        smsc47m1_remove_files(dev);
 801        return err;
 802}
 803
 804static 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
 814static 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
 863static 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
 906exit_device_put:
 907        platform_device_put(pdev);
 908exit:
 909        return err;
 910}
 911
 912static 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
 934exit_device:
 935        platform_device_unregister(pdev);
 936        smsc47m1_restore(&sio_data);
 937        return err;
 938}
 939
 940static void __exit sm_smsc47m1_exit(void)
 941{
 942        platform_driver_unregister(&smsc47m1_driver);
 943        smsc47m1_restore(pdev->dev.platform_data);
 944        platform_device_unregister(pdev);
 945}
 946
 947MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
 948MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver");
 949MODULE_LICENSE("GPL");
 950
 951module_init(sm_smsc47m1_init);
 952module_exit(sm_smsc47m1_exit);
 953
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.