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