1 /* 2 * LEDs driver for GPIOs 3 * 4 * Copyright (C) 2007 8D Technologies inc. 5 * Raphael Assenat <raph@8d.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 * 11 */ 12 #include <linux/kernel.h> 13 #include <linux/init.h> 14 #include <linux/platform_device.h> 15 #include <linux/leds.h> 16 #include <linux/workqueue.h> 17 18 #include <asm/gpio.h> 19 20 struct gpio_led_data { 21 struct led_classdev cdev; 22 unsigned gpio; 23 struct work_struct work; 24 u8 new_level; 25 u8 can_sleep; 26 u8 active_low; 27 }; 28 29 static void gpio_led_work(struct work_struct *work) 30 { 31 struct gpio_led_data *led_dat = 32 container_of(work, struct gpio_led_data, work); 33 34 gpio_set_value_cansleep(led_dat->gpio, led_dat->new_level); 35 } 36 37 static void gpio_led_set(struct led_classdev *led_cdev, 38 enum led_brightness value) 39 { 40 struct gpio_led_data *led_dat = 41 container_of(led_cdev, struct gpio_led_data, cdev); 42 int level; 43 44 if (value == LED_OFF) 45 level = 0; 46 else 47 level = 1; 48 49 if (led_dat->active_low) 50 level = !level; 51 52 /* Setting GPIOs with I2C/etc requires a task context, and we don't 53 * seem to have a reliable way to know if we're already in one; so 54 * let's just assume the worst. 55 */ 56 if (led_dat->can_sleep) { 57 led_dat->new_level = level; 58 schedule_work(&led_dat->work); 59 } else 60 gpio_set_value(led_dat->gpio, level); 61 } 62 63 static int gpio_led_probe(struct platform_device *pdev) 64 { 65 struct gpio_led_platform_data *pdata = pdev->dev.platform_data; 66 struct gpio_led *cur_led; 67 struct gpio_led_data *leds_data, *led_dat; 68 int i, ret = 0; 69 70 if (!pdata) 71 return -EBUSY; 72 73 leds_data = kzalloc(sizeof(struct gpio_led_data) * pdata->num_leds, 74 GFP_KERNEL); 75 if (!leds_data) 76 return -ENOMEM; 77 78 for (i = 0; i < pdata->num_leds; i++) { 79 cur_led = &pdata->leds[i]; 80 led_dat = &leds_data[i]; 81 82 ret = gpio_request(cur_led->gpio, cur_led->name); 83 if (ret < 0) 84 goto err; 85 86 led_dat->cdev.name = cur_led->name; 87 led_dat->cdev.default_trigger = cur_led->default_trigger; 88 led_dat->gpio = cur_led->gpio; 89 led_dat->can_sleep = gpio_cansleep(cur_led->gpio); 90 led_dat->active_low = cur_led->active_low; 91 led_dat->cdev.brightness_set = gpio_led_set; 92 led_dat->cdev.brightness = LED_OFF; 93 94 gpio_direction_output(led_dat->gpio, led_dat->active_low); 95 96 INIT_WORK(&led_dat->work, gpio_led_work); 97 98 ret = led_classdev_register(&pdev->dev, &led_dat->cdev); 99 if (ret < 0) { 100 gpio_free(led_dat->gpio); 101 goto err; 102 } 103 } 104 105 platform_set_drvdata(pdev, leds_data); 106 107 return 0; 108 109 err: 110 if (i > 0) { 111 for (i = i - 1; i >= 0; i--) { 112 led_classdev_unregister(&leds_data[i].cdev); 113 cancel_work_sync(&leds_data[i].work); 114 gpio_free(leds_data[i].gpio); 115 } 116 } 117 118 kfree(leds_data); 119 120 return ret; 121 } 122 123 static int __devexit gpio_led_remove(struct platform_device *pdev) 124 { 125 int i; 126 struct gpio_led_platform_data *pdata = pdev->dev.platform_data; 127 struct gpio_led_data *leds_data; 128 129 leds_data = platform_get_drvdata(pdev); 130 131 for (i = 0; i < pdata->num_leds; i++) { 132 led_classdev_unregister(&leds_data[i].cdev); 133 cancel_work_sync(&leds_data[i].work); 134 gpio_free(leds_data[i].gpio); 135 } 136 137 kfree(leds_data); 138 139 return 0; 140 } 141 142 #ifdef CONFIG_PM 143 static int gpio_led_suspend(struct platform_device *pdev, pm_message_t state) 144 { 145 struct gpio_led_platform_data *pdata = pdev->dev.platform_data; 146 struct gpio_led_data *leds_data; 147 int i; 148 149 leds_data = platform_get_drvdata(pdev); 150 151 for (i = 0; i < pdata->num_leds; i++) 152 led_classdev_suspend(&leds_data[i].cdev); 153 154 return 0; 155 } 156 157 static int gpio_led_resume(struct platform_device *pdev) 158 { 159 struct gpio_led_platform_data *pdata = pdev->dev.platform_data; 160 struct gpio_led_data *leds_data; 161 int i; 162 163 leds_data = platform_get_drvdata(pdev); 164 165 for (i = 0; i < pdata->num_leds; i++) 166 led_classdev_resume(&leds_data[i].cdev); 167 168 return 0; 169 } 170 #else 171 #define gpio_led_suspend NULL 172 #define gpio_led_resume NULL 173 #endif 174 175 static struct platform_driver gpio_led_driver = { 176 .probe = gpio_led_probe, 177 .remove = __devexit_p(gpio_led_remove), 178 .suspend = gpio_led_suspend, 179 .resume = gpio_led_resume, 180 .driver = { 181 .name = "leds-gpio", 182 .owner = THIS_MODULE, 183 }, 184 }; 185 186 static int __init gpio_led_init(void) 187 { 188 return platform_driver_register(&gpio_led_driver); 189 } 190 191 static void __exit gpio_led_exit(void) 192 { 193 platform_driver_unregister(&gpio_led_driver); 194 } 195 196 module_init(gpio_led_init); 197 module_exit(gpio_led_exit); 198 199 MODULE_AUTHOR("Raphael Assenat <raph@8d.com>"); 200 MODULE_DESCRIPTION("GPIO LED driver"); 201 MODULE_LICENSE("GPL"); 202