1 // SPDX-License-Identifier: GPL-2.0-only
3 #include <linux/bitops.h>
4 #include <linux/delay.h>
5 #include <linux/init.h>
6 #include <linux/interrupt.h>
7 #include <linux/kernel.h>
8 #include <linux/led-class-flash.h>
9 #include <linux/led-class-multicolor.h>
10 #include <linux/module.h>
11 #include <linux/mutex.h>
12 #include <linux/platform_device.h>
13 #include <linux/property.h>
14 #include <linux/regmap.h>
15 #include <media/v4l2-flash-led-class.h>
27 #define MT6360_REG_RGBEN 0x380
28 #define MT6360_REG_ISNK(_led_no) (0x381 + (_led_no))
29 #define MT6360_ISNK_ENMASK(_led_no) BIT(7 - (_led_no))
30 #define MT6360_ISNK_MASK GENMASK(4, 0)
31 #define MT6360_CHRINDSEL_MASK BIT(3)
33 /* Virtual definition for multicolor */
34 #define MT6360_VIRTUAL_MULTICOLOR (MT6360_MAX_LEDS + 1)
35 #define MULTICOLOR_NUM_CHANNELS 3
37 #define MT6360_REG_FLEDEN 0x37E
38 #define MT6360_REG_STRBTO 0x373
39 #define MT6360_REG_FLEDBASE(_id) (0x372 + 4 * (_id - MT6360_LED_FLASH1))
40 #define MT6360_REG_FLEDISTRB(_id) (MT6360_REG_FLEDBASE(_id) + 2)
41 #define MT6360_REG_FLEDITOR(_id) (MT6360_REG_FLEDBASE(_id) + 3)
42 #define MT6360_REG_CHGSTAT2 0x3E1
43 #define MT6360_REG_FLEDSTAT1 0x3E9
44 #define MT6360_ITORCH_MASK GENMASK(4, 0)
45 #define MT6360_ISTROBE_MASK GENMASK(6, 0)
46 #define MT6360_STRBTO_MASK GENMASK(6, 0)
47 #define MT6360_TORCHEN_MASK BIT(3)
48 #define MT6360_STROBEN_MASK BIT(2)
49 #define MT6360_FLCSEN_MASK(_id) BIT(MT6360_LED_FLASH2 - _id)
50 #define MT6360_FLEDCHGVINOVP_MASK BIT(3)
51 #define MT6360_FLED1STRBTO_MASK BIT(11)
52 #define MT6360_FLED2STRBTO_MASK BIT(10)
53 #define MT6360_FLED1STRB_MASK BIT(9)
54 #define MT6360_FLED2STRB_MASK BIT(8)
55 #define MT6360_FLED1SHORT_MASK BIT(7)
56 #define MT6360_FLED2SHORT_MASK BIT(6)
57 #define MT6360_FLEDLVF_MASK BIT(3)
59 #define MT6360_ISNKRGB_STEPUA 2000
60 #define MT6360_ISNKRGB_MAXUA 24000
61 #define MT6360_ISNKML_STEPUA 5000
62 #define MT6360_ISNKML_MAXUA 150000
64 #define MT6360_ITORCH_MINUA 25000
65 #define MT6360_ITORCH_STEPUA 12500
66 #define MT6360_ITORCH_MAXUA 400000
67 #define MT6360_ISTRB_MINUA 50000
68 #define MT6360_ISTRB_STEPUA 12500
69 #define MT6360_ISTRB_MAXUA 1500000
70 #define MT6360_STRBTO_MINUS 64000
71 #define MT6360_STRBTO_STEPUS 32000
72 #define MT6360_STRBTO_MAXUS 2432000
76 struct led_classdev isnk;
77 struct led_classdev_mc mc;
78 struct led_classdev_flash flash;
80 struct v4l2_flash *v4l2_flash;
81 struct mt6360_priv *priv;
83 enum led_default_state default_state;
88 struct regmap *regmap;
90 unsigned int fled_strobe_used;
91 unsigned int fled_torch_used;
92 unsigned int leds_active;
93 unsigned int leds_count;
94 struct mt6360_led leds[] __counted_by(leds_count);
97 static int mt6360_mc_brightness_set(struct led_classdev *lcdev,
98 enum led_brightness level)
100 struct led_classdev_mc *mccdev = lcdev_to_mccdev(lcdev);
101 struct mt6360_led *led = container_of(mccdev, struct mt6360_led, mc);
102 struct mt6360_priv *priv = led->priv;
103 u32 real_bright, enable_mask = 0, enable = 0;
106 mutex_lock(&priv->lock);
108 led_mc_calc_color_components(mccdev, level);
110 for (i = 0; i < mccdev->num_colors; i++) {
111 struct mc_subled *subled = mccdev->subled_info + i;
113 real_bright = min(lcdev->max_brightness, subled->brightness);
114 ret = regmap_update_bits(priv->regmap, MT6360_REG_ISNK(i),
115 MT6360_ISNK_MASK, real_bright);
119 enable_mask |= MT6360_ISNK_ENMASK(subled->channel);
121 enable |= MT6360_ISNK_ENMASK(subled->channel);
124 ret = regmap_update_bits(priv->regmap, MT6360_REG_RGBEN, enable_mask,
128 mutex_unlock(&priv->lock);
132 static int mt6360_isnk_brightness_set(struct led_classdev *lcdev,
133 enum led_brightness level)
135 struct mt6360_led *led = container_of(lcdev, struct mt6360_led, isnk);
136 struct mt6360_priv *priv = led->priv;
137 u32 enable_mask = MT6360_ISNK_ENMASK(led->led_no);
138 u32 val = level ? MT6360_ISNK_ENMASK(led->led_no) : 0;
141 mutex_lock(&priv->lock);
143 ret = regmap_update_bits(priv->regmap, MT6360_REG_ISNK(led->led_no),
144 MT6360_ISNK_MASK, level);
148 ret = regmap_update_bits(priv->regmap, MT6360_REG_RGBEN, enable_mask,
152 mutex_unlock(&priv->lock);
156 static int mt6360_torch_brightness_set(struct led_classdev *lcdev,
157 enum led_brightness level)
159 struct mt6360_led *led =
160 container_of(lcdev, struct mt6360_led, flash.led_cdev);
161 struct mt6360_priv *priv = led->priv;
162 u32 enable_mask = MT6360_TORCHEN_MASK | MT6360_FLCSEN_MASK(led->led_no);
163 u32 val = level ? MT6360_FLCSEN_MASK(led->led_no) : 0;
164 u32 prev = priv->fled_torch_used, curr;
167 mutex_lock(&priv->lock);
170 * Only one set of flash control logic, use the flag to avoid strobe is
173 if (priv->fled_strobe_used) {
174 dev_warn(lcdev->dev, "Please disable strobe first [%d]\n",
175 priv->fled_strobe_used);
181 curr = prev | BIT(led->led_no);
183 curr = prev & ~BIT(led->led_no);
186 val |= MT6360_TORCHEN_MASK;
189 ret = regmap_update_bits(priv->regmap,
190 MT6360_REG_FLEDITOR(led->led_no),
191 MT6360_ITORCH_MASK, level - 1);
196 ret = regmap_update_bits(priv->regmap, MT6360_REG_FLEDEN, enable_mask,
201 priv->fled_torch_used = curr;
204 mutex_unlock(&priv->lock);
208 static int mt6360_flash_brightness_set(struct led_classdev_flash *fl_cdev,
212 * Due to the current spike when turning on flash, let brightness to be
214 * This empty function is used to prevent led_classdev_flash register
220 static int _mt6360_flash_brightness_set(struct led_classdev_flash *fl_cdev,
223 struct mt6360_led *led =
224 container_of(fl_cdev, struct mt6360_led, flash);
225 struct mt6360_priv *priv = led->priv;
226 struct led_flash_setting *s = &fl_cdev->brightness;
227 u32 val = (brightness - s->min) / s->step;
229 return regmap_update_bits(priv->regmap,
230 MT6360_REG_FLEDISTRB(led->led_no),
231 MT6360_ISTROBE_MASK, val);
234 static int mt6360_strobe_set(struct led_classdev_flash *fl_cdev, bool state)
236 struct mt6360_led *led =
237 container_of(fl_cdev, struct mt6360_led, flash);
238 struct mt6360_priv *priv = led->priv;
239 struct led_classdev *lcdev = &fl_cdev->led_cdev;
240 struct led_flash_setting *s = &fl_cdev->brightness;
241 u32 enable_mask = MT6360_STROBEN_MASK | MT6360_FLCSEN_MASK(led->led_no);
242 u32 val = state ? MT6360_FLCSEN_MASK(led->led_no) : 0;
243 u32 prev = priv->fled_strobe_used, curr;
246 mutex_lock(&priv->lock);
249 * Only one set of flash control logic, use the flag to avoid torch is
252 if (priv->fled_torch_used) {
253 dev_warn(lcdev->dev, "Please disable torch first [0x%x]\n",
254 priv->fled_torch_used);
260 curr = prev | BIT(led->led_no);
262 curr = prev & ~BIT(led->led_no);
265 val |= MT6360_STROBEN_MASK;
267 ret = regmap_update_bits(priv->regmap, MT6360_REG_FLEDEN, enable_mask,
270 dev_err(lcdev->dev, "[%d] control current source %d fail\n",
276 * If the flash need to be on, config the flash current ramping up to
278 * Else, always recover back to the minimum one
280 ret = _mt6360_flash_brightness_set(fl_cdev, state ? s->val : s->min);
285 * For the flash turn on/off, HW rampping up/down time is 5ms/500us,
289 usleep_range(5000, 6000);
290 else if (prev && !curr)
293 priv->fled_strobe_used = curr;
296 mutex_unlock(&priv->lock);
300 static int mt6360_strobe_get(struct led_classdev_flash *fl_cdev, bool *state)
302 struct mt6360_led *led =
303 container_of(fl_cdev, struct mt6360_led, flash);
304 struct mt6360_priv *priv = led->priv;
306 mutex_lock(&priv->lock);
307 *state = !!(priv->fled_strobe_used & BIT(led->led_no));
308 mutex_unlock(&priv->lock);
313 static int mt6360_timeout_set(struct led_classdev_flash *fl_cdev, u32 timeout)
315 struct mt6360_led *led =
316 container_of(fl_cdev, struct mt6360_led, flash);
317 struct mt6360_priv *priv = led->priv;
318 struct led_flash_setting *s = &fl_cdev->timeout;
319 u32 val = (timeout - s->min) / s->step;
322 mutex_lock(&priv->lock);
323 ret = regmap_update_bits(priv->regmap, MT6360_REG_STRBTO,
324 MT6360_STRBTO_MASK, val);
325 mutex_unlock(&priv->lock);
330 static int mt6360_fault_get(struct led_classdev_flash *fl_cdev, u32 *fault)
332 struct mt6360_led *led =
333 container_of(fl_cdev, struct mt6360_led, flash);
334 struct mt6360_priv *priv = led->priv;
336 unsigned int chg_stat, strobe_timeout_mask, fled_short_mask;
340 mutex_lock(&priv->lock);
341 ret = regmap_read(priv->regmap, MT6360_REG_CHGSTAT2, &chg_stat);
345 ret = regmap_raw_read(priv->regmap, MT6360_REG_FLEDSTAT1, &fled_stat,
350 if (led->led_no == MT6360_LED_FLASH1) {
351 strobe_timeout_mask = MT6360_FLED1STRBTO_MASK;
352 fled_short_mask = MT6360_FLED1SHORT_MASK;
354 strobe_timeout_mask = MT6360_FLED2STRBTO_MASK;
355 fled_short_mask = MT6360_FLED2SHORT_MASK;
358 if (chg_stat & MT6360_FLEDCHGVINOVP_MASK)
359 rfault |= LED_FAULT_INPUT_VOLTAGE;
361 if (fled_stat & strobe_timeout_mask)
362 rfault |= LED_FAULT_TIMEOUT;
364 if (fled_stat & fled_short_mask)
365 rfault |= LED_FAULT_SHORT_CIRCUIT;
367 if (fled_stat & MT6360_FLEDLVF_MASK)
368 rfault |= LED_FAULT_UNDER_VOLTAGE;
372 mutex_unlock(&priv->lock);
376 static const struct led_flash_ops mt6360_flash_ops = {
377 .flash_brightness_set = mt6360_flash_brightness_set,
378 .strobe_set = mt6360_strobe_set,
379 .strobe_get = mt6360_strobe_get,
380 .timeout_set = mt6360_timeout_set,
381 .fault_get = mt6360_fault_get,
384 static int mt6360_isnk_init_default_state(struct mt6360_led *led)
386 struct mt6360_priv *priv = led->priv;
391 ret = regmap_read(priv->regmap, MT6360_REG_ISNK(led->led_no), ®val);
394 level = regval & MT6360_ISNK_MASK;
396 ret = regmap_read(priv->regmap, MT6360_REG_RGBEN, ®val);
400 if (!(regval & MT6360_ISNK_ENMASK(led->led_no)))
403 switch (led->default_state) {
404 case LEDS_DEFSTATE_ON:
405 led->isnk.brightness = led->isnk.max_brightness;
407 case LEDS_DEFSTATE_KEEP:
408 led->isnk.brightness = min(level, led->isnk.max_brightness);
411 led->isnk.brightness = LED_OFF;
414 return mt6360_isnk_brightness_set(&led->isnk, led->isnk.brightness);
417 static int mt6360_flash_init_default_state(struct mt6360_led *led)
419 struct led_classdev_flash *flash = &led->flash;
420 struct mt6360_priv *priv = led->priv;
421 u32 enable_mask = MT6360_TORCHEN_MASK | MT6360_FLCSEN_MASK(led->led_no);
426 ret = regmap_read(priv->regmap, MT6360_REG_FLEDITOR(led->led_no),
430 level = regval & MT6360_ITORCH_MASK;
432 ret = regmap_read(priv->regmap, MT6360_REG_FLEDEN, ®val);
436 if ((regval & enable_mask) == enable_mask)
441 switch (led->default_state) {
442 case LEDS_DEFSTATE_ON:
443 flash->led_cdev.brightness = flash->led_cdev.max_brightness;
445 case LEDS_DEFSTATE_KEEP:
446 flash->led_cdev.brightness =
447 min(level, flash->led_cdev.max_brightness);
450 flash->led_cdev.brightness = LED_OFF;
453 return mt6360_torch_brightness_set(&flash->led_cdev,
454 flash->led_cdev.brightness);
457 #if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS)
458 static int mt6360_flash_external_strobe_set(struct v4l2_flash *v4l2_flash,
461 struct led_classdev_flash *flash = v4l2_flash->fled_cdev;
462 struct mt6360_led *led = container_of(flash, struct mt6360_led, flash);
463 struct mt6360_priv *priv = led->priv;
464 u32 mask = MT6360_FLCSEN_MASK(led->led_no);
465 u32 val = enable ? mask : 0;
468 mutex_lock(&priv->lock);
470 ret = regmap_update_bits(priv->regmap, MT6360_REG_FLEDEN, mask, val);
475 priv->fled_strobe_used |= BIT(led->led_no);
477 priv->fled_strobe_used &= ~BIT(led->led_no);
480 mutex_unlock(&priv->lock);
484 static const struct v4l2_flash_ops v4l2_flash_ops = {
485 .external_strobe_set = mt6360_flash_external_strobe_set,
488 static void mt6360_init_v4l2_flash_config(struct mt6360_led *led,
489 struct v4l2_flash_config *config)
491 struct led_classdev *lcdev;
492 struct led_flash_setting *s = &config->intensity;
494 lcdev = &led->flash.led_cdev;
496 s->min = MT6360_ITORCH_MINUA;
497 s->step = MT6360_ITORCH_STEPUA;
498 s->val = s->max = s->min + (lcdev->max_brightness - 1) * s->step;
500 config->has_external_strobe = 1;
501 strscpy(config->dev_name, lcdev->dev->kobj.name,
502 sizeof(config->dev_name));
504 config->flash_faults = LED_FAULT_SHORT_CIRCUIT | LED_FAULT_TIMEOUT |
505 LED_FAULT_INPUT_VOLTAGE |
506 LED_FAULT_UNDER_VOLTAGE;
509 static const struct v4l2_flash_ops v4l2_flash_ops;
510 static void mt6360_init_v4l2_flash_config(struct mt6360_led *led,
511 struct v4l2_flash_config *config)
516 static int mt6360_led_register(struct device *parent, struct mt6360_led *led,
517 struct led_init_data *init_data)
519 struct mt6360_priv *priv = led->priv;
520 struct v4l2_flash_config v4l2_config = {0};
523 if ((led->led_no == MT6360_LED_ISNK1 ||
524 led->led_no == MT6360_VIRTUAL_MULTICOLOR) &&
525 (priv->leds_active & BIT(MT6360_LED_ISNK1))) {
527 * Change isink1 to SW control mode, disconnect it with
530 ret = regmap_update_bits(priv->regmap, MT6360_REG_RGBEN,
531 MT6360_CHRINDSEL_MASK,
532 MT6360_CHRINDSEL_MASK);
534 dev_err(parent, "Failed to config ISNK1 to SW mode\n");
539 switch (led->led_no) {
540 case MT6360_VIRTUAL_MULTICOLOR:
541 ret = mt6360_mc_brightness_set(&led->mc.led_cdev, LED_OFF);
544 "Failed to init multicolor brightness\n");
548 ret = devm_led_classdev_multicolor_register_ext(parent,
549 &led->mc, init_data);
551 dev_err(parent, "Couldn't register multicolor\n");
555 case MT6360_LED_ISNK1 ... MT6360_LED_ISNKML:
556 ret = mt6360_isnk_init_default_state(led);
558 dev_err(parent, "Failed to init %d isnk state\n",
563 ret = devm_led_classdev_register_ext(parent, &led->isnk,
566 dev_err(parent, "Couldn't register isink %d\n",
572 ret = mt6360_flash_init_default_state(led);
574 dev_err(parent, "Failed to init %d flash state\n",
579 ret = devm_led_classdev_flash_register_ext(parent, &led->flash,
582 dev_err(parent, "Couldn't register flash %d\n",
587 mt6360_init_v4l2_flash_config(led, &v4l2_config);
588 led->v4l2_flash = v4l2_flash_init(parent, init_data->fwnode,
592 if (IS_ERR(led->v4l2_flash)) {
593 dev_err(parent, "Failed to register %d v4l2 sd\n",
595 return PTR_ERR(led->v4l2_flash);
602 static u32 clamp_align(u32 val, u32 min, u32 max, u32 step)
606 retval = clamp_val(val, min, max);
608 retval = rounddown(retval - min, step) + min;
613 static int mt6360_init_isnk_properties(struct mt6360_led *led,
614 struct led_init_data *init_data)
616 struct led_classdev *lcdev;
617 struct mt6360_priv *priv = led->priv;
618 struct fwnode_handle *child;
619 u32 step_uA = MT6360_ISNKRGB_STEPUA, max_uA = MT6360_ISNKRGB_MAXUA;
621 int num_color = 0, ret;
623 if (led->led_no == MT6360_VIRTUAL_MULTICOLOR) {
624 struct mc_subled *sub_led;
626 sub_led = devm_kzalloc(priv->dev,
627 sizeof(*sub_led) * MULTICOLOR_NUM_CHANNELS, GFP_KERNEL);
631 fwnode_for_each_child_node(init_data->fwnode, child) {
634 ret = fwnode_property_read_u32(child, "reg", ®);
635 if (ret || reg > MT6360_LED_ISNK3 ||
636 priv->leds_active & BIT(reg))
639 ret = fwnode_property_read_u32(child, "color", &color);
642 "led %d, no color specified\n",
647 priv->leds_active |= BIT(reg);
648 sub_led[num_color].color_index = color;
649 sub_led[num_color].channel = reg;
655 "Multicolor must include 2 or more led channel\n");
659 led->mc.num_colors = num_color;
660 led->mc.subled_info = sub_led;
662 lcdev = &led->mc.led_cdev;
663 lcdev->brightness_set_blocking = mt6360_mc_brightness_set;
665 if (led->led_no == MT6360_LED_ISNKML) {
666 step_uA = MT6360_ISNKML_STEPUA;
667 max_uA = MT6360_ISNKML_MAXUA;
671 lcdev->brightness_set_blocking = mt6360_isnk_brightness_set;
674 ret = fwnode_property_read_u32(init_data->fwnode, "led-max-microamp",
678 "Not specified led-max-microamp, config to the minimum\n");
681 val = clamp_align(val, 0, max_uA, step_uA);
683 lcdev->max_brightness = val / step_uA;
685 fwnode_property_read_string(init_data->fwnode, "linux,default-trigger",
686 &lcdev->default_trigger);
691 static int mt6360_init_flash_properties(struct mt6360_led *led,
692 struct led_init_data *init_data)
694 struct led_classdev_flash *flash = &led->flash;
695 struct led_classdev *lcdev = &flash->led_cdev;
696 struct mt6360_priv *priv = led->priv;
697 struct led_flash_setting *s;
701 ret = fwnode_property_read_u32(init_data->fwnode, "led-max-microamp",
705 "Not specified led-max-microamp, config to the minimum\n");
706 val = MT6360_ITORCH_MINUA;
708 val = clamp_align(val, MT6360_ITORCH_MINUA, MT6360_ITORCH_MAXUA,
709 MT6360_ITORCH_STEPUA);
711 lcdev->max_brightness =
712 (val - MT6360_ITORCH_MINUA) / MT6360_ITORCH_STEPUA + 1;
713 lcdev->brightness_set_blocking = mt6360_torch_brightness_set;
714 lcdev->flags |= LED_DEV_CAP_FLASH;
716 ret = fwnode_property_read_u32(init_data->fwnode, "flash-max-microamp",
720 "Not specified flash-max-microamp, config to the minimum\n");
721 val = MT6360_ISTRB_MINUA;
723 val = clamp_align(val, MT6360_ISTRB_MINUA, MT6360_ISTRB_MAXUA,
724 MT6360_ISTRB_STEPUA);
726 s = &flash->brightness;
727 s->min = MT6360_ISTRB_MINUA;
728 s->step = MT6360_ISTRB_STEPUA;
729 s->val = s->max = val;
732 * Always configure as min level when off to prevent flash current
735 ret = _mt6360_flash_brightness_set(flash, s->min);
739 ret = fwnode_property_read_u32(init_data->fwnode,
740 "flash-max-timeout-us", &val);
743 "Not specified flash-max-timeout-us, config to the minimum\n");
744 val = MT6360_STRBTO_MINUS;
746 val = clamp_align(val, MT6360_STRBTO_MINUS, MT6360_STRBTO_MAXUS,
747 MT6360_STRBTO_STEPUS);
750 s->min = MT6360_STRBTO_MINUS;
751 s->step = MT6360_STRBTO_STEPUS;
752 s->val = s->max = val;
754 flash->ops = &mt6360_flash_ops;
759 static void mt6360_v4l2_flash_release(struct mt6360_priv *priv)
763 for (i = 0; i < priv->leds_count; i++) {
764 struct mt6360_led *led = priv->leds + i;
767 v4l2_flash_release(led->v4l2_flash);
771 static int mt6360_led_probe(struct platform_device *pdev)
773 struct mt6360_priv *priv;
774 struct fwnode_handle *child;
778 count = device_get_child_node_count(&pdev->dev);
779 if (!count || count > MT6360_MAX_LEDS) {
781 "No child node or node count over max led number %zu\n",
786 priv = devm_kzalloc(&pdev->dev,
787 struct_size(priv, leds, count), GFP_KERNEL);
791 priv->leds_count = count;
792 priv->dev = &pdev->dev;
793 mutex_init(&priv->lock);
795 priv->regmap = dev_get_regmap(pdev->dev.parent, NULL);
797 dev_err(&pdev->dev, "Failed to get parent regmap\n");
801 device_for_each_child_node(&pdev->dev, child) {
802 struct mt6360_led *led = priv->leds + i;
803 struct led_init_data init_data = { .fwnode = child, };
806 ret = fwnode_property_read_u32(child, "color", &led_color);
808 goto out_flash_release;
810 if (led_color == LED_COLOR_ID_RGB ||
811 led_color == LED_COLOR_ID_MULTI)
812 reg = MT6360_VIRTUAL_MULTICOLOR;
814 ret = fwnode_property_read_u32(child, "reg", ®);
816 goto out_flash_release;
818 if (reg >= MT6360_MAX_LEDS) {
820 goto out_flash_release;
824 if (priv->leds_active & BIT(reg)) {
826 goto out_flash_release;
828 priv->leds_active |= BIT(reg);
832 led->default_state = led_init_default_state_get(child);
834 if (reg == MT6360_VIRTUAL_MULTICOLOR ||
835 reg <= MT6360_LED_ISNKML)
836 ret = mt6360_init_isnk_properties(led, &init_data);
838 ret = mt6360_init_flash_properties(led, &init_data);
841 goto out_flash_release;
843 ret = mt6360_led_register(&pdev->dev, led, &init_data);
845 goto out_flash_release;
850 platform_set_drvdata(pdev, priv);
854 mt6360_v4l2_flash_release(priv);
858 static void mt6360_led_remove(struct platform_device *pdev)
860 struct mt6360_priv *priv = platform_get_drvdata(pdev);
862 mt6360_v4l2_flash_release(priv);
865 static const struct of_device_id __maybe_unused mt6360_led_of_id[] = {
866 { .compatible = "mediatek,mt6360-led", },
869 MODULE_DEVICE_TABLE(of, mt6360_led_of_id);
871 static struct platform_driver mt6360_led_driver = {
873 .name = "mt6360-led",
874 .of_match_table = mt6360_led_of_id,
876 .probe = mt6360_led_probe,
877 .remove_new = mt6360_led_remove,
879 module_platform_driver(mt6360_led_driver);
881 MODULE_AUTHOR("Gene Chen <gene_chen@richtek.com>");
882 MODULE_DESCRIPTION("MT6360 LED Driver");
883 MODULE_LICENSE("GPL v2");