* [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
` (2 more replies)
0 siblings, 3 replies; 4+ 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] 4+ 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 17:51 ` [PATCH 2/3] media: ipu-bridge: Add Sony IMX175 (INTCF1A) Volodymyr Chapman
2026-11-16 17:51 ` [PATCH 3/3] media: atomisp: csi2-bridge: Add IMX175 sensor config Volodymyr Chapman
2 siblings, 0 replies; 4+ 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] 4+ 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-16 17:51 ` [PATCH 3/3] media: atomisp: csi2-bridge: Add IMX175 sensor config Volodymyr Chapman
2 siblings, 0 replies; 4+ 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] 4+ 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
2 siblings, 0 replies; 4+ 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] 4+ messages in thread
end of thread, other threads:[~2026-11-16 17:52 UTC | newest]
Thread overview: 4+ 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 17:51 ` [PATCH 2/3] media: ipu-bridge: Add Sony IMX175 (INTCF1A) Volodymyr Chapman
2026-11-16 17:51 ` [PATCH 3/3] media: atomisp: csi2-bridge: Add IMX175 sensor config Volodymyr Chapman
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®