Commit | Line | Data |
---|---|---|
49c34b8e JA |
1 | /* |
2 | * LED Flash class driver for the AAT1290 | |
3 | * 1.5A Step-Up Current Regulator for Flash LEDs | |
4 | * | |
5 | * Copyright (C) 2015, Samsung Electronics Co., Ltd. | |
6 | * Author: Jacek Anaszewski <j.anaszewski@samsung.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License | |
10 | * version 2 as published by the Free Software Foundation. | |
11 | */ | |
12 | ||
13 | #include <linux/delay.h> | |
14 | #include <linux/gpio/consumer.h> | |
15 | #include <linux/led-class-flash.h> | |
16 | #include <linux/leds.h> | |
17 | #include <linux/module.h> | |
18 | #include <linux/mutex.h> | |
19 | #include <linux/of.h> | |
ac69b903 | 20 | #include <linux/pinctrl/consumer.h> |
49c34b8e JA |
21 | #include <linux/platform_device.h> |
22 | #include <linux/slab.h> | |
ac69b903 | 23 | #include <media/v4l2-flash-led-class.h> |
49c34b8e JA |
24 | |
25 | #define AAT1290_MOVIE_MODE_CURRENT_ADDR 17 | |
26 | #define AAT1290_MAX_MM_CURR_PERCENT_0 16 | |
27 | #define AAT1290_MAX_MM_CURR_PERCENT_100 1 | |
28 | ||
29 | #define AAT1290_FLASH_SAFETY_TIMER_ADDR 18 | |
30 | ||
31 | #define AAT1290_MOVIE_MODE_CONFIG_ADDR 19 | |
32 | #define AAT1290_MOVIE_MODE_OFF 1 | |
33 | #define AAT1290_MOVIE_MODE_ON 3 | |
34 | ||
35 | #define AAT1290_MM_CURRENT_RATIO_ADDR 20 | |
36 | #define AAT1290_MM_TO_FL_1_92 1 | |
37 | ||
38 | #define AAT1290_MM_TO_FL_RATIO 1000 / 1920 | |
39 | #define AAT1290_MAX_MM_CURRENT(fl_max) (fl_max * AAT1290_MM_TO_FL_RATIO) | |
40 | ||
41 | #define AAT1290_LATCH_TIME_MIN_US 500 | |
42 | #define AAT1290_LATCH_TIME_MAX_US 1000 | |
43 | #define AAT1290_EN_SET_TICK_TIME_US 1 | |
44 | #define AAT1290_FLEN_OFF_DELAY_TIME_US 10 | |
45 | #define AAT1290_FLASH_TM_NUM_LEVELS 16 | |
46 | #define AAT1290_MM_CURRENT_SCALE_SIZE 15 | |
47 | ||
48 | ||
49 | struct aat1290_led_config_data { | |
50 | /* maximum LED current in movie mode */ | |
51 | u32 max_mm_current; | |
52 | /* maximum LED current in flash mode */ | |
53 | u32 max_flash_current; | |
54 | /* maximum flash timeout */ | |
55 | u32 max_flash_tm; | |
ac69b903 JA |
56 | /* external strobe capability */ |
57 | bool has_external_strobe; | |
49c34b8e JA |
58 | /* max LED brightness level */ |
59 | enum led_brightness max_brightness; | |
60 | }; | |
61 | ||
62 | struct aat1290_led { | |
63 | /* platform device data */ | |
64 | struct platform_device *pdev; | |
65 | /* secures access to the device */ | |
66 | struct mutex lock; | |
67 | ||
68 | /* corresponding LED Flash class device */ | |
69 | struct led_classdev_flash fled_cdev; | |
ac69b903 JA |
70 | /* V4L2 Flash device */ |
71 | struct v4l2_flash *v4l2_flash; | |
49c34b8e JA |
72 | |
73 | /* FLEN pin */ | |
74 | struct gpio_desc *gpio_fl_en; | |
75 | /* EN|SET pin */ | |
76 | struct gpio_desc *gpio_en_set; | |
77 | /* movie mode current scale */ | |
78 | int *mm_current_scale; | |
79 | /* device mode */ | |
80 | bool movie_mode; | |
81 | ||
82 | /* brightness cache */ | |
83 | unsigned int torch_brightness; | |
49c34b8e JA |
84 | }; |
85 | ||
86 | static struct aat1290_led *fled_cdev_to_led( | |
87 | struct led_classdev_flash *fled_cdev) | |
88 | { | |
89 | return container_of(fled_cdev, struct aat1290_led, fled_cdev); | |
90 | } | |
91 | ||
269e92da JA |
92 | static struct led_classdev_flash *led_cdev_to_fled_cdev( |
93 | struct led_classdev *led_cdev) | |
94 | { | |
95 | return container_of(led_cdev, struct led_classdev_flash, led_cdev); | |
96 | } | |
97 | ||
49c34b8e JA |
98 | static void aat1290_as2cwire_write(struct aat1290_led *led, int addr, int value) |
99 | { | |
100 | int i; | |
101 | ||
102 | gpiod_direction_output(led->gpio_fl_en, 0); | |
103 | gpiod_direction_output(led->gpio_en_set, 0); | |
104 | ||
105 | udelay(AAT1290_FLEN_OFF_DELAY_TIME_US); | |
106 | ||
107 | /* write address */ | |
108 | for (i = 0; i < addr; ++i) { | |
109 | udelay(AAT1290_EN_SET_TICK_TIME_US); | |
110 | gpiod_direction_output(led->gpio_en_set, 0); | |
111 | udelay(AAT1290_EN_SET_TICK_TIME_US); | |
112 | gpiod_direction_output(led->gpio_en_set, 1); | |
113 | } | |
114 | ||
115 | usleep_range(AAT1290_LATCH_TIME_MIN_US, AAT1290_LATCH_TIME_MAX_US); | |
116 | ||
117 | /* write data */ | |
118 | for (i = 0; i < value; ++i) { | |
119 | udelay(AAT1290_EN_SET_TICK_TIME_US); | |
120 | gpiod_direction_output(led->gpio_en_set, 0); | |
121 | udelay(AAT1290_EN_SET_TICK_TIME_US); | |
122 | gpiod_direction_output(led->gpio_en_set, 1); | |
123 | } | |
124 | ||
125 | usleep_range(AAT1290_LATCH_TIME_MIN_US, AAT1290_LATCH_TIME_MAX_US); | |
126 | } | |
127 | ||
128 | static void aat1290_set_flash_safety_timer(struct aat1290_led *led, | |
129 | unsigned int micro_sec) | |
130 | { | |
131 | struct led_classdev_flash *fled_cdev = &led->fled_cdev; | |
132 | struct led_flash_setting *flash_tm = &fled_cdev->timeout; | |
133 | int flash_tm_reg = AAT1290_FLASH_TM_NUM_LEVELS - | |
134 | (micro_sec / flash_tm->step) + 1; | |
135 | ||
136 | aat1290_as2cwire_write(led, AAT1290_FLASH_SAFETY_TIMER_ADDR, | |
137 | flash_tm_reg); | |
138 | } | |
139 | ||
269e92da JA |
140 | /* LED subsystem callbacks */ |
141 | ||
142 | static int aat1290_led_brightness_set(struct led_classdev *led_cdev, | |
49c34b8e JA |
143 | enum led_brightness brightness) |
144 | { | |
269e92da JA |
145 | struct led_classdev_flash *fled_cdev = led_cdev_to_fled_cdev(led_cdev); |
146 | struct aat1290_led *led = fled_cdev_to_led(fled_cdev); | |
147 | ||
49c34b8e JA |
148 | mutex_lock(&led->lock); |
149 | ||
150 | if (brightness == 0) { | |
151 | gpiod_direction_output(led->gpio_fl_en, 0); | |
152 | gpiod_direction_output(led->gpio_en_set, 0); | |
153 | led->movie_mode = false; | |
154 | } else { | |
155 | if (!led->movie_mode) { | |
156 | aat1290_as2cwire_write(led, | |
157 | AAT1290_MM_CURRENT_RATIO_ADDR, | |
158 | AAT1290_MM_TO_FL_1_92); | |
159 | led->movie_mode = true; | |
160 | } | |
161 | ||
162 | aat1290_as2cwire_write(led, AAT1290_MOVIE_MODE_CURRENT_ADDR, | |
163 | AAT1290_MAX_MM_CURR_PERCENT_0 - brightness); | |
164 | aat1290_as2cwire_write(led, AAT1290_MOVIE_MODE_CONFIG_ADDR, | |
165 | AAT1290_MOVIE_MODE_ON); | |
166 | } | |
167 | ||
168 | mutex_unlock(&led->lock); | |
49c34b8e JA |
169 | |
170 | return 0; | |
171 | } | |
172 | ||
173 | static int aat1290_led_flash_strobe_set(struct led_classdev_flash *fled_cdev, | |
174 | bool state) | |
175 | ||
176 | { | |
177 | struct aat1290_led *led = fled_cdev_to_led(fled_cdev); | |
178 | struct led_classdev *led_cdev = &fled_cdev->led_cdev; | |
179 | struct led_flash_setting *timeout = &fled_cdev->timeout; | |
180 | ||
181 | mutex_lock(&led->lock); | |
182 | ||
183 | if (state) { | |
184 | aat1290_set_flash_safety_timer(led, timeout->val); | |
185 | gpiod_direction_output(led->gpio_fl_en, 1); | |
186 | } else { | |
187 | gpiod_direction_output(led->gpio_fl_en, 0); | |
188 | gpiod_direction_output(led->gpio_en_set, 0); | |
189 | } | |
190 | ||
191 | /* | |
192 | * To reenter movie mode after a flash event the part must be cycled | |
193 | * off and back on to reset the movie mode and reprogrammed via the | |
194 | * AS2Cwire. Therefore the brightness and movie_mode properties needs | |
195 | * to be updated here to reflect the actual state. | |
196 | */ | |
197 | led_cdev->brightness = 0; | |
198 | led->movie_mode = false; | |
199 | ||
200 | mutex_unlock(&led->lock); | |
201 | ||
202 | return 0; | |
203 | } | |
204 | ||
205 | static int aat1290_led_flash_timeout_set(struct led_classdev_flash *fled_cdev, | |
206 | u32 timeout) | |
207 | { | |
208 | /* | |
209 | * Don't do anything - flash timeout is cached in the led-class-flash | |
210 | * core and will be applied in the strobe_set op, as writing the | |
211 | * safety timer register spuriously turns the torch mode on. | |
212 | */ | |
213 | ||
214 | return 0; | |
215 | } | |
216 | ||
217 | static int aat1290_led_parse_dt(struct aat1290_led *led, | |
ac69b903 JA |
218 | struct aat1290_led_config_data *cfg, |
219 | struct device_node **sub_node) | |
49c34b8e JA |
220 | { |
221 | struct led_classdev *led_cdev = &led->fled_cdev.led_cdev; | |
222 | struct device *dev = &led->pdev->dev; | |
223 | struct device_node *child_node; | |
ac69b903 JA |
224 | #if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS) |
225 | struct pinctrl *pinctrl; | |
226 | #endif | |
49c34b8e JA |
227 | int ret = 0; |
228 | ||
8a687719 | 229 | led->gpio_fl_en = devm_gpiod_get(dev, "flen", GPIOD_ASIS); |
49c34b8e JA |
230 | if (IS_ERR(led->gpio_fl_en)) { |
231 | ret = PTR_ERR(led->gpio_fl_en); | |
232 | dev_err(dev, "Unable to claim gpio \"flen\".\n"); | |
233 | return ret; | |
234 | } | |
235 | ||
8a687719 | 236 | led->gpio_en_set = devm_gpiod_get(dev, "enset", GPIOD_ASIS); |
49c34b8e JA |
237 | if (IS_ERR(led->gpio_en_set)) { |
238 | ret = PTR_ERR(led->gpio_en_set); | |
239 | dev_err(dev, "Unable to claim gpio \"enset\".\n"); | |
240 | return ret; | |
241 | } | |
242 | ||
ac69b903 JA |
243 | #if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS) |
244 | pinctrl = devm_pinctrl_get_select_default(&led->pdev->dev); | |
245 | if (IS_ERR(pinctrl)) { | |
246 | cfg->has_external_strobe = false; | |
247 | dev_info(dev, | |
248 | "No support for external strobe detected.\n"); | |
249 | } else { | |
250 | cfg->has_external_strobe = true; | |
251 | } | |
252 | #endif | |
253 | ||
49c34b8e JA |
254 | child_node = of_get_next_available_child(dev->of_node, NULL); |
255 | if (!child_node) { | |
256 | dev_err(dev, "No DT child node found for connected LED.\n"); | |
257 | return -EINVAL; | |
258 | } | |
259 | ||
260 | led_cdev->name = of_get_property(child_node, "label", NULL) ? : | |
261 | child_node->name; | |
262 | ||
263 | ret = of_property_read_u32(child_node, "led-max-microamp", | |
264 | &cfg->max_mm_current); | |
265 | /* | |
266 | * led-max-microamp will default to 1/20 of flash-max-microamp | |
267 | * in case it is missing. | |
268 | */ | |
269 | if (ret < 0) | |
270 | dev_warn(dev, | |
271 | "led-max-microamp DT property missing\n"); | |
272 | ||
273 | ret = of_property_read_u32(child_node, "flash-max-microamp", | |
274 | &cfg->max_flash_current); | |
275 | if (ret < 0) { | |
276 | dev_err(dev, | |
277 | "flash-max-microamp DT property missing\n"); | |
0c24199c | 278 | goto err_parse_dt; |
49c34b8e JA |
279 | } |
280 | ||
281 | ret = of_property_read_u32(child_node, "flash-max-timeout-us", | |
282 | &cfg->max_flash_tm); | |
283 | if (ret < 0) { | |
284 | dev_err(dev, | |
285 | "flash-max-timeout-us DT property missing\n"); | |
0c24199c | 286 | goto err_parse_dt; |
49c34b8e JA |
287 | } |
288 | ||
ac69b903 JA |
289 | *sub_node = child_node; |
290 | ||
0c24199c JA |
291 | err_parse_dt: |
292 | of_node_put(child_node); | |
293 | ||
49c34b8e JA |
294 | return ret; |
295 | } | |
296 | ||
297 | static void aat1290_led_validate_mm_current(struct aat1290_led *led, | |
298 | struct aat1290_led_config_data *cfg) | |
299 | { | |
300 | int i, b = 0, e = AAT1290_MM_CURRENT_SCALE_SIZE; | |
301 | ||
302 | while (e - b > 1) { | |
303 | i = b + (e - b) / 2; | |
304 | if (cfg->max_mm_current < led->mm_current_scale[i]) | |
305 | e = i; | |
306 | else | |
307 | b = i; | |
308 | } | |
309 | ||
310 | cfg->max_mm_current = led->mm_current_scale[b]; | |
311 | cfg->max_brightness = b + 1; | |
312 | } | |
313 | ||
305c324f | 314 | static int init_mm_current_scale(struct aat1290_led *led, |
49c34b8e JA |
315 | struct aat1290_led_config_data *cfg) |
316 | { | |
317 | int max_mm_current_percent[] = { 20, 22, 25, 28, 32, 36, 40, 45, 50, 56, | |
318 | 63, 71, 79, 89, 100 }; | |
319 | int i, max_mm_current = | |
320 | AAT1290_MAX_MM_CURRENT(cfg->max_flash_current); | |
321 | ||
ac69b903 JA |
322 | led->mm_current_scale = devm_kzalloc(&led->pdev->dev, |
323 | sizeof(max_mm_current_percent), | |
49c34b8e JA |
324 | GFP_KERNEL); |
325 | if (!led->mm_current_scale) | |
326 | return -ENOMEM; | |
327 | ||
328 | for (i = 0; i < AAT1290_MM_CURRENT_SCALE_SIZE; ++i) | |
329 | led->mm_current_scale[i] = max_mm_current * | |
330 | max_mm_current_percent[i] / 100; | |
331 | ||
332 | return 0; | |
333 | } | |
334 | ||
335 | static int aat1290_led_get_configuration(struct aat1290_led *led, | |
ac69b903 JA |
336 | struct aat1290_led_config_data *cfg, |
337 | struct device_node **sub_node) | |
49c34b8e JA |
338 | { |
339 | int ret; | |
340 | ||
ac69b903 | 341 | ret = aat1290_led_parse_dt(led, cfg, sub_node); |
49c34b8e JA |
342 | if (ret < 0) |
343 | return ret; | |
344 | /* | |
345 | * Init non-linear movie mode current scale basing | |
346 | * on the max flash current from led configuration. | |
347 | */ | |
348 | ret = init_mm_current_scale(led, cfg); | |
349 | if (ret < 0) | |
350 | return ret; | |
351 | ||
352 | aat1290_led_validate_mm_current(led, cfg); | |
353 | ||
ac69b903 JA |
354 | #if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS) |
355 | #else | |
356 | devm_kfree(&led->pdev->dev, led->mm_current_scale); | |
357 | #endif | |
49c34b8e JA |
358 | |
359 | return 0; | |
360 | } | |
361 | ||
362 | static void aat1290_init_flash_timeout(struct aat1290_led *led, | |
363 | struct aat1290_led_config_data *cfg) | |
364 | { | |
365 | struct led_classdev_flash *fled_cdev = &led->fled_cdev; | |
366 | struct led_flash_setting *setting; | |
367 | ||
368 | /* Init flash timeout setting */ | |
369 | setting = &fled_cdev->timeout; | |
370 | setting->min = cfg->max_flash_tm / AAT1290_FLASH_TM_NUM_LEVELS; | |
371 | setting->max = cfg->max_flash_tm; | |
372 | setting->step = setting->min; | |
373 | setting->val = setting->max; | |
374 | } | |
375 | ||
ac69b903 JA |
376 | #if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS) |
377 | static enum led_brightness aat1290_intensity_to_brightness( | |
378 | struct v4l2_flash *v4l2_flash, | |
379 | s32 intensity) | |
380 | { | |
381 | struct led_classdev_flash *fled_cdev = v4l2_flash->fled_cdev; | |
382 | struct aat1290_led *led = fled_cdev_to_led(fled_cdev); | |
383 | int i; | |
384 | ||
385 | for (i = AAT1290_MM_CURRENT_SCALE_SIZE - 1; i >= 0; --i) | |
386 | if (intensity >= led->mm_current_scale[i]) | |
387 | return i + 1; | |
388 | ||
389 | return 1; | |
390 | } | |
391 | ||
392 | static s32 aat1290_brightness_to_intensity(struct v4l2_flash *v4l2_flash, | |
393 | enum led_brightness brightness) | |
394 | { | |
395 | struct led_classdev_flash *fled_cdev = v4l2_flash->fled_cdev; | |
396 | struct aat1290_led *led = fled_cdev_to_led(fled_cdev); | |
397 | ||
398 | return led->mm_current_scale[brightness - 1]; | |
399 | } | |
400 | ||
401 | static int aat1290_led_external_strobe_set(struct v4l2_flash *v4l2_flash, | |
402 | bool enable) | |
403 | { | |
404 | struct aat1290_led *led = fled_cdev_to_led(v4l2_flash->fled_cdev); | |
405 | struct led_classdev_flash *fled_cdev = v4l2_flash->fled_cdev; | |
406 | struct led_classdev *led_cdev = &fled_cdev->led_cdev; | |
407 | struct pinctrl *pinctrl; | |
408 | ||
409 | gpiod_direction_output(led->gpio_fl_en, 0); | |
410 | gpiod_direction_output(led->gpio_en_set, 0); | |
411 | ||
412 | led->movie_mode = false; | |
413 | led_cdev->brightness = 0; | |
414 | ||
415 | pinctrl = devm_pinctrl_get_select(&led->pdev->dev, | |
416 | enable ? "isp" : "host"); | |
417 | if (IS_ERR(pinctrl)) { | |
418 | dev_warn(&led->pdev->dev, "Unable to switch strobe source.\n"); | |
419 | return PTR_ERR(pinctrl); | |
420 | } | |
421 | ||
422 | return 0; | |
423 | } | |
424 | ||
425 | static void aat1290_init_v4l2_flash_config(struct aat1290_led *led, | |
426 | struct aat1290_led_config_data *led_cfg, | |
427 | struct v4l2_flash_config *v4l2_sd_cfg) | |
428 | { | |
429 | struct led_classdev *led_cdev = &led->fled_cdev.led_cdev; | |
430 | struct led_flash_setting *s; | |
431 | ||
432 | strlcpy(v4l2_sd_cfg->dev_name, led_cdev->name, | |
433 | sizeof(v4l2_sd_cfg->dev_name)); | |
434 | ||
435 | s = &v4l2_sd_cfg->torch_intensity; | |
436 | s->min = led->mm_current_scale[0]; | |
437 | s->max = led_cfg->max_mm_current; | |
438 | s->step = 1; | |
439 | s->val = s->max; | |
440 | ||
441 | v4l2_sd_cfg->has_external_strobe = led_cfg->has_external_strobe; | |
442 | } | |
443 | ||
444 | static const struct v4l2_flash_ops v4l2_flash_ops = { | |
445 | .external_strobe_set = aat1290_led_external_strobe_set, | |
446 | .intensity_to_led_brightness = aat1290_intensity_to_brightness, | |
447 | .led_brightness_to_intensity = aat1290_brightness_to_intensity, | |
448 | }; | |
449 | #else | |
450 | static inline void aat1290_init_v4l2_flash_config(struct aat1290_led *led, | |
451 | struct aat1290_led_config_data *led_cfg, | |
452 | struct v4l2_flash_config *v4l2_sd_cfg) | |
453 | { | |
454 | } | |
455 | static const struct v4l2_flash_ops v4l2_flash_ops; | |
456 | #endif | |
457 | ||
49c34b8e JA |
458 | static const struct led_flash_ops flash_ops = { |
459 | .strobe_set = aat1290_led_flash_strobe_set, | |
460 | .timeout_set = aat1290_led_flash_timeout_set, | |
461 | }; | |
462 | ||
463 | static int aat1290_led_probe(struct platform_device *pdev) | |
464 | { | |
465 | struct device *dev = &pdev->dev; | |
ac69b903 | 466 | struct device_node *sub_node = NULL; |
49c34b8e JA |
467 | struct aat1290_led *led; |
468 | struct led_classdev *led_cdev; | |
469 | struct led_classdev_flash *fled_cdev; | |
470 | struct aat1290_led_config_data led_cfg = {}; | |
ac69b903 | 471 | struct v4l2_flash_config v4l2_sd_cfg = {}; |
49c34b8e JA |
472 | int ret; |
473 | ||
474 | led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL); | |
475 | if (!led) | |
476 | return -ENOMEM; | |
477 | ||
478 | led->pdev = pdev; | |
479 | platform_set_drvdata(pdev, led); | |
480 | ||
481 | fled_cdev = &led->fled_cdev; | |
482 | fled_cdev->ops = &flash_ops; | |
483 | led_cdev = &fled_cdev->led_cdev; | |
484 | ||
ac69b903 | 485 | ret = aat1290_led_get_configuration(led, &led_cfg, &sub_node); |
49c34b8e JA |
486 | if (ret < 0) |
487 | return ret; | |
488 | ||
489 | mutex_init(&led->lock); | |
490 | ||
491 | /* Initialize LED Flash class device */ | |
269e92da | 492 | led_cdev->brightness_set_blocking = aat1290_led_brightness_set; |
49c34b8e JA |
493 | led_cdev->max_brightness = led_cfg.max_brightness; |
494 | led_cdev->flags |= LED_DEV_CAP_FLASH; | |
49c34b8e JA |
495 | |
496 | aat1290_init_flash_timeout(led, &led_cfg); | |
497 | ||
498 | /* Register LED Flash class device */ | |
499 | ret = led_classdev_flash_register(&pdev->dev, fled_cdev); | |
500 | if (ret < 0) | |
501 | goto err_flash_register; | |
502 | ||
ac69b903 JA |
503 | aat1290_init_v4l2_flash_config(led, &led_cfg, &v4l2_sd_cfg); |
504 | ||
505 | /* Create V4L2 Flash subdev. */ | |
506 | led->v4l2_flash = v4l2_flash_init(dev, sub_node, fled_cdev, NULL, | |
507 | &v4l2_flash_ops, &v4l2_sd_cfg); | |
508 | if (IS_ERR(led->v4l2_flash)) { | |
509 | ret = PTR_ERR(led->v4l2_flash); | |
510 | goto error_v4l2_flash_init; | |
511 | } | |
512 | ||
49c34b8e JA |
513 | return 0; |
514 | ||
ac69b903 JA |
515 | error_v4l2_flash_init: |
516 | led_classdev_flash_unregister(fled_cdev); | |
49c34b8e JA |
517 | err_flash_register: |
518 | mutex_destroy(&led->lock); | |
519 | ||
520 | return ret; | |
521 | } | |
522 | ||
523 | static int aat1290_led_remove(struct platform_device *pdev) | |
524 | { | |
525 | struct aat1290_led *led = platform_get_drvdata(pdev); | |
526 | ||
ac69b903 | 527 | v4l2_flash_release(led->v4l2_flash); |
49c34b8e | 528 | led_classdev_flash_unregister(&led->fled_cdev); |
49c34b8e JA |
529 | |
530 | mutex_destroy(&led->lock); | |
531 | ||
532 | return 0; | |
533 | } | |
534 | ||
535 | static const struct of_device_id aat1290_led_dt_match[] = { | |
536 | { .compatible = "skyworks,aat1290" }, | |
537 | {}, | |
538 | }; | |
93a51aa4 | 539 | MODULE_DEVICE_TABLE(of, aat1290_led_dt_match); |
49c34b8e JA |
540 | |
541 | static struct platform_driver aat1290_led_driver = { | |
542 | .probe = aat1290_led_probe, | |
543 | .remove = aat1290_led_remove, | |
544 | .driver = { | |
545 | .name = "aat1290", | |
546 | .of_match_table = aat1290_led_dt_match, | |
547 | }, | |
548 | }; | |
549 | ||
550 | module_platform_driver(aat1290_led_driver); | |
551 | ||
552 | MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>"); | |
553 | MODULE_DESCRIPTION("Skyworks Current Regulator for Flash LEDs"); | |
554 | MODULE_LICENSE("GPL v2"); |