From eaac70137183ed2d598d8bb067373c39296894d1 Mon Sep 17 00:00:00 2001 From: Benjamin Mugnier Date: Tue, 19 Aug 2025 16:47:41 +0200 Subject: [PATCH 01/10] media: dt-bindings: vd55g1: Add vd65g4 compatible Switch compatible from a const to an enum to accommodate both the vd55g1 and the vd65g4, which is the color variant. Signed-off-by: Benjamin Mugnier Acked-by: Conor Dooley Signed-off-by: Sakari Ailus Signed-off-by: Hans Verkuil --- Documentation/devicetree/bindings/media/i2c/st,vd55g1.yaml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/Documentation/devicetree/bindings/media/i2c/st,vd55g1.yaml b/Documentation/devicetree/bindings/media/i2c/st,vd55g1.yaml index 3c071e6fbea61..060ac6829b661 100644 --- a/Documentation/devicetree/bindings/media/i2c/st,vd55g1.yaml +++ b/Documentation/devicetree/bindings/media/i2c/st,vd55g1.yaml @@ -25,7 +25,11 @@ allOf: properties: compatible: - const: st,vd55g1 + enum: + - st,vd55g1 + - st,vd65g4 + description: + VD55G1 is the monochrome variant, while VD65G4 is the color one. reg: maxItems: 1 From d909f812f45a1aad94e6bbdbfa56f978bd87756e Mon Sep 17 00:00:00 2001 From: Benjamin Mugnier Date: Tue, 19 Aug 2025 16:47:42 +0200 Subject: [PATCH 02/10] media: i2c: vd55g1: Add support for vd65g4 RGB variant The vd65g4 is the bayer version of the vd55g1. As opposed to the vd55g1, the vd65g4 does not need any patch. Check the sensor id at probe and choose to patch or not on power_on() according to it. It's bayer matrix's order is RGGB. This commit handles hflip and vflip by switching the bayer pattern accordingly. Signed-off-by: Benjamin Mugnier Signed-off-by: Sakari Ailus Signed-off-by: Hans Verkuil --- drivers/media/i2c/vd55g1.c | 234 ++++++++++++++++++++++++++----------- 1 file changed, 167 insertions(+), 67 deletions(-) diff --git a/drivers/media/i2c/vd55g1.c b/drivers/media/i2c/vd55g1.c index f09d6bf326413..78d18c0281541 100644 --- a/drivers/media/i2c/vd55g1.c +++ b/drivers/media/i2c/vd55g1.c @@ -29,9 +29,11 @@ /* Register Map */ #define VD55G1_REG_MODEL_ID CCI_REG32_LE(0x0000) -#define VD55G1_MODEL_ID 0x53354731 +#define VD55G1_MODEL_ID_VD55G1 0x53354731 /* Mono */ +#define VD55G1_MODEL_ID_VD65G4 0x53354733 /* RGB */ #define VD55G1_REG_REVISION CCI_REG16_LE(0x0004) #define VD55G1_REVISION_CCB 0x2020 +#define VD55G1_REVISION_BAYER 0x3030 #define VD55G1_REG_FWPATCH_REVISION CCI_REG16_LE(0x0012) #define VD55G1_REG_FWPATCH_START_ADDR CCI_REG8(0x2000) #define VD55G1_REG_SYSTEM_FSM CCI_REG8(0x001c) @@ -39,7 +41,8 @@ #define VD55G1_SYSTEM_FSM_SW_STBY 0x02 #define VD55G1_SYSTEM_FSM_STREAMING 0x03 #define VD55G1_REG_BOOT CCI_REG8(0x0200) -#define VD55G1_BOOT_PATCH_SETUP 2 +#define VD55G1_BOOT_BOOT 1 +#define VD55G1_BOOT_PATCH_AND_BOOT 2 #define VD55G1_REG_STBY CCI_REG8(0x0201) #define VD55G1_STBY_START_STREAM 1 #define VD55G1_REG_STREAMING CCI_REG8(0x0202) @@ -132,7 +135,10 @@ #define VD55G1_MIPI_RATE_MIN (250 * MEGA) #define VD55G1_MIPI_RATE_MAX (1200 * MEGA) -static const u8 patch_array[] = { +#define VD55G1_MODEL_ID_NAME(id) \ + ((id) == VD55G1_MODEL_ID_VD55G1 ? "vd55g1" : "vd65g4") + +static const u8 vd55g1_patch_array[] = { 0x44, 0x03, 0x09, 0x02, 0xe6, 0x01, 0x42, 0x00, 0xea, 0x01, 0x42, 0x00, 0xf0, 0x01, 0x42, 0x00, 0xe6, 0x01, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -466,22 +472,24 @@ struct vd55g1_mode { u32 height; }; -struct vd55g1_fmt_desc { - u32 code; - u8 bpp; - u8 data_type; +static const u32 vd55g1_mbus_formats_mono[] = { + MEDIA_BUS_FMT_Y8_1X8, + MEDIA_BUS_FMT_Y10_1X10, }; -static const struct vd55g1_fmt_desc vd55g1_mbus_codes[] = { +/* Format order is : no flip, hflip, vflip, both */ +static const u32 vd55g1_mbus_formats_bayer[][4] = { { - .code = MEDIA_BUS_FMT_Y8_1X8, - .bpp = 8, - .data_type = MIPI_CSI2_DT_RAW8, + MEDIA_BUS_FMT_SRGGB8_1X8, + MEDIA_BUS_FMT_SGRBG8_1X8, + MEDIA_BUS_FMT_SGBRG8_1X8, + MEDIA_BUS_FMT_SBGGR8_1X8, }, { - .code = MEDIA_BUS_FMT_Y10_1X10, - .bpp = 10, - .data_type = MIPI_CSI2_DT_RAW10, + MEDIA_BUS_FMT_SRGGB10_1X10, + MEDIA_BUS_FMT_SGRBG10_1X10, + MEDIA_BUS_FMT_SGBRG10_1X10, + MEDIA_BUS_FMT_SBGGR10_1X10, }, }; @@ -524,6 +532,7 @@ struct vd55g1_vblank_limits { struct vd55g1 { struct device *dev; + unsigned int id; struct v4l2_subdev sd; struct media_pad pad; struct regulator_bulk_data supplies[ARRAY_SIZE(vd55g1_supply_name)]; @@ -572,27 +581,78 @@ static inline struct vd55g1 *ctrl_to_vd55g1(struct v4l2_ctrl *ctrl) return to_vd55g1(sd); } -static const struct vd55g1_fmt_desc *vd55g1_get_fmt_desc(struct vd55g1 *sensor, - u32 code) +static unsigned int vd55g1_get_fmt_bpp(u32 code) { - unsigned int i; + switch (code) { + case MEDIA_BUS_FMT_Y8_1X8: + case MEDIA_BUS_FMT_SRGGB8_1X8: + case MEDIA_BUS_FMT_SGRBG8_1X8: + case MEDIA_BUS_FMT_SGBRG8_1X8: + case MEDIA_BUS_FMT_SBGGR8_1X8: + default: + return 8; + + case MEDIA_BUS_FMT_Y10_1X10: + case MEDIA_BUS_FMT_SRGGB10_1X10: + case MEDIA_BUS_FMT_SGRBG10_1X10: + case MEDIA_BUS_FMT_SGBRG10_1X10: + case MEDIA_BUS_FMT_SBGGR10_1X10: + return 10; + } +} + +static unsigned int vd55g1_get_fmt_data_type(u32 code) +{ + switch (code) { + case MEDIA_BUS_FMT_Y8_1X8: + case MEDIA_BUS_FMT_SRGGB8_1X8: + case MEDIA_BUS_FMT_SGRBG8_1X8: + case MEDIA_BUS_FMT_SGBRG8_1X8: + case MEDIA_BUS_FMT_SBGGR8_1X8: + default: + return MIPI_CSI2_DT_RAW8; + + case MEDIA_BUS_FMT_Y10_1X10: + case MEDIA_BUS_FMT_SRGGB10_1X10: + case MEDIA_BUS_FMT_SGRBG10_1X10: + case MEDIA_BUS_FMT_SGBRG10_1X10: + case MEDIA_BUS_FMT_SBGGR10_1X10: + return MIPI_CSI2_DT_RAW10; + } +} + +static u32 vd55g1_get_fmt_code(struct vd55g1 *sensor, u32 code) +{ + unsigned int i, j; - for (i = 0; i < ARRAY_SIZE(vd55g1_mbus_codes); i++) { - if (vd55g1_mbus_codes[i].code == code) - return &vd55g1_mbus_codes[i]; + if (sensor->id == VD55G1_MODEL_ID_VD55G1) + return code; + + for (i = 0; i < ARRAY_SIZE(vd55g1_mbus_formats_bayer); i++) { + for (j = 0; j < ARRAY_SIZE(vd55g1_mbus_formats_bayer[i]); j++) { + if (vd55g1_mbus_formats_bayer[i][j] == code) + goto adapt_bayer_pattern; + } } + dev_warn(sensor->dev, "Unsupported mbus format\n"); - /* Should never happen */ - dev_warn(sensor->dev, "Unsupported code %d. default to 8 bpp\n", code); + return code; + +adapt_bayer_pattern: + j = 0; + /* In first init_state() call, controls might not be initialized yet */ + if (sensor->hflip_ctrl && sensor->vflip_ctrl) { + j = (sensor->hflip_ctrl->val ? 1 : 0) + + (sensor->vflip_ctrl->val ? 2 : 0); + } - return &vd55g1_mbus_codes[0]; + return vd55g1_mbus_formats_bayer[i][j]; } static s32 vd55g1_get_pixel_rate(struct vd55g1 *sensor, struct v4l2_mbus_framefmt *format) { - return sensor->mipi_rate / - vd55g1_get_fmt_desc(sensor, format->code)->bpp; + return sensor->mipi_rate / vd55g1_get_fmt_bpp(format->code); } static unsigned int vd55g1_get_hblank_min(struct vd55g1 *sensor, @@ -605,7 +665,7 @@ static unsigned int vd55g1_get_hblank_min(struct vd55g1 *sensor, /* MIPI required time */ mipi_req_line_time = (crop->width * - vd55g1_get_fmt_desc(sensor, format->code)->bpp + + vd55g1_get_fmt_bpp(format->code) + VD55G1_MIPI_MARGIN) / (sensor->mipi_rate / MEGA); mipi_req_line_length = mipi_req_line_time * sensor->pixel_clock / @@ -887,7 +947,7 @@ static void vd55g1_update_pad_fmt(struct vd55g1 *sensor, const struct vd55g1_mode *mode, u32 code, struct v4l2_mbus_framefmt *fmt) { - fmt->code = code; + fmt->code = vd55g1_get_fmt_code(sensor, code); fmt->width = mode->width; fmt->height = mode->height; fmt->colorspace = V4L2_COLORSPACE_RAW; @@ -951,10 +1011,9 @@ static int vd55g1_set_framefmt(struct vd55g1 *sensor, int ret = 0; vd55g1_write(sensor, VD55G1_REG_FORMAT_CTRL, - vd55g1_get_fmt_desc(sensor, format->code)->bpp, &ret); + vd55g1_get_fmt_bpp(format->code), &ret); vd55g1_write(sensor, VD55G1_REG_OIF_IMG_CTRL, - vd55g1_get_fmt_desc(sensor, format->code)->data_type, - &ret); + vd55g1_get_fmt_data_type(format->code), &ret); switch (crop->width / format->width) { case 1: @@ -1114,26 +1173,45 @@ static int vd55g1_patch(struct vd55g1 *sensor) u64 patch; int ret = 0; - vd55g1_write_array(sensor, VD55G1_REG_FWPATCH_START_ADDR, - sizeof(patch_array), patch_array, &ret); - vd55g1_write(sensor, VD55G1_REG_BOOT, VD55G1_BOOT_PATCH_SETUP, &ret); - vd55g1_poll_reg(sensor, VD55G1_REG_BOOT, 0, &ret); - if (ret) { - dev_err(sensor->dev, "Failed to apply patch\n"); - return ret; - } + /* vd55g1 needs a patch while vd65g4 does not */ + if (sensor->id == VD55G1_MODEL_ID_VD55G1) { + vd55g1_write_array(sensor, VD55G1_REG_FWPATCH_START_ADDR, + sizeof(vd55g1_patch_array), + vd55g1_patch_array, &ret); + vd55g1_write(sensor, VD55G1_REG_BOOT, + VD55G1_BOOT_PATCH_AND_BOOT, &ret); + vd55g1_poll_reg(sensor, VD55G1_REG_BOOT, 0, &ret); + if (ret) { + dev_err(sensor->dev, "Failed to apply patch\n"); + return ret; + } - vd55g1_read(sensor, VD55G1_REG_FWPATCH_REVISION, &patch, &ret); - if (patch != (VD55G1_FWPATCH_REVISION_MAJOR << 8) + - VD55G1_FWPATCH_REVISION_MINOR) { - dev_err(sensor->dev, "Bad patch version expected %d.%d got %d.%d\n", - VD55G1_FWPATCH_REVISION_MAJOR, - VD55G1_FWPATCH_REVISION_MINOR, + vd55g1_read(sensor, VD55G1_REG_FWPATCH_REVISION, &patch, &ret); + if (patch != (VD55G1_FWPATCH_REVISION_MAJOR << 8) + + VD55G1_FWPATCH_REVISION_MINOR) { + dev_err(sensor->dev, "Bad patch version expected %d.%d got %d.%d\n", + VD55G1_FWPATCH_REVISION_MAJOR, + VD55G1_FWPATCH_REVISION_MINOR, + (u8)(patch >> 8), (u8)(patch & 0xff)); + return -ENODEV; + } + dev_dbg(sensor->dev, "patch %d.%d applied\n", (u8)(patch >> 8), (u8)(patch & 0xff)); - return -ENODEV; + + } else { + vd55g1_write(sensor, VD55G1_REG_BOOT, VD55G1_BOOT_BOOT, &ret); + vd55g1_poll_reg(sensor, VD55G1_REG_BOOT, 0, &ret); + if (ret) { + dev_err(sensor->dev, "Failed to boot\n"); + return ret; + } + } + + ret = vd55g1_wait_state(sensor, VD55G1_SYSTEM_FSM_SW_STBY, NULL); + if (ret) { + dev_err(sensor->dev, "Sensor waiting after boot failed\n"); + return ret; } - dev_dbg(sensor->dev, "patch %d.%d applied\n", - (u8)(patch >> 8), (u8)(patch & 0xff)); return 0; } @@ -1165,10 +1243,19 @@ static int vd55g1_enum_mbus_code(struct v4l2_subdev *sd, struct v4l2_subdev_state *sd_state, struct v4l2_subdev_mbus_code_enum *code) { - if (code->index >= ARRAY_SIZE(vd55g1_mbus_codes)) - return -EINVAL; + struct vd55g1 *sensor = to_vd55g1(sd); + u32 base_code; - code->code = vd55g1_mbus_codes[code->index].code; + if (sensor->id == VD55G1_MODEL_ID_VD55G1) { + if (code->index >= ARRAY_SIZE(vd55g1_mbus_formats_mono)) + return -EINVAL; + base_code = vd55g1_mbus_formats_mono[code->index]; + } else { + if (code->index >= ARRAY_SIZE(vd55g1_mbus_formats_bayer)) + return -EINVAL; + base_code = vd55g1_mbus_formats_bayer[code->index][0]; + } + code->code = vd55g1_get_fmt_code(sensor, base_code); return 0; } @@ -1275,7 +1362,7 @@ static int vd55g1_init_state(struct v4l2_subdev *sd, return ret; vd55g1_update_pad_fmt(sensor, &vd55g1_supported_modes[VD55G1_MODE_DEF], - vd55g1_mbus_codes[VD55G1_MBUS_CODE_DEF].code, + vd55g1_get_fmt_code(sensor, VD55G1_MBUS_CODE_DEF), &fmt.format); return vd55g1_set_pad_fmt(sd, sd_state, &fmt); @@ -1285,9 +1372,16 @@ static int vd55g1_enum_frame_size(struct v4l2_subdev *sd, struct v4l2_subdev_state *sd_state, struct v4l2_subdev_frame_size_enum *fse) { + struct vd55g1 *sensor = to_vd55g1(sd); + u32 code; + if (fse->index >= ARRAY_SIZE(vd55g1_supported_modes)) return -EINVAL; + code = vd55g1_get_fmt_code(sensor, fse->code); + if (fse->code != code) + return -EINVAL; + fse->min_width = vd55g1_supported_modes[fse->index].width; fse->max_width = fse->min_width; fse->min_height = vd55g1_supported_modes[fse->index].height; @@ -1463,8 +1557,12 @@ static int vd55g1_init_ctrls(struct vd55g1 *sensor) /* Flip cluster */ sensor->hflip_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_HFLIP, 0, 1, 1, 0); + if (sensor->hflip_ctrl) + sensor->hflip_ctrl->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT; sensor->vflip_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_VFLIP, 0, 1, 1, 0); + if (sensor->vflip_ctrl) + sensor->vflip_ctrl->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT; v4l2_ctrl_cluster(2, &sensor->hflip_ctrl); /* Exposition cluster */ @@ -1548,26 +1646,34 @@ static int vd55g1_init_ctrls(struct vd55g1 *sensor) static int vd55g1_detect(struct vd55g1 *sensor) { - u64 device_rev; - u64 id; + unsigned int dt_id = (uintptr_t)device_get_match_data(sensor->dev); + u64 rev, id; int ret; ret = vd55g1_read(sensor, VD55G1_REG_MODEL_ID, &id, NULL); if (ret) return ret; - if (id != VD55G1_MODEL_ID) { - dev_warn(sensor->dev, "Unsupported sensor id %x\n", (u32)id); + if (id != VD55G1_MODEL_ID_VD55G1 && id != VD55G1_MODEL_ID_VD65G4) { + dev_warn(sensor->dev, "Unsupported sensor id 0x%x\n", + (u32)id); + return -ENODEV; + } + if (id != dt_id) { + dev_err(sensor->dev, "Probed sensor %s and device tree definition (%s) mismatch", + VD55G1_MODEL_ID_NAME(id), VD55G1_MODEL_ID_NAME(dt_id)); return -ENODEV; } + sensor->id = id; - ret = vd55g1_read(sensor, VD55G1_REG_REVISION, &device_rev, NULL); + ret = vd55g1_read(sensor, VD55G1_REG_REVISION, &rev, NULL); if (ret) return ret; - if (device_rev != VD55G1_REVISION_CCB) { - dev_err(sensor->dev, "Unsupported sensor revision (0x%x)\n", - (u16)device_rev); + if ((id == VD55G1_MODEL_ID_VD55G1 && rev != VD55G1_REVISION_CCB) && + (id == VD55G1_MODEL_ID_VD65G4 && rev != VD55G1_REVISION_BAYER)) { + dev_err(sensor->dev, "Unsupported sensor revision 0x%x for sensor %s\n", + (u16)rev, VD55G1_MODEL_ID_NAME(id)); return -ENODEV; } @@ -1616,13 +1722,6 @@ static int vd55g1_power_on(struct device *dev) goto disable_clock; } - ret = vd55g1_wait_state(sensor, VD55G1_SYSTEM_FSM_SW_STBY, NULL); - if (ret) { - dev_err(dev, "Sensor waiting after patch failed %d\n", - ret); - goto disable_clock; - } - return 0; disable_clock: @@ -1934,7 +2033,8 @@ static void vd55g1_remove(struct i2c_client *client) } static const struct of_device_id vd55g1_dt_ids[] = { - { .compatible = "st,vd55g1" }, + { .compatible = "st,vd55g1", .data = (void *)VD55G1_MODEL_ID_VD55G1 }, + { .compatible = "st,vd65g4", .data = (void *)VD55G1_MODEL_ID_VD65G4 }, { /* sentinel */ } }; MODULE_DEVICE_TABLE(of, vd55g1_dt_ids); From c731f17fcd23d96b2f62b6e99e82c58fbbdcaaf9 Mon Sep 17 00:00:00 2001 From: Peter Marshall Date: Sat, 1 Aug 2026 18:56:40 -0400 Subject: [PATCH 03/10] media: i2c: vd55g: move patch array to a separate firmware header A firmware patch consisting of an array of bytes is uploaded to the chip during its boot sequence. Declutter the driver source by moving it to a separate header file. --- drivers/media/i2c/vd55g-fw.h | 305 +++++++++++++++++++++++++++++++++++ drivers/media/i2c/vd55g1.c | 296 +-------------------------------- 2 files changed, 306 insertions(+), 295 deletions(-) create mode 100644 drivers/media/i2c/vd55g-fw.h diff --git a/drivers/media/i2c/vd55g-fw.h b/drivers/media/i2c/vd55g-fw.h new file mode 100644 index 0000000000000..bc41a57bbe978 --- /dev/null +++ b/drivers/media/i2c/vd55g-fw.h @@ -0,0 +1,305 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Driver for VD55G1 global shutter sensor family driver + * + * Copyright (C) 2025 STMicroelectronics SA + */ + +#include +#include + +static const u8 vd55g1_patch_array[] = { + 0x44, 0x03, 0x09, 0x02, 0xe6, 0x01, 0x42, 0x00, 0xea, 0x01, 0x42, 0x00, + 0xf0, 0x01, 0x42, 0x00, 0xe6, 0x01, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0xfa, 0x68, 0x40, 0x00, 0xe8, + 0x09, 0xbe, 0x4c, 0x08, 0x00, 0xf2, 0x93, 0xdd, 0x1c, 0x00, 0xc0, 0xe2, + 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x00, 0xfa, 0x6b, 0x80, 0x98, 0x7f, + 0xfc, 0xef, 0x11, 0xc1, 0x0f, 0x82, 0x69, 0xbe, 0x0f, 0xac, 0x58, 0x40, + 0x00, 0xe8, 0x0c, 0x0c, 0x00, 0xf2, 0x93, 0xdd, 0x1c, 0x00, 0x40, 0xe3, + 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x84, 0xfa, 0x46, 0x0e, 0xe8, 0xe0, + 0x08, 0xde, 0x4a, 0x40, 0x84, 0xe0, 0xa5, 0x86, 0xa8, 0x7d, 0xfc, 0xef, + 0x6b, 0x80, 0x01, 0xbf, 0x28, 0x77, 0x0c, 0xef, 0x0b, 0x0e, 0x21, 0x78, + 0x06, 0xc0, 0x0b, 0xa5, 0xb5, 0x84, 0x06, 0x42, 0x98, 0xe1, 0x01, 0x81, + 0x01, 0x42, 0x38, 0xe0, 0x0c, 0xc4, 0x0e, 0x84, 0x46, 0x02, 0x84, 0xe0, + 0x0c, 0x84, 0x11, 0x81, 0x21, 0x81, 0x31, 0x81, 0x41, 0x81, 0x51, 0x81, + 0xc1, 0x81, 0x05, 0x83, 0x0c, 0x0c, 0x84, 0xf2, 0x93, 0xdd, 0x06, 0x40, + 0x98, 0xe1, 0xc8, 0x80, 0x58, 0x82, 0x48, 0xc0, 0x38, 0xc2, 0x29, 0x00, + 0x10, 0xe0, 0x19, 0x00, 0x14, 0xe0, 0x09, 0x00, 0x38, 0xe0, 0x5f, 0xb8, + 0x5f, 0xa8, 0x5f, 0xa6, 0x5f, 0xa4, 0x5f, 0xa2, 0x5f, 0xa0, 0x56, 0x41, + 0x98, 0xe1, 0x18, 0x82, 0x28, 0x80, 0x38, 0xc0, 0x5f, 0xa2, 0x19, 0x00, + 0x20, 0xf8, 0x5f, 0xa4, 0x28, 0xc2, 0x5f, 0xa6, 0x39, 0x00, 0x10, 0xe0, + 0x5f, 0xa2, 0x19, 0x00, 0x14, 0xe0, 0x5f, 0xa4, 0x29, 0x00, 0x18, 0xe0, + 0x5f, 0xa6, 0x39, 0x00, 0x40, 0xe0, 0x5f, 0xa2, 0x19, 0x00, 0x44, 0xe0, + 0x5f, 0xa4, 0x29, 0x00, 0x1c, 0xe0, 0x5f, 0xa6, 0x39, 0x00, 0x38, 0xe0, + 0x5f, 0xa2, 0x19, 0x00, 0x20, 0xe0, 0x5f, 0xa4, 0x29, 0x00, 0x24, 0xe0, + 0x5f, 0xa6, 0x39, 0x00, 0x28, 0xe0, 0x5f, 0xa2, 0x19, 0x00, 0x2c, 0xe0, + 0x5f, 0xa4, 0x29, 0x00, 0x30, 0xe0, 0x5f, 0xa6, 0x09, 0x00, 0x34, 0xe0, + 0x5f, 0xa2, 0x5f, 0xa4, 0x5f, 0xa0, 0x4a, 0x0a, 0xfc, 0xfb, 0xe5, 0x82, + 0x08, 0xde, 0x4a, 0x40, 0x88, 0xe0, 0xf6, 0x40, 0x00, 0xe0, 0x01, 0x4e, + 0x99, 0x78, 0x0a, 0xc0, 0x85, 0x80, 0x98, 0x40, 0x00, 0xe8, 0x35, 0x81, + 0xa8, 0x40, 0x00, 0xe8, 0x0b, 0x8c, 0x0c, 0x0c, 0x84, 0xf2, 0xd5, 0xed, + 0x83, 0xc1, 0x13, 0xc5, 0x93, 0xdd, 0xc3, 0xc1, 0x83, 0xc1, 0x13, 0xc3, + 0x93, 0xdd, 0xc3, 0xc1, 0x4c, 0x04, 0x04, 0xfa, 0xc6, 0x0f, 0x94, 0xe0, + 0x19, 0x0e, 0xc9, 0x65, 0x01, 0xc0, 0x28, 0xde, 0x0a, 0x42, 0x80, 0xe0, + 0x24, 0x02, 0x00, 0xfc, 0x16, 0xde, 0xa5, 0x8a, 0x19, 0x00, 0xb8, 0xe0, + 0x10, 0x02, 0x0c, 0xec, 0x1d, 0xe6, 0x14, 0x02, 0x88, 0x80, 0x4e, 0x04, + 0x01, 0x00, 0x10, 0x80, 0x25, 0x02, 0x08, 0x9c, 0x86, 0x02, 0x00, 0x80, + 0x08, 0x44, 0x00, 0x98, 0x55, 0x81, 0x11, 0x85, 0x45, 0x81, 0x11, 0x89, + 0x25, 0x81, 0x11, 0x83, 0x2b, 0x00, 0x24, 0xe0, 0x64, 0xc2, 0x0b, 0x84, + 0x08, 0x51, 0x00, 0xef, 0x2b, 0x80, 0x01, 0x83, 0x1b, 0x8c, 0x38, 0x7d, + 0x5c, 0xef, 0x18, 0xde, 0x0b, 0xa1, 0x25, 0x82, 0x0b, 0x0e, 0x88, 0xf9, + 0x0a, 0x00, 0x00, 0xe8, 0x10, 0x42, 0x04, 0x9c, 0x11, 0x4e, 0x0c, 0x80, + 0x10, 0x40, 0x04, 0xf0, 0x4e, 0x05, 0x01, 0x60, 0x10, 0xc0, 0x06, 0x88, + 0x10, 0x40, 0xf8, 0xf3, 0x06, 0xde, 0x4c, 0x0c, 0x04, 0xf2, 0x93, 0xdd, + 0x0c, 0x04, 0x1c, 0xfe, 0xf6, 0x0f, 0x94, 0xe0, 0x38, 0x9c, 0x46, 0x51, + 0xfc, 0xe0, 0x46, 0x49, 0x38, 0xe2, 0x30, 0x46, 0xf8, 0xf3, 0x36, 0x9c, + 0xc6, 0x46, 0x0c, 0xe1, 0x34, 0x8c, 0x94, 0xa0, 0x4e, 0xa0, 0x39, 0x06, + 0x80, 0xe0, 0x4a, 0x46, 0x94, 0xe0, 0x05, 0x8c, 0x6a, 0x40, 0x80, 0xe0, + 0x2c, 0x0c, 0x00, 0xe2, 0x0b, 0x8c, 0xb8, 0x7c, 0x5c, 0xef, 0x0b, 0x8c, + 0x9e, 0xa0, 0xf8, 0x40, 0x60, 0xef, 0x0b, 0xa1, 0x5a, 0x40, 0x80, 0xe0, + 0x65, 0x88, 0x28, 0x02, 0x01, 0x40, 0x00, 0x80, 0x2a, 0x42, 0x9c, 0xe1, + 0x28, 0x49, 0x60, 0xef, 0x96, 0x4d, 0x9c, 0xe1, 0x01, 0x81, 0x06, 0x98, + 0xd5, 0x81, 0x09, 0x0e, 0xa1, 0x64, 0x01, 0xc0, 0x4a, 0x40, 0x88, 0xe0, + 0x85, 0x80, 0xb8, 0x77, 0xfc, 0xef, 0x35, 0x81, 0xc8, 0x77, 0xfc, 0xef, + 0x08, 0x98, 0x4a, 0x00, 0xfc, 0xfb, 0x55, 0xfc, 0xe8, 0x4a, 0x60, 0xef, + 0x1a, 0x44, 0x9c, 0xe1, 0x35, 0x81, 0x1a, 0x4e, 0x9c, 0xe9, 0x1c, 0x00, + 0x00, 0xe2, 0x0c, 0x0c, 0x1c, 0xf6, 0x93, 0xdd, 0x0d, 0xc3, 0x1a, 0x41, + 0x08, 0xe4, 0x0a, 0x40, 0x84, 0xe1, 0x0c, 0x00, 0x00, 0xe2, 0x93, 0xdd, + 0x4c, 0x04, 0x1c, 0xfa, 0x86, 0x52, 0xec, 0xe1, 0x08, 0xa6, 0x65, 0x12, + 0x24, 0xf8, 0x0e, 0x02, 0x99, 0x7a, 0x00, 0xc0, 0x00, 0x40, 0xa0, 0xf3, + 0x06, 0xa6, 0x0b, 0x8c, 0x08, 0x49, 0x00, 0xef, 0x85, 0x12, 0x28, 0xf8, + 0x02, 0x02, 0xfc, 0xed, 0xf6, 0x47, 0xfd, 0x6f, 0xe0, 0xff, 0x04, 0xe2, + 0x14, 0x04, 0xc0, 0xe0, 0x0f, 0x86, 0x2f, 0xa0, 0x0b, 0x8c, 0x2e, 0xe2, + 0x08, 0x48, 0x00, 0xef, 0x86, 0x02, 0x84, 0xfe, 0x0e, 0x05, 0x09, 0x7d, + 0x00, 0xc0, 0x05, 0x52, 0x08, 0xf8, 0x18, 0x7d, 0xfc, 0xef, 0x4a, 0x40, + 0x80, 0xe0, 0x09, 0x12, 0x04, 0xc0, 0x65, 0x12, 0x20, 0xf8, 0x00, 0x40, + 0x40, 0xdc, 0x01, 0x52, 0x04, 0xc0, 0x0e, 0x00, 0x41, 0x78, 0xf5, 0xc5, + 0x6d, 0xc0, 0xb5, 0x82, 0x05, 0x10, 0x10, 0xe0, 0x11, 0xf1, 0x0f, 0x82, + 0x05, 0x50, 0x10, 0xe0, 0x05, 0x10, 0x10, 0xe0, 0xfe, 0x02, 0xf0, 0xff, + 0x0f, 0x82, 0x85, 0x83, 0x15, 0x10, 0x10, 0xe0, 0x16, 0x00, 0x91, 0x6e, + 0x69, 0xcd, 0x21, 0xf1, 0x6d, 0xc1, 0x01, 0x83, 0x2f, 0x82, 0x26, 0x00, + 0x00, 0x80, 0x2f, 0xa0, 0x25, 0x50, 0x10, 0xe0, 0x05, 0x10, 0x10, 0xe0, + 0x11, 0xa1, 0xfe, 0x04, 0xf0, 0xff, 0x06, 0x42, 0x00, 0x80, 0x0f, 0x84, + 0x0f, 0xa2, 0x05, 0x50, 0x10, 0xe0, 0x16, 0x00, 0x91, 0x6e, 0x69, 0xcd, + 0x6d, 0xc1, 0x71, 0x8d, 0x16, 0x00, 0x79, 0x61, 0x2d, 0xcb, 0x86, 0x0e, + 0x00, 0x80, 0x6d, 0xc1, 0x56, 0x0e, 0x00, 0xc0, 0x0b, 0x8c, 0x1b, 0x8e, + 0x71, 0x52, 0x0c, 0xf8, 0x08, 0x43, 0x00, 0xef, 0x05, 0x52, 0x14, 0xf8, + 0x15, 0x10, 0x28, 0xe0, 0x70, 0x04, 0x04, 0xec, 0x31, 0xe1, 0x29, 0x9e, + 0x1f, 0x86, 0x1f, 0xa4, 0x15, 0x50, 0x28, 0xe0, 0x86, 0x42, 0x3c, 0xe0, + 0x0e, 0x04, 0x9d, 0x64, 0x9b, 0xc2, 0x05, 0x52, 0x1c, 0xf8, 0x78, 0xa6, + 0x48, 0x77, 0xfc, 0xef, 0x4a, 0x40, 0x80, 0xe0, 0x70, 0x4e, 0x10, 0xdc, + 0x1e, 0x00, 0x81, 0x70, 0xeb, 0xcb, 0x70, 0x4e, 0xec, 0x93, 0x6d, 0xc1, + 0x11, 0x85, 0x36, 0x02, 0x00, 0x80, 0x76, 0xa6, 0x11, 0x52, 0x10, 0xf8, + 0x05, 0x10, 0x40, 0xe0, 0xfe, 0x47, 0x0c, 0xff, 0x14, 0x04, 0xa0, 0xe0, + 0x0f, 0x86, 0x0f, 0xa4, 0x05, 0x50, 0x40, 0xe0, 0x05, 0x10, 0x28, 0xe0, + 0xfe, 0x47, 0xfd, 0x7f, 0xe3, 0xff, 0x14, 0x04, 0xd0, 0xe0, 0x0f, 0x86, + 0x2f, 0xa0, 0x20, 0x00, 0x01, 0x6c, 0x00, 0xd0, 0x05, 0x50, 0x28, 0xe0, + 0x0b, 0x8c, 0xf8, 0x7e, 0xfc, 0xee, 0x0e, 0x03, 0x59, 0x78, 0xf5, 0xc5, + 0x0d, 0xc2, 0x05, 0x52, 0x0c, 0xf8, 0x08, 0xa6, 0x46, 0x42, 0xb4, 0xe0, + 0x18, 0x84, 0x00, 0x40, 0xf4, 0x93, 0x00, 0x40, 0x08, 0xdc, 0x1b, 0xa1, + 0x06, 0xa6, 0x05, 0x10, 0x40, 0x80, 0x04, 0x00, 0x50, 0x9c, 0x65, 0x8a, + 0x05, 0x10, 0x44, 0xe0, 0xf6, 0x43, 0xfd, 0x6f, 0x00, 0xf8, 0x0f, 0x82, + 0x06, 0x02, 0x01, 0x60, 0x1e, 0xc0, 0x0f, 0xa2, 0x05, 0x50, 0x44, 0xe0, + 0x05, 0x10, 0x44, 0xe0, 0x0e, 0x02, 0x00, 0xf8, 0x0f, 0x82, 0x09, 0xf6, + 0x05, 0x50, 0x44, 0xe0, 0x05, 0x10, 0x40, 0xe0, 0x04, 0x00, 0x54, 0xfc, + 0x05, 0x50, 0x40, 0xe0, 0x05, 0x10, 0x40, 0xe0, 0x04, 0x00, 0xcc, 0xfc, + 0x05, 0x50, 0x40, 0xe0, 0x05, 0x10, 0x40, 0xe0, 0x04, 0x00, 0x4c, 0xfc, + 0x05, 0x50, 0x40, 0xe0, 0x05, 0x10, 0x40, 0xe0, 0x04, 0x00, 0xd0, 0xfc, + 0x05, 0x50, 0x40, 0xe0, 0x4c, 0x0c, 0x1c, 0xf2, 0x93, 0xdd, 0xc3, 0xc1, + 0xc6, 0x40, 0xfc, 0xe0, 0x04, 0x80, 0xc6, 0x44, 0x0c, 0xe1, 0x15, 0x04, + 0x0c, 0xf8, 0x0a, 0x80, 0x06, 0x07, 0x04, 0xe0, 0x03, 0x42, 0x48, 0xe1, + 0x46, 0x02, 0x40, 0xe2, 0x08, 0xc6, 0x44, 0x88, 0x06, 0x46, 0x0e, 0xe0, + 0x86, 0x01, 0x84, 0xe0, 0x33, 0x80, 0x39, 0x06, 0xd8, 0xef, 0x0a, 0x46, + 0x80, 0xe0, 0x31, 0xbf, 0x06, 0x06, 0x00, 0xc0, 0x31, 0x48, 0x60, 0xe0, + 0x34, 0x88, 0x49, 0x06, 0x40, 0xe1, 0x40, 0x48, 0x7c, 0xf3, 0x41, 0x46, + 0x40, 0xe1, 0x24, 0x8a, 0x39, 0x04, 0x10, 0xe0, 0x39, 0xc2, 0x31, 0x44, + 0x10, 0xe0, 0x14, 0xc4, 0x1b, 0xa5, 0x11, 0x83, 0x11, 0x40, 0x25, 0x6a, + 0x01, 0xc0, 0x08, 0x5c, 0x00, 0xda, 0x15, 0x00, 0xcc, 0xe0, 0x25, 0x00, + 0xf8, 0xe0, 0x1b, 0x85, 0x08, 0x5c, 0x00, 0x9a, 0x4e, 0x03, 0x01, 0x60, + 0x10, 0xc0, 0x29, 0x00, 0x1c, 0xe4, 0x18, 0x84, 0x20, 0x44, 0xf8, 0xf3, + 0x2f, 0xa2, 0x21, 0x40, 0x1c, 0xe4, 0x93, 0xdd, 0x0c, 0x00, 0x80, 0xfa, + 0x15, 0x00, 0x3c, 0xe0, 0x21, 0x81, 0x31, 0x85, 0x21, 0x42, 0x60, 0xe0, + 0x15, 0x00, 0x44, 0xe0, 0x31, 0x42, 0x40, 0xe1, 0x15, 0x00, 0x34, 0xe0, + 0x21, 0x42, 0x20, 0xe0, 0x15, 0x00, 0x34, 0xe0, 0xd6, 0x04, 0x10, 0xe0, + 0x23, 0x42, 0x30, 0xe0, 0x15, 0x00, 0x34, 0xe0, 0x86, 0x44, 0x04, 0xe0, + 0x23, 0x42, 0x38, 0xe0, 0x05, 0x00, 0x30, 0xe0, 0xc6, 0x02, 0x08, 0xe0, + 0x13, 0x40, 0x10, 0xe3, 0xe8, 0x56, 0x40, 0xef, 0x06, 0x40, 0x0c, 0xe1, + 0x04, 0x80, 0x06, 0x02, 0x94, 0xe0, 0x2b, 0x02, 0xc4, 0xea, 0x3b, 0x00, + 0x78, 0xe2, 0x20, 0x44, 0xfd, 0x73, 0x07, 0xc0, 0x30, 0x46, 0x01, 0x70, + 0xf8, 0xc0, 0x3f, 0xa4, 0x33, 0x40, 0x78, 0xe2, 0x0a, 0x84, 0x0c, 0x08, + 0x80, 0xf2, 0xf8, 0x3b, 0x3c, 0xff, 0xc3, 0xc1, 0x06, 0x40, 0x0c, 0xe1, + 0x04, 0x80, 0x1b, 0x00, 0x40, 0xe4, 0x19, 0xc2, 0x13, 0x40, 0x40, 0xe4, + 0x1b, 0x00, 0x40, 0xe4, 0x19, 0xc4, 0x13, 0x40, 0x40, 0xe4, 0x93, 0xdd, + 0xc6, 0x43, 0xec, 0xe0, 0x46, 0x41, 0xfc, 0xe0, 0x24, 0x84, 0x04, 0x80, + 0x31, 0x81, 0x4a, 0x44, 0x80, 0xe0, 0x86, 0x44, 0x0c, 0xe1, 0x09, 0x00, + 0x6c, 0xe0, 0xc4, 0x8a, 0x8e, 0x47, 0xfc, 0x9f, 0x01, 0x42, 0x51, 0x78, + 0x0c, 0xc0, 0x31, 0x58, 0x90, 0xe0, 0x34, 0x8a, 0x41, 0xbf, 0x06, 0x08, + 0x00, 0xc0, 0x41, 0x46, 0xa0, 0xe0, 0x34, 0x8a, 0x51, 0x81, 0xf6, 0x0b, + 0x00, 0xc0, 0x51, 0x46, 0xd0, 0xe0, 0x34, 0x8a, 0x01, 0xbf, 0x51, 0x46, + 0xe0, 0xe0, 0x44, 0x84, 0x0a, 0x48, 0x84, 0xe0, 0x75, 0x86, 0x54, 0xca, + 0x49, 0x88, 0x44, 0x06, 0x88, 0xe1, 0x36, 0x94, 0x4a, 0x46, 0x80, 0xe0, + 0x34, 0xca, 0x47, 0xc6, 0x11, 0x8d, 0x41, 0x46, 0xd0, 0xe0, 0x34, 0x88, + 0x76, 0x02, 0x00, 0xc0, 0x06, 0x00, 0x00, 0xc0, 0x16, 0x8c, 0x14, 0x88, + 0x01, 0x42, 0xc0, 0xe1, 0x01, 0x42, 0xe0, 0xe1, 0x01, 0x42, 0xf0, 0xe1, + 0x93, 0xdd, 0x34, 0xca, 0x41, 0x85, 0x46, 0x8c, 0x34, 0xca, 0x06, 0x48, + 0x00, 0xe0, 0x41, 0x46, 0xd0, 0xe0, 0x34, 0x88, 0x41, 0x83, 0x46, 0x8c, + 0x34, 0x88, 0x01, 0x46, 0xc0, 0xe1, 0x01, 0x46, 0xe0, 0xe1, 0x01, 0x46, + 0xf0, 0xe1, 0x09, 0x02, 0x20, 0xe0, 0x14, 0xca, 0x03, 0x42, 0x58, 0xe0, + 0x93, 0xdd, 0xc3, 0xc1, 0x4c, 0x04, 0x04, 0xfa, 0x46, 0x4e, 0x08, 0xe1, + 0x06, 0x4c, 0x0c, 0xe1, 0x0a, 0x9e, 0x14, 0x98, 0x05, 0x42, 0x44, 0xe0, + 0x10, 0x00, 0xe1, 0x65, 0x03, 0xc0, 0x78, 0x41, 0x00, 0xe8, 0x08, 0x9c, + 0x0b, 0xa1, 0x04, 0x98, 0x06, 0x02, 0x10, 0x80, 0x13, 0x40, 0xf8, 0x86, + 0x65, 0x82, 0x00, 0x00, 0xe1, 0x65, 0x03, 0xc0, 0xa8, 0x40, 0x00, 0xe8, + 0x14, 0x98, 0x04, 0x00, 0xa0, 0xfc, 0x03, 0x42, 0x00, 0xe7, 0x4c, 0x0c, + 0x04, 0xf2, 0x93, 0xdd, 0x0a, 0x80, 0x93, 0xdd, 0x0c, 0x04, 0x00, 0xfa, + 0x06, 0x02, 0xec, 0xe1, 0x64, 0x84, 0x15, 0x0c, 0x2c, 0xe0, 0x14, 0x02, + 0xa0, 0xfc, 0x15, 0x4c, 0x2c, 0xe0, 0xd8, 0x40, 0x00, 0xe8, 0x14, 0xd8, + 0x09, 0x82, 0x14, 0x02, 0x00, 0xfc, 0x1f, 0xa0, 0x1e, 0xd8, 0x01, 0x85, + 0x0c, 0x0c, 0x00, 0xf2, 0xe8, 0x32, 0x2c, 0xff, 0x93, 0xdd, 0xc3, 0xc1, + 0x0c, 0x04, 0x00, 0xfa, 0x6b, 0x80, 0xf6, 0x01, 0x94, 0xe0, 0x08, 0x80, + 0x4a, 0x40, 0x80, 0xe0, 0x45, 0x86, 0x06, 0x40, 0x0c, 0xe1, 0x04, 0x80, + 0xc6, 0x02, 0x40, 0xe2, 0x09, 0x00, 0xd0, 0xe0, 0x14, 0x84, 0x1b, 0xa5, + 0x15, 0x84, 0x07, 0xc5, 0x09, 0x82, 0x18, 0x41, 0x00, 0xe8, 0x46, 0x43, + 0xfc, 0xe0, 0x14, 0x84, 0x19, 0x02, 0xd8, 0xe0, 0x19, 0x82, 0x0b, 0x83, + 0x16, 0x00, 0x00, 0xc0, 0x01, 0x4c, 0x00, 0xc0, 0x0c, 0x0c, 0x00, 0xf2, + 0x93, 0xdd, 0xc3, 0xc1, 0x4a, 0x00, 0x00, 0xe0, 0x0c, 0x00, 0x00, 0xe2, + 0x93, 0xdd, 0xc3, 0xc1, 0x46, 0x40, 0x84, 0xe0, 0x11, 0xaf, 0x13, 0x40, + 0x6c, 0xec, 0x11, 0xb3, 0x13, 0x40, 0x70, 0xec, 0xc6, 0x43, 0xf0, 0xe0, + 0x13, 0x40, 0xdc, 0xec, 0xc6, 0x02, 0x24, 0xe0, 0x1c, 0x80, 0x93, 0xdd, + 0x4c, 0x00, 0x00, 0xfa, 0xc8, 0x60, 0x7c, 0xef, 0xe8, 0x61, 0x7c, 0xef, + 0x28, 0x7e, 0x80, 0xef, 0xc6, 0x40, 0x98, 0xe1, 0x11, 0x83, 0x16, 0x80, + 0x46, 0x01, 0x10, 0xe1, 0x11, 0x81, 0x16, 0x80, 0x4c, 0x08, 0x00, 0xf2, + 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x0c, 0xfa, 0x6b, 0x80, 0x04, 0x98, + 0x7b, 0x82, 0x56, 0x42, 0xb4, 0xe0, 0x88, 0x84, 0x05, 0x00, 0x10, 0xe0, + 0x09, 0x86, 0x0b, 0xa5, 0x46, 0x02, 0x00, 0x80, 0x06, 0x05, 0x00, 0x80, + 0x25, 0x82, 0x0b, 0xa3, 0xa5, 0x80, 0x0b, 0xa1, 0x06, 0x00, 0xf4, 0xef, + 0xd5, 0x84, 0x11, 0x85, 0x21, 0x91, 0x0b, 0x8e, 0x88, 0x74, 0x10, 0xef, + 0x0b, 0xa1, 0xf5, 0x82, 0x0a, 0x9e, 0x1a, 0x9c, 0x24, 0x98, 0x07, 0xe0, + 0x0f, 0xa2, 0x0e, 0xca, 0x0a, 0xde, 0x1a, 0xdc, 0x24, 0x98, 0x03, 0xb0, + 0x07, 0xe0, 0x0f, 0xa2, 0x0e, 0xc8, 0x01, 0x81, 0x0c, 0x0c, 0x0c, 0xf2, + 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x7c, 0xfa, 0x46, 0x42, 0x9c, 0xe0, + 0x0b, 0x02, 0x04, 0xe3, 0xf0, 0x1e, 0x30, 0xec, 0x0b, 0xa3, 0x35, 0x96, + 0x8e, 0x01, 0x01, 0x60, 0x10, 0xc0, 0x0e, 0xfc, 0xc6, 0x05, 0xd0, 0xe1, + 0x0b, 0x82, 0x31, 0x81, 0x10, 0x16, 0x00, 0xe5, 0x20, 0x10, 0x20, 0xe7, + 0x0e, 0xbe, 0xb5, 0x85, 0x94, 0xfc, 0xa4, 0xbe, 0x82, 0x4c, 0x9c, 0xf0, + 0x05, 0x0c, 0x40, 0xe0, 0x11, 0x89, 0x93, 0x8e, 0xa3, 0x8e, 0x58, 0x44, + 0x00, 0xe8, 0x15, 0x0c, 0xc0, 0xf8, 0x04, 0x0c, 0x80, 0xfb, 0x0c, 0xed, + 0x0b, 0x82, 0x1b, 0x8c, 0x48, 0x44, 0x00, 0xe8, 0x15, 0x10, 0x1c, 0xfc, + 0x0e, 0xa8, 0x0b, 0x82, 0x1b, 0x8c, 0xd8, 0x43, 0x00, 0xe8, 0x71, 0x88, + 0x0e, 0xa4, 0x0a, 0x0e, 0x40, 0xe0, 0x35, 0xf8, 0x04, 0xbe, 0x14, 0xbc, + 0x81, 0xa0, 0x03, 0x8e, 0x0e, 0xbe, 0x04, 0xfc, 0x11, 0x82, 0x3b, 0x82, + 0x03, 0x8e, 0x0e, 0xfc, 0x3b, 0xa9, 0x06, 0x0e, 0x00, 0xc0, 0x35, 0x5e, + 0x00, 0xc0, 0xd5, 0xfa, 0xc6, 0x01, 0xd0, 0xe1, 0x7b, 0x80, 0x04, 0x9e, + 0x11, 0x91, 0x98, 0x41, 0x00, 0xe8, 0x24, 0x9c, 0x46, 0x42, 0x9c, 0xe0, + 0x6b, 0x82, 0x03, 0x4c, 0xc4, 0xe0, 0x11, 0x91, 0x0b, 0x84, 0xf8, 0x40, + 0x00, 0xe8, 0x19, 0x0e, 0x20, 0xe5, 0x03, 0x4c, 0xc0, 0xe0, 0x0b, 0x82, + 0x08, 0x72, 0xfc, 0xef, 0x01, 0x4c, 0x24, 0xf9, 0xf1, 0x98, 0x0c, 0x0c, + 0x7c, 0xf2, 0x93, 0xdd, 0x4c, 0x00, 0x00, 0xfa, 0x48, 0x65, 0x2c, 0xef, + 0x4c, 0x08, 0x00, 0xf2, 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x00, 0xfa, + 0x6b, 0x82, 0x78, 0x6e, 0xfc, 0xee, 0x46, 0x42, 0xec, 0xe0, 0x24, 0x84, + 0x24, 0x02, 0x80, 0xfa, 0x1d, 0xcc, 0x11, 0x83, 0xf5, 0x82, 0x24, 0x02, + 0xa0, 0xe1, 0x14, 0x02, 0x80, 0xfa, 0x1d, 0xcc, 0x11, 0x85, 0x15, 0x82, + 0x27, 0xe1, 0x24, 0x02, 0x80, 0xfa, 0x1d, 0xcc, 0x11, 0x89, 0x86, 0x02, + 0x00, 0x80, 0x0c, 0x0c, 0x00, 0xf2, 0x18, 0x17, 0xfc, 0xfe, 0xc3, 0xc1, + 0x0c, 0x04, 0x00, 0xfa, 0x06, 0x41, 0x8c, 0xe0, 0x1b, 0x00, 0xec, 0xe4, + 0x1b, 0xa3, 0x75, 0x84, 0x11, 0x81, 0x8e, 0x05, 0x01, 0x60, 0x10, 0xc0, + 0x00, 0x06, 0xc0, 0xe5, 0x95, 0x81, 0x44, 0x88, 0x1d, 0xee, 0x75, 0x80, + 0x4e, 0xc1, 0x25, 0x81, 0x4e, 0xcd, 0x21, 0x88, 0x11, 0x82, 0x0a, 0x02, + 0x40, 0xe0, 0xd5, 0xfc, 0x56, 0x00, 0x00, 0xe1, 0x18, 0x80, 0x1b, 0xa1, + 0xc5, 0x84, 0x08, 0x82, 0x4a, 0x00, 0xfc, 0xfb, 0x45, 0x84, 0x86, 0x4d, + 0x84, 0xe1, 0x04, 0x98, 0x05, 0x00, 0x10, 0xe0, 0x4a, 0x40, 0x80, 0xe0, + 0x45, 0x82, 0x11, 0x81, 0x0b, 0x8c, 0x58, 0x76, 0x28, 0xef, 0x0b, 0x8c, + 0x0c, 0x0c, 0x00, 0xf2, 0x88, 0x35, 0x28, 0xff, 0x0c, 0x0c, 0x00, 0xf2, + 0x93, 0xdd, 0xc3, 0xc1, 0x46, 0x41, 0xfc, 0xe0, 0x04, 0x80, 0x09, 0x00, + 0x80, 0xe0, 0x09, 0x9e, 0x0b, 0xa3, 0x75, 0x82, 0x46, 0x41, 0x80, 0xe1, + 0x04, 0x80, 0xc6, 0x42, 0x8c, 0xe0, 0x04, 0xc2, 0x00, 0x40, 0x00, 0xf2, + 0x07, 0xcf, 0x06, 0x84, 0x06, 0x40, 0x84, 0xe0, 0x15, 0x00, 0x28, 0xe5, + 0x1c, 0xc2, 0x93, 0xdd, 0x0b, 0xa1, 0xc6, 0x00, 0xa0, 0xe1, 0x15, 0x00, + 0x04, 0xf8, 0x05, 0x84, 0x21, 0x8b, 0x2c, 0x84, 0x14, 0x80, 0x2c, 0x84, + 0x14, 0x82, 0x2c, 0x84, 0x15, 0x00, 0x10, 0xe0, 0x21, 0xa1, 0x21, 0x42, + 0x10, 0xe0, 0x05, 0x00, 0x14, 0xe0, 0x01, 0x88, 0x75, 0x83, 0x21, 0x85, + 0x2c, 0x84, 0x14, 0x80, 0x06, 0x46, 0x00, 0xe0, 0x2c, 0x84, 0x14, 0x82, + 0x2c, 0x84, 0x14, 0xc0, 0x21, 0xa1, 0x21, 0x42, 0x20, 0xe0, 0x14, 0xc2, + 0x31, 0x42, 0x20, 0xe0, 0x15, 0x00, 0x10, 0xe0, 0x21, 0x42, 0x20, 0xe0, + 0x05, 0x00, 0x14, 0xe0, 0x01, 0x90, 0x06, 0x42, 0x00, 0xe0, 0x16, 0x80, + 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x7c, 0xfa, 0x4a, 0x40, 0x80, 0xe0, + 0xf0, 0x1e, 0x30, 0xec, 0xe5, 0x82, 0xa6, 0x40, 0x00, 0xe1, 0x1a, 0x80, + 0x2a, 0xc0, 0x3a, 0xc2, 0x13, 0x40, 0x10, 0xe0, 0x1a, 0x82, 0x23, 0x40, + 0x18, 0xe0, 0x33, 0x40, 0x1c, 0xe0, 0x13, 0x40, 0x14, 0xe0, 0xf8, 0x61, + 0x68, 0xef, 0xc6, 0x13, 0x00, 0xe1, 0x15, 0x12, 0x28, 0xf8, 0x0b, 0x02, + 0x2c, 0xe0, 0x1b, 0x02, 0x24, 0xe0, 0x8a, 0x00, 0xa5, 0x64, 0x03, 0xc0, + 0x35, 0x82, 0x0a, 0x4e, 0x9c, 0xe1, 0x1a, 0x03, 0x11, 0x6f, 0x02, 0xc0, + 0xe8, 0x13, 0x01, 0x20, 0x00, 0xc0, 0x1f, 0xa0, 0x5a, 0x42, 0x80, 0xe0, + 0x0a, 0x4e, 0x9c, 0xe1, 0x68, 0x13, 0x00, 0xa0, 0x09, 0x12, 0x78, 0xf8, + 0xa1, 0x81, 0xf0, 0x02, 0x10, 0xe4, 0x07, 0xc4, 0x0c, 0xfc, 0xf0, 0x00, + 0x20, 0xe4, 0xa6, 0x91, 0xa8, 0x53, 0x74, 0xef, 0x05, 0x12, 0x30, 0xf8, + 0x25, 0x12, 0x28, 0xf8, 0x61, 0x87, 0x09, 0x00, 0x48, 0xe0, 0x81, 0x85, + 0x09, 0x86, 0x0b, 0xa7, 0x26, 0x0c, 0x00, 0xc0, 0x0b, 0xa1, 0x0b, 0x04, + 0x28, 0xe0, 0x16, 0x0c, 0x00, 0x80, 0x03, 0x52, 0x04, 0xf8, 0x0b, 0x04, + 0x20, 0xe0, 0x0c, 0xa6, 0x1b, 0x04, 0x2c, 0xe0, 0x3b, 0x04, 0x28, 0xe0, + 0x4b, 0x04, 0x20, 0xe0, 0x13, 0x86, 0x3b, 0x04, 0x24, 0xe0, 0x10, 0x0a, + 0x04, 0xec, 0x1a, 0xfc, 0x33, 0x88, 0x30, 0x06, 0x04, 0xec, 0x12, 0x4e, + 0x94, 0xf0, 0x32, 0x48, 0x84, 0xf0, 0x4c, 0xe4, 0x7c, 0xa4, 0xcb, 0x04, + 0x28, 0xe0, 0x14, 0x08, 0x84, 0xe1, 0xcd, 0xc9, 0xc2, 0x58, 0x90, 0x91, + 0x42, 0x4e, 0x94, 0x90, 0xc3, 0x52, 0x04, 0x98, 0x73, 0x52, 0x00, 0x80, + 0x5b, 0x04, 0x20, 0xe0, 0x5d, 0xc9, 0x52, 0x40, 0x90, 0x91, 0x42, 0x48, + 0x8c, 0x90, 0x03, 0x52, 0x04, 0x80, 0x43, 0x52, 0x08, 0x80, 0x3b, 0x04, + 0x2c, 0xe0, 0x49, 0x04, 0xb8, 0xe0, 0x33, 0x52, 0x1c, 0xf8, 0x2b, 0x04, + 0x24, 0xe0, 0x4b, 0xab, 0x23, 0x52, 0x18, 0xf8, 0x65, 0x8a, 0x4b, 0xa9, + 0xe5, 0x90, 0x4b, 0xa7, 0x22, 0x44, 0x84, 0xd0, 0x32, 0x46, 0x84, 0xd0, + 0x33, 0x52, 0x1c, 0xd8, 0x23, 0x52, 0x18, 0xd8, 0x95, 0x96, 0x20, 0x44, + 0xf9, 0x73, 0xff, 0xc0, 0x27, 0xc3, 0x23, 0x82, 0x23, 0x52, 0x18, 0xf8, + 0x24, 0x02, 0x80, 0xfb, 0x04, 0x00, 0x80, 0xfb, 0x2b, 0x8c, 0x58, 0x52, + 0x74, 0xef, 0x1b, 0x12, 0x1c, 0xf8, 0x2a, 0xfc, 0x0c, 0xe4, 0x17, 0xc3, + 0x13, 0x84, 0x13, 0x52, 0x1c, 0xf8, 0x0b, 0x12, 0x04, 0xf8, 0x14, 0x02, + 0x80, 0xfb, 0x2b, 0x8c, 0x68, 0x51, 0x74, 0xef, 0xc5, 0x87, 0x20, 0x44, + 0xe1, 0x73, 0xff, 0xc0, 0x27, 0xc7, 0x23, 0x82, 0x23, 0x52, 0x18, 0xf8, + 0x24, 0x02, 0x80, 0xfb, 0x04, 0x00, 0x80, 0xfb, 0x2b, 0x8c, 0x78, 0x57, + 0x74, 0xef, 0x1b, 0x12, 0x1c, 0xf8, 0x2a, 0xfc, 0x0c, 0xe4, 0x17, 0xc7, + 0x13, 0x84, 0x13, 0x52, 0x1c, 0xf8, 0x0b, 0x12, 0x04, 0xf8, 0x14, 0x02, + 0x80, 0xfb, 0x2b, 0x8c, 0x88, 0x56, 0x74, 0xef, 0xe5, 0x83, 0x20, 0x44, + 0xf1, 0x73, 0xff, 0xc0, 0x27, 0xc5, 0x23, 0x82, 0x23, 0x52, 0x18, 0xf8, + 0x24, 0x02, 0x80, 0xfb, 0x04, 0x00, 0x80, 0xfb, 0x2b, 0x8c, 0x18, 0x52, + 0x74, 0xef, 0x1b, 0x12, 0x1c, 0xf8, 0x2a, 0xfc, 0x0c, 0xe4, 0x17, 0xc5, + 0x13, 0x84, 0x13, 0x52, 0x1c, 0xf8, 0x0b, 0x12, 0x04, 0xf8, 0x14, 0x02, + 0x80, 0xfb, 0x2b, 0x8c, 0x28, 0x51, 0x74, 0xef, 0x7b, 0x80, 0x7c, 0xa4, + 0x08, 0x91, 0xa3, 0x52, 0x1c, 0xe0, 0xa3, 0x52, 0x24, 0xe0, 0x0b, 0xa1, + 0x83, 0x52, 0x1c, 0x80, 0x83, 0x52, 0x24, 0x80, 0x89, 0x12, 0x78, 0xf8, + 0xf6, 0x57, 0xfc, 0xef, 0x6b, 0x12, 0x1c, 0xf8, 0xab, 0x12, 0x18, 0xf8, + 0xd6, 0x57, 0xfc, 0x8f, 0x8b, 0xa3, 0xa0, 0x40, 0x00, 0x9c, 0xa5, 0x86, + 0x64, 0x00, 0x80, 0xfb, 0x1b, 0x90, 0xf8, 0x7d, 0xf8, 0xee, 0x6b, 0x80, + 0xa4, 0x00, 0x80, 0xfb, 0x1b, 0x90, 0x98, 0x7d, 0xf8, 0xee, 0x15, 0x12, + 0x28, 0xf8, 0x19, 0x02, 0xb8, 0xe0, 0x1b, 0xad, 0x95, 0x82, 0x1a, 0xa6, + 0xa0, 0x44, 0xf9, 0x73, 0xff, 0xc0, 0x27, 0xc3, 0x13, 0x94, 0x10, 0x02, + 0x08, 0xec, 0x1c, 0xe4, 0x23, 0x52, 0x18, 0xf8, 0x1b, 0x12, 0x04, 0xf8, + 0x03, 0x96, 0x03, 0x52, 0x28, 0xe0, 0x1c, 0xe6, 0x0a, 0xa6, 0x1a, 0xe4, + 0x63, 0x96, 0x63, 0x52, 0x20, 0xe0, 0x73, 0x52, 0x10, 0xe0, 0x03, 0x52, + 0x14, 0xe0, 0x13, 0x52, 0x18, 0xe0, 0x98, 0x52, 0x74, 0xef, 0x09, 0x12, + 0x8c, 0xe0, 0x0b, 0xa1, 0x01, 0x81, 0x01, 0x52, 0x90, 0xe0, 0x65, 0x82, + 0x05, 0x12, 0x30, 0xf8, 0x09, 0x00, 0xa8, 0xe0, 0x0a, 0x00, 0x0c, 0xf8, + 0x16, 0x00, 0x00, 0xc0, 0x01, 0x52, 0x90, 0xc0, 0x46, 0x41, 0x84, 0xe0, + 0x0a, 0x80, 0x0a, 0x4e, 0x9c, 0xe9, 0x1a, 0x00, 0x08, 0xe0, 0x38, 0x01, + 0x01, 0x20, 0x00, 0xc0, 0x0b, 0x12, 0x1c, 0xe0, 0x1b, 0x12, 0x24, 0xe0, + 0x2b, 0x12, 0x28, 0xe0, 0x03, 0x52, 0x2c, 0xe0, 0x0b, 0x12, 0x20, 0xe0, + 0x13, 0x52, 0x34, 0xe0, 0x23, 0x52, 0x38, 0xe0, 0x03, 0x52, 0x30, 0xe0, + 0x0c, 0x00, 0x00, 0xe2, 0xf1, 0x98, 0x0c, 0x0c, 0x7c, 0xf2, 0x93, 0xdd, + 0x13, 0xa9, 0x00, 0x00, 0xa8, 0xc1, 0x40, 0x00, 0x68, 0x04, 0xa0, 0xe0, + 0x40, 0x6c, 0x40, 0x00, 0xe8, 0x34, 0xc8, 0xe0, 0xfc, 0x91, 0x40, 0x00, + 0x68, 0x1f, 0xb8, 0xe0, 0x30, 0x16, 0x41, 0x00, 0x28, 0x39, 0x74, 0xe0, + 0xb0, 0x7e, 0x40, 0x00, 0xe8, 0x38, 0xc0, 0xe0, 0x30, 0x04, 0x41, 0x00, + 0x48, 0x1b, 0x80, 0xe0, 0x30, 0x2e, 0x40, 0x00, 0x88, 0x0c, 0xec, 0xe0, + 0x10, 0x9f, 0x40, 0x00, 0x88, 0x08, 0xb4, 0xe0, 0x10, 0x01, 0x41, 0x00, + 0x68, 0x01, 0x84, 0xe0, 0x54, 0xd6, 0x40, 0x00, 0xc8, 0x1a, 0x98, 0xe0, + 0xd0, 0xc8, 0x40, 0x00, 0x68, 0x08, 0xa0, 0xe0, 0x80, 0xdb, 0x40, 0x00, + 0xe8, 0x35, 0x94, 0xe0, 0x74, 0xff, 0x40, 0x00, 0xa8, 0x11, 0x80, 0xe0, + 0xf8, 0x89, 0x40, 0x00, 0x88, 0x16, 0xbc, 0xe0, 0x00, 0x90, 0x40, 0x00, + 0x08, 0x35, 0xb8, 0xe0, 0x7c, 0x73, 0x40, 0x00, 0x88, 0x1b, 0xc8, 0xe0, + 0xf4, 0xff, 0x40, 0x00, 0x68, 0x39, 0x80, 0xe0, 0xa4, 0xa4, 0x40, 0x00, + 0xa8, 0x16, 0xb0, 0xe0, 0x50, 0xc9, 0x40, 0x00, 0x28, 0x3a, 0x98, 0xe0, + 0x00, 0xb9, 0x00, 0x00, 0xb6, 0x85, 0x00, 0x00, +}; diff --git a/drivers/media/i2c/vd55g1.c b/drivers/media/i2c/vd55g1.c index 78d18c0281541..1ae42e448490a 100644 --- a/drivers/media/i2c/vd55g1.c +++ b/drivers/media/i2c/vd55g1.c @@ -138,301 +138,7 @@ #define VD55G1_MODEL_ID_NAME(id) \ ((id) == VD55G1_MODEL_ID_VD55G1 ? "vd55g1" : "vd65g4") -static const u8 vd55g1_patch_array[] = { - 0x44, 0x03, 0x09, 0x02, 0xe6, 0x01, 0x42, 0x00, 0xea, 0x01, 0x42, 0x00, - 0xf0, 0x01, 0x42, 0x00, 0xe6, 0x01, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0xfa, 0x68, 0x40, 0x00, 0xe8, - 0x09, 0xbe, 0x4c, 0x08, 0x00, 0xf2, 0x93, 0xdd, 0x1c, 0x00, 0xc0, 0xe2, - 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x00, 0xfa, 0x6b, 0x80, 0x98, 0x7f, - 0xfc, 0xef, 0x11, 0xc1, 0x0f, 0x82, 0x69, 0xbe, 0x0f, 0xac, 0x58, 0x40, - 0x00, 0xe8, 0x0c, 0x0c, 0x00, 0xf2, 0x93, 0xdd, 0x1c, 0x00, 0x40, 0xe3, - 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x84, 0xfa, 0x46, 0x0e, 0xe8, 0xe0, - 0x08, 0xde, 0x4a, 0x40, 0x84, 0xe0, 0xa5, 0x86, 0xa8, 0x7d, 0xfc, 0xef, - 0x6b, 0x80, 0x01, 0xbf, 0x28, 0x77, 0x0c, 0xef, 0x0b, 0x0e, 0x21, 0x78, - 0x06, 0xc0, 0x0b, 0xa5, 0xb5, 0x84, 0x06, 0x42, 0x98, 0xe1, 0x01, 0x81, - 0x01, 0x42, 0x38, 0xe0, 0x0c, 0xc4, 0x0e, 0x84, 0x46, 0x02, 0x84, 0xe0, - 0x0c, 0x84, 0x11, 0x81, 0x21, 0x81, 0x31, 0x81, 0x41, 0x81, 0x51, 0x81, - 0xc1, 0x81, 0x05, 0x83, 0x0c, 0x0c, 0x84, 0xf2, 0x93, 0xdd, 0x06, 0x40, - 0x98, 0xe1, 0xc8, 0x80, 0x58, 0x82, 0x48, 0xc0, 0x38, 0xc2, 0x29, 0x00, - 0x10, 0xe0, 0x19, 0x00, 0x14, 0xe0, 0x09, 0x00, 0x38, 0xe0, 0x5f, 0xb8, - 0x5f, 0xa8, 0x5f, 0xa6, 0x5f, 0xa4, 0x5f, 0xa2, 0x5f, 0xa0, 0x56, 0x41, - 0x98, 0xe1, 0x18, 0x82, 0x28, 0x80, 0x38, 0xc0, 0x5f, 0xa2, 0x19, 0x00, - 0x20, 0xf8, 0x5f, 0xa4, 0x28, 0xc2, 0x5f, 0xa6, 0x39, 0x00, 0x10, 0xe0, - 0x5f, 0xa2, 0x19, 0x00, 0x14, 0xe0, 0x5f, 0xa4, 0x29, 0x00, 0x18, 0xe0, - 0x5f, 0xa6, 0x39, 0x00, 0x40, 0xe0, 0x5f, 0xa2, 0x19, 0x00, 0x44, 0xe0, - 0x5f, 0xa4, 0x29, 0x00, 0x1c, 0xe0, 0x5f, 0xa6, 0x39, 0x00, 0x38, 0xe0, - 0x5f, 0xa2, 0x19, 0x00, 0x20, 0xe0, 0x5f, 0xa4, 0x29, 0x00, 0x24, 0xe0, - 0x5f, 0xa6, 0x39, 0x00, 0x28, 0xe0, 0x5f, 0xa2, 0x19, 0x00, 0x2c, 0xe0, - 0x5f, 0xa4, 0x29, 0x00, 0x30, 0xe0, 0x5f, 0xa6, 0x09, 0x00, 0x34, 0xe0, - 0x5f, 0xa2, 0x5f, 0xa4, 0x5f, 0xa0, 0x4a, 0x0a, 0xfc, 0xfb, 0xe5, 0x82, - 0x08, 0xde, 0x4a, 0x40, 0x88, 0xe0, 0xf6, 0x40, 0x00, 0xe0, 0x01, 0x4e, - 0x99, 0x78, 0x0a, 0xc0, 0x85, 0x80, 0x98, 0x40, 0x00, 0xe8, 0x35, 0x81, - 0xa8, 0x40, 0x00, 0xe8, 0x0b, 0x8c, 0x0c, 0x0c, 0x84, 0xf2, 0xd5, 0xed, - 0x83, 0xc1, 0x13, 0xc5, 0x93, 0xdd, 0xc3, 0xc1, 0x83, 0xc1, 0x13, 0xc3, - 0x93, 0xdd, 0xc3, 0xc1, 0x4c, 0x04, 0x04, 0xfa, 0xc6, 0x0f, 0x94, 0xe0, - 0x19, 0x0e, 0xc9, 0x65, 0x01, 0xc0, 0x28, 0xde, 0x0a, 0x42, 0x80, 0xe0, - 0x24, 0x02, 0x00, 0xfc, 0x16, 0xde, 0xa5, 0x8a, 0x19, 0x00, 0xb8, 0xe0, - 0x10, 0x02, 0x0c, 0xec, 0x1d, 0xe6, 0x14, 0x02, 0x88, 0x80, 0x4e, 0x04, - 0x01, 0x00, 0x10, 0x80, 0x25, 0x02, 0x08, 0x9c, 0x86, 0x02, 0x00, 0x80, - 0x08, 0x44, 0x00, 0x98, 0x55, 0x81, 0x11, 0x85, 0x45, 0x81, 0x11, 0x89, - 0x25, 0x81, 0x11, 0x83, 0x2b, 0x00, 0x24, 0xe0, 0x64, 0xc2, 0x0b, 0x84, - 0x08, 0x51, 0x00, 0xef, 0x2b, 0x80, 0x01, 0x83, 0x1b, 0x8c, 0x38, 0x7d, - 0x5c, 0xef, 0x18, 0xde, 0x0b, 0xa1, 0x25, 0x82, 0x0b, 0x0e, 0x88, 0xf9, - 0x0a, 0x00, 0x00, 0xe8, 0x10, 0x42, 0x04, 0x9c, 0x11, 0x4e, 0x0c, 0x80, - 0x10, 0x40, 0x04, 0xf0, 0x4e, 0x05, 0x01, 0x60, 0x10, 0xc0, 0x06, 0x88, - 0x10, 0x40, 0xf8, 0xf3, 0x06, 0xde, 0x4c, 0x0c, 0x04, 0xf2, 0x93, 0xdd, - 0x0c, 0x04, 0x1c, 0xfe, 0xf6, 0x0f, 0x94, 0xe0, 0x38, 0x9c, 0x46, 0x51, - 0xfc, 0xe0, 0x46, 0x49, 0x38, 0xe2, 0x30, 0x46, 0xf8, 0xf3, 0x36, 0x9c, - 0xc6, 0x46, 0x0c, 0xe1, 0x34, 0x8c, 0x94, 0xa0, 0x4e, 0xa0, 0x39, 0x06, - 0x80, 0xe0, 0x4a, 0x46, 0x94, 0xe0, 0x05, 0x8c, 0x6a, 0x40, 0x80, 0xe0, - 0x2c, 0x0c, 0x00, 0xe2, 0x0b, 0x8c, 0xb8, 0x7c, 0x5c, 0xef, 0x0b, 0x8c, - 0x9e, 0xa0, 0xf8, 0x40, 0x60, 0xef, 0x0b, 0xa1, 0x5a, 0x40, 0x80, 0xe0, - 0x65, 0x88, 0x28, 0x02, 0x01, 0x40, 0x00, 0x80, 0x2a, 0x42, 0x9c, 0xe1, - 0x28, 0x49, 0x60, 0xef, 0x96, 0x4d, 0x9c, 0xe1, 0x01, 0x81, 0x06, 0x98, - 0xd5, 0x81, 0x09, 0x0e, 0xa1, 0x64, 0x01, 0xc0, 0x4a, 0x40, 0x88, 0xe0, - 0x85, 0x80, 0xb8, 0x77, 0xfc, 0xef, 0x35, 0x81, 0xc8, 0x77, 0xfc, 0xef, - 0x08, 0x98, 0x4a, 0x00, 0xfc, 0xfb, 0x55, 0xfc, 0xe8, 0x4a, 0x60, 0xef, - 0x1a, 0x44, 0x9c, 0xe1, 0x35, 0x81, 0x1a, 0x4e, 0x9c, 0xe9, 0x1c, 0x00, - 0x00, 0xe2, 0x0c, 0x0c, 0x1c, 0xf6, 0x93, 0xdd, 0x0d, 0xc3, 0x1a, 0x41, - 0x08, 0xe4, 0x0a, 0x40, 0x84, 0xe1, 0x0c, 0x00, 0x00, 0xe2, 0x93, 0xdd, - 0x4c, 0x04, 0x1c, 0xfa, 0x86, 0x52, 0xec, 0xe1, 0x08, 0xa6, 0x65, 0x12, - 0x24, 0xf8, 0x0e, 0x02, 0x99, 0x7a, 0x00, 0xc0, 0x00, 0x40, 0xa0, 0xf3, - 0x06, 0xa6, 0x0b, 0x8c, 0x08, 0x49, 0x00, 0xef, 0x85, 0x12, 0x28, 0xf8, - 0x02, 0x02, 0xfc, 0xed, 0xf6, 0x47, 0xfd, 0x6f, 0xe0, 0xff, 0x04, 0xe2, - 0x14, 0x04, 0xc0, 0xe0, 0x0f, 0x86, 0x2f, 0xa0, 0x0b, 0x8c, 0x2e, 0xe2, - 0x08, 0x48, 0x00, 0xef, 0x86, 0x02, 0x84, 0xfe, 0x0e, 0x05, 0x09, 0x7d, - 0x00, 0xc0, 0x05, 0x52, 0x08, 0xf8, 0x18, 0x7d, 0xfc, 0xef, 0x4a, 0x40, - 0x80, 0xe0, 0x09, 0x12, 0x04, 0xc0, 0x65, 0x12, 0x20, 0xf8, 0x00, 0x40, - 0x40, 0xdc, 0x01, 0x52, 0x04, 0xc0, 0x0e, 0x00, 0x41, 0x78, 0xf5, 0xc5, - 0x6d, 0xc0, 0xb5, 0x82, 0x05, 0x10, 0x10, 0xe0, 0x11, 0xf1, 0x0f, 0x82, - 0x05, 0x50, 0x10, 0xe0, 0x05, 0x10, 0x10, 0xe0, 0xfe, 0x02, 0xf0, 0xff, - 0x0f, 0x82, 0x85, 0x83, 0x15, 0x10, 0x10, 0xe0, 0x16, 0x00, 0x91, 0x6e, - 0x69, 0xcd, 0x21, 0xf1, 0x6d, 0xc1, 0x01, 0x83, 0x2f, 0x82, 0x26, 0x00, - 0x00, 0x80, 0x2f, 0xa0, 0x25, 0x50, 0x10, 0xe0, 0x05, 0x10, 0x10, 0xe0, - 0x11, 0xa1, 0xfe, 0x04, 0xf0, 0xff, 0x06, 0x42, 0x00, 0x80, 0x0f, 0x84, - 0x0f, 0xa2, 0x05, 0x50, 0x10, 0xe0, 0x16, 0x00, 0x91, 0x6e, 0x69, 0xcd, - 0x6d, 0xc1, 0x71, 0x8d, 0x16, 0x00, 0x79, 0x61, 0x2d, 0xcb, 0x86, 0x0e, - 0x00, 0x80, 0x6d, 0xc1, 0x56, 0x0e, 0x00, 0xc0, 0x0b, 0x8c, 0x1b, 0x8e, - 0x71, 0x52, 0x0c, 0xf8, 0x08, 0x43, 0x00, 0xef, 0x05, 0x52, 0x14, 0xf8, - 0x15, 0x10, 0x28, 0xe0, 0x70, 0x04, 0x04, 0xec, 0x31, 0xe1, 0x29, 0x9e, - 0x1f, 0x86, 0x1f, 0xa4, 0x15, 0x50, 0x28, 0xe0, 0x86, 0x42, 0x3c, 0xe0, - 0x0e, 0x04, 0x9d, 0x64, 0x9b, 0xc2, 0x05, 0x52, 0x1c, 0xf8, 0x78, 0xa6, - 0x48, 0x77, 0xfc, 0xef, 0x4a, 0x40, 0x80, 0xe0, 0x70, 0x4e, 0x10, 0xdc, - 0x1e, 0x00, 0x81, 0x70, 0xeb, 0xcb, 0x70, 0x4e, 0xec, 0x93, 0x6d, 0xc1, - 0x11, 0x85, 0x36, 0x02, 0x00, 0x80, 0x76, 0xa6, 0x11, 0x52, 0x10, 0xf8, - 0x05, 0x10, 0x40, 0xe0, 0xfe, 0x47, 0x0c, 0xff, 0x14, 0x04, 0xa0, 0xe0, - 0x0f, 0x86, 0x0f, 0xa4, 0x05, 0x50, 0x40, 0xe0, 0x05, 0x10, 0x28, 0xe0, - 0xfe, 0x47, 0xfd, 0x7f, 0xe3, 0xff, 0x14, 0x04, 0xd0, 0xe0, 0x0f, 0x86, - 0x2f, 0xa0, 0x20, 0x00, 0x01, 0x6c, 0x00, 0xd0, 0x05, 0x50, 0x28, 0xe0, - 0x0b, 0x8c, 0xf8, 0x7e, 0xfc, 0xee, 0x0e, 0x03, 0x59, 0x78, 0xf5, 0xc5, - 0x0d, 0xc2, 0x05, 0x52, 0x0c, 0xf8, 0x08, 0xa6, 0x46, 0x42, 0xb4, 0xe0, - 0x18, 0x84, 0x00, 0x40, 0xf4, 0x93, 0x00, 0x40, 0x08, 0xdc, 0x1b, 0xa1, - 0x06, 0xa6, 0x05, 0x10, 0x40, 0x80, 0x04, 0x00, 0x50, 0x9c, 0x65, 0x8a, - 0x05, 0x10, 0x44, 0xe0, 0xf6, 0x43, 0xfd, 0x6f, 0x00, 0xf8, 0x0f, 0x82, - 0x06, 0x02, 0x01, 0x60, 0x1e, 0xc0, 0x0f, 0xa2, 0x05, 0x50, 0x44, 0xe0, - 0x05, 0x10, 0x44, 0xe0, 0x0e, 0x02, 0x00, 0xf8, 0x0f, 0x82, 0x09, 0xf6, - 0x05, 0x50, 0x44, 0xe0, 0x05, 0x10, 0x40, 0xe0, 0x04, 0x00, 0x54, 0xfc, - 0x05, 0x50, 0x40, 0xe0, 0x05, 0x10, 0x40, 0xe0, 0x04, 0x00, 0xcc, 0xfc, - 0x05, 0x50, 0x40, 0xe0, 0x05, 0x10, 0x40, 0xe0, 0x04, 0x00, 0x4c, 0xfc, - 0x05, 0x50, 0x40, 0xe0, 0x05, 0x10, 0x40, 0xe0, 0x04, 0x00, 0xd0, 0xfc, - 0x05, 0x50, 0x40, 0xe0, 0x4c, 0x0c, 0x1c, 0xf2, 0x93, 0xdd, 0xc3, 0xc1, - 0xc6, 0x40, 0xfc, 0xe0, 0x04, 0x80, 0xc6, 0x44, 0x0c, 0xe1, 0x15, 0x04, - 0x0c, 0xf8, 0x0a, 0x80, 0x06, 0x07, 0x04, 0xe0, 0x03, 0x42, 0x48, 0xe1, - 0x46, 0x02, 0x40, 0xe2, 0x08, 0xc6, 0x44, 0x88, 0x06, 0x46, 0x0e, 0xe0, - 0x86, 0x01, 0x84, 0xe0, 0x33, 0x80, 0x39, 0x06, 0xd8, 0xef, 0x0a, 0x46, - 0x80, 0xe0, 0x31, 0xbf, 0x06, 0x06, 0x00, 0xc0, 0x31, 0x48, 0x60, 0xe0, - 0x34, 0x88, 0x49, 0x06, 0x40, 0xe1, 0x40, 0x48, 0x7c, 0xf3, 0x41, 0x46, - 0x40, 0xe1, 0x24, 0x8a, 0x39, 0x04, 0x10, 0xe0, 0x39, 0xc2, 0x31, 0x44, - 0x10, 0xe0, 0x14, 0xc4, 0x1b, 0xa5, 0x11, 0x83, 0x11, 0x40, 0x25, 0x6a, - 0x01, 0xc0, 0x08, 0x5c, 0x00, 0xda, 0x15, 0x00, 0xcc, 0xe0, 0x25, 0x00, - 0xf8, 0xe0, 0x1b, 0x85, 0x08, 0x5c, 0x00, 0x9a, 0x4e, 0x03, 0x01, 0x60, - 0x10, 0xc0, 0x29, 0x00, 0x1c, 0xe4, 0x18, 0x84, 0x20, 0x44, 0xf8, 0xf3, - 0x2f, 0xa2, 0x21, 0x40, 0x1c, 0xe4, 0x93, 0xdd, 0x0c, 0x00, 0x80, 0xfa, - 0x15, 0x00, 0x3c, 0xe0, 0x21, 0x81, 0x31, 0x85, 0x21, 0x42, 0x60, 0xe0, - 0x15, 0x00, 0x44, 0xe0, 0x31, 0x42, 0x40, 0xe1, 0x15, 0x00, 0x34, 0xe0, - 0x21, 0x42, 0x20, 0xe0, 0x15, 0x00, 0x34, 0xe0, 0xd6, 0x04, 0x10, 0xe0, - 0x23, 0x42, 0x30, 0xe0, 0x15, 0x00, 0x34, 0xe0, 0x86, 0x44, 0x04, 0xe0, - 0x23, 0x42, 0x38, 0xe0, 0x05, 0x00, 0x30, 0xe0, 0xc6, 0x02, 0x08, 0xe0, - 0x13, 0x40, 0x10, 0xe3, 0xe8, 0x56, 0x40, 0xef, 0x06, 0x40, 0x0c, 0xe1, - 0x04, 0x80, 0x06, 0x02, 0x94, 0xe0, 0x2b, 0x02, 0xc4, 0xea, 0x3b, 0x00, - 0x78, 0xe2, 0x20, 0x44, 0xfd, 0x73, 0x07, 0xc0, 0x30, 0x46, 0x01, 0x70, - 0xf8, 0xc0, 0x3f, 0xa4, 0x33, 0x40, 0x78, 0xe2, 0x0a, 0x84, 0x0c, 0x08, - 0x80, 0xf2, 0xf8, 0x3b, 0x3c, 0xff, 0xc3, 0xc1, 0x06, 0x40, 0x0c, 0xe1, - 0x04, 0x80, 0x1b, 0x00, 0x40, 0xe4, 0x19, 0xc2, 0x13, 0x40, 0x40, 0xe4, - 0x1b, 0x00, 0x40, 0xe4, 0x19, 0xc4, 0x13, 0x40, 0x40, 0xe4, 0x93, 0xdd, - 0xc6, 0x43, 0xec, 0xe0, 0x46, 0x41, 0xfc, 0xe0, 0x24, 0x84, 0x04, 0x80, - 0x31, 0x81, 0x4a, 0x44, 0x80, 0xe0, 0x86, 0x44, 0x0c, 0xe1, 0x09, 0x00, - 0x6c, 0xe0, 0xc4, 0x8a, 0x8e, 0x47, 0xfc, 0x9f, 0x01, 0x42, 0x51, 0x78, - 0x0c, 0xc0, 0x31, 0x58, 0x90, 0xe0, 0x34, 0x8a, 0x41, 0xbf, 0x06, 0x08, - 0x00, 0xc0, 0x41, 0x46, 0xa0, 0xe0, 0x34, 0x8a, 0x51, 0x81, 0xf6, 0x0b, - 0x00, 0xc0, 0x51, 0x46, 0xd0, 0xe0, 0x34, 0x8a, 0x01, 0xbf, 0x51, 0x46, - 0xe0, 0xe0, 0x44, 0x84, 0x0a, 0x48, 0x84, 0xe0, 0x75, 0x86, 0x54, 0xca, - 0x49, 0x88, 0x44, 0x06, 0x88, 0xe1, 0x36, 0x94, 0x4a, 0x46, 0x80, 0xe0, - 0x34, 0xca, 0x47, 0xc6, 0x11, 0x8d, 0x41, 0x46, 0xd0, 0xe0, 0x34, 0x88, - 0x76, 0x02, 0x00, 0xc0, 0x06, 0x00, 0x00, 0xc0, 0x16, 0x8c, 0x14, 0x88, - 0x01, 0x42, 0xc0, 0xe1, 0x01, 0x42, 0xe0, 0xe1, 0x01, 0x42, 0xf0, 0xe1, - 0x93, 0xdd, 0x34, 0xca, 0x41, 0x85, 0x46, 0x8c, 0x34, 0xca, 0x06, 0x48, - 0x00, 0xe0, 0x41, 0x46, 0xd0, 0xe0, 0x34, 0x88, 0x41, 0x83, 0x46, 0x8c, - 0x34, 0x88, 0x01, 0x46, 0xc0, 0xe1, 0x01, 0x46, 0xe0, 0xe1, 0x01, 0x46, - 0xf0, 0xe1, 0x09, 0x02, 0x20, 0xe0, 0x14, 0xca, 0x03, 0x42, 0x58, 0xe0, - 0x93, 0xdd, 0xc3, 0xc1, 0x4c, 0x04, 0x04, 0xfa, 0x46, 0x4e, 0x08, 0xe1, - 0x06, 0x4c, 0x0c, 0xe1, 0x0a, 0x9e, 0x14, 0x98, 0x05, 0x42, 0x44, 0xe0, - 0x10, 0x00, 0xe1, 0x65, 0x03, 0xc0, 0x78, 0x41, 0x00, 0xe8, 0x08, 0x9c, - 0x0b, 0xa1, 0x04, 0x98, 0x06, 0x02, 0x10, 0x80, 0x13, 0x40, 0xf8, 0x86, - 0x65, 0x82, 0x00, 0x00, 0xe1, 0x65, 0x03, 0xc0, 0xa8, 0x40, 0x00, 0xe8, - 0x14, 0x98, 0x04, 0x00, 0xa0, 0xfc, 0x03, 0x42, 0x00, 0xe7, 0x4c, 0x0c, - 0x04, 0xf2, 0x93, 0xdd, 0x0a, 0x80, 0x93, 0xdd, 0x0c, 0x04, 0x00, 0xfa, - 0x06, 0x02, 0xec, 0xe1, 0x64, 0x84, 0x15, 0x0c, 0x2c, 0xe0, 0x14, 0x02, - 0xa0, 0xfc, 0x15, 0x4c, 0x2c, 0xe0, 0xd8, 0x40, 0x00, 0xe8, 0x14, 0xd8, - 0x09, 0x82, 0x14, 0x02, 0x00, 0xfc, 0x1f, 0xa0, 0x1e, 0xd8, 0x01, 0x85, - 0x0c, 0x0c, 0x00, 0xf2, 0xe8, 0x32, 0x2c, 0xff, 0x93, 0xdd, 0xc3, 0xc1, - 0x0c, 0x04, 0x00, 0xfa, 0x6b, 0x80, 0xf6, 0x01, 0x94, 0xe0, 0x08, 0x80, - 0x4a, 0x40, 0x80, 0xe0, 0x45, 0x86, 0x06, 0x40, 0x0c, 0xe1, 0x04, 0x80, - 0xc6, 0x02, 0x40, 0xe2, 0x09, 0x00, 0xd0, 0xe0, 0x14, 0x84, 0x1b, 0xa5, - 0x15, 0x84, 0x07, 0xc5, 0x09, 0x82, 0x18, 0x41, 0x00, 0xe8, 0x46, 0x43, - 0xfc, 0xe0, 0x14, 0x84, 0x19, 0x02, 0xd8, 0xe0, 0x19, 0x82, 0x0b, 0x83, - 0x16, 0x00, 0x00, 0xc0, 0x01, 0x4c, 0x00, 0xc0, 0x0c, 0x0c, 0x00, 0xf2, - 0x93, 0xdd, 0xc3, 0xc1, 0x4a, 0x00, 0x00, 0xe0, 0x0c, 0x00, 0x00, 0xe2, - 0x93, 0xdd, 0xc3, 0xc1, 0x46, 0x40, 0x84, 0xe0, 0x11, 0xaf, 0x13, 0x40, - 0x6c, 0xec, 0x11, 0xb3, 0x13, 0x40, 0x70, 0xec, 0xc6, 0x43, 0xf0, 0xe0, - 0x13, 0x40, 0xdc, 0xec, 0xc6, 0x02, 0x24, 0xe0, 0x1c, 0x80, 0x93, 0xdd, - 0x4c, 0x00, 0x00, 0xfa, 0xc8, 0x60, 0x7c, 0xef, 0xe8, 0x61, 0x7c, 0xef, - 0x28, 0x7e, 0x80, 0xef, 0xc6, 0x40, 0x98, 0xe1, 0x11, 0x83, 0x16, 0x80, - 0x46, 0x01, 0x10, 0xe1, 0x11, 0x81, 0x16, 0x80, 0x4c, 0x08, 0x00, 0xf2, - 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x0c, 0xfa, 0x6b, 0x80, 0x04, 0x98, - 0x7b, 0x82, 0x56, 0x42, 0xb4, 0xe0, 0x88, 0x84, 0x05, 0x00, 0x10, 0xe0, - 0x09, 0x86, 0x0b, 0xa5, 0x46, 0x02, 0x00, 0x80, 0x06, 0x05, 0x00, 0x80, - 0x25, 0x82, 0x0b, 0xa3, 0xa5, 0x80, 0x0b, 0xa1, 0x06, 0x00, 0xf4, 0xef, - 0xd5, 0x84, 0x11, 0x85, 0x21, 0x91, 0x0b, 0x8e, 0x88, 0x74, 0x10, 0xef, - 0x0b, 0xa1, 0xf5, 0x82, 0x0a, 0x9e, 0x1a, 0x9c, 0x24, 0x98, 0x07, 0xe0, - 0x0f, 0xa2, 0x0e, 0xca, 0x0a, 0xde, 0x1a, 0xdc, 0x24, 0x98, 0x03, 0xb0, - 0x07, 0xe0, 0x0f, 0xa2, 0x0e, 0xc8, 0x01, 0x81, 0x0c, 0x0c, 0x0c, 0xf2, - 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x7c, 0xfa, 0x46, 0x42, 0x9c, 0xe0, - 0x0b, 0x02, 0x04, 0xe3, 0xf0, 0x1e, 0x30, 0xec, 0x0b, 0xa3, 0x35, 0x96, - 0x8e, 0x01, 0x01, 0x60, 0x10, 0xc0, 0x0e, 0xfc, 0xc6, 0x05, 0xd0, 0xe1, - 0x0b, 0x82, 0x31, 0x81, 0x10, 0x16, 0x00, 0xe5, 0x20, 0x10, 0x20, 0xe7, - 0x0e, 0xbe, 0xb5, 0x85, 0x94, 0xfc, 0xa4, 0xbe, 0x82, 0x4c, 0x9c, 0xf0, - 0x05, 0x0c, 0x40, 0xe0, 0x11, 0x89, 0x93, 0x8e, 0xa3, 0x8e, 0x58, 0x44, - 0x00, 0xe8, 0x15, 0x0c, 0xc0, 0xf8, 0x04, 0x0c, 0x80, 0xfb, 0x0c, 0xed, - 0x0b, 0x82, 0x1b, 0x8c, 0x48, 0x44, 0x00, 0xe8, 0x15, 0x10, 0x1c, 0xfc, - 0x0e, 0xa8, 0x0b, 0x82, 0x1b, 0x8c, 0xd8, 0x43, 0x00, 0xe8, 0x71, 0x88, - 0x0e, 0xa4, 0x0a, 0x0e, 0x40, 0xe0, 0x35, 0xf8, 0x04, 0xbe, 0x14, 0xbc, - 0x81, 0xa0, 0x03, 0x8e, 0x0e, 0xbe, 0x04, 0xfc, 0x11, 0x82, 0x3b, 0x82, - 0x03, 0x8e, 0x0e, 0xfc, 0x3b, 0xa9, 0x06, 0x0e, 0x00, 0xc0, 0x35, 0x5e, - 0x00, 0xc0, 0xd5, 0xfa, 0xc6, 0x01, 0xd0, 0xe1, 0x7b, 0x80, 0x04, 0x9e, - 0x11, 0x91, 0x98, 0x41, 0x00, 0xe8, 0x24, 0x9c, 0x46, 0x42, 0x9c, 0xe0, - 0x6b, 0x82, 0x03, 0x4c, 0xc4, 0xe0, 0x11, 0x91, 0x0b, 0x84, 0xf8, 0x40, - 0x00, 0xe8, 0x19, 0x0e, 0x20, 0xe5, 0x03, 0x4c, 0xc0, 0xe0, 0x0b, 0x82, - 0x08, 0x72, 0xfc, 0xef, 0x01, 0x4c, 0x24, 0xf9, 0xf1, 0x98, 0x0c, 0x0c, - 0x7c, 0xf2, 0x93, 0xdd, 0x4c, 0x00, 0x00, 0xfa, 0x48, 0x65, 0x2c, 0xef, - 0x4c, 0x08, 0x00, 0xf2, 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x00, 0xfa, - 0x6b, 0x82, 0x78, 0x6e, 0xfc, 0xee, 0x46, 0x42, 0xec, 0xe0, 0x24, 0x84, - 0x24, 0x02, 0x80, 0xfa, 0x1d, 0xcc, 0x11, 0x83, 0xf5, 0x82, 0x24, 0x02, - 0xa0, 0xe1, 0x14, 0x02, 0x80, 0xfa, 0x1d, 0xcc, 0x11, 0x85, 0x15, 0x82, - 0x27, 0xe1, 0x24, 0x02, 0x80, 0xfa, 0x1d, 0xcc, 0x11, 0x89, 0x86, 0x02, - 0x00, 0x80, 0x0c, 0x0c, 0x00, 0xf2, 0x18, 0x17, 0xfc, 0xfe, 0xc3, 0xc1, - 0x0c, 0x04, 0x00, 0xfa, 0x06, 0x41, 0x8c, 0xe0, 0x1b, 0x00, 0xec, 0xe4, - 0x1b, 0xa3, 0x75, 0x84, 0x11, 0x81, 0x8e, 0x05, 0x01, 0x60, 0x10, 0xc0, - 0x00, 0x06, 0xc0, 0xe5, 0x95, 0x81, 0x44, 0x88, 0x1d, 0xee, 0x75, 0x80, - 0x4e, 0xc1, 0x25, 0x81, 0x4e, 0xcd, 0x21, 0x88, 0x11, 0x82, 0x0a, 0x02, - 0x40, 0xe0, 0xd5, 0xfc, 0x56, 0x00, 0x00, 0xe1, 0x18, 0x80, 0x1b, 0xa1, - 0xc5, 0x84, 0x08, 0x82, 0x4a, 0x00, 0xfc, 0xfb, 0x45, 0x84, 0x86, 0x4d, - 0x84, 0xe1, 0x04, 0x98, 0x05, 0x00, 0x10, 0xe0, 0x4a, 0x40, 0x80, 0xe0, - 0x45, 0x82, 0x11, 0x81, 0x0b, 0x8c, 0x58, 0x76, 0x28, 0xef, 0x0b, 0x8c, - 0x0c, 0x0c, 0x00, 0xf2, 0x88, 0x35, 0x28, 0xff, 0x0c, 0x0c, 0x00, 0xf2, - 0x93, 0xdd, 0xc3, 0xc1, 0x46, 0x41, 0xfc, 0xe0, 0x04, 0x80, 0x09, 0x00, - 0x80, 0xe0, 0x09, 0x9e, 0x0b, 0xa3, 0x75, 0x82, 0x46, 0x41, 0x80, 0xe1, - 0x04, 0x80, 0xc6, 0x42, 0x8c, 0xe0, 0x04, 0xc2, 0x00, 0x40, 0x00, 0xf2, - 0x07, 0xcf, 0x06, 0x84, 0x06, 0x40, 0x84, 0xe0, 0x15, 0x00, 0x28, 0xe5, - 0x1c, 0xc2, 0x93, 0xdd, 0x0b, 0xa1, 0xc6, 0x00, 0xa0, 0xe1, 0x15, 0x00, - 0x04, 0xf8, 0x05, 0x84, 0x21, 0x8b, 0x2c, 0x84, 0x14, 0x80, 0x2c, 0x84, - 0x14, 0x82, 0x2c, 0x84, 0x15, 0x00, 0x10, 0xe0, 0x21, 0xa1, 0x21, 0x42, - 0x10, 0xe0, 0x05, 0x00, 0x14, 0xe0, 0x01, 0x88, 0x75, 0x83, 0x21, 0x85, - 0x2c, 0x84, 0x14, 0x80, 0x06, 0x46, 0x00, 0xe0, 0x2c, 0x84, 0x14, 0x82, - 0x2c, 0x84, 0x14, 0xc0, 0x21, 0xa1, 0x21, 0x42, 0x20, 0xe0, 0x14, 0xc2, - 0x31, 0x42, 0x20, 0xe0, 0x15, 0x00, 0x10, 0xe0, 0x21, 0x42, 0x20, 0xe0, - 0x05, 0x00, 0x14, 0xe0, 0x01, 0x90, 0x06, 0x42, 0x00, 0xe0, 0x16, 0x80, - 0x93, 0xdd, 0xc3, 0xc1, 0x0c, 0x04, 0x7c, 0xfa, 0x4a, 0x40, 0x80, 0xe0, - 0xf0, 0x1e, 0x30, 0xec, 0xe5, 0x82, 0xa6, 0x40, 0x00, 0xe1, 0x1a, 0x80, - 0x2a, 0xc0, 0x3a, 0xc2, 0x13, 0x40, 0x10, 0xe0, 0x1a, 0x82, 0x23, 0x40, - 0x18, 0xe0, 0x33, 0x40, 0x1c, 0xe0, 0x13, 0x40, 0x14, 0xe0, 0xf8, 0x61, - 0x68, 0xef, 0xc6, 0x13, 0x00, 0xe1, 0x15, 0x12, 0x28, 0xf8, 0x0b, 0x02, - 0x2c, 0xe0, 0x1b, 0x02, 0x24, 0xe0, 0x8a, 0x00, 0xa5, 0x64, 0x03, 0xc0, - 0x35, 0x82, 0x0a, 0x4e, 0x9c, 0xe1, 0x1a, 0x03, 0x11, 0x6f, 0x02, 0xc0, - 0xe8, 0x13, 0x01, 0x20, 0x00, 0xc0, 0x1f, 0xa0, 0x5a, 0x42, 0x80, 0xe0, - 0x0a, 0x4e, 0x9c, 0xe1, 0x68, 0x13, 0x00, 0xa0, 0x09, 0x12, 0x78, 0xf8, - 0xa1, 0x81, 0xf0, 0x02, 0x10, 0xe4, 0x07, 0xc4, 0x0c, 0xfc, 0xf0, 0x00, - 0x20, 0xe4, 0xa6, 0x91, 0xa8, 0x53, 0x74, 0xef, 0x05, 0x12, 0x30, 0xf8, - 0x25, 0x12, 0x28, 0xf8, 0x61, 0x87, 0x09, 0x00, 0x48, 0xe0, 0x81, 0x85, - 0x09, 0x86, 0x0b, 0xa7, 0x26, 0x0c, 0x00, 0xc0, 0x0b, 0xa1, 0x0b, 0x04, - 0x28, 0xe0, 0x16, 0x0c, 0x00, 0x80, 0x03, 0x52, 0x04, 0xf8, 0x0b, 0x04, - 0x20, 0xe0, 0x0c, 0xa6, 0x1b, 0x04, 0x2c, 0xe0, 0x3b, 0x04, 0x28, 0xe0, - 0x4b, 0x04, 0x20, 0xe0, 0x13, 0x86, 0x3b, 0x04, 0x24, 0xe0, 0x10, 0x0a, - 0x04, 0xec, 0x1a, 0xfc, 0x33, 0x88, 0x30, 0x06, 0x04, 0xec, 0x12, 0x4e, - 0x94, 0xf0, 0x32, 0x48, 0x84, 0xf0, 0x4c, 0xe4, 0x7c, 0xa4, 0xcb, 0x04, - 0x28, 0xe0, 0x14, 0x08, 0x84, 0xe1, 0xcd, 0xc9, 0xc2, 0x58, 0x90, 0x91, - 0x42, 0x4e, 0x94, 0x90, 0xc3, 0x52, 0x04, 0x98, 0x73, 0x52, 0x00, 0x80, - 0x5b, 0x04, 0x20, 0xe0, 0x5d, 0xc9, 0x52, 0x40, 0x90, 0x91, 0x42, 0x48, - 0x8c, 0x90, 0x03, 0x52, 0x04, 0x80, 0x43, 0x52, 0x08, 0x80, 0x3b, 0x04, - 0x2c, 0xe0, 0x49, 0x04, 0xb8, 0xe0, 0x33, 0x52, 0x1c, 0xf8, 0x2b, 0x04, - 0x24, 0xe0, 0x4b, 0xab, 0x23, 0x52, 0x18, 0xf8, 0x65, 0x8a, 0x4b, 0xa9, - 0xe5, 0x90, 0x4b, 0xa7, 0x22, 0x44, 0x84, 0xd0, 0x32, 0x46, 0x84, 0xd0, - 0x33, 0x52, 0x1c, 0xd8, 0x23, 0x52, 0x18, 0xd8, 0x95, 0x96, 0x20, 0x44, - 0xf9, 0x73, 0xff, 0xc0, 0x27, 0xc3, 0x23, 0x82, 0x23, 0x52, 0x18, 0xf8, - 0x24, 0x02, 0x80, 0xfb, 0x04, 0x00, 0x80, 0xfb, 0x2b, 0x8c, 0x58, 0x52, - 0x74, 0xef, 0x1b, 0x12, 0x1c, 0xf8, 0x2a, 0xfc, 0x0c, 0xe4, 0x17, 0xc3, - 0x13, 0x84, 0x13, 0x52, 0x1c, 0xf8, 0x0b, 0x12, 0x04, 0xf8, 0x14, 0x02, - 0x80, 0xfb, 0x2b, 0x8c, 0x68, 0x51, 0x74, 0xef, 0xc5, 0x87, 0x20, 0x44, - 0xe1, 0x73, 0xff, 0xc0, 0x27, 0xc7, 0x23, 0x82, 0x23, 0x52, 0x18, 0xf8, - 0x24, 0x02, 0x80, 0xfb, 0x04, 0x00, 0x80, 0xfb, 0x2b, 0x8c, 0x78, 0x57, - 0x74, 0xef, 0x1b, 0x12, 0x1c, 0xf8, 0x2a, 0xfc, 0x0c, 0xe4, 0x17, 0xc7, - 0x13, 0x84, 0x13, 0x52, 0x1c, 0xf8, 0x0b, 0x12, 0x04, 0xf8, 0x14, 0x02, - 0x80, 0xfb, 0x2b, 0x8c, 0x88, 0x56, 0x74, 0xef, 0xe5, 0x83, 0x20, 0x44, - 0xf1, 0x73, 0xff, 0xc0, 0x27, 0xc5, 0x23, 0x82, 0x23, 0x52, 0x18, 0xf8, - 0x24, 0x02, 0x80, 0xfb, 0x04, 0x00, 0x80, 0xfb, 0x2b, 0x8c, 0x18, 0x52, - 0x74, 0xef, 0x1b, 0x12, 0x1c, 0xf8, 0x2a, 0xfc, 0x0c, 0xe4, 0x17, 0xc5, - 0x13, 0x84, 0x13, 0x52, 0x1c, 0xf8, 0x0b, 0x12, 0x04, 0xf8, 0x14, 0x02, - 0x80, 0xfb, 0x2b, 0x8c, 0x28, 0x51, 0x74, 0xef, 0x7b, 0x80, 0x7c, 0xa4, - 0x08, 0x91, 0xa3, 0x52, 0x1c, 0xe0, 0xa3, 0x52, 0x24, 0xe0, 0x0b, 0xa1, - 0x83, 0x52, 0x1c, 0x80, 0x83, 0x52, 0x24, 0x80, 0x89, 0x12, 0x78, 0xf8, - 0xf6, 0x57, 0xfc, 0xef, 0x6b, 0x12, 0x1c, 0xf8, 0xab, 0x12, 0x18, 0xf8, - 0xd6, 0x57, 0xfc, 0x8f, 0x8b, 0xa3, 0xa0, 0x40, 0x00, 0x9c, 0xa5, 0x86, - 0x64, 0x00, 0x80, 0xfb, 0x1b, 0x90, 0xf8, 0x7d, 0xf8, 0xee, 0x6b, 0x80, - 0xa4, 0x00, 0x80, 0xfb, 0x1b, 0x90, 0x98, 0x7d, 0xf8, 0xee, 0x15, 0x12, - 0x28, 0xf8, 0x19, 0x02, 0xb8, 0xe0, 0x1b, 0xad, 0x95, 0x82, 0x1a, 0xa6, - 0xa0, 0x44, 0xf9, 0x73, 0xff, 0xc0, 0x27, 0xc3, 0x13, 0x94, 0x10, 0x02, - 0x08, 0xec, 0x1c, 0xe4, 0x23, 0x52, 0x18, 0xf8, 0x1b, 0x12, 0x04, 0xf8, - 0x03, 0x96, 0x03, 0x52, 0x28, 0xe0, 0x1c, 0xe6, 0x0a, 0xa6, 0x1a, 0xe4, - 0x63, 0x96, 0x63, 0x52, 0x20, 0xe0, 0x73, 0x52, 0x10, 0xe0, 0x03, 0x52, - 0x14, 0xe0, 0x13, 0x52, 0x18, 0xe0, 0x98, 0x52, 0x74, 0xef, 0x09, 0x12, - 0x8c, 0xe0, 0x0b, 0xa1, 0x01, 0x81, 0x01, 0x52, 0x90, 0xe0, 0x65, 0x82, - 0x05, 0x12, 0x30, 0xf8, 0x09, 0x00, 0xa8, 0xe0, 0x0a, 0x00, 0x0c, 0xf8, - 0x16, 0x00, 0x00, 0xc0, 0x01, 0x52, 0x90, 0xc0, 0x46, 0x41, 0x84, 0xe0, - 0x0a, 0x80, 0x0a, 0x4e, 0x9c, 0xe9, 0x1a, 0x00, 0x08, 0xe0, 0x38, 0x01, - 0x01, 0x20, 0x00, 0xc0, 0x0b, 0x12, 0x1c, 0xe0, 0x1b, 0x12, 0x24, 0xe0, - 0x2b, 0x12, 0x28, 0xe0, 0x03, 0x52, 0x2c, 0xe0, 0x0b, 0x12, 0x20, 0xe0, - 0x13, 0x52, 0x34, 0xe0, 0x23, 0x52, 0x38, 0xe0, 0x03, 0x52, 0x30, 0xe0, - 0x0c, 0x00, 0x00, 0xe2, 0xf1, 0x98, 0x0c, 0x0c, 0x7c, 0xf2, 0x93, 0xdd, - 0x13, 0xa9, 0x00, 0x00, 0xa8, 0xc1, 0x40, 0x00, 0x68, 0x04, 0xa0, 0xe0, - 0x40, 0x6c, 0x40, 0x00, 0xe8, 0x34, 0xc8, 0xe0, 0xfc, 0x91, 0x40, 0x00, - 0x68, 0x1f, 0xb8, 0xe0, 0x30, 0x16, 0x41, 0x00, 0x28, 0x39, 0x74, 0xe0, - 0xb0, 0x7e, 0x40, 0x00, 0xe8, 0x38, 0xc0, 0xe0, 0x30, 0x04, 0x41, 0x00, - 0x48, 0x1b, 0x80, 0xe0, 0x30, 0x2e, 0x40, 0x00, 0x88, 0x0c, 0xec, 0xe0, - 0x10, 0x9f, 0x40, 0x00, 0x88, 0x08, 0xb4, 0xe0, 0x10, 0x01, 0x41, 0x00, - 0x68, 0x01, 0x84, 0xe0, 0x54, 0xd6, 0x40, 0x00, 0xc8, 0x1a, 0x98, 0xe0, - 0xd0, 0xc8, 0x40, 0x00, 0x68, 0x08, 0xa0, 0xe0, 0x80, 0xdb, 0x40, 0x00, - 0xe8, 0x35, 0x94, 0xe0, 0x74, 0xff, 0x40, 0x00, 0xa8, 0x11, 0x80, 0xe0, - 0xf8, 0x89, 0x40, 0x00, 0x88, 0x16, 0xbc, 0xe0, 0x00, 0x90, 0x40, 0x00, - 0x08, 0x35, 0xb8, 0xe0, 0x7c, 0x73, 0x40, 0x00, 0x88, 0x1b, 0xc8, 0xe0, - 0xf4, 0xff, 0x40, 0x00, 0x68, 0x39, 0x80, 0xe0, 0xa4, 0xa4, 0x40, 0x00, - 0xa8, 0x16, 0xb0, 0xe0, 0x50, 0xc9, 0x40, 0x00, 0x28, 0x3a, 0x98, 0xe0, - 0x00, 0xb9, 0x00, 0x00, 0xb6, 0x85, 0x00, 0x00, -}; +#include "vd55g-fw.h" static const char * const vd55g1_tp_menu[] = { "Disabled", From 14ff18fa0ea26d1454fbc0ff4a48527b7aec820a Mon Sep 17 00:00:00 2001 From: Peter Marshall Date: Thu, 30 Jul 2026 16:03:35 -0400 Subject: [PATCH 04/10] dt-bindings: media: i2c: st,vd55g: rename and add VD55G0 variant Document the STMicroelectronics VD55G0 camera sensor. Rename the device tree bindings to represent a generic VD55G family sensor. Signed-off-by: Peter Marshall --- .../i2c/{st,vd55g1.yaml => st,vd55g.yaml} | 30 +++++++++++++++---- 1 file changed, 24 insertions(+), 6 deletions(-) rename Documentation/devicetree/bindings/media/i2c/{st,vd55g1.yaml => st,vd55g.yaml} (76%) diff --git a/Documentation/devicetree/bindings/media/i2c/st,vd55g1.yaml b/Documentation/devicetree/bindings/media/i2c/st,vd55g.yaml similarity index 76% rename from Documentation/devicetree/bindings/media/i2c/st,vd55g1.yaml rename to Documentation/devicetree/bindings/media/i2c/st,vd55g.yaml index 060ac6829b661..bd6feeb6c6ac9 100644 --- a/Documentation/devicetree/bindings/media/i2c/st,vd55g1.yaml +++ b/Documentation/devicetree/bindings/media/i2c/st,vd55g.yaml @@ -2,19 +2,21 @@ # Copyright (c) 2025 STMicroelectronics SA. %YAML 1.2 --- -$id: http://devicetree.org/schemas/media/i2c/st,vd55g1.yaml# +$id: http://devicetree.org/schemas/media/i2c/st,vd55g.yaml# $schema: http://devicetree.org/meta-schemas/core.yaml# -title: STMicroelectronics VD55G1 Global Shutter Image Sensor +title: STMicroelectronics VD55G Family Global Shutter Image Sensors maintainers: - Benjamin Mugnier - Sylvain Petinot + - Peter Marshall description: |- - The STMicroelectronics VD55G1 is a global shutter image sensor with an active - array size of 804H x 704V. It is programmable through I2C interface. The I2C - address is fixed to 0x10. + The STMicroelectronics VD55G family (VD55G0, VD55G1, and VD65G4) consists of + global shutter image sensors. The VD55G0 has an array size of 644H x 604V. + The VD55G1 and VD65G4 have an array size of 804H x 704V. They are programmable + through I2C interface. The I2C address is fixed to 0x10. Image data is sent through MIPI CSI-2, which is configured as only 1 data lane. The sensor provides 4 GPIOS that can be used for external LED signal @@ -23,13 +25,29 @@ description: |- allOf: - $ref: /schemas/media/video-interface-devices.yaml# + - if: + properties: + compatible: + contains: + const: st,vd55g0 + then: + properties: + port: + properties: + endpoint: + properties: + link-frequencies: + items: + minimum: 375000000 + properties: compatible: enum: + - st,vd55g0 - st,vd55g1 - st,vd65g4 description: - VD55G1 is the monochrome variant, while VD65G4 is the color one. + VD55G0 and VD55G1 are monochrome variants, while VD65G4 is the color variant. reg: maxItems: 1 From e531c778625a8afddd1abb58a4c4801fdc5ee920 Mon Sep 17 00:00:00 2001 From: Peter Marshall Date: Thu, 30 Jul 2026 16:03:35 -0400 Subject: [PATCH 05/10] media: ipu-bridge: Add VD55G0 to the list of supported sensors Add SMO55F0 ACPI HID for the ST VD55G0 sensor to the list of supported sensors. The sensor is found with this HID on a Microsoft Surface Pro 9 tablet. Use the lowest supported link frequency. Signed-off-by: Peter Marshall --- drivers/media/pci/intel/ipu-bridge.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/drivers/media/pci/intel/ipu-bridge.c b/drivers/media/pci/intel/ipu-bridge.c index 1ef31d6553923..562f301d47916 100644 --- a/drivers/media/pci/intel/ipu-bridge.c +++ b/drivers/media/pci/intel/ipu-bridge.c @@ -95,6 +95,8 @@ static const struct ipu_sensor_config ipu_supported_sensors[] = { IPU_SENSOR_CONFIG("OVTI2680", 1, 331200000), /* Omnivision OV8856 */ IPU_SENSOR_CONFIG("OVTI8856", 3, 180000000, 360000000, 720000000), + /* STMicroelectronics VD55G0 */ + IPU_SENSOR_CONFIG("SMO55F0", 1, 380000000), /* Toshiba T4KA3 */ IPU_SENSOR_CONFIG("XMCC0003", 1, 321468000), }; From 3241234fe4930606d86be46a627f8cc637c60941 Mon Sep 17 00:00:00 2001 From: Peter Marshall Date: Thu, 30 Jul 2026 20:23:28 -0400 Subject: [PATCH 06/10] platform/x86: int3472: Add VD55G0 supply GPIO mapping The vd55g sensor drivers / DT bindings expect non-standard supply names. Add a mapping to enable them. Signed-off-by: Peter Marshall --- drivers/platform/x86/intel/int3472/discrete.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/drivers/platform/x86/intel/int3472/discrete.c b/drivers/platform/x86/intel/int3472/discrete.c index 20962e8acb263..936cfc73fe115 100644 --- a/drivers/platform/x86/intel/int3472/discrete.c +++ b/drivers/platform/x86/intel/int3472/discrete.c @@ -164,6 +164,24 @@ static const struct int3472_gpio_map int3472_gpio_map[] = { .con_id = "dvdd", .enable_time_us = 45 * USEC_PER_MSEC, }, + { + .hid = "SMO55F0", + .type_from = INT3472_GPIO_TYPE_HANDSHAKE, + .type_to = INT3472_GPIO_TYPE_HANDSHAKE, + .con_id = "vcore", + }, + { + .hid = "SMO55F0", + .type_from = INT3472_GPIO_TYPE_DOVDD, + .type_to = INT3472_GPIO_TYPE_DOVDD, + .con_id = "vddio", + }, + { + .hid = "SMO55F0", + .type_from = INT3472_GPIO_TYPE_POWER_ENABLE, + .type_to = INT3472_GPIO_TYPE_POWER_ENABLE, + .con_id = "vana", + }, }; static void int3472_get_con_id_and_polarity(struct int3472_discrete_device *int3472, u8 *type, From a59c16335d3ecbfc8ceb3370eab3fcb17c7d29ef Mon Sep 17 00:00:00 2001 From: Peter Marshall Date: Thu, 30 Jul 2026 16:03:35 -0400 Subject: [PATCH 07/10] media: i2c: st-vd55g: Add generic driver and VD55G0 support Rewrite the existing vd55g1 module supporting ST VD55G1 and VD65G4 to make it generic for ST VD55G family global-shutter camera sensors. Registers and supported features differ between sensor generations. Replace the static register addresses and revision-specific branches with a per-chip info struct. Add support for the VD55G0 monochrome camera sensor. The VD55G0 has a native resolution of 644 x 604 pixels and does not support HDR via internal subtraction. Add a quirk limiting exposure duty cycle with strobe illumination enabled to avoid tripping overcurrent protection. Co-authored-by: Fernando Rimoli <119756054+femito1@users.noreply.github.com> Signed-off-by: Peter Marshall --- drivers/media/i2c/Kconfig | 11 + drivers/media/i2c/Makefile | 1 + drivers/media/i2c/vd55g.c | 2152 ++++++++++++++++++++++++++++++++++++ 3 files changed, 2164 insertions(+) create mode 100644 drivers/media/i2c/vd55g.c diff --git a/drivers/media/i2c/Kconfig b/drivers/media/i2c/Kconfig index cdd7ba5da0d50..a138cedbd4f25 100644 --- a/drivers/media/i2c/Kconfig +++ b/drivers/media/i2c/Kconfig @@ -745,6 +745,17 @@ config VIDEO_S5K6A3 This is a V4L2 sensor driver for Samsung S5K6A3 raw camera sensor. +config VIDEO_VD55G + tristate "ST VD55G family sensor support" + select V4L2_CCI_I2C + depends on GPIOLIB + help + This is a Video4Linux2 sensor driver for the ST VD55G family + of camera sensors. + + To compile this driver as a module, choose M here: the + module will be called vd55g. + config VIDEO_VD55G1 tristate "ST VD55G1 sensor support" select V4L2_CCI_I2C diff --git a/drivers/media/i2c/Makefile b/drivers/media/i2c/Makefile index 57cdd8dc96f63..22e6ba4728dcf 100644 --- a/drivers/media/i2c/Makefile +++ b/drivers/media/i2c/Makefile @@ -158,6 +158,7 @@ obj-$(CONFIG_VIDEO_TW9910) += tw9910.o obj-$(CONFIG_VIDEO_UDA1342) += uda1342.o obj-$(CONFIG_VIDEO_UPD64031A) += upd64031a.o obj-$(CONFIG_VIDEO_UPD64083) += upd64083.o +obj-$(CONFIG_VIDEO_VD55G) += vd55g.o obj-$(CONFIG_VIDEO_VD55G1) += vd55g1.o obj-$(CONFIG_VIDEO_VD56G3) += vd56g3.o obj-$(CONFIG_VIDEO_VGXY61) += vgxy61.o diff --git a/drivers/media/i2c/vd55g.c b/drivers/media/i2c/vd55g.c new file mode 100644 index 0000000000000..0df7e103e490a --- /dev/null +++ b/drivers/media/i2c/vd55g.c @@ -0,0 +1,2152 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Driver for VD55G family global shutter sensors + * + * Copyright (C) 2025 STMicroelectronics SA + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +/* Register Map */ +#define VD55G_REG_MODEL_ID CCI_REG32_LE(0x0000) +#define VD55G_REG_REVISION CCI_REG16_LE(0x0004) +#define VD55G_REG_FWPATCH_START_ADDR CCI_REG8(0x2000) +#define VD55G_SYSTEM_FSM_READY_TO_BOOT 0x01 +#define VD55G_SYSTEM_FSM_SW_STBY 0x02 +#define VD55G_SYSTEM_FSM_STREAMING 0x03 +#define VD55G_REG_BOOT CCI_REG8(0x0200) +#define VD55G_BOOT_BOOT 1 +#define VD55G_BOOT_PATCH 2 +#define VD55G_REG_STBY CCI_REG8(0x0201) +#define VD55G_STBY_START_STREAM 1 +#define VD55G_REG_STREAMING CCI_REG8(0x0202) +#define VD55G_STREAMING_STOP_STREAM 1 +#define VD55G_REG_EXT_CLOCK CCI_REG32_LE(0x0220) +#define VD55G_REG_LINE_LENGTH CCI_REG16_LE(0x0300) +#define VD55G_REG_ORIENTATION CCI_REG8(0x0302) +#define VD55G_REG_FORMAT_CTRL CCI_REG8(0x030a) +#define VD55G_REG_OIF_CTRL CCI_REG16_LE(0x030c) +#define VD55G_REG_OIF_IMG_CTRL CCI_REG8(0x030f) +#define VD55G_REG_MIPI_DATA_RATE CCI_REG32_LE(0x0224) +#define VD55G_PATGEN_TYPE_SHIFT 4 +#define VD55G_PATGEN_ENABLE BIT(0) +#define VD55G_READOUT_CTRL_BIN_MODE_NORMAL 0 +#define VD55G_READOUT_CTRL_BIN_MODE_DIGITAL_X2 1 +#define VD55G_DUSTER_ENABLE BIT(0) +#define VD55G_DUSTER_DISABLE 0 +#define VD55G_DUSTER_DYN_ENABLE BIT(1) +#define VD55G_DUSTER_RING_ENABLE BIT(4) +#define VD55G1_EXPOSURE_USE_CASES_MULTI_CONTEXT BIT(2) +#define VD55G1_EXPOSURE_MAX_COARSE_SUB 446 + +#define VD55G_REG_EXP_MODE(sensor, ctx) \ + CCI_REG8(vd55g_get_ctx_addr(sensor, REG_CTX_EXP_MODE, ctx)) +#define VD55G_REG_FRAME_LENGTH(sensor, ctx) \ + CCI_REG32_LE(vd55g_get_ctx_addr(sensor, REG_CTX_FRAME_LENGTH, ctx)) +#define VD55G_REG_X_START(sensor, ctx) \ + CCI_REG16_LE(vd55g_get_ctx_addr(sensor, REG_CTX_X_START, ctx)) +#define VD55G_REG_X_WIDTH_OR_END(sensor, ctx) \ + CCI_REG16_LE(vd55g_get_ctx_addr(sensor, REG_CTX_X_WIDTH_OR_END, ctx)) +#define VD55G_REG_Y_START(sensor, ctx) \ + CCI_REG16_LE(vd55g_get_ctx_addr(sensor, REG_CTX_Y_START, ctx)) +#define VD55G_REG_Y_HEIGHT_OR_END(sensor, ctx) \ + CCI_REG16_LE(vd55g_get_ctx_addr(sensor, REG_CTX_Y_HEIGHT_OR_END, ctx)) +#define VD55G_REG_GPIO_CTRL(sensor, ctx, led) \ + CCI_REG8(vd55g_get_ctx_addr(sensor, REG_CTX_GPIO_0_CTRL, ctx) + (led)) +#define VD55G_GPIO_MODE_IN 0x01 +#define VD55G_GPIO_MODE_STROBE 0x02 +#define VD55G_REG_VT_MODE(sensor, ctx) \ + CCI_REG8(vd55g_get_ctx_addr(sensor, REG_CTX_VT_MODE, ctx)) +#define VD55G1_VT_MODE_NORMAL 0 +#define VD55G1_VT_MODE_SUBTRACTION 1 +#define VD55G_REG_MASK_FRAME_CTRL(sensor, ctx) \ + CCI_REG8(vd55g_get_ctx_addr(sensor, REG_CTX_MASK_FRAME_CTRL, ctx)) +#define VD55G1_MASK_FRAME_CTRL_OUTPUT 0 +#define VD55G1_MASK_FRAME_CTRL_MASK 1 +#define VD55G_REG_EXPOSURE_INSTANCE(sensor, ctx) \ + CCI_REG32_LE(vd55g_get_ctx_addr(sensor, REG_CTX_EXPOSURE_INSTANCE, ctx)) + +#define VD55G0_WIDTH 644 +#define VD55G0_HEIGHT 604 +#define VD55G1_WIDTH 804 +#define VD55G1_HEIGHT 704 +#define VD55G_MODE_DEF 0 +#define VD55G_NB_GPIOS 4 +#define VD55G_MBUS_CODE_DEF 0 +#define VD55G_DGAIN_DEF 256 +#define VD55G_AGAIN_DEF 19 +#define VD55G_EXPO_MAX_TERM 64 +#define VD55G_EXPO_DEF 500 +#define VD55G_LINE_LENGTH_MIN 1200 +#define VD55G1_LINE_LENGTH_SUB_MIN 1344 +#define VD55G_VBLANK_MIN 86 +#define VD55G_VBLANK_MAX 0xffff +#define VD55G_FRAME_LENGTH_DEF 1860 /* 60 fps */ +#define VD55G_MIPI_MARGIN 900 +#define VD55G_XCLK_FREQ_MIN (6 * HZ_PER_MHZ) +#define VD55G_XCLK_FREQ_MAX (27 * HZ_PER_MHZ) +#define VD55G1_MIPI_RATE_MIN (250 * MEGA) +#define VD55G1_MIPI_RATE_MAX (1200 * MEGA) +#define VD55G0_MIPI_RATE_MIN (750 * MEGA) +#define VD55G0_MIPI_RATE_MAX (1200 * MEGA) + +static const char *const vd55g_tp_menu[] = { + "Disabled", + "Diagonal Grey Scale", + "Pseudo-random Noise", +}; + +static const s64 vd55g_ev_bias_menu[] = { + -3000, -2500, -2000, -1500, -1000, -500, 0, + 500, 1000, 1500, 2000, 2500, 3000, +}; + +static const char *const vd55g1_hdr_menu[] = { + "No HDR", + /* + * This mode acquires 2 frames on the sensor, the first one is ditched + * out and only used for auto exposure data, the second one is output to + * the host + */ + "Internal subtraction", +}; + +static const char *const vd55g_supply_name[] = { + "vcore", + "vddio", + "vana", +}; + +enum vd55g1_hdr_mode { + VD55G1_NO_HDR, + VD55G1_HDR_SUB, +}; + +struct vd55g_mode { + u32 width; + u32 height; +}; + +static const u32 vd55g_mbus_formats_mono[] = { + MEDIA_BUS_FMT_Y8_1X8, + MEDIA_BUS_FMT_Y10_1X10, +}; + +/* Format order is : no flip, hflip, vflip, both */ +static const u32 vd55g_mbus_formats_bayer[][4] = { + { + MEDIA_BUS_FMT_SRGGB8_1X8, + MEDIA_BUS_FMT_SGRBG8_1X8, + MEDIA_BUS_FMT_SGBRG8_1X8, + MEDIA_BUS_FMT_SBGGR8_1X8, + }, + { + MEDIA_BUS_FMT_SRGGB10_1X10, + MEDIA_BUS_FMT_SGRBG10_1X10, + MEDIA_BUS_FMT_SGBRG10_1X10, + MEDIA_BUS_FMT_SBGGR10_1X10, + }, +}; + +static const struct vd55g_mode vd55g0_supported_modes[] = { + { + .width = VD55G0_WIDTH, + .height = VD55G0_HEIGHT, + }, + { + .width = 640, + .height = 600, + }, + { + .width = 640, + .height = 480, + }, + { + .width = 320, + .height = 240, + }, +}; + +static const struct vd55g_mode vd55g1_supported_modes[] = { + { + .width = VD55G1_WIDTH, + .height = VD55G1_HEIGHT, + }, + { + .width = 800, + .height = VD55G1_HEIGHT, + }, + { + .width = 800, + .height = 600, + }, + { + .width = 640, + .height = 480, + }, + { + .width = 320, + .height = 240, + }, +}; + +enum vd55g_expo_state { + VD55G1_EXP_AUTO, + VD55G1_EXP_FREEZE, + VD55G1_EXP_MANUAL, + VD55G1_EXP_SINGLE_STEP, + VD55G1_EXP_BYPASS, +}; + +struct vd55g_vblank_limits { + u16 min; + u16 def; + u16 max; +}; + +struct vd55g_frame_timings { + u16 frame_length; + u16 expo_max; +}; + +enum vd55g_reg_id { + REG_SYSTEM_FSM, + REG_ISL_ENABLE, + REG_FWPATCH_REVISION, + REG_PATGEN_CTRL, + REG_READOUT_CTRL, + REG_DUSTER_CTRL, + REG_AE_TARGET_PERCENTAGE, + REG_MANUAL_ANALOG_GAIN, + REG_MANUAL_COARSE_EXPOSURE, + REG_MANUAL_DIGITAL_GAIN, + REG_APPLIED_COARSE_EXPOSURE, + REG_APPLIED_ANALOG_GAIN, + REG_APPLIED_DIGITAL_GAIN, + REG_AE_FORCE_COLDSTART, + REG_AE_COLDSTART_EXPOSURE_US, + REG_AE_COLDSTART_COARSE_EXPOSURE, + /* HDR-specific */ + REG_NEXT_CTX, + REG_EXPOSURE_USE_CASES, + REG_EXPOSURE_MAX_COARSE, + REG_CTX_REPEAT_COUNT_CTX0, + REG_CTX_REPEAT_COUNT_CTX1, + + /* Context-specific register bases */ + REG_CTX_STRIDE, /* Not a real register, stores the context bank offset */ + REG_CTX_REPEAT_COUNT, + REG_CTX_EXP_MODE, + REG_CTX_FRAME_LENGTH, + REG_CTX_X_START, + REG_CTX_X_WIDTH_OR_END, + REG_CTX_Y_START, + REG_CTX_Y_HEIGHT_OR_END, + REG_CTX_GPIO_0_CTRL, + /* HDR-specific */ + REG_CTX_VT_MODE, + REG_CTX_MASK_FRAME_CTRL, + REG_CTX_EXPOSURE_INSTANCE, + + REG_MAX_INDEX /* Keeps track of enum size */ +}; + +static const int vd55g0_reg_map[REG_MAX_INDEX] = { + [REG_SYSTEM_FSM] = CCI_REG8(0x002c), + [REG_ISL_ENABLE] = CCI_REG8(0x0329), + [REG_FWPATCH_REVISION] = CCI_REG16_LE(0x0022), + [REG_PATGEN_CTRL] = CCI_REG16_LE(0x0400), + [REG_READOUT_CTRL] = CCI_REG8(0x047a), + [REG_DUSTER_CTRL] = CCI_REG8(0x0316), + [REG_AE_TARGET_PERCENTAGE] = CCI_REG8(0x0440), + [REG_MANUAL_ANALOG_GAIN] = CCI_REG8(0x044d), + [REG_MANUAL_COARSE_EXPOSURE] = CCI_REG16_LE(0x044e), + [REG_MANUAL_DIGITAL_GAIN] = CCI_REG16_LE(0x0450), + [REG_APPLIED_COARSE_EXPOSURE] = CCI_REG16_LE(0x0064), + [REG_APPLIED_ANALOG_GAIN] = CCI_REG16_LE(0x0066), + [REG_APPLIED_DIGITAL_GAIN] = CCI_REG16_LE(0x0068), + [REG_AE_FORCE_COLDSTART] = CCI_REG8(0x042c), + [REG_AE_COLDSTART_COARSE_EXPOSURE] = CCI_REG32_LE(0x042e), + [REG_NEXT_CTX] = CCI_REG16_LE(0x0478), + [REG_EXPOSURE_MAX_COARSE] = CCI_REG16_LE(0x096c), + [REG_CTX_REPEAT_COUNT_CTX0] = CCI_REG16_LE(0x0476), + [REG_CTX_REPEAT_COUNT_CTX1] = CCI_REG16_LE(0x04a6), + + /* Context properties */ + [REG_CTX_STRIDE] = 0x30, + [REG_CTX_EXP_MODE] = 0x044c, + [REG_CTX_FRAME_LENGTH] = 0x0458, + [REG_CTX_X_START] = 0x045e, + [REG_CTX_X_WIDTH_OR_END] = 0x0460, + [REG_CTX_Y_START] = 0x0462, + [REG_CTX_Y_HEIGHT_OR_END] = 0x0464, + [REG_CTX_GPIO_0_CTRL] = 0x0467, +}; + +static const int vd55g1_reg_map[REG_MAX_INDEX] = { + [REG_SYSTEM_FSM] = CCI_REG8(0x001c), + [REG_ISL_ENABLE] = CCI_REG8(0x0326), + [REG_FWPATCH_REVISION] = CCI_REG16_LE(0x0012), + [REG_PATGEN_CTRL] = CCI_REG16_LE(0x0304), + [REG_READOUT_CTRL] = CCI_REG8(0x057e), + [REG_DUSTER_CTRL] = CCI_REG8(0x03ae), + [REG_AE_TARGET_PERCENTAGE] = CCI_REG8(0x0486), + [REG_MANUAL_ANALOG_GAIN] = CCI_REG8(0x0501), + [REG_MANUAL_COARSE_EXPOSURE] = CCI_REG16_LE(0x0502), + [REG_MANUAL_DIGITAL_GAIN] = CCI_REG16_LE(0x0504), + [REG_APPLIED_COARSE_EXPOSURE] = CCI_REG16_LE(0x00e8), + [REG_APPLIED_ANALOG_GAIN] = CCI_REG16_LE(0x00ea), + [REG_APPLIED_DIGITAL_GAIN] = CCI_REG16_LE(0x00ec), + [REG_AE_FORCE_COLDSTART] = CCI_REG8(0x0308), + [REG_AE_COLDSTART_EXPOSURE_US] = CCI_REG32_LE(0x0374), + [REG_NEXT_CTX] = CCI_REG16_LE(0x03e4), + [REG_EXPOSURE_USE_CASES] = CCI_REG8(0x0312), + [REG_EXPOSURE_MAX_COARSE] = CCI_REG16_LE(0x0372), + [REG_CTX_REPEAT_COUNT_CTX0] = CCI_REG16_LE(0x03dc), + [REG_CTX_REPEAT_COUNT_CTX1] = CCI_REG16_LE(0x03de), + + /* Context properties */ + [REG_CTX_STRIDE] = 0x50, + [REG_CTX_EXP_MODE] = 0x0500, + [REG_CTX_FRAME_LENGTH] = 0x050c, + [REG_CTX_X_START] = 0x0514, + [REG_CTX_X_WIDTH_OR_END] = 0x0516, + [REG_CTX_Y_START] = 0x0510, + [REG_CTX_Y_HEIGHT_OR_END] = 0x0512, + [REG_CTX_GPIO_0_CTRL] = 0x051d, + [REG_CTX_VT_MODE] = 0x0536, + [REG_CTX_MASK_FRAME_CTRL] = 0x0537, + [REG_CTX_EXPOSURE_INSTANCE] = 0x052d, +}; + +#include "vd55g-fw.h" + +struct vd55g_patch_header { + __le16 patch_size; + u8 minor; + u8 major; +} __packed; + +struct vd55g_fw_revision_map { + u64 revision; + bool needs_patch; + const char *fw_name; + const struct firmware *builtin_fw; +}; + +struct vd55g_chip_info { + unsigned int id; + const char *name; + const struct vd55g_mode *modes; + u16 num_modes; + const int *reg_map; + const struct vd55g_fw_revision_map *fw_maps; + u16 num_fw_maps; + bool needs_patch_boot; + u32 mipi_rate_min; + u32 mipi_rate_max; + u16 width; + u16 height; + bool bayer; + bool hdr; + bool absolute_endpoints; + bool ae_coldstart_exposure_in_us; + bool limit_flash_duty_cycle; +}; + +static const struct vd55g_fw_revision_map vd55g0_fw_maps[] = { + { .revision = 0x1111, .needs_patch = true, .fw_name = "vd55g0-cut1.bin" }, + { .revision = 0x1120, .needs_patch = true, .fw_name = "vd55g0-cut2.bin" }, +}; + +static const struct firmware vd55g1_builtin_fw = { + .data = vd55g1_patch_array, .size = ARRAY_SIZE(vd55g1_patch_array) +}; + +static const struct vd55g_fw_revision_map vd55g1_fw_maps[] = { + { .revision = 0x2020, .needs_patch = true, .fw_name = "vd55g1.bin", .builtin_fw = &vd55g1_builtin_fw }, +}; + +static const struct vd55g_fw_revision_map vd65g4_fw_maps[] = { + { .revision = 0x3030, .needs_patch = false }, +}; + +static const struct vd55g_chip_info vd55g0_chip_info = { + .id = 0x53354730, + .name = "vd55g0", + .modes = vd55g0_supported_modes, + .num_modes = ARRAY_SIZE(vd55g0_supported_modes), + .reg_map = vd55g0_reg_map, + .fw_maps = vd55g0_fw_maps, + .num_fw_maps = ARRAY_SIZE(vd55g0_fw_maps), + .needs_patch_boot = true, + .mipi_rate_min = VD55G0_MIPI_RATE_MIN, + .mipi_rate_max = VD55G0_MIPI_RATE_MAX, + .width = VD55G0_WIDTH, + .height = VD55G0_HEIGHT, + .bayer = false, + .hdr = false, + .absolute_endpoints = true, + .ae_coldstart_exposure_in_us = false, + .limit_flash_duty_cycle = true, +}; + +static const struct vd55g_chip_info vd55g1_chip_info = { + .id = 0x53354731, + .name = "vd55g1", + .modes = vd55g1_supported_modes, + .num_modes = ARRAY_SIZE(vd55g1_supported_modes), + .reg_map = vd55g1_reg_map, + .fw_maps = vd55g1_fw_maps, + .num_fw_maps = ARRAY_SIZE(vd55g1_fw_maps), + .needs_patch_boot = false, + .mipi_rate_min = VD55G1_MIPI_RATE_MIN, + .mipi_rate_max = VD55G1_MIPI_RATE_MAX, + .width = VD55G1_WIDTH, + .height = VD55G1_HEIGHT, + .bayer = false, + .hdr = true, + .absolute_endpoints = false, + .ae_coldstart_exposure_in_us = true, + .limit_flash_duty_cycle = false, +}; + +static const struct vd55g_chip_info vd65g4_chip_info = { + .id = 0x53354733, + .name = "vd65g4", + .modes = vd55g1_supported_modes, + .num_modes = ARRAY_SIZE(vd55g1_supported_modes), + .reg_map = vd55g1_reg_map, + .fw_maps = vd65g4_fw_maps, + .num_fw_maps = ARRAY_SIZE(vd65g4_fw_maps), + .width = VD55G1_WIDTH, + .height = VD55G1_HEIGHT, + .bayer = true, + .hdr = true, + .absolute_endpoints = false, + .ae_coldstart_exposure_in_us = true, + .limit_flash_duty_cycle = false, +}; + +struct vd55g { + struct device *dev; + struct v4l2_subdev sd; + struct media_pad pad; + struct regulator_bulk_data supplies[ARRAY_SIZE(vd55g_supply_name)]; + struct gpio_desc *reset_gpio; + struct clk *xclk; + struct regmap *regmap; + const struct vd55g_chip_info *info; + u32 xclk_freq; + u16 oif_ctrl; + u8 gpios[VD55G_NB_GPIOS]; + unsigned long ext_leds_mask; + u32 mipi_rate; + u32 pixel_clock; + u64 link_freq; + struct v4l2_ctrl_handler ctrl_handler; + struct v4l2_ctrl *pixel_rate_ctrl; + struct v4l2_ctrl *vblank_ctrl; + struct v4l2_ctrl *hblank_ctrl; + struct { + struct v4l2_ctrl *hflip_ctrl; + struct v4l2_ctrl *vflip_ctrl; + }; + struct v4l2_ctrl *patgen_ctrl; + struct { + struct v4l2_ctrl *ae_ctrl; + struct v4l2_ctrl *expo_ctrl; + struct v4l2_ctrl *again_ctrl; + struct v4l2_ctrl *dgain_ctrl; + }; + struct v4l2_ctrl *ae_lock_ctrl; + struct v4l2_ctrl *ae_bias_ctrl; + struct v4l2_ctrl *led_ctrl; + struct v4l2_ctrl *hdr_ctrl; +}; + +static inline struct vd55g *to_vd55g(struct v4l2_subdev *sd) +{ + return container_of_const(sd, struct vd55g, sd); +} + +static inline struct vd55g *ctrl_to_vd55g(struct v4l2_ctrl *ctrl) +{ + struct v4l2_subdev *sd = + &container_of_const(ctrl->handler, struct vd55g, ctrl_handler) + ->sd; + + return to_vd55g(sd); +} + +static inline int vd55g_get_ctx_addr(struct vd55g *sensor, + enum vd55g_reg_id reg, u8 ctx) +{ + u16 base_addr = sensor->info->reg_map[reg]; + u16 stride = sensor->info->reg_map[REG_CTX_STRIDE]; + + return base_addr + (stride * ctx); +} + +static unsigned int vd55g_get_fmt_bpp(u32 code) +{ + switch (code) { + case MEDIA_BUS_FMT_Y8_1X8: + case MEDIA_BUS_FMT_SRGGB8_1X8: + case MEDIA_BUS_FMT_SGRBG8_1X8: + case MEDIA_BUS_FMT_SGBRG8_1X8: + case MEDIA_BUS_FMT_SBGGR8_1X8: + default: + return 8; + + case MEDIA_BUS_FMT_Y10_1X10: + case MEDIA_BUS_FMT_SRGGB10_1X10: + case MEDIA_BUS_FMT_SGRBG10_1X10: + case MEDIA_BUS_FMT_SGBRG10_1X10: + case MEDIA_BUS_FMT_SBGGR10_1X10: + return 10; + } +} + +static unsigned int vd55g_get_fmt_data_type(u32 code) +{ + switch (code) { + case MEDIA_BUS_FMT_Y8_1X8: + case MEDIA_BUS_FMT_SRGGB8_1X8: + case MEDIA_BUS_FMT_SGRBG8_1X8: + case MEDIA_BUS_FMT_SGBRG8_1X8: + case MEDIA_BUS_FMT_SBGGR8_1X8: + default: + return MIPI_CSI2_DT_RAW8; + + case MEDIA_BUS_FMT_Y10_1X10: + case MEDIA_BUS_FMT_SRGGB10_1X10: + case MEDIA_BUS_FMT_SGRBG10_1X10: + case MEDIA_BUS_FMT_SGBRG10_1X10: + case MEDIA_BUS_FMT_SBGGR10_1X10: + return MIPI_CSI2_DT_RAW10; + } +} + +static u32 vd55g_get_fmt_code(struct vd55g *sensor, u32 code) +{ + unsigned int i, j; + + if (!sensor->info->bayer) + return code; + + for (i = 0; i < ARRAY_SIZE(vd55g_mbus_formats_bayer); i++) { + for (j = 0; j < ARRAY_SIZE(vd55g_mbus_formats_bayer[i]); j++) { + if (vd55g_mbus_formats_bayer[i][j] == code) + goto adapt_bayer_pattern; + } + } + dev_warn(sensor->dev, "Unsupported mbus format\n"); + + return code; + +adapt_bayer_pattern: + j = 0; + /* In first init_state() call, controls might not be initialized yet */ + if (sensor->hflip_ctrl && sensor->vflip_ctrl) { + j = (sensor->hflip_ctrl->val ? 1 : 0) + + (sensor->vflip_ctrl->val ? 2 : 0); + } + + return vd55g_mbus_formats_bayer[i][j]; +} + +static s32 vd55g_get_pixel_rate(struct vd55g *sensor, + struct v4l2_mbus_framefmt *format) +{ + return sensor->mipi_rate / vd55g_get_fmt_bpp(format->code); +} + +static unsigned int vd55g_get_hblank_min(struct vd55g *sensor, + struct v4l2_mbus_framefmt *format, + struct v4l2_rect *crop) +{ + u32 mipi_req_line_time; + u32 mipi_req_line_length; + u32 min_line_length; + + /* MIPI required time */ + mipi_req_line_time = (crop->width * vd55g_get_fmt_bpp(format->code) + + VD55G_MIPI_MARGIN) / + (sensor->mipi_rate / MEGA); + mipi_req_line_length = + mipi_req_line_time * sensor->pixel_clock / HZ_PER_MHZ; + + /* Absolute time required for ADCs to convert pixels */ + min_line_length = VD55G_LINE_LENGTH_MIN; + if (sensor->info->hdr) + if (sensor->hdr_ctrl->val == VD55G1_HDR_SUB) + min_line_length = VD55G1_LINE_LENGTH_SUB_MIN; + + /* Respect both constraint */ + min_line_length = max(min_line_length, mipi_req_line_length); + + return min_line_length - crop->width; +} + +static void vd55g_get_vblank_limits(struct vd55g *sensor, + struct v4l2_rect *crop, + struct vd55g_vblank_limits *limits) +{ + limits->min = VD55G_VBLANK_MIN; + limits->def = VD55G_FRAME_LENGTH_DEF - crop->height; + limits->max = VD55G_VBLANK_MAX - crop->height; +} + +static void vd55g_get_frame_timings(struct vd55g *sensor, + struct v4l2_rect *crop, + struct vd55g_frame_timings *timings) +{ + timings->frame_length = crop->height + sensor->vblank_ctrl->val; + + timings->expo_max = timings->frame_length - VD55G_EXPO_MAX_TERM; + + if (sensor->info->limit_flash_duty_cycle && + sensor->led_ctrl->val == V4L2_FLASH_LED_MODE_FLASH) { + timings->expo_max = timings->expo_max / 2; + } +} + +#define vd55g_read(sensor, reg, val, err) \ + cci_read((sensor)->regmap, reg, val, err) + +#define vd55g_write(sensor, reg, val, err) \ + cci_write((sensor)->regmap, reg, val, err) + +static int vd55g_cci_read(struct vd55g *sensor, enum vd55g_reg_id reg, u64 *val, + int *err) +{ + u32 physical_addr; + + if (err && *err) + return *err; + + physical_addr = sensor->info->reg_map[reg]; + + if (!physical_addr) { + dev_err(sensor->dev, + "Register %d not supported on this variant\n", reg); + if (err) + *err = -EOPNOTSUPP; + return -EOPNOTSUPP; + } + + return cci_read(sensor->regmap, physical_addr, val, err); +} + +static int vd55g_cci_write(struct vd55g *sensor, enum vd55g_reg_id reg, u32 val, + int *err) +{ + u32 physical_addr; + + if (err && *err) + return *err; + + physical_addr = sensor->info->reg_map[reg]; + + if (!physical_addr) { + dev_err(sensor->dev, + "Register %d not supported on this variant\n", reg); + if (err) + *err = -EOPNOTSUPP; + return -EOPNOTSUPP; + } + + return cci_write(sensor->regmap, physical_addr, val, err); +} + +static int vd55g_write_array(struct vd55g *sensor, u32 reg, unsigned int len, + const u8 *array, int *err) +{ + unsigned int chunk_sz = 1024; + unsigned int sz; + int ret = 0; + + if (err && *err) + return *err; + + /* + * This loop isn't necessary but in certains conditions (platforms, cpu + * load, etc.) it has been observed that the bulk write could timeout. + */ + while (len) { + sz = min(len, chunk_sz); + ret = regmap_bulk_write(sensor->regmap, reg, array, sz); + if (ret < 0) + goto out; + len -= sz; + reg += sz; + array += sz; + } + +out: + if (ret && err) + *err = ret; + + return ret; +} + +static int vd55g_poll_reg(struct vd55g *sensor, u32 reg, u8 poll_val, int *err) +{ + unsigned int val = 0; + int ret; + + if (err && *err) + return *err; + + ret = regmap_read_poll_timeout(sensor->regmap, CCI_REG_ADDR(reg), val, + (val == poll_val), 2000, + 500 * USEC_PER_MSEC); + + if (ret && err) + *err = ret; + + return ret; +} + +static int vd55g_wait_state(struct vd55g *sensor, int state, int *err) +{ + u32 reg = sensor->info->reg_map[REG_SYSTEM_FSM]; + + return vd55g_poll_reg(sensor, reg, state, err); +} + +static int vd55g_prepare_clock_tree(struct vd55g *sensor) +{ + u32 sys_clk, mipi_div, pixel_div; + + if (sensor->xclk_freq < VD55G_XCLK_FREQ_MIN || + sensor->xclk_freq > VD55G_XCLK_FREQ_MAX) { + dev_err(sensor->dev, + "Only %luMhz-%luMhz clock range supported. Provided %lu MHz\n", + VD55G_XCLK_FREQ_MIN / HZ_PER_MHZ, + VD55G_XCLK_FREQ_MAX / HZ_PER_MHZ, + sensor->xclk_freq / HZ_PER_MHZ); + return -EINVAL; + } + + /* MIPI bus is double data rate */ + sensor->mipi_rate = sensor->link_freq * 2; + + if (sensor->mipi_rate < sensor->info->mipi_rate_min || + sensor->mipi_rate > sensor->info->mipi_rate_max) { + dev_err(sensor->dev, + "Only %luMbps-%luMbps data rate range supported. Provided %lu Mbps\n", + sensor->info->mipi_rate_min / MEGA, + sensor->info->mipi_rate_max / MEGA, + sensor->mipi_rate / MEGA); + return -EINVAL; + } + + if (sensor->mipi_rate <= 300 * MEGA) + mipi_div = 4; + else if (sensor->mipi_rate <= 600 * MEGA) + mipi_div = 2; + else + mipi_div = 1; + + sys_clk = sensor->mipi_rate * mipi_div; + + if (sys_clk <= 780 * HZ_PER_MHZ) + pixel_div = 5; + else if (sys_clk <= 900 * HZ_PER_MHZ) + pixel_div = 6; + else + pixel_div = 8; + + sensor->pixel_clock = sys_clk / pixel_div; + + return 0; +} + +static int vd55g_update_patgen(struct vd55g *sensor, u32 patgen_index) +{ + static const u8 index2val[] = { 0x0, 0x22, 0x28 }; + u32 pattern = index2val[patgen_index]; + u32 reg = pattern << VD55G_PATGEN_TYPE_SHIFT; + u8 duster = VD55G_DUSTER_RING_ENABLE | VD55G_DUSTER_DYN_ENABLE | + VD55G_DUSTER_ENABLE; + int ret = 0; + + BUILD_BUG_ON(ARRAY_SIZE(index2val) != ARRAY_SIZE(vd55g_tp_menu)); + + if (pattern != 0) { + reg |= VD55G_PATGEN_ENABLE; + /* Take care of duster to not mess up the test pattern output */ + duster = VD55G_DUSTER_DISABLE; + } + + vd55g_cci_write(sensor, REG_DUSTER_CTRL, duster, &ret); + vd55g_cci_write(sensor, REG_PATGEN_CTRL, reg, &ret); + + return ret; +} + +static int vd55g_update_expo_cluster(struct vd55g *sensor, bool is_auto) +{ + enum vd55g_expo_state expo_state = is_auto ? VD55G1_EXP_AUTO : + VD55G1_EXP_MANUAL; + int ret = 0; + + if (sensor->ae_ctrl->is_new) { + vd55g_write(sensor, VD55G_REG_EXP_MODE(sensor, 0), expo_state, + &ret); + vd55g_cci_write(sensor, REG_EXPOSURE_MAX_COARSE, + sensor->expo_ctrl->maximum, &ret); + } + + if (sensor->info->hdr) { + if (sensor->hdr_ctrl->val == VD55G1_HDR_SUB && + sensor->hdr_ctrl->is_new) { + vd55g_write(sensor, VD55G_REG_EXP_MODE(sensor, 1), + VD55G1_EXP_BYPASS, &ret); + if (ret) + return ret; + } + } + + if (!is_auto && sensor->expo_ctrl->is_new) + vd55g_cci_write(sensor, REG_MANUAL_COARSE_EXPOSURE, + sensor->expo_ctrl->val, &ret); + + if (!is_auto && sensor->again_ctrl->is_new) + vd55g_cci_write(sensor, REG_MANUAL_ANALOG_GAIN, + sensor->again_ctrl->val, &ret); + + if (!is_auto && sensor->dgain_ctrl->is_new) + vd55g_cci_write(sensor, REG_MANUAL_DIGITAL_GAIN, + sensor->dgain_ctrl->val, &ret); + + return ret; +} + +static int vd55g_lock_exposure(struct vd55g *sensor, u32 lock_val) +{ + bool ae_lock = lock_val & V4L2_LOCK_EXPOSURE; + enum vd55g_expo_state expo_state = ae_lock ? VD55G1_EXP_FREEZE : + VD55G1_EXP_AUTO; + int ret = 0; + + if (sensor->ae_ctrl->val == V4L2_EXPOSURE_AUTO) + vd55g_write(sensor, VD55G_REG_EXP_MODE(sensor, 0), expo_state, + &ret); + + return ret; +} + +static int vd55g_read_expo_cluster(struct vd55g *sensor) +{ + u64 exposure = 0; + u64 again = 0; + u64 dgain = 0; + int ret = 0; + + vd55g_cci_read(sensor, REG_APPLIED_COARSE_EXPOSURE, &exposure, &ret); + vd55g_cci_read(sensor, REG_APPLIED_ANALOG_GAIN, &again, &ret); + vd55g_cci_read(sensor, REG_APPLIED_DIGITAL_GAIN, &dgain, &ret); + if (ret) + return ret; + + sensor->expo_ctrl->cur.val = exposure; + sensor->again_ctrl->cur.val = again; + sensor->dgain_ctrl->cur.val = dgain; + + return 0; +} + +static int vd55g_update_frame_length(struct vd55g *sensor, + unsigned int frame_length) +{ + int ret = 0; + + if (sensor->info->hdr) + if (sensor->hdr_ctrl->val == VD55G1_HDR_SUB) + vd55g_write(sensor, VD55G_REG_FRAME_LENGTH(sensor, 1), + frame_length, &ret); + vd55g_write(sensor, VD55G_REG_FRAME_LENGTH(sensor, 0), frame_length, + &ret); + + return ret; +} + +static int vd55g_update_exposure_target(struct vd55g *sensor, int index) +{ + /* + * Find auto exposure target with: default target exposure * 2^EV + * Defaut target exposure being 27 for the sensor. + */ + static const unsigned int index2exposure_target[] = { + 3, 5, 7, 10, 14, 19, 27, 38, 54, 76, 108, 153, 216, + }; + int exposure_target = index2exposure_target[index]; + + return vd55g_cci_write(sensor, REG_AE_TARGET_PERCENTAGE, + exposure_target, NULL); +} + +static int vd55g_apply_cold_start(struct vd55g *sensor, struct v4l2_rect *crop) +{ + int ret; + + if (sensor->info->ae_coldstart_exposure_in_us) { + /* + * Cold start register is a single register expressed as exposure time + * in us. This differ from status registers being a combination of + * exposure, digital gain, and analog gain, requiring the following + * format conversion. + */ + unsigned int line_length = + crop->width + sensor->hblank_ctrl->val; + unsigned int line_time_us = + DIV_ROUND_UP(line_length * MEGA, sensor->pixel_clock); + u8 d_gain = DIV_ROUND_CLOSEST(sensor->dgain_ctrl->val, 1 << 8); + u8 a_gain = + DIV_ROUND_CLOSEST(32, (32 - sensor->again_ctrl->val)); + unsigned int expo_us = + sensor->expo_ctrl->val * d_gain * a_gain * line_time_us; + vd55g_cci_write(sensor, REG_AE_COLDSTART_EXPOSURE_US, expo_us, + &ret); + } else { + vd55g_cci_write(sensor, REG_AE_COLDSTART_COARSE_EXPOSURE, + sensor->expo_ctrl->val, &ret); + } + + vd55g_cci_write(sensor, REG_AE_FORCE_COLDSTART, 1, &ret); + + return ret; +} + +static void vd55g_update_pad_fmt(struct vd55g *sensor, + const struct vd55g_mode *mode, u32 code, + struct v4l2_mbus_framefmt *fmt) +{ + fmt->code = vd55g_get_fmt_code(sensor, code); + fmt->width = mode->width; + fmt->height = mode->height; + fmt->colorspace = V4L2_COLORSPACE_RAW; + fmt->field = V4L2_FIELD_NONE; + fmt->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; + fmt->quantization = V4L2_QUANTIZATION_DEFAULT; + fmt->xfer_func = V4L2_XFER_FUNC_DEFAULT; +} + +static int vd55g_update_hdr_mode(struct vd55g *sensor) +{ + int ret = 0; + + if (!sensor->info->hdr) + return -EINVAL; + + switch (sensor->hdr_ctrl->val) { + case VD55G1_NO_HDR: + vd55g_cci_write(sensor, REG_EXPOSURE_MAX_COARSE, + sensor->expo_ctrl->maximum, &ret); + vd55g_cci_write(sensor, REG_EXPOSURE_USE_CASES, 0, &ret); + vd55g_cci_write(sensor, REG_NEXT_CTX, 0x0, &ret); + + vd55g_cci_write(sensor, REG_CTX_REPEAT_COUNT_CTX0, 0, &ret); + + vd55g_write(sensor, VD55G_REG_VT_MODE(sensor, 0), + VD55G1_VT_MODE_NORMAL, &ret); + vd55g_write(sensor, VD55G_REG_MASK_FRAME_CTRL(sensor, 0), + VD55G1_MASK_FRAME_CTRL_OUTPUT, &ret); + break; + case VD55G1_HDR_SUB: + vd55g_cci_write(sensor, REG_EXPOSURE_MAX_COARSE, + VD55G1_EXPOSURE_MAX_COARSE_SUB, &ret); + vd55g_cci_write(sensor, REG_EXPOSURE_USE_CASES, + VD55G1_EXPOSURE_USE_CASES_MULTI_CONTEXT, &ret); + vd55g_cci_write(sensor, REG_NEXT_CTX, 0x0001, &ret); + + vd55g_cci_write(sensor, REG_CTX_REPEAT_COUNT_CTX0, 1, &ret); + vd55g_cci_write(sensor, REG_CTX_REPEAT_COUNT_CTX1, 1, &ret); + + vd55g_write(sensor, VD55G_REG_VT_MODE(sensor, 0), + VD55G1_VT_MODE_NORMAL, &ret); + vd55g_write(sensor, VD55G_REG_MASK_FRAME_CTRL(sensor, 0), + VD55G1_MASK_FRAME_CTRL_MASK, &ret); + vd55g_write(sensor, VD55G_REG_EXPOSURE_INSTANCE(sensor, 0), 0, + &ret); + vd55g_write(sensor, VD55G_REG_VT_MODE(sensor, 1), + VD55G1_VT_MODE_SUBTRACTION, &ret); + vd55g_write(sensor, VD55G_REG_MASK_FRAME_CTRL(sensor, 1), + VD55G1_MASK_FRAME_CTRL_OUTPUT, &ret); + vd55g_write(sensor, VD55G_REG_EXPOSURE_INSTANCE(sensor, 1), 1, + &ret); + break; + default: + ret = -EINVAL; + } + + return ret; +} + +static int vd55g_set_framefmt(struct vd55g *sensor, + struct v4l2_mbus_framefmt *format, + struct v4l2_rect *crop) +{ + u8 binning; + int ret = 0; + int x_val, y_val; + + vd55g_write(sensor, VD55G_REG_FORMAT_CTRL, + vd55g_get_fmt_bpp(format->code), &ret); + vd55g_write(sensor, VD55G_REG_OIF_IMG_CTRL, + vd55g_get_fmt_data_type(format->code), &ret); + + switch (crop->width / format->width) { + case 1: + default: + binning = VD55G_READOUT_CTRL_BIN_MODE_NORMAL; + break; + case 2: + binning = VD55G_READOUT_CTRL_BIN_MODE_DIGITAL_X2; + break; + } + vd55g_cci_write(sensor, REG_READOUT_CTRL, binning, &ret); + + if (sensor->info->absolute_endpoints) { + x_val = crop->left + crop->width - 1; + y_val = crop->top + crop->height - 1; + } else { + x_val = crop->width; + y_val = crop->height; + } + + vd55g_write(sensor, VD55G_REG_X_START(sensor, 0), crop->left, &ret); + vd55g_write(sensor, VD55G_REG_X_WIDTH_OR_END(sensor, 0), x_val, &ret); + vd55g_write(sensor, VD55G_REG_Y_START(sensor, 0), crop->top, &ret); + vd55g_write(sensor, VD55G_REG_Y_HEIGHT_OR_END(sensor, 0), y_val, &ret); + + if (sensor->info->hdr) { + vd55g_write(sensor, VD55G_REG_X_START(sensor, 1), crop->left, + &ret); + vd55g_write(sensor, VD55G_REG_X_WIDTH_OR_END(sensor, 1), x_val, + &ret); + vd55g_write(sensor, VD55G_REG_Y_START(sensor, 1), crop->top, + &ret); + vd55g_write(sensor, VD55G_REG_Y_HEIGHT_OR_END(sensor, 1), y_val, + &ret); + } + + return ret; +} + +static int vd55g_update_gpios(struct vd55g *sensor, unsigned long gpio_mask) +{ + unsigned long io; + u8 gpio_val; + int ret = 0; + + for_each_set_bit(io, &gpio_mask, VD55G_NB_GPIOS) { + gpio_val = sensor->gpios[io]; + + if (gpio_val == VD55G_GPIO_MODE_STROBE && + sensor->led_ctrl->val == V4L2_FLASH_LED_MODE_NONE) { + gpio_val = VD55G_GPIO_MODE_IN; + if (sensor->info->hdr) { + if (sensor->hdr_ctrl->val == VD55G1_HDR_SUB) { + /* Make its context 1 counterpart strobe too */ + vd55g_write(sensor, + VD55G_REG_GPIO_CTRL(sensor, + 1, io), + gpio_val, &ret); + } + } + } + + ret = vd55g_write(sensor, VD55G_REG_GPIO_CTRL(sensor, 0, io), + gpio_val, &ret); + } + + return ret; +} + +static int vd55g_ro_ctrls_setup(struct vd55g *sensor, struct v4l2_rect *crop) +{ + return vd55g_write(sensor, VD55G_REG_LINE_LENGTH, + crop->width + sensor->hblank_ctrl->val, NULL); +} + +static void vd55g_grab_ctrls(struct vd55g *sensor, bool enable) +{ + /* These settings cannot change during stream */ + v4l2_ctrl_grab(sensor->hflip_ctrl, enable); + v4l2_ctrl_grab(sensor->vflip_ctrl, enable); + v4l2_ctrl_grab(sensor->patgen_ctrl, enable); + v4l2_ctrl_grab(sensor->hdr_ctrl, enable); +} + +static int vd55g_enable_streams(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state, u32 pad, + u64 streams_mask) +{ + struct vd55g *sensor = to_vd55g(sd); + struct v4l2_rect *crop = v4l2_subdev_state_get_crop(state, 0); + struct v4l2_mbus_framefmt *format = + v4l2_subdev_state_get_format(state, 0); + int ret; + + ret = pm_runtime_resume_and_get(sensor->dev); + if (ret < 0) + return ret; + + /* Configure output */ + vd55g_write(sensor, VD55G_REG_MIPI_DATA_RATE, sensor->mipi_rate, &ret); + vd55g_write(sensor, VD55G_REG_OIF_CTRL, sensor->oif_ctrl, &ret); + vd55g_cci_write(sensor, REG_ISL_ENABLE, 0, &ret); + if (ret) + goto err_rpm_put; + + ret = vd55g_set_framefmt(sensor, format, crop); + if (ret) + goto err_rpm_put; + + /* Setup default GPIO values; could be overridden by V4L2 ctrl setup */ + ret = vd55g_update_gpios(sensor, GENMASK(VD55G_NB_GPIOS - 1, 0)); + if (ret) + goto err_rpm_put; + + ret = vd55g_apply_cold_start(sensor, crop); + if (ret) + goto err_rpm_put; + + /* Apply settings from V4L2 ctrls */ + ret = __v4l2_ctrl_handler_setup(&sensor->ctrl_handler); + if (ret) + goto err_rpm_put; + + /* Also apply settings from read-only V4L2 ctrls */ + ret = vd55g_ro_ctrls_setup(sensor, crop); + if (ret) + goto err_rpm_put; + + /* Start streaming */ + vd55g_write(sensor, VD55G_REG_STBY, VD55G_STBY_START_STREAM, &ret); + vd55g_poll_reg(sensor, VD55G_REG_STBY, 0, &ret); + vd55g_wait_state(sensor, VD55G_SYSTEM_FSM_STREAMING, &ret); + if (ret) + goto err_rpm_put; + + vd55g_grab_ctrls(sensor, true); + + return 0; + +err_rpm_put: + pm_runtime_put(sensor->dev); + return -EINVAL; +} + +static int vd55g_disable_streams(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state, u32 pad, + u64 streams_mask) +{ + struct vd55g *sensor = to_vd55g(sd); + int ret = 0; + + /* Retrieve Expo cluster to enable coldstart of AE */ + ret = vd55g_read_expo_cluster(sensor); + + vd55g_write(sensor, VD55G_REG_STREAMING, VD55G_STREAMING_STOP_STREAM, + &ret); + vd55g_poll_reg(sensor, VD55G_REG_STREAMING, 0, &ret); + vd55g_wait_state(sensor, VD55G_SYSTEM_FSM_SW_STBY, &ret); + + if (ret) + dev_warn(sensor->dev, "Can't disable stream\n"); + + vd55g_grab_ctrls(sensor, false); + + pm_runtime_put_autosuspend(sensor->dev); + + return ret; +} + +static int vd55g_load_and_apply_patch(struct vd55g *sensor, const struct vd55g_fw_revision_map *fw_info) +{ + const struct firmware *fw; + const struct vd55g_patch_header *hdr; + u16 payload_len; + u64 hardware_version; + int ret; + + ret = request_firmware(&fw, fw_info->fw_name, sensor->dev); + + if (ret == -ENOENT && fw_info->builtin_fw) { + dev_info(sensor->dev, + "External firmware %s not found, using built-in defaults\n", + fw_info->fw_name); + fw = fw_info->builtin_fw; + } else if (ret) { + dev_err(sensor->dev, + "Failed to load required firmware %s: %d\n", + fw_info->fw_name, + ret); + return ret; + } + + if (fw->size < sizeof(*hdr)) { + dev_err(sensor->dev, + "Patch file is too small to contain a header\n"); + return -EINVAL; + } + + hdr = (const struct vd55g_patch_header *)fw->data; + payload_len = le16_to_cpu(hdr->patch_size); + + if (payload_len > fw->size) { + dev_err(sensor->dev, + "Patch payload length mismatch in header\n"); + return -EINVAL; + } + + vd55g_write_array(sensor, VD55G_REG_FWPATCH_START_ADDR, fw->size, + fw->data, &ret); + vd55g_write(sensor, VD55G_REG_BOOT, VD55G_BOOT_PATCH, &ret); + vd55g_poll_reg(sensor, VD55G_REG_BOOT, 0, &ret); + if (ret) { + dev_err(sensor->dev, "Failed to apply patch\n"); + return ret; + } + + ret = vd55g_cci_read(sensor, REG_FWPATCH_REVISION, &hardware_version, + &ret); + if (ret) + return ret; + + if ((hardware_version & 0xFFFF) != ((hdr->major << 8) | hdr->minor)) { + dev_err(sensor->dev, + "Bad patch version expected %d.%d got %d.%d\n", + hdr->major, hdr->minor, (u8)(hardware_version >> 8), + (u8)(hardware_version & 0xff)); + return -ENODEV; + } + + dev_dbg(sensor->dev, "patch %d.%d applied\n", + (u8)(hardware_version >> 8), (u8)(hardware_version & 0xff)); + return 0; +} + +static int vd55g_get_firmware_name(struct vd55g *sensor, u64 revision, + const struct vd55g_fw_revision_map **fw_info) +{ + for (int i = 0; i < sensor->info->num_fw_maps; i++) { + const struct vd55g_fw_revision_map *map = &sensor->info->fw_maps[i]; + + if (map->revision == revision) { + *fw_info = map; + return 0; + } + } + + return -ENOENT; +} + +static int vd55g_boot(struct vd55g *sensor) +{ + int ret = 0; + u64 rev; + const struct vd55g_fw_revision_map *fw_info; + + ret = vd55g_read(sensor, VD55G_REG_REVISION, &rev, NULL); + if (ret) + return ret; + + ret = vd55g_get_firmware_name(sensor, rev, &fw_info); + if (ret == -ENOENT) { + dev_err(sensor->dev, + "Unsupported sensor revision 0x%x for sensor %s\n", + (u16)rev, sensor->info->name); + return -ENODEV; + } + + if (fw_info->needs_patch) + vd55g_load_and_apply_patch(sensor, fw_info); + + if (!fw_info->needs_patch || sensor->info->needs_patch_boot) { + vd55g_write(sensor, VD55G_REG_BOOT, VD55G_BOOT_BOOT, &ret); + vd55g_poll_reg(sensor, VD55G_REG_BOOT, 0, &ret); + if (ret) { + dev_err(sensor->dev, "Failed to boot\n"); + return ret; + } + } + + ret = vd55g_wait_state(sensor, VD55G_SYSTEM_FSM_SW_STBY, NULL); + if (ret) { + dev_err(sensor->dev, "Sensor waiting after boot failed\n"); + return ret; + } + + return 0; +} + +static int vd55g_get_selection(struct v4l2_subdev *sd, + struct v4l2_subdev_state *sd_state, + struct v4l2_subdev_selection *sel) +{ + struct vd55g *sensor = to_vd55g(sd); + const struct v4l2_rect *crop = v4l2_subdev_state_get_crop(sd_state, 0); + + switch (sel->target) { + case V4L2_SEL_TGT_CROP: + sel->r = *crop; + return 0; + case V4L2_SEL_TGT_NATIVE_SIZE: + case V4L2_SEL_TGT_CROP_DEFAULT: + case V4L2_SEL_TGT_CROP_BOUNDS: + sel->r.top = 0; + sel->r.left = 0; + sel->r.width = sensor->info->width; + sel->r.height = sensor->info->height; + return 0; + } + + return -EINVAL; +} + +static int vd55g_enum_mbus_code(struct v4l2_subdev *sd, + struct v4l2_subdev_state *sd_state, + struct v4l2_subdev_mbus_code_enum *code) +{ + struct vd55g *sensor = to_vd55g(sd); + u32 base_code; + + if (!sensor->info->bayer) { + if (code->index >= ARRAY_SIZE(vd55g_mbus_formats_mono)) + return -EINVAL; + base_code = vd55g_mbus_formats_mono[code->index]; + } else { + if (code->index >= ARRAY_SIZE(vd55g_mbus_formats_bayer)) + return -EINVAL; + base_code = vd55g_mbus_formats_bayer[code->index][0]; + } + code->code = vd55g_get_fmt_code(sensor, base_code); + + return 0; +} + +static int vd55g_new_format_change_controls(struct vd55g *sensor, + struct v4l2_mbus_framefmt *format, + struct v4l2_rect *crop) +{ + struct vd55g_vblank_limits vblank; + struct vd55g_frame_timings timings; + unsigned int hblank; + int ret; + + /* Reset vblank and frame length to default */ + vd55g_get_vblank_limits(sensor, crop, &vblank); + ret = __v4l2_ctrl_modify_range(sensor->vblank_ctrl, vblank.min, + vblank.max, 1, vblank.def); + if (ret) + return ret; + + /* Max exposure changes with vblank */ + vd55g_get_frame_timings(sensor, crop, &timings); + ret = __v4l2_ctrl_modify_range(sensor->expo_ctrl, 0, timings.expo_max, + 1, VD55G_EXPO_DEF); + if (ret) + return ret; + + /* Update pixel rate to reflect new bpp */ + ret = __v4l2_ctrl_s_ctrl_int64(sensor->pixel_rate_ctrl, + vd55g_get_pixel_rate(sensor, format)); + if (ret) + return ret; + + /* Update hblank according to new width */ + hblank = vd55g_get_hblank_min(sensor, format, crop); + ret = __v4l2_ctrl_modify_range(sensor->hblank_ctrl, hblank, hblank, 1, + hblank); + + return ret; +} + +static int vd55g_set_pad_fmt(struct v4l2_subdev *sd, + struct v4l2_subdev_state *sd_state, + struct v4l2_subdev_format *sd_fmt) +{ + struct vd55g *sensor = to_vd55g(sd); + const struct vd55g_mode *new_mode; + struct v4l2_mbus_framefmt *format; + struct v4l2_rect pad_crop; + unsigned int binning; + + new_mode = v4l2_find_nearest_size(sensor->info->modes, + sensor->info->num_modes, width, + height, sd_fmt->format.width, + sd_fmt->format.height); + + vd55g_update_pad_fmt(sensor, new_mode, sd_fmt->format.code, + &sd_fmt->format); + + /* + * Use binning to maximize the crop rectangle size, and centre it in the + * sensor. + */ + binning = min(sensor->info->width / sd_fmt->format.width, + sensor->info->height / sd_fmt->format.height); + binning = min(binning, 2U); + pad_crop.width = sd_fmt->format.width * binning; + pad_crop.height = sd_fmt->format.height * binning; + pad_crop.left = (sensor->info->width - pad_crop.width) / 2; + pad_crop.top = (sensor->info->height - pad_crop.height) / 2; + + format = v4l2_subdev_state_get_format(sd_state, sd_fmt->pad); + + *format = sd_fmt->format; + + *v4l2_subdev_state_get_crop(sd_state, sd_fmt->pad) = pad_crop; + if (sd_fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) + return vd55g_new_format_change_controls(sensor, &sd_fmt->format, + &pad_crop); + + return 0; +} + +static int vd55g_init_state(struct v4l2_subdev *sd, + struct v4l2_subdev_state *sd_state) +{ + struct vd55g *sensor = to_vd55g(sd); + struct v4l2_subdev_format fmt = { 0 }; + struct v4l2_subdev_route routes[] = { + { .flags = V4L2_SUBDEV_ROUTE_FL_ACTIVE } + }; + struct v4l2_subdev_krouting routing = { + .num_routes = ARRAY_SIZE(routes), + .routes = routes, + }; + int ret; + + /* Needed by v4l2_subdev_s_stream_helper(), even with 1 stream only */ + ret = v4l2_subdev_set_routing(sd, sd_state, &routing); + if (ret) + return ret; + + vd55g_update_pad_fmt(sensor, &sensor->info->modes[VD55G_MODE_DEF], + vd55g_get_fmt_code(sensor, VD55G_MBUS_CODE_DEF), + &fmt.format); + + return vd55g_set_pad_fmt(sd, sd_state, &fmt); +} + +static int vd55g_enum_frame_size(struct v4l2_subdev *sd, + struct v4l2_subdev_state *sd_state, + struct v4l2_subdev_frame_size_enum *fse) +{ + struct vd55g *sensor = to_vd55g(sd); + u32 code; + + if (fse->index >= sensor->info->num_modes) + return -EINVAL; + + code = vd55g_get_fmt_code(sensor, fse->code); + if (fse->code != code) + return -EINVAL; + + fse->min_width = sensor->info->modes[fse->index].width; + fse->max_width = fse->min_width; + fse->min_height = sensor->info->modes[fse->index].height; + fse->max_height = fse->min_height; + + return 0; +} + +static const struct v4l2_subdev_internal_ops vd55g_internal_ops = { + .init_state = vd55g_init_state, +}; + +static const struct v4l2_subdev_pad_ops vd55g_pad_ops = { + .enum_mbus_code = vd55g_enum_mbus_code, + .get_fmt = v4l2_subdev_get_fmt, + .set_fmt = vd55g_set_pad_fmt, + .get_selection = vd55g_get_selection, + .enum_frame_size = vd55g_enum_frame_size, + .enable_streams = vd55g_enable_streams, + .disable_streams = vd55g_disable_streams, +}; + +static const struct v4l2_subdev_video_ops vd55g_video_ops = { + .s_stream = v4l2_subdev_s_stream_helper, +}; + +static const struct v4l2_subdev_ops vd55g_subdev_ops = { + .video = &vd55g_video_ops, + .pad = &vd55g_pad_ops, +}; + +static int vd55g_g_volatile_ctrl(struct v4l2_ctrl *ctrl) +{ + struct vd55g *sensor = ctrl_to_vd55g(ctrl); + int ret = 0; + + /* Interact with HW only when it is powered ON */ + if (!pm_runtime_get_if_in_use(sensor->dev)) + return 0; + + switch (ctrl->id) { + case V4L2_CID_EXPOSURE_AUTO: + ret = vd55g_read_expo_cluster(sensor); + break; + default: + ret = -EINVAL; + break; + } + + pm_runtime_put_autosuspend(sensor->dev); + + return ret; +} + +static int vd55g_s_ctrl(struct v4l2_ctrl *ctrl) +{ + struct vd55g *sensor = ctrl_to_vd55g(ctrl); + struct v4l2_subdev_state *state = + v4l2_subdev_get_locked_active_state(&sensor->sd); + struct v4l2_rect *crop = v4l2_subdev_state_get_crop(state, 0); + struct v4l2_mbus_framefmt *format = + v4l2_subdev_state_get_format(state, 0); + unsigned int hblank = vd55g_get_hblank_min(sensor, format, crop); + struct vd55g_frame_timings timings; + bool is_auto = false; + int ret = 0; + + if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY) + return 0; + + /* Update controls state, range, etc. whatever the state of the HW */ + switch (ctrl->id) { + case V4L2_CID_VBLANK: + case V4L2_CID_FLASH_LED_MODE: + vd55g_get_frame_timings(sensor, crop, &timings); + ret = __v4l2_ctrl_modify_range(sensor->expo_ctrl, 0, + timings.expo_max, 1, + VD55G_EXPO_DEF); + break; + case V4L2_CID_EXPOSURE_AUTO: + is_auto = (ctrl->val == V4L2_EXPOSURE_AUTO); + __v4l2_ctrl_grab(sensor->ae_lock_ctrl, !is_auto); + __v4l2_ctrl_grab(sensor->ae_bias_ctrl, !is_auto); + break; + case V4L2_CID_HDR_SENSOR_MODE: + /* Discriminate if the userspace changed the control value */ + if (ctrl->val != ctrl->cur.val) { + /* Max horizontal blanking changes with hdr mode */ + ret = __v4l2_ctrl_modify_range(sensor->hblank_ctrl, + hblank, hblank, 1, + hblank); + } + break; + default: + break; + } + + /* Don't modify hardware if controls modification failed */ + if (ret) + return ret; + + /* Interact with HW only when it is powered ON */ + if (!pm_runtime_get_if_in_use(sensor->dev)) + return 0; + + switch (ctrl->id) { + case V4L2_CID_HFLIP: + ret = vd55g_write(sensor, VD55G_REG_ORIENTATION, + sensor->hflip_ctrl->val | + (sensor->vflip_ctrl->val << 1), + NULL); + break; + case V4L2_CID_TEST_PATTERN: + ret = vd55g_update_patgen(sensor, ctrl->val); + break; + case V4L2_CID_EXPOSURE_AUTO: + ret = vd55g_update_expo_cluster(sensor, is_auto); + break; + case V4L2_CID_3A_LOCK: + ret = vd55g_lock_exposure(sensor, ctrl->val); + break; + case V4L2_CID_AUTO_EXPOSURE_BIAS: + /* + * We use auto exposure target percentage register to control + * exposure bias for more precision. + */ + ret = vd55g_update_exposure_target(sensor, ctrl->val); + break; + case V4L2_CID_VBLANK: + ret = vd55g_update_frame_length(sensor, timings.frame_length); + break; + case V4L2_CID_FLASH_LED_MODE: + ret = vd55g_update_gpios(sensor, sensor->ext_leds_mask); + break; + case V4L2_CID_HDR_SENSOR_MODE: + ret = vd55g_update_hdr_mode(sensor); + break; + default: + ret = -EINVAL; + break; + } + + pm_runtime_put_autosuspend(sensor->dev); + + return ret; +} + +static const struct v4l2_ctrl_ops vd55g_ctrl_ops = { + .g_volatile_ctrl = vd55g_g_volatile_ctrl, + .s_ctrl = vd55g_s_ctrl, +}; + +static int vd55g_init_ctrls(struct vd55g *sensor) +{ + const struct v4l2_ctrl_ops *ops = &vd55g_ctrl_ops; + struct v4l2_ctrl_handler *hdl = &sensor->ctrl_handler; + struct v4l2_ctrl *ctrl; + struct v4l2_fwnode_device_properties fwnode_props; + struct vd55g_vblank_limits vblank; + unsigned int hblank; + struct v4l2_subdev_state *state = + v4l2_subdev_lock_and_get_active_state(&sensor->sd); + struct v4l2_rect *crop = v4l2_subdev_state_get_crop(state, 0); + struct v4l2_mbus_framefmt *format = + v4l2_subdev_state_get_format(state, 0); + s32 pixel_rate = vd55g_get_pixel_rate(sensor, format); + int ret; + + v4l2_ctrl_handler_init(hdl, 16); + + /* Flip cluster */ + sensor->hflip_ctrl = + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_HFLIP, 0, 1, 1, 0); + if (sensor->hflip_ctrl) + sensor->hflip_ctrl->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT; + sensor->vflip_ctrl = + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_VFLIP, 0, 1, 1, 0); + if (sensor->vflip_ctrl) + sensor->vflip_ctrl->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT; + v4l2_ctrl_cluster(2, &sensor->hflip_ctrl); + + /* Exposition cluster */ + sensor->ae_ctrl = v4l2_ctrl_new_std_menu(hdl, ops, + V4L2_CID_EXPOSURE_AUTO, 1, + ~0x3, V4L2_EXPOSURE_AUTO); + sensor->again_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_ANALOGUE_GAIN, + 0, 0x1c, 1, VD55G_AGAIN_DEF); + sensor->dgain_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_DIGITAL_GAIN, + 256, 0xffff, 1, VD55G_DGAIN_DEF); + sensor->expo_ctrl = + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_EXPOSURE, 0, + VD55G_FRAME_LENGTH_DEF - VD55G_EXPO_MAX_TERM, + 1, VD55G_EXPO_DEF); + v4l2_ctrl_auto_cluster(4, &sensor->ae_ctrl, V4L2_EXPOSURE_MANUAL, true); + + sensor->patgen_ctrl = + v4l2_ctrl_new_std_menu_items(hdl, ops, V4L2_CID_TEST_PATTERN, + ARRAY_SIZE(vd55g_tp_menu) - 1, 0, + 0, vd55g_tp_menu); + ctrl = v4l2_ctrl_new_int_menu(hdl, ops, V4L2_CID_LINK_FREQ, 0, 0, + &sensor->link_freq); + if (ctrl) + ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; + sensor->pixel_rate_ctrl = v4l2_ctrl_new_std(hdl, ops, + V4L2_CID_PIXEL_RATE, 1, + INT_MAX, 1, pixel_rate); + if (sensor->pixel_rate_ctrl) + sensor->pixel_rate_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; + sensor->ae_lock_ctrl = + v4l2_ctrl_new_std(hdl, ops, V4L2_CID_3A_LOCK, 0, 1, 0, 0); + sensor->ae_bias_ctrl = + v4l2_ctrl_new_int_menu(hdl, ops, V4L2_CID_AUTO_EXPOSURE_BIAS, + ARRAY_SIZE(vd55g_ev_bias_menu) - 1, + ARRAY_SIZE(vd55g_ev_bias_menu) / 2, + vd55g_ev_bias_menu); + if (sensor->info->hdr) { + sensor->hdr_ctrl = + v4l2_ctrl_new_std_menu_items(hdl, ops, + V4L2_CID_HDR_SENSOR_MODE, + ARRAY_SIZE(vd55g1_hdr_menu) - 1, + 0, VD55G1_NO_HDR, + vd55g1_hdr_menu); + } + hblank = vd55g_get_hblank_min(sensor, format, crop); + sensor->hblank_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_HBLANK, + hblank, hblank, 1, hblank); + if (sensor->hblank_ctrl) + sensor->hblank_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; + vd55g_get_vblank_limits(sensor, crop, &vblank); + sensor->vblank_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_VBLANK, + vblank.min, vblank.max, 1, + vblank.def); + + /* Additional controls based on device tree properties */ + if (sensor->ext_leds_mask) { + sensor->led_ctrl = + v4l2_ctrl_new_std_menu(hdl, ops, + V4L2_CID_FLASH_LED_MODE, + V4L2_FLASH_LED_MODE_FLASH, 0, + V4L2_FLASH_LED_MODE_NONE); + } + + ret = v4l2_fwnode_device_parse(sensor->dev, &fwnode_props); + if (ret) + goto free_ctrls; + + ret = v4l2_ctrl_new_fwnode_properties(hdl, ops, &fwnode_props); + if (ret) + goto free_ctrls; + + sensor->sd.ctrl_handler = hdl; + goto unlock_state; + +free_ctrls: + v4l2_ctrl_handler_free(hdl); +unlock_state: + v4l2_subdev_unlock_state(state); + return ret; +} + +static int vd55g_detect(struct vd55g *sensor) +{ + const struct vd55g_chip_info *info; + u64 id; + int ret; + + info = device_get_match_data(sensor->dev); + + sensor->info = info; + + ret = vd55g_wait_state(sensor, VD55G_SYSTEM_FSM_READY_TO_BOOT, NULL); + if (ret) + return ret; + + ret = vd55g_read(sensor, VD55G_REG_MODEL_ID, &id, NULL); + if (ret) + return ret; + + if (id != sensor->info->id) { + dev_err(sensor->dev, + "Expected %s (0x%x), but detected mismatched sensor id 0x%x\n", + sensor->info->name, (u32)sensor->info->id, (u32)id); + return -ENODEV; + } + + return 0; +} + +static int vd55g_power_on(struct device *dev) +{ + struct v4l2_subdev *sd = dev_get_drvdata(dev); + struct vd55g *sensor = to_vd55g(sd); + int ret; + + ret = regulator_bulk_enable(ARRAY_SIZE(vd55g_supply_name), + sensor->supplies); + if (ret) { + dev_err(dev, "Failed to enable regulators %d\n", ret); + return ret; + } + + ret = clk_prepare_enable(sensor->xclk); + if (ret) { + dev_err(dev, "Failed to enable clock %d\n", ret); + goto disable_bulk; + } + + gpiod_set_value_cansleep(sensor->reset_gpio, 0); + usleep_range(5000, 10000); + ret = vd55g_detect(sensor); + if (ret) { + dev_err(dev, "Sensor detect failed %d\n", ret); + goto disable_clock; + } + + ret = vd55g_prepare_clock_tree(sensor); + if (ret) + goto disable_clock; + + /* Setup clock now to advance through system FSM states */ + vd55g_write(sensor, VD55G_REG_EXT_CLOCK, sensor->xclk_freq, &ret); + + ret = vd55g_boot(sensor); + if (ret) { + dev_err(dev, "Sensor boot failed %d\n", ret); + goto disable_clock; + } + + return 0; + +disable_clock: + gpiod_set_value_cansleep(sensor->reset_gpio, 1); + clk_disable_unprepare(sensor->xclk); +disable_bulk: + regulator_bulk_disable(ARRAY_SIZE(vd55g_supply_name), sensor->supplies); + + return ret; +} + +static int vd55g_power_off(struct device *dev) +{ + struct v4l2_subdev *sd = dev_get_drvdata(dev); + struct vd55g *sensor = to_vd55g(sd); + + gpiod_set_value_cansleep(sensor->reset_gpio, 1); + clk_disable_unprepare(sensor->xclk); + regulator_bulk_disable(ARRAY_SIZE(sensor->supplies), sensor->supplies); + + return 0; +} + +static int vd55g_check_csi_conf(struct vd55g *sensor, + struct fwnode_handle *endpoint) +{ + struct v4l2_fwnode_endpoint ep = { .bus_type = V4L2_MBUS_CSI2_DPHY }; + u8 n_lanes; + int ret; + + ret = v4l2_fwnode_endpoint_alloc_parse(endpoint, &ep); + fwnode_handle_put(endpoint); + if (ret) + return ret; + + /* Check lanes number */ + n_lanes = ep.bus.mipi_csi2.num_data_lanes; + if (n_lanes != 1) { + dev_err(sensor->dev, "Sensor only supports 1 lane, found %d\n", + n_lanes); + ret = -EINVAL; + goto done; + } + + /* Clock lane must be first */ + if (ep.bus.mipi_csi2.clock_lane != 0) { + dev_err(sensor->dev, "Clock lane must be mapped to lane 0\n"); + ret = -EINVAL; + goto done; + } + + /* Handle polarities in sensor configuration */ + sensor->oif_ctrl = (ep.bus.mipi_csi2.lane_polarities[0] << 3) | + (ep.bus.mipi_csi2.lane_polarities[1] << 6); + + /* Check the link frequency set in device tree */ + if (!ep.nr_of_link_frequencies) { + dev_err(sensor->dev, + "link-frequency property not found in DT\n"); + ret = -EINVAL; + goto done; + } + if (ep.nr_of_link_frequencies != 1) { + dev_err(sensor->dev, + "Multiple link frequencies not supported\n"); + ret = -EINVAL; + goto done; + } + sensor->link_freq = ep.link_frequencies[0]; + +done: + v4l2_fwnode_endpoint_free(&ep); + + return ret; +} + +static int vd55g_parse_dt_gpios_array(struct vd55g *sensor, char *prop_name, + u32 *array, int *nb) +{ + unsigned int i; + int ret; + + *nb = device_property_count_u32(sensor->dev, prop_name); + if (*nb == -EINVAL) { + /* Property not found */ + *nb = 0; + return 0; + } + + ret = device_property_read_u32_array(sensor->dev, prop_name, array, + *nb); + if (ret) { + dev_err(sensor->dev, "Failed to read %s prop\n", prop_name); + return ret; + } + for (i = 0; i < *nb; i++) { + if (array[i] >= VD55G_NB_GPIOS) { + dev_err(sensor->dev, "Invalid GPIO number %d\n", + array[i]); + return -EINVAL; + } + } + + return 0; +} + +static int vd55g_parse_dt_gpios(struct vd55g *sensor) +{ + u32 led_gpios[VD55G_NB_GPIOS]; + int nb_gpios_leds; + unsigned int i; + int ret; + + /* Initialize GPIOs to default */ + for (i = 0; i < VD55G_NB_GPIOS; i++) + sensor->gpios[i] = VD55G_GPIO_MODE_IN; + sensor->ext_leds_mask = 0; + + /* Take into account optional 'st,leds' output for GPIOs */ + ret = vd55g_parse_dt_gpios_array(sensor, "st,leds", led_gpios, + &nb_gpios_leds); + if (ret) + return ret; + + for (i = 0; i < nb_gpios_leds; i++) { + sensor->gpios[led_gpios[i]] = VD55G_GPIO_MODE_STROBE; + set_bit(led_gpios[i], &sensor->ext_leds_mask); + } + + if (nb_gpios_leds == 0) { + sensor->gpios[1] = VD55G_GPIO_MODE_STROBE; + set_bit(1, &sensor->ext_leds_mask); + } + + return 0; +} + +static int vd55g_parse_dt(struct vd55g *sensor) +{ + struct fwnode_handle *endpoint; + int ret; + + endpoint = + fwnode_graph_get_next_endpoint(dev_fwnode(sensor->dev), NULL); + if (!endpoint) + return dev_err_probe(sensor->dev, -EPROBE_DEFER, + "waiting for fwnode graph endpoint\n"); + + ret = vd55g_check_csi_conf(sensor, endpoint); + if (ret) + return ret; + + return vd55g_parse_dt_gpios(sensor); +} + +static int vd55g_subdev_init(struct vd55g *sensor) +{ + int ret; + + /* Init sub device */ + sensor->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; + sensor->sd.internal_ops = &vd55g_internal_ops; + + /* Init source pad */ + sensor->pad.flags = MEDIA_PAD_FL_SOURCE; + sensor->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; + ret = media_entity_pads_init(&sensor->sd.entity, 1, &sensor->pad); + if (ret) { + dev_err(sensor->dev, "Failed to init media entity: %d\n", ret); + return ret; + } + + sensor->sd.state_lock = sensor->ctrl_handler.lock; + ret = v4l2_subdev_init_finalize(&sensor->sd); + if (ret) { + dev_err(sensor->dev, "Subdev init error: %d\n", ret); + goto err_ctrls; + } + + /* + * Initialize controls after v4l2_subdev_init_finalize() to make sure + * active state is set + */ + ret = vd55g_init_ctrls(sensor); + if (ret) { + dev_err(sensor->dev, "Controls initialization failed %d\n", + ret); + goto err_media; + } + + return 0; + +err_ctrls: + v4l2_ctrl_handler_free(sensor->sd.ctrl_handler); + +err_media: + media_entity_cleanup(&sensor->sd.entity); + return ret; +} + +static void vd55g_subdev_cleanup(struct vd55g *sensor) +{ + v4l2_async_unregister_subdev(&sensor->sd); + v4l2_subdev_cleanup(&sensor->sd); + media_entity_cleanup(&sensor->sd.entity); + v4l2_ctrl_handler_free(sensor->sd.ctrl_handler); +} + +static int vd55g_get_regulators(struct vd55g *sensor) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(vd55g_supply_name); i++) + sensor->supplies[i].supply = vd55g_supply_name[i]; + + return devm_regulator_bulk_get(sensor->dev, + ARRAY_SIZE(vd55g_supply_name), + sensor->supplies); +} + +static int vd55g_probe(struct i2c_client *client) +{ + struct device *dev = &client->dev; + struct vd55g *sensor; + int ret; + + sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL); + if (!sensor) + return -ENOMEM; + sensor->dev = &client->dev; + + v4l2_i2c_subdev_init(&sensor->sd, client, &vd55g_subdev_ops); + + ret = vd55g_parse_dt(sensor); + if (ret) + return dev_err_probe(dev, ret, "Failed to parse Device Tree\n"); + + /* Get (and check) resources : power regs, ext clock, reset gpio */ + ret = vd55g_get_regulators(sensor); + if (ret) + return dev_err_probe(dev, ret, "Failed to get regulators\n"); + + sensor->xclk = devm_v4l2_sensor_clk_get(dev, NULL); + if (IS_ERR(sensor->xclk)) + return dev_err_probe(dev, PTR_ERR(sensor->xclk), + "Failed to get xclk\n"); + + sensor->xclk_freq = clk_get_rate(sensor->xclk); + + sensor->reset_gpio = + devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH); + if (IS_ERR(sensor->reset_gpio)) + return dev_err_probe(dev, PTR_ERR(sensor->reset_gpio), + "Failed to get reset gpio\n"); + + sensor->regmap = devm_cci_regmap_init_i2c(client, 16); + if (IS_ERR(sensor->regmap)) + return dev_err_probe(dev, PTR_ERR(sensor->regmap), + "Failed to init regmap\n"); + + /* Detect if sensor is present and if its revision is supported */ + ret = vd55g_power_on(dev); + if (ret) + return ret; + + /* Enable pm_runtime and power off the sensor */ + pm_runtime_set_active(dev); + pm_runtime_get_noresume(dev); + pm_runtime_enable(dev); + pm_runtime_set_autosuspend_delay(dev, 4000); + pm_runtime_use_autosuspend(dev); + pm_runtime_put_autosuspend(dev); + + ret = vd55g_subdev_init(sensor); + if (ret) { + dev_err(dev, "V4l2 init failed: %d\n", ret); + goto err_power_off; + } + + ret = v4l2_async_register_subdev(&sensor->sd); + if (ret) { + dev_err(dev, "async subdev register failed %d\n", ret); + goto err_subdev; + } + + return 0; + +err_subdev: + vd55g_subdev_cleanup(sensor); +err_power_off: + pm_runtime_disable(dev); + pm_runtime_put_noidle(dev); + pm_runtime_dont_use_autosuspend(dev); + vd55g_power_off(dev); + + return ret; +} + +static void vd55g_remove(struct i2c_client *client) +{ + struct v4l2_subdev *sd = i2c_get_clientdata(client); + struct vd55g *sensor = to_vd55g(sd); + + vd55g_subdev_cleanup(sensor); + + pm_runtime_disable(&client->dev); + if (!pm_runtime_status_suspended(&client->dev)) + vd55g_power_off(&client->dev); + pm_runtime_set_suspended(&client->dev); + pm_runtime_dont_use_autosuspend(&client->dev); +} + +static const struct acpi_device_id vd55g_acpi_match[] = { + { "SMO55F0", (kernel_ulong_t)&vd55g0_chip_info }, + { /* sentinel */ } +}; +MODULE_DEVICE_TABLE(acpi, vd55g_acpi_match); + +static const struct of_device_id vd55g_dt_ids[] = { + { .compatible = "st,vd55g0", .data = &vd55g0_chip_info }, + { .compatible = "st,vd55g1", .data = &vd55g1_chip_info }, + { .compatible = "st,vd65g4", .data = &vd65g4_chip_info }, + { /* sentinel */ } +}; +MODULE_DEVICE_TABLE(of, vd55g_dt_ids); + +static const struct dev_pm_ops vd55g_pm_ops = { + SET_RUNTIME_PM_OPS(vd55g_power_off, vd55g_power_on, NULL) +}; + +static struct i2c_driver vd55g_i2c_driver = { + .driver = { + .name = "vd55g", + .acpi_match_table = vd55g_acpi_match, + .of_match_table = vd55g_dt_ids, + .pm = &vd55g_pm_ops, + }, + .probe = vd55g_probe, + .remove = vd55g_remove, +}; + +module_i2c_driver(vd55g_i2c_driver); + +MODULE_AUTHOR("Peter Marshall "); +MODULE_AUTHOR("Benjamin Mugnier "); +MODULE_AUTHOR("Sylvain Petinot "); +MODULE_DESCRIPTION("VD55G camera subdev driver"); +MODULE_FIRMWARE("vd55g0-cut1.bin"); +MODULE_FIRMWARE("vd55g0-cut2.bin"); +MODULE_FIRMWARE("vd55g1.bin"); +MODULE_LICENSE("GPL"); From 9646481593d738b0a1b73833adc2f5a1b273807e Mon Sep 17 00:00:00 2001 From: Peter Marshall Date: Thu, 30 Jul 2026 16:03:36 -0400 Subject: [PATCH 08/10] media: i2c: st-vd55g: Remove legacy vd55g1 remnants vd55g1 is superseded by the generic vd55g driver supporting the same hardware and feature set. Remove it. Signed-off-by: Peter Marshall --- drivers/media/i2c/Makefile | 1 - drivers/media/i2c/vd55g1.c | 1767 ------------------------------------ 2 files changed, 1768 deletions(-) delete mode 100644 drivers/media/i2c/vd55g1.c diff --git a/drivers/media/i2c/Makefile b/drivers/media/i2c/Makefile index 22e6ba4728dcf..cce4e9053a730 100644 --- a/drivers/media/i2c/Makefile +++ b/drivers/media/i2c/Makefile @@ -159,7 +159,6 @@ obj-$(CONFIG_VIDEO_UDA1342) += uda1342.o obj-$(CONFIG_VIDEO_UPD64031A) += upd64031a.o obj-$(CONFIG_VIDEO_UPD64083) += upd64083.o obj-$(CONFIG_VIDEO_VD55G) += vd55g.o -obj-$(CONFIG_VIDEO_VD55G1) += vd55g1.o obj-$(CONFIG_VIDEO_VD56G3) += vd56g3.o obj-$(CONFIG_VIDEO_VGXY61) += vgxy61.o obj-$(CONFIG_VIDEO_VP27SMPX) += vp27smpx.o diff --git a/drivers/media/i2c/vd55g1.c b/drivers/media/i2c/vd55g1.c deleted file mode 100644 index 1ae42e448490a..0000000000000 --- a/drivers/media/i2c/vd55g1.c +++ /dev/null @@ -1,1767 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0 -/* - * Driver for VD55G1 global shutter sensor family driver - * - * Copyright (C) 2025 STMicroelectronics SA - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -/* Register Map */ -#define VD55G1_REG_MODEL_ID CCI_REG32_LE(0x0000) -#define VD55G1_MODEL_ID_VD55G1 0x53354731 /* Mono */ -#define VD55G1_MODEL_ID_VD65G4 0x53354733 /* RGB */ -#define VD55G1_REG_REVISION CCI_REG16_LE(0x0004) -#define VD55G1_REVISION_CCB 0x2020 -#define VD55G1_REVISION_BAYER 0x3030 -#define VD55G1_REG_FWPATCH_REVISION CCI_REG16_LE(0x0012) -#define VD55G1_REG_FWPATCH_START_ADDR CCI_REG8(0x2000) -#define VD55G1_REG_SYSTEM_FSM CCI_REG8(0x001c) -#define VD55G1_SYSTEM_FSM_READY_TO_BOOT 0x01 -#define VD55G1_SYSTEM_FSM_SW_STBY 0x02 -#define VD55G1_SYSTEM_FSM_STREAMING 0x03 -#define VD55G1_REG_BOOT CCI_REG8(0x0200) -#define VD55G1_BOOT_BOOT 1 -#define VD55G1_BOOT_PATCH_AND_BOOT 2 -#define VD55G1_REG_STBY CCI_REG8(0x0201) -#define VD55G1_STBY_START_STREAM 1 -#define VD55G1_REG_STREAMING CCI_REG8(0x0202) -#define VD55G1_STREAMING_STOP_STREAM 1 -#define VD55G1_REG_EXT_CLOCK CCI_REG32_LE(0x0220) -#define VD55G1_REG_LINE_LENGTH CCI_REG16_LE(0x0300) -#define VD55G1_REG_ORIENTATION CCI_REG8(0x0302) -#define VD55G1_REG_FORMAT_CTRL CCI_REG8(0x030a) -#define VD55G1_REG_OIF_CTRL CCI_REG16_LE(0x030c) -#define VD55G1_REG_ISL_ENABLE CCI_REG16_LE(0x326) -#define VD55G1_REG_OIF_IMG_CTRL CCI_REG8(0x030f) -#define VD55G1_REG_MIPI_DATA_RATE CCI_REG32_LE(0x0224) -#define VD55G1_REG_PATGEN_CTRL CCI_REG16_LE(0x0304) -#define VD55G1_PATGEN_TYPE_SHIFT 4 -#define VD55G1_PATGEN_ENABLE BIT(0) -#define VD55G1_REG_MANUAL_ANALOG_GAIN CCI_REG8(0x0501) -#define VD55G1_REG_MANUAL_COARSE_EXPOSURE CCI_REG16_LE(0x0502) -#define VD55G1_REG_MANUAL_DIGITAL_GAIN CCI_REG16_LE(0x0504) -#define VD55G1_REG_APPLIED_COARSE_EXPOSURE CCI_REG16_LE(0x00e8) -#define VD55G1_REG_APPLIED_ANALOG_GAIN CCI_REG16_LE(0x00ea) -#define VD55G1_REG_APPLIED_DIGITAL_GAIN CCI_REG16_LE(0x00ec) -#define VD55G1_REG_AE_FORCE_COLDSTART CCI_REG8(0x0308) -#define VD55G1_REG_AE_COLDSTART_EXP_TIME CCI_REG32_LE(0x0374) -#define VD55G1_REG_READOUT_CTRL CCI_REG8(0x052e) -#define VD55G1_READOUT_CTRL_BIN_MODE_NORMAL 0 -#define VD55G1_READOUT_CTRL_BIN_MODE_DIGITAL_X2 1 -#define VD55G1_REG_DUSTER_CTRL CCI_REG8(0x03ae) -#define VD55G1_DUSTER_ENABLE BIT(0) -#define VD55G1_DUSTER_DISABLE 0 -#define VD55G1_DUSTER_DYN_ENABLE BIT(1) -#define VD55G1_DUSTER_RING_ENABLE BIT(4) -#define VD55G1_REG_AE_TARGET_PERCENTAGE CCI_REG8(0x0486) -#define VD55G1_REG_NEXT_CTX CCI_REG16_LE(0x03e4) -#define VD55G1_REG_EXPOSURE_USE_CASES CCI_REG8(0x0312) -#define VD55G1_EXPOSURE_USE_CASES_MULTI_CONTEXT BIT(2) -#define VD55G1_REG_EXPOSURE_MAX_COARSE CCI_REG16_LE(0x0372) -#define VD55G1_EXPOSURE_MAX_COARSE_DEF 0x7fff -#define VD55G1_EXPOSURE_MAX_COARSE_SUB 446 -#define VD55G1_REG_CTX_REPEAT_COUNT_CTX0 CCI_REG16_LE(0x03dc) -#define VD55G1_REG_CTX_REPEAT_COUNT_CTX1 CCI_REG16_LE(0x03de) - -#define VD55G1_REG_EXP_MODE(ctx) \ - CCI_REG8(0x0500 + VD55G1_CTX_OFFSET * (ctx)) -#define VD55G1_REG_FRAME_LENGTH(ctx) \ - CCI_REG32_LE(0x050c + VD55G1_CTX_OFFSET * (ctx)) -#define VD55G1_REG_X_START(ctx) \ - CCI_REG16_LE(0x0514 + VD55G1_CTX_OFFSET * (ctx)) -#define VD55G1_REG_X_WIDTH(ctx) \ - CCI_REG16_LE(0x0516 + VD55G1_CTX_OFFSET * (ctx)) -#define VD55G1_REG_Y_START(ctx) \ - CCI_REG16_LE(0x0510 + VD55G1_CTX_OFFSET * (ctx)) -#define VD55G1_REG_Y_HEIGHT(ctx) \ - CCI_REG16_LE(0x0512 + VD55G1_CTX_OFFSET * (ctx)) -#define VD55G1_REG_GPIO_0_CTRL(ctx) \ - CCI_REG8(0x051d + VD55G1_CTX_OFFSET * (ctx)) -#define VD55G1_GPIO_MODE_FSYNC_OUT 0x00 -#define VD55G1_GPIO_MODE_IN 0x01 -#define VD55G1_GPIO_MODE_STROBE 0x02 -#define VD55G1_REG_VT_MODE(ctx) \ - CCI_REG8(0x0536 + VD55G1_CTX_OFFSET * (ctx)) -#define VD55G1_VT_MODE_NORMAL 0 -#define VD55G1_VT_MODE_SUBTRACTION 1 -#define VD55G1_REG_MASK_FRAME_CTRL(ctx) \ - CCI_REG8(0x0537 + VD55G1_CTX_OFFSET * (ctx)) -#define VD55G1_MASK_FRAME_CTRL_OUTPUT 0 -#define VD55G1_MASK_FRAME_CTRL_MASK 1 -#define VD55G1_REG_EXPOSURE_INSTANCE(ctx) \ - CCI_REG32_LE(0x52D + VD55G1_CTX_OFFSET * (ctx)) - -#define VD55G1_WIDTH 804 -#define VD55G1_HEIGHT 704 -#define VD55G1_MODE_DEF 0 -#define VD55G1_NB_GPIOS 4 -#define VD55G1_MBUS_CODE_DEF 0 -#define VD55G1_DGAIN_DEF 256 -#define VD55G1_AGAIN_DEF 19 -#define VD55G1_EXPO_MAX_TERM 64 -#define VD55G1_EXPO_DEF 500 -#define VD55G1_LINE_LENGTH_MIN 1128 -#define VD55G1_LINE_LENGTH_SUB_MIN 1344 -#define VD55G1_VBLANK_MIN 86 -#define VD55G1_VBLANK_MAX 0xffff -#define VD55G1_FRAME_LENGTH_DEF 1860 /* 60 fps */ -#define VD55G1_MIPI_MARGIN 900 -#define VD55G1_CTX_OFFSET 0x50 -#define VD55G1_FWPATCH_REVISION_MAJOR 2 -#define VD55G1_FWPATCH_REVISION_MINOR 9 -#define VD55G1_XCLK_FREQ_MIN (6 * HZ_PER_MHZ) -#define VD55G1_XCLK_FREQ_MAX (27 * HZ_PER_MHZ) -#define VD55G1_MIPI_RATE_MIN (250 * MEGA) -#define VD55G1_MIPI_RATE_MAX (1200 * MEGA) - -#define VD55G1_MODEL_ID_NAME(id) \ - ((id) == VD55G1_MODEL_ID_VD55G1 ? "vd55g1" : "vd65g4") - -#include "vd55g-fw.h" - -static const char * const vd55g1_tp_menu[] = { - "Disabled", - "Diagonal Grey Scale", - "Pseudo-random Noise", -}; - -static const s64 vd55g1_ev_bias_menu[] = { - -3000, -2500, -2000, -1500, -1000, -500, - 0, - 500, 1000, 1500, 2000, 2500, 3000, -}; - -static const char * const vd55g1_hdr_menu[] = { - "No HDR", - /* - * This mode acquires 2 frames on the sensor, the first one is ditched - * out and only used for auto exposure data, the second one is output to - * the host - */ - "Internal subtraction", -}; - -static const char * const vd55g1_supply_name[] = { - "vcore", - "vddio", - "vana", -}; - -enum vd55g1_hdr_mode { - VD55G1_NO_HDR, - VD55G1_HDR_SUB, -}; - -struct vd55g1_mode { - u32 width; - u32 height; -}; - -static const u32 vd55g1_mbus_formats_mono[] = { - MEDIA_BUS_FMT_Y8_1X8, - MEDIA_BUS_FMT_Y10_1X10, -}; - -/* Format order is : no flip, hflip, vflip, both */ -static const u32 vd55g1_mbus_formats_bayer[][4] = { - { - MEDIA_BUS_FMT_SRGGB8_1X8, - MEDIA_BUS_FMT_SGRBG8_1X8, - MEDIA_BUS_FMT_SGBRG8_1X8, - MEDIA_BUS_FMT_SBGGR8_1X8, - }, - { - MEDIA_BUS_FMT_SRGGB10_1X10, - MEDIA_BUS_FMT_SGRBG10_1X10, - MEDIA_BUS_FMT_SGBRG10_1X10, - MEDIA_BUS_FMT_SBGGR10_1X10, - }, -}; - -static const struct vd55g1_mode vd55g1_supported_modes[] = { - { - .width = VD55G1_WIDTH, - .height = VD55G1_HEIGHT, - }, - { - .width = 800, - .height = VD55G1_HEIGHT, - }, - { - .width = 800, - .height = 600, - }, - { - .width = 640, - .height = 480, - }, - { - .width = 320, - .height = 240, - }, -}; - -enum vd55g1_expo_state { - VD55G1_EXP_AUTO, - VD55G1_EXP_FREEZE, - VD55G1_EXP_MANUAL, - VD55G1_EXP_SINGLE_STEP, - VD55G1_EXP_BYPASS, -}; - -struct vd55g1_vblank_limits { - u16 min; - u16 def; - u16 max; -}; - -struct vd55g1 { - struct device *dev; - unsigned int id; - struct v4l2_subdev sd; - struct media_pad pad; - struct regulator_bulk_data supplies[ARRAY_SIZE(vd55g1_supply_name)]; - struct gpio_desc *reset_gpio; - struct clk *xclk; - struct regmap *regmap; - u32 xclk_freq; - u16 oif_ctrl; - u8 gpios[VD55G1_NB_GPIOS]; - unsigned long ext_leds_mask; - u32 mipi_rate; - u32 pixel_clock; - u64 link_freq; - struct v4l2_ctrl_handler ctrl_handler; - struct v4l2_ctrl *pixel_rate_ctrl; - struct v4l2_ctrl *vblank_ctrl; - struct v4l2_ctrl *hblank_ctrl; - struct { - struct v4l2_ctrl *hflip_ctrl; - struct v4l2_ctrl *vflip_ctrl; - }; - struct v4l2_ctrl *patgen_ctrl; - struct { - struct v4l2_ctrl *ae_ctrl; - struct v4l2_ctrl *expo_ctrl; - struct v4l2_ctrl *again_ctrl; - struct v4l2_ctrl *dgain_ctrl; - }; - struct v4l2_ctrl *ae_lock_ctrl; - struct v4l2_ctrl *ae_bias_ctrl; - struct v4l2_ctrl *led_ctrl; - struct v4l2_ctrl *hdr_ctrl; -}; - -static inline struct vd55g1 *to_vd55g1(struct v4l2_subdev *sd) -{ - return container_of_const(sd, struct vd55g1, sd); -} - -static inline struct vd55g1 *ctrl_to_vd55g1(struct v4l2_ctrl *ctrl) -{ - struct v4l2_subdev *sd = &container_of_const(ctrl->handler, - struct vd55g1, - ctrl_handler)->sd; - - return to_vd55g1(sd); -} - -static unsigned int vd55g1_get_fmt_bpp(u32 code) -{ - switch (code) { - case MEDIA_BUS_FMT_Y8_1X8: - case MEDIA_BUS_FMT_SRGGB8_1X8: - case MEDIA_BUS_FMT_SGRBG8_1X8: - case MEDIA_BUS_FMT_SGBRG8_1X8: - case MEDIA_BUS_FMT_SBGGR8_1X8: - default: - return 8; - - case MEDIA_BUS_FMT_Y10_1X10: - case MEDIA_BUS_FMT_SRGGB10_1X10: - case MEDIA_BUS_FMT_SGRBG10_1X10: - case MEDIA_BUS_FMT_SGBRG10_1X10: - case MEDIA_BUS_FMT_SBGGR10_1X10: - return 10; - } -} - -static unsigned int vd55g1_get_fmt_data_type(u32 code) -{ - switch (code) { - case MEDIA_BUS_FMT_Y8_1X8: - case MEDIA_BUS_FMT_SRGGB8_1X8: - case MEDIA_BUS_FMT_SGRBG8_1X8: - case MEDIA_BUS_FMT_SGBRG8_1X8: - case MEDIA_BUS_FMT_SBGGR8_1X8: - default: - return MIPI_CSI2_DT_RAW8; - - case MEDIA_BUS_FMT_Y10_1X10: - case MEDIA_BUS_FMT_SRGGB10_1X10: - case MEDIA_BUS_FMT_SGRBG10_1X10: - case MEDIA_BUS_FMT_SGBRG10_1X10: - case MEDIA_BUS_FMT_SBGGR10_1X10: - return MIPI_CSI2_DT_RAW10; - } -} - -static u32 vd55g1_get_fmt_code(struct vd55g1 *sensor, u32 code) -{ - unsigned int i, j; - - if (sensor->id == VD55G1_MODEL_ID_VD55G1) - return code; - - for (i = 0; i < ARRAY_SIZE(vd55g1_mbus_formats_bayer); i++) { - for (j = 0; j < ARRAY_SIZE(vd55g1_mbus_formats_bayer[i]); j++) { - if (vd55g1_mbus_formats_bayer[i][j] == code) - goto adapt_bayer_pattern; - } - } - dev_warn(sensor->dev, "Unsupported mbus format\n"); - - return code; - -adapt_bayer_pattern: - j = 0; - /* In first init_state() call, controls might not be initialized yet */ - if (sensor->hflip_ctrl && sensor->vflip_ctrl) { - j = (sensor->hflip_ctrl->val ? 1 : 0) + - (sensor->vflip_ctrl->val ? 2 : 0); - } - - return vd55g1_mbus_formats_bayer[i][j]; -} - -static s32 vd55g1_get_pixel_rate(struct vd55g1 *sensor, - struct v4l2_mbus_framefmt *format) -{ - return sensor->mipi_rate / vd55g1_get_fmt_bpp(format->code); -} - -static unsigned int vd55g1_get_hblank_min(struct vd55g1 *sensor, - struct v4l2_mbus_framefmt *format, - struct v4l2_rect *crop) -{ - u32 mipi_req_line_time; - u32 mipi_req_line_length; - u32 min_line_length; - - /* MIPI required time */ - mipi_req_line_time = (crop->width * - vd55g1_get_fmt_bpp(format->code) + - VD55G1_MIPI_MARGIN) / - (sensor->mipi_rate / MEGA); - mipi_req_line_length = mipi_req_line_time * sensor->pixel_clock / - HZ_PER_MHZ; - - /* Absolute time required for ADCs to convert pixels */ - min_line_length = VD55G1_LINE_LENGTH_MIN; - if (sensor->hdr_ctrl->val == VD55G1_HDR_SUB) - min_line_length = VD55G1_LINE_LENGTH_SUB_MIN; - - /* Respect both constraint */ - min_line_length = max(min_line_length, mipi_req_line_length); - - return min_line_length - crop->width; -} - -static void vd55g1_get_vblank_limits(struct vd55g1 *sensor, - struct v4l2_rect *crop, - struct vd55g1_vblank_limits *limits) -{ - limits->min = VD55G1_VBLANK_MIN; - limits->def = VD55G1_FRAME_LENGTH_DEF - crop->height; - limits->max = VD55G1_VBLANK_MAX - crop->height; -} - -#define vd55g1_read(sensor, reg, val, err) \ - cci_read((sensor)->regmap, reg, val, err) - -#define vd55g1_write(sensor, reg, val, err) \ - cci_write((sensor)->regmap, reg, val, err) - -static int vd55g1_write_array(struct vd55g1 *sensor, u32 reg, unsigned int len, - const u8 *array, int *err) -{ - unsigned int chunk_sz = 1024; - unsigned int sz; - int ret = 0; - - if (err && *err) - return *err; - - /* - * This loop isn't necessary but in certains conditions (platforms, cpu - * load, etc.) it has been observed that the bulk write could timeout. - */ - while (len) { - sz = min(len, chunk_sz); - ret = regmap_bulk_write(sensor->regmap, reg, array, sz); - if (ret < 0) - goto out; - len -= sz; - reg += sz; - array += sz; - } - -out: - if (ret && err) - *err = ret; - - return ret; -} - -static int vd55g1_poll_reg(struct vd55g1 *sensor, u32 reg, u8 poll_val, - int *err) -{ - unsigned int val = 0; - int ret; - - if (err && *err) - return *err; - - ret = regmap_read_poll_timeout(sensor->regmap, CCI_REG_ADDR(reg), val, - (val == poll_val), 2000, - 500 * USEC_PER_MSEC); - - if (ret && err) - *err = ret; - - return ret; -} - -static int vd55g1_wait_state(struct vd55g1 *sensor, int state, int *err) -{ - return vd55g1_poll_reg(sensor, VD55G1_REG_SYSTEM_FSM, state, err); -} - -static int vd55g1_prepare_clock_tree(struct vd55g1 *sensor) -{ - u32 sys_clk, mipi_div, pixel_div; - - if (sensor->xclk_freq < VD55G1_XCLK_FREQ_MIN || - sensor->xclk_freq > VD55G1_XCLK_FREQ_MAX) { - dev_err(sensor->dev, - "Only %luMhz-%luMhz clock range supported. Provided %lu MHz\n", - VD55G1_XCLK_FREQ_MIN / HZ_PER_MHZ, - VD55G1_XCLK_FREQ_MAX / HZ_PER_MHZ, - sensor->xclk_freq / HZ_PER_MHZ); - return -EINVAL; - } - - /* MIPI bus is double data rate */ - sensor->mipi_rate = sensor->link_freq * 2; - - if (sensor->mipi_rate < VD55G1_MIPI_RATE_MIN || - sensor->mipi_rate > VD55G1_MIPI_RATE_MAX) { - dev_err(sensor->dev, - "Only %luMbps-%luMbps data rate range supported. Provided %lu Mbps\n", - VD55G1_MIPI_RATE_MIN / MEGA, - VD55G1_MIPI_RATE_MAX / MEGA, - sensor->mipi_rate / MEGA); - return -EINVAL; - } - - if (sensor->mipi_rate <= 300 * MEGA) - mipi_div = 4; - else if (sensor->mipi_rate <= 600 * MEGA) - mipi_div = 2; - else - mipi_div = 1; - - sys_clk = sensor->mipi_rate * mipi_div; - - if (sys_clk <= 780 * HZ_PER_MHZ) - pixel_div = 5; - else if (sys_clk <= 900 * HZ_PER_MHZ) - pixel_div = 6; - else - pixel_div = 8; - - sensor->pixel_clock = sys_clk / pixel_div; - - return 0; -} - -static int vd55g1_update_patgen(struct vd55g1 *sensor, u32 patgen_index) -{ - static const u8 index2val[] = { - 0x0, 0x22, 0x28 - }; - u32 pattern = index2val[patgen_index]; - u32 reg = pattern << VD55G1_PATGEN_TYPE_SHIFT; - u8 duster = VD55G1_DUSTER_RING_ENABLE | VD55G1_DUSTER_DYN_ENABLE | - VD55G1_DUSTER_ENABLE; - int ret = 0; - - BUILD_BUG_ON(ARRAY_SIZE(index2val) != ARRAY_SIZE(vd55g1_tp_menu)); - - if (pattern != 0) { - reg |= VD55G1_PATGEN_ENABLE; - /* Take care of duster to not mess up the test pattern output */ - duster = VD55G1_DUSTER_DISABLE; - } - - vd55g1_write(sensor, VD55G1_REG_DUSTER_CTRL, duster, &ret); - vd55g1_write(sensor, VD55G1_REG_PATGEN_CTRL, reg, &ret); - - return ret; -} - -static int vd55g1_update_expo_cluster(struct vd55g1 *sensor, bool is_auto) -{ - enum vd55g1_expo_state expo_state = is_auto ? VD55G1_EXP_AUTO : - VD55G1_EXP_MANUAL; - int ret = 0; - - if (sensor->ae_ctrl->is_new) - vd55g1_write(sensor, VD55G1_REG_EXP_MODE(0), expo_state, &ret); - - if (sensor->hdr_ctrl->val == VD55G1_HDR_SUB && - sensor->hdr_ctrl->is_new) { - vd55g1_write(sensor, VD55G1_REG_EXP_MODE(1), VD55G1_EXP_BYPASS, - &ret); - if (ret) - return ret; - } - - if (!is_auto && sensor->expo_ctrl->is_new) - vd55g1_write(sensor, VD55G1_REG_MANUAL_COARSE_EXPOSURE, - sensor->expo_ctrl->val, &ret); - - if (!is_auto && sensor->again_ctrl->is_new) - vd55g1_write(sensor, VD55G1_REG_MANUAL_ANALOG_GAIN, - sensor->again_ctrl->val, &ret); - - if (!is_auto && sensor->dgain_ctrl->is_new) - vd55g1_write(sensor, VD55G1_REG_MANUAL_DIGITAL_GAIN, - sensor->dgain_ctrl->val, &ret); - - return ret; -} - -static int vd55g1_lock_exposure(struct vd55g1 *sensor, u32 lock_val) -{ - bool ae_lock = lock_val & V4L2_LOCK_EXPOSURE; - enum vd55g1_expo_state expo_state = ae_lock ? VD55G1_EXP_FREEZE : - VD55G1_EXP_AUTO; - int ret = 0; - - if (sensor->ae_ctrl->val == V4L2_EXPOSURE_AUTO) - vd55g1_write(sensor, VD55G1_REG_EXP_MODE(0), expo_state, &ret); - - return ret; -} - -static int vd55g1_read_expo_cluster(struct vd55g1 *sensor) -{ - u64 exposure = 0; - u64 again = 0; - u64 dgain = 0; - int ret = 0; - - vd55g1_read(sensor, VD55G1_REG_APPLIED_COARSE_EXPOSURE, &exposure, - &ret); - vd55g1_read(sensor, VD55G1_REG_APPLIED_ANALOG_GAIN, &again, &ret); - vd55g1_read(sensor, VD55G1_REG_APPLIED_DIGITAL_GAIN, &dgain, &ret); - if (ret) - return ret; - - sensor->expo_ctrl->cur.val = exposure; - sensor->again_ctrl->cur.val = again; - sensor->dgain_ctrl->cur.val = dgain; - - return 0; -} - -static int vd55g1_update_frame_length(struct vd55g1 *sensor, - unsigned int frame_length) -{ - int ret = 0; - - if (sensor->hdr_ctrl->val == VD55G1_HDR_SUB) - vd55g1_write(sensor, VD55G1_REG_FRAME_LENGTH(1), frame_length, - &ret); - vd55g1_write(sensor, VD55G1_REG_FRAME_LENGTH(0), frame_length, &ret); - - return ret; -} - -static int vd55g1_update_exposure_target(struct vd55g1 *sensor, int index) -{ - /* - * Find auto exposure target with: default target exposure * 2^EV - * Defaut target exposure being 27 for the sensor. - */ - static const unsigned int index2exposure_target[] = { - 3, 5, 7, 10, 14, 19, 27, 38, 54, 76, 108, 153, 216, - }; - int exposure_target = index2exposure_target[index]; - - return vd55g1_write(sensor, VD55G1_REG_AE_TARGET_PERCENTAGE, - exposure_target, NULL); -} - -static int vd55g1_apply_cold_start(struct vd55g1 *sensor, - struct v4l2_rect *crop) -{ - /* - * Cold start register is a single register expressed as exposure time - * in us. This differ from status registers being a combination of - * exposure, digital gain, and analog gain, requiring the following - * format conversion. - */ - unsigned int line_length = crop->width + sensor->hblank_ctrl->val; - unsigned int line_time_us = DIV_ROUND_UP(line_length * MEGA, - sensor->pixel_clock); - u8 d_gain = DIV_ROUND_CLOSEST(sensor->dgain_ctrl->val, 1 << 8); - u8 a_gain = DIV_ROUND_CLOSEST(32, (32 - sensor->again_ctrl->val)); - unsigned int expo_us = sensor->expo_ctrl->val * d_gain * a_gain * - line_time_us; - int ret = 0; - - vd55g1_write(sensor, VD55G1_REG_AE_FORCE_COLDSTART, 1, &ret); - vd55g1_write(sensor, VD55G1_REG_AE_COLDSTART_EXP_TIME, expo_us, &ret); - - return ret; -} - -static void vd55g1_update_pad_fmt(struct vd55g1 *sensor, - const struct vd55g1_mode *mode, u32 code, - struct v4l2_mbus_framefmt *fmt) -{ - fmt->code = vd55g1_get_fmt_code(sensor, code); - fmt->width = mode->width; - fmt->height = mode->height; - fmt->colorspace = V4L2_COLORSPACE_RAW; - fmt->field = V4L2_FIELD_NONE; - fmt->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; - fmt->quantization = V4L2_QUANTIZATION_DEFAULT; - fmt->xfer_func = V4L2_XFER_FUNC_DEFAULT; -} - -static int vd55g1_update_hdr_mode(struct vd55g1 *sensor) -{ - int ret = 0; - - switch (sensor->hdr_ctrl->val) { - case VD55G1_NO_HDR: - vd55g1_write(sensor, VD55G1_REG_EXPOSURE_MAX_COARSE, - VD55G1_EXPOSURE_MAX_COARSE_DEF, &ret); - vd55g1_write(sensor, VD55G1_REG_EXPOSURE_USE_CASES, 0, &ret); - vd55g1_write(sensor, VD55G1_REG_NEXT_CTX, 0x0, &ret); - - vd55g1_write(sensor, VD55G1_REG_CTX_REPEAT_COUNT_CTX0, 0, &ret); - - vd55g1_write(sensor, VD55G1_REG_VT_MODE(0), - VD55G1_VT_MODE_NORMAL, &ret); - vd55g1_write(sensor, VD55G1_REG_MASK_FRAME_CTRL(0), - VD55G1_MASK_FRAME_CTRL_OUTPUT, &ret); - break; - case VD55G1_HDR_SUB: - vd55g1_write(sensor, VD55G1_REG_EXPOSURE_MAX_COARSE, - VD55G1_EXPOSURE_MAX_COARSE_SUB, &ret); - vd55g1_write(sensor, VD55G1_REG_EXPOSURE_USE_CASES, - VD55G1_EXPOSURE_USE_CASES_MULTI_CONTEXT, &ret); - vd55g1_write(sensor, VD55G1_REG_NEXT_CTX, 0x0001, &ret); - - vd55g1_write(sensor, VD55G1_REG_CTX_REPEAT_COUNT_CTX0, 1, &ret); - vd55g1_write(sensor, VD55G1_REG_CTX_REPEAT_COUNT_CTX1, 1, &ret); - - vd55g1_write(sensor, VD55G1_REG_VT_MODE(0), - VD55G1_VT_MODE_NORMAL, &ret); - vd55g1_write(sensor, VD55G1_REG_MASK_FRAME_CTRL(0), - VD55G1_MASK_FRAME_CTRL_MASK, &ret); - vd55g1_write(sensor, VD55G1_REG_EXPOSURE_INSTANCE(0), 0, &ret); - vd55g1_write(sensor, VD55G1_REG_VT_MODE(1), - VD55G1_VT_MODE_SUBTRACTION, &ret); - vd55g1_write(sensor, VD55G1_REG_MASK_FRAME_CTRL(1), - VD55G1_MASK_FRAME_CTRL_OUTPUT, &ret); - vd55g1_write(sensor, VD55G1_REG_EXPOSURE_INSTANCE(1), 1, &ret); - break; - default: - ret = -EINVAL; - } - - return ret; -} - -static int vd55g1_set_framefmt(struct vd55g1 *sensor, - struct v4l2_mbus_framefmt *format, - struct v4l2_rect *crop) -{ - u8 binning; - int ret = 0; - - vd55g1_write(sensor, VD55G1_REG_FORMAT_CTRL, - vd55g1_get_fmt_bpp(format->code), &ret); - vd55g1_write(sensor, VD55G1_REG_OIF_IMG_CTRL, - vd55g1_get_fmt_data_type(format->code), &ret); - - switch (crop->width / format->width) { - case 1: - default: - binning = VD55G1_READOUT_CTRL_BIN_MODE_NORMAL; - break; - case 2: - binning = VD55G1_READOUT_CTRL_BIN_MODE_DIGITAL_X2; - break; - } - vd55g1_write(sensor, VD55G1_REG_READOUT_CTRL, binning, &ret); - - vd55g1_write(sensor, VD55G1_REG_X_START(0), crop->left, &ret); - vd55g1_write(sensor, VD55G1_REG_X_WIDTH(0), crop->width, &ret); - vd55g1_write(sensor, VD55G1_REG_Y_START(0), crop->top, &ret); - vd55g1_write(sensor, VD55G1_REG_Y_HEIGHT(0), crop->height, &ret); - - vd55g1_write(sensor, VD55G1_REG_X_START(1), crop->left, &ret); - vd55g1_write(sensor, VD55G1_REG_X_WIDTH(1), crop->width, &ret); - vd55g1_write(sensor, VD55G1_REG_Y_START(1), crop->top, &ret); - vd55g1_write(sensor, VD55G1_REG_Y_HEIGHT(1), crop->height, &ret); - - return ret; -} - -static int vd55g1_update_gpios(struct vd55g1 *sensor, unsigned long gpio_mask) -{ - unsigned long io; - u8 gpio_val; - int ret = 0; - - for_each_set_bit(io, &gpio_mask, VD55G1_NB_GPIOS) { - gpio_val = sensor->gpios[io]; - - if (gpio_val == VD55G1_GPIO_MODE_STROBE && - sensor->led_ctrl->val == V4L2_FLASH_LED_MODE_NONE) { - gpio_val = VD55G1_GPIO_MODE_IN; - if (sensor->hdr_ctrl->val == VD55G1_HDR_SUB) { - /* Make its context 1 counterpart strobe too */ - vd55g1_write(sensor, - VD55G1_REG_GPIO_0_CTRL(1) + io, - gpio_val, &ret); - } - } - - ret = vd55g1_write(sensor, VD55G1_REG_GPIO_0_CTRL(0) + io, - gpio_val, &ret); - } - - return ret; -} - -static int vd55g1_ro_ctrls_setup(struct vd55g1 *sensor, struct v4l2_rect *crop) -{ - return vd55g1_write(sensor, VD55G1_REG_LINE_LENGTH, - crop->width + sensor->hblank_ctrl->val, NULL); -} - -static void vd55g1_grab_ctrls(struct vd55g1 *sensor, bool enable) -{ - /* These settings cannot change during stream */ - v4l2_ctrl_grab(sensor->hflip_ctrl, enable); - v4l2_ctrl_grab(sensor->vflip_ctrl, enable); - v4l2_ctrl_grab(sensor->patgen_ctrl, enable); - v4l2_ctrl_grab(sensor->hdr_ctrl, enable); -} - -static int vd55g1_enable_streams(struct v4l2_subdev *sd, - struct v4l2_subdev_state *state, u32 pad, - u64 streams_mask) -{ - struct vd55g1 *sensor = to_vd55g1(sd); - struct v4l2_rect *crop = - v4l2_subdev_state_get_crop(state, 0); - struct v4l2_mbus_framefmt *format = - v4l2_subdev_state_get_format(state, 0); - int ret; - - ret = pm_runtime_resume_and_get(sensor->dev); - if (ret < 0) - return ret; - - /* Configure output */ - vd55g1_write(sensor, VD55G1_REG_MIPI_DATA_RATE, - sensor->mipi_rate, &ret); - vd55g1_write(sensor, VD55G1_REG_OIF_CTRL, sensor->oif_ctrl, &ret); - vd55g1_write(sensor, VD55G1_REG_ISL_ENABLE, 0, &ret); - if (ret) - goto err_rpm_put; - - ret = vd55g1_set_framefmt(sensor, format, crop); - if (ret) - goto err_rpm_put; - - /* Setup default GPIO values; could be overridden by V4L2 ctrl setup */ - ret = vd55g1_update_gpios(sensor, GENMASK(VD55G1_NB_GPIOS - 1, 0)); - if (ret) - goto err_rpm_put; - - ret = vd55g1_apply_cold_start(sensor, crop); - if (ret) - goto err_rpm_put; - - /* Apply settings from V4L2 ctrls */ - ret = __v4l2_ctrl_handler_setup(&sensor->ctrl_handler); - if (ret) - goto err_rpm_put; - - /* Also apply settings from read-only V4L2 ctrls */ - ret = vd55g1_ro_ctrls_setup(sensor, crop); - if (ret) - goto err_rpm_put; - - /* Start streaming */ - vd55g1_write(sensor, VD55G1_REG_STBY, VD55G1_STBY_START_STREAM, &ret); - vd55g1_poll_reg(sensor, VD55G1_REG_STBY, 0, &ret); - vd55g1_wait_state(sensor, VD55G1_SYSTEM_FSM_STREAMING, &ret); - if (ret) - goto err_rpm_put; - - vd55g1_grab_ctrls(sensor, true); - - return 0; - -err_rpm_put: - pm_runtime_put(sensor->dev); - return -EINVAL; -} - -static int vd55g1_disable_streams(struct v4l2_subdev *sd, - struct v4l2_subdev_state *state, u32 pad, - u64 streams_mask) -{ - struct vd55g1 *sensor = to_vd55g1(sd); - int ret = 0; - - /* Retrieve Expo cluster to enable coldstart of AE */ - ret = vd55g1_read_expo_cluster(sensor); - - vd55g1_write(sensor, VD55G1_REG_STREAMING, VD55G1_STREAMING_STOP_STREAM, - &ret); - vd55g1_poll_reg(sensor, VD55G1_REG_STREAMING, 0, &ret); - vd55g1_wait_state(sensor, VD55G1_SYSTEM_FSM_SW_STBY, &ret); - - if (ret) - dev_warn(sensor->dev, "Can't disable stream\n"); - - vd55g1_grab_ctrls(sensor, false); - - pm_runtime_put_autosuspend(sensor->dev); - - return ret; -} - -static int vd55g1_patch(struct vd55g1 *sensor) -{ - u64 patch; - int ret = 0; - - /* vd55g1 needs a patch while vd65g4 does not */ - if (sensor->id == VD55G1_MODEL_ID_VD55G1) { - vd55g1_write_array(sensor, VD55G1_REG_FWPATCH_START_ADDR, - sizeof(vd55g1_patch_array), - vd55g1_patch_array, &ret); - vd55g1_write(sensor, VD55G1_REG_BOOT, - VD55G1_BOOT_PATCH_AND_BOOT, &ret); - vd55g1_poll_reg(sensor, VD55G1_REG_BOOT, 0, &ret); - if (ret) { - dev_err(sensor->dev, "Failed to apply patch\n"); - return ret; - } - - vd55g1_read(sensor, VD55G1_REG_FWPATCH_REVISION, &patch, &ret); - if (patch != (VD55G1_FWPATCH_REVISION_MAJOR << 8) + - VD55G1_FWPATCH_REVISION_MINOR) { - dev_err(sensor->dev, "Bad patch version expected %d.%d got %d.%d\n", - VD55G1_FWPATCH_REVISION_MAJOR, - VD55G1_FWPATCH_REVISION_MINOR, - (u8)(patch >> 8), (u8)(patch & 0xff)); - return -ENODEV; - } - dev_dbg(sensor->dev, "patch %d.%d applied\n", - (u8)(patch >> 8), (u8)(patch & 0xff)); - - } else { - vd55g1_write(sensor, VD55G1_REG_BOOT, VD55G1_BOOT_BOOT, &ret); - vd55g1_poll_reg(sensor, VD55G1_REG_BOOT, 0, &ret); - if (ret) { - dev_err(sensor->dev, "Failed to boot\n"); - return ret; - } - } - - ret = vd55g1_wait_state(sensor, VD55G1_SYSTEM_FSM_SW_STBY, NULL); - if (ret) { - dev_err(sensor->dev, "Sensor waiting after boot failed\n"); - return ret; - } - - return 0; -} - -static int vd55g1_get_selection(struct v4l2_subdev *sd, - struct v4l2_subdev_state *sd_state, - struct v4l2_subdev_selection *sel) -{ - const struct v4l2_rect *crop = v4l2_subdev_state_get_crop(sd_state, 0); - - switch (sel->target) { - case V4L2_SEL_TGT_CROP: - sel->r = *crop; - return 0; - case V4L2_SEL_TGT_NATIVE_SIZE: - case V4L2_SEL_TGT_CROP_DEFAULT: - case V4L2_SEL_TGT_CROP_BOUNDS: - sel->r.top = 0; - sel->r.left = 0; - sel->r.width = VD55G1_WIDTH; - sel->r.height = VD55G1_HEIGHT; - return 0; - } - - return -EINVAL; -} - -static int vd55g1_enum_mbus_code(struct v4l2_subdev *sd, - struct v4l2_subdev_state *sd_state, - struct v4l2_subdev_mbus_code_enum *code) -{ - struct vd55g1 *sensor = to_vd55g1(sd); - u32 base_code; - - if (sensor->id == VD55G1_MODEL_ID_VD55G1) { - if (code->index >= ARRAY_SIZE(vd55g1_mbus_formats_mono)) - return -EINVAL; - base_code = vd55g1_mbus_formats_mono[code->index]; - } else { - if (code->index >= ARRAY_SIZE(vd55g1_mbus_formats_bayer)) - return -EINVAL; - base_code = vd55g1_mbus_formats_bayer[code->index][0]; - } - code->code = vd55g1_get_fmt_code(sensor, base_code); - - return 0; -} - -static int vd55g1_new_format_change_controls(struct vd55g1 *sensor, - struct v4l2_mbus_framefmt *format, - struct v4l2_rect *crop) -{ - struct vd55g1_vblank_limits vblank; - unsigned int hblank; - unsigned int frame_length = 0; - unsigned int expo_max; - int ret; - - /* Reset vblank and frame length to default */ - vd55g1_get_vblank_limits(sensor, crop, &vblank); - ret = __v4l2_ctrl_modify_range(sensor->vblank_ctrl, vblank.min, - vblank.max, 1, vblank.def); - if (ret) - return ret; - - /* Max exposure changes with vblank */ - frame_length = crop->height + sensor->vblank_ctrl->val; - expo_max = frame_length - VD55G1_EXPO_MAX_TERM; - ret = __v4l2_ctrl_modify_range(sensor->expo_ctrl, 0, expo_max, 1, - VD55G1_EXPO_DEF); - if (ret) - return ret; - - /* Update pixel rate to reflect new bpp */ - ret = __v4l2_ctrl_s_ctrl_int64(sensor->pixel_rate_ctrl, - vd55g1_get_pixel_rate(sensor, format)); - if (ret) - return ret; - - /* Update hblank according to new width */ - hblank = vd55g1_get_hblank_min(sensor, format, crop); - ret = __v4l2_ctrl_modify_range(sensor->hblank_ctrl, hblank, hblank, 1, - hblank); - - return ret; -} - -static int vd55g1_set_pad_fmt(struct v4l2_subdev *sd, - struct v4l2_subdev_state *sd_state, - struct v4l2_subdev_format *sd_fmt) -{ - struct vd55g1 *sensor = to_vd55g1(sd); - const struct vd55g1_mode *new_mode; - struct v4l2_mbus_framefmt *format; - struct v4l2_rect pad_crop; - unsigned int binning; - - new_mode = v4l2_find_nearest_size(vd55g1_supported_modes, - ARRAY_SIZE(vd55g1_supported_modes), - width, height, sd_fmt->format.width, - sd_fmt->format.height); - - vd55g1_update_pad_fmt(sensor, new_mode, sd_fmt->format.code, - &sd_fmt->format); - - /* - * Use binning to maximize the crop rectangle size, and centre it in the - * sensor. - */ - binning = min(VD55G1_WIDTH / sd_fmt->format.width, - VD55G1_HEIGHT / sd_fmt->format.height); - binning = min(binning, 2U); - pad_crop.width = sd_fmt->format.width * binning; - pad_crop.height = sd_fmt->format.height * binning; - pad_crop.left = (VD55G1_WIDTH - pad_crop.width) / 2; - pad_crop.top = (VD55G1_HEIGHT - pad_crop.height) / 2; - - format = v4l2_subdev_state_get_format(sd_state, sd_fmt->pad); - - *format = sd_fmt->format; - - *v4l2_subdev_state_get_crop(sd_state, sd_fmt->pad) = pad_crop; - if (sd_fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) - return vd55g1_new_format_change_controls(sensor, - &sd_fmt->format, - &pad_crop); - - return 0; -} - -static int vd55g1_init_state(struct v4l2_subdev *sd, - struct v4l2_subdev_state *sd_state) -{ - struct vd55g1 *sensor = to_vd55g1(sd); - struct v4l2_subdev_format fmt = { 0 }; - struct v4l2_subdev_route routes[] = { - { .flags = V4L2_SUBDEV_ROUTE_FL_ACTIVE } - }; - struct v4l2_subdev_krouting routing = { - .num_routes = ARRAY_SIZE(routes), - .routes = routes, - }; - int ret; - - /* Needed by v4l2_subdev_s_stream_helper(), even with 1 stream only */ - ret = v4l2_subdev_set_routing(sd, sd_state, &routing); - if (ret) - return ret; - - vd55g1_update_pad_fmt(sensor, &vd55g1_supported_modes[VD55G1_MODE_DEF], - vd55g1_get_fmt_code(sensor, VD55G1_MBUS_CODE_DEF), - &fmt.format); - - return vd55g1_set_pad_fmt(sd, sd_state, &fmt); -} - -static int vd55g1_enum_frame_size(struct v4l2_subdev *sd, - struct v4l2_subdev_state *sd_state, - struct v4l2_subdev_frame_size_enum *fse) -{ - struct vd55g1 *sensor = to_vd55g1(sd); - u32 code; - - if (fse->index >= ARRAY_SIZE(vd55g1_supported_modes)) - return -EINVAL; - - code = vd55g1_get_fmt_code(sensor, fse->code); - if (fse->code != code) - return -EINVAL; - - fse->min_width = vd55g1_supported_modes[fse->index].width; - fse->max_width = fse->min_width; - fse->min_height = vd55g1_supported_modes[fse->index].height; - fse->max_height = fse->min_height; - - return 0; -} - -static const struct v4l2_subdev_internal_ops vd55g1_internal_ops = { - .init_state = vd55g1_init_state, -}; - -static const struct v4l2_subdev_pad_ops vd55g1_pad_ops = { - .enum_mbus_code = vd55g1_enum_mbus_code, - .get_fmt = v4l2_subdev_get_fmt, - .set_fmt = vd55g1_set_pad_fmt, - .get_selection = vd55g1_get_selection, - .enum_frame_size = vd55g1_enum_frame_size, - .enable_streams = vd55g1_enable_streams, - .disable_streams = vd55g1_disable_streams, -}; - -static const struct v4l2_subdev_video_ops vd55g1_video_ops = { - .s_stream = v4l2_subdev_s_stream_helper, -}; - -static const struct v4l2_subdev_ops vd55g1_subdev_ops = { - .video = &vd55g1_video_ops, - .pad = &vd55g1_pad_ops, -}; - -static int vd55g1_g_volatile_ctrl(struct v4l2_ctrl *ctrl) -{ - struct vd55g1 *sensor = ctrl_to_vd55g1(ctrl); - int ret = 0; - - /* Interact with HW only when it is powered ON */ - if (!pm_runtime_get_if_in_use(sensor->dev)) - return 0; - - switch (ctrl->id) { - case V4L2_CID_EXPOSURE_AUTO: - ret = vd55g1_read_expo_cluster(sensor); - break; - default: - ret = -EINVAL; - break; - } - - pm_runtime_put_autosuspend(sensor->dev); - - return ret; -} - -static int vd55g1_s_ctrl(struct v4l2_ctrl *ctrl) -{ - struct vd55g1 *sensor = ctrl_to_vd55g1(ctrl); - unsigned int frame_length = 0; - unsigned int expo_max; - struct v4l2_subdev_state *state = - v4l2_subdev_get_locked_active_state(&sensor->sd); - struct v4l2_rect *crop = - v4l2_subdev_state_get_crop(state, 0); - struct v4l2_mbus_framefmt *format = - v4l2_subdev_state_get_format(state, 0); - unsigned int hblank = vd55g1_get_hblank_min(sensor, format, crop); - bool is_auto = false; - int ret = 0; - - if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY) - return 0; - - /* Update controls state, range, etc. whatever the state of the HW */ - switch (ctrl->id) { - case V4L2_CID_VBLANK: - frame_length = crop->height + ctrl->val; - expo_max = frame_length - VD55G1_EXPO_MAX_TERM; - ret = __v4l2_ctrl_modify_range(sensor->expo_ctrl, 0, expo_max, - 1, VD55G1_EXPO_DEF); - break; - case V4L2_CID_EXPOSURE_AUTO: - is_auto = (ctrl->val == V4L2_EXPOSURE_AUTO); - __v4l2_ctrl_grab(sensor->ae_lock_ctrl, !is_auto); - __v4l2_ctrl_grab(sensor->ae_bias_ctrl, !is_auto); - break; - case V4L2_CID_HDR_SENSOR_MODE: - /* Discriminate if the userspace changed the control value */ - if (ctrl->val != ctrl->cur.val) { - /* Max horizontal blanking changes with hdr mode */ - ret = __v4l2_ctrl_modify_range(sensor->hblank_ctrl, - hblank, hblank, 1, - hblank); - } - break; - default: - break; - } - - /* Don't modify hardware if controls modification failed */ - if (ret) - return ret; - - /* Interact with HW only when it is powered ON */ - if (!pm_runtime_get_if_in_use(sensor->dev)) - return 0; - - switch (ctrl->id) { - case V4L2_CID_HFLIP: - ret = vd55g1_write(sensor, VD55G1_REG_ORIENTATION, - sensor->hflip_ctrl->val | - (sensor->vflip_ctrl->val << 1), - NULL); - break; - case V4L2_CID_TEST_PATTERN: - ret = vd55g1_update_patgen(sensor, ctrl->val); - break; - case V4L2_CID_EXPOSURE_AUTO: - ret = vd55g1_update_expo_cluster(sensor, is_auto); - break; - case V4L2_CID_3A_LOCK: - ret = vd55g1_lock_exposure(sensor, ctrl->val); - break; - case V4L2_CID_AUTO_EXPOSURE_BIAS: - /* - * We use auto exposure target percentage register to control - * exposure bias for more precision. - */ - ret = vd55g1_update_exposure_target(sensor, ctrl->val); - break; - case V4L2_CID_VBLANK: - ret = vd55g1_update_frame_length(sensor, frame_length); - break; - case V4L2_CID_FLASH_LED_MODE: - ret = vd55g1_update_gpios(sensor, sensor->ext_leds_mask); - break; - case V4L2_CID_HDR_SENSOR_MODE: - ret = vd55g1_update_hdr_mode(sensor); - break; - default: - ret = -EINVAL; - break; - } - - pm_runtime_put_autosuspend(sensor->dev); - - return ret; -} - -static const struct v4l2_ctrl_ops vd55g1_ctrl_ops = { - .g_volatile_ctrl = vd55g1_g_volatile_ctrl, - .s_ctrl = vd55g1_s_ctrl, -}; - -static int vd55g1_init_ctrls(struct vd55g1 *sensor) -{ - const struct v4l2_ctrl_ops *ops = &vd55g1_ctrl_ops; - struct v4l2_ctrl_handler *hdl = &sensor->ctrl_handler; - struct v4l2_ctrl *ctrl; - struct v4l2_fwnode_device_properties fwnode_props; - struct vd55g1_vblank_limits vblank; - unsigned int hblank; - struct v4l2_subdev_state *state = - v4l2_subdev_lock_and_get_active_state(&sensor->sd); - struct v4l2_rect *crop = - v4l2_subdev_state_get_crop(state, 0); - struct v4l2_mbus_framefmt *format = - v4l2_subdev_state_get_format(state, 0); - s32 pixel_rate = vd55g1_get_pixel_rate(sensor, format); - int ret; - - v4l2_ctrl_handler_init(hdl, 16); - - /* Flip cluster */ - sensor->hflip_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_HFLIP, - 0, 1, 1, 0); - if (sensor->hflip_ctrl) - sensor->hflip_ctrl->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT; - sensor->vflip_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_VFLIP, - 0, 1, 1, 0); - if (sensor->vflip_ctrl) - sensor->vflip_ctrl->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT; - v4l2_ctrl_cluster(2, &sensor->hflip_ctrl); - - /* Exposition cluster */ - sensor->ae_ctrl = v4l2_ctrl_new_std_menu(hdl, ops, - V4L2_CID_EXPOSURE_AUTO, 1, - ~0x3, V4L2_EXPOSURE_AUTO); - sensor->again_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_ANALOGUE_GAIN, - 0, 0x1c, 1, VD55G1_AGAIN_DEF); - sensor->dgain_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_DIGITAL_GAIN, - 256, 0xffff, 1, - VD55G1_DGAIN_DEF); - sensor->expo_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_EXPOSURE, 0, - VD55G1_FRAME_LENGTH_DEF - - VD55G1_EXPO_MAX_TERM, - 1, VD55G1_EXPO_DEF); - v4l2_ctrl_auto_cluster(4, &sensor->ae_ctrl, V4L2_EXPOSURE_MANUAL, true); - - sensor->patgen_ctrl = - v4l2_ctrl_new_std_menu_items(hdl, ops, V4L2_CID_TEST_PATTERN, - ARRAY_SIZE(vd55g1_tp_menu) - 1, 0, - 0, vd55g1_tp_menu); - ctrl = v4l2_ctrl_new_int_menu(hdl, ops, V4L2_CID_LINK_FREQ, - 0, 0, &sensor->link_freq); - if (ctrl) - ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; - sensor->pixel_rate_ctrl = v4l2_ctrl_new_std(hdl, ops, - V4L2_CID_PIXEL_RATE, 1, - INT_MAX, 1, - pixel_rate); - if (sensor->pixel_rate_ctrl) - sensor->pixel_rate_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; - sensor->ae_lock_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_3A_LOCK, - 0, 1, 0, 0); - sensor->ae_bias_ctrl = - v4l2_ctrl_new_int_menu(hdl, ops, - V4L2_CID_AUTO_EXPOSURE_BIAS, - ARRAY_SIZE(vd55g1_ev_bias_menu) - 1, - ARRAY_SIZE(vd55g1_ev_bias_menu) / 2, - vd55g1_ev_bias_menu); - sensor->hdr_ctrl = - v4l2_ctrl_new_std_menu_items(hdl, ops, - V4L2_CID_HDR_SENSOR_MODE, - ARRAY_SIZE(vd55g1_hdr_menu) - 1, 0, - VD55G1_NO_HDR, vd55g1_hdr_menu); - hblank = vd55g1_get_hblank_min(sensor, format, crop); - sensor->hblank_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_HBLANK, - hblank, hblank, 1, hblank); - if (sensor->hblank_ctrl) - sensor->hblank_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; - vd55g1_get_vblank_limits(sensor, crop, &vblank); - sensor->vblank_ctrl = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_VBLANK, - vblank.min, vblank.max, - 1, vblank.def); - - /* Additional controls based on device tree properties */ - if (sensor->ext_leds_mask) { - sensor->led_ctrl = - v4l2_ctrl_new_std_menu(hdl, ops, - V4L2_CID_FLASH_LED_MODE, - V4L2_FLASH_LED_MODE_FLASH, 0, - V4L2_FLASH_LED_MODE_NONE); - } - - ret = v4l2_fwnode_device_parse(sensor->dev, &fwnode_props); - if (ret) - goto free_ctrls; - - ret = v4l2_ctrl_new_fwnode_properties(hdl, ops, &fwnode_props); - if (ret) - goto free_ctrls; - - sensor->sd.ctrl_handler = hdl; - goto unlock_state; - -free_ctrls: - v4l2_ctrl_handler_free(hdl); -unlock_state: - v4l2_subdev_unlock_state(state); - return ret; -} - -static int vd55g1_detect(struct vd55g1 *sensor) -{ - unsigned int dt_id = (uintptr_t)device_get_match_data(sensor->dev); - u64 rev, id; - int ret; - - ret = vd55g1_read(sensor, VD55G1_REG_MODEL_ID, &id, NULL); - if (ret) - return ret; - - if (id != VD55G1_MODEL_ID_VD55G1 && id != VD55G1_MODEL_ID_VD65G4) { - dev_warn(sensor->dev, "Unsupported sensor id 0x%x\n", - (u32)id); - return -ENODEV; - } - if (id != dt_id) { - dev_err(sensor->dev, "Probed sensor %s and device tree definition (%s) mismatch", - VD55G1_MODEL_ID_NAME(id), VD55G1_MODEL_ID_NAME(dt_id)); - return -ENODEV; - } - sensor->id = id; - - ret = vd55g1_read(sensor, VD55G1_REG_REVISION, &rev, NULL); - if (ret) - return ret; - - if ((id == VD55G1_MODEL_ID_VD55G1 && rev != VD55G1_REVISION_CCB) && - (id == VD55G1_MODEL_ID_VD65G4 && rev != VD55G1_REVISION_BAYER)) { - dev_err(sensor->dev, "Unsupported sensor revision 0x%x for sensor %s\n", - (u16)rev, VD55G1_MODEL_ID_NAME(id)); - return -ENODEV; - } - - return 0; -} - -static int vd55g1_power_on(struct device *dev) -{ - struct v4l2_subdev *sd = dev_get_drvdata(dev); - struct vd55g1 *sensor = to_vd55g1(sd); - int ret; - - ret = regulator_bulk_enable(ARRAY_SIZE(vd55g1_supply_name), - sensor->supplies); - if (ret) { - dev_err(dev, "Failed to enable regulators %d\n", ret); - return ret; - } - - ret = clk_prepare_enable(sensor->xclk); - if (ret) { - dev_err(dev, "Failed to enable clock %d\n", ret); - goto disable_bulk; - } - - gpiod_set_value_cansleep(sensor->reset_gpio, 0); - usleep_range(5000, 10000); - ret = vd55g1_wait_state(sensor, VD55G1_SYSTEM_FSM_READY_TO_BOOT, NULL); - if (ret) { - dev_err(dev, "Sensor reset failed %d\n", ret); - goto disable_clock; - } - - ret = vd55g1_detect(sensor); - if (ret) { - dev_err(dev, "Sensor detect failed %d\n", ret); - goto disable_clock; - } - - /* Setup clock now to advance through system FSM states */ - vd55g1_write(sensor, VD55G1_REG_EXT_CLOCK, sensor->xclk_freq, &ret); - - ret = vd55g1_patch(sensor); - if (ret) { - dev_err(dev, "Sensor patch failed %d\n", ret); - goto disable_clock; - } - - return 0; - -disable_clock: - gpiod_set_value_cansleep(sensor->reset_gpio, 1); - clk_disable_unprepare(sensor->xclk); -disable_bulk: - regulator_bulk_disable(ARRAY_SIZE(vd55g1_supply_name), - sensor->supplies); - - return ret; -} - -static int vd55g1_power_off(struct device *dev) -{ - struct v4l2_subdev *sd = dev_get_drvdata(dev); - struct vd55g1 *sensor = to_vd55g1(sd); - - gpiod_set_value_cansleep(sensor->reset_gpio, 1); - clk_disable_unprepare(sensor->xclk); - regulator_bulk_disable(ARRAY_SIZE(sensor->supplies), sensor->supplies); - - return 0; -} - -static int vd55g1_check_csi_conf(struct vd55g1 *sensor, - struct fwnode_handle *endpoint) -{ - struct v4l2_fwnode_endpoint ep = { .bus_type = V4L2_MBUS_CSI2_DPHY }; - u8 n_lanes; - int ret; - - ret = v4l2_fwnode_endpoint_alloc_parse(endpoint, &ep); - if (ret) - return -EINVAL; - - /* Check lanes number */ - n_lanes = ep.bus.mipi_csi2.num_data_lanes; - if (n_lanes != 1) { - dev_err(sensor->dev, "Sensor only supports 1 lane, found %d\n", - n_lanes); - ret = -EINVAL; - goto done; - } - - /* Clock lane must be first */ - if (ep.bus.mipi_csi2.clock_lane != 0) { - dev_err(sensor->dev, "Clock lane must be mapped to lane 0\n"); - ret = -EINVAL; - goto done; - } - - /* Handle polarities in sensor configuration */ - sensor->oif_ctrl = (ep.bus.mipi_csi2.lane_polarities[0] << 3) | - (ep.bus.mipi_csi2.lane_polarities[1] << 6); - - /* Check the link frequency set in device tree */ - if (!ep.nr_of_link_frequencies) { - dev_err(sensor->dev, "link-frequency property not found in DT\n"); - ret = -EINVAL; - goto done; - } - if (ep.nr_of_link_frequencies != 1) { - dev_err(sensor->dev, "Multiple link frequencies not supported\n"); - ret = -EINVAL; - goto done; - } - sensor->link_freq = ep.link_frequencies[0]; - -done: - v4l2_fwnode_endpoint_free(&ep); - - return ret; -} - -static int vd55g1_parse_dt_gpios_array(struct vd55g1 *sensor, - char *prop_name, u32 *array, int *nb) -{ - unsigned int i; - int ret; - - *nb = device_property_count_u32(sensor->dev, prop_name); - if (*nb == -EINVAL) { - /* Property not found */ - *nb = 0; - return 0; - } - - ret = device_property_read_u32_array(sensor->dev, - prop_name, array, *nb); - if (ret) { - dev_err(sensor->dev, "Failed to read %s prop\n", prop_name); - return ret; - } - for (i = 0; i < *nb; i++) { - if (array[i] >= VD55G1_NB_GPIOS) { - dev_err(sensor->dev, "Invalid GPIO number %d\n", - array[i]); - return -EINVAL; - } - } - - return 0; -} - -static int vd55g1_parse_dt_gpios(struct vd55g1 *sensor) -{ - u32 led_gpios[VD55G1_NB_GPIOS]; - int nb_gpios_leds; - unsigned int i; - int ret; - - /* Initialize GPIOs to default */ - for (i = 0; i < VD55G1_NB_GPIOS; i++) - sensor->gpios[i] = VD55G1_GPIO_MODE_IN; - sensor->ext_leds_mask = 0; - - /* Take into account optional 'st,leds' output for GPIOs */ - ret = vd55g1_parse_dt_gpios_array(sensor, "st,leds", led_gpios, - &nb_gpios_leds); - if (ret) - return ret; - - for (i = 0; i < nb_gpios_leds; i++) { - sensor->gpios[led_gpios[i]] = VD55G1_GPIO_MODE_STROBE; - set_bit(led_gpios[i], &sensor->ext_leds_mask); - } - - return 0; -} - -static int vd55g1_parse_dt(struct vd55g1 *sensor) -{ - struct fwnode_handle *endpoint; - int ret; - - endpoint = fwnode_graph_get_endpoint_by_id(dev_fwnode(sensor->dev), - 0, 0, 0); - if (!endpoint) { - dev_err(sensor->dev, "Endpoint node not found\n"); - return -EINVAL; - } - - ret = vd55g1_check_csi_conf(sensor, endpoint); - fwnode_handle_put(endpoint); - if (ret) - return ret; - - return vd55g1_parse_dt_gpios(sensor); -} - -static int vd55g1_subdev_init(struct vd55g1 *sensor) -{ - int ret; - - /* Init sub device */ - sensor->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; - sensor->sd.internal_ops = &vd55g1_internal_ops; - - /* Init source pad */ - sensor->pad.flags = MEDIA_PAD_FL_SOURCE; - sensor->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; - ret = media_entity_pads_init(&sensor->sd.entity, 1, &sensor->pad); - if (ret) { - dev_err(sensor->dev, "Failed to init media entity: %d\n", ret); - return ret; - } - - sensor->sd.state_lock = sensor->ctrl_handler.lock; - ret = v4l2_subdev_init_finalize(&sensor->sd); - if (ret) { - dev_err(sensor->dev, "Subdev init error: %d\n", ret); - goto err_ctrls; - } - - /* - * Initialize controls after v4l2_subdev_init_finalize() to make sure - * active state is set - */ - ret = vd55g1_init_ctrls(sensor); - if (ret) { - dev_err(sensor->dev, "Controls initialization failed %d\n", - ret); - goto err_media; - } - - return 0; - -err_ctrls: - v4l2_ctrl_handler_free(sensor->sd.ctrl_handler); - -err_media: - media_entity_cleanup(&sensor->sd.entity); - return ret; -} - -static void vd55g1_subdev_cleanup(struct vd55g1 *sensor) -{ - v4l2_async_unregister_subdev(&sensor->sd); - v4l2_subdev_cleanup(&sensor->sd); - media_entity_cleanup(&sensor->sd.entity); - v4l2_ctrl_handler_free(sensor->sd.ctrl_handler); -} - -static int vd55g1_get_regulators(struct vd55g1 *sensor) -{ - unsigned int i; - - for (i = 0; i < ARRAY_SIZE(vd55g1_supply_name); i++) - sensor->supplies[i].supply = vd55g1_supply_name[i]; - - return devm_regulator_bulk_get(sensor->dev, - ARRAY_SIZE(vd55g1_supply_name), - sensor->supplies); -} - -static int vd55g1_probe(struct i2c_client *client) -{ - struct device *dev = &client->dev; - struct vd55g1 *sensor; - int ret; - - sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL); - if (!sensor) - return -ENOMEM; - sensor->dev = &client->dev; - - v4l2_i2c_subdev_init(&sensor->sd, client, &vd55g1_subdev_ops); - - ret = vd55g1_parse_dt(sensor); - if (ret) - return dev_err_probe(dev, ret, "Failed to parse Device Tree\n"); - - /* Get (and check) resources : power regs, ext clock, reset gpio */ - ret = vd55g1_get_regulators(sensor); - if (ret) - return dev_err_probe(dev, ret, "Failed to get regulators\n"); - - sensor->xclk = devm_v4l2_sensor_clk_get(dev, NULL); - if (IS_ERR(sensor->xclk)) - return dev_err_probe(dev, PTR_ERR(sensor->xclk), - "Failed to get xclk\n"); - - sensor->xclk_freq = clk_get_rate(sensor->xclk); - ret = vd55g1_prepare_clock_tree(sensor); - if (ret) - return ret; - - sensor->reset_gpio = devm_gpiod_get_optional(dev, "reset", - GPIOD_OUT_HIGH); - if (IS_ERR(sensor->reset_gpio)) - return dev_err_probe(dev, PTR_ERR(sensor->reset_gpio), - "Failed to get reset gpio\n"); - - sensor->regmap = devm_cci_regmap_init_i2c(client, 16); - if (IS_ERR(sensor->regmap)) - return dev_err_probe(dev, PTR_ERR(sensor->regmap), - "Failed to init regmap\n"); - - /* Detect if sensor is present and if its revision is supported */ - ret = vd55g1_power_on(dev); - if (ret) - return ret; - - /* Enable pm_runtime and power off the sensor */ - pm_runtime_set_active(dev); - pm_runtime_get_noresume(dev); - pm_runtime_enable(dev); - pm_runtime_set_autosuspend_delay(dev, 4000); - pm_runtime_use_autosuspend(dev); - pm_runtime_put_autosuspend(dev); - - ret = vd55g1_subdev_init(sensor); - if (ret) { - dev_err(dev, "V4l2 init failed: %d\n", ret); - goto err_power_off; - } - - ret = v4l2_async_register_subdev(&sensor->sd); - if (ret) { - dev_err(dev, "async subdev register failed %d\n", ret); - goto err_subdev; - } - - return 0; - -err_subdev: - vd55g1_subdev_cleanup(sensor); -err_power_off: - pm_runtime_disable(dev); - pm_runtime_put_noidle(dev); - pm_runtime_dont_use_autosuspend(dev); - vd55g1_power_off(dev); - - return ret; -} - -static void vd55g1_remove(struct i2c_client *client) -{ - struct v4l2_subdev *sd = i2c_get_clientdata(client); - struct vd55g1 *sensor = to_vd55g1(sd); - - vd55g1_subdev_cleanup(sensor); - - pm_runtime_disable(&client->dev); - if (!pm_runtime_status_suspended(&client->dev)) - vd55g1_power_off(&client->dev); - pm_runtime_set_suspended(&client->dev); - pm_runtime_dont_use_autosuspend(&client->dev); -} - -static const struct of_device_id vd55g1_dt_ids[] = { - { .compatible = "st,vd55g1", .data = (void *)VD55G1_MODEL_ID_VD55G1 }, - { .compatible = "st,vd65g4", .data = (void *)VD55G1_MODEL_ID_VD65G4 }, - { /* sentinel */ } -}; -MODULE_DEVICE_TABLE(of, vd55g1_dt_ids); - -static const struct dev_pm_ops vd55g1_pm_ops = { - SET_RUNTIME_PM_OPS(vd55g1_power_off, vd55g1_power_on, NULL) -}; - -static struct i2c_driver vd55g1_i2c_driver = { - .driver = { - .name = "vd55g1", - .of_match_table = vd55g1_dt_ids, - .pm = &vd55g1_pm_ops, - }, - .probe = vd55g1_probe, - .remove = vd55g1_remove, -}; - -module_i2c_driver(vd55g1_i2c_driver); - -MODULE_AUTHOR("Benjamin Mugnier "); -MODULE_AUTHOR("Sylvain Petinot "); -MODULE_DESCRIPTION("VD55G1 camera subdev driver"); -MODULE_LICENSE("GPL"); From 0a2285cdb89b65733b4adb0d6298a372b395d4fc Mon Sep 17 00:00:00 2001 From: Peter Marshall Date: Thu, 30 Jul 2026 16:03:36 -0400 Subject: [PATCH 09/10] MAINTAINERS: Update ST VD55G camera driver entry Point to the updated vd55g sources and documentation, and add myself as a maintainer. Signed-off-by: Peter Marshall --- MAINTAINERS | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/MAINTAINERS b/MAINTAINERS index e8f06145fb54c..76c0eb7a68464 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -24369,13 +24369,14 @@ S: Maintained F: Documentation/hwmon/stpddc60.rst F: drivers/hwmon/pmbus/stpddc60.c -ST VD55G1 DRIVER +ST VD55G DRIVER M: Benjamin Mugnier M: Sylvain Petinot +M: Peter Marshall L: linux-media@vger.kernel.org S: Maintained -F: Documentation/devicetree/bindings/media/i2c/st,vd55g1.yaml -F: drivers/media/i2c/vd55g1.c +F: Documentation/devicetree/bindings/media/i2c/st,vd55g.yaml +F: drivers/media/i2c/vd55g.c ST VD56G3 IMAGE SENSOR DRIVER M: Benjamin Mugnier From c34d8d02713e755183b9200fd6c68448eb4e7767 Mon Sep 17 00:00:00 2001 From: Peter Marshall Date: Thu, 30 Jul 2026 13:16:34 -0400 Subject: [PATCH 10/10] media: ipu6: work around stream issues The system's ring bus / RAM is clocked down during low power states, causing flickering and FIFO timeut errors with some sensors when the CPU is idle. This was originally noticed by Hans de Goede on the linux-media mailing list (see https://marc.info/?l=linux-media&m=175999034702772). Tighten the PM QoS value during IPU6 streaming to work around the issue. A value of 50ms appears to work fine. The IPU6 fails to start streaming with modes using 384 bytes per line or less. Bump the minimum frame width up to a safe pixel limit. --- drivers/media/pci/intel/ipu6/ipu6-isys.c | 2 +- drivers/media/pci/intel/ipu6/ipu6-isys.h | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/drivers/media/pci/intel/ipu6/ipu6-isys.c b/drivers/media/pci/intel/ipu6/ipu6-isys.c index fc0ec0a4b8f54..84aa98f15dd20 100644 --- a/drivers/media/pci/intel/ipu6/ipu6-isys.c +++ b/drivers/media/pci/intel/ipu6/ipu6-isys.c @@ -98,7 +98,7 @@ enum ltr_did_type { LTR_TYPE_MAX }; -#define ISYS_PM_QOS_VALUE 300 +#define ISYS_PM_QOS_VALUE 50 static int isys_isr_one(struct ipu6_bus_device *adev); diff --git a/drivers/media/pci/intel/ipu6/ipu6-isys.h b/drivers/media/pci/intel/ipu6/ipu6-isys.h index 0e2c8b71edfc9..465c4e00f46d0 100644 --- a/drivers/media/pci/intel/ipu6/ipu6-isys.h +++ b/drivers/media/pci/intel/ipu6/ipu6-isys.h @@ -39,7 +39,8 @@ struct ipu6_bus_device; #define IPU6_ISYS_SIZE_PROXY_SEND_QUEUE 5 #define IPU6_ISYS_NUM_RECV_QUEUE 1 -#define IPU6_ISYS_MIN_WIDTH 2U +/* Work around stream failing with low bytes per line */ +#define IPU6_ISYS_MIN_WIDTH 392U #define IPU6_ISYS_MIN_HEIGHT 1U #define IPU6_ISYS_MAX_WIDTH 4672U #define IPU6_ISYS_MAX_HEIGHT 3416U