ov5647.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * A V4L2 driver for OmniVision OV5647 cameras.
   4 *
   5 * Based on Samsung S5K6AAFX SXGA 1/6" 1.3M CMOS Image Sensor driver
   6 * Copyright (C) 2011 Sylwester Nawrocki <s.nawrocki@samsung.com>
   7 *
   8 * Based on Omnivision OV7670 Camera Driver
   9 * Copyright (C) 2006-7 Jonathan Corbet <corbet@lwn.net>
  10 *
  11 * Copyright (C) 2016, Synopsys, Inc.
  12 */
  13
  14#include <linux/clk.h>
  15#include <linux/delay.h>
  16#include <linux/gpio/consumer.h>
  17#include <linux/i2c.h>
  18#include <linux/init.h>
  19#include <linux/io.h>
  20#include <linux/module.h>
  21#include <linux/of_graph.h>
  22#include <linux/pm_runtime.h>
  23#include <linux/slab.h>
  24#include <linux/videodev2.h>
  25#include <media/v4l2-ctrls.h>
  26#include <media/v4l2-device.h>
  27#include <media/v4l2-event.h>
  28#include <media/v4l2-fwnode.h>
  29#include <media/v4l2-image-sizes.h>
  30#include <media/v4l2-mediabus.h>
  31
  32/*
  33 * From the datasheet, "20ms after PWDN goes low or 20ms after RESETB goes
  34 * high if reset is inserted after PWDN goes high, host can access sensor's
  35 * SCCB to initialize sensor."
  36 */
  37#define PWDN_ACTIVE_DELAY_MS	20
  38
  39#define MIPI_CTRL00_CLOCK_LANE_GATE		BIT(5)
  40#define MIPI_CTRL00_LINE_SYNC_ENABLE		BIT(4)
  41#define MIPI_CTRL00_BUS_IDLE			BIT(2)
  42#define MIPI_CTRL00_CLOCK_LANE_DISABLE		BIT(0)
  43
  44#define OV5647_SW_STANDBY		0x0100
  45#define OV5647_SW_RESET			0x0103
  46#define OV5647_REG_CHIPID_H		0x300a
  47#define OV5647_REG_CHIPID_L		0x300b
  48#define OV5640_REG_PAD_OUT		0x300d
  49#define OV5647_REG_EXP_HI		0x3500
  50#define OV5647_REG_EXP_MID		0x3501
  51#define OV5647_REG_EXP_LO		0x3502
  52#define OV5647_REG_AEC_AGC		0x3503
  53#define OV5647_REG_GAIN_HI		0x350a
  54#define OV5647_REG_GAIN_LO		0x350b
  55#define OV5647_REG_VTS_HI		0x380e
  56#define OV5647_REG_VTS_LO		0x380f
  57#define OV5647_REG_FRAME_OFF_NUMBER	0x4202
  58#define OV5647_REG_MIPI_CTRL00		0x4800
  59#define OV5647_REG_MIPI_CTRL14		0x4814
  60#define OV5647_REG_AWB			0x5001
  61#define OV5647_REG_ISPCTRL3D		0x503d
  62
  63#define REG_TERM 0xfffe
  64#define VAL_TERM 0xfe
  65#define REG_DLY  0xffff
  66
  67/* OV5647 native and active pixel array size */
  68#define OV5647_NATIVE_WIDTH		2624U
  69#define OV5647_NATIVE_HEIGHT		1956U
  70
  71#define OV5647_PIXEL_ARRAY_LEFT		16U
  72#define OV5647_PIXEL_ARRAY_TOP		6U
  73#define OV5647_PIXEL_ARRAY_WIDTH	2592U
  74#define OV5647_PIXEL_ARRAY_HEIGHT	1944U
  75
  76#define OV5647_VBLANK_MIN		24
  77#define OV5647_VTS_MAX			32767
  78
  79#define OV5647_EXPOSURE_MIN		4
  80#define OV5647_EXPOSURE_STEP		1
  81#define OV5647_EXPOSURE_DEFAULT		1000
  82#define OV5647_EXPOSURE_MAX		65535
  83
  84struct regval_list {
  85	u16 addr;
  86	u8 data;
  87};
  88
  89struct ov5647_mode {
  90	struct v4l2_mbus_framefmt	format;
  91	struct v4l2_rect		crop;
  92	u64				pixel_rate;
  93	int				hts;
  94	int				vts;
  95	const struct regval_list	*reg_list;
  96	unsigned int			num_regs;
  97};
  98
  99struct ov5647 {
 100	struct v4l2_subdev		sd;
 101	struct media_pad		pad;
 102	struct mutex			lock;
 103	struct clk			*xclk;
 104	struct gpio_desc		*pwdn;
 105	bool				clock_ncont;
 106	struct v4l2_ctrl_handler	ctrls;
 107	const struct ov5647_mode	*mode;
 108	struct v4l2_ctrl		*pixel_rate;
 109	struct v4l2_ctrl		*hblank;
 110	struct v4l2_ctrl		*vblank;
 111	struct v4l2_ctrl		*exposure;
 112};
 113
 114static inline struct ov5647 *to_sensor(struct v4l2_subdev *sd)
 115{
 116	return container_of(sd, struct ov5647, sd);
 117}
 118
 119static const char * const ov5647_test_pattern_menu[] = {
 120	"Disabled",
 121	"Color Bars",
 122	"Color Squares",
 123	"Random Data",
 124};
 125
 126static const u8 ov5647_test_pattern_val[] = {
 127	0x00,	/* Disabled */
 128	0x80,	/* Color Bars */
 129	0x82,	/* Color Squares */
 130	0x81,	/* Random Data */
 131};
 132
 133static const struct regval_list sensor_oe_disable_regs[] = {
 134	{0x3000, 0x00},
 135	{0x3001, 0x00},
 136	{0x3002, 0x00},
 137};
 138
 139static const struct regval_list sensor_oe_enable_regs[] = {
 140	{0x3000, 0x0f},
 141	{0x3001, 0xff},
 142	{0x3002, 0xe4},
 143};
 144
 145static struct regval_list ov5647_2592x1944_10bpp[] = {
 146	{0x0100, 0x00},
 147	{0x0103, 0x01},
 148	{0x3034, 0x1a},
 149	{0x3035, 0x21},
 150	{0x3036, 0x69},
 151	{0x303c, 0x11},
 152	{0x3106, 0xf5},
 153	{0x3821, 0x06},
 154	{0x3820, 0x00},
 155	{0x3827, 0xec},
 156	{0x370c, 0x03},
 157	{0x3612, 0x5b},
 158	{0x3618, 0x04},
 159	{0x5000, 0x06},
 160	{0x5002, 0x41},
 161	{0x5003, 0x08},
 162	{0x5a00, 0x08},
 163	{0x3000, 0x00},
 164	{0x3001, 0x00},
 165	{0x3002, 0x00},
 166	{0x3016, 0x08},
 167	{0x3017, 0xe0},
 168	{0x3018, 0x44},
 169	{0x301c, 0xf8},
 170	{0x301d, 0xf0},
 171	{0x3a18, 0x00},
 172	{0x3a19, 0xf8},
 173	{0x3c01, 0x80},
 174	{0x3b07, 0x0c},
 175	{0x380c, 0x0b},
 176	{0x380d, 0x1c},
 177	{0x3814, 0x11},
 178	{0x3815, 0x11},
 179	{0x3708, 0x64},
 180	{0x3709, 0x12},
 181	{0x3808, 0x0a},
 182	{0x3809, 0x20},
 183	{0x380a, 0x07},
 184	{0x380b, 0x98},
 185	{0x3800, 0x00},
 186	{0x3801, 0x00},
 187	{0x3802, 0x00},
 188	{0x3803, 0x00},
 189	{0x3804, 0x0a},
 190	{0x3805, 0x3f},
 191	{0x3806, 0x07},
 192	{0x3807, 0xa3},
 193	{0x3811, 0x10},
 194	{0x3813, 0x06},
 195	{0x3630, 0x2e},
 196	{0x3632, 0xe2},
 197	{0x3633, 0x23},
 198	{0x3634, 0x44},
 199	{0x3636, 0x06},
 200	{0x3620, 0x64},
 201	{0x3621, 0xe0},
 202	{0x3600, 0x37},
 203	{0x3704, 0xa0},
 204	{0x3703, 0x5a},
 205	{0x3715, 0x78},
 206	{0x3717, 0x01},
 207	{0x3731, 0x02},
 208	{0x370b, 0x60},
 209	{0x3705, 0x1a},
 210	{0x3f05, 0x02},
 211	{0x3f06, 0x10},
 212	{0x3f01, 0x0a},
 213	{0x3a08, 0x01},
 214	{0x3a09, 0x28},
 215	{0x3a0a, 0x00},
 216	{0x3a0b, 0xf6},
 217	{0x3a0d, 0x08},
 218	{0x3a0e, 0x06},
 219	{0x3a0f, 0x58},
 220	{0x3a10, 0x50},
 221	{0x3a1b, 0x58},
 222	{0x3a1e, 0x50},
 223	{0x3a11, 0x60},
 224	{0x3a1f, 0x28},
 225	{0x4001, 0x02},
 226	{0x4004, 0x04},
 227	{0x4000, 0x09},
 228	{0x4837, 0x19},
 229	{0x4800, 0x24},
 230	{0x3503, 0x03},
 231	{0x0100, 0x01},
 232};
 233
 234static struct regval_list ov5647_1080p30_10bpp[] = {
 235	{0x0100, 0x00},
 236	{0x0103, 0x01},
 237	{0x3034, 0x1a},
 238	{0x3035, 0x21},
 239	{0x3036, 0x62},
 240	{0x303c, 0x11},
 241	{0x3106, 0xf5},
 242	{0x3821, 0x06},
 243	{0x3820, 0x00},
 244	{0x3827, 0xec},
 245	{0x370c, 0x03},
 246	{0x3612, 0x5b},
 247	{0x3618, 0x04},
 248	{0x5000, 0x06},
 249	{0x5002, 0x41},
 250	{0x5003, 0x08},
 251	{0x5a00, 0x08},
 252	{0x3000, 0x00},
 253	{0x3001, 0x00},
 254	{0x3002, 0x00},
 255	{0x3016, 0x08},
 256	{0x3017, 0xe0},
 257	{0x3018, 0x44},
 258	{0x301c, 0xf8},
 259	{0x301d, 0xf0},
 260	{0x3a18, 0x00},
 261	{0x3a19, 0xf8},
 262	{0x3c01, 0x80},
 263	{0x3b07, 0x0c},
 264	{0x380c, 0x09},
 265	{0x380d, 0x70},
 266	{0x3814, 0x11},
 267	{0x3815, 0x11},
 268	{0x3708, 0x64},
 269	{0x3709, 0x12},
 270	{0x3808, 0x07},
 271	{0x3809, 0x80},
 272	{0x380a, 0x04},
 273	{0x380b, 0x38},
 274	{0x3800, 0x01},
 275	{0x3801, 0x5c},
 276	{0x3802, 0x01},
 277	{0x3803, 0xb2},
 278	{0x3804, 0x08},
 279	{0x3805, 0xe3},
 280	{0x3806, 0x05},
 281	{0x3807, 0xf1},
 282	{0x3811, 0x04},
 283	{0x3813, 0x02},
 284	{0x3630, 0x2e},
 285	{0x3632, 0xe2},
 286	{0x3633, 0x23},
 287	{0x3634, 0x44},
 288	{0x3636, 0x06},
 289	{0x3620, 0x64},
 290	{0x3621, 0xe0},
 291	{0x3600, 0x37},
 292	{0x3704, 0xa0},
 293	{0x3703, 0x5a},
 294	{0x3715, 0x78},
 295	{0x3717, 0x01},
 296	{0x3731, 0x02},
 297	{0x370b, 0x60},
 298	{0x3705, 0x1a},
 299	{0x3f05, 0x02},
 300	{0x3f06, 0x10},
 301	{0x3f01, 0x0a},
 302	{0x3a08, 0x01},
 303	{0x3a09, 0x4b},
 304	{0x3a0a, 0x01},
 305	{0x3a0b, 0x13},
 306	{0x3a0d, 0x04},
 307	{0x3a0e, 0x03},
 308	{0x3a0f, 0x58},
 309	{0x3a10, 0x50},
 310	{0x3a1b, 0x58},
 311	{0x3a1e, 0x50},
 312	{0x3a11, 0x60},
 313	{0x3a1f, 0x28},
 314	{0x4001, 0x02},
 315	{0x4004, 0x04},
 316	{0x4000, 0x09},
 317	{0x4837, 0x19},
 318	{0x4800, 0x34},
 319	{0x3503, 0x03},
 320	{0x0100, 0x01},
 321};
 322
 323static struct regval_list ov5647_2x2binned_10bpp[] = {
 324	{0x0100, 0x00},
 325	{0x0103, 0x01},
 326	{0x3034, 0x1a},
 327	{0x3035, 0x21},
 328	{0x3036, 0x62},
 329	{0x303c, 0x11},
 330	{0x3106, 0xf5},
 331	{0x3827, 0xec},
 332	{0x370c, 0x03},
 333	{0x3612, 0x59},
 334	{0x3618, 0x00},
 335	{0x5000, 0x06},
 336	{0x5002, 0x41},
 337	{0x5003, 0x08},
 338	{0x5a00, 0x08},
 339	{0x3000, 0x00},
 340	{0x3001, 0x00},
 341	{0x3002, 0x00},
 342	{0x3016, 0x08},
 343	{0x3017, 0xe0},
 344	{0x3018, 0x44},
 345	{0x301c, 0xf8},
 346	{0x301d, 0xf0},
 347	{0x3a18, 0x00},
 348	{0x3a19, 0xf8},
 349	{0x3c01, 0x80},
 350	{0x3b07, 0x0c},
 351	{0x3800, 0x00},
 352	{0x3801, 0x00},
 353	{0x3802, 0x00},
 354	{0x3803, 0x00},
 355	{0x3804, 0x0a},
 356	{0x3805, 0x3f},
 357	{0x3806, 0x07},
 358	{0x3807, 0xa3},
 359	{0x3808, 0x05},
 360	{0x3809, 0x10},
 361	{0x380a, 0x03},
 362	{0x380b, 0xcc},
 363	{0x380c, 0x07},
 364	{0x380d, 0x68},
 365	{0x3811, 0x0c},
 366	{0x3813, 0x06},
 367	{0x3814, 0x31},
 368	{0x3815, 0x31},
 369	{0x3630, 0x2e},
 370	{0x3632, 0xe2},
 371	{0x3633, 0x23},
 372	{0x3634, 0x44},
 373	{0x3636, 0x06},
 374	{0x3620, 0x64},
 375	{0x3621, 0xe0},
 376	{0x3600, 0x37},
 377	{0x3704, 0xa0},
 378	{0x3703, 0x5a},
 379	{0x3715, 0x78},
 380	{0x3717, 0x01},
 381	{0x3731, 0x02},
 382	{0x370b, 0x60},
 383	{0x3705, 0x1a},
 384	{0x3f05, 0x02},
 385	{0x3f06, 0x10},
 386	{0x3f01, 0x0a},
 387	{0x3a08, 0x01},
 388	{0x3a09, 0x28},
 389	{0x3a0a, 0x00},
 390	{0x3a0b, 0xf6},
 391	{0x3a0d, 0x08},
 392	{0x3a0e, 0x06},
 393	{0x3a0f, 0x58},
 394	{0x3a10, 0x50},
 395	{0x3a1b, 0x58},
 396	{0x3a1e, 0x50},
 397	{0x3a11, 0x60},
 398	{0x3a1f, 0x28},
 399	{0x4001, 0x02},
 400	{0x4004, 0x04},
 401	{0x4000, 0x09},
 402	{0x4837, 0x16},
 403	{0x4800, 0x24},
 404	{0x3503, 0x03},
 405	{0x3820, 0x41},
 406	{0x3821, 0x07},
 407	{0x350a, 0x00},
 408	{0x350b, 0x10},
 409	{0x3500, 0x00},
 410	{0x3501, 0x1a},
 411	{0x3502, 0xf0},
 412	{0x3212, 0xa0},
 413	{0x0100, 0x01},
 414};
 415
 416static struct regval_list ov5647_640x480_10bpp[] = {
 417	{0x0100, 0x00},
 418	{0x0103, 0x01},
 419	{0x3035, 0x11},
 420	{0x3036, 0x46},
 421	{0x303c, 0x11},
 422	{0x3821, 0x07},
 423	{0x3820, 0x41},
 424	{0x370c, 0x03},
 425	{0x3612, 0x59},
 426	{0x3618, 0x00},
 427	{0x5000, 0x06},
 428	{0x5003, 0x08},
 429	{0x5a00, 0x08},
 430	{0x3000, 0xff},
 431	{0x3001, 0xff},
 432	{0x3002, 0xff},
 433	{0x301d, 0xf0},
 434	{0x3a18, 0x00},
 435	{0x3a19, 0xf8},
 436	{0x3c01, 0x80},
 437	{0x3b07, 0x0c},
 438	{0x380c, 0x07},
 439	{0x380d, 0x3c},
 440	{0x3814, 0x35},
 441	{0x3815, 0x35},
 442	{0x3708, 0x64},
 443	{0x3709, 0x52},
 444	{0x3808, 0x02},
 445	{0x3809, 0x80},
 446	{0x380a, 0x01},
 447	{0x380b, 0xe0},
 448	{0x3800, 0x00},
 449	{0x3801, 0x10},
 450	{0x3802, 0x00},
 451	{0x3803, 0x00},
 452	{0x3804, 0x0a},
 453	{0x3805, 0x2f},
 454	{0x3806, 0x07},
 455	{0x3807, 0x9f},
 456	{0x3630, 0x2e},
 457	{0x3632, 0xe2},
 458	{0x3633, 0x23},
 459	{0x3634, 0x44},
 460	{0x3620, 0x64},
 461	{0x3621, 0xe0},
 462	{0x3600, 0x37},
 463	{0x3704, 0xa0},
 464	{0x3703, 0x5a},
 465	{0x3715, 0x78},
 466	{0x3717, 0x01},
 467	{0x3731, 0x02},
 468	{0x370b, 0x60},
 469	{0x3705, 0x1a},
 470	{0x3f05, 0x02},
 471	{0x3f06, 0x10},
 472	{0x3f01, 0x0a},
 473	{0x3a08, 0x01},
 474	{0x3a09, 0x2e},
 475	{0x3a0a, 0x00},
 476	{0x3a0b, 0xfb},
 477	{0x3a0d, 0x02},
 478	{0x3a0e, 0x01},
 479	{0x3a0f, 0x58},
 480	{0x3a10, 0x50},
 481	{0x3a1b, 0x58},
 482	{0x3a1e, 0x50},
 483	{0x3a11, 0x60},
 484	{0x3a1f, 0x28},
 485	{0x4001, 0x02},
 486	{0x4004, 0x02},
 487	{0x4000, 0x09},
 488	{0x3000, 0x00},
 489	{0x3001, 0x00},
 490	{0x3002, 0x00},
 491	{0x3017, 0xe0},
 492	{0x301c, 0xfc},
 493	{0x3636, 0x06},
 494	{0x3016, 0x08},
 495	{0x3827, 0xec},
 496	{0x3018, 0x44},
 497	{0x3035, 0x21},
 498	{0x3106, 0xf5},
 499	{0x3034, 0x1a},
 500	{0x301c, 0xf8},
 501	{0x4800, 0x34},
 502	{0x3503, 0x03},
 503	{0x0100, 0x01},
 504};
 505
 506static const struct ov5647_mode ov5647_modes[] = {
 507	/* 2592x1944 full resolution full FOV 10-bit mode. */
 508	{
 509		.format = {
 510			.code		= MEDIA_BUS_FMT_SBGGR10_1X10,
 511			.colorspace	= V4L2_COLORSPACE_RAW,
 512			.field		= V4L2_FIELD_NONE,
 513			.width		= 2592,
 514			.height		= 1944
 515		},
 516		.crop = {
 517			.left		= OV5647_PIXEL_ARRAY_LEFT,
 518			.top		= OV5647_PIXEL_ARRAY_TOP,
 519			.width		= 2592,
 520			.height		= 1944
 521		},
 522		.pixel_rate	= 87500000,
 523		.hts		= 2844,
 524		.vts		= 0x7b0,
 525		.reg_list	= ov5647_2592x1944_10bpp,
 526		.num_regs	= ARRAY_SIZE(ov5647_2592x1944_10bpp)
 527	},
 528	/* 1080p30 10-bit mode. Full resolution centre-cropped down to 1080p. */
 529	{
 530		.format = {
 531			.code		= MEDIA_BUS_FMT_SBGGR10_1X10,
 532			.colorspace	= V4L2_COLORSPACE_RAW,
 533			.field		= V4L2_FIELD_NONE,
 534			.width		= 1920,
 535			.height		= 1080
 536		},
 537		.crop = {
 538			.left		= 348 + OV5647_PIXEL_ARRAY_LEFT,
 539			.top		= 434 + OV5647_PIXEL_ARRAY_TOP,
 540			.width		= 1928,
 541			.height		= 1080,
 542		},
 543		.pixel_rate	= 81666700,
 544		.hts		= 2416,
 545		.vts		= 0x450,
 546		.reg_list	= ov5647_1080p30_10bpp,
 547		.num_regs	= ARRAY_SIZE(ov5647_1080p30_10bpp)
 548	},
 549	/* 2x2 binned full FOV 10-bit mode. */
 550	{
 551		.format = {
 552			.code		= MEDIA_BUS_FMT_SBGGR10_1X10,
 553			.colorspace	= V4L2_COLORSPACE_RAW,
 554			.field		= V4L2_FIELD_NONE,
 555			.width		= 1296,
 556			.height		= 972
 557		},
 558		.crop = {
 559			.left		= OV5647_PIXEL_ARRAY_LEFT,
 560			.top		= OV5647_PIXEL_ARRAY_TOP,
 561			.width		= 2592,
 562			.height		= 1944,
 563		},
 564		.pixel_rate	= 81666700,
 565		.hts		= 1896,
 566		.vts		= 0x59b,
 567		.reg_list	= ov5647_2x2binned_10bpp,
 568		.num_regs	= ARRAY_SIZE(ov5647_2x2binned_10bpp)
 569	},
 570	/* 10-bit VGA full FOV 60fps. 2x2 binned and subsampled down to VGA. */
 571	{
 572		.format = {
 573			.code		= MEDIA_BUS_FMT_SBGGR10_1X10,
 574			.colorspace	= V4L2_COLORSPACE_RAW,
 575			.field		= V4L2_FIELD_NONE,
 576			.width		= 640,
 577			.height		= 480
 578		},
 579		.crop = {
 580			.left		= 16 + OV5647_PIXEL_ARRAY_LEFT,
 581			.top		= OV5647_PIXEL_ARRAY_TOP,
 582			.width		= 2560,
 583			.height		= 1920,
 584		},
 585		.pixel_rate	= 58333000,
 586		.hts		= 1852,
 587		.vts		= 0x1f8,
 588		.reg_list	= ov5647_640x480_10bpp,
 589		.num_regs	= ARRAY_SIZE(ov5647_640x480_10bpp)
 590	},
 591};
 592
 593/* Default sensor mode is 2x2 binned 640x480 SBGGR10_1X10. */
 594#define OV5647_DEFAULT_MODE	(&ov5647_modes[3])
 595#define OV5647_DEFAULT_FORMAT	(ov5647_modes[3].format)
 596
 597static int ov5647_write16(struct v4l2_subdev *sd, u16 reg, u16 val)
 598{
 599	unsigned char data[4] = { reg >> 8, reg & 0xff, val >> 8, val & 0xff};
 600	struct i2c_client *client = v4l2_get_subdevdata(sd);
 601	int ret;
 602
 603	ret = i2c_master_send(client, data, 4);
 604	if (ret < 0) {
 605		dev_dbg(&client->dev, "%s: i2c write error, reg: %x\n",
 606			__func__, reg);
 607		return ret;
 608	}
 609
 610	return 0;
 611}
 612
 613static int ov5647_write(struct v4l2_subdev *sd, u16 reg, u8 val)
 614{
 615	unsigned char data[3] = { reg >> 8, reg & 0xff, val};
 616	struct i2c_client *client = v4l2_get_subdevdata(sd);
 617	int ret;
 618
 619	ret = i2c_master_send(client, data, 3);
 620	if (ret < 0) {
 621		dev_dbg(&client->dev, "%s: i2c write error, reg: %x\n",
 622				__func__, reg);
 623		return ret;
 624	}
 625
 626	return 0;
 627}
 628
 629static int ov5647_read(struct v4l2_subdev *sd, u16 reg, u8 *val)
 630{
 631	struct i2c_client *client = v4l2_get_subdevdata(sd);
 632	u8 buf[2] = { reg >> 8, reg & 0xff };
 633	struct i2c_msg msg[2];
 634	int ret;
 635
 636	msg[0].addr = client->addr;
 637	msg[0].flags = client->flags;
 638	msg[0].buf = buf;
 639	msg[0].len = sizeof(buf);
 640
 641	msg[1].addr = client->addr;
 642	msg[1].flags = client->flags | I2C_M_RD;
 643	msg[1].buf = buf;
 644	msg[1].len = 1;
 645
 646	ret = i2c_transfer(client->adapter, msg, 2);
 647	if (ret != 2) {
 648		dev_err(&client->dev, "%s: i2c read error, reg: %x = %d\n",
 649			__func__, reg, ret);
 650		return ret >= 0 ? -EINVAL : ret;
 651	}
 652
 653	*val = buf[0];
 654
 655	return 0;
 656}
 657
 658static int ov5647_write_array(struct v4l2_subdev *sd,
 659			      const struct regval_list *regs, int array_size)
 660{
 661	int i, ret;
 662
 663	for (i = 0; i < array_size; i++) {
 664		ret = ov5647_write(sd, regs[i].addr, regs[i].data);
 665		if (ret < 0)
 666			return ret;
 667	}
 668
 669	return 0;
 670}
 671
 672static int ov5647_set_virtual_channel(struct v4l2_subdev *sd, int channel)
 673{
 674	u8 channel_id;
 675	int ret;
 676
 677	ret = ov5647_read(sd, OV5647_REG_MIPI_CTRL14, &channel_id);
 678	if (ret < 0)
 679		return ret;
 680
 681	channel_id &= ~(3 << 6);
 682
 683	return ov5647_write(sd, OV5647_REG_MIPI_CTRL14,
 684			    channel_id | (channel << 6));
 685}
 686
 687static int ov5647_set_mode(struct v4l2_subdev *sd)
 688{
 689	struct i2c_client *client = v4l2_get_subdevdata(sd);
 690	struct ov5647 *sensor = to_sensor(sd);
 691	u8 resetval, rdval;
 692	int ret;
 693
 694	ret = ov5647_read(sd, OV5647_SW_STANDBY, &rdval);
 695	if (ret < 0)
 696		return ret;
 697
 698	ret = ov5647_write_array(sd, sensor->mode->reg_list,
 699				 sensor->mode->num_regs);
 700	if (ret < 0) {
 701		dev_err(&client->dev, "write sensor default regs error\n");
 702		return ret;
 703	}
 704
 705	ret = ov5647_set_virtual_channel(sd, 0);
 706	if (ret < 0)
 707		return ret;
 708
 709	ret = ov5647_read(sd, OV5647_SW_STANDBY, &resetval);
 710	if (ret < 0)
 711		return ret;
 712
 713	if (!(resetval & 0x01)) {
 714		dev_err(&client->dev, "Device was in SW standby");
 715		ret = ov5647_write(sd, OV5647_SW_STANDBY, 0x01);
 716		if (ret < 0)
 717			return ret;
 718	}
 719
 720	return 0;
 721}
 722
 723static int ov5647_stream_on(struct v4l2_subdev *sd)
 724{
 725	struct i2c_client *client = v4l2_get_subdevdata(sd);
 726	struct ov5647 *sensor = to_sensor(sd);
 727	u8 val = MIPI_CTRL00_BUS_IDLE;
 728	int ret;
 729
 730	ret = ov5647_set_mode(sd);
 731	if (ret) {
 732		dev_err(&client->dev, "Failed to program sensor mode: %d\n", ret);
 733		return ret;
 734	}
 735
 736	/* Apply customized values from user when stream starts. */
 737	ret =  __v4l2_ctrl_handler_setup(sd->ctrl_handler);
 738	if (ret)
 739		return ret;
 740
 741	if (sensor->clock_ncont)
 742		val |= MIPI_CTRL00_CLOCK_LANE_GATE |
 743		       MIPI_CTRL00_LINE_SYNC_ENABLE;
 744
 745	ret = ov5647_write(sd, OV5647_REG_MIPI_CTRL00, val);
 746	if (ret < 0)
 747		return ret;
 748
 749	ret = ov5647_write(sd, OV5647_REG_FRAME_OFF_NUMBER, 0x00);
 750	if (ret < 0)
 751		return ret;
 752
 753	return ov5647_write(sd, OV5640_REG_PAD_OUT, 0x00);
 754}
 755
 756static int ov5647_stream_off(struct v4l2_subdev *sd)
 757{
 758	int ret;
 759
 760	ret = ov5647_write(sd, OV5647_REG_MIPI_CTRL00,
 761			   MIPI_CTRL00_CLOCK_LANE_GATE | MIPI_CTRL00_BUS_IDLE |
 762			   MIPI_CTRL00_CLOCK_LANE_DISABLE);
 763	if (ret < 0)
 764		return ret;
 765
 766	ret = ov5647_write(sd, OV5647_REG_FRAME_OFF_NUMBER, 0x0f);
 767	if (ret < 0)
 768		return ret;
 769
 770	return ov5647_write(sd, OV5640_REG_PAD_OUT, 0x01);
 771}
 772
 773static int ov5647_power_on(struct device *dev)
 774{
 775	struct ov5647 *sensor = dev_get_drvdata(dev);
 776	int ret;
 777
 778	dev_dbg(dev, "OV5647 power on\n");
 779
 780	if (sensor->pwdn) {
 781		gpiod_set_value_cansleep(sensor->pwdn, 0);
 782		msleep(PWDN_ACTIVE_DELAY_MS);
 783	}
 784
 785	ret = clk_prepare_enable(sensor->xclk);
 786	if (ret < 0) {
 787		dev_err(dev, "clk prepare enable failed\n");
 788		goto error_pwdn;
 789	}
 790
 791	ret = ov5647_write_array(&sensor->sd, sensor_oe_enable_regs,
 792				 ARRAY_SIZE(sensor_oe_enable_regs));
 793	if (ret < 0) {
 794		dev_err(dev, "write sensor_oe_enable_regs error\n");
 795		goto error_clk_disable;
 796	}
 797
 798	/* Stream off to coax lanes into LP-11 state. */
 799	ret = ov5647_stream_off(&sensor->sd);
 800	if (ret < 0) {
 801		dev_err(dev, "camera not available, check power\n");
 802		goto error_clk_disable;
 803	}
 804
 805	return 0;
 806
 807error_clk_disable:
 808	clk_disable_unprepare(sensor->xclk);
 809error_pwdn:
 810	gpiod_set_value_cansleep(sensor->pwdn, 1);
 811
 812	return ret;
 813}
 814
 815static int ov5647_power_off(struct device *dev)
 816{
 817	struct ov5647 *sensor = dev_get_drvdata(dev);
 818	u8 rdval;
 819	int ret;
 820
 821	dev_dbg(dev, "OV5647 power off\n");
 822
 823	ret = ov5647_write_array(&sensor->sd, sensor_oe_disable_regs,
 824				 ARRAY_SIZE(sensor_oe_disable_regs));
 825	if (ret < 0)
 826		dev_dbg(dev, "disable oe failed\n");
 827
 828	/* Enter software standby */
 829	ret = ov5647_read(&sensor->sd, OV5647_SW_STANDBY, &rdval);
 830	if (ret < 0)
 831		dev_dbg(dev, "software standby failed\n");
 832
 833	rdval &= ~0x01;
 834	ret = ov5647_write(&sensor->sd, OV5647_SW_STANDBY, rdval);
 835	if (ret < 0)
 836		dev_dbg(dev, "software standby failed\n");
 837
 838	clk_disable_unprepare(sensor->xclk);
 839	gpiod_set_value_cansleep(sensor->pwdn, 1);
 840
 841	return 0;
 842}
 843
 844#ifdef CONFIG_VIDEO_ADV_DEBUG
 845static int ov5647_sensor_get_register(struct v4l2_subdev *sd,
 846				      struct v4l2_dbg_register *reg)
 847{
 848	int ret;
 849	u8 val;
 850
 851	ret = ov5647_read(sd, reg->reg & 0xff, &val);
 852	if (ret < 0)
 853		return ret;
 854
 855	reg->val = val;
 856	reg->size = 1;
 857
 858	return 0;
 859}
 860
 861static int ov5647_sensor_set_register(struct v4l2_subdev *sd,
 862				      const struct v4l2_dbg_register *reg)
 863{
 864	return ov5647_write(sd, reg->reg & 0xff, reg->val & 0xff);
 865}
 866#endif
 867
 868/* Subdev core operations registration */
 869static const struct v4l2_subdev_core_ops ov5647_subdev_core_ops = {
 870	.subscribe_event	= v4l2_ctrl_subdev_subscribe_event,
 871	.unsubscribe_event	= v4l2_event_subdev_unsubscribe,
 872#ifdef CONFIG_VIDEO_ADV_DEBUG
 873	.g_register		= ov5647_sensor_get_register,
 874	.s_register		= ov5647_sensor_set_register,
 875#endif
 876};
 877
 878static const struct v4l2_rect *
 879__ov5647_get_pad_crop(struct ov5647 *ov5647,
 880		      struct v4l2_subdev_state *sd_state,
 881		      unsigned int pad, enum v4l2_subdev_format_whence which)
 882{
 883	switch (which) {
 884	case V4L2_SUBDEV_FORMAT_TRY:
 885		return v4l2_subdev_state_get_crop(sd_state, pad);
 886	case V4L2_SUBDEV_FORMAT_ACTIVE:
 887		return &ov5647->mode->crop;
 888	}
 889
 890	return NULL;
 891}
 892
 893static int ov5647_s_stream(struct v4l2_subdev *sd, int enable)
 894{
 895	struct i2c_client *client = v4l2_get_subdevdata(sd);
 896	struct ov5647 *sensor = to_sensor(sd);
 897	int ret;
 898
 899	mutex_lock(&sensor->lock);
 900
 901	if (enable) {
 902		ret = pm_runtime_resume_and_get(&client->dev);
 903		if (ret < 0)
 904			goto error_unlock;
 905
 906		ret = ov5647_stream_on(sd);
 907		if (ret < 0) {
 908			dev_err(&client->dev, "stream start failed: %d\n", ret);
 909			goto error_pm;
 910		}
 911	} else {
 912		ret = ov5647_stream_off(sd);
 913		if (ret < 0) {
 914			dev_err(&client->dev, "stream stop failed: %d\n", ret);
 915			goto error_pm;
 916		}
 917		pm_runtime_put(&client->dev);
 918	}
 919
 920	mutex_unlock(&sensor->lock);
 921
 922	return 0;
 923
 924error_pm:
 925	pm_runtime_put(&client->dev);
 926error_unlock:
 927	mutex_unlock(&sensor->lock);
 928
 929	return ret;
 930}
 931
 932static const struct v4l2_subdev_video_ops ov5647_subdev_video_ops = {
 933	.s_stream =		ov5647_s_stream,
 934};
 935
 936static int ov5647_enum_mbus_code(struct v4l2_subdev *sd,
 937				 struct v4l2_subdev_state *sd_state,
 938				 struct v4l2_subdev_mbus_code_enum *code)
 939{
 940	if (code->index > 0)
 941		return -EINVAL;
 942
 943	code->code = MEDIA_BUS_FMT_SBGGR10_1X10;
 944
 945	return 0;
 946}
 947
 948static int ov5647_enum_frame_size(struct v4l2_subdev *sd,
 949				  struct v4l2_subdev_state *sd_state,
 950				  struct v4l2_subdev_frame_size_enum *fse)
 951{
 952	const struct v4l2_mbus_framefmt *fmt;
 953
 954	if (fse->code != MEDIA_BUS_FMT_SBGGR10_1X10 ||
 955	    fse->index >= ARRAY_SIZE(ov5647_modes))
 956		return -EINVAL;
 957
 958	fmt = &ov5647_modes[fse->index].format;
 959	fse->min_width = fmt->width;
 960	fse->max_width = fmt->width;
 961	fse->min_height = fmt->height;
 962	fse->max_height = fmt->height;
 963
 964	return 0;
 965}
 966
 967static int ov5647_get_pad_fmt(struct v4l2_subdev *sd,
 968			      struct v4l2_subdev_state *sd_state,
 969			      struct v4l2_subdev_format *format)
 970{
 971	struct v4l2_mbus_framefmt *fmt = &format->format;
 972	const struct v4l2_mbus_framefmt *sensor_format;
 973	struct ov5647 *sensor = to_sensor(sd);
 974
 975	mutex_lock(&sensor->lock);
 976	switch (format->which) {
 977	case V4L2_SUBDEV_FORMAT_TRY:
 978		sensor_format = v4l2_subdev_state_get_format(sd_state,
 979							     format->pad);
 980		break;
 981	default:
 982		sensor_format = &sensor->mode->format;
 983		break;
 984	}
 985
 986	*fmt = *sensor_format;
 987	mutex_unlock(&sensor->lock);
 988
 989	return 0;
 990}
 991
 992static int ov5647_set_pad_fmt(struct v4l2_subdev *sd,
 993			      struct v4l2_subdev_state *sd_state,
 994			      struct v4l2_subdev_format *format)
 995{
 996	struct v4l2_mbus_framefmt *fmt = &format->format;
 997	struct ov5647 *sensor = to_sensor(sd);
 998	const struct ov5647_mode *mode;
 999
1000	mode = v4l2_find_nearest_size(ov5647_modes, ARRAY_SIZE(ov5647_modes),
1001				      format.width, format.height,
1002				      fmt->width, fmt->height);
1003
1004	/* Update the sensor mode and apply at it at streamon time. */
1005	mutex_lock(&sensor->lock);
1006	if (format->which == V4L2_SUBDEV_FORMAT_TRY) {
1007		*v4l2_subdev_state_get_format(sd_state, format->pad) = mode->format;
1008	} else {
1009		int exposure_max, exposure_def;
1010		int hblank, vblank;
1011
1012		sensor->mode = mode;
1013		__v4l2_ctrl_modify_range(sensor->pixel_rate, mode->pixel_rate,
1014					 mode->pixel_rate, 1, mode->pixel_rate);
1015
1016		hblank = mode->hts - mode->format.width;
1017		__v4l2_ctrl_modify_range(sensor->hblank, hblank, hblank, 1,
1018					 hblank);
1019
1020		vblank = mode->vts - mode->format.height;
1021		__v4l2_ctrl_modify_range(sensor->vblank, OV5647_VBLANK_MIN,
1022					 OV5647_VTS_MAX - mode->format.height,
1023					 1, vblank);
1024		__v4l2_ctrl_s_ctrl(sensor->vblank, vblank);
1025
1026		exposure_max = mode->vts - 4;
1027		exposure_def = min(exposure_max, OV5647_EXPOSURE_DEFAULT);
1028		__v4l2_ctrl_modify_range(sensor->exposure,
1029					 sensor->exposure->minimum,
1030					 exposure_max, sensor->exposure->step,
1031					 exposure_def);
1032	}
1033	*fmt = mode->format;
1034	mutex_unlock(&sensor->lock);
1035
1036	return 0;
1037}
1038
1039static int ov5647_get_selection(struct v4l2_subdev *sd,
1040				struct v4l2_subdev_state *sd_state,
1041				struct v4l2_subdev_selection *sel)
1042{
1043	switch (sel->target) {
1044	case V4L2_SEL_TGT_CROP: {
1045		struct ov5647 *sensor = to_sensor(sd);
1046
1047		mutex_lock(&sensor->lock);
1048		sel->r = *__ov5647_get_pad_crop(sensor, sd_state, sel->pad,
1049						sel->which);
1050		mutex_unlock(&sensor->lock);
1051
1052		return 0;
1053	}
1054
1055	case V4L2_SEL_TGT_NATIVE_SIZE:
1056		sel->r.top = 0;
1057		sel->r.left = 0;
1058		sel->r.width = OV5647_NATIVE_WIDTH;
1059		sel->r.height = OV5647_NATIVE_HEIGHT;
1060
1061		return 0;
1062
1063	case V4L2_SEL_TGT_CROP_DEFAULT:
1064	case V4L2_SEL_TGT_CROP_BOUNDS:
1065		sel->r.top = OV5647_PIXEL_ARRAY_TOP;
1066		sel->r.left = OV5647_PIXEL_ARRAY_LEFT;
1067		sel->r.width = OV5647_PIXEL_ARRAY_WIDTH;
1068		sel->r.height = OV5647_PIXEL_ARRAY_HEIGHT;
1069
1070		return 0;
1071	}
1072
1073	return -EINVAL;
1074}
1075
1076static const struct v4l2_subdev_pad_ops ov5647_subdev_pad_ops = {
1077	.enum_mbus_code		= ov5647_enum_mbus_code,
1078	.enum_frame_size	= ov5647_enum_frame_size,
1079	.set_fmt		= ov5647_set_pad_fmt,
1080	.get_fmt		= ov5647_get_pad_fmt,
1081	.get_selection		= ov5647_get_selection,
1082};
1083
1084static const struct v4l2_subdev_ops ov5647_subdev_ops = {
1085	.core		= &ov5647_subdev_core_ops,
1086	.video		= &ov5647_subdev_video_ops,
1087	.pad		= &ov5647_subdev_pad_ops,
1088};
1089
1090static int ov5647_detect(struct v4l2_subdev *sd)
1091{
1092	struct i2c_client *client = v4l2_get_subdevdata(sd);
1093	u8 read;
1094	int ret;
1095
1096	ret = ov5647_write(sd, OV5647_SW_RESET, 0x01);
1097	if (ret < 0)
1098		return ret;
1099
1100	ret = ov5647_read(sd, OV5647_REG_CHIPID_H, &read);
1101	if (ret < 0)
1102		return ret;
1103
1104	if (read != 0x56) {
1105		dev_err(&client->dev, "ID High expected 0x56 got %x", read);
1106		return -ENODEV;
1107	}
1108
1109	ret = ov5647_read(sd, OV5647_REG_CHIPID_L, &read);
1110	if (ret < 0)
1111		return ret;
1112
1113	if (read != 0x47) {
1114		dev_err(&client->dev, "ID Low expected 0x47 got %x", read);
1115		return -ENODEV;
1116	}
1117
1118	return ov5647_write(sd, OV5647_SW_RESET, 0x00);
1119}
1120
1121static int ov5647_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
1122{
1123	struct v4l2_mbus_framefmt *format =
1124				v4l2_subdev_state_get_format(fh->state, 0);
1125	struct v4l2_rect *crop = v4l2_subdev_state_get_crop(fh->state, 0);
1126
1127	crop->left = OV5647_PIXEL_ARRAY_LEFT;
1128	crop->top = OV5647_PIXEL_ARRAY_TOP;
1129	crop->width = OV5647_PIXEL_ARRAY_WIDTH;
1130	crop->height = OV5647_PIXEL_ARRAY_HEIGHT;
1131
1132	*format = OV5647_DEFAULT_FORMAT;
1133
1134	return 0;
1135}
1136
1137static const struct v4l2_subdev_internal_ops ov5647_subdev_internal_ops = {
1138	.open = ov5647_open,
1139};
1140
1141static int ov5647_s_auto_white_balance(struct v4l2_subdev *sd, u32 val)
1142{
1143	return ov5647_write(sd, OV5647_REG_AWB, val ? 1 : 0);
1144}
1145
1146static int ov5647_s_autogain(struct v4l2_subdev *sd, u32 val)
1147{
1148	int ret;
1149	u8 reg;
1150
1151	/* Non-zero turns on AGC by clearing bit 1.*/
1152	ret = ov5647_read(sd, OV5647_REG_AEC_AGC, &reg);
1153	if (ret)
1154		return ret;
1155
1156	return ov5647_write(sd, OV5647_REG_AEC_AGC, val ? reg & ~BIT(1)
1157							: reg | BIT(1));
1158}
1159
1160static int ov5647_s_exposure_auto(struct v4l2_subdev *sd, u32 val)
1161{
1162	int ret;
1163	u8 reg;
1164
1165	/*
1166	 * Everything except V4L2_EXPOSURE_MANUAL turns on AEC by
1167	 * clearing bit 0.
1168	 */
1169	ret = ov5647_read(sd, OV5647_REG_AEC_AGC, &reg);
1170	if (ret)
1171		return ret;
1172
1173	return ov5647_write(sd, OV5647_REG_AEC_AGC,
1174			    val == V4L2_EXPOSURE_MANUAL ? reg | BIT(0)
1175							: reg & ~BIT(0));
1176}
1177
1178static int ov5647_s_analogue_gain(struct v4l2_subdev *sd, u32 val)
1179{
1180	int ret;
1181
1182	/* 10 bits of gain, 2 in the high register. */
1183	ret = ov5647_write(sd, OV5647_REG_GAIN_HI, (val >> 8) & 3);
1184	if (ret)
1185		return ret;
1186
1187	return ov5647_write(sd, OV5647_REG_GAIN_LO, val & 0xff);
1188}
1189
1190static int ov5647_s_exposure(struct v4l2_subdev *sd, u32 val)
1191{
1192	int ret;
1193
1194	/*
1195	 * Sensor has 20 bits, but the bottom 4 bits are fractions of a line
1196	 * which we leave as zero (and don't receive in "val").
1197	 */
1198	ret = ov5647_write(sd, OV5647_REG_EXP_HI, (val >> 12) & 0xf);
1199	if (ret)
1200		return ret;
1201
1202	ret = ov5647_write(sd, OV5647_REG_EXP_MID, (val >> 4) & 0xff);
1203	if (ret)
1204		return ret;
1205
1206	return ov5647_write(sd, OV5647_REG_EXP_LO, (val & 0xf) << 4);
1207}
1208
1209static int ov5647_s_ctrl(struct v4l2_ctrl *ctrl)
1210{
1211	struct ov5647 *sensor = container_of(ctrl->handler,
1212					    struct ov5647, ctrls);
1213	struct v4l2_subdev *sd = &sensor->sd;
1214	struct i2c_client *client = v4l2_get_subdevdata(sd);
1215	int ret = 0;
1216
1217
1218	/* v4l2_ctrl_lock() locks our own mutex */
1219
1220	if (ctrl->id == V4L2_CID_VBLANK) {
1221		int exposure_max, exposure_def;
1222
1223		/* Update max exposure while meeting expected vblanking */
1224		exposure_max = sensor->mode->format.height + ctrl->val - 4;
1225		exposure_def = min(exposure_max, OV5647_EXPOSURE_DEFAULT);
1226		__v4l2_ctrl_modify_range(sensor->exposure,
1227					 sensor->exposure->minimum,
1228					 exposure_max, sensor->exposure->step,
1229					 exposure_def);
1230	}
1231
1232	/*
1233	 * If the device is not powered up do not apply any controls
1234	 * to H/W at this time. Instead the controls will be restored
1235	 * at s_stream(1) time.
1236	 */
1237	if (pm_runtime_get_if_in_use(&client->dev) == 0)
1238		return 0;
1239
1240	switch (ctrl->id) {
1241	case V4L2_CID_AUTO_WHITE_BALANCE:
1242		ret = ov5647_s_auto_white_balance(sd, ctrl->val);
1243		break;
1244	case V4L2_CID_AUTOGAIN:
1245		ret = ov5647_s_autogain(sd, ctrl->val);
1246		break;
1247	case V4L2_CID_EXPOSURE_AUTO:
1248		ret = ov5647_s_exposure_auto(sd, ctrl->val);
1249		break;
1250	case V4L2_CID_ANALOGUE_GAIN:
1251		ret =  ov5647_s_analogue_gain(sd, ctrl->val);
1252		break;
1253	case V4L2_CID_EXPOSURE:
1254		ret = ov5647_s_exposure(sd, ctrl->val);
1255		break;
1256	case V4L2_CID_VBLANK:
1257		ret = ov5647_write16(sd, OV5647_REG_VTS_HI,
1258				     sensor->mode->format.height + ctrl->val);
1259		break;
1260	case V4L2_CID_TEST_PATTERN:
1261		ret = ov5647_write(sd, OV5647_REG_ISPCTRL3D,
1262				   ov5647_test_pattern_val[ctrl->val]);
1263		break;
1264
1265	/* Read-only, but we adjust it based on mode. */
1266	case V4L2_CID_PIXEL_RATE:
1267	case V4L2_CID_HBLANK:
1268		/* Read-only, but we adjust it based on mode. */
1269		break;
1270
1271	default:
1272		dev_info(&client->dev,
1273			 "Control (id:0x%x, val:0x%x) not supported\n",
1274			 ctrl->id, ctrl->val);
1275		return -EINVAL;
1276	}
1277
1278	pm_runtime_put(&client->dev);
1279
1280	return ret;
1281}
1282
1283static const struct v4l2_ctrl_ops ov5647_ctrl_ops = {
1284	.s_ctrl = ov5647_s_ctrl,
1285};
1286
1287static int ov5647_init_controls(struct ov5647 *sensor)
1288{
1289	struct i2c_client *client = v4l2_get_subdevdata(&sensor->sd);
1290	int hblank, exposure_max, exposure_def;
1291
1292	v4l2_ctrl_handler_init(&sensor->ctrls, 9);
1293
1294	sensor->ctrls.lock = &sensor->lock;
1295
1296	v4l2_ctrl_new_std(&sensor->ctrls, &ov5647_ctrl_ops,
1297			  V4L2_CID_AUTOGAIN, 0, 1, 1, 0);
1298
1299	v4l2_ctrl_new_std(&sensor->ctrls, &ov5647_ctrl_ops,
1300			  V4L2_CID_AUTO_WHITE_BALANCE, 0, 1, 1, 0);
1301
1302	v4l2_ctrl_new_std_menu(&sensor->ctrls, &ov5647_ctrl_ops,
1303			       V4L2_CID_EXPOSURE_AUTO, V4L2_EXPOSURE_MANUAL,
1304			       0, V4L2_EXPOSURE_MANUAL);
1305
1306	exposure_max = sensor->mode->vts - 4;
1307	exposure_def = min(exposure_max, OV5647_EXPOSURE_DEFAULT);
1308	sensor->exposure = v4l2_ctrl_new_std(&sensor->ctrls, &ov5647_ctrl_ops,
1309					     V4L2_CID_EXPOSURE,
1310					     OV5647_EXPOSURE_MIN,
1311					     exposure_max, OV5647_EXPOSURE_STEP,
1312					     exposure_def);
1313
1314	/* min: 16 = 1.0x; max (10 bits); default: 32 = 2.0x. */
1315	v4l2_ctrl_new_std(&sensor->ctrls, &ov5647_ctrl_ops,
1316			  V4L2_CID_ANALOGUE_GAIN, 16, 1023, 1, 32);
1317
1318	/* By default, PIXEL_RATE is read only, but it does change per mode */
1319	sensor->pixel_rate = v4l2_ctrl_new_std(&sensor->ctrls, &ov5647_ctrl_ops,
1320					       V4L2_CID_PIXEL_RATE,
1321					       sensor->mode->pixel_rate,
1322					       sensor->mode->pixel_rate, 1,
1323					       sensor->mode->pixel_rate);
1324
1325	/* By default, HBLANK is read only, but it does change per mode. */
1326	hblank = sensor->mode->hts - sensor->mode->format.width;
1327	sensor->hblank = v4l2_ctrl_new_std(&sensor->ctrls, &ov5647_ctrl_ops,
1328					   V4L2_CID_HBLANK, hblank, hblank, 1,
1329					   hblank);
1330
1331	sensor->vblank = v4l2_ctrl_new_std(&sensor->ctrls, &ov5647_ctrl_ops,
1332					   V4L2_CID_VBLANK, OV5647_VBLANK_MIN,
1333					   OV5647_VTS_MAX -
1334					   sensor->mode->format.height, 1,
1335					   sensor->mode->vts -
1336					   sensor->mode->format.height);
1337
1338	v4l2_ctrl_new_std_menu_items(&sensor->ctrls, &ov5647_ctrl_ops,
1339				     V4L2_CID_TEST_PATTERN,
1340				     ARRAY_SIZE(ov5647_test_pattern_menu) - 1,
1341				     0, 0, ov5647_test_pattern_menu);
1342
1343	if (sensor->ctrls.error)
1344		goto handler_free;
1345
1346	sensor->pixel_rate->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1347	sensor->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1348	sensor->sd.ctrl_handler = &sensor->ctrls;
1349
1350	return 0;
1351
1352handler_free:
1353	dev_err(&client->dev, "%s Controls initialization failed (%d)\n",
1354		__func__, sensor->ctrls.error);
1355	v4l2_ctrl_handler_free(&sensor->ctrls);
1356
1357	return sensor->ctrls.error;
1358}
1359
1360static int ov5647_parse_dt(struct ov5647 *sensor, struct device_node *np)
1361{
1362	struct v4l2_fwnode_endpoint bus_cfg = {
1363		.bus_type = V4L2_MBUS_CSI2_DPHY,
1364	};
1365	struct device_node *ep __free(device_node) =
1366		of_graph_get_endpoint_by_regs(np, 0, -1);
1367	int ret;
1368
1369	if (!ep)
1370		return -EINVAL;
1371
1372	ret = v4l2_fwnode_endpoint_parse(of_fwnode_handle(ep), &bus_cfg);
1373	if (ret)
1374		return ret;
1375
1376	sensor->clock_ncont = bus_cfg.bus.mipi_csi2.flags &
1377			      V4L2_MBUS_CSI2_NONCONTINUOUS_CLOCK;
1378
1379	return 0;
1380}
1381
1382static int ov5647_probe(struct i2c_client *client)
1383{
1384	struct device_node *np = client->dev.of_node;
1385	struct device *dev = &client->dev;
1386	struct ov5647 *sensor;
1387	struct v4l2_subdev *sd;
1388	u32 xclk_freq;
1389	int ret;
1390
1391	sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL);
1392	if (!sensor)
1393		return -ENOMEM;
1394
1395	if (IS_ENABLED(CONFIG_OF) && np) {
1396		ret = ov5647_parse_dt(sensor, np);
1397		if (ret) {
1398			dev_err(dev, "DT parsing error: %d\n", ret);
1399			return ret;
1400		}
1401	}
1402
1403	sensor->xclk = devm_v4l2_sensor_clk_get(dev, NULL);
1404	if (IS_ERR(sensor->xclk))
1405		return dev_err_probe(dev, PTR_ERR(sensor->xclk),
1406				     "could not get xclk\n");
1407
1408	xclk_freq = clk_get_rate(sensor->xclk);
1409	if (xclk_freq != 25000000) {
1410		dev_err(dev, "Unsupported clock frequency: %u\n", xclk_freq);
1411		return -EINVAL;
1412	}
1413
1414	/* Request the power down GPIO asserted. */
1415	sensor->pwdn = devm_gpiod_get_optional(dev, "pwdn", GPIOD_OUT_HIGH);
1416	if (IS_ERR(sensor->pwdn)) {
1417		dev_err(dev, "Failed to get 'pwdn' gpio\n");
1418		return -EINVAL;
1419	}
1420
1421	mutex_init(&sensor->lock);
1422
1423	sensor->mode = OV5647_DEFAULT_MODE;
1424
1425	sd = &sensor->sd;
1426	v4l2_i2c_subdev_init(sd, client, &ov5647_subdev_ops);
1427	sd->internal_ops = &ov5647_subdev_internal_ops;
1428	sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_HAS_EVENTS;
1429
1430	ret = ov5647_init_controls(sensor);
1431	if (ret)
1432		goto mutex_destroy;
1433
1434	sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
1435	sd->entity.function = MEDIA_ENT_F_CAM_SENSOR;
1436	ret = media_entity_pads_init(&sd->entity, 1, &sensor->pad);
1437	if (ret < 0)
1438		goto ctrl_handler_free;
1439
1440	ret = ov5647_power_on(dev);
1441	if (ret)
1442		goto entity_cleanup;
1443
1444	ret = ov5647_detect(sd);
1445	if (ret < 0)
1446		goto power_off;
1447
1448	ret = v4l2_async_register_subdev(sd);
1449	if (ret < 0)
1450		goto power_off;
1451
1452	/* Enable runtime PM and turn off the device */
1453	pm_runtime_set_active(dev);
1454	pm_runtime_enable(dev);
1455	pm_runtime_idle(dev);
1456
1457	dev_dbg(dev, "OmniVision OV5647 camera driver probed\n");
1458
1459	return 0;
1460
1461power_off:
1462	ov5647_power_off(dev);
1463entity_cleanup:
1464	media_entity_cleanup(&sd->entity);
1465ctrl_handler_free:
1466	v4l2_ctrl_handler_free(&sensor->ctrls);
1467mutex_destroy:
1468	mutex_destroy(&sensor->lock);
1469
1470	return ret;
1471}
1472
1473static void ov5647_remove(struct i2c_client *client)
1474{
1475	struct v4l2_subdev *sd = i2c_get_clientdata(client);
1476	struct ov5647 *sensor = to_sensor(sd);
1477
1478	v4l2_async_unregister_subdev(&sensor->sd);
1479	media_entity_cleanup(&sensor->sd.entity);
1480	v4l2_ctrl_handler_free(&sensor->ctrls);
1481	v4l2_device_unregister_subdev(sd);
1482	pm_runtime_disable(&client->dev);
1483	mutex_destroy(&sensor->lock);
1484}
1485
1486static const struct dev_pm_ops ov5647_pm_ops = {
1487	SET_RUNTIME_PM_OPS(ov5647_power_off, ov5647_power_on, NULL)
1488};
1489
1490static const struct i2c_device_id ov5647_id[] = {
1491	{ "ov5647" },
1492	{ /* sentinel */ }
1493};
1494MODULE_DEVICE_TABLE(i2c, ov5647_id);
1495
1496#if IS_ENABLED(CONFIG_OF)
1497static const struct of_device_id ov5647_of_match[] = {
1498	{ .compatible = "ovti,ov5647" },
1499	{ /* sentinel */ },
1500};
1501MODULE_DEVICE_TABLE(of, ov5647_of_match);
1502#endif
1503
1504static struct i2c_driver ov5647_driver = {
1505	.driver = {
1506		.of_match_table = of_match_ptr(ov5647_of_match),
1507		.name	= "ov5647",
1508		.pm	= &ov5647_pm_ops,
1509	},
1510	.probe		= ov5647_probe,
1511	.remove		= ov5647_remove,
1512	.id_table	= ov5647_id,
1513};
1514
1515module_i2c_driver(ov5647_driver);
1516
1517MODULE_AUTHOR("Ramiro Oliveira <roliveir@synopsys.com>");
1518MODULE_DESCRIPTION("A low-level driver for OmniVision ov5647 sensors");
1519MODULE_LICENSE("GPL v2");