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 35 struct 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 56 static 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 65 static 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 74 static 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 87 static DEVICE_ATTR(fan1_alarm, S_IRUGO, show_fan_alarm, NULL); 88 89 static 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 127 err_free_sysfs: 128 device_remove_file(&pdev->dev, &dev_attr_fan1_alarm); 129 return err; 130 } 131 132 static 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. */ 144 static 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 152 static 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. */ 167 static 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 176 static 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 191 static 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 203 static 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 212 static 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 233 exit_unlock: 234 mutex_unlock(&fan_data->lock); 235 236 return ret; 237 } 238 239 static 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 247 static 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 272 static ssize_t show_pwm_mode(struct device *dev, 273 struct device_attribute *attr, char *buf) 274 { 275 return sprintf(buf, "0\n"); 276 } 277 278 static 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 286 static 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 295 static 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 303 static 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 322 exit_unlock: 323 mutex_unlock(&fan_data->lock); 324 325 return ret; 326 } 327 328 static DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm); 329 static DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, 330 show_pwm_enable, set_pwm_enable); 331 static DEVICE_ATTR(pwm1_mode, S_IRUGO, show_pwm_mode, NULL); 332 static DEVICE_ATTR(fan1_min, S_IRUGO, show_rpm_min, NULL); 333 static DEVICE_ATTR(fan1_max, S_IRUGO, show_rpm_max, NULL); 334 static DEVICE_ATTR(fan1_input, S_IRUGO, show_rpm, NULL); 335 static DEVICE_ATTR(fan1_target, S_IRUGO | S_IWUSR, show_rpm, set_rpm); 336 337 static 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 348 static const struct attribute_group gpio_fan_ctrl_group = { 349 .attrs = gpio_fan_ctrl_attributes, 350 }; 351 352 static 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 384 static 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 395 static ssize_t show_name(struct device *dev, 396 struct device_attribute *attr, char *buf) 397 { 398 return sprintf(buf, "gpio-fan\n"); 399 } 400 401 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); 402 403 static 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 454 err_remove_name: 455 device_remove_file(&pdev->dev, &dev_attr_name); 456 err_free_ctrl: 457 if (fan_data->ctrl) 458 fan_ctrl_free(fan_data); 459 err_free_alarm: 460 if (fan_data->alarm) 461 fan_alarm_free(fan_data); 462 return err; 463 } 464 465 static 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 480 static 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 492 static 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 502 static 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 508 static 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 517 module_platform_driver(gpio_fan_driver); 518 519 MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>"); 520 MODULE_DESCRIPTION("GPIO FAN driver"); 521 MODULE_LICENSE("GPL"); 522 MODULE_ALIAS("platform:gpio-fan"); 523