From 173cbf58c73e04ab96ce7938699d2860c06212cc Mon Sep 17 00:00:00 2001 From: Jai Luthra Date: Fri, 3 Jul 2026 14:49:16 +0530 Subject: [PATCH 01/18] dt-bindings: media: i2c: Add Sony IMX678 Commit 447ea0c26e57c1b423426e6c46d7ff89fd66eb6b upstream. Sony IMX678 is an 8.4 Megapixel (3856x2180) CMOS sensor, that can output pixels over MIPI CSI-2 bus. Add bindings for it. Runtime detection for mono vs color variant of this sensor is feasible by reading a register, but it's not always desirable given the sensor needs to be powered on for it, potentially flashing a privacy LED or wasting precious boot time. The manufacturer or vendor knows which sensor variant they are putting on their board, so we define the compatible property to expect the (color/mono) specific name of the sensor, along with a generic fallback. Reviewed-by: Conor Dooley Signed-off-by: Jai Luthra Signed-off-by: Sakari Ailus --- MAINTAINERS | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 944802a56d2ca..ba9f3135f5327 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -24129,6 +24129,12 @@ T: git git://linuxtv.org/media_tree.git F: Documentation/devicetree/bindings/media/i2c/sony,imx708.yaml F: drivers/media/i2c/imx708.c +SONY IMX678 SENSOR DRIVER +M: Jai Luthra +L: linux-media@vger.kernel.org +S: Maintained +F: Documentation/devicetree/bindings/media/i2c/sony,imx678.yaml + SONY MEMORYSTICK SUBSYSTEM M: Maxim Levitsky M: Alex Dubov From 1ea96c75d32d7f7f1f830ffdb6800a66437308d1 Mon Sep 17 00:00:00 2001 From: Jai Luthra Date: Fri, 3 Jul 2026 14:49:17 +0530 Subject: [PATCH 02/18] media: i2c: imx678: Add driver for Sony IMX678 Commit bf40cc53b1e00c312046f6dd88e9054bc91865af upstream. Add a V4L2 subdev driver for the Sony IMX678 image sensor. IMX678 is a diagonal 8.86 mm (Type 1/1.8) CMOS active pixel type solid-state image sensor with a square pixel array and 8.40 M effective pixels. The following features are supported by this driver: - MIPI RAW12 output - Monochrome and Color (Bayer filter) variants - Multiple input clock frequencies - Multiple link frequencies - VBLANK and HBLANK control for variable framerate - VFLIP and HFLIP control for flipping readout - Exposure and analogue gain control - Test pattern control Following features are not currently supported: - MIPI RAW10 output - Pixel-perfect crop reporting, accounting for the shift-by-1 when doing HFLIP/VFLIP where the sensor maintains RGGB bayer ordering Along with the ones below which depend on the new raw sensor model: - Embedded data stream - Freely configurable cropping - Increased framerate when cropping - 2x2 binning support Signed-off-by: Jai Luthra Reviewed-by: Tarang Raval [Sakari Ailus: Add an extra newline to the enum_mbus_code op.] Signed-off-by: Sakari Ailus --- MAINTAINERS | 1 + drivers/media/i2c/Kconfig | 11 + drivers/media/i2c/Makefile | 1 + drivers/media/i2c/imx678.c | 1447 ++++++++++++++++++++++++++++++++++++ 4 files changed, 1460 insertions(+) create mode 100644 drivers/media/i2c/imx678.c diff --git a/MAINTAINERS b/MAINTAINERS index ba9f3135f5327..1057c9aa8bf34 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -24134,6 +24134,7 @@ M: Jai Luthra L: linux-media@vger.kernel.org S: Maintained F: Documentation/devicetree/bindings/media/i2c/sony,imx678.yaml +F: drivers/media/i2c/imx678.c SONY MEMORYSTICK SUBSYSTEM M: Maxim Levitsky diff --git a/drivers/media/i2c/Kconfig b/drivers/media/i2c/Kconfig index e1c13cc5b3126..1b0247be8ed0b 100644 --- a/drivers/media/i2c/Kconfig +++ b/drivers/media/i2c/Kconfig @@ -350,6 +350,17 @@ config VIDEO_IMX708 To compile this driver as a module, choose M here: the module will be called imx708. +config VIDEO_IMX678 + tristate "Sony IMX678 sensor support" + depends on GPIOLIB + select V4L2_CCI_I2C + help + This is a Video4Linux2 sensor driver for the Sony + IMX678 camera. + + To compile this driver as a module, choose M here: the + module will be called imx678. + config VIDEO_MAX9271_LIB tristate diff --git a/drivers/media/i2c/Makefile b/drivers/media/i2c/Makefile index 9d139d07eb4f1..84c89056a7a10 100644 --- a/drivers/media/i2c/Makefile +++ b/drivers/media/i2c/Makefile @@ -67,6 +67,7 @@ obj-$(CONFIG_VIDEO_IMX415) += imx415.o obj-$(CONFIG_VIDEO_IMX477) += imx477.o obj-$(CONFIG_VIDEO_IMX500) += imx500.o obj-$(CONFIG_VIDEO_IMX519) += imx519.o +obj-$(CONFIG_VIDEO_IMX678) += imx678.o obj-$(CONFIG_VIDEO_IMX708) += imx708.o obj-$(CONFIG_VIDEO_IR_I2C) += ir-kbd-i2c.o obj-$(CONFIG_VIDEO_IRS1125) += irs1125.o diff --git a/drivers/media/i2c/imx678.c b/drivers/media/i2c/imx678.c new file mode 100644 index 0000000000000..0efbf43d2fe6c --- /dev/null +++ b/drivers/media/i2c/imx678.c @@ -0,0 +1,1447 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * V4L2 driver for Sony IMX678 + * + * Diagonal 8.86 mm (Type 1/1.8) CMOS image sensor with 8.40 M effective pixels. + * + * Copyright (C) 2026 Ideas On Board Oy. + * + * Based on Sony IMX678 driver prepared by Will Whang & Soho Enterprise Ltd. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Standby or streaming mode */ +#define IMX678_REG_MODE_SELECT CCI_REG8(0x3000) +#define IMX678_MODE_STANDBY 0x01 +#define IMX678_MODE_STREAMING 0x00 +#define IMX678_STREAM_DELAY_US 25000 +#define IMX678_STREAM_DELAY_RANGE_US 1000 + +/* XVS/XHS sync control */ +#define IMX678_REG_XMSTA CCI_REG8(0x3002) +#define IMX678_REG_XXS_DRV CCI_REG8(0x30a6) +#define IMX678_REG_XXS_OUTSEL CCI_REG8(0x30a4) + +/* Clk selection */ +#define IMX678_REG_INCK_SEL CCI_REG8(0x3014) + +/* Link Speed */ +#define IMX678_REG_DATARATE_SEL CCI_REG8(0x3015) + +/* Lane Count */ +#define IMX678_REG_LANEMODE CCI_REG8(0x3040) + +/* + * The internal readout clock runs at 74.25 MHz. In one cycle the AD reads 8 + * pixels, thus giving us a rate of 74.25 * 8 = 594 MPix/s + */ +#define IMX678_PIXEL_RATE 594000000 +#define IMX678_PIX_PER_CLK 8 + +/* VMAX - Frame Length in Lines */ +#define IMX678_REG_VMAX CCI_REG24_LE(0x3028) +#define IMX678_VMAX_MAX 0xfffff +#define IMX678_VMAX_DEFAULT 2250 + +/* HMAX - Line Length in Cycles (8 Pixels) */ +#define IMX678_REG_HMAX CCI_REG16_LE(0x302c) +#define IMX678_HMAX_MAX 0xffff + +/* SHR internal */ +#define IMX678_REG_SHR CCI_REG24_LE(0x3050) +#define IMX678_SHR_MIN 8 + +/* Exposure control */ +#define IMX678_EXPOSURE_MIN 2 +#define IMX678_EXPOSURE_STEP 1 +#define IMX678_EXPOSURE_DEFAULT 1000 + +/* + * Analogue gain control + * Range is from 0 to 100 (0dB - 30dB) with 0.3dB step size + * Values from 101 to 240 are valid but correspond to additional digital gain + * (0.3dB - 42dB) so don't expose it to userspace + */ +#define IMX678_REG_GAIN CCI_REG16_LE(0x3070) +#define IMX678_ANA_GAIN_MIN_NORMAL 0 +#define IMX678_ANA_GAIN_MAX_NORMAL 100 +#define IMX678_ANA_GAIN_STEP 1 +#define IMX678_ANA_GAIN_DEFAULT 0 + +/* Crop */ +#define IMX678_REG_WINMODE CCI_REG8(0x3018) +#define IMX678_REG_PIX_HST CCI_REG16_LE(0x303c) +#define IMX678_REG_PIX_HWIDTH CCI_REG16_LE(0x303e) +#define IMX678_REG_PIX_VST CCI_REG16_LE(0x3044) +#define IMX678_REG_PIX_VWIDTH CCI_REG16_LE(0x3046) + +/* Flip */ +#define IMX678_REG_WINMODEH CCI_REG8(0x3020) +#define IMX678_REG_WINMODEV CCI_REG8(0x3021) + +/* Sensor Identification */ +#define IMX678_REG_MONOCHROME CCI_REG8(0x4d18) +#define IMX678_TYPE BIT(0) +#define IMX678_REG_MODULE_ID CCI_REG16_LE(0x4d1c) +#define IMX678_ID 0x02a6 +#define IMX678_MODULE_ID_DELAY 80000 + +/* Common configuration registers */ +#define IMX678_REG_WDMODE CCI_REG8(0x301a) +#define IMX678_REG_ADDMODE CCI_REG8(0x301b) +#define IMX678_REG_THIN_V_EN CCI_REG8(0x301c) +#define IMX678_REG_VCMODE CCI_REG8(0x301e) +#define IMX678_REG_ADBIT CCI_REG8(0x3022) +#define IMX678_REG_MDBIT CCI_REG8(0x3023) +#define IMX678_REG_GAIN_PGC_FIDMD CCI_REG8(0x3400) + +/* Test pattern generator */ +#define IMX678_REG_TPG_EN_DUOUT CCI_REG8(0x30e0) +#define IMX678_REG_TPG_PATSEL_DUOUT CCI_REG8(0x30e2) +#define IMX678_TPG_ALL_000 0 +#define IMX678_TPG_ALL_FFF 1 +#define IMX678_TPG_ALL_555 2 +#define IMX678_TPG_ALL_AAA 3 +#define IMX678_TPG_TOG_555_AAA 4 +#define IMX678_TPG_TOG_AAA_555 5 +#define IMX678_TPG_TOG_000_555 6 +#define IMX678_TPG_TOG_555_000 7 +#define IMX678_TPG_TOG_000_FFF 8 +#define IMX678_TPG_TOG_FFF_000 9 +#define IMX678_TPG_H_COLOR_BARS 10 +#define IMX678_TPG_V_COLOR_BARS 11 +#define IMX678_REG_TPG_COLORWIDTH CCI_REG8(0x30e4) +#define IMX678_TPG_COLORWIDTH_80PIX 0 +#define IMX678_TPG_COLORWIDTH_160PIX 1 +#define IMX678_TPG_COLORWIDTH_320PIX 2 +#define IMX678_TPG_COLORWIDTH_640PIX 3 + +#define IMX678_REG_INTERFACE_SEL CCI_REG8(0x4e3c) +#define IMX678_INTERFACE_2L_4L 0x07 +#define IMX678_INTERFACE_8L_2x4L 0x7f + +/* Minimum output resolution */ +#define IMX678_PIXEL_ARRAY_MIN_WIDTH 1040 +#define IMX678_PIXEL_ARRAY_MIN_HEIGHT 956 + +/* Sensor windowing register alignment */ +#define IMX678_CROP_HWIDTH_ALIGN 16 +#define IMX678_CROP_VWIDTH_ALIGN 4 +#define IMX678_CROP_HST_ALIGN 4 +#define IMX678_CROP_VST_ALIGN 4 + +/* Subdev pads */ +#define IMX678_SOURCE_PAD 0 + +/* IMX678 native and active pixel array size. */ +static const struct v4l2_rect imx678_native_area = { + .top = 0, + .left = 0, + .width = 3857, + .height = 2201, +}; + +static const struct v4l2_rect imx678_active_area = { + .top = 20, + .left = 0, + .width = 3856, + .height = 2180, +}; + +enum imx678_type { + IMX678_COLOR = 0, + IMX678_MONOCHROME = 1, +}; + +struct imx678_model_info { + enum imx678_type type; + const u32 *codes; + unsigned int num_codes; +}; + +enum imx678_lanemode { + IMX678_LANEMODE_2L = 1, + IMX678_LANEMODE_4L = 3, +}; + +/* Link frequency setup (DDR: lane rate = 2 x link freq) */ +enum { + IMX678_LINK_FREQ_297MHZ, + IMX678_LINK_FREQ_360MHZ, + IMX678_LINK_FREQ_445MHZ, + IMX678_LINK_FREQ_594MHZ, + IMX678_LINK_FREQ_720MHZ, + IMX678_LINK_FREQ_891MHZ, + IMX678_LINK_FREQ_1039MHZ, + IMX678_LINK_FREQ_1188MHZ, +}; + +static const u8 link_freqs_reg_value[] = { + [IMX678_LINK_FREQ_297MHZ] = 0x07, + [IMX678_LINK_FREQ_360MHZ] = 0x06, + [IMX678_LINK_FREQ_445MHZ] = 0x05, + [IMX678_LINK_FREQ_594MHZ] = 0x04, + [IMX678_LINK_FREQ_720MHZ] = 0x03, + [IMX678_LINK_FREQ_891MHZ] = 0x02, + [IMX678_LINK_FREQ_1039MHZ] = 0x01, + [IMX678_LINK_FREQ_1188MHZ] = 0x00, +}; + +static const u64 link_freqs[] = { + [IMX678_LINK_FREQ_297MHZ] = 297000000, + [IMX678_LINK_FREQ_360MHZ] = 360000000, + [IMX678_LINK_FREQ_445MHZ] = 445500000, + [IMX678_LINK_FREQ_594MHZ] = 594000000, + [IMX678_LINK_FREQ_720MHZ] = 720000000, + [IMX678_LINK_FREQ_891MHZ] = 891000000, + [IMX678_LINK_FREQ_1039MHZ] = 1039500000, + [IMX678_LINK_FREQ_1188MHZ] = 1188000000, +}; + +static const u16 min_hmax_4lane[] = { + [IMX678_LINK_FREQ_297MHZ] = 1584, + [IMX678_LINK_FREQ_360MHZ] = 1320, + [IMX678_LINK_FREQ_445MHZ] = 1100, + [IMX678_LINK_FREQ_594MHZ] = 792, + [IMX678_LINK_FREQ_720MHZ] = 660, + [IMX678_LINK_FREQ_891MHZ] = 550, + [IMX678_LINK_FREQ_1039MHZ] = 550, + [IMX678_LINK_FREQ_1188MHZ] = 550, +}; + +struct imx678_inck_cfg { + u32 xclk_hz; /* platform clock rate */ + u8 inck_sel; /* value for reg */ +}; + +static const struct imx678_inck_cfg imx678_inck_table[] = { + { 74250000, 0x00 }, + { 37125000, 0x01 }, + { 72000000, 0x02 }, + { 27000000, 0x03 }, + { 24000000, 0x04 }, + { 36000000, 0x05 }, + { 18000000, 0x06 }, + { 13500000, 0x07 }, +}; + +static const char * const imx678_tpg_menu[] = { + "Disabled", + "All 000h", + "All FFFh", + "All 555h", + "All AAAh", + "Toggle 555/AAAh", + "Toggle AAA/555h", + "Toggle 000/555h", + "Toggle 555/000h", + "Toggle 000/FFFh", + "Toggle FFF/000h", + "Horizontal color bars", + "Vertical color bars", +}; + +static const int imx678_tpg_val[] = { + IMX678_TPG_ALL_000, + IMX678_TPG_ALL_000, + IMX678_TPG_ALL_FFF, + IMX678_TPG_ALL_555, + IMX678_TPG_ALL_AAA, + IMX678_TPG_TOG_555_AAA, + IMX678_TPG_TOG_AAA_555, + IMX678_TPG_TOG_000_555, + IMX678_TPG_TOG_555_000, + IMX678_TPG_TOG_000_FFF, + IMX678_TPG_TOG_FFF_000, + IMX678_TPG_H_COLOR_BARS, + IMX678_TPG_V_COLOR_BARS, +}; + +/* Common configuration */ +static const struct cci_reg_sequence common_regs[] = { + { IMX678_REG_THIN_V_EN, 0x00 }, + { IMX678_REG_VCMODE, 0x01 }, + { CCI_REG8(0x306b), 0x00 }, + { IMX678_REG_GAIN_PGC_FIDMD, 0x01 }, + { CCI_REG8(0x3460), 0x22 }, + { CCI_REG8(0x355a), 0x64 }, + { CCI_REG8(0x3a02), 0x7a }, + { CCI_REG8(0x3a10), 0xec }, + { CCI_REG8(0x3a12), 0x71 }, + { CCI_REG8(0x3a14), 0xde }, + { CCI_REG8(0x3a20), 0x2b }, + { CCI_REG8(0x3a24), 0x22 }, + { CCI_REG8(0x3a25), 0x25 }, + { CCI_REG8(0x3a26), 0x2a }, + { CCI_REG8(0x3a27), 0x2c }, + { CCI_REG8(0x3a28), 0x39 }, + { CCI_REG8(0x3a29), 0x38 }, + { CCI_REG8(0x3a30), 0x04 }, + { CCI_REG8(0x3a31), 0x04 }, + { CCI_REG8(0x3a32), 0x03 }, + { CCI_REG8(0x3a33), 0x03 }, + { CCI_REG8(0x3a34), 0x09 }, + { CCI_REG8(0x3a35), 0x06 }, + { CCI_REG8(0x3a38), 0xcd }, + { CCI_REG8(0x3a3a), 0x4c }, + { CCI_REG8(0x3a3c), 0xb9 }, + { CCI_REG8(0x3a3e), 0x30 }, + { CCI_REG8(0x3a40), 0x2c }, + { CCI_REG8(0x3a42), 0x39 }, + { CCI_REG8(0x3a4e), 0x00 }, + { CCI_REG8(0x3a52), 0x00 }, + { CCI_REG8(0x3a56), 0x00 }, + { CCI_REG8(0x3a5a), 0x00 }, + { CCI_REG8(0x3a5e), 0x00 }, + { CCI_REG8(0x3a62), 0x00 }, + { CCI_REG8(0x3a64), 0x00 }, + { CCI_REG8(0x3a6e), 0xa0 }, + { CCI_REG8(0x3a70), 0x50 }, + { CCI_REG8(0x3a8c), 0x04 }, + { CCI_REG8(0x3a8d), 0x03 }, + { CCI_REG8(0x3a8e), 0x09 }, + { CCI_REG8(0x3a90), 0x38 }, + { CCI_REG8(0x3a91), 0x42 }, + { CCI_REG8(0x3a92), 0x3c }, + { CCI_REG8(0x3b0e), 0xf3 }, + { CCI_REG8(0x3b12), 0xe5 }, + { CCI_REG8(0x3b27), 0xc0 }, + { CCI_REG8(0x3b2e), 0xef }, + { CCI_REG8(0x3b30), 0x6a }, + { CCI_REG8(0x3b32), 0xf6 }, + { CCI_REG8(0x3b36), 0xe1 }, + { CCI_REG8(0x3b3a), 0xe8 }, + { CCI_REG8(0x3b5a), 0x17 }, + { CCI_REG8(0x3b5e), 0xef }, + { CCI_REG8(0x3b60), 0x6a }, + { CCI_REG8(0x3b62), 0xf6 }, + { CCI_REG8(0x3b66), 0xe1 }, + { CCI_REG8(0x3b6a), 0xe8 }, + { CCI_REG8(0x3b88), 0xec }, + { CCI_REG8(0x3b8a), 0xed }, + { CCI_REG8(0x3b94), 0x71 }, + { CCI_REG8(0x3b96), 0x72 }, + { CCI_REG8(0x3b98), 0xde }, + { CCI_REG8(0x3b9a), 0xdf }, + { CCI_REG8(0x3c0f), 0x06 }, + { CCI_REG8(0x3c10), 0x06 }, + { CCI_REG8(0x3c11), 0x06 }, + { CCI_REG8(0x3c12), 0x06 }, + { CCI_REG8(0x3c13), 0x06 }, + { CCI_REG8(0x3c18), 0x20 }, + { CCI_REG8(0x3c37), 0x10 }, + { CCI_REG8(0x3c3a), 0x7a }, + { CCI_REG8(0x3c40), 0xf4 }, + { CCI_REG8(0x3c48), 0xe6 }, + { CCI_REG8(0x3c54), 0xce }, + { CCI_REG8(0x3c56), 0xd0 }, + { CCI_REG8(0x3c6c), 0x53 }, + { CCI_REG8(0x3c6e), 0x55 }, + { CCI_REG8(0x3c70), 0xc0 }, + { CCI_REG8(0x3c72), 0xc2 }, + { CCI_REG8(0x3c7e), 0xce }, + { CCI_REG8(0x3c8c), 0xcf }, + { CCI_REG8(0x3c8e), 0xeb }, + { CCI_REG8(0x3c98), 0x54 }, + { CCI_REG8(0x3c9a), 0x70 }, + { CCI_REG8(0x3c9c), 0xc1 }, + { CCI_REG8(0x3c9e), 0xdd }, + { CCI_REG8(0x3cb0), 0x7a }, + { CCI_REG8(0x3cb2), 0xba }, + { CCI_REG8(0x3cc8), 0xbc }, + { CCI_REG8(0x3cca), 0x7c }, + { CCI_REG8(0x3cd4), 0xea }, + { CCI_REG8(0x3cd5), 0x01 }, + { CCI_REG8(0x3cd6), 0x4a }, + { CCI_REG8(0x3cd8), 0x00 }, + { CCI_REG8(0x3cd9), 0x00 }, + { CCI_REG8(0x3cda), 0xff }, + { CCI_REG8(0x3cdb), 0x03 }, + { CCI_REG8(0x3cdc), 0x00 }, + { CCI_REG8(0x3cdd), 0x00 }, + { CCI_REG8(0x3cde), 0xff }, + { CCI_REG8(0x3cdf), 0x03 }, + { CCI_REG8(0x3ce4), 0x4c }, + { CCI_REG8(0x3ce6), 0xec }, + { CCI_REG8(0x3ce7), 0x01 }, + { CCI_REG8(0x3ce8), 0xff }, + { CCI_REG8(0x3ce9), 0x03 }, + { CCI_REG8(0x3cea), 0x00 }, + { CCI_REG8(0x3ceb), 0x00 }, + { CCI_REG8(0x3cec), 0xff }, + { CCI_REG8(0x3ced), 0x03 }, + { CCI_REG8(0x3cee), 0x00 }, + { CCI_REG8(0x3cef), 0x00 }, + { CCI_REG8(0x3cf2), 0xff }, + { CCI_REG8(0x3cf3), 0x03 }, + { CCI_REG8(0x3cf4), 0x00 }, + { CCI_REG8(0x3e28), 0x82 }, + { CCI_REG8(0x3e2a), 0x80 }, + { CCI_REG8(0x3e30), 0x85 }, + { CCI_REG8(0x3e32), 0x7d }, + { CCI_REG8(0x3e5c), 0xce }, + { CCI_REG8(0x3e5e), 0xd3 }, + { CCI_REG8(0x3e70), 0x53 }, + { CCI_REG8(0x3e72), 0x58 }, + { CCI_REG8(0x3e74), 0xc0 }, + { CCI_REG8(0x3e76), 0xc5 }, + { CCI_REG8(0x3e78), 0xc0 }, + { CCI_REG8(0x3e79), 0x01 }, + { CCI_REG8(0x3e7a), 0xd4 }, + { CCI_REG8(0x3e7b), 0x01 }, + { CCI_REG8(0x3eb4), 0x0b }, + { CCI_REG8(0x3eb5), 0x02 }, + { CCI_REG8(0x3eb6), 0x4d }, + { CCI_REG8(0x3eb7), 0x42 }, + { CCI_REG8(0x3eec), 0xf3 }, + { CCI_REG8(0x3eee), 0xe7 }, + { CCI_REG8(0x3f01), 0x01 }, + { CCI_REG8(0x3f24), 0x10 }, + { CCI_REG8(0x3f28), 0x2d }, + { CCI_REG8(0x3f2a), 0x2d }, + { CCI_REG8(0x3f2c), 0x2d }, + { CCI_REG8(0x3f2e), 0x2d }, + { CCI_REG8(0x3f30), 0x23 }, + { CCI_REG8(0x3f38), 0x2d }, + { CCI_REG8(0x3f3a), 0x2d }, + { CCI_REG8(0x3f3c), 0x2d }, + { CCI_REG8(0x3f3e), 0x28 }, + { CCI_REG8(0x3f40), 0x1e }, + { CCI_REG8(0x3f48), 0x2d }, + { CCI_REG8(0x3f4a), 0x2d }, + { CCI_REG8(0x3f4c), 0x00 }, + { CCI_REG8(0x4004), 0xe4 }, + { CCI_REG8(0x4006), 0xff }, + { CCI_REG8(0x4018), 0x69 }, + { CCI_REG8(0x401a), 0x84 }, + { CCI_REG8(0x401c), 0xd6 }, + { CCI_REG8(0x401e), 0xf1 }, + { CCI_REG8(0x4038), 0xde }, + { CCI_REG8(0x403a), 0x00 }, + { CCI_REG8(0x403b), 0x01 }, + { CCI_REG8(0x404c), 0x63 }, + { CCI_REG8(0x404e), 0x85 }, + { CCI_REG8(0x4050), 0xd0 }, + { CCI_REG8(0x4052), 0xf2 }, + { CCI_REG8(0x4108), 0xdd }, + { CCI_REG8(0x410a), 0xf7 }, + { CCI_REG8(0x411c), 0x62 }, + { CCI_REG8(0x411e), 0x7c }, + { CCI_REG8(0x4120), 0xcf }, + { CCI_REG8(0x4122), 0xe9 }, + { CCI_REG8(0x4138), 0xe6 }, + { CCI_REG8(0x413a), 0xf1 }, + { CCI_REG8(0x414c), 0x6b }, + { CCI_REG8(0x414e), 0x76 }, + { CCI_REG8(0x4150), 0xd8 }, + { CCI_REG8(0x4152), 0xe3 }, + { CCI_REG8(0x417e), 0x03 }, + { CCI_REG8(0x417f), 0x01 }, + { CCI_REG8(0x4186), 0xe0 }, + { CCI_REG8(0x4190), 0xf3 }, + { CCI_REG8(0x4192), 0xf7 }, + { CCI_REG8(0x419c), 0x78 }, + { CCI_REG8(0x419e), 0x7c }, + { CCI_REG8(0x41a0), 0xe5 }, + { CCI_REG8(0x41a2), 0xe9 }, + { CCI_REG8(0x41c8), 0xe2 }, + { CCI_REG8(0x41ca), 0xfd }, + { CCI_REG8(0x41dc), 0x67 }, + { CCI_REG8(0x41de), 0x82 }, + { CCI_REG8(0x41e0), 0xd4 }, + { CCI_REG8(0x41e2), 0xef }, + { CCI_REG8(0x4200), 0xde }, + { CCI_REG8(0x4202), 0xda }, + { CCI_REG8(0x4218), 0x63 }, + { CCI_REG8(0x421a), 0x5f }, + { CCI_REG8(0x421c), 0xd0 }, + { CCI_REG8(0x421e), 0xcc }, + { CCI_REG8(0x425a), 0x82 }, + { CCI_REG8(0x425c), 0xef }, + { CCI_REG8(0x4348), 0xfe }, + { CCI_REG8(0x4349), 0x06 }, + { CCI_REG8(0x4352), 0xce }, + { CCI_REG8(0x4420), 0x0b }, + { CCI_REG8(0x4421), 0x02 }, + { CCI_REG8(0x4422), 0x4d }, + { CCI_REG8(0x4423), 0x0a }, + { CCI_REG8(0x4426), 0xf5 }, + { CCI_REG8(0x442a), 0xe7 }, + { CCI_REG8(0x4432), 0xf5 }, + { CCI_REG8(0x4436), 0xe7 }, + { CCI_REG8(0x4466), 0xb4 }, + { CCI_REG8(0x446e), 0x32 }, + { CCI_REG8(0x449f), 0x1c }, + { CCI_REG8(0x44a4), 0x2c }, + { CCI_REG8(0x44a6), 0x2c }, + { CCI_REG8(0x44a8), 0x2c }, + { CCI_REG8(0x44aa), 0x2c }, + { CCI_REG8(0x44b4), 0x2c }, + { CCI_REG8(0x44b6), 0x2c }, + { CCI_REG8(0x44b8), 0x2c }, + { CCI_REG8(0x44ba), 0x2c }, + { CCI_REG8(0x44c4), 0x2c }, + { CCI_REG8(0x44c6), 0x2c }, + { CCI_REG8(0x44c8), 0x2c }, + { CCI_REG8(0x4506), 0xf3 }, + { CCI_REG8(0x450e), 0xe5 }, + { CCI_REG8(0x4516), 0xf3 }, + { CCI_REG8(0x4522), 0xe5 }, + { CCI_REG8(0x4524), 0xf3 }, + { CCI_REG8(0x452c), 0xe5 }, + { CCI_REG8(0x453c), 0x22 }, + { CCI_REG8(0x453d), 0x1b }, + { CCI_REG8(0x453e), 0x1b }, + { CCI_REG8(0x453f), 0x15 }, + { CCI_REG8(0x4540), 0x15 }, + { CCI_REG8(0x4541), 0x15 }, + { CCI_REG8(0x4542), 0x15 }, + { CCI_REG8(0x4543), 0x15 }, + { CCI_REG8(0x4544), 0x15 }, + { CCI_REG8(0x4548), 0x00 }, + { CCI_REG8(0x4549), 0x01 }, + { CCI_REG8(0x454a), 0x01 }, + { CCI_REG8(0x454b), 0x06 }, + { CCI_REG8(0x454c), 0x06 }, + { CCI_REG8(0x454d), 0x06 }, + { CCI_REG8(0x454e), 0x06 }, + { CCI_REG8(0x454f), 0x06 }, + { CCI_REG8(0x4550), 0x06 }, + { CCI_REG8(0x4554), 0x55 }, + { CCI_REG8(0x4555), 0x02 }, + { CCI_REG8(0x4556), 0x42 }, + { CCI_REG8(0x4557), 0x05 }, + { CCI_REG8(0x4558), 0xfd }, + { CCI_REG8(0x4559), 0x05 }, + { CCI_REG8(0x455a), 0x94 }, + { CCI_REG8(0x455b), 0x06 }, + { CCI_REG8(0x455d), 0x06 }, + { CCI_REG8(0x455e), 0x49 }, + { CCI_REG8(0x455f), 0x07 }, + { CCI_REG8(0x4560), 0x7f }, + { CCI_REG8(0x4561), 0x07 }, + { CCI_REG8(0x4562), 0xa5 }, + { CCI_REG8(0x4564), 0x55 }, + { CCI_REG8(0x4565), 0x02 }, + { CCI_REG8(0x4566), 0x42 }, + { CCI_REG8(0x4567), 0x05 }, + { CCI_REG8(0x4568), 0xfd }, + { CCI_REG8(0x4569), 0x05 }, + { CCI_REG8(0x456a), 0x94 }, + { CCI_REG8(0x456b), 0x06 }, + { CCI_REG8(0x456d), 0x06 }, + { CCI_REG8(0x456e), 0x49 }, + { CCI_REG8(0x456f), 0x07 }, + { CCI_REG8(0x4572), 0xa5 }, + { CCI_REG8(0x460c), 0x7d }, + { CCI_REG8(0x460e), 0xb1 }, + { CCI_REG8(0x4614), 0xa8 }, + { CCI_REG8(0x4616), 0xb2 }, + { CCI_REG8(0x461c), 0x7e }, + { CCI_REG8(0x461e), 0xa7 }, + { CCI_REG8(0x4624), 0xa8 }, + { CCI_REG8(0x4626), 0xb2 }, + { CCI_REG8(0x462c), 0x7e }, + { CCI_REG8(0x462e), 0x8a }, + { CCI_REG8(0x4630), 0x94 }, + { CCI_REG8(0x4632), 0xa7 }, + { CCI_REG8(0x4634), 0xfb }, + { CCI_REG8(0x4636), 0x2f }, + { CCI_REG8(0x4638), 0x81 }, + { CCI_REG8(0x4639), 0x01 }, + { CCI_REG8(0x463a), 0xb5 }, + { CCI_REG8(0x463b), 0x01 }, + { CCI_REG8(0x463c), 0x26 }, + { CCI_REG8(0x463e), 0x30 }, + { CCI_REG8(0x4640), 0xac }, + { CCI_REG8(0x4641), 0x01 }, + { CCI_REG8(0x4642), 0xb6 }, + { CCI_REG8(0x4643), 0x01 }, + { CCI_REG8(0x4644), 0xfc }, + { CCI_REG8(0x4646), 0x25 }, + { CCI_REG8(0x4648), 0x82 }, + { CCI_REG8(0x4649), 0x01 }, + { CCI_REG8(0x464a), 0xab }, + { CCI_REG8(0x464b), 0x01 }, + { CCI_REG8(0x464c), 0x26 }, + { CCI_REG8(0x464e), 0x30 }, + { CCI_REG8(0x4654), 0xfc }, + { CCI_REG8(0x4656), 0x08 }, + { CCI_REG8(0x4658), 0x12 }, + { CCI_REG8(0x465a), 0x25 }, + { CCI_REG8(0x4662), 0xfc }, + { CCI_REG8(0x46a2), 0xfb }, + { CCI_REG8(0x46d6), 0xf3 }, + { CCI_REG8(0x46e6), 0x00 }, + { CCI_REG8(0x46e8), 0xff }, + { CCI_REG8(0x46e9), 0x03 }, + { CCI_REG8(0x46ec), 0x7a }, + { CCI_REG8(0x46ee), 0xe5 }, + { CCI_REG8(0x46f4), 0xee }, + { CCI_REG8(0x46f6), 0xf2 }, + { CCI_REG8(0x470c), 0xff }, + { CCI_REG8(0x470d), 0x03 }, + { CCI_REG8(0x470e), 0x00 }, + { CCI_REG8(0x4714), 0xe0 }, + { CCI_REG8(0x4716), 0xe4 }, + { CCI_REG8(0x471e), 0xed }, + { CCI_REG8(0x472e), 0x00 }, + { CCI_REG8(0x4730), 0xff }, + { CCI_REG8(0x4731), 0x03 }, + { CCI_REG8(0x4734), 0x7b }, + { CCI_REG8(0x4736), 0xdf }, + { CCI_REG8(0x4754), 0x7d }, + { CCI_REG8(0x4756), 0x8b }, + { CCI_REG8(0x4758), 0x93 }, + { CCI_REG8(0x475a), 0xb1 }, + { CCI_REG8(0x475c), 0xfb }, + { CCI_REG8(0x475e), 0x09 }, + { CCI_REG8(0x4760), 0x11 }, + { CCI_REG8(0x4762), 0x2f }, + { CCI_REG8(0x4766), 0xcc }, + { CCI_REG8(0x4776), 0xcb }, + { CCI_REG8(0x477e), 0x4a }, + { CCI_REG8(0x478e), 0x49 }, + { CCI_REG8(0x4794), 0x7c }, + { CCI_REG8(0x4796), 0x8f }, + { CCI_REG8(0x4798), 0xb3 }, + { CCI_REG8(0x4799), 0x00 }, + { CCI_REG8(0x479a), 0xcc }, + { CCI_REG8(0x479c), 0xc1 }, + { CCI_REG8(0x479e), 0xcb }, + { CCI_REG8(0x47a4), 0x7d }, + { CCI_REG8(0x47a6), 0x8e }, + { CCI_REG8(0x47a8), 0xb4 }, + { CCI_REG8(0x47a9), 0x00 }, + { CCI_REG8(0x47aa), 0xc0 }, + { CCI_REG8(0x47ac), 0xfa }, + { CCI_REG8(0x47ae), 0x0d }, + { CCI_REG8(0x47b0), 0x31 }, + { CCI_REG8(0x47b1), 0x01 }, + { CCI_REG8(0x47b2), 0x4a }, + { CCI_REG8(0x47b3), 0x01 }, + { CCI_REG8(0x47b4), 0x3f }, + { CCI_REG8(0x47b6), 0x49 }, + { CCI_REG8(0x47bc), 0xfb }, + { CCI_REG8(0x47be), 0x0c }, + { CCI_REG8(0x47c0), 0x32 }, + { CCI_REG8(0x47c1), 0x01 }, + { CCI_REG8(0x47c2), 0x3e }, + { CCI_REG8(0x47c3), 0x01 }, + { IMX678_REG_WDMODE, 0x00 }, + { IMX678_REG_MDBIT, 0x01 }, + { IMX678_REG_XXS_DRV, 0x00 }, +}; + +static const u32 codes_bayer[] = { + MEDIA_BUS_FMT_SRGGB12_1X12, +}; + +static const u32 codes_monochrome[] = { + MEDIA_BUS_FMT_Y12_1X12, +}; + +static const struct imx678_model_info imx678_aaqr_info = { + .type = IMX678_COLOR, + .codes = codes_bayer, + .num_codes = ARRAY_SIZE(codes_bayer), +}; + +static const struct imx678_model_info imx678_aamr_info = { + .type = IMX678_MONOCHROME, + .codes = codes_monochrome, + .num_codes = ARRAY_SIZE(codes_monochrome), +}; + +static const char * const imx678_supply_name[] = { + "avdd", /* Analog (3.3V) supply */ + "dvdd", /* Digital Core (1.1V) supply */ + "ovdd", /* IF (1.8V) supply */ +}; + +struct imx678 { + struct v4l2_subdev sd; + struct media_pad pad; + struct regmap *cci; + + const struct imx678_model_info *info; + + struct clk *xclk; + u32 xclk_freq; + + /* chosen INCK_SEL register value */ + u8 inck_sel_val; + + /* Link configurations */ + enum imx678_lanemode lane_mode; + unsigned long link_freq_bitmap; + + struct gpio_desc *reset_gpio; + struct regulator_bulk_data supplies[ARRAY_SIZE(imx678_supply_name)]; + + struct v4l2_ctrl_handler ctrl_handler; + + /* V4L2 Controls */ + struct v4l2_ctrl *exposure; + struct v4l2_ctrl *vblank; + struct v4l2_ctrl *hblank; + + /* Track VMAX for exposure updates */ + u32 vmax; +}; + +static inline struct imx678 *to_imx678(struct v4l2_subdev *_sd) +{ + return container_of_const(_sd, struct imx678, sd); +} + +static u32 imx678_default_mbus_code(struct imx678 *imx678) +{ + return imx678->info->codes[0]; +} + +static bool imx678_mbus_code_supported(struct imx678 *imx678, u32 code) +{ + for (unsigned int i = 0; i < imx678->info->num_codes; i++) { + if (imx678->info->codes[i] == code) + return true; + } + + return false; +} + +static int imx678_set_ctrl(struct v4l2_ctrl *ctrl) +{ + struct imx678 *imx678 = container_of_const(ctrl->handler, struct + imx678, ctrl_handler); + struct i2c_client *client = v4l2_get_subdevdata(&imx678->sd); + const struct v4l2_mbus_framefmt *format; + struct v4l2_subdev_state *state; + int ret = 0; + + state = v4l2_subdev_get_locked_active_state(&imx678->sd); + format = v4l2_subdev_state_get_format(state, IMX678_SOURCE_PAD); + + if (ctrl->id == V4L2_CID_VBLANK) { + u32 current_exposure = imx678->exposure->cur.val; + + imx678->vmax = format->height + ctrl->val; + + current_exposure = clamp_t(u32, current_exposure, + IMX678_EXPOSURE_MIN, + imx678->vmax - IMX678_SHR_MIN); + ret = __v4l2_ctrl_modify_range(imx678->exposure, + IMX678_EXPOSURE_MIN, + imx678->vmax - IMX678_SHR_MIN, + 1, current_exposure); + if (ret) + return ret; + } + + /* + * Only apply control values when device is powered on (RPM ACTIVE) + * and streaming (usage count != 0) + */ + if (!pm_runtime_get_if_in_use(&client->dev)) + return 0; + + switch (ctrl->id) { + case V4L2_CID_VBLANK: + cci_write(imx678->cci, IMX678_REG_VMAX, imx678->vmax, &ret); + fallthrough; /* SHR = VMAX - exposure, so update it */ + case V4L2_CID_EXPOSURE: { + u32 shr = imx678->vmax - imx678->exposure->val; + + cci_write(imx678->cci, IMX678_REG_SHR, shr, &ret); + break; + } + case V4L2_CID_ANALOGUE_GAIN: + cci_write(imx678->cci, IMX678_REG_GAIN, ctrl->val, &ret); + break; + case V4L2_CID_HBLANK: { + u32 hmax = (format->width + ctrl->val) / IMX678_PIX_PER_CLK; + + cci_write(imx678->cci, IMX678_REG_HMAX, hmax, &ret); + break; + } + case V4L2_CID_TEST_PATTERN: { + cci_write(imx678->cci, IMX678_REG_TPG_COLORWIDTH, + IMX678_TPG_COLORWIDTH_160PIX, &ret); + cci_write(imx678->cci, IMX678_REG_TPG_PATSEL_DUOUT, + imx678_tpg_val[ctrl->val], &ret); + cci_write(imx678->cci, IMX678_REG_TPG_EN_DUOUT, + (ctrl->val) ? 1 : 0, + &ret); + break; + } + case V4L2_CID_HFLIP: + cci_write(imx678->cci, IMX678_REG_WINMODEH, ctrl->val, &ret); + break; + case V4L2_CID_VFLIP: + cci_write(imx678->cci, IMX678_REG_WINMODEV, ctrl->val, &ret); + break; + default: + dev_warn(&client->dev, + "ctrl(id:0x%x,val:0x%x) is not handled\n", + ctrl->id, ctrl->val); + break; + } + + pm_runtime_put(&client->dev); + + return ret; +} + +static const struct v4l2_ctrl_ops imx678_ctrl_ops = { + .s_ctrl = imx678_set_ctrl, +}; + +static int imx678_enum_mbus_code(struct v4l2_subdev *sd, + struct v4l2_subdev_state *sd_state, + struct v4l2_subdev_mbus_code_enum *code) +{ + struct imx678 *imx678 = to_imx678(sd); + + if (code->index >= imx678->info->num_codes) + return -EINVAL; + + code->code = imx678->info->codes[code->index]; + + return 0; +} + +static int imx678_enum_frame_size(struct v4l2_subdev *sd, + struct v4l2_subdev_state *sd_state, + struct v4l2_subdev_frame_size_enum *fse) +{ + struct imx678 *imx678 = to_imx678(sd); + const struct v4l2_rect *crop; + + if (fse->index) + return -EINVAL; + + if (!imx678_mbus_code_supported(imx678, fse->code)) + return -EINVAL; + + crop = v4l2_subdev_state_get_crop(sd_state, fse->pad); + + fse->min_width = crop->width; + fse->max_width = fse->min_width; + fse->min_height = crop->height; + fse->max_height = fse->min_height; + + return 0; +} + +static int imx678_get_selection(struct v4l2_subdev *sd, + struct v4l2_subdev_state *sd_state, + struct v4l2_subdev_selection *sel) +{ + switch (sel->target) { + case V4L2_SEL_TGT_CROP: + sel->r = *v4l2_subdev_state_get_crop(sd_state, sel->pad); + return 0; + + case V4L2_SEL_TGT_NATIVE_SIZE: + sel->r = imx678_native_area; + return 0; + + case V4L2_SEL_TGT_CROP_DEFAULT: + case V4L2_SEL_TGT_CROP_BOUNDS: + sel->r = imx678_active_area; + return 0; + } + + return -EINVAL; +} + +static int imx678_init_state(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state) +{ + struct imx678 *imx678 = to_imx678(sd); + struct v4l2_mbus_framefmt *format; + struct v4l2_rect *crop; + + crop = v4l2_subdev_state_get_crop(state, IMX678_SOURCE_PAD); + *crop = imx678_active_area; + + format = v4l2_subdev_state_get_format(state, IMX678_SOURCE_PAD); + format->code = imx678_default_mbus_code(imx678); + format->width = imx678_active_area.width; + format->height = imx678_active_area.height; + format->field = V4L2_FIELD_NONE; + format->colorspace = V4L2_COLORSPACE_RAW; + format->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; + format->quantization = V4L2_QUANTIZATION_FULL_RANGE; + format->xfer_func = V4L2_XFER_FUNC_NONE; + + return 0; +} + +static int imx678_write_common(struct imx678 *imx678) +{ + int ret = 0; + + cci_multi_reg_write(imx678->cci, common_regs, ARRAY_SIZE(common_regs), + &ret); + + cci_write(imx678->cci, IMX678_REG_INCK_SEL, imx678->inck_sel_val, &ret); + cci_write(imx678->cci, IMX678_REG_DATARATE_SEL, + link_freqs_reg_value[__ffs(imx678->link_freq_bitmap)], &ret); + cci_write(imx678->cci, IMX678_REG_LANEMODE, imx678->lane_mode, &ret); + + cci_write(imx678->cci, IMX678_REG_INTERFACE_SEL, IMX678_INTERFACE_2L_4L, + &ret); + + return ret; +} + +static int imx678_program_window(struct imx678 *imx678, + const struct v4l2_rect *crop) +{ + int ret = 0; + + cci_write(imx678->cci, IMX678_REG_ADDMODE, 0x00, &ret); + cci_write(imx678->cci, IMX678_REG_WINMODE, + v4l2_rect_equal(crop, &imx678_active_area) ? 0x00 : 0x04, + &ret); + cci_write(imx678->cci, IMX678_REG_PIX_HST, + crop->left - imx678_active_area.left, &ret); + cci_write(imx678->cci, IMX678_REG_PIX_HWIDTH, crop->width, &ret); + cci_write(imx678->cci, IMX678_REG_PIX_VST, + crop->top - imx678_active_area.top, &ret); + cci_write(imx678->cci, IMX678_REG_PIX_VWIDTH, crop->height, &ret); + cci_write(imx678->cci, IMX678_REG_ADBIT, 0x01, &ret); + + return ret; +} + +static int imx678_enable_streams(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state, u32 pad, + u64 mask) +{ + struct i2c_client *client = v4l2_get_subdevdata(sd); + struct imx678 *imx678 = to_imx678(sd); + const struct v4l2_rect *crop; + int ret; + + ret = pm_runtime_resume_and_get(&client->dev); + if (ret < 0) + return ret; + + crop = v4l2_subdev_state_get_crop(state, pad); + ret = imx678_program_window(imx678, crop); + if (ret) { + dev_err(&client->dev, "%s failed to set mode\n", __func__); + goto err_rpm_put; + } + + ret = __v4l2_ctrl_handler_setup(imx678->sd.ctrl_handler); + if (ret) { + dev_err(&client->dev, "%s failed to apply user values\n", + __func__); + goto err_rpm_put; + } + + cci_write(imx678->cci, IMX678_REG_MODE_SELECT, IMX678_MODE_STREAMING, + &ret); + usleep_range(IMX678_STREAM_DELAY_US, IMX678_STREAM_DELAY_US + + IMX678_STREAM_DELAY_RANGE_US); + cci_write(imx678->cci, IMX678_REG_XMSTA, 0x00, &ret); + + if (ret) { + dev_err(&client->dev, "%s failed to start streaming\n", + __func__); + goto err_rpm_put; + } + + return 0; + +err_rpm_put: + pm_runtime_put(&client->dev); + + return ret; +} + +static int imx678_disable_streams(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state, + u32 pad, u64 mask) +{ + struct i2c_client *client = v4l2_get_subdevdata(sd); + struct imx678 *imx678 = to_imx678(sd); + int ret = 0; + + /* Master mode disable */ + cci_write(imx678->cci, IMX678_REG_XMSTA, 0x01, &ret); + /* Standby */ + cci_write(imx678->cci, IMX678_REG_MODE_SELECT, IMX678_MODE_STANDBY, + &ret); + if (ret) + dev_err(&client->dev, "%s failed to stop stream\n", __func__); + + pm_runtime_put(&client->dev); + + return ret; +} + +static int imx678_power_on(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + struct v4l2_subdev *sd = i2c_get_clientdata(client); + struct imx678 *imx678 = to_imx678(sd); + int ret; + + ret = regulator_bulk_enable(ARRAY_SIZE(imx678_supply_name), + imx678->supplies); + if (ret) { + dev_err(&client->dev, "%s: failed to enable regulators\n", + __func__); + return ret; + } + + fsleep(1); /* Tlow > 500ns */ + + gpiod_set_value_cansleep(imx678->reset_gpio, 0); + + fsleep(1); /* T3 > 1us */ + + ret = clk_prepare_enable(imx678->xclk); + if (ret) { + dev_err(&client->dev, "%s: failed to enable clock\n", + __func__); + goto reg_off; + } + + fsleep(20); /* T4 > 20us */ + + ret = imx678_write_common(imx678); + if (ret) { + dev_err(&client->dev, "%s failed to write registers\n", + __func__); + goto clk_off; + } + + return 0; + +clk_off: + clk_disable_unprepare(imx678->xclk); + +reg_off: + gpiod_set_value_cansleep(imx678->reset_gpio, 1); + regulator_bulk_disable(ARRAY_SIZE(imx678_supply_name), + imx678->supplies); + + return ret; +} + +static int imx678_power_off(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + struct v4l2_subdev *sd = i2c_get_clientdata(client); + struct imx678 *imx678 = to_imx678(sd); + + clk_disable_unprepare(imx678->xclk); + gpiod_set_value_cansleep(imx678->reset_gpio, 1); + regulator_bulk_disable(ARRAY_SIZE(imx678_supply_name), + imx678->supplies); + + return 0; +} + +static int imx678_identify_model(struct imx678 *imx678) +{ + struct i2c_client *client = v4l2_get_subdevdata(&imx678->sd); + const struct imx678_model_info *info; + enum imx678_type detected; + int ret = 0; + u64 val = 0; + + info = device_get_match_data(&client->dev); + + /* + * This sensor's ID registers become accessible 80ms after coming out + * of STANDBY mode. + */ + cci_write(imx678->cci, IMX678_REG_MODE_SELECT, 0, &ret); + fsleep(IMX678_MODULE_ID_DELAY); + + cci_read(imx678->cci, IMX678_REG_MODULE_ID, &val, &ret); + + if (ret) { + dev_err(&client->dev, + "I2C transaction failed ret = %d\n", ret); + return ret; + } + + if (val != IMX678_ID) { + dev_err(&client->dev, + "Chip ID mismatch: %x!=%llx\n", IMX678_ID, val); + return -ENXIO; + } + + cci_read(imx678->cci, IMX678_REG_MONOCHROME, &val, &ret); + + if (ret) { + dev_err(&client->dev, + "I2C transaction failed ret = %d\n", ret); + return ret; + } + + detected = val & IMX678_TYPE; + + /* Prefer to use sensor type specified in device tree */ + if (info) { + imx678->info = info; + if (detected != info->type) + dev_err(&client->dev, + "detected %s sensor, DT specifies %s; using DT value\n", + detected == IMX678_COLOR ? "color" : "mono", + info->type == IMX678_COLOR ? "color" : "mono"); + } else { + imx678->info = detected == IMX678_MONOCHROME ? + &imx678_aamr_info : &imx678_aaqr_info; + dev_info(&client->dev, + "sensor type missing in DT; detected %s sensor\n", + detected == IMX678_MONOCHROME ? "mono" : "color"); + } + + return 0; +} + +static const struct v4l2_subdev_video_ops imx678_video_ops = { + .s_stream = v4l2_subdev_s_stream_helper, +}; + +static const struct v4l2_subdev_pad_ops imx678_pad_ops = { + .enum_mbus_code = imx678_enum_mbus_code, + .get_fmt = v4l2_subdev_get_fmt, + .set_fmt = v4l2_subdev_get_fmt, + .get_selection = imx678_get_selection, + .enum_frame_size = imx678_enum_frame_size, + .enable_streams = imx678_enable_streams, + .disable_streams = imx678_disable_streams, +}; + +static const struct v4l2_subdev_ops imx678_subdev_ops = { + .video = &imx678_video_ops, + .pad = &imx678_pad_ops, +}; + +static const struct v4l2_subdev_internal_ops imx678_internal_ops = { + .init_state = imx678_init_state, +}; + +static int imx678_init_controls(struct imx678 *imx678) +{ + struct v4l2_ctrl_handler *ctrl_hdlr; + const u32 hmax_4lane = min_hmax_4lane[__ffs(imx678->link_freq_bitmap)]; + const u32 lane_scale = imx678->lane_mode == IMX678_LANEMODE_2L ? 2 : 1; + struct i2c_client *client = v4l2_get_subdevdata(&imx678->sd); + struct v4l2_fwnode_device_properties props; + struct v4l2_ctrl *link_freq; + s32 hblank, max_hblank, vblank, max_vblank; + u32 hmax; + int ret; + + ret = v4l2_fwnode_device_parse(&client->dev, &props); + if (ret < 0) + return ret; + + ctrl_hdlr = &imx678->ctrl_handler; + ret = v4l2_ctrl_handler_init(ctrl_hdlr, 11); + if (ret) + return ret; + + imx678->vmax = IMX678_VMAX_DEFAULT; + hmax = hmax_4lane * lane_scale; + + /* PIXEL_RATE is fixed and read-only */ + v4l2_ctrl_new_std(ctrl_hdlr, &imx678_ctrl_ops, V4L2_CID_PIXEL_RATE, + IMX678_PIXEL_RATE, IMX678_PIXEL_RATE, 1, + IMX678_PIXEL_RATE); + + /* LINK_FREQ is also read only */ + link_freq = v4l2_ctrl_new_int_menu(ctrl_hdlr, &imx678_ctrl_ops, + V4L2_CID_LINK_FREQ, + ARRAY_SIZE(link_freqs) - 1, + __ffs(imx678->link_freq_bitmap), + link_freqs); + + if (link_freq) + link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY; + + vblank = imx678->vmax - imx678_active_area.height; + max_vblank = IMX678_VMAX_MAX - imx678_active_area.height; + imx678->vblank = v4l2_ctrl_new_std(ctrl_hdlr, &imx678_ctrl_ops, + V4L2_CID_VBLANK, vblank, max_vblank, + 2, vblank); + + hblank = hmax * IMX678_PIX_PER_CLK - imx678_active_area.width; + max_hblank = IMX678_HMAX_MAX * IMX678_PIX_PER_CLK - + imx678_active_area.width; + imx678->hblank = v4l2_ctrl_new_std(ctrl_hdlr, &imx678_ctrl_ops, + V4L2_CID_HBLANK, hblank, max_hblank, + IMX678_PIX_PER_CLK, hblank); + + imx678->exposure = v4l2_ctrl_new_std(ctrl_hdlr, &imx678_ctrl_ops, + V4L2_CID_EXPOSURE, + IMX678_EXPOSURE_MIN, + IMX678_VMAX_DEFAULT - + IMX678_SHR_MIN, + IMX678_EXPOSURE_STEP, + IMX678_EXPOSURE_DEFAULT); + + v4l2_ctrl_new_std(ctrl_hdlr, &imx678_ctrl_ops, V4L2_CID_ANALOGUE_GAIN, + IMX678_ANA_GAIN_MIN_NORMAL, + IMX678_ANA_GAIN_MAX_NORMAL, IMX678_ANA_GAIN_STEP, + IMX678_ANA_GAIN_DEFAULT); + + v4l2_ctrl_new_std(ctrl_hdlr, &imx678_ctrl_ops, V4L2_CID_HFLIP, + 0, 1, 1, 0); + v4l2_ctrl_new_std(ctrl_hdlr, &imx678_ctrl_ops, V4L2_CID_VFLIP, + 0, 1, 1, 0); + + v4l2_ctrl_new_std_menu_items(ctrl_hdlr, &imx678_ctrl_ops, + V4L2_CID_TEST_PATTERN, + ARRAY_SIZE(imx678_tpg_menu) - 1, 0, 0, + imx678_tpg_menu); + + v4l2_ctrl_new_fwnode_properties(ctrl_hdlr, &imx678_ctrl_ops, &props); + + if (ctrl_hdlr->error) { + ret = ctrl_hdlr->error; + dev_err(&client->dev, "%s control init failed (%d)\n", + __func__, ret); + v4l2_ctrl_handler_free(ctrl_hdlr); + return ret; + } + + imx678->sd.ctrl_handler = ctrl_hdlr; + + return 0; +} + +static int imx678_check_hwcfg(struct device *dev, struct imx678 *imx678) +{ + struct fwnode_handle *endpoint; + struct v4l2_fwnode_endpoint ep_cfg = { + .bus_type = V4L2_MBUS_CSI2_DPHY + }; + int ret = -EINVAL; + + endpoint = fwnode_graph_get_endpoint_by_id(dev_fwnode(dev), 0, 0, 0); + if (!endpoint) { + dev_err(dev, "endpoint node not found\n"); + return -EINVAL; + } + + if (v4l2_fwnode_endpoint_alloc_parse(endpoint, &ep_cfg)) { + dev_err(dev, "could not parse endpoint\n"); + goto error_out; + } + + switch (ep_cfg.bus.mipi_csi2.num_data_lanes) { + case 2: + imx678->lane_mode = IMX678_LANEMODE_2L; + break; + case 4: + imx678->lane_mode = IMX678_LANEMODE_4L; + break; + default: + dev_err(dev, + "only 2 or 4 CSI2 data lanes are currently supported\n"); + goto error_out; + } + + ret = v4l2_link_freq_to_bitmap(dev, ep_cfg.link_frequencies, + ep_cfg.nr_of_link_frequencies, + link_freqs, ARRAY_SIZE(link_freqs), + &imx678->link_freq_bitmap); + +error_out: + v4l2_fwnode_endpoint_free(&ep_cfg); + fwnode_handle_put(endpoint); + + return ret; +} + +static int imx678_probe(struct i2c_client *client) +{ + struct device *dev = &client->dev; + struct imx678 *imx678; + int ret, i; + + imx678 = devm_kzalloc(&client->dev, sizeof(*imx678), GFP_KERNEL); + if (!imx678) + return -ENOMEM; + + v4l2_i2c_subdev_init(&imx678->sd, client, &imx678_subdev_ops); + + imx678->cci = devm_cci_regmap_init_i2c(client, 16); + if (IS_ERR(imx678->cci)) + return dev_err_probe(dev, PTR_ERR(imx678->cci), + "failed to init CCI\n"); + + if (imx678_check_hwcfg(dev, imx678)) + return -EINVAL; + + imx678->xclk = devm_v4l2_sensor_clk_get(dev, NULL); + if (IS_ERR(imx678->xclk)) + return dev_err_probe(dev, PTR_ERR(imx678->xclk), + "failed to get xclk\n"); + + imx678->xclk_freq = clk_get_rate(imx678->xclk); + + for (i = 0; i < ARRAY_SIZE(imx678_inck_table); ++i) { + if (imx678_inck_table[i].xclk_hz == imx678->xclk_freq) { + imx678->inck_sel_val = imx678_inck_table[i].inck_sel; + break; + } + } + + if (i == ARRAY_SIZE(imx678_inck_table)) + return dev_err_probe(dev, -EINVAL, + "unsupported XCLK rate %u Hz\n", + imx678->xclk_freq); + + for (i = 0; i < ARRAY_SIZE(imx678_supply_name); i++) + imx678->supplies[i].supply = imx678_supply_name[i]; + + ret = devm_regulator_bulk_get(&client->dev, + ARRAY_SIZE(imx678_supply_name), + imx678->supplies); + if (ret) + return dev_err_probe(dev, ret, "failed to get regulators\n"); + + imx678->reset_gpio = devm_gpiod_get_optional(dev, "reset", + GPIOD_OUT_HIGH); + if (IS_ERR(imx678->reset_gpio)) + return dev_err_probe(dev, PTR_ERR(imx678->reset_gpio), + "failed to get reset GPIO\n"); + + ret = imx678_power_on(dev); + if (ret) + return ret; + + ret = imx678_identify_model(imx678); + if (ret) + goto error_power_off; + + pm_runtime_set_active(dev); + pm_runtime_enable(dev); + + ret = imx678_init_controls(imx678); + if (ret) + goto error_pm_runtime; + + imx678->sd.internal_ops = &imx678_internal_ops; + imx678->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; + imx678->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; + + imx678->pad.flags = MEDIA_PAD_FL_SOURCE; + + ret = media_entity_pads_init(&imx678->sd.entity, 1, &imx678->pad); + if (ret) { + dev_err_probe(dev, ret, "failed to init entity pads\n"); + goto error_handler_free; + } + + imx678->sd.state_lock = imx678->ctrl_handler.lock; + ret = v4l2_subdev_init_finalize(&imx678->sd); + if (ret < 0) { + dev_err_probe(dev, ret, "subdev init error\n"); + goto error_media_entity; + } + + ret = v4l2_async_register_subdev_sensor(&imx678->sd); + if (ret < 0) { + dev_err_probe(dev, ret, + "failed to register sensor sub-device\n"); + goto error_subdev_cleanup; + } + + pm_runtime_idle(dev); + + return 0; + +error_subdev_cleanup: + v4l2_subdev_cleanup(&imx678->sd); + +error_media_entity: + media_entity_cleanup(&imx678->sd.entity); + +error_handler_free: + v4l2_ctrl_handler_free(imx678->sd.ctrl_handler); + +error_pm_runtime: + pm_runtime_disable(&client->dev); + pm_runtime_set_suspended(&client->dev); + +error_power_off: + imx678_power_off(&client->dev); + + return ret; +} + +static void imx678_remove(struct i2c_client *client) +{ + struct v4l2_subdev *sd = i2c_get_clientdata(client); + struct imx678 *imx678 = to_imx678(sd); + + v4l2_async_unregister_subdev(sd); + v4l2_subdev_cleanup(sd); + media_entity_cleanup(&sd->entity); + v4l2_ctrl_handler_free(imx678->sd.ctrl_handler); + + pm_runtime_disable(&client->dev); + if (!pm_runtime_status_suspended(&client->dev)) + imx678_power_off(&client->dev); + pm_runtime_set_suspended(&client->dev); +} + +static const struct dev_pm_ops imx678_pm_ops = { + SET_RUNTIME_PM_OPS(imx678_power_off, imx678_power_on, NULL) +}; + +static const struct of_device_id imx678_of_match[] = { + { .compatible = "sony,imx678-aamr", .data = &imx678_aamr_info }, + { .compatible = "sony,imx678-aaqr", .data = &imx678_aaqr_info }, + /* for non-conforming DTs that rely on runtime check */ + { .compatible = "sony,imx678" }, + { /* sentinel */ } +}; + +MODULE_DEVICE_TABLE(of, imx678_of_match); + +static struct i2c_driver imx678_i2c_driver = { + .driver = { + .name = "imx678", + .of_match_table = imx678_of_match, + .pm = pm_ptr(&imx678_pm_ops), + }, + .probe = imx678_probe, + .remove = imx678_remove, +}; + +module_i2c_driver(imx678_i2c_driver); + +MODULE_AUTHOR("Will Whang "); +MODULE_AUTHOR("Tetsuya NOMURA "); +MODULE_AUTHOR("Jai Luthra "); +MODULE_DESCRIPTION("Sony imx678 sensor driver"); +MODULE_LICENSE("GPL"); From 35726bbb2f7394291f11c60e7041a41679f0babb Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Thu, 3 Sep 2026 16:33:22 +0100 Subject: [PATCH 03/18] media: imx678: Rework into generic Starvis 2 sensor driver. The register layout and programming model for multiple of the Sony Starvis2 sensors is identical, so prepare for supporting those by renaming all common parts of the driver to a starvis2_ prefix, and renaming the driver. Signed-off-by: Dave Stevenson --- MAINTAINERS | 14 +- drivers/media/i2c/Kconfig | 20 +- drivers/media/i2c/Makefile | 2 +- .../media/i2c/{imx678.c => sony-starvis2.c} | 755 +++++++++--------- 4 files changed, 406 insertions(+), 385 deletions(-) rename drivers/media/i2c/{imx678.c => sony-starvis2.c} (57%) diff --git a/MAINTAINERS b/MAINTAINERS index 1057c9aa8bf34..1e808fd09ae92 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -24129,13 +24129,6 @@ T: git git://linuxtv.org/media_tree.git F: Documentation/devicetree/bindings/media/i2c/sony,imx708.yaml F: drivers/media/i2c/imx708.c -SONY IMX678 SENSOR DRIVER -M: Jai Luthra -L: linux-media@vger.kernel.org -S: Maintained -F: Documentation/devicetree/bindings/media/i2c/sony,imx678.yaml -F: drivers/media/i2c/imx678.c - SONY MEMORYSTICK SUBSYSTEM M: Maxim Levitsky M: Alex Dubov @@ -24146,6 +24139,13 @@ T: git git://git.kernel.org/pub/scm/linux/kernel/git/ulfh/mmc.git F: drivers/memstick/ F: include/linux/memstick.h +SONY STARVIS 2 SENSOR DRIVER +M: Jai Luthra +L: linux-media@vger.kernel.org +S: Maintained +F: Documentation/devicetree/bindings/media/i2c/sony,imx678.yaml +F: drivers/media/i2c/sony-starvis2.c + SONY VAIO CONTROL DEVICE DRIVER M: Mattia Dongili L: platform-driver-x86@vger.kernel.org diff --git a/drivers/media/i2c/Kconfig b/drivers/media/i2c/Kconfig index 1b0247be8ed0b..6711a3739392e 100644 --- a/drivers/media/i2c/Kconfig +++ b/drivers/media/i2c/Kconfig @@ -352,14 +352,11 @@ config VIDEO_IMX708 config VIDEO_IMX678 tristate "Sony IMX678 sensor support" - depends on GPIOLIB - select V4L2_CCI_I2C +select VIDEO_SONY_STARVIS2 help This is a Video4Linux2 sensor driver for the Sony - IMX678 camera. - - To compile this driver as a module, choose M here: the - module will be called imx678. + IMX678 camera. This sensor is now supported by the common + Sony Starvis 2 sensor driver. config VIDEO_MAX9271_LIB tristate @@ -853,6 +850,17 @@ config VIDEO_S5K6A3 This is a V4L2 sensor driver for Samsung S5K6A3 raw camera sensor. +config VIDEO_SONY_STARVIS2 + tristate "Sony Starvis 2 sensor support" + depends on GPIOLIB + select V4L2_CCI_I2C + help + This is a Video4Linux2 sensor driver for the Sony Starvis + 2 image sensors. + + To compile this driver as a module, choose M here: the + module will be called sony-starvis2. + 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 84c89056a7a10..41c31e23cef52 100644 --- a/drivers/media/i2c/Makefile +++ b/drivers/media/i2c/Makefile @@ -67,7 +67,6 @@ obj-$(CONFIG_VIDEO_IMX415) += imx415.o obj-$(CONFIG_VIDEO_IMX477) += imx477.o obj-$(CONFIG_VIDEO_IMX500) += imx500.o obj-$(CONFIG_VIDEO_IMX519) += imx519.o -obj-$(CONFIG_VIDEO_IMX678) += imx678.o obj-$(CONFIG_VIDEO_IMX708) += imx708.o obj-$(CONFIG_VIDEO_IR_I2C) += ir-kbd-i2c.o obj-$(CONFIG_VIDEO_IRS1125) += irs1125.o @@ -146,6 +145,7 @@ obj-$(CONFIG_VIDEO_SAA7127) += saa7127.o obj-$(CONFIG_VIDEO_SAA717X) += saa717x.o obj-$(CONFIG_VIDEO_SAA7185) += saa7185.o obj-$(CONFIG_VIDEO_SONY_BTF_MPX) += sony-btf-mpx.o +obj-$(CONFIG_VIDEO_SONY_STARVIS2) += sony-starvis2.o obj-$(CONFIG_VIDEO_ST_MIPID02) += st-mipid02.o obj-$(CONFIG_VIDEO_TC358743) += tc358743.o obj-$(CONFIG_VIDEO_TC358746) += tc358746.o diff --git a/drivers/media/i2c/imx678.c b/drivers/media/i2c/sony-starvis2.c similarity index 57% rename from drivers/media/i2c/imx678.c rename to drivers/media/i2c/sony-starvis2.c index 0efbf43d2fe6c..c75b5a8a84884 100644 --- a/drivers/media/i2c/imx678.c +++ b/drivers/media/i2c/sony-starvis2.c @@ -1,8 +1,13 @@ // SPDX-License-Identifier: GPL-2.0 /* - * V4L2 driver for Sony IMX678 + * V4L2 driver for Sony Starvis 2 sensors * - * Diagonal 8.86 mm (Type 1/1.8) CMOS image sensor with 8.40 M effective pixels. + * Many of the Sony Starvis 2 sensors share a common register layout, so + * many can be supported by a common driver. + * + * Currently supported are: + * IMX678: Diagonal 8.86 mm (Type 1/1.8) CMOS image sensor with 8.40 M effective + * pixels. * * Copyright (C) 2026 Ideas On Board Oy. * @@ -26,25 +31,25 @@ #include /* Standby or streaming mode */ -#define IMX678_REG_MODE_SELECT CCI_REG8(0x3000) -#define IMX678_MODE_STANDBY 0x01 -#define IMX678_MODE_STREAMING 0x00 -#define IMX678_STREAM_DELAY_US 25000 -#define IMX678_STREAM_DELAY_RANGE_US 1000 +#define STARVIS2_REG_MODE_SELECT CCI_REG8(0x3000) +#define STARVIS2_MODE_STANDBY 0x01 +#define STARVIS2_MODE_STREAMING 0x00 +#define STARVIS2_STREAM_DELAY_US 25000 +#define STARVIS2_STREAM_DELAY_RANGE_US 1000 /* XVS/XHS sync control */ -#define IMX678_REG_XMSTA CCI_REG8(0x3002) -#define IMX678_REG_XXS_DRV CCI_REG8(0x30a6) -#define IMX678_REG_XXS_OUTSEL CCI_REG8(0x30a4) +#define STARVIS2_REG_XMSTA CCI_REG8(0x3002) +#define STARVIS2_REG_XXS_DRV CCI_REG8(0x30a6) +#define STARVIS2_REG_XXS_OUTSEL CCI_REG8(0x30a4) /* Clk selection */ -#define IMX678_REG_INCK_SEL CCI_REG8(0x3014) +#define STARVIS2_REG_INCK_SEL CCI_REG8(0x3014) /* Link Speed */ -#define IMX678_REG_DATARATE_SEL CCI_REG8(0x3015) +#define STARVIS2_REG_DATARATE_SEL CCI_REG8(0x3015) /* Lane Count */ -#define IMX678_REG_LANEMODE CCI_REG8(0x3040) +#define STARVIS2_REG_LANEMODE CCI_REG8(0x3040) /* * The internal readout clock runs at 74.25 MHz. In one cycle the AD reads 8 @@ -54,22 +59,22 @@ #define IMX678_PIX_PER_CLK 8 /* VMAX - Frame Length in Lines */ -#define IMX678_REG_VMAX CCI_REG24_LE(0x3028) -#define IMX678_VMAX_MAX 0xfffff +#define STARVIS2_REG_VMAX CCI_REG24_LE(0x3028) +#define STARVIS2_VMAX_MAX 0xfffff #define IMX678_VMAX_DEFAULT 2250 /* HMAX - Line Length in Cycles (8 Pixels) */ -#define IMX678_REG_HMAX CCI_REG16_LE(0x302c) -#define IMX678_HMAX_MAX 0xffff +#define STARVIS2_REG_HMAX CCI_REG16_LE(0x302c) +#define STARVIS2_HMAX_MAX 0xffff /* SHR internal */ -#define IMX678_REG_SHR CCI_REG24_LE(0x3050) -#define IMX678_SHR_MIN 8 +#define STARVIS2_REG_SHR CCI_REG24_LE(0x3050) +#define STARVIS2_SHR_MIN 8 /* Exposure control */ -#define IMX678_EXPOSURE_MIN 2 -#define IMX678_EXPOSURE_STEP 1 -#define IMX678_EXPOSURE_DEFAULT 1000 +#define STARVIS2_EXPOSURE_MIN 2 +#define STARVIS2_EXPOSURE_STEP 1 +#define STARVIS2_EXPOSURE_DEFAULT 1000 /* * Analogue gain control @@ -77,63 +82,63 @@ * Values from 101 to 240 are valid but correspond to additional digital gain * (0.3dB - 42dB) so don't expose it to userspace */ -#define IMX678_REG_GAIN CCI_REG16_LE(0x3070) -#define IMX678_ANA_GAIN_MIN_NORMAL 0 -#define IMX678_ANA_GAIN_MAX_NORMAL 100 -#define IMX678_ANA_GAIN_STEP 1 -#define IMX678_ANA_GAIN_DEFAULT 0 +#define STARVIS2_REG_GAIN CCI_REG16_LE(0x3070) +#define STARVIS2_ANA_GAIN_MIN_NORMAL 0 +#define STARVIS2_ANA_GAIN_MAX_NORMAL 100 +#define STARVIS2_ANA_GAIN_STEP 1 +#define STARVIS2_ANA_GAIN_DEFAULT 0 /* Crop */ -#define IMX678_REG_WINMODE CCI_REG8(0x3018) -#define IMX678_REG_PIX_HST CCI_REG16_LE(0x303c) -#define IMX678_REG_PIX_HWIDTH CCI_REG16_LE(0x303e) -#define IMX678_REG_PIX_VST CCI_REG16_LE(0x3044) -#define IMX678_REG_PIX_VWIDTH CCI_REG16_LE(0x3046) +#define STARVIS2_REG_WINMODE CCI_REG8(0x3018) +#define STARVIS2_REG_PIX_HST CCI_REG16_LE(0x303c) +#define STARVIS2_REG_PIX_HWIDTH CCI_REG16_LE(0x303e) +#define STARVIS2_REG_PIX_VST CCI_REG16_LE(0x3044) +#define STARVIS2_REG_PIX_VWIDTH CCI_REG16_LE(0x3046) /* Flip */ -#define IMX678_REG_WINMODEH CCI_REG8(0x3020) -#define IMX678_REG_WINMODEV CCI_REG8(0x3021) +#define STARVIS2_REG_WINMODEH CCI_REG8(0x3020) +#define STARVIS2_REG_WINMODEV CCI_REG8(0x3021) /* Sensor Identification */ -#define IMX678_REG_MONOCHROME CCI_REG8(0x4d18) -#define IMX678_TYPE BIT(0) -#define IMX678_REG_MODULE_ID CCI_REG16_LE(0x4d1c) +#define STARVIS2_REG_MONOCHROME CCI_REG8(0x4d18) +#define STARVIS2_TYPE BIT(0) +#define STARVIS2_REG_MODULE_ID CCI_REG16_LE(0x4d1c) #define IMX678_ID 0x02a6 #define IMX678_MODULE_ID_DELAY 80000 /* Common configuration registers */ -#define IMX678_REG_WDMODE CCI_REG8(0x301a) -#define IMX678_REG_ADDMODE CCI_REG8(0x301b) -#define IMX678_REG_THIN_V_EN CCI_REG8(0x301c) -#define IMX678_REG_VCMODE CCI_REG8(0x301e) -#define IMX678_REG_ADBIT CCI_REG8(0x3022) -#define IMX678_REG_MDBIT CCI_REG8(0x3023) -#define IMX678_REG_GAIN_PGC_FIDMD CCI_REG8(0x3400) +#define STARVIS2_REG_WDMODE CCI_REG8(0x301a) +#define STARVIS2_REG_ADDMODE CCI_REG8(0x301b) +#define STARVIS2_REG_THIN_V_EN CCI_REG8(0x301c) +#define STARVIS2_REG_VCMODE CCI_REG8(0x301e) +#define STARVIS2_REG_ADBIT CCI_REG8(0x3022) +#define STARVIS2_REG_MDBIT CCI_REG8(0x3023) +#define STARVIS2_REG_GAIN_PGC_FIDMD CCI_REG8(0x3400) /* Test pattern generator */ -#define IMX678_REG_TPG_EN_DUOUT CCI_REG8(0x30e0) -#define IMX678_REG_TPG_PATSEL_DUOUT CCI_REG8(0x30e2) -#define IMX678_TPG_ALL_000 0 -#define IMX678_TPG_ALL_FFF 1 -#define IMX678_TPG_ALL_555 2 -#define IMX678_TPG_ALL_AAA 3 -#define IMX678_TPG_TOG_555_AAA 4 -#define IMX678_TPG_TOG_AAA_555 5 -#define IMX678_TPG_TOG_000_555 6 -#define IMX678_TPG_TOG_555_000 7 -#define IMX678_TPG_TOG_000_FFF 8 -#define IMX678_TPG_TOG_FFF_000 9 -#define IMX678_TPG_H_COLOR_BARS 10 -#define IMX678_TPG_V_COLOR_BARS 11 -#define IMX678_REG_TPG_COLORWIDTH CCI_REG8(0x30e4) -#define IMX678_TPG_COLORWIDTH_80PIX 0 -#define IMX678_TPG_COLORWIDTH_160PIX 1 -#define IMX678_TPG_COLORWIDTH_320PIX 2 -#define IMX678_TPG_COLORWIDTH_640PIX 3 - -#define IMX678_REG_INTERFACE_SEL CCI_REG8(0x4e3c) -#define IMX678_INTERFACE_2L_4L 0x07 -#define IMX678_INTERFACE_8L_2x4L 0x7f +#define STARVIS2_REG_TPG_EN_DUOUT CCI_REG8(0x30e0) +#define STARVIS2_REG_TPG_PATSEL_DUOUT CCI_REG8(0x30e2) +#define STARVIS2_TPG_ALL_000 0 +#define STARVIS2_TPG_ALL_FFF 1 +#define STARVIS2_TPG_ALL_555 2 +#define STARVIS2_TPG_ALL_AAA 3 +#define STARVIS2_TPG_TOG_555_AAA 4 +#define STARVIS2_TPG_TOG_AAA_555 5 +#define STARVIS2_TPG_TOG_000_555 6 +#define STARVIS2_TPG_TOG_555_000 7 +#define STARVIS2_TPG_TOG_000_FFF 8 +#define STARVIS2_TPG_TOG_FFF_000 9 +#define STARVIS2_TPG_H_COLOR_BARS 10 +#define STARVIS2_TPG_V_COLOR_BARS 11 +#define STARVIS2_REG_TPG_COLORWIDTH CCI_REG8(0x30e4) +#define STARVIS2_TPG_COLORWIDTH_80PIX 0 +#define STARVIS2_TPG_COLORWIDTH_160PIX 1 +#define STARVIS2_TPG_COLORWIDTH_320PIX 2 +#define STARVIS2_TPG_COLORWIDTH_640PIX 3 + +#define STARVIS2_REG_INTERFACE_SEL CCI_REG8(0x4e3c) +#define STARVIS2_INTERFACE_2L_4L 0x07 +#define STARVIS2_INTERFACE_8L_2x4L 0x7f /* Minimum output resolution */ #define IMX678_PIXEL_ARRAY_MIN_WIDTH 1040 @@ -146,7 +151,7 @@ #define IMX678_CROP_VST_ALIGN 4 /* Subdev pads */ -#define IMX678_SOURCE_PAD 0 +#define STARVIS2_SOURCE_PAD 0 /* IMX678 native and active pixel array size. */ static const struct v4l2_rect imx678_native_area = { @@ -163,73 +168,73 @@ static const struct v4l2_rect imx678_active_area = { .height = 2180, }; -enum imx678_type { - IMX678_COLOR = 0, - IMX678_MONOCHROME = 1, +enum starvis2_type { + STARVIS2_COLOR = 0, + STARVIS2_MONOCHROME = 1, }; -struct imx678_model_info { - enum imx678_type type; +struct starvis2_model_info { + enum starvis2_type type; const u32 *codes; unsigned int num_codes; }; -enum imx678_lanemode { - IMX678_LANEMODE_2L = 1, - IMX678_LANEMODE_4L = 3, +enum starvis2_lanemode { + STARVIS2_LANEMODE_2L = 1, + STARVIS2_LANEMODE_4L = 3, }; /* Link frequency setup (DDR: lane rate = 2 x link freq) */ enum { - IMX678_LINK_FREQ_297MHZ, - IMX678_LINK_FREQ_360MHZ, - IMX678_LINK_FREQ_445MHZ, - IMX678_LINK_FREQ_594MHZ, - IMX678_LINK_FREQ_720MHZ, - IMX678_LINK_FREQ_891MHZ, - IMX678_LINK_FREQ_1039MHZ, - IMX678_LINK_FREQ_1188MHZ, + STARVIS2_LINK_FREQ_297MHZ, + STARVIS2_LINK_FREQ_360MHZ, + STARVIS2_LINK_FREQ_445MHZ, + STARVIS2_LINK_FREQ_594MHZ, + STARVIS2_LINK_FREQ_720MHZ, + STARVIS2_LINK_FREQ_891MHZ, + STARVIS2_LINK_FREQ_1039MHZ, + STARVIS2_LINK_FREQ_1188MHZ, }; static const u8 link_freqs_reg_value[] = { - [IMX678_LINK_FREQ_297MHZ] = 0x07, - [IMX678_LINK_FREQ_360MHZ] = 0x06, - [IMX678_LINK_FREQ_445MHZ] = 0x05, - [IMX678_LINK_FREQ_594MHZ] = 0x04, - [IMX678_LINK_FREQ_720MHZ] = 0x03, - [IMX678_LINK_FREQ_891MHZ] = 0x02, - [IMX678_LINK_FREQ_1039MHZ] = 0x01, - [IMX678_LINK_FREQ_1188MHZ] = 0x00, + [STARVIS2_LINK_FREQ_297MHZ] = 0x07, + [STARVIS2_LINK_FREQ_360MHZ] = 0x06, + [STARVIS2_LINK_FREQ_445MHZ] = 0x05, + [STARVIS2_LINK_FREQ_594MHZ] = 0x04, + [STARVIS2_LINK_FREQ_720MHZ] = 0x03, + [STARVIS2_LINK_FREQ_891MHZ] = 0x02, + [STARVIS2_LINK_FREQ_1039MHZ] = 0x01, + [STARVIS2_LINK_FREQ_1188MHZ] = 0x00, }; static const u64 link_freqs[] = { - [IMX678_LINK_FREQ_297MHZ] = 297000000, - [IMX678_LINK_FREQ_360MHZ] = 360000000, - [IMX678_LINK_FREQ_445MHZ] = 445500000, - [IMX678_LINK_FREQ_594MHZ] = 594000000, - [IMX678_LINK_FREQ_720MHZ] = 720000000, - [IMX678_LINK_FREQ_891MHZ] = 891000000, - [IMX678_LINK_FREQ_1039MHZ] = 1039500000, - [IMX678_LINK_FREQ_1188MHZ] = 1188000000, + [STARVIS2_LINK_FREQ_297MHZ] = 297000000, + [STARVIS2_LINK_FREQ_360MHZ] = 360000000, + [STARVIS2_LINK_FREQ_445MHZ] = 445500000, + [STARVIS2_LINK_FREQ_594MHZ] = 594000000, + [STARVIS2_LINK_FREQ_720MHZ] = 720000000, + [STARVIS2_LINK_FREQ_891MHZ] = 891000000, + [STARVIS2_LINK_FREQ_1039MHZ] = 1039500000, + [STARVIS2_LINK_FREQ_1188MHZ] = 1188000000, }; static const u16 min_hmax_4lane[] = { - [IMX678_LINK_FREQ_297MHZ] = 1584, - [IMX678_LINK_FREQ_360MHZ] = 1320, - [IMX678_LINK_FREQ_445MHZ] = 1100, - [IMX678_LINK_FREQ_594MHZ] = 792, - [IMX678_LINK_FREQ_720MHZ] = 660, - [IMX678_LINK_FREQ_891MHZ] = 550, - [IMX678_LINK_FREQ_1039MHZ] = 550, - [IMX678_LINK_FREQ_1188MHZ] = 550, + [STARVIS2_LINK_FREQ_297MHZ] = 1584, + [STARVIS2_LINK_FREQ_360MHZ] = 1320, + [STARVIS2_LINK_FREQ_445MHZ] = 1100, + [STARVIS2_LINK_FREQ_594MHZ] = 792, + [STARVIS2_LINK_FREQ_720MHZ] = 660, + [STARVIS2_LINK_FREQ_891MHZ] = 550, + [STARVIS2_LINK_FREQ_1039MHZ] = 550, + [STARVIS2_LINK_FREQ_1188MHZ] = 550, }; -struct imx678_inck_cfg { +struct starvis2_inck_cfg { u32 xclk_hz; /* platform clock rate */ u8 inck_sel; /* value for reg */ }; -static const struct imx678_inck_cfg imx678_inck_table[] = { +static const struct starvis2_inck_cfg starvis2_inck_table[] = { { 74250000, 0x00 }, { 37125000, 0x01 }, { 72000000, 0x02 }, @@ -240,7 +245,7 @@ static const struct imx678_inck_cfg imx678_inck_table[] = { { 13500000, 0x07 }, }; -static const char * const imx678_tpg_menu[] = { +static const char * const starvis2_tpg_menu[] = { "Disabled", "All 000h", "All FFFh", @@ -256,28 +261,28 @@ static const char * const imx678_tpg_menu[] = { "Vertical color bars", }; -static const int imx678_tpg_val[] = { - IMX678_TPG_ALL_000, - IMX678_TPG_ALL_000, - IMX678_TPG_ALL_FFF, - IMX678_TPG_ALL_555, - IMX678_TPG_ALL_AAA, - IMX678_TPG_TOG_555_AAA, - IMX678_TPG_TOG_AAA_555, - IMX678_TPG_TOG_000_555, - IMX678_TPG_TOG_555_000, - IMX678_TPG_TOG_000_FFF, - IMX678_TPG_TOG_FFF_000, - IMX678_TPG_H_COLOR_BARS, - IMX678_TPG_V_COLOR_BARS, +static const int starvis2_tpg_val[] = { + STARVIS2_TPG_ALL_000, + STARVIS2_TPG_ALL_000, + STARVIS2_TPG_ALL_FFF, + STARVIS2_TPG_ALL_555, + STARVIS2_TPG_ALL_AAA, + STARVIS2_TPG_TOG_555_AAA, + STARVIS2_TPG_TOG_AAA_555, + STARVIS2_TPG_TOG_000_555, + STARVIS2_TPG_TOG_555_000, + STARVIS2_TPG_TOG_000_FFF, + STARVIS2_TPG_TOG_FFF_000, + STARVIS2_TPG_H_COLOR_BARS, + STARVIS2_TPG_V_COLOR_BARS, }; /* Common configuration */ static const struct cci_reg_sequence common_regs[] = { - { IMX678_REG_THIN_V_EN, 0x00 }, - { IMX678_REG_VCMODE, 0x01 }, + { STARVIS2_REG_THIN_V_EN, 0x00 }, + { STARVIS2_REG_VCMODE, 0x01 }, { CCI_REG8(0x306b), 0x00 }, - { IMX678_REG_GAIN_PGC_FIDMD, 0x01 }, + { STARVIS2_REG_GAIN_PGC_FIDMD, 0x01 }, { CCI_REG8(0x3460), 0x22 }, { CCI_REG8(0x355a), 0x64 }, { CCI_REG8(0x3a02), 0x7a }, @@ -643,9 +648,9 @@ static const struct cci_reg_sequence common_regs[] = { { CCI_REG8(0x47c1), 0x01 }, { CCI_REG8(0x47c2), 0x3e }, { CCI_REG8(0x47c3), 0x01 }, - { IMX678_REG_WDMODE, 0x00 }, - { IMX678_REG_MDBIT, 0x01 }, - { IMX678_REG_XXS_DRV, 0x00 }, + { STARVIS2_REG_WDMODE, 0x00 }, + { STARVIS2_REG_MDBIT, 0x01 }, + { STARVIS2_REG_XXS_DRV, 0x00 }, }; static const u32 codes_bayer[] = { @@ -656,30 +661,30 @@ static const u32 codes_monochrome[] = { MEDIA_BUS_FMT_Y12_1X12, }; -static const struct imx678_model_info imx678_aaqr_info = { - .type = IMX678_COLOR, +static const struct starvis2_model_info imx678_aaqr_info = { + .type = STARVIS2_COLOR, .codes = codes_bayer, .num_codes = ARRAY_SIZE(codes_bayer), }; -static const struct imx678_model_info imx678_aamr_info = { - .type = IMX678_MONOCHROME, +static const struct starvis2_model_info imx678_aamr_info = { + .type = STARVIS2_MONOCHROME, .codes = codes_monochrome, .num_codes = ARRAY_SIZE(codes_monochrome), }; -static const char * const imx678_supply_name[] = { +static const char * const starvis2_supply_name[] = { "avdd", /* Analog (3.3V) supply */ "dvdd", /* Digital Core (1.1V) supply */ "ovdd", /* IF (1.8V) supply */ }; -struct imx678 { +struct starvis2 { struct v4l2_subdev sd; struct media_pad pad; struct regmap *cci; - const struct imx678_model_info *info; + const struct starvis2_model_info *info; struct clk *xclk; u32 xclk_freq; @@ -688,11 +693,11 @@ struct imx678 { u8 inck_sel_val; /* Link configurations */ - enum imx678_lanemode lane_mode; + enum starvis2_lanemode lane_mode; unsigned long link_freq_bitmap; struct gpio_desc *reset_gpio; - struct regulator_bulk_data supplies[ARRAY_SIZE(imx678_supply_name)]; + struct regulator_bulk_data supplies[ARRAY_SIZE(starvis2_supply_name)]; struct v4l2_ctrl_handler ctrl_handler; @@ -705,49 +710,49 @@ struct imx678 { u32 vmax; }; -static inline struct imx678 *to_imx678(struct v4l2_subdev *_sd) +static inline struct starvis2 *to_starvis2(struct v4l2_subdev *_sd) { - return container_of_const(_sd, struct imx678, sd); + return container_of_const(_sd, struct starvis2, sd); } -static u32 imx678_default_mbus_code(struct imx678 *imx678) +static u32 starvis2_default_mbus_code(struct starvis2 *starvis2) { - return imx678->info->codes[0]; + return starvis2->info->codes[0]; } -static bool imx678_mbus_code_supported(struct imx678 *imx678, u32 code) +static bool starvis2_mbus_code_supported(struct starvis2 *starvis2, u32 code) { - for (unsigned int i = 0; i < imx678->info->num_codes; i++) { - if (imx678->info->codes[i] == code) + for (unsigned int i = 0; i < starvis2->info->num_codes; i++) { + if (starvis2->info->codes[i] == code) return true; } return false; } -static int imx678_set_ctrl(struct v4l2_ctrl *ctrl) +static int starvis2_set_ctrl(struct v4l2_ctrl *ctrl) { - struct imx678 *imx678 = container_of_const(ctrl->handler, struct - imx678, ctrl_handler); - struct i2c_client *client = v4l2_get_subdevdata(&imx678->sd); + struct starvis2 *starvis2 = container_of_const(ctrl->handler, struct + starvis2, ctrl_handler); + struct i2c_client *client = v4l2_get_subdevdata(&starvis2->sd); const struct v4l2_mbus_framefmt *format; struct v4l2_subdev_state *state; int ret = 0; - state = v4l2_subdev_get_locked_active_state(&imx678->sd); - format = v4l2_subdev_state_get_format(state, IMX678_SOURCE_PAD); + state = v4l2_subdev_get_locked_active_state(&starvis2->sd); + format = v4l2_subdev_state_get_format(state, STARVIS2_SOURCE_PAD); if (ctrl->id == V4L2_CID_VBLANK) { - u32 current_exposure = imx678->exposure->cur.val; + u32 current_exposure = starvis2->exposure->cur.val; - imx678->vmax = format->height + ctrl->val; + starvis2->vmax = format->height + ctrl->val; current_exposure = clamp_t(u32, current_exposure, - IMX678_EXPOSURE_MIN, - imx678->vmax - IMX678_SHR_MIN); - ret = __v4l2_ctrl_modify_range(imx678->exposure, - IMX678_EXPOSURE_MIN, - imx678->vmax - IMX678_SHR_MIN, + STARVIS2_EXPOSURE_MIN, + starvis2->vmax - STARVIS2_SHR_MIN); + ret = __v4l2_ctrl_modify_range(starvis2->exposure, + STARVIS2_EXPOSURE_MIN, + starvis2->vmax - STARVIS2_SHR_MIN, 1, current_exposure); if (ret) return ret; @@ -762,38 +767,41 @@ static int imx678_set_ctrl(struct v4l2_ctrl *ctrl) switch (ctrl->id) { case V4L2_CID_VBLANK: - cci_write(imx678->cci, IMX678_REG_VMAX, imx678->vmax, &ret); + cci_write(starvis2->cci, STARVIS2_REG_VMAX, starvis2->vmax, + &ret); fallthrough; /* SHR = VMAX - exposure, so update it */ case V4L2_CID_EXPOSURE: { - u32 shr = imx678->vmax - imx678->exposure->val; + u32 shr = starvis2->vmax - starvis2->exposure->val; - cci_write(imx678->cci, IMX678_REG_SHR, shr, &ret); + cci_write(starvis2->cci, STARVIS2_REG_SHR, shr, &ret); break; } case V4L2_CID_ANALOGUE_GAIN: - cci_write(imx678->cci, IMX678_REG_GAIN, ctrl->val, &ret); + cci_write(starvis2->cci, STARVIS2_REG_GAIN, ctrl->val, &ret); break; case V4L2_CID_HBLANK: { u32 hmax = (format->width + ctrl->val) / IMX678_PIX_PER_CLK; - cci_write(imx678->cci, IMX678_REG_HMAX, hmax, &ret); + cci_write(starvis2->cci, STARVIS2_REG_HMAX, hmax, &ret); break; } case V4L2_CID_TEST_PATTERN: { - cci_write(imx678->cci, IMX678_REG_TPG_COLORWIDTH, - IMX678_TPG_COLORWIDTH_160PIX, &ret); - cci_write(imx678->cci, IMX678_REG_TPG_PATSEL_DUOUT, - imx678_tpg_val[ctrl->val], &ret); - cci_write(imx678->cci, IMX678_REG_TPG_EN_DUOUT, + cci_write(starvis2->cci, STARVIS2_REG_TPG_COLORWIDTH, + STARVIS2_TPG_COLORWIDTH_160PIX, &ret); + cci_write(starvis2->cci, STARVIS2_REG_TPG_PATSEL_DUOUT, + starvis2_tpg_val[ctrl->val], &ret); + cci_write(starvis2->cci, STARVIS2_REG_TPG_EN_DUOUT, (ctrl->val) ? 1 : 0, &ret); break; } case V4L2_CID_HFLIP: - cci_write(imx678->cci, IMX678_REG_WINMODEH, ctrl->val, &ret); + cci_write(starvis2->cci, STARVIS2_REG_WINMODEH, ctrl->val, + &ret); break; case V4L2_CID_VFLIP: - cci_write(imx678->cci, IMX678_REG_WINMODEV, ctrl->val, &ret); + cci_write(starvis2->cci, STARVIS2_REG_WINMODEV, ctrl->val, + &ret); break; default: dev_warn(&client->dev, @@ -807,35 +815,35 @@ static int imx678_set_ctrl(struct v4l2_ctrl *ctrl) return ret; } -static const struct v4l2_ctrl_ops imx678_ctrl_ops = { - .s_ctrl = imx678_set_ctrl, +static const struct v4l2_ctrl_ops starvis2_ctrl_ops = { + .s_ctrl = starvis2_set_ctrl, }; -static int imx678_enum_mbus_code(struct v4l2_subdev *sd, - struct v4l2_subdev_state *sd_state, - struct v4l2_subdev_mbus_code_enum *code) +static int starvis2_enum_mbus_code(struct v4l2_subdev *sd, + struct v4l2_subdev_state *sd_state, + struct v4l2_subdev_mbus_code_enum *code) { - struct imx678 *imx678 = to_imx678(sd); + struct starvis2 *starvis2 = to_starvis2(sd); - if (code->index >= imx678->info->num_codes) + if (code->index >= starvis2->info->num_codes) return -EINVAL; - code->code = imx678->info->codes[code->index]; + code->code = starvis2->info->codes[code->index]; return 0; } -static int imx678_enum_frame_size(struct v4l2_subdev *sd, - struct v4l2_subdev_state *sd_state, - struct v4l2_subdev_frame_size_enum *fse) +static int starvis2_enum_frame_size(struct v4l2_subdev *sd, + struct v4l2_subdev_state *sd_state, + struct v4l2_subdev_frame_size_enum *fse) { - struct imx678 *imx678 = to_imx678(sd); + struct starvis2 *starvis2 = to_starvis2(sd); const struct v4l2_rect *crop; if (fse->index) return -EINVAL; - if (!imx678_mbus_code_supported(imx678, fse->code)) + if (!starvis2_mbus_code_supported(starvis2, fse->code)) return -EINVAL; crop = v4l2_subdev_state_get_crop(sd_state, fse->pad); @@ -848,9 +856,9 @@ static int imx678_enum_frame_size(struct v4l2_subdev *sd, return 0; } -static int imx678_get_selection(struct v4l2_subdev *sd, - struct v4l2_subdev_state *sd_state, - struct v4l2_subdev_selection *sel) +static int starvis2_get_selection(struct v4l2_subdev *sd, + struct v4l2_subdev_state *sd_state, + struct v4l2_subdev_selection *sel) { switch (sel->target) { case V4L2_SEL_TGT_CROP: @@ -870,18 +878,18 @@ static int imx678_get_selection(struct v4l2_subdev *sd, return -EINVAL; } -static int imx678_init_state(struct v4l2_subdev *sd, - struct v4l2_subdev_state *state) +static int starvis2_init_state(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state) { - struct imx678 *imx678 = to_imx678(sd); + struct starvis2 *starvis2 = to_starvis2(sd); struct v4l2_mbus_framefmt *format; struct v4l2_rect *crop; - crop = v4l2_subdev_state_get_crop(state, IMX678_SOURCE_PAD); + crop = v4l2_subdev_state_get_crop(state, STARVIS2_SOURCE_PAD); *crop = imx678_active_area; - format = v4l2_subdev_state_get_format(state, IMX678_SOURCE_PAD); - format->code = imx678_default_mbus_code(imx678); + format = v4l2_subdev_state_get_format(state, STARVIS2_SOURCE_PAD); + format->code = starvis2_default_mbus_code(starvis2); format->width = imx678_active_area.width; format->height = imx678_active_area.height; format->field = V4L2_FIELD_NONE; @@ -893,50 +901,53 @@ static int imx678_init_state(struct v4l2_subdev *sd, return 0; } -static int imx678_write_common(struct imx678 *imx678) +static int starvis2_write_common(struct starvis2 *starvis2) { int ret = 0; - cci_multi_reg_write(imx678->cci, common_regs, ARRAY_SIZE(common_regs), + cci_multi_reg_write(starvis2->cci, common_regs, ARRAY_SIZE(common_regs), &ret); - cci_write(imx678->cci, IMX678_REG_INCK_SEL, imx678->inck_sel_val, &ret); - cci_write(imx678->cci, IMX678_REG_DATARATE_SEL, - link_freqs_reg_value[__ffs(imx678->link_freq_bitmap)], &ret); - cci_write(imx678->cci, IMX678_REG_LANEMODE, imx678->lane_mode, &ret); - - cci_write(imx678->cci, IMX678_REG_INTERFACE_SEL, IMX678_INTERFACE_2L_4L, + cci_write(starvis2->cci, STARVIS2_REG_INCK_SEL, starvis2->inck_sel_val, + &ret); + cci_write(starvis2->cci, STARVIS2_REG_DATARATE_SEL, + link_freqs_reg_value[__ffs(starvis2->link_freq_bitmap)], + &ret); + cci_write(starvis2->cci, STARVIS2_REG_LANEMODE, starvis2->lane_mode, &ret); + cci_write(starvis2->cci, STARVIS2_REG_INTERFACE_SEL, + STARVIS2_INTERFACE_2L_4L, &ret); + return ret; } -static int imx678_program_window(struct imx678 *imx678, - const struct v4l2_rect *crop) +static int starvis2_program_window(struct starvis2 *starvis2, + const struct v4l2_rect *crop) { int ret = 0; - cci_write(imx678->cci, IMX678_REG_ADDMODE, 0x00, &ret); - cci_write(imx678->cci, IMX678_REG_WINMODE, + cci_write(starvis2->cci, STARVIS2_REG_ADDMODE, 0x00, &ret); + cci_write(starvis2->cci, STARVIS2_REG_WINMODE, v4l2_rect_equal(crop, &imx678_active_area) ? 0x00 : 0x04, &ret); - cci_write(imx678->cci, IMX678_REG_PIX_HST, + cci_write(starvis2->cci, STARVIS2_REG_PIX_HST, crop->left - imx678_active_area.left, &ret); - cci_write(imx678->cci, IMX678_REG_PIX_HWIDTH, crop->width, &ret); - cci_write(imx678->cci, IMX678_REG_PIX_VST, + cci_write(starvis2->cci, STARVIS2_REG_PIX_HWIDTH, crop->width, &ret); + cci_write(starvis2->cci, STARVIS2_REG_PIX_VST, crop->top - imx678_active_area.top, &ret); - cci_write(imx678->cci, IMX678_REG_PIX_VWIDTH, crop->height, &ret); - cci_write(imx678->cci, IMX678_REG_ADBIT, 0x01, &ret); + cci_write(starvis2->cci, STARVIS2_REG_PIX_VWIDTH, crop->height, &ret); + cci_write(starvis2->cci, STARVIS2_REG_ADBIT, 0x01, &ret); return ret; } -static int imx678_enable_streams(struct v4l2_subdev *sd, - struct v4l2_subdev_state *state, u32 pad, - u64 mask) +static int starvis2_enable_streams(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state, u32 pad, + u64 mask) { struct i2c_client *client = v4l2_get_subdevdata(sd); - struct imx678 *imx678 = to_imx678(sd); + struct starvis2 *starvis2 = to_starvis2(sd); const struct v4l2_rect *crop; int ret; @@ -945,24 +956,24 @@ static int imx678_enable_streams(struct v4l2_subdev *sd, return ret; crop = v4l2_subdev_state_get_crop(state, pad); - ret = imx678_program_window(imx678, crop); + ret = starvis2_program_window(starvis2, crop); if (ret) { dev_err(&client->dev, "%s failed to set mode\n", __func__); goto err_rpm_put; } - ret = __v4l2_ctrl_handler_setup(imx678->sd.ctrl_handler); + ret = __v4l2_ctrl_handler_setup(starvis2->sd.ctrl_handler); if (ret) { dev_err(&client->dev, "%s failed to apply user values\n", __func__); goto err_rpm_put; } - cci_write(imx678->cci, IMX678_REG_MODE_SELECT, IMX678_MODE_STREAMING, - &ret); - usleep_range(IMX678_STREAM_DELAY_US, IMX678_STREAM_DELAY_US + - IMX678_STREAM_DELAY_RANGE_US); - cci_write(imx678->cci, IMX678_REG_XMSTA, 0x00, &ret); + cci_write(starvis2->cci, STARVIS2_REG_MODE_SELECT, + STARVIS2_MODE_STREAMING, &ret); + usleep_range(STARVIS2_STREAM_DELAY_US, STARVIS2_STREAM_DELAY_US + + STARVIS2_STREAM_DELAY_RANGE_US); + cci_write(starvis2->cci, STARVIS2_REG_XMSTA, 0x00, &ret); if (ret) { dev_err(&client->dev, "%s failed to start streaming\n", @@ -978,19 +989,19 @@ static int imx678_enable_streams(struct v4l2_subdev *sd, return ret; } -static int imx678_disable_streams(struct v4l2_subdev *sd, - struct v4l2_subdev_state *state, - u32 pad, u64 mask) +static int starvis2_disable_streams(struct v4l2_subdev *sd, + struct v4l2_subdev_state *state, + u32 pad, u64 mask) { struct i2c_client *client = v4l2_get_subdevdata(sd); - struct imx678 *imx678 = to_imx678(sd); + struct starvis2 *starvis2 = to_starvis2(sd); int ret = 0; /* Master mode disable */ - cci_write(imx678->cci, IMX678_REG_XMSTA, 0x01, &ret); + cci_write(starvis2->cci, STARVIS2_REG_XMSTA, 0x01, &ret); /* Standby */ - cci_write(imx678->cci, IMX678_REG_MODE_SELECT, IMX678_MODE_STANDBY, - &ret); + cci_write(starvis2->cci, STARVIS2_REG_MODE_SELECT, + STARVIS2_MODE_STANDBY, &ret); if (ret) dev_err(&client->dev, "%s failed to stop stream\n", __func__); @@ -999,15 +1010,15 @@ static int imx678_disable_streams(struct v4l2_subdev *sd, return ret; } -static int imx678_power_on(struct device *dev) +static int starvis2_power_on(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct v4l2_subdev *sd = i2c_get_clientdata(client); - struct imx678 *imx678 = to_imx678(sd); + struct starvis2 *starvis2 = to_starvis2(sd); int ret; - ret = regulator_bulk_enable(ARRAY_SIZE(imx678_supply_name), - imx678->supplies); + ret = regulator_bulk_enable(ARRAY_SIZE(starvis2_supply_name), + starvis2->supplies); if (ret) { dev_err(&client->dev, "%s: failed to enable regulators\n", __func__); @@ -1016,11 +1027,11 @@ static int imx678_power_on(struct device *dev) fsleep(1); /* Tlow > 500ns */ - gpiod_set_value_cansleep(imx678->reset_gpio, 0); + gpiod_set_value_cansleep(starvis2->reset_gpio, 0); fsleep(1); /* T3 > 1us */ - ret = clk_prepare_enable(imx678->xclk); + ret = clk_prepare_enable(starvis2->xclk); if (ret) { dev_err(&client->dev, "%s: failed to enable clock\n", __func__); @@ -1029,7 +1040,7 @@ static int imx678_power_on(struct device *dev) fsleep(20); /* T4 > 20us */ - ret = imx678_write_common(imx678); + ret = starvis2_write_common(starvis2); if (ret) { dev_err(&client->dev, "%s failed to write registers\n", __func__); @@ -1039,35 +1050,35 @@ static int imx678_power_on(struct device *dev) return 0; clk_off: - clk_disable_unprepare(imx678->xclk); + clk_disable_unprepare(starvis2->xclk); reg_off: - gpiod_set_value_cansleep(imx678->reset_gpio, 1); - regulator_bulk_disable(ARRAY_SIZE(imx678_supply_name), - imx678->supplies); + gpiod_set_value_cansleep(starvis2->reset_gpio, 1); + regulator_bulk_disable(ARRAY_SIZE(starvis2_supply_name), + starvis2->supplies); return ret; } -static int imx678_power_off(struct device *dev) +static int starvis2_power_off(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct v4l2_subdev *sd = i2c_get_clientdata(client); - struct imx678 *imx678 = to_imx678(sd); + struct starvis2 *starvis2 = to_starvis2(sd); - clk_disable_unprepare(imx678->xclk); - gpiod_set_value_cansleep(imx678->reset_gpio, 1); - regulator_bulk_disable(ARRAY_SIZE(imx678_supply_name), - imx678->supplies); + clk_disable_unprepare(starvis2->xclk); + gpiod_set_value_cansleep(starvis2->reset_gpio, 1); + regulator_bulk_disable(ARRAY_SIZE(starvis2_supply_name), + starvis2->supplies); return 0; } -static int imx678_identify_model(struct imx678 *imx678) +static int starvis2_identify_model(struct starvis2 *starvis2) { - struct i2c_client *client = v4l2_get_subdevdata(&imx678->sd); - const struct imx678_model_info *info; - enum imx678_type detected; + struct i2c_client *client = v4l2_get_subdevdata(&starvis2->sd); + const struct starvis2_model_info *info; + enum starvis2_type detected; int ret = 0; u64 val = 0; @@ -1077,10 +1088,10 @@ static int imx678_identify_model(struct imx678 *imx678) * This sensor's ID registers become accessible 80ms after coming out * of STANDBY mode. */ - cci_write(imx678->cci, IMX678_REG_MODE_SELECT, 0, &ret); + cci_write(starvis2->cci, STARVIS2_REG_MODE_SELECT, 0, &ret); fsleep(IMX678_MODULE_ID_DELAY); - cci_read(imx678->cci, IMX678_REG_MODULE_ID, &val, &ret); + cci_read(starvis2->cci, STARVIS2_REG_MODULE_ID, &val, &ret); if (ret) { dev_err(&client->dev, @@ -1094,7 +1105,7 @@ static int imx678_identify_model(struct imx678 *imx678) return -ENXIO; } - cci_read(imx678->cci, IMX678_REG_MONOCHROME, &val, &ret); + cci_read(starvis2->cci, STARVIS2_REG_MONOCHROME, &val, &ret); if (ret) { dev_err(&client->dev, @@ -1102,56 +1113,58 @@ static int imx678_identify_model(struct imx678 *imx678) return ret; } - detected = val & IMX678_TYPE; + detected = val & STARVIS2_TYPE; /* Prefer to use sensor type specified in device tree */ if (info) { - imx678->info = info; + starvis2->info = info; if (detected != info->type) dev_err(&client->dev, "detected %s sensor, DT specifies %s; using DT value\n", - detected == IMX678_COLOR ? "color" : "mono", - info->type == IMX678_COLOR ? "color" : "mono"); + detected == STARVIS2_COLOR ? "color" : "mono", + info->type == STARVIS2_COLOR ? "color" : "mono"); } else { - imx678->info = detected == IMX678_MONOCHROME ? + starvis2->info = detected == STARVIS2_MONOCHROME ? &imx678_aamr_info : &imx678_aaqr_info; dev_info(&client->dev, "sensor type missing in DT; detected %s sensor\n", - detected == IMX678_MONOCHROME ? "mono" : "color"); + detected == STARVIS2_MONOCHROME ? "mono" : "color"); } return 0; } -static const struct v4l2_subdev_video_ops imx678_video_ops = { +static const struct v4l2_subdev_video_ops starvis2_video_ops = { .s_stream = v4l2_subdev_s_stream_helper, }; -static const struct v4l2_subdev_pad_ops imx678_pad_ops = { - .enum_mbus_code = imx678_enum_mbus_code, +static const struct v4l2_subdev_pad_ops starvis2_pad_ops = { + .enum_mbus_code = starvis2_enum_mbus_code, .get_fmt = v4l2_subdev_get_fmt, .set_fmt = v4l2_subdev_get_fmt, - .get_selection = imx678_get_selection, - .enum_frame_size = imx678_enum_frame_size, - .enable_streams = imx678_enable_streams, - .disable_streams = imx678_disable_streams, + .get_selection = starvis2_get_selection, + .enum_frame_size = starvis2_enum_frame_size, + .enable_streams = starvis2_enable_streams, + .disable_streams = starvis2_disable_streams, }; -static const struct v4l2_subdev_ops imx678_subdev_ops = { - .video = &imx678_video_ops, - .pad = &imx678_pad_ops, +static const struct v4l2_subdev_ops starvis2_subdev_ops = { + .video = &starvis2_video_ops, + .pad = &starvis2_pad_ops, }; -static const struct v4l2_subdev_internal_ops imx678_internal_ops = { - .init_state = imx678_init_state, +static const struct v4l2_subdev_internal_ops starvis2_internal_ops = { + .init_state = starvis2_init_state, }; -static int imx678_init_controls(struct imx678 *imx678) +static int starvis2_init_controls(struct starvis2 *starvis2) { struct v4l2_ctrl_handler *ctrl_hdlr; - const u32 hmax_4lane = min_hmax_4lane[__ffs(imx678->link_freq_bitmap)]; - const u32 lane_scale = imx678->lane_mode == IMX678_LANEMODE_2L ? 2 : 1; - struct i2c_client *client = v4l2_get_subdevdata(&imx678->sd); + const u32 hmax_4lane = + min_hmax_4lane[__ffs(starvis2->link_freq_bitmap)]; + const u32 lane_scale = + starvis2->lane_mode == STARVIS2_LANEMODE_2L ? 2 : 1; + struct i2c_client *client = v4l2_get_subdevdata(&starvis2->sd); struct v4l2_fwnode_device_properties props; struct v4l2_ctrl *link_freq; s32 hblank, max_hblank, vblank, max_vblank; @@ -1162,66 +1175,66 @@ static int imx678_init_controls(struct imx678 *imx678) if (ret < 0) return ret; - ctrl_hdlr = &imx678->ctrl_handler; + ctrl_hdlr = &starvis2->ctrl_handler; ret = v4l2_ctrl_handler_init(ctrl_hdlr, 11); if (ret) return ret; - imx678->vmax = IMX678_VMAX_DEFAULT; + starvis2->vmax = IMX678_VMAX_DEFAULT; hmax = hmax_4lane * lane_scale; /* PIXEL_RATE is fixed and read-only */ - v4l2_ctrl_new_std(ctrl_hdlr, &imx678_ctrl_ops, V4L2_CID_PIXEL_RATE, + v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, V4L2_CID_PIXEL_RATE, IMX678_PIXEL_RATE, IMX678_PIXEL_RATE, 1, IMX678_PIXEL_RATE); /* LINK_FREQ is also read only */ - link_freq = v4l2_ctrl_new_int_menu(ctrl_hdlr, &imx678_ctrl_ops, + link_freq = v4l2_ctrl_new_int_menu(ctrl_hdlr, &starvis2_ctrl_ops, V4L2_CID_LINK_FREQ, ARRAY_SIZE(link_freqs) - 1, - __ffs(imx678->link_freq_bitmap), + __ffs(starvis2->link_freq_bitmap), link_freqs); if (link_freq) link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY; - vblank = imx678->vmax - imx678_active_area.height; - max_vblank = IMX678_VMAX_MAX - imx678_active_area.height; - imx678->vblank = v4l2_ctrl_new_std(ctrl_hdlr, &imx678_ctrl_ops, - V4L2_CID_VBLANK, vblank, max_vblank, - 2, vblank); + vblank = starvis2->vmax - imx678_active_area.height; + max_vblank = STARVIS2_VMAX_MAX - imx678_active_area.height; + starvis2->vblank = v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, + V4L2_CID_VBLANK, vblank, max_vblank, + 2, vblank); hblank = hmax * IMX678_PIX_PER_CLK - imx678_active_area.width; - max_hblank = IMX678_HMAX_MAX * IMX678_PIX_PER_CLK - + max_hblank = STARVIS2_HMAX_MAX * IMX678_PIX_PER_CLK - imx678_active_area.width; - imx678->hblank = v4l2_ctrl_new_std(ctrl_hdlr, &imx678_ctrl_ops, - V4L2_CID_HBLANK, hblank, max_hblank, - IMX678_PIX_PER_CLK, hblank); - - imx678->exposure = v4l2_ctrl_new_std(ctrl_hdlr, &imx678_ctrl_ops, - V4L2_CID_EXPOSURE, - IMX678_EXPOSURE_MIN, - IMX678_VMAX_DEFAULT - - IMX678_SHR_MIN, - IMX678_EXPOSURE_STEP, - IMX678_EXPOSURE_DEFAULT); - - v4l2_ctrl_new_std(ctrl_hdlr, &imx678_ctrl_ops, V4L2_CID_ANALOGUE_GAIN, - IMX678_ANA_GAIN_MIN_NORMAL, - IMX678_ANA_GAIN_MAX_NORMAL, IMX678_ANA_GAIN_STEP, - IMX678_ANA_GAIN_DEFAULT); - - v4l2_ctrl_new_std(ctrl_hdlr, &imx678_ctrl_ops, V4L2_CID_HFLIP, + starvis2->hblank = v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, + V4L2_CID_HBLANK, hblank, max_hblank, + IMX678_PIX_PER_CLK, hblank); + + starvis2->exposure = v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, + V4L2_CID_EXPOSURE, + STARVIS2_EXPOSURE_MIN, + IMX678_VMAX_DEFAULT - + STARVIS2_SHR_MIN, + STARVIS2_EXPOSURE_STEP, + STARVIS2_EXPOSURE_DEFAULT); + + v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, V4L2_CID_ANALOGUE_GAIN, + STARVIS2_ANA_GAIN_MIN_NORMAL, + STARVIS2_ANA_GAIN_MAX_NORMAL, STARVIS2_ANA_GAIN_STEP, + STARVIS2_ANA_GAIN_DEFAULT); + + v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, V4L2_CID_HFLIP, 0, 1, 1, 0); - v4l2_ctrl_new_std(ctrl_hdlr, &imx678_ctrl_ops, V4L2_CID_VFLIP, + v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, V4L2_CID_VFLIP, 0, 1, 1, 0); - v4l2_ctrl_new_std_menu_items(ctrl_hdlr, &imx678_ctrl_ops, + v4l2_ctrl_new_std_menu_items(ctrl_hdlr, &starvis2_ctrl_ops, V4L2_CID_TEST_PATTERN, - ARRAY_SIZE(imx678_tpg_menu) - 1, 0, 0, - imx678_tpg_menu); + ARRAY_SIZE(starvis2_tpg_menu) - 1, 0, 0, + starvis2_tpg_menu); - v4l2_ctrl_new_fwnode_properties(ctrl_hdlr, &imx678_ctrl_ops, &props); + v4l2_ctrl_new_fwnode_properties(ctrl_hdlr, &starvis2_ctrl_ops, &props); if (ctrl_hdlr->error) { ret = ctrl_hdlr->error; @@ -1231,12 +1244,12 @@ static int imx678_init_controls(struct imx678 *imx678) return ret; } - imx678->sd.ctrl_handler = ctrl_hdlr; + starvis2->sd.ctrl_handler = ctrl_hdlr; return 0; } -static int imx678_check_hwcfg(struct device *dev, struct imx678 *imx678) +static int starvis2_check_hwcfg(struct device *dev, struct starvis2 *starvis2) { struct fwnode_handle *endpoint; struct v4l2_fwnode_endpoint ep_cfg = { @@ -1257,10 +1270,10 @@ static int imx678_check_hwcfg(struct device *dev, struct imx678 *imx678) switch (ep_cfg.bus.mipi_csi2.num_data_lanes) { case 2: - imx678->lane_mode = IMX678_LANEMODE_2L; + starvis2->lane_mode = STARVIS2_LANEMODE_2L; break; case 4: - imx678->lane_mode = IMX678_LANEMODE_4L; + starvis2->lane_mode = STARVIS2_LANEMODE_4L; break; default: dev_err(dev, @@ -1271,7 +1284,7 @@ static int imx678_check_hwcfg(struct device *dev, struct imx678 *imx678) ret = v4l2_link_freq_to_bitmap(dev, ep_cfg.link_frequencies, ep_cfg.nr_of_link_frequencies, link_freqs, ARRAY_SIZE(link_freqs), - &imx678->link_freq_bitmap); + &starvis2->link_freq_bitmap); error_out: v4l2_fwnode_endpoint_free(&ep_cfg); @@ -1280,95 +1293,95 @@ static int imx678_check_hwcfg(struct device *dev, struct imx678 *imx678) return ret; } -static int imx678_probe(struct i2c_client *client) +static int starvis2_probe(struct i2c_client *client) { struct device *dev = &client->dev; - struct imx678 *imx678; + struct starvis2 *starvis2; int ret, i; - imx678 = devm_kzalloc(&client->dev, sizeof(*imx678), GFP_KERNEL); - if (!imx678) + starvis2 = devm_kzalloc(&client->dev, sizeof(*starvis2), GFP_KERNEL); + if (!starvis2) return -ENOMEM; - v4l2_i2c_subdev_init(&imx678->sd, client, &imx678_subdev_ops); + v4l2_i2c_subdev_init(&starvis2->sd, client, &starvis2_subdev_ops); - imx678->cci = devm_cci_regmap_init_i2c(client, 16); - if (IS_ERR(imx678->cci)) - return dev_err_probe(dev, PTR_ERR(imx678->cci), + starvis2->cci = devm_cci_regmap_init_i2c(client, 16); + if (IS_ERR(starvis2->cci)) + return dev_err_probe(dev, PTR_ERR(starvis2->cci), "failed to init CCI\n"); - if (imx678_check_hwcfg(dev, imx678)) + if (starvis2_check_hwcfg(dev, starvis2)) return -EINVAL; - imx678->xclk = devm_v4l2_sensor_clk_get(dev, NULL); - if (IS_ERR(imx678->xclk)) - return dev_err_probe(dev, PTR_ERR(imx678->xclk), + starvis2->xclk = devm_v4l2_sensor_clk_get(dev, NULL); + if (IS_ERR(starvis2->xclk)) + return dev_err_probe(dev, PTR_ERR(starvis2->xclk), "failed to get xclk\n"); - imx678->xclk_freq = clk_get_rate(imx678->xclk); + starvis2->xclk_freq = clk_get_rate(starvis2->xclk); - for (i = 0; i < ARRAY_SIZE(imx678_inck_table); ++i) { - if (imx678_inck_table[i].xclk_hz == imx678->xclk_freq) { - imx678->inck_sel_val = imx678_inck_table[i].inck_sel; + for (i = 0; i < ARRAY_SIZE(starvis2_inck_table); ++i) { + if (starvis2_inck_table[i].xclk_hz == starvis2->xclk_freq) { + starvis2->inck_sel_val = starvis2_inck_table[i].inck_sel; break; } } - if (i == ARRAY_SIZE(imx678_inck_table)) + if (i == ARRAY_SIZE(starvis2_inck_table)) return dev_err_probe(dev, -EINVAL, "unsupported XCLK rate %u Hz\n", - imx678->xclk_freq); + starvis2->xclk_freq); - for (i = 0; i < ARRAY_SIZE(imx678_supply_name); i++) - imx678->supplies[i].supply = imx678_supply_name[i]; + for (i = 0; i < ARRAY_SIZE(starvis2_supply_name); i++) + starvis2->supplies[i].supply = starvis2_supply_name[i]; ret = devm_regulator_bulk_get(&client->dev, - ARRAY_SIZE(imx678_supply_name), - imx678->supplies); + ARRAY_SIZE(starvis2_supply_name), + starvis2->supplies); if (ret) return dev_err_probe(dev, ret, "failed to get regulators\n"); - imx678->reset_gpio = devm_gpiod_get_optional(dev, "reset", - GPIOD_OUT_HIGH); - if (IS_ERR(imx678->reset_gpio)) - return dev_err_probe(dev, PTR_ERR(imx678->reset_gpio), + starvis2->reset_gpio = devm_gpiod_get_optional(dev, "reset", + GPIOD_OUT_HIGH); + if (IS_ERR(starvis2->reset_gpio)) + return dev_err_probe(dev, PTR_ERR(starvis2->reset_gpio), "failed to get reset GPIO\n"); - ret = imx678_power_on(dev); + ret = starvis2_power_on(dev); if (ret) return ret; - ret = imx678_identify_model(imx678); + ret = starvis2_identify_model(starvis2); if (ret) goto error_power_off; pm_runtime_set_active(dev); pm_runtime_enable(dev); - ret = imx678_init_controls(imx678); + ret = starvis2_init_controls(starvis2); if (ret) goto error_pm_runtime; - imx678->sd.internal_ops = &imx678_internal_ops; - imx678->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; - imx678->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; + starvis2->sd.internal_ops = &starvis2_internal_ops; + starvis2->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; + starvis2->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; - imx678->pad.flags = MEDIA_PAD_FL_SOURCE; + starvis2->pad.flags = MEDIA_PAD_FL_SOURCE; - ret = media_entity_pads_init(&imx678->sd.entity, 1, &imx678->pad); + ret = media_entity_pads_init(&starvis2->sd.entity, 1, &starvis2->pad); if (ret) { dev_err_probe(dev, ret, "failed to init entity pads\n"); goto error_handler_free; } - imx678->sd.state_lock = imx678->ctrl_handler.lock; - ret = v4l2_subdev_init_finalize(&imx678->sd); + starvis2->sd.state_lock = starvis2->ctrl_handler.lock; + ret = v4l2_subdev_init_finalize(&starvis2->sd); if (ret < 0) { dev_err_probe(dev, ret, "subdev init error\n"); goto error_media_entity; } - ret = v4l2_async_register_subdev_sensor(&imx678->sd); + ret = v4l2_async_register_subdev_sensor(&starvis2->sd); if (ret < 0) { dev_err_probe(dev, ret, "failed to register sensor sub-device\n"); @@ -1380,45 +1393,45 @@ static int imx678_probe(struct i2c_client *client) return 0; error_subdev_cleanup: - v4l2_subdev_cleanup(&imx678->sd); + v4l2_subdev_cleanup(&starvis2->sd); error_media_entity: - media_entity_cleanup(&imx678->sd.entity); + media_entity_cleanup(&starvis2->sd.entity); error_handler_free: - v4l2_ctrl_handler_free(imx678->sd.ctrl_handler); + v4l2_ctrl_handler_free(starvis2->sd.ctrl_handler); error_pm_runtime: pm_runtime_disable(&client->dev); pm_runtime_set_suspended(&client->dev); error_power_off: - imx678_power_off(&client->dev); + starvis2_power_off(&client->dev); return ret; } -static void imx678_remove(struct i2c_client *client) +static void starvis2_remove(struct i2c_client *client) { struct v4l2_subdev *sd = i2c_get_clientdata(client); - struct imx678 *imx678 = to_imx678(sd); + struct starvis2 *starvis2 = to_starvis2(sd); v4l2_async_unregister_subdev(sd); v4l2_subdev_cleanup(sd); media_entity_cleanup(&sd->entity); - v4l2_ctrl_handler_free(imx678->sd.ctrl_handler); + v4l2_ctrl_handler_free(starvis2->sd.ctrl_handler); pm_runtime_disable(&client->dev); if (!pm_runtime_status_suspended(&client->dev)) - imx678_power_off(&client->dev); + starvis2_power_off(&client->dev); pm_runtime_set_suspended(&client->dev); } -static const struct dev_pm_ops imx678_pm_ops = { - SET_RUNTIME_PM_OPS(imx678_power_off, imx678_power_on, NULL) +static const struct dev_pm_ops starvis2_pm_ops = { + SET_RUNTIME_PM_OPS(starvis2_power_off, starvis2_power_on, NULL) }; -static const struct of_device_id imx678_of_match[] = { +static const struct of_device_id starvis2_of_match[] = { { .compatible = "sony,imx678-aamr", .data = &imx678_aamr_info }, { .compatible = "sony,imx678-aaqr", .data = &imx678_aaqr_info }, /* for non-conforming DTs that rely on runtime check */ @@ -1426,22 +1439,22 @@ static const struct of_device_id imx678_of_match[] = { { /* sentinel */ } }; -MODULE_DEVICE_TABLE(of, imx678_of_match); +MODULE_DEVICE_TABLE(of, starvis2_of_match); -static struct i2c_driver imx678_i2c_driver = { +static struct i2c_driver starvis2_i2c_driver = { .driver = { - .name = "imx678", - .of_match_table = imx678_of_match, - .pm = pm_ptr(&imx678_pm_ops), + .name = "starvis2", + .of_match_table = starvis2_of_match, + .pm = pm_ptr(&starvis2_pm_ops), }, - .probe = imx678_probe, - .remove = imx678_remove, + .probe = starvis2_probe, + .remove = starvis2_remove, }; -module_i2c_driver(imx678_i2c_driver); +module_i2c_driver(starvis2_i2c_driver); MODULE_AUTHOR("Will Whang "); MODULE_AUTHOR("Tetsuya NOMURA "); MODULE_AUTHOR("Jai Luthra "); -MODULE_DESCRIPTION("Sony imx678 sensor driver"); +MODULE_DESCRIPTION("Sony Starvis 2 sensor driver"); MODULE_LICENSE("GPL"); From a29aa06521016d118772002f46f8ff5780df0a66 Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Thu, 3 Sep 2026 16:46:00 +0100 Subject: [PATCH 04/18] media: sony-starvis2: Reorder link frequencies to remove lookup link_freqs_reg_value is table that just reverses the order of the link frequency enum. Reverse the order of the link frequencies so that the table is redundant, and remove it. Signed-off-by: Dave Stevenson --- drivers/media/i2c/sony-starvis2.c | 31 ++++++++++--------------------- 1 file changed, 10 insertions(+), 21 deletions(-) diff --git a/drivers/media/i2c/sony-starvis2.c b/drivers/media/i2c/sony-starvis2.c index c75b5a8a84884..fb2e2bc4b9da9 100644 --- a/drivers/media/i2c/sony-starvis2.c +++ b/drivers/media/i2c/sony-starvis2.c @@ -186,25 +186,14 @@ enum starvis2_lanemode { /* Link frequency setup (DDR: lane rate = 2 x link freq) */ enum { - STARVIS2_LINK_FREQ_297MHZ, - STARVIS2_LINK_FREQ_360MHZ, - STARVIS2_LINK_FREQ_445MHZ, - STARVIS2_LINK_FREQ_594MHZ, - STARVIS2_LINK_FREQ_720MHZ, - STARVIS2_LINK_FREQ_891MHZ, - STARVIS2_LINK_FREQ_1039MHZ, - STARVIS2_LINK_FREQ_1188MHZ, -}; - -static const u8 link_freqs_reg_value[] = { - [STARVIS2_LINK_FREQ_297MHZ] = 0x07, - [STARVIS2_LINK_FREQ_360MHZ] = 0x06, - [STARVIS2_LINK_FREQ_445MHZ] = 0x05, - [STARVIS2_LINK_FREQ_594MHZ] = 0x04, - [STARVIS2_LINK_FREQ_720MHZ] = 0x03, - [STARVIS2_LINK_FREQ_891MHZ] = 0x02, - [STARVIS2_LINK_FREQ_1039MHZ] = 0x01, - [STARVIS2_LINK_FREQ_1188MHZ] = 0x00, + STARVIS2_LINK_FREQ_1188MHZ = 0x00, + STARVIS2_LINK_FREQ_1039MHZ = 0x01, + STARVIS2_LINK_FREQ_891MHZ = 0x02, + STARVIS2_LINK_FREQ_720MHZ = 0x03, + STARVIS2_LINK_FREQ_594MHZ = 0x04, + STARVIS2_LINK_FREQ_445MHZ = 0x05, + STARVIS2_LINK_FREQ_360MHZ = 0x06, + STARVIS2_LINK_FREQ_297MHZ = 0x07, }; static const u64 link_freqs[] = { @@ -911,7 +900,7 @@ static int starvis2_write_common(struct starvis2 *starvis2) cci_write(starvis2->cci, STARVIS2_REG_INCK_SEL, starvis2->inck_sel_val, &ret); cci_write(starvis2->cci, STARVIS2_REG_DATARATE_SEL, - link_freqs_reg_value[__ffs(starvis2->link_freq_bitmap)], + __fls(starvis2->link_freq_bitmap), &ret); cci_write(starvis2->cci, STARVIS2_REG_LANEMODE, starvis2->lane_mode, &ret); @@ -1161,7 +1150,7 @@ static int starvis2_init_controls(struct starvis2 *starvis2) { struct v4l2_ctrl_handler *ctrl_hdlr; const u32 hmax_4lane = - min_hmax_4lane[__ffs(starvis2->link_freq_bitmap)]; + min_hmax_4lane[__fls(starvis2->link_freq_bitmap)]; const u32 lane_scale = starvis2->lane_mode == STARVIS2_LANEMODE_2L ? 2 : 1; struct i2c_client *client = v4l2_get_subdevdata(&starvis2->sd); From 52c788494b5bcd0e59d64ee101ab75948534486f Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Thu, 3 Sep 2026 16:50:37 +0100 Subject: [PATCH 05/18] media: sony-starvis2: Always program the sensor in window mode If the requested region matched the defined active area then the driver switched to all-pixel mode. This left the possibility that the activeare was incorrect and not reading out the area expected. Switch to always requesting window mode. Signed-off-by: Dave Stevenson --- drivers/media/i2c/sony-starvis2.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/drivers/media/i2c/sony-starvis2.c b/drivers/media/i2c/sony-starvis2.c index fb2e2bc4b9da9..412ae263eea61 100644 --- a/drivers/media/i2c/sony-starvis2.c +++ b/drivers/media/i2c/sony-starvis2.c @@ -917,9 +917,7 @@ static int starvis2_program_window(struct starvis2 *starvis2, int ret = 0; cci_write(starvis2->cci, STARVIS2_REG_ADDMODE, 0x00, &ret); - cci_write(starvis2->cci, STARVIS2_REG_WINMODE, - v4l2_rect_equal(crop, &imx678_active_area) ? 0x00 : 0x04, - &ret); + cci_write(starvis2->cci, STARVIS2_REG_WINMODE, 0x04, &ret); cci_write(starvis2->cci, STARVIS2_REG_PIX_HST, crop->left - imx678_active_area.left, &ret); cci_write(starvis2->cci, STARVIS2_REG_PIX_HWIDTH, crop->width, &ret); From c8e681ca865e7335ea06dfd910138686e4224e15 Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Thu, 3 Sep 2026 17:19:16 +0100 Subject: [PATCH 06/18] media: sony-starvis2: Parameterise the configuration to allow for other models Several of the Sony Starvis 2 sensors are identical in the majority of their programming, but differ largely only in the size of pixel array and some timing parameters. Parameterise those parameters in preparation for supporting other variants. Signed-off-by: Dave Stevenson --- drivers/media/i2c/sony-starvis2.c | 166 +++++++++++++++++++----------- 1 file changed, 106 insertions(+), 60 deletions(-) diff --git a/drivers/media/i2c/sony-starvis2.c b/drivers/media/i2c/sony-starvis2.c index 412ae263eea61..1f9bc177ecb0b 100644 --- a/drivers/media/i2c/sony-starvis2.c +++ b/drivers/media/i2c/sony-starvis2.c @@ -51,17 +51,9 @@ /* Lane Count */ #define STARVIS2_REG_LANEMODE CCI_REG8(0x3040) -/* - * The internal readout clock runs at 74.25 MHz. In one cycle the AD reads 8 - * pixels, thus giving us a rate of 74.25 * 8 = 594 MPix/s - */ -#define IMX678_PIXEL_RATE 594000000 -#define IMX678_PIX_PER_CLK 8 - /* VMAX - Frame Length in Lines */ #define STARVIS2_REG_VMAX CCI_REG24_LE(0x3028) #define STARVIS2_VMAX_MAX 0xfffff -#define IMX678_VMAX_DEFAULT 2250 /* HMAX - Line Length in Cycles (8 Pixels) */ #define STARVIS2_REG_HMAX CCI_REG16_LE(0x302c) @@ -103,7 +95,6 @@ #define STARVIS2_REG_MONOCHROME CCI_REG8(0x4d18) #define STARVIS2_TYPE BIT(0) #define STARVIS2_REG_MODULE_ID CCI_REG16_LE(0x4d1c) -#define IMX678_ID 0x02a6 #define IMX678_MODULE_ID_DELAY 80000 /* Common configuration registers */ @@ -153,32 +144,11 @@ /* Subdev pads */ #define STARVIS2_SOURCE_PAD 0 -/* IMX678 native and active pixel array size. */ -static const struct v4l2_rect imx678_native_area = { - .top = 0, - .left = 0, - .width = 3857, - .height = 2201, -}; - -static const struct v4l2_rect imx678_active_area = { - .top = 20, - .left = 0, - .width = 3856, - .height = 2180, -}; - enum starvis2_type { STARVIS2_COLOR = 0, STARVIS2_MONOCHROME = 1, }; -struct starvis2_model_info { - enum starvis2_type type; - const u32 *codes; - unsigned int num_codes; -}; - enum starvis2_lanemode { STARVIS2_LANEMODE_2L = 1, STARVIS2_LANEMODE_4L = 3, @@ -207,7 +177,7 @@ static const u64 link_freqs[] = { [STARVIS2_LINK_FREQ_1188MHZ] = 1188000000, }; -static const u16 min_hmax_4lane[] = { +static const u16 imx678_min_hmax_4lane[] = { [STARVIS2_LINK_FREQ_297MHZ] = 1584, [STARVIS2_LINK_FREQ_360MHZ] = 1320, [STARVIS2_LINK_FREQ_445MHZ] = 1100, @@ -267,7 +237,7 @@ static const int starvis2_tpg_val[] = { }; /* Common configuration */ -static const struct cci_reg_sequence common_regs[] = { +static const struct cci_reg_sequence imx678_common_regs[] = { { STARVIS2_REG_THIN_V_EN, 0x00 }, { STARVIS2_REG_VCMODE, 0x01 }, { CCI_REG8(0x306b), 0x00 }, @@ -650,16 +620,72 @@ static const u32 codes_monochrome[] = { MEDIA_BUS_FMT_Y12_1X12, }; +struct starvis2_variant { + const char *name; + u32 id_reg; + u32 id_value; + struct v4l2_rect native_area; + struct v4l2_rect active_area; + u64 pixel_rate; + unsigned int pix_per_clk; + const struct cci_reg_sequence *common_regs; + unsigned int num_common_regs; + unsigned int vmax_default; + const u16 *hmax_min; +}; + +const struct starvis2_variant imx678_variant_def = { + .name = "imx678", + .id_reg = STARVIS2_REG_MODULE_ID, + .id_value = 0x2a6, + .native_area = { + .top = 0, + .left = 0, + .width = 3857, + .height = 2201, + }, + .active_area = { + .top = 20, + .left = 0, + .width = 3856, + .height = 2180, + }, + .pixel_rate = 594000000, + .pix_per_clk = 8, + .common_regs = imx678_common_regs, + .num_common_regs = ARRAY_SIZE(imx678_common_regs), + .vmax_default = 2250, + .hmax_min = imx678_min_hmax_4lane, +}; + +struct starvis2_model_info { + enum starvis2_type type; + const u32 *codes; + unsigned int num_codes; + const struct starvis2_variant *variant; + + const struct starvis2_model_info *auto_detect_colour; + const struct starvis2_model_info *auto_detect_mono; +}; + static const struct starvis2_model_info imx678_aaqr_info = { .type = STARVIS2_COLOR, .codes = codes_bayer, .num_codes = ARRAY_SIZE(codes_bayer), + .variant = &imx678_variant_def, }; static const struct starvis2_model_info imx678_aamr_info = { .type = STARVIS2_MONOCHROME, .codes = codes_monochrome, .num_codes = ARRAY_SIZE(codes_monochrome), + .variant = &imx678_variant_def, +}; + +static const struct starvis2_model_info imx678_autodetect_info = { + .variant = &imx678_variant_def, + .auto_detect_colour = &imx678_aaqr_info, + .auto_detect_mono = &imx678_aamr_info, }; static const char * const starvis2_supply_name[] = { @@ -674,6 +700,7 @@ struct starvis2 { struct regmap *cci; const struct starvis2_model_info *info; + const struct starvis2_variant *variant; struct clk *xclk; u32 xclk_freq; @@ -769,7 +796,8 @@ static int starvis2_set_ctrl(struct v4l2_ctrl *ctrl) cci_write(starvis2->cci, STARVIS2_REG_GAIN, ctrl->val, &ret); break; case V4L2_CID_HBLANK: { - u32 hmax = (format->width + ctrl->val) / IMX678_PIX_PER_CLK; + u32 hmax = (format->width + ctrl->val) / + starvis2->variant->pix_per_clk; cci_write(starvis2->cci, STARVIS2_REG_HMAX, hmax, &ret); break; @@ -849,18 +877,20 @@ static int starvis2_get_selection(struct v4l2_subdev *sd, struct v4l2_subdev_state *sd_state, struct v4l2_subdev_selection *sel) { + struct starvis2 *starvis2 = to_starvis2(sd); + switch (sel->target) { case V4L2_SEL_TGT_CROP: sel->r = *v4l2_subdev_state_get_crop(sd_state, sel->pad); return 0; case V4L2_SEL_TGT_NATIVE_SIZE: - sel->r = imx678_native_area; + sel->r = starvis2->variant->native_area; return 0; case V4L2_SEL_TGT_CROP_DEFAULT: case V4L2_SEL_TGT_CROP_BOUNDS: - sel->r = imx678_active_area; + sel->r = starvis2->variant->active_area; return 0; } @@ -875,12 +905,12 @@ static int starvis2_init_state(struct v4l2_subdev *sd, struct v4l2_rect *crop; crop = v4l2_subdev_state_get_crop(state, STARVIS2_SOURCE_PAD); - *crop = imx678_active_area; + *crop = starvis2->variant->active_area; format = v4l2_subdev_state_get_format(state, STARVIS2_SOURCE_PAD); format->code = starvis2_default_mbus_code(starvis2); - format->width = imx678_active_area.width; - format->height = imx678_active_area.height; + format->width = starvis2->variant->active_area.width; + format->height = starvis2->variant->active_area.height; format->field = V4L2_FIELD_NONE; format->colorspace = V4L2_COLORSPACE_RAW; format->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; @@ -894,8 +924,12 @@ static int starvis2_write_common(struct starvis2 *starvis2) { int ret = 0; - cci_multi_reg_write(starvis2->cci, common_regs, ARRAY_SIZE(common_regs), - &ret); + if (!starvis2->variant) + /* Powered on during probe to do detection. Variant unknown. */ + return 0; + + cci_multi_reg_write(starvis2->cci, starvis2->variant->common_regs, + starvis2->variant->num_common_regs, &ret); cci_write(starvis2->cci, STARVIS2_REG_INCK_SEL, starvis2->inck_sel_val, &ret); @@ -919,10 +953,10 @@ static int starvis2_program_window(struct starvis2 *starvis2, cci_write(starvis2->cci, STARVIS2_REG_ADDMODE, 0x00, &ret); cci_write(starvis2->cci, STARVIS2_REG_WINMODE, 0x04, &ret); cci_write(starvis2->cci, STARVIS2_REG_PIX_HST, - crop->left - imx678_active_area.left, &ret); + crop->left - starvis2->variant->active_area.left, &ret); cci_write(starvis2->cci, STARVIS2_REG_PIX_HWIDTH, crop->width, &ret); cci_write(starvis2->cci, STARVIS2_REG_PIX_VST, - crop->top - imx678_active_area.top, &ret); + crop->top - starvis2->variant->active_area.top, &ret); cci_write(starvis2->cci, STARVIS2_REG_PIX_VWIDTH, crop->height, &ret); cci_write(starvis2->cci, STARVIS2_REG_ADBIT, 0x01, &ret); @@ -1065,11 +1099,16 @@ static int starvis2_identify_model(struct starvis2 *starvis2) { struct i2c_client *client = v4l2_get_subdevdata(&starvis2->sd); const struct starvis2_model_info *info; + const struct starvis2_variant *variant; enum starvis2_type detected; int ret = 0; u64 val = 0; info = device_get_match_data(&client->dev); + if (!info) + return -EINVAL; + + variant = info->variant; /* * This sensor's ID registers become accessible 80ms after coming out @@ -1078,7 +1117,7 @@ static int starvis2_identify_model(struct starvis2 *starvis2) cci_write(starvis2->cci, STARVIS2_REG_MODE_SELECT, 0, &ret); fsleep(IMX678_MODULE_ID_DELAY); - cci_read(starvis2->cci, STARVIS2_REG_MODULE_ID, &val, &ret); + cci_read(starvis2->cci, variant->id_reg, &val, &ret); if (ret) { dev_err(&client->dev, @@ -1086,9 +1125,9 @@ static int starvis2_identify_model(struct starvis2 *starvis2) return ret; } - if (val != IMX678_ID) { - dev_err(&client->dev, - "Chip ID mismatch: %x!=%llx\n", IMX678_ID, val); + if (val != variant->id_value) { + dev_err(&client->dev, "Chip ID mismatch: %x!=%llx\n", + variant->id_value, val); return -ENXIO; } @@ -1103,7 +1142,7 @@ static int starvis2_identify_model(struct starvis2 *starvis2) detected = val & STARVIS2_TYPE; /* Prefer to use sensor type specified in device tree */ - if (info) { + if (info->codes) { starvis2->info = info; if (detected != info->type) dev_err(&client->dev, @@ -1112,11 +1151,12 @@ static int starvis2_identify_model(struct starvis2 *starvis2) info->type == STARVIS2_COLOR ? "color" : "mono"); } else { starvis2->info = detected == STARVIS2_MONOCHROME ? - &imx678_aamr_info : &imx678_aaqr_info; + info->auto_detect_mono : info->auto_detect_colour; dev_info(&client->dev, "sensor type missing in DT; detected %s sensor\n", detected == STARVIS2_MONOCHROME ? "mono" : "color"); } + starvis2->variant = starvis2->info->variant; return 0; } @@ -1148,7 +1188,7 @@ static int starvis2_init_controls(struct starvis2 *starvis2) { struct v4l2_ctrl_handler *ctrl_hdlr; const u32 hmax_4lane = - min_hmax_4lane[__fls(starvis2->link_freq_bitmap)]; + starvis2->variant->hmax_min[__fls(starvis2->link_freq_bitmap)]; const u32 lane_scale = starvis2->lane_mode == STARVIS2_LANEMODE_2L ? 2 : 1; struct i2c_client *client = v4l2_get_subdevdata(&starvis2->sd); @@ -1167,13 +1207,14 @@ static int starvis2_init_controls(struct starvis2 *starvis2) if (ret) return ret; - starvis2->vmax = IMX678_VMAX_DEFAULT; + starvis2->vmax = starvis2->variant->vmax_default; hmax = hmax_4lane * lane_scale; /* PIXEL_RATE is fixed and read-only */ v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, V4L2_CID_PIXEL_RATE, - IMX678_PIXEL_RATE, IMX678_PIXEL_RATE, 1, - IMX678_PIXEL_RATE); + starvis2->variant->pixel_rate, + starvis2->variant->pixel_rate, 1, + starvis2->variant->pixel_rate); /* LINK_FREQ is also read only */ link_freq = v4l2_ctrl_new_int_menu(ctrl_hdlr, &starvis2_ctrl_ops, @@ -1185,23 +1226,25 @@ static int starvis2_init_controls(struct starvis2 *starvis2) if (link_freq) link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY; - vblank = starvis2->vmax - imx678_active_area.height; - max_vblank = STARVIS2_VMAX_MAX - imx678_active_area.height; + vblank = starvis2->vmax - starvis2->variant->active_area.height; + max_vblank = STARVIS2_VMAX_MAX - starvis2->variant->active_area.height; starvis2->vblank = v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, V4L2_CID_VBLANK, vblank, max_vblank, 2, vblank); - hblank = hmax * IMX678_PIX_PER_CLK - imx678_active_area.width; - max_hblank = STARVIS2_HMAX_MAX * IMX678_PIX_PER_CLK - - imx678_active_area.width; + hblank = hmax * starvis2->variant->pix_per_clk - + starvis2->variant->active_area.width; + max_hblank = STARVIS2_HMAX_MAX * starvis2->variant->pix_per_clk - + starvis2->variant->active_area.width; starvis2->hblank = v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, V4L2_CID_HBLANK, hblank, max_hblank, - IMX678_PIX_PER_CLK, hblank); + starvis2->variant->pix_per_clk, + hblank); starvis2->exposure = v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, V4L2_CID_EXPOSURE, STARVIS2_EXPOSURE_MIN, - IMX678_VMAX_DEFAULT - + starvis2->variant->vmax_default - STARVIS2_SHR_MIN, STARVIS2_EXPOSURE_STEP, STARVIS2_EXPOSURE_DEFAULT); @@ -1342,6 +1385,9 @@ static int starvis2_probe(struct i2c_client *client) if (ret) goto error_power_off; + v4l2_i2c_subdev_set_name(&starvis2->sd, client, starvis2->variant->name, + NULL); + pm_runtime_set_active(dev); pm_runtime_enable(dev); @@ -1422,7 +1468,7 @@ static const struct of_device_id starvis2_of_match[] = { { .compatible = "sony,imx678-aamr", .data = &imx678_aamr_info }, { .compatible = "sony,imx678-aaqr", .data = &imx678_aaqr_info }, /* for non-conforming DTs that rely on runtime check */ - { .compatible = "sony,imx678" }, + { .compatible = "sony,imx678", .data = &imx678_autodetect_info }, { /* sentinel */ } }; From 1c2cb402c47a5e7262b7e2a6b5e87644f4d7239d Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Thu, 10 Sep 2026 12:29:40 +0100 Subject: [PATCH 07/18] media: sony-starvis2: Rework 2 lane support for higher link freqs With some Starvis 2 sensors, the link frequency on 2 lanes is sufficient to achieve a lower line time than the 4 lane divided by 2, effectively that it hits the minimum that the pixel array can handle. That can't easily be handled with the way the values are currently stored. Storing the 2 lane hmax alongside the pixel array's minimum allows the 4 lane support to divide the value by 2, and then clip to the pixel array value as a minimum. Signed-off-by: Dave Stevenson --- drivers/media/i2c/sony-starvis2.c | 34 ++++++++++++++++--------------- 1 file changed, 18 insertions(+), 16 deletions(-) diff --git a/drivers/media/i2c/sony-starvis2.c b/drivers/media/i2c/sony-starvis2.c index 1f9bc177ecb0b..a9f9333a208ca 100644 --- a/drivers/media/i2c/sony-starvis2.c +++ b/drivers/media/i2c/sony-starvis2.c @@ -177,15 +177,15 @@ static const u64 link_freqs[] = { [STARVIS2_LINK_FREQ_1188MHZ] = 1188000000, }; -static const u16 imx678_min_hmax_4lane[] = { - [STARVIS2_LINK_FREQ_297MHZ] = 1584, - [STARVIS2_LINK_FREQ_360MHZ] = 1320, - [STARVIS2_LINK_FREQ_445MHZ] = 1100, - [STARVIS2_LINK_FREQ_594MHZ] = 792, - [STARVIS2_LINK_FREQ_720MHZ] = 660, - [STARVIS2_LINK_FREQ_891MHZ] = 550, - [STARVIS2_LINK_FREQ_1039MHZ] = 550, - [STARVIS2_LINK_FREQ_1188MHZ] = 550, +static const u16 imx678_min_hmax_2lane[] = { + [STARVIS2_LINK_FREQ_297MHZ] = 3168, + [STARVIS2_LINK_FREQ_360MHZ] = 2640, + [STARVIS2_LINK_FREQ_445MHZ] = 2200, + [STARVIS2_LINK_FREQ_594MHZ] = 1584, + [STARVIS2_LINK_FREQ_720MHZ] = 1320, + [STARVIS2_LINK_FREQ_891MHZ] = 1100, + [STARVIS2_LINK_FREQ_1039MHZ] = 1100, + [STARVIS2_LINK_FREQ_1188MHZ] = 1100, }; struct starvis2_inck_cfg { @@ -631,7 +631,8 @@ struct starvis2_variant { const struct cci_reg_sequence *common_regs; unsigned int num_common_regs; unsigned int vmax_default; - const u16 *hmax_min; + const u16 *hmax_min_link_freq; + u16 hmax_min_pixel_array; }; const struct starvis2_variant imx678_variant_def = { @@ -655,7 +656,8 @@ const struct starvis2_variant imx678_variant_def = { .common_regs = imx678_common_regs, .num_common_regs = ARRAY_SIZE(imx678_common_regs), .vmax_default = 2250, - .hmax_min = imx678_min_hmax_4lane, + .hmax_min_link_freq = imx678_min_hmax_2lane, + .hmax_min_pixel_array = 550, }; struct starvis2_model_info { @@ -1187,11 +1189,8 @@ static const struct v4l2_subdev_internal_ops starvis2_internal_ops = { static int starvis2_init_controls(struct starvis2 *starvis2) { struct v4l2_ctrl_handler *ctrl_hdlr; - const u32 hmax_4lane = - starvis2->variant->hmax_min[__fls(starvis2->link_freq_bitmap)]; - const u32 lane_scale = - starvis2->lane_mode == STARVIS2_LANEMODE_2L ? 2 : 1; struct i2c_client *client = v4l2_get_subdevdata(&starvis2->sd); + const struct starvis2_variant *variant = starvis2->variant; struct v4l2_fwnode_device_properties props; struct v4l2_ctrl *link_freq; s32 hblank, max_hblank, vblank, max_vblank; @@ -1208,7 +1207,10 @@ static int starvis2_init_controls(struct starvis2 *starvis2) return ret; starvis2->vmax = starvis2->variant->vmax_default; - hmax = hmax_4lane * lane_scale; + + hmax = variant->hmax_min_link_freq[__fls(starvis2->link_freq_bitmap)]; + if (starvis2->lane_mode == STARVIS2_LANEMODE_4L) + hmax = max(hmax >> 1, variant->hmax_min_pixel_array); /* PIXEL_RATE is fixed and read-only */ v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, V4L2_CID_PIXEL_RATE, From b1afdfa1b071c0836e957ac13ec5ab0b449da82e Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Thu, 10 Sep 2026 12:49:22 +0100 Subject: [PATCH 08/18] media: sony-starvis2: Allow runtime control of link frequency DT allows configuration of multiple link frequencies. V4L2_CID_LINK_FREQ allows read write control. Join these up so that link frequency can be configured at run time, as long, as the sensor isn't streaming. Signed-off-by: Dave Stevenson --- drivers/media/i2c/sony-starvis2.c | 62 ++++++++++++++++++++++--------- 1 file changed, 45 insertions(+), 17 deletions(-) diff --git a/drivers/media/i2c/sony-starvis2.c b/drivers/media/i2c/sony-starvis2.c index a9f9333a208ca..78f20054b8727 100644 --- a/drivers/media/i2c/sony-starvis2.c +++ b/drivers/media/i2c/sony-starvis2.c @@ -723,6 +723,7 @@ struct starvis2 { struct v4l2_ctrl *exposure; struct v4l2_ctrl *vblank; struct v4l2_ctrl *hblank; + struct v4l2_ctrl *link_freq; /* Track VMAX for exposure updates */ u32 vmax; @@ -753,6 +754,7 @@ static int starvis2_set_ctrl(struct v4l2_ctrl *ctrl) struct starvis2 *starvis2 = container_of_const(ctrl->handler, struct starvis2, ctrl_handler); struct i2c_client *client = v4l2_get_subdevdata(&starvis2->sd); + const struct starvis2_variant *variant = starvis2->variant; const struct v4l2_mbus_framefmt *format; struct v4l2_subdev_state *state; int ret = 0; @@ -776,6 +778,25 @@ static int starvis2_set_ctrl(struct v4l2_ctrl *ctrl) return ret; } + if (ctrl->id == V4L2_CID_LINK_FREQ) { + u32 hmax = variant->hmax_min_link_freq[ctrl->val]; + s32 hblank; + + if (starvis2->lane_mode == STARVIS2_LANEMODE_4L) + hmax = max(hmax >> 1, variant->hmax_min_pixel_array); + + hblank = hmax * variant->pix_per_clk - + variant->active_area.width; + + ret = __v4l2_ctrl_modify_range(starvis2->hblank, + hblank, + starvis2->hblank->maximum, + starvis2->hblank->step, + hblank); + if (ret) + return ret; + } + /* * Only apply control values when device is powered on (RPM ACTIVE) * and streaming (usage count != 0) @@ -822,6 +843,12 @@ static int starvis2_set_ctrl(struct v4l2_ctrl *ctrl) cci_write(starvis2->cci, STARVIS2_REG_WINMODEV, ctrl->val, &ret); break; + case V4L2_CID_LINK_FREQ: + /* The STARVIS2_LINK_FREQ_ enums match up with the register */ + cci_write(starvis2->cci, STARVIS2_REG_DATARATE_SEL, ctrl->val, + &ret); + break; + default: dev_warn(&client->dev, "ctrl(id:0x%x,val:0x%x) is not handled\n", @@ -935,9 +962,6 @@ static int starvis2_write_common(struct starvis2 *starvis2) cci_write(starvis2->cci, STARVIS2_REG_INCK_SEL, starvis2->inck_sel_val, &ret); - cci_write(starvis2->cci, STARVIS2_REG_DATARATE_SEL, - __fls(starvis2->link_freq_bitmap), - &ret); cci_write(starvis2->cci, STARVIS2_REG_LANEMODE, starvis2->lane_mode, &ret); @@ -1004,6 +1028,7 @@ static int starvis2_enable_streams(struct v4l2_subdev *sd, goto err_rpm_put; } + __v4l2_ctrl_grab(starvis2->link_freq, true); return 0; err_rpm_put: @@ -1028,6 +1053,8 @@ static int starvis2_disable_streams(struct v4l2_subdev *sd, if (ret) dev_err(&client->dev, "%s failed to stop stream\n", __func__); + __v4l2_ctrl_grab(starvis2->link_freq, false); + pm_runtime_put(&client->dev); return ret; @@ -1192,7 +1219,6 @@ static int starvis2_init_controls(struct starvis2 *starvis2) struct i2c_client *client = v4l2_get_subdevdata(&starvis2->sd); const struct starvis2_variant *variant = starvis2->variant; struct v4l2_fwnode_device_properties props; - struct v4l2_ctrl *link_freq; s32 hblank, max_hblank, vblank, max_vblank; u32 hmax; int ret; @@ -1208,25 +1234,23 @@ static int starvis2_init_controls(struct starvis2 *starvis2) starvis2->vmax = starvis2->variant->vmax_default; - hmax = variant->hmax_min_link_freq[__fls(starvis2->link_freq_bitmap)]; - if (starvis2->lane_mode == STARVIS2_LANEMODE_4L) - hmax = max(hmax >> 1, variant->hmax_min_pixel_array); - /* PIXEL_RATE is fixed and read-only */ v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, V4L2_CID_PIXEL_RATE, starvis2->variant->pixel_rate, starvis2->variant->pixel_rate, 1, starvis2->variant->pixel_rate); - /* LINK_FREQ is also read only */ - link_freq = v4l2_ctrl_new_int_menu(ctrl_hdlr, &starvis2_ctrl_ops, - V4L2_CID_LINK_FREQ, - ARRAY_SIZE(link_freqs) - 1, - __ffs(starvis2->link_freq_bitmap), - link_freqs); - - if (link_freq) - link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY; + starvis2->link_freq = + v4l2_ctrl_new_int_menu(ctrl_hdlr, &starvis2_ctrl_ops, + V4L2_CID_LINK_FREQ, + __fls(starvis2->link_freq_bitmap), + __ffs(starvis2->link_freq_bitmap), + link_freqs); + __v4l2_ctrl_modify_range(starvis2->link_freq, + __ffs(starvis2->link_freq_bitmap), + __fls(starvis2->link_freq_bitmap), + ~(starvis2->link_freq_bitmap), + __ffs(starvis2->link_freq_bitmap)); vblank = starvis2->vmax - starvis2->variant->active_area.height; max_vblank = STARVIS2_VMAX_MAX - starvis2->variant->active_area.height; @@ -1234,6 +1258,10 @@ static int starvis2_init_controls(struct starvis2 *starvis2) V4L2_CID_VBLANK, vblank, max_vblank, 2, vblank); + hmax = variant->hmax_min_link_freq[starvis2->link_freq->val]; + if (starvis2->lane_mode == STARVIS2_LANEMODE_4L) + hmax = max(hmax >> 1, variant->hmax_min_pixel_array); + hblank = hmax * starvis2->variant->pix_per_clk - starvis2->variant->active_area.width; max_hblank = STARVIS2_HMAX_MAX * starvis2->variant->pix_per_clk - From cb2db8038c34e515accfe05d5573bf7ded74bad5 Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Thu, 17 Sep 2026 16:15:39 +0100 Subject: [PATCH 09/18] media: sony-starvis2: Add a mechanism for detection of Starvis2 variant As we have a way to confirm which Starvis2 module is connected, add a generic compatible that will use all defined variants to attempt to identify which module is connected. Signed-off-by: Dave Stevenson --- drivers/media/i2c/sony-starvis2.c | 61 ++++++++++++++++++++++--------- 1 file changed, 43 insertions(+), 18 deletions(-) diff --git a/drivers/media/i2c/sony-starvis2.c b/drivers/media/i2c/sony-starvis2.c index 78f20054b8727..d706fad3399d3 100644 --- a/drivers/media/i2c/sony-starvis2.c +++ b/drivers/media/i2c/sony-starvis2.c @@ -94,7 +94,6 @@ /* Sensor Identification */ #define STARVIS2_REG_MONOCHROME CCI_REG8(0x4d18) #define STARVIS2_TYPE BIT(0) -#define STARVIS2_REG_MODULE_ID CCI_REG16_LE(0x4d1c) #define IMX678_MODULE_ID_DELAY 80000 /* Common configuration registers */ @@ -623,6 +622,7 @@ static const u32 codes_monochrome[] = { struct starvis2_variant { const char *name; u32 id_reg; + u32 id_mask; u32 id_value; struct v4l2_rect native_area; struct v4l2_rect active_area; @@ -637,7 +637,8 @@ struct starvis2_variant { const struct starvis2_variant imx678_variant_def = { .name = "imx678", - .id_reg = STARVIS2_REG_MODULE_ID, + .id_reg = CCI_REG16_LE(0x4d1c), + .id_mask = 0x3ff, .id_value = 0x2a6, .native_area = { .top = 0, @@ -690,6 +691,10 @@ static const struct starvis2_model_info imx678_autodetect_info = { .auto_detect_mono = &imx678_aamr_info, }; +static const struct starvis2_model_info *starvis2_all_model_autodetect[] = { + &imx678_autodetect_info, +}; + static const char * const starvis2_supply_name[] = { "avdd", /* Analog (3.3V) supply */ "dvdd", /* Digital Core (1.1V) supply */ @@ -1134,10 +1139,6 @@ static int starvis2_identify_model(struct starvis2 *starvis2) u64 val = 0; info = device_get_match_data(&client->dev); - if (!info) - return -EINVAL; - - variant = info->variant; /* * This sensor's ID registers become accessible 80ms after coming out @@ -1146,18 +1147,40 @@ static int starvis2_identify_model(struct starvis2 *starvis2) cci_write(starvis2->cci, STARVIS2_REG_MODE_SELECT, 0, &ret); fsleep(IMX678_MODULE_ID_DELAY); - cci_read(starvis2->cci, variant->id_reg, &val, &ret); + if (!info) { + /* Generic "sony,starvis2" - identify the module */ + int i; - if (ret) { - dev_err(&client->dev, - "I2C transaction failed ret = %d\n", ret); - return ret; - } + for (i = 0; i < ARRAY_SIZE(starvis2_all_model_autodetect); i++) { + variant = starvis2_all_model_autodetect[i]->variant; + + cci_read(starvis2->cci, variant->id_reg, &val, &ret); + if ((val & variant->id_mask) == variant->id_value) { + info = starvis2_all_model_autodetect[i]; + break; + } + } + + if (!info) { + dev_err(&client->dev, "No Starvis2 camera found\n"); + return -ENXIO; + } + } else { + variant = info->variant; + + cci_read(starvis2->cci, variant->id_reg, &val, &ret); - if (val != variant->id_value) { - dev_err(&client->dev, "Chip ID mismatch: %x!=%llx\n", - variant->id_value, val); - return -ENXIO; + if (ret) { + dev_err(&client->dev, + "I2C transaction failed ret = %d\n", ret); + return ret; + } + + if (val != variant->id_value) { + dev_err(&client->dev, "Chip ID mismatch: %x!=%llx\n", + variant->id_value, val); + return -ENXIO; + } } cci_read(starvis2->cci, STARVIS2_REG_MONOCHROME, &val, &ret); @@ -1182,8 +1205,9 @@ static int starvis2_identify_model(struct starvis2 *starvis2) starvis2->info = detected == STARVIS2_MONOCHROME ? info->auto_detect_mono : info->auto_detect_colour; dev_info(&client->dev, - "sensor type missing in DT; detected %s sensor\n", - detected == STARVIS2_MONOCHROME ? "mono" : "color"); + "sensor type not specified in DT; detected %s %s sensor\n", + detected == STARVIS2_MONOCHROME ? "mono" : "color", + info->variant->name); } starvis2->variant = starvis2->info->variant; @@ -1499,6 +1523,7 @@ static const struct of_device_id starvis2_of_match[] = { { .compatible = "sony,imx678-aaqr", .data = &imx678_aaqr_info }, /* for non-conforming DTs that rely on runtime check */ { .compatible = "sony,imx678", .data = &imx678_autodetect_info }, + { .compatible = "sony,starvis2", .data = NULL }, { /* sentinel */ } }; From d9ee3e35a3a24bc7f94c0f3e10a66b177e7520ef Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Thu, 3 Sep 2026 17:30:49 +0100 Subject: [PATCH 10/18] media: sony-starvis2: Add support for IMX662 IMX662 is a 1080p Starvis 2 sensor that follows the same programming pattern as IMX678, so add it to the newly parameterised common driver. Signed-off-by: Dave Stevenson --- drivers/media/i2c/sony-starvis2.c | 158 +++++++++++++++++++++++++++++- 1 file changed, 157 insertions(+), 1 deletion(-) diff --git a/drivers/media/i2c/sony-starvis2.c b/drivers/media/i2c/sony-starvis2.c index d706fad3399d3..70bc28432f03a 100644 --- a/drivers/media/i2c/sony-starvis2.c +++ b/drivers/media/i2c/sony-starvis2.c @@ -8,7 +8,9 @@ * Currently supported are: * IMX678: Diagonal 8.86 mm (Type 1/1.8) CMOS image sensor with 8.40 M effective * pixels. - * + * IMX662: Diagonal 6.45mm (Type 1/2.8) CMOS image sensor with 2.12 M effective + * pixels. + * Copyright (C) 2026 Ideas On Board Oy. * * Based on Sony IMX678 driver prepared by Will Whang & Soho Enterprise Ltd. @@ -661,6 +663,136 @@ const struct starvis2_variant imx678_variant_def = { .hmax_min_pixel_array = 550, }; +static const struct cci_reg_sequence imx662_common_regs[] = { + { CCI_REG8(0x3444), 0xac }, + { CCI_REG8(0x3492), 0x08 }, + { CCI_REG8(0x3b00), 0x39 }, + { CCI_REG8(0x3b23), 0x2d }, + { CCI_REG8(0x3b45), 0x04 }, + { CCI_REG8(0x3c0a), 0x1f }, + { CCI_REG8(0x3c0b), 0x1e }, + { CCI_REG8(0x3c38), 0x21 }, + { CCI_REG8(0x3c44), 0x00 }, + { CCI_REG8(0x3cb6), 0xd8 }, + { CCI_REG8(0x3cc4), 0xda }, + { CCI_REG8(0x3e24), 0x79 }, + { CCI_REG8(0x3e2c), 0x15 }, + { CCI_REG8(0x3edc), 0x2d }, + { CCI_REG8(0x4498), 0x05 }, + { CCI_REG8(0x449c), 0x19 }, + { CCI_REG8(0x449d), 0x00 }, + { CCI_REG8(0x449e), 0x32 }, + { CCI_REG8(0x449f), 0x01 }, + { CCI_REG8(0x44a0), 0x92 }, + { CCI_REG8(0x44a2), 0x91 }, + { CCI_REG8(0x44a4), 0x8c }, + { CCI_REG8(0x44a6), 0x87 }, + { CCI_REG8(0x44a8), 0x82 }, + { CCI_REG8(0x44aa), 0x78 }, + { CCI_REG8(0x44ac), 0x6e }, + { CCI_REG8(0x44ae), 0x69 }, + { CCI_REG8(0x44b0), 0x92 }, + { CCI_REG8(0x44b2), 0x91 }, + { CCI_REG8(0x44b4), 0x8c }, + { CCI_REG8(0x44b6), 0x87 }, + { CCI_REG8(0x44b8), 0x82 }, + { CCI_REG8(0x44ba), 0x78 }, + { CCI_REG8(0x44bc), 0x6e }, + { CCI_REG8(0x44be), 0x69 }, + { CCI_REG8(0x44c0), 0x7f }, + { CCI_REG8(0x44c1), 0x01 }, + { CCI_REG8(0x44c2), 0x7f }, + { CCI_REG8(0x44c3), 0x01 }, + { CCI_REG8(0x44c4), 0x7a }, + { CCI_REG8(0x44c5), 0x01 }, + { CCI_REG8(0x44c6), 0x7a }, + { CCI_REG8(0x44c7), 0x01 }, + { CCI_REG8(0x44c8), 0x70 }, + { CCI_REG8(0x44c9), 0x01 }, + { CCI_REG8(0x44ca), 0x6b }, + { CCI_REG8(0x44cb), 0x01 }, + { CCI_REG8(0x44cc), 0x6b }, + { CCI_REG8(0x44cd), 0x01 }, + { CCI_REG8(0x44ce), 0x5c }, + { CCI_REG8(0x44cf), 0x01 }, + { CCI_REG8(0x44d0), 0x7f }, + { CCI_REG8(0x44d1), 0x01 }, + { CCI_REG8(0x44d2), 0x7f }, + { CCI_REG8(0x44d3), 0x01 }, + { CCI_REG8(0x44d4), 0x7a }, + { CCI_REG8(0x44d5), 0x01 }, + { CCI_REG8(0x44d6), 0x7a }, + { CCI_REG8(0x44d7), 0x01 }, + { CCI_REG8(0x44d8), 0x70 }, + { CCI_REG8(0x44d9), 0x01 }, + { CCI_REG8(0x44da), 0x6b }, + { CCI_REG8(0x44db), 0x01 }, + { CCI_REG8(0x44dc), 0x6b }, + { CCI_REG8(0x44dd), 0x01 }, + { CCI_REG8(0x44de), 0x5c }, + { CCI_REG8(0x44df), 0x01 }, + { CCI_REG8(0x4534), 0x1c }, + { CCI_REG8(0x4535), 0x03 }, + { CCI_REG8(0x4538), 0x1c }, + { CCI_REG8(0x4539), 0x1c }, + { CCI_REG8(0x453a), 0x1c }, + { CCI_REG8(0x453b), 0x1c }, + { CCI_REG8(0x453c), 0x1c }, + { CCI_REG8(0x453d), 0x1c }, + { CCI_REG8(0x453e), 0x1c }, + { CCI_REG8(0x453f), 0x1c }, + { CCI_REG8(0x4540), 0x1c }, + { CCI_REG8(0x4541), 0x03 }, + { CCI_REG8(0x4542), 0x03 }, + { CCI_REG8(0x4543), 0x03 }, + { CCI_REG8(0x4544), 0x03 }, + { CCI_REG8(0x4545), 0x03 }, + { CCI_REG8(0x4546), 0x03 }, + { CCI_REG8(0x4547), 0x03 }, + { CCI_REG8(0x4548), 0x03 }, + { CCI_REG8(0x4549), 0x03 }, + { STARVIS2_REG_WDMODE, 0x00 }, + { STARVIS2_REG_MDBIT, 0x01 }, + { STARVIS2_REG_XXS_DRV, 0x00 }, +}; + +static const u16 imx662_min_hmax_2lane[] = { + [STARVIS2_LINK_FREQ_297MHZ] = 1980, + [STARVIS2_LINK_FREQ_360MHZ] = 1980, + [STARVIS2_LINK_FREQ_445MHZ] = 1188, + [STARVIS2_LINK_FREQ_594MHZ] = 990, + [STARVIS2_LINK_FREQ_720MHZ] = 990, + [STARVIS2_LINK_FREQ_891MHZ] = 990, + [STARVIS2_LINK_FREQ_1039MHZ] = 990, + [STARVIS2_LINK_FREQ_1188MHZ] = 990, +}; + +const struct starvis2_variant imx662_variant_def = { + .name = "imx662", + .id_reg = CCI_REG16_LE(0x4d1c), + .id_mask = 0x3ff, + .id_value = 0x296, + .native_area = { + .top = 0, + .left = 0, + .width = 1937, + .height = 1101, + }, + .active_area = { + .top = 0, + .left = 0, + .width = 1936, + .height = 1096, + }, + .pixel_rate = 222750000, + .pix_per_clk = 3, + .common_regs = imx662_common_regs, + .num_common_regs = ARRAY_SIZE(imx662_common_regs), + .vmax_default = 1136, + .hmax_min_link_freq = imx662_min_hmax_2lane, + .hmax_min_pixel_array = 990, +}; + struct starvis2_model_info { enum starvis2_type type; const u32 *codes; @@ -691,7 +823,28 @@ static const struct starvis2_model_info imx678_autodetect_info = { .auto_detect_mono = &imx678_aamr_info, }; +static const struct starvis2_model_info imx662_aaqr_info = { + .type = STARVIS2_COLOR, + .codes = codes_bayer, + .num_codes = ARRAY_SIZE(codes_bayer), + .variant = &imx662_variant_def, +}; + +static const struct starvis2_model_info imx662_aamr_info = { + .type = STARVIS2_MONOCHROME, + .codes = codes_monochrome, + .num_codes = ARRAY_SIZE(codes_monochrome), + .variant = &imx662_variant_def, +}; + +static const struct starvis2_model_info imx662_autodetect_info = { + .variant = &imx662_variant_def, + .auto_detect_colour = &imx662_aaqr_info, + .auto_detect_mono = &imx662_aamr_info, +}; + static const struct starvis2_model_info *starvis2_all_model_autodetect[] = { + &imx662_autodetect_info, &imx678_autodetect_info, }; @@ -1521,8 +1674,11 @@ static const struct dev_pm_ops starvis2_pm_ops = { static const struct of_device_id starvis2_of_match[] = { { .compatible = "sony,imx678-aamr", .data = &imx678_aamr_info }, { .compatible = "sony,imx678-aaqr", .data = &imx678_aaqr_info }, + { .compatible = "sony,imx662-aamr", .data = &imx662_aamr_info }, + { .compatible = "sony,imx662-aaqr", .data = &imx662_aaqr_info }, /* for non-conforming DTs that rely on runtime check */ { .compatible = "sony,imx678", .data = &imx678_autodetect_info }, + { .compatible = "sony,imx662", .data = &imx662_autodetect_info }, { .compatible = "sony,starvis2", .data = NULL }, { /* sentinel */ } }; From a8ecfb99a3dcc7e9ade316792dc4aaf6b7eaa3d1 Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Thu, 3 Sep 2026 17:49:44 +0100 Subject: [PATCH 11/18] media: sony-starvis2: Add support for IMX675 The IMX675 is a 5MPix Starvis2 sensor that follows the same programming pattern as IMX678 and IMX662, so add it into the driver. Signed-off-by: Dave Stevenson --- drivers/media/i2c/sony-starvis2.c | 219 +++++++++++++++++++++++++++++- 1 file changed, 218 insertions(+), 1 deletion(-) diff --git a/drivers/media/i2c/sony-starvis2.c b/drivers/media/i2c/sony-starvis2.c index 70bc28432f03a..61ff9d98c8863 100644 --- a/drivers/media/i2c/sony-starvis2.c +++ b/drivers/media/i2c/sony-starvis2.c @@ -10,7 +10,9 @@ * pixels. * IMX662: Diagonal 6.45mm (Type 1/2.8) CMOS image sensor with 2.12 M effective * pixels. - + * IMX675: Diagonal 6.53mm (Type 1/2.8) CMOS image sensor with 5.12 M effective + * pixels. + * * Copyright (C) 2026 Ideas On Board Oy. * * Based on Sony IMX678 driver prepared by Will Whang & Soho Enterprise Ltd. @@ -793,6 +795,193 @@ const struct starvis2_variant imx662_variant_def = { .hmax_min_pixel_array = 990, }; +static const struct cci_reg_sequence imx675_common_regs[] = { + { STARVIS2_REG_THIN_V_EN, 0x00 }, + { STARVIS2_REG_VCMODE, 0x01 }, + + { CCI_REG8(0x3081), 0x00 }, + { STARVIS2_REG_XXS_OUTSEL, 0xaa }, + { STARVIS2_REG_XXS_DRV, 0x0f }, + { CCI_REG8(0x30cc), 0x00 }, + { CCI_REG8(0x30cd), 0x00 }, + { CCI_REG8(0x30ce), 0x02 }, + { CCI_REG8(0x3400), 0x01 }, + + { CCI_REG8(0x3460), 0x22 }, + { CCI_REG8(0x347b), 0x02 }, + { CCI_REG8(0x3492), 0x08 }, + { CCI_REG8(0x3b1d), 0x17 }, + { CCI_REG8(0x3b44), 0x3f }, + { CCI_REG8(0x3b60), 0x03 }, + { CCI_REG8(0x3c03), 0x04 }, + { CCI_REG8(0x3c04), 0x04 }, + { CCI_REG8(0x3c0a), 0x1f }, + { CCI_REG8(0x3c0b), 0x1f }, + { CCI_REG8(0x3c0c), 0x1f }, + { CCI_REG8(0x3c0d), 0x1f }, + { CCI_REG8(0x3c0e), 0x1f }, + { CCI_REG8(0x3c0f), 0x1f }, + { CCI_REG8(0x3c30), 0x73 }, + { CCI_REG8(0x3c3c), 0x20 }, + { CCI_REG8(0x3c44), 0x06 }, + { CCI_REG8(0x3c7c), 0xb9 }, + { CCI_REG8(0x3c7d), 0x01 }, + { CCI_REG8(0x3c7e), 0xb7 }, + { CCI_REG8(0x3c7f), 0x01 }, + { CCI_REG8(0x3cb0), 0x00 }, + { CCI_REG8(0x3cb2), 0xff }, + { CCI_REG8(0x3cb3), 0x03 }, + { CCI_REG8(0x3cb4), 0xff }, + { CCI_REG8(0x3cb5), 0x03 }, + { CCI_REG8(0x3cba), 0xff }, + { CCI_REG8(0x3cbb), 0x03 }, + { CCI_REG8(0x3cc0), 0xff }, + { CCI_REG8(0x3cc1), 0x03 }, + { CCI_REG8(0x3cc2), 0x00 }, + { CCI_REG8(0x3cc6), 0xff }, + { CCI_REG8(0x3cc7), 0x03 }, + { CCI_REG8(0x3cc8), 0xff }, + { CCI_REG8(0x3cc9), 0x03 }, + { CCI_REG8(0x3e00), 0x1e }, + { CCI_REG8(0x3e02), 0x04 }, + { CCI_REG8(0x3e03), 0x00 }, + { CCI_REG8(0x3e20), 0x04 }, + { CCI_REG8(0x3e21), 0x00 }, + { CCI_REG8(0x3e22), 0x1e }, + { CCI_REG8(0x3e24), 0xba }, + { CCI_REG8(0x3e72), 0x85 }, + { CCI_REG8(0x3e76), 0x0c }, + { CCI_REG8(0x3e77), 0x01 }, + { CCI_REG8(0x3e7a), 0x85 }, + { CCI_REG8(0x3e7e), 0x1f }, + { CCI_REG8(0x3e82), 0xa6 }, + { CCI_REG8(0x3e86), 0x2d }, + { CCI_REG8(0x3ee2), 0x33 }, + { CCI_REG8(0x3ee3), 0x03 }, + { CCI_REG8(0x4490), 0x07 }, + { CCI_REG8(0x4494), 0x19 }, + { CCI_REG8(0x4495), 0x00 }, + { CCI_REG8(0x4496), 0xbb }, + { CCI_REG8(0x4497), 0x00 }, + { CCI_REG8(0x4498), 0x55 }, + { CCI_REG8(0x449a), 0x50 }, + { CCI_REG8(0x449c), 0x50 }, + { CCI_REG8(0x449e), 0x50 }, + { CCI_REG8(0x44a0), 0x3c }, + { CCI_REG8(0x44a2), 0x19 }, + { CCI_REG8(0x44a4), 0x19 }, + { CCI_REG8(0x44a6), 0x19 }, + { CCI_REG8(0x44a8), 0x4b }, + { CCI_REG8(0x44aa), 0x4b }, + { CCI_REG8(0x44ac), 0x4b }, + { CCI_REG8(0x44ae), 0x4b }, + { CCI_REG8(0x44b0), 0x3c }, + { CCI_REG8(0x44b2), 0x19 }, + { CCI_REG8(0x44b4), 0x19 }, + { CCI_REG8(0x44b6), 0x19 }, + { CCI_REG8(0x44b8), 0x4b }, + { CCI_REG8(0x44ba), 0x4b }, + { CCI_REG8(0x44bc), 0x4b }, + { CCI_REG8(0x44be), 0x4b }, + { CCI_REG8(0x44c0), 0x3c }, + { CCI_REG8(0x44c2), 0x19 }, + { CCI_REG8(0x44c4), 0x19 }, + { CCI_REG8(0x44c6), 0x19 }, + { CCI_REG8(0x44c8), 0xf0 }, + { CCI_REG8(0x44ca), 0xeb }, + { CCI_REG8(0x44cc), 0xeb }, + { CCI_REG8(0x44ce), 0xe6 }, + { CCI_REG8(0x44d0), 0xe6 }, + { CCI_REG8(0x44d2), 0xbb }, + { CCI_REG8(0x44d4), 0xbb }, + { CCI_REG8(0x44d6), 0xbb }, + { CCI_REG8(0x44d8), 0xe6 }, + { CCI_REG8(0x44da), 0xe6 }, + { CCI_REG8(0x44dc), 0xe6 }, + { CCI_REG8(0x44de), 0xe6 }, + { CCI_REG8(0x44e0), 0xe6 }, + { CCI_REG8(0x44e2), 0xbb }, + { CCI_REG8(0x44e4), 0xbb }, + { CCI_REG8(0x44e6), 0xbb }, + { CCI_REG8(0x44e8), 0xe6 }, + { CCI_REG8(0x44ea), 0xe6 }, + { CCI_REG8(0x44ec), 0xe6 }, + { CCI_REG8(0x44ee), 0xe6 }, + { CCI_REG8(0x44f0), 0xe6 }, + { CCI_REG8(0x44f2), 0xbb }, + { CCI_REG8(0x44f4), 0xbb }, + { CCI_REG8(0x44f6), 0xbb }, + { CCI_REG8(0x4538), 0x15 }, + { CCI_REG8(0x4539), 0x15 }, + { CCI_REG8(0x453a), 0x15 }, + { CCI_REG8(0x4544), 0x15 }, + { CCI_REG8(0x4545), 0x15 }, + { CCI_REG8(0x4546), 0x15 }, + { CCI_REG8(0x4550), 0x10 }, + { CCI_REG8(0x4551), 0x10 }, + { CCI_REG8(0x4552), 0x10 }, + { CCI_REG8(0x4553), 0x10 }, + { CCI_REG8(0x4554), 0x10 }, + { CCI_REG8(0x4555), 0x10 }, + { CCI_REG8(0x4556), 0x10 }, + { CCI_REG8(0x4557), 0x10 }, + { CCI_REG8(0x4558), 0x10 }, + { CCI_REG8(0x455c), 0x10 }, + { CCI_REG8(0x455d), 0x10 }, + { CCI_REG8(0x455e), 0x10 }, + { CCI_REG8(0x455f), 0x10 }, + { CCI_REG8(0x4560), 0x10 }, + { CCI_REG8(0x4561), 0x10 }, + { CCI_REG8(0x4562), 0x10 }, + { CCI_REG8(0x4563), 0x10 }, + { CCI_REG8(0x4564), 0x10 }, + { CCI_REG8(0x4569), 0x01 }, + { CCI_REG8(0x456a), 0x01 }, + { CCI_REG8(0x456b), 0x06 }, + { CCI_REG8(0x456c), 0x06 }, + { CCI_REG8(0x456d), 0x06 }, + { CCI_REG8(0x456e), 0x06 }, + { CCI_REG8(0x456f), 0x06 }, + { CCI_REG8(0x4570), 0x06 }, +}; + +static const u16 imx675_min_hmax_2lane[] = { + [STARVIS2_LINK_FREQ_297MHZ] = 2044, + [STARVIS2_LINK_FREQ_360MHZ] = 1692, + [STARVIS2_LINK_FREQ_445MHZ] = 1376, + [STARVIS2_LINK_FREQ_594MHZ] = 1064, + [STARVIS2_LINK_FREQ_720MHZ] = 840, + [STARVIS2_LINK_FREQ_891MHZ] = 684, + [STARVIS2_LINK_FREQ_1039MHZ] = 592, + [STARVIS2_LINK_FREQ_1188MHZ] = 528, +}; + +const struct starvis2_variant imx675_variant_def = { + .name = "imx675", + .id_reg = CCI_REG16_LE(0x4d12), + .id_mask = 0xfff, + .id_value = 0x576, + .native_area = { + .top = 0, + .left = 0, + .width = 2609, + .height = 1984, + }, + .active_area = { + .top = 0, + .left = 0, + .width = 2608, + .height = 1984, + }, + .pixel_rate = 594000000, + .pix_per_clk = 8, + .common_regs = imx675_common_regs, + .num_common_regs = ARRAY_SIZE(imx675_common_regs), + .vmax_default = 2024, + .hmax_min_link_freq = imx675_min_hmax_2lane, + .hmax_min_pixel_array = 528, +}; + struct starvis2_model_info { enum starvis2_type type; const u32 *codes; @@ -843,7 +1032,32 @@ static const struct starvis2_model_info imx662_autodetect_info = { .auto_detect_mono = &imx662_aamr_info, }; +static const struct starvis2_model_info imx675_aaqr_info = { + .type = STARVIS2_COLOR, + .codes = codes_bayer, + .num_codes = ARRAY_SIZE(codes_bayer), + .variant = &imx675_variant_def, +}; + +static const struct starvis2_model_info imx675_aamr_info = { + .type = STARVIS2_MONOCHROME, + .codes = codes_monochrome, + .num_codes = ARRAY_SIZE(codes_monochrome), + .variant = &imx675_variant_def, +}; + +static const struct starvis2_model_info imx675_autodetect_info = { + .variant = &imx675_variant_def, + .auto_detect_colour = &imx675_aaqr_info, + .auto_detect_mono = &imx675_aamr_info, +}; + static const struct starvis2_model_info *starvis2_all_model_autodetect[] = { + /* + * NB IMX675 responds to 0x4d1c with 0x0296, same as IMX662 does + * officially, so it MUST come before IMX662 in the search order + */ + &imx675_autodetect_info, &imx662_autodetect_info, &imx678_autodetect_info, }; @@ -1674,10 +1888,13 @@ static const struct dev_pm_ops starvis2_pm_ops = { static const struct of_device_id starvis2_of_match[] = { { .compatible = "sony,imx678-aamr", .data = &imx678_aamr_info }, { .compatible = "sony,imx678-aaqr", .data = &imx678_aaqr_info }, + { .compatible = "sony,imx675-aamr", .data = &imx675_aamr_info }, + { .compatible = "sony,imx675-aaqr", .data = &imx675_aaqr_info }, { .compatible = "sony,imx662-aamr", .data = &imx662_aamr_info }, { .compatible = "sony,imx662-aaqr", .data = &imx662_aaqr_info }, /* for non-conforming DTs that rely on runtime check */ { .compatible = "sony,imx678", .data = &imx678_autodetect_info }, + { .compatible = "sony,imx675", .data = &imx675_autodetect_info }, { .compatible = "sony,imx662", .data = &imx662_autodetect_info }, { .compatible = "sony,starvis2", .data = NULL }, { /* sentinel */ } From 2bc10eb2c1d3f42d0dc0582abce84326371a8444 Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Wed, 16 Sep 2026 17:30:13 +0100 Subject: [PATCH 12/18] media: sony-starvis2: Add support for IMX832 IMX832 is replacing IMX662, and it follows the same pattern as all the Starvis2 sensors. Add the sensor specific configuration for it. Signed-off-by: Dave Stevenson --- drivers/media/i2c/sony-starvis2.c | 119 ++++++++++++++++++++++++++++++ 1 file changed, 119 insertions(+) diff --git a/drivers/media/i2c/sony-starvis2.c b/drivers/media/i2c/sony-starvis2.c index 61ff9d98c8863..c2b4d06687b57 100644 --- a/drivers/media/i2c/sony-starvis2.c +++ b/drivers/media/i2c/sony-starvis2.c @@ -12,6 +12,8 @@ * pixels. * IMX675: Diagonal 6.53mm (Type 1/2.8) CMOS image sensor with 5.12 M effective * pixels. + * IMX832: Diagonal 6.45mm (Type 1/2.8) CMOS image sensor with 2.12 M effective + * pixels. * * Copyright (C) 2026 Ideas On Board Oy. * @@ -982,6 +984,99 @@ const struct starvis2_variant imx675_variant_def = { .hmax_min_pixel_array = 528, }; +static const struct cci_reg_sequence imx832_common_regs[] = { + { CCI_REG8(0x3460), 0x21 }, + { CCI_REG8(0x3a94), 0x75 }, + { CCI_REG8(0x3a96), 0x69 }, + { CCI_REG8(0x3a98), 0x1e }, + { CCI_REG8(0x3a9a), 0x1e }, + { CCI_REG8(0x3b58), 0xeb }, + { CCI_REG8(0x3b5c), 0xeb }, + { CCI_REG8(0x3b88), 0xeb }, + { CCI_REG8(0x3b8c), 0xeb }, + { CCI_REG8(0x3c40), 0x06 }, + { CCI_REG8(0x3cae), 0x79 }, + { CCI_REG8(0x3cbc), 0x7b }, + { CCI_REG8(0x4508), 0x00 }, + { CCI_REG8(0x4509), 0x02 }, + { CCI_REG8(0x450a), 0x41 }, + { CCI_REG8(0x450b), 0x03 }, + { CCI_REG8(0x4660), 0x12 }, + { CCI_REG8(0x4661), 0x00 }, + { CCI_REG8(0x4662), 0x29 }, + { CCI_REG8(0x4664), 0x12 }, + { CCI_REG8(0x4665), 0x00 }, + { CCI_REG8(0x4666), 0x25 }, + { CCI_REG8(0x4667), 0x03 }, + { CCI_REG8(0x46c0), 0x13 }, + { CCI_REG8(0x46c1), 0x00 }, + { CCI_REG8(0x46c2), 0x28 }, + { CCI_REG8(0x46c4), 0x13 }, + { CCI_REG8(0x46c5), 0x00 }, + { CCI_REG8(0x46c6), 0x24 }, + { CCI_REG8(0x46c7), 0x03 }, + { CCI_REG8(0x4720), 0x07 }, + { CCI_REG8(0x4721), 0x00 }, + { CCI_REG8(0x4722), 0x23 }, + { CCI_REG8(0x4723), 0x03 }, + { CCI_REG8(0x4724), 0x14 }, + { CCI_REG8(0x4725), 0x00 }, + { CCI_REG8(0x4726), 0x2a }, + { CCI_REG8(0x4750), 0x1e }, + { CCI_REG8(0x4752), 0x22 }, + { CCI_REG8(0x4753), 0x03 }, + { CCI_REG8(0x4754), 0x25 }, + { CCI_REG8(0x4755), 0x00 }, + { CCI_REG8(0x4756), 0x29 }, + { CCI_REG8(0x4780), 0x08 }, + { CCI_REG8(0x4781), 0x00 }, + { CCI_REG8(0x4782), 0x1d }, + { CCI_REG8(0x4783), 0x03 }, + { CCI_REG8(0x4784), 0x15 }, + { CCI_REG8(0x4785), 0x00 }, + { CCI_REG8(0x4786), 0x24 }, + { STARVIS2_REG_WDMODE, 0x00 }, + { STARVIS2_REG_MDBIT, 0x01 }, + { STARVIS2_REG_XXS_DRV, 0x00 }, +}; + +static const u16 imx832_min_hmax_2lane[] = { + [STARVIS2_LINK_FREQ_297MHZ] = 1980, + [STARVIS2_LINK_FREQ_360MHZ] = 1980, + [STARVIS2_LINK_FREQ_445MHZ] = 1188, + [STARVIS2_LINK_FREQ_594MHZ] = 990, + [STARVIS2_LINK_FREQ_720MHZ] = 990, + [STARVIS2_LINK_FREQ_891MHZ] = 990, + [STARVIS2_LINK_FREQ_1039MHZ] = 990, + [STARVIS2_LINK_FREQ_1188MHZ] = 990, +}; + +const struct starvis2_variant imx832_variant_def = { + .name = "imx832", + .id_reg = CCI_REG16_LE(0x4d1c), + .id_mask = 0x3ff, + .id_value = 0x340, + .native_area = { + .top = 0, + .left = 0, + .width = 1937, + .height = 1101, + }, + .active_area = { + .top = 0, + .left = 0, + .width = 1936, + .height = 1096, + }, + .pixel_rate = 222750000, + .pix_per_clk = 3, + .common_regs = imx832_common_regs, + .num_common_regs = ARRAY_SIZE(imx832_common_regs), + .vmax_default = 1136, + .hmax_min_link_freq = imx832_min_hmax_2lane, + .hmax_min_pixel_array = 990, +}; + struct starvis2_model_info { enum starvis2_type type; const u32 *codes; @@ -1052,6 +1147,26 @@ static const struct starvis2_model_info imx675_autodetect_info = { .auto_detect_mono = &imx675_aamr_info, }; +static const struct starvis2_model_info imx832_aaqr_info = { + .type = STARVIS2_COLOR, + .codes = codes_bayer, + .num_codes = ARRAY_SIZE(codes_bayer), + .variant = &imx832_variant_def, +}; + +static const struct starvis2_model_info imx832_aamr_info = { + .type = STARVIS2_MONOCHROME, + .codes = codes_monochrome, + .num_codes = ARRAY_SIZE(codes_monochrome), + .variant = &imx832_variant_def, +}; + +static const struct starvis2_model_info imx832_autodetect_info = { + .variant = &imx832_variant_def, + .auto_detect_colour = &imx832_aaqr_info, + .auto_detect_mono = &imx832_aamr_info, +}; + static const struct starvis2_model_info *starvis2_all_model_autodetect[] = { /* * NB IMX675 responds to 0x4d1c with 0x0296, same as IMX662 does @@ -1059,6 +1174,7 @@ static const struct starvis2_model_info *starvis2_all_model_autodetect[] = { */ &imx675_autodetect_info, &imx662_autodetect_info, + &imx832_autodetect_info, &imx678_autodetect_info, }; @@ -1892,10 +2008,13 @@ static const struct of_device_id starvis2_of_match[] = { { .compatible = "sony,imx675-aaqr", .data = &imx675_aaqr_info }, { .compatible = "sony,imx662-aamr", .data = &imx662_aamr_info }, { .compatible = "sony,imx662-aaqr", .data = &imx662_aaqr_info }, + { .compatible = "sony,imx832-aamr", .data = &imx832_aamr_info }, + { .compatible = "sony,imx832-aaqr", .data = &imx832_aaqr_info }, /* for non-conforming DTs that rely on runtime check */ { .compatible = "sony,imx678", .data = &imx678_autodetect_info }, { .compatible = "sony,imx675", .data = &imx675_autodetect_info }, { .compatible = "sony,imx662", .data = &imx662_autodetect_info }, + { .compatible = "sony,imx832", .data = &imx832_autodetect_info }, { .compatible = "sony,starvis2", .data = NULL }, { /* sentinel */ } }; From 9252add6f208eb29178e3c0499e16eef85a98ec0 Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Thu, 17 Sep 2026 09:57:15 +0100 Subject: [PATCH 13/18] media: sony-starvis2: Add support for IMX585 IMX585 is an 8MPix Starvis 2 sensor, so add support for it. Signed-off-by: Dave Stevenson --- drivers/media/i2c/sony-starvis2.c | 438 ++++++++++++++++++++++++++++++ 1 file changed, 438 insertions(+) diff --git a/drivers/media/i2c/sony-starvis2.c b/drivers/media/i2c/sony-starvis2.c index c2b4d06687b57..a7d374d9aef90 100644 --- a/drivers/media/i2c/sony-starvis2.c +++ b/drivers/media/i2c/sony-starvis2.c @@ -14,6 +14,8 @@ * pixels. * IMX832: Diagonal 6.45mm (Type 1/2.8) CMOS image sensor with 2.12 M effective * pixels. + * IMX585: Diagonal 12.84 mm (Type 1/1.2) CMOS image sensor with 8.40 M effective + * pixels. * * Copyright (C) 2026 Ideas On Board Oy. * @@ -1077,6 +1079,418 @@ const struct starvis2_variant imx832_variant_def = { .hmax_min_pixel_array = 990, }; +static const struct cci_reg_sequence imx585_common_regs[] = { + { STARVIS2_REG_THIN_V_EN, 0x00 }, + { STARVIS2_REG_VCMODE, 0x01 }, + { CCI_REG8(0x306b), 0x00 }, + { STARVIS2_REG_GAIN_PGC_FIDMD, 0x01 }, + { CCI_REG8(0x3460), 0x22 }, + { CCI_REG8(0x355a), 0x64 }, + { CCI_REG8(0x3a02), 0x7a }, + { CCI_REG8(0x3a10), 0xec }, + { CCI_REG8(0x3a12), 0x71 }, + { CCI_REG8(0x3a14), 0xde }, + { CCI_REG8(0x3a20), 0x2b }, + { CCI_REG8(0x3a24), 0x22 }, + { CCI_REG8(0x3a25), 0x25 }, + { CCI_REG8(0x3a26), 0x2a }, + { CCI_REG8(0x3a27), 0x2c }, + { CCI_REG8(0x3a28), 0x39 }, + { CCI_REG8(0x3a29), 0x38 }, + { CCI_REG8(0x3a30), 0x04 }, + { CCI_REG8(0x3a31), 0x04 }, + { CCI_REG8(0x3a32), 0x03 }, + { CCI_REG8(0x3a33), 0x03 }, + { CCI_REG8(0x3a34), 0x09 }, + { CCI_REG8(0x3a35), 0x06 }, + { CCI_REG8(0x3a38), 0xcd }, + { CCI_REG8(0x3a3a), 0x4c }, + { CCI_REG8(0x3a3c), 0xb9 }, + { CCI_REG8(0x3a3e), 0x30 }, + { CCI_REG8(0x3a40), 0x2c }, + { CCI_REG8(0x3a42), 0x39 }, + { CCI_REG8(0x3a4e), 0x00 }, + { CCI_REG8(0x3a52), 0x00 }, + { CCI_REG8(0x3a56), 0x00 }, + { CCI_REG8(0x3a5a), 0x00 }, + { CCI_REG8(0x3a5e), 0x00 }, + { CCI_REG8(0x3a62), 0x00 }, + { CCI_REG8(0x3a64), 0x00 }, + { CCI_REG8(0x3a6e), 0xa0 }, + { CCI_REG8(0x3a70), 0x50 }, + { CCI_REG8(0x3a8c), 0x04 }, + { CCI_REG8(0x3a8d), 0x03 }, + { CCI_REG8(0x3a8e), 0x09 }, + { CCI_REG8(0x3a90), 0x38 }, + { CCI_REG8(0x3a91), 0x42 }, + { CCI_REG8(0x3a92), 0x3c }, + { CCI_REG8(0x3b0e), 0xf3 }, + { CCI_REG8(0x3b12), 0xe5 }, + { CCI_REG8(0x3b27), 0xc0 }, + { CCI_REG8(0x3b2e), 0xef }, + { CCI_REG8(0x3b30), 0x6a }, + { CCI_REG8(0x3b32), 0xf6 }, + { CCI_REG8(0x3b36), 0xe1 }, + { CCI_REG8(0x3b3a), 0xe8 }, + { CCI_REG8(0x3b5a), 0x17 }, + { CCI_REG8(0x3b5e), 0xef }, + { CCI_REG8(0x3b60), 0x6a }, + { CCI_REG8(0x3b62), 0xf6 }, + { CCI_REG8(0x3b66), 0xe1 }, + { CCI_REG8(0x3b6a), 0xe8 }, + { CCI_REG8(0x3b88), 0xec }, + { CCI_REG8(0x3b8a), 0xed }, + { CCI_REG8(0x3b94), 0x71 }, + { CCI_REG8(0x3b96), 0x72 }, + { CCI_REG8(0x3b98), 0xde }, + { CCI_REG8(0x3b9a), 0xdf }, + { CCI_REG8(0x3c0f), 0x06 }, + { CCI_REG8(0x3c10), 0x06 }, + { CCI_REG8(0x3c11), 0x06 }, + { CCI_REG8(0x3c12), 0x06 }, + { CCI_REG8(0x3c13), 0x06 }, + { CCI_REG8(0x3c18), 0x20 }, + { CCI_REG8(0x3c37), 0x10 }, + { CCI_REG8(0x3c3a), 0x7a }, + { CCI_REG8(0x3c40), 0xf4 }, + { CCI_REG8(0x3c48), 0xe6 }, + { CCI_REG8(0x3c54), 0xce }, + { CCI_REG8(0x3c56), 0xd0 }, + { CCI_REG8(0x3c6c), 0x53 }, + { CCI_REG8(0x3c6e), 0x55 }, + { CCI_REG8(0x3c70), 0xc0 }, + { CCI_REG8(0x3c72), 0xc2 }, + { CCI_REG8(0x3c7e), 0xce }, + { CCI_REG8(0x3c8c), 0xcf }, + { CCI_REG8(0x3c8e), 0xeb }, + { CCI_REG8(0x3c98), 0x54 }, + { CCI_REG8(0x3c9a), 0x70 }, + { CCI_REG8(0x3c9c), 0xc1 }, + { CCI_REG8(0x3c9e), 0xdd }, + { CCI_REG8(0x3cb0), 0x7a }, + { CCI_REG8(0x3cb2), 0xba }, + { CCI_REG8(0x3cc8), 0xbc }, + { CCI_REG8(0x3cca), 0x7c }, + { CCI_REG8(0x3cd4), 0xea }, + { CCI_REG8(0x3cd5), 0x01 }, + { CCI_REG8(0x3cd6), 0x4a }, + { CCI_REG8(0x3cd8), 0x00 }, + { CCI_REG8(0x3cd9), 0x00 }, + { CCI_REG8(0x3cda), 0xff }, + { CCI_REG8(0x3cdb), 0x03 }, + { CCI_REG8(0x3cdc), 0x00 }, + { CCI_REG8(0x3cdd), 0x00 }, + { CCI_REG8(0x3cde), 0xff }, + { CCI_REG8(0x3cdf), 0x03 }, + { CCI_REG8(0x3ce4), 0x4c }, + { CCI_REG8(0x3ce6), 0xec }, + { CCI_REG8(0x3ce7), 0x01 }, + { CCI_REG8(0x3ce8), 0xff }, + { CCI_REG8(0x3ce9), 0x03 }, + { CCI_REG8(0x3cea), 0x00 }, + { CCI_REG8(0x3ceb), 0x00 }, + { CCI_REG8(0x3cec), 0xff }, + { CCI_REG8(0x3ced), 0x03 }, + { CCI_REG8(0x3cee), 0x00 }, + { CCI_REG8(0x3cef), 0x00 }, + { CCI_REG8(0x3cf2), 0xff }, + { CCI_REG8(0x3cf3), 0x03 }, + { CCI_REG8(0x3cf4), 0x00 }, + { CCI_REG8(0x3e28), 0x82 }, + { CCI_REG8(0x3e2a), 0x80 }, + { CCI_REG8(0x3e30), 0x85 }, + { CCI_REG8(0x3e32), 0x7d }, + { CCI_REG8(0x3e5c), 0xce }, + { CCI_REG8(0x3e5e), 0xd3 }, + { CCI_REG8(0x3e70), 0x53 }, + { CCI_REG8(0x3e72), 0x58 }, + { CCI_REG8(0x3e74), 0xc0 }, + { CCI_REG8(0x3e76), 0xc5 }, + { CCI_REG8(0x3e78), 0xc0 }, + { CCI_REG8(0x3e79), 0x01 }, + { CCI_REG8(0x3e7a), 0xd4 }, + { CCI_REG8(0x3e7b), 0x01 }, + { CCI_REG8(0x3eb4), 0x0b }, + { CCI_REG8(0x3eb5), 0x02 }, + { CCI_REG8(0x3eb6), 0x4d }, + { CCI_REG8(0x3eb7), 0x42 }, + { CCI_REG8(0x3eec), 0xf3 }, + { CCI_REG8(0x3eee), 0xe7 }, + { CCI_REG8(0x3f01), 0x01 }, + { CCI_REG8(0x3f24), 0x10 }, + { CCI_REG8(0x3f28), 0x2d }, + { CCI_REG8(0x3f2a), 0x2d }, + { CCI_REG8(0x3f2c), 0x2d }, + { CCI_REG8(0x3f2e), 0x2d }, + { CCI_REG8(0x3f30), 0x23 }, + { CCI_REG8(0x3f38), 0x2d }, + { CCI_REG8(0x3f3a), 0x2d }, + { CCI_REG8(0x3f3c), 0x2d }, + { CCI_REG8(0x3f3e), 0x28 }, + { CCI_REG8(0x3f40), 0x1e }, + { CCI_REG8(0x3f48), 0x2d }, + { CCI_REG8(0x3f4a), 0x2d }, + { CCI_REG8(0x3f4c), 0x00 }, + { CCI_REG8(0x4004), 0xe4 }, + { CCI_REG8(0x4006), 0xff }, + { CCI_REG8(0x4018), 0x69 }, + { CCI_REG8(0x401a), 0x84 }, + { CCI_REG8(0x401c), 0xd6 }, + { CCI_REG8(0x401e), 0xf1 }, + { CCI_REG8(0x4038), 0xde }, + { CCI_REG8(0x403a), 0x00 }, + { CCI_REG8(0x403b), 0x01 }, + { CCI_REG8(0x404c), 0x63 }, + { CCI_REG8(0x404e), 0x85 }, + { CCI_REG8(0x4050), 0xd0 }, + { CCI_REG8(0x4052), 0xf2 }, + { CCI_REG8(0x4108), 0xdd }, + { CCI_REG8(0x410a), 0xf7 }, + { CCI_REG8(0x411c), 0x62 }, + { CCI_REG8(0x411e), 0x7c }, + { CCI_REG8(0x4120), 0xcf }, + { CCI_REG8(0x4122), 0xe9 }, + { CCI_REG8(0x4138), 0xe6 }, + { CCI_REG8(0x413a), 0xf1 }, + { CCI_REG8(0x414c), 0x6b }, + { CCI_REG8(0x414e), 0x76 }, + { CCI_REG8(0x4150), 0xd8 }, + { CCI_REG8(0x4152), 0xe3 }, + { CCI_REG8(0x417e), 0x03 }, + { CCI_REG8(0x417f), 0x01 }, + { CCI_REG8(0x4186), 0xe0 }, + { CCI_REG8(0x4190), 0xf3 }, + { CCI_REG8(0x4192), 0xf7 }, + { CCI_REG8(0x419c), 0x78 }, + { CCI_REG8(0x419e), 0x7c }, + { CCI_REG8(0x41a0), 0xe5 }, + { CCI_REG8(0x41a2), 0xe9 }, + { CCI_REG8(0x41c8), 0xe2 }, + { CCI_REG8(0x41ca), 0xfd }, + { CCI_REG8(0x41dc), 0x67 }, + { CCI_REG8(0x41de), 0x82 }, + { CCI_REG8(0x41e0), 0xd4 }, + { CCI_REG8(0x41e2), 0xef }, + { CCI_REG8(0x4200), 0xde }, + { CCI_REG8(0x4202), 0xda }, + { CCI_REG8(0x4218), 0x63 }, + { CCI_REG8(0x421a), 0x5f }, + { CCI_REG8(0x421c), 0xd0 }, + { CCI_REG8(0x421e), 0xcc }, + { CCI_REG8(0x425a), 0x82 }, + { CCI_REG8(0x425c), 0xef }, + { CCI_REG8(0x4348), 0xfe }, + { CCI_REG8(0x4349), 0x06 }, + { CCI_REG8(0x4352), 0xce }, + { CCI_REG8(0x4420), 0x0b }, + { CCI_REG8(0x4421), 0x02 }, + { CCI_REG8(0x4422), 0x4d }, + { CCI_REG8(0x4423), 0x0a }, + { CCI_REG8(0x4426), 0xf5 }, + { CCI_REG8(0x442a), 0xe7 }, + { CCI_REG8(0x4432), 0xf5 }, + { CCI_REG8(0x4436), 0xe7 }, + { CCI_REG8(0x4466), 0xb4 }, + { CCI_REG8(0x446e), 0x32 }, + { CCI_REG8(0x449f), 0x1c }, + { CCI_REG8(0x44a4), 0x2c }, + { CCI_REG8(0x44a6), 0x2c }, + { CCI_REG8(0x44a8), 0x2c }, + { CCI_REG8(0x44aa), 0x2c }, + { CCI_REG8(0x44b4), 0x2c }, + { CCI_REG8(0x44b6), 0x2c }, + { CCI_REG8(0x44b8), 0x2c }, + { CCI_REG8(0x44ba), 0x2c }, + { CCI_REG8(0x44c4), 0x2c }, + { CCI_REG8(0x44c6), 0x2c }, + { CCI_REG8(0x44c8), 0x2c }, + { CCI_REG8(0x4506), 0xf3 }, + { CCI_REG8(0x450e), 0xe5 }, + { CCI_REG8(0x4516), 0xf3 }, + { CCI_REG8(0x4522), 0xe5 }, + { CCI_REG8(0x4524), 0xf3 }, + { CCI_REG8(0x452c), 0xe5 }, + { CCI_REG8(0x453c), 0x22 }, + { CCI_REG8(0x453d), 0x1b }, + { CCI_REG8(0x453e), 0x1b }, + { CCI_REG8(0x453f), 0x15 }, + { CCI_REG8(0x4540), 0x15 }, + { CCI_REG8(0x4541), 0x15 }, + { CCI_REG8(0x4542), 0x15 }, + { CCI_REG8(0x4543), 0x15 }, + { CCI_REG8(0x4544), 0x15 }, + { CCI_REG8(0x4548), 0x00 }, + { CCI_REG8(0x4549), 0x01 }, + { CCI_REG8(0x454a), 0x01 }, + { CCI_REG8(0x454b), 0x06 }, + { CCI_REG8(0x454c), 0x06 }, + { CCI_REG8(0x454d), 0x06 }, + { CCI_REG8(0x454e), 0x06 }, + { CCI_REG8(0x454f), 0x06 }, + { CCI_REG8(0x4550), 0x06 }, + { CCI_REG8(0x4554), 0x55 }, + { CCI_REG8(0x4555), 0x02 }, + { CCI_REG8(0x4556), 0x42 }, + { CCI_REG8(0x4557), 0x05 }, + { CCI_REG8(0x4558), 0xfd }, + { CCI_REG8(0x4559), 0x05 }, + { CCI_REG8(0x455a), 0x94 }, + { CCI_REG8(0x455b), 0x06 }, + { CCI_REG8(0x455d), 0x06 }, + { CCI_REG8(0x455e), 0x49 }, + { CCI_REG8(0x455f), 0x07 }, + { CCI_REG8(0x4560), 0x7f }, + { CCI_REG8(0x4561), 0x07 }, + { CCI_REG8(0x4562), 0xa5 }, + { CCI_REG8(0x4564), 0x55 }, + { CCI_REG8(0x4565), 0x02 }, + { CCI_REG8(0x4566), 0x42 }, + { CCI_REG8(0x4567), 0x05 }, + { CCI_REG8(0x4568), 0xfd }, + { CCI_REG8(0x4569), 0x05 }, + { CCI_REG8(0x456a), 0x94 }, + { CCI_REG8(0x456b), 0x06 }, + { CCI_REG8(0x456d), 0x06 }, + { CCI_REG8(0x456e), 0x49 }, + { CCI_REG8(0x456f), 0x07 }, + { CCI_REG8(0x4572), 0xa5 }, + { CCI_REG8(0x460c), 0x7d }, + { CCI_REG8(0x460e), 0xb1 }, + { CCI_REG8(0x4614), 0xa8 }, + { CCI_REG8(0x4616), 0xb2 }, + { CCI_REG8(0x461c), 0x7e }, + { CCI_REG8(0x461e), 0xa7 }, + { CCI_REG8(0x4624), 0xa8 }, + { CCI_REG8(0x4626), 0xb2 }, + { CCI_REG8(0x462c), 0x7e }, + { CCI_REG8(0x462e), 0x8a }, + { CCI_REG8(0x4630), 0x94 }, + { CCI_REG8(0x4632), 0xa7 }, + { CCI_REG8(0x4634), 0xfb }, + { CCI_REG8(0x4636), 0x2f }, + { CCI_REG8(0x4638), 0x81 }, + { CCI_REG8(0x4639), 0x01 }, + { CCI_REG8(0x463a), 0xb5 }, + { CCI_REG8(0x463b), 0x01 }, + { CCI_REG8(0x463c), 0x26 }, + { CCI_REG8(0x463e), 0x30 }, + { CCI_REG8(0x4640), 0xac }, + { CCI_REG8(0x4641), 0x01 }, + { CCI_REG8(0x4642), 0xb6 }, + { CCI_REG8(0x4643), 0x01 }, + { CCI_REG8(0x4644), 0xfc }, + { CCI_REG8(0x4646), 0x25 }, + { CCI_REG8(0x4648), 0x82 }, + { CCI_REG8(0x4649), 0x01 }, + { CCI_REG8(0x464a), 0xab }, + { CCI_REG8(0x464b), 0x01 }, + { CCI_REG8(0x464c), 0x26 }, + { CCI_REG8(0x464e), 0x30 }, + { CCI_REG8(0x4654), 0xfc }, + { CCI_REG8(0x4656), 0x08 }, + { CCI_REG8(0x4658), 0x12 }, + { CCI_REG8(0x465a), 0x25 }, + { CCI_REG8(0x4662), 0xfc }, + { CCI_REG8(0x46a2), 0xfb }, + { CCI_REG8(0x46d6), 0xf3 }, + { CCI_REG8(0x46e6), 0x00 }, + { CCI_REG8(0x46e8), 0xff }, + { CCI_REG8(0x46e9), 0x03 }, + { CCI_REG8(0x46ec), 0x7a }, + { CCI_REG8(0x46ee), 0xe5 }, + { CCI_REG8(0x46f4), 0xee }, + { CCI_REG8(0x46f6), 0xf2 }, + { CCI_REG8(0x470c), 0xff }, + { CCI_REG8(0x470d), 0x03 }, + { CCI_REG8(0x470e), 0x00 }, + { CCI_REG8(0x4714), 0xe0 }, + { CCI_REG8(0x4716), 0xe4 }, + { CCI_REG8(0x471e), 0xed }, + { CCI_REG8(0x472e), 0x00 }, + { CCI_REG8(0x4730), 0xff }, + { CCI_REG8(0x4731), 0x03 }, + { CCI_REG8(0x4734), 0x7b }, + { CCI_REG8(0x4736), 0xdf }, + { CCI_REG8(0x4754), 0x7d }, + { CCI_REG8(0x4756), 0x8b }, + { CCI_REG8(0x4758), 0x93 }, + { CCI_REG8(0x475a), 0xb1 }, + { CCI_REG8(0x475c), 0xfb }, + { CCI_REG8(0x475e), 0x09 }, + { CCI_REG8(0x4760), 0x11 }, + { CCI_REG8(0x4762), 0x2f }, + { CCI_REG8(0x4766), 0xcc }, + { CCI_REG8(0x4776), 0xcb }, + { CCI_REG8(0x477e), 0x4a }, + { CCI_REG8(0x478e), 0x49 }, + { CCI_REG8(0x4794), 0x7c }, + { CCI_REG8(0x4796), 0x8f }, + { CCI_REG8(0x4798), 0xb3 }, + { CCI_REG8(0x4799), 0x00 }, + { CCI_REG8(0x479a), 0xcc }, + { CCI_REG8(0x479c), 0xc1 }, + { CCI_REG8(0x479e), 0xcb }, + { CCI_REG8(0x47a4), 0x7d }, + { CCI_REG8(0x47a6), 0x8e }, + { CCI_REG8(0x47a8), 0xb4 }, + { CCI_REG8(0x47a9), 0x00 }, + { CCI_REG8(0x47aa), 0xc0 }, + { CCI_REG8(0x47ac), 0xfa }, + { CCI_REG8(0x47ae), 0x0d }, + { CCI_REG8(0x47b0), 0x31 }, + { CCI_REG8(0x47b1), 0x01 }, + { CCI_REG8(0x47b2), 0x4a }, + { CCI_REG8(0x47b3), 0x01 }, + { CCI_REG8(0x47b4), 0x3f }, + { CCI_REG8(0x47b6), 0x49 }, + { CCI_REG8(0x47bc), 0xfb }, + { CCI_REG8(0x47be), 0x0c }, + { CCI_REG8(0x47c0), 0x32 }, + { CCI_REG8(0x47c1), 0x01 }, + { CCI_REG8(0x47c2), 0x3e }, + { CCI_REG8(0x47c3), 0x01 }, + { STARVIS2_REG_WDMODE, 0x00 }, + { STARVIS2_REG_MDBIT, 0x01 }, + { STARVIS2_REG_XXS_DRV, 0x00 }, +}; + +static const u16 imx585_min_hmax_2lane[] = { + [STARVIS2_LINK_FREQ_297MHZ] = 1980, + [STARVIS2_LINK_FREQ_360MHZ] = 1980, + [STARVIS2_LINK_FREQ_445MHZ] = 1188, + [STARVIS2_LINK_FREQ_594MHZ] = 990, + [STARVIS2_LINK_FREQ_720MHZ] = 990, + [STARVIS2_LINK_FREQ_891MHZ] = 990, + [STARVIS2_LINK_FREQ_1039MHZ] = 990, + [STARVIS2_LINK_FREQ_1188MHZ] = 990, +}; + +const struct starvis2_variant imx585_variant_def = { + .name = "imx585", + .id_reg = CCI_REG16_LE(0x5a1d), + .id_mask = 0x3ff, + .id_value = 0x259, + .active_area = { + .top = 0, + .left = 0, + .width = 3857, + .height = 2201, + }, + .active_area = { + .top = 20, + .left = 0, + .width = 3856, + .height = 2180, + }, + .pixel_rate = 594000000, + .pix_per_clk = 8, + .common_regs = imx585_common_regs, + .num_common_regs = ARRAY_SIZE(imx585_common_regs), + .vmax_default = 2250, + .hmax_min_link_freq = imx585_min_hmax_2lane, + .hmax_min_pixel_array = 550, +}; + struct starvis2_model_info { enum starvis2_type type; const u32 *codes; @@ -1167,6 +1581,26 @@ static const struct starvis2_model_info imx832_autodetect_info = { .auto_detect_mono = &imx832_aamr_info, }; +static const struct starvis2_model_info imx585_aaqr_info = { + .type = STARVIS2_COLOR, + .codes = codes_bayer, + .num_codes = ARRAY_SIZE(codes_bayer), + .variant = &imx585_variant_def, +}; + +static const struct starvis2_model_info imx585_aamr_info = { + .type = STARVIS2_MONOCHROME, + .codes = codes_monochrome, + .num_codes = ARRAY_SIZE(codes_monochrome), + .variant = &imx585_variant_def, +}; + +static const struct starvis2_model_info imx585_autodetect_info = { + .variant = &imx585_variant_def, + .auto_detect_colour = &imx585_aaqr_info, + .auto_detect_mono = &imx585_aamr_info, +}; + static const struct starvis2_model_info *starvis2_all_model_autodetect[] = { /* * NB IMX675 responds to 0x4d1c with 0x0296, same as IMX662 does @@ -1176,6 +1610,7 @@ static const struct starvis2_model_info *starvis2_all_model_autodetect[] = { &imx662_autodetect_info, &imx832_autodetect_info, &imx678_autodetect_info, + &imx585_autodetect_info, }; static const char * const starvis2_supply_name[] = { @@ -2010,11 +2445,14 @@ static const struct of_device_id starvis2_of_match[] = { { .compatible = "sony,imx662-aaqr", .data = &imx662_aaqr_info }, { .compatible = "sony,imx832-aamr", .data = &imx832_aamr_info }, { .compatible = "sony,imx832-aaqr", .data = &imx832_aaqr_info }, + { .compatible = "sony,imx585-aamr", .data = &imx585_aamr_info }, + { .compatible = "sony,imx585-aaqr", .data = &imx585_aaqr_info }, /* for non-conforming DTs that rely on runtime check */ { .compatible = "sony,imx678", .data = &imx678_autodetect_info }, { .compatible = "sony,imx675", .data = &imx675_autodetect_info }, { .compatible = "sony,imx662", .data = &imx662_autodetect_info }, { .compatible = "sony,imx832", .data = &imx832_autodetect_info }, + { .compatible = "sony,imx585", .data = &imx585_autodetect_info }, { .compatible = "sony,starvis2", .data = NULL }, { /* sentinel */ } }; From 6b665b5ac8a5ae04779d023048f6adc676ba56db Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Wed, 9 Sep 2026 16:49:40 +0100 Subject: [PATCH 14/18] defconfigs: Add SONY_STARVIS2 sensor driver to Pi defconfigs Signed-off-by: Dave Stevenson --- arch/arm/configs/bcm2709_defconfig | 1 + arch/arm/configs/bcmrpi_defconfig | 1 + arch/arm64/configs/bcm2711_defconfig | 1 + arch/arm64/configs/bcm2711_rt_defconfig | 1 + arch/arm64/configs/bcm2712_defconfig | 1 + 5 files changed, 5 insertions(+) diff --git a/arch/arm/configs/bcm2709_defconfig b/arch/arm/configs/bcm2709_defconfig index 09c5082c770ec..9375555fe43bf 100644 --- a/arch/arm/configs/bcm2709_defconfig +++ b/arch/arm/configs/bcm2709_defconfig @@ -959,6 +959,7 @@ CONFIG_VIDEO_OV64A40=m CONFIG_VIDEO_OV7251=m CONFIG_VIDEO_OV7640=m CONFIG_VIDEO_OV9282=m +CONFIG_VIDEO_SONY_STARVIS2=m CONFIG_VIDEO_VD55G1=m CONFIG_VIDEO_VD56G3=m CONFIG_VIDEO_AD5398=m diff --git a/arch/arm/configs/bcmrpi_defconfig b/arch/arm/configs/bcmrpi_defconfig index 197ca950ee36e..76ed78a63212a 100644 --- a/arch/arm/configs/bcmrpi_defconfig +++ b/arch/arm/configs/bcmrpi_defconfig @@ -952,6 +952,7 @@ CONFIG_VIDEO_OV64A40=m CONFIG_VIDEO_OV7251=m CONFIG_VIDEO_OV7640=m CONFIG_VIDEO_OV9282=m +CONFIG_VIDEO_SONY_STARVIS2=m CONFIG_VIDEO_VD55G1=m CONFIG_VIDEO_VD56G3=m CONFIG_VIDEO_AD5398=m diff --git a/arch/arm64/configs/bcm2711_defconfig b/arch/arm64/configs/bcm2711_defconfig index 753fcdf918b4a..d5a728e2ce9f6 100644 --- a/arch/arm64/configs/bcm2711_defconfig +++ b/arch/arm64/configs/bcm2711_defconfig @@ -1062,6 +1062,7 @@ CONFIG_VIDEO_OV64A40=m CONFIG_VIDEO_OV7251=m CONFIG_VIDEO_OV7640=m CONFIG_VIDEO_OV9282=m +CONFIG_VIDEO_SONY_STARVIS2=m CONFIG_VIDEO_VD55G1=m CONFIG_VIDEO_VD56G3=m CONFIG_VIDEO_AD5398=m diff --git a/arch/arm64/configs/bcm2711_rt_defconfig b/arch/arm64/configs/bcm2711_rt_defconfig index 32da405f3223e..7e646b4ae849c 100644 --- a/arch/arm64/configs/bcm2711_rt_defconfig +++ b/arch/arm64/configs/bcm2711_rt_defconfig @@ -1059,6 +1059,7 @@ CONFIG_VIDEO_OV64A40=m CONFIG_VIDEO_OV7251=m CONFIG_VIDEO_OV7640=m CONFIG_VIDEO_OV9282=m +CONFIG_VIDEO_SONY_STARVIS2=m CONFIG_VIDEO_VD55G1=m CONFIG_VIDEO_VD56G3=m CONFIG_VIDEO_AD5398=m diff --git a/arch/arm64/configs/bcm2712_defconfig b/arch/arm64/configs/bcm2712_defconfig index 04aaa031f6b44..8faf29c5ed832 100644 --- a/arch/arm64/configs/bcm2712_defconfig +++ b/arch/arm64/configs/bcm2712_defconfig @@ -1064,6 +1064,7 @@ CONFIG_VIDEO_OV64A40=m CONFIG_VIDEO_OV7251=m CONFIG_VIDEO_OV7640=m CONFIG_VIDEO_OV9282=m +CONFIG_VIDEO_SONY_STARVIS2=m CONFIG_VIDEO_VD55G1=m CONFIG_VIDEO_VD56G3=m CONFIG_VIDEO_AD5398=m From 7da0d6e693dceca42713ea45e452a6ca001ba151 Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Thu, 17 Sep 2026 16:39:10 +0100 Subject: [PATCH 15/18] dtoverlays: Add the generic Sony Starvis2 image sensor overlay Signed-off-by: Dave Stevenson --- arch/arm/boot/dts/overlays/Makefile | 1 + arch/arm/boot/dts/overlays/README | 33 +++++ .../boot/dts/overlays/starvis2-overlay.dts | 136 ++++++++++++++++++ arch/arm/boot/dts/overlays/starvis2.dtsi | 26 ++++ 4 files changed, 196 insertions(+) create mode 100644 arch/arm/boot/dts/overlays/starvis2-overlay.dts create mode 100644 arch/arm/boot/dts/overlays/starvis2.dtsi diff --git a/arch/arm/boot/dts/overlays/Makefile b/arch/arm/boot/dts/overlays/Makefile index 3ca704516da0c..38a886a359001 100644 --- a/arch/arm/boot/dts/overlays/Makefile +++ b/arch/arm/boot/dts/overlays/Makefile @@ -317,6 +317,7 @@ dtbo-$(CONFIG_ARCH_BCM2835) += \ ssd1327-spi.dtbo \ ssd1331-spi.dtbo \ ssd1351-spi.dtbo \ + starvis2.dtbo \ sunfounder-pipower3.dtbo \ sunfounder-pironman5.dtbo \ superaudioboard.dtbo \ diff --git a/arch/arm/boot/dts/overlays/README b/arch/arm/boot/dts/overlays/README index 64aab639e4984..e511331caa94c 100644 --- a/arch/arm/boot/dts/overlays/README +++ b/arch/arm/boot/dts/overlays/README @@ -5477,6 +5477,39 @@ Params: speed SPI bus speed (default 4500000) reset_pin GPIO pin for RESET (default 25) +Name: starvis2 +Info: Sony Starvis2 camera module. + Uses Unicam 1, which is the standard camera connector on most Pi + variants. +Load: dtoverlay=starvis2, +Params: 4lane Enable 4 CSI2 data lanes (default is for 2 lane + operation), which requires a Pi5 or CM. + clock-frequency Sets the clock frequency to match that used on + the board. + Valid values are 24, 27, 37.125, 72, or + 74.25MHz. + The default is 24MHz. + link-frequency Confgures the link frequency to be used. Note + that the permitted values vary based on + clock-frequency and number of lanes. + The default is 445.5MHz for 891Mbit/s. + all-link-frequencies Define all permitted link frequencies to allow + for user selection of the preferred rate. + Does NOT include 1188Mbit/s as that is not + reliable. + orientation Sensor orientation (0 = front, 1 = rear, + 2 = external, default external) + rotation Mounting rotation of the camera sensor (0 or + 180, default 0) + media-controller Configure use of Media Controller API for + configuring the sensor (default on) + cam0 Adopt the default configuration for CAM0 on a + Compute Module (CSI0, i2c_vc, and cam0_reg). + vcm Enable ad5398 VCM associated with the sensor. + compatible Allows overriding of the compatible if automatic + detection at probe is undesirable. + + Name: sunfounder-pipower3 Info: Overlay for SunFounder PiPower 3 Load: dtoverlay=sunfounder-pipower3,= diff --git a/arch/arm/boot/dts/overlays/starvis2-overlay.dts b/arch/arm/boot/dts/overlays/starvis2-overlay.dts new file mode 100644 index 0000000000000..02f29ef976912 --- /dev/null +++ b/arch/arm/boot/dts/overlays/starvis2-overlay.dts @@ -0,0 +1,136 @@ +// SPDX-License-Identifier: GPL-2.0-only +// Definitions for a Sony Starvis2 camera module on VC I2C bus +/dts-v1/; +/plugin/; + +#include + +/{ + compatible = "brcm,bcm2835"; + + fragment@0 { + target = <&i2c0if>; + __overlay__ { + status = "okay"; + }; + }; + + clk_frag: fragment@1 { + target = <&cam1_clk>; + clk: __overlay__ { + status = "okay"; + clock-frequency = <24000000>; + }; + }; + + fragment@2 { + target = <&i2c0mux>; + __overlay__ { + status = "okay"; + }; + }; + + reg_frag: fragment@3 { + target = <&cam1_reg>; + cam_reg: __overlay__ { + startup-delay-us = <300000>; + }; + }; + + i2c_frag: fragment@100 { + target = <&i2c_csi_dsi>; + __overlay__ { + #address-cells = <1>; + #size-cells = <0>; + status = "okay"; + + #include "starvis2.dtsi" + + vcm: ad5398@c { + compatible = "adi,ad5398"; + reg = <0x0c>; + status = "disabled"; + VANA-supply = <&cam1_reg>; + }; + }; + }; + + csi_frag: fragment@101 { + target = <&csi1>; + csi: __overlay__ { + status = "okay"; + + port { + csi_ep: endpoint { + remote-endpoint = <&cam_endpoint>; + clock-lanes = <0>; + data-lanes = <1 2>; + clock-noncontinuous; + }; + }; + }; + }; + + fragment@102 { + target = <&csi1>; + __dormant__ { + compatible = "brcm,bcm2835-unicam-legacy"; + }; + }; + + fragment@201 { + target = <&csi_ep>; + __dormant__ { + data-lanes = <1 2 3 4>; + }; + }; + + fragment@202 { + target = <&cam_endpoint>; + __dormant__ { + data-lanes = <1 2 3 4>; + }; + }; + + fragment@203 { + target = <&cam_endpoint>; + __dormant__ { + link-frequencies = /bits/ 64 + <1039500000 + 891000000 + 720000000 + 594000000 + 445500000 + 360000000 + 297000000>; + }; + }; + + __overrides__ { + rotation = <&cam_node>,"rotation:0"; + orientation = <&cam_node>,"orientation:0"; + media-controller = <0>,"!102"; + cam0 = <&i2c_frag>, "target:0=",<&i2c_csi_dsi0>, + <&csi_frag>, "target:0=",<&csi0>, + <&clk_frag>, "target:0=",<&cam0_clk>, + <&cam_node>, "clocks:0=",<&cam0_clk>, + <®_frag>, "target:0=",<&cam0_reg>, + <&cam_node>, "avdd-supply:0=",<&cam0_reg>, + <&vcm>, "VANA-supply:0=", <&cam0_reg>; + vcm = <&vcm>, "status=okay", + <&cam_node>,"lens-focus:0=", <&vcm>; + 4lane = <0>, "+201+202"; + clock-frequency = <&clk>,"clock-frequency:0"; + link-frequency = <&cam_endpoint>,"link-frequencies#0"; + all-link-frequencies = <0>, "+203"; + compatible = <&cam_node>,"compatible"; + }; +}; + +&cam_node { + status = "okay"; +}; + +&cam_endpoint { + remote-endpoint = <&csi_ep>; +}; diff --git a/arch/arm/boot/dts/overlays/starvis2.dtsi b/arch/arm/boot/dts/overlays/starvis2.dtsi new file mode 100644 index 0000000000000..d2947cad4be44 --- /dev/null +++ b/arch/arm/boot/dts/overlays/starvis2.dtsi @@ -0,0 +1,26 @@ +// Fragment that configures a Sony Starvis 2 image sensor + +cam_node: starvis2@1a { + compatible = "sony,starvis2"; + reg = <0x1a>; + status = "disabled"; + + clocks = <&cam1_clk>; + + avdd-supply = <&cam1_reg>; /* 2.8v */ + dvdd-supply = <&cam_dummy_reg>; /* 1.8v */ + ovdd-supply = <&cam_dummy_reg>;/* 1.2v */ + + rotation = <180>; + orientation = <2>; + + port { + cam_endpoint: endpoint { + clock-lanes = <0>; + data-lanes = <1 2>; + clock-noncontinuous; + link-frequencies = + /bits/ 64 <594000000>; + }; + }; +}; From 78c9ff73a38f2041e7093b76314adafbec76daad Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Mon, 21 Sep 2026 12:16:28 +0100 Subject: [PATCH 16/18] dtoverlays: Add an overlay for the Sony imx662 image sensor Signed-off-by: Dave Stevenson --- arch/arm/boot/dts/overlays/Makefile | 1 + arch/arm/boot/dts/overlays/README | 33 +++++++++++++++++++ arch/arm/boot/dts/overlays/imx662-overlay.dts | 1 + 3 files changed, 35 insertions(+) create mode 100644 arch/arm/boot/dts/overlays/imx662-overlay.dts diff --git a/arch/arm/boot/dts/overlays/Makefile b/arch/arm/boot/dts/overlays/Makefile index 38a886a359001..688e3f786b736 100644 --- a/arch/arm/boot/dts/overlays/Makefile +++ b/arch/arm/boot/dts/overlays/Makefile @@ -157,6 +157,7 @@ dtbo-$(CONFIG_ARCH_BCM2835) += \ imx500.dtbo \ imx500-pi5.dtbo \ imx519.dtbo \ + imx662.dtbo \ imx708.dtbo \ interludeaudio-analog.dtbo \ interludeaudio-digital.dtbo \ diff --git a/arch/arm/boot/dts/overlays/README b/arch/arm/boot/dts/overlays/README index e511331caa94c..dae2f9a3efdb4 100644 --- a/arch/arm/boot/dts/overlays/README +++ b/arch/arm/boot/dts/overlays/README @@ -3278,6 +3278,39 @@ Params: rotation Mounting rotation of the camera sensor (0 or but vcm=off will disable. +Name: imx662 +Info: Sony imx662 camera module. + Uses Unicam 1, which is the standard camera connector on most Pi + variants. +Load: dtoverlay=imx662, +Params: 4lane Enable 4 CSI2 data lanes (default is for 2 lane + operation), which requires a Pi5 or CM. + clock-frequency Sets the clock frequency to match that used on + the board. + Valid values are 24, 27, 37.125, 72, or + 74.25MHz. + The default is 24MHz. + link-frequency Confgures the link frequency to be used. Note + that the permitted values vary based on + clock-frequency and number of lanes. + The default is 445.5MHz for 891Mbit/s. + all-link-frequencies Define all permitted link frequencies to allow + for user selection of the preferred rate. + Does NOT include 1188Mbit/s as that is not + reliable. + orientation Sensor orientation (0 = front, 1 = rear, + 2 = external, default external) + rotation Mounting rotation of the camera sensor (0 or + 180, default 0) + media-controller Configure use of Media Controller API for + configuring the sensor (default on) + cam0 Adopt the default configuration for CAM0 on a + Compute Module (CSI0, i2c_vc, and cam0_reg). + vcm Enable ad5398 VCM associated with the sensor. + compatible Allows overriding of the compatible if automatic + detection at probe is undesirable. + + Name: imx708 Info: Sony IMX708 camera module. Uses Unicam 1, which is the standard camera connector on most Pi diff --git a/arch/arm/boot/dts/overlays/imx662-overlay.dts b/arch/arm/boot/dts/overlays/imx662-overlay.dts new file mode 100644 index 0000000000000..939b643f97e6e --- /dev/null +++ b/arch/arm/boot/dts/overlays/imx662-overlay.dts @@ -0,0 +1 @@ +#include "starvis2-overlay.dts" From a4b5bf47c12283668343726a823228f10763af6e Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Tue, 15 Sep 2026 18:09:45 +0100 Subject: [PATCH 17/18] media: sony-starvis2: Add support for HCG mode HCG (High Conversion Gain) adds additional gain within the sensor, but also requires that the minimum analogue gain is 34 rather than 0 when in the default LCG mode. Add a module parameter that is read during probe and at the start of enable_streams, and adjust settings accordingly. Signed-off-by: Dave Stevenson --- drivers/media/i2c/sony-starvis2.c | 41 ++++++++++++++++++++++++++++--- 1 file changed, 37 insertions(+), 4 deletions(-) diff --git a/drivers/media/i2c/sony-starvis2.c b/drivers/media/i2c/sony-starvis2.c index a7d374d9aef90..c15c11b63c17b 100644 --- a/drivers/media/i2c/sony-starvis2.c +++ b/drivers/media/i2c/sony-starvis2.c @@ -27,6 +27,7 @@ #include #include #include +#include #include #include #include @@ -38,6 +39,10 @@ #include #include +static bool hcg_mode; +module_param(hcg_mode, bool, 0664); +MODULE_PARM_DESC(hcg_mode, "Enable HCG mode"); + /* Standby or streaming mode */ #define STARVIS2_REG_MODE_SELECT CCI_REG8(0x3000) #define STARVIS2_MODE_STANDBY 0x01 @@ -84,10 +89,14 @@ */ #define STARVIS2_REG_GAIN CCI_REG16_LE(0x3070) #define STARVIS2_ANA_GAIN_MIN_NORMAL 0 +#define STARVIS2_ANA_GAIN_MIN_HCG 34 #define STARVIS2_ANA_GAIN_MAX_NORMAL 100 #define STARVIS2_ANA_GAIN_STEP 1 #define STARVIS2_ANA_GAIN_DEFAULT 0 +#define STARVIS2_REG_FDG_SEL0 CCI_REG8(0x3030) +#define STARVIS2_FDG_SEL0_HCG BIT(0) + /* Crop */ #define STARVIS2_REG_WINMODE CCI_REG8(0x3018) #define STARVIS2_REG_PIX_HST CCI_REG16_LE(0x303c) @@ -1647,6 +1656,8 @@ struct starvis2 { struct v4l2_ctrl *vblank; struct v4l2_ctrl *hblank; struct v4l2_ctrl *link_freq; + struct v4l2_ctrl *gain; + bool hcg_mode; /* Track VMAX for exposure updates */ u32 vmax; @@ -1925,6 +1936,17 @@ static int starvis2_enable_streams(struct v4l2_subdev *sd, if (ret < 0) return ret; + starvis2->hcg_mode = hcg_mode; + __v4l2_ctrl_modify_range(starvis2->gain, + starvis2->hcg_mode ? + STARVIS2_ANA_GAIN_MIN_HCG : + STARVIS2_ANA_GAIN_MIN_NORMAL, + STARVIS2_ANA_GAIN_MAX_NORMAL, + STARVIS2_ANA_GAIN_STEP, + starvis2->hcg_mode ? + STARVIS2_ANA_GAIN_MIN_HCG : + STARVIS2_ANA_GAIN_DEFAULT); + crop = v4l2_subdev_state_get_crop(state, pad); ret = starvis2_program_window(starvis2, crop); if (ret) { @@ -1939,6 +1961,9 @@ static int starvis2_enable_streams(struct v4l2_subdev *sd, goto err_rpm_put; } + cci_write(starvis2->cci, STARVIS2_REG_FDG_SEL0, + starvis2->hcg_mode ? STARVIS2_FDG_SEL0_HCG : 0, &ret); + cci_write(starvis2->cci, STARVIS2_REG_MODE_SELECT, STARVIS2_MODE_STREAMING, &ret); usleep_range(STARVIS2_STREAM_DELAY_US, STARVIS2_STREAM_DELAY_US + @@ -2221,10 +2246,16 @@ static int starvis2_init_controls(struct starvis2 *starvis2) STARVIS2_EXPOSURE_STEP, STARVIS2_EXPOSURE_DEFAULT); - v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, V4L2_CID_ANALOGUE_GAIN, - STARVIS2_ANA_GAIN_MIN_NORMAL, - STARVIS2_ANA_GAIN_MAX_NORMAL, STARVIS2_ANA_GAIN_STEP, - STARVIS2_ANA_GAIN_DEFAULT); + starvis2->gain = v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, + V4L2_CID_ANALOGUE_GAIN, + starvis2->hcg_mode ? + STARVIS2_ANA_GAIN_MIN_HCG : + STARVIS2_ANA_GAIN_MIN_NORMAL, + STARVIS2_ANA_GAIN_MAX_NORMAL, + STARVIS2_ANA_GAIN_STEP, + starvis2->hcg_mode ? + STARVIS2_ANA_GAIN_MIN_HCG : + STARVIS2_ANA_GAIN_DEFAULT); v4l2_ctrl_new_std(ctrl_hdlr, &starvis2_ctrl_ops, V4L2_CID_HFLIP, 0, 1, 1, 0); @@ -2363,6 +2394,8 @@ static int starvis2_probe(struct i2c_client *client) pm_runtime_set_active(dev); pm_runtime_enable(dev); + starvis2->hcg_mode = hcg_mode; + ret = starvis2_init_controls(starvis2); if (ret) goto error_pm_runtime; From 8343b64ccb703f64d28035fc90f499a580c417e8 Mon Sep 17 00:00:00 2001 From: Dave Stevenson Date: Wed, 16 Sep 2026 16:52:45 +0100 Subject: [PATCH 18/18] media: sony-starvis2: Allow the use of on sensor digital gain Whilst normally digital gain would be applied in the ISP, there are some situations where it is an advantage to allow the use of the on-sensor digital gain too. Allow it. Signed-off-by: Dave Stevenson --- drivers/media/i2c/sony-starvis2.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/drivers/media/i2c/sony-starvis2.c b/drivers/media/i2c/sony-starvis2.c index c15c11b63c17b..39d1a226a06de 100644 --- a/drivers/media/i2c/sony-starvis2.c +++ b/drivers/media/i2c/sony-starvis2.c @@ -82,15 +82,15 @@ MODULE_PARM_DESC(hcg_mode, "Enable HCG mode"); #define STARVIS2_EXPOSURE_DEFAULT 1000 /* - * Analogue gain control - * Range is from 0 to 100 (0dB - 30dB) with 0.3dB step size + * Gain control + * Range is from 0 to 100 (0dB - 30dB) analogue gain with 0.3dB step size * Values from 101 to 240 are valid but correspond to additional digital gain - * (0.3dB - 42dB) so don't expose it to userspace + * (0.3dB - 42dB). */ #define STARVIS2_REG_GAIN CCI_REG16_LE(0x3070) #define STARVIS2_ANA_GAIN_MIN_NORMAL 0 #define STARVIS2_ANA_GAIN_MIN_HCG 34 -#define STARVIS2_ANA_GAIN_MAX_NORMAL 100 +#define STARVIS2_ANA_GAIN_MAX_NORMAL 240 #define STARVIS2_ANA_GAIN_STEP 1 #define STARVIS2_ANA_GAIN_DEFAULT 0