Re: [PATCH v5 3/3] media: i2c: Add support for alvium camera

From: Sakari Ailus
Date: Fri Jun 09 2023 - 05:27:23 EST

Next message: Tianrui Zhao: "[PATCH v13 23/30] LoongArch: KVM: Implement handle gspr exception"
Previous message: Stephan Gerhold: "Re: [PATCH 1/5] dt-bindings: reserved-memory: Add alloc-{bottom-up,top-down}"
In reply to: kernel test robot: "Re: [PATCH v5 3/3] media: i2c: Add support for alvium camera"
Next in thread: Tommaso Merciai: "Re: [PATCH v5 3/3] media: i2c: Add support for alvium camera"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

Hi Tommaso,

Thanks for the patch.

On Thu, Jun 08, 2023 at 10:31:16AM +0200, Tommaso Merciai wrote:
> The Alvium camera is shipped with sensor + isp in the same housing.
> The camera can be equipped with one out of various sensor and abstract
> the user from this. Camera is connected via MIPI CSI-2.
>
> Most of the camera module features are supported, with the main exception
> being fw update.
>
> The driver provides all mandatory, optional and recommended V4L2 controls
> for maximum compatibility with libcamera
>
> References:
> - https://www.alliedvision.com/en/products/embedded-vision-solutions
>
> Signed-off-by: Tommaso Merciai <tomm.merciai@xxxxxxxxx>
> ---
> Changes since v2:
> - Removed gpios/clock handling as suggested by LPinchart
> - Added vcc-ext-in supply support as suggested by LPinchart
> - Fixed alvium_setup_mipi_fmt funct as suggested by CJAILLET
> - Removed upside_down/hshake_bit priv data as suggested by CJAILLET
> - Fixed commit body as suggested by LPinchart
> - Mv alvium_set_streamon_delay to yalvium_set_lp2hs_delay
> - Fixed comment on lp2hs prop as suggested by LPinchart
> - Added pm resume/suspend functs as suggested by LPinchart
> - Dropped alvium_link_setup/alvium_s_power as suggested by LPinchart
> - Fixed regs defines as suggested by LPinchart
> - Fixed typedef as suggested by LPinchart
> - Dropped bcrm_v/fw_v from priv data as suggested by LPinchart
> - Now driver use the subdev active state to store the active format and crop
> as suggested by LPinchart
> - Dropped alvium_is_csi2/i2c_to_alvium as suggested by LPinchart
>
> Changes since v3:
> - Fixed warnings Reported-by: kernel test robot <lkp@xxxxxxxxx>
>
> Changes since v4:
> - Removed print into alvium_get_dt_data for alliedvision,lp2hs-delay-us as
> suggested by CDooley
>
> drivers/media/i2c/Kconfig | 10 +
> drivers/media/i2c/Makefile | 1 +
> drivers/media/i2c/alvium-csi2.c | 3479 +++++++++++++++++++++++++++++++
> drivers/media/i2c/alvium-csi2.h | 485 +++++
> 4 files changed, 3975 insertions(+)
> create mode 100644 drivers/media/i2c/alvium-csi2.c
> create mode 100644 drivers/media/i2c/alvium-csi2.h
>
> diff --git a/drivers/media/i2c/Kconfig b/drivers/media/i2c/Kconfig
> index 256d55bb2b1d..a9fdf10ffc15 100644
> --- a/drivers/media/i2c/Kconfig
> +++ b/drivers/media/i2c/Kconfig
> @@ -34,6 +34,16 @@ config VIDEO_APTINA_PLL
> config VIDEO_CCS_PLL
> tristate
>
> +config VIDEO_ALVIUM_CSI2
> + tristate "Allied Vision ALVIUM MIPI CSI-2 camera support"
> + depends on I2C
> + select MEDIA_CONTROLLER
> + select VIDEO_V4L2_SUBDEV_API
> + select V4L2_FWNODE
> + help
> + This is a Video4Linux2 sensor driver for the Allied Vision
> + ALVIUM camera connected via MIPI CSI-2 interface.
> +
> config VIDEO_AR0521
> tristate "ON Semiconductor AR0521 sensor support"
> depends on I2C && VIDEO_DEV
> diff --git a/drivers/media/i2c/Makefile b/drivers/media/i2c/Makefile
> index b44dacf935f4..be4dddd6fd98 100644
> --- a/drivers/media/i2c/Makefile
> +++ b/drivers/media/i2c/Makefile
> @@ -17,6 +17,7 @@ obj-$(CONFIG_VIDEO_ADV7604) += adv7604.o
> obj-$(CONFIG_VIDEO_ADV7842) += adv7842.o
> obj-$(CONFIG_VIDEO_AK7375) += ak7375.o
> obj-$(CONFIG_VIDEO_AK881X) += ak881x.o
> +obj-$(CONFIG_VIDEO_ALVIUM_CSI2) += alvium-csi2.o
> obj-$(CONFIG_VIDEO_APTINA_PLL) += aptina-pll.o
> obj-$(CONFIG_VIDEO_AR0521) += ar0521.o
> obj-$(CONFIG_VIDEO_BT819) += bt819.o
> diff --git a/drivers/media/i2c/alvium-csi2.c b/drivers/media/i2c/alvium-csi2.c
> new file mode 100644
> index 000000000000..52c9263075cf
> --- /dev/null
> +++ b/drivers/media/i2c/alvium-csi2.c
> @@ -0,0 +1,3479 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Allied Vision Inc. Alvium camera driver
> + *
> + * Copyright (C) 2023 Tommaso Merciai
> + * Copyright (C) 2023 Martin Hecht
> + * Copyright (C) 2023 Avnet EMG GmbH
> + */
> +
> +#include <asm/unaligned.h>
> +#include <linux/clk.h>
> +#include <linux/clk-provider.h>
> +#include <linux/clkdev.h>
> +#include <linux/ctype.h>
> +#include <linux/delay.h>
> +#include <linux/device.h>
> +#include <linux/gpio/consumer.h>
> +#include <linux/i2c.h>
> +#include <linux/init.h>

Do you need this?

> +#include <linux/module.h>
> +#include <linux/of_device.h>
> +#include <linux/of_graph.h>
> +#include <linux/pm_runtime.h>
> +#include <linux/regulator/consumer.h>
> +#include <linux/slab.h>
> +#include <linux/types.h>
> +#include <media/v4l2-async.h>
> +#include <media/v4l2-ctrls.h>
> +#include <media/mipi-csi2.h>

Please order alphabetically.

> +#include <media/v4l2-device.h>
> +#include <media/v4l2-event.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 = {
> + .code = MEDIA_BUS_FMT_UYVY8_1X16,
> + .width = 640,
> + .height = 480,
> + .colorspace = V4L2_COLORSPACE_SRGB,
> + .ycbcr_enc = V4L2_MAP_YCBCR_ENC_DEFAULT(V4L2_COLORSPACE_SRGB),
> + .quantization = V4L2_QUANTIZATION_FULL_RANGE,
> + .xfer_func = V4L2_MAP_XFER_FUNC_DEFAULT(V4L2_COLORSPACE_SRGB),
> + .field = V4L2_FIELD_NONE,
> +};
> +
> +static const struct alvium_pixfmt alvium_csi2_fmts[] = {
> + {
> + /* UYVY8_2X8 */
> + .id = ALVIUM_FMT_UYVY8_2X8,
> + .code = MEDIA_BUS_FMT_UYVY8_2X8,
> + .colorspace = V4L2_COLORSPACE_SRGB,
> + .fmt_av_bit = ALVIUM_BIT_YUV422_8,
> + .bay_av_bit = ALVIUM_BIT_BAY_NONE,
> + .mipi_fmt_regval = 0x1E,

Could you use MIPI_CSI2_DT_ definitions in mipi-csi2.h?

> + .bay_fmt_regval = -1,
> + .is_raw = 0,
> + }, {
> + /* UYVY8_1X16 */
> + .id = ALVIUM_FMT_UYVY8_1X16,
> + .code = MEDIA_BUS_FMT_UYVY8_1X16,
> + .colorspace = V4L2_COLORSPACE_SRGB,
> + .fmt_av_bit = ALVIUM_BIT_YUV422_8,
> + .bay_av_bit = ALVIUM_BIT_BAY_NONE,
> + .mipi_fmt_regval = 0x1E,
> + .bay_fmt_regval = -1,
> + .is_raw = 0,
> + }, {
> + /* YUYV8_1X16 */
> + .id = ALVIUM_FMT_YUYV8_1X16,
> + .code = MEDIA_BUS_FMT_YUYV8_1X16,
> + .colorspace = V4L2_COLORSPACE_SRGB,
> + .fmt_av_bit = ALVIUM_BIT_YUV422_8,
> + .bay_av_bit = ALVIUM_BIT_BAY_NONE,
> + .mipi_fmt_regval = 0x1E,
> + .bay_fmt_regval = -1,
> + .is_raw = 0,
> + }, {
> + /* YUYV8_2X8 */
> + .id = ALVIUM_FMT_YUYV8_2X8,
> + .code = MEDIA_BUS_FMT_YUYV8_2X8,
> + .colorspace = V4L2_COLORSPACE_SRGB,
> + .fmt_av_bit = ALVIUM_BIT_YUV422_8,
> + .bay_av_bit = ALVIUM_BIT_BAY_NONE,
> + .mipi_fmt_regval = 0x1E,
> + .bay_fmt_regval = -1,
> + .is_raw = 0,
> + }, {
> + /* YUYV10_1X20 */
> + .id = ALVIUM_FMT_YUYV10_1X20,
> + .code = MEDIA_BUS_FMT_YUYV10_1X20,
> + .colorspace = V4L2_COLORSPACE_SRGB,
> + .fmt_av_bit = ALVIUM_BIT_YUV422_10,
> + .bay_av_bit = ALVIUM_BIT_BAY_NONE,
> + .mipi_fmt_regval = 0x1F,
> + .bay_fmt_regval = -1,
> + .is_raw = 0,
> + }, {
> + /* RGB888_1X24 */
> + .id = ALVIUM_FMT_RGB888_1X24,
> + .code = MEDIA_BUS_FMT_RGB888_1X24,
> + .colorspace = V4L2_COLORSPACE_SRGB,
> + .fmt_av_bit = ALVIUM_BIT_RGB888,
> + .bay_av_bit = ALVIUM_BIT_BAY_NONE,
> + .mipi_fmt_regval = 0x24,
> + .bay_fmt_regval = -1,
> + .is_raw = 0,
> + }, {
> + /* RBG888_1X24 */
> + .id = ALVIUM_FMT_RBG888_1X24,
> + .code = MEDIA_BUS_FMT_RBG888_1X24,
> + .colorspace = V4L2_COLORSPACE_SRGB,
> + .fmt_av_bit = ALVIUM_BIT_RGB888,
> + .bay_av_bit = ALVIUM_BIT_BAY_NONE,
> + .mipi_fmt_regval = 0x24,
> + .bay_fmt_regval = -1,
> + .is_raw = 0,
> + }, {
> + /* BGR888_1X24 */
> + .id = ALVIUM_FMT_BGR888_1X24,
> + .code = MEDIA_BUS_FMT_BGR888_1X24,
> + .colorspace = V4L2_COLORSPACE_SRGB,
> + .fmt_av_bit = ALVIUM_BIT_RGB888,
> + .bay_av_bit = ALVIUM_BIT_BAY_NONE,
> + .mipi_fmt_regval = 0x24,
> + .bay_fmt_regval = -1,
> + .is_raw = 0,
> + }, {
> + /* RGB888_3X8 */
> + .id = ALVIUM_FMT_RGB888_3X8,
> + .code = MEDIA_BUS_FMT_RGB888_3X8,
> + .colorspace = V4L2_COLORSPACE_SRGB,
> + .fmt_av_bit = ALVIUM_BIT_RGB888,
> + .bay_av_bit = ALVIUM_BIT_BAY_NONE,
> + .mipi_fmt_regval = 0x24,
> + .bay_fmt_regval = -1,
> + .is_raw = 0,
> + }, {
> + /* Y8_1X8 */
> + .id = ALVIUM_FMT_Y8_1X8,
> + .code = MEDIA_BUS_FMT_Y8_1X8,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW8,
> + .bay_av_bit = ALVIUM_BIT_BAY_MONO,
> + .mipi_fmt_regval = 0x2A,
> + .bay_fmt_regval = 0x00,
> + .is_raw = 1,
> + }, {
> + /* SGRBG8_1X8 */
> + .id = ALVIUM_FMT_SGRBG8_1X8,
> + .code = MEDIA_BUS_FMT_SGRBG8_1X8,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW8,
> + .bay_av_bit = ALVIUM_BIT_BAY_GR,
> + .mipi_fmt_regval = 0x2A,
> + .bay_fmt_regval = 0x01,
> + .is_raw = 1,
> + }, {
> + /* SRGGB8_1X8 */
> + .id = ALVIUM_FMT_SRGGB8_1X8,
> + .code = MEDIA_BUS_FMT_SRGGB8_1X8,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW8,
> + .bay_av_bit = ALVIUM_BIT_BAY_RG,
> + .mipi_fmt_regval = 0x2A,
> + .bay_fmt_regval = 0x02,
> + .is_raw = 1,
> + }, {
> + /* SGBRG8_1X8 */
> + .id = ALVIUM_FMT_SGBRG8_1X8,
> + .code = MEDIA_BUS_FMT_SGBRG8_1X8,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW8,
> + .bay_av_bit = ALVIUM_BIT_BAY_GB,
> + .mipi_fmt_regval = 0x2A,
> + .bay_fmt_regval = 0x03,
> + .is_raw = 1,
> + }, {
> + /* SBGGR8_1X8 */
> + .id = ALVIUM_FMT_SBGGR8_1X8,
> + .code = MEDIA_BUS_FMT_SBGGR8_1X8,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW8,
> + .bay_av_bit = ALVIUM_BIT_BAY_BG,
> + .mipi_fmt_regval = 0x2A,
> + .bay_fmt_regval = 0x04,
> + .is_raw = 1,
> + }, {
> + /* Y10_1X10 */
> + .id = ALVIUM_FMT_Y10_1X10,
> + .code = MEDIA_BUS_FMT_Y10_1X10,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW10,
> + .bay_av_bit = ALVIUM_BIT_BAY_MONO,
> + .mipi_fmt_regval = 0x2B,
> + .bay_fmt_regval = 0x00,
> + .is_raw = 1,
> + }, {
> + /* SGRBG10_1X10 */
> + .id = ALVIUM_FMT_SGRBG10_1X10,
> + .code = MEDIA_BUS_FMT_SGRBG10_1X10,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW10,
> + .bay_av_bit = ALVIUM_BIT_BAY_GR,
> + .mipi_fmt_regval = 0x2B,
> + .bay_fmt_regval = 0x01,
> + .is_raw = 1,
> + }, {
> + /* SRGGB10_1X10 */
> + .id = ALVIUM_FMT_SRGGB10_1X10,
> + .code = MEDIA_BUS_FMT_SRGGB10_1X10,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW10,
> + .bay_av_bit = ALVIUM_BIT_BAY_RG,
> + .mipi_fmt_regval = 0x2B,
> + .bay_fmt_regval = 0x02,
> + .is_raw = 1,
> + }, {
> + /* SGBRG10_1X10 */
> + .id = ALVIUM_FMT_SGBRG10_1X10,
> + .code = MEDIA_BUS_FMT_SGBRG10_1X10,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW10,
> + .bay_av_bit = ALVIUM_BIT_BAY_GB,
> + .mipi_fmt_regval = 0x2B,
> + .bay_fmt_regval = 0x03,
> + .is_raw = 1,
> + }, {
> + /* SBGGR10_1X10 */
> + .id = ALVIUM_FMT_SBGGR10_1X10,
> + .code = MEDIA_BUS_FMT_SBGGR10_1X10,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW10,
> + .bay_av_bit = ALVIUM_BIT_BAY_BG,
> + .mipi_fmt_regval = 0x2B,
> + .bay_fmt_regval = 0x04,
> + .is_raw = 1,
> + }, {
> + /* Y12_1X12 */
> + .id = ALVIUM_FMT_Y12_1X12,
> + .code = MEDIA_BUS_FMT_Y12_1X12,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW12,
> + .bay_av_bit = ALVIUM_BIT_BAY_MONO,
> + .mipi_fmt_regval = 0x2C,
> + .bay_fmt_regval = 0x00,
> + .is_raw = 1,
> + }, {
> + /* SGRBG12_1X12 */
> + .id = ALVIUM_FMT_SGRBG12_1X12,
> + .code = MEDIA_BUS_FMT_SGRBG12_1X12,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW12,
> + .bay_av_bit = ALVIUM_BIT_BAY_GR,
> + .mipi_fmt_regval = 0x2C,
> + .bay_fmt_regval = 0x01,
> + .is_raw = 1,
> + }, {
> + /* SRGGB12_1X12 */
> + .id = ALVIUM_FMT_SRGGB12_1X12,
> + .code = MEDIA_BUS_FMT_SRGGB12_1X12,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW12,
> + .bay_av_bit = ALVIUM_BIT_BAY_RG,
> + .mipi_fmt_regval = 0x2C,
> + .bay_fmt_regval = 0x02,
> + .is_raw = 1,
> + }, {
> + /* SGBRG12_1X12 */
> + .id = ALVIUM_FMT_SGBRG12_1X12,
> + .code = MEDIA_BUS_FMT_SGBRG12_1X12,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW12,
> + .bay_av_bit = ALVIUM_BIT_BAY_GB,
> + .mipi_fmt_regval = 0x2C,
> + .bay_fmt_regval = 0x03,
> + .is_raw = 1,
> + }, {
> + /* SBGGR12_1X12 */
> + .id = ALVIUM_FMT_SBGGR12_1X12,
> + .code = MEDIA_BUS_FMT_SBGGR12_1X12,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW12,
> + .bay_av_bit = ALVIUM_BIT_BAY_BG,
> + .mipi_fmt_regval = 0x2C,
> + .bay_fmt_regval = 0x04,
> + .is_raw = 1,
> + }, {
> + /* SBGGR14_1X14 */
> + .id = ALVIUM_FMT_SBGGR14_1X14,
> + .code = MEDIA_BUS_FMT_SBGGR14_1X14,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW14,
> + .bay_av_bit = ALVIUM_BIT_BAY_GR,
> + .mipi_fmt_regval = 0x2D,
> + .bay_fmt_regval = 0x01,
> + .is_raw = 1,
> + }, {
> + /* SGBRG14_1X14 */
> + .id = ALVIUM_FMT_SGBRG14_1X14,
> + .code = MEDIA_BUS_FMT_SGBRG14_1X14,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW14,
> + .bay_av_bit = ALVIUM_BIT_BAY_RG,
> + .mipi_fmt_regval = 0x2D,
> + .bay_fmt_regval = 0x02,
> + .is_raw = 1,
> + }, {
> + /* SRGGB14_1X14 */
> + .id = ALVIUM_FMT_SRGGB14_1X14,
> + .code = MEDIA_BUS_FMT_SRGGB14_1X14,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW14,
> + .bay_av_bit = ALVIUM_BIT_BAY_GB,
> + .mipi_fmt_regval = 0x2D,
> + .bay_fmt_regval = 0x03,
> + .is_raw = 1,
> + }, {
> + /* SGRBG14_1X14 */
> + .id = ALVIUM_FMT_SGRBG14_1X14,
> + .code = MEDIA_BUS_FMT_SGRBG14_1X14,
> + .colorspace = V4L2_COLORSPACE_RAW,
> + .fmt_av_bit = ALVIUM_BIT_RAW14,
> + .bay_av_bit = ALVIUM_BIT_BAY_BG,
> + .mipi_fmt_regval = 0x2D,
> + .bay_fmt_regval = 0x04,
> + .is_raw = 1,
> + },
> + { /* sentinel */ }
> +};
> +
> +static int alvium_read(struct alvium_dev *alvium,
> + u32 reg, u64 *val)

Fits on a single line.

> +{
> + struct i2c_client *client = alvium->i2c_client;
> + u16 addr = REG_BCRM_ADDR(reg);
> + unsigned int len = REG_BCRM_SIZE(reg);
> + struct i2c_msg msgs[2] = {0};
> + u8 addr_buf[2] = {0};
> + u8 data_buf[8] = {0};
> + int ret;
> +
> + if (WARN_ON(len > 8))
> + return -EINVAL;
> +
> + if (reg & REG_BCRM_V4L2)
> + addr += alvium->bcrm_addr;
> +
> + put_unaligned_be16(addr, addr_buf);
> +
> + msgs[0].addr = client->addr;
> + msgs[0].flags = 0;
> + msgs[0].len = ARRAY_SIZE(addr_buf);
> + msgs[0].buf = addr_buf;
> +
> + msgs[1].addr = client->addr;
> + msgs[1].flags = I2C_M_RD;
> + msgs[1].len = len;
> + msgs[1].buf = &data_buf[8 - len];
> +
> + ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
> + if (ret != ARRAY_SIZE(msgs))
> + return -EIO;
> +
> + *val = get_unaligned_be64(data_buf);

Could you use CCI wrapper Hans has been working on? It'll be merged fairly
soon I presume:
<URL:https://lore.kernel.org/linux-media/20230606165808.70751-1-hdegoede@xxxxxxxxxx/T/#t>.

> +
> + return 0;
> +}
> +
> +static int alvium_write(struct alvium_dev *alvium,
> + u32 reg, u64 val)
> +{
> + struct i2c_client *client = alvium->i2c_client;
> + u16 addr = REG_BCRM_ADDR(reg);
> + unsigned int len = REG_BCRM_SIZE(reg);
> + u8 buf[10] = {0};
> +
> + if (WARN_ON(len > 8))
> + return -EINVAL;
> +
> + if (reg & REG_BCRM_V4L2)
> + addr += alvium->bcrm_addr;
> +
> + put_unaligned_be16(addr, buf);
> + put_unaligned_be64(val << (8 * (8 - len)), buf + 2);
> + if (i2c_master_send(client, buf, len + 2) != len + 2)
> + return -EIO;

Same here.

> +
> + return 0;
> +}
> +
> +static int alvium_write_hshake(struct alvium_dev *alvium,
> + u32 reg, u64 val)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + u64 hshake_regval;
> + u8 hshake_bit;
> + int ret;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + /* reset handshake bit */
> + ret = alvium_write(alvium,
> + REG_BCRM_WRITE_HANDSHAKE_RW,
> + BCRM_HANDSHAKE_W_RST);
> + if (ret) {
> + dev_err(dev, "Fail to reset hshake reg\n");
> + return ret;
> + }
> +
> + /* write alvium reg*/
> + ret = alvium_write(alvium, reg, val);
> + if (ret) {
> + dev_err(dev, "Fail to write reg\n");
> + return ret;
> + }
> +
> + /* poll handshake bit since bit0 = 1*/
> + do {
> + ret = alvium_read(alvium,
> + REG_BCRM_WRITE_HANDSHAKE_RW,
> + &hshake_regval);
> + if (ret) {
> + dev_err(dev, "Fail to read hshake reg\n");
> + return ret;
> + }
> +
> + hshake_bit = (hshake_regval & BCRM_HANDSHAKE_W_DONE_EN_BIT);
> +
> + } while (!hshake_bit);
> +
> + /* reset handshake bit, write 0 to bit0 */
> + ret = alvium_write(alvium,
> + REG_BCRM_WRITE_HANDSHAKE_RW,
> + BCRM_HANDSHAKE_W_RST);
> + if (ret) {
> + dev_err(dev, "Fail to reset hshake reg\n");
> + return ret;
> + }
> +
> + /* poll handshake bit since bit0 = 0 */
> + do {
> + ret = alvium_read(alvium,
> + REG_BCRM_WRITE_HANDSHAKE_RW,
> + &hshake_regval);
> + if (ret) {
> + dev_err(dev, "Fail to read hshake reg\n");
> + return ret;
> + }
> +
> + hshake_bit = (hshake_regval & BCRM_HANDSHAKE_W_DONE_EN_BIT);
> +
> + } while (hshake_bit);
> +
> + return 0;
> +}
> +
> +static int alvium_get_bcrm_vers(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> + struct alvium_bcrm_vers *v;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_VERSION_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read bcrm version reg\n");
> + return ret;
> + }
> +
> + v = (struct alvium_bcrm_vers *) &val;
> +
> + v->minor = cpu_to_le16(v->minor);
> + v->major = cpu_to_le16(v->major);
> +
> + dev_info(dev, "bcrm version: %u.%u\n", v->minor,
> + v->major);
> +
> + return 0;
> +}
> +
> +static int alvium_get_fw_version(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> + struct alvium_fw_vers *fw_v;

Please order temporary, loop etc. variables as last. Same for the other
functions. Reverse Christmas tree order is often the same.

> +
> + ret = alvium_read(alvium,
> + REG_BCRM_DEVICE_FIRMWARE_VERSION_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read fw version reg\n");
> + return ret;
> + }
> +
> + fw_v = (struct alvium_fw_vers *) &val;
> +
> + fw_v->minor = cpu_to_le16(fw_v->minor);
> + fw_v->patch = cpu_to_le32(fw_v->patch);
> +
> + dev_info(dev, "fw version: %u.%u.%u.%u\n",
> + fw_v->special,

Please align arguments to just right of the opening parenthesis. Also, more
fits on the same line (up to 80 chars). This applies to the entire patch.

> + fw_v->major,
> + fw_v->minor,
> + fw_v->patch);
> +
> + return 0;
> +}
> +
> +static int alvium_get_bcrm_addr(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_REG_ADDR_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read bcrm addr reg\n");
> + return ret;
> + }
> +
> + alvium->bcrm_addr = (u16)val;
> + dev_dbg(dev, "bcrm addr: %d\n", alvium->bcrm_addr);
> +
> + return 0;
> +}
> +
> +static bool alvium_is_alive(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val = 0;
> + u8 hbeat_val = 0;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_VERSION_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read bcrm version reg\n");
> + return ret;
> + }
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_HEARTBEAT_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read heartbeat reg\n");
> + return false;
> + }
> +
> + hbeat_val = (u8)val;
> + dev_dbg(dev, "hearthbeat = %d", hbeat_val);
> +
> + if (hbeat_val)
> + return true;
> + else
> + return false;

return hbeat_val;

> +}
> +
> +static void alvium_print_avail_mipi_fmt(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> +
> + dev_dbg(dev, "avail mipi_fmt yuv420_8_leg: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_YUV420_8_LEG]);
> + dev_dbg(dev, "avail mipi_fmt yuv420_8: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_YUV420_8]);
> + dev_dbg(dev, "avail mipi_fmt yuv420_10: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_YUV420_10]);
> + dev_dbg(dev, "avail mipi_fmt yuv420_8_csps: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_YUV420_8_CSPS]);
> + dev_dbg(dev, "avail mipi_fmt yuv420_10_csps: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_YUV420_10_CSPS]);
> + dev_dbg(dev, "avail mipi_fmt yuv422_8: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_YUV422_8]);
> + dev_dbg(dev, "avail mipi_fmt yuv422_10: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_YUV422_10]);
> + dev_dbg(dev, "avail mipi_fmt rgb888: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RGB888]);
> + dev_dbg(dev, "avail mipi_fmt rgb666: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RGB666]);
> + dev_dbg(dev, "avail mipi_fmt rgb565: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RGB565]);
> + dev_dbg(dev, "avail mipi_fmt rgb555: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RGB555]);
> + dev_dbg(dev, "avail mipi_fmt rgb444: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RGB444]);
> + dev_dbg(dev, "avail mipi_fmt raw6: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RAW6]);
> + dev_dbg(dev, "avail mipi_fmt raw7: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RAW7]);
> + dev_dbg(dev, "avail mipi_fmt raw8: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RAW8]);
> + dev_dbg(dev, "avail mipi_fmt raw10: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RAW10]);
> + dev_dbg(dev, "avail mipi_fmt raw12: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RAW12]);
> + dev_dbg(dev, "avail mipi_fmt raw14: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RAW14]);
> + dev_dbg(dev, "avail mipi_fmt jpeg: %u\n",
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_JPEG]);
> +}
> +
> +static void alvium_print_avail_feat(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> +
> + dev_dbg(dev, "feature rev_x: %u\n",
> + alvium->avail_ft.rev_x);
> + dev_dbg(dev, "feature rev_y: %u\n",
> + alvium->avail_ft.rev_y);
> + dev_dbg(dev, "feature int_autop: %u\n",
> + alvium->avail_ft.int_autop);
> + dev_dbg(dev, "feature black_lvl: %u\n",
> + alvium->avail_ft.black_lvl);
> + dev_dbg(dev, "feature gain: %u\n",
> + alvium->avail_ft.gain);
> + dev_dbg(dev, "feature gamma: %u\n",
> + alvium->avail_ft.gamma);
> + dev_dbg(dev, "feature contrast: %u\n",
> + alvium->avail_ft.contrast);
> + dev_dbg(dev, "feature sat: %u\n",
> + alvium->avail_ft.sat);
> + dev_dbg(dev, "feature hue: %u\n",
> + alvium->avail_ft.hue);
> + dev_dbg(dev, "feature whiteb: %u\n",
> + alvium->avail_ft.whiteb);
> + dev_dbg(dev, "feature sharp: %u\n",
> + alvium->avail_ft.sharp);
> + dev_dbg(dev, "feature auto_exp: %u\n",
> + alvium->avail_ft.auto_exp);
> + dev_dbg(dev, "feature auto_gain: %u\n",
> + alvium->avail_ft.auto_gain);
> + dev_dbg(dev, "feature auto_whiteb: %u\n",
> + alvium->avail_ft.auto_whiteb);
> + dev_dbg(dev, "feature dev_temp: %u\n",
> + alvium->avail_ft.dev_temp);
> + dev_dbg(dev, "feature acq_abort: %u\n",
> + alvium->avail_ft.acq_abort);
> + dev_dbg(dev, "feature acq_fr: %u\n",
> + alvium->avail_ft.acq_fr);
> + dev_dbg(dev, "feature fr_trigger: %u\n",
> + alvium->avail_ft.fr_trigger);
> + dev_dbg(dev, "feature exp_acq_line: %u\n",
> + alvium->avail_ft.exp_acq_line);
> +}
> +
> +static void alvium_print_avail_bayer(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> +
> + dev_dbg(dev, "avail bayer mono: %u\n",
> + alvium->is_bay_avail[ALVIUM_BIT_BAY_MONO]);
> + dev_dbg(dev, "avail bayer gr: %u\n",
> + alvium->is_bay_avail[ALVIUM_BIT_BAY_GR]);
> + dev_dbg(dev, "avail bayer rg: %u\n",
> + alvium->is_bay_avail[ALVIUM_BIT_BAY_RG]);
> + dev_dbg(dev, "avail bayer gb: %u\n",
> + alvium->is_bay_avail[ALVIUM_BIT_BAY_GB]);
> + dev_dbg(dev, "avail bayer bg: %u\n",
> + alvium->is_bay_avail[ALVIUM_BIT_BAY_BG]);
> +}
> +
> +static int alvium_get_feat_inq(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + struct alvium_avail_feat *f;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_FEATURE_INQUIRY_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to features inquiry reg\n");
> + return ret;
> + }
> +
> + f = (struct alvium_avail_feat *) &val;
> +
> + alvium->avail_ft.rev_x = f->rev_x;
> + alvium->avail_ft.rev_y = f->rev_y;
> + alvium->avail_ft.int_autop = f->int_autop;
> + alvium->avail_ft.black_lvl = f->black_lvl;
> + alvium->avail_ft.gain = f->gain;
> + alvium->avail_ft.gamma = f->gamma;
> + alvium->avail_ft.contrast = f->contrast;
> + alvium->avail_ft.sat = f->sat;
> + alvium->avail_ft.hue = f->rev_y;
> + alvium->avail_ft.whiteb = f->whiteb;
> + alvium->avail_ft.sharp = f->sharp;
> + alvium->avail_ft.auto_exp = f->auto_exp;
> + alvium->avail_ft.auto_gain = f->auto_gain;
> + alvium->avail_ft.auto_whiteb = f->auto_whiteb;
> + alvium->avail_ft.dev_temp = f->dev_temp;
> + alvium->avail_ft.acq_abort = f->acq_abort;
> + alvium->avail_ft.acq_fr = f->acq_fr;
> + alvium->avail_ft.fr_trigger = f->fr_trigger;
> + alvium->avail_ft.exp_acq_line = f->exp_acq_line;

You could instead do:

alvium->avail_ft = *f;

But is there an endianness issue here? I think you should use u64 also for
the struct fields.

> +
> + alvium_print_avail_feat(alvium);
> +
> + return 0;
> +}
> +
> +static int alvium_get_host_supp_csi_lanes(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_CSI2_LANE_COUNT_RW,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read host supported csi2 lanes reg\n");
> + return ret;
> + }
> +
> + alvium->h_sup_csi_lanes = (u8)val;
> + dev_dbg(dev, "host supported csi2 lanes count: %d\n",
> + alvium->h_sup_csi_lanes);
> +
> + return 0;
> +}
> +
> +static int alvium_set_csi_lanes(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 num_lanes;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + num_lanes = alvium->ep.bus.mipi_csi2.num_data_lanes;
> +
> + if (num_lanes <= alvium->h_sup_csi_lanes) {
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_CSI2_LANE_COUNT_RW,
> + num_lanes);
> + if (ret) {
> + dev_err(dev, "Fail to set csi lanes reg\n");
> + return ret;
> + }
> + } else {
> + return -EINVAL;
> + }
> +
> + dev_dbg(dev, "Set n lanes = %llu", num_lanes);
> +
> + return 0;
> +}
> +
> +static int alvium_set_lp2hs_delay(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 lp2hs_delay;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + /*
> + * The purpose of this reg is force a DPhy reset
> + * for the period described by the microseconds 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.
> + *
> + * This may help a csi2 rx ip to reset if that IP
> + * can't deal with a continous clock.
> + */
> + lp2hs_delay = (u64)alvium->lp2hs_delay;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_STREAM_ON_DELAY_RW,
> + lp2hs_delay);
> + if (ret) {
> + dev_err(dev, "Fail to set streamon delay reg\n");
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int alvium_get_csi_clk_params(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_CSI2_CLOCK_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read host supported csi2 lanes reg\n");
> + return ret;
> + }
> +
> + alvium->min_csi_clk = (u32)val;
> + dev_dbg(dev, "Min host supported csi clock: %d\n",
> + alvium->min_csi_clk);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_CSI2_CLOCK_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read host supported csi2 lanes reg\n");
> + return ret;
> + }
> +
> + alvium->max_csi_clk = (u32)val;
> + dev_dbg(dev, "Max host supported csi clock: %d\n",
> + alvium->max_csi_clk);
> +
> + return 0;
> +}
> +
> +static int alvium_set_csi_clk(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 csi_clk;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + csi_clk = (u32)alvium->ep.link_frequencies[0];
> +
> + if (csi_clk > alvium->min_csi_clk ||
> + csi_clk < alvium->max_csi_clk) {
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_CSI2_CLOCK_RW,
> + csi_clk);
> + if (ret) {
> + dev_err(dev, "Fail to set csi lanes reg\n");
> + return ret;
> + }
> + } else {
> + return -EINVAL;
> + }
> +
> + alvium->link_freq = alvium->ep.link_frequencies[0];
> +
> + return 0;
> +}
> +
> +static int alvium_get_img_width_params(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_IMG_WIDTH_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read img min width reg\n");
> + return ret;
> + }

Could you add a macro that assigns the value to the variable (or a struct
field in this case) when the read is successful? Add the print if you think
you need it.

> +
> + alvium->img_min_width = (u32)val;
> + dev_dbg(dev, "Min img width: %d\n",
> + alvium->img_min_width);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_IMG_WIDTH_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read img max width reg\n");
> + return ret;
> + }
> +
> + alvium->img_max_width = (u32)val;
> + dev_dbg(dev, "Max img width: %d\n",
> + alvium->img_max_width);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_IMG_WIDTH_INC_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read img inc width reg\n");
> + return ret;
> + }
> +
> + alvium->img_inc_width = (u32)val;
> + dev_dbg(dev, "img width increment: %d px\n",
> + alvium->img_inc_width);
> +
> + return 0;
> +}
> +
> +static int alvium_get_img_height_params(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_IMG_HEIGHT_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read img min height reg\n");
> + return ret;
> + }
> +
> + alvium->img_min_height = (u32)val;
> + dev_dbg(dev, "Min img height: %d\n",
> + alvium->img_min_height);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_IMG_HEIGHT_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read img max height reg\n");
> + return ret;
> + }
> +
> + alvium->img_max_height = (u32)val;
> + dev_dbg(dev, "Max img height: %d\n",
> + alvium->img_max_height);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_IMG_HEIGHT_INC_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read img inc height reg\n");
> + return ret;
> + }
> +
> + alvium->img_inc_height = (u32)val;
> + dev_dbg(dev, "img height increment: %d\n",
> + alvium->img_inc_height);
> +
> + return 0;
> +}
> +
> +static int alvium_set_img_width(struct alvium_dev *alvium, u32 width)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_IMG_WIDTH_RW,
> + width);
> + if (ret) {
> + dev_err(dev, "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;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_IMG_HEIGHT_RW,
> + height);
> + if (ret) {
> + dev_err(dev, "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;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_IMG_OFFSET_X_RW,
> + offx);
> + if (ret) {
> + dev_err(dev, "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;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_IMG_OFFSET_Y_RW,
> + offy);
> + if (ret) {
> + dev_err(dev, "Fail to set img offy\n");
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int alvium_get_offx_params(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_IMG_OFFSET_X_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read min offx reg\n");
> + return ret;
> + }
> +
> + alvium->min_offx = (u32)val;
> + dev_dbg(dev, "Min img offx: %d\n",
> + alvium->min_offx);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_IMG_OFFSET_X_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read max offx reg\n");
> + return ret;
> + }
> +
> + alvium->max_offx = (u32)val;
> + dev_dbg(dev, "Max img offx: %d\n",
> + alvium->max_offx);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_IMG_OFFSET_X_INC_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read inc offx reg\n");
> + return ret;
> + }
> +
> + alvium->inc_offx = (u32)val;
> + dev_dbg(dev, "Inc img offx: %d\n",
> + alvium->inc_offx);
> +
> + return 0;
> +}
> +
> +static int alvium_get_offy_params(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_IMG_OFFSET_Y_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read min offy reg\n");
> + return ret;
> + }
> +
> + alvium->min_offy = (u32)val;
> + dev_dbg(dev, "Min img offy: %d\n",
> + alvium->min_offy);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_IMG_OFFSET_Y_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read max offy reg\n");
> + return ret;
> + }
> +
> + alvium->max_offy = (u32)val;
> + dev_dbg(dev, "Max img offy: %d\n",
> + alvium->max_offy);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_IMG_OFFSET_Y_INC_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read inc offy reg\n");
> + return ret;
> + }
> +
> + alvium->inc_offy = (u32)val;
> + dev_dbg(dev, "Inc img offy: %d\n",
> + alvium->inc_offy);
> +
> + return 0;
> +}
> +
> +static int alvium_get_gain_params(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_GAIN_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to min gain reg\n");
> + return ret;
> + }
> +
> + alvium->min_gain = val;
> + dev_dbg(dev, "Min gain: %llu mB\n",
> + alvium->min_gain);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_GAIN_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to max gain reg\n");
> + return ret;
> + }
> +
> + alvium->max_gain = val;
> + dev_dbg(dev, "Max gain: %llu mB\n",
> + alvium->max_gain);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_GAIN_INC_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to inc gain reg\n");
> + return ret;
> + }
> +
> + alvium->inc_gain = val;
> + dev_dbg(dev, "gain inc: %llu mB\n",
> + alvium->inc_gain);
> +
> + return 0;
> +}
> +
> +static int alvium_get_exposure_params(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_EXPOSURE_TIME_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read img min exp reg\n");
> + return ret;
> + }
> +
> + alvium->min_exp = val;
> + dev_dbg(dev, "Min exp: %llu ns\n",
> + alvium->min_exp);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_EXPOSURE_TIME_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read img max exp reg\n");
> + return ret;
> + }
> +
> + alvium->max_exp = val;
> + dev_dbg(dev, "Max exp: %llu ns\n",
> + alvium->max_exp);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_EXPOSURE_TIME_INC_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read inc exp reg\n");
> + return ret;
> + }
> +
> + alvium->inc_exp = val;
> + dev_dbg(dev, "Inc exp: %llu ns\n",
> + alvium->inc_exp);
> +
> + return 0;
> +}
> +
> +static int alvium_get_red_balance_ratio_params(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_RED_BALANCE_RATIO_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read min rbalance reg\n");
> + return ret;
> + }
> +
> + alvium->min_rbalance = val;
> + dev_dbg(dev, "Min rbalance: %llu\n",
> + alvium->min_rbalance);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_RED_BALANCE_RATIO_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read max rbalance reg\n");
> + return ret;
> + }
> +
> + alvium->max_rbalance = val;
> + dev_dbg(dev, "Max rbalance: %llu\n",
> + alvium->max_rbalance);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_RED_BALANCE_RATIO_INC_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read inc rbalance reg\n");
> + return ret;
> + }
> +
> + alvium->inc_rbalance = val;
> + dev_dbg(dev, "Inc rbalance: %llu\n",
> + alvium->inc_rbalance);
> +
> + return 0;
> +}
> +
> +static int alvium_get_blue_balance_ratio_params(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_BLUE_BALANCE_RATIO_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read min bbalance reg\n");
> + return ret;
> + }
> +
> + alvium->min_bbalance = val;
> + dev_dbg(dev, "Min bbalance: %llu\n",
> + alvium->min_bbalance);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_BLUE_BALANCE_RATIO_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read max bbalance reg\n");
> + return ret;
> + }
> +
> + alvium->max_bbalance = val;
> + dev_dbg(dev, "Max bbalance: %llu\n",
> + alvium->max_bbalance);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_BLUE_BALANCE_RATIO_INC_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read inc bbalance reg\n");
> + return ret;
> + }
> +
> + alvium->inc_bbalance = val;
> + dev_dbg(dev, "Inc bbalance: %llu\n",
> + alvium->inc_bbalance);
> +
> + return 0;
> +}
> +
> +static int alvium_get_hue_params(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_HUE_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read min hue reg\n");
> + return ret;
> + }
> +
> + alvium->min_hue = (s32)val;
> + dev_dbg(dev, "Min hue: %d\n",
> + alvium->min_hue);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_HUE_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read max hue reg\n");
> + return ret;
> + }
> +
> + alvium->max_hue = (s32)val;
> + dev_dbg(dev, "Max hue: %d\n",
> + alvium->max_hue);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_HUE_INC_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read inc hue reg\n");
> + return ret;
> + }
> +
> + alvium->inc_hue = (s32)val;
> + dev_dbg(dev, "Inc hue: %d\n",
> + alvium->inc_hue);
> +
> + return 0;
> +}
> +
> +static int alvium_get_black_lvl_params(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_BLACK_LEVEL_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read min black lvl reg\n");
> + return ret;
> + }
> +
> + alvium->min_black_lvl = (s32)val;
> + dev_dbg(dev, "Min black lvl: %d\n",
> + alvium->min_hue);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_BLACK_LEVEL_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read max black lvl reg\n");
> + return ret;
> + }
> +
> + alvium->max_black_lvl = (s32)val;
> + dev_dbg(dev, "Max black lvl: %d\n",
> + alvium->max_black_lvl);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_BLACK_LEVEL_INC_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read inc black lvl reg\n");
> + return ret;
> + }
> +
> + alvium->inc_black_lvl = (s32)val;
> + dev_dbg(dev, "Inc black lvl: %d\n",
> + alvium->inc_black_lvl);
> +
> + return 0;
> +}
> +
> +static int alvium_get_gamma_params(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_GAMMA_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read min gamma reg\n");
> + return ret;
> + }
> +
> + alvium->min_gamma = val;
> + dev_dbg(dev, "Min gamma: %llu\n",
> + alvium->min_gamma);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_GAMMA_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read max bbalance reg\n");
> + return ret;
> + }
> +
> + alvium->max_gamma = val;
> + dev_dbg(dev, "Max gamma: %llu\n",
> + alvium->max_gamma);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_GAMMA_INC_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read inc gamma reg\n");
> + return ret;
> + }
> +
> + alvium->inc_gamma = val;
> + dev_dbg(dev, "Inc gamma: %llu\n",
> + alvium->inc_gamma);
> +
> + return 0;
> +}
> +
> +static int alvium_get_sharpness_params(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_SHARPNESS_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read min sharpness lvl reg\n");
> + return ret;
> + }
> +
> + alvium->min_sharp = (s32)val;
> + dev_dbg(dev, "Min sharpness: %d\n",
> + alvium->min_sharp);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_BLACK_LEVEL_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read max sharpness reg\n");
> + return ret;
> + }
> +
> + alvium->max_sharp = (s32)val;
> + dev_dbg(dev, "Max sharpness: %d\n",
> + alvium->max_sharp);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_SHARPNESS_INC_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read inc sharpness reg\n");
> + return ret;
> + }
> +
> + alvium->inc_sharp = (s32)val;
> + dev_dbg(dev, "Inc sharpness: %d\n",
> + alvium->inc_sharp);
> +
> + return 0;
> +}
> +
> +static int alvium_get_contrast_params(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_CONTRAST_VALUE_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read min contrast reg\n");
> + return ret;
> + }
> +
> + alvium->min_contrast = (u32)val;
> + dev_dbg(dev, "Min contrast: %d\n",
> + alvium->min_contrast);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_CONTRAST_VALUE_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read max contrast reg\n");
> + return ret;
> + }
> +
> + alvium->max_contrast = (u32)val;
> + dev_dbg(dev, "Max contrast: %d\n",
> + alvium->max_contrast);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_CONTRAST_VALUE_INC_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read inc contrast reg\n");
> + return ret;
> + }
> +
> + alvium->inc_contrast = (u32)val;
> + dev_dbg(dev, "Inc contrast: %d\n",
> + alvium->inc_contrast);
> +
> + return 0;
> +}
> +
> +static int alvium_get_saturation_params(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_SATURATION_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read min saturation reg\n");
> + return ret;
> + }
> +
> + alvium->min_sat = (u32)val;
> + dev_dbg(dev, "Min saturation: %d\n",
> + alvium->min_sat);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_SATURATION_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read max saturation reg\n");
> + return ret;
> + }
> +
> + alvium->max_sat = (u32)val;
> + dev_dbg(dev, "Max saturation: %d\n",
> + alvium->max_sat);
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_SATURATION_INC_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read max saturation reg\n");
> + return ret;
> + }
> +
> + alvium->inc_sat = (u32)val;
> + dev_dbg(dev, "Inc saturation: %d\n",
> + alvium->inc_sat);
> +
> + return 0;
> +}
> +
> +static int alvium_set_bcm_mode(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> +
> + ret = alvium_write(alvium,
> + REG_GENCP_CHANGEMODE_W,
> + ALVIUM_BCM_MODE);
> + if (ret) {
> + dev_err(dev, "Fail to current mode reg\n");
> + return ret;
> + }
> +
> + alvium->bcrm_mode = ALVIUM_BCM_MODE;
> + dev_dbg(dev, "Set BCM mode");
> +
> + return 0;
> +}
> +
> +static int alvium_get_mode(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 bcrm_mode;
> +
> + ret = alvium_read(alvium,
> + REG_GENCP_CURRENTMODE_R,
> + &bcrm_mode);
> + if (ret) {
> + dev_err(dev, "Fail to read current mode reg\n");
> + return ret;
> + }
> +
> + switch (bcrm_mode) {
> + case ALVIUM_BCM_MODE:
> + alvium->bcrm_mode = ALVIUM_BCM_MODE;
> + break;
> + case ALVIUM_GENCP_MODE:
> + alvium->bcrm_mode = ALVIUM_GENCP_MODE;
> + break;
> + }
> +
> + dev_dbg(dev, "Current mode is: %d\n", alvium->bcrm_mode);
> + return 0;
> +}
> +
> +static int alvium_get_avail_mipi_data_format(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + struct alvium_avail_mipi_fmt *avail_fmt;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_IMG_AVAILABLE_MIPI_DATA_FORMATS_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "available mipi data format reg\n");
> + return ret;
> + }
> +
> + avail_fmt = (struct alvium_avail_mipi_fmt *) &val;
> +
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_YUV420_8_LEG]
> + = avail_fmt->yuv420_8_leg;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_YUV420_8]
> + = avail_fmt->yuv420_8;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_YUV420_10]
> + = avail_fmt->yuv420_10;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_YUV420_8_CSPS]
> + = avail_fmt->yuv420_8_csps;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_YUV420_10_CSPS]
> + = avail_fmt->yuv420_10_csps;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_YUV422_8]
> + = avail_fmt->yuv422_8;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_YUV422_10]
> + = avail_fmt->yuv422_10;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RGB888]
> + = avail_fmt->rgb888;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RGB666]
> + = avail_fmt->rgb666;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RGB565]
> + = avail_fmt->rgb565;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RGB555]
> + = avail_fmt->rgb555;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RGB444]
> + = avail_fmt->rgb444;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RAW6]
> + = avail_fmt->raw6;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RAW7]
> + = avail_fmt->raw7;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RAW8]
> + = avail_fmt->raw8;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RAW10]
> + = avail_fmt->raw10;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RAW12]
> + = avail_fmt->raw12;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_RAW14]
> + = avail_fmt->raw14;
> + alvium->is_mipi_fmt_avail[ALVIUM_BIT_JPEG]
> + = avail_fmt->jpeg;
> +
> + alvium_print_avail_mipi_fmt(alvium);
> +
> + return 0;
> +}
> +
> +static int alvium_setup_mipi_fmt(struct alvium_dev *alvium)
> +{
> + int avail_fmt_cnt = 0;
> + int sz = 0;
> +
> + alvium->alvium_csi2_fmt = NULL;
> +
> + /* calculate fmt array size */
> + for (int fmt = 0; fmt < ALVIUM_NUM_SUPP_MIPI_DATA_FMT; fmt++) {
> + if (alvium->is_mipi_fmt_avail[alvium_csi2_fmts[fmt].fmt_av_bit])
> + if ((!alvium_csi2_fmts[fmt].is_raw) ||
> + (alvium->is_bay_avail[alvium_csi2_fmts[fmt].bay_av_bit]))
> + sz++;
> + }
> +
> + /* init alvium_csi2_fmt array */
> + alvium->alvium_csi2_fmt_n = sz;
> + alvium->alvium_csi2_fmt = kmalloc_array(sz,
> + sizeof(struct alvium_pixfmt),
> + GFP_KERNEL);
> +
> + /* Create the alvium_csi2 fmt array from formats available */
> + for (int fmt = 0; fmt < ALVIUM_NUM_SUPP_MIPI_DATA_FMT; fmt++) {
> + if (alvium->is_mipi_fmt_avail[alvium_csi2_fmts[fmt].fmt_av_bit])
> + if ((!alvium_csi2_fmts[fmt].is_raw) ||
> + (alvium->is_bay_avail[alvium_csi2_fmts[fmt].bay_av_bit])) {
> + alvium->alvium_csi2_fmt[avail_fmt_cnt] =
> + alvium_csi2_fmts[fmt];
> + avail_fmt_cnt++;
> + }
> + }
> +
> + return 0;
> +}
> +
> +static int alvium_set_mipi_fmt(struct alvium_dev *alvium,
> + const struct alvium_pixfmt *pixfmt)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + u64 reg_val;
> + int ret;
> +
> + reg_val = pixfmt->mipi_fmt_regval;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_IMG_MIPI_DATA_FORMAT_RW,
> + reg_val);
> + if (ret) {
> + dev_err(dev, "Fail to set mipi fmt\n");
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int alvium_get_avail_bayer(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + struct alvium_avail_bayer *avail_bay;
> + int ret;
> + u64 val;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_IMG_BAYER_PATTERN_INQUIRY_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read available Bayer patterns reg\n");
> + return ret;
> + }
> +
> + avail_bay = (struct alvium_avail_bayer *) &val;
> +
> + alvium->is_bay_avail[ALVIUM_BIT_BAY_MONO] = avail_bay->mono;
> + alvium->is_bay_avail[ALVIUM_BIT_BAY_GR] = avail_bay->gr;
> + alvium->is_bay_avail[ALVIUM_BIT_BAY_RG] = avail_bay->rg;
> + alvium->is_bay_avail[ALVIUM_BIT_BAY_GB] = avail_bay->gb;
> + alvium->is_bay_avail[ALVIUM_BIT_BAY_BG] = avail_bay->bg;
> +
> + alvium_print_avail_bayer(alvium);
> +
> + return 0;
> +}
> +
> +static int alvium_set_bayer_pattern(struct alvium_dev *alvium,
> + const struct alvium_pixfmt *pixfmt)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + u64 reg_val;
> + int ret;
> +
> + reg_val = pixfmt->bay_fmt_regval;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_IMG_BAYER_PATTERN_RW,
> + reg_val);
> + if (ret) {
> + dev_err(dev, "Fail to set bayer pattern\n");
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int alvium_get_frame_interval(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 val;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_ACQUISITION_FRAME_RATE_MIN_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read min frame rate reg\n");
> + return ret;
> + }
> +
> + alvium->min_fr = val;
> +
> + ret = alvium_read(alvium,
> + REG_BCRM_ACQUISITION_FRAME_RATE_MAX_R,
> + &val);
> + if (ret) {
> + dev_err(dev, "Fail to read max frame rate reg\n");
> + return ret;
> + }
> +
> + alvium->max_fr = val;
> +
> + dev_dbg(dev, "framerate min: %llu µHz, max: %llu µHz\n",
> + alvium->min_fr, alvium->max_fr);
> + return 0;
> +}
> +
> +static int alvium_set_frame_rate(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 fr;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + fr = alvium->fr;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_ACQUISITION_FRAME_RATE_RW,
> + fr);
> + if (ret) {
> + dev_err(dev, "Fail to set frame rate lanes reg\n");
> + return ret;
> + }
> +
> + dev_dbg(dev, "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 (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + if (on) {
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_ACQUISITION_START_RW,
> + 0x01);
> + } else {
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_ACQUISITION_STOP_RW,
> + 0x01);
> + }
> +
> + if (ret) {
> + dev_err(dev, "Fail set_stream_mipi\n");
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int alvium_get_gain(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 gain;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + if (!alvium->avail_ft.auto_gain)
> + return -EINVAL;
> +
> + /* The unit is millibel (1 mB = 0.01 dB) */
> + ret = alvium_read(alvium,
> + REG_BCRM_GAIN_RW,
> + &gain);
> + if (ret) {
> + dev_err(dev, "Fail to read gain value reg\n");
> + return ret;
> + }
> +
> + return gain;
> +}
> +
> +static int alvium_set_gain(struct alvium_dev *alvium, int gain)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + if (!alvium->avail_ft.auto_gain)
> + return -EINVAL;
> +
> + /* The unit is millibel (1 mB = 0.01 dB) */
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_GAIN_RW,
> + (u64)gain);
> + if (ret) {
> + dev_err(dev, "Fail to set gain value reg\n");
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int alvium_set_autogain(struct alvium_dev *alvium, bool on)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + if (!alvium->avail_ft.auto_gain)
> + return -EINVAL;
> +
> + if (on) {
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_GAIN_AUTO_RW,
> + 0x02);
> + } else {
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_GAIN_AUTO_RW,
> + 0x00);
> + }
> +
> + if (ret) {
> + dev_err(dev, "Fail to set autogain reg\n");
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int alvium_get_exposure(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> + u64 exp;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + if (!alvium->avail_ft.auto_exp)
> + return -EINVAL;
> +
> + /* Exposure time in ns */
> + ret = alvium_read(alvium,
> + REG_BCRM_EXPOSURE_TIME_RW,
> + &exp);
> + if (ret) {
> + dev_err(dev, "Fail to read exposure value reg\n");
> + return ret;
> + }
> +
> + return exp;
> +}
> +
> +static int alvium_set_autoexposure(struct alvium_dev *alvium, bool on)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + if (!alvium->avail_ft.auto_exp)
> + return -EINVAL;
> +
> + if (on) {
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_EXPOSURE_AUTO_RW,
> + 0x02);
> + } else {
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_EXPOSURE_AUTO_RW,
> + 0x00);
> + }
> +
> + if (ret) {
> + dev_err(dev, "Fail to set autoexposure reg\n");
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int alvium_set_exposure(struct alvium_dev *alvium, int exposure_ns)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_EXPOSURE_TIME_RW,
> + (u64)exposure_ns);
> + if (ret) {
> + dev_err(dev, "Fail to set exposure value reg\n");
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int alvium_set_ctrl_gain(struct alvium_dev *alvium, bool auto_gain)
> +{
> + struct alvium_ctrls *ctrls = &alvium->ctrls;
> + int ret = 0;
> +
> + if (ctrls->auto_gain->is_new) {
> + ret = alvium_set_autogain(alvium, auto_gain);
> + if (ret)
> + return ret;
> + }
> +
> + if (!auto_gain && ctrls->gain->is_new) {
> + u64 max_gain;
> + u64 min_gain;
> +
> + ret = alvium_get_gain_params(alvium);
> + if (ret)
> + return ret;
> +
> + max_gain = alvium->max_gain;
> + min_gain = alvium->min_gain;
> +
> + if (ctrls->gain->val >= min_gain &&
> + ctrls->gain->val <= max_gain) {
> + ret = alvium_set_gain(alvium, ctrls->gain->val);
> + } else {
> + return -EINVAL;
> + }
> + }
> +
> + return ret;
> +}
> +
> +static int alvium_set_blue_balance_ratio(struct alvium_dev *alvium,
> + int blue)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_BLUE_BALANCE_RATIO_RW,
> + (u64)blue);
> + if (ret) {
> + dev_err(dev, "Fail to set blue ratio value reg\n");
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int alvium_set_red_balance_ratio(struct alvium_dev *alvium,
> + int red)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_RED_BALANCE_RATIO_RW,
> + (u64)red);
> + if (ret) {
> + dev_err(dev, "Fail to set red ratio value reg\n");
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int alvium_set_awb(struct alvium_dev *alvium, bool on)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + if (!alvium->avail_ft.auto_whiteb)
> + return -EINVAL;
> +
> + if (on) {
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_WHITE_BALANCE_AUTO_RW,
> + 0x02);
> + } else {
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_WHITE_BALANCE_AUTO_RW,
> + 0x00);
> + }
> +
> + if (ret) {
> + dev_err(dev, "Fail to set awb reg\n");
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int alvium_set_ctrl_exposure(struct alvium_dev *alvium,
> + enum v4l2_exposure_auto_type auto_exposure)
> +{
> + struct alvium_ctrls *ctrls = &alvium->ctrls;
> + bool auto_exp = (auto_exposure == V4L2_EXPOSURE_AUTO);
> + int ret = 0;
> +
> + if (ctrls->auto_exp->is_new) {
> + ret = alvium_set_autoexposure(alvium, auto_exp);
> + if (ret)
> + return ret;
> + }
> +
> + if (!auto_exp && ctrls->exposure->is_new) {
> + u64 max_exp;
> + u64 min_exp;
> +
> + ret = alvium_get_exposure_params(alvium);
> + if (ret)
> + return ret;
> +
> + max_exp = alvium->max_exp;
> + min_exp = alvium->min_exp;
> +
> + if (ctrls->exposure->val >= min_exp &&
> + ctrls->exposure->val <= max_exp) {
> + ret = alvium_set_exposure(alvium, ctrls->exposure->val);
> + if (ret)
> + return ret;
> + } else {
> + return -EINVAL;
> + }
> + }
> +
> + return ret;
> +}
> +
> +static int alvium_set_ctrl_white_balance(struct alvium_dev *alvium,
> + bool awb)
> +{
> + struct alvium_ctrls *ctrls = &alvium->ctrls;
> + int ret = 0;
> +
> + if (ctrls->auto_wb->is_new) {
> + ret = alvium_set_awb(alvium, awb);
> + if (ret)
> + return ret;
> + }
> +
> + if (!awb && ctrls->auto_wb->is_new) {
> + u64 red = (u64)ctrls->red_balance->val;
> + u64 blue = (u64)ctrls->blue_balance->val;
> + u64 red_max;
> + u64 red_min;
> + u64 blue_max;
> + u64 blue_min;
> +
> + ret = alvium_get_red_balance_ratio_params(alvium);
> + if (ret)
> + return ret;
> +
> + ret = alvium_get_blue_balance_ratio_params(alvium);
> + if (ret)
> + return ret;
> +
> + red_max = alvium->max_rbalance;
> + red_min = alvium->min_rbalance;
> + blue_max = alvium->max_bbalance;
> + blue_min = alvium->min_rbalance;
> +
> + if (red >= red_min &&
> + red <= red_max) {
> + ret = alvium_set_red_balance_ratio(alvium, red);
> + if (ret)
> + return ret;
> + } else {
> + return -EINVAL;
> + }
> +
> + if (blue >= blue_min &&
> + blue <= blue_max) {
> + ret = alvium_set_blue_balance_ratio(alvium, blue);
> + if (ret)
> + return ret;
> + } else {
> + return -EINVAL;
> + }
> + }
> +
> + return ret;
> +}
> +
> +static int alvium_set_ctrl_hue(struct alvium_dev *alvium, int val)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret;
> +
> + if (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_HUE_RW,
> + (u64)val);
> + if (ret) {
> + dev_err(dev, "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 (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_CONTRAST_VALUE_RW,
> + (u64)val);
> + if (ret) {
> + dev_err(dev, "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 (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_SATURATION_RW,
> + (u64)val);
> + if (ret) {
> + dev_err(dev, "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 (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_GAMMA_RW,
> + (u64)val);
> + if (ret) {
> + dev_err(dev, "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 (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_SHARPNESS_RW,
> + (u64)val);
> + if (ret) {
> + dev_err(dev, "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 (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_IMG_REVERSE_X_RW,
> + (u64)val);
> + if (ret) {
> + dev_err(dev, "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 (!alvium->bcrm_addr)
> + return -EINVAL;
> +
> + ret = alvium_write_hshake(alvium,
> + REG_BCRM_IMG_REVERSE_Y_RW,
> + (u64)val);
> + if (ret) {
> + dev_err(dev, "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;
> +
> + ret = alvium_get_csi_clk_params(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read min/max csi clock regs\n");
> + return ret;
> + }
> +
> + ret = alvium_get_img_width_params(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read img width regs\n");
> + return ret;
> + }
> +
> + ret = alvium_get_img_height_params(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read img heigth regs\n");
> + return ret;
> + }
> +
> + ret = alvium_get_offx_params(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read offx regs\n");
> + return ret;
> + }
> +
> + ret = alvium_get_offy_params(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read offy regs\n");
> + return ret;
> + }
> +
> + ret = alvium_get_gain_params(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read gain regs\n");
> + return ret;
> + }
> +
> + ret = alvium_get_exposure_params(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read min/max exp regs\n");
> + return ret;
> + }
> +
> + ret = alvium_get_red_balance_ratio_params(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read red balance ratio regs\n");
> + return ret;
> + }
> +
> + ret = alvium_get_blue_balance_ratio_params(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read blue balance ratio regs\n");
> + return ret;
> + }
> +
> + ret = alvium_get_hue_params(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read hue regs\n");
> + return ret;
> + }
> +
> + ret = alvium_get_contrast_params(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read contrast regs\n");
> + return ret;
> + }
> +
> + ret = alvium_get_saturation_params(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read saturation regs\n");
> + return ret;
> + }
> +
> + ret = alvium_get_black_lvl_params(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read black lvl regs\n");
> + return ret;
> + }
> +
> + ret = alvium_get_gamma_params(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read gamma regs\n");
> + return ret;
> + }
> +
> + ret = alvium_get_sharpness_params(alvium);
> + if (ret) {
> + dev_err(dev, "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;
> +
> + ret = alvium_get_bcrm_vers(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read bcrm version reg\n");
> + return ret;
> + }
> +
> + ret = alvium_get_bcrm_addr(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to bcrm address reg\n");
> + return ret;
> + }
> +
> + ret = alvium_get_fw_version(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read fw version reg\n");
> + return ret;
> + }
> +
> + ret = alvium_get_host_supp_csi_lanes(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read host supported csi lanes reg\n");
> + return ret;
> + }
> +
> + ret = alvium_get_feat_inq(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read bcrm feature inquiry reg\n");
> + return ret;
> + }
> +
> + ret = alvium_get_hw_features_params(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read features params regs\n");
> + return ret;
> + }
> +
> + ret = alvium_get_avail_mipi_data_format(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read available mipi data formats reg\n");
> + return ret;
> + }
> +
> + ret = alvium_get_avail_bayer(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to read available Bayer patterns reg\n");
> + return ret;
> + }
> +
> + ret = alvium_get_mode(alvium);
> + if (ret) {
> + dev_err(dev, "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*/
> + ret = alvium_set_bcm_mode(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to set BCM mode\n");
> + return ret;
> + }
> +
> + ret = alvium_set_csi_lanes(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to set csi lanes\n");
> + return ret;
> + }
> +
> + ret = alvium_set_csi_clk(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to set csi lanes\n");
> + return ret;
> + }
> +
> + ret = alvium_set_lp2hs_delay(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to set streamon reg\n");
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +/* --------------- Subdev Operations --------------- */
> +
> +static int alvium_g_frame_interval(struct v4l2_subdev *sd,
> + struct v4l2_subdev_frame_interval *fi)
> +{
> + struct alvium_dev *alvium = sd_to_alvium(sd);
> +
> + fi->interval = alvium->frame_interval;
> +
> + return 0;
> +}
> +
> +static int alvium_set_frame_interval(struct alvium_dev *alvium,
> + struct v4l2_subdev_frame_interval *fi)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + u64 req_fr, min_fr, max_fr;
> + int ret;
> +
> + if (fi->interval.denominator == 0)
> + return -EINVAL;
> +
> + ret = alvium_get_frame_interval(alvium);
> + if (ret) {
> + dev_err(dev, "Fail to get frame interval\n");
> + return ret;
> + }
> +
> + min_fr = alvium->min_fr;
> + max_fr = alvium->max_fr;
> +
> + dev_dbg(dev, "fi->interval.numerator = %d\n",
> + fi->interval.numerator);
> + dev_dbg(dev, "fi->interval.denominator = %d\n",
> + fi->interval.denominator);
> +
> + req_fr = (fi->interval.denominator * USEC_PER_SEC) /
> + fi->interval.numerator;
> +
> + if (req_fr >= max_fr &&
> + req_fr <= min_fr)
> + return -EINVAL;
> +
> + alvium->fr = req_fr;
> + alvium->frame_interval.numerator = fi->interval.numerator;
> + alvium->frame_interval.denominator = fi->interval.denominator;
> +
> + return 0;
> +}
> +
> +static int alvium_s_frame_interval(struct v4l2_subdev *sd,
> + struct v4l2_subdev_frame_interval *fi)
> +{
> + struct alvium_dev *alvium = sd_to_alvium(sd);
> + int ret;
> +
> + if (fi->pad != 0)
> + return -EINVAL;

The caller will have checked for this already.

> +
> + if (alvium->streaming)
> + return -EBUSY;
> +
> + ret = alvium_set_frame_interval(alvium, fi);
> + if (!ret) {
> + ret = alvium_set_frame_rate(alvium);
> + if (ret)
> + return -EIO;
> + }
> +
> + return ret;
> +}
> +
> +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);
> + const struct alvium_pixfmt *formats;
> + unsigned int num_formats;
> +
> + formats = alvium->alvium_csi2_fmt;
> + num_formats = alvium->alvium_csi2_fmt_n;
> +
> + if (code->index >= num_formats)
> + return -EINVAL;
> +
> + code->code = formats[code->index].code;
> +
> + return 0;
> +}
> +
> +static const struct alvium_pixfmt *
> +alvium_code_to_pixfmt(struct alvium_dev *alvium, u32 code)
> +{
> + const struct alvium_pixfmt *formats = alvium->alvium_csi2_fmt;
> + unsigned int i;
> +
> + for (i = 0; formats[i].code; ++i) {
> + if (formats[i].code == code)
> + return &formats[i];
> + }

No need for braces here.

> +
> + return &formats[0];
> +}
> +
> +static int alvium_set_mode(struct alvium_dev *alvium,
> + struct v4l2_subdev_state *state)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + struct v4l2_subdev *sd = &alvium->sd;
> + struct v4l2_mbus_framefmt *fmt;
> + struct v4l2_rect *crop;
> + int ret;
> +
> + crop = v4l2_subdev_get_pad_crop(sd, state, 0);
> + fmt = v4l2_subdev_get_pad_format(sd, state, 0);
> +
> + if (fmt->width < alvium->img_max_width &&
> + fmt->width > alvium->img_min_width) {
> + ret = alvium_set_img_width(alvium, fmt->width);
> + if (ret)
> + return ret;
> + } else {
> + dev_err(dev, "Unsupported width");
> + return -EINVAL;
> + }
> +
> + if (fmt->height < alvium->img_max_height &&
> + fmt->height > alvium->img_min_height) {
> + ret = alvium_set_img_height(alvium, fmt->height);
> + if (ret)
> + return ret;
> + } else {
> + dev_err(dev, "Unsupported height");
> + return -EINVAL;
> + }
> +
> + ret = alvium_set_img_offx(alvium, crop->left);
> + if (ret)
> + return ret;
> +
> + ret = alvium_set_img_offy(alvium, crop->top);
> + 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;
> +
> + alvium_csi2_fmt = alvium_code_to_pixfmt(alvium, format->code);
> +
> + ret = alvium_set_mipi_fmt(alvium, alvium_csi2_fmt);
> + if (ret)
> + return ret;
> +
> + if (alvium_csi2_fmt->is_raw) {
> + ret = alvium_set_bayer_pattern(alvium, alvium_csi2_fmt);
> + if (ret)
> + return ret;
> + }
> +
> + dev_dbg(dev, "start: %s, mipi_fmt_regval regval = 0x%llx",
> + __func__, alvium_csi2_fmt->mipi_fmt_regval);
> +
> + return ret;
> +}
> +
> +static int alvium_s_stream(struct v4l2_subdev *sd, int enable)
> +{
> + struct alvium_dev *alvium = sd_to_alvium(sd);
> + struct v4l2_mbus_framefmt *fmt;
> + struct v4l2_subdev_state *state;
> + int ret = 0;
> +
> + state = v4l2_subdev_lock_and_get_active_state(sd);
> +
> + if (enable) {
> + ret = __v4l2_ctrl_handler_setup(&alvium->ctrls.handler);
> + if (ret)
> + goto out;
> +
> + ret = alvium_set_mode(alvium, state);
> + if (ret)
> + goto out;
> +
> + fmt = v4l2_subdev_get_pad_format(sd, state, 0);
> + ret = alvium_set_framefmt(alvium, fmt);
> + if (ret)
> + goto out;
> +
> + ret = alvium_set_stream_mipi(alvium, enable);
> + if (ret)
> + goto out;
> +
> + } else {
> + ret = alvium_set_stream_mipi(alvium, enable);
> + if (ret)
> + goto out;
> + }
> +
> + v4l2_subdev_unlock_state(state);
> + alvium->streaming = !!enable;
> +
> + return 0;
> +
> +out:
> + v4l2_subdev_unlock_state(state);
> + return ret;
> +}
> +
> +static int alvium_init_cfg(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_mbus_framefmt *fmt;
> + struct v4l2_rect *crop;
> +
> + struct v4l2_subdev_format sd_fmt = {
> + .which = V4L2_SUBDEV_FORMAT_TRY,
> + .format = alvium_csi2_default_fmt,
> + };
> +
> + struct v4l2_subdev_crop sd_crop = {
> + .which = V4L2_SUBDEV_FORMAT_TRY,
> + .rect = {
> + .left = mode->crop.left,
> + .top = mode->crop.top,
> + .width = mode->crop.width,
> + .height = mode->crop.height,
> + },
> + };
> +
> + crop = v4l2_subdev_get_pad_crop(sd, state, 0);
> + fmt = v4l2_subdev_get_pad_format(sd, state, 0);
> +
> + *crop = sd_crop.rect;
> + *fmt = sd_fmt.format;
> +
> + 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;
> +
> + fmt = v4l2_subdev_get_pad_format(sd, sd_state, 0);
> + crop = v4l2_subdev_get_pad_crop(sd, sd_state, 0);
> +
> + if (format->format.width <= alvium->img_max_width &&
> + format->format.width >= alvium->img_min_width) {
> + fmt->width = format->format.width;
> + } else {
> + return -EINVAL;
> + }
> +
> + if (format->format.height <= alvium->img_max_height &&
> + format->format.height >= alvium->img_min_height) {
> + fmt->height = format->format.height;
> + } else {
> + return -EINVAL;
> + }
> +
> + alvium_csi2_fmt = alvium_code_to_pixfmt(alvium, format->format.code);
> + fmt->code = alvium_csi2_fmt->code;
> +
> + /* Set also the crop width and height when set a new fmt */
> + crop->width = fmt->width;
> + crop->height = fmt->height;
> +
> + *fmt = format->format;
> +
> + 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;
> +
> + crop = v4l2_subdev_get_pad_crop(sd, sd_state, 0);
> + fmt = v4l2_subdev_get_pad_format(sd, sd_state, 0);
> +
> + /*
> + * 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 ||
> + sel->r.height != fmt->height)
> + return -EINVAL;
> +
> + if (sel->target != V4L2_SEL_TGT_CROP)
> + return -EINVAL;
> +
> + if ((sel->r.left + sel->r.width) <= alvium->img_max_width)
> + crop->left = sel->r.left;
> + else
> + return -EINVAL;
> +
> + if ((sel->r.top + sel->r.height) <= alvium->img_max_height)
> + crop->top = sel->r.top;
> + else
> + return -EINVAL;
> +
> + crop->width = sel->r.width;
> + crop->height = sel->r.height;
> +
> + sel->r = *crop;
> +
> + 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:
> + sel->r = *v4l2_subdev_get_pad_crop(sd, sd_state, 0);
> + break;
> + /* Cropping bounds */
> + case V4L2_SEL_TGT_NATIVE_SIZE:
> + sel->r.top = 0;
> + sel->r.left = 0;
> + sel->r.width = alvium->img_max_width;
> + sel->r.height = alvium->img_max_height;
> + break;
> + /* Default cropping area */
> + case V4L2_SEL_TGT_CROP_BOUNDS:
> + case V4L2_SEL_TGT_CROP_DEFAULT:
> + sel->r.top = alvium->min_offy;
> + sel->r.left = alvium->min_offx;
> + sel->r.width = alvium->img_max_width;
> + sel->r.height = alvium->img_max_height;
> + 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_AUTOGAIN:
> + val = alvium_get_gain(alvium);
> + if (val < 0)
> + return val;
> + alvium->ctrls.gain->val = val;
> + break;
> + case V4L2_CID_EXPOSURE_AUTO:
> + val = alvium_get_exposure(alvium);
> + if (val < 0)
> + return val;
> + alvium->ctrls.exposure->val = 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);
> + int ret;
> +
> + switch (ctrl->id) {
> + case V4L2_CID_AUTOGAIN:
> + ret = alvium_set_ctrl_gain(alvium, ctrl->val);
> + break;
> + case V4L2_CID_EXPOSURE_AUTO:
> + ret = alvium_set_ctrl_exposure(alvium, ctrl->val);
> + break;
> + case V4L2_CID_AUTO_WHITE_BALANCE:
> + ret = alvium_set_ctrl_white_balance(alvium, ctrl->val);
> + break;
> + case V4L2_CID_HUE:
> + ret = alvium_set_ctrl_hue(alvium, ctrl->val);
> + break;
> + case V4L2_CID_CONTRAST:
> + ret = alvium_set_ctrl_contrast(alvium, ctrl->val);
> + break;
> + case V4L2_CID_SATURATION:
> + ret = alvium_set_ctrl_saturation(alvium, ctrl->val);
> + break;
> + case V4L2_CID_GAMMA:
> + ret = alvium_set_ctrl_gamma(alvium, ctrl->val);
> + break;
> + case V4L2_CID_SHARPNESS:
> + ret = alvium_set_ctrl_sharpness(alvium, ctrl->val);
> + break;
> + case V4L2_CID_HFLIP:
> + ret = alvium_set_ctrl_hflip(alvium, ctrl->val);
> + break;
> + case V4L2_CID_VFLIP:
> + ret = alvium_set_ctrl_vflip(alvium, ctrl->val);
> + break;

No hsync or vsync controls?

> + default:
> + ret = -EINVAL;
> + break;
> + }
> +
> + return ret;
> +}
> +
> +static const struct v4l2_ctrl_ops alvium_ctrl_ops = {
> + .g_volatile_ctrl = alvium_g_volatile_ctrl,
> + .s_ctrl = alvium_s_ctrl,
> +};
> +
> +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;
> +
> + v4l2_ctrl_handler_init(hdl, 32);
> +
> + /* Pixel rate is fixed */
> + ctrls->pixel_rate = v4l2_ctrl_new_std(hdl, ops,
> + V4L2_CID_PIXEL_RATE, 0,
> + ALVIUM_DEFAULT_PIXEL_RATE_MHZ, 1,
> + ALVIUM_DEFAULT_PIXEL_RATE_MHZ);
> +
> + /* Link freq is fixed */
> + ctrls->link_freq = v4l2_ctrl_new_int_menu(hdl, ops,
> + V4L2_CID_LINK_FREQ,
> + 0, 0, &alvium->link_freq);
> +
> + /* Auto/manual white balance */
> + if (alvium->avail_ft.auto_whiteb)
> + ctrls->auto_wb = v4l2_ctrl_new_std(hdl, ops,
> + V4L2_CID_AUTO_WHITE_BALANCE,
> + 0, 1, 1, 1);
> +
> + ctrls->blue_balance = v4l2_ctrl_new_std(hdl, ops,
> + V4L2_CID_BLUE_BALANCE,
> + alvium->min_bbalance,
> + alvium->max_bbalance,
> + alvium->inc_bbalance,
> + alvium->min_bbalance);
> + ctrls->red_balance = v4l2_ctrl_new_std(hdl, ops,
> + V4L2_CID_RED_BALANCE,
> + alvium->min_rbalance,
> + alvium->max_rbalance,
> + alvium->inc_rbalance,
> + alvium->min_rbalance);
> +
> + /* Auto/manual exposure */
> + if (alvium->avail_ft.auto_exp)
> + ctrls->auto_exp = v4l2_ctrl_new_std_menu(hdl, ops,
> + V4L2_CID_EXPOSURE_AUTO,
> + V4L2_EXPOSURE_MANUAL, 0,
> + V4L2_EXPOSURE_AUTO);
> +
> + ctrls->exposure = v4l2_ctrl_new_std(hdl, ops,
> + V4L2_CID_EXPOSURE,
> + alvium->min_exp,
> + alvium->max_exp,
> + alvium->inc_exp,
> + alvium->min_exp);
> +
> + /* Auto/manual gain */
> + if (alvium->avail_ft.auto_gain)
> + ctrls->auto_gain = v4l2_ctrl_new_std(hdl, ops,
> + V4L2_CID_AUTOGAIN,
> + 0, 1, 1, 1);
> +
> + if (alvium->avail_ft.gain)
> + ctrls->gain = v4l2_ctrl_new_std(hdl, ops,
> + V4L2_CID_GAIN,
> + alvium->min_gain,
> + alvium->max_gain,
> + alvium->inc_gain,
> + alvium->min_gain);
> +
> + if (alvium->avail_ft.sat)
> + ctrls->saturation = v4l2_ctrl_new_std(hdl, ops,
> + V4L2_CID_SATURATION,
> + alvium->min_sat,
> + alvium->max_sat,
> + alvium->inc_sat,
> + alvium->max_sat);
> +
> + if (alvium->avail_ft.hue)
> + ctrls->hue = v4l2_ctrl_new_std(hdl, ops,
> + V4L2_CID_HUE,
> + alvium->min_hue,
> + alvium->max_hue,
> + alvium->inc_hue,
> + alvium->min_hue);
> +
> + if (alvium->avail_ft.contrast)
> + ctrls->contrast = v4l2_ctrl_new_std(hdl, ops,
> + V4L2_CID_CONTRAST,
> + alvium->min_contrast,
> + alvium->max_contrast,
> + alvium->inc_contrast,
> + alvium->min_contrast);
> +
> + if (alvium->avail_ft.gamma)
> + ctrls->contrast = v4l2_ctrl_new_std(hdl, ops,
> + V4L2_CID_GAMMA,
> + alvium->min_gamma,
> + alvium->max_gamma,
> + alvium->inc_gamma,
> + alvium->min_gamma);
> +
> + if (alvium->avail_ft.sharp)
> + ctrls->contrast = v4l2_ctrl_new_std(hdl, ops,
> + V4L2_CID_SHARPNESS,
> + alvium->min_sharp,
> + alvium->max_sharp,
> + alvium->inc_sharp,
> + alvium->min_sharp);
> +
> + if (alvium->avail_ft.rev_x)
> + ctrls->hflip = v4l2_ctrl_new_std(hdl, ops,
> + V4L2_CID_HFLIP,
> + 0, 1, 1, 0);
> +
> + if (alvium->avail_ft.rev_y)
> + ctrls->vflip = v4l2_ctrl_new_std(hdl, ops,
> + V4L2_CID_VFLIP,
> + 0, 1, 1, 0);
> +
> + if (hdl->error) {
> + ret = hdl->error;
> + goto free_ctrls;
> + }
> +
> + ret = v4l2_fwnode_device_parse(&alvium->i2c_client->dev, &props);
> + if (ret)
> + goto free_ctrls;
> +
> + ret = v4l2_ctrl_new_fwnode_properties(hdl, ops, &props);
> + if (ret)
> + goto free_ctrls;
> +
> + ctrls->pixel_rate->flags |= V4L2_CTRL_FLAG_READ_ONLY;
> + ctrls->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY;
> + ctrls->gain->flags |= V4L2_CTRL_FLAG_VOLATILE;
> + ctrls->exposure->flags |= V4L2_CTRL_FLAG_VOLATILE;
> +
> + v4l2_ctrl_auto_cluster(3, &ctrls->auto_wb, 0, false);
> + v4l2_ctrl_auto_cluster(2, &ctrls->auto_gain, 0, true);
> + v4l2_ctrl_auto_cluster(2, &ctrls->auto_exp, 1, true);
> +
> + alvium->sd.ctrl_handler = hdl;
> + return 0;
> +
> +free_ctrls:
> + v4l2_ctrl_handler_free(hdl);
> + return ret;
> +}
> +
> +static const struct v4l2_subdev_core_ops alvium_core_ops = {
> + .log_status = v4l2_ctrl_subdev_log_status,
> + .subscribe_event = v4l2_ctrl_subdev_subscribe_event,
> + .unsubscribe_event = v4l2_event_subdev_unsubscribe,
> +};
> +
> +static const struct v4l2_subdev_video_ops alvium_video_ops = {
> + .g_frame_interval = alvium_g_frame_interval,
> + .s_frame_interval = alvium_s_frame_interval,
> + .s_stream = alvium_s_stream,
> +};
> +
> +static const struct v4l2_subdev_pad_ops alvium_pad_ops = {
> + .init_cfg = alvium_init_cfg,
> + .enum_mbus_code = alvium_enum_mbus_code,
> + .get_fmt = v4l2_subdev_get_fmt,
> + .set_fmt = alvium_set_fmt,
> + .get_selection = alvium_get_selection,
> + .set_selection = alvium_set_selection,
> +};
> +
> +static const struct v4l2_subdev_ops alvium_subdev_ops = {
> + .core = &alvium_core_ops,
> + .pad = &alvium_pad_ops,
> + .video = &alvium_video_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 initial frame interval*/
> + alvium->frame_interval.numerator = 1;
> + alvium->frame_interval.denominator = ALVIUM_DEFAULT_FR_HZ;
> + alvium->fr = ALVIUM_DEFAULT_FR_HZ;
> +
> + /* Setup the initial mode */
> + alvium->mode.fmt = alvium_csi2_default_fmt;
> + alvium->mode.width = alvium_csi2_default_fmt.width;
> + alvium->mode.height = alvium_csi2_default_fmt.height;
> + alvium->mode.crop.left = alvium->min_offx;
> + alvium->mode.crop.top = alvium->min_offy;
> + alvium->mode.crop.width = alvium_csi2_default_fmt.width;
> + alvium->mode.crop.height = alvium_csi2_default_fmt.height;
> +
> + /* init alvium sd */
> + v4l2_i2c_subdev_init(sd, client, &alvium_subdev_ops);
> +
> + sd->flags |= V4L2_SUBDEV_FL_HAS_EVENTS | V4L2_SUBDEV_FL_HAS_DEVNODE;
> + alvium->pad.flags = MEDIA_PAD_FL_SOURCE;
> + sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;
> +
> + ret = media_entity_pads_init(&sd->entity, 1, &alvium->pad);
> + if (ret) {
> + dev_err(dev, "Could not register media entity\n");
> + return ret;
> + }
> +
> + ret = alvium_ctrl_init(alvium);
> + if (ret) {
> + dev_err(dev, "Control initialization error %d\n", ret);
> + goto entity_cleanup;
> + }
> +
> + alvium->sd.state_lock = alvium->ctrls.handler.lock;
> +
> + ret = v4l2_subdev_init_finalize(sd);
> + if (ret < 0) {
> + dev_err(dev, "subdev initialization error %d\n", ret);
> + goto err_ctrls;
> + }
> +
> + return 0;
> +
> +err_ctrls:
> + v4l2_ctrl_handler_free(&alvium->ctrls.handler);
> +entity_cleanup:
> + media_entity_cleanup(&alvium->sd.entity);
> + return ret;
> +}
> +
> +static void alvium_subdev_cleanup(struct alvium_dev *alvium)
> +{
> + v4l2_subdev_cleanup(&alvium->sd);
> + media_entity_cleanup(&alvium->sd.entity);
> + v4l2_ctrl_handler_free(&alvium->ctrls.handler);
> +}
> +
> +static int alvium_get_dt_data(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + struct device_node *node = dev->of_node;

It's not wrong to use OF nodes in general, but all APIs you're using
require an fwnode instead. So please use fwnodes here.

struct fwnode_handle *fwnode = dev_fwnode(dev);

This makes also of_* headers unnecessary, but please include
linux/property.h.

> + struct fwnode_handle *endpoint;
> + int ret = 0;

No need to initialise ret.

> +
> + if (!node)
> + return -EINVAL;
> +
> + ret = fwnode_property_read_u32(dev_fwnode(dev),
> + "alliedvision,lp2hs-delay-us",
> + &alvium->lp2hs_delay);
> +
> + endpoint = fwnode_graph_get_next_endpoint(dev_fwnode(dev), NULL);
> + if (!endpoint) {
> + dev_err(dev, "endpoint node not found\n");
> + return -EINVAL;
> + }
> +

As you have D-PHY, please assign bus type to D-PHY before parsing the
endpoint.

> + if (v4l2_fwnode_endpoint_alloc_parse(endpoint, &alvium->ep)) {
> + dev_err(dev, "could not parse endpoint\n");
> + return 0;
> + }
> +
> + if (alvium->ep.bus_type != V4L2_MBUS_CSI2_DPHY) {
> + dev_err(dev, "unsupported bus type\n");
> + return -EINVAL;
> + }
> +
> + if (!alvium->ep.nr_of_link_frequencies) {
> + dev_err(dev, "no link frequencies defined");
> + return -EINVAL;
> + }
> +
> + dev_info(dev, "freq: %llu\n",
> + alvium->ep.link_frequencies[0]);
> + dev_info(dev, "lanes: %d\n",
> + alvium->ep.bus.mipi_csi2.num_data_lanes);

The V4L2 fwnode framework prints the number of lanes already (with dynamic
debug).

If you want to leave frequency print, then make it dev_dbg().

> +
> + return 0;
> +}
> +
> +static int alvium_power_on(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret = 0;
> +
> + if (regulator_is_enabled(alvium->reg_vcc)) {
> + /* vcc-ext-in reg is already enabled */
> + dev_dbg(dev, "vcc-ext-in reg already enabled");

This seems useless and wrong: the regulator may be also used by another
driver.

> + } else {
> + ret = regulator_enable(alvium->reg_vcc);
> + if (ret)
> + return ret;
> +
> + /* alvium boot time 7s*/
> + msleep(7000);

Wow. That's the longest I've ever seen, by a large margin.

> + }
> +
> + return 0;
> +}
> +
> +static int alvium_power_off(struct alvium_dev *alvium)
> +{
> + struct device *dev = &alvium->i2c_client->dev;
> + int ret = 0;
> +
> + ret = regulator_disable(alvium->reg_vcc);
> + if (ret)
> + return ret;
> +
> + dev_dbg(dev, "power off alvium\n");

Remove perhaps?

> +
> + 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;
> +
> + ret = alvium_power_on(alvium);
> + if (ret)
> + return ret;
> +
> + ret = alvium_hw_init(alvium);
> + if (ret)
> + 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);
> +
> + alvium_power_off(alvium);
> +
> + return 0;
> +}
> +
> +static const struct dev_pm_ops alvium_pm_ops = {
> + RUNTIME_PM_OPS(alvium_runtime_suspend, alvium_runtime_resume, NULL)
> +};
> +
> +static int alvium_probe(struct i2c_client *client)
> +{
> + struct device *dev = &client->dev;
> + struct alvium_dev *alvium;
> + int ret;
> +
> + alvium = devm_kzalloc(dev, sizeof(*alvium), GFP_KERNEL);
> + if (!alvium)
> + return -ENOMEM;
> +
> + alvium->i2c_client = client;
> +
> + ret = alvium_get_dt_data(alvium);
> + if (ret)
> + return ret;
> +
> + alvium->reg_vcc = devm_regulator_get_optional(dev, "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");
> +
> + ret = alvium_power_on(alvium);
> + if (ret)
> + return ret;
> +
> + if (!alvium_is_alive(alvium)) {
> + dev_err(dev, "Device detection failed: %d\n", ret);
> + return ret;
> + }
> +
> + ret = alvium_get_hw_info(alvium);
> + if (ret) {
> + dev_err(dev, "get_hw_info fai %d\n", ret);
> + return ret;
> + }
> +
> + ret = alvium_hw_init(alvium);
> + if (ret) {
> + dev_err(dev, "hw_init fail %d\n", ret);
> + return ret;
> + }
> +
> + ret = alvium_setup_mipi_fmt(alvium);
> + if (ret) {
> + dev_err(dev, "setup_mipi_fmt fail %d\n", ret);
> + return ret;
> + }
> +
> + /*
> + * 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.
> + */
> + pm_runtime_set_active(dev);
> + pm_runtime_get_noresume(dev);
> + pm_runtime_enable(dev);
> + pm_runtime_dont_use_autosuspend(dev);

Autosuspend is disabled by default.

What's the purpose of this? Leave the device powered on after probe?

> +
> + /* Initialize the V4L2 subdev. */
> + ret = alvium_subdev_init(alvium);
> + if (ret)
> + goto err_pm;
> +
> + ret = v4l2_async_register_subdev(&alvium->sd);
> + if (ret < 0) {
> + dev_err(dev, "Could not register v4l2 device\n");
> + goto err_subdev;
> + }
> +
> + v4l2_info(&alvium->sd, "%s: completed successfully\n", __func__);

This looks like development time leftover, please remove.

> + return 0;
> +
> +err_subdev:
> + alvium_subdev_cleanup(alvium);
> +err_pm:
> + pm_runtime_disable(dev);
> + pm_runtime_put_noidle(dev);
> + alvium_power_off(alvium);
> + 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;
> +
> + i2c_unregister_device(alvium->i2c_client);
> +
> + /*
> + * Disable runtime PM. In case runtime PM is disabled in the kernel,
> + * make sure to turn power off manually.
> + */
> + pm_runtime_disable(dev);
> + if (!pm_runtime_status_suspended(dev))
> + alvium_power_off(alvium);
> + pm_runtime_set_suspended(dev);
> +}
> +
> +static const struct i2c_device_id alvium_id[] = {
> + {"alvium-csi2", 0},
> + {},
> +};
> +MODULE_DEVICE_TABLE(i2c, alvium_id);
> +
> +static const struct of_device_id alvium_of_ids[] = {
> + { .compatible = "alliedvision,alvium-csi2", },
> + { }
> +};
> +MODULE_DEVICE_TABLE(of, alvium_of_ids);
> +
> +static struct i2c_driver alvium_i2c_driver = {
> + .probe_new = alvium_probe,
> + .remove = alvium_remove,
> + .id_table = alvium_id,
> + .driver = {
> + .name = "alvium-csi2",
> + .pm = pm_ptr(&alvium_pm_ops),
> + .of_match_table = alvium_of_ids,
> + },
> +};
> +
> +module_i2c_driver(alvium_i2c_driver);
> +
> +MODULE_DESCRIPTION("Allied Vision's Alvium Camera Driver");
> +MODULE_AUTHOR("Tommaso Merciai <tomm.merciai@xxxxxxxxx>");
> +MODULE_AUTHOR("Martin Hecht <martin.hecht@xxxxxxxx>");
> +MODULE_AUTHOR("Avnet Silica Software & Services EMEA");
> +MODULE_LICENSE("GPL v2");
> diff --git a/drivers/media/i2c/alvium-csi2.h b/drivers/media/i2c/alvium-csi2.h
> new file mode 100644
> index 000000000000..30b70e2ddb16
> --- /dev/null
> +++ b/drivers/media/i2c/alvium-csi2.h
> @@ -0,0 +1,485 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Allied Vision Inc. Alvium camera driver
> + *
> + * Copyright (C) 2023 Tommaso Merciai
> + * Copyright (C) 2023 Martin Hecht
> + * Copyright (C) 2023 Avnet EMG GmbH
> + */
> +
> +#ifndef ALVIUM_H_
> +#define ALVIUM_H_
> +
> +#include <linux/clk.h>
> +#include <linux/gpio/consumer.h>
> +#include <linux/kernel.h>
> +#include <linux/regulator/consumer.h>
> +#include <media/v4l2-common.h>
> +#include <media/v4l2-ctrls.h>
> +#include <media/v4l2-fwnode.h>
> +#include <media/v4l2-subdev.h>
> +
> +#define REG_BCRM_V4L2 BIT(31)
> +#define REG_BCRM_SIZE_SHIFT 16
> +#define REG_BCRM_SIZE_MASK 0x000f0000
> +#define REG_BCRM_SIZE(reg) (((reg) & REG_BCRM_SIZE_MASK) >> REG_BCRM_SIZE_SHIFT)
> +#define REG_BCRM_ADDR_MASK 0x0000ffff
> +#define REG_BCRM_ADDR(reg) ((reg) & REG_BCRM_ADDR_MASK)
> +
> +#define REG_BCRM_CCI_8BIT(n) ((1U << REG_BCRM_SIZE_SHIFT) | (n))
> +#define REG_BCRM_CCI_16BIT(n) ((2U << REG_BCRM_SIZE_SHIFT) | (n))
> +#define REG_BCRM_CCI_32BIT(n) ((4U << REG_BCRM_SIZE_SHIFT) | (n))
> +#define REG_BCRM_CCI_64BIT(n) ((8U << REG_BCRM_SIZE_SHIFT) | (n))
> +
> +#define REG_BCRM_V4L2_8BIT(n) (REG_BCRM_V4L2 | (1U << REG_BCRM_SIZE_SHIFT) | (n))
> +#define REG_BCRM_V4L2_16BIT(n) (REG_BCRM_V4L2 | (2U << REG_BCRM_SIZE_SHIFT) | (n))
> +#define REG_BCRM_V4L2_32BIT(n) (REG_BCRM_V4L2 | (4U << REG_BCRM_SIZE_SHIFT) | (n))
> +#define REG_BCRM_V4L2_64BIT(n) (REG_BCRM_V4L2 | (8U << REG_BCRM_SIZE_SHIFT) | (n))
> +
> +/* Basic Control Register Map register offsets (BCRM) */
> +#define REG_BCRM_VERSION_R REG_BCRM_CCI_32BIT(0x0000)
> +#define REG_BCRM_REG_ADDR_R REG_BCRM_CCI_16BIT(0x0014)
> +
> +#define REG_BCRM_FEATURE_INQUIRY_R REG_BCRM_V4L2_64BIT(0x0008)
> +#define REG_BCRM_DEVICE_FIRMWARE_VERSION_R REG_BCRM_V4L2_64BIT(0x0010)
> +#define REG_BCRM_WRITE_HANDSHAKE_RW REG_BCRM_V4L2_8BIT(0x0018)
> +
> +/* Streaming Control Registers */
> +#define REG_BCRM_SUPPORTED_CSI2_LANE_COUNTS_R REG_BCRM_V4L2_8BIT(0x0040)
> +#define REG_BCRM_CSI2_LANE_COUNT_RW REG_BCRM_V4L2_8BIT(0x0044)
> +#define REG_BCRM_CSI2_CLOCK_MIN_R REG_BCRM_V4L2_32BIT(0x0048)
> +#define REG_BCRM_CSI2_CLOCK_MAX_R REG_BCRM_V4L2_32BIT(0x004c)
> +#define REG_BCRM_CSI2_CLOCK_RW REG_BCRM_V4L2_32BIT(0x0050)
> +#define REG_BCRM_BUFFER_SIZE_R REG_BCRM_V4L2_32BIT(0x0054)
> +
> +#define REG_BCRM_IPU_X_MIN_W REG_BCRM_V4L2_32BIT(0x0058)
> +#define REG_BCRM_IPU_X_MAX_W REG_BCRM_V4L2_32BIT(0x005c)
> +#define REG_BCRM_IPU_X_INC_W REG_BCRM_V4L2_32BIT(0x0060)
> +#define REG_BCRM_IPU_Y_MIN_W REG_BCRM_V4L2_32BIT(0x0064)
> +#define REG_BCRM_IPU_Y_MAX_W REG_BCRM_V4L2_32BIT(0x0068)
> +#define REG_BCRM_IPU_Y_INC_W REG_BCRM_V4L2_32BIT(0x006c)
> +#define REG_BCRM_IPU_X_R REG_BCRM_V4L2_32BIT(0x0070)
> +#define REG_BCRM_IPU_Y_R REG_BCRM_V4L2_32BIT(0x0074)
> +
> +#define REG_BCRM_PHY_RESET_RW REG_BCRM_V4L2_8BIT(0x0078)
> +#define REG_BCRM_STREAM_ON_DELAY_RW REG_BCRM_V4L2_32BIT(0x007c)
> +
> +/* Acquisition Control Registers */
> +#define REG_BCRM_ACQUISITION_START_RW REG_BCRM_V4L2_8BIT(0x0080)
> +#define REG_BCRM_ACQUISITION_STOP_RW REG_BCRM_V4L2_8BIT(0x0084)
> +#define REG_BCRM_ACQUISITION_ABORT_RW REG_BCRM_V4L2_8BIT(0x0088)
> +#define REG_BCRM_ACQUISITION_STATUS_R REG_BCRM_V4L2_8BIT(0x008c)
> +#define REG_BCRM_ACQUISITION_FRAME_RATE_RW REG_BCRM_V4L2_64BIT(0x0090)
> +#define REG_BCRM_ACQUISITION_FRAME_RATE_MIN_R REG_BCRM_V4L2_64BIT(0x0098)
> +#define REG_BCRM_ACQUISITION_FRAME_RATE_MAX_R REG_BCRM_V4L2_64BIT(0x00a0)
> +#define REG_BCRM_ACQUISITION_FRAME_RATE_INC_R REG_BCRM_V4L2_64BIT(0x00a8)
> +#define REG_BCRM_ACQUISITION_FRAME_RATE_ENABLE_RW REG_BCRM_V4L2_8BIT(0x00b0)
> +
> +#define REG_BCRM_FRAME_START_TRIGGER_MODE_RW REG_BCRM_V4L2_8BIT(0x00b4)
> +#define REG_BCRM_FRAME_START_TRIGGER_SOURCE_RW REG_BCRM_V4L2_8BIT(0x00b8)
> +#define REG_BCRM_FRAME_START_TRIGGER_ACTIVATION_RW REG_BCRM_V4L2_8BIT(0x00bc)
> +#define REG_BCRM_FRAME_START_TRIGGER_SOFTWARE_W REG_BCRM_V4L2_8BIT(0x00c0)
> +#define REG_BCRM_FRAME_START_TRIGGER_DELAY_RW REG_BCRM_V4L2_32BIT(0x00c4)
> +#define REG_BCRM_EXPOSURE_ACTIVE_LINE_MODE_RW REG_BCRM_V4L2_8BIT(0x00c8)
> +#define REG_BCRM_EXPOSURE_ACTIVE_LINE_SELECTOR_RW REG_BCRM_V4L2_8BIT(0x00cc)
> +#define REG_BCRM_LINE_CONFIGURATION_RW REG_BCRM_V4L2_32BIT(0x00d0)
> +
> +#define REG_BCRM_IMG_WIDTH_RW REG_BCRM_V4L2_32BIT(0x0100)
> +#define REG_BCRM_IMG_WIDTH_MIN_R REG_BCRM_V4L2_32BIT(0x0104)
> +#define REG_BCRM_IMG_WIDTH_MAX_R REG_BCRM_V4L2_32BIT(0x0108)
> +#define REG_BCRM_IMG_WIDTH_INC_R REG_BCRM_V4L2_32BIT(0x010c)
> +
> +#define REG_BCRM_IMG_HEIGHT_RW REG_BCRM_V4L2_32BIT(0x0110)
> +#define REG_BCRM_IMG_HEIGHT_MIN_R REG_BCRM_V4L2_32BIT(0x0114)
> +#define REG_BCRM_IMG_HEIGHT_MAX_R REG_BCRM_V4L2_32BIT(0x0118)
> +#define REG_BCRM_IMG_HEIGHT_INC_R REG_BCRM_V4L2_32BIT(0x011c)
> +
> +#define REG_BCRM_IMG_OFFSET_X_RW REG_BCRM_V4L2_32BIT(0x0120)
> +#define REG_BCRM_IMG_OFFSET_X_MIN_R REG_BCRM_V4L2_32BIT(0x0124)
> +#define REG_BCRM_IMG_OFFSET_X_MAX_R REG_BCRM_V4L2_32BIT(0x0128)
> +#define REG_BCRM_IMG_OFFSET_X_INC_R REG_BCRM_V4L2_32BIT(0x012c)
> +
> +#define REG_BCRM_IMG_OFFSET_Y_RW REG_BCRM_V4L2_32BIT(0x0130)
> +#define REG_BCRM_IMG_OFFSET_Y_MIN_R REG_BCRM_V4L2_32BIT(0x0134)
> +#define REG_BCRM_IMG_OFFSET_Y_MAX_R REG_BCRM_V4L2_32BIT(0x0138)
> +#define REG_BCRM_IMG_OFFSET_Y_INC_R REG_BCRM_V4L2_32BIT(0x013c)
> +
> +#define REG_BCRM_IMG_MIPI_DATA_FORMAT_RW REG_BCRM_V4L2_32BIT(0x0140)
> +#define REG_BCRM_IMG_AVAILABLE_MIPI_DATA_FORMATS_R REG_BCRM_V4L2_64BIT(0x0148)
> +#define REG_BCRM_IMG_BAYER_PATTERN_INQUIRY_R REG_BCRM_V4L2_8BIT(0x0150)
> +#define REG_BCRM_IMG_BAYER_PATTERN_RW REG_BCRM_V4L2_8BIT(0x0154)
> +#define REG_BCRM_IMG_REVERSE_X_RW REG_BCRM_V4L2_8BIT(0x0158)
> +#define REG_BCRM_IMG_REVERSE_Y_RW REG_BCRM_V4L2_8BIT(0x015c)
> +
> +#define REG_BCRM_SENSOR_WIDTH_R REG_BCRM_V4L2_32BIT(0x0160)
> +#define REG_BCRM_SENSOR_HEIGHT_R REG_BCRM_V4L2_32BIT(0x0164)
> +#define REG_BCRM_WIDTH_MAX_R REG_BCRM_V4L2_32BIT(0x0168)
> +#define REG_BCRM_HEIGHT_MAX_R REG_BCRM_V4L2_32BIT(0x016c)
> +
> +#define REG_BCRM_EXPOSURE_TIME_RW REG_BCRM_V4L2_64BIT(0x0180)
> +#define REG_BCRM_EXPOSURE_TIME_MIN_R REG_BCRM_V4L2_64BIT(0x0188)
> +#define REG_BCRM_EXPOSURE_TIME_MAX_R REG_BCRM_V4L2_64BIT(0x0190)
> +#define REG_BCRM_EXPOSURE_TIME_INC_R REG_BCRM_V4L2_64BIT(0x0198)
> +#define REG_BCRM_EXPOSURE_AUTO_RW REG_BCRM_V4L2_8BIT(0x01a0)
> +
> +#define REG_BCRM_INTENSITY_AUTO_PRECEDENCE_RW REG_BCRM_V4L2_8BIT(0x01a4)
> +#define REG_BCRM_INTENSITY_AUTO_PRECEDENCE_VALUE_RW REG_BCRM_V4L2_32BIT(0x01a8)
> +#define REG_BCRM_INTENSITY_AUTO_PRECEDENCE_MIN_R REG_BCRM_V4L2_32BIT(0x01ac)
> +#define REG_BCRM_INTENSITY_AUTO_PRECEDENCE_MAX_R REG_BCRM_V4L2_32BIT(0x01b0)
> +#define REG_BCRM_INTENSITY_AUTO_PRECEDENCE_INC_R REG_BCRM_V4L2_32BIT(0x01b4)
> +
> +#define REG_BCRM_BLACK_LEVEL_RW REG_BCRM_V4L2_32BIT(0x01b8)
> +#define REG_BCRM_BLACK_LEVEL_MIN_R REG_BCRM_V4L2_32BIT(0x01bc)
> +#define REG_BCRM_BLACK_LEVEL_MAX_R REG_BCRM_V4L2_32BIT(0x01c0)
> +#define REG_BCRM_BLACK_LEVEL_INC_R REG_BCRM_V4L2_32BIT(0x01c4)
> +
> +#define REG_BCRM_GAIN_RW REG_BCRM_V4L2_64BIT(0x01c8)
> +#define REG_BCRM_GAIN_MIN_R REG_BCRM_V4L2_64BIT(0x01d0)
> +#define REG_BCRM_GAIN_MAX_R REG_BCRM_V4L2_64BIT(0x01d8)
> +#define REG_BCRM_GAIN_INC_R REG_BCRM_V4L2_64BIT(0x01e0)
> +#define REG_BCRM_GAIN_AUTO_RW REG_BCRM_V4L2_8BIT(0x01e8)
> +
> +#define REG_BCRM_GAMMA_RW REG_BCRM_V4L2_64BIT(0x01f0)
> +#define REG_BCRM_GAMMA_MIN_R REG_BCRM_V4L2_64BIT(0x01f8)
> +#define REG_BCRM_GAMMA_MAX_R REG_BCRM_V4L2_64BIT(0x0200)
> +#define REG_BCRM_GAMMA_INC_R REG_BCRM_V4L2_64BIT(0x0208)
> +
> +#define REG_BCRM_CONTRAST_VALUE_RW REG_BCRM_V4L2_32BIT(0x0214)
> +#define REG_BCRM_CONTRAST_VALUE_MIN_R REG_BCRM_V4L2_32BIT(0x0218)
> +#define REG_BCRM_CONTRAST_VALUE_MAX_R REG_BCRM_V4L2_32BIT(0x021c)
> +#define REG_BCRM_CONTRAST_VALUE_INC_R REG_BCRM_V4L2_32BIT(0x0220)
> +
> +#define REG_BCRM_SATURATION_RW REG_BCRM_V4L2_32BIT(0x0240)
> +#define REG_BCRM_SATURATION_MIN_R REG_BCRM_V4L2_32BIT(0x0244)
> +#define REG_BCRM_SATURATION_MAX_R REG_BCRM_V4L2_32BIT(0x0248)
> +#define REG_BCRM_SATURATION_INC_R REG_BCRM_V4L2_32BIT(0x024c)
> +
> +#define REG_BCRM_HUE_RW REG_BCRM_V4L2_32BIT(0x0250)
> +#define REG_BCRM_HUE_MIN_R REG_BCRM_V4L2_32BIT(0x0254)
> +#define REG_BCRM_HUE_MAX_R REG_BCRM_V4L2_32BIT(0x0258)
> +#define REG_BCRM_HUE_INC_R REG_BCRM_V4L2_32BIT(0x025c)
> +
> +#define REG_BCRM_ALL_BALANCE_RATIO_RW REG_BCRM_V4L2_64BIT(0x0260)
> +#define REG_BCRM_ALL_BALANCE_RATIO_MIN_R REG_BCRM_V4L2_64BIT(0x0268)
> +#define REG_BCRM_ALL_BALANCE_RATIO_MAX_R REG_BCRM_V4L2_64BIT(0x0270)
> +#define REG_BCRM_ALL_BALANCE_RATIO_INC_R REG_BCRM_V4L2_64BIT(0x0278)
> +
> +#define REG_BCRM_RED_BALANCE_RATIO_RW REG_BCRM_V4L2_64BIT(0x0280)
> +#define REG_BCRM_RED_BALANCE_RATIO_MIN_R REG_BCRM_V4L2_64BIT(0x0288)
> +#define REG_BCRM_RED_BALANCE_RATIO_MAX_R REG_BCRM_V4L2_64BIT(0x0290)
> +#define REG_BCRM_RED_BALANCE_RATIO_INC_R REG_BCRM_V4L2_64BIT(0x0298)
> +
> +#define REG_BCRM_GREEN_BALANCE_RATIO_RW REG_BCRM_V4L2_64BIT(0x02a0)
> +#define REG_BCRM_GREEN_BALANCE_RATIO_MIN_R REG_BCRM_V4L2_64BIT(0x02a8)
> +#define REG_BCRM_GREEN_BALANCE_RATIO_MAX_R REG_BCRM_V4L2_64BIT(0x02b0)
> +#define REG_BCRM_GREEN_BALANCE_RATIO_INC_R REG_BCRM_V4L2_64BIT(0x02b8)
> +
> +#define REG_BCRM_BLUE_BALANCE_RATIO_RW REG_BCRM_V4L2_64BIT(0x02c0)
> +#define REG_BCRM_BLUE_BALANCE_RATIO_MIN_R REG_BCRM_V4L2_64BIT(0x02c8)
> +#define REG_BCRM_BLUE_BALANCE_RATIO_MAX_R REG_BCRM_V4L2_64BIT(0x02d0)
> +#define REG_BCRM_BLUE_BALANCE_RATIO_INC_R REG_BCRM_V4L2_64BIT(0x02d8)
> +
> +#define REG_BCRM_WHITE_BALANCE_AUTO_RW REG_BCRM_V4L2_8BIT(0x02e0)
> +#define REG_BCRM_SHARPNESS_RW REG_BCRM_V4L2_32BIT(0x0300)
> +#define REG_BCRM_SHARPNESS_MIN_R REG_BCRM_V4L2_32BIT(0x0304)
> +#define REG_BCRM_SHARPNESS_MAX_R REG_BCRM_V4L2_32BIT(0x0308)
> +#define REG_BCRM_SHARPNESS_INC_R REG_BCRM_V4L2_32BIT(0x030c)
> +
> +#define REG_BCRM_DEVICE_TEMPERATURE_R REG_BCRM_V4L2_32BIT(0x0310)
> +#define REG_BCRM_EXPOSURE_AUTO_MIN_RW REG_BCRM_V4L2_64BIT(0x0330)
> +#define REG_BCRM_EXPOSURE_AUTO_MAX_RW REG_BCRM_V4L2_64BIT(0x0338)
> +#define REG_BCRM_GAIN_AUTO_MIN_RW REG_BCRM_V4L2_64BIT(0x0340)
> +#define REG_BCRM_GAIN_AUTO_MAX_RW REG_BCRM_V4L2_64BIT(0x0348)
> +
> +/* Heartbeat reg*/
> +#define REG_BCRM_HEARTBEAT_R REG_BCRM_CCI_8BIT(0x021f)
> +
> +/* GenCP Registers */
> +#define REG_GENCP_CHANGEMODE_W REG_BCRM_CCI_8BIT(0x021c)
> +#define REG_GENCP_CURRENTMODE_R REG_BCRM_CCI_8BIT(0x021d)
> +#define REG_GENCP_IN_HANDSHAKE_RW REG_BCRM_CCI_8BIT(0x001c)
> +#define REG_GENCP_OUT_SIZE_W REG_BCRM_CCI_16BIT(0x0020)
> +#define REG_GENCP_IN_SIZE_R REG_BCRM_CCI_16BIT(0x0024)

Please use tabs instead.

> +
> +/* defines */
> +#define REG_BCRM_HANDSHAKE_STATUS_MASK 0x01
> +#define REG_BCRM_HANDSHAKE_AVAILABLE_MASK 0x80

And align the value to the same column.

> +
> +#define BCRM_HANDSHAKE_W_DONE_EN_BIT BIT(0)
> +#define BCRM_HANDSHAKE_W_RST 0
> +
> +#define ALVIUM_DEFAULT_FR_HZ 10
> +#define ALVIUM_DEFAULT_PIXEL_RATE_MHZ 148000000
> +
> +enum alvium_bcrm_mode {
> + ALVIUM_BCM_MODE,
> + ALVIUM_GENCP_MODE,
> + ALVIUM_NUM_MODE
> +};
> +
> +enum alvium_mipi_fmt {
> + ALVIUM_FMT_UYVY8_2X8 = 0,
> + ALVIUM_FMT_UYVY8_1X16,
> + ALVIUM_FMT_YUYV8_1X16,
> + ALVIUM_FMT_YUYV8_2X8,
> + ALVIUM_FMT_YUYV10_1X20,
> + ALVIUM_FMT_RGB888_1X24,
> + ALVIUM_FMT_RBG888_1X24,
> + ALVIUM_FMT_BGR888_1X24,
> + ALVIUM_FMT_RGB888_3X8,
> + ALVIUM_FMT_Y8_1X8,
> + ALVIUM_FMT_SGRBG8_1X8,
> + ALVIUM_FMT_SRGGB8_1X8,
> + ALVIUM_FMT_SGBRG8_1X8,
> + ALVIUM_FMT_SBGGR8_1X8,
> + ALVIUM_FMT_Y10_1X10,
> + ALVIUM_FMT_SGRBG10_1X10,
> + ALVIUM_FMT_SRGGB10_1X10,
> + ALVIUM_FMT_SGBRG10_1X10,
> + ALVIUM_FMT_SBGGR10_1X10,
> + ALVIUM_FMT_Y12_1X12,
> + ALVIUM_FMT_SGRBG12_1X12,
> + ALVIUM_FMT_SRGGB12_1X12,
> + ALVIUM_FMT_SGBRG12_1X12,
> + ALVIUM_FMT_SBGGR12_1X12,
> + ALVIUM_FMT_SBGGR14_1X14,
> + ALVIUM_FMT_SGBRG14_1X14,
> + ALVIUM_FMT_SRGGB14_1X14,
> + ALVIUM_FMT_SGRBG14_1X14,
> + ALVIUM_NUM_SUPP_MIPI_DATA_FMT
> +};
> +
> +enum alvium_av_bayer_bit {
> + ALVIUM_BIT_BAY_NONE = -1,
> + ALVIUM_BIT_BAY_MONO = 0,
> + ALVIUM_BIT_BAY_GR,
> + ALVIUM_BIT_BAY_RG,
> + ALVIUM_BIT_BAY_GB,
> + ALVIUM_BIT_BAY_BG,
> + ALVIUM_NUM_BAY_AV_BIT
> +};
> +
> +enum alvium_av_mipi_bit {
> + ALVIUM_BIT_YUV420_8_LEG = 0,
> + ALVIUM_BIT_YUV420_8,
> + ALVIUM_BIT_YUV420_10,
> + ALVIUM_BIT_YUV420_8_CSPS,
> + ALVIUM_BIT_YUV420_10_CSPS,
> + ALVIUM_BIT_YUV422_8,
> + ALVIUM_BIT_YUV422_10,
> + ALVIUM_BIT_RGB888,
> + ALVIUM_BIT_RGB666,
> + ALVIUM_BIT_RGB565,
> + ALVIUM_BIT_RGB555,
> + ALVIUM_BIT_RGB444,
> + ALVIUM_BIT_RAW6,
> + ALVIUM_BIT_RAW7,
> + ALVIUM_BIT_RAW8,
> + ALVIUM_BIT_RAW10,
> + ALVIUM_BIT_RAW12,
> + ALVIUM_BIT_RAW14,
> + ALVIUM_BIT_JPEG,
> + ALVIUM_NUM_SUPP_MIPI_DATA_BIT
> +};
> +
> +struct alvium_bcrm_vers {
> + u16 minor;
> + u16 major;
> +};
> +
> +struct alvium_fw_vers {
> + u8 special;
> + u8 major;
> + u16 minor;
> + u32 patch;
> +};
> +
> +struct alvium_avail_feat {
> + u8 rev_x:1;
> + u8 rev_y:1;
> + u8 int_autop:1;
> + u8 black_lvl:1;
> + u8 gain:1;
> + u8 gamma:1;
> + u8 contrast:1;
> + u8 sat:1;
> + u8 hue:1;
> + u8 whiteb:1;
> + u8 sharp:1;
> + u8 auto_exp:1;
> + u8 auto_gain:1;
> + u8 auto_whiteb:1;
> + u8 dev_temp:1;
> + u8 acq_abort:1;
> + u8 acq_fr:1;
> + u8 fr_trigger:1;
> + u8 exp_acq_line:1;
> +};
> +
> +struct alvium_avail_mipi_fmt {
> + u8 yuv420_8_leg:1;
> + u8 yuv420_8:1;
> + u8 yuv420_10:1;
> + u8 yuv420_8_csps:1;
> + u8 yuv420_10_csps:1;
> + u8 yuv422_8:1;
> + u8 yuv422_10:1;
> + u8 rgb888:1;
> + u8 rgb666:1;
> + u8 rgb565:1;
> + u8 rgb555:1;
> + u8 rgb444:1;
> + u8 raw6:1;
> + u8 raw7:1;
> + u8 raw8:1;
> + u8 raw10:1;
> + u8 raw12:1;
> + u8 raw14:1;
> + u8 jpeg:1;

I don't think C defines a particular location for the bit fields if their
size is less than that of the type. Could you add padding to ensure that?
Same for other structs.

> +};
> +
> +struct alvium_avail_bayer {
> + u8 mono:1;
> + u8 gr:1;
> + u8 rg:1;
> + u8 gb:1;
> + u8 bg:1;
> +};
> +
> +struct alvium_mode {
> + struct v4l2_rect crop;
> + struct v4l2_mbus_framefmt fmt;
> + u32 width;
> + u32 height;
> +};
> +
> +struct alvium_pixfmt {
> + u8 id;
> + u32 code;
> + u32 colorspace;
> + u8 fmt_av_bit;
> + u8 bay_av_bit;
> + u64 mipi_fmt_regval;
> + u64 bay_fmt_regval;
> + u8 is_raw;

This would require less memory if you moved all 8-bit fields to the end of
the struct.

> +};
> +
> +struct alvium_ctrls {
> + struct v4l2_ctrl_handler handler;
> + struct v4l2_ctrl *pixel_rate;
> + struct v4l2_ctrl *link_freq;
> + struct {
> + struct v4l2_ctrl *auto_exp;
> + struct v4l2_ctrl *exposure;
> + };
> + struct {
> + struct v4l2_ctrl *auto_wb;
> + struct v4l2_ctrl *blue_balance;
> + struct v4l2_ctrl *red_balance;
> + };
> + struct {
> + struct v4l2_ctrl *auto_gain;
> + struct v4l2_ctrl *gain;
> + };
> + struct v4l2_ctrl *saturation;
> + struct v4l2_ctrl *hue;
> + struct v4l2_ctrl *contrast;
> + struct v4l2_ctrl *gamma;
> + struct v4l2_ctrl *sharpness;
> + struct v4l2_ctrl *hflip;
> + struct v4l2_ctrl *vflip;
> +};
> +
> +struct alvium_dev {
> + struct i2c_client *i2c_client;
> + struct v4l2_subdev sd;
> + struct v4l2_fwnode_endpoint ep;
> + struct media_pad pad;
> +
> + struct regulator *reg_vcc;
> +
> + u16 bcrm_addr;
> +
> + struct alvium_avail_feat avail_ft;
> + u8 is_mipi_fmt_avail[ALVIUM_NUM_SUPP_MIPI_DATA_BIT];
> + u8 is_bay_avail[ALVIUM_NUM_BAY_AV_BIT];
> +
> + u32 min_csi_clk;
> + u32 max_csi_clk;
> + u32 img_min_width;
> + u32 img_max_width;
> + u32 img_inc_width;
> + u32 img_min_height;
> + u32 img_max_height;
> + u32 img_inc_height;
> + u32 min_offx;
> + u32 max_offx;
> + u32 inc_offx;
> + u32 min_offy;
> + u32 max_offy;
> + u32 inc_offy;
> + u64 min_gain;
> + u64 max_gain;
> + u64 inc_gain;
> + u64 min_exp;
> + u64 max_exp;
> + u64 inc_exp;
> + u64 min_rbalance;
> + u64 max_rbalance;
> + u64 inc_rbalance;
> + u64 min_bbalance;
> + u64 max_bbalance;
> + u64 inc_bbalance;
> + s32 min_hue;
> + s32 max_hue;
> + s32 inc_hue;
> + u32 min_contrast;
> + u32 max_contrast;
> + u32 inc_contrast;
> + u32 min_sat;
> + u32 max_sat;
> + u32 inc_sat;
> + s32 min_black_lvl;
> + s32 max_black_lvl;
> + s32 inc_black_lvl;
> + u64 min_gamma;
> + u64 max_gamma;
> + u64 inc_gamma;
> + s32 min_sharp;
> + s32 max_sharp;
> + s32 inc_sharp;
> +
> + u32 lp2hs_delay;
> +
> + struct alvium_mode mode;
> + struct v4l2_fract frame_interval;
> + u64 min_fr;
> + u64 max_fr;
> + u64 fr;
> +
> + u8 h_sup_csi_lanes;
> + u32 csi_clk;
> + u64 link_freq;
> +
> + struct alvium_ctrls ctrls;
> +
> + u8 bcrm_mode;
> +
> + struct alvium_pixfmt *alvium_csi2_fmt;
> + u8 alvium_csi2_fmt_n;
> +
> + u8 streaming:1;
> + u8 apply_fiv:1;
> +};
> +
> +static inline struct alvium_dev *sd_to_alvium(struct v4l2_subdev *sd)
> +{
> + return container_of(sd, struct alvium_dev, sd);
> +}
> +
> +static inline struct v4l2_subdev *ctrl_to_sd(struct v4l2_ctrl *ctrl)
> +{
> + return &container_of(ctrl->handler, struct alvium_dev,
> + ctrls.handler)->sd;
> +}
> +#endif /* ALVIUM_H_ */

--
Kind regards,

Sakari Ailus

Next message: Tianrui Zhao: "[PATCH v13 23/30] LoongArch: KVM: Implement handle gspr exception"
Previous message: Stephan Gerhold: "Re: [PATCH 1/5] dt-bindings: reserved-memory: Add alloc-{bottom-up,top-down}"
In reply to: kernel test robot: "Re: [PATCH v5 3/3] media: i2c: Add support for alvium camera"
Next in thread: Tommaso Merciai: "Re: [PATCH v5 3/3] media: i2c: Add support for alvium camera"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]