* [PATCH 0/3] media: Add Sony IMX175 sensor driver (Lenovo ThinkPad 10 rear camera)
@ 2026-11-16 17:51 Volodymyr Chapman
2026-11-16 17:51 ` [PATCH 1/3] media: i2c: Add Sony IMX175 sensor driver Volodymyr Chapman
` (3 more replies)
0 siblings, 4 replies; 8+ messages in thread
From: Volodymyr Chapman @ 2026-11-16 17:51 UTC (permalink / raw)
To: Sakari Ailus, Mauro Carvalho Chehab
Cc: Dan Scally, Hans de Goede, Andy Shevchenko, Greg Kroah-Hartman,
linux-media, linux-staging, linux-kernel, Volodymyr Chapman
This series adds support for the Sony IMX175 8 Mpixel raw sensor, the
rear camera of the Lenovo ThinkPad 10 (20C1/20C3, Bay Trail), using the
atomisp driver through its v4l2-async csi2-bridge path:
1. a new standard sensor driver, drivers/media/i2c/imx175.c;
2. the INTCF1A ACPI HID in ipu-bridge;
3. a 4-lane sensor config entry for INTCF1A in the atomisp csi2-bridge.
Notes for testing on this machine:
- The firmware exposes the ISP in "ACPI mode" by default (subdevice of
the IGD), which atomisp does not support. The hidden BIOS setup option
"ISP PCI Device Selection" (Setup variable offset 0x235, value 2 =
"ISP PCI Device as B0D3F0") must be set for the ISP to appear as PCI
device 00:03.0.
- The IMX175 probe fails intermittently at boot (-EREMOTEIO) without
"media: atomisp: csi2-bridge: Don't cycle the PMC clock if its rate is
correct", sent separately [1]. With it, the probe succeeded on 10 out
of 10 boots in my testing; without it on 8 out of 10.
- The OV2722 front camera of the same machine needs "media: atomisp:
ov2722: Report SGRBG10 consistently as media bus code", also sent
separately [2], but is not otherwise related to this series.
[1] https://lore.kernel.org/linux-media/20261116173307.14169-1-volodymyrchapman@gmail.com/
[2] https://lore.kernel.org/linux-media/20261116173143.13584-1-volodymyrchapman@gmail.com/
Testing, on a media.git next kernel (3fc9303dba01) with this series and
the two patches above, on a ThinkPad 10 20C3 (Atom Z3795):
- the binned 1640x1232 mode streams through atomisp, alternating with
the front camera; the full 3280x2464 mode was tested as a still
capture, as atomisp limits continuous capture to 1920 pixels wide;
- the sensor's colour bar test pattern and real scenes have the correct
colours, also with horizontal and vertical flip;
- v4l2-compliance 1.32.0 on the IMX175 sub-device: 46 tests, 0 failures,
0 warnings.
Not supported: the voice coil motor (the firmware does not name its
type) and the LM3554 flash.
No DT binding is added, as the sensor is only known to be used on ACPI
systems; one can be added when a DT user appears.
This series was developed with the help of an AI coding assistant
(Claude), which wrote most of the driver code and commit messages based
on Intel's register tables, existing sensor drivers and my testing on
the hardware. I have reviewed the series and tested it as described
above.
Volodymyr Chapman (3):
media: i2c: Add Sony IMX175 sensor driver
media: ipu-bridge: Add Sony IMX175 (INTCF1A)
media: atomisp: csi2-bridge: Add IMX175 sensor config
MAINTAINERS | 7 +
drivers/media/i2c/Kconfig | 10 +
drivers/media/i2c/Makefile | 1 +
drivers/media/i2c/imx175.c | 797 ++++++++++++++++++
drivers/media/pci/intel/ipu-bridge.c | 2 +
.../media/atomisp/pci/atomisp_csi2_bridge.c | 1 +
6 files changed, 818 insertions(+)
create mode 100644 drivers/media/i2c/imx175.c
base-commit: 3fc9303dba01676c2090768126e5327e341b7761
--
2.43.0
^ permalink raw reply [flat|nested] 8+ messages in thread
* [PATCH 1/3] media: i2c: Add Sony IMX175 sensor driver
2026-11-16 17:51 [PATCH 0/3] media: Add Sony IMX175 sensor driver (Lenovo ThinkPad 10 rear camera) Volodymyr Chapman
@ 2026-11-16 17:51 ` Volodymyr Chapman
2026-11-16 19:25 ` Dave Stevenson
2026-11-16 17:51 ` [PATCH 2/3] media: ipu-bridge: Add Sony IMX175 (INTCF1A) Volodymyr Chapman
` (2 subsequent siblings)
3 siblings, 1 reply; 8+ messages in thread
From: Volodymyr Chapman @ 2026-11-16 17:51 UTC (permalink / raw)
To: Sakari Ailus, Mauro Carvalho Chehab
Cc: Dan Scally, Hans de Goede, Andy Shevchenko, Greg Kroah-Hartman,
linux-media, linux-staging, linux-kernel, Volodymyr Chapman
Add a V4L2 sub-device driver for the Sony IMX175, an 8 Mpixel raw Bayer
image sensor with a 4-lane MIPI CSI-2 interface. It is used for example
as the rear camera of the Lenovo ThinkPad 10 (20C1/20C3), where ACPI
describes it as INTCF1A.
The driver supports a 3280x2464 mode and a 2x2 binned 1640x1232 mode,
both at about 30 fps, with a 19.2 MHz external clock and a 320 MHz link
frequency on 4 data lanes (RAW10). It implements exposure, analogue and
digital gain, vertical blanking, horizontal and vertical flip (which
change the Bayer order), the SMIA test patterns and runtime PM.
The register settings are derived from the IMX175 support in Intel's
atomisp imx driver (drivers/staging/media/atomisp/i2c/imx/imx175.h),
which was added in commit a49d25364dfb ("staging/atomisp: Add support for
the Intel IPU v2") and removed in commit 3a81c7660f80 ("media: staging:
atomisp: Remove IMX sensor support").
The voice coil motor and the LM3554 flash on the ThinkPad 10 camera
module are not supported.
Tested on a Lenovo ThinkPad 10 (20C3, Atom Z3795) with atomisp, on a
media.git next kernel with the other two patches of this series:
- the binned mode streams; the colour bar test pattern comes out in the
correct colour order, and real scenes have plausible colours;
- v4l2-compliance 1.32.0 on the sensor sub-device: 46 tests, 0 failures,
0 warnings;
- horizontal and vertical flip mirror the image with correct colours
through atomisp, and VIDIOC_SUBDEV_G_FMT reports the same Bayer order
as VIDIOC_SUBDEV_ENUM_MBUS_CODE for all four flip combinations (the
test pattern itself is not affected by the flips);
- the 3280x2464 mode was tested as a single still capture, as atomisp
limits continuous capture to 1920 pixels wide.
This driver was written with the help of an AI coding assistant (Claude),
based on the register tables mentioned above and on existing sensor
drivers; it was tested on the hardware by the submitter.
Signed-off-by: Volodymyr Chapman <volodymyrchapman@gmail.com>
---
MAINTAINERS | 7 +
drivers/media/i2c/Kconfig | 10 +
drivers/media/i2c/Makefile | 1 +
drivers/media/i2c/imx175.c | 797 +++++++++++++++++++++++++++++++++++++
4 files changed, 815 insertions(+)
create mode 100644 drivers/media/i2c/imx175.c
diff --git a/MAINTAINERS b/MAINTAINERS
index af302622c..286926a01 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -26061,6 +26061,13 @@ S: Maintained
F: drivers/ssb/
F: include/linux/ssb/
+SONY IMX175 SENSOR DRIVER
+M: Volodymyr Chapman <volodymyrchapman@gmail.com>
+L: linux-media@vger.kernel.org
+S: Maintained
+T: git git://linuxtv.org/media.git
+F: drivers/media/i2c/imx175.c
+
SONY IMX208 SENSOR DRIVER
M: Sakari Ailus <sakari.ailus@linux.intel.com>
L: linux-media@vger.kernel.org
diff --git a/drivers/media/i2c/Kconfig b/drivers/media/i2c/Kconfig
index 11c302525..8047a12e2 100644
--- a/drivers/media/i2c/Kconfig
+++ b/drivers/media/i2c/Kconfig
@@ -158,6 +158,16 @@ config VIDEO_IMX111
To compile this driver as a module, choose M here: the
module will be called imx111.
+config VIDEO_IMX175
+ tristate "Sony IMX175 sensor support"
+ select V4L2_CCI_I2C
+ help
+ This is a Video4Linux2 sensor driver for the Sony
+ IMX175 camera.
+
+ To compile this driver as a module, choose M here: the
+ module will be called imx175.
+
config VIDEO_IMX208
tristate "Sony IMX208 sensor support"
help
diff --git a/drivers/media/i2c/Makefile b/drivers/media/i2c/Makefile
index 59e31af45..af107440c 100644
--- a/drivers/media/i2c/Makefile
+++ b/drivers/media/i2c/Makefile
@@ -48,6 +48,7 @@ obj-$(CONFIG_VIDEO_HI847) += hi847.o
obj-$(CONFIG_VIDEO_HM1246) += hm1246.o
obj-$(CONFIG_VIDEO_I2C) += video-i2c.o
obj-$(CONFIG_VIDEO_IMX111) += imx111.o
+obj-$(CONFIG_VIDEO_IMX175) += imx175.o
obj-$(CONFIG_VIDEO_IMX208) += imx208.o
obj-$(CONFIG_VIDEO_IMX214) += imx214.o
obj-$(CONFIG_VIDEO_IMX219) += imx219.o
diff --git a/drivers/media/i2c/imx175.c b/drivers/media/i2c/imx175.c
new file mode 100644
index 000000000..b0b80ddeb
--- /dev/null
+++ b/drivers/media/i2c/imx175.c
@@ -0,0 +1,797 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Sony IMX175 8MP raw image sensor driver
+ *
+ * Register settings derived from the Intel atomisp imx driver
+ * (drivers/staging/media/atomisp/i2c/imx/imx175.h in Linux v4.14),
+ * Copyright (c) 2010-2014 Intel Corporation.
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/gpio/consumer.h>
+#include <linux/i2c.h>
+#include <linux/mod_devicetable.h>
+#include <linux/module.h>
+#include <linux/pm_runtime.h>
+#include <linux/regulator/consumer.h>
+#include <linux/units.h>
+
+#include <media/v4l2-cci.h>
+#include <media/v4l2-common.h>
+#include <media/v4l2-ctrls.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-fwnode.h>
+#include <media/v4l2-subdev.h>
+
+#define IMX175_REG_MODEL_ID CCI_REG16(0x0000)
+#define IMX175_MODEL_ID 0x0175
+#define IMX175_REG_MODE_SELECT CCI_REG8(0x0100)
+#define IMX175_MODE_STANDBY 0x00
+#define IMX175_MODE_STREAMING 0x01
+#define IMX175_REG_ORIENTATION CCI_REG8(0x0101)
+#define IMX175_HFLIP BIT(0)
+#define IMX175_VFLIP BIT(1)
+#define IMX175_REG_SW_RESET CCI_REG8(0x0103)
+#define IMX175_REG_GROUP_HOLD CCI_REG8(0x0104)
+#define IMX175_REG_EXPOSURE CCI_REG16(0x0202)
+#define IMX175_EXPOSURE_MIN 1
+#define IMX175_EXPOSURE_MARGIN 4
+#define IMX175_REG_ANALOG_GAIN CCI_REG8(0x0205)
+#define IMX175_ANA_GAIN_MIN 0
+#define IMX175_ANA_GAIN_MAX 224 /* 256 / (256 - 224) = 8x */
+#define IMX175_ANA_GAIN_DEFAULT 0
+#define IMX175_REG_DGAIN_GR CCI_REG16(0x020e)
+#define IMX175_REG_DGAIN_R CCI_REG16(0x0210)
+#define IMX175_REG_DGAIN_B CCI_REG16(0x0212)
+#define IMX175_REG_DGAIN_GB CCI_REG16(0x0214)
+#define IMX175_DGAIN_MIN 0x0100
+#define IMX175_DGAIN_MAX 0x0fff
+#define IMX175_DGAIN_DEFAULT 0x0100
+#define IMX175_REG_FRAME_LENGTH CCI_REG16(0x0340)
+#define IMX175_FLL_MAX 0xffff
+#define IMX175_REG_LINE_LENGTH CCI_REG16(0x0342)
+#define IMX175_REG_X_OUTPUT_SIZE CCI_REG16(0x034c)
+#define IMX175_REG_Y_OUTPUT_SIZE CCI_REG16(0x034e)
+#define IMX175_REG_BINNING_MODE CCI_REG8(0x0390)
+#define IMX175_REG_TEST_PATTERN CCI_REG16(0x0600)
+
+#define IMX175_XCLK_FREQ (19200 * HZ_PER_KHZ)
+#define IMX175_LINK_FREQ (320 * HZ_PER_MHZ)
+#define IMX175_DATA_LANES 4
+#define IMX175_BPP 10
+/* pixel rate = link freq * 2 (DDR) * lanes / bpp */
+#define IMX175_PIXEL_RATE (IMX175_LINK_FREQ * 2 * IMX175_DATA_LANES / IMX175_BPP)
+
+#define IMX175_NATIVE_WIDTH 3280
+#define IMX175_NATIVE_HEIGHT 2464
+#define IMX175_LLP 3430
+#define IMX175_FLL_DEFAULT 2500
+
+static const char * const imx175_supply_names[] = {
+ "avdd", /* Analog power */
+ "dovdd", /* Digital I/O power */
+ "dvdd", /* Digital core power */
+};
+
+struct imx175_mode {
+ u32 width;
+ u32 height;
+ bool binning;
+ u32 fll_default;
+};
+
+static const struct imx175_mode imx175_modes[] = {
+ {
+ .width = 3280,
+ .height = 2464,
+ .binning = false,
+ .fll_default = IMX175_FLL_DEFAULT,
+ },
+ {
+ .width = 1640,
+ .height = 1232,
+ .binning = true,
+ .fll_default = IMX175_FLL_DEFAULT,
+ },
+};
+
+/* Static settings, applied after a software reset */
+static const struct cci_reg_sequence imx175_init_regs[] = {
+ /* misc control */
+ { CCI_REG8(0x3020), 0x10 },
+ { CCI_REG8(0x302d), 0x02 },
+ { CCI_REG8(0x302f), 0x80 },
+ { CCI_REG8(0x3032), 0xa3 },
+ { CCI_REG8(0x3033), 0x20 },
+ { CCI_REG8(0x3034), 0x24 },
+ { CCI_REG8(0x3041), 0x15 },
+ { CCI_REG8(0x3042), 0x87 },
+ { CCI_REG8(0x3050), 0x35 },
+ { CCI_REG8(0x3056), 0x57 },
+ { CCI_REG8(0x305d), 0x41 },
+ { CCI_REG8(0x3097), 0x69 },
+ { CCI_REG8(0x3109), 0x41 },
+ { CCI_REG8(0x3148), 0x3f },
+ { CCI_REG8(0x330f), 0x07 },
+ /* CSI-2 and INCK */
+ { CCI_REG8(0x3364), 0x00 },
+ { CCI_REG8(0x3368), 0x13 },
+ { CCI_REG8(0x3369), 0x33 },
+ /* ZNR */
+ { CCI_REG8(0x4100), 0x0e },
+ { CCI_REG8(0x4104), 0x32 },
+ { CCI_REG8(0x4105), 0x32 },
+ { CCI_REG8(0x4108), 0x01 },
+ { CCI_REG8(0x4109), 0x7c },
+ { CCI_REG8(0x410a), 0x00 },
+ { CCI_REG8(0x410b), 0x00 },
+ /*
+ * PLL for a 19.2 MHz INCK: pre_pll_clk_div 9, pll multiplier 300,
+ * vt_pix_clk_div 5, vt_sys_clk_div 1, op_pix_clk_div 5,
+ * op_sys_clk_div 1 -> 640 Mbps/lane, 4 lanes.
+ */
+ { CCI_REG8(0x0301), 0x05 },
+ { CCI_REG8(0x0303), 0x01 },
+ { CCI_REG8(0x0305), 0x09 },
+ { CCI_REG8(0x0309), 0x05 },
+ { CCI_REG8(0x030b), 0x01 },
+ { CCI_REG16(0x030c), 0x012c },
+ { CCI_REG8(0x030e), 0x01 },
+ { CCI_REG16(0x0342), IMX175_LLP },
+ /* analog crop: full 3280x2464 array */
+ { CCI_REG16(0x0344), 0 },
+ { CCI_REG16(0x0346), 0 },
+ { CCI_REG16(0x0348), IMX175_NATIVE_WIDTH - 1 },
+ { CCI_REG16(0x034a), IMX175_NATIVE_HEIGHT - 1 },
+ /* no scaling */
+ { CCI_REG8(0x0401), 0x00 },
+ { CCI_REG8(0x0405), 0x10 },
+ /* timer */
+ { CCI_REG8(0x3344), 0x57 },
+ { CCI_REG8(0x3345), 0x1f },
+ /* timing */
+ { CCI_REG8(0x3370), 0x77 },
+ { CCI_REG8(0x3371), 0x2f },
+ { CCI_REG8(0x3372), 0x4f },
+ { CCI_REG8(0x3373), 0x2f },
+ { CCI_REG8(0x3374), 0x2f },
+ { CCI_REG8(0x3375), 0x37 },
+ { CCI_REG8(0x3376), 0x9f },
+ { CCI_REG8(0x3377), 0x37 },
+ { CCI_REG8(0x33c8), 0x01 },
+ { CCI_REG16(0x33d4), IMX175_NATIVE_WIDTH },
+ { CCI_REG16(0x33d6), IMX175_NATIVE_HEIGHT },
+ { CCI_REG8(0x41c0), 0x01 },
+};
+
+static const s64 imx175_link_freqs[] = {
+ IMX175_LINK_FREQ,
+};
+
+static const char * const imx175_test_pattern_menu[] = {
+ "Disabled",
+ "Solid Colour",
+ "Colour Bars",
+ "Fade to Grey Colour Bars",
+ "PN9",
+};
+
+/* RGGB is the native order; flips shift the pattern */
+static const u32 imx175_mbus_codes[] = {
+ MEDIA_BUS_FMT_SRGGB10_1X10, /* no flip */
+ MEDIA_BUS_FMT_SGRBG10_1X10, /* hflip */
+ MEDIA_BUS_FMT_SGBRG10_1X10, /* vflip */
+ MEDIA_BUS_FMT_SBGGR10_1X10, /* hflip + vflip */
+};
+
+struct imx175 {
+ struct device *dev;
+ struct regmap *regmap;
+ struct clk *xclk;
+ struct gpio_desc *reset;
+ struct regulator_bulk_data supplies[ARRAY_SIZE(imx175_supply_names)];
+
+ struct v4l2_subdev sd;
+ struct media_pad pad;
+
+ struct v4l2_ctrl_handler ctrls;
+ struct v4l2_ctrl *link_freq;
+ struct v4l2_ctrl *pixel_rate;
+ struct v4l2_ctrl *exposure;
+ struct v4l2_ctrl *vblank;
+ struct v4l2_ctrl *hblank;
+ struct v4l2_ctrl *hflip;
+ struct v4l2_ctrl *vflip;
+
+ const struct imx175_mode *mode;
+};
+
+static inline struct imx175 *to_imx175(struct v4l2_subdev *sd)
+{
+ return container_of(sd, struct imx175, sd);
+}
+
+static u32 imx175_mbus_code(struct imx175 *imx175)
+{
+ unsigned int idx = 0;
+
+ if (imx175->hflip && imx175->hflip->val)
+ idx |= 1;
+ if (imx175->vflip && imx175->vflip->val)
+ idx |= 2;
+
+ return imx175_mbus_codes[idx];
+}
+
+static void imx175_update_pad_format(struct imx175 *imx175,
+ const struct imx175_mode *mode,
+ struct v4l2_mbus_framefmt *fmt)
+{
+ fmt->width = mode->width;
+ fmt->height = mode->height;
+ fmt->code = imx175_mbus_code(imx175);
+ fmt->field = V4L2_FIELD_NONE;
+ fmt->colorspace = V4L2_COLORSPACE_RAW;
+ fmt->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
+ fmt->quantization = V4L2_QUANTIZATION_FULL_RANGE;
+ fmt->xfer_func = V4L2_XFER_FUNC_NONE;
+}
+
+static int imx175_set_ctrl(struct v4l2_ctrl *ctrl)
+{
+ struct imx175 *imx175 = container_of(ctrl->handler, struct imx175, ctrls);
+ int ret = 0;
+
+ if (ctrl->id == V4L2_CID_VBLANK) {
+ s64 max = imx175->mode->height + ctrl->val - IMX175_EXPOSURE_MARGIN;
+
+ ret = __v4l2_ctrl_modify_range(imx175->exposure,
+ imx175->exposure->minimum, max,
+ imx175->exposure->step,
+ min(imx175->exposure->default_value, max));
+ if (ret)
+ return ret;
+ }
+
+ /* Flips change the Bayer order, keep the active format in sync */
+ if (ctrl->id == V4L2_CID_HFLIP || ctrl->id == V4L2_CID_VFLIP) {
+ struct v4l2_subdev_state *state =
+ v4l2_subdev_get_locked_active_state(&imx175->sd);
+
+ v4l2_subdev_state_get_format(state, 0)->code =
+ imx175_mbus_code(imx175);
+ }
+
+ if (!pm_runtime_get_if_in_use(imx175->dev))
+ return 0;
+
+ switch (ctrl->id) {
+ case V4L2_CID_EXPOSURE:
+ cci_write(imx175->regmap, IMX175_REG_EXPOSURE, ctrl->val, &ret);
+ break;
+ case V4L2_CID_ANALOGUE_GAIN:
+ cci_write(imx175->regmap, IMX175_REG_ANALOG_GAIN, ctrl->val, &ret);
+ break;
+ case V4L2_CID_DIGITAL_GAIN:
+ cci_write(imx175->regmap, IMX175_REG_DGAIN_GR, ctrl->val, &ret);
+ cci_write(imx175->regmap, IMX175_REG_DGAIN_R, ctrl->val, &ret);
+ cci_write(imx175->regmap, IMX175_REG_DGAIN_B, ctrl->val, &ret);
+ cci_write(imx175->regmap, IMX175_REG_DGAIN_GB, ctrl->val, &ret);
+ break;
+ case V4L2_CID_VBLANK:
+ cci_write(imx175->regmap, IMX175_REG_FRAME_LENGTH,
+ imx175->mode->height + ctrl->val, &ret);
+ break;
+ case V4L2_CID_HFLIP:
+ case V4L2_CID_VFLIP:
+ cci_write(imx175->regmap, IMX175_REG_ORIENTATION,
+ (imx175->hflip->val ? IMX175_HFLIP : 0) |
+ (imx175->vflip->val ? IMX175_VFLIP : 0), &ret);
+ break;
+ case V4L2_CID_TEST_PATTERN:
+ cci_write(imx175->regmap, IMX175_REG_TEST_PATTERN, ctrl->val, &ret);
+ break;
+ default:
+ ret = -EINVAL;
+ break;
+ }
+
+ pm_runtime_put(imx175->dev);
+ return ret;
+}
+
+static const struct v4l2_ctrl_ops imx175_ctrl_ops = {
+ .s_ctrl = imx175_set_ctrl,
+};
+
+static int imx175_init_controls(struct imx175 *imx175)
+{
+ const struct imx175_mode *mode = &imx175_modes[0];
+ struct v4l2_ctrl_handler *hdl = &imx175->ctrls;
+ struct v4l2_fwnode_device_properties props;
+ s64 vblank_def, hblank, exposure_max;
+ int ret;
+
+ ret = v4l2_fwnode_device_parse(imx175->dev, &props);
+ if (ret)
+ return ret;
+
+ v4l2_ctrl_handler_init(hdl, 12);
+
+ imx175->link_freq = v4l2_ctrl_new_int_menu(hdl, &imx175_ctrl_ops,
+ V4L2_CID_LINK_FREQ,
+ ARRAY_SIZE(imx175_link_freqs) - 1,
+ 0, imx175_link_freqs);
+ if (imx175->link_freq)
+ imx175->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY;
+
+ imx175->pixel_rate = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops,
+ V4L2_CID_PIXEL_RATE,
+ IMX175_PIXEL_RATE, IMX175_PIXEL_RATE,
+ 1, IMX175_PIXEL_RATE);
+
+ vblank_def = mode->fll_default - mode->height;
+ imx175->vblank = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_VBLANK,
+ IMX175_EXPOSURE_MARGIN,
+ IMX175_FLL_MAX - mode->height, 1,
+ vblank_def);
+
+ hblank = IMX175_LLP - mode->width;
+ imx175->hblank = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_HBLANK,
+ hblank, hblank, 1, hblank);
+ if (imx175->hblank)
+ imx175->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY;
+
+ exposure_max = mode->fll_default - IMX175_EXPOSURE_MARGIN;
+ imx175->exposure = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops,
+ V4L2_CID_EXPOSURE,
+ IMX175_EXPOSURE_MIN, exposure_max, 1,
+ exposure_max);
+
+ v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_ANALOGUE_GAIN,
+ IMX175_ANA_GAIN_MIN, IMX175_ANA_GAIN_MAX, 1,
+ IMX175_ANA_GAIN_DEFAULT);
+
+ v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_DIGITAL_GAIN,
+ IMX175_DGAIN_MIN, IMX175_DGAIN_MAX, 1,
+ IMX175_DGAIN_DEFAULT);
+
+ imx175->hflip = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_HFLIP,
+ 0, 1, 1, 0);
+ if (imx175->hflip)
+ imx175->hflip->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT;
+
+ imx175->vflip = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_VFLIP,
+ 0, 1, 1, 0);
+ if (imx175->vflip)
+ imx175->vflip->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT;
+
+ v4l2_ctrl_new_std_menu_items(hdl, &imx175_ctrl_ops, V4L2_CID_TEST_PATTERN,
+ ARRAY_SIZE(imx175_test_pattern_menu) - 1,
+ 0, 0, imx175_test_pattern_menu);
+
+ v4l2_ctrl_new_fwnode_properties(hdl, &imx175_ctrl_ops, &props);
+
+ if (hdl->error) {
+ ret = hdl->error;
+ v4l2_ctrl_handler_free(hdl);
+ return ret;
+ }
+
+ imx175->sd.ctrl_handler = hdl;
+ return 0;
+}
+
+static int imx175_enable_streams(struct v4l2_subdev *sd,
+ struct v4l2_subdev_state *state, u32 pad,
+ u64 streams_mask)
+{
+ struct imx175 *imx175 = to_imx175(sd);
+ const struct imx175_mode *mode = imx175->mode;
+ int ret;
+
+ ret = pm_runtime_resume_and_get(imx175->dev);
+ if (ret)
+ return ret;
+
+ ret = cci_write(imx175->regmap, IMX175_REG_SW_RESET, 0x01, NULL);
+ if (ret)
+ goto err_put;
+ usleep_range(5000, 6000);
+
+ ret = cci_multi_reg_write(imx175->regmap, imx175_init_regs,
+ ARRAY_SIZE(imx175_init_regs), NULL);
+ cci_write(imx175->regmap, IMX175_REG_X_OUTPUT_SIZE, mode->width, &ret);
+ cci_write(imx175->regmap, IMX175_REG_Y_OUTPUT_SIZE, mode->height, &ret);
+ cci_write(imx175->regmap, IMX175_REG_BINNING_MODE, mode->binning ? 1 : 0,
+ &ret);
+ if (ret)
+ goto err_put;
+
+ ret = __v4l2_ctrl_handler_setup(imx175->sd.ctrl_handler);
+ if (ret)
+ goto err_put;
+
+ ret = cci_write(imx175->regmap, IMX175_REG_MODE_SELECT,
+ IMX175_MODE_STREAMING, NULL);
+ if (ret)
+ goto err_put;
+
+ /* Flips change the Bayer order; don't allow them while streaming */
+ __v4l2_ctrl_grab(imx175->hflip, true);
+ __v4l2_ctrl_grab(imx175->vflip, true);
+ return 0;
+
+err_put:
+ pm_runtime_put(imx175->dev);
+ return ret;
+}
+
+static int imx175_disable_streams(struct v4l2_subdev *sd,
+ struct v4l2_subdev_state *state, u32 pad,
+ u64 streams_mask)
+{
+ struct imx175 *imx175 = to_imx175(sd);
+ int ret;
+
+ ret = cci_write(imx175->regmap, IMX175_REG_MODE_SELECT,
+ IMX175_MODE_STANDBY, NULL);
+
+ __v4l2_ctrl_grab(imx175->hflip, false);
+ __v4l2_ctrl_grab(imx175->vflip, false);
+
+ pm_runtime_put(imx175->dev);
+ return ret;
+}
+
+static int imx175_set_format(struct v4l2_subdev *sd,
+ const struct v4l2_subdev_client_info *ci,
+ struct v4l2_subdev_state *state,
+ struct v4l2_subdev_format *fmt)
+{
+ struct imx175 *imx175 = to_imx175(sd);
+ const struct imx175_mode *mode;
+ struct v4l2_mbus_framefmt *format;
+ int ret;
+
+ mode = v4l2_find_nearest_size(imx175_modes, ARRAY_SIZE(imx175_modes),
+ width, height,
+ fmt->format.width, fmt->format.height);
+
+ imx175_update_pad_format(imx175, mode, &fmt->format);
+ format = v4l2_subdev_state_get_format(state, 0);
+ *format = fmt->format;
+
+ if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
+ return 0;
+
+ imx175->mode = mode;
+
+ ret = __v4l2_ctrl_modify_range(imx175->vblank, IMX175_EXPOSURE_MARGIN,
+ IMX175_FLL_MAX - mode->height, 1,
+ mode->fll_default - mode->height);
+ if (ret)
+ return ret;
+ ret = __v4l2_ctrl_s_ctrl(imx175->vblank, mode->fll_default - mode->height);
+ if (ret)
+ return ret;
+
+ return __v4l2_ctrl_modify_range(imx175->hblank,
+ IMX175_LLP - mode->width,
+ IMX175_LLP - mode->width, 1,
+ IMX175_LLP - mode->width);
+}
+
+static int imx175_enum_mbus_code(struct v4l2_subdev *sd,
+ struct v4l2_subdev_state *state,
+ struct v4l2_subdev_mbus_code_enum *code)
+{
+ if (code->index > 0)
+ return -EINVAL;
+
+ code->code = imx175_mbus_code(to_imx175(sd));
+ return 0;
+}
+
+static int imx175_enum_frame_size(struct v4l2_subdev *sd,
+ struct v4l2_subdev_state *state,
+ struct v4l2_subdev_frame_size_enum *fse)
+{
+ if (fse->index >= ARRAY_SIZE(imx175_modes))
+ return -EINVAL;
+
+ if (fse->code != imx175_mbus_code(to_imx175(sd)))
+ return -EINVAL;
+
+ fse->min_width = imx175_modes[fse->index].width;
+ fse->max_width = fse->min_width;
+ fse->min_height = imx175_modes[fse->index].height;
+ fse->max_height = fse->min_height;
+ return 0;
+}
+
+static int imx175_get_selection(struct v4l2_subdev *sd,
+ const struct v4l2_subdev_client_info *ci,
+ struct v4l2_subdev_state *state,
+ struct v4l2_subdev_selection *sel)
+{
+ switch (sel->target) {
+ case V4L2_SEL_TGT_CROP:
+ case V4L2_SEL_TGT_CROP_DEFAULT:
+ case V4L2_SEL_TGT_CROP_BOUNDS:
+ case V4L2_SEL_TGT_NATIVE_SIZE:
+ sel->r.left = 0;
+ sel->r.top = 0;
+ sel->r.width = IMX175_NATIVE_WIDTH;
+ sel->r.height = IMX175_NATIVE_HEIGHT;
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static int imx175_init_state(struct v4l2_subdev *sd,
+ struct v4l2_subdev_state *state)
+{
+ struct v4l2_subdev_format fmt = {
+ .which = V4L2_SUBDEV_FORMAT_TRY,
+ .pad = 0,
+ .format = {
+ .width = imx175_modes[0].width,
+ .height = imx175_modes[0].height,
+ },
+ };
+
+ return imx175_set_format(sd, NULL, state, &fmt);
+}
+
+static const struct v4l2_subdev_video_ops imx175_video_ops = {
+ .s_stream = v4l2_subdev_s_stream_helper,
+};
+
+static const struct v4l2_subdev_pad_ops imx175_pad_ops = {
+ .enum_mbus_code = imx175_enum_mbus_code,
+ .enum_frame_size = imx175_enum_frame_size,
+ .get_fmt = v4l2_subdev_get_fmt,
+ .set_fmt = imx175_set_format,
+ .get_selection = imx175_get_selection,
+ .enable_streams = imx175_enable_streams,
+ .disable_streams = imx175_disable_streams,
+};
+
+static const struct v4l2_subdev_ops imx175_subdev_ops = {
+ .video = &imx175_video_ops,
+ .pad = &imx175_pad_ops,
+};
+
+static const struct v4l2_subdev_internal_ops imx175_internal_ops = {
+ .init_state = imx175_init_state,
+};
+
+static int imx175_power_on(struct device *dev)
+{
+ struct v4l2_subdev *sd = dev_get_drvdata(dev);
+ struct imx175 *imx175 = to_imx175(sd);
+ int ret;
+
+ ret = regulator_bulk_enable(ARRAY_SIZE(imx175->supplies),
+ imx175->supplies);
+ if (ret)
+ return ret;
+
+ ret = clk_prepare_enable(imx175->xclk);
+ if (ret) {
+ regulator_bulk_disable(ARRAY_SIZE(imx175->supplies),
+ imx175->supplies);
+ return ret;
+ }
+
+ usleep_range(1000, 2000);
+ gpiod_set_value_cansleep(imx175->reset, 0);
+ /* Wait for the sensor to come out of reset before using I2C */
+ usleep_range(10000, 12000);
+
+ return 0;
+}
+
+static int imx175_power_off(struct device *dev)
+{
+ struct v4l2_subdev *sd = dev_get_drvdata(dev);
+ struct imx175 *imx175 = to_imx175(sd);
+
+ gpiod_set_value_cansleep(imx175->reset, 1);
+ clk_disable_unprepare(imx175->xclk);
+ regulator_bulk_disable(ARRAY_SIZE(imx175->supplies), imx175->supplies);
+
+ return 0;
+}
+
+static int imx175_identify(struct imx175 *imx175)
+{
+ u64 id;
+ int ret;
+
+ ret = cci_read(imx175->regmap, IMX175_REG_MODEL_ID, &id, NULL);
+ if (ret)
+ return dev_err_probe(imx175->dev, ret, "failed to read model id\n");
+
+ if (id != IMX175_MODEL_ID)
+ return dev_err_probe(imx175->dev, -ENODEV,
+ "unexpected model id 0x%04llx\n", id);
+
+ return 0;
+}
+
+static int imx175_check_hwcfg(struct imx175 *imx175)
+{
+ struct v4l2_fwnode_endpoint bus_cfg = {
+ .bus_type = V4L2_MBUS_CSI2_DPHY,
+ };
+ struct fwnode_handle *ep;
+ unsigned long link_freq_bitmap;
+ int ret;
+
+ /* The endpoint is created by ipu-bridge on ACPI systems */
+ ep = fwnode_graph_get_endpoint_by_id(dev_fwnode(imx175->dev), 0, 0, 0);
+ if (!ep)
+ return dev_err_probe(imx175->dev, -EPROBE_DEFER,
+ "waiting for fwnode graph endpoint\n");
+
+ ret = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg);
+ fwnode_handle_put(ep);
+ if (ret)
+ return dev_err_probe(imx175->dev, ret, "parsing endpoint\n");
+
+ if (bus_cfg.bus.mipi_csi2.num_data_lanes != IMX175_DATA_LANES) {
+ ret = dev_err_probe(imx175->dev, -EINVAL,
+ "%u data lanes not supported\n",
+ bus_cfg.bus.mipi_csi2.num_data_lanes);
+ goto out;
+ }
+
+ ret = v4l2_link_freq_to_bitmap(imx175->dev, bus_cfg.link_frequencies,
+ bus_cfg.nr_of_link_frequencies,
+ imx175_link_freqs,
+ ARRAY_SIZE(imx175_link_freqs),
+ &link_freq_bitmap);
+out:
+ v4l2_fwnode_endpoint_free(&bus_cfg);
+ return ret;
+}
+
+static int imx175_probe(struct i2c_client *client)
+{
+ struct device *dev = &client->dev;
+ struct imx175 *imx175;
+ unsigned long rate;
+ unsigned int i;
+ int ret;
+
+ imx175 = devm_kzalloc(dev, sizeof(*imx175), GFP_KERNEL);
+ if (!imx175)
+ return -ENOMEM;
+
+ imx175->dev = dev;
+ imx175->mode = &imx175_modes[0];
+
+ ret = imx175_check_hwcfg(imx175);
+ if (ret)
+ return ret;
+
+ imx175->regmap = devm_cci_regmap_init_i2c(client, 16);
+ if (IS_ERR(imx175->regmap))
+ return PTR_ERR(imx175->regmap);
+
+ imx175->xclk = devm_v4l2_sensor_clk_get(dev, NULL);
+ if (IS_ERR(imx175->xclk))
+ return dev_err_probe(dev, PTR_ERR(imx175->xclk),
+ "failed to get xclk\n");
+
+ rate = clk_get_rate(imx175->xclk);
+ if (rate != IMX175_XCLK_FREQ)
+ return dev_err_probe(dev, -EINVAL,
+ "unsupported xclk rate %lu Hz\n", rate);
+
+ imx175->reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
+ if (IS_ERR(imx175->reset))
+ return dev_err_probe(dev, PTR_ERR(imx175->reset),
+ "failed to get reset gpio\n");
+
+ for (i = 0; i < ARRAY_SIZE(imx175_supply_names); i++)
+ imx175->supplies[i].supply = imx175_supply_names[i];
+
+ ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(imx175->supplies),
+ imx175->supplies);
+ if (ret)
+ return dev_err_probe(dev, ret, "failed to get regulators\n");
+
+ v4l2_i2c_subdev_init(&imx175->sd, client, &imx175_subdev_ops);
+ imx175->sd.internal_ops = &imx175_internal_ops;
+
+ ret = imx175_power_on(dev);
+ if (ret)
+ return ret;
+
+ ret = imx175_identify(imx175);
+ if (ret)
+ goto err_power_off;
+
+ ret = imx175_init_controls(imx175);
+ if (ret)
+ goto err_power_off;
+
+ imx175->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
+ imx175->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
+ imx175->pad.flags = MEDIA_PAD_FL_SOURCE;
+
+ ret = media_entity_pads_init(&imx175->sd.entity, 1, &imx175->pad);
+ if (ret)
+ goto err_free_ctrls;
+
+ imx175->sd.state_lock = imx175->ctrls.lock;
+ ret = v4l2_subdev_init_finalize(&imx175->sd);
+ if (ret)
+ goto err_entity_cleanup;
+
+ pm_runtime_set_active(dev);
+ pm_runtime_enable(dev);
+
+ ret = v4l2_async_register_subdev_sensor(&imx175->sd);
+ if (ret)
+ goto err_pm;
+
+ pm_runtime_idle(dev);
+ return 0;
+
+err_pm:
+ pm_runtime_disable(dev);
+ pm_runtime_set_suspended(dev);
+ v4l2_subdev_cleanup(&imx175->sd);
+err_entity_cleanup:
+ media_entity_cleanup(&imx175->sd.entity);
+err_free_ctrls:
+ v4l2_ctrl_handler_free(&imx175->ctrls);
+err_power_off:
+ imx175_power_off(dev);
+ return ret;
+}
+
+static void imx175_remove(struct i2c_client *client)
+{
+ struct v4l2_subdev *sd = i2c_get_clientdata(client);
+ struct imx175 *imx175 = to_imx175(sd);
+
+ v4l2_async_unregister_subdev(sd);
+ v4l2_subdev_cleanup(sd);
+ media_entity_cleanup(&sd->entity);
+ v4l2_ctrl_handler_free(&imx175->ctrls);
+
+ pm_runtime_disable(&client->dev);
+ if (!pm_runtime_status_suspended(&client->dev))
+ imx175_power_off(&client->dev);
+ pm_runtime_set_suspended(&client->dev);
+}
+
+static DEFINE_RUNTIME_DEV_PM_OPS(imx175_pm_ops, imx175_power_off,
+ imx175_power_on, NULL);
+
+static const struct acpi_device_id imx175_acpi_ids[] = {
+ { "INTCF1A" },
+ { }
+};
+MODULE_DEVICE_TABLE(acpi, imx175_acpi_ids);
+
+static struct i2c_driver imx175_i2c_driver = {
+ .driver = {
+ .name = "imx175",
+ .acpi_match_table = imx175_acpi_ids,
+ .pm = pm_ptr(&imx175_pm_ops),
+ },
+ .probe = imx175_probe,
+ .remove = imx175_remove,
+};
+module_i2c_driver(imx175_i2c_driver);
+
+MODULE_DESCRIPTION("Sony IMX175 sensor driver");
+MODULE_LICENSE("GPL");
--
2.43.0
^ permalink raw reply [flat|nested] 8+ messages in thread
* [PATCH 2/3] media: ipu-bridge: Add Sony IMX175 (INTCF1A)
2026-11-16 17:51 [PATCH 0/3] media: Add Sony IMX175 sensor driver (Lenovo ThinkPad 10 rear camera) Volodymyr Chapman
2026-11-16 17:51 ` [PATCH 1/3] media: i2c: Add Sony IMX175 sensor driver Volodymyr Chapman
@ 2026-11-16 17:51 ` Volodymyr Chapman
2026-11-17 9:57 ` Andy Shevchenko
2026-11-16 17:51 ` [PATCH 3/3] media: atomisp: csi2-bridge: Add IMX175 sensor config Volodymyr Chapman
2026-11-17 10:08 ` [PATCH 0/3] media: Add Sony IMX175 sensor driver (Lenovo ThinkPad 10 rear camera) Andy Shevchenko
3 siblings, 1 reply; 8+ messages in thread
From: Volodymyr Chapman @ 2026-11-16 17:51 UTC (permalink / raw)
To: Sakari Ailus, Mauro Carvalho Chehab
Cc: Dan Scally, Hans de Goede, Andy Shevchenko, Greg Kroah-Hartman,
linux-media, linux-staging, linux-kernel, Volodymyr Chapman
Add the ACPI HID which the Lenovo ThinkPad 10 (20C1/20C3) uses for its
Sony IMX175 rear camera, with the 320 MHz link frequency supported by the
imx175 driver, so that ipu-bridge creates the fwnode graph for it. On
this Bay Trail machine ipu-bridge is used through the atomisp
csi2-bridge.
Tested on a Lenovo ThinkPad 10 (20C3) together with the rest of this
series: the IMX175 is found ("Found supported sensor INTCF1A:00") and
streams through atomisp.
This patch was drafted with the help of an AI coding assistant (Claude)
and tested on the hardware by the submitter.
Signed-off-by: Volodymyr Chapman <volodymyrchapman@gmail.com>
---
drivers/media/pci/intel/ipu-bridge.c | 2 ++
1 file changed, 2 insertions(+)
diff --git a/drivers/media/pci/intel/ipu-bridge.c b/drivers/media/pci/intel/ipu-bridge.c
index 5e419c7b9..880b06d71 100644
--- a/drivers/media/pci/intel/ipu-bridge.c
+++ b/drivers/media/pci/intel/ipu-bridge.c
@@ -94,6 +94,8 @@ static const struct ipu_sensor_config ipu_supported_sensors[] = {
IPU_SENSOR_CONFIG("INT3537", 1, 437000000),
/* Lontium lt6911uxe */
IPU_SENSOR_CONFIG("INTC10C5", 0),
+ /* Sony IMX175 */
+ IPU_SENSOR_CONFIG("INTCF1A", 1, 320000000),
/* Omnivision OV01A10 / OV01A1B / OV01A1S */
IPU_SENSOR_CONFIG("OVTI01A0", 1, 400000000),
IPU_SENSOR_CONFIG("OVTI01AB", 1, 400000000),
--
2.43.0
^ permalink raw reply [flat|nested] 8+ messages in thread
* [PATCH 3/3] media: atomisp: csi2-bridge: Add IMX175 sensor config
2026-11-16 17:51 [PATCH 0/3] media: Add Sony IMX175 sensor driver (Lenovo ThinkPad 10 rear camera) Volodymyr Chapman
2026-11-16 17:51 ` [PATCH 1/3] media: i2c: Add Sony IMX175 sensor driver Volodymyr Chapman
2026-11-16 17:51 ` [PATCH 2/3] media: ipu-bridge: Add Sony IMX175 (INTCF1A) Volodymyr Chapman
@ 2026-11-16 17:51 ` Volodymyr Chapman
2026-11-17 10:08 ` [PATCH 0/3] media: Add Sony IMX175 sensor driver (Lenovo ThinkPad 10 rear camera) Andy Shevchenko
3 siblings, 0 replies; 8+ messages in thread
From: Volodymyr Chapman @ 2026-11-16 17:51 UTC (permalink / raw)
To: Sakari Ailus, Mauro Carvalho Chehab
Cc: Dan Scally, Hans de Goede, Andy Shevchenko, Greg Kroah-Hartman,
linux-media, linux-staging, linux-kernel, Volodymyr Chapman
Sensors without an entry in atomisp_sensor_configs[] default to 1 CSI-2
data lane, unless the firmware provides a CsiLanes setting, which the
Lenovo ThinkPad 10 (20C1/20C3) does not. The IMX175 rear camera of this
machine uses 4 lanes, which the imx175 driver requires, so add an entry
for its ACPI HID INTCF1A.
The firmware's own camera _DSM data is consistent with this: it returns
0x0104 for the IMX175 and 0x0101 for the 1-lane OV2722 front camera from
the same method (GUID 918ab242-c37c-450a-9d0f-f47ab97c3dea), which
appears to encode the lane count in the low byte.
The VCM is left disabled: the firmware does not name the VCM type and
driving it has not been tested.
Tested on a Lenovo ThinkPad 10 (20C3) together with the rest of this
series: atomisp configures the primary port for 4 lanes and the IMX175
streams in both of its modes.
This patch was drafted with the help of an AI coding assistant (Claude)
and tested on the hardware by the submitter.
Signed-off-by: Volodymyr Chapman <volodymyrchapman@gmail.com>
---
drivers/staging/media/atomisp/pci/atomisp_csi2_bridge.c | 1 +
1 file changed, 1 insertion(+)
diff --git a/drivers/staging/media/atomisp/pci/atomisp_csi2_bridge.c b/drivers/staging/media/atomisp/pci/atomisp_csi2_bridge.c
index cca91c6d7..239c287ce 100644
--- a/drivers/staging/media/atomisp/pci/atomisp_csi2_bridge.c
+++ b/drivers/staging/media/atomisp/pci/atomisp_csi2_bridge.c
@@ -360,6 +360,7 @@ static const struct acpi_device_id atomisp_sensor_configs[] = {
* an i2c-client for the VCM, so it is disabled for now.
*/
ATOMISP_SENSOR_CONFIG("INT33BE", 2, false), /* OV5693 */
+ ATOMISP_SENSOR_CONFIG("INTCF1A", 4, false), /* IMX175 */
{}
};
--
2.43.0
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH 1/3] media: i2c: Add Sony IMX175 sensor driver
2026-11-16 17:51 ` [PATCH 1/3] media: i2c: Add Sony IMX175 sensor driver Volodymyr Chapman
@ 2026-11-16 19:25 ` Dave Stevenson
2026-11-16 23:09 ` Volodymyr Chapman
0 siblings, 1 reply; 8+ messages in thread
From: Dave Stevenson @ 2026-11-16 19:25 UTC (permalink / raw)
To: Volodymyr Chapman
Cc: Sakari Ailus, Mauro Carvalho Chehab, Dan Scally, Hans de Goede,
Andy Shevchenko, Greg Kroah-Hartman, linux-media, linux-staging,
linux-kernel
Hi Volodymyr
A couple of things jumped out from a very quick read through.
On Mon, 16 Nov 2026 at 17:52, Volodymyr Chapman
<volodymyrchapman@gmail.com> wrote:
>
> Add a V4L2 sub-device driver for the Sony IMX175, an 8 Mpixel raw Bayer
> image sensor with a 4-lane MIPI CSI-2 interface. It is used for example
> as the rear camera of the Lenovo ThinkPad 10 (20C1/20C3), where ACPI
> describes it as INTCF1A.
>
> The driver supports a 3280x2464 mode and a 2x2 binned 1640x1232 mode,
> both at about 30 fps, with a 19.2 MHz external clock and a 320 MHz link
> frequency on 4 data lanes (RAW10). It implements exposure, analogue and
> digital gain, vertical blanking, horizontal and vertical flip (which
> change the Bayer order), the SMIA test patterns and runtime PM.
>
> The register settings are derived from the IMX175 support in Intel's
> atomisp imx driver (drivers/staging/media/atomisp/i2c/imx/imx175.h),
> which was added in commit a49d25364dfb ("staging/atomisp: Add support for
> the Intel IPU v2") and removed in commit 3a81c7660f80 ("media: staging:
> atomisp: Remove IMX sensor support").
>
> The voice coil motor and the LM3554 flash on the ThinkPad 10 camera
> module are not supported.
>
> Tested on a Lenovo ThinkPad 10 (20C3, Atom Z3795) with atomisp, on a
> media.git next kernel with the other two patches of this series:
> - the binned mode streams; the colour bar test pattern comes out in the
> correct colour order, and real scenes have plausible colours;
> - v4l2-compliance 1.32.0 on the sensor sub-device: 46 tests, 0 failures,
> 0 warnings;
> - horizontal and vertical flip mirror the image with correct colours
> through atomisp, and VIDIOC_SUBDEV_G_FMT reports the same Bayer order
> as VIDIOC_SUBDEV_ENUM_MBUS_CODE for all four flip combinations (the
> test pattern itself is not affected by the flips);
> - the 3280x2464 mode was tested as a single still capture, as atomisp
> limits continuous capture to 1920 pixels wide.
>
> This driver was written with the help of an AI coding assistant (Claude),
> based on the register tables mentioned above and on existing sensor
> drivers; it was tested on the hardware by the submitter.
>
> Signed-off-by: Volodymyr Chapman <volodymyrchapman@gmail.com>
> ---
> MAINTAINERS | 7 +
> drivers/media/i2c/Kconfig | 10 +
> drivers/media/i2c/Makefile | 1 +
> drivers/media/i2c/imx175.c | 797 +++++++++++++++++++++++++++++++++++++
> 4 files changed, 815 insertions(+)
> create mode 100644 drivers/media/i2c/imx175.c
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index af302622c..286926a01 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -26061,6 +26061,13 @@ S: Maintained
> F: drivers/ssb/
> F: include/linux/ssb/
>
> +SONY IMX175 SENSOR DRIVER
> +M: Volodymyr Chapman <volodymyrchapman@gmail.com>
> +L: linux-media@vger.kernel.org
> +S: Maintained
> +T: git git://linuxtv.org/media.git
> +F: drivers/media/i2c/imx175.c
> +
> SONY IMX208 SENSOR DRIVER
> M: Sakari Ailus <sakari.ailus@linux.intel.com>
> L: linux-media@vger.kernel.org
> diff --git a/drivers/media/i2c/Kconfig b/drivers/media/i2c/Kconfig
> index 11c302525..8047a12e2 100644
> --- a/drivers/media/i2c/Kconfig
> +++ b/drivers/media/i2c/Kconfig
> @@ -158,6 +158,16 @@ config VIDEO_IMX111
> To compile this driver as a module, choose M here: the
> module will be called imx111.
>
> +config VIDEO_IMX175
> + tristate "Sony IMX175 sensor support"
> + select V4L2_CCI_I2C
> + help
> + This is a Video4Linux2 sensor driver for the Sony
> + IMX175 camera.
> +
> + To compile this driver as a module, choose M here: the
> + module will be called imx175.
> +
> config VIDEO_IMX208
> tristate "Sony IMX208 sensor support"
> help
> diff --git a/drivers/media/i2c/Makefile b/drivers/media/i2c/Makefile
> index 59e31af45..af107440c 100644
> --- a/drivers/media/i2c/Makefile
> +++ b/drivers/media/i2c/Makefile
> @@ -48,6 +48,7 @@ obj-$(CONFIG_VIDEO_HI847) += hi847.o
> obj-$(CONFIG_VIDEO_HM1246) += hm1246.o
> obj-$(CONFIG_VIDEO_I2C) += video-i2c.o
> obj-$(CONFIG_VIDEO_IMX111) += imx111.o
> +obj-$(CONFIG_VIDEO_IMX175) += imx175.o
> obj-$(CONFIG_VIDEO_IMX208) += imx208.o
> obj-$(CONFIG_VIDEO_IMX214) += imx214.o
> obj-$(CONFIG_VIDEO_IMX219) += imx219.o
> diff --git a/drivers/media/i2c/imx175.c b/drivers/media/i2c/imx175.c
> new file mode 100644
> index 000000000..b0b80ddeb
> --- /dev/null
> +++ b/drivers/media/i2c/imx175.c
> @@ -0,0 +1,797 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Sony IMX175 8MP raw image sensor driver
> + *
> + * Register settings derived from the Intel atomisp imx driver
> + * (drivers/staging/media/atomisp/i2c/imx/imx175.h in Linux v4.14),
> + * Copyright (c) 2010-2014 Intel Corporation.
No Copyright from you? Or are you representing Intel here, in which
case the end date should be 2026.
> + */
> +
> +#include <linux/clk.h>
> +#include <linux/delay.h>
> +#include <linux/gpio/consumer.h>
> +#include <linux/i2c.h>
> +#include <linux/mod_devicetable.h>
> +#include <linux/module.h>
> +#include <linux/pm_runtime.h>
> +#include <linux/regulator/consumer.h>
> +#include <linux/units.h>
> +
> +#include <media/v4l2-cci.h>
> +#include <media/v4l2-common.h>
> +#include <media/v4l2-ctrls.h>
> +#include <media/v4l2-device.h>
> +#include <media/v4l2-fwnode.h>
> +#include <media/v4l2-subdev.h>
> +
> +#define IMX175_REG_MODEL_ID CCI_REG16(0x0000)
Most of these registers are following the standard CCS register
definitions (see drivers/media/i2c/ccs/ccs-regs.h). Can you use the
standard defines rather than adding your own?
> +#define IMX175_MODEL_ID 0x0175
> +#define IMX175_REG_MODE_SELECT CCI_REG8(0x0100)
> +#define IMX175_MODE_STANDBY 0x00
> +#define IMX175_MODE_STREAMING 0x01
> +#define IMX175_REG_ORIENTATION CCI_REG8(0x0101)
> +#define IMX175_HFLIP BIT(0)
> +#define IMX175_VFLIP BIT(1)
> +#define IMX175_REG_SW_RESET CCI_REG8(0x0103)
> +#define IMX175_REG_GROUP_HOLD CCI_REG8(0x0104)
> +#define IMX175_REG_EXPOSURE CCI_REG16(0x0202)
> +#define IMX175_EXPOSURE_MIN 1
> +#define IMX175_EXPOSURE_MARGIN 4
> +#define IMX175_REG_ANALOG_GAIN CCI_REG8(0x0205)
> +#define IMX175_ANA_GAIN_MIN 0
> +#define IMX175_ANA_GAIN_MAX 224 /* 256 / (256 - 224) = 8x */
> +#define IMX175_ANA_GAIN_DEFAULT 0
> +#define IMX175_REG_DGAIN_GR CCI_REG16(0x020e)
> +#define IMX175_REG_DGAIN_R CCI_REG16(0x0210)
> +#define IMX175_REG_DGAIN_B CCI_REG16(0x0212)
> +#define IMX175_REG_DGAIN_GB CCI_REG16(0x0214)
> +#define IMX175_DGAIN_MIN 0x0100
> +#define IMX175_DGAIN_MAX 0x0fff
> +#define IMX175_DGAIN_DEFAULT 0x0100
> +#define IMX175_REG_FRAME_LENGTH CCI_REG16(0x0340)
> +#define IMX175_FLL_MAX 0xffff
> +#define IMX175_REG_LINE_LENGTH CCI_REG16(0x0342)
> +#define IMX175_REG_X_OUTPUT_SIZE CCI_REG16(0x034c)
> +#define IMX175_REG_Y_OUTPUT_SIZE CCI_REG16(0x034e)
> +#define IMX175_REG_BINNING_MODE CCI_REG8(0x0390)
> +#define IMX175_REG_TEST_PATTERN CCI_REG16(0x0600)
> +
> +#define IMX175_XCLK_FREQ (19200 * HZ_PER_KHZ)
> +#define IMX175_LINK_FREQ (320 * HZ_PER_MHZ)
> +#define IMX175_DATA_LANES 4
> +#define IMX175_BPP 10
> +/* pixel rate = link freq * 2 (DDR) * lanes / bpp */
> +#define IMX175_PIXEL_RATE (IMX175_LINK_FREQ * 2 * IMX175_DATA_LANES / IMX175_BPP)
> +
> +#define IMX175_NATIVE_WIDTH 3280
> +#define IMX175_NATIVE_HEIGHT 2464
> +#define IMX175_LLP 3430
> +#define IMX175_FLL_DEFAULT 2500
> +
> +static const char * const imx175_supply_names[] = {
> + "avdd", /* Analog power */
> + "dovdd", /* Digital I/O power */
> + "dvdd", /* Digital core power */
> +};
> +
> +struct imx175_mode {
> + u32 width;
> + u32 height;
> + bool binning;
> + u32 fll_default;
> +};
> +
> +static const struct imx175_mode imx175_modes[] = {
> + {
> + .width = 3280,
> + .height = 2464,
> + .binning = false,
> + .fll_default = IMX175_FLL_DEFAULT,
> + },
> + {
> + .width = 1640,
> + .height = 1232,
> + .binning = true,
> + .fll_default = IMX175_FLL_DEFAULT,
> + },
This is probably another case where adding the binning mode will have
to wait until the Common Raw Sensor Model patches are merged, and then
binning (and cropping?) be implemented using that.
> +};
> +
> +/* Static settings, applied after a software reset */
> +static const struct cci_reg_sequence imx175_init_regs[] = {
> + /* misc control */
> + { CCI_REG8(0x3020), 0x10 },
> + { CCI_REG8(0x302d), 0x02 },
> + { CCI_REG8(0x302f), 0x80 },
> + { CCI_REG8(0x3032), 0xa3 },
> + { CCI_REG8(0x3033), 0x20 },
> + { CCI_REG8(0x3034), 0x24 },
> + { CCI_REG8(0x3041), 0x15 },
> + { CCI_REG8(0x3042), 0x87 },
> + { CCI_REG8(0x3050), 0x35 },
> + { CCI_REG8(0x3056), 0x57 },
> + { CCI_REG8(0x305d), 0x41 },
> + { CCI_REG8(0x3097), 0x69 },
> + { CCI_REG8(0x3109), 0x41 },
> + { CCI_REG8(0x3148), 0x3f },
> + { CCI_REG8(0x330f), 0x07 },
> + /* CSI-2 and INCK */
> + { CCI_REG8(0x3364), 0x00 },
> + { CCI_REG8(0x3368), 0x13 },
> + { CCI_REG8(0x3369), 0x33 },
> + /* ZNR */
> + { CCI_REG8(0x4100), 0x0e },
> + { CCI_REG8(0x4104), 0x32 },
> + { CCI_REG8(0x4105), 0x32 },
> + { CCI_REG8(0x4108), 0x01 },
> + { CCI_REG8(0x4109), 0x7c },
> + { CCI_REG8(0x410a), 0x00 },
> + { CCI_REG8(0x410b), 0x00 },
> + /*
> + * PLL for a 19.2 MHz INCK: pre_pll_clk_div 9, pll multiplier 300,
> + * vt_pix_clk_div 5, vt_sys_clk_div 1, op_pix_clk_div 5,
> + * op_sys_clk_div 1 -> 640 Mbps/lane, 4 lanes.
> + */
> + { CCI_REG8(0x0301), 0x05 },
> + { CCI_REG8(0x0303), 0x01 },
> + { CCI_REG8(0x0305), 0x09 },
> + { CCI_REG8(0x0309), 0x05 },
> + { CCI_REG8(0x030b), 0x01 },
> + { CCI_REG16(0x030c), 0x012c },
> + { CCI_REG8(0x030e), 0x01 },
> + { CCI_REG16(0x0342), IMX175_LLP },
> + /* analog crop: full 3280x2464 array */
> + { CCI_REG16(0x0344), 0 },
> + { CCI_REG16(0x0346), 0 },
> + { CCI_REG16(0x0348), IMX175_NATIVE_WIDTH - 1 },
> + { CCI_REG16(0x034a), IMX175_NATIVE_HEIGHT - 1 },
> + /* no scaling */
> + { CCI_REG8(0x0401), 0x00 },
> + { CCI_REG8(0x0405), 0x10 },
> + /* timer */
> + { CCI_REG8(0x3344), 0x57 },
> + { CCI_REG8(0x3345), 0x1f },
> + /* timing */
> + { CCI_REG8(0x3370), 0x77 },
> + { CCI_REG8(0x3371), 0x2f },
> + { CCI_REG8(0x3372), 0x4f },
> + { CCI_REG8(0x3373), 0x2f },
> + { CCI_REG8(0x3374), 0x2f },
> + { CCI_REG8(0x3375), 0x37 },
> + { CCI_REG8(0x3376), 0x9f },
> + { CCI_REG8(0x3377), 0x37 },
> + { CCI_REG8(0x33c8), 0x01 },
> + { CCI_REG16(0x33d4), IMX175_NATIVE_WIDTH },
> + { CCI_REG16(0x33d6), IMX175_NATIVE_HEIGHT },
> + { CCI_REG8(0x41c0), 0x01 },
> +};
> +
> +static const s64 imx175_link_freqs[] = {
> + IMX175_LINK_FREQ,
> +};
> +
> +static const char * const imx175_test_pattern_menu[] = {
> + "Disabled",
> + "Solid Colour",
> + "Colour Bars",
> + "Fade to Grey Colour Bars",
> + "PN9",
> +};
> +
> +/* RGGB is the native order; flips shift the pattern */
> +static const u32 imx175_mbus_codes[] = {
> + MEDIA_BUS_FMT_SRGGB10_1X10, /* no flip */
> + MEDIA_BUS_FMT_SGRBG10_1X10, /* hflip */
> + MEDIA_BUS_FMT_SGBRG10_1X10, /* vflip */
> + MEDIA_BUS_FMT_SBGGR10_1X10, /* hflip + vflip */
> +};
> +
> +struct imx175 {
> + struct device *dev;
> + struct regmap *regmap;
> + struct clk *xclk;
> + struct gpio_desc *reset;
> + struct regulator_bulk_data supplies[ARRAY_SIZE(imx175_supply_names)];
> +
> + struct v4l2_subdev sd;
> + struct media_pad pad;
> +
> + struct v4l2_ctrl_handler ctrls;
> + struct v4l2_ctrl *link_freq;
> + struct v4l2_ctrl *pixel_rate;
> + struct v4l2_ctrl *exposure;
> + struct v4l2_ctrl *vblank;
> + struct v4l2_ctrl *hblank;
> + struct v4l2_ctrl *hflip;
> + struct v4l2_ctrl *vflip;
> +
> + const struct imx175_mode *mode;
> +};
> +
> +static inline struct imx175 *to_imx175(struct v4l2_subdev *sd)
> +{
> + return container_of(sd, struct imx175, sd);
> +}
> +
> +static u32 imx175_mbus_code(struct imx175 *imx175)
> +{
> + unsigned int idx = 0;
> +
> + if (imx175->hflip && imx175->hflip->val)
Is there a path where this is called before imx175->hflip has been
initiialised? I couldn't see one by inspection.
> + idx |= 1;
> + if (imx175->vflip && imx175->vflip->val)
> + idx |= 2;
> +
> + return imx175_mbus_codes[idx];
> +}
> +
> +static void imx175_update_pad_format(struct imx175 *imx175,
> + const struct imx175_mode *mode,
> + struct v4l2_mbus_framefmt *fmt)
> +{
> + fmt->width = mode->width;
> + fmt->height = mode->height;
> + fmt->code = imx175_mbus_code(imx175);
> + fmt->field = V4L2_FIELD_NONE;
> + fmt->colorspace = V4L2_COLORSPACE_RAW;
> + fmt->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
> + fmt->quantization = V4L2_QUANTIZATION_FULL_RANGE;
> + fmt->xfer_func = V4L2_XFER_FUNC_NONE;
> +}
> +
> +static int imx175_set_ctrl(struct v4l2_ctrl *ctrl)
> +{
> + struct imx175 *imx175 = container_of(ctrl->handler, struct imx175, ctrls);
> + int ret = 0;
> +
> + if (ctrl->id == V4L2_CID_VBLANK) {
> + s64 max = imx175->mode->height + ctrl->val - IMX175_EXPOSURE_MARGIN;
> +
> + ret = __v4l2_ctrl_modify_range(imx175->exposure,
> + imx175->exposure->minimum, max,
> + imx175->exposure->step,
> + min(imx175->exposure->default_value, max));
I'd suggest you adopt the minimum as the default value, rather than
trying to retain the default from when the control was initialised.
Currently you default to the full 3280x2464 mode, and set the default
exposure to be "mode->fll_default - IMX175_EXPOSURE_MARGIN". Switch to
the binned mode and reduce the VBLANK, and you'll be in a situation
where the default value won't be in the valid range, and this call
will fail.
> + if (ret)
> + return ret;
> + }
> +
> + /* Flips change the Bayer order, keep the active format in sync */
> + if (ctrl->id == V4L2_CID_HFLIP || ctrl->id == V4L2_CID_VFLIP) {
> + struct v4l2_subdev_state *state =
> + v4l2_subdev_get_locked_active_state(&imx175->sd);
> +
> + v4l2_subdev_state_get_format(state, 0)->code =
> + imx175_mbus_code(imx175);
> + }
> +
> + if (!pm_runtime_get_if_in_use(imx175->dev))
> + return 0;
> +
> + switch (ctrl->id) {
> + case V4L2_CID_EXPOSURE:
> + cci_write(imx175->regmap, IMX175_REG_EXPOSURE, ctrl->val, &ret);
> + break;
> + case V4L2_CID_ANALOGUE_GAIN:
> + cci_write(imx175->regmap, IMX175_REG_ANALOG_GAIN, ctrl->val, &ret);
> + break;
> + case V4L2_CID_DIGITAL_GAIN:
> + cci_write(imx175->regmap, IMX175_REG_DGAIN_GR, ctrl->val, &ret);
> + cci_write(imx175->regmap, IMX175_REG_DGAIN_R, ctrl->val, &ret);
> + cci_write(imx175->regmap, IMX175_REG_DGAIN_B, ctrl->val, &ret);
> + cci_write(imx175->regmap, IMX175_REG_DGAIN_GB, ctrl->val, &ret);
> + break;
> + case V4L2_CID_VBLANK:
> + cci_write(imx175->regmap, IMX175_REG_FRAME_LENGTH,
> + imx175->mode->height + ctrl->val, &ret);
> + break;
> + case V4L2_CID_HFLIP:
> + case V4L2_CID_VFLIP:
Use v4l2_ctrl_cluster for these so that updating both only results in
one call through set_ctrl. See imx290 for an example.
> + cci_write(imx175->regmap, IMX175_REG_ORIENTATION,
> + (imx175->hflip->val ? IMX175_HFLIP : 0) |
> + (imx175->vflip->val ? IMX175_VFLIP : 0), &ret);
> + break;
> + case V4L2_CID_TEST_PATTERN:
> + cci_write(imx175->regmap, IMX175_REG_TEST_PATTERN, ctrl->val, &ret);
> + break;
> + default:
> + ret = -EINVAL;
> + break;
> + }
> +
> + pm_runtime_put(imx175->dev);
> + return ret;
> +}
> +
> +static const struct v4l2_ctrl_ops imx175_ctrl_ops = {
> + .s_ctrl = imx175_set_ctrl,
> +};
> +
> +static int imx175_init_controls(struct imx175 *imx175)
> +{
> + const struct imx175_mode *mode = &imx175_modes[0];
> + struct v4l2_ctrl_handler *hdl = &imx175->ctrls;
> + struct v4l2_fwnode_device_properties props;
> + s64 vblank_def, hblank, exposure_max;
> + int ret;
> +
> + ret = v4l2_fwnode_device_parse(imx175->dev, &props);
> + if (ret)
> + return ret;
> +
> + v4l2_ctrl_handler_init(hdl, 12);
> +
> + imx175->link_freq = v4l2_ctrl_new_int_menu(hdl, &imx175_ctrl_ops,
> + V4L2_CID_LINK_FREQ,
> + ARRAY_SIZE(imx175_link_freqs) - 1,
> + 0, imx175_link_freqs);
> + if (imx175->link_freq)
> + imx175->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY;
If the control is read-only, then pass NULL instead of
&imx175_ctrl_ops as the control ops. Otherwise there are some paths
where set_ctrl can be called and it'll hit your "default: ret =
-EINVAL" case.
Ditto for the other read only controls below.
> +
> + imx175->pixel_rate = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops,
> + V4L2_CID_PIXEL_RATE,
> + IMX175_PIXEL_RATE, IMX175_PIXEL_RATE,
> + 1, IMX175_PIXEL_RATE);
> +
> + vblank_def = mode->fll_default - mode->height;
> + imx175->vblank = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_VBLANK,
> + IMX175_EXPOSURE_MARGIN,
The minimum VBLANK period being the same as the exposure margin feels
a little strange. It may be the case, but the two are usually
disassociated.
> + IMX175_FLL_MAX - mode->height, 1,
> + vblank_def);
> +
> + hblank = IMX175_LLP - mode->width;
> + imx175->hblank = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_HBLANK,
> + hblank, hblank, 1, hblank);
> + if (imx175->hblank)
> + imx175->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY;
> +
> + exposure_max = mode->fll_default - IMX175_EXPOSURE_MARGIN;
> + imx175->exposure = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops,
> + V4L2_CID_EXPOSURE,
> + IMX175_EXPOSURE_MIN, exposure_max, 1,
> + exposure_max);
> +
> + v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_ANALOGUE_GAIN,
> + IMX175_ANA_GAIN_MIN, IMX175_ANA_GAIN_MAX, 1,
> + IMX175_ANA_GAIN_DEFAULT);
> +
> + v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_DIGITAL_GAIN,
> + IMX175_DGAIN_MIN, IMX175_DGAIN_MAX, 1,
> + IMX175_DGAIN_DEFAULT);
> +
> + imx175->hflip = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_HFLIP,
> + 0, 1, 1, 0);
> + if (imx175->hflip)
> + imx175->hflip->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT;
> +
> + imx175->vflip = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_VFLIP,
> + 0, 1, 1, 0);
> + if (imx175->vflip)
> + imx175->vflip->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT;
> +
> + v4l2_ctrl_new_std_menu_items(hdl, &imx175_ctrl_ops, V4L2_CID_TEST_PATTERN,
> + ARRAY_SIZE(imx175_test_pattern_menu) - 1,
> + 0, 0, imx175_test_pattern_menu);
> +
> + v4l2_ctrl_new_fwnode_properties(hdl, &imx175_ctrl_ops, &props);
> +
> + if (hdl->error) {
> + ret = hdl->error;
> + v4l2_ctrl_handler_free(hdl);
> + return ret;
> + }
> +
> + imx175->sd.ctrl_handler = hdl;
> + return 0;
> +}
> +
> +static int imx175_enable_streams(struct v4l2_subdev *sd,
> + struct v4l2_subdev_state *state, u32 pad,
> + u64 streams_mask)
> +{
> + struct imx175 *imx175 = to_imx175(sd);
> + const struct imx175_mode *mode = imx175->mode;
> + int ret;
> +
> + ret = pm_runtime_resume_and_get(imx175->dev);
> + if (ret)
> + return ret;
> +
> + ret = cci_write(imx175->regmap, IMX175_REG_SW_RESET, 0x01, NULL);
> + if (ret)
> + goto err_put;
> + usleep_range(5000, 6000);
> +
> + ret = cci_multi_reg_write(imx175->regmap, imx175_init_regs,
> + ARRAY_SIZE(imx175_init_regs), NULL);
The reset and imx175_init_regs could be sent from imx175_power_on. If
combined with pm_runtime_autosuspend, then switching mode becomes just
a handful of register writes.
> + cci_write(imx175->regmap, IMX175_REG_X_OUTPUT_SIZE, mode->width, &ret);
> + cci_write(imx175->regmap, IMX175_REG_Y_OUTPUT_SIZE, mode->height, &ret);
> + cci_write(imx175->regmap, IMX175_REG_BINNING_MODE, mode->binning ? 1 : 0,
> + &ret);
> + if (ret)
> + goto err_put;
> +
> + ret = __v4l2_ctrl_handler_setup(imx175->sd.ctrl_handler);
> + if (ret)
> + goto err_put;
> +
> + ret = cci_write(imx175->regmap, IMX175_REG_MODE_SELECT,
> + IMX175_MODE_STREAMING, NULL);
> + if (ret)
> + goto err_put;
> +
> + /* Flips change the Bayer order; don't allow them while streaming */
> + __v4l2_ctrl_grab(imx175->hflip, true);
> + __v4l2_ctrl_grab(imx175->vflip, true);
> + return 0;
> +
> +err_put:
> + pm_runtime_put(imx175->dev);
> + return ret;
> +}
> +
> +static int imx175_disable_streams(struct v4l2_subdev *sd,
> + struct v4l2_subdev_state *state, u32 pad,
> + u64 streams_mask)
> +{
> + struct imx175 *imx175 = to_imx175(sd);
> + int ret;
> +
> + ret = cci_write(imx175->regmap, IMX175_REG_MODE_SELECT,
> + IMX175_MODE_STANDBY, NULL);
> +
> + __v4l2_ctrl_grab(imx175->hflip, false);
> + __v4l2_ctrl_grab(imx175->vflip, false);
> +
> + pm_runtime_put(imx175->dev);
> + return ret;
> +}
> +
> +static int imx175_set_format(struct v4l2_subdev *sd,
> + const struct v4l2_subdev_client_info *ci,
> + struct v4l2_subdev_state *state,
> + struct v4l2_subdev_format *fmt)
> +{
> + struct imx175 *imx175 = to_imx175(sd);
> + const struct imx175_mode *mode;
> + struct v4l2_mbus_framefmt *format;
> + int ret;
> +
> + mode = v4l2_find_nearest_size(imx175_modes, ARRAY_SIZE(imx175_modes),
> + width, height,
> + fmt->format.width, fmt->format.height);
> +
> + imx175_update_pad_format(imx175, mode, &fmt->format);
> + format = v4l2_subdev_state_get_format(state, 0);
> + *format = fmt->format;
> +
> + if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
> + return 0;
> +
> + imx175->mode = mode;
> +
> + ret = __v4l2_ctrl_modify_range(imx175->vblank, IMX175_EXPOSURE_MARGIN,
> + IMX175_FLL_MAX - mode->height, 1,
> + mode->fll_default - mode->height);
> + if (ret)
> + return ret;
> + ret = __v4l2_ctrl_s_ctrl(imx175->vblank, mode->fll_default - mode->height);
> + if (ret)
> + return ret;
> +
> + return __v4l2_ctrl_modify_range(imx175->hblank,
> + IMX175_LLP - mode->width,
> + IMX175_LLP - mode->width, 1,
> + IMX175_LLP - mode->width);
> +}
> +
> +static int imx175_enum_mbus_code(struct v4l2_subdev *sd,
> + struct v4l2_subdev_state *state,
> + struct v4l2_subdev_mbus_code_enum *code)
> +{
> + if (code->index > 0)
> + return -EINVAL;
> +
> + code->code = imx175_mbus_code(to_imx175(sd));
> + return 0;
> +}
> +
> +static int imx175_enum_frame_size(struct v4l2_subdev *sd,
> + struct v4l2_subdev_state *state,
> + struct v4l2_subdev_frame_size_enum *fse)
> +{
> + if (fse->index >= ARRAY_SIZE(imx175_modes))
> + return -EINVAL;
> +
> + if (fse->code != imx175_mbus_code(to_imx175(sd)))
> + return -EINVAL;
> +
> + fse->min_width = imx175_modes[fse->index].width;
> + fse->max_width = fse->min_width;
> + fse->min_height = imx175_modes[fse->index].height;
> + fse->max_height = fse->min_height;
> + return 0;
> +}
> +
> +static int imx175_get_selection(struct v4l2_subdev *sd,
> + const struct v4l2_subdev_client_info *ci,
> + struct v4l2_subdev_state *state,
> + struct v4l2_subdev_selection *sel)
> +{
> + switch (sel->target) {
> + case V4L2_SEL_TGT_CROP:
> + case V4L2_SEL_TGT_CROP_DEFAULT:
> + case V4L2_SEL_TGT_CROP_BOUNDS:
> + case V4L2_SEL_TGT_NATIVE_SIZE:
> + sel->r.left = 0;
> + sel->r.top = 0;
> + sel->r.width = IMX175_NATIVE_WIDTH;
> + sel->r.height = IMX175_NATIVE_HEIGHT;
> + return 0;
> + }
> +
> + return -EINVAL;
> +}
> +
> +static int imx175_init_state(struct v4l2_subdev *sd,
> + struct v4l2_subdev_state *state)
> +{
> + struct v4l2_subdev_format fmt = {
> + .which = V4L2_SUBDEV_FORMAT_TRY,
> + .pad = 0,
> + .format = {
> + .width = imx175_modes[0].width,
> + .height = imx175_modes[0].height,
> + },
> + };
> +
> + return imx175_set_format(sd, NULL, state, &fmt);
> +}
> +
> +static const struct v4l2_subdev_video_ops imx175_video_ops = {
> + .s_stream = v4l2_subdev_s_stream_helper,
> +};
> +
> +static const struct v4l2_subdev_pad_ops imx175_pad_ops = {
> + .enum_mbus_code = imx175_enum_mbus_code,
> + .enum_frame_size = imx175_enum_frame_size,
> + .get_fmt = v4l2_subdev_get_fmt,
> + .set_fmt = imx175_set_format,
> + .get_selection = imx175_get_selection,
> + .enable_streams = imx175_enable_streams,
> + .disable_streams = imx175_disable_streams,
> +};
> +
> +static const struct v4l2_subdev_ops imx175_subdev_ops = {
> + .video = &imx175_video_ops,
> + .pad = &imx175_pad_ops,
> +};
> +
> +static const struct v4l2_subdev_internal_ops imx175_internal_ops = {
> + .init_state = imx175_init_state,
> +};
> +
> +static int imx175_power_on(struct device *dev)
> +{
> + struct v4l2_subdev *sd = dev_get_drvdata(dev);
> + struct imx175 *imx175 = to_imx175(sd);
> + int ret;
> +
> + ret = regulator_bulk_enable(ARRAY_SIZE(imx175->supplies),
> + imx175->supplies);
> + if (ret)
> + return ret;
> +
> + ret = clk_prepare_enable(imx175->xclk);
> + if (ret) {
> + regulator_bulk_disable(ARRAY_SIZE(imx175->supplies),
> + imx175->supplies);
> + return ret;
> + }
> +
> + usleep_range(1000, 2000);
> + gpiod_set_value_cansleep(imx175->reset, 0);
> + /* Wait for the sensor to come out of reset before using I2C */
> + usleep_range(10000, 12000);
> +
> + return 0;
> +}
> +
> +static int imx175_power_off(struct device *dev)
> +{
> + struct v4l2_subdev *sd = dev_get_drvdata(dev);
> + struct imx175 *imx175 = to_imx175(sd);
> +
> + gpiod_set_value_cansleep(imx175->reset, 1);
> + clk_disable_unprepare(imx175->xclk);
> + regulator_bulk_disable(ARRAY_SIZE(imx175->supplies), imx175->supplies);
> +
> + return 0;
> +}
> +
> +static int imx175_identify(struct imx175 *imx175)
> +{
> + u64 id;
> + int ret;
> +
> + ret = cci_read(imx175->regmap, IMX175_REG_MODEL_ID, &id, NULL);
> + if (ret)
> + return dev_err_probe(imx175->dev, ret, "failed to read model id\n");
> +
> + if (id != IMX175_MODEL_ID)
> + return dev_err_probe(imx175->dev, -ENODEV,
> + "unexpected model id 0x%04llx\n", id);
> +
> + return 0;
> +}
> +
> +static int imx175_check_hwcfg(struct imx175 *imx175)
> +{
> + struct v4l2_fwnode_endpoint bus_cfg = {
> + .bus_type = V4L2_MBUS_CSI2_DPHY,
> + };
> + struct fwnode_handle *ep;
> + unsigned long link_freq_bitmap;
> + int ret;
> +
> + /* The endpoint is created by ipu-bridge on ACPI systems */
> + ep = fwnode_graph_get_endpoint_by_id(dev_fwnode(imx175->dev), 0, 0, 0);
> + if (!ep)
> + return dev_err_probe(imx175->dev, -EPROBE_DEFER,
> + "waiting for fwnode graph endpoint\n");
> +
> + ret = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg);
> + fwnode_handle_put(ep);
> + if (ret)
> + return dev_err_probe(imx175->dev, ret, "parsing endpoint\n");
> +
> + if (bus_cfg.bus.mipi_csi2.num_data_lanes != IMX175_DATA_LANES) {
> + ret = dev_err_probe(imx175->dev, -EINVAL,
> + "%u data lanes not supported\n",
> + bus_cfg.bus.mipi_csi2.num_data_lanes);
> + goto out;
> + }
> +
> + ret = v4l2_link_freq_to_bitmap(imx175->dev, bus_cfg.link_frequencies,
> + bus_cfg.nr_of_link_frequencies,
> + imx175_link_freqs,
> + ARRAY_SIZE(imx175_link_freqs),
> + &link_freq_bitmap);
> +out:
> + v4l2_fwnode_endpoint_free(&bus_cfg);
> + return ret;
> +}
> +
> +static int imx175_probe(struct i2c_client *client)
> +{
> + struct device *dev = &client->dev;
> + struct imx175 *imx175;
> + unsigned long rate;
> + unsigned int i;
> + int ret;
> +
> + imx175 = devm_kzalloc(dev, sizeof(*imx175), GFP_KERNEL);
> + if (!imx175)
> + return -ENOMEM;
> +
> + imx175->dev = dev;
> + imx175->mode = &imx175_modes[0];
> +
> + ret = imx175_check_hwcfg(imx175);
> + if (ret)
> + return ret;
> +
> + imx175->regmap = devm_cci_regmap_init_i2c(client, 16);
> + if (IS_ERR(imx175->regmap))
> + return PTR_ERR(imx175->regmap);
> +
> + imx175->xclk = devm_v4l2_sensor_clk_get(dev, NULL);
> + if (IS_ERR(imx175->xclk))
> + return dev_err_probe(dev, PTR_ERR(imx175->xclk),
> + "failed to get xclk\n");
> +
> + rate = clk_get_rate(imx175->xclk);
> + if (rate != IMX175_XCLK_FREQ)
> + return dev_err_probe(dev, -EINVAL,
> + "unsupported xclk rate %lu Hz\n", rate);
> +
> + imx175->reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
> + if (IS_ERR(imx175->reset))
> + return dev_err_probe(dev, PTR_ERR(imx175->reset),
> + "failed to get reset gpio\n");
> +
> + for (i = 0; i < ARRAY_SIZE(imx175_supply_names); i++)
> + imx175->supplies[i].supply = imx175_supply_names[i];
> +
> + ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(imx175->supplies),
> + imx175->supplies);
> + if (ret)
> + return dev_err_probe(dev, ret, "failed to get regulators\n");
> +
> + v4l2_i2c_subdev_init(&imx175->sd, client, &imx175_subdev_ops);
> + imx175->sd.internal_ops = &imx175_internal_ops;
> +
> + ret = imx175_power_on(dev);
> + if (ret)
> + return ret;
> +
> + ret = imx175_identify(imx175);
> + if (ret)
> + goto err_power_off;
> +
> + ret = imx175_init_controls(imx175);
> + if (ret)
> + goto err_power_off;
> +
> + imx175->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
> + imx175->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
> + imx175->pad.flags = MEDIA_PAD_FL_SOURCE;
> +
> + ret = media_entity_pads_init(&imx175->sd.entity, 1, &imx175->pad);
> + if (ret)
> + goto err_free_ctrls;
> +
> + imx175->sd.state_lock = imx175->ctrls.lock;
> + ret = v4l2_subdev_init_finalize(&imx175->sd);
> + if (ret)
> + goto err_entity_cleanup;
> +
> + pm_runtime_set_active(dev);
> + pm_runtime_enable(dev);
Use pm_runtime_autosuspend? It saves a little bit of time when
switching modes on the sensor.
> +
> + ret = v4l2_async_register_subdev_sensor(&imx175->sd);
> + if (ret)
> + goto err_pm;
> +
> + pm_runtime_idle(dev);
> + return 0;
> +
> +err_pm:
> + pm_runtime_disable(dev);
> + pm_runtime_set_suspended(dev);
> + v4l2_subdev_cleanup(&imx175->sd);
> +err_entity_cleanup:
> + media_entity_cleanup(&imx175->sd.entity);
> +err_free_ctrls:
> + v4l2_ctrl_handler_free(&imx175->ctrls);
> +err_power_off:
> + imx175_power_off(dev);
> + return ret;
> +}
> +
> +static void imx175_remove(struct i2c_client *client)
> +{
> + struct v4l2_subdev *sd = i2c_get_clientdata(client);
> + struct imx175 *imx175 = to_imx175(sd);
> +
> + v4l2_async_unregister_subdev(sd);
> + v4l2_subdev_cleanup(sd);
> + media_entity_cleanup(&sd->entity);
> + v4l2_ctrl_handler_free(&imx175->ctrls);
> +
> + pm_runtime_disable(&client->dev);
> + if (!pm_runtime_status_suspended(&client->dev))
> + imx175_power_off(&client->dev);
> + pm_runtime_set_suspended(&client->dev);
> +}
> +
> +static DEFINE_RUNTIME_DEV_PM_OPS(imx175_pm_ops, imx175_power_off,
> + imx175_power_on, NULL);
> +
> +static const struct acpi_device_id imx175_acpi_ids[] = {
> + { "INTCF1A" },
> + { }
> +};
> +MODULE_DEVICE_TABLE(acpi, imx175_acpi_ids);
> +
> +static struct i2c_driver imx175_i2c_driver = {
> + .driver = {
> + .name = "imx175",
> + .acpi_match_table = imx175_acpi_ids,
> + .pm = pm_ptr(&imx175_pm_ops),
> + },
> + .probe = imx175_probe,
> + .remove = imx175_remove,
> +};
> +module_i2c_driver(imx175_i2c_driver);
> +
> +MODULE_DESCRIPTION("Sony IMX175 sensor driver");
> +MODULE_LICENSE("GPL");
MODULE_AUTHOR?
Hope that's helpful.
Dave
> --
> 2.43.0
>
>
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH 1/3] media: i2c: Add Sony IMX175 sensor driver
2026-11-16 19:25 ` Dave Stevenson
@ 2026-11-16 23:09 ` Volodymyr Chapman
0 siblings, 0 replies; 8+ messages in thread
From: Volodymyr Chapman @ 2026-11-16 23:09 UTC (permalink / raw)
To: Dave Stevenson
Cc: Sakari Ailus, Mauro Carvalho Chehab, Dan Scally, Hans de Goede,
Andy Shevchenko, Greg Kroah-Hartman, linux-media, linux-staging,
linux-kernel
Hi Dave,
Thanks for taking a look.
> No Copyright from you? Or are you representing Intel here, in which
> case the end date should be 2026.
I'm not representing Intel; that line credits the register settings
taken from the removed atomisp imx driver. I'll add my own copyright
line in v2, and MODULE_AUTHOR.
> Most of these registers are following the standard CCS register
> definitions (see drivers/media/i2c/ccs/ccs-regs.h). Can you use the
> standard defines rather than adding your own?
Will do, as imx576 does, keeping driver defines only for the Sony
specific registers such as the binning mode register at 0x0390.
> This is probably another case where adding the binning mode will have
> to wait until the Common Raw Sensor Model patches are merged, and then
> binning (and cropping?) be implemented using that.
The binned 1640x1232 mode is the important one on this platform: the
atomisp preview pipeline is limited to 1920 pixels wide, so it is the
only mode that can stream there; the full 3280x2464 mode only works
for still captures. Would it be acceptable to keep the binned mode as a
fixed mode for now and move to the Common Raw Sensor Model once it is
merged? Sakari, what would you prefer?
> Is there a path where this is called before imx175->hflip has been
> initiialised? I couldn't see one by inspection.
No, the controls are created before v4l2_subdev_init_finalize(), so
I'll drop the NULL checks.
> I'd suggest you adopt the minimum as the default value, rather than
> trying to retain the default from when the control was initialised.
The default is clamped with min(default_value, max), so I don't think
the call can fail, but I agree that carrying the old default around is
fragile. I'll change it as you suggest in v2.
> Use v4l2_ctrl_cluster for these so that updating both only results in
> one call through set_ctrl. See imx290 for an example.
Will do.
> If the control is read-only, then pass NULL instead of
> &imx175_ctrl_ops as the control ops.
Will do, for all of the read-only controls.
> The minimum VBLANK period being the same as the exposure margin feels
> a little strange.
Agreed, there is no good reason for it. I'll read the sensor's
min_frame_blanking_lines limit register and use that instead.
> The reset and imx175_init_regs could be sent from imx175_power_on. If
> combined with pm_runtime_autosuspend, then switching mode becomes just
> a handful of register writes.
Will do, both.
> MODULE_AUTHOR?
Will add.
I'll wait a little for any further comments before sending v2.
Thanks,
Volodymyr
On Mon, Nov 16, 2026 at 7:25 PM Dave Stevenson
<dave.stevenson@raspberrypi.com> wrote:
>
> Hi Volodymyr
>
> A couple of things jumped out from a very quick read through.
>
> On Mon, 16 Nov 2026 at 17:52, Volodymyr Chapman
> <volodymyrchapman@gmail.com> wrote:
> >
> > Add a V4L2 sub-device driver for the Sony IMX175, an 8 Mpixel raw Bayer
> > image sensor with a 4-lane MIPI CSI-2 interface. It is used for example
> > as the rear camera of the Lenovo ThinkPad 10 (20C1/20C3), where ACPI
> > describes it as INTCF1A.
> >
> > The driver supports a 3280x2464 mode and a 2x2 binned 1640x1232 mode,
> > both at about 30 fps, with a 19.2 MHz external clock and a 320 MHz link
> > frequency on 4 data lanes (RAW10). It implements exposure, analogue and
> > digital gain, vertical blanking, horizontal and vertical flip (which
> > change the Bayer order), the SMIA test patterns and runtime PM.
> >
> > The register settings are derived from the IMX175 support in Intel's
> > atomisp imx driver (drivers/staging/media/atomisp/i2c/imx/imx175.h),
> > which was added in commit a49d25364dfb ("staging/atomisp: Add support for
> > the Intel IPU v2") and removed in commit 3a81c7660f80 ("media: staging:
> > atomisp: Remove IMX sensor support").
> >
> > The voice coil motor and the LM3554 flash on the ThinkPad 10 camera
> > module are not supported.
> >
> > Tested on a Lenovo ThinkPad 10 (20C3, Atom Z3795) with atomisp, on a
> > media.git next kernel with the other two patches of this series:
> > - the binned mode streams; the colour bar test pattern comes out in the
> > correct colour order, and real scenes have plausible colours;
> > - v4l2-compliance 1.32.0 on the sensor sub-device: 46 tests, 0 failures,
> > 0 warnings;
> > - horizontal and vertical flip mirror the image with correct colours
> > through atomisp, and VIDIOC_SUBDEV_G_FMT reports the same Bayer order
> > as VIDIOC_SUBDEV_ENUM_MBUS_CODE for all four flip combinations (the
> > test pattern itself is not affected by the flips);
> > - the 3280x2464 mode was tested as a single still capture, as atomisp
> > limits continuous capture to 1920 pixels wide.
> >
> > This driver was written with the help of an AI coding assistant (Claude),
> > based on the register tables mentioned above and on existing sensor
> > drivers; it was tested on the hardware by the submitter.
> >
> > Signed-off-by: Volodymyr Chapman <volodymyrchapman@gmail.com>
> > ---
> > MAINTAINERS | 7 +
> > drivers/media/i2c/Kconfig | 10 +
> > drivers/media/i2c/Makefile | 1 +
> > drivers/media/i2c/imx175.c | 797 +++++++++++++++++++++++++++++++++++++
> > 4 files changed, 815 insertions(+)
> > create mode 100644 drivers/media/i2c/imx175.c
> >
> > diff --git a/MAINTAINERS b/MAINTAINERS
> > index af302622c..286926a01 100644
> > --- a/MAINTAINERS
> > +++ b/MAINTAINERS
> > @@ -26061,6 +26061,13 @@ S: Maintained
> > F: drivers/ssb/
> > F: include/linux/ssb/
> >
> > +SONY IMX175 SENSOR DRIVER
> > +M: Volodymyr Chapman <volodymyrchapman@gmail.com>
> > +L: linux-media@vger.kernel.org
> > +S: Maintained
> > +T: git git://linuxtv.org/media.git
> > +F: drivers/media/i2c/imx175.c
> > +
> > SONY IMX208 SENSOR DRIVER
> > M: Sakari Ailus <sakari.ailus@linux.intel.com>
> > L: linux-media@vger.kernel.org
> > diff --git a/drivers/media/i2c/Kconfig b/drivers/media/i2c/Kconfig
> > index 11c302525..8047a12e2 100644
> > --- a/drivers/media/i2c/Kconfig
> > +++ b/drivers/media/i2c/Kconfig
> > @@ -158,6 +158,16 @@ config VIDEO_IMX111
> > To compile this driver as a module, choose M here: the
> > module will be called imx111.
> >
> > +config VIDEO_IMX175
> > + tristate "Sony IMX175 sensor support"
> > + select V4L2_CCI_I2C
> > + help
> > + This is a Video4Linux2 sensor driver for the Sony
> > + IMX175 camera.
> > +
> > + To compile this driver as a module, choose M here: the
> > + module will be called imx175.
> > +
> > config VIDEO_IMX208
> > tristate "Sony IMX208 sensor support"
> > help
> > diff --git a/drivers/media/i2c/Makefile b/drivers/media/i2c/Makefile
> > index 59e31af45..af107440c 100644
> > --- a/drivers/media/i2c/Makefile
> > +++ b/drivers/media/i2c/Makefile
> > @@ -48,6 +48,7 @@ obj-$(CONFIG_VIDEO_HI847) += hi847.o
> > obj-$(CONFIG_VIDEO_HM1246) += hm1246.o
> > obj-$(CONFIG_VIDEO_I2C) += video-i2c.o
> > obj-$(CONFIG_VIDEO_IMX111) += imx111.o
> > +obj-$(CONFIG_VIDEO_IMX175) += imx175.o
> > obj-$(CONFIG_VIDEO_IMX208) += imx208.o
> > obj-$(CONFIG_VIDEO_IMX214) += imx214.o
> > obj-$(CONFIG_VIDEO_IMX219) += imx219.o
> > diff --git a/drivers/media/i2c/imx175.c b/drivers/media/i2c/imx175.c
> > new file mode 100644
> > index 000000000..b0b80ddeb
> > --- /dev/null
> > +++ b/drivers/media/i2c/imx175.c
> > @@ -0,0 +1,797 @@
> > +// SPDX-License-Identifier: GPL-2.0
> > +/*
> > + * Sony IMX175 8MP raw image sensor driver
> > + *
> > + * Register settings derived from the Intel atomisp imx driver
> > + * (drivers/staging/media/atomisp/i2c/imx/imx175.h in Linux v4.14),
> > + * Copyright (c) 2010-2014 Intel Corporation.
>
> No Copyright from you? Or are you representing Intel here, in which
> case the end date should be 2026.
>
> > + */
> > +
> > +#include <linux/clk.h>
> > +#include <linux/delay.h>
> > +#include <linux/gpio/consumer.h>
> > +#include <linux/i2c.h>
> > +#include <linux/mod_devicetable.h>
> > +#include <linux/module.h>
> > +#include <linux/pm_runtime.h>
> > +#include <linux/regulator/consumer.h>
> > +#include <linux/units.h>
> > +
> > +#include <media/v4l2-cci.h>
> > +#include <media/v4l2-common.h>
> > +#include <media/v4l2-ctrls.h>
> > +#include <media/v4l2-device.h>
> > +#include <media/v4l2-fwnode.h>
> > +#include <media/v4l2-subdev.h>
> > +
> > +#define IMX175_REG_MODEL_ID CCI_REG16(0x0000)
>
> Most of these registers are following the standard CCS register
> definitions (see drivers/media/i2c/ccs/ccs-regs.h). Can you use the
> standard defines rather than adding your own?
>
> > +#define IMX175_MODEL_ID 0x0175
> > +#define IMX175_REG_MODE_SELECT CCI_REG8(0x0100)
> > +#define IMX175_MODE_STANDBY 0x00
> > +#define IMX175_MODE_STREAMING 0x01
> > +#define IMX175_REG_ORIENTATION CCI_REG8(0x0101)
> > +#define IMX175_HFLIP BIT(0)
> > +#define IMX175_VFLIP BIT(1)
> > +#define IMX175_REG_SW_RESET CCI_REG8(0x0103)
> > +#define IMX175_REG_GROUP_HOLD CCI_REG8(0x0104)
> > +#define IMX175_REG_EXPOSURE CCI_REG16(0x0202)
> > +#define IMX175_EXPOSURE_MIN 1
> > +#define IMX175_EXPOSURE_MARGIN 4
> > +#define IMX175_REG_ANALOG_GAIN CCI_REG8(0x0205)
> > +#define IMX175_ANA_GAIN_MIN 0
> > +#define IMX175_ANA_GAIN_MAX 224 /* 256 / (256 - 224) = 8x */
> > +#define IMX175_ANA_GAIN_DEFAULT 0
> > +#define IMX175_REG_DGAIN_GR CCI_REG16(0x020e)
> > +#define IMX175_REG_DGAIN_R CCI_REG16(0x0210)
> > +#define IMX175_REG_DGAIN_B CCI_REG16(0x0212)
> > +#define IMX175_REG_DGAIN_GB CCI_REG16(0x0214)
> > +#define IMX175_DGAIN_MIN 0x0100
> > +#define IMX175_DGAIN_MAX 0x0fff
> > +#define IMX175_DGAIN_DEFAULT 0x0100
> > +#define IMX175_REG_FRAME_LENGTH CCI_REG16(0x0340)
> > +#define IMX175_FLL_MAX 0xffff
> > +#define IMX175_REG_LINE_LENGTH CCI_REG16(0x0342)
> > +#define IMX175_REG_X_OUTPUT_SIZE CCI_REG16(0x034c)
> > +#define IMX175_REG_Y_OUTPUT_SIZE CCI_REG16(0x034e)
> > +#define IMX175_REG_BINNING_MODE CCI_REG8(0x0390)
> > +#define IMX175_REG_TEST_PATTERN CCI_REG16(0x0600)
> > +
> > +#define IMX175_XCLK_FREQ (19200 * HZ_PER_KHZ)
> > +#define IMX175_LINK_FREQ (320 * HZ_PER_MHZ)
> > +#define IMX175_DATA_LANES 4
> > +#define IMX175_BPP 10
> > +/* pixel rate = link freq * 2 (DDR) * lanes / bpp */
> > +#define IMX175_PIXEL_RATE (IMX175_LINK_FREQ * 2 * IMX175_DATA_LANES / IMX175_BPP)
> > +
> > +#define IMX175_NATIVE_WIDTH 3280
> > +#define IMX175_NATIVE_HEIGHT 2464
> > +#define IMX175_LLP 3430
> > +#define IMX175_FLL_DEFAULT 2500
> > +
> > +static const char * const imx175_supply_names[] = {
> > + "avdd", /* Analog power */
> > + "dovdd", /* Digital I/O power */
> > + "dvdd", /* Digital core power */
> > +};
> > +
> > +struct imx175_mode {
> > + u32 width;
> > + u32 height;
> > + bool binning;
> > + u32 fll_default;
> > +};
> > +
> > +static const struct imx175_mode imx175_modes[] = {
> > + {
> > + .width = 3280,
> > + .height = 2464,
> > + .binning = false,
> > + .fll_default = IMX175_FLL_DEFAULT,
> > + },
> > + {
> > + .width = 1640,
> > + .height = 1232,
> > + .binning = true,
> > + .fll_default = IMX175_FLL_DEFAULT,
> > + },
>
> This is probably another case where adding the binning mode will have
> to wait until the Common Raw Sensor Model patches are merged, and then
> binning (and cropping?) be implemented using that.
>
> > +};
> > +
> > +/* Static settings, applied after a software reset */
> > +static const struct cci_reg_sequence imx175_init_regs[] = {
> > + /* misc control */
> > + { CCI_REG8(0x3020), 0x10 },
> > + { CCI_REG8(0x302d), 0x02 },
> > + { CCI_REG8(0x302f), 0x80 },
> > + { CCI_REG8(0x3032), 0xa3 },
> > + { CCI_REG8(0x3033), 0x20 },
> > + { CCI_REG8(0x3034), 0x24 },
> > + { CCI_REG8(0x3041), 0x15 },
> > + { CCI_REG8(0x3042), 0x87 },
> > + { CCI_REG8(0x3050), 0x35 },
> > + { CCI_REG8(0x3056), 0x57 },
> > + { CCI_REG8(0x305d), 0x41 },
> > + { CCI_REG8(0x3097), 0x69 },
> > + { CCI_REG8(0x3109), 0x41 },
> > + { CCI_REG8(0x3148), 0x3f },
> > + { CCI_REG8(0x330f), 0x07 },
> > + /* CSI-2 and INCK */
> > + { CCI_REG8(0x3364), 0x00 },
> > + { CCI_REG8(0x3368), 0x13 },
> > + { CCI_REG8(0x3369), 0x33 },
> > + /* ZNR */
> > + { CCI_REG8(0x4100), 0x0e },
> > + { CCI_REG8(0x4104), 0x32 },
> > + { CCI_REG8(0x4105), 0x32 },
> > + { CCI_REG8(0x4108), 0x01 },
> > + { CCI_REG8(0x4109), 0x7c },
> > + { CCI_REG8(0x410a), 0x00 },
> > + { CCI_REG8(0x410b), 0x00 },
> > + /*
> > + * PLL for a 19.2 MHz INCK: pre_pll_clk_div 9, pll multiplier 300,
> > + * vt_pix_clk_div 5, vt_sys_clk_div 1, op_pix_clk_div 5,
> > + * op_sys_clk_div 1 -> 640 Mbps/lane, 4 lanes.
> > + */
> > + { CCI_REG8(0x0301), 0x05 },
> > + { CCI_REG8(0x0303), 0x01 },
> > + { CCI_REG8(0x0305), 0x09 },
> > + { CCI_REG8(0x0309), 0x05 },
> > + { CCI_REG8(0x030b), 0x01 },
> > + { CCI_REG16(0x030c), 0x012c },
> > + { CCI_REG8(0x030e), 0x01 },
> > + { CCI_REG16(0x0342), IMX175_LLP },
> > + /* analog crop: full 3280x2464 array */
> > + { CCI_REG16(0x0344), 0 },
> > + { CCI_REG16(0x0346), 0 },
> > + { CCI_REG16(0x0348), IMX175_NATIVE_WIDTH - 1 },
> > + { CCI_REG16(0x034a), IMX175_NATIVE_HEIGHT - 1 },
> > + /* no scaling */
> > + { CCI_REG8(0x0401), 0x00 },
> > + { CCI_REG8(0x0405), 0x10 },
> > + /* timer */
> > + { CCI_REG8(0x3344), 0x57 },
> > + { CCI_REG8(0x3345), 0x1f },
> > + /* timing */
> > + { CCI_REG8(0x3370), 0x77 },
> > + { CCI_REG8(0x3371), 0x2f },
> > + { CCI_REG8(0x3372), 0x4f },
> > + { CCI_REG8(0x3373), 0x2f },
> > + { CCI_REG8(0x3374), 0x2f },
> > + { CCI_REG8(0x3375), 0x37 },
> > + { CCI_REG8(0x3376), 0x9f },
> > + { CCI_REG8(0x3377), 0x37 },
> > + { CCI_REG8(0x33c8), 0x01 },
> > + { CCI_REG16(0x33d4), IMX175_NATIVE_WIDTH },
> > + { CCI_REG16(0x33d6), IMX175_NATIVE_HEIGHT },
> > + { CCI_REG8(0x41c0), 0x01 },
> > +};
> > +
> > +static const s64 imx175_link_freqs[] = {
> > + IMX175_LINK_FREQ,
> > +};
> > +
> > +static const char * const imx175_test_pattern_menu[] = {
> > + "Disabled",
> > + "Solid Colour",
> > + "Colour Bars",
> > + "Fade to Grey Colour Bars",
> > + "PN9",
> > +};
> > +
> > +/* RGGB is the native order; flips shift the pattern */
> > +static const u32 imx175_mbus_codes[] = {
> > + MEDIA_BUS_FMT_SRGGB10_1X10, /* no flip */
> > + MEDIA_BUS_FMT_SGRBG10_1X10, /* hflip */
> > + MEDIA_BUS_FMT_SGBRG10_1X10, /* vflip */
> > + MEDIA_BUS_FMT_SBGGR10_1X10, /* hflip + vflip */
> > +};
> > +
> > +struct imx175 {
> > + struct device *dev;
> > + struct regmap *regmap;
> > + struct clk *xclk;
> > + struct gpio_desc *reset;
> > + struct regulator_bulk_data supplies[ARRAY_SIZE(imx175_supply_names)];
> > +
> > + struct v4l2_subdev sd;
> > + struct media_pad pad;
> > +
> > + struct v4l2_ctrl_handler ctrls;
> > + struct v4l2_ctrl *link_freq;
> > + struct v4l2_ctrl *pixel_rate;
> > + struct v4l2_ctrl *exposure;
> > + struct v4l2_ctrl *vblank;
> > + struct v4l2_ctrl *hblank;
> > + struct v4l2_ctrl *hflip;
> > + struct v4l2_ctrl *vflip;
> > +
> > + const struct imx175_mode *mode;
> > +};
> > +
> > +static inline struct imx175 *to_imx175(struct v4l2_subdev *sd)
> > +{
> > + return container_of(sd, struct imx175, sd);
> > +}
> > +
> > +static u32 imx175_mbus_code(struct imx175 *imx175)
> > +{
> > + unsigned int idx = 0;
> > +
> > + if (imx175->hflip && imx175->hflip->val)
>
> Is there a path where this is called before imx175->hflip has been
> initiialised? I couldn't see one by inspection.
>
> > + idx |= 1;
> > + if (imx175->vflip && imx175->vflip->val)
> > + idx |= 2;
> > +
> > + return imx175_mbus_codes[idx];
> > +}
> > +
> > +static void imx175_update_pad_format(struct imx175 *imx175,
> > + const struct imx175_mode *mode,
> > + struct v4l2_mbus_framefmt *fmt)
> > +{
> > + fmt->width = mode->width;
> > + fmt->height = mode->height;
> > + fmt->code = imx175_mbus_code(imx175);
> > + fmt->field = V4L2_FIELD_NONE;
> > + fmt->colorspace = V4L2_COLORSPACE_RAW;
> > + fmt->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
> > + fmt->quantization = V4L2_QUANTIZATION_FULL_RANGE;
> > + fmt->xfer_func = V4L2_XFER_FUNC_NONE;
> > +}
> > +
> > +static int imx175_set_ctrl(struct v4l2_ctrl *ctrl)
> > +{
> > + struct imx175 *imx175 = container_of(ctrl->handler, struct imx175, ctrls);
> > + int ret = 0;
> > +
> > + if (ctrl->id == V4L2_CID_VBLANK) {
> > + s64 max = imx175->mode->height + ctrl->val - IMX175_EXPOSURE_MARGIN;
> > +
> > + ret = __v4l2_ctrl_modify_range(imx175->exposure,
> > + imx175->exposure->minimum, max,
> > + imx175->exposure->step,
> > + min(imx175->exposure->default_value, max));
>
> I'd suggest you adopt the minimum as the default value, rather than
> trying to retain the default from when the control was initialised.
> Currently you default to the full 3280x2464 mode, and set the default
> exposure to be "mode->fll_default - IMX175_EXPOSURE_MARGIN". Switch to
> the binned mode and reduce the VBLANK, and you'll be in a situation
> where the default value won't be in the valid range, and this call
> will fail.
>
> > + if (ret)
> > + return ret;
> > + }
> > +
> > + /* Flips change the Bayer order, keep the active format in sync */
> > + if (ctrl->id == V4L2_CID_HFLIP || ctrl->id == V4L2_CID_VFLIP) {
> > + struct v4l2_subdev_state *state =
> > + v4l2_subdev_get_locked_active_state(&imx175->sd);
> > +
> > + v4l2_subdev_state_get_format(state, 0)->code =
> > + imx175_mbus_code(imx175);
> > + }
> > +
> > + if (!pm_runtime_get_if_in_use(imx175->dev))
> > + return 0;
> > +
> > + switch (ctrl->id) {
> > + case V4L2_CID_EXPOSURE:
> > + cci_write(imx175->regmap, IMX175_REG_EXPOSURE, ctrl->val, &ret);
> > + break;
> > + case V4L2_CID_ANALOGUE_GAIN:
> > + cci_write(imx175->regmap, IMX175_REG_ANALOG_GAIN, ctrl->val, &ret);
> > + break;
> > + case V4L2_CID_DIGITAL_GAIN:
> > + cci_write(imx175->regmap, IMX175_REG_DGAIN_GR, ctrl->val, &ret);
> > + cci_write(imx175->regmap, IMX175_REG_DGAIN_R, ctrl->val, &ret);
> > + cci_write(imx175->regmap, IMX175_REG_DGAIN_B, ctrl->val, &ret);
> > + cci_write(imx175->regmap, IMX175_REG_DGAIN_GB, ctrl->val, &ret);
> > + break;
> > + case V4L2_CID_VBLANK:
> > + cci_write(imx175->regmap, IMX175_REG_FRAME_LENGTH,
> > + imx175->mode->height + ctrl->val, &ret);
> > + break;
> > + case V4L2_CID_HFLIP:
> > + case V4L2_CID_VFLIP:
>
> Use v4l2_ctrl_cluster for these so that updating both only results in
> one call through set_ctrl. See imx290 for an example.
>
> > + cci_write(imx175->regmap, IMX175_REG_ORIENTATION,
> > + (imx175->hflip->val ? IMX175_HFLIP : 0) |
> > + (imx175->vflip->val ? IMX175_VFLIP : 0), &ret);
> > + break;
> > + case V4L2_CID_TEST_PATTERN:
> > + cci_write(imx175->regmap, IMX175_REG_TEST_PATTERN, ctrl->val, &ret);
> > + break;
> > + default:
> > + ret = -EINVAL;
> > + break;
> > + }
> > +
> > + pm_runtime_put(imx175->dev);
> > + return ret;
> > +}
> > +
> > +static const struct v4l2_ctrl_ops imx175_ctrl_ops = {
> > + .s_ctrl = imx175_set_ctrl,
> > +};
> > +
> > +static int imx175_init_controls(struct imx175 *imx175)
> > +{
> > + const struct imx175_mode *mode = &imx175_modes[0];
> > + struct v4l2_ctrl_handler *hdl = &imx175->ctrls;
> > + struct v4l2_fwnode_device_properties props;
> > + s64 vblank_def, hblank, exposure_max;
> > + int ret;
> > +
> > + ret = v4l2_fwnode_device_parse(imx175->dev, &props);
> > + if (ret)
> > + return ret;
> > +
> > + v4l2_ctrl_handler_init(hdl, 12);
> > +
> > + imx175->link_freq = v4l2_ctrl_new_int_menu(hdl, &imx175_ctrl_ops,
> > + V4L2_CID_LINK_FREQ,
> > + ARRAY_SIZE(imx175_link_freqs) - 1,
> > + 0, imx175_link_freqs);
> > + if (imx175->link_freq)
> > + imx175->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY;
>
> If the control is read-only, then pass NULL instead of
> &imx175_ctrl_ops as the control ops. Otherwise there are some paths
> where set_ctrl can be called and it'll hit your "default: ret =
> -EINVAL" case.
> Ditto for the other read only controls below.
>
> > +
> > + imx175->pixel_rate = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops,
> > + V4L2_CID_PIXEL_RATE,
> > + IMX175_PIXEL_RATE, IMX175_PIXEL_RATE,
> > + 1, IMX175_PIXEL_RATE);
> > +
> > + vblank_def = mode->fll_default - mode->height;
> > + imx175->vblank = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_VBLANK,
> > + IMX175_EXPOSURE_MARGIN,
>
> The minimum VBLANK period being the same as the exposure margin feels
> a little strange. It may be the case, but the two are usually
> disassociated.
>
> > + IMX175_FLL_MAX - mode->height, 1,
> > + vblank_def);
> > +
> > + hblank = IMX175_LLP - mode->width;
> > + imx175->hblank = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_HBLANK,
> > + hblank, hblank, 1, hblank);
> > + if (imx175->hblank)
> > + imx175->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY;
> > +
> > + exposure_max = mode->fll_default - IMX175_EXPOSURE_MARGIN;
> > + imx175->exposure = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops,
> > + V4L2_CID_EXPOSURE,
> > + IMX175_EXPOSURE_MIN, exposure_max, 1,
> > + exposure_max);
> > +
> > + v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_ANALOGUE_GAIN,
> > + IMX175_ANA_GAIN_MIN, IMX175_ANA_GAIN_MAX, 1,
> > + IMX175_ANA_GAIN_DEFAULT);
> > +
> > + v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_DIGITAL_GAIN,
> > + IMX175_DGAIN_MIN, IMX175_DGAIN_MAX, 1,
> > + IMX175_DGAIN_DEFAULT);
> > +
> > + imx175->hflip = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_HFLIP,
> > + 0, 1, 1, 0);
> > + if (imx175->hflip)
> > + imx175->hflip->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT;
> > +
> > + imx175->vflip = v4l2_ctrl_new_std(hdl, &imx175_ctrl_ops, V4L2_CID_VFLIP,
> > + 0, 1, 1, 0);
> > + if (imx175->vflip)
> > + imx175->vflip->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT;
> > +
> > + v4l2_ctrl_new_std_menu_items(hdl, &imx175_ctrl_ops, V4L2_CID_TEST_PATTERN,
> > + ARRAY_SIZE(imx175_test_pattern_menu) - 1,
> > + 0, 0, imx175_test_pattern_menu);
> > +
> > + v4l2_ctrl_new_fwnode_properties(hdl, &imx175_ctrl_ops, &props);
> > +
> > + if (hdl->error) {
> > + ret = hdl->error;
> > + v4l2_ctrl_handler_free(hdl);
> > + return ret;
> > + }
> > +
> > + imx175->sd.ctrl_handler = hdl;
> > + return 0;
> > +}
> > +
> > +static int imx175_enable_streams(struct v4l2_subdev *sd,
> > + struct v4l2_subdev_state *state, u32 pad,
> > + u64 streams_mask)
> > +{
> > + struct imx175 *imx175 = to_imx175(sd);
> > + const struct imx175_mode *mode = imx175->mode;
> > + int ret;
> > +
> > + ret = pm_runtime_resume_and_get(imx175->dev);
> > + if (ret)
> > + return ret;
> > +
> > + ret = cci_write(imx175->regmap, IMX175_REG_SW_RESET, 0x01, NULL);
> > + if (ret)
> > + goto err_put;
> > + usleep_range(5000, 6000);
> > +
> > + ret = cci_multi_reg_write(imx175->regmap, imx175_init_regs,
> > + ARRAY_SIZE(imx175_init_regs), NULL);
>
> The reset and imx175_init_regs could be sent from imx175_power_on. If
> combined with pm_runtime_autosuspend, then switching mode becomes just
> a handful of register writes.
>
> > + cci_write(imx175->regmap, IMX175_REG_X_OUTPUT_SIZE, mode->width, &ret);
> > + cci_write(imx175->regmap, IMX175_REG_Y_OUTPUT_SIZE, mode->height, &ret);
> > + cci_write(imx175->regmap, IMX175_REG_BINNING_MODE, mode->binning ? 1 : 0,
> > + &ret);
> > + if (ret)
> > + goto err_put;
> > +
> > + ret = __v4l2_ctrl_handler_setup(imx175->sd.ctrl_handler);
> > + if (ret)
> > + goto err_put;
> > +
> > + ret = cci_write(imx175->regmap, IMX175_REG_MODE_SELECT,
> > + IMX175_MODE_STREAMING, NULL);
> > + if (ret)
> > + goto err_put;
> > +
> > + /* Flips change the Bayer order; don't allow them while streaming */
> > + __v4l2_ctrl_grab(imx175->hflip, true);
> > + __v4l2_ctrl_grab(imx175->vflip, true);
> > + return 0;
> > +
> > +err_put:
> > + pm_runtime_put(imx175->dev);
> > + return ret;
> > +}
> > +
> > +static int imx175_disable_streams(struct v4l2_subdev *sd,
> > + struct v4l2_subdev_state *state, u32 pad,
> > + u64 streams_mask)
> > +{
> > + struct imx175 *imx175 = to_imx175(sd);
> > + int ret;
> > +
> > + ret = cci_write(imx175->regmap, IMX175_REG_MODE_SELECT,
> > + IMX175_MODE_STANDBY, NULL);
> > +
> > + __v4l2_ctrl_grab(imx175->hflip, false);
> > + __v4l2_ctrl_grab(imx175->vflip, false);
> > +
> > + pm_runtime_put(imx175->dev);
> > + return ret;
> > +}
> > +
> > +static int imx175_set_format(struct v4l2_subdev *sd,
> > + const struct v4l2_subdev_client_info *ci,
> > + struct v4l2_subdev_state *state,
> > + struct v4l2_subdev_format *fmt)
> > +{
> > + struct imx175 *imx175 = to_imx175(sd);
> > + const struct imx175_mode *mode;
> > + struct v4l2_mbus_framefmt *format;
> > + int ret;
> > +
> > + mode = v4l2_find_nearest_size(imx175_modes, ARRAY_SIZE(imx175_modes),
> > + width, height,
> > + fmt->format.width, fmt->format.height);
> > +
> > + imx175_update_pad_format(imx175, mode, &fmt->format);
> > + format = v4l2_subdev_state_get_format(state, 0);
> > + *format = fmt->format;
> > +
> > + if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
> > + return 0;
> > +
> > + imx175->mode = mode;
> > +
> > + ret = __v4l2_ctrl_modify_range(imx175->vblank, IMX175_EXPOSURE_MARGIN,
> > + IMX175_FLL_MAX - mode->height, 1,
> > + mode->fll_default - mode->height);
> > + if (ret)
> > + return ret;
> > + ret = __v4l2_ctrl_s_ctrl(imx175->vblank, mode->fll_default - mode->height);
> > + if (ret)
> > + return ret;
> > +
> > + return __v4l2_ctrl_modify_range(imx175->hblank,
> > + IMX175_LLP - mode->width,
> > + IMX175_LLP - mode->width, 1,
> > + IMX175_LLP - mode->width);
> > +}
> > +
> > +static int imx175_enum_mbus_code(struct v4l2_subdev *sd,
> > + struct v4l2_subdev_state *state,
> > + struct v4l2_subdev_mbus_code_enum *code)
> > +{
> > + if (code->index > 0)
> > + return -EINVAL;
> > +
> > + code->code = imx175_mbus_code(to_imx175(sd));
> > + return 0;
> > +}
> > +
> > +static int imx175_enum_frame_size(struct v4l2_subdev *sd,
> > + struct v4l2_subdev_state *state,
> > + struct v4l2_subdev_frame_size_enum *fse)
> > +{
> > + if (fse->index >= ARRAY_SIZE(imx175_modes))
> > + return -EINVAL;
> > +
> > + if (fse->code != imx175_mbus_code(to_imx175(sd)))
> > + return -EINVAL;
> > +
> > + fse->min_width = imx175_modes[fse->index].width;
> > + fse->max_width = fse->min_width;
> > + fse->min_height = imx175_modes[fse->index].height;
> > + fse->max_height = fse->min_height;
> > + return 0;
> > +}
> > +
> > +static int imx175_get_selection(struct v4l2_subdev *sd,
> > + const struct v4l2_subdev_client_info *ci,
> > + struct v4l2_subdev_state *state,
> > + struct v4l2_subdev_selection *sel)
> > +{
> > + switch (sel->target) {
> > + case V4L2_SEL_TGT_CROP:
> > + case V4L2_SEL_TGT_CROP_DEFAULT:
> > + case V4L2_SEL_TGT_CROP_BOUNDS:
> > + case V4L2_SEL_TGT_NATIVE_SIZE:
> > + sel->r.left = 0;
> > + sel->r.top = 0;
> > + sel->r.width = IMX175_NATIVE_WIDTH;
> > + sel->r.height = IMX175_NATIVE_HEIGHT;
> > + return 0;
> > + }
> > +
> > + return -EINVAL;
> > +}
> > +
> > +static int imx175_init_state(struct v4l2_subdev *sd,
> > + struct v4l2_subdev_state *state)
> > +{
> > + struct v4l2_subdev_format fmt = {
> > + .which = V4L2_SUBDEV_FORMAT_TRY,
> > + .pad = 0,
> > + .format = {
> > + .width = imx175_modes[0].width,
> > + .height = imx175_modes[0].height,
> > + },
> > + };
> > +
> > + return imx175_set_format(sd, NULL, state, &fmt);
> > +}
> > +
> > +static const struct v4l2_subdev_video_ops imx175_video_ops = {
> > + .s_stream = v4l2_subdev_s_stream_helper,
> > +};
> > +
> > +static const struct v4l2_subdev_pad_ops imx175_pad_ops = {
> > + .enum_mbus_code = imx175_enum_mbus_code,
> > + .enum_frame_size = imx175_enum_frame_size,
> > + .get_fmt = v4l2_subdev_get_fmt,
> > + .set_fmt = imx175_set_format,
> > + .get_selection = imx175_get_selection,
> > + .enable_streams = imx175_enable_streams,
> > + .disable_streams = imx175_disable_streams,
> > +};
> > +
> > +static const struct v4l2_subdev_ops imx175_subdev_ops = {
> > + .video = &imx175_video_ops,
> > + .pad = &imx175_pad_ops,
> > +};
> > +
> > +static const struct v4l2_subdev_internal_ops imx175_internal_ops = {
> > + .init_state = imx175_init_state,
> > +};
> > +
> > +static int imx175_power_on(struct device *dev)
> > +{
> > + struct v4l2_subdev *sd = dev_get_drvdata(dev);
> > + struct imx175 *imx175 = to_imx175(sd);
> > + int ret;
> > +
> > + ret = regulator_bulk_enable(ARRAY_SIZE(imx175->supplies),
> > + imx175->supplies);
> > + if (ret)
> > + return ret;
> > +
> > + ret = clk_prepare_enable(imx175->xclk);
> > + if (ret) {
> > + regulator_bulk_disable(ARRAY_SIZE(imx175->supplies),
> > + imx175->supplies);
> > + return ret;
> > + }
> > +
> > + usleep_range(1000, 2000);
> > + gpiod_set_value_cansleep(imx175->reset, 0);
> > + /* Wait for the sensor to come out of reset before using I2C */
> > + usleep_range(10000, 12000);
> > +
> > + return 0;
> > +}
> > +
> > +static int imx175_power_off(struct device *dev)
> > +{
> > + struct v4l2_subdev *sd = dev_get_drvdata(dev);
> > + struct imx175 *imx175 = to_imx175(sd);
> > +
> > + gpiod_set_value_cansleep(imx175->reset, 1);
> > + clk_disable_unprepare(imx175->xclk);
> > + regulator_bulk_disable(ARRAY_SIZE(imx175->supplies), imx175->supplies);
> > +
> > + return 0;
> > +}
> > +
> > +static int imx175_identify(struct imx175 *imx175)
> > +{
> > + u64 id;
> > + int ret;
> > +
> > + ret = cci_read(imx175->regmap, IMX175_REG_MODEL_ID, &id, NULL);
> > + if (ret)
> > + return dev_err_probe(imx175->dev, ret, "failed to read model id\n");
> > +
> > + if (id != IMX175_MODEL_ID)
> > + return dev_err_probe(imx175->dev, -ENODEV,
> > + "unexpected model id 0x%04llx\n", id);
> > +
> > + return 0;
> > +}
> > +
> > +static int imx175_check_hwcfg(struct imx175 *imx175)
> > +{
> > + struct v4l2_fwnode_endpoint bus_cfg = {
> > + .bus_type = V4L2_MBUS_CSI2_DPHY,
> > + };
> > + struct fwnode_handle *ep;
> > + unsigned long link_freq_bitmap;
> > + int ret;
> > +
> > + /* The endpoint is created by ipu-bridge on ACPI systems */
> > + ep = fwnode_graph_get_endpoint_by_id(dev_fwnode(imx175->dev), 0, 0, 0);
> > + if (!ep)
> > + return dev_err_probe(imx175->dev, -EPROBE_DEFER,
> > + "waiting for fwnode graph endpoint\n");
> > +
> > + ret = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg);
> > + fwnode_handle_put(ep);
> > + if (ret)
> > + return dev_err_probe(imx175->dev, ret, "parsing endpoint\n");
> > +
> > + if (bus_cfg.bus.mipi_csi2.num_data_lanes != IMX175_DATA_LANES) {
> > + ret = dev_err_probe(imx175->dev, -EINVAL,
> > + "%u data lanes not supported\n",
> > + bus_cfg.bus.mipi_csi2.num_data_lanes);
> > + goto out;
> > + }
> > +
> > + ret = v4l2_link_freq_to_bitmap(imx175->dev, bus_cfg.link_frequencies,
> > + bus_cfg.nr_of_link_frequencies,
> > + imx175_link_freqs,
> > + ARRAY_SIZE(imx175_link_freqs),
> > + &link_freq_bitmap);
> > +out:
> > + v4l2_fwnode_endpoint_free(&bus_cfg);
> > + return ret;
> > +}
> > +
> > +static int imx175_probe(struct i2c_client *client)
> > +{
> > + struct device *dev = &client->dev;
> > + struct imx175 *imx175;
> > + unsigned long rate;
> > + unsigned int i;
> > + int ret;
> > +
> > + imx175 = devm_kzalloc(dev, sizeof(*imx175), GFP_KERNEL);
> > + if (!imx175)
> > + return -ENOMEM;
> > +
> > + imx175->dev = dev;
> > + imx175->mode = &imx175_modes[0];
> > +
> > + ret = imx175_check_hwcfg(imx175);
> > + if (ret)
> > + return ret;
> > +
> > + imx175->regmap = devm_cci_regmap_init_i2c(client, 16);
> > + if (IS_ERR(imx175->regmap))
> > + return PTR_ERR(imx175->regmap);
> > +
> > + imx175->xclk = devm_v4l2_sensor_clk_get(dev, NULL);
> > + if (IS_ERR(imx175->xclk))
> > + return dev_err_probe(dev, PTR_ERR(imx175->xclk),
> > + "failed to get xclk\n");
> > +
> > + rate = clk_get_rate(imx175->xclk);
> > + if (rate != IMX175_XCLK_FREQ)
> > + return dev_err_probe(dev, -EINVAL,
> > + "unsupported xclk rate %lu Hz\n", rate);
> > +
> > + imx175->reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
> > + if (IS_ERR(imx175->reset))
> > + return dev_err_probe(dev, PTR_ERR(imx175->reset),
> > + "failed to get reset gpio\n");
> > +
> > + for (i = 0; i < ARRAY_SIZE(imx175_supply_names); i++)
> > + imx175->supplies[i].supply = imx175_supply_names[i];
> > +
> > + ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(imx175->supplies),
> > + imx175->supplies);
> > + if (ret)
> > + return dev_err_probe(dev, ret, "failed to get regulators\n");
> > +
> > + v4l2_i2c_subdev_init(&imx175->sd, client, &imx175_subdev_ops);
> > + imx175->sd.internal_ops = &imx175_internal_ops;
> > +
> > + ret = imx175_power_on(dev);
> > + if (ret)
> > + return ret;
> > +
> > + ret = imx175_identify(imx175);
> > + if (ret)
> > + goto err_power_off;
> > +
> > + ret = imx175_init_controls(imx175);
> > + if (ret)
> > + goto err_power_off;
> > +
> > + imx175->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
> > + imx175->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
> > + imx175->pad.flags = MEDIA_PAD_FL_SOURCE;
> > +
> > + ret = media_entity_pads_init(&imx175->sd.entity, 1, &imx175->pad);
> > + if (ret)
> > + goto err_free_ctrls;
> > +
> > + imx175->sd.state_lock = imx175->ctrls.lock;
> > + ret = v4l2_subdev_init_finalize(&imx175->sd);
> > + if (ret)
> > + goto err_entity_cleanup;
> > +
> > + pm_runtime_set_active(dev);
> > + pm_runtime_enable(dev);
>
> Use pm_runtime_autosuspend? It saves a little bit of time when
> switching modes on the sensor.
>
> > +
> > + ret = v4l2_async_register_subdev_sensor(&imx175->sd);
> > + if (ret)
> > + goto err_pm;
> > +
> > + pm_runtime_idle(dev);
> > + return 0;
> > +
> > +err_pm:
> > + pm_runtime_disable(dev);
> > + pm_runtime_set_suspended(dev);
> > + v4l2_subdev_cleanup(&imx175->sd);
> > +err_entity_cleanup:
> > + media_entity_cleanup(&imx175->sd.entity);
> > +err_free_ctrls:
> > + v4l2_ctrl_handler_free(&imx175->ctrls);
> > +err_power_off:
> > + imx175_power_off(dev);
> > + return ret;
> > +}
> > +
> > +static void imx175_remove(struct i2c_client *client)
> > +{
> > + struct v4l2_subdev *sd = i2c_get_clientdata(client);
> > + struct imx175 *imx175 = to_imx175(sd);
> > +
> > + v4l2_async_unregister_subdev(sd);
> > + v4l2_subdev_cleanup(sd);
> > + media_entity_cleanup(&sd->entity);
> > + v4l2_ctrl_handler_free(&imx175->ctrls);
> > +
> > + pm_runtime_disable(&client->dev);
> > + if (!pm_runtime_status_suspended(&client->dev))
> > + imx175_power_off(&client->dev);
> > + pm_runtime_set_suspended(&client->dev);
> > +}
> > +
> > +static DEFINE_RUNTIME_DEV_PM_OPS(imx175_pm_ops, imx175_power_off,
> > + imx175_power_on, NULL);
> > +
> > +static const struct acpi_device_id imx175_acpi_ids[] = {
> > + { "INTCF1A" },
> > + { }
> > +};
> > +MODULE_DEVICE_TABLE(acpi, imx175_acpi_ids);
> > +
> > +static struct i2c_driver imx175_i2c_driver = {
> > + .driver = {
> > + .name = "imx175",
> > + .acpi_match_table = imx175_acpi_ids,
> > + .pm = pm_ptr(&imx175_pm_ops),
> > + },
> > + .probe = imx175_probe,
> > + .remove = imx175_remove,
> > +};
> > +module_i2c_driver(imx175_i2c_driver);
> > +
> > +MODULE_DESCRIPTION("Sony IMX175 sensor driver");
> > +MODULE_LICENSE("GPL");
>
> MODULE_AUTHOR?
>
> Hope that's helpful.
> Dave
>
> > --
> > 2.43.0
> >
> >
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH 2/3] media: ipu-bridge: Add Sony IMX175 (INTCF1A)
2026-11-16 17:51 ` [PATCH 2/3] media: ipu-bridge: Add Sony IMX175 (INTCF1A) Volodymyr Chapman
@ 2026-11-17 9:57 ` Andy Shevchenko
0 siblings, 0 replies; 8+ messages in thread
From: Andy Shevchenko @ 2026-11-17 9:57 UTC (permalink / raw)
To: Volodymyr Chapman
Cc: Sakari Ailus, Mauro Carvalho Chehab, Dan Scally, Hans de Goede,
Andy Shevchenko, Greg Kroah-Hartman, linux-media, linux-staging,
linux-kernel
On Mon, Nov 16, 2026 at 05:51:50PM +0000, Volodymyr Chapman wrote:
> Add the ACPI HID which the Lenovo ThinkPad 10 (20C1/20C3) uses for its
> Sony IMX175 rear camera, with the 320 MHz link frequency supported by the
> imx175 driver, so that ipu-bridge creates the fwnode graph for it. On
> this Bay Trail machine ipu-bridge is used through the atomisp
> csi2-bridge.
>
> Tested on a Lenovo ThinkPad 10 (20C3) together with the rest of this
> series: the IMX175 is found ("Found supported sensor INTCF1A:00") and
> streams through atomisp.
Enough to mention this in the cover letter message.
> This patch was drafted with the help of an AI coding assistant (Claude)
> and tested on the hardware by the submitter.
This paragraph needs to be once in a cover letter, no need to have it in the
individual commit messages.
...
Since the ACPI HID here is broken (it's actually a PNP ID), can you also
provide (as a comment) the excerpt from DSDT to show that device description?
--
With Best Regards,
Andy Shevchenko
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH 0/3] media: Add Sony IMX175 sensor driver (Lenovo ThinkPad 10 rear camera)
2026-11-16 17:51 [PATCH 0/3] media: Add Sony IMX175 sensor driver (Lenovo ThinkPad 10 rear camera) Volodymyr Chapman
` (2 preceding siblings ...)
2026-11-16 17:51 ` [PATCH 3/3] media: atomisp: csi2-bridge: Add IMX175 sensor config Volodymyr Chapman
@ 2026-11-17 10:08 ` Andy Shevchenko
3 siblings, 0 replies; 8+ messages in thread
From: Andy Shevchenko @ 2026-11-17 10:08 UTC (permalink / raw)
To: Volodymyr Chapman
Cc: Sakari Ailus, Mauro Carvalho Chehab, Dan Scally, Hans de Goede,
Andy Shevchenko, Greg Kroah-Hartman, linux-media, linux-staging,
linux-kernel
On Mon, Nov 16, 2026 at 05:51:48PM +0000, Volodymyr Chapman wrote:
> This series adds support for the Sony IMX175 8 Mpixel raw sensor, the
> rear camera of the Lenovo ThinkPad 10 (20C1/20C3, Bay Trail), using the
> atomisp driver through its v4l2-async csi2-bridge path:
>
> 1. a new standard sensor driver, drivers/media/i2c/imx175.c;
> 2. the INTCF1A ACPI HID in ipu-bridge;
> 3. a 4-lane sensor config entry for INTCF1A in the atomisp csi2-bridge.
>
> Notes for testing on this machine:
>
> - The firmware exposes the ISP in "ACPI mode" by default (subdevice of
> the IGD), which atomisp does not support. The hidden BIOS setup option
> "ISP PCI Device Selection" (Setup variable offset 0x235, value 2 =
> "ISP PCI Device as B0D3F0") must be set for the ISP to appear as PCI
> device 00:03.0.
> - The IMX175 probe fails intermittently at boot (-EREMOTEIO) without
> "media: atomisp: csi2-bridge: Don't cycle the PMC clock if its rate is
> correct", sent separately [1]. With it, the probe succeeded on 10 out
> of 10 boots in my testing; without it on 8 out of 10.
> - The OV2722 front camera of the same machine needs "media: atomisp:
> ov2722: Report SGRBG10 consistently as media bus code", also sent
> separately [2], but is not otherwise related to this series.
>
> [1] https://lore.kernel.org/linux-media/20261116173307.14169-1-volodymyrchapman@gmail.com/
> [2] https://lore.kernel.org/linux-media/20261116173143.13584-1-volodymyrchapman@gmail.com/
> Not supported: the voice coil motor (the firmware does not name its
> type) and the LM3554 flash.
Why not flash? It's in the kernel provided by drivers/leds/leds-lm355x.c
> No DT binding is added, as the sensor is only known to be used on ACPI
> systems; one can be added when a DT user appears.
>
> This series was developed with the help of an AI coding assistant
> (Claude), which wrote most of the driver code and commit messages based
> on Intel's register tables, existing sensor drivers and my testing on
> the hardware. I have reviewed the series and tested it as described
> above.
--
With Best Regards,
Andy Shevchenko
^ permalink raw reply [flat|nested] 8+ messages in thread
end of thread, other threads:[~2026-11-17 10:08 UTC | newest]
Thread overview: 8+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-16 17:51 [PATCH 0/3] media: Add Sony IMX175 sensor driver (Lenovo ThinkPad 10 rear camera) Volodymyr Chapman
2026-11-16 17:51 ` [PATCH 1/3] media: i2c: Add Sony IMX175 sensor driver Volodymyr Chapman
2026-11-16 19:25 ` Dave Stevenson
2026-11-16 23:09 ` Volodymyr Chapman
2026-11-16 17:51 ` [PATCH 2/3] media: ipu-bridge: Add Sony IMX175 (INTCF1A) Volodymyr Chapman
2026-11-17 9:57 ` Andy Shevchenko
2026-11-16 17:51 ` [PATCH 3/3] media: atomisp: csi2-bridge: Add IMX175 sensor config Volodymyr Chapman
2026-11-17 10:08 ` [PATCH 0/3] media: Add Sony IMX175 sensor driver (Lenovo ThinkPad 10 rear camera) Andy Shevchenko
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®