Re: [PATCH] media: i2c: add new driver for single string flash.

From: Andy Shevchenko
Date: Mon Jan 19 2015 - 04:29:19 EST

On Mon, 2015-01-19 at 17:25 +0900, Daniel Jeong wrote:
> This patch adds the driver for the single string flash products of TI.
> Several single string flash controllers of TI have similar register map
> and bit data. This driver supports four products,lm3556, lm3561, lm3642
> and lm3648.

Why not to name it as lm3648 to be in align with other drivers?

Or even better solution (I suppose) to create a "library" and on top of
that one driver per each device?

Sakari, what do you think?

>
> Signed-off-by: Daniel Jeong <gshark.jeong@xxxxxxxxx>
> ---
> drivers/media/i2c/Kconfig | 9 +
> drivers/media/i2c/Makefile | 1 +
> drivers/media/i2c/ti-ss-flash.c | 744 +++++++++++++++++++++++++++++++++++++++
> include/media/ti-ss-flash.h | 33 ++
> 4 files changed, 787 insertions(+)
> create mode 100644 drivers/media/i2c/ti-ss-flash.c
> create mode 100644 include/media/ti-ss-flash.h
>
> diff --git a/drivers/media/i2c/Kconfig b/drivers/media/i2c/Kconfig
> index 205d713..886c1fb 100644
> --- a/drivers/media/i2c/Kconfig
> +++ b/drivers/media/i2c/Kconfig
> @@ -638,6 +638,15 @@ config VIDEO_LM3646
> This is a driver for the lm3646 dual flash controllers. It controls
> flash, torch LEDs.
>
> +config VIDEO_TI_SS_FLASH
> + tristate "TI Single String Flash driver support"
> + depends on I2C && VIDEO_V4L2 && MEDIA_CONTROLLER
> + depends on MEDIA_CAMERA_SUPPORT
> + select REGMAP_I2C
> + ---help---
> + This is a driver for the signle string flash controllers of TI.
> + It supports LM3556, LM3561, LM3642 and LM3648.
> +
> comment "Video improvement chips"
>
> config VIDEO_UPD64031A
> diff --git a/drivers/media/i2c/Makefile b/drivers/media/i2c/Makefile
> index 98589001..0e523ec 100644
> --- a/drivers/media/i2c/Makefile
> +++ b/drivers/media/i2c/Makefile
> @@ -73,6 +73,7 @@ obj-$(CONFIG_VIDEO_ADP1653) += adp1653.o
> obj-$(CONFIG_VIDEO_AS3645A) += as3645a.o
> obj-$(CONFIG_VIDEO_LM3560) += lm3560.o
> obj-$(CONFIG_VIDEO_LM3646) += lm3646.o
> +obj-$(CONFIG_VIDEO_TI_SS_FLASH) += ti-ss-flash.o
> obj-$(CONFIG_VIDEO_SMIAPP_PLL) += smiapp-pll.o
> obj-$(CONFIG_VIDEO_AK881X) += ak881x.o
> obj-$(CONFIG_VIDEO_IR_I2C) += ir-kbd-i2c.o
> diff --git a/drivers/media/i2c/ti-ss-flash.c b/drivers/media/i2c/ti-ss-flash.c
> new file mode 100644
> index 0000000..035aeba
> --- /dev/null
> +++ b/drivers/media/i2c/ti-ss-flash.c
> @@ -0,0 +1,744 @@
> +/*
> + * drivers/media/i2c/ti-ss-flash.c
> + * General device driver for Single String FLASH LED Drivers of TI
> + * It covers lm3556, lm3561, lm3642 and lm3648.
> + *
> + * Copyright (C) 2015 Texas Instruments
> + *
> + * Contact: Daniel Jeong <gshark.jeong@xxxxxxxxx>
> + * Ldd-Mlp <ldd-mlp@xxxxxxxxxxx>
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License
> + * version 2 as published by the Free Software Foundation.
> + *
> + */
> +
> +#include <linux/delay.h>
> +#include <linux/i2c.h>
> +#include <linux/module.h>
> +#include <linux/of_device.h>
> +#include <linux/regmap.h>
> +#include <linux/slab.h>
> +#include <linux/videodev2.h>
> +#include <media/ti-ss-flash.h>
> +#include <media/v4l2-ctrls.h>
> +#include <media/v4l2-device.h>
> +
> +/* operation mode */
> +enum led_opmode {
> + OPMODE_SHDN = 0x0,
> + OPMODE_INDI_IR,
> + OPMODE_TORCH,
> + OPMODE_FLASH,
> +};
> +
> +/*
> + * register data
> + * @reg : register
> + * @mask : mask bits
> + * @shift : bit shift of data
> + */
> +struct ctrl_reg {
> + unsigned int reg;
> + unsigned int mask;
> + unsigned int shift;
> +};
> +
> +/*
> + * unit data
> + * @min : min value of brightness or timeout
> + * brightness : uA
> + * timeout : ms
> + * @step : step value of brightness or timeout
> + * brightness : uA
> + * timeout : ms
> + * @knee: knee point of step of brightness/timeout
> + * brightness : uA
> + * timeout : ms
> + * @knee_step : step value of brightness or timeout after knee point
> + * brightness : uA
> + * timeout : ms
> + * @max : max value of brightness or timeout
> + * brightness : uA
> + * timeout : ms
> + * @ctrl : register info to control brightness or timeout
> + */
> +struct ssflash_config {
> + unsigned int min;
> + unsigned int step;
> + unsigned int knee;
> + unsigned int knee_step;
> + unsigned int max;
> + struct ctrl_reg ctrl;
> +};
> +
> +/*
> + * @reg : fault register
> + * @mask : fault mask bit
> + * @v4l2_fault : bit mapping to V4L2_FLASH_FAULT_
> + * refer to include//uapi/linux/v4l2-controls.h
> + */
> +struct ssflash_fault {
> + unsigned int reg;
> + unsigned int mask;
> + unsigned int v4l2_fault;
> +};
> +
> +#define NUM_V4L2_FAULT 9
> +
> +/*
> + * ssflash data
> + * @name: device name
> + * @mode: operation mode control data
> + * @flash_br: flash brightness register and bit data
> + * @timeout: timeout control data
> + * @strobe: strobe control data
> + * @torch_br: torch brightness register and bit data
> + * @fault: fault data
> + * @func: initialize function
> + */
> +struct ssflash_data {
> + char *name;
> + struct ctrl_reg mode;
> + struct ssflash_config flash_br;
> + struct ssflash_config timeout;
> + struct ctrl_reg strobe;
> +
> + struct ssflash_config torch_br;
> + struct ssflash_fault fault[NUM_V4L2_FAULT];
> +
> + int (*func)(struct regmap *regmap);
> +};
> +
> +/*
> + * struct ssflash_flash
> + * @dev: device
> + * @regmap: reg map for interface
> + * @ctrls_led: V4L2 contols
> + * @subdev_led: V4L2 subdev
> + * @data : chip control data
> + * @mode_reg: value of mode register
> + */
> +struct ssflash_flash {
> + struct device *dev;
> + struct regmap *regmap;
> +
> + struct v4l2_ctrl_handler ctrls_led;
> + struct v4l2_subdev subdev_led;
> + const struct ssflash_data *data;
> + u8 mode_reg;
> +};
> +
> +#define to_ssflash_flash(_ctrl) \
> + container_of(_ctrl->handler, struct ssflash_flash, ctrls_led)
> +
> +static const struct ssflash_data flash_lm3556 = {
> + .name = LM3556_NAME,
> + .mode = {
> + .reg = 0x0a, .mask = 0x03, .shift = 0
> + },
> + .flash_br = {
> + .min = 93750, .step = 93750,
> + .max = 1500000,
> + .ctrl = {
> + .reg = 0x09, .mask = 0xf, .shift = 0
> + },
> + },
> + .timeout = {
> + .min = 100, .step = 100,
> + .max = 800,
> + .ctrl = {
> + .reg = 0x08, .mask = 0x07, .shift = 0
> + }
> + },
> + .torch_br = {
> + .min = 46880, .step = 46880,
> + .max = 375000,
> + .ctrl = {
> + .reg = 0x09, .mask = 0x70, .shift = 4
> + }
> + },
> + .strobe = {
> + .reg = 0x0a, .mask = 0x20, .shift = 5
> + },
> + .fault = {
> + [0] = {
> + .reg = 0x0b, .mask = 0x01,
> + .v4l2_fault = V4L2_FLASH_FAULT_TIMEOUT,
> + },
> + [1] = {
> + .reg = 0x0b, .mask = 0x02,
> + .v4l2_fault = V4L2_FLASH_FAULT_OVER_TEMPERATURE,
> + },
> + [2] = {
> + .reg = 0x0b, .mask = 0x04,
> + .v4l2_fault = V4L2_FLASH_FAULT_SHORT_CIRCUIT,
> + },
> + [3] = {
> + .reg = 0x0b, .mask = 0x08,
> + .v4l2_fault = V4L2_FLASH_FAULT_OVER_VOLTAGE,
> + },
> +
> + [4] = {
> + .reg = 0x0b, .mask = 0x10,
> + .v4l2_fault = V4L2_FLASH_FAULT_UNDER_VOLTAGE,
> + },
> + [5] = {
> + .reg = 0x0b, .mask = 0x20,
> + .v4l2_fault = V4L2_FLASH_FAULT_INPUT_VOLTAGE,
> + },
> + },
> + .func = NULL
> +};
> +
> +static const struct ssflash_data flash_lm3561 = {
> + .name = LM3561_NAME,
> + .mode = {
> + .reg = 0x10, .mask = 0x03, .shift = 0
> + },
> + .flash_br = {
> + .min = 36000, .step = 37600,
> + .max = 600000,
> + .ctrl = {
> + .reg = 0xb0, .mask = 0xf, .shift = 0
> + },
> + },
> + .timeout = {
> + .min = 32, .step = 32,
> + .max = 1024,
> + .ctrl = {
> + .reg = 0xc0, .mask = 0x1f, .shift = 0
> + }
> + },
> + .torch_br = {
> + .min = 18000, .step = 18800,
> + .max = 149600,
> + .ctrl = {
> + .reg = 0xa0, .mask = 0x07, .shift = 0
> + }
> + },
> + .strobe = {
> + .reg = 0xe0, .mask = 0x04, .shift = 2
> + },
> + .fault = {
> + [0] = {
> + .reg = 0xd0, .mask = 0x01,
> + .v4l2_fault = V4L2_FLASH_FAULT_TIMEOUT,
> + },
> + [1] = {
> + .reg = 0xd0, .mask = 0x02,
> + .v4l2_fault = V4L2_FLASH_FAULT_OVER_TEMPERATURE,
> + },
> + [2] = {
> + .reg = 0xd0, .mask = 0x04,
> + .v4l2_fault = V4L2_FLASH_FAULT_SHORT_CIRCUIT,
> + },
> + [3] = {
> + .reg = 0xd0, .mask = 0x20,
> + .v4l2_fault = V4L2_FLASH_FAULT_LED_OVER_TEMPERATURE,
> + },
> + [4] = {
> + .reg = 0xd0, .mask = 0x80,
> + .v4l2_fault = V4L2_FLASH_FAULT_INPUT_VOLTAGE,
> + },
> + },
> + .func = NULL
> +};
> +
> +static const struct ssflash_data flash_lm3642 = {
> + .name = LM3642_NAME,
> + .mode = {
> + .reg = 0x0a, .mask = 0x03, .shift = 0
> + },
> + .flash_br = {
> + .min = 93750, .step = 93750,
> + .max = 1500000,
> + .ctrl = {
> + .reg = 0x09, .mask = 0xf, .shift = 0
> + },
> + },
> + .timeout = {
> + .min = 100, .step = 100,
> + .max = 800,
> + .ctrl = {
> + .reg = 0x08, .mask = 0x07, .shift = 0
> + }
> + },
> + .torch_br = {
> + .min = 46880, .step = 46880,
> + .max = 375000,
> + .ctrl = {
> + .reg = 0x09, .mask = 0x70, .shift = 4
> + }
> + },
> + .strobe = {
> + .reg = 0x0a, .mask = 0x20, .shift = 5
> + },
> + .fault = {
> + [0] = {
> + .reg = 0x0b, .mask = 0x01,
> + .v4l2_fault = V4L2_FLASH_FAULT_TIMEOUT,
> + },
> + [1] = {
> + .reg = 0x0b, .mask = 0x02,
> + .v4l2_fault = V4L2_FLASH_FAULT_OVER_TEMPERATURE,
> + },
> + [2] = {
> + .reg = 0x0b, .mask = 0x04,
> + .v4l2_fault = V4L2_FLASH_FAULT_SHORT_CIRCUIT,
> + },
> + [3] = {
> + .reg = 0x0b, .mask = 0x20,
> + .v4l2_fault = V4L2_FLASH_FAULT_INPUT_VOLTAGE,
> + },
> + },
> + .func = NULL
> +};
> +
> +static int ssflash_lm3648_init(struct regmap *regmap)
> +{
> + int rval;
> +
> + /* enable LED */
> + rval = regmap_update_bits(regmap, 0x01, 0x03, 0x03);
> + /* bit[7:6] must be set to 10b for proper operation */
> + rval |= regmap_update_bits(regmap, 0x03, 0xc0, 0x80);
> + /* bit[7] must be set to 1b for proper operation */
> + rval |= regmap_update_bits(regmap, 0x05, 0x80, 0x80);
> + if (rval < 0)
> + return rval;
> + return 0;
> +}
> +
> +static const struct ssflash_data flash_lm3648 = {
> + .name = LM3648_NAME,
> + .mode = {
> + .reg = 0x01, .mask = 0x0c, .shift = 2
> + },
> + .flash_br = {
> + .min = 21800, .step = 23450,
> + .max = 1500000,
> + .ctrl = {
> + .reg = 0x03, .mask = 0x3f, .shift = 0
> + },
> + },
> + .timeout = {
> + .min = 10, .step = 10,
> + .knee = 100, .knee_step = 50,
> + .max = 1024,
> + .ctrl = {
> + .reg = 0x08, .mask = 0x0f, .shift = 0
> + }
> + },
> + .torch_br = {
> + .min = 1954, .step = 2800,
> + .max = 357600,
> + .ctrl = {
> + .reg = 0x5, .mask = 0x7f, .shift = 0
> + }
> + },
> + .strobe = {
> + .reg = 0x1, .mask = 0x20, .shift = 5
> + },
> + .fault = {
> + [0] = {
> + .reg = 0x0a, .mask = 0x01,
> + .v4l2_fault = V4L2_FLASH_FAULT_TIMEOUT,
> + },
> + [1] = {
> + .reg = 0x0a, .mask = 0x04,
> + .v4l2_fault = V4L2_FLASH_FAULT_OVER_TEMPERATURE,
> + },
> + [2] = {
> + .reg = 0x0a, .mask = 0x70,
> + .v4l2_fault = V4L2_FLASH_FAULT_SHORT_CIRCUIT,
> + },
> + [3] = {
> + .reg = 0x0b, .mask = 0x04,
> + .v4l2_fault = V4L2_FLASH_FAULT_INPUT_VOLTAGE,
> + },
> + [4] = {
> + .reg = 0x0b, .mask = 0x01,
> + .v4l2_fault = V4L2_FLASH_FAULT_LED_OVER_TEMPERATURE,
> + },
> + },
> + .func = ssflash_lm3648_init
> +};
> +
> +static u8 ssflash_conv_val_to_reg(unsigned int val,
> + unsigned int min, unsigned int step,
> + unsigned int knee, unsigned int knee_step,
> + unsigned int max)
> +{
> + if (val >= max)
> + return 0xff;
> +
> + if (knee <= min)
> + return (u8)(val < min ? 0 : (val - min)/step);
> + return (u8)val < min ? 0 :
> + (val < knee ? (val-min)/step :
> + (val-knee)/knee_step + (knee-min)/step);
> +}
> +
> +/* mode control */
> +static int ssflash_mode_ctrl(struct ssflash_flash *flash,
> + enum v4l2_flash_led_mode v4l_led_mode)
> +{
> + const struct ssflash_data *data = flash->data;
> + enum led_opmode opmode;
> +
> + switch (v4l_led_mode) {
> + case V4L2_FLASH_LED_MODE_NONE:
> + opmode = OPMODE_SHDN;
> + break;
> + case V4L2_FLASH_LED_MODE_TORCH:
> + opmode = OPMODE_TORCH;
> + break;
> + case V4L2_FLASH_LED_MODE_FLASH:
> + opmode = OPMODE_FLASH;
> + break;
> + default:
> + return -EINVAL;
> + }
> + return regmap_update_bits(flash->regmap, data->mode.reg,
> + data->mode.mask, opmode << data->mode.shift);
> +}
> +
> +/* torch brightness control */
> +static int ssflash_torch_brt_ctrl
> + (struct ssflash_flash *flash, unsigned int brt)
> +{
> + const struct ssflash_data *data = flash->data;
> + int rval;
> + u8 br_bits;
> +
> + br_bits = ssflash_conv_val_to_reg(brt,
> + data->torch_br.min, data->torch_br.step,
> + data->torch_br.knee, data->torch_br.knee_step,
> + data->torch_br.max);
> +
> + rval = regmap_update_bits(flash->regmap,
> + data->torch_br.ctrl.reg,
> + data->torch_br.ctrl.mask,
> + br_bits << data->torch_br.ctrl.shift);
> +
> + return rval;
> +}
> +
> +/* flash brightness control */
> +static int ssflash_flash_brt_ctrl(struct ssflash_flash *flash,
> + unsigned int brt)
> +{
> + const struct ssflash_data *data = flash->data;
> + int rval;
> + u8 br_bits;
> +
> + br_bits = ssflash_conv_val_to_reg(brt,
> + data->flash_br.min,
> + data->flash_br.step,
> + data->flash_br.knee,
> + data->flash_br.knee_step,
> + data->flash_br.max);
> +
> + rval = regmap_update_bits(flash->regmap,
> + data->flash_br.ctrl.reg,
> + data->flash_br.ctrl.mask,
> + br_bits << data->flash_br.ctrl.shift);
> +
> + return rval;
> +}
> +
> +/* fault status */
> +static int ssflash_get_ctrl(struct v4l2_ctrl *ctrl)
> +{
> + struct ssflash_flash *flash = to_ssflash_flash(ctrl);
> + const struct ssflash_data *data = flash->data;
> + int rval = -EINVAL;
> +
> + if (ctrl->id == V4L2_CID_FLASH_FAULT) {
> + int icnt;
> + s32 fault = 0;
> + unsigned int reg_val;
> + unsigned int reg = 0xfff;
> +
> + for (icnt = 0; icnt < NUM_V4L2_FAULT; icnt++) {
> + if (data->fault[icnt].mask == 0x0)
> + continue;
> + if (data->fault[icnt].reg != reg) {
> + reg = data->fault[icnt].reg;
> + rval = regmap_read(
> + flash->regmap, reg, &reg_val);
> + if (rval < 0)
> + goto out;
> + }
> + if (rval & data->fault[icnt].mask)
> + fault |= data->fault[icnt].v4l2_fault;
> + }
> + ctrl->cur.val = fault;
> + }
> +
> +out:
> + return rval;
> +}
> +
> +static int ssflash_set_ctrl(struct v4l2_ctrl *ctrl)
> +{
> + struct ssflash_flash *flash = to_ssflash_flash(ctrl);
> + const struct ssflash_data *data = flash->data;
> + u8 tout_bits;
> + unsigned int reg_val;
> + int rval = -EINVAL;
> +
> + switch (ctrl->id) {
> + case V4L2_CID_FLASH_LED_MODE:
> + if (ctrl->val != V4L2_FLASH_LED_MODE_FLASH)
> + return ssflash_mode_ctrl(flash, ctrl->val);
> + /* switch to SHDN mode before flash strobe on */
> + return ssflash_mode_ctrl(flash, V4L2_FLASH_LED_MODE_NONE);
> +
> + case V4L2_CID_FLASH_TORCH_INTENSITY:
> + return ssflash_torch_brt_ctrl(flash, ctrl->val);
> +
> + case V4L2_CID_FLASH_INTENSITY:
> + return ssflash_flash_brt_ctrl(flash, ctrl->val);
> +
> + case V4L2_CID_FLASH_STROBE_SOURCE:
> + return regmap_update_bits(flash->regmap,
> + data->strobe.reg, data->strobe.mask,
> + (ctrl->val) << data->strobe.shift);
> +
> + case V4L2_CID_FLASH_STROBE:
> + /* read and check current mode of chip to start flash */
> + rval = regmap_read(flash->regmap, data->mode.reg, &reg_val);
> + if (rval < 0 ||
> + (((reg_val & data->mode.mask)>>data->mode.shift)
> + != OPMODE_SHDN))
> + return rval;
> + /* flash on */
> + return ssflash_mode_ctrl(flash,
> + V4L2_FLASH_LED_MODE_FLASH);
> +
> + case V4L2_CID_FLASH_STROBE_STOP:
> + /*
> + * flash mode will be turned automatically
> + * from FLASH mode to SHDN mode after flash duration timeout
> + * read and check current mode of chip to stop flash
> + */
> + rval = regmap_read(flash->regmap, data->mode.reg, &reg_val);
> + if (rval < 0)
> + return rval;
> + if (((reg_val & data->mode.mask)
> + >> data->mode.shift) == OPMODE_FLASH)
> + return ssflash_mode_ctrl(flash,
> + V4L2_FLASH_LED_MODE_NONE);
> + return rval;
> +
> + case V4L2_CID_FLASH_TIMEOUT:
> + tout_bits = ssflash_conv_val_to_reg(ctrl->val,
> + data->timeout.min,
> + data->timeout.step,
> + data->timeout.knee,
> + data->timeout.knee_step,
> + data->timeout.max);
> +
> + return regmap_update_bits(flash->regmap,
> + data->timeout.ctrl.reg,
> + data->timeout.ctrl.mask,
> + tout_bits << data->timeout.ctrl.shift);
> + }
> +
> + return rval;
> +}
> +
> +static int ssflash_led_get_ctrl(struct v4l2_ctrl *ctrl)
> +{
> + return ssflash_get_ctrl(ctrl);
> +}
> +
> +static int ssflash_led_set_ctrl(struct v4l2_ctrl *ctrl)
> +{
> + return ssflash_set_ctrl(ctrl);
> +}
> +
> +static const struct v4l2_ctrl_ops ssflash_led_ctrl_ops = {
> + .g_volatile_ctrl = ssflash_led_get_ctrl,
> + .s_ctrl = ssflash_led_set_ctrl,
> +};
> +
> +static int ssflash_init_controls(struct ssflash_flash *flash)
> +{
> + struct v4l2_ctrl *fault;
> + struct v4l2_ctrl_handler *hdl = &flash->ctrls_led;
> + const struct v4l2_ctrl_ops *ops = &ssflash_led_ctrl_ops;
> + const struct ssflash_data *data = flash->data;
> + s64 fault_max = 0;
> + int icnt;
> +
> + v4l2_ctrl_handler_init(hdl, 8);
> + /* flash mode */
> + v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_FLASH_LED_MODE,
> + V4L2_FLASH_LED_MODE_TORCH, ~0x7,
> + V4L2_FLASH_LED_MODE_NONE);
> + /* flash source */
> + v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_FLASH_STROBE_SOURCE,
> + 0x1, ~0x3, V4L2_FLASH_STROBE_SOURCE_SOFTWARE);
> + /* flash strobe */
> + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_STROBE, 0, 0, 0, 0);
> + /* flash strobe stop */
> + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_STROBE_STOP, 0, 0, 0, 0);
> + /* flash strobe timeout */
> + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_TIMEOUT,
> + data->timeout.min,
> + data->timeout.max,
> + data->timeout.step,
> + data->timeout.max);
> + /* flash brt */
> + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_INTENSITY,
> + data->flash_br.min,
> + data->flash_br.max,
> + data->flash_br.step,
> + data->flash_br.max);
> + /* torch brt */
> + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_TORCH_INTENSITY,
> + data->torch_br.min,
> + data->torch_br.max,
> + data->torch_br.step,
> + data->torch_br.max);
> + /* fault */
> + for (icnt = 0; icnt < NUM_V4L2_FAULT; icnt++)
> + fault_max |= data->fault[icnt].v4l2_fault;
> + fault = v4l2_ctrl_new_std(hdl,
> + ops, V4L2_CID_FLASH_FAULT, 0, fault_max, 0, 0);
> + if (fault != NULL)
> + fault->flags |= V4L2_CTRL_FLAG_VOLATILE;
> +
> + if (hdl->error)
> + return hdl->error;
> +
> + flash->subdev_led.ctrl_handler = hdl;
> + return 0;
> +}
> +
> +/* initialize device */
> +static const struct v4l2_subdev_ops ssflash_ops = {
> + .core = NULL,
> +};
> +
> +static const struct regmap_config ssflash_regmap = {
> + .reg_bits = 8,
> + .val_bits = 8,
> + .max_register = 0xff,
> +};
> +
> +static int ssflash_subdev_init(struct ssflash_flash *flash)
> +{
> + struct i2c_client *client = to_i2c_client(flash->dev);
> + int rval;
> +
> + v4l2_i2c_subdev_init(&flash->subdev_led, client, &ssflash_ops);
> + flash->subdev_led.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
> + strcpy(flash->subdev_led.name, flash->data->name);
> +
> + rval = ssflash_init_controls(flash);
> + if (rval)
> + goto err_out;
> +
> + rval = media_entity_init(&flash->subdev_led.entity, 0, NULL, 0);
> + if (rval < 0)
> + goto err_out;
> +
> + flash->subdev_led.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_FLASH;
> + return rval;
> +
> +err_out:
> + v4l2_ctrl_handler_free(&flash->ctrls_led);
> + return rval;
> +}
> +
> +static int ssflash_init_device(struct ssflash_flash *flash)
> +{
> + int rval;
> +
> + /* output disable */
> + rval = ssflash_mode_ctrl(flash, V4L2_FLASH_LED_MODE_NONE);
> + if (rval < 0)
> + return rval;
> +
> + if (flash->data->func != NULL) {
> + rval = flash->data->func(flash->regmap);
> + if (rval < 0)
> + return rval;
> + }
> +
> + return rval;
> +}
> +
> +static int ssflash_probe(struct i2c_client *client,
> + const struct i2c_device_id *devid)
> +{
> + struct ssflash_flash *flash;
> + int rval;
> +
> + flash = devm_kzalloc(&client->dev, sizeof(*flash), GFP_KERNEL);
> + if (flash == NULL)
> + return -ENOMEM;
> +
> + flash->regmap = devm_regmap_init_i2c(client, &ssflash_regmap);
> + if (IS_ERR(flash->regmap)) {
> + rval = PTR_ERR(flash->regmap);
> + return rval;
> + }
> +
> + flash->dev = &client->dev;
> + flash->data = (const struct ssflash_data *)devid->driver_data;
> +
> + rval = ssflash_subdev_init(flash);
> + if (rval < 0)
> + return rval;
> +
> + rval = ssflash_init_device(flash);
> + if (rval < 0)
> + return rval;
> +
> + i2c_set_clientdata(client, flash);
> +
> + return 0;
> +}
> +
> +static int ssflash_remove(struct i2c_client *client)
> +{
> + struct ssflash_flash *flash = i2c_get_clientdata(client);
> +
> + v4l2_device_unregister_subdev(&flash->subdev_led);
> + v4l2_ctrl_handler_free(&flash->ctrls_led);
> + media_entity_cleanup(&flash->subdev_led.entity);
> +
> + return 0;
> +}
> +
> +static const struct i2c_device_id ssflash_id_table[] = {
> + {LM3556_NAME, (unsigned long)&flash_lm3556},
> + {LM3561_NAME, (unsigned long)&flash_lm3561},
> + {LM3642_NAME, (unsigned long)&flash_lm3642},
> + {LM3648_NAME, (unsigned long)&flash_lm3648},
> + {}
> +};
> +
> +MODULE_DEVICE_TABLE(i2c, ssflash_id_table);
> +
> +static struct i2c_driver ssflash_i2c_driver = {
> + .driver = {
> + .name = SINGLE_STRING_FLASH_NAME,
> + },
> + .probe = ssflash_probe,
> + .remove = ssflash_remove,
> + .id_table = ssflash_id_table,
> +};
> +
> +module_i2c_driver(ssflash_i2c_driver);
> +
> +MODULE_AUTHOR("Daniel Jeong <gshark.jeong@xxxxxxxxx>");
> +MODULE_AUTHOR("Ldd Mlp <ldd-mlp@xxxxxxxxxxx>");
> +MODULE_DESCRIPTION("Texas Instruments single string LED flash driver");
> +MODULE_LICENSE("GPL");
> diff --git a/include/media/ti-ss-flash.h b/include/media/ti-ss-flash.h
> new file mode 100644
> index 0000000..505b33f
> --- /dev/null
> +++ b/include/media/ti-ss-flash.h
> @@ -0,0 +1,33 @@
> +/*
> + * include/media/ti-ss-flash.h
> + *
> + * Copyright (C) 2014 Texas Instruments
> + *
> + * Contact: Daniel Jeong <gshark.jeong@xxxxxxxxx>
> + * Ldd-Mlp <ldd-mlp@xxxxxxxxxxx>
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License
> + * version 2 as published by the Free Software Foundation.
> + */
> +
> +#ifndef __TI_SS_FLASH_H__
> +#define __TI_SS_FLASH_H__
> +
> +#include <media/v4l2-subdev.h>
> +
> +#define LM3556_NAME "lm3556"
> +#define LM3556_I2C_ADDR (0x63)
> +
> +#define LM3561_NAME "lm3561"
> +#define LM3561_I2C_ADDR (0x53)
> +
> +#define LM3642_NAME "lm3642"
> +#define LM3642_I2C_ADDR (0x63)
> +
> +#define LM3648_NAME "lm3648"
> +#define LM3648_I2C_ADDR (0x63)
> +
> +#define SINGLE_STRING_FLASH_NAME "ti_ss_flash"
> +
> +#endif /* __TI_SS_FLASH_H__ */


--
Andy Shevchenko <andriy.shevchenko@xxxxxxxxx>
Intel Finland Oy

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/