Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
leds-lt3593.c
Go to the documentation of this file.
1 /*
2  * LEDs driver for LT3593 controllers
3  *
4  * See the datasheet at http://cds.linear.com/docs/Datasheet/3593f.pdf
5  *
6  * Copyright (c) 2009 Daniel Mack <[email protected]>
7  *
8  * Based on leds-gpio.c,
9  *
10  * Copyright (C) 2007 8D Technologies inc.
11  * Raphael Assenat <[email protected]>
12  * Copyright (C) 2008 Freescale Semiconductor, Inc.
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 version 2 as
16  * published by the Free Software Foundation.
17  */
18 
19 #include <linux/kernel.h>
20 #include <linux/init.h>
21 #include <linux/platform_device.h>
22 #include <linux/leds.h>
23 #include <linux/workqueue.h>
24 #include <linux/delay.h>
25 #include <linux/gpio.h>
26 #include <linux/slab.h>
27 #include <linux/module.h>
28 
31  unsigned gpio;
32  struct work_struct work;
34 };
35 
36 static void lt3593_led_work(struct work_struct *work)
37 {
38  int pulses;
39  struct lt3593_led_data *led_dat =
40  container_of(work, struct lt3593_led_data, work);
41 
42  /*
43  * The LT3593 resets its internal current level register to the maximum
44  * level on the first falling edge on the control pin. Each following
45  * falling edge decreases the current level by 625uA. Up to 32 pulses
46  * can be sent, so the maximum power reduction is 20mA.
47  * After a timeout of 128us, the value is taken from the register and
48  * applied is to the output driver.
49  */
50 
51  if (led_dat->new_level == 0) {
52  gpio_set_value_cansleep(led_dat->gpio, 0);
53  return;
54  }
55 
56  pulses = 32 - (led_dat->new_level * 32) / 255;
57 
58  if (pulses == 0) {
59  gpio_set_value_cansleep(led_dat->gpio, 0);
60  mdelay(1);
61  gpio_set_value_cansleep(led_dat->gpio, 1);
62  return;
63  }
64 
65  gpio_set_value_cansleep(led_dat->gpio, 1);
66 
67  while (pulses--) {
68  gpio_set_value_cansleep(led_dat->gpio, 0);
69  udelay(1);
70  gpio_set_value_cansleep(led_dat->gpio, 1);
71  udelay(1);
72  }
73 }
74 
75 static void lt3593_led_set(struct led_classdev *led_cdev,
76  enum led_brightness value)
77 {
78  struct lt3593_led_data *led_dat =
79  container_of(led_cdev, struct lt3593_led_data, cdev);
80 
81  led_dat->new_level = value;
82  schedule_work(&led_dat->work);
83 }
84 
85 static int __devinit create_lt3593_led(const struct gpio_led *template,
86  struct lt3593_led_data *led_dat, struct device *parent)
87 {
88  int ret, state;
89 
90  /* skip leds on GPIOs that aren't available */
91  if (!gpio_is_valid(template->gpio)) {
92  printk(KERN_INFO "%s: skipping unavailable LT3593 LED at gpio %d (%s)\n",
93  KBUILD_MODNAME, template->gpio, template->name);
94  return 0;
95  }
96 
97  ret = gpio_request(template->gpio, template->name);
98  if (ret < 0)
99  return ret;
100 
101  led_dat->cdev.name = template->name;
102  led_dat->cdev.default_trigger = template->default_trigger;
103  led_dat->gpio = template->gpio;
104 
105  led_dat->cdev.brightness_set = lt3593_led_set;
106 
107  state = (template->default_state == LEDS_GPIO_DEFSTATE_ON);
108  led_dat->cdev.brightness = state ? LED_FULL : LED_OFF;
109 
110  if (!template->retain_state_suspended)
111  led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;
112 
113  ret = gpio_direction_output(led_dat->gpio, state);
114  if (ret < 0)
115  goto err;
116 
117  INIT_WORK(&led_dat->work, lt3593_led_work);
118 
119  ret = led_classdev_register(parent, &led_dat->cdev);
120  if (ret < 0)
121  goto err;
122 
123  printk(KERN_INFO "%s: registered LT3593 LED '%s' at GPIO %d\n",
124  KBUILD_MODNAME, template->name, template->gpio);
125 
126  return 0;
127 
128 err:
129  gpio_free(led_dat->gpio);
130  return ret;
131 }
132 
133 static void delete_lt3593_led(struct lt3593_led_data *led)
134 {
135  if (!gpio_is_valid(led->gpio))
136  return;
137 
139  cancel_work_sync(&led->work);
140  gpio_free(led->gpio);
141 }
142 
143 static int __devinit lt3593_led_probe(struct platform_device *pdev)
144 {
145  struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
146  struct lt3593_led_data *leds_data;
147  int i, ret = 0;
148 
149  if (!pdata)
150  return -EBUSY;
151 
152  leds_data = devm_kzalloc(&pdev->dev,
153  sizeof(struct lt3593_led_data) * pdata->num_leds,
154  GFP_KERNEL);
155  if (!leds_data)
156  return -ENOMEM;
157 
158  for (i = 0; i < pdata->num_leds; i++) {
159  ret = create_lt3593_led(&pdata->leds[i], &leds_data[i],
160  &pdev->dev);
161  if (ret < 0)
162  goto err;
163  }
164 
165  platform_set_drvdata(pdev, leds_data);
166 
167  return 0;
168 
169 err:
170  for (i = i - 1; i >= 0; i--)
171  delete_lt3593_led(&leds_data[i]);
172 
173  return ret;
174 }
175 
176 static int __devexit lt3593_led_remove(struct platform_device *pdev)
177 {
178  int i;
179  struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
180  struct lt3593_led_data *leds_data;
181 
182  leds_data = platform_get_drvdata(pdev);
183 
184  for (i = 0; i < pdata->num_leds; i++)
185  delete_lt3593_led(&leds_data[i]);
186 
187  return 0;
188 }
189 
190 static struct platform_driver lt3593_led_driver = {
191  .probe = lt3593_led_probe,
192  .remove = __devexit_p(lt3593_led_remove),
193  .driver = {
194  .name = "leds-lt3593",
195  .owner = THIS_MODULE,
196  },
197 };
198 
199 module_platform_driver(lt3593_led_driver);
200 
201 MODULE_AUTHOR("Daniel Mack <[email protected]>");
202 MODULE_DESCRIPTION("LED driver for LT3593 controllers");
203 MODULE_LICENSE("GPL");
204 MODULE_ALIAS("platform:leds-lt3593");