[linux-2.6-block.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
 * @clock: pointer to &struct clk.
 * @clock_frequency: clock frequency
 * @power_count: stores state if device is powered
 */
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);
		*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 const 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 const struct v4l2_subdev_core_ops s5k6a3_core_ops = {
	.s_power = s5k6a3_s_power,
};

static const 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;

	sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;
	sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
	ret = media_entity_pads_init(&sd->entity, 1, &sensor->pad);
	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[] = {
	{ }
};
MODULE_DEVICE_TABLE(i2c, 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,
	},
	.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
7cd18369 MCC	56	* @clock: pointer to &struct clk.
	57	* @clock_frequency: clock frequency
	58	* @power_count: stores state if device is powered
814b4dd9 SN	59	*/
	60	struct s5k6a3 {
	61	struct device *dev;
	62	struct v4l2_subdev subdev;
	63	struct media_pad pad;
	64	struct regulator_bulk_data supplies[S5K6A3_NUM_SUPPLIES];
	65	int gpio_reset;
	66	struct mutex lock;
	67	struct v4l2_mbus_framefmt format;
	68	struct clk *clock;
	69	u32 clock_frequency;
	70	int power_count;
	71	};
	72
	73	static const char * const s5k6a3_supply_names[] = {
	74	[S5K6A3_SUPP_VDDA] = "svdda",
	75	[S5K6A3_SUPP_VDDIO] = "svddio",
	76	[S5K6A3_SUPP_AFVDD] = "afvdd",
	77	};
	78
	79	static inline struct s5k6a3 sd_to_s5k6a3(struct v4l2_subdev sd)
	80	{
	81	return container_of(sd, struct s5k6a3, subdev);
	82	}
	83
	84	static const struct v4l2_mbus_framefmt s5k6a3_formats[] = {
	85	{
f5fe58fd	86	.code = MEDIA_BUS_FMT_SGRBG10_1X10,
814b4dd9 SN	87	.colorspace = V4L2_COLORSPACE_SRGB,
	88	.field = V4L2_FIELD_NONE,
	89	}
	90	};
	91
	92	static const struct v4l2_mbus_framefmt *find_sensor_format(
	93	struct v4l2_mbus_framefmt *mf)
	94	{
	95	int i;
	96
	97	for (i = 0; i < ARRAY_SIZE(s5k6a3_formats); i++)
	98	if (mf->code == s5k6a3_formats[i].code)
	99	return &s5k6a3_formats[i];
	100
	101	return &s5k6a3_formats[0];
	102	}
	103
	104	static int s5k6a3_enum_mbus_code(struct v4l2_subdev *sd,
f7234138	105	struct v4l2_subdev_pad_config *cfg,
814b4dd9 SN	106	struct v4l2_subdev_mbus_code_enum *code)
	107	{
	108	if (code->index >= ARRAY_SIZE(s5k6a3_formats))
	109	return -EINVAL;
	110
	111	code->code = s5k6a3_formats[code->index].code;
	112	return 0;
	113	}
	114
	115	static void s5k6a3_try_format(struct v4l2_mbus_framefmt *mf)
	116	{
	117	const struct v4l2_mbus_framefmt *fmt;
	118
	119	fmt = find_sensor_format(mf);
	120	mf->code = fmt->code;
d53ce5ac	121	mf->field = V4L2_FIELD_NONE;
814b4dd9 SN	122	v4l_bound_align_image(&mf->width, S5K6A3_SENSOR_MIN_WIDTH,
	123	S5K6A3_SENSOR_MAX_WIDTH, 0,
	124	&mf->height, S5K6A3_SENSOR_MIN_HEIGHT,
	125	S5K6A3_SENSOR_MAX_HEIGHT, 0, 0);
	126	}
	127
	128	static struct v4l2_mbus_framefmt *__s5k6a3_get_format(
f7234138	129	struct s5k6a3 sensor, struct v4l2_subdev_pad_config cfg,
814b4dd9 SN	130	u32 pad, enum v4l2_subdev_format_whence which)
	131	{
	132	if (which == V4L2_SUBDEV_FORMAT_TRY)
f7234138	133	return cfg ? v4l2_subdev_get_try_format(&sensor->subdev, cfg, pad) : NULL;
814b4dd9 SN	134
	135	return &sensor->format;
	136	}
	137
	138	static int s5k6a3_set_fmt(struct v4l2_subdev *sd,
f7234138	139	struct v4l2_subdev_pad_config *cfg,
814b4dd9 SN	140	struct v4l2_subdev_format *fmt)
	141	{
	142	struct s5k6a3 *sensor = sd_to_s5k6a3(sd);
	143	struct v4l2_mbus_framefmt *mf;
	144
	145	s5k6a3_try_format(&fmt->format);
	146
f7234138	147	mf = __s5k6a3_get_format(sensor, cfg, fmt->pad, fmt->which);
814b4dd9 SN	148	if (mf) {
814b4dd9 SN	149	mutex_lock(&sensor->lock);
4e63959e	150	*mf = fmt->format;
814b4dd9 SN	151	mutex_unlock(&sensor->lock);
	152	}
	153	return 0;
	154	}
	155
	156	static int s5k6a3_get_fmt(struct v4l2_subdev *sd,
f7234138 HV	157	struct v4l2_subdev_pad_config *cfg,
f7234138 HV	158	struct v4l2_subdev_format *fmt)
814b4dd9 SN	159	{
	160	struct s5k6a3 *sensor = sd_to_s5k6a3(sd);
	161	struct v4l2_mbus_framefmt *mf;
	162
f7234138	163	mf = __s5k6a3_get_format(sensor, cfg, fmt->pad, fmt->which);
814b4dd9 SN	164
	165	mutex_lock(&sensor->lock);
	166	fmt->format = *mf;
	167	mutex_unlock(&sensor->lock);
	168	return 0;
	169	}
	170
7c137c60	171	static const struct v4l2_subdev_pad_ops s5k6a3_pad_ops = {
814b4dd9 SN	172	.enum_mbus_code = s5k6a3_enum_mbus_code,
	173	.get_fmt = s5k6a3_get_fmt,
	174	.set_fmt = s5k6a3_set_fmt,
	175	};
	176
	177	static int s5k6a3_open(struct v4l2_subdev sd, struct v4l2_subdev_fh fh)
	178	{
f7234138	179	struct v4l2_mbus_framefmt *format = v4l2_subdev_get_try_format(sd, fh->pad, 0);
814b4dd9 SN	180
	181	*format = s5k6a3_formats[0];
	182	format->width = S5K6A3_DEFAULT_WIDTH;
	183	format->height = S5K6A3_DEFAULT_HEIGHT;
	184
	185	return 0;
	186	}
	187
	188	static const struct v4l2_subdev_internal_ops s5k6a3_sd_internal_ops = {
	189	.open = s5k6a3_open,
	190	};
	191
	192	static int __s5k6a3_power_on(struct s5k6a3 *sensor)
	193	{
	194	int i = S5K6A3_SUPP_VDDA;
	195	int ret;
	196
	197	ret = clk_set_rate(sensor->clock, sensor->clock_frequency);
	198	if (ret < 0)
	199	return ret;
	200
	201	ret = pm_runtime_get(sensor->dev);
	202	if (ret < 0)
	203	return ret;
	204
	205	ret = regulator_enable(sensor->supplies[i].consumer);
	206	if (ret < 0)
	207	goto error_rpm_put;
	208
	209	ret = clk_prepare_enable(sensor->clock);
	210	if (ret < 0)
	211	goto error_reg_dis;
	212
	213	for (i++; i < S5K6A3_NUM_SUPPLIES; i++) {
	214	ret = regulator_enable(sensor->supplies[i].consumer);
	215	if (ret < 0)
	216	goto error_reg_dis;
	217	}
	218
	219	gpio_set_value(sensor->gpio_reset, 1);
	220	usleep_range(600, 800);
	221	gpio_set_value(sensor->gpio_reset, 0);
	222	usleep_range(600, 800);
	223	gpio_set_value(sensor->gpio_reset, 1);
	224
	225	/* Delay needed for the sensor initialization */
	226	msleep(20);
	227	return 0;
	228
	229	error_reg_dis:
	230	for (--i; i >= 0; --i)
	231	regulator_disable(sensor->supplies[i].consumer);
	232	error_rpm_put:
	233	pm_runtime_put(sensor->dev);
	234	return ret;
	235	}
	236
	237	static int __s5k6a3_power_off(struct s5k6a3 *sensor)
	238	{
	239	int i;
	240
	241	gpio_set_value(sensor->gpio_reset, 0);
	242
	243	for (i = S5K6A3_NUM_SUPPLIES - 1; i >= 0; i--)
244	regulator_disable(sensor->supplies[i].consumer);
245
246	clk_disable_unprepare(sensor->clock);
247	pm_runtime_put(sensor->dev);
248	return 0;
249	}
250
251	static int s5k6a3_s_power(struct v4l2_subdev *sd, int on)
252	{
253	struct s5k6a3 *sensor = sd_to_s5k6a3(sd);
254	int ret = 0;
255
256	mutex_lock(&sensor->lock);
257
258	if (sensor->power_count == !on) {
259	if (on)
260	ret = __s5k6a3_power_on(sensor);
261	else
262	ret = __s5k6a3_power_off(sensor);
263
264	if (ret == 0)
265	sensor->power_count += on ? 1 : -1;
266	}
267
268	mutex_unlock(&sensor->lock);
269	return ret;
270	}
271
7c137c60	272	static const struct v4l2_subdev_core_ops s5k6a3_core_ops = {
814b4dd9 SN	273	.s_power = s5k6a3_s_power,
	274	};
	275
7c137c60	276	static const struct v4l2_subdev_ops s5k6a3_subdev_ops = {
814b4dd9 SN	277	.core = &s5k6a3_core_ops,
	278	.pad = &s5k6a3_pad_ops,
	279	};
	280
	281	static int s5k6a3_probe(struct i2c_client *client,
	282	const struct i2c_device_id *id)
	283	{
	284	struct device *dev = &client->dev;
	285	struct s5k6a3 *sensor;
	286	struct v4l2_subdev *sd;
	287	int gpio, i, ret;
	288
	289	sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL);
	290	if (!sensor)
	291	return -ENOMEM;
	292
	293	mutex_init(&sensor->lock);
	294	sensor->gpio_reset = -EINVAL;
	295	sensor->clock = ERR_PTR(-EINVAL);
	296	sensor->dev = dev;
	297
	298	sensor->clock = devm_clk_get(sensor->dev, S5K6A3_CLK_NAME);
	299	if (IS_ERR(sensor->clock))
	300	return PTR_ERR(sensor->clock);
	301
	302	gpio = of_get_gpio_flags(dev->of_node, 0, NULL);
	303	if (!gpio_is_valid(gpio))
	304	return gpio;
	305
	306	ret = devm_gpio_request_one(dev, gpio, GPIOF_OUT_INIT_LOW,
	307	S5K6A3_DRV_NAME);
	308	if (ret < 0)
	309	return ret;
	310
	311	sensor->gpio_reset = gpio;
	312
	313	if (of_property_read_u32(dev->of_node, "clock-frequency",
	314	&sensor->clock_frequency)) {
	315	sensor->clock_frequency = S5K6A3_DEFAULT_CLK_FREQ;
	316	dev_info(dev, "using default %u Hz clock frequency\n",
	317	sensor->clock_frequency);
	318	}
	319
	320	for (i = 0; i < S5K6A3_NUM_SUPPLIES; i++)
	321	sensor->supplies[i].supply = s5k6a3_supply_names[i];
	322
	323	ret = devm_regulator_bulk_get(&client->dev, S5K6A3_NUM_SUPPLIES,
	324	sensor->supplies);
	325	if (ret < 0)
	326	return ret;
	327
	328	sd = &sensor->subdev;
	329	v4l2_i2c_subdev_init(sd, client, &s5k6a3_subdev_ops);
	330	sensor->subdev.flags \|= V4L2_SUBDEV_FL_HAS_DEVNODE;
	331	sd->internal_ops = &s5k6a3_sd_internal_ops;
	332
	333	sensor->format.code = s5k6a3_formats[0].code;
	334	sensor->format.width = S5K6A3_DEFAULT_WIDTH;
	335	sensor->format.height = S5K6A3_DEFAULT_HEIGHT;
	336
654fa103	337	sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;
814b4dd9	338	sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
ab22e77c	339	ret = media_entity_pads_init(&sd->entity, 1, &sensor->pad);
814b4dd9 SN	340	if (ret < 0)
	341	return ret;
	342
	343	pm_runtime_no_callbacks(dev);
	344	pm_runtime_enable(dev);
	345
	346	ret = v4l2_async_register_subdev(sd);
	347
	348	if (ret < 0) {
	349	pm_runtime_disable(&client->dev);
	350	media_entity_cleanup(&sd->entity);
	351	}
	352
	353	return ret;
	354	}
	355
	356	static int s5k6a3_remove(struct i2c_client *client)
	357	{
	358	struct v4l2_subdev *sd = i2c_get_clientdata(client);
	359
	360	pm_runtime_disable(&client->dev);
	361	v4l2_async_unregister_subdev(sd);
	362	media_entity_cleanup(&sd->entity);
	363	return 0;
	364	}
	365
	366	static const struct i2c_device_id s5k6a3_ids[] = {
	367	{ }
	368	};
ed8d1cf0	369	MODULE_DEVICE_TABLE(i2c, s5k6a3_ids);
814b4dd9 SN	370
	371	#ifdef CONFIG_OF
	372	static const struct of_device_id s5k6a3_of_match[] = {
	373	{ .compatible = "samsung,s5k6a3" },
	374	{ /* sentinel */ }
	375	};
	376	MODULE_DEVICE_TABLE(of, s5k6a3_of_match);
	377	#endif
	378
	379	static struct i2c_driver s5k6a3_driver = {
	380	.driver = {
	381	.of_match_table = of_match_ptr(s5k6a3_of_match),
	382	.name = S5K6A3_DRV_NAME,
814b4dd9 SN	383	},
	384	.probe = s5k6a3_probe,
	385	.remove = s5k6a3_remove,
	386	.id_table = s5k6a3_ids,
	387	};
	388
	389	module_i2c_driver(s5k6a3_driver);
	390
	391	MODULE_DESCRIPTION("S5K6A3 image sensor subdev driver");
	392	MODULE_AUTHOR("Sylwester Nawrocki <s.nawrocki@samsung.com>");
	393	MODULE_LICENSE("GPL v2");