// SPDX-License-Identifier: GPL-2.0-only /* * Samsung S5K6A3 image sensor driver * * Copyright (C) 2013 Samsung Electronics Co., Ltd. * Author: Sylwester Nawrocki <s.nawrocki@samsung.com> */ #include <linux/clk.h> #include <linux/delay.h> #include <linux/device.h> #include <linux/err.h> #include <linux/errno.h> #include <linux/gpio/consumer.h> #include <linux/i2c.h> #include <linux/kernel.h> #include <linux/module.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]; struct gpio_desc *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_state_get_format(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_state_get_format(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_clk; } gpiod_set_value_cansleep(sensor->gpio_reset, 0); usleep_range(600, 800); gpiod_set_value_cansleep(sensor->gpio_reset, 1); usleep_range(600, 800); gpiod_set_value_cansleep(sensor->gpio_reset, 0); /* Delay needed for the sensor initialization */ msleep(20); return 0; error_clk: clk_disable_unprepare(sensor->clock); 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; gpiod_set_value_cansleep(sensor->gpio_reset, 1); 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 i, ret; sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL); if (!sensor) return -ENOMEM; mutex_init(&sensor->lock); sensor->dev = dev; sensor->clock = devm_clk_get(sensor->dev, S5K6A3_CLK_NAME); if (IS_ERR(sensor->clock)) return PTR_ERR(sensor->clock); sensor->gpio_reset = devm_gpiod_get(dev, NULL, GPIOD_OUT_HIGH); ret = PTR_ERR_OR_ZERO(sensor->gpio_reset); if (ret) return ret; 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 void 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); } 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");