brcm2708: rename target to bcm27xx

This change makes the names of Broadcom targets consistent by using
the common notation based on SoC/CPU ID (which is used internally
anyway), bcmXXXX instead of brcmXXXX.
This is even used for target TITLE in make menuconfig already,
only the short target name used brcm so far.

Despite, since subtargets range from bcm2708 to bcm2711, it seems
appropriate to use bcm27xx instead of bcm2708 (again, as already done
for BOARDNAME).

This also renames the packages brcm2708-userland and brcm2708-gpu-fw.

Signed-off-by: Adrian Schmutzler <freifunk@adrianschmutzler.de>
Acked-by: Álvaro Fernández Rojas <noltari@gmail.com>

1 files changed, 1146 insertions, 0 deletions

diff --git a/target/linux/bcm27xx/patches-4.19/950-0678-media-i2c-Add-driver-for-Sony-IMX219-sensor.patch b/target/linux/bcm27xx/patches-4.19/950-0678-media-i2c-Add-driver-for-Sony-IMX219-sensor.patch
new file mode 100644
index 0000000000..70b9d54c4e
--- /dev/null
+++ b/target/linux/bcm27xx/patches-4.19/950-0678-media-i2c-Add-driver-for-Sony-IMX219-sensor.patch
@@ -0,0 +1,1146 @@
+From 2186344c6d83ccd169e16c048c8b43aff95545e2 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
+@@ -597,6 +597,17 @@ config VIDEO_APTINA_PLL
+ config VIDEO_SMIAPP_PLL
+ 	tristate
+ 
++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
+@@ -106,6 +106,7 @@ obj-$(CONFIG_VIDEO_I2C)		+= video-i2c.o
+ obj-$(CONFIG_VIDEO_ML86V7667)	+= ml86v7667.o
+ obj-$(CONFIG_VIDEO_OV2659)	+= ov2659.o
+ obj-$(CONFIG_VIDEO_TC358743)	+= tc358743.o
++obj-$(CONFIG_VIDEO_IMX219)	+= imx219.o
+ obj-$(CONFIG_VIDEO_IMX258)	+= imx258.o
+ obj-$(CONFIG_VIDEO_IMX274)	+= imx274.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");