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