2 * LED flash driver for LM3554
4 * Copyright (c) 2010-2012 Intel Corporation. All Rights Reserved.
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License version
8 * 2 as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21 #include <linux/module.h>
22 #include <linux/i2c.h>
23 #include <linux/mutex.h>
24 #include <linux/delay.h>
25 #include <linux/gpio.h>
26 #include <linux/slab.h>
28 #include "../include/media/lm3554.h"
29 #include <media/v4l2-ctrls.h>
30 #include <media/v4l2-device.h>
31 #include <linux/acpi.h>
32 #include <linux/gpio/consumer.h>
33 #include "../include/linux/atomisp_gmin_platform.h"
34 #include "../include/linux/atomisp.h"
38 #define LM3554_TORCH_BRIGHTNESS_REG 0xA0
39 #define LM3554_TORCH_MODE_SHIFT 0
40 #define LM3554_TORCH_CURRENT_SHIFT 3
41 #define LM3554_INDICATOR_CURRENT_SHIFT 6
43 #define LM3554_FLASH_BRIGHTNESS_REG 0xB0
44 #define LM3554_FLASH_MODE_SHIFT 0
45 #define LM3554_FLASH_CURRENT_SHIFT 3
46 #define LM3554_STROBE_SENSITIVITY_SHIFT 7
48 #define LM3554_FLASH_DURATION_REG 0xC0
49 #define LM3554_FLASH_TIMEOUT_SHIFT 0
50 #define LM3554_CURRENT_LIMIT_SHIFT 5
52 #define LM3554_FLAGS_REG 0xD0
53 #define LM3554_FLAG_TIMEOUT (1 << 0)
54 #define LM3554_FLAG_THERMAL_SHUTDOWN (1 << 1)
55 #define LM3554_FLAG_LED_FAULT (1 << 2)
56 #define LM3554_FLAG_TX1_INTERRUPT (1 << 3)
57 #define LM3554_FLAG_TX2_INTERRUPT (1 << 4)
58 #define LM3554_FLAG_LED_THERMAL_FAULT (1 << 5)
59 #define LM3554_FLAG_UNUSED (1 << 6)
60 #define LM3554_FLAG_INPUT_VOLTAGE_LOW (1 << 7)
62 #define LM3554_CONFIG_REG_1 0xE0
63 #define LM3554_ENVM_TX2_SHIFT 5
64 #define LM3554_TX2_POLARITY_SHIFT 6
67 struct v4l2_subdev sd;
69 struct mutex power_lock;
70 struct v4l2_ctrl_handler ctrl_handler;
79 struct timer_list flash_off_delay;
80 struct lm3554_platform_data *pdata;
83 #define to_lm3554(p_sd) container_of(p_sd, struct lm3554, sd)
85 /* Return negative errno else zero on success */
86 static int lm3554_write(struct lm3554 *flash, u8 addr, u8 val)
88 struct i2c_client *client = v4l2_get_subdevdata(&flash->sd);
91 ret = i2c_smbus_write_byte_data(client, addr, val);
93 dev_dbg(&client->dev, "Write Addr:%02X Val:%02X %s\n", addr, val,
94 ret < 0 ? "fail" : "ok");
99 /* Return negative errno else a data byte received from the device. */
100 static int lm3554_read(struct lm3554 *flash, u8 addr)
102 struct i2c_client *client = v4l2_get_subdevdata(&flash->sd);
105 ret = i2c_smbus_read_byte_data(client, addr);
107 dev_dbg(&client->dev, "Read Addr:%02X Val:%02X %s\n", addr, ret,
108 ret < 0 ? "fail" : "ok");
113 /* -----------------------------------------------------------------------------
114 * Hardware configuration
117 static int lm3554_set_mode(struct lm3554 *flash, unsigned int mode)
122 val = (mode << LM3554_FLASH_MODE_SHIFT) |
123 (flash->flash_current << LM3554_FLASH_CURRENT_SHIFT);
125 ret = lm3554_write(flash, LM3554_FLASH_BRIGHTNESS_REG, val);
131 static int lm3554_set_torch(struct lm3554 *flash)
135 val = (flash->mode << LM3554_TORCH_MODE_SHIFT) |
136 (flash->torch_current << LM3554_TORCH_CURRENT_SHIFT) |
137 (flash->indicator_current << LM3554_INDICATOR_CURRENT_SHIFT);
139 return lm3554_write(flash, LM3554_TORCH_BRIGHTNESS_REG, val);
142 static int lm3554_set_flash(struct lm3554 *flash)
146 val = (flash->mode << LM3554_FLASH_MODE_SHIFT) |
147 (flash->flash_current << LM3554_FLASH_CURRENT_SHIFT);
149 return lm3554_write(flash, LM3554_FLASH_BRIGHTNESS_REG, val);
152 static int lm3554_set_duration(struct lm3554 *flash)
156 val = (flash->timeout << LM3554_FLASH_TIMEOUT_SHIFT) |
157 (flash->pdata->current_limit << LM3554_CURRENT_LIMIT_SHIFT);
159 return lm3554_write(flash, LM3554_FLASH_DURATION_REG, val);
162 static int lm3554_set_config1(struct lm3554 *flash)
166 val = (flash->pdata->envm_tx2 << LM3554_ENVM_TX2_SHIFT) |
167 (flash->pdata->tx2_polarity << LM3554_TX2_POLARITY_SHIFT);
168 return lm3554_write(flash, LM3554_CONFIG_REG_1, val);
171 /* -----------------------------------------------------------------------------
174 static void lm3554_flash_off_delay(long unsigned int arg)
176 struct v4l2_subdev *sd = i2c_get_clientdata((struct i2c_client *)arg);
177 struct lm3554 *flash = to_lm3554(sd);
178 struct lm3554_platform_data *pdata = flash->pdata;
180 gpio_set_value(pdata->gpio_strobe, 0);
183 static int lm3554_hw_strobe(struct i2c_client *client, bool strobe)
185 int ret, timer_pending;
186 struct v4l2_subdev *sd = i2c_get_clientdata(client);
187 struct lm3554 *flash = to_lm3554(sd);
188 struct lm3554_platform_data *pdata = flash->pdata;
191 * An abnormal high flash current is observed when strobe off the
192 * flash. Workaround here is firstly set flash current to lower level,
193 * wait a short moment, and then strobe off the flash.
196 timer_pending = del_timer_sync(&flash->flash_off_delay);
200 /* set current to 70mA and wait a while */
201 ret = lm3554_write(flash, LM3554_FLASH_BRIGHTNESS_REG, 0);
204 mod_timer(&flash->flash_off_delay,
205 jiffies + msecs_to_jiffies(LM3554_TIMER_DELAY));
212 * If timer is killed before run, flash is not strobe off,
213 * so must strobe off here
216 gpio_set_value(pdata->gpio_strobe, 0);
218 /* Restore flash current settings */
219 ret = lm3554_set_flash(flash);
223 /* Strobe on Flash */
224 gpio_set_value(pdata->gpio_strobe, 1);
228 dev_err(&client->dev, "failed to %s flash strobe (%d)\n",
229 strobe ? "on" : "off", ret);
233 /* -----------------------------------------------------------------------------
237 static int lm3554_read_status(struct lm3554 *flash)
240 struct i2c_client *client = v4l2_get_subdevdata(&flash->sd);
242 /* NOTE: reading register clear fault status */
243 ret = lm3554_read(flash, LM3554_FLAGS_REG);
248 * Accordingly to datasheet we read back '1' in bit 6.
251 ret &= ~LM3554_FLAG_UNUSED;
254 * Do not take TX1/TX2 signal as an error
255 * because MSIC will not turn off flash, but turn to
256 * torch mode according to gsm modem signal by hardware.
258 ret &= ~(LM3554_FLAG_TX1_INTERRUPT | LM3554_FLAG_TX2_INTERRUPT);
261 dev_dbg(&client->dev, "LM3554 flag status: %02x\n", ret);
266 static int lm3554_s_flash_timeout(struct v4l2_subdev *sd, u32 val)
268 struct lm3554 *flash = to_lm3554(sd);
270 val = clamp(val, LM3554_MIN_TIMEOUT, LM3554_MAX_TIMEOUT);
271 val = val / LM3554_TIMEOUT_STEPSIZE - 1;
273 flash->timeout = val;
275 return lm3554_set_duration(flash);
278 static int lm3554_g_flash_timeout(struct v4l2_subdev *sd, s32 *val)
280 struct lm3554 *flash = to_lm3554(sd);
282 *val = (u32)(flash->timeout + 1) * LM3554_TIMEOUT_STEPSIZE;
287 static int lm3554_s_flash_intensity(struct v4l2_subdev *sd, u32 intensity)
289 struct lm3554 *flash = to_lm3554(sd);
291 intensity = LM3554_CLAMP_PERCENTAGE(intensity);
292 intensity = LM3554_PERCENT_TO_VALUE(intensity, LM3554_FLASH_STEP);
294 flash->flash_current = intensity;
296 return lm3554_set_flash(flash);
299 static int lm3554_g_flash_intensity(struct v4l2_subdev *sd, s32 *val)
301 struct lm3554 *flash = to_lm3554(sd);
303 *val = LM3554_VALUE_TO_PERCENT((u32)flash->flash_current,
309 static int lm3554_s_torch_intensity(struct v4l2_subdev *sd, u32 intensity)
311 struct lm3554 *flash = to_lm3554(sd);
313 intensity = LM3554_CLAMP_PERCENTAGE(intensity);
314 intensity = LM3554_PERCENT_TO_VALUE(intensity, LM3554_TORCH_STEP);
316 flash->torch_current = intensity;
318 return lm3554_set_torch(flash);
321 static int lm3554_g_torch_intensity(struct v4l2_subdev *sd, s32 *val)
323 struct lm3554 *flash = to_lm3554(sd);
325 *val = LM3554_VALUE_TO_PERCENT((u32)flash->torch_current,
331 static int lm3554_s_indicator_intensity(struct v4l2_subdev *sd, u32 intensity)
333 struct lm3554 *flash = to_lm3554(sd);
335 intensity = LM3554_CLAMP_PERCENTAGE(intensity);
336 intensity = LM3554_PERCENT_TO_VALUE(intensity, LM3554_INDICATOR_STEP);
338 flash->indicator_current = intensity;
340 return lm3554_set_torch(flash);
343 static int lm3554_g_indicator_intensity(struct v4l2_subdev *sd, s32 *val)
345 struct lm3554 *flash = to_lm3554(sd);
347 *val = LM3554_VALUE_TO_PERCENT((u32)flash->indicator_current,
348 LM3554_INDICATOR_STEP);
353 static int lm3554_s_flash_strobe(struct v4l2_subdev *sd, u32 val)
355 struct i2c_client *client = v4l2_get_subdevdata(sd);
357 return lm3554_hw_strobe(client, val);
360 static int lm3554_s_flash_mode(struct v4l2_subdev *sd, u32 new_mode)
362 struct lm3554 *flash = to_lm3554(sd);
366 case ATOMISP_FLASH_MODE_OFF:
367 mode = LM3554_MODE_SHUTDOWN;
369 case ATOMISP_FLASH_MODE_FLASH:
370 mode = LM3554_MODE_FLASH;
372 case ATOMISP_FLASH_MODE_INDICATOR:
373 mode = LM3554_MODE_INDICATOR;
375 case ATOMISP_FLASH_MODE_TORCH:
376 mode = LM3554_MODE_TORCH;
382 return lm3554_set_mode(flash, mode);
385 static int lm3554_g_flash_mode(struct v4l2_subdev *sd, s32 *val)
387 struct lm3554 *flash = to_lm3554(sd);
392 static int lm3554_g_flash_status(struct v4l2_subdev *sd, s32 *val)
394 struct lm3554 *flash = to_lm3554(sd);
397 value = lm3554_read_status(flash);
401 if (value & LM3554_FLAG_TIMEOUT)
402 *val = ATOMISP_FLASH_STATUS_TIMEOUT;
404 *val = ATOMISP_FLASH_STATUS_HW_ERROR;
406 *val = ATOMISP_FLASH_STATUS_OK;
412 static int lm3554_g_flash_status_register(struct v4l2_subdev *sd, s32 *val)
414 struct lm3554 *flash = to_lm3554(sd);
417 ret = lm3554_read(flash, LM3554_FLAGS_REG);
427 static int lm3554_s_ctrl(struct v4l2_ctrl *ctrl)
430 container_of(ctrl->handler, struct lm3554, ctrl_handler);
434 case V4L2_CID_FLASH_TIMEOUT:
435 ret = lm3554_s_flash_timeout(&dev->sd, ctrl->val);
437 case V4L2_CID_FLASH_INTENSITY:
438 ret = lm3554_s_flash_intensity(&dev->sd, ctrl->val);
440 case V4L2_CID_FLASH_TORCH_INTENSITY:
441 ret = lm3554_s_torch_intensity(&dev->sd, ctrl->val);
443 case V4L2_CID_FLASH_INDICATOR_INTENSITY:
444 ret = lm3554_s_indicator_intensity(&dev->sd, ctrl->val);
446 case V4L2_CID_FLASH_STROBE:
447 ret = lm3554_s_flash_strobe(&dev->sd, ctrl->val);
449 case V4L2_CID_FLASH_MODE:
450 ret = lm3554_s_flash_mode(&dev->sd, ctrl->val);
458 static int lm3554_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
461 container_of(ctrl->handler, struct lm3554, ctrl_handler);
465 case V4L2_CID_FLASH_TIMEOUT:
466 ret = lm3554_g_flash_timeout(&dev->sd, &ctrl->val);
468 case V4L2_CID_FLASH_INTENSITY:
469 ret = lm3554_g_flash_intensity(&dev->sd, &ctrl->val);
471 case V4L2_CID_FLASH_TORCH_INTENSITY:
472 ret = lm3554_g_torch_intensity(&dev->sd, &ctrl->val);
474 case V4L2_CID_FLASH_INDICATOR_INTENSITY:
475 ret = lm3554_g_indicator_intensity(&dev->sd, &ctrl->val);
477 case V4L2_CID_FLASH_MODE:
478 ret = lm3554_g_flash_mode(&dev->sd, &ctrl->val);
480 case V4L2_CID_FLASH_STATUS:
481 ret = lm3554_g_flash_status(&dev->sd, &ctrl->val);
484 case V4L2_CID_FLASH_STATUS_REGISTER:
485 ret = lm3554_g_flash_status_register(&dev->sd, &ctrl->val);
495 static const struct v4l2_ctrl_ops ctrl_ops = {
496 .s_ctrl = lm3554_s_ctrl,
497 .g_volatile_ctrl = lm3554_g_volatile_ctrl
500 static const struct v4l2_ctrl_config lm3554_controls[] = {
503 .id = V4L2_CID_FLASH_TIMEOUT,
504 .type = V4L2_CTRL_TYPE_INTEGER,
505 .name = "Flash Timeout",
507 .max = LM3554_MAX_TIMEOUT,
509 .def = LM3554_DEFAULT_TIMEOUT,
514 .id = V4L2_CID_FLASH_INTENSITY,
515 .type = V4L2_CTRL_TYPE_INTEGER,
516 .name = "Flash Intensity",
517 .min = LM3554_MIN_PERCENT,
518 .max = LM3554_MAX_PERCENT,
520 .def = LM3554_FLASH_DEFAULT_BRIGHTNESS,
525 .id = V4L2_CID_FLASH_TORCH_INTENSITY,
526 .type = V4L2_CTRL_TYPE_INTEGER,
527 .name = "Torch Intensity",
528 .min = LM3554_MIN_PERCENT,
529 .max = LM3554_MAX_PERCENT,
531 .def = LM3554_TORCH_DEFAULT_BRIGHTNESS,
536 .id = V4L2_CID_FLASH_INDICATOR_INTENSITY,
537 .type = V4L2_CTRL_TYPE_INTEGER,
538 .name = "Indicator Intensity",
539 .min = LM3554_MIN_PERCENT,
540 .max = LM3554_MAX_PERCENT,
542 .def = LM3554_INDICATOR_DEFAULT_BRIGHTNESS,
547 .id = V4L2_CID_FLASH_STROBE,
548 .type = V4L2_CTRL_TYPE_BOOLEAN,
549 .name = "Flash Strobe",
558 .id = V4L2_CID_FLASH_MODE,
559 .type = V4L2_CTRL_TYPE_INTEGER,
560 .name = "Flash Mode",
564 .def = ATOMISP_FLASH_MODE_OFF,
569 .id = V4L2_CID_FLASH_STATUS,
570 .type = V4L2_CTRL_TYPE_BOOLEAN,
571 .name = "Flash Status",
575 .def = ATOMISP_FLASH_STATUS_OK,
581 .id = V4L2_CID_FLASH_STATUS_REGISTER,
582 .type = V4L2_CTRL_TYPE_BOOLEAN,
583 .name = "Flash Status Register",
593 /* -----------------------------------------------------------------------------
594 * V4L2 subdev core operations
597 /* Put device into known state. */
598 static int lm3554_setup(struct lm3554 *flash)
600 struct i2c_client *client = v4l2_get_subdevdata(&flash->sd);
603 /* clear the flags register */
604 ret = lm3554_read(flash, LM3554_FLAGS_REG);
608 dev_dbg(&client->dev, "Fault info: %02x\n", ret);
610 ret = lm3554_set_config1(flash);
614 ret = lm3554_set_duration(flash);
618 ret = lm3554_set_torch(flash);
622 ret = lm3554_set_flash(flash);
627 ret = lm3554_read_status(flash);
631 return ret ? -EIO : 0;
634 static int __lm3554_s_power(struct lm3554 *flash, int power)
636 struct lm3554_platform_data *pdata = flash->pdata;
639 /*initialize flash driver*/
640 gpio_set_value(pdata->gpio_reset, power);
641 usleep_range(100, 100 + 1);
644 /* Setup default values. This makes sure that the chip
645 * is in a known state.
647 ret = lm3554_setup(flash);
649 __lm3554_s_power(flash, 0);
657 static int lm3554_s_power(struct v4l2_subdev *sd, int power)
659 struct lm3554 *flash = to_lm3554(sd);
662 mutex_lock(&flash->power_lock);
664 if (flash->power_count == !power) {
665 ret = __lm3554_s_power(flash, !!power);
670 flash->power_count += power ? 1 : -1;
671 WARN_ON(flash->power_count < 0);
674 mutex_unlock(&flash->power_lock);
678 static const struct v4l2_subdev_core_ops lm3554_core_ops = {
679 .s_power = lm3554_s_power,
682 static const struct v4l2_subdev_ops lm3554_ops = {
683 .core = &lm3554_core_ops,
686 static int lm3554_detect(struct v4l2_subdev *sd)
688 struct i2c_client *client = v4l2_get_subdevdata(sd);
689 struct i2c_adapter *adapter = client->adapter;
690 struct lm3554 *flash = to_lm3554(sd);
693 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
694 dev_err(&client->dev, "lm3554_detect i2c error\n");
698 /* Power up the flash driver and reset it */
699 ret = lm3554_s_power(&flash->sd, 1);
701 dev_err(&client->dev, "Failed to power on lm3554 LED flash\n");
703 dev_dbg(&client->dev, "Successfully detected lm3554 LED flash\n");
704 lm3554_s_power(&flash->sd, 0);
710 static int lm3554_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
712 return lm3554_s_power(sd, 1);
715 static int lm3554_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
717 return lm3554_s_power(sd, 0);
720 static const struct v4l2_subdev_internal_ops lm3554_internal_ops = {
721 .registered = lm3554_detect,
723 .close = lm3554_close,
726 /* -----------------------------------------------------------------------------
731 static int lm3554_suspend(struct device *dev)
733 struct i2c_client *client = to_i2c_client(dev);
734 struct v4l2_subdev *subdev = i2c_get_clientdata(client);
735 struct lm3554 *flash = to_lm3554(subdev);
738 if (flash->power_count == 0)
741 rval = __lm3554_s_power(flash, 0);
743 dev_dbg(&client->dev, "Suspend %s\n", rval < 0 ? "failed" : "ok");
748 static int lm3554_resume(struct device *dev)
750 struct i2c_client *client = to_i2c_client(dev);
751 struct v4l2_subdev *subdev = i2c_get_clientdata(client);
752 struct lm3554 *flash = to_lm3554(subdev);
755 if (flash->power_count == 0)
758 rval = __lm3554_s_power(flash, 1);
760 dev_dbg(&client->dev, "Resume %s\n", rval < 0 ? "fail" : "ok");
767 #define lm3554_suspend NULL
768 #define lm3554_resume NULL
770 #endif /* CONFIG_PM */
772 static int lm3554_gpio_init(struct i2c_client *client)
774 struct v4l2_subdev *sd = i2c_get_clientdata(client);
775 struct lm3554 *flash = to_lm3554(sd);
776 struct lm3554_platform_data *pdata = flash->pdata;
779 if (!gpio_is_valid(pdata->gpio_reset))
782 ret = gpio_direction_output(pdata->gpio_reset, 0);
785 dev_info(&client->dev, "flash led reset successfully\n");
787 if (!gpio_is_valid(pdata->gpio_strobe)) {
789 goto err_gpio_dir_reset;
792 ret = gpio_direction_output(pdata->gpio_strobe, 0);
794 goto err_gpio_strobe;
799 gpio_free(pdata->gpio_strobe);
801 gpio_direction_output(pdata->gpio_reset, 0);
803 gpio_free(pdata->gpio_reset);
808 static int lm3554_gpio_uninit(struct i2c_client *client)
810 struct v4l2_subdev *sd = i2c_get_clientdata(client);
811 struct lm3554 *flash = to_lm3554(sd);
812 struct lm3554_platform_data *pdata = flash->pdata;
815 ret = gpio_direction_output(pdata->gpio_strobe, 0);
819 ret = gpio_direction_output(pdata->gpio_reset, 0);
823 gpio_free(pdata->gpio_strobe);
824 gpio_free(pdata->gpio_reset);
828 static void *lm3554_platform_data_func(struct i2c_client *client)
830 static struct lm3554_platform_data platform_data;
832 if (ACPI_COMPANION(&client->dev)) {
833 platform_data.gpio_reset =
834 desc_to_gpio(gpiod_get_index(&(client->dev),
835 NULL, 2, GPIOD_OUT_LOW));
836 platform_data.gpio_strobe =
837 desc_to_gpio(gpiod_get_index(&(client->dev),
838 NULL, 0, GPIOD_OUT_LOW));
839 platform_data.gpio_torch =
840 desc_to_gpio(gpiod_get_index(&(client->dev),
841 NULL, 1, GPIOD_OUT_LOW));
843 platform_data.gpio_reset = -1;
844 platform_data.gpio_strobe = -1;
845 platform_data.gpio_torch = -1;
848 dev_info(&client->dev, "camera pdata: lm3554: reset: %d strobe %d torch %d\n",
849 platform_data.gpio_reset, platform_data.gpio_strobe,
850 platform_data.gpio_torch);
852 /* Set to TX2 mode, then ENVM/TX2 pin is a power amplifier sync input:
853 * ENVM/TX pin asserted, flash forced into torch;
854 * ENVM/TX pin desserted, flash set back;
856 platform_data.envm_tx2 = 1;
857 platform_data.tx2_polarity = 0;
859 /* set peak current limit to be 1000mA */
860 platform_data.current_limit = 0;
862 return &platform_data;
865 static int lm3554_probe(struct i2c_client *client,
866 const struct i2c_device_id *id)
869 struct lm3554 *flash;
873 flash = kzalloc(sizeof(*flash), GFP_KERNEL);
875 dev_err(&client->dev, "out of memory\n");
879 flash->pdata = client->dev.platform_data;
881 if (!flash->pdata || ACPI_COMPANION(&client->dev))
882 flash->pdata = lm3554_platform_data_func(client);
884 v4l2_i2c_subdev_init(&flash->sd, client, &lm3554_ops);
885 flash->sd.internal_ops = &lm3554_internal_ops;
886 flash->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
887 flash->mode = ATOMISP_FLASH_MODE_OFF;
888 flash->timeout = LM3554_MAX_TIMEOUT / LM3554_TIMEOUT_STEPSIZE - 1;
890 v4l2_ctrl_handler_init(&flash->ctrl_handler,
891 ARRAY_SIZE(lm3554_controls));
893 dev_err(&client->dev, "error initialize a ctrl_handler.\n");
897 for (i = 0; i < ARRAY_SIZE(lm3554_controls); i++)
898 v4l2_ctrl_new_custom(&flash->ctrl_handler, &lm3554_controls[i],
901 if (flash->ctrl_handler.error) {
903 dev_err(&client->dev, "ctrl_handler error.\n");
907 flash->sd.ctrl_handler = &flash->ctrl_handler;
908 err = media_entity_pads_init(&flash->sd.entity, 0, NULL);
910 dev_err(&client->dev, "error initialize a media entity.\n");
914 flash->sd.entity.function = MEDIA_ENT_F_FLASH;
916 mutex_init(&flash->power_lock);
918 setup_timer(&flash->flash_off_delay, lm3554_flash_off_delay,
919 (unsigned long)client);
921 err = lm3554_gpio_init(client);
923 dev_err(&client->dev, "gpio request/direction_output fail");
926 if (ACPI_HANDLE(&client->dev))
927 err = atomisp_register_i2c_module(&flash->sd, NULL, LED_FLASH);
930 media_entity_cleanup(&flash->sd.entity);
931 v4l2_ctrl_handler_free(&flash->ctrl_handler);
933 v4l2_device_unregister_subdev(&flash->sd);
939 static int lm3554_remove(struct i2c_client *client)
941 struct v4l2_subdev *sd = i2c_get_clientdata(client);
942 struct lm3554 *flash = to_lm3554(sd);
945 media_entity_cleanup(&flash->sd.entity);
946 v4l2_ctrl_handler_free(&flash->ctrl_handler);
947 v4l2_device_unregister_subdev(sd);
949 atomisp_gmin_remove_subdev(sd);
951 del_timer_sync(&flash->flash_off_delay);
953 ret = lm3554_gpio_uninit(client);
961 dev_err(&client->dev, "gpio request/direction_output fail");
965 static const struct i2c_device_id lm3554_id[] = {
970 MODULE_DEVICE_TABLE(i2c, lm3554_id);
972 static const struct dev_pm_ops lm3554_pm_ops = {
973 .suspend = lm3554_suspend,
974 .resume = lm3554_resume,
977 static struct acpi_device_id lm3554_acpi_match[] = {
982 MODULE_DEVICE_TABLE(acpi, lm3554_acpi_match);
984 static struct i2c_driver lm3554_driver = {
987 .pm = &lm3554_pm_ops,
988 .acpi_match_table = ACPI_PTR(lm3554_acpi_match),
990 .probe = lm3554_probe,
991 .remove = lm3554_remove,
992 .id_table = lm3554_id,
995 static __init int init_lm3554(void)
997 return i2c_add_driver(&lm3554_driver);
1000 static __exit void exit_lm3554(void)
1002 i2c_del_driver(&lm3554_driver);
1005 module_init(init_lm3554);
1006 module_exit(exit_lm3554);
1007 MODULE_AUTHOR("Jing Tao <jing.tao@intel.com>");
1008 MODULE_DESCRIPTION("LED flash driver for LM3554");
1009 MODULE_LICENSE("GPL");