linux/drivers/hwmon/gpio-fan.c
<<
>>
Prefs
   1/*
   2 * gpio-fan.c - Hwmon driver for fans connected to GPIO lines.
   3 *
   4 * Copyright (C) 2010 LaCie
   5 *
   6 * Author: Simon Guinot <sguinot@lacie.com>
   7 *
   8 * This program is free software; you can redistribute it and/or modify
   9 * it under the terms of the GNU General Public License as published by
  10 * the Free Software Foundation; either version 2 of the License, or
  11 * (at your option) any later version.
  12 *
  13 * This program is distributed in the hope that it will be useful,
  14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 * GNU General Public License for more details.
  17 *
  18 * You should have received a copy of the GNU General Public License
  19 * along with this program; if not, write to the Free Software
  20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21 */
  22
  23#include <linux/module.h>
  24#include <linux/init.h>
  25#include <linux/slab.h>
  26#include <linux/interrupt.h>
  27#include <linux/irq.h>
  28#include <linux/platform_device.h>
  29#include <linux/err.h>
  30#include <linux/mutex.h>
  31#include <linux/hwmon.h>
  32#include <linux/gpio.h>
  33#include <linux/gpio-fan.h>
  34
  35struct gpio_fan_data {
  36        struct platform_device  *pdev;
  37        struct device           *hwmon_dev;
  38        struct mutex            lock; /* lock GPIOs operations. */
  39        int                     num_ctrl;
  40        unsigned                *ctrl;
  41        int                     num_speed;
  42        struct gpio_fan_speed   *speed;
  43        int                     speed_index;
  44#ifdef CONFIG_PM_SLEEP
  45        int                     resume_speed;
  46#endif
  47        bool                    pwm_enable;
  48        struct gpio_fan_alarm   *alarm;
  49        struct work_struct      alarm_work;
  50};
  51
  52/*
  53 * Alarm GPIO.
  54 */
  55
  56static void fan_alarm_notify(struct work_struct *ws)
  57{
  58        struct gpio_fan_data *fan_data =
  59                container_of(ws, struct gpio_fan_data, alarm_work);
  60
  61        sysfs_notify(&fan_data->pdev->dev.kobj, NULL, "fan1_alarm");
  62        kobject_uevent(&fan_data->pdev->dev.kobj, KOBJ_CHANGE);
  63}
  64
  65static irqreturn_t fan_alarm_irq_handler(int irq, void *dev_id)
  66{
  67        struct gpio_fan_data *fan_data = dev_id;
  68
  69        schedule_work(&fan_data->alarm_work);
  70
  71        return IRQ_NONE;
  72}
  73
  74static ssize_t show_fan_alarm(struct device *dev,
  75                              struct device_attribute *attr, char *buf)
  76{
  77        struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
  78        struct gpio_fan_alarm *alarm = fan_data->alarm;
  79        int value = gpio_get_value(alarm->gpio);
  80
  81        if (alarm->active_low)
  82                value = !value;
  83
  84        return sprintf(buf, "%d\n", value);
  85}
  86
  87static DEVICE_ATTR(fan1_alarm, S_IRUGO, show_fan_alarm, NULL);
  88
  89static int fan_alarm_init(struct gpio_fan_data *fan_data,
  90                          struct gpio_fan_alarm *alarm)
  91{
  92        int err;
  93        int alarm_irq;
  94        struct platform_device *pdev = fan_data->pdev;
  95
  96        fan_data->alarm = alarm;
  97
  98        err = devm_gpio_request(&pdev->dev, alarm->gpio, "GPIO fan alarm");
  99        if (err)
 100                return err;
 101
 102        err = gpio_direction_input(alarm->gpio);
 103        if (err)
 104                return err;
 105
 106        err = device_create_file(&pdev->dev, &dev_attr_fan1_alarm);
 107        if (err)
 108                return err;
 109
 110        /*
 111         * If the alarm GPIO don't support interrupts, just leave
 112         * without initializing the fail notification support.
 113         */
 114        alarm_irq = gpio_to_irq(alarm->gpio);
 115        if (alarm_irq < 0)
 116                return 0;
 117
 118        INIT_WORK(&fan_data->alarm_work, fan_alarm_notify);
 119        irq_set_irq_type(alarm_irq, IRQ_TYPE_EDGE_BOTH);
 120        err = devm_request_irq(&pdev->dev, alarm_irq, fan_alarm_irq_handler,
 121                               IRQF_SHARED, "GPIO fan alarm", fan_data);
 122        if (err)
 123                goto err_free_sysfs;
 124
 125        return 0;
 126
 127err_free_sysfs:
 128        device_remove_file(&pdev->dev, &dev_attr_fan1_alarm);
 129        return err;
 130}
 131
 132static void fan_alarm_free(struct gpio_fan_data *fan_data)
 133{
 134        struct platform_device *pdev = fan_data->pdev;
 135
 136        device_remove_file(&pdev->dev, &dev_attr_fan1_alarm);
 137}
 138
 139/*
 140 * Control GPIOs.
 141 */
 142
 143/* Must be called with fan_data->lock held, except during initialization. */
 144static void __set_fan_ctrl(struct gpio_fan_data *fan_data, int ctrl_val)
 145{
 146        int i;
 147
 148        for (i = 0; i < fan_data->num_ctrl; i++)
 149                gpio_set_value(fan_data->ctrl[i], (ctrl_val >> i) & 1);
 150}
 151
 152static int __get_fan_ctrl(struct gpio_fan_data *fan_data)
 153{
 154        int i;
 155        int ctrl_val = 0;
 156
 157        for (i = 0; i < fan_data->num_ctrl; i++) {
 158                int value;
 159
 160                value = gpio_get_value(fan_data->ctrl[i]);
 161                ctrl_val |= (value << i);
 162        }
 163        return ctrl_val;
 164}
 165
 166/* Must be called with fan_data->lock held, except during initialization. */
 167static void set_fan_speed(struct gpio_fan_data *fan_data, int speed_index)
 168{
 169        if (fan_data->speed_index == speed_index)
 170                return;
 171
 172        __set_fan_ctrl(fan_data, fan_data->speed[speed_index].ctrl_val);
 173        fan_data->speed_index = speed_index;
 174}
 175
 176static int get_fan_speed_index(struct gpio_fan_data *fan_data)
 177{
 178        int ctrl_val = __get_fan_ctrl(fan_data);
 179        int i;
 180
 181        for (i = 0; i < fan_data->num_speed; i++)
 182                if (fan_data->speed[i].ctrl_val == ctrl_val)
 183                        return i;
 184
 185        dev_warn(&fan_data->pdev->dev,
 186                 "missing speed array entry for GPIO value 0x%x\n", ctrl_val);
 187
 188        return -EINVAL;
 189}
 190
 191static int rpm_to_speed_index(struct gpio_fan_data *fan_data, int rpm)
 192{
 193        struct gpio_fan_speed *speed = fan_data->speed;
 194        int i;
 195
 196        for (i = 0; i < fan_data->num_speed; i++)
 197                if (speed[i].rpm >= rpm)
 198                        return i;
 199
 200        return fan_data->num_speed - 1;
 201}
 202
 203static ssize_t show_pwm(struct device *dev,
 204                        struct device_attribute *attr, char *buf)
 205{
 206        struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
 207        u8 pwm = fan_data->speed_index * 255 / (fan_data->num_speed - 1);
 208
 209        return sprintf(buf, "%d\n", pwm);
 210}
 211
 212static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
 213                       const char *buf, size_t count)
 214{
 215        struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
 216        unsigned long pwm;
 217        int speed_index;
 218        int ret = count;
 219
 220        if (kstrtoul(buf, 10, &pwm) || pwm > 255)
 221                return -EINVAL;
 222
 223        mutex_lock(&fan_data->lock);
 224
 225        if (!fan_data->pwm_enable) {
 226                ret = -EPERM;
 227                goto exit_unlock;
 228        }
 229
 230        speed_index = DIV_ROUND_UP(pwm * (fan_data->num_speed - 1), 255);
 231        set_fan_speed(fan_data, speed_index);
 232
 233exit_unlock:
 234        mutex_unlock(&fan_data->lock);
 235
 236        return ret;
 237}
 238
 239static ssize_t show_pwm_enable(struct device *dev,
 240                               struct device_attribute *attr, char *buf)
 241{
 242        struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
 243
 244        return sprintf(buf, "%d\n", fan_data->pwm_enable);
 245}
 246
 247static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *attr,
 248                              const char *buf, size_t count)
 249{
 250        struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
 251        unsigned long val;
 252
 253        if (kstrtoul(buf, 10, &val) || val > 1)
 254                return -EINVAL;
 255
 256        if (fan_data->pwm_enable == val)
 257                return count;
 258
 259        mutex_lock(&fan_data->lock);
 260
 261        fan_data->pwm_enable = val;
 262
 263        /* Disable manual control mode: set fan at full speed. */
 264        if (val == 0)
 265                set_fan_speed(fan_data, fan_data->num_speed - 1);
 266
 267        mutex_unlock(&fan_data->lock);
 268
 269        return count;
 270}
 271
 272static ssize_t show_pwm_mode(struct device *dev,
 273                             struct device_attribute *attr, char *buf)
 274{
 275        return sprintf(buf, "0\n");
 276}
 277
 278static ssize_t show_rpm_min(struct device *dev,
 279                            struct device_attribute *attr, char *buf)
 280{
 281        struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
 282
 283        return sprintf(buf, "%d\n", fan_data->speed[0].rpm);
 284}
 285
 286static ssize_t show_rpm_max(struct device *dev,
 287                            struct device_attribute *attr, char *buf)
 288{
 289        struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
 290
 291        return sprintf(buf, "%d\n",
 292                       fan_data->speed[fan_data->num_speed - 1].rpm);
 293}
 294
 295static ssize_t show_rpm(struct device *dev,
 296                        struct device_attribute *attr, char *buf)
 297{
 298        struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
 299
 300        return sprintf(buf, "%d\n", fan_data->speed[fan_data->speed_index].rpm);
 301}
 302
 303static ssize_t set_rpm(struct device *dev, struct device_attribute *attr,
 304                       const char *buf, size_t count)
 305{
 306        struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
 307        unsigned long rpm;
 308        int ret = count;
 309
 310        if (kstrtoul(buf, 10, &rpm))
 311                return -EINVAL;
 312
 313        mutex_lock(&fan_data->lock);
 314
 315        if (!fan_data->pwm_enable) {
 316                ret = -EPERM;
 317                goto exit_unlock;
 318        }
 319
 320        set_fan_speed(fan_data, rpm_to_speed_index(fan_data, rpm));
 321
 322exit_unlock:
 323        mutex_unlock(&fan_data->lock);
 324
 325        return ret;
 326}
 327
 328static DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm);
 329static DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
 330                   show_pwm_enable, set_pwm_enable);
 331static DEVICE_ATTR(pwm1_mode, S_IRUGO, show_pwm_mode, NULL);
 332static DEVICE_ATTR(fan1_min, S_IRUGO, show_rpm_min, NULL);
 333static DEVICE_ATTR(fan1_max, S_IRUGO, show_rpm_max, NULL);
 334static DEVICE_ATTR(fan1_input, S_IRUGO, show_rpm, NULL);
 335static DEVICE_ATTR(fan1_target, S_IRUGO | S_IWUSR, show_rpm, set_rpm);
 336
 337static struct attribute *gpio_fan_ctrl_attributes[] = {
 338        &dev_attr_pwm1.attr,
 339        &dev_attr_pwm1_enable.attr,
 340        &dev_attr_pwm1_mode.attr,
 341        &dev_attr_fan1_input.attr,
 342        &dev_attr_fan1_target.attr,
 343        &dev_attr_fan1_min.attr,
 344        &dev_attr_fan1_max.attr,
 345        NULL
 346};
 347
 348static const struct attribute_group gpio_fan_ctrl_group = {
 349        .attrs = gpio_fan_ctrl_attributes,
 350};
 351
 352static int fan_ctrl_init(struct gpio_fan_data *fan_data,
 353                         struct gpio_fan_platform_data *pdata)
 354{
 355        struct platform_device *pdev = fan_data->pdev;
 356        int num_ctrl = pdata->num_ctrl;
 357        unsigned *ctrl = pdata->ctrl;
 358        int i, err;
 359
 360        for (i = 0; i < num_ctrl; i++) {
 361                err = devm_gpio_request(&pdev->dev, ctrl[i],
 362                                        "GPIO fan control");
 363                if (err)
 364                        return err;
 365
 366                err = gpio_direction_output(ctrl[i], gpio_get_value(ctrl[i]));
 367                if (err)
 368                        return err;
 369        }
 370
 371        fan_data->num_ctrl = num_ctrl;
 372        fan_data->ctrl = ctrl;
 373        fan_data->num_speed = pdata->num_speed;
 374        fan_data->speed = pdata->speed;
 375        fan_data->pwm_enable = true; /* Enable manual fan speed control. */
 376        fan_data->speed_index = get_fan_speed_index(fan_data);
 377        if (fan_data->speed_index < 0)
 378                return -ENODEV;
 379
 380        err = sysfs_create_group(&pdev->dev.kobj, &gpio_fan_ctrl_group);
 381        return err;
 382}
 383
 384static void fan_ctrl_free(struct gpio_fan_data *fan_data)
 385{
 386        struct platform_device *pdev = fan_data->pdev;
 387
 388        sysfs_remove_group(&pdev->dev.kobj, &gpio_fan_ctrl_group);
 389}
 390
 391/*
 392 * Platform driver.
 393 */
 394
 395static ssize_t show_name(struct device *dev,
 396                         struct device_attribute *attr, char *buf)
 397{
 398        return sprintf(buf, "gpio-fan\n");
 399}
 400
 401static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 402
 403static int __devinit gpio_fan_probe(struct platform_device *pdev)
 404{
 405        int err;
 406        struct gpio_fan_data *fan_data;
 407        struct gpio_fan_platform_data *pdata = pdev->dev.platform_data;
 408
 409        if (!pdata)
 410                return -EINVAL;
 411
 412        fan_data = devm_kzalloc(&pdev->dev, sizeof(struct gpio_fan_data),
 413                                GFP_KERNEL);
 414        if (!fan_data)
 415                return -ENOMEM;
 416
 417        fan_data->pdev = pdev;
 418        platform_set_drvdata(pdev, fan_data);
 419        mutex_init(&fan_data->lock);
 420
 421        /* Configure alarm GPIO if available. */
 422        if (pdata->alarm) {
 423                err = fan_alarm_init(fan_data, pdata->alarm);
 424                if (err)
 425                        return err;
 426        }
 427
 428        /* Configure control GPIOs if available. */
 429        if (pdata->ctrl && pdata->num_ctrl > 0) {
 430                if (!pdata->speed || pdata->num_speed <= 1) {
 431                        err = -EINVAL;
 432                        goto err_free_alarm;
 433                }
 434                err = fan_ctrl_init(fan_data, pdata);
 435                if (err)
 436                        goto err_free_alarm;
 437        }
 438
 439        err = device_create_file(&pdev->dev, &dev_attr_name);
 440        if (err)
 441                goto err_free_ctrl;
 442
 443        /* Make this driver part of hwmon class. */
 444        fan_data->hwmon_dev = hwmon_device_register(&pdev->dev);
 445        if (IS_ERR(fan_data->hwmon_dev)) {
 446                err = PTR_ERR(fan_data->hwmon_dev);
 447                goto err_remove_name;
 448        }
 449
 450        dev_info(&pdev->dev, "GPIO fan initialized\n");
 451
 452        return 0;
 453
 454err_remove_name:
 455        device_remove_file(&pdev->dev, &dev_attr_name);
 456err_free_ctrl:
 457        if (fan_data->ctrl)
 458                fan_ctrl_free(fan_data);
 459err_free_alarm:
 460        if (fan_data->alarm)
 461                fan_alarm_free(fan_data);
 462        return err;
 463}
 464
 465static int __devexit gpio_fan_remove(struct platform_device *pdev)
 466{
 467        struct gpio_fan_data *fan_data = platform_get_drvdata(pdev);
 468
 469        hwmon_device_unregister(fan_data->hwmon_dev);
 470        device_remove_file(&pdev->dev, &dev_attr_name);
 471        if (fan_data->alarm)
 472                fan_alarm_free(fan_data);
 473        if (fan_data->ctrl)
 474                fan_ctrl_free(fan_data);
 475
 476        return 0;
 477}
 478
 479#ifdef CONFIG_PM_SLEEP
 480static int gpio_fan_suspend(struct device *dev)
 481{
 482        struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
 483
 484        if (fan_data->ctrl) {
 485                fan_data->resume_speed = fan_data->speed_index;
 486                set_fan_speed(fan_data, 0);
 487        }
 488
 489        return 0;
 490}
 491
 492static int gpio_fan_resume(struct device *dev)
 493{
 494        struct gpio_fan_data *fan_data = dev_get_drvdata(dev);
 495
 496        if (fan_data->ctrl)
 497                set_fan_speed(fan_data, fan_data->resume_speed);
 498
 499        return 0;
 500}
 501
 502static SIMPLE_DEV_PM_OPS(gpio_fan_pm, gpio_fan_suspend, gpio_fan_resume);
 503#define GPIO_FAN_PM     &gpio_fan_pm
 504#else
 505#define GPIO_FAN_PM     NULL
 506#endif
 507
 508static struct platform_driver gpio_fan_driver = {
 509        .probe          = gpio_fan_probe,
 510        .remove         = __devexit_p(gpio_fan_remove),
 511        .driver = {
 512                .name   = "gpio-fan",
 513                .pm     = GPIO_FAN_PM,
 514        },
 515};
 516
 517module_platform_driver(gpio_fan_driver);
 518
 519MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>");
 520MODULE_DESCRIPTION("GPIO FAN driver");
 521MODULE_LICENSE("GPL");
 522MODULE_ALIAS("platform:gpio-fan");
 523
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.