Commit | Line | Data |
---|---|---|
7fdcef8a | 1 | /* |
a59ce658 | 2 | * LEDs driver for Freescale MC13783/MC13892/MC34708 |
7fdcef8a PR |
3 | * |
4 | * Copyright (C) 2010 Philippe Rétornaz | |
5 | * | |
6 | * Based on leds-da903x: | |
7 | * Copyright (C) 2008 Compulab, Ltd. | |
8 | * Mike Rapoport <mike@compulab.co.il> | |
9 | * | |
10 | * Copyright (C) 2006-2008 Marvell International Ltd. | |
11 | * Eric Miao <eric.miao@marvell.com> | |
12 | * | |
13 | * This program is free software; you can redistribute it and/or modify | |
14 | * it under the terms of the GNU General Public License version 2 as | |
15 | * published by the Free Software Foundation. | |
16 | */ | |
17 | ||
18 | #include <linux/module.h> | |
19 | #include <linux/kernel.h> | |
7fdcef8a PR |
20 | #include <linux/platform_device.h> |
21 | #include <linux/leds.h> | |
25c6579f | 22 | #include <linux/of.h> |
7fdcef8a | 23 | #include <linux/workqueue.h> |
f3ca0782 | 24 | #include <linux/mfd/mc13xxx.h> |
7fdcef8a | 25 | |
9d263813 AS |
26 | struct mc13xxx_led_devtype { |
27 | int led_min; | |
28 | int led_max; | |
29 | int num_regs; | |
a59ce658 | 30 | u32 ledctrl_base; |
9d263813 AS |
31 | }; |
32 | ||
33 | struct mc13xxx_led { | |
7fdcef8a PR |
34 | struct led_classdev cdev; |
35 | struct work_struct work; | |
7fdcef8a PR |
36 | enum led_brightness new_brightness; |
37 | int id; | |
a59ce658 | 38 | struct mc13xxx_leds *leds; |
7fdcef8a PR |
39 | }; |
40 | ||
9d263813 | 41 | struct mc13xxx_leds { |
a59ce658 | 42 | struct mc13xxx *master; |
9d263813 AS |
43 | struct mc13xxx_led_devtype *devtype; |
44 | int num_leds; | |
25c6579f | 45 | struct mc13xxx_led *led; |
9d263813 AS |
46 | }; |
47 | ||
677d13f2 AS |
48 | static unsigned int mc13xxx_max_brightness(int id) |
49 | { | |
50 | if (id >= MC13783_LED_MD && id <= MC13783_LED_KP) | |
51 | return 0x0f; | |
52 | else if (id >= MC13783_LED_R1 && id <= MC13783_LED_B3) | |
53 | return 0x1f; | |
54 | ||
55 | return 0x3f; | |
56 | } | |
57 | ||
9d263813 | 58 | static void mc13xxx_led_work(struct work_struct *work) |
7fdcef8a | 59 | { |
9d263813 | 60 | struct mc13xxx_led *led = container_of(work, struct mc13xxx_led, work); |
a59ce658 | 61 | struct mc13xxx_leds *leds = led->leds; |
677d13f2 | 62 | unsigned int reg, bank, off, shift; |
7fdcef8a PR |
63 | |
64 | switch (led->id) { | |
65 | case MC13783_LED_MD: | |
7fdcef8a | 66 | case MC13783_LED_AD: |
7fdcef8a | 67 | case MC13783_LED_KP: |
a59ce658 AS |
68 | reg = 2; |
69 | shift = 9 + (led->id - MC13783_LED_MD) * 4; | |
7fdcef8a PR |
70 | break; |
71 | case MC13783_LED_R1: | |
72 | case MC13783_LED_G1: | |
73 | case MC13783_LED_B1: | |
74 | case MC13783_LED_R2: | |
75 | case MC13783_LED_G2: | |
76 | case MC13783_LED_B2: | |
77 | case MC13783_LED_R3: | |
78 | case MC13783_LED_G3: | |
79 | case MC13783_LED_B3: | |
80 | off = led->id - MC13783_LED_R1; | |
9d263813 | 81 | bank = off / 3; |
a59ce658 | 82 | reg = 3 + bank; |
9d263813 | 83 | shift = (off - bank * 3) * 5 + 6; |
7fdcef8a | 84 | break; |
ae6cdb03 | 85 | case MC13892_LED_MD: |
ae6cdb03 | 86 | case MC13892_LED_AD: |
ae6cdb03 | 87 | case MC13892_LED_KP: |
a59ce658 AS |
88 | reg = (led->id - MC13892_LED_MD) / 2; |
89 | shift = 3 + (led->id - MC13892_LED_MD) * 12; | |
ae6cdb03 AS |
90 | break; |
91 | case MC13892_LED_R: | |
92 | case MC13892_LED_G: | |
93 | case MC13892_LED_B: | |
94 | off = led->id - MC13892_LED_R; | |
95 | bank = off / 2; | |
a59ce658 | 96 | reg = 2 + bank; |
ae6cdb03 | 97 | shift = (off - bank * 2) * 12 + 3; |
ae6cdb03 | 98 | break; |
a59ce658 AS |
99 | case MC34708_LED_R: |
100 | case MC34708_LED_G: | |
101 | reg = 0; | |
102 | shift = 3 + (led->id - MC34708_LED_R) * 12; | |
a59ce658 | 103 | break; |
9d263813 AS |
104 | default: |
105 | BUG(); | |
7fdcef8a PR |
106 | } |
107 | ||
a59ce658 | 108 | mc13xxx_reg_rmw(leds->master, leds->devtype->ledctrl_base + reg, |
677d13f2 AS |
109 | mc13xxx_max_brightness(led->id) << shift, |
110 | led->new_brightness << shift); | |
7fdcef8a PR |
111 | } |
112 | ||
9d263813 AS |
113 | static void mc13xxx_led_set(struct led_classdev *led_cdev, |
114 | enum led_brightness value) | |
7fdcef8a | 115 | { |
9d263813 AS |
116 | struct mc13xxx_led *led = |
117 | container_of(led_cdev, struct mc13xxx_led, cdev); | |
7fdcef8a | 118 | |
7fdcef8a PR |
119 | led->new_brightness = value; |
120 | schedule_work(&led->work); | |
121 | } | |
122 | ||
25c6579f AS |
123 | #ifdef CONFIG_OF |
124 | static struct mc13xxx_leds_platform_data __init *mc13xxx_led_probe_dt( | |
125 | struct platform_device *pdev) | |
126 | { | |
127 | struct mc13xxx_leds *leds = platform_get_drvdata(pdev); | |
128 | struct mc13xxx_leds_platform_data *pdata; | |
129 | struct device_node *parent, *child; | |
130 | struct device *dev = &pdev->dev; | |
131 | int i = 0, ret = -ENODATA; | |
132 | ||
133 | pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); | |
134 | if (!pdata) | |
135 | return ERR_PTR(-ENOMEM); | |
136 | ||
137 | of_node_get(dev->parent->of_node); | |
138 | ||
139 | parent = of_find_node_by_name(dev->parent->of_node, "leds"); | |
140 | if (!parent) | |
141 | goto out_node_put; | |
142 | ||
143 | ret = of_property_read_u32_array(parent, "led-control", | |
144 | pdata->led_control, | |
145 | leds->devtype->num_regs); | |
146 | if (ret) | |
147 | goto out_node_put; | |
148 | ||
149 | pdata->num_leds = of_get_child_count(parent); | |
150 | ||
151 | pdata->led = devm_kzalloc(dev, pdata->num_leds * sizeof(*pdata->led), | |
152 | GFP_KERNEL); | |
153 | if (!pdata->led) { | |
154 | ret = -ENOMEM; | |
155 | goto out_node_put; | |
156 | } | |
157 | ||
158 | for_each_child_of_node(parent, child) { | |
159 | const char *str; | |
160 | u32 tmp; | |
161 | ||
162 | if (of_property_read_u32(child, "reg", &tmp)) | |
163 | continue; | |
164 | pdata->led[i].id = leds->devtype->led_min + tmp; | |
165 | ||
166 | if (!of_property_read_string(child, "label", &str)) | |
167 | pdata->led[i].name = str; | |
168 | if (!of_property_read_string(child, "linux,default-trigger", | |
169 | &str)) | |
170 | pdata->led[i].default_trigger = str; | |
171 | ||
172 | i++; | |
173 | } | |
174 | ||
175 | pdata->num_leds = i; | |
176 | ret = i > 0 ? 0 : -ENODATA; | |
177 | ||
178 | out_node_put: | |
179 | of_node_put(parent); | |
180 | ||
181 | return ret ? ERR_PTR(ret) : pdata; | |
182 | } | |
183 | #else | |
184 | static inline struct mc13xxx_leds_platform_data __init *mc13xxx_led_probe_dt( | |
185 | struct platform_device *pdev) | |
186 | { | |
187 | return ERR_PTR(-ENOSYS); | |
188 | } | |
189 | #endif | |
190 | ||
9d263813 | 191 | static int __init mc13xxx_led_probe(struct platform_device *pdev) |
7fdcef8a | 192 | { |
a59ce658 AS |
193 | struct device *dev = &pdev->dev; |
194 | struct mc13xxx_leds_platform_data *pdata = dev_get_platdata(dev); | |
195 | struct mc13xxx *mcdev = dev_get_drvdata(dev->parent); | |
9d263813 AS |
196 | struct mc13xxx_led_devtype *devtype = |
197 | (struct mc13xxx_led_devtype *)pdev->id_entry->driver_data; | |
198 | struct mc13xxx_leds *leds; | |
25c6579f | 199 | int i, id, ret = -ENODATA; |
a59ce658 | 200 | u32 init_led = 0; |
9d263813 | 201 | |
25c6579f | 202 | leds = devm_kzalloc(dev, sizeof(*leds), GFP_KERNEL); |
9d263813 | 203 | if (!leds) |
7fdcef8a | 204 | return -ENOMEM; |
9d263813 AS |
205 | |
206 | leds->devtype = devtype; | |
a59ce658 | 207 | leds->master = mcdev; |
9d263813 AS |
208 | platform_set_drvdata(pdev, leds); |
209 | ||
25c6579f AS |
210 | if (dev->parent->of_node) { |
211 | pdata = mc13xxx_led_probe_dt(pdev); | |
212 | if (IS_ERR(pdata)) | |
213 | return PTR_ERR(pdata); | |
214 | } else if (!pdata) | |
215 | return -ENODATA; | |
216 | ||
217 | leds->num_leds = pdata->num_leds; | |
218 | ||
219 | if ((leds->num_leds < 1) || | |
220 | (leds->num_leds > (devtype->led_max - devtype->led_min + 1))) { | |
221 | dev_err(dev, "Invalid LED count %d\n", leds->num_leds); | |
222 | return -EINVAL; | |
223 | } | |
224 | ||
225 | leds->led = devm_kzalloc(dev, leds->num_leds * sizeof(*leds->led), | |
226 | GFP_KERNEL); | |
227 | if (!leds->led) | |
228 | return -ENOMEM; | |
229 | ||
9d263813 | 230 | for (i = 0; i < devtype->num_regs; i++) { |
a59ce658 AS |
231 | ret = mc13xxx_reg_write(mcdev, leds->devtype->ledctrl_base + i, |
232 | pdata->led_control[i]); | |
9d263813 | 233 | if (ret) |
3df22c06 | 234 | return ret; |
7fdcef8a PR |
235 | } |
236 | ||
25c6579f | 237 | for (i = 0; i < leds->num_leds; i++) { |
9d263813 | 238 | const char *name, *trig; |
7fdcef8a | 239 | |
9d263813 AS |
240 | ret = -EINVAL; |
241 | ||
242 | id = pdata->led[i].id; | |
243 | name = pdata->led[i].name; | |
244 | trig = pdata->led[i].default_trigger; | |
9d263813 AS |
245 | |
246 | if ((id > devtype->led_max) || (id < devtype->led_min)) { | |
a59ce658 | 247 | dev_err(dev, "Invalid ID %i\n", id); |
9d263813 | 248 | break; |
7fdcef8a PR |
249 | } |
250 | ||
9d263813 | 251 | if (init_led & (1 << id)) { |
a59ce658 | 252 | dev_warn(dev, "LED %i already initialized\n", id); |
9d263813 | 253 | break; |
7fdcef8a PR |
254 | } |
255 | ||
9d263813 AS |
256 | init_led |= 1 << id; |
257 | leds->led[i].id = id; | |
a59ce658 | 258 | leds->led[i].leds = leds; |
9d263813 AS |
259 | leds->led[i].cdev.name = name; |
260 | leds->led[i].cdev.default_trigger = trig; | |
02e9e11e | 261 | leds->led[i].cdev.flags = LED_CORE_SUSPENDRESUME; |
9d263813 | 262 | leds->led[i].cdev.brightness_set = mc13xxx_led_set; |
677d13f2 | 263 | leds->led[i].cdev.max_brightness = mc13xxx_max_brightness(id); |
7fdcef8a | 264 | |
9d263813 | 265 | INIT_WORK(&leds->led[i].work, mc13xxx_led_work); |
7fdcef8a | 266 | |
a59ce658 | 267 | ret = led_classdev_register(dev->parent, &leds->led[i].cdev); |
7fdcef8a | 268 | if (ret) { |
a59ce658 | 269 | dev_err(dev, "Failed to register LED %i\n", id); |
9d263813 | 270 | break; |
7fdcef8a PR |
271 | } |
272 | } | |
273 | ||
9d263813 AS |
274 | if (ret) |
275 | while (--i >= 0) { | |
276 | led_classdev_unregister(&leds->led[i].cdev); | |
277 | cancel_work_sync(&leds->led[i].work); | |
278 | } | |
7fdcef8a | 279 | |
7fdcef8a PR |
280 | return ret; |
281 | } | |
282 | ||
9d263813 | 283 | static int mc13xxx_led_remove(struct platform_device *pdev) |
7fdcef8a | 284 | { |
9d263813 | 285 | struct mc13xxx_leds *leds = platform_get_drvdata(pdev); |
7fdcef8a PR |
286 | int i; |
287 | ||
9d263813 AS |
288 | for (i = 0; i < leds->num_leds; i++) { |
289 | led_classdev_unregister(&leds->led[i].cdev); | |
290 | cancel_work_sync(&leds->led[i].work); | |
7fdcef8a PR |
291 | } |
292 | ||
7fdcef8a PR |
293 | return 0; |
294 | } | |
295 | ||
9d263813 AS |
296 | static const struct mc13xxx_led_devtype mc13783_led_devtype = { |
297 | .led_min = MC13783_LED_MD, | |
298 | .led_max = MC13783_LED_B3, | |
299 | .num_regs = 6, | |
a59ce658 | 300 | .ledctrl_base = 51, |
9d263813 AS |
301 | }; |
302 | ||
ae6cdb03 AS |
303 | static const struct mc13xxx_led_devtype mc13892_led_devtype = { |
304 | .led_min = MC13892_LED_MD, | |
305 | .led_max = MC13892_LED_B, | |
306 | .num_regs = 4, | |
a59ce658 AS |
307 | .ledctrl_base = 51, |
308 | }; | |
309 | ||
310 | static const struct mc13xxx_led_devtype mc34708_led_devtype = { | |
311 | .led_min = MC34708_LED_R, | |
312 | .led_max = MC34708_LED_G, | |
313 | .num_regs = 1, | |
314 | .ledctrl_base = 54, | |
ae6cdb03 AS |
315 | }; |
316 | ||
9d263813 AS |
317 | static const struct platform_device_id mc13xxx_led_id_table[] = { |
318 | { "mc13783-led", (kernel_ulong_t)&mc13783_led_devtype, }, | |
ae6cdb03 | 319 | { "mc13892-led", (kernel_ulong_t)&mc13892_led_devtype, }, |
a59ce658 | 320 | { "mc34708-led", (kernel_ulong_t)&mc34708_led_devtype, }, |
9d263813 AS |
321 | { } |
322 | }; | |
323 | MODULE_DEVICE_TABLE(platform, mc13xxx_led_id_table); | |
324 | ||
325 | static struct platform_driver mc13xxx_led_driver = { | |
7fdcef8a | 326 | .driver = { |
9d263813 | 327 | .name = "mc13xxx-led", |
7fdcef8a | 328 | }, |
9d263813 AS |
329 | .remove = mc13xxx_led_remove, |
330 | .id_table = mc13xxx_led_id_table, | |
7fdcef8a | 331 | }; |
9d263813 | 332 | module_platform_driver_probe(mc13xxx_led_driver, mc13xxx_led_probe); |
7fdcef8a | 333 | |
9d263813 | 334 | MODULE_DESCRIPTION("LEDs driver for Freescale MC13XXX PMIC"); |
7fdcef8a PR |
335 | MODULE_AUTHOR("Philippe Retornaz <philippe.retornaz@epfl.ch>"); |
336 | MODULE_LICENSE("GPL"); |