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