mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
392 lines
9.3 KiB
392 lines
9.3 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Samsung S5K6A3 image sensor driver |
|
* |
|
* Copyright (C) 2013 Samsung Electronics Co., Ltd. |
|
* Author: Sylwester Nawrocki <[email protected]> |
|
*/ |
|
|
|
#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_state *sd_state, |
|
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_state *sd_state, |
|
u32 pad, enum v4l2_subdev_format_whence which) |
|
{ |
|
if (which == V4L2_SUBDEV_FORMAT_TRY) |
|
return sd_state ? v4l2_subdev_get_try_format(&sensor->subdev, |
|
sd_state, pad) : NULL; |
|
|
|
return &sensor->format; |
|
} |
|
|
|
static int s5k6a3_set_fmt(struct v4l2_subdev *sd, |
|
struct v4l2_subdev_state *sd_state, |
|
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, sd_state, 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_state *sd_state, |
|
struct v4l2_subdev_format *fmt) |
|
{ |
|
struct s5k6a3 *sensor = sd_to_s5k6a3(sd); |
|
struct v4l2_mbus_framefmt *mf; |
|
|
|
mf = __s5k6a3_get_format(sensor, sd_state, 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->state, |
|
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) |
|
goto error_rpm_put; |
|
|
|
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) |
|
{ |
|
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_new = 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 <[email protected]>"); |
|
MODULE_LICENSE("GPL v2");
|
|
|