[deliverable/linux.git] / drivers / media / i2c / s5k6a3.c

/*
 * Samsung S5K6A3 image sensor driver
 *
 * Copyright (C) 2013 Samsung Electronics Co., Ltd.
 * Author: Sylwester Nawrocki <s.nawrocki@samsung.com>
 *
 * 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/clk.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/i2c.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of_gpio.h>
#include <linux/pm_runtime.h>
#include <linux/regulator/consumer.h>
#include <linux/slab.h>
#include <linux/videodev2.h>
#include <media/v4l2-async.h>
#include <media/v4l2-subdev.h>

#define S5K6A3_SENSOR_MAX_WIDTH		1412
#define S5K6A3_SENSOR_MAX_HEIGHT	1412
#define S5K6A3_SENSOR_MIN_WIDTH		32
#define S5K6A3_SENSOR_MIN_HEIGHT	32

#define S5K6A3_DEFAULT_WIDTH		1296
#define S5K6A3_DEFAULT_HEIGHT		732

#define S5K6A3_DRV_NAME			"S5K6A3"
#define S5K6A3_CLK_NAME			"extclk"
#define S5K6A3_DEFAULT_CLK_FREQ		24000000U

enum {
	S5K6A3_SUPP_VDDA,
	S5K6A3_SUPP_VDDIO,
	S5K6A3_SUPP_AFVDD,
	S5K6A3_NUM_SUPPLIES,
};

/**
 * struct s5k6a3 - fimc-is sensor data structure
 * @dev: pointer to this I2C client device structure
 * @subdev: the image sensor's v4l2 subdev
 * @pad: subdev media source pad
 * @supplies: image sensor's voltage regulator supplies
 * @gpio_reset: GPIO connected to the sensor's reset pin
 * @lock: mutex protecting the structure's members below
 * @format: media bus format at the sensor's source pad
 */
struct s5k6a3 {
	struct device *dev;
	struct v4l2_subdev subdev;
	struct media_pad pad;
	struct regulator_bulk_data supplies[S5K6A3_NUM_SUPPLIES];
	int gpio_reset;
	struct mutex lock;
	struct v4l2_mbus_framefmt format;
	struct clk *clock;
	u32 clock_frequency;
	int power_count;
};

static const char * const s5k6a3_supply_names[] = {
	[S5K6A3_SUPP_VDDA]	= "svdda",
	[S5K6A3_SUPP_VDDIO]	= "svddio",
	[S5K6A3_SUPP_AFVDD]	= "afvdd",
};

static inline struct s5k6a3 *sd_to_s5k6a3(struct v4l2_subdev *sd)
{
	return container_of(sd, struct s5k6a3, subdev);
}

static const struct v4l2_mbus_framefmt s5k6a3_formats[] = {
	{
		.code = MEDIA_BUS_FMT_SGRBG10_1X10,
		.colorspace = V4L2_COLORSPACE_SRGB,
		.field = V4L2_FIELD_NONE,
	}
};

static const struct v4l2_mbus_framefmt *find_sensor_format(
	struct v4l2_mbus_framefmt *mf)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(s5k6a3_formats); i++)
		if (mf->code == s5k6a3_formats[i].code)
			return &s5k6a3_formats[i];

	return &s5k6a3_formats[0];
}

static int s5k6a3_enum_mbus_code(struct v4l2_subdev *sd,
				  struct v4l2_subdev_pad_config *cfg,
				  struct v4l2_subdev_mbus_code_enum *code)
{
	if (code->index >= ARRAY_SIZE(s5k6a3_formats))
		return -EINVAL;

	code->code = s5k6a3_formats[code->index].code;
	return 0;
}

static void s5k6a3_try_format(struct v4l2_mbus_framefmt *mf)
{
	const struct v4l2_mbus_framefmt *fmt;

	fmt = find_sensor_format(mf);
	mf->code = fmt->code;
	mf->field = V4L2_FIELD_NONE;
	v4l_bound_align_image(&mf->width, S5K6A3_SENSOR_MIN_WIDTH,
			      S5K6A3_SENSOR_MAX_WIDTH, 0,
			      &mf->height, S5K6A3_SENSOR_MIN_HEIGHT,
			      S5K6A3_SENSOR_MAX_HEIGHT, 0, 0);
}

static struct v4l2_mbus_framefmt *__s5k6a3_get_format(
		struct s5k6a3 *sensor, struct v4l2_subdev_pad_config *cfg,
		u32 pad, enum v4l2_subdev_format_whence which)
{
	if (which == V4L2_SUBDEV_FORMAT_TRY)
		return cfg ? v4l2_subdev_get_try_format(&sensor->subdev, cfg, pad) : NULL;

	return &sensor->format;
}

static int s5k6a3_set_fmt(struct v4l2_subdev *sd,
				  struct v4l2_subdev_pad_config *cfg,
				  struct v4l2_subdev_format *fmt)
{
	struct s5k6a3 *sensor = sd_to_s5k6a3(sd);
	struct v4l2_mbus_framefmt *mf;

	s5k6a3_try_format(&fmt->format);

	mf = __s5k6a3_get_format(sensor, cfg, fmt->pad, fmt->which);
	if (mf) {
		mutex_lock(&sensor->lock);
		if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE)
			*mf = fmt->format;
		mutex_unlock(&sensor->lock);
	}
	return 0;
}

static int s5k6a3_get_fmt(struct v4l2_subdev *sd,
			  struct v4l2_subdev_pad_config *cfg,
			  struct v4l2_subdev_format *fmt)
{
	struct s5k6a3 *sensor = sd_to_s5k6a3(sd);
	struct v4l2_mbus_framefmt *mf;

	mf = __s5k6a3_get_format(sensor, cfg, fmt->pad, fmt->which);

	mutex_lock(&sensor->lock);
	fmt->format = *mf;
	mutex_unlock(&sensor->lock);
	return 0;
}

static struct v4l2_subdev_pad_ops s5k6a3_pad_ops = {
	.enum_mbus_code	= s5k6a3_enum_mbus_code,
	.get_fmt	= s5k6a3_get_fmt,
	.set_fmt	= s5k6a3_set_fmt,
};

static int s5k6a3_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
{
	struct v4l2_mbus_framefmt *format = v4l2_subdev_get_try_format(sd, fh->pad, 0);

	*format		= s5k6a3_formats[0];
	format->width	= S5K6A3_DEFAULT_WIDTH;
	format->height	= S5K6A3_DEFAULT_HEIGHT;

	return 0;
}

static const struct v4l2_subdev_internal_ops s5k6a3_sd_internal_ops = {
	.open = s5k6a3_open,
};

static int __s5k6a3_power_on(struct s5k6a3 *sensor)
{
	int i = S5K6A3_SUPP_VDDA;
	int ret;

	ret = clk_set_rate(sensor->clock, sensor->clock_frequency);
	if (ret < 0)
		return ret;

	ret = pm_runtime_get(sensor->dev);
	if (ret < 0)
		return ret;

	ret = regulator_enable(sensor->supplies[i].consumer);
	if (ret < 0)
		goto error_rpm_put;

	ret = clk_prepare_enable(sensor->clock);
	if (ret < 0)
		goto error_reg_dis;

	for (i++; i < S5K6A3_NUM_SUPPLIES; i++) {
		ret = regulator_enable(sensor->supplies[i].consumer);
		if (ret < 0)
			goto error_reg_dis;
	}

	gpio_set_value(sensor->gpio_reset, 1);
	usleep_range(600, 800);
	gpio_set_value(sensor->gpio_reset, 0);
	usleep_range(600, 800);
	gpio_set_value(sensor->gpio_reset, 1);

	/* Delay needed for the sensor initialization */
	msleep(20);
	return 0;

error_reg_dis:
	for (--i; i >= 0; --i)
		regulator_disable(sensor->supplies[i].consumer);
error_rpm_put:
	pm_runtime_put(sensor->dev);
	return ret;
}

static int __s5k6a3_power_off(struct s5k6a3 *sensor)
{
	int i;

	gpio_set_value(sensor->gpio_reset, 0);

	for (i = S5K6A3_NUM_SUPPLIES - 1; i >= 0; i--)
		regulator_disable(sensor->supplies[i].consumer);

	clk_disable_unprepare(sensor->clock);
	pm_runtime_put(sensor->dev);
	return 0;
}

static int s5k6a3_s_power(struct v4l2_subdev *sd, int on)
{
	struct s5k6a3 *sensor = sd_to_s5k6a3(sd);
	int ret = 0;

	mutex_lock(&sensor->lock);

	if (sensor->power_count == !on) {
		if (on)
			ret = __s5k6a3_power_on(sensor);
		else
			ret = __s5k6a3_power_off(sensor);

		if (ret == 0)
			sensor->power_count += on ? 1 : -1;
	}

	mutex_unlock(&sensor->lock);
	return ret;
}

static struct v4l2_subdev_core_ops s5k6a3_core_ops = {
	.s_power = s5k6a3_s_power,
};

static struct v4l2_subdev_ops s5k6a3_subdev_ops = {
	.core = &s5k6a3_core_ops,
	.pad = &s5k6a3_pad_ops,
};

static int s5k6a3_probe(struct i2c_client *client,
				const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
	struct s5k6a3 *sensor;
	struct v4l2_subdev *sd;
	int gpio, i, ret;

	sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL);
	if (!sensor)
		return -ENOMEM;

	mutex_init(&sensor->lock);
	sensor->gpio_reset = -EINVAL;
	sensor->clock = ERR_PTR(-EINVAL);
	sensor->dev = dev;

	sensor->clock = devm_clk_get(sensor->dev, S5K6A3_CLK_NAME);
	if (IS_ERR(sensor->clock))
		return PTR_ERR(sensor->clock);

	gpio = of_get_gpio_flags(dev->of_node, 0, NULL);
	if (!gpio_is_valid(gpio))
		return gpio;

	ret = devm_gpio_request_one(dev, gpio, GPIOF_OUT_INIT_LOW,
						S5K6A3_DRV_NAME);
	if (ret < 0)
		return ret;

	sensor->gpio_reset = gpio;

	if (of_property_read_u32(dev->of_node, "clock-frequency",
				 &sensor->clock_frequency)) {
		sensor->clock_frequency = S5K6A3_DEFAULT_CLK_FREQ;
		dev_info(dev, "using default %u Hz clock frequency\n",
					sensor->clock_frequency);
	}

	for (i = 0; i < S5K6A3_NUM_SUPPLIES; i++)
		sensor->supplies[i].supply = s5k6a3_supply_names[i];

	ret = devm_regulator_bulk_get(&client->dev, S5K6A3_NUM_SUPPLIES,
				      sensor->supplies);
	if (ret < 0)
		return ret;

	sd = &sensor->subdev;
	v4l2_i2c_subdev_init(sd, client, &s5k6a3_subdev_ops);
	sensor->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
	sd->internal_ops = &s5k6a3_sd_internal_ops;

	sensor->format.code = s5k6a3_formats[0].code;
	sensor->format.width = S5K6A3_DEFAULT_WIDTH;
	sensor->format.height = S5K6A3_DEFAULT_HEIGHT;

	sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
	ret = media_entity_init(&sd->entity, 1, &sensor->pad, 0);
	if (ret < 0)
		return ret;

	pm_runtime_no_callbacks(dev);
	pm_runtime_enable(dev);

	ret = v4l2_async_register_subdev(sd);

	if (ret < 0) {
		pm_runtime_disable(&client->dev);
		media_entity_cleanup(&sd->entity);
	}

	return ret;
}

static int s5k6a3_remove(struct i2c_client *client)
{
	struct v4l2_subdev *sd = i2c_get_clientdata(client);

	pm_runtime_disable(&client->dev);
	v4l2_async_unregister_subdev(sd);
	media_entity_cleanup(&sd->entity);
	return 0;
}

static const struct i2c_device_id s5k6a3_ids[] = {
	{ }
};

#ifdef CONFIG_OF
static const struct of_device_id s5k6a3_of_match[] = {
	{ .compatible = "samsung,s5k6a3" },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, s5k6a3_of_match);
#endif

static struct i2c_driver s5k6a3_driver = {
	.driver = {
		.of_match_table	= of_match_ptr(s5k6a3_of_match),
		.name		= S5K6A3_DRV_NAME,
		.owner		= THIS_MODULE,
	},
	.probe		= s5k6a3_probe,
	.remove		= s5k6a3_remove,
	.id_table	= s5k6a3_ids,
};

module_i2c_driver(s5k6a3_driver);

MODULE_DESCRIPTION("S5K6A3 image sensor subdev driver");
MODULE_AUTHOR("Sylwester Nawrocki <s.nawrocki@samsung.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
814b4dd9 SN	1	/*
	2	* Samsung S5K6A3 image sensor driver
	3	*
	4	* Copyright (C) 2013 Samsung Electronics Co., Ltd.
	5	* Author: Sylwester Nawrocki <s.nawrocki@samsung.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
	12	#include <linux/clk.h>
	13	#include <linux/delay.h>
	14	#include <linux/device.h>
	15	#include <linux/errno.h>
	16	#include <linux/gpio.h>
	17	#include <linux/i2c.h>
	18	#include <linux/kernel.h>
	19	#include <linux/module.h>
	20	#include <linux/of_gpio.h>
	21	#include <linux/pm_runtime.h>
	22	#include <linux/regulator/consumer.h>
	23	#include <linux/slab.h>
	24	#include <linux/videodev2.h>
	25	#include <media/v4l2-async.h>
	26	#include <media/v4l2-subdev.h>
	27
	28	#define S5K6A3_SENSOR_MAX_WIDTH 1412
	29	#define S5K6A3_SENSOR_MAX_HEIGHT 1412
	30	#define S5K6A3_SENSOR_MIN_WIDTH 32
	31	#define S5K6A3_SENSOR_MIN_HEIGHT 32
	32
	33	#define S5K6A3_DEFAULT_WIDTH 1296
	34	#define S5K6A3_DEFAULT_HEIGHT 732
	35
	36	#define S5K6A3_DRV_NAME "S5K6A3"
	37	#define S5K6A3_CLK_NAME "extclk"
	38	#define S5K6A3_DEFAULT_CLK_FREQ 24000000U
	39
	40	enum {
	41	S5K6A3_SUPP_VDDA,
	42	S5K6A3_SUPP_VDDIO,
	43	S5K6A3_SUPP_AFVDD,
	44	S5K6A3_NUM_SUPPLIES,
	45	};
	46
	47	/**
	48	* struct s5k6a3 - fimc-is sensor data structure
	49	* @dev: pointer to this I2C client device structure
	50	* @subdev: the image sensor's v4l2 subdev
	51	* @pad: subdev media source pad
	52	* @supplies: image sensor's voltage regulator supplies
	53	* @gpio_reset: GPIO connected to the sensor's reset pin
	54	* @lock: mutex protecting the structure's members below
	55	* @format: media bus format at the sensor's source pad
	56	*/
	57	struct s5k6a3 {
	58	struct device *dev;
	59	struct v4l2_subdev subdev;
	60	struct media_pad pad;
	61	struct regulator_bulk_data supplies[S5K6A3_NUM_SUPPLIES];
	62	int gpio_reset;
	63	struct mutex lock;
	64	struct v4l2_mbus_framefmt format;
65	struct clk *clock;
66	u32 clock_frequency;
67	int power_count;
68	};
69
70	static const char * const s5k6a3_supply_names[] = {
71	[S5K6A3_SUPP_VDDA] = "svdda",
72	[S5K6A3_SUPP_VDDIO] = "svddio",
73	[S5K6A3_SUPP_AFVDD] = "afvdd",
74	};
75
76	static inline struct s5k6a3 sd_to_s5k6a3(struct v4l2_subdev sd)
77	{
78	return container_of(sd, struct s5k6a3, subdev);
79	}
80
81	static const struct v4l2_mbus_framefmt s5k6a3_formats[] = {
82	{
f5fe58fd	83	.code = MEDIA_BUS_FMT_SGRBG10_1X10,
814b4dd9 SN	84	.colorspace = V4L2_COLORSPACE_SRGB,
	85	.field = V4L2_FIELD_NONE,
	86	}
	87	};
	88
	89	static const struct v4l2_mbus_framefmt *find_sensor_format(
	90	struct v4l2_mbus_framefmt *mf)
	91	{
	92	int i;
	93
	94	for (i = 0; i < ARRAY_SIZE(s5k6a3_formats); i++)
	95	if (mf->code == s5k6a3_formats[i].code)
	96	return &s5k6a3_formats[i];
	97
	98	return &s5k6a3_formats[0];
	99	}
	100
	101	static int s5k6a3_enum_mbus_code(struct v4l2_subdev *sd,
f7234138	102	struct v4l2_subdev_pad_config *cfg,
814b4dd9 SN	103	struct v4l2_subdev_mbus_code_enum *code)
	104	{
	105	if (code->index >= ARRAY_SIZE(s5k6a3_formats))
	106	return -EINVAL;
	107
	108	code->code = s5k6a3_formats[code->index].code;
	109	return 0;
	110	}
	111
	112	static void s5k6a3_try_format(struct v4l2_mbus_framefmt *mf)
	113	{
	114	const struct v4l2_mbus_framefmt *fmt;
	115
	116	fmt = find_sensor_format(mf);
	117	mf->code = fmt->code;
d53ce5ac	118	mf->field = V4L2_FIELD_NONE;
814b4dd9 SN	119	v4l_bound_align_image(&mf->width, S5K6A3_SENSOR_MIN_WIDTH,
	120	S5K6A3_SENSOR_MAX_WIDTH, 0,
	121	&mf->height, S5K6A3_SENSOR_MIN_HEIGHT,
	122	S5K6A3_SENSOR_MAX_HEIGHT, 0, 0);
	123	}
	124
	125	static struct v4l2_mbus_framefmt *__s5k6a3_get_format(
f7234138	126	struct s5k6a3 sensor, struct v4l2_subdev_pad_config cfg,
814b4dd9 SN	127	u32 pad, enum v4l2_subdev_format_whence which)
	128	{
	129	if (which == V4L2_SUBDEV_FORMAT_TRY)
f7234138	130	return cfg ? v4l2_subdev_get_try_format(&sensor->subdev, cfg, pad) : NULL;
814b4dd9 SN	131
	132	return &sensor->format;
	133	}
	134
	135	static int s5k6a3_set_fmt(struct v4l2_subdev *sd,
f7234138	136	struct v4l2_subdev_pad_config *cfg,
814b4dd9 SN	137	struct v4l2_subdev_format *fmt)
	138	{
	139	struct s5k6a3 *sensor = sd_to_s5k6a3(sd);
	140	struct v4l2_mbus_framefmt *mf;
	141
	142	s5k6a3_try_format(&fmt->format);
	143
f7234138	144	mf = __s5k6a3_get_format(sensor, cfg, fmt->pad, fmt->which);
814b4dd9 SN	145	if (mf) {
	146	mutex_lock(&sensor->lock);
	147	if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE)
	148	*mf = fmt->format;
	149	mutex_unlock(&sensor->lock);
	150	}
	151	return 0;
	152	}
	153
	154	static int s5k6a3_get_fmt(struct v4l2_subdev *sd,
f7234138 HV	155	struct v4l2_subdev_pad_config *cfg,
f7234138 HV	156	struct v4l2_subdev_format *fmt)
814b4dd9 SN	157	{
	158	struct s5k6a3 *sensor = sd_to_s5k6a3(sd);
	159	struct v4l2_mbus_framefmt *mf;
	160
f7234138	161	mf = __s5k6a3_get_format(sensor, cfg, fmt->pad, fmt->which);
814b4dd9 SN	162
	163	mutex_lock(&sensor->lock);
	164	fmt->format = *mf;
	165	mutex_unlock(&sensor->lock);
	166	return 0;
	167	}
	168
	169	static struct v4l2_subdev_pad_ops s5k6a3_pad_ops = {
	170	.enum_mbus_code = s5k6a3_enum_mbus_code,
	171	.get_fmt = s5k6a3_get_fmt,
	172	.set_fmt = s5k6a3_set_fmt,
	173	};
	174
	175	static int s5k6a3_open(struct v4l2_subdev sd, struct v4l2_subdev_fh fh)
	176	{
f7234138	177	struct v4l2_mbus_framefmt *format = v4l2_subdev_get_try_format(sd, fh->pad, 0);
814b4dd9 SN	178
	179	*format = s5k6a3_formats[0];
	180	format->width = S5K6A3_DEFAULT_WIDTH;
	181	format->height = S5K6A3_DEFAULT_HEIGHT;
	182
	183	return 0;
	184	}
	185
	186	static const struct v4l2_subdev_internal_ops s5k6a3_sd_internal_ops = {
	187	.open = s5k6a3_open,
	188	};
	189
	190	static int __s5k6a3_power_on(struct s5k6a3 *sensor)
	191	{
	192	int i = S5K6A3_SUPP_VDDA;
	193	int ret;
	194
	195	ret = clk_set_rate(sensor->clock, sensor->clock_frequency);
	196	if (ret < 0)
	197	return ret;
	198
	199	ret = pm_runtime_get(sensor->dev);
	200	if (ret < 0)
	201	return ret;
	202
	203	ret = regulator_enable(sensor->supplies[i].consumer);
	204	if (ret < 0)
	205	goto error_rpm_put;
	206
	207	ret = clk_prepare_enable(sensor->clock);
	208	if (ret < 0)
	209	goto error_reg_dis;
	210
	211	for (i++; i < S5K6A3_NUM_SUPPLIES; i++) {
	212	ret = regulator_enable(sensor->supplies[i].consumer);
	213	if (ret < 0)
	214	goto error_reg_dis;
	215	}
	216
	217	gpio_set_value(sensor->gpio_reset, 1);
	218	usleep_range(600, 800);
	219	gpio_set_value(sensor->gpio_reset, 0);
	220	usleep_range(600, 800);
	221	gpio_set_value(sensor->gpio_reset, 1);
	222
	223	/* Delay needed for the sensor initialization */
	224	msleep(20);
	225	return 0;
	226
	227	error_reg_dis:
	228	for (--i; i >= 0; --i)
	229	regulator_disable(sensor->supplies[i].consumer);
	230	error_rpm_put:
	231	pm_runtime_put(sensor->dev);
	232	return ret;
	233	}
	234
	235	static int __s5k6a3_power_off(struct s5k6a3 *sensor)
	236	{
	237	int i;
	238
	239	gpio_set_value(sensor->gpio_reset, 0);
	240
	241	for (i = S5K6A3_NUM_SUPPLIES - 1; i >= 0; i--)
242	regulator_disable(sensor->supplies[i].consumer);
243
244	clk_disable_unprepare(sensor->clock);
245	pm_runtime_put(sensor->dev);
246	return 0;
247	}
248
249	static int s5k6a3_s_power(struct v4l2_subdev *sd, int on)
250	{
251	struct s5k6a3 *sensor = sd_to_s5k6a3(sd);
252	int ret = 0;
253
254	mutex_lock(&sensor->lock);
255
256	if (sensor->power_count == !on) {
257	if (on)
258	ret = __s5k6a3_power_on(sensor);
259	else
260	ret = __s5k6a3_power_off(sensor);
261
262	if (ret == 0)
263	sensor->power_count += on ? 1 : -1;
264	}
265
266	mutex_unlock(&sensor->lock);
267	return ret;
268	}
269
270	static struct v4l2_subdev_core_ops s5k6a3_core_ops = {
271	.s_power = s5k6a3_s_power,
272	};
273
274	static struct v4l2_subdev_ops s5k6a3_subdev_ops = {
275	.core = &s5k6a3_core_ops,
276	.pad = &s5k6a3_pad_ops,
277	};
278
279	static int s5k6a3_probe(struct i2c_client *client,
280	const struct i2c_device_id *id)
281	{
282	struct device *dev = &client->dev;
283	struct s5k6a3 *sensor;
284	struct v4l2_subdev *sd;
285	int gpio, i, ret;
286
287	sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL);
288	if (!sensor)
289	return -ENOMEM;
290
291	mutex_init(&sensor->lock);
292	sensor->gpio_reset = -EINVAL;
293	sensor->clock = ERR_PTR(-EINVAL);
294	sensor->dev = dev;
295
296	sensor->clock = devm_clk_get(sensor->dev, S5K6A3_CLK_NAME);
297	if (IS_ERR(sensor->clock))
298	return PTR_ERR(sensor->clock);
299
300	gpio = of_get_gpio_flags(dev->of_node, 0, NULL);
301	if (!gpio_is_valid(gpio))
302	return gpio;
303
304	ret = devm_gpio_request_one(dev, gpio, GPIOF_OUT_INIT_LOW,
305	S5K6A3_DRV_NAME);
306	if (ret < 0)
307	return ret;
308
309	sensor->gpio_reset = gpio;
310
311	if (of_property_read_u32(dev->of_node, "clock-frequency",
312	&sensor->clock_frequency)) {
313	sensor->clock_frequency = S5K6A3_DEFAULT_CLK_FREQ;
314	dev_info(dev, "using default %u Hz clock frequency\n",
315	sensor->clock_frequency);
316	}
317
318	for (i = 0; i < S5K6A3_NUM_SUPPLIES; i++)
319	sensor->supplies[i].supply = s5k6a3_supply_names[i];
320
321	ret = devm_regulator_bulk_get(&client->dev, S5K6A3_NUM_SUPPLIES,
322	sensor->supplies);
323	if (ret < 0)
324	return ret;
325
326	sd = &sensor->subdev;
327	v4l2_i2c_subdev_init(sd, client, &s5k6a3_subdev_ops);
328	sensor->subdev.flags \|= V4L2_SUBDEV_FL_HAS_DEVNODE;
329	sd->internal_ops = &s5k6a3_sd_internal_ops;
330
331	sensor->format.code = s5k6a3_formats[0].code;
332	sensor->format.width = S5K6A3_DEFAULT_WIDTH;
333	sensor->format.height = S5K6A3_DEFAULT_HEIGHT;
334
335	sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
336	ret = media_entity_init(&sd->entity, 1, &sensor->pad, 0);
337	if (ret < 0)
338	return ret;
339
340	pm_runtime_no_callbacks(dev);
341	pm_runtime_enable(dev);
342
343	ret = v4l2_async_register_subdev(sd);
344
345	if (ret < 0) {
346	pm_runtime_disable(&client->dev);
347	media_entity_cleanup(&sd->entity);
348	}
349
350	return ret;
351	}
352
353	static int s5k6a3_remove(struct i2c_client *client)
354	{
355	struct v4l2_subdev *sd = i2c_get_clientdata(client);
356
357	pm_runtime_disable(&client->dev);
358	v4l2_async_unregister_subdev(sd);
359	media_entity_cleanup(&sd->entity);
360	return 0;
361	}
362
363	static const struct i2c_device_id s5k6a3_ids[] = {
364	{ }
365	};
366
367	#ifdef CONFIG_OF
368	static const struct of_device_id s5k6a3_of_match[] = {
369	{ .compatible = "samsung,s5k6a3" },
370	{ /* sentinel */ }
371	};
372	MODULE_DEVICE_TABLE(of, s5k6a3_of_match);
373	#endif
374
375	static struct i2c_driver s5k6a3_driver = {
376	.driver = {
377	.of_match_table = of_match_ptr(s5k6a3_of_match),
378	.name = S5K6A3_DRV_NAME,
379	.owner = THIS_MODULE,
380	},
381	.probe = s5k6a3_probe,
382	.remove = s5k6a3_remove,
383	.id_table = s5k6a3_ids,
384	};
385
386	module_i2c_driver(s5k6a3_driver);
387
388	MODULE_DESCRIPTION("S5K6A3 image sensor subdev driver");
389	MODULE_AUTHOR("Sylwester Nawrocki <s.nawrocki@samsung.com>");
390	MODULE_LICENSE("GPL v2");