From 898198428aa35f52c2b58c037e960dcbcc4ef9d8 Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Tue, 14 Apr 2020 16:12:33 +0100 Subject: [PATCH] media: i2c: ov9281: Fixup for recent kernel releases, and remove custom code The Rockchip driver was based on a 4.4 kernel, and had several custom Rockchip parts. Update to 5.4 kernel APIs, with the relevant controls required by libcamera, and remove custom Rockchip parts. Signed-off-by: Dave Stevenson --- drivers/media/i2c/Kconfig | 2 +- drivers/media/i2c/ov9281.c | 361 +++++++++++++------------------------ 2 files changed, 123 insertions(+), 240 deletions(-) --- a/drivers/media/i2c/Kconfig +++ b/drivers/media/i2c/Kconfig @@ -857,7 +857,7 @@ config VIDEO_OV9640 config VIDEO_OV9281 tristate "OmniVision OV9281 sensor support" - depends on I2C && VIDEO_V4L2 + depends on I2C && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API depends on MEDIA_CAMERA_SUPPORT help This is a Video4Linux2 sensor-level driver for the OmniVision --- a/drivers/media/i2c/ov9281.c +++ b/drivers/media/i2c/ov9281.c @@ -1,6 +1,11 @@ // SPDX-License-Identifier: GPL-2.0 /* - * ov9281 driver + * Omnivision OV9281 1280x800 global shutter image sensor driver + * + * This driver has been taken from + * https://github.com/rockchip-linux/kernel/blob/develop-4.4/drivers/media/i2c/ov9281.c + * cleaned up, made to compile against mainline kernels instead of the Rockchip + * vendor kernel, and the relevant controls added to work with libcamera. * * Copyright (C) 2017 Fuzhou Rockchip Electronics Co., Ltd. * V0.0X01.0X02 fix mclk issue when probe multiple camera. @@ -17,22 +22,18 @@ #include #include #include -#include #include #include #include #include -#include - -#define DRIVER_VERSION KERNEL_VERSION(0, 0x01, 0x3) - -#ifndef V4L2_CID_DIGITAL_GAIN -#define V4L2_CID_DIGITAL_GAIN V4L2_CID_GAIN -#endif #define OV9281_LINK_FREQ_400MHZ 400000000 +#define OV9281_LANES 2 +#define OV9281_BITS_PER_SAMPLE 10 + /* pixel rate = link frequency * 2 * lanes / BITS_PER_SAMPLE */ -#define OV9281_PIXEL_RATE (OV9281_LINK_FREQ_400MHZ * 2 * 2 / 10) +#define OV9281_PIXEL_RATE (OV9281_LINK_FREQ_400MHZ * 2 * \ + OV9281_LANES / OV9281_BITS_PER_SAMPLE) #define OV9281_XVCLK_FREQ 24000000 #define CHIP_ID 0x9281 @@ -63,18 +64,24 @@ #define OV9281_REG_VTS 0x380e +/* + * OV9281 native and active pixel array size. + * Datasheet not available to confirm these values, so assume there are no + * border pixels. + */ +#define OV9281_NATIVE_WIDTH 1280U +#define OV9281_NATIVE_HEIGHT 800U +#define OV9281_PIXEL_ARRAY_LEFT 0U +#define OV9281_PIXEL_ARRAY_TOP 0U +#define OV9281_PIXEL_ARRAY_WIDTH 1280U +#define OV9281_PIXEL_ARRAY_HEIGHT 800U + #define REG_NULL 0xFFFF #define OV9281_REG_VALUE_08BIT 1 #define OV9281_REG_VALUE_16BIT 2 #define OV9281_REG_VALUE_24BIT 3 -#define OV9281_LANES 2 -#define OV9281_BITS_PER_SAMPLE 10 - -#define OF_CAMERA_PINCTRL_STATE_DEFAULT "rockchip,camera_default" -#define OF_CAMERA_PINCTRL_STATE_SLEEP "rockchip,camera_sleep" - #define OV9281_NAME "ov9281" static const char * const ov9281_supply_names[] = { @@ -93,10 +100,10 @@ struct regval { struct ov9281_mode { u32 width; u32 height; - struct v4l2_fract max_fps; u32 hts_def; u32 vts_def; u32 exp_def; + struct v4l2_rect crop; const struct regval *reg_list; }; @@ -107,10 +114,6 @@ struct ov9281 { struct gpio_desc *pwdn_gpio; struct regulator_bulk_data supplies[OV9281_NUM_SUPPLIES]; - struct pinctrl *pinctrl; - struct pinctrl_state *pins_default; - struct pinctrl_state *pins_sleep; - struct v4l2_subdev subdev; struct media_pad pad; struct v4l2_ctrl_handler ctrl_handler; @@ -124,23 +127,12 @@ struct ov9281 { bool streaming; bool power_on; const struct ov9281_mode *cur_mode; - u32 module_index; - const char *module_facing; - const char *module_name; - const char *len_name; }; #define to_ov9281(sd) container_of(sd, struct ov9281, subdev) /* * Xclk 24Mhz - */ -static const struct regval ov9281_global_regs[] = { - {REG_NULL, 0x00}, -}; - -/* - * Xclk 24Mhz * max_framerate 120fps * mipi_datarate per lane 800Mbps */ @@ -247,13 +239,15 @@ static const struct ov9281_mode supporte { .width = 1280, .height = 800, - .max_fps = { - .numerator = 10000, - .denominator = 1200000, - }, .exp_def = 0x0320, - .hts_def = 0x0b60,//0x2d8*4 + .hts_def = 0x05b0, /* 0x2d8*2 */ .vts_def = 0x038e, + .crop = { + .left = 0, + .top = 0, + .width = 1280, + .height = 800 + }, .reg_list = ov9281_1280x800_regs, }, }; @@ -389,22 +383,28 @@ static int ov9281_set_fmt(struct v4l2_su fmt->format.width = mode->width; fmt->format.height = mode->height; fmt->format.field = V4L2_FIELD_NONE; + fmt->format.colorspace = V4L2_COLORSPACE_SRGB; + fmt->format.ycbcr_enc = + V4L2_MAP_YCBCR_ENC_DEFAULT(fmt->format.colorspace); + fmt->format.quantization = + V4L2_MAP_QUANTIZATION_DEFAULT(true, fmt->format.colorspace, + fmt->format.ycbcr_enc); + fmt->format.xfer_func = + V4L2_MAP_XFER_FUNC_DEFAULT(fmt->format.colorspace); + if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) { -#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API *v4l2_subdev_get_try_format(sd, cfg, fmt->pad) = fmt->format; -#else - mutex_unlock(&ov9281->mutex); - return -ENOTTY; -#endif } else { ov9281->cur_mode = mode; h_blank = mode->hts_def - mode->width; __v4l2_ctrl_modify_range(ov9281->hblank, h_blank, h_blank, 1, h_blank); + __v4l2_ctrl_s_ctrl(ov9281->hblank, h_blank); vblank_def = mode->vts_def - mode->height; __v4l2_ctrl_modify_range(ov9281->vblank, vblank_def, OV9281_VTS_MAX - mode->height, 1, vblank_def); + __v4l2_ctrl_s_ctrl(ov9281->vblank, vblank_def); } mutex_unlock(&ov9281->mutex); @@ -421,17 +421,21 @@ static int ov9281_get_fmt(struct v4l2_su mutex_lock(&ov9281->mutex); if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) { -#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API fmt->format = *v4l2_subdev_get_try_format(sd, cfg, fmt->pad); -#else - mutex_unlock(&ov9281->mutex); - return -ENOTTY; -#endif } else { fmt->format.width = mode->width; fmt->format.height = mode->height; fmt->format.code = MEDIA_BUS_FMT_Y10_1X10; fmt->format.field = V4L2_FIELD_NONE; + fmt->format.colorspace = V4L2_COLORSPACE_SRGB; + fmt->format.ycbcr_enc = + V4L2_MAP_YCBCR_ENC_DEFAULT(fmt->format.colorspace); + fmt->format.quantization = + V4L2_MAP_QUANTIZATION_DEFAULT(true, + fmt->format.colorspace, + fmt->format.ycbcr_enc); + fmt->format.xfer_func = + V4L2_MAP_XFER_FUNC_DEFAULT(fmt->format.colorspace); } mutex_unlock(&ov9281->mutex); @@ -442,7 +446,7 @@ static int ov9281_enum_mbus_code(struct struct v4l2_subdev_pad_config *cfg, struct v4l2_subdev_mbus_code_enum *code) { - if (code->index != 0) + if (code->index) return -EINVAL; code->code = MEDIA_BUS_FMT_Y10_1X10; @@ -480,88 +484,56 @@ static int ov9281_enable_test_pattern(st OV9281_REG_VALUE_08BIT, val); } -static int OV9281_g_frame_interval(struct v4l2_subdev *sd, - struct v4l2_subdev_frame_interval *fi) -{ - struct ov9281 *ov9281 = to_ov9281(sd); - const struct ov9281_mode *mode = ov9281->cur_mode; - - mutex_lock(&ov9281->mutex); - fi->interval = mode->max_fps; - mutex_unlock(&ov9281->mutex); +static const struct v4l2_rect * +__ov9281_get_pad_crop(struct ov9281 *ov9281, struct v4l2_subdev_pad_config *cfg, + unsigned int pad, enum v4l2_subdev_format_whence which) +{ + switch (which) { + case V4L2_SUBDEV_FORMAT_TRY: + return v4l2_subdev_get_try_crop(&ov9281->subdev, cfg, pad); + case V4L2_SUBDEV_FORMAT_ACTIVE: + return &ov9281->cur_mode->crop; + } - return 0; + return NULL; } -static void ov9281_get_module_inf(struct ov9281 *ov9281, - struct rkmodule_inf *inf) +static int ov9281_get_selection(struct v4l2_subdev *sd, + struct v4l2_subdev_pad_config *cfg, + struct v4l2_subdev_selection *sel) { - memset(inf, 0, sizeof(*inf)); - strlcpy(inf->base.sensor, OV9281_NAME, sizeof(inf->base.sensor)); - strlcpy(inf->base.module, ov9281->module_name, - sizeof(inf->base.module)); - strlcpy(inf->base.lens, ov9281->len_name, sizeof(inf->base.lens)); -} + switch (sel->target) { + case V4L2_SEL_TGT_CROP: { + struct ov9281 *ov9281 = to_ov9281(sd); -static long ov9281_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg) -{ - struct ov9281 *ov9281 = to_ov9281(sd); - long ret = 0; + mutex_lock(&ov9281->mutex); + sel->r = *__ov9281_get_pad_crop(ov9281, cfg, sel->pad, + sel->which); + mutex_unlock(&ov9281->mutex); - switch (cmd) { - case RKMODULE_GET_MODULE_INFO: - ov9281_get_module_inf(ov9281, (struct rkmodule_inf *)arg); - break; - default: - ret = -ENOIOCTLCMD; - break; + return 0; } - return ret; -} + case V4L2_SEL_TGT_NATIVE_SIZE: + sel->r.top = 0; + sel->r.left = 0; + sel->r.width = OV9281_NATIVE_WIDTH; + sel->r.height = OV9281_NATIVE_HEIGHT; -#ifdef CONFIG_COMPAT -static long ov9281_compat_ioctl32(struct v4l2_subdev *sd, - unsigned int cmd, unsigned long arg) -{ - void __user *up = compat_ptr(arg); - struct rkmodule_inf *inf; - struct rkmodule_awb_cfg *cfg; - long ret; - - switch (cmd) { - case RKMODULE_GET_MODULE_INFO: - inf = kzalloc(sizeof(*inf), GFP_KERNEL); - if (!inf) { - ret = -ENOMEM; - return ret; - } + return 0; - ret = ov9281_ioctl(sd, cmd, inf); - if (!ret) - ret = copy_to_user(up, inf, sizeof(*inf)); - kfree(inf); - break; - case RKMODULE_AWB_CFG: - cfg = kzalloc(sizeof(*cfg), GFP_KERNEL); - if (!cfg) { - ret = -ENOMEM; - return ret; - } + case V4L2_SEL_TGT_CROP_DEFAULT: + case V4L2_SEL_TGT_CROP_BOUNDS: + sel->r.top = OV9281_PIXEL_ARRAY_TOP; + sel->r.left = OV9281_PIXEL_ARRAY_LEFT; + sel->r.width = OV9281_PIXEL_ARRAY_WIDTH; + sel->r.height = OV9281_PIXEL_ARRAY_HEIGHT; - ret = copy_from_user(cfg, up, sizeof(*cfg)); - if (!ret) - ret = ov9281_ioctl(sd, cmd, cfg); - kfree(cfg); - break; - default: - ret = -ENOIOCTLCMD; - break; + return 0; } - return ret; + return -EINVAL; } -#endif static int __ov9281_start_stream(struct ov9281 *ov9281) { @@ -643,12 +615,6 @@ static int ov9281_s_power(struct v4l2_su pm_runtime_put_noidle(&client->dev); goto unlock_and_return; } - ret = ov9281_write_array(ov9281->client, ov9281_global_regs); - if (ret) { - v4l2_err(sd, "could not set init registers\n"); - pm_runtime_put_noidle(&client->dev); - goto unlock_and_return; - } ov9281->power_on = true; } else { pm_runtime_put(&client->dev); @@ -673,18 +639,12 @@ static int __ov9281_power_on(struct ov92 u32 delay_us; struct device *dev = &ov9281->client->dev; - if (!IS_ERR_OR_NULL(ov9281->pins_default)) { - ret = pinctrl_select_state(ov9281->pinctrl, - ov9281->pins_default); - if (ret < 0) - dev_err(dev, "could not set pins\n"); - } - ret = clk_set_rate(ov9281->xvclk, OV9281_XVCLK_FREQ); if (ret < 0) dev_warn(dev, "Failed to set xvclk rate (24MHz)\n"); if (clk_get_rate(ov9281->xvclk) != OV9281_XVCLK_FREQ) - dev_warn(dev, "xvclk mismatched, modes are based on 24MHz\n"); + dev_warn(dev, "xvclk mismatched, modes are based on 24MHz - rate is %lu\n", + clk_get_rate(ov9281->xvclk)); ret = clk_prepare_enable(ov9281->xvclk); if (ret < 0) { @@ -722,20 +682,11 @@ disable_clk: static void __ov9281_power_off(struct ov9281 *ov9281) { - int ret; - struct device *dev = &ov9281->client->dev; - if (!IS_ERR(ov9281->pwdn_gpio)) gpiod_set_value_cansleep(ov9281->pwdn_gpio, 0); clk_disable_unprepare(ov9281->xvclk); if (!IS_ERR(ov9281->reset_gpio)) gpiod_set_value_cansleep(ov9281->reset_gpio, 0); - if (!IS_ERR_OR_NULL(ov9281->pins_sleep)) { - ret = pinctrl_select_state(ov9281->pinctrl, - ov9281->pins_sleep); - if (ret < 0) - dev_dbg(dev, "could not set pins\n"); - } regulator_bulk_disable(OV9281_NUM_SUPPLIES, ov9281->supplies); } @@ -759,7 +710,6 @@ static int ov9281_runtime_suspend(struct return 0; } -#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API static int ov9281_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh) { struct ov9281 *ov9281 = to_ov9281(sd); @@ -773,61 +723,42 @@ static int ov9281_open(struct v4l2_subde try_fmt->height = def_mode->height; try_fmt->code = MEDIA_BUS_FMT_Y10_1X10; try_fmt->field = V4L2_FIELD_NONE; + try_fmt->colorspace = V4L2_COLORSPACE_SRGB; + try_fmt->ycbcr_enc = V4L2_MAP_YCBCR_ENC_DEFAULT(try_fmt->colorspace); + try_fmt->quantization = + V4L2_MAP_QUANTIZATION_DEFAULT(true, try_fmt->colorspace, + try_fmt->ycbcr_enc); + try_fmt->xfer_func = V4L2_MAP_XFER_FUNC_DEFAULT(try_fmt->colorspace); mutex_unlock(&ov9281->mutex); /* No crop or compose */ return 0; } -#endif - -static int -ov9281_enum_frame_interval(struct v4l2_subdev *sd, - struct v4l2_subdev_pad_config *cfg, - struct v4l2_subdev_frame_interval_enum *fie) -{ - if (fie->index >= ARRAY_SIZE(supported_modes)) - return -EINVAL; - - if (fie->code != MEDIA_BUS_FMT_Y10_1X10) - return -EINVAL; - - fie->width = supported_modes[fie->index].width; - fie->height = supported_modes[fie->index].height; - fie->interval = supported_modes[fie->index].max_fps; - return 0; -} static const struct dev_pm_ops ov9281_pm_ops = { SET_RUNTIME_PM_OPS(ov9281_runtime_suspend, ov9281_runtime_resume, NULL) }; -#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API static const struct v4l2_subdev_internal_ops ov9281_internal_ops = { .open = ov9281_open, }; -#endif static const struct v4l2_subdev_core_ops ov9281_core_ops = { .s_power = ov9281_s_power, - .ioctl = ov9281_ioctl, -#ifdef CONFIG_COMPAT - .compat_ioctl32 = ov9281_compat_ioctl32, -#endif }; static const struct v4l2_subdev_video_ops ov9281_video_ops = { .s_stream = ov9281_s_stream, - .g_frame_interval = OV9281_g_frame_interval, }; static const struct v4l2_subdev_pad_ops ov9281_pad_ops = { .enum_mbus_code = ov9281_enum_mbus_code, .enum_frame_size = ov9281_enum_frame_sizes, - .enum_frame_interval = ov9281_enum_frame_interval, .get_fmt = ov9281_get_fmt, .set_fmt = ov9281_set_fmt, + .get_selection = ov9281_get_selection, }; static const struct v4l2_subdev_ops ov9281_subdev_ops = { @@ -868,7 +799,8 @@ static int ov9281_set_ctrl(struct v4l2_c case V4L2_CID_ANALOGUE_GAIN: ret = ov9281_write_reg(ov9281->client, OV9281_REG_GAIN_H, OV9281_REG_VALUE_08BIT, - (ctrl->val >> OV9281_GAIN_H_SHIFT) & OV9281_GAIN_H_MASK); + (ctrl->val >> OV9281_GAIN_H_SHIFT) & + OV9281_GAIN_H_MASK); ret |= ov9281_write_reg(ov9281->client, OV9281_REG_GAIN_L, OV9281_REG_VALUE_08BIT, ctrl->val & OV9281_GAIN_L_MASK); @@ -922,31 +854,34 @@ static int ov9281_initialize_controls(st h_blank = mode->hts_def - mode->width; ov9281->hblank = v4l2_ctrl_new_std(handler, NULL, V4L2_CID_HBLANK, - h_blank, h_blank, 1, h_blank); + h_blank, h_blank, 1, h_blank); if (ov9281->hblank) ov9281->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY; vblank_def = mode->vts_def - mode->height; ov9281->vblank = v4l2_ctrl_new_std(handler, &ov9281_ctrl_ops, - V4L2_CID_VBLANK, vblank_def, - OV9281_VTS_MAX - mode->height, - 1, vblank_def); + V4L2_CID_VBLANK, vblank_def, + OV9281_VTS_MAX - mode->height, 1, + vblank_def); exposure_max = mode->vts_def - 4; ov9281->exposure = v4l2_ctrl_new_std(handler, &ov9281_ctrl_ops, - V4L2_CID_EXPOSURE, OV9281_EXPOSURE_MIN, - exposure_max, OV9281_EXPOSURE_STEP, - mode->exp_def); + V4L2_CID_EXPOSURE, + OV9281_EXPOSURE_MIN, exposure_max, + OV9281_EXPOSURE_STEP, + mode->exp_def); ov9281->anal_gain = v4l2_ctrl_new_std(handler, &ov9281_ctrl_ops, - V4L2_CID_ANALOGUE_GAIN, OV9281_GAIN_MIN, - OV9281_GAIN_MAX, OV9281_GAIN_STEP, - OV9281_GAIN_DEFAULT); - - ov9281->test_pattern = v4l2_ctrl_new_std_menu_items(handler, - &ov9281_ctrl_ops, V4L2_CID_TEST_PATTERN, - ARRAY_SIZE(ov9281_test_pattern_menu) - 1, - 0, 0, ov9281_test_pattern_menu); + V4L2_CID_ANALOGUE_GAIN, + OV9281_GAIN_MIN, OV9281_GAIN_MAX, + OV9281_GAIN_STEP, + OV9281_GAIN_DEFAULT); + + ov9281->test_pattern = + v4l2_ctrl_new_std_menu_items(handler, &ov9281_ctrl_ops, + V4L2_CID_TEST_PATTERN, + ARRAY_SIZE(ov9281_test_pattern_menu) - 1, + 0, 0, ov9281_test_pattern_menu); if (handler->error) { ret = handler->error; @@ -1000,34 +935,14 @@ static int ov9281_probe(struct i2c_clien const struct i2c_device_id *id) { struct device *dev = &client->dev; - struct device_node *node = dev->of_node; struct ov9281 *ov9281; struct v4l2_subdev *sd; - char facing[2]; int ret; - dev_info(dev, "driver version: %02x.%02x.%02x", - DRIVER_VERSION >> 16, - (DRIVER_VERSION & 0xff00) >> 8, - DRIVER_VERSION & 0x00ff); - ov9281 = devm_kzalloc(dev, sizeof(*ov9281), GFP_KERNEL); if (!ov9281) return -ENOMEM; - ret = of_property_read_u32(node, RKMODULE_CAMERA_MODULE_INDEX, - &ov9281->module_index); - ret |= of_property_read_string(node, RKMODULE_CAMERA_MODULE_FACING, - &ov9281->module_facing); - ret |= of_property_read_string(node, RKMODULE_CAMERA_MODULE_NAME, - &ov9281->module_name); - ret |= of_property_read_string(node, RKMODULE_CAMERA_LENS_NAME, - &ov9281->len_name); - if (ret) { - dev_err(dev, "could not get module information!\n"); - return -EINVAL; - } - ov9281->client = client; ov9281->cur_mode = &supported_modes[0]; @@ -1037,31 +952,15 @@ static int ov9281_probe(struct i2c_clien return -EINVAL; } - ov9281->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW); + ov9281->reset_gpio = devm_gpiod_get_optional(dev, "reset", + GPIOD_OUT_LOW); if (IS_ERR(ov9281->reset_gpio)) dev_warn(dev, "Failed to get reset-gpios\n"); - ov9281->pwdn_gpio = devm_gpiod_get(dev, "pwdn", GPIOD_OUT_LOW); + ov9281->pwdn_gpio = devm_gpiod_get_optional(dev, "pwdn", GPIOD_OUT_LOW); if (IS_ERR(ov9281->pwdn_gpio)) dev_warn(dev, "Failed to get pwdn-gpios\n"); - ov9281->pinctrl = devm_pinctrl_get(dev); - if (!IS_ERR(ov9281->pinctrl)) { - ov9281->pins_default = - pinctrl_lookup_state(ov9281->pinctrl, - OF_CAMERA_PINCTRL_STATE_DEFAULT); - if (IS_ERR(ov9281->pins_default)) - dev_err(dev, "could not get default pinstate\n"); - - ov9281->pins_sleep = - pinctrl_lookup_state(ov9281->pinctrl, - OF_CAMERA_PINCTRL_STATE_SLEEP); - if (IS_ERR(ov9281->pins_sleep)) - dev_err(dev, "could not get sleep pinstate\n"); - } else { - dev_err(dev, "no pinctrl\n"); - } - ret = ov9281_configure_regulators(ov9281); if (ret) { dev_err(dev, "Failed to get power regulators\n"); @@ -1084,26 +983,16 @@ static int ov9281_probe(struct i2c_clien if (ret) goto err_power_off; -#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API sd->internal_ops = &ov9281_internal_ops; sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; -#endif -#if defined(CONFIG_MEDIA_CONTROLLER) + ov9281->pad.flags = MEDIA_PAD_FL_SOURCE; - sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR; - ret = media_entity_init(&sd->entity, 1, &ov9281->pad, 0); + sd->entity.function = MEDIA_ENT_F_CAM_SENSOR; + ret = media_entity_pads_init(&sd->entity, 1, &ov9281->pad); if (ret < 0) goto err_power_off; -#endif - - memset(facing, 0, sizeof(facing)); - if (strcmp(ov9281->module_facing, "back") == 0) - facing[0] = 'b'; - else - facing[0] = 'f'; - snprintf(sd->name, sizeof(sd->name), "m%02d_%s_%s %s", - ov9281->module_index, facing, + snprintf(sd->name, sizeof(sd->name), "m%s %s", OV9281_NAME, dev_name(sd->dev)); ret = v4l2_async_register_subdev_sensor_common(sd); if (ret) { @@ -1118,9 +1007,7 @@ static int ov9281_probe(struct i2c_clien return 0; err_clean_entity: -#if defined(CONFIG_MEDIA_CONTROLLER) media_entity_cleanup(&sd->entity); -#endif err_power_off: __ov9281_power_off(ov9281); err_free_handler: @@ -1137,9 +1024,7 @@ static int ov9281_remove(struct i2c_clie struct ov9281 *ov9281 = to_ov9281(sd); v4l2_async_unregister_subdev(sd); -#if defined(CONFIG_MEDIA_CONTROLLER) media_entity_cleanup(&sd->entity); -#endif v4l2_ctrl_handler_free(&ov9281->ctrl_handler); mutex_destroy(&ov9281->mutex); @@ -1151,13 +1036,11 @@ static int ov9281_remove(struct i2c_clie return 0; } -#if IS_ENABLED(CONFIG_OF) static const struct of_device_id ov9281_of_match[] = { { .compatible = "ovti,ov9281" }, {}, }; MODULE_DEVICE_TABLE(of, ov9281_of_match); -#endif static const struct i2c_device_id ov9281_match_id[] = { { "ovti,ov9281", 0 },