1 // SPDX-License-Identifier: GPL-2.0
3 * LED flash driver for LM3554
5 * Copyright (c) 2010-2012 Intel Corporation. All Rights Reserved.
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License version
9 * 2 as published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
18 #include <linux/module.h>
19 #include <linux/i2c.h>
20 #include <linux/mutex.h>
21 #include <linux/delay.h>
22 #include <linux/gpio/consumer.h>
23 #include <linux/slab.h>
25 #include "../include/media/lm3554.h"
26 #include <media/v4l2-ctrls.h>
27 #include <media/v4l2-device.h>
28 #include <linux/acpi.h>
29 #include "../include/linux/atomisp_gmin_platform.h"
30 #include "../include/linux/atomisp.h"
34 #define LM3554_TORCH_BRIGHTNESS_REG 0xA0
35 #define LM3554_TORCH_MODE_SHIFT 0
36 #define LM3554_TORCH_CURRENT_SHIFT 3
37 #define LM3554_INDICATOR_CURRENT_SHIFT 6
39 #define LM3554_FLASH_BRIGHTNESS_REG 0xB0
40 #define LM3554_FLASH_MODE_SHIFT 0
41 #define LM3554_FLASH_CURRENT_SHIFT 3
42 #define LM3554_STROBE_SENSITIVITY_SHIFT 7
44 #define LM3554_FLASH_DURATION_REG 0xC0
45 #define LM3554_FLASH_TIMEOUT_SHIFT 0
46 #define LM3554_CURRENT_LIMIT_SHIFT 5
48 #define LM3554_FLAGS_REG 0xD0
49 #define LM3554_FLAG_TIMEOUT BIT(0)
50 #define LM3554_FLAG_THERMAL_SHUTDOWN BIT(1)
51 #define LM3554_FLAG_LED_FAULT BIT(2)
52 #define LM3554_FLAG_TX1_INTERRUPT BIT(3)
53 #define LM3554_FLAG_TX2_INTERRUPT BIT(4)
54 #define LM3554_FLAG_LED_THERMAL_FAULT BIT(5)
55 #define LM3554_FLAG_UNUSED BIT(6)
56 #define LM3554_FLAG_INPUT_VOLTAGE_LOW BIT(7)
58 #define LM3554_CONFIG_REG_1 0xE0
59 #define LM3554_ENVM_TX2_SHIFT 5
60 #define LM3554_TX2_POLARITY_SHIFT 6
63 struct v4l2_subdev sd;
65 struct mutex power_lock;
66 struct v4l2_ctrl_handler ctrl_handler;
75 struct timer_list flash_off_delay;
76 struct lm3554_platform_data *pdata;
79 #define to_lm3554(p_sd) container_of(p_sd, struct lm3554, sd)
81 /* Return negative errno else zero on success */
82 static int lm3554_write(struct lm3554 *flash, u8 addr, u8 val)
84 struct i2c_client *client = v4l2_get_subdevdata(&flash->sd);
87 ret = i2c_smbus_write_byte_data(client, addr, val);
89 dev_dbg(&client->dev, "Write Addr:%02X Val:%02X %s\n", addr, val,
90 ret < 0 ? "fail" : "ok");
95 /* Return negative errno else a data byte received from the device. */
96 static int lm3554_read(struct lm3554 *flash, u8 addr)
98 struct i2c_client *client = v4l2_get_subdevdata(&flash->sd);
101 ret = i2c_smbus_read_byte_data(client, addr);
103 dev_dbg(&client->dev, "Read Addr:%02X Val:%02X %s\n", addr, ret,
104 ret < 0 ? "fail" : "ok");
109 /* -----------------------------------------------------------------------------
110 * Hardware configuration
113 static int lm3554_set_mode(struct lm3554 *flash, unsigned int mode)
118 val = (mode << LM3554_FLASH_MODE_SHIFT) |
119 (flash->flash_current << LM3554_FLASH_CURRENT_SHIFT);
121 ret = lm3554_write(flash, LM3554_FLASH_BRIGHTNESS_REG, val);
127 static int lm3554_set_torch(struct lm3554 *flash)
131 val = (flash->mode << LM3554_TORCH_MODE_SHIFT) |
132 (flash->torch_current << LM3554_TORCH_CURRENT_SHIFT) |
133 (flash->indicator_current << LM3554_INDICATOR_CURRENT_SHIFT);
135 return lm3554_write(flash, LM3554_TORCH_BRIGHTNESS_REG, val);
138 static int lm3554_set_flash(struct lm3554 *flash)
142 val = (flash->mode << LM3554_FLASH_MODE_SHIFT) |
143 (flash->flash_current << LM3554_FLASH_CURRENT_SHIFT);
145 return lm3554_write(flash, LM3554_FLASH_BRIGHTNESS_REG, val);
148 static int lm3554_set_duration(struct lm3554 *flash)
152 val = (flash->timeout << LM3554_FLASH_TIMEOUT_SHIFT) |
153 (flash->pdata->current_limit << LM3554_CURRENT_LIMIT_SHIFT);
155 return lm3554_write(flash, LM3554_FLASH_DURATION_REG, val);
158 static int lm3554_set_config1(struct lm3554 *flash)
162 val = (flash->pdata->envm_tx2 << LM3554_ENVM_TX2_SHIFT) |
163 (flash->pdata->tx2_polarity << LM3554_TX2_POLARITY_SHIFT);
164 return lm3554_write(flash, LM3554_CONFIG_REG_1, val);
167 /* -----------------------------------------------------------------------------
170 static void lm3554_flash_off_delay(struct timer_list *t)
172 struct lm3554 *flash = from_timer(flash, t, flash_off_delay);
173 struct lm3554_platform_data *pdata = flash->pdata;
175 gpiod_set_value(pdata->gpio_strobe, 0);
178 static int lm3554_hw_strobe(struct i2c_client *client, bool strobe)
180 int ret, timer_pending;
181 struct v4l2_subdev *sd = i2c_get_clientdata(client);
182 struct lm3554 *flash = to_lm3554(sd);
183 struct lm3554_platform_data *pdata = flash->pdata;
186 * An abnormal high flash current is observed when strobe off the
187 * flash. Workaround here is firstly set flash current to lower level,
188 * wait a short moment, and then strobe off the flash.
191 timer_pending = del_timer_sync(&flash->flash_off_delay);
195 /* set current to 70mA and wait a while */
196 ret = lm3554_write(flash, LM3554_FLASH_BRIGHTNESS_REG, 0);
199 mod_timer(&flash->flash_off_delay,
200 jiffies + msecs_to_jiffies(LM3554_TIMER_DELAY));
207 * If timer is killed before run, flash is not strobe off,
208 * so must strobe off here
211 gpiod_set_value(pdata->gpio_strobe, 0);
213 /* Restore flash current settings */
214 ret = lm3554_set_flash(flash);
218 /* Strobe on Flash */
219 gpiod_set_value(pdata->gpio_strobe, 1);
223 dev_err(&client->dev, "failed to %s flash strobe (%d)\n",
224 strobe ? "on" : "off", ret);
228 /* -----------------------------------------------------------------------------
232 static int lm3554_read_status(struct lm3554 *flash)
235 struct i2c_client *client = v4l2_get_subdevdata(&flash->sd);
237 /* NOTE: reading register clear fault status */
238 ret = lm3554_read(flash, LM3554_FLAGS_REG);
243 * Accordingly to datasheet we read back '1' in bit 6.
246 ret &= ~LM3554_FLAG_UNUSED;
249 * Do not take TX1/TX2 signal as an error
250 * because MSIC will not turn off flash, but turn to
251 * torch mode according to gsm modem signal by hardware.
253 ret &= ~(LM3554_FLAG_TX1_INTERRUPT | LM3554_FLAG_TX2_INTERRUPT);
256 dev_dbg(&client->dev, "LM3554 flag status: %02x\n", ret);
261 static int lm3554_s_flash_timeout(struct v4l2_subdev *sd, u32 val)
263 struct lm3554 *flash = to_lm3554(sd);
265 val = clamp(val, LM3554_MIN_TIMEOUT, LM3554_MAX_TIMEOUT);
266 val = val / LM3554_TIMEOUT_STEPSIZE - 1;
268 flash->timeout = val;
270 return lm3554_set_duration(flash);
273 static int lm3554_g_flash_timeout(struct v4l2_subdev *sd, s32 *val)
275 struct lm3554 *flash = to_lm3554(sd);
277 *val = (u32)(flash->timeout + 1) * LM3554_TIMEOUT_STEPSIZE;
282 static int lm3554_s_flash_intensity(struct v4l2_subdev *sd, u32 intensity)
284 struct lm3554 *flash = to_lm3554(sd);
286 intensity = LM3554_CLAMP_PERCENTAGE(intensity);
287 intensity = LM3554_PERCENT_TO_VALUE(intensity, LM3554_FLASH_STEP);
289 flash->flash_current = intensity;
291 return lm3554_set_flash(flash);
294 static int lm3554_g_flash_intensity(struct v4l2_subdev *sd, s32 *val)
296 struct lm3554 *flash = to_lm3554(sd);
298 *val = LM3554_VALUE_TO_PERCENT((u32)flash->flash_current,
304 static int lm3554_s_torch_intensity(struct v4l2_subdev *sd, u32 intensity)
306 struct lm3554 *flash = to_lm3554(sd);
308 intensity = LM3554_CLAMP_PERCENTAGE(intensity);
309 intensity = LM3554_PERCENT_TO_VALUE(intensity, LM3554_TORCH_STEP);
311 flash->torch_current = intensity;
313 return lm3554_set_torch(flash);
316 static int lm3554_g_torch_intensity(struct v4l2_subdev *sd, s32 *val)
318 struct lm3554 *flash = to_lm3554(sd);
320 *val = LM3554_VALUE_TO_PERCENT((u32)flash->torch_current,
326 static int lm3554_s_indicator_intensity(struct v4l2_subdev *sd, u32 intensity)
328 struct lm3554 *flash = to_lm3554(sd);
330 intensity = LM3554_CLAMP_PERCENTAGE(intensity);
331 intensity = LM3554_PERCENT_TO_VALUE(intensity, LM3554_INDICATOR_STEP);
333 flash->indicator_current = intensity;
335 return lm3554_set_torch(flash);
338 static int lm3554_g_indicator_intensity(struct v4l2_subdev *sd, s32 *val)
340 struct lm3554 *flash = to_lm3554(sd);
342 *val = LM3554_VALUE_TO_PERCENT((u32)flash->indicator_current,
343 LM3554_INDICATOR_STEP);
348 static int lm3554_s_flash_strobe(struct v4l2_subdev *sd, u32 val)
350 struct i2c_client *client = v4l2_get_subdevdata(sd);
352 return lm3554_hw_strobe(client, val);
355 static int lm3554_s_flash_mode(struct v4l2_subdev *sd, u32 new_mode)
357 struct lm3554 *flash = to_lm3554(sd);
361 case ATOMISP_FLASH_MODE_OFF:
362 mode = LM3554_MODE_SHUTDOWN;
364 case ATOMISP_FLASH_MODE_FLASH:
365 mode = LM3554_MODE_FLASH;
367 case ATOMISP_FLASH_MODE_INDICATOR:
368 mode = LM3554_MODE_INDICATOR;
370 case ATOMISP_FLASH_MODE_TORCH:
371 mode = LM3554_MODE_TORCH;
377 return lm3554_set_mode(flash, mode);
380 static int lm3554_g_flash_mode(struct v4l2_subdev *sd, s32 *val)
382 struct lm3554 *flash = to_lm3554(sd);
387 static int lm3554_g_flash_status(struct v4l2_subdev *sd, s32 *val)
389 struct lm3554 *flash = to_lm3554(sd);
392 value = lm3554_read_status(flash);
396 if (value & LM3554_FLAG_TIMEOUT)
397 *val = ATOMISP_FLASH_STATUS_TIMEOUT;
399 *val = ATOMISP_FLASH_STATUS_HW_ERROR;
401 *val = ATOMISP_FLASH_STATUS_OK;
406 static int lm3554_g_flash_status_register(struct v4l2_subdev *sd, s32 *val)
408 struct lm3554 *flash = to_lm3554(sd);
411 ret = lm3554_read(flash, LM3554_FLAGS_REG);
420 static int lm3554_s_ctrl(struct v4l2_ctrl *ctrl)
423 container_of(ctrl->handler, struct lm3554, ctrl_handler);
427 case V4L2_CID_FLASH_TIMEOUT:
428 ret = lm3554_s_flash_timeout(&dev->sd, ctrl->val);
430 case V4L2_CID_FLASH_INTENSITY:
431 ret = lm3554_s_flash_intensity(&dev->sd, ctrl->val);
433 case V4L2_CID_FLASH_TORCH_INTENSITY:
434 ret = lm3554_s_torch_intensity(&dev->sd, ctrl->val);
436 case V4L2_CID_FLASH_INDICATOR_INTENSITY:
437 ret = lm3554_s_indicator_intensity(&dev->sd, ctrl->val);
439 case V4L2_CID_FLASH_STROBE:
440 ret = lm3554_s_flash_strobe(&dev->sd, ctrl->val);
442 case V4L2_CID_FLASH_MODE:
443 ret = lm3554_s_flash_mode(&dev->sd, ctrl->val);
451 static int lm3554_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
454 container_of(ctrl->handler, struct lm3554, ctrl_handler);
458 case V4L2_CID_FLASH_TIMEOUT:
459 ret = lm3554_g_flash_timeout(&dev->sd, &ctrl->val);
461 case V4L2_CID_FLASH_INTENSITY:
462 ret = lm3554_g_flash_intensity(&dev->sd, &ctrl->val);
464 case V4L2_CID_FLASH_TORCH_INTENSITY:
465 ret = lm3554_g_torch_intensity(&dev->sd, &ctrl->val);
467 case V4L2_CID_FLASH_INDICATOR_INTENSITY:
468 ret = lm3554_g_indicator_intensity(&dev->sd, &ctrl->val);
470 case V4L2_CID_FLASH_MODE:
471 ret = lm3554_g_flash_mode(&dev->sd, &ctrl->val);
473 case V4L2_CID_FLASH_STATUS:
474 ret = lm3554_g_flash_status(&dev->sd, &ctrl->val);
476 case V4L2_CID_FLASH_STATUS_REGISTER:
477 ret = lm3554_g_flash_status_register(&dev->sd, &ctrl->val);
486 static const struct v4l2_ctrl_ops ctrl_ops = {
487 .s_ctrl = lm3554_s_ctrl,
488 .g_volatile_ctrl = lm3554_g_volatile_ctrl
491 static const struct v4l2_ctrl_config lm3554_controls[] = {
494 .id = V4L2_CID_FLASH_TIMEOUT,
495 .type = V4L2_CTRL_TYPE_INTEGER,
496 .name = "Flash Timeout",
498 .max = LM3554_MAX_TIMEOUT,
500 .def = LM3554_DEFAULT_TIMEOUT,
505 .id = V4L2_CID_FLASH_INTENSITY,
506 .type = V4L2_CTRL_TYPE_INTEGER,
507 .name = "Flash Intensity",
508 .min = LM3554_MIN_PERCENT,
509 .max = LM3554_MAX_PERCENT,
511 .def = LM3554_FLASH_DEFAULT_BRIGHTNESS,
516 .id = V4L2_CID_FLASH_TORCH_INTENSITY,
517 .type = V4L2_CTRL_TYPE_INTEGER,
518 .name = "Torch Intensity",
519 .min = LM3554_MIN_PERCENT,
520 .max = LM3554_MAX_PERCENT,
522 .def = LM3554_TORCH_DEFAULT_BRIGHTNESS,
527 .id = V4L2_CID_FLASH_INDICATOR_INTENSITY,
528 .type = V4L2_CTRL_TYPE_INTEGER,
529 .name = "Indicator Intensity",
530 .min = LM3554_MIN_PERCENT,
531 .max = LM3554_MAX_PERCENT,
533 .def = LM3554_INDICATOR_DEFAULT_BRIGHTNESS,
538 .id = V4L2_CID_FLASH_STROBE,
539 .type = V4L2_CTRL_TYPE_BOOLEAN,
540 .name = "Flash Strobe",
549 .id = V4L2_CID_FLASH_MODE,
550 .type = V4L2_CTRL_TYPE_INTEGER,
551 .name = "Flash Mode",
555 .def = ATOMISP_FLASH_MODE_OFF,
560 .id = V4L2_CID_FLASH_STATUS,
561 .type = V4L2_CTRL_TYPE_INTEGER,
562 .name = "Flash Status",
563 .min = ATOMISP_FLASH_STATUS_OK,
564 .max = ATOMISP_FLASH_STATUS_TIMEOUT,
566 .def = ATOMISP_FLASH_STATUS_OK,
571 .id = V4L2_CID_FLASH_STATUS_REGISTER,
572 .type = V4L2_CTRL_TYPE_INTEGER,
573 .name = "Flash Status Register",
582 /* -----------------------------------------------------------------------------
583 * V4L2 subdev core operations
586 /* Put device into known state. */
587 static int lm3554_setup(struct lm3554 *flash)
589 struct i2c_client *client = v4l2_get_subdevdata(&flash->sd);
592 /* clear the flags register */
593 ret = lm3554_read(flash, LM3554_FLAGS_REG);
597 dev_dbg(&client->dev, "Fault info: %02x\n", ret);
599 ret = lm3554_set_config1(flash);
603 ret = lm3554_set_duration(flash);
607 ret = lm3554_set_torch(flash);
611 ret = lm3554_set_flash(flash);
616 ret = lm3554_read_status(flash);
620 return ret ? -EIO : 0;
623 static int __lm3554_s_power(struct lm3554 *flash, int power)
625 struct lm3554_platform_data *pdata = flash->pdata;
628 /*initialize flash driver*/
629 gpiod_set_value(pdata->gpio_reset, power);
630 usleep_range(100, 100 + 1);
633 /* Setup default values. This makes sure that the chip
634 * is in a known state.
636 ret = lm3554_setup(flash);
638 __lm3554_s_power(flash, 0);
646 static int lm3554_s_power(struct v4l2_subdev *sd, int power)
648 struct lm3554 *flash = to_lm3554(sd);
651 mutex_lock(&flash->power_lock);
653 if (flash->power_count == !power) {
654 ret = __lm3554_s_power(flash, !!power);
659 flash->power_count += power ? 1 : -1;
660 WARN_ON(flash->power_count < 0);
663 mutex_unlock(&flash->power_lock);
667 static const struct v4l2_subdev_core_ops lm3554_core_ops = {
668 .s_power = lm3554_s_power,
671 static const struct v4l2_subdev_ops lm3554_ops = {
672 .core = &lm3554_core_ops,
675 static int lm3554_detect(struct v4l2_subdev *sd)
677 struct i2c_client *client = v4l2_get_subdevdata(sd);
678 struct i2c_adapter *adapter = client->adapter;
679 struct lm3554 *flash = to_lm3554(sd);
682 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
683 dev_err(&client->dev, "lm3554_detect i2c error\n");
687 /* Power up the flash driver and reset it */
688 ret = lm3554_s_power(&flash->sd, 1);
690 dev_err(&client->dev, "Failed to power on lm3554 LED flash\n");
692 dev_dbg(&client->dev, "Successfully detected lm3554 LED flash\n");
693 lm3554_s_power(&flash->sd, 0);
699 static int lm3554_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
701 return lm3554_s_power(sd, 1);
704 static int lm3554_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
706 return lm3554_s_power(sd, 0);
709 static const struct v4l2_subdev_internal_ops lm3554_internal_ops = {
710 .registered = lm3554_detect,
712 .close = lm3554_close,
715 /* -----------------------------------------------------------------------------
720 static int lm3554_suspend(struct device *dev)
722 struct i2c_client *client = to_i2c_client(dev);
723 struct v4l2_subdev *subdev = i2c_get_clientdata(client);
724 struct lm3554 *flash = to_lm3554(subdev);
727 if (flash->power_count == 0)
730 rval = __lm3554_s_power(flash, 0);
732 dev_dbg(&client->dev, "Suspend %s\n", rval < 0 ? "failed" : "ok");
737 static int lm3554_resume(struct device *dev)
739 struct i2c_client *client = to_i2c_client(dev);
740 struct v4l2_subdev *subdev = i2c_get_clientdata(client);
741 struct lm3554 *flash = to_lm3554(subdev);
744 if (flash->power_count == 0)
747 rval = __lm3554_s_power(flash, 1);
749 dev_dbg(&client->dev, "Resume %s\n", rval < 0 ? "fail" : "ok");
756 #define lm3554_suspend NULL
757 #define lm3554_resume NULL
759 #endif /* CONFIG_PM */
761 static int lm3554_gpio_init(struct i2c_client *client)
763 struct v4l2_subdev *sd = i2c_get_clientdata(client);
764 struct lm3554 *flash = to_lm3554(sd);
765 struct lm3554_platform_data *pdata = flash->pdata;
768 if (!pdata->gpio_reset)
771 ret = gpiod_direction_output(pdata->gpio_reset, 0);
775 if (!pdata->gpio_strobe)
778 ret = gpiod_direction_output(pdata->gpio_strobe, 0);
785 static void lm3554_gpio_uninit(struct i2c_client *client)
787 struct v4l2_subdev *sd = i2c_get_clientdata(client);
788 struct lm3554 *flash = to_lm3554(sd);
789 struct lm3554_platform_data *pdata = flash->pdata;
792 ret = gpiod_direction_output(pdata->gpio_strobe, 0);
794 dev_err(&client->dev,
795 "gpio request/direction_output fail for gpio_strobe");
797 ret = gpiod_direction_output(pdata->gpio_reset, 0);
799 dev_err(&client->dev,
800 "gpio request/direction_output fail for gpio_reset");
803 static void *lm3554_platform_data_func(struct i2c_client *client)
805 static struct lm3554_platform_data platform_data;
807 platform_data.gpio_reset = gpiod_get_index(&client->dev,
808 NULL, 2, GPIOD_OUT_LOW);
809 if (IS_ERR(platform_data.gpio_reset))
810 return ERR_CAST(platform_data.gpio_reset);
811 platform_data.gpio_strobe = gpiod_get_index(&client->dev,
812 NULL, 0, GPIOD_OUT_LOW);
813 if (IS_ERR(platform_data.gpio_strobe))
814 return ERR_CAST(platform_data.gpio_strobe);
815 platform_data.gpio_torch = gpiod_get_index(&client->dev,
816 NULL, 1, GPIOD_OUT_LOW);
817 if (IS_ERR(platform_data.gpio_torch))
818 return ERR_CAST(platform_data.gpio_torch);
820 /* Set to TX2 mode, then ENVM/TX2 pin is a power amplifier sync input:
821 * ENVM/TX pin asserted, flash forced into torch;
822 * ENVM/TX pin desserted, flash set back;
824 platform_data.envm_tx2 = 1;
825 platform_data.tx2_polarity = 0;
827 /* set peak current limit to be 1000mA */
828 platform_data.current_limit = 0;
830 return &platform_data;
833 static int lm3554_probe(struct i2c_client *client)
836 struct lm3554 *flash;
839 flash = kzalloc(sizeof(*flash), GFP_KERNEL);
843 flash->pdata = lm3554_platform_data_func(client);
844 if (IS_ERR(flash->pdata)) {
845 err = PTR_ERR(flash->pdata);
849 v4l2_i2c_subdev_init(&flash->sd, client, &lm3554_ops);
850 flash->sd.internal_ops = &lm3554_internal_ops;
851 flash->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
852 flash->mode = ATOMISP_FLASH_MODE_OFF;
853 flash->timeout = LM3554_MAX_TIMEOUT / LM3554_TIMEOUT_STEPSIZE - 1;
855 v4l2_ctrl_handler_init(&flash->ctrl_handler,
856 ARRAY_SIZE(lm3554_controls));
858 dev_err(&client->dev, "error initialize a ctrl_handler.\n");
859 goto unregister_subdev;
862 for (i = 0; i < ARRAY_SIZE(lm3554_controls); i++)
863 v4l2_ctrl_new_custom(&flash->ctrl_handler, &lm3554_controls[i],
866 if (flash->ctrl_handler.error) {
867 dev_err(&client->dev, "ctrl_handler error.\n");
868 err = flash->ctrl_handler.error;
872 flash->sd.ctrl_handler = &flash->ctrl_handler;
873 err = media_entity_pads_init(&flash->sd.entity, 0, NULL);
875 dev_err(&client->dev, "error initialize a media entity.\n");
879 flash->sd.entity.function = MEDIA_ENT_F_FLASH;
881 mutex_init(&flash->power_lock);
883 timer_setup(&flash->flash_off_delay, lm3554_flash_off_delay, 0);
885 err = lm3554_gpio_init(client);
887 dev_err(&client->dev, "gpio request/direction_output fail.\n");
891 err = atomisp_register_i2c_module(&flash->sd, NULL, LED_FLASH);
893 dev_err(&client->dev, "fail to register atomisp i2c module.\n");
900 lm3554_gpio_uninit(client);
902 media_entity_cleanup(&flash->sd.entity);
904 v4l2_ctrl_handler_free(&flash->ctrl_handler);
906 v4l2_device_unregister_subdev(&flash->sd);
913 static int lm3554_remove(struct i2c_client *client)
915 struct v4l2_subdev *sd = i2c_get_clientdata(client);
916 struct lm3554 *flash = to_lm3554(sd);
918 media_entity_cleanup(&flash->sd.entity);
919 v4l2_ctrl_handler_free(&flash->ctrl_handler);
920 v4l2_device_unregister_subdev(sd);
922 atomisp_gmin_remove_subdev(sd);
924 del_timer_sync(&flash->flash_off_delay);
926 lm3554_gpio_uninit(client);
933 static const struct dev_pm_ops lm3554_pm_ops = {
934 .suspend = lm3554_suspend,
935 .resume = lm3554_resume,
938 static const struct acpi_device_id lm3554_acpi_match[] = {
942 MODULE_DEVICE_TABLE(acpi, lm3554_acpi_match);
944 static struct i2c_driver lm3554_driver = {
947 .pm = &lm3554_pm_ops,
948 .acpi_match_table = lm3554_acpi_match,
950 .probe_new = lm3554_probe,
951 .remove = lm3554_remove,
953 module_i2c_driver(lm3554_driver);
955 MODULE_AUTHOR("Jing Tao <jing.tao@intel.com>");
956 MODULE_DESCRIPTION("LED flash driver for LM3554");
957 MODULE_LICENSE("GPL");