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