bcm27xx: add linux 5.4 support

Tested on bcm2710 (Raspberry Pi 3B).

Signed-off-by: Álvaro Fernández Rojas <noltari@gmail.com>

1 files changed, 1146 insertions, 0 deletions

diff --git a/target/linux/bcm27xx/patches-5.4/950-0312-media-i2c-Add-driver-for-Sony-IMX219-sensor.patch b/target/linux/bcm27xx/patches-5.4/950-0312-media-i2c-Add-driver-for-Sony-IMX219-sensor.patch
new file mode 100644
index 0000000000..0880d419c7
--- /dev/null
+++ b/target/linux/bcm27xx/patches-5.4/950-0312-media-i2c-Add-driver-for-Sony-IMX219-sensor.patch
@@ -0,0 +1,1146 @@
+From 8436bbdd722445870c514d889eb082155f88dde1 Mon Sep 17 00:00:00 2001
+From: Dave Stevenson <dave.stevenson@raspberrypi.org>
+Date: Wed, 28 Aug 2019 13:34:49 +0100
+Subject: [PATCH] media: i2c: Add driver for Sony IMX219 sensor
+
+Adds a driver for the 8MPix Sony IMX219 CSI2 sensor.
+Whilst the sensor supports 2 or 4 CSI2 data lanes, this driver
+currently only supports 2 lanes.
+8MPix @ 15fps, 1080P @ 30fps (cropped FOV), and 1640x1232 (2x2 binned)
+@ 30fps are currently supported.
+
+Signed-off-by: Dave Stevenson <dave.stevenson@raspberrypi.org>
+Tested-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
+---
+ drivers/media/i2c/Kconfig  |   11 +
+ drivers/media/i2c/Makefile |    1 +
+ drivers/media/i2c/imx219.c | 1093 ++++++++++++++++++++++++++++++++++++
+ 3 files changed, 1105 insertions(+)
+ create mode 100644 drivers/media/i2c/imx219.c
+
+--- a/drivers/media/i2c/Kconfig
++++ b/drivers/media/i2c/Kconfig
+@@ -578,6 +578,17 @@ config VIDEO_IMX214
+ 	  To compile this driver as a module, choose M here: the
+ 	  module will be called imx214.
+ 
++config VIDEO_IMX219
++	tristate "Sony IMX219 sensor support"
++	depends on I2C && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
++	depends on MEDIA_CAMERA_SUPPORT
++	help
++	  This is a Video4Linux2 sensor driver for the Sony
++	  IMX219 camera.
++
++	  To compile this driver as a module, choose M here: the
++	  module will be called imx219.
++
+ config VIDEO_IMX258
+ 	tristate "Sony IMX258 sensor support"
+ 	depends on I2C && VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
+--- a/drivers/media/i2c/Makefile
++++ b/drivers/media/i2c/Makefile
+@@ -110,6 +110,7 @@ obj-$(CONFIG_VIDEO_ML86V7667)	+= ml86v76
+ obj-$(CONFIG_VIDEO_OV2659)	+= ov2659.o
+ obj-$(CONFIG_VIDEO_TC358743)	+= tc358743.o
+ obj-$(CONFIG_VIDEO_IMX214)	+= imx214.o
++obj-$(CONFIG_VIDEO_IMX219)	+= imx219.o
+ obj-$(CONFIG_VIDEO_IMX258)	+= imx258.o
+ obj-$(CONFIG_VIDEO_IMX274)	+= imx274.o
+ obj-$(CONFIG_VIDEO_IMX319)	+= imx319.o
+--- /dev/null
++++ b/drivers/media/i2c/imx219.c
+@@ -0,0 +1,1093 @@
++// SPDX-License-Identifier: GPL-2.0
++/*
++ * A V4L2 driver for Sony IMX219 cameras.
++ * Copyright (C) 2019, Raspberry Pi (Trading) Ltd
++ *
++ * Based on Sony imx258 camera driver
++ * Copyright (C) 2018 Intel Corporation
++ *
++ * DT / fwnode changes, and regulator / GPIO control taken from ov5640.c
++ * Copyright (C) 2011-2013 Freescale Semiconductor, Inc. All Rights Reserved.
++ * Copyright (C) 2014-2017 Mentor Graphics Inc.
++ *
++ */
++
++#include <linux/clk.h>
++#include <linux/clk-provider.h>
++#include <linux/clkdev.h>
++#include <linux/delay.h>
++#include <linux/gpio/consumer.h>
++#include <linux/i2c.h>
++#include <linux/module.h>
++#include <linux/pm_runtime.h>
++#include <linux/regulator/consumer.h>
++#include <media/v4l2-ctrls.h>
++#include <media/v4l2-device.h>
++#include <media/v4l2-fwnode.h>
++#include <media/v4l2-mediabus.h>
++#include <asm/unaligned.h>
++
++#define IMX219_REG_VALUE_08BIT		1
++#define IMX219_REG_VALUE_16BIT		2
++
++#define IMX219_REG_MODE_SELECT		0x0100
++#define IMX219_MODE_STANDBY		0x00
++#define IMX219_MODE_STREAMING		0x01
++
++/* Chip ID */
++#define IMX219_REG_CHIP_ID		0x0000
++#define IMX219_CHIP_ID			0x0219
++
++/* V_TIMING internal */
++#define IMX219_REG_VTS			0x0160
++#define IMX219_VTS_15FPS		0x0dc6
++#define IMX219_VTS_30FPS_1080P		0x06e3
++#define IMX219_VTS_30FPS_BINNED		0x06e3
++#define IMX219_VTS_MAX			0xffff
++
++/*Frame Length Line*/
++#define IMX219_FLL_MIN			0x08a6
++#define IMX219_FLL_MAX			0xffff
++#define IMX219_FLL_STEP			1
++#define IMX219_FLL_DEFAULT		0x0c98
++
++/* HBLANK control - read only */
++#define IMX219_PPL_DEFAULT		5352
++
++/* Exposure control */
++#define IMX219_REG_EXPOSURE		0x015a
++#define IMX219_EXPOSURE_MIN		4
++#define IMX219_EXPOSURE_STEP		1
++#define IMX219_EXPOSURE_DEFAULT		0x640
++#define IMX219_EXPOSURE_MAX		65535
++
++/* Analog gain control */
++#define IMX219_REG_ANALOG_GAIN		0x0157
++#define IMX219_ANA_GAIN_MIN		0
++#define IMX219_ANA_GAIN_MAX		232
++#define IMX219_ANA_GAIN_STEP		1
++#define IMX219_ANA_GAIN_DEFAULT		0x0
++
++/* Digital gain control */
++#define IMX219_REG_DIGITAL_GAIN		0x0158
++#define IMX219_DGTL_GAIN_MIN		0x0100
++#define IMX219_DGTL_GAIN_MAX		0x0fff
++#define IMX219_DGTL_GAIN_DEFAULT	0x0100
++#define IMX219_DGTL_GAIN_STEP		1
++
++/* Test Pattern Control */
++#define IMX219_REG_TEST_PATTERN		0x0600
++#define IMX219_TEST_PATTERN_DISABLE	0
++#define IMX219_TEST_PATTERN_SOLID_COLOR	1
++#define IMX219_TEST_PATTERN_COLOR_BARS	2
++#define IMX219_TEST_PATTERN_GREY_COLOR	3
++#define IMX219_TEST_PATTERN_PN9		4
++
++struct imx219_reg {
++	u16 address;
++	u8 val;
++};
++
++struct imx219_reg_list {
++	u32 num_of_regs;
++	const struct imx219_reg *regs;
++};
++
++/* Mode : resolution and related config&values */
++struct imx219_mode {
++	/* Frame width */
++	u32 width;
++	/* Frame height */
++	u32 height;
++
++	/* V-timing */
++	u32 vts_def;
++
++	/* Default register values */
++	struct imx219_reg_list reg_list;
++};
++
++/*
++ * Register sets lifted off the i2C interface from the Raspberry Pi firmware
++ * driver.
++ * 3280x2464 = mode 2, 1920x1080 = mode 1, and 1640x1232 = mode 4.
++ */
++static const struct imx219_reg mode_3280x2464_regs[] = {
++	{0x0100, 0x00},
++	{0x30eb, 0x0c},
++	{0x30eb, 0x05},
++	{0x300a, 0xff},
++	{0x300b, 0xff},
++	{0x30eb, 0x05},
++	{0x30eb, 0x09},
++	{0x0114, 0x01},
++	{0x0128, 0x00},
++	{0x012a, 0x18},
++	{0x012b, 0x00},
++	{0x0164, 0x00},
++	{0x0165, 0x00},
++	{0x0166, 0x0c},
++	{0x0167, 0xcf},
++	{0x0168, 0x00},
++	{0x0169, 0x00},
++	{0x016a, 0x09},
++	{0x016b, 0x9f},
++	{0x016c, 0x0c},
++	{0x016d, 0xd0},
++	{0x016e, 0x09},
++	{0x016f, 0xa0},
++	{0x0170, 0x01},
++	{0x0171, 0x01},
++	{0x0174, 0x00},
++	{0x0175, 0x00},
++	{0x018c, 0x0a},
++	{0x018d, 0x0a},
++	{0x0301, 0x05},
++	{0x0303, 0x01},
++	{0x0304, 0x03},
++	{0x0305, 0x03},
++	{0x0306, 0x00},
++	{0x0307, 0x39},
++	{0x0309, 0x0a},
++	{0x030b, 0x01},
++	{0x030c, 0x00},
++	{0x030d, 0x72},
++	{0x0624, 0x0c},
++	{0x0625, 0xd0},
++	{0x0626, 0x09},
++	{0x0627, 0xa0},
++	{0x455e, 0x00},
++	{0x471e, 0x4b},
++	{0x4767, 0x0f},
++	{0x4750, 0x14},
++	{0x4540, 0x00},
++	{0x47b4, 0x14},
++	{0x4713, 0x30},
++	{0x478b, 0x10},
++	{0x478f, 0x10},
++	{0x4793, 0x10},
++	{0x4797, 0x0e},
++	{0x479b, 0x0e},
++
++	{0x0172, 0x03},
++	{0x0162, 0x0d},
++	{0x0163, 0x78},
++};
++
++static const struct imx219_reg mode_1920_1080_regs[] = {
++	{0x0100, 0x00},
++	{0x30eb, 0x05},
++	{0x30eb, 0x0c},
++	{0x300a, 0xff},
++	{0x300b, 0xff},
++	{0x30eb, 0x05},
++	{0x30eb, 0x09},
++	{0x0114, 0x01},
++	{0x0128, 0x00},
++	{0x012a, 0x18},
++	{0x012b, 0x00},
++	{0x0162, 0x0d},
++	{0x0163, 0x78},
++	{0x0164, 0x02},
++	{0x0165, 0xa8},
++	{0x0166, 0x0a},
++	{0x0167, 0x27},
++	{0x0168, 0x02},
++	{0x0169, 0xb4},
++	{0x016a, 0x06},
++	{0x016b, 0xeb},
++	{0x016c, 0x07},
++	{0x016d, 0x80},
++	{0x016e, 0x04},
++	{0x016f, 0x38},
++	{0x0170, 0x01},
++	{0x0171, 0x01},
++	{0x0174, 0x00},
++	{0x0175, 0x00},
++	{0x018c, 0x0a},
++	{0x018d, 0x0a},
++	{0x0301, 0x05},
++	{0x0303, 0x01},
++	{0x0304, 0x03},
++	{0x0305, 0x03},
++	{0x0306, 0x00},
++	{0x0307, 0x39},
++	{0x0309, 0x0a},
++	{0x030b, 0x01},
++	{0x030c, 0x00},
++	{0x030d, 0x72},
++	{0x455e, 0x00},
++	{0x471e, 0x4b},
++	{0x4767, 0x0f},
++	{0x4750, 0x14},
++	{0x4540, 0x00},
++	{0x47b4, 0x14},
++	{0x4713, 0x30},
++	{0x478b, 0x10},
++	{0x478f, 0x10},
++	{0x4793, 0x10},
++	{0x4797, 0x0e},
++	{0x479b, 0x0e},
++
++	{0x0172, 0x03},
++	{0x0162, 0x0d},
++	{0x0163, 0x78},
++};
++
++static const struct imx219_reg mode_1640_1232_regs[] = {
++	{0x30eb, 0x0c},
++	{0x30eb, 0x05},
++	{0x300a, 0xff},
++	{0x300b, 0xff},
++	{0x30eb, 0x05},
++	{0x30eb, 0x09},
++	{0x0114, 0x01},
++	{0x0128, 0x00},
++	{0x012a, 0x18},
++	{0x012b, 0x00},
++	{0x0164, 0x00},
++	{0x0165, 0x00},
++	{0x0166, 0x0c},
++	{0x0167, 0xcf},
++	{0x0168, 0x00},
++	{0x0169, 0x00},
++	{0x016a, 0x09},
++	{0x016b, 0x9f},
++	{0x016c, 0x06},
++	{0x016d, 0x68},
++	{0x016e, 0x04},
++	{0x016f, 0xd0},
++	{0x0170, 0x01},
++	{0x0171, 0x01},
++	{0x0174, 0x01},
++	{0x0175, 0x01},
++	{0x018c, 0x0a},
++	{0x018d, 0x0a},
++	{0x0301, 0x05},
++	{0x0303, 0x01},
++	{0x0304, 0x03},
++	{0x0305, 0x03},
++	{0x0306, 0x00},
++	{0x0307, 0x39},
++	{0x0309, 0x0a},
++	{0x030b, 0x01},
++	{0x030c, 0x00},
++	{0x030d, 0x72},
++	{0x455e, 0x00},
++	{0x471e, 0x4b},
++	{0x4767, 0x0f},
++	{0x4750, 0x14},
++	{0x4540, 0x00},
++	{0x47b4, 0x14},
++	{0x4713, 0x30},
++	{0x478b, 0x10},
++	{0x478f, 0x10},
++	{0x4793, 0x10},
++	{0x4797, 0x0e},
++	{0x479b, 0x0e},
++
++	{0x0172, 0x03},
++	{0x0162, 0x0d},
++	{0x0163, 0x78},
++};
++
++static const char * const imx219_test_pattern_menu[] = {
++	"Disabled",
++	"Color Bars",
++	"Solid Color",
++	"Grey Color Bars",
++	"PN9"
++};
++
++static const int imx219_test_pattern_val[] = {
++	IMX219_TEST_PATTERN_DISABLE,
++	IMX219_TEST_PATTERN_COLOR_BARS,
++	IMX219_TEST_PATTERN_SOLID_COLOR,
++	IMX219_TEST_PATTERN_GREY_COLOR,
++	IMX219_TEST_PATTERN_PN9,
++};
++
++/* regulator supplies */
++static const char * const imx219_supply_name[] = {
++	/* Supplies can be enabled in any order */
++	"VANA",  /* Analog (2.8V) supply */
++	"VDIG",  /* Digital Core (1.8V) supply */
++	"VDDL",  /* IF (1.2V) supply */
++};
++
++#define IMX219_NUM_SUPPLIES ARRAY_SIZE(imx219_supply_name)
++
++#define IMX219_XCLR_DELAY_MS 10	/* Initialisation delay after XCLR low->high */
++
++/* Mode configs */
++static const struct imx219_mode supported_modes[] = {
++	{
++		/* 8MPix 15fps mode */
++		.width = 3280,
++		.height = 2464,
++		.vts_def = IMX219_VTS_15FPS,
++		.reg_list = {
++			.num_of_regs = ARRAY_SIZE(mode_3280x2464_regs),
++			.regs = mode_3280x2464_regs,
++		},
++	},
++	{
++		/* 1080P 30fps cropped */
++		.width = 1920,
++		.height = 1080,
++		.vts_def = IMX219_VTS_30FPS_1080P,
++		.reg_list = {
++			.num_of_regs = ARRAY_SIZE(mode_1920_1080_regs),
++			.regs = mode_1920_1080_regs,
++		},
++	},
++	{
++		/* 2x2 binned 30fps mode */
++		.width = 1640,
++		.height = 1232,
++		.vts_def = IMX219_VTS_30FPS_BINNED,
++		.reg_list = {
++			.num_of_regs = ARRAY_SIZE(mode_1640_1232_regs),
++			.regs = mode_1640_1232_regs,
++		},
++	},
++};
++
++struct imx219 {
++	struct v4l2_subdev sd;
++	struct media_pad pad;
++
++	struct v4l2_fwnode_endpoint ep; /* the parsed DT endpoint info */
++	struct clk *xclk; /* system clock to IMX219 */
++	u32 xclk_freq;
++
++	struct gpio_desc *xclr_gpio;
++	struct regulator_bulk_data supplies[IMX219_NUM_SUPPLIES];
++
++	struct v4l2_ctrl_handler ctrl_handler;
++	/* V4L2 Controls */
++	struct v4l2_ctrl *pixel_rate;
++	struct v4l2_ctrl *exposure;
++
++	/* Current mode */
++	const struct imx219_mode *mode;
++
++	/*
++	 * Mutex for serialized access:
++	 * Protect sensor module set pad format and start/stop streaming safely.
++	 */
++	struct mutex mutex;
++
++	int power_count;
++	/* Streaming on/off */
++	bool streaming;
++};
++
++static inline struct imx219 *to_imx219(struct v4l2_subdev *_sd)
++{
++	return container_of(_sd, struct imx219, sd);
++}
++
++/* Read registers up to 2 at a time */
++static int imx219_read_reg(struct imx219 *imx219, u16 reg, u32 len, u32 *val)
++{
++	struct i2c_client *client = v4l2_get_subdevdata(&imx219->sd);
++	struct i2c_msg msgs[2];
++	u8 addr_buf[2] = { reg >> 8, reg & 0xff };
++	u8 data_buf[4] = { 0, };
++	int ret;
++
++	if (len > 4)
++		return -EINVAL;
++
++	/* Write register address */
++	msgs[0].addr = client->addr;
++	msgs[0].flags = 0;
++	msgs[0].len = ARRAY_SIZE(addr_buf);
++	msgs[0].buf = addr_buf;
++
++	/* Read data from register */
++	msgs[1].addr = client->addr;
++	msgs[1].flags = I2C_M_RD;
++	msgs[1].len = len;
++	msgs[1].buf = &data_buf[4 - len];
++
++	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
++	if (ret != ARRAY_SIZE(msgs))
++		return -EIO;
++
++	*val = get_unaligned_be32(data_buf);
++
++	return 0;
++}
++
++/* Write registers up to 2 at a time */
++static int imx219_write_reg(struct imx219 *imx219, u16 reg, u32 len, u32 val)
++{
++	struct i2c_client *client = v4l2_get_subdevdata(&imx219->sd);
++	u8 buf[6];
++
++	if (len > 4)
++		return -EINVAL;
++
++	put_unaligned_be16(reg, buf);
++	put_unaligned_be32(val << (8 * (4 - len)), buf + 2);
++	if (i2c_master_send(client, buf, len + 2) != len + 2)
++		return -EIO;
++
++	return 0;
++}
++
++/* Write a list of registers */
++static int imx219_write_regs(struct imx219 *imx219,
++			     const struct imx219_reg *regs, u32 len)
++{
++	struct i2c_client *client = v4l2_get_subdevdata(&imx219->sd);
++	unsigned int i;
++	int ret;
++
++	for (i = 0; i < len; i++) {
++		ret = imx219_write_reg(imx219, regs[i].address, 1, regs[i].val);
++		if (ret) {
++			dev_err_ratelimited(&client->dev,
++					    "Failed to write reg 0x%4.4x. error = %d\n",
++					    regs[i].address, ret);
++
++			return ret;
++		}
++	}
++
++	return 0;
++}
++
++/* Power/clock management functions */
++static void imx219_power(struct imx219 *imx219, bool enable)
++{
++	gpiod_set_value_cansleep(imx219->xclr_gpio, enable ? 1 : 0);
++}
++
++static int imx219_set_power_on(struct imx219 *imx219)
++{
++	struct i2c_client *client = v4l2_get_subdevdata(&imx219->sd);
++	int ret;
++
++	ret = clk_prepare_enable(imx219->xclk);
++	if (ret) {
++		dev_err(&client->dev, "%s: failed to enable clock\n",
++			__func__);
++		return ret;
++	}
++
++	ret = regulator_bulk_enable(IMX219_NUM_SUPPLIES,
++				    imx219->supplies);
++	if (ret) {
++		dev_err(&client->dev, "%s: failed to enable regulators\n",
++			__func__);
++		goto xclk_off;
++	}
++
++	imx219_power(imx219, true);
++	msleep(IMX219_XCLR_DELAY_MS);
++
++	return 0;
++xclk_off:
++	clk_disable_unprepare(imx219->xclk);
++	return ret;
++}
++
++static void imx219_set_power_off(struct imx219 *imx219)
++{
++	imx219_power(imx219, false);
++	regulator_bulk_disable(IMX219_NUM_SUPPLIES, imx219->supplies);
++	clk_disable_unprepare(imx219->xclk);
++}
++
++static int imx219_set_power(struct imx219 *imx219, bool on)
++{
++	int ret = 0;
++
++	if (on) {
++		ret = imx219_set_power_on(imx219);
++		if (ret)
++			return ret;
++	} else {
++		imx219_set_power_off(imx219);
++	}
++
++	return 0;
++}
++
++/* Open sub-device */
++static int imx219_s_power(struct v4l2_subdev *sd, int on)
++{
++	struct imx219 *imx219 = to_imx219(sd);
++	int ret = 0;
++
++	mutex_lock(&imx219->mutex);
++
++	/*
++	 * If the power count is modified from 0 to != 0 or from != 0 to 0,
++	 * update the power state.
++	 */
++	if (imx219->power_count == !on) {
++		ret = imx219_set_power(imx219, !!on);
++		if (ret)
++			goto out;
++	}
++
++	/* Update the power count. */
++	imx219->power_count += on ? 1 : -1;
++	WARN_ON(imx219->power_count < 0);
++out:
++	mutex_unlock(&imx219->mutex);
++
++	return ret;
++}
++
++static int imx219_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
++{
++	struct v4l2_mbus_framefmt *try_fmt =
++		v4l2_subdev_get_try_format(sd, fh->pad, 0);
++
++	/* Initialize try_fmt */
++	try_fmt->width = supported_modes[0].width;
++	try_fmt->height = supported_modes[0].height;
++	try_fmt->code = MEDIA_BUS_FMT_SBGGR10_1X10;
++	try_fmt->field = V4L2_FIELD_NONE;
++
++	return 0;
++}
++
++static int imx219_set_ctrl(struct v4l2_ctrl *ctrl)
++{
++	struct imx219 *imx219 =
++		container_of(ctrl->handler, struct imx219, ctrl_handler);
++	struct i2c_client *client = v4l2_get_subdevdata(&imx219->sd);
++	int ret = 0;
++
++	/*
++	 * Applying V4L2 control value only happens
++	 * when power is up for streaming
++	 */
++	if (pm_runtime_get_if_in_use(&client->dev) == 0)
++		return 0;
++
++	switch (ctrl->id) {
++	case V4L2_CID_ANALOGUE_GAIN:
++		ret = imx219_write_reg(imx219, IMX219_REG_ANALOG_GAIN,
++				       IMX219_REG_VALUE_08BIT, ctrl->val);
++		break;
++	case V4L2_CID_EXPOSURE:
++		ret = imx219_write_reg(imx219, IMX219_REG_EXPOSURE,
++				       IMX219_REG_VALUE_16BIT, ctrl->val);
++		break;
++	case V4L2_CID_DIGITAL_GAIN:
++		ret = imx219_write_reg(imx219, IMX219_REG_DIGITAL_GAIN,
++				       IMX219_REG_VALUE_16BIT, ctrl->val);
++		break;
++	case V4L2_CID_TEST_PATTERN:
++		ret = imx219_write_reg(imx219, IMX219_REG_TEST_PATTERN,
++				       IMX219_REG_VALUE_16BIT,
++				       imx219_test_pattern_val[ctrl->val]);
++		break;
++	default:
++		dev_info(&client->dev,
++			 "ctrl(id:0x%x,val:0x%x) is not handled\n",
++			 ctrl->id, ctrl->val);
++		ret = -EINVAL;
++		break;
++	}
++
++	pm_runtime_put(&client->dev);
++
++	return ret;
++}
++
++static const struct v4l2_ctrl_ops imx219_ctrl_ops = {
++	.s_ctrl = imx219_set_ctrl,
++};
++
++static int imx219_enum_mbus_code(struct v4l2_subdev *sd,
++				 struct v4l2_subdev_pad_config *cfg,
++				 struct v4l2_subdev_mbus_code_enum *code)
++{
++	/* Only one bayer order(GRBG) is supported */
++	if (code->index > 0)
++		return -EINVAL;
++
++	code->code = MEDIA_BUS_FMT_SBGGR10_1X10;
++
++	return 0;
++}
++
++static int imx219_enum_frame_size(struct v4l2_subdev *sd,
++				  struct v4l2_subdev_pad_config *cfg,
++				  struct v4l2_subdev_frame_size_enum *fse)
++{
++	if (fse->index >= ARRAY_SIZE(supported_modes))
++		return -EINVAL;
++
++	if (fse->code != MEDIA_BUS_FMT_SBGGR10_1X10)
++		return -EINVAL;
++
++	fse->min_width = supported_modes[fse->index].width;
++	fse->max_width = fse->min_width;
++	fse->min_height = supported_modes[fse->index].height;
++	fse->max_height = fse->min_height;
++
++	return 0;
++}
++
++static void imx219_update_pad_format(const struct imx219_mode *mode,
++				     struct v4l2_subdev_format *fmt)
++{
++	fmt->format.width = mode->width;
++	fmt->format.height = mode->height;
++	fmt->format.code = MEDIA_BUS_FMT_SBGGR10_1X10;
++	fmt->format.field = V4L2_FIELD_NONE;
++}
++
++static int __imx219_get_pad_format(struct imx219 *imx219,
++				   struct v4l2_subdev_pad_config *cfg,
++				   struct v4l2_subdev_format *fmt)
++{
++	if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
++		fmt->format = *v4l2_subdev_get_try_format(&imx219->sd, cfg,
++							  fmt->pad);
++	else
++		imx219_update_pad_format(imx219->mode, fmt);
++
++	return 0;
++}
++
++static int imx219_get_pad_format(struct v4l2_subdev *sd,
++				 struct v4l2_subdev_pad_config *cfg,
++				 struct v4l2_subdev_format *fmt)
++{
++	struct imx219 *imx219 = to_imx219(sd);
++	int ret;
++
++	mutex_lock(&imx219->mutex);
++	ret = __imx219_get_pad_format(imx219, cfg, fmt);
++	mutex_unlock(&imx219->mutex);
++
++	return ret;
++}
++
++static int imx219_set_pad_format(struct v4l2_subdev *sd,
++				 struct v4l2_subdev_pad_config *cfg,
++				 struct v4l2_subdev_format *fmt)
++{
++	struct imx219 *imx219 = to_imx219(sd);
++	const struct imx219_mode *mode;
++	struct v4l2_mbus_framefmt *framefmt;
++
++	mutex_lock(&imx219->mutex);
++
++	/* Only one raw bayer(BGGR) order is supported */
++	fmt->format.code = MEDIA_BUS_FMT_SBGGR10_1X10;
++
++	mode = v4l2_find_nearest_size(supported_modes,
++				      ARRAY_SIZE(supported_modes),
++				      width, height,
++				      fmt->format.width, fmt->format.height);
++	imx219_update_pad_format(mode, fmt);
++	if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
++		framefmt = v4l2_subdev_get_try_format(sd, cfg, fmt->pad);
++		*framefmt = fmt->format;
++	} else {
++		imx219->mode = mode;
++	}
++
++	mutex_unlock(&imx219->mutex);
++
++	return 0;
++}
++
++/* Start streaming */
++static int imx219_start_streaming(struct imx219 *imx219)
++{
++	struct i2c_client *client = v4l2_get_subdevdata(&imx219->sd);
++	const struct imx219_reg_list *reg_list;
++	int ret;
++
++	/* Apply default values of current mode */
++	reg_list = &imx219->mode->reg_list;
++	ret = imx219_write_regs(imx219, reg_list->regs, reg_list->num_of_regs);
++	if (ret) {
++		dev_err(&client->dev, "%s failed to set mode\n", __func__);
++		return ret;
++	}
++
++	/*
++	 * Set VTS appropriately for frame rate control.
++	 * Currently fixed per mode.
++	 */
++	ret = imx219_write_reg(imx219, IMX219_REG_VTS,
++			       IMX219_REG_VALUE_16BIT, imx219->mode->vts_def);
++	if (ret)
++		return ret;
++
++	/* Apply customized values from user */
++	ret =  __v4l2_ctrl_handler_setup(imx219->sd.ctrl_handler);
++	if (ret)
++		return ret;
++
++	/* set stream on register */
++	return imx219_write_reg(imx219, IMX219_REG_MODE_SELECT,
++				IMX219_REG_VALUE_08BIT, IMX219_MODE_STREAMING);
++}
++
++/* Stop streaming */
++static int imx219_stop_streaming(struct imx219 *imx219)
++{
++	struct i2c_client *client = v4l2_get_subdevdata(&imx219->sd);
++	int ret;
++
++	/* set stream off register */
++	ret = imx219_write_reg(imx219, IMX219_REG_MODE_SELECT,
++			       IMX219_REG_VALUE_08BIT, IMX219_MODE_STANDBY);
++	if (ret)
++		dev_err(&client->dev, "%s failed to set stream\n", __func__);
++
++	/*
++	 * Return success even if it was an error, as there is nothing the
++	 * caller can do about it.
++	 */
++	return 0;
++}
++
++static int imx219_set_stream(struct v4l2_subdev *sd, int enable)
++{
++	struct imx219 *imx219 = to_imx219(sd);
++	struct i2c_client *client = v4l2_get_subdevdata(sd);
++	int ret = 0;
++
++	mutex_lock(&imx219->mutex);
++	if (imx219->streaming == enable) {
++		mutex_unlock(&imx219->mutex);
++		return 0;
++	}
++
++	if (enable) {
++		ret = pm_runtime_get_sync(&client->dev);
++		if (ret < 0) {
++			pm_runtime_put_noidle(&client->dev);
++			goto err_unlock;
++		}
++
++		/*
++		 * Apply default & customized values
++		 * and then start streaming.
++		 */
++		ret = imx219_start_streaming(imx219);
++		if (ret) {
++			pm_runtime_put(&client->dev);
++			goto err_unlock;
++		}
++	} else {
++		imx219_stop_streaming(imx219);
++		pm_runtime_put(&client->dev);
++	}
++
++	imx219->streaming = enable;
++	mutex_unlock(&imx219->mutex);
++
++	return ret;
++
++err_unlock:
++	mutex_unlock(&imx219->mutex);
++
++	return ret;
++}
++
++static int __maybe_unused imx219_suspend(struct device *dev)
++{
++	struct i2c_client *client = to_i2c_client(dev);
++	struct v4l2_subdev *sd = i2c_get_clientdata(client);
++	struct imx219 *imx219 = to_imx219(sd);
++
++	if (imx219->streaming)
++		imx219_stop_streaming(imx219);
++
++	return 0;
++}
++
++static int __maybe_unused imx219_resume(struct device *dev)
++{
++	struct i2c_client *client = to_i2c_client(dev);
++	struct v4l2_subdev *sd = i2c_get_clientdata(client);
++	struct imx219 *imx219 = to_imx219(sd);
++	int ret;
++
++	if (imx219->streaming) {
++		ret = imx219_start_streaming(imx219);
++		if (ret)
++			goto error;
++	}
++
++	return 0;
++
++error:
++	imx219_stop_streaming(imx219);
++	imx219->streaming = 0;
++	return ret;
++}
++
++static int imx219_get_regulators(struct imx219 *imx219)
++{
++	struct i2c_client *client = v4l2_get_subdevdata(&imx219->sd);
++	int i;
++
++	for (i = 0; i < IMX219_NUM_SUPPLIES; i++)
++		imx219->supplies[i].supply = imx219_supply_name[i];
++
++	return devm_regulator_bulk_get(&client->dev,
++				       IMX219_NUM_SUPPLIES,
++				       imx219->supplies);
++}
++
++/* Verify chip ID */
++static int imx219_identify_module(struct imx219 *imx219)
++{
++	struct i2c_client *client = v4l2_get_subdevdata(&imx219->sd);
++	int ret;
++	u32 val;
++
++	ret = imx219_set_power_on(imx219);
++	if (ret)
++		return ret;
++
++	ret = imx219_read_reg(imx219, IMX219_REG_CHIP_ID,
++			      IMX219_REG_VALUE_16BIT, &val);
++	if (ret) {
++		dev_err(&client->dev, "failed to read chip id %x\n",
++			IMX219_CHIP_ID);
++		goto power_off;
++	}
++
++	if (val != IMX219_CHIP_ID) {
++		dev_err(&client->dev, "chip id mismatch: %x!=%x\n",
++			IMX219_CHIP_ID, val);
++		ret = -EIO;
++	}
++
++power_off:
++	imx219_set_power_off(imx219);
++	return ret;
++}
++
++static const struct v4l2_subdev_core_ops imx219_core_ops = {
++	.s_power = imx219_s_power,
++};
++
++static const struct v4l2_subdev_video_ops imx219_video_ops = {
++	.s_stream = imx219_set_stream,
++};
++
++static const struct v4l2_subdev_pad_ops imx219_pad_ops = {
++	.enum_mbus_code = imx219_enum_mbus_code,
++	.get_fmt = imx219_get_pad_format,
++	.set_fmt = imx219_set_pad_format,
++	.enum_frame_size = imx219_enum_frame_size,
++};
++
++static const struct v4l2_subdev_ops imx219_subdev_ops = {
++	.core = &imx219_core_ops,
++	.video = &imx219_video_ops,
++	.pad = &imx219_pad_ops,
++};
++
++static const struct v4l2_subdev_internal_ops imx219_internal_ops = {
++	.open = imx219_open,
++};
++
++/* Initialize control handlers */
++static int imx219_init_controls(struct imx219 *imx219)
++{
++	struct i2c_client *client = v4l2_get_subdevdata(&imx219->sd);
++	struct v4l2_ctrl_handler *ctrl_hdlr;
++	int ret;
++
++	ctrl_hdlr = &imx219->ctrl_handler;
++	ret = v4l2_ctrl_handler_init(ctrl_hdlr, 8);
++	if (ret)
++		return ret;
++
++	mutex_init(&imx219->mutex);
++	ctrl_hdlr->lock = &imx219->mutex;
++
++	imx219->exposure = v4l2_ctrl_new_std(ctrl_hdlr, &imx219_ctrl_ops,
++					     V4L2_CID_EXPOSURE,
++					     IMX219_EXPOSURE_MIN,
++					     IMX219_EXPOSURE_MAX,
++					     IMX219_EXPOSURE_STEP,
++					     IMX219_EXPOSURE_DEFAULT);
++
++	v4l2_ctrl_new_std(ctrl_hdlr, &imx219_ctrl_ops, V4L2_CID_ANALOGUE_GAIN,
++			  IMX219_ANA_GAIN_MIN, IMX219_ANA_GAIN_MAX,
++			  IMX219_ANA_GAIN_STEP, IMX219_ANA_GAIN_DEFAULT);
++
++	v4l2_ctrl_new_std(ctrl_hdlr, &imx219_ctrl_ops, V4L2_CID_DIGITAL_GAIN,
++			  IMX219_DGTL_GAIN_MIN, IMX219_DGTL_GAIN_MAX,
++			  IMX219_DGTL_GAIN_STEP, IMX219_DGTL_GAIN_DEFAULT);
++
++	v4l2_ctrl_new_std_menu_items(ctrl_hdlr, &imx219_ctrl_ops,
++				     V4L2_CID_TEST_PATTERN,
++				     ARRAY_SIZE(imx219_test_pattern_menu) - 1,
++				     0, 0, imx219_test_pattern_menu);
++
++	if (ctrl_hdlr->error) {
++		ret = ctrl_hdlr->error;
++		dev_err(&client->dev, "%s control init failed (%d)\n",
++			__func__, ret);
++		goto error;
++	}
++
++	imx219->sd.ctrl_handler = ctrl_hdlr;
++
++	return 0;
++
++error:
++	v4l2_ctrl_handler_free(ctrl_hdlr);
++	mutex_destroy(&imx219->mutex);
++
++	return ret;
++}
++
++static void imx219_free_controls(struct imx219 *imx219)
++{
++	v4l2_ctrl_handler_free(imx219->sd.ctrl_handler);
++	mutex_destroy(&imx219->mutex);
++}
++
++static int imx219_probe(struct i2c_client *client,
++			const struct i2c_device_id *id)
++{
++	struct device *dev = &client->dev;
++	struct fwnode_handle *endpoint;
++	struct imx219 *imx219;
++	int ret;
++
++	imx219 = devm_kzalloc(&client->dev, sizeof(*imx219), GFP_KERNEL);
++	if (!imx219)
++		return -ENOMEM;
++
++	/* Initialize subdev */
++	v4l2_i2c_subdev_init(&imx219->sd, client, &imx219_subdev_ops);
++
++	/* Get CSI2 bus config */
++	endpoint = fwnode_graph_get_next_endpoint(dev_fwnode(&client->dev),
++						  NULL);
++	if (!endpoint) {
++		dev_err(dev, "endpoint node not found\n");
++		return -EINVAL;
++	}
++
++	ret = v4l2_fwnode_endpoint_parse(endpoint, &imx219->ep);
++	fwnode_handle_put(endpoint);
++	if (ret) {
++		dev_err(dev, "Could not parse endpoint\n");
++		return ret;
++	}
++
++	/* Get system clock (xclk) */
++	imx219->xclk = devm_clk_get(dev, "xclk");
++	if (IS_ERR(imx219->xclk)) {
++		dev_err(dev, "failed to get xclk\n");
++		return PTR_ERR(imx219->xclk);
++	}
++
++	imx219->xclk_freq = clk_get_rate(imx219->xclk);
++	if (imx219->xclk_freq != 24000000) {
++		dev_err(dev, "xclk frequency not supported: %d Hz\n",
++			imx219->xclk_freq);
++		return -EINVAL;
++	}
++
++	ret = imx219_get_regulators(imx219);
++	if (ret)
++		return ret;
++
++	/* request optional power down pin */
++	imx219->xclr_gpio = devm_gpiod_get_optional(dev, "xclr",
++						    GPIOD_OUT_HIGH);
++
++	/* Check module identity */
++	ret = imx219_identify_module(imx219);
++	if (ret)
++		return ret;
++
++	/* Set default mode to max resolution */
++	imx219->mode = &supported_modes[0];
++
++	ret = imx219_init_controls(imx219);
++	if (ret)
++		return ret;
++
++	/* Initialize subdev */
++	imx219->sd.internal_ops = &imx219_internal_ops;
++	imx219->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
++	imx219->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
++
++	/* Initialize source pad */
++	imx219->pad.flags = MEDIA_PAD_FL_SOURCE;
++
++	ret = media_entity_pads_init(&imx219->sd.entity, 1, &imx219->pad);
++	if (ret)
++		goto error_handler_free;
++
++	ret = v4l2_async_register_subdev_sensor_common(&imx219->sd);
++	if (ret < 0)
++		goto error_media_entity;
++
++	pm_runtime_set_active(&client->dev);
++	pm_runtime_enable(&client->dev);
++	pm_runtime_idle(&client->dev);
++
++	return 0;
++
++error_media_entity:
++	media_entity_cleanup(&imx219->sd.entity);
++
++error_handler_free:
++	imx219_free_controls(imx219);
++
++	return ret;
++}
++
++static int imx219_remove(struct i2c_client *client)
++{
++	struct v4l2_subdev *sd = i2c_get_clientdata(client);
++	struct imx219 *imx219 = to_imx219(sd);
++
++	v4l2_async_unregister_subdev(sd);
++	media_entity_cleanup(&sd->entity);
++	imx219_free_controls(imx219);
++
++	pm_runtime_disable(&client->dev);
++	pm_runtime_set_suspended(&client->dev);
++
++	return 0;
++}
++
++static const struct of_device_id imx219_dt_ids[] = {
++	{ .compatible = "sony,imx219" },
++	{ /* sentinel */ }
++};
++MODULE_DEVICE_TABLE(of, imx219_dt_ids);
++
++static struct i2c_driver imx219_i2c_driver = {
++	.driver = {
++		.name = "imx219",
++		.of_match_table	= imx219_dt_ids,
++	},
++	.probe = imx219_probe,
++	.remove = imx219_remove,
++};
++
++module_i2c_driver(imx219_i2c_driver);
++
++MODULE_AUTHOR("Dave Stevenson <dave.stevenson@raspberrypi.org");
++MODULE_DESCRIPTION("Sony IMX219 sensor driver");
++MODULE_LICENSE("GPL v2");