// SPDX-License-Identifier: GPL-2.0 /* * Allied Vision Technologies GmbH Alvium camera driver * * Copyright (C) 2023 Tommaso Merciai * Copyright (C) 2023 Martin Hecht * Copyright (C) 2023 Avnet EMG GmbH #include <linux/i2c.h>#include <linux/module.h>#include <linux/pm_runtime.h>#include <linux/regmap.h>#include <linux/regulator/consumer.h>#include <media/mipi-csi2.h>#include <media/v4l2-async.h>#include <media/v4l2-ctrls.h>#include <media/v4l2-device.h>#include <media/v4l2-fwnode.h>#include <media/v4l2-subdev.h>#include "alvium-csi2.h" static const struct v4l2_mbus_framefmt alvium_csi2_default_fmt = {static const struct alvium_pixfmt alvium_csi2_fmts[] = {/* UYVY8_2X8 */ /* UYVY8_1X16 */ /* YUYV8_1X16 */ /* YUYV8_2X8 */ /* YUYV10_1X20 */ /* RGB888_1X24 */ /* RBG888_1X24 */ /* BGR888_1X24 */ /* RGB888_3X8 */ /* Y8_1X8 */ /* SGRBG8_1X8 */ /* SRGGB8_1X8 */ /* SGBRG8_1X8 */ /* SBGGR8_1X8 */ /* Y10_1X10 */ /* SGRBG10_1X10 */ /* SRGGB10_1X10 */ /* SGBRG10_1X10 */ /* SBGGR10_1X10 */ /* Y12_1X12 */ /* SGRBG12_1X12 */ /* SRGGB12_1X12 */ /* SGBRG12_1X12 */ /* SBGGR12_1X12 */ /* SBGGR14_1X14 */ /* SGBRG14_1X14 */ /* SRGGB14_1X14 */ /* SGRBG14_1X14 */ /* sentinel */ } static int alvium_read(struct alvium_dev *alvium, u32 reg, u64 *val, int *err)if (reg & REG_BCRM_V4L2) {return cci_read(alvium->regmap, reg, val, err);static int alvium_write(struct alvium_dev *alvium, u32 reg, u64 val, int *err)if (reg & REG_BCRM_V4L2) {return cci_write(alvium->regmap, reg, val, err);static int alvium_write_hshake(struct alvium_dev *alvium, u32 reg, u64 val)struct device *dev = &alvium->i2c_client->dev;int ret = 0;/* reset handshake bit and write alvium reg */ if (ret) {"Fail to write reg\n" );return ret;/* poll handshake bit since bit0 = 1 */ true ,if (ret) {"poll bit[0] = 1, hshake reg fail\n" );return ret;/* reset handshake bit, write 0 to bit0 */ if (ret) {"Fail to reset hshake reg\n" );return ret;/* poll handshake bit since bit0 = 0 */ true ,if (ret) {"poll bit[0] = 0, hshake reg fail\n" );return ret;return 0;static int alvium_get_bcrm_vers(struct alvium_dev *alvium)struct device *dev = &alvium->i2c_client->dev;int ret = 0;if (ret)return ret;"bcrm version: %llu.%llu\n" , min, maj);return 0;static int alvium_get_fw_version(struct alvium_dev *alvium)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret)return ret;"fw version: %02u.%02u.%04u.%08x\n" ,return 0;static int alvium_get_bcrm_addr(struct alvium_dev *alvium)int ret;if (ret)return ret;return 0;static int alvium_is_alive(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return hbeat;static void alvium_print_avail_mipi_fmt(struct alvium_dev *alvium)struct device *dev = &alvium->i2c_client->dev;"avail mipi_fmt yuv420_8_leg: %u\n" ,"avail mipi_fmt yuv420_8: %u\n" ,"avail mipi_fmt yuv420_10: %u\n" ,"avail mipi_fmt yuv420_8_csps: %u\n" ,"avail mipi_fmt yuv420_10_csps: %u\n" ,"avail mipi_fmt yuv422_8: %u\n" ,"avail mipi_fmt yuv422_10: %u\n" ,"avail mipi_fmt rgb888: %u\n" ,"avail mipi_fmt rgb666: %u\n" ,"avail mipi_fmt rgb565: %u\n" ,"avail mipi_fmt rgb555: %u\n" ,"avail mipi_fmt rgb444: %u\n" ,"avail mipi_fmt raw6: %u\n" ,"avail mipi_fmt raw7: %u\n" ,"avail mipi_fmt raw8: %u\n" ,"avail mipi_fmt raw10: %u\n" ,"avail mipi_fmt raw12: %u\n" ,"avail mipi_fmt raw14: %u\n" ,"avail mipi_fmt jpeg: %u\n" ,static void alvium_print_avail_feat(struct alvium_dev *alvium)struct device *dev = &alvium->i2c_client->dev;"feature rev_x: %u\n" , alvium->avail_ft.rev_x);"feature rev_y: %u\n" , alvium->avail_ft.rev_y);"feature int_autop: %u\n" , alvium->avail_ft.int_autop);"feature black_lvl: %u\n" , alvium->avail_ft.black_lvl);"feature gain: %u\n" , alvium->avail_ft.gain);"feature gamma: %u\n" , alvium->avail_ft.gamma);"feature contrast: %u\n" , alvium->avail_ft.contrast);"feature sat: %u\n" , alvium->avail_ft.sat);"feature hue: %u\n" , alvium->avail_ft.hue);"feature whiteb: %u\n" , alvium->avail_ft.whiteb);"feature sharp: %u\n" , alvium->avail_ft.sharp);"feature auto_exp: %u\n" , alvium->avail_ft.auto_exp);"feature auto_gain: %u\n" , alvium->avail_ft.auto_gain);"feature auto_whiteb: %u\n" , alvium->avail_ft.auto_whiteb);"feature dev_temp: %u\n" , alvium->avail_ft.dev_temp);"feature acq_abort: %u\n" , alvium->avail_ft.acq_abort);"feature acq_fr: %u\n" , alvium->avail_ft.acq_fr);"feature fr_trigger: %u\n" , alvium->avail_ft.fr_trigger);"feature exp_acq_line: %u\n" ,static void alvium_print_avail_bayer(struct alvium_dev *alvium)struct device *dev = &alvium->i2c_client->dev;"avail bayer mono: %u\n" ,"avail bayer gr: %u\n" ,"avail bayer rg: %u\n" ,"avail bayer gb: %u\n" ,"avail bayer bg: %u\n" ,static int alvium_get_feat_inq(struct alvium_dev *alvium)struct alvium_avail_feat *f;int ret;if (ret)return ret;struct alvium_avail_feat *)&val;return 0;static int alvium_get_host_supp_csi_lanes(struct alvium_dev *alvium)int ret;if (ret)return ret;return 0;static int alvium_set_csi_lanes(struct alvium_dev *alvium)struct device *dev = &alvium->i2c_client->dev;int ret;if (num_lanes > alvium->h_sup_csi_lanes)return -EINVAL;if (ret) {"Fail to set csi lanes reg\n" );return ret;return 0;static int alvium_set_lp2hs_delay(struct alvium_dev *alvium)struct device *dev = &alvium->i2c_client->dev;int ret = 0;/* * The purpose of this reg is force a DPhy reset * for the period described by the millisecond on * the reg, before it starts streaming. * * To be clear, with that value bigger than 0 the * Alvium forces a dphy-reset on all lanes for that period. * That means all lanes go up into low power state. * if (ret) {"Fail to set lp2hs delay reg\n" );return ret;return 0;static int alvium_get_csi_clk_params(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return 0;static int alvium_set_csi_clk(struct alvium_dev *alvium)struct device *dev = &alvium->i2c_client->dev;int ret;if (alvium->ep.link_frequencies[0] != (u64)csi_clk) {"requested csi clock (%llu MHz) out of range [%u, %u] Adjusted to %llu\n" ,if (ret) {"Fail to set csi clock reg\n" );return ret;return 0;static int alvium_get_img_width_params(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return 0;static int alvium_get_img_height_params(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return 0;static int alvium_set_img_width(struct alvium_dev *alvium, u32 width)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set img width\n" );return ret;return 0;static int alvium_set_img_height(struct alvium_dev *alvium, u32 height)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set img height\n" );return ret;return 0;static int alvium_set_img_offx(struct alvium_dev *alvium, u32 offx)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set img offx\n" );return ret;return 0;static int alvium_set_img_offy(struct alvium_dev *alvium, u32 offy)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set img offy\n" );return ret;return 0;static int alvium_get_offx_params(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return 0;static int alvium_get_offy_params(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return 0;static int alvium_get_gain_params(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return 0;static int alvium_get_exposure_params(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return 0;static int alvium_get_red_balance_ratio_params(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return 0;static int alvium_get_blue_balance_ratio_params(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return 0;static int alvium_get_hue_params(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return 0;static int alvium_get_black_lvl_params(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return 0;static int alvium_get_gamma_params(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return 0;static int alvium_get_sharpness_params(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return 0;static int alvium_get_contrast_params(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return 0;static int alvium_get_saturation_params(struct alvium_dev *alvium)int ret = 0;if (ret)return ret;return 0;static int alvium_set_bcm_mode(struct alvium_dev *alvium)int ret = 0;return ret;static int alvium_get_mode(struct alvium_dev *alvium)int ret;if (ret)return ret;switch (bcrm_mode) {case ALVIUM_BCM_MODE:break ;case ALVIUM_GENCP_MODE:break ;return 0;static int alvium_get_avail_mipi_data_format(struct alvium_dev *alvium)struct alvium_avail_mipi_fmt *avail_fmt;int ret;if (ret)return ret;struct alvium_avail_mipi_fmt *)&val;return 0;static int alvium_setup_mipi_fmt(struct alvium_dev *alvium)unsigned int avail_fmt_cnt = 0;unsigned int fmt = 0;/* calculate fmt array size */ for (fmt = 0; fmt < ALVIUM_NUM_SUPP_MIPI_DATA_FMT; fmt++) {if (!alvium->is_mipi_fmt_avail[alvium_csi2_fmts[fmt].fmt_av_bit])continue ;if (!alvium_csi2_fmts[fmt].is_raw ||/* init alvium_csi2_fmt array */ sizeof (struct alvium_pixfmt), GFP_KERNEL);if (!alvium->alvium_csi2_fmt)return -ENOMEM;/* Create the alvium_csi2 fmt array from formats available */ for (fmt = 0; fmt < ALVIUM_NUM_SUPP_MIPI_DATA_FMT; fmt++) {if (!alvium->is_mipi_fmt_avail[alvium_csi2_fmts[fmt].fmt_av_bit])continue ;if (!alvium_csi2_fmts[fmt].is_raw ||return 0;static int alvium_set_mipi_fmt(struct alvium_dev *alvium,const struct alvium_pixfmt *pixfmt)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set mipi fmt\n" );return ret;return 0;static int alvium_get_avail_bayer(struct alvium_dev *alvium)struct alvium_avail_bayer *avail_bay;int ret;if (ret)return ret;struct alvium_avail_bayer *)&val;return 0;static int alvium_set_bayer_pattern(struct alvium_dev *alvium,const struct alvium_pixfmt *pixfmt)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set bayer pattern\n" );return ret;return 0;static int alvium_get_frame_interval(struct alvium_dev *alvium,int ret = 0;return ret;static int alvium_set_frame_rate(struct alvium_dev *alvium, u64 fr)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set acquisition frame rate enable reg\n" );return ret;if (ret) {"Fail to set frame start trigger mode reg\n" );return ret;if (ret) {"Fail to set frame rate lanes reg\n" );return ret;"set frame rate: %llu us\n" , fr);return 0;static int alvium_set_stream_mipi(struct alvium_dev *alvium, bool on)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail set_stream_mipi\n" );return ret;return 0;static int alvium_get_gain(struct alvium_dev *alvium)int ret;/* The unit is millibel (1 mB = 0.01 dB) */ if (ret)return ret;return gain;static int alvium_set_ctrl_gain(struct alvium_dev *alvium, int gain)struct device *dev = &alvium->i2c_client->dev;int ret;/* The unit is millibel (1 mB = 0.01 dB) */ if (ret) {"Fail to set gain value reg\n" );return ret;return 0;static int alvium_set_ctrl_auto_gain(struct alvium_dev *alvium, bool on)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set autogain reg\n" );return ret;return 0;static int alvium_get_exposure(struct alvium_dev *alvium)int ret;/* Exposure time in ns */ if (ret)return ret;return exp;static int alvium_set_ctrl_auto_exposure(struct alvium_dev *alvium, bool on)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set autoexposure reg\n" );return ret;return 0;static int alvium_set_ctrl_exposure(struct alvium_dev *alvium, int exposure_ns)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set exposure value reg\n" );return ret;return 0;static int alvium_set_ctrl_blue_balance_ratio(struct alvium_dev *alvium,int blue)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set blue ratio value reg\n" );return ret;return 0;static int alvium_set_ctrl_red_balance_ratio(struct alvium_dev *alvium, int red)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set red ratio value reg\n" );return ret;return 0;static int alvium_set_ctrl_awb(struct alvium_dev *alvium, bool on)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set awb reg\n" );return ret;return 0;static int alvium_set_ctrl_hue(struct alvium_dev *alvium, int val)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set hue value reg\n" );return ret;return 0;static int alvium_set_ctrl_contrast(struct alvium_dev *alvium, int val)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set contrast value reg\n" );return ret;return 0;static int alvium_set_ctrl_saturation(struct alvium_dev *alvium, int val)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set contrast value reg\n" );return ret;return 0;static int alvium_set_ctrl_gamma(struct alvium_dev *alvium, int val)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set gamma value reg\n" );return ret;return 0;static int alvium_set_ctrl_sharpness(struct alvium_dev *alvium, int val)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set sharpness value reg\n" );return ret;return 0;static int alvium_set_ctrl_hflip(struct alvium_dev *alvium, int val)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set reverse_x value reg\n" );return ret;return 0;static int alvium_set_ctrl_vflip(struct alvium_dev *alvium, int val)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to set reverse_y value reg\n" );return ret;return 0;static int alvium_get_hw_features_params(struct alvium_dev *alvium)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to read min/max csi clock regs\n" );return ret;if (ret) {"Fail to read img width regs\n" );return ret;if (ret) {"Fail to read img height regs\n" );return ret;if (ret) {"Fail to read offx regs\n" );return ret;if (ret) {"Fail to read offy regs\n" );return ret;if (ret) {"Fail to read gain regs\n" );return ret;if (ret) {"Fail to read min/max exp regs\n" );return ret;if (ret) {"Fail to read red balance ratio regs\n" );return ret;if (ret) {"Fail to read blue balance ratio regs\n" );return ret;if (ret) {"Fail to read hue regs\n" );return ret;if (ret) {"Fail to read contrast regs\n" );return ret;if (ret) {"Fail to read saturation regs\n" );return ret;if (ret) {"Fail to read black lvl regs\n" );return ret;if (ret) {"Fail to read gamma regs\n" );return ret;if (ret) {"Fail to read sharpness regs\n" );return ret;return 0;static int alvium_get_hw_info(struct alvium_dev *alvium)struct device *dev = &alvium->i2c_client->dev;int ret;if (ret) {"Fail to read bcrm version reg\n" );return ret;if (ret) {"Fail to bcrm address reg\n" );return ret;if (ret) {"Fail to read fw version reg\n" );return ret;if (ret) {"Fail to read host supported csi lanes reg\n" );return ret;if (ret) {"Fail to read bcrm feature inquiry reg\n" );return ret;if (ret) {"Fail to read features params regs\n" );return ret;if (ret) {"Fail to read available mipi data formats reg\n" );return ret;if (ret) {"Fail to read available Bayer patterns reg\n" );return ret;if (ret) {"Fail to get current mode reg\n" );return ret;return 0;static int alvium_hw_init(struct alvium_dev *alvium)struct device *dev = &alvium->i2c_client->dev;int ret;/* Set Alvium BCM mode*/ if (ret) {"Fail to set BCM mode\n" );return ret;if (ret) {"Fail to set csi lanes\n" );return ret;if (ret) {"Fail to set csi clk\n" );return ret;if (ret) {"Fail to set lp2hs reg\n" );return ret;return 0;/* --------------- Subdev Operations --------------- */ static int alvium_s_frame_interval(struct v4l2_subdev *sd,struct v4l2_subdev_state *sd_state,struct v4l2_subdev_frame_interval *fi)struct alvium_dev *alvium = sd_to_alvium(sd);struct device *dev = &alvium->i2c_client->dev;struct v4l2_fract *interval;int ret;if (alvium->streaming)return -EBUSY;if (fi->interval.denominator == 0)return -EINVAL;if (ret) {"Fail to get frame interval\n" );return ret;"fi->interval.numerator = %d\n" ,"fi->interval.denominator = %d\n" ,if (fi->which != V4L2_SUBDEV_FORMAT_ACTIVE)return 0;return alvium_set_frame_rate(alvium, req_fr);static int alvium_enum_mbus_code(struct v4l2_subdev *sd,struct v4l2_subdev_state *sd_state,struct v4l2_subdev_mbus_code_enum *code)struct alvium_dev *alvium = sd_to_alvium(sd);if (code->index >= alvium->alvium_csi2_fmt_n)return -EINVAL;return 0;static const struct alvium_pixfmt *struct alvium_dev *alvium, u32 code)unsigned int i;for (i = 0; alvium->alvium_csi2_fmt[i].code; ++i)if (alvium->alvium_csi2_fmt[i].code == code)return &alvium->alvium_csi2_fmt[i];return &alvium->alvium_csi2_fmt[0];static int alvium_enum_frame_size(struct v4l2_subdev *sd,struct v4l2_subdev_state *state,struct v4l2_subdev_frame_size_enum *fse)struct alvium_dev *alvium = sd_to_alvium(sd);const struct alvium_pixfmt *alvium_csi2_fmt;if (fse->index)return -EINVAL;if (fse->code != alvium_csi2_fmt->code)return -EINVAL;return 0;static int alvium_set_mode(struct alvium_dev *alvium,struct v4l2_subdev_state *state)struct v4l2_mbus_framefmt *fmt;struct v4l2_rect *crop;int ret;/* alvium don't accept negative crop left/top */ if (ret)return ret;if (ret)return ret;if (ret)return ret;if (ret)return ret;return 0;static int alvium_set_framefmt(struct alvium_dev *alvium,struct v4l2_mbus_framefmt *format)struct device *dev = &alvium->i2c_client->dev;const struct alvium_pixfmt *alvium_csi2_fmt;int ret = 0;if (ret)return ret;if (alvium_csi2_fmt->is_raw) {if (ret)return ret;"start: %s, mipi_fmt_regval regval = 0x%llx" ,return ret;static int alvium_s_stream(struct v4l2_subdev *sd, int enable)struct alvium_dev *alvium = sd_to_alvium(sd);struct i2c_client *client = v4l2_get_subdevdata(&alvium->sd);struct v4l2_mbus_framefmt *fmt;struct v4l2_subdev_state *state;int ret = 0;if (enable) {if (ret < 0)goto out;if (ret)goto out;if (ret)goto out;if (ret)goto out;if (ret)goto out;else {return 0;return ret;static int alvium_init_state(struct v4l2_subdev *sd,struct v4l2_subdev_state *state)struct alvium_dev *alvium = sd_to_alvium(sd);struct alvium_mode *mode = &alvium->mode;struct v4l2_fract *interval;struct v4l2_subdev_format sd_fmt = {struct v4l2_subdev_crop sd_crop = {/* Setup initial frame interval*/ return 0;static int alvium_set_fmt(struct v4l2_subdev *sd,struct v4l2_subdev_state *sd_state,struct v4l2_subdev_format *format)struct alvium_dev *alvium = sd_to_alvium(sd);const struct alvium_pixfmt *alvium_csi2_fmt;struct v4l2_mbus_framefmt *fmt;struct v4l2_rect *crop;/* Adjust left and top to prevent roll over sensor area */ /* Set also the crop width and height when set a new fmt */ return 0;static int alvium_set_selection(struct v4l2_subdev *sd,struct v4l2_subdev_state *sd_state,struct v4l2_subdev_selection *sel)struct alvium_dev *alvium = sd_to_alvium(sd);struct v4l2_mbus_framefmt *fmt;struct v4l2_rect *crop;if (sel->target != V4L2_SEL_TGT_CROP)return -EINVAL;/* * Alvium can only shift the origin of the img * then we accept only value with the same value of the actual fmt if (sel->r.width != fmt->width)if (sel->r.height != fmt->height)/* alvium don't accept negative crop left/top */ return 0;static int alvium_get_selection(struct v4l2_subdev *sd,struct v4l2_subdev_state *sd_state,struct v4l2_subdev_selection *sel)struct alvium_dev *alvium = sd_to_alvium(sd);switch (sel->target) {/* Current cropping area */ case V4L2_SEL_TGT_CROP:break ;/* Cropping bounds */ case V4L2_SEL_TGT_NATIVE_SIZE:break ;/* Default cropping area */ case V4L2_SEL_TGT_CROP_BOUNDS:case V4L2_SEL_TGT_CROP_DEFAULT:break ;default :return -EINVAL;return 0;static int alvium_g_volatile_ctrl(struct v4l2_ctrl *ctrl)struct v4l2_subdev *sd = ctrl_to_sd(ctrl);struct alvium_dev *alvium = sd_to_alvium(sd);int val;switch (ctrl->id) {case V4L2_CID_ANALOGUE_GAIN:if (val < 0)return val;break ;case V4L2_CID_EXPOSURE:if (val < 0)return val;break ;return 0;static int alvium_s_ctrl(struct v4l2_ctrl *ctrl)struct v4l2_subdev *sd = ctrl_to_sd(ctrl);struct alvium_dev *alvium = sd_to_alvium(sd);struct i2c_client *client = v4l2_get_subdevdata(&alvium->sd);int ret;/* * Applying V4L2 control value only happens * when power is up for streaming if (!pm_runtime_get_if_in_use(&client->dev))return 0;switch (ctrl->id) {case V4L2_CID_ANALOGUE_GAIN:break ;case V4L2_CID_AUTOGAIN:break ;case V4L2_CID_EXPOSURE:break ;case V4L2_CID_EXPOSURE_AUTO:break ;case V4L2_CID_RED_BALANCE:break ;case V4L2_CID_BLUE_BALANCE:break ;case V4L2_CID_AUTO_WHITE_BALANCE:break ;case V4L2_CID_HUE:break ;case V4L2_CID_CONTRAST:break ;case V4L2_CID_SATURATION:break ;case V4L2_CID_GAMMA:break ;case V4L2_CID_SHARPNESS:break ;case V4L2_CID_HFLIP:break ;case V4L2_CID_VFLIP:break ;default :break ;return ret;static const struct v4l2_ctrl_ops alvium_ctrl_ops = {static int alvium_ctrl_init(struct alvium_dev *alvium)const struct v4l2_ctrl_ops *ops = &alvium_ctrl_ops;struct alvium_ctrls *ctrls = &alvium->ctrls;struct v4l2_ctrl_handler *hdl = &ctrls->handler;struct v4l2_fwnode_device_properties props;int ret;/* Pixel rate is fixed */ /* Link freq is fixed */ /* Auto/manual white balance */ if (alvium->avail_ft.auto_whiteb) {false );/* Auto/manual exposure */ if (alvium->avail_ft.auto_exp) {true );/* Auto/manual gain */ if (alvium->avail_ft.auto_gain) {true );if (alvium->avail_ft.gain) {if (alvium->avail_ft.sat)if (alvium->avail_ft.hue)if (alvium->avail_ft.contrast)if (alvium->avail_ft.gamma)if (alvium->avail_ft.sharp)if (alvium->avail_ft.rev_x)if (alvium->avail_ft.rev_y)if (hdl->error) {goto free_ctrls;if (ret)goto free_ctrls;if (ret)goto free_ctrls;return 0;return ret;static const struct v4l2_subdev_core_ops alvium_core_ops = {static const struct v4l2_subdev_video_ops alvium_video_ops = {static const struct v4l2_subdev_pad_ops alvium_pad_ops = {static const struct v4l2_subdev_internal_ops alvium_internal_ops = {static const struct v4l2_subdev_ops alvium_subdev_ops = {static int alvium_subdev_init(struct alvium_dev *alvium)struct i2c_client *client = alvium->i2c_client;struct device *dev = &alvium->i2c_client->dev;struct v4l2_subdev *sd = &alvium->sd;int ret;/* Setup the initial mode */ /* init alvium sd */ if (ret) {"Could not register media entity\n" );return ret;if (ret) {"Control initialization error %d\n" , ret);goto entity_cleanup;if (ret < 0) {"subdev initialization error %d\n" , ret);goto err_ctrls;return 0;return ret;static void alvium_subdev_cleanup(struct alvium_dev *alvium)static int alvium_get_dt_data(struct alvium_dev *alvium)struct device *dev = &alvium->i2c_client->dev;struct fwnode_handle *fwnode = dev_fwnode(dev);struct fwnode_handle *endpoint;if (!fwnode)return -EINVAL;/* Only CSI2 is supported for now: */ if (!endpoint) {"endpoint node not found\n" );return -EINVAL;if (v4l2_fwnode_endpoint_alloc_parse(endpoint, &alvium->ep)) {"could not parse endpoint\n" );goto error_out;if (!alvium->ep.nr_of_link_frequencies) {"no link frequencies defined" );goto error_out;return 0;return -EINVAL;static int alvium_set_power(struct alvium_dev *alvium, bool on)int ret;if (!on)return regulator_disable(alvium->reg_vcc);if (ret)return ret;/* alvium boot time 7s */ return 0;static int alvium_runtime_resume(struct device *dev)struct v4l2_subdev *sd = dev_get_drvdata(dev);struct alvium_dev *alvium = sd_to_alvium(sd);int ret;true );if (ret)return ret;if (ret) {false );return ret;return 0;static int alvium_runtime_suspend(struct device *dev)struct v4l2_subdev *sd = dev_get_drvdata(dev);struct alvium_dev *alvium = sd_to_alvium(sd);false );return 0;static const struct dev_pm_ops alvium_pm_ops = {static int alvium_probe(struct i2c_client *client)struct device *dev = &client->dev;struct alvium_dev *alvium;int ret;sizeof (*alvium), GFP_KERNEL);if (!alvium)return -ENOMEM;if (IS_ERR(alvium->regmap))return PTR_ERR(alvium->regmap);if (ret)return ret;"vcc-ext-in" );if (IS_ERR(alvium->reg_vcc))return dev_err_probe(dev, PTR_ERR(alvium->reg_vcc),"no vcc-ext-in regulator provided\n" );true );if (ret)goto err_powerdown;if (!alvium_is_alive(alvium)) {"Device detection failed\n" );goto err_powerdown;if (ret) {"get_hw_info fail\n" );goto err_powerdown;if (ret) {"hw_init fail\n" );goto err_powerdown;if (ret) {"setup_mipi_fmt fail\n" );goto err_powerdown;/* * Enable runtime PM without autosuspend: * * Don't use pm autosuspend (alvium have ~7s boot time). * Alvium has been powered manually: * - mark it as active * - increase the usage count without resuming the device. /* Initialize the V4L2 subdev. */ if (ret)goto err_pm;if (ret < 0) {"Could not register v4l2 device\n" );goto err_subdev;return 0;false );return ret;static void alvium_remove(struct i2c_client *client)struct v4l2_subdev *sd = i2c_get_clientdata(client);struct alvium_dev *alvium = sd_to_alvium(sd);struct device *dev = &alvium->i2c_client->dev;/* * Disable runtime PM. In case runtime PM is disabled in the kernel, * make sure to turn power off manually. if (!pm_runtime_status_suspended(dev))false );static const struct of_device_id alvium_of_ids[] = {"alliedvision,alvium-csi2" , },static struct i2c_driver alvium_i2c_driver = {"alvium-csi2" ,"Allied Vision's Alvium Camera Driver" );"Tommaso Merciai " );"Martin Hecht " );"Avnet Silica Software & Services EMEA" );"GPL" );
Messung V0.5 C=95 H=93 G=93
¤ Dauer der Verarbeitung: 0.23 Sekunden
¤ *© Formatika GbR, Deutschland
