drivers/media/i2c/ov5693.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2013 Intel Corporation. All Rights Reserved.
   4  *
   5  * Adapted from the atomisp-ov5693 driver, with contributions from:
   6  *
   7  * Daniel Scally
   8  * Jean-Michel Hautbois
   9  * Fabian Wuthrich
  10  * Tsuchiya Yuto
  11  * Jordan Hand
  12  * Jake Day
  13  */
  14
  15 #include <asm/unaligned.h>
  16 #include <linux/acpi.h>
  17 #include <linux/clk.h>
  18 #include <linux/delay.h>
  19 #include <linux/device.h>
  20 #include <linux/i2c.h>
  21 #include <linux/module.h>
  22 #include <linux/pm_runtime.h>
  23 #include <linux/regulator/consumer.h>
  24 #include <linux/slab.h>
  25 #include <linux/types.h>
  26 #include <media/v4l2-ctrls.h>
  27 #include <media/v4l2-device.h>
  28 #include <media/v4l2-fwnode.h>
  29
  30 #define OV5693_REG_8BIT(n)                      ((1 << 16) | (n))
  31 #define OV5693_REG_16BIT(n)                     ((2 << 16) | (n))
  32 #define OV5693_REG_24BIT(n)                     ((3 << 16) | (n))
  33 #define OV5693_REG_SIZE_SHIFT                   16
  34 #define OV5693_REG_ADDR_MASK                    0xffff
  35
  36 /* System Control */
  37 #define OV5693_SW_RESET_REG                     OV5693_REG_8BIT(0x0103)
  38 #define OV5693_SW_STREAM_REG                    OV5693_REG_8BIT(0x0100)
  39 #define OV5693_START_STREAMING                  0x01
  40 #define OV5693_STOP_STREAMING                   0x00
  41 #define OV5693_SW_RESET                         0x01
  42
  43 #define OV5693_REG_CHIP_ID                      OV5693_REG_16BIT(0x300a)
  44 /* Yes, this is right. The datasheet for the OV5693 gives its ID as 0x5690 */
  45 #define OV5693_CHIP_ID                          0x5690
  46
  47 /* Exposure */
  48 #define OV5693_EXPOSURE_CTRL_REG                OV5693_REG_24BIT(0x3500)
  49 #define OV5693_EXPOSURE_CTRL_MASK               GENMASK(19, 4)
  50 #define OV5693_INTEGRATION_TIME_MARGIN          8
  51 #define OV5693_EXPOSURE_MIN                     1
  52 #define OV5693_EXPOSURE_STEP                    1
  53
  54 /* Analogue Gain */
  55 #define OV5693_GAIN_CTRL_REG                    OV5693_REG_16BIT(0x350a)
  56 #define OV5693_GAIN_CTRL_MASK                   GENMASK(10, 4)
  57 #define OV5693_GAIN_MIN                         1
  58 #define OV5693_GAIN_MAX                         127
  59 #define OV5693_GAIN_DEF                         8
  60 #define OV5693_GAIN_STEP                        1
  61
  62 /* Digital Gain */
  63 #define OV5693_MWB_RED_GAIN_REG                 OV5693_REG_16BIT(0x3400)
  64 #define OV5693_MWB_GREEN_GAIN_REG               OV5693_REG_16BIT(0x3402)
  65 #define OV5693_MWB_BLUE_GAIN_REG                OV5693_REG_16BIT(0x3404)
  66 #define OV5693_MWB_GAIN_MASK                    GENMASK(11, 0)
  67 #define OV5693_MWB_GAIN_MAX                     0x0fff
  68 #define OV5693_DIGITAL_GAIN_MIN                 1
  69 #define OV5693_DIGITAL_GAIN_MAX                 4095
  70 #define OV5693_DIGITAL_GAIN_DEF                 1024
  71 #define OV5693_DIGITAL_GAIN_STEP                1
  72
  73 /* Timing and Format */
  74 #define OV5693_CROP_START_X_REG                 OV5693_REG_16BIT(0x3800)
  75 #define OV5693_CROP_START_Y_REG                 OV5693_REG_16BIT(0x3802)
  76 #define OV5693_CROP_END_X_REG                   OV5693_REG_16BIT(0x3804)
  77 #define OV5693_CROP_END_Y_REG                   OV5693_REG_16BIT(0x3806)
  78 #define OV5693_OUTPUT_SIZE_X_REG                OV5693_REG_16BIT(0x3808)
  79 #define OV5693_OUTPUT_SIZE_Y_REG                OV5693_REG_16BIT(0x380a)
  80
  81 #define OV5693_TIMING_HTS_REG                   OV5693_REG_16BIT(0x380c)
  82 #define OV5693_FIXED_PPL                        2688U
  83 #define OV5693_TIMING_VTS_REG                   OV5693_REG_16BIT(0x380e)
  84 #define OV5693_TIMING_MAX_VTS                   0xffff
  85 #define OV5693_TIMING_MIN_VTS                   0x04
  86
  87 #define OV5693_OFFSET_START_X_REG               OV5693_REG_16BIT(0x3810)
  88 #define OV5693_OFFSET_START_Y_REG               OV5693_REG_16BIT(0x3812)
  89
  90 #define OV5693_SUB_INC_X_REG                    OV5693_REG_8BIT(0x3814)
  91 #define OV5693_SUB_INC_Y_REG                    OV5693_REG_8BIT(0x3815)
  92
  93 #define OV5693_FORMAT1_REG                      OV5693_REG_8BIT(0x3820)
  94 #define OV5693_FORMAT1_FLIP_VERT_ISP_EN         BIT(6)
  95 #define OV5693_FORMAT1_FLIP_VERT_SENSOR_EN      BIT(1)
  96 #define OV5693_FORMAT1_VBIN_EN                  BIT(0)
  97 #define OV5693_FORMAT2_REG                      OV5693_REG_8BIT(0x3821)
  98 #define OV5693_FORMAT2_HDR_EN                   BIT(7)
  99 #define OV5693_FORMAT2_FLIP_HORZ_ISP_EN         BIT(2)
 100 #define OV5693_FORMAT2_FLIP_HORZ_SENSOR_EN      BIT(1)
 101 #define OV5693_FORMAT2_HBIN_EN                  BIT(0)
 102
 103 #define OV5693_ISP_CTRL2_REG                    OV5693_REG_8BIT(0x5002)
 104 #define OV5693_ISP_SCALE_ENABLE                 BIT(7)
 105
 106 /* Pixel Array */
 107 #define OV5693_NATIVE_WIDTH                     2624
 108 #define OV5693_NATIVE_HEIGHT                    1956
 109 #define OV5693_NATIVE_START_LEFT                0
 110 #define OV5693_NATIVE_START_TOP                 0
 111 #define OV5693_ACTIVE_WIDTH                     2592
 112 #define OV5693_ACTIVE_HEIGHT                    1944
 113 #define OV5693_ACTIVE_START_LEFT                16
 114 #define OV5693_ACTIVE_START_TOP                 6
 115 #define OV5693_MIN_CROP_WIDTH                   2
 116 #define OV5693_MIN_CROP_HEIGHT                  2
 117
 118 /* Test Pattern */
 119 #define OV5693_TEST_PATTERN_REG                 OV5693_REG_8BIT(0x5e00)
 120 #define OV5693_TEST_PATTERN_ENABLE              BIT(7)
 121 #define OV5693_TEST_PATTERN_ROLLING             BIT(6)
 122 #define OV5693_TEST_PATTERN_RANDOM              0x01
 123 #define OV5693_TEST_PATTERN_BARS                0x00
 124
 125 /* System Frequencies */
 126 #define OV5693_XVCLK_FREQ                       19200000
 127 #define OV5693_LINK_FREQ_419_2MHZ               419200000
 128 #define OV5693_PIXEL_RATE                       167680000
 129
 130 #define to_ov5693_sensor(x) container_of(x, struct ov5693_device, sd)
 131
 132 static const char * const ov5693_supply_names[] = {
 133         "avdd",         /* Analog power */
 134         "dovdd",        /* Digital I/O power */
 135         "dvdd",         /* Digital circuit power */
 136 };
 137
 138 #define OV5693_NUM_SUPPLIES     ARRAY_SIZE(ov5693_supply_names)
 139
 140 struct ov5693_reg {
 141         u32 reg;
 142         u8 val;
 143 };
 144
 145 struct ov5693_reg_list {
 146         u32 num_regs;
 147         const struct ov5693_reg *regs;
 148 };
 149
 150 struct ov5693_device {
 151         struct i2c_client *client;
 152         struct device *dev;
 153
 154         /* Protect against concurrent changes to controls */
 155         struct mutex lock;
 156
 157         struct gpio_desc *reset;
 158         struct gpio_desc *powerdown;
 159         struct gpio_desc *privacy_led;
 160         struct regulator_bulk_data supplies[OV5693_NUM_SUPPLIES];
 161         struct clk *xvclk;
 162
 163         struct ov5693_mode {
 164                 struct v4l2_rect crop;
 165                 struct v4l2_mbus_framefmt format;
 166                 bool binning_x;
 167                 bool binning_y;
 168                 unsigned int inc_x_odd;
 169                 unsigned int inc_y_odd;
 170                 unsigned int vts;
 171         } mode;
 172         bool streaming;
 173
 174         struct v4l2_subdev sd;
 175         struct media_pad pad;
 176
 177         struct ov5693_v4l2_ctrls {
 178                 struct v4l2_ctrl_handler handler;
 179                 struct v4l2_ctrl *link_freq;
 180                 struct v4l2_ctrl *pixel_rate;
 181                 struct v4l2_ctrl *exposure;
 182                 struct v4l2_ctrl *analogue_gain;
 183                 struct v4l2_ctrl *digital_gain;
 184                 struct v4l2_ctrl *hflip;
 185                 struct v4l2_ctrl *vflip;
 186                 struct v4l2_ctrl *hblank;
 187                 struct v4l2_ctrl *vblank;
 188                 struct v4l2_ctrl *test_pattern;
 189         } ctrls;
 190 };
 191
 192 static const struct ov5693_reg ov5693_global_regs[] = {
 193         {OV5693_REG_8BIT(0x3016), 0xf0},
 194         {OV5693_REG_8BIT(0x3017), 0xf0},
 195         {OV5693_REG_8BIT(0x3018), 0xf0},
 196         {OV5693_REG_8BIT(0x3022), 0x01},
 197         {OV5693_REG_8BIT(0x3028), 0x44},
 198         {OV5693_REG_8BIT(0x3098), 0x02},
 199         {OV5693_REG_8BIT(0x3099), 0x19},
 200         {OV5693_REG_8BIT(0x309a), 0x02},
 201         {OV5693_REG_8BIT(0x309b), 0x01},
 202         {OV5693_REG_8BIT(0x309c), 0x00},
 203         {OV5693_REG_8BIT(0x30a0), 0xd2},
 204         {OV5693_REG_8BIT(0x30a2), 0x01},
 205         {OV5693_REG_8BIT(0x30b2), 0x00},
 206         {OV5693_REG_8BIT(0x30b3), 0x83},
 207         {OV5693_REG_8BIT(0x30b4), 0x03},
 208         {OV5693_REG_8BIT(0x30b5), 0x04},
 209         {OV5693_REG_8BIT(0x30b6), 0x01},
 210         {OV5693_REG_8BIT(0x3080), 0x01},
 211         {OV5693_REG_8BIT(0x3104), 0x21},
 212         {OV5693_REG_8BIT(0x3106), 0x00},
 213         {OV5693_REG_8BIT(0x3406), 0x01},
 214         {OV5693_REG_8BIT(0x3503), 0x07},
 215         {OV5693_REG_8BIT(0x350b), 0x40},
 216         {OV5693_REG_8BIT(0x3601), 0x0a},
 217         {OV5693_REG_8BIT(0x3602), 0x38},
 218         {OV5693_REG_8BIT(0x3612), 0x80},
 219         {OV5693_REG_8BIT(0x3620), 0x54},
 220         {OV5693_REG_8BIT(0x3621), 0xc7},
 221         {OV5693_REG_8BIT(0x3622), 0x0f},
 222         {OV5693_REG_8BIT(0x3625), 0x10},
 223         {OV5693_REG_8BIT(0x3630), 0x55},
 224         {OV5693_REG_8BIT(0x3631), 0xf4},
 225         {OV5693_REG_8BIT(0x3632), 0x00},
 226         {OV5693_REG_8BIT(0x3633), 0x34},
 227         {OV5693_REG_8BIT(0x3634), 0x02},
 228         {OV5693_REG_8BIT(0x364d), 0x0d},
 229         {OV5693_REG_8BIT(0x364f), 0xdd},
 230         {OV5693_REG_8BIT(0x3660), 0x04},
 231         {OV5693_REG_8BIT(0x3662), 0x10},
 232         {OV5693_REG_8BIT(0x3663), 0xf1},
 233         {OV5693_REG_8BIT(0x3665), 0x00},
 234         {OV5693_REG_8BIT(0x3666), 0x20},
 235         {OV5693_REG_8BIT(0x3667), 0x00},
 236         {OV5693_REG_8BIT(0x366a), 0x80},
 237         {OV5693_REG_8BIT(0x3680), 0xe0},
 238         {OV5693_REG_8BIT(0x3681), 0x00},
 239         {OV5693_REG_8BIT(0x3700), 0x42},
 240         {OV5693_REG_8BIT(0x3701), 0x14},
 241         {OV5693_REG_8BIT(0x3702), 0xa0},
 242         {OV5693_REG_8BIT(0x3703), 0xd8},
 243         {OV5693_REG_8BIT(0x3704), 0x78},
 244         {OV5693_REG_8BIT(0x3705), 0x02},
 245         {OV5693_REG_8BIT(0x370a), 0x00},
 246         {OV5693_REG_8BIT(0x370b), 0x20},
 247         {OV5693_REG_8BIT(0x370c), 0x0c},
 248         {OV5693_REG_8BIT(0x370d), 0x11},
 249         {OV5693_REG_8BIT(0x370e), 0x00},
 250         {OV5693_REG_8BIT(0x370f), 0x40},
 251         {OV5693_REG_8BIT(0x3710), 0x00},
 252         {OV5693_REG_8BIT(0x371a), 0x1c},
 253         {OV5693_REG_8BIT(0x371b), 0x05},
 254         {OV5693_REG_8BIT(0x371c), 0x01},
 255         {OV5693_REG_8BIT(0x371e), 0xa1},
 256         {OV5693_REG_8BIT(0x371f), 0x0c},
 257         {OV5693_REG_8BIT(0x3721), 0x00},
 258         {OV5693_REG_8BIT(0x3724), 0x10},
 259         {OV5693_REG_8BIT(0x3726), 0x00},
 260         {OV5693_REG_8BIT(0x372a), 0x01},
 261         {OV5693_REG_8BIT(0x3730), 0x10},
 262         {OV5693_REG_8BIT(0x3738), 0x22},
 263         {OV5693_REG_8BIT(0x3739), 0xe5},
 264         {OV5693_REG_8BIT(0x373a), 0x50},
 265         {OV5693_REG_8BIT(0x373b), 0x02},
 266         {OV5693_REG_8BIT(0x373c), 0x41},
 267         {OV5693_REG_8BIT(0x373f), 0x02},
 268         {OV5693_REG_8BIT(0x3740), 0x42},
 269         {OV5693_REG_8BIT(0x3741), 0x02},
 270         {OV5693_REG_8BIT(0x3742), 0x18},
 271         {OV5693_REG_8BIT(0x3743), 0x01},
 272         {OV5693_REG_8BIT(0x3744), 0x02},
 273         {OV5693_REG_8BIT(0x3747), 0x10},
 274         {OV5693_REG_8BIT(0x374c), 0x04},
 275         {OV5693_REG_8BIT(0x3751), 0xf0},
 276         {OV5693_REG_8BIT(0x3752), 0x00},
 277         {OV5693_REG_8BIT(0x3753), 0x00},
 278         {OV5693_REG_8BIT(0x3754), 0xc0},
 279         {OV5693_REG_8BIT(0x3755), 0x00},
 280         {OV5693_REG_8BIT(0x3756), 0x1a},
 281         {OV5693_REG_8BIT(0x3758), 0x00},
 282         {OV5693_REG_8BIT(0x3759), 0x0f},
 283         {OV5693_REG_8BIT(0x376b), 0x44},
 284         {OV5693_REG_8BIT(0x375c), 0x04},
 285         {OV5693_REG_8BIT(0x3774), 0x10},
 286         {OV5693_REG_8BIT(0x3776), 0x00},
 287         {OV5693_REG_8BIT(0x377f), 0x08},
 288         {OV5693_REG_8BIT(0x3780), 0x22},
 289         {OV5693_REG_8BIT(0x3781), 0x0c},
 290         {OV5693_REG_8BIT(0x3784), 0x2c},
 291         {OV5693_REG_8BIT(0x3785), 0x1e},
 292         {OV5693_REG_8BIT(0x378f), 0xf5},
 293         {OV5693_REG_8BIT(0x3791), 0xb0},
 294         {OV5693_REG_8BIT(0x3795), 0x00},
 295         {OV5693_REG_8BIT(0x3796), 0x64},
 296         {OV5693_REG_8BIT(0x3797), 0x11},
 297         {OV5693_REG_8BIT(0x3798), 0x30},
 298         {OV5693_REG_8BIT(0x3799), 0x41},
 299         {OV5693_REG_8BIT(0x379a), 0x07},
 300         {OV5693_REG_8BIT(0x379b), 0xb0},
 301         {OV5693_REG_8BIT(0x379c), 0x0c},
 302         {OV5693_REG_8BIT(0x3a04), 0x06},
 303         {OV5693_REG_8BIT(0x3a05), 0x14},
 304         {OV5693_REG_8BIT(0x3e07), 0x20},
 305         {OV5693_REG_8BIT(0x4000), 0x08},
 306         {OV5693_REG_8BIT(0x4001), 0x04},
 307         {OV5693_REG_8BIT(0x4004), 0x08},
 308         {OV5693_REG_8BIT(0x4006), 0x20},
 309         {OV5693_REG_8BIT(0x4008), 0x24},
 310         {OV5693_REG_8BIT(0x4009), 0x10},
 311         {OV5693_REG_8BIT(0x4058), 0x00},
 312         {OV5693_REG_8BIT(0x4101), 0xb2},
 313         {OV5693_REG_8BIT(0x4307), 0x31},
 314         {OV5693_REG_8BIT(0x4511), 0x05},
 315         {OV5693_REG_8BIT(0x4512), 0x01},
 316         {OV5693_REG_8BIT(0x481f), 0x30},
 317         {OV5693_REG_8BIT(0x4826), 0x2c},
 318         {OV5693_REG_8BIT(0x4d02), 0xfd},
 319         {OV5693_REG_8BIT(0x4d03), 0xf5},
 320         {OV5693_REG_8BIT(0x4d04), 0x0c},
 321         {OV5693_REG_8BIT(0x4d05), 0xcc},
 322         {OV5693_REG_8BIT(0x4837), 0x0a},
 323         {OV5693_REG_8BIT(0x5003), 0x20},
 324         {OV5693_REG_8BIT(0x5013), 0x00},
 325         {OV5693_REG_8BIT(0x5842), 0x01},
 326         {OV5693_REG_8BIT(0x5843), 0x2b},
 327         {OV5693_REG_8BIT(0x5844), 0x01},
 328         {OV5693_REG_8BIT(0x5845), 0x92},
 329         {OV5693_REG_8BIT(0x5846), 0x01},
 330         {OV5693_REG_8BIT(0x5847), 0x8f},
 331         {OV5693_REG_8BIT(0x5848), 0x01},
 332         {OV5693_REG_8BIT(0x5849), 0x0c},
 333         {OV5693_REG_8BIT(0x5e10), 0x0c},
 334         {OV5693_REG_8BIT(0x3820), 0x00},
 335         {OV5693_REG_8BIT(0x3821), 0x1e},
 336         {OV5693_REG_8BIT(0x5041), 0x14}
 337 };
 338
 339 static const struct ov5693_reg_list ov5693_global_setting = {
 340         .num_regs = ARRAY_SIZE(ov5693_global_regs),
 341         .regs = ov5693_global_regs,
 342 };
 343
 344 static const struct v4l2_rect ov5693_default_crop = {
 345         .left = OV5693_ACTIVE_START_LEFT,
 346         .top = OV5693_ACTIVE_START_TOP,
 347         .width = OV5693_ACTIVE_WIDTH,
 348         .height = OV5693_ACTIVE_HEIGHT,
 349 };
 350
 351 static const struct v4l2_mbus_framefmt ov5693_default_fmt = {
 352         .width = OV5693_ACTIVE_WIDTH,
 353         .height = OV5693_ACTIVE_HEIGHT,
 354         .code = MEDIA_BUS_FMT_SBGGR10_1X10,
 355 };
 356
 357 static const s64 link_freq_menu_items[] = {
 358         OV5693_LINK_FREQ_419_2MHZ
 359 };
 360
 361 static const char * const ov5693_test_pattern_menu[] = {
 362         "Disabled",
 363         "Random Data",
 364         "Colour Bars",
 365         "Colour Bars with Rolling Bar"
 366 };
 367
 368 static const u8 ov5693_test_pattern_bits[] = {
 369         0,
 370         OV5693_TEST_PATTERN_ENABLE | OV5693_TEST_PATTERN_RANDOM,
 371         OV5693_TEST_PATTERN_ENABLE | OV5693_TEST_PATTERN_BARS,
 372         OV5693_TEST_PATTERN_ENABLE | OV5693_TEST_PATTERN_BARS |
 373         OV5693_TEST_PATTERN_ROLLING,
 374 };
 375
 376 /* I2C I/O Operations */
 377
 378 static int ov5693_read_reg(struct ov5693_device *ov5693, u32 addr, u32 *value)
 379 {
 380         struct i2c_client *client = ov5693->client;
 381         __be16 reg;
 382         u8 val[4];
 383         struct i2c_msg msg[] = {
 384                 {
 385                         .addr   = client->addr,
 386                         .flags  = 0,
 387                         .len    = 2,
 388                         .buf    = (u8 *)&reg,
 389                 },
 390                 {
 391                         .addr   = client->addr,
 392                         .flags  = I2C_M_RD,
 393                         .buf    = (u8 *)&val,
 394                 },
 395         };
 396         unsigned int len = ((addr >> OV5693_REG_SIZE_SHIFT) & 3);
 397         unsigned int i;
 398         int ret;
 399
 400         reg = cpu_to_be16(addr & OV5693_REG_ADDR_MASK);
 401
 402         msg[1].len = len;
 403
 404         ret = i2c_transfer(client->adapter, msg, 2);
 405         if (ret < 0)
 406                 return dev_err_probe(&client->dev, ret,
 407                                      "Failed to read register 0x%04x\n",
 408                                      addr & OV5693_REG_ADDR_MASK);
 409
 410         *value = 0;
 411         for (i = 0; i < len; ++i) {
 412                 *value <<= 8;
 413                 *value |= val[i];
 414         }
 415
 416         return 0;
 417 }
 418
 419 static void ov5693_write_reg(struct ov5693_device *ov5693, u32 addr, u32 value,
 420                              int *error)
 421 {
 422         struct i2c_client *client = ov5693->client;
 423         struct {
 424                 __be16 reg;
 425                 u8 val[4];
 426         } __packed buf;
 427         struct i2c_msg msg = {
 428                 .addr   = client->addr,
 429                 .buf    = (u8 *)&buf,
 430         };
 431         unsigned int len = ((addr >> OV5693_REG_SIZE_SHIFT) & 3);
 432         unsigned int i;
 433         int ret;
 434
 435         if (*error < 0)
 436                 return;
 437
 438         buf.reg = cpu_to_be16(addr & OV5693_REG_ADDR_MASK);
 439         for (i = 0; i < len; ++i) {
 440                 buf.val[len - i - 1] = value & 0xff;
 441                 value >>= 8;
 442         }
 443
 444         msg.len = len + 2;
 445
 446         ret = i2c_transfer(client->adapter, &msg, 1);
 447         if (ret < 0) {
 448                 dev_err(&client->dev, "Failed to write register 0x%04x: %d\n",
 449                         addr & OV5693_REG_ADDR_MASK, ret);
 450                 *error = ret;
 451         }
 452 }
 453
 454 static int ov5693_write_reg_array(struct ov5693_device *ov5693,
 455                                   const struct ov5693_reg_list *reglist)
 456 {
 457         unsigned int i;
 458         int ret = 0;
 459
 460         for (i = 0; i < reglist->num_regs; i++)
 461                 ov5693_write_reg(ov5693, reglist->regs[i].reg,
 462                                  reglist->regs[i].val, &ret);
 463
 464         return ret;
 465 }
 466
 467 static int ov5693_update_bits(struct ov5693_device *ov5693, u32 address,
 468                               u32 mask, u32 bits)
 469 {
 470         u32 value = 0;
 471         int ret;
 472
 473         ret = ov5693_read_reg(ov5693, address, &value);
 474         if (ret)
 475                 return ret;
 476
 477         value &= ~mask;
 478         value |= bits;
 479
 480         ov5693_write_reg(ov5693, address, value, &ret);
 481
 482         return ret;
 483 }
 484
 485 /* V4L2 Controls Functions */
 486
 487 static int ov5693_flip_vert_configure(struct ov5693_device *ov5693,
 488                                       bool enable)
 489 {
 490         u8 bits = OV5693_FORMAT1_FLIP_VERT_ISP_EN |
 491                   OV5693_FORMAT1_FLIP_VERT_SENSOR_EN;
 492         int ret;
 493
 494         ret = ov5693_update_bits(ov5693, OV5693_FORMAT1_REG, bits,
 495                                  enable ? bits : 0);
 496         if (ret)
 497                 return ret;
 498
 499         return 0;
 500 }
 501
 502 static int ov5693_flip_horz_configure(struct ov5693_device *ov5693,
 503                                       bool enable)
 504 {
 505         u8 bits = OV5693_FORMAT2_FLIP_HORZ_ISP_EN |
 506                   OV5693_FORMAT2_FLIP_HORZ_SENSOR_EN;
 507         int ret;
 508
 509         ret = ov5693_update_bits(ov5693, OV5693_FORMAT2_REG, bits,
 510                                  enable ? bits : 0);
 511         if (ret)
 512                 return ret;
 513
 514         return 0;
 515 }
 516
 517 static int ov5693_get_exposure(struct ov5693_device *ov5693, s32 *value)
 518 {
 519         u32 exposure;
 520         int ret;
 521
 522         ret = ov5693_read_reg(ov5693, OV5693_EXPOSURE_CTRL_REG, &exposure);
 523         if (ret)
 524                 return ret;
 525
 526         /* The lowest 4 bits are unsupported fractional bits */
 527         *value = exposure >> 4;
 528
 529         return 0;
 530 }
 531
 532 static int ov5693_exposure_configure(struct ov5693_device *ov5693,
 533                                      u32 exposure)
 534 {
 535         int ret = 0;
 536
 537         exposure = (exposure << 4) & OV5693_EXPOSURE_CTRL_MASK;
 538
 539         ov5693_write_reg(ov5693, OV5693_EXPOSURE_CTRL_REG, exposure, &ret);
 540
 541         return ret;
 542 }
 543
 544 static int ov5693_get_gain(struct ov5693_device *ov5693, u32 *gain)
 545 {
 546         u32 value;
 547         int ret;
 548
 549         ret = ov5693_read_reg(ov5693, OV5693_GAIN_CTRL_REG, &value);
 550         if (ret)
 551                 return ret;
 552
 553         /* As with exposure, the lowest 4 bits are fractional bits. */
 554         *gain = value >> 4;
 555
 556         return ret;
 557 }
 558
 559 static int ov5693_digital_gain_configure(struct ov5693_device *ov5693,
 560                                          u32 gain)
 561 {
 562         int ret = 0;
 563
 564         gain &= OV5693_MWB_GAIN_MASK;
 565
 566         ov5693_write_reg(ov5693, OV5693_MWB_RED_GAIN_REG, gain, &ret);
 567         ov5693_write_reg(ov5693, OV5693_MWB_GREEN_GAIN_REG, gain, &ret);
 568         ov5693_write_reg(ov5693, OV5693_MWB_BLUE_GAIN_REG, gain, &ret);
 569
 570         return ret;
 571 }
 572
 573 static int ov5693_analog_gain_configure(struct ov5693_device *ov5693, u32 gain)
 574 {
 575         int ret = 0;
 576
 577         gain = (gain << 4) & OV5693_GAIN_CTRL_MASK;
 578
 579         ov5693_write_reg(ov5693, OV5693_GAIN_CTRL_REG, gain, &ret);
 580
 581         return ret;
 582 }
 583
 584 static int ov5693_vts_configure(struct ov5693_device *ov5693, u32 vblank)
 585 {
 586         u16 vts = ov5693->mode.format.height + vblank;
 587         int ret = 0;
 588
 589         ov5693_write_reg(ov5693, OV5693_TIMING_VTS_REG, vts, &ret);
 590
 591         return ret;
 592 }
 593
 594 static int ov5693_test_pattern_configure(struct ov5693_device *ov5693, u32 idx)
 595 {
 596         int ret = 0;
 597
 598         ov5693_write_reg(ov5693, OV5693_TEST_PATTERN_REG,
 599                          ov5693_test_pattern_bits[idx], &ret);
 600
 601         return ret;
 602 }
 603
 604 static int ov5693_s_ctrl(struct v4l2_ctrl *ctrl)
 605 {
 606         struct ov5693_device *ov5693 =
 607             container_of(ctrl->handler, struct ov5693_device, ctrls.handler);
 608         int ret = 0;
 609
 610         /* If VBLANK is altered we need to update exposure to compensate */
 611         if (ctrl->id == V4L2_CID_VBLANK) {
 612                 int exposure_max;
 613
 614                 exposure_max = ov5693->mode.format.height + ctrl->val -
 615                                OV5693_INTEGRATION_TIME_MARGIN;
 616                 __v4l2_ctrl_modify_range(ov5693->ctrls.exposure,
 617                                          ov5693->ctrls.exposure->minimum,
 618                                          exposure_max,
 619                                          ov5693->ctrls.exposure->step,
 620                                          min(ov5693->ctrls.exposure->val,
 621                                              exposure_max));
 622         }
 623
 624         /* Only apply changes to the controls if the device is powered up */
 625         if (!pm_runtime_get_if_in_use(ov5693->dev))
 626                 return 0;
 627
 628         switch (ctrl->id) {
 629         case V4L2_CID_EXPOSURE:
 630                 ret = ov5693_exposure_configure(ov5693, ctrl->val);
 631                 break;
 632         case V4L2_CID_ANALOGUE_GAIN:
 633                 ret = ov5693_analog_gain_configure(ov5693, ctrl->val);
 634                 break;
 635         case V4L2_CID_DIGITAL_GAIN:
 636                 ret = ov5693_digital_gain_configure(ov5693, ctrl->val);
 637                 break;
 638         case V4L2_CID_HFLIP:
 639                 ret = ov5693_flip_horz_configure(ov5693, !!ctrl->val);
 640                 break;
 641         case V4L2_CID_VFLIP:
 642                 ret = ov5693_flip_vert_configure(ov5693, !!ctrl->val);
 643                 break;
 644         case V4L2_CID_VBLANK:
 645                 ret = ov5693_vts_configure(ov5693, ctrl->val);
 646                 break;
 647         case V4L2_CID_TEST_PATTERN:
 648                 ret = ov5693_test_pattern_configure(ov5693, ctrl->val);
 649                 break;
 650         default:
 651                 ret = -EINVAL;
 652         }
 653
 654         pm_runtime_put(ov5693->dev);
 655
 656         return ret;
 657 }
 658
 659 static int ov5693_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
 660 {
 661         struct ov5693_device *ov5693 = container_of(ctrl->handler,
 662                                                     struct ov5693_device,
 663                                                     ctrls.handler);
 664
 665         switch (ctrl->id) {
 666         case V4L2_CID_EXPOSURE_ABSOLUTE:
 667                 return ov5693_get_exposure(ov5693, &ctrl->val);
 668         case V4L2_CID_AUTOGAIN:
 669                 return ov5693_get_gain(ov5693, &ctrl->val);
 670         default:
 671                 return -EINVAL;
 672         }
 673 }
 674
 675 static const struct v4l2_ctrl_ops ov5693_ctrl_ops = {
 676         .s_ctrl = ov5693_s_ctrl,
 677         .g_volatile_ctrl = ov5693_g_volatile_ctrl
 678 };
 679
 680 /* System Control Functions */
 681
 682 static int ov5693_mode_configure(struct ov5693_device *ov5693)
 683 {
 684         const struct ov5693_mode *mode = &ov5693->mode;
 685         int ret = 0;
 686
 687         /* Crop Start X */
 688         ov5693_write_reg(ov5693, OV5693_CROP_START_X_REG, mode->crop.left,
 689                          &ret);
 690
 691         /* Offset X */
 692         ov5693_write_reg(ov5693, OV5693_OFFSET_START_X_REG, 0, &ret);
 693
 694         /* Output Size X */
 695         ov5693_write_reg(ov5693, OV5693_OUTPUT_SIZE_X_REG, mode->format.width,
 696                          &ret);
 697
 698         /* Crop End X */
 699         ov5693_write_reg(ov5693, OV5693_CROP_END_X_REG,
 700                          mode->crop.left + mode->crop.width, &ret);
 701
 702         /* Horizontal Total Size */
 703         ov5693_write_reg(ov5693, OV5693_TIMING_HTS_REG, OV5693_FIXED_PPL,
 704                          &ret);
 705
 706         /* Crop Start Y */
 707         ov5693_write_reg(ov5693, OV5693_CROP_START_Y_REG, mode->crop.top,
 708                          &ret);
 709
 710         /* Offset Y */
 711         ov5693_write_reg(ov5693, OV5693_OFFSET_START_Y_REG, 0, &ret);
 712
 713         /* Output Size Y */
 714         ov5693_write_reg(ov5693, OV5693_OUTPUT_SIZE_Y_REG, mode->format.height,
 715                          &ret);
 716
 717         /* Crop End Y */
 718         ov5693_write_reg(ov5693, OV5693_CROP_END_Y_REG,
 719                          mode->crop.top + mode->crop.height, &ret);
 720
 721         /* Subsample X increase */
 722         ov5693_write_reg(ov5693, OV5693_SUB_INC_X_REG,
 723                          ((mode->inc_x_odd << 4) & 0xf0) | 0x01, &ret);
 724         /* Subsample Y increase */
 725         ov5693_write_reg(ov5693, OV5693_SUB_INC_Y_REG,
 726                          ((mode->inc_y_odd << 4) & 0xf0) | 0x01, &ret);
 727
 728         if (ret)
 729                 return ret;
 730
 731         /* Binning */
 732         ret = ov5693_update_bits(ov5693, OV5693_FORMAT1_REG,
 733                                  OV5693_FORMAT1_VBIN_EN,
 734                                  mode->binning_y ? OV5693_FORMAT1_VBIN_EN : 0);
 735         if (ret)
 736                 return ret;
 737
 738         ret = ov5693_update_bits(ov5693, OV5693_FORMAT2_REG,
 739                                  OV5693_FORMAT2_HBIN_EN,
 740                                  mode->binning_x ? OV5693_FORMAT2_HBIN_EN : 0);
 741
 742         return ret;
 743 }
 744
 745 static int ov5693_enable_streaming(struct ov5693_device *ov5693, bool enable)
 746 {
 747         int ret = 0;
 748
 749         ov5693_write_reg(ov5693, OV5693_SW_STREAM_REG,
 750                          enable ? OV5693_START_STREAMING :
 751                                   OV5693_STOP_STREAMING, &ret);
 752
 753         return ret;
 754 }
 755
 756 static int ov5693_sw_reset(struct ov5693_device *ov5693)
 757 {
 758         int ret = 0;
 759
 760         ov5693_write_reg(ov5693, OV5693_SW_RESET_REG, OV5693_SW_RESET, &ret);
 761
 762         return ret;
 763 }
 764
 765 static int ov5693_sensor_init(struct ov5693_device *ov5693)
 766 {
 767         int ret;
 768
 769         ret = ov5693_sw_reset(ov5693);
 770         if (ret)
 771                 return dev_err_probe(ov5693->dev, ret,
 772                                      "software reset error\n");
 773
 774         ret = ov5693_write_reg_array(ov5693, &ov5693_global_setting);
 775         if (ret)
 776                 return dev_err_probe(ov5693->dev, ret,
 777                                      "global settings error\n");
 778
 779         ret = ov5693_mode_configure(ov5693);
 780         if (ret)
 781                 return dev_err_probe(ov5693->dev, ret,
 782                                      "mode configure error\n");
 783
 784         ret = ov5693_enable_streaming(ov5693, false);
 785         if (ret)
 786                 dev_err(ov5693->dev, "stop streaming error\n");
 787
 788         return ret;
 789 }
 790
 791 static void ov5693_sensor_powerdown(struct ov5693_device *ov5693)
 792 {
 793         gpiod_set_value_cansleep(ov5693->privacy_led, 0);
 794         gpiod_set_value_cansleep(ov5693->reset, 1);
 795         gpiod_set_value_cansleep(ov5693->powerdown, 1);
 796
 797         regulator_bulk_disable(OV5693_NUM_SUPPLIES, ov5693->supplies);
 798
 799         clk_disable_unprepare(ov5693->xvclk);
 800 }
 801
 802 static int ov5693_sensor_powerup(struct ov5693_device *ov5693)
 803 {
 804         int ret;
 805
 806         gpiod_set_value_cansleep(ov5693->reset, 1);
 807         gpiod_set_value_cansleep(ov5693->powerdown, 1);
 808
 809         ret = clk_prepare_enable(ov5693->xvclk);
 810         if (ret) {
 811                 dev_err(ov5693->dev, "Failed to enable clk\n");
 812                 goto fail_power;
 813         }
 814
 815         ret = regulator_bulk_enable(OV5693_NUM_SUPPLIES, ov5693->supplies);
 816         if (ret) {
 817                 dev_err(ov5693->dev, "Failed to enable regulators\n");
 818                 goto fail_power;
 819         }
 820
 821         gpiod_set_value_cansleep(ov5693->powerdown, 0);
 822         gpiod_set_value_cansleep(ov5693->reset, 0);
 823         gpiod_set_value_cansleep(ov5693->privacy_led, 1);
 824
 825         usleep_range(5000, 7500);
 826
 827         return 0;
 828
 829 fail_power:
 830         ov5693_sensor_powerdown(ov5693);
 831         return ret;
 832 }
 833
 834 static int __maybe_unused ov5693_sensor_suspend(struct device *dev)
 835 {
 836         struct v4l2_subdev *sd = dev_get_drvdata(dev);
 837         struct ov5693_device *ov5693 = to_ov5693_sensor(sd);
 838
 839         ov5693_sensor_powerdown(ov5693);
 840
 841         return 0;
 842 }
 843
 844 static int __maybe_unused ov5693_sensor_resume(struct device *dev)
 845 {
 846         struct v4l2_subdev *sd = dev_get_drvdata(dev);
 847         struct ov5693_device *ov5693 = to_ov5693_sensor(sd);
 848         int ret;
 849
 850         mutex_lock(&ov5693->lock);
 851
 852         ret = ov5693_sensor_powerup(ov5693);
 853         if (ret)
 854                 goto out_unlock;
 855
 856         ret = ov5693_sensor_init(ov5693);
 857         if (ret) {
 858                 dev_err(dev, "ov5693 sensor init failure\n");
 859                 goto err_power;
 860         }
 861
 862         goto out_unlock;
 863
 864 err_power:
 865         ov5693_sensor_powerdown(ov5693);
 866 out_unlock:
 867         mutex_unlock(&ov5693->lock);
 868         return ret;
 869 }
 870
 871 static int ov5693_detect(struct ov5693_device *ov5693)
 872 {
 873         int ret;
 874         u32 id;
 875
 876         ret = ov5693_read_reg(ov5693, OV5693_REG_CHIP_ID, &id);
 877         if (ret)
 878                 return ret;
 879
 880         if (id != OV5693_CHIP_ID)
 881                 return dev_err_probe(ov5693->dev, -ENODEV,
 882                                      "sensor ID mismatch. Found 0x%04x\n", id);
 883
 884         return 0;
 885 }
 886
 887 /* V4L2 Framework callbacks */
 888
 889 static unsigned int __ov5693_calc_vts(u32 height)
 890 {
 891         /*
 892          * We need to set a sensible default VTS for whatever format height we
 893          * happen to be given from set_fmt(). This function just targets
 894          * an even multiple of 30fps.
 895          */
 896
 897         unsigned int tgt_fps;
 898
 899         tgt_fps = rounddown(OV5693_PIXEL_RATE / OV5693_FIXED_PPL / height, 30);
 900
 901         return ALIGN_DOWN(OV5693_PIXEL_RATE / OV5693_FIXED_PPL / tgt_fps, 2);
 902 }
 903
 904 static struct v4l2_mbus_framefmt *
 905 __ov5693_get_pad_format(struct ov5693_device *ov5693,
 906                         struct v4l2_subdev_state *state,
 907                         unsigned int pad, enum v4l2_subdev_format_whence which)
 908 {
 909         switch (which) {
 910         case V4L2_SUBDEV_FORMAT_TRY:
 911                 return v4l2_subdev_get_try_format(&ov5693->sd, state, pad);
 912         case V4L2_SUBDEV_FORMAT_ACTIVE:
 913                 return &ov5693->mode.format;
 914         default:
 915                 return NULL;
 916         }
 917 }
 918
 919 static struct v4l2_rect *
 920 __ov5693_get_pad_crop(struct ov5693_device *ov5693,
 921                       struct v4l2_subdev_state *state,
 922                       unsigned int pad, enum v4l2_subdev_format_whence which)
 923 {
 924         switch (which) {
 925         case V4L2_SUBDEV_FORMAT_TRY:
 926                 return v4l2_subdev_get_try_crop(&ov5693->sd, state, pad);
 927         case V4L2_SUBDEV_FORMAT_ACTIVE:
 928                 return &ov5693->mode.crop;
 929         }
 930
 931         return NULL;
 932 }
 933
 934 static int ov5693_get_fmt(struct v4l2_subdev *sd,
 935                           struct v4l2_subdev_state *state,
 936                           struct v4l2_subdev_format *format)
 937 {
 938         struct ov5693_device *ov5693 = to_ov5693_sensor(sd);
 939
 940         format->format = ov5693->mode.format;
 941
 942         return 0;
 943 }
 944
 945 static int ov5693_set_fmt(struct v4l2_subdev *sd,
 946                           struct v4l2_subdev_state *state,
 947                           struct v4l2_subdev_format *format)
 948 {
 949         struct ov5693_device *ov5693 = to_ov5693_sensor(sd);
 950         const struct v4l2_rect *crop;
 951         struct v4l2_mbus_framefmt *fmt;
 952         unsigned int hratio, vratio;
 953         unsigned int width, height;
 954         unsigned int hblank;
 955         int exposure_max;
 956
 957         crop = __ov5693_get_pad_crop(ov5693, state, format->pad, format->which);
 958
 959         /*
 960          * Align to two to simplify the binning calculations below, and clamp
 961          * the requested format at the crop rectangle
 962          */
 963         width = clamp_t(unsigned int, ALIGN(format->format.width, 2),
 964                         OV5693_MIN_CROP_WIDTH, crop->width);
 965         height = clamp_t(unsigned int, ALIGN(format->format.height, 2),
 966                          OV5693_MIN_CROP_HEIGHT, crop->height);
 967
 968         /*
 969          * We can only support setting either the dimensions of the crop rect
 970          * or those dimensions binned (separately) by a factor of two.
 971          */
 972         hratio = clamp_t(unsigned int,
 973                          DIV_ROUND_CLOSEST(crop->width, width), 1, 2);
 974         vratio = clamp_t(unsigned int,
 975                          DIV_ROUND_CLOSEST(crop->height, height), 1, 2);
 976
 977         fmt = __ov5693_get_pad_format(ov5693, state, format->pad,
 978                                       format->which);
 979
 980         fmt->width = crop->width / hratio;
 981         fmt->height = crop->height / vratio;
 982         fmt->code = MEDIA_BUS_FMT_SBGGR10_1X10;
 983
 984         format->format = *fmt;
 985
 986         if (format->which == V4L2_SUBDEV_FORMAT_TRY)
 987                 return 0;
 988
 989         mutex_lock(&ov5693->lock);
 990
 991         ov5693->mode.binning_x = hratio > 1;
 992         ov5693->mode.inc_x_odd = hratio > 1 ? 3 : 1;
 993         ov5693->mode.binning_y = vratio > 1;
 994         ov5693->mode.inc_y_odd = vratio > 1 ? 3 : 1;
 995
 996         ov5693->mode.vts = __ov5693_calc_vts(fmt->height);
 997
 998         __v4l2_ctrl_modify_range(ov5693->ctrls.vblank,
 999                                  OV5693_TIMING_MIN_VTS,
1000                                  OV5693_TIMING_MAX_VTS - fmt->height,
1001                                  1, ov5693->mode.vts - fmt->height);
1002         __v4l2_ctrl_s_ctrl(ov5693->ctrls.vblank,
1003                            ov5693->mode.vts - fmt->height);
1004
1005         hblank = OV5693_FIXED_PPL - fmt->width;
1006         __v4l2_ctrl_modify_range(ov5693->ctrls.hblank, hblank, hblank, 1,
1007                                  hblank);
1008
1009         exposure_max = ov5693->mode.vts - OV5693_INTEGRATION_TIME_MARGIN;
1010         __v4l2_ctrl_modify_range(ov5693->ctrls.exposure,
1011                                  ov5693->ctrls.exposure->minimum, exposure_max,
1012                                  ov5693->ctrls.exposure->step,
1013                                  min(ov5693->ctrls.exposure->val,
1014                                      exposure_max));
1015
1016         mutex_unlock(&ov5693->lock);
1017         return 0;
1018 }
1019
1020 static int ov5693_get_selection(struct v4l2_subdev *sd,
1021                                 struct v4l2_subdev_state *state,
1022                                 struct v4l2_subdev_selection *sel)
1023 {
1024         struct ov5693_device *ov5693 = to_ov5693_sensor(sd);
1025
1026         switch (sel->target) {
1027         case V4L2_SEL_TGT_CROP:
1028                 mutex_lock(&ov5693->lock);
1029                 sel->r = *__ov5693_get_pad_crop(ov5693, state, sel->pad,
1030                                                 sel->which);
1031                 mutex_unlock(&ov5693->lock);
1032                 break;
1033         case V4L2_SEL_TGT_NATIVE_SIZE:
1034                 sel->r.top = 0;
1035                 sel->r.left = 0;
1036                 sel->r.width = OV5693_NATIVE_WIDTH;
1037                 sel->r.height = OV5693_NATIVE_HEIGHT;
1038                 break;
1039         case V4L2_SEL_TGT_CROP_BOUNDS:
1040         case V4L2_SEL_TGT_CROP_DEFAULT:
1041                 sel->r.top = OV5693_ACTIVE_START_TOP;
1042                 sel->r.left = OV5693_ACTIVE_START_LEFT;
1043                 sel->r.width = OV5693_ACTIVE_WIDTH;
1044                 sel->r.height = OV5693_ACTIVE_HEIGHT;
1045                 break;
1046         default:
1047                 return -EINVAL;
1048         }
1049
1050         return 0;
1051 }
1052
1053 static int ov5693_set_selection(struct v4l2_subdev *sd,
1054                                 struct v4l2_subdev_state *state,
1055                                 struct v4l2_subdev_selection *sel)
1056 {
1057         struct ov5693_device *ov5693 = to_ov5693_sensor(sd);
1058         struct v4l2_mbus_framefmt *format;
1059         struct v4l2_rect *__crop;
1060         struct v4l2_rect rect;
1061
1062         if (sel->target != V4L2_SEL_TGT_CROP)
1063                 return -EINVAL;
1064
1065         /*
1066          * Clamp the boundaries of the crop rectangle to the size of the sensor
1067          * pixel array. Align to multiples of 2 to ensure Bayer pattern isn't
1068          * disrupted.
1069          */
1070         rect.left = clamp(ALIGN(sel->r.left, 2), OV5693_NATIVE_START_LEFT,
1071                           OV5693_NATIVE_WIDTH);
1072         rect.top = clamp(ALIGN(sel->r.top, 2), OV5693_NATIVE_START_TOP,
1073                          OV5693_NATIVE_HEIGHT);
1074         rect.width = clamp_t(unsigned int, ALIGN(sel->r.width, 2),
1075                              OV5693_MIN_CROP_WIDTH, OV5693_NATIVE_WIDTH);
1076         rect.height = clamp_t(unsigned int, ALIGN(sel->r.height, 2),
1077                               OV5693_MIN_CROP_HEIGHT, OV5693_NATIVE_HEIGHT);
1078
1079         /* Make sure the crop rectangle isn't outside the bounds of the array */
1080         rect.width = min_t(unsigned int, rect.width,
1081                            OV5693_NATIVE_WIDTH - rect.left);
1082         rect.height = min_t(unsigned int, rect.height,
1083                             OV5693_NATIVE_HEIGHT - rect.top);
1084
1085         __crop = __ov5693_get_pad_crop(ov5693, state, sel->pad, sel->which);
1086
1087         if (rect.width != __crop->width || rect.height != __crop->height) {
1088                 /*
1089                  * Reset the output image size if the crop rectangle size has
1090                  * been modified.
1091                  */
1092                 format = __ov5693_get_pad_format(ov5693, state, sel->pad,
1093                                                  sel->which);
1094                 format->width = rect.width;
1095                 format->height = rect.height;
1096         }
1097
1098         *__crop = rect;
1099         sel->r = rect;
1100
1101         return 0;
1102 }
1103
1104 static int ov5693_s_stream(struct v4l2_subdev *sd, int enable)
1105 {
1106         struct ov5693_device *ov5693 = to_ov5693_sensor(sd);
1107         int ret;
1108
1109         if (enable) {
1110                 ret = pm_runtime_get_sync(ov5693->dev);
1111                 if (ret < 0)
1112                         goto err_power_down;
1113
1114                 mutex_lock(&ov5693->lock);
1115                 ret = __v4l2_ctrl_handler_setup(&ov5693->ctrls.handler);
1116                 if (ret) {
1117                         mutex_unlock(&ov5693->lock);
1118                         goto err_power_down;
1119                 }
1120
1121                 ret = ov5693_enable_streaming(ov5693, true);
1122                 mutex_unlock(&ov5693->lock);
1123         } else {
1124                 mutex_lock(&ov5693->lock);
1125                 ret = ov5693_enable_streaming(ov5693, false);
1126                 mutex_unlock(&ov5693->lock);
1127         }
1128         if (ret)
1129                 goto err_power_down;
1130
1131         ov5693->streaming = !!enable;
1132
1133         if (!enable)
1134                 pm_runtime_put(ov5693->dev);
1135
1136         return 0;
1137 err_power_down:
1138         pm_runtime_put_noidle(ov5693->dev);
1139         return ret;
1140 }
1141
1142 static int ov5693_g_frame_interval(struct v4l2_subdev *sd,
1143                                    struct v4l2_subdev_frame_interval *interval)
1144 {
1145         struct ov5693_device *ov5693 = to_ov5693_sensor(sd);
1146         unsigned int framesize = OV5693_FIXED_PPL * (ov5693->mode.format.height +
1147                                  ov5693->ctrls.vblank->val);
1148         unsigned int fps = DIV_ROUND_CLOSEST(OV5693_PIXEL_RATE, framesize);
1149
1150         interval->interval.numerator = 1;
1151         interval->interval.denominator = fps;
1152
1153         return 0;
1154 }
1155
1156 static int ov5693_enum_mbus_code(struct v4l2_subdev *sd,
1157                                  struct v4l2_subdev_state *state,
1158                                  struct v4l2_subdev_mbus_code_enum *code)
1159 {
1160         /* Only a single mbus format is supported */
1161         if (code->index > 0)
1162                 return -EINVAL;
1163
1164         code->code = MEDIA_BUS_FMT_SBGGR10_1X10;
1165         return 0;
1166 }
1167
1168 static int ov5693_enum_frame_size(struct v4l2_subdev *sd,
1169                                   struct v4l2_subdev_state *state,
1170                                   struct v4l2_subdev_frame_size_enum *fse)
1171 {
1172         struct ov5693_device *ov5693 = to_ov5693_sensor(sd);
1173         struct v4l2_rect *__crop;
1174
1175         if (fse->index > 1 || fse->code != MEDIA_BUS_FMT_SBGGR10_1X10)
1176                 return -EINVAL;
1177
1178         __crop = __ov5693_get_pad_crop(ov5693, state, fse->pad, fse->which);
1179         if (!__crop)
1180                 return -EINVAL;
1181
1182         fse->min_width = __crop->width / (fse->index + 1);
1183         fse->min_height = __crop->height / (fse->index + 1);
1184         fse->max_width = fse->min_width;
1185         fse->max_height = fse->min_height;
1186
1187         return 0;
1188 }
1189
1190 static const struct v4l2_subdev_video_ops ov5693_video_ops = {
1191         .s_stream = ov5693_s_stream,
1192         .g_frame_interval = ov5693_g_frame_interval,
1193 };
1194
1195 static const struct v4l2_subdev_pad_ops ov5693_pad_ops = {
1196         .enum_mbus_code = ov5693_enum_mbus_code,
1197         .enum_frame_size = ov5693_enum_frame_size,
1198         .get_fmt = ov5693_get_fmt,
1199         .set_fmt = ov5693_set_fmt,
1200         .get_selection = ov5693_get_selection,
1201         .set_selection = ov5693_set_selection,
1202 };
1203
1204 static const struct v4l2_subdev_ops ov5693_ops = {
1205         .video = &ov5693_video_ops,
1206         .pad = &ov5693_pad_ops,
1207 };
1208
1209 /* Sensor and Driver Configuration Functions */
1210
1211 static int ov5693_init_controls(struct ov5693_device *ov5693)
1212 {
1213         const struct v4l2_ctrl_ops *ops = &ov5693_ctrl_ops;
1214         struct ov5693_v4l2_ctrls *ctrls = &ov5693->ctrls;
1215         struct v4l2_fwnode_device_properties props;
1216         int vblank_max, vblank_def;
1217         int exposure_max;
1218         int hblank;
1219         int ret;
1220
1221         ret = v4l2_ctrl_handler_init(&ctrls->handler, 12);
1222         if (ret)
1223                 return ret;
1224
1225         /* link freq */
1226         ctrls->link_freq = v4l2_ctrl_new_int_menu(&ctrls->handler,
1227                                                   NULL, V4L2_CID_LINK_FREQ,
1228                                                   0, 0, link_freq_menu_items);
1229         if (ctrls->link_freq)
1230                 ctrls->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1231
1232         /* pixel rate */
1233         ctrls->pixel_rate = v4l2_ctrl_new_std(&ctrls->handler, NULL,
1234                                               V4L2_CID_PIXEL_RATE, 0,
1235                                               OV5693_PIXEL_RATE, 1,
1236                                               OV5693_PIXEL_RATE);
1237
1238         /* Exposure */
1239         exposure_max = ov5693->mode.vts - OV5693_INTEGRATION_TIME_MARGIN;
1240         ctrls->exposure = v4l2_ctrl_new_std(&ctrls->handler, ops,
1241                                             V4L2_CID_EXPOSURE,
1242                                             OV5693_EXPOSURE_MIN, exposure_max,
1243                                             OV5693_EXPOSURE_STEP, exposure_max);
1244
1245         /* Gain */
1246         ctrls->analogue_gain = v4l2_ctrl_new_std(&ctrls->handler,
1247                                                  ops, V4L2_CID_ANALOGUE_GAIN,
1248                                                  OV5693_GAIN_MIN,
1249                                                  OV5693_GAIN_MAX,
1250                                                  OV5693_GAIN_STEP,
1251                                                  OV5693_GAIN_DEF);
1252
1253         ctrls->digital_gain = v4l2_ctrl_new_std(&ctrls->handler, ops,
1254                                                 V4L2_CID_DIGITAL_GAIN,
1255                                                 OV5693_DIGITAL_GAIN_MIN,
1256                                                 OV5693_DIGITAL_GAIN_MAX,
1257                                                 OV5693_DIGITAL_GAIN_STEP,
1258                                                 OV5693_DIGITAL_GAIN_DEF);
1259
1260         /* Flip */
1261         ctrls->hflip = v4l2_ctrl_new_std(&ctrls->handler, ops,
1262                                          V4L2_CID_HFLIP, 0, 1, 1, 0);
1263
1264         ctrls->vflip = v4l2_ctrl_new_std(&ctrls->handler, ops,
1265                                          V4L2_CID_VFLIP, 0, 1, 1, 0);
1266
1267         hblank = OV5693_FIXED_PPL - ov5693->mode.format.width;
1268         ctrls->hblank = v4l2_ctrl_new_std(&ctrls->handler, ops,
1269                                           V4L2_CID_HBLANK, hblank,
1270                                           hblank, 1, hblank);
1271
1272         if (ctrls->hblank)
1273                 ctrls->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1274
1275         vblank_max = OV5693_TIMING_MAX_VTS - ov5693->mode.format.height;
1276         vblank_def = ov5693->mode.vts - ov5693->mode.format.height;
1277         ctrls->vblank = v4l2_ctrl_new_std(&ctrls->handler, ops,
1278                                           V4L2_CID_VBLANK,
1279                                           OV5693_TIMING_MIN_VTS,
1280                                           vblank_max, 1, vblank_def);
1281
1282         ctrls->test_pattern = v4l2_ctrl_new_std_menu_items(
1283                                         &ctrls->handler, ops,
1284                                         V4L2_CID_TEST_PATTERN,
1285                                         ARRAY_SIZE(ov5693_test_pattern_menu) - 1,
1286                                         0, 0, ov5693_test_pattern_menu);
1287
1288         if (ctrls->handler.error) {
1289                 dev_err(ov5693->dev, "Error initialising v4l2 ctrls\n");
1290                 ret = ctrls->handler.error;
1291                 goto err_free_handler;
1292         }
1293
1294         /* set properties from fwnode (e.g. rotation, orientation) */
1295         ret = v4l2_fwnode_device_parse(ov5693->dev, &props);
1296         if (ret)
1297                 goto err_free_handler;
1298
1299         ret = v4l2_ctrl_new_fwnode_properties(&ctrls->handler, ops,
1300                                               &props);
1301         if (ret)
1302                 goto err_free_handler;
1303
1304         /* Use same lock for controls as for everything else. */
1305         ctrls->handler.lock = &ov5693->lock;
1306         ov5693->sd.ctrl_handler = &ctrls->handler;
1307
1308         return 0;
1309
1310 err_free_handler:
1311         v4l2_ctrl_handler_free(&ctrls->handler);
1312         return ret;
1313 }
1314
1315 static int ov5693_configure_gpios(struct ov5693_device *ov5693)
1316 {
1317         ov5693->reset = devm_gpiod_get_optional(ov5693->dev, "reset",
1318                                                 GPIOD_OUT_HIGH);
1319         if (IS_ERR(ov5693->reset)) {
1320                 dev_err(ov5693->dev, "Error fetching reset GPIO\n");
1321                 return PTR_ERR(ov5693->reset);
1322         }
1323
1324         ov5693->powerdown = devm_gpiod_get_optional(ov5693->dev, "powerdown",
1325                                                     GPIOD_OUT_HIGH);
1326         if (IS_ERR(ov5693->powerdown)) {
1327                 dev_err(ov5693->dev, "Error fetching powerdown GPIO\n");
1328                 return PTR_ERR(ov5693->powerdown);
1329         }
1330
1331         ov5693->privacy_led = devm_gpiod_get_optional(ov5693->dev, "privacy-led",
1332                                                       GPIOD_OUT_LOW);
1333         if (IS_ERR(ov5693->privacy_led)) {
1334                 dev_err(ov5693->dev, "Error fetching privacy-led GPIO\n");
1335                 return PTR_ERR(ov5693->privacy_led);
1336         }
1337
1338         return 0;
1339 }
1340
1341 static int ov5693_get_regulators(struct ov5693_device *ov5693)
1342 {
1343         unsigned int i;
1344
1345         for (i = 0; i < OV5693_NUM_SUPPLIES; i++)
1346                 ov5693->supplies[i].supply = ov5693_supply_names[i];
1347
1348         return devm_regulator_bulk_get(ov5693->dev, OV5693_NUM_SUPPLIES,
1349                                        ov5693->supplies);
1350 }
1351
1352 static int ov5693_check_hwcfg(struct ov5693_device *ov5693)
1353 {
1354         struct fwnode_handle *fwnode = dev_fwnode(ov5693->dev);
1355         struct v4l2_fwnode_endpoint bus_cfg = {
1356                 .bus_type = V4L2_MBUS_CSI2_DPHY,
1357         };
1358         struct fwnode_handle *endpoint;
1359         unsigned int i;
1360         int ret;
1361
1362         endpoint = fwnode_graph_get_next_endpoint(fwnode, NULL);
1363         if (!endpoint)
1364                 return -EPROBE_DEFER; /* Could be provided by cio2-bridge */
1365
1366         ret = v4l2_fwnode_endpoint_alloc_parse(endpoint, &bus_cfg);
1367         fwnode_handle_put(endpoint);
1368         if (ret)
1369                 return ret;
1370
1371         if (bus_cfg.bus.mipi_csi2.num_data_lanes != 2) {
1372                 dev_err(ov5693->dev, "only a 2-lane CSI2 config is supported");
1373                 ret = -EINVAL;
1374                 goto out_free_bus_cfg;
1375         }
1376
1377         if (!bus_cfg.nr_of_link_frequencies) {
1378                 dev_err(ov5693->dev, "no link frequencies defined\n");
1379                 ret = -EINVAL;
1380                 goto out_free_bus_cfg;
1381         }
1382
1383         for (i = 0; i < bus_cfg.nr_of_link_frequencies; i++)
1384                 if (bus_cfg.link_frequencies[i] == OV5693_LINK_FREQ_419_2MHZ)
1385                         break;
1386
1387         if (i == bus_cfg.nr_of_link_frequencies) {
1388                 dev_err(ov5693->dev, "supported link freq %ull not found\n",
1389                         OV5693_LINK_FREQ_419_2MHZ);
1390                 ret = -EINVAL;
1391                 goto out_free_bus_cfg;
1392         }
1393
1394 out_free_bus_cfg:
1395         v4l2_fwnode_endpoint_free(&bus_cfg);
1396
1397         return ret;
1398 }
1399
1400 static int ov5693_probe(struct i2c_client *client)
1401 {
1402         struct ov5693_device *ov5693;
1403         u32 xvclk_rate;
1404         int ret = 0;
1405
1406         ov5693 = devm_kzalloc(&client->dev, sizeof(*ov5693), GFP_KERNEL);
1407         if (!ov5693)
1408                 return -ENOMEM;
1409
1410         ov5693->client = client;
1411         ov5693->dev = &client->dev;
1412
1413         ret = ov5693_check_hwcfg(ov5693);
1414         if (ret)
1415                 return ret;
1416
1417         mutex_init(&ov5693->lock);
1418
1419         v4l2_i2c_subdev_init(&ov5693->sd, client, &ov5693_ops);
1420
1421         ov5693->xvclk = devm_clk_get_optional(&client->dev, "xvclk");
1422         if (IS_ERR(ov5693->xvclk))
1423                 return dev_err_probe(&client->dev, PTR_ERR(ov5693->xvclk),
1424                                      "failed to get xvclk: %ld\n",
1425                                      PTR_ERR(ov5693->xvclk));
1426
1427         if (ov5693->xvclk) {
1428                 xvclk_rate = clk_get_rate(ov5693->xvclk);
1429         } else {
1430                 ret = fwnode_property_read_u32(dev_fwnode(&client->dev),
1431                                      "clock-frequency",
1432                                      &xvclk_rate);
1433
1434                 if (ret) {
1435                         dev_err(&client->dev, "can't get clock frequency");
1436                         return ret;
1437                 }
1438         }
1439
1440         if (xvclk_rate != OV5693_XVCLK_FREQ)
1441                 dev_warn(&client->dev, "Found clk freq %u, expected %u\n",
1442                          xvclk_rate, OV5693_XVCLK_FREQ);
1443
1444         ret = ov5693_configure_gpios(ov5693);
1445         if (ret)
1446                 return ret;
1447
1448         ret = ov5693_get_regulators(ov5693);
1449         if (ret)
1450                 return dev_err_probe(&client->dev, ret,
1451                                      "Error fetching regulators\n");
1452
1453         ov5693->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
1454         ov5693->pad.flags = MEDIA_PAD_FL_SOURCE;
1455         ov5693->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
1456
1457         ov5693->mode.crop = ov5693_default_crop;
1458         ov5693->mode.format = ov5693_default_fmt;
1459         ov5693->mode.vts = __ov5693_calc_vts(ov5693->mode.format.height);
1460
1461         ret = ov5693_init_controls(ov5693);
1462         if (ret)
1463                 return ret;
1464
1465         ret = media_entity_pads_init(&ov5693->sd.entity, 1, &ov5693->pad);
1466         if (ret)
1467                 goto err_ctrl_handler_free;
1468
1469         /*
1470          * We need the driver to work in the event that pm runtime is disable in
1471          * the kernel, so power up and verify the chip now. In the event that
1472          * runtime pm is disabled this will leave the chip on, so that streaming
1473          * will work.
1474          */
1475
1476         ret = ov5693_sensor_powerup(ov5693);
1477         if (ret)
1478                 goto err_media_entity_cleanup;
1479
1480         ret = ov5693_detect(ov5693);
1481         if (ret)
1482                 goto err_powerdown;
1483
1484         pm_runtime_set_active(&client->dev);
1485         pm_runtime_get_noresume(&client->dev);
1486         pm_runtime_enable(&client->dev);
1487
1488         ret = v4l2_async_register_subdev_sensor(&ov5693->sd);
1489         if (ret) {
1490                 dev_err(&client->dev, "failed to register V4L2 subdev: %d",
1491                         ret);
1492                 goto err_pm_runtime;
1493         }
1494
1495         pm_runtime_set_autosuspend_delay(&client->dev, 1000);
1496         pm_runtime_use_autosuspend(&client->dev);
1497         pm_runtime_put_autosuspend(&client->dev);
1498
1499         return ret;
1500
1501 err_pm_runtime:
1502         pm_runtime_disable(&client->dev);
1503         pm_runtime_put_noidle(&client->dev);
1504 err_powerdown:
1505         ov5693_sensor_powerdown(ov5693);
1506 err_media_entity_cleanup:
1507         media_entity_cleanup(&ov5693->sd.entity);
1508 err_ctrl_handler_free:
1509         v4l2_ctrl_handler_free(&ov5693->ctrls.handler);
1510
1511         return ret;
1512 }
1513
1514 static void ov5693_remove(struct i2c_client *client)
1515 {
1516         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1517         struct ov5693_device *ov5693 = to_ov5693_sensor(sd);
1518
1519         v4l2_async_unregister_subdev(sd);
1520         media_entity_cleanup(&ov5693->sd.entity);
1521         v4l2_ctrl_handler_free(&ov5693->ctrls.handler);
1522         mutex_destroy(&ov5693->lock);
1523
1524         /*
1525          * Disable runtime PM. In case runtime PM is disabled in the kernel,
1526          * make sure to turn power off manually.
1527          */
1528         pm_runtime_disable(&client->dev);
1529         if (!pm_runtime_status_suspended(&client->dev))
1530                 ov5693_sensor_powerdown(ov5693);
1531         pm_runtime_set_suspended(&client->dev);
1532 }
1533
1534 static const struct dev_pm_ops ov5693_pm_ops = {
1535         SET_RUNTIME_PM_OPS(ov5693_sensor_suspend, ov5693_sensor_resume, NULL)
1536 };
1537
1538 static const struct acpi_device_id ov5693_acpi_match[] = {
1539         {"INT33BE"},
1540         {},
1541 };
1542 MODULE_DEVICE_TABLE(acpi, ov5693_acpi_match);
1543
1544 static const struct of_device_id ov5693_of_match[] = {
1545         { .compatible = "ovti,ov5693", },
1546         { /* sentinel */ },
1547 };
1548 MODULE_DEVICE_TABLE(of, ov5693_of_match);
1549
1550 static struct i2c_driver ov5693_driver = {
1551         .driver = {
1552                 .name = "ov5693",
1553                 .acpi_match_table = ov5693_acpi_match,
1554                 .of_match_table = ov5693_of_match,
1555                 .pm = &ov5693_pm_ops,
1556         },
1557         .probe = ov5693_probe,
1558         .remove = ov5693_remove,
1559 };
1560 module_i2c_driver(ov5693_driver);
1561
1562 MODULE_DESCRIPTION("A low-level driver for OmniVision 5693 sensors");
1563 MODULE_LICENSE("GPL");