// SPDX-License-Identifier: GPL-2.0-only /* * Driver for the Sony IMX415 CMOS Image Sensor. * * Copyright (C) 2023 WolfVision GmbH. #include <linux/clk.h>#include <linux/gpio/consumer.h>#include <linux/i2c.h>#include <linux/module.h>#include <linux/of.h>#include <linux/pm_runtime.h>#include <linux/regmap.h>#include <linux/regulator/consumer.h>#include <linux/slab.h>#include <linux/videodev2.h>#include <media/v4l2-cci.h>#include <media/v4l2-ctrls.h>#include <media/v4l2-fwnode.h>#include <media/v4l2-subdev.h>#define IMX415_PIXEL_ARRAY_TOP 0#define IMX415_PIXEL_ARRAY_LEFT 0#define IMX415_PIXEL_ARRAY_WIDTH 3864#define IMX415_PIXEL_ARRAY_HEIGHT 2192#define IMX415_PIXEL_ARRAY_VBLANK 58#define IMX415_EXPOSURE_OFFSET 8#define IMX415_PIXEL_RATE_74_25MHZ 891000000#define IMX415_PIXEL_RATE_72MHZ 864000000#define IMX415_NUM_CLK_PARAM_REGS 11#define IMX415_MODE CCI_REG8(0x3000)#define IMX415_MODE_OPERATING (0)#define IMX415_MODE_STANDBY BIT(0)#define IMX415_REGHOLD CCI_REG8(0x3001)#define IMX415_REGHOLD_INVALID (0)#define IMX415_REGHOLD_VALID BIT(0)#define IMX415_XMSTA CCI_REG8(0x3002)#define IMX415_XMSTA_START (0)#define IMX415_XMSTA_STOP BIT(0)#define IMX415_BCWAIT_TIME CCI_REG16_LE(0x3008)#define IMX415_CPWAIT_TIME CCI_REG16_LE(0x300a)#define IMX415_WINMODE CCI_REG8(0x301c)#define IMX415_ADDMODE CCI_REG8(0x3022)#define IMX415_REVERSE CCI_REG8(0x3030)#define IMX415_HREVERSE_SHIFT (0)#define IMX415_VREVERSE_SHIFT BIT(0)#define IMX415_ADBIT CCI_REG8(0x3031)#define IMX415_MDBIT CCI_REG8(0x3032)#define IMX415_SYS_MODE CCI_REG8(0x3033)#define IMX415_OUTSEL CCI_REG8(0x30c0)#define IMX415_DRV CCI_REG8(0x30c1)#define IMX415_VMAX CCI_REG24_LE(0x3024)#define IMX415_VMAX_MAX 0xfffff#define IMX415_HMAX CCI_REG16_LE(0x3028)#define IMX415_HMAX_MAX 0xffff#define IMX415_HMAX_MULTIPLIER 12#define IMX415_SHR0 CCI_REG24_LE(0x3050)#define IMX415_GAIN_PCG_0 CCI_REG16_LE(0x3090)#define IMX415_AGAIN_MIN 0#define IMX415_AGAIN_MAX 100#define IMX415_AGAIN_STEP 1#define IMX415_BLKLEVEL CCI_REG16_LE(0x30e2)#define IMX415_BLKLEVEL_DEFAULT 50#define IMX415_TPG_EN_DUOUT CCI_REG8(0x30e4)#define IMX415_TPG_PATSEL_DUOUT CCI_REG8(0x30e6)#define IMX415_TPG_COLORWIDTH CCI_REG8(0x30e8)#define IMX415_TESTCLKEN_MIPI CCI_REG8(0x3110)#define IMX415_INCKSEL1 CCI_REG8(0x3115)#define IMX415_INCKSEL2 CCI_REG8(0x3116)#define IMX415_INCKSEL3 CCI_REG16_LE(0x3118)#define IMX415_INCKSEL4 CCI_REG16_LE(0x311a)#define IMX415_INCKSEL5 CCI_REG8(0x311e)#define IMX415_DIG_CLP_MODE CCI_REG8(0x32c8)#define IMX415_WRJ_OPEN CCI_REG8(0x3390)#define IMX415_SENSOR_INFO CCI_REG16_LE(0x3f12)#define IMX415_SENSOR_INFO_MASK 0xfff#define IMX415_CHIP_ID 0x514#define IMX415_LANEMODE CCI_REG16_LE(0x4001)#define IMX415_LANEMODE_2 1#define IMX415_LANEMODE_4 3#define IMX415_TXCLKESC_FREQ CCI_REG16_LE(0x4004)#define IMX415_INCKSEL6 CCI_REG8(0x400c)#define IMX415_TCLKPOST CCI_REG16_LE(0x4018)#define IMX415_TCLKPREPARE CCI_REG16_LE(0x401a)#define IMX415_TCLKTRAIL CCI_REG16_LE(0x401c)#define IMX415_TCLKZERO CCI_REG16_LE(0x401e)#define IMX415_THSPREPARE CCI_REG16_LE(0x4020)#define IMX415_THSZERO CCI_REG16_LE(0x4022)#define IMX415_THSTRAIL CCI_REG16_LE(0x4024)#define IMX415_THSEXIT CCI_REG16_LE(0x4026)#define IMX415_TLPX CCI_REG16_LE(0x4028)#define IMX415_INCKSEL7 CCI_REG8(0x4074)static const char *const imx415_supply_names[] = {"dvdd" ,"ovdd" ,"avdd" ,/* * The IMX415 data sheet uses lane rates but v4l2 uses link frequency to * describe MIPI CSI-2 speed. This driver uses lane rates wherever possible * and converts them to link frequencies by a factor of two when needed. static const s64 link_freq_menu_items[] = {struct imx415_clk_params {struct cci_reg_sequence regs[IMX415_NUM_CLK_PARAM_REGS];/* INCK Settings - includes all lane rate and INCK dependent registers */ static const struct imx415_clk_params imx415_clk_params[] = {/* 720 Mbps CSI configuration */ static const struct cci_reg_sequence imx415_linkrate_720mbps[] = {/* 1440 Mbps CSI configuration */ static const struct cci_reg_sequence imx415_linkrate_1440mbps[] = {/* 891 Mbps CSI configuration */ static const struct cci_reg_sequence imx415_linkrate_891mbps[] = {struct imx415_mode_reg_list {const struct cci_reg_sequence *regs;struct imx415_mode {struct imx415_mode_reg_list reg_list;/* mode configs */ static const struct imx415_mode supported_modes[] = {static const char *const imx415_test_pattern_menu[] = {"disabled" ,"solid black" ,"solid white" ,"solid dark gray" ,"solid light gray" ,"stripes light/dark grey" ,"stripes dark/light grey" ,"stripes black/dark grey" ,"stripes dark grey/black" ,"stripes black/white" ,"stripes white/black" ,"horizontal color bar" ,"vertical color bar" ,struct imx415 {struct device *dev;struct clk *clk;unsigned long pixel_rate;struct regulator_bulk_data supplies[ARRAY_SIZE(imx415_supply_names)];struct gpio_desc *reset;struct regmap *regmap;const struct imx415_clk_params *clk_params;struct v4l2_subdev subdev;struct media_pad pad;struct v4l2_ctrl_handler ctrls;struct v4l2_ctrl *vblank;struct v4l2_ctrl *hblank;struct v4l2_ctrl *hflip;struct v4l2_ctrl *vflip;struct v4l2_ctrl *exposure;unsigned int cur_mode;unsigned int num_data_lanes;/* * This table includes fixed register settings and a bunch of undocumented * registers that have to be set to another value than default. static const struct cci_reg_sequence imx415_init_table[] = {/* use all-pixel readout mode, no flip */ /* use RAW 10-bit mode */ /* output VSYNC on XVS and low on XHS */ /* SONY magic registers */ static inline struct imx415 *to_imx415(struct v4l2_subdev *sd)return container_of(sd, struct imx415, subdev);static int imx415_set_testpattern(struct imx415 *sensor, int val)int ret = 0;if (val) {else {return 0;static int imx415_s_ctrl(struct v4l2_ctrl *ctrl)struct imx415 *sensor = container_of(ctrl->handler, struct imx415,const struct v4l2_mbus_framefmt *format;struct v4l2_subdev_state *state;unsigned int vmax;unsigned int flip;int ret;if (ctrl->id == V4L2_CID_VBLANK) {if (!pm_runtime_get_if_in_use(sensor->dev))return 0;switch (ctrl->id) {case V4L2_CID_VBLANK:if (ret)return ret;/* * Exposure is set based on VMAX which has just changed, so * program exposure register as well case V4L2_CID_EXPOSURE:/* clamp the exposure value to VMAX. */ int , ctrl->val, vmax);break ;case V4L2_CID_ANALOGUE_GAIN:/* analogue gain in 0.3 dB step size */ break ;case V4L2_CID_HFLIP:case V4L2_CID_VFLIP:break ;case V4L2_CID_TEST_PATTERN:break ;case V4L2_CID_HBLANK:break ;default :break ;return ret;static const struct v4l2_ctrl_ops imx415_ctrl_ops = {static int imx415_ctrls_init(struct imx415 *sensor)struct v4l2_fwnode_device_properties props;struct v4l2_ctrl *ctrl;const struct imx415_mode *cur_mode = &supported_modes[sensor->cur_mode];unsigned int i;int ret;if (ret < 0)return ret;for (i = 0; i < ARRAY_SIZE(link_freq_menu_items); ++i) {if (lane_rate == link_freq_menu_items[i] * 2)break ;if (i == ARRAY_SIZE(link_freq_menu_items)) {return dev_err_probe(sensor->dev, -EINVAL,"lane rate %llu not supported\n" ,if (ctrl)if (sensor->ctrls.error) {"failed to add controls\n" );return sensor->ctrls.error;return 0;static int imx415_set_mode(struct imx415 *sensor, int mode)int ret = 0;if (mode >= ARRAY_SIZE(supported_modes)) {"Mode %d not supported\n" , mode);return -EINVAL;return ret;static int imx415_setup(struct imx415 *sensor, struct v4l2_subdev_state *state)int ret;if (ret)return ret;return imx415_set_mode(sensor, sensor->cur_mode);static int imx415_wakeup(struct imx415 *sensor)int ret;if (ret)return ret;/* * According to the datasheet we have to wait at least 63 us after * leaving standby mode. But this doesn't work even after 30 ms. * So probably this should be 63 ms and therefore we wait for 80 ms. return 0;static int imx415_stream_on(struct imx415 *sensor)int ret;return cci_write(sensor->regmap, IMX415_XMSTA,static int imx415_stream_off(struct imx415 *sensor)int ret;return cci_write(sensor->regmap, IMX415_MODE,static int imx415_s_stream(struct v4l2_subdev *sd, int enable)struct imx415 *sensor = to_imx415(sd);struct v4l2_subdev_state *state;int ret;if (!enable) {goto unlock;if (ret < 0)goto unlock;if (ret)goto err_pm;if (ret < 0)goto err_pm;if (ret)goto err_pm;return ret;/* * In case of error, turn the power off synchronously as the device * likely has no other chance to recover. goto unlock;static int imx415_enum_mbus_code(struct v4l2_subdev *sd,struct v4l2_subdev_state *state,struct v4l2_subdev_mbus_code_enum *code)if (code->index != 0)return -EINVAL;return 0;static int imx415_enum_frame_size(struct v4l2_subdev *sd,struct v4l2_subdev_state *state,struct v4l2_subdev_frame_size_enum *fse)const struct v4l2_mbus_framefmt *format;if (fse->index > 0 || fse->code != format->code)return -EINVAL;return 0;static int imx415_set_format(struct v4l2_subdev *sd,struct v4l2_subdev_state *state,struct v4l2_subdev_format *fmt)struct v4l2_mbus_framefmt *format;return 0;static int imx415_get_selection(struct v4l2_subdev *sd,struct v4l2_subdev_state *sd_state,struct v4l2_subdev_selection *sel)switch (sel->target) {case V4L2_SEL_TGT_CROP:case V4L2_SEL_TGT_CROP_DEFAULT:case V4L2_SEL_TGT_CROP_BOUNDS:return 0;return -EINVAL;static int imx415_init_state(struct v4l2_subdev *sd,struct v4l2_subdev_state *state)struct v4l2_subdev_format format = {return 0;static const struct v4l2_subdev_video_ops imx415_subdev_video_ops = {static const struct v4l2_subdev_pad_ops imx415_subdev_pad_ops = {static const struct v4l2_subdev_ops imx415_subdev_ops = {static const struct v4l2_subdev_internal_ops imx415_internal_ops = {static int imx415_subdev_init(struct imx415 *sensor)struct i2c_client *client = to_i2c_client(sensor->dev);int ret;if (ret)return ret;if (ret < 0) {return ret;return 0;static void imx415_subdev_cleanup(struct imx415 *sensor)static int imx415_power_on(struct imx415 *sensor)int ret;if (ret < 0)return ret;if (ret < 0)goto err_reset;/* * Data sheet states that 20 us are required before communication start, * but this doesn't work in all cases. Use 100 us to be on the safe * side. return 0;return ret;static void imx415_power_off(struct imx415 *sensor)static int imx415_identify_model(struct imx415 *sensor)int model, ret;/* * While most registers can be read when the sensor is in standby, this * is not the case of the sensor info register :-( if (ret)return dev_err_probe(sensor->dev, ret,"failed to get sensor out of standby\n" );if (ret < 0) {"failed to read sensor information\n" );goto done;switch (model) {case IMX415_CHIP_ID:"Detected IMX415 image sensor\n" );break ;default :"invalid device model 0x%04x\n" , model);goto done;return ret;static int imx415_check_inck(unsigned long inck, u64 link_frequency)unsigned int i;for (i = 0; i < ARRAY_SIZE(imx415_clk_params); ++i) {if ((imx415_clk_params[i].lane_rate == link_frequency * 2) &&break ;if (i == ARRAY_SIZE(imx415_clk_params))return -EINVAL;else return 0;static int imx415_parse_hw_config(struct imx415 *sensor)struct v4l2_fwnode_endpoint bus_cfg = {struct fwnode_handle *ep;unsigned long inck;unsigned int i, j;int ret;for (i = 0; i < ARRAY_SIZE(sensor->supplies); ++i)if (ret)return dev_err_probe(sensor->dev, ret,"failed to get supplies\n" );"reset" ,if (IS_ERR(sensor->reset))return dev_err_probe(sensor->dev, PTR_ERR(sensor->reset),"failed to get reset GPIO\n" );if (IS_ERR(sensor->clk))return dev_err_probe(sensor->dev, PTR_ERR(sensor->clk),"failed to get clock\n" );if (!ep)return -ENXIO;if (ret)return ret;switch (bus_cfg.bus.mipi_csi2.num_data_lanes) {case 2:case 4:break ;default :"invalid number of CSI2 data lanes %d\n" ,goto done_endpoint_free;if (!bus_cfg.nr_of_link_frequencies) {"no link frequencies defined" );goto done_endpoint_free;/* * Check if there exists a sensor mode defined for current INCK, * number of lanes and given lane rates. for (i = 0; i < bus_cfg.nr_of_link_frequencies; ++i) {if (imx415_check_inck(inck, bus_cfg.link_frequencies[i])) {"INCK %lu Hz not supported for this link freq" ,continue ;for (j = 0; j < ARRAY_SIZE(supported_modes); ++j) {if (bus_cfg.link_frequencies[i] * 2 !=continue ;break ;if (j < ARRAY_SIZE(supported_modes))break ;if (i == bus_cfg.nr_of_link_frequencies) {"no valid sensor mode defined\n" );goto done_endpoint_free;switch (inck) {case 27000000:case 37125000:case 74250000:break ;case 24000000:case 72000000:break ;for (i = 0; i < ARRAY_SIZE(imx415_clk_params); ++i) {if (lane_rate == imx415_clk_params[i].lane_rate &&break ;if (i == ARRAY_SIZE(imx415_clk_params)) {"Mode %d not supported\n" ,goto done_endpoint_free;"clock: %lu Hz, lane_rate: %llu bps, lanes: %d\n" ,return ret;static int imx415_probe(struct i2c_client *client)struct imx415 *sensor;int ret;sizeof (*sensor), GFP_KERNEL);if (!sensor)return -ENOMEM;if (ret)return ret;if (IS_ERR(sensor->regmap))return PTR_ERR(sensor->regmap);/* * Enable power management. The driver supports runtime PM, but needs to * work when runtime PM is disabled in the kernel. To that end, power * the sensor on manually here, identify it, and fully initialize it. if (ret)return ret;if (ret)goto err_power;if (ret)goto err_power;/* * Enable runtime PM. As the device has been powered manually, mark it * as active, and increase the usage count without resuming the device. if (ret < 0)goto err_pm;/* * Finally, enable autosuspend and decrease the usage count. The device * will get suspended after the autosuspend delay, turning the power * off. return 0;return ret;static void imx415_remove(struct i2c_client *client)struct v4l2_subdev *subdev = i2c_get_clientdata(client);struct imx415 *sensor = to_imx415(subdev);/* * Disable runtime PM. In case runtime PM is disabled in the kernel, * make sure to turn power off manually. if (!pm_runtime_status_suspended(sensor->dev))static int imx415_runtime_resume(struct device *dev)struct i2c_client *client = to_i2c_client(dev);struct v4l2_subdev *subdev = i2c_get_clientdata(client);struct imx415 *sensor = to_imx415(subdev);return imx415_power_on(sensor);static int imx415_runtime_suspend(struct device *dev)struct i2c_client *client = to_i2c_client(dev);struct v4l2_subdev *subdev = i2c_get_clientdata(client);struct imx415 *sensor = to_imx415(subdev);return 0;static DEFINE_RUNTIME_DEV_PM_OPS(imx415_pm_ops, imx415_runtime_suspend,static const struct of_device_id imx415_of_match[] = {"sony,imx415" },/* sentinel */ } static struct i2c_driver imx415_driver = {"imx415" ,"Sony IMX415 image sensor driver" );"Gerald Loacker " );"Michael Riesch " );"GPL" );
Messung V0.5 C=91 H=94 G=92
¤ Dauer der Verarbeitung: 0.10 Sekunden
(vorverarbeitet)
¤ *© Formatika GbR, Deutschland
