1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * ov5695 driver 4 * 5 * Copyright (C) 2017 Fuzhou Rockchip Electronics Co., Ltd. 6 */ 7 8 #include <linux/clk.h> 9 #include <linux/device.h> 10 #include <linux/delay.h> 11 #include <linux/gpio/consumer.h> 12 #include <linux/i2c.h> 13 #include <linux/module.h> 14 #include <linux/pm_runtime.h> 15 #include <linux/regulator/consumer.h> 16 #include <linux/sysfs.h> 17 #include <media/media-entity.h> 18 #include <media/v4l2-async.h> 19 #include <media/v4l2-ctrls.h> 20 #include <media/v4l2-subdev.h> 21 22 #ifndef V4L2_CID_DIGITAL_GAIN 23 #define V4L2_CID_DIGITAL_GAIN V4L2_CID_GAIN 24 #endif 25 26 /* 45Mhz * 4 Binning */ 27 #define OV5695_PIXEL_RATE (45 * 1000 * 1000 * 4) 28 #define OV5695_XVCLK_FREQ 24000000 29 30 #define CHIP_ID 0x005695 31 #define OV5695_REG_CHIP_ID 0x300a 32 33 #define OV5695_REG_CTRL_MODE 0x0100 34 #define OV5695_MODE_SW_STANDBY 0x0 35 #define OV5695_MODE_STREAMING BIT(0) 36 37 #define OV5695_REG_EXPOSURE 0x3500 38 #define OV5695_EXPOSURE_MIN 4 39 #define OV5695_EXPOSURE_STEP 1 40 #define OV5695_VTS_MAX 0x7fff 41 42 #define OV5695_REG_ANALOG_GAIN 0x3509 43 #define ANALOG_GAIN_MIN 0x10 44 #define ANALOG_GAIN_MAX 0xf8 45 #define ANALOG_GAIN_STEP 1 46 #define ANALOG_GAIN_DEFAULT 0xf8 47 48 #define OV5695_REG_DIGI_GAIN_H 0x350a 49 #define OV5695_REG_DIGI_GAIN_L 0x350b 50 #define OV5695_DIGI_GAIN_L_MASK 0x3f 51 #define OV5695_DIGI_GAIN_H_SHIFT 6 52 #define OV5695_DIGI_GAIN_MIN 0 53 #define OV5695_DIGI_GAIN_MAX (0x4000 - 1) 54 #define OV5695_DIGI_GAIN_STEP 1 55 #define OV5695_DIGI_GAIN_DEFAULT 1024 56 57 #define OV5695_REG_TEST_PATTERN 0x4503 58 #define OV5695_TEST_PATTERN_ENABLE 0x80 59 #define OV5695_TEST_PATTERN_DISABLE 0x0 60 61 #define OV5695_REG_VTS 0x380e 62 63 #define REG_NULL 0xFFFF 64 65 #define OV5695_REG_VALUE_08BIT 1 66 #define OV5695_REG_VALUE_16BIT 2 67 #define OV5695_REG_VALUE_24BIT 3 68 69 #define OV5695_LANES 2 70 #define OV5695_BITS_PER_SAMPLE 10 71 72 static const char * const ov5695_supply_names[] = { 73 "avdd", /* Analog power */ 74 "dovdd", /* Digital I/O power */ 75 "dvdd", /* Digital core power */ 76 }; 77 78 #define OV5695_NUM_SUPPLIES ARRAY_SIZE(ov5695_supply_names) 79 80 struct regval { 81 u16 addr; 82 u8 val; 83 }; 84 85 struct ov5695_mode { 86 u32 width; 87 u32 height; 88 u32 max_fps; 89 u32 hts_def; 90 u32 vts_def; 91 u32 exp_def; 92 const struct regval *reg_list; 93 }; 94 95 struct ov5695 { 96 struct i2c_client *client; 97 struct clk *xvclk; 98 struct gpio_desc *reset_gpio; 99 struct regulator_bulk_data supplies[OV5695_NUM_SUPPLIES]; 100 101 struct v4l2_subdev subdev; 102 struct media_pad pad; 103 struct v4l2_ctrl_handler ctrl_handler; 104 struct v4l2_ctrl *exposure; 105 struct v4l2_ctrl *anal_gain; 106 struct v4l2_ctrl *digi_gain; 107 struct v4l2_ctrl *hblank; 108 struct v4l2_ctrl *vblank; 109 struct v4l2_ctrl *test_pattern; 110 struct mutex mutex; 111 bool streaming; 112 const struct ov5695_mode *cur_mode; 113 }; 114 115 #define to_ov5695(sd) container_of(sd, struct ov5695, subdev) 116 117 /* 118 * Xclk 24Mhz 119 * Pclk 45Mhz 120 * linelength 672(0x2a0) 121 * framelength 2232(0x8b8) 122 * grabwindow_width 1296 123 * grabwindow_height 972 124 * max_framerate 30fps 125 * mipi_datarate per lane 840Mbps 126 */ 127 static const struct regval ov5695_global_regs[] = { 128 {0x0103, 0x01}, 129 {0x0100, 0x00}, 130 {0x0300, 0x04}, 131 {0x0301, 0x00}, 132 {0x0302, 0x69}, 133 {0x0303, 0x00}, 134 {0x0304, 0x00}, 135 {0x0305, 0x01}, 136 {0x0307, 0x00}, 137 {0x030b, 0x00}, 138 {0x030c, 0x00}, 139 {0x030d, 0x1e}, 140 {0x030e, 0x04}, 141 {0x030f, 0x03}, 142 {0x0312, 0x01}, 143 {0x3000, 0x00}, 144 {0x3002, 0xa1}, 145 {0x3008, 0x00}, 146 {0x3010, 0x00}, 147 {0x3022, 0x51}, 148 {0x3106, 0x15}, 149 {0x3107, 0x01}, 150 {0x3108, 0x05}, 151 {0x3500, 0x00}, 152 {0x3501, 0x45}, 153 {0x3502, 0x00}, 154 {0x3503, 0x08}, 155 {0x3504, 0x03}, 156 {0x3505, 0x8c}, 157 {0x3507, 0x03}, 158 {0x3508, 0x00}, 159 {0x3509, 0x10}, 160 {0x350c, 0x00}, 161 {0x350d, 0x80}, 162 {0x3510, 0x00}, 163 {0x3511, 0x02}, 164 {0x3512, 0x00}, 165 {0x3601, 0x55}, 166 {0x3602, 0x58}, 167 {0x3614, 0x30}, 168 {0x3615, 0x77}, 169 {0x3621, 0x08}, 170 {0x3624, 0x40}, 171 {0x3633, 0x0c}, 172 {0x3634, 0x0c}, 173 {0x3635, 0x0c}, 174 {0x3636, 0x0c}, 175 {0x3638, 0x00}, 176 {0x3639, 0x00}, 177 {0x363a, 0x00}, 178 {0x363b, 0x00}, 179 {0x363c, 0xff}, 180 {0x363d, 0xfa}, 181 {0x3650, 0x44}, 182 {0x3651, 0x44}, 183 {0x3652, 0x44}, 184 {0x3653, 0x44}, 185 {0x3654, 0x44}, 186 {0x3655, 0x44}, 187 {0x3656, 0x44}, 188 {0x3657, 0x44}, 189 {0x3660, 0x00}, 190 {0x3661, 0x00}, 191 {0x3662, 0x00}, 192 {0x366a, 0x00}, 193 {0x366e, 0x0c}, 194 {0x3673, 0x04}, 195 {0x3700, 0x14}, 196 {0x3703, 0x0c}, 197 {0x3715, 0x01}, 198 {0x3733, 0x10}, 199 {0x3734, 0x40}, 200 {0x373f, 0xa0}, 201 {0x3765, 0x20}, 202 {0x37a1, 0x1d}, 203 {0x37a8, 0x26}, 204 {0x37ab, 0x14}, 205 {0x37c2, 0x04}, 206 {0x37cb, 0x09}, 207 {0x37cc, 0x13}, 208 {0x37cd, 0x1f}, 209 {0x37ce, 0x1f}, 210 {0x3800, 0x00}, 211 {0x3801, 0x00}, 212 {0x3802, 0x00}, 213 {0x3803, 0x00}, 214 {0x3804, 0x0a}, 215 {0x3805, 0x3f}, 216 {0x3806, 0x07}, 217 {0x3807, 0xaf}, 218 {0x3808, 0x05}, 219 {0x3809, 0x10}, 220 {0x380a, 0x03}, 221 {0x380b, 0xcc}, 222 {0x380c, 0x02}, 223 {0x380d, 0xa0}, 224 {0x380e, 0x08}, 225 {0x380f, 0xb8}, 226 {0x3810, 0x00}, 227 {0x3811, 0x06}, 228 {0x3812, 0x00}, 229 {0x3813, 0x06}, 230 {0x3814, 0x03}, 231 {0x3815, 0x01}, 232 {0x3816, 0x03}, 233 {0x3817, 0x01}, 234 {0x3818, 0x00}, 235 {0x3819, 0x00}, 236 {0x381a, 0x00}, 237 {0x381b, 0x01}, 238 {0x3820, 0x8b}, 239 {0x3821, 0x01}, 240 {0x3c80, 0x08}, 241 {0x3c82, 0x00}, 242 {0x3c83, 0x00}, 243 {0x3c88, 0x00}, 244 {0x3d85, 0x14}, 245 {0x3f02, 0x08}, 246 {0x3f03, 0x10}, 247 {0x4008, 0x02}, 248 {0x4009, 0x09}, 249 {0x404e, 0x20}, 250 {0x4501, 0x00}, 251 {0x4502, 0x10}, 252 {0x4800, 0x00}, 253 {0x481f, 0x2a}, 254 {0x4837, 0x13}, 255 {0x5000, 0x17}, 256 {0x5780, 0x3e}, 257 {0x5781, 0x0f}, 258 {0x5782, 0x44}, 259 {0x5783, 0x02}, 260 {0x5784, 0x01}, 261 {0x5785, 0x01}, 262 {0x5786, 0x00}, 263 {0x5787, 0x04}, 264 {0x5788, 0x02}, 265 {0x5789, 0x0f}, 266 {0x578a, 0xfd}, 267 {0x578b, 0xf5}, 268 {0x578c, 0xf5}, 269 {0x578d, 0x03}, 270 {0x578e, 0x08}, 271 {0x578f, 0x0c}, 272 {0x5790, 0x08}, 273 {0x5791, 0x06}, 274 {0x5792, 0x00}, 275 {0x5793, 0x52}, 276 {0x5794, 0xa3}, 277 {0x5b00, 0x00}, 278 {0x5b01, 0x1c}, 279 {0x5b02, 0x00}, 280 {0x5b03, 0x7f}, 281 {0x5b05, 0x6c}, 282 {0x5e10, 0xfc}, 283 {0x4010, 0xf1}, 284 {0x3503, 0x08}, 285 {0x3505, 0x8c}, 286 {0x3507, 0x03}, 287 {0x3508, 0x00}, 288 {0x3509, 0xf8}, 289 {REG_NULL, 0x00}, 290 }; 291 292 /* 293 * Xclk 24Mhz 294 * Pclk 45Mhz 295 * linelength 740(0x2e4) 296 * framelength 2024(0x7e8) 297 * grabwindow_width 2592 298 * grabwindow_height 1944 299 * max_framerate 30fps 300 * mipi_datarate per lane 840Mbps 301 */ 302 static const struct regval ov5695_2592x1944_regs[] = { 303 {0x3501, 0x7e}, 304 {0x366e, 0x18}, 305 {0x3800, 0x00}, 306 {0x3801, 0x00}, 307 {0x3802, 0x00}, 308 {0x3803, 0x04}, 309 {0x3804, 0x0a}, 310 {0x3805, 0x3f}, 311 {0x3806, 0x07}, 312 {0x3807, 0xab}, 313 {0x3808, 0x0a}, 314 {0x3809, 0x20}, 315 {0x380a, 0x07}, 316 {0x380b, 0x98}, 317 {0x380c, 0x02}, 318 {0x380d, 0xe4}, 319 {0x380e, 0x07}, 320 {0x380f, 0xe8}, 321 {0x3811, 0x06}, 322 {0x3813, 0x08}, 323 {0x3814, 0x01}, 324 {0x3816, 0x01}, 325 {0x3817, 0x01}, 326 {0x3820, 0x88}, 327 {0x3821, 0x00}, 328 {0x4501, 0x00}, 329 {0x4008, 0x04}, 330 {0x4009, 0x13}, 331 {REG_NULL, 0x00}, 332 }; 333 334 /* 335 * Xclk 24Mhz 336 * Pclk 45Mhz 337 * linelength 672(0x2a0) 338 * framelength 2232(0x8b8) 339 * grabwindow_width 1920 340 * grabwindow_height 1080 341 * max_framerate 30fps 342 * mipi_datarate per lane 840Mbps 343 */ 344 static const struct regval ov5695_1920x1080_regs[] = { 345 {0x3501, 0x45}, 346 {0x366e, 0x18}, 347 {0x3800, 0x01}, 348 {0x3801, 0x50}, 349 {0x3802, 0x01}, 350 {0x3803, 0xb8}, 351 {0x3804, 0x08}, 352 {0x3805, 0xef}, 353 {0x3806, 0x05}, 354 {0x3807, 0xf7}, 355 {0x3808, 0x07}, 356 {0x3809, 0x80}, 357 {0x380a, 0x04}, 358 {0x380b, 0x38}, 359 {0x380c, 0x02}, 360 {0x380d, 0xa0}, 361 {0x380e, 0x08}, 362 {0x380f, 0xb8}, 363 {0x3811, 0x06}, 364 {0x3813, 0x04}, 365 {0x3814, 0x01}, 366 {0x3816, 0x01}, 367 {0x3817, 0x01}, 368 {0x3820, 0x88}, 369 {0x3821, 0x00}, 370 {0x4501, 0x00}, 371 {0x4008, 0x04}, 372 {0x4009, 0x13}, 373 {REG_NULL, 0x00} 374 }; 375 376 /* 377 * Xclk 24Mhz 378 * Pclk 45Mhz 379 * linelength 740(0x02e4) 380 * framelength 1012(0x03f4) 381 * grabwindow_width 1296 382 * grabwindow_height 972 383 * max_framerate 60fps 384 * mipi_datarate per lane 840Mbps 385 */ 386 static const struct regval ov5695_1296x972_regs[] = { 387 {0x0103, 0x01}, 388 {0x0100, 0x00}, 389 {0x0300, 0x04}, 390 {0x0301, 0x00}, 391 {0x0302, 0x69}, 392 {0x0303, 0x00}, 393 {0x0304, 0x00}, 394 {0x0305, 0x01}, 395 {0x0307, 0x00}, 396 {0x030b, 0x00}, 397 {0x030c, 0x00}, 398 {0x030d, 0x1e}, 399 {0x030e, 0x04}, 400 {0x030f, 0x03}, 401 {0x0312, 0x01}, 402 {0x3000, 0x00}, 403 {0x3002, 0xa1}, 404 {0x3008, 0x00}, 405 {0x3010, 0x00}, 406 {0x3016, 0x32}, 407 {0x3022, 0x51}, 408 {0x3106, 0x15}, 409 {0x3107, 0x01}, 410 {0x3108, 0x05}, 411 {0x3500, 0x00}, 412 {0x3501, 0x3e}, 413 {0x3502, 0x00}, 414 {0x3503, 0x08}, 415 {0x3504, 0x03}, 416 {0x3505, 0x8c}, 417 {0x3507, 0x03}, 418 {0x3508, 0x00}, 419 {0x3509, 0x10}, 420 {0x350c, 0x00}, 421 {0x350d, 0x80}, 422 {0x3510, 0x00}, 423 {0x3511, 0x02}, 424 {0x3512, 0x00}, 425 {0x3601, 0x55}, 426 {0x3602, 0x58}, 427 {0x3611, 0x58}, 428 {0x3614, 0x30}, 429 {0x3615, 0x77}, 430 {0x3621, 0x08}, 431 {0x3624, 0x40}, 432 {0x3633, 0x0c}, 433 {0x3634, 0x0c}, 434 {0x3635, 0x0c}, 435 {0x3636, 0x0c}, 436 {0x3638, 0x00}, 437 {0x3639, 0x00}, 438 {0x363a, 0x00}, 439 {0x363b, 0x00}, 440 {0x363c, 0xff}, 441 {0x363d, 0xfa}, 442 {0x3650, 0x44}, 443 {0x3651, 0x44}, 444 {0x3652, 0x44}, 445 {0x3653, 0x44}, 446 {0x3654, 0x44}, 447 {0x3655, 0x44}, 448 {0x3656, 0x44}, 449 {0x3657, 0x44}, 450 {0x3660, 0x00}, 451 {0x3661, 0x00}, 452 {0x3662, 0x00}, 453 {0x366a, 0x00}, 454 {0x366e, 0x0c}, 455 {0x3673, 0x04}, 456 {0x3700, 0x14}, 457 {0x3703, 0x0c}, 458 {0x3706, 0x24}, 459 {0x3714, 0x27}, 460 {0x3715, 0x01}, 461 {0x3716, 0x00}, 462 {0x3717, 0x02}, 463 {0x3733, 0x10}, 464 {0x3734, 0x40}, 465 {0x373f, 0xa0}, 466 {0x3765, 0x20}, 467 {0x37a1, 0x1d}, 468 {0x37a8, 0x26}, 469 {0x37ab, 0x14}, 470 {0x37c2, 0x04}, 471 {0x37c3, 0xf0}, 472 {0x37cb, 0x09}, 473 {0x37cc, 0x13}, 474 {0x37cd, 0x1f}, 475 {0x37ce, 0x1f}, 476 {0x3800, 0x00}, 477 {0x3801, 0x00}, 478 {0x3802, 0x00}, 479 {0x3803, 0x00}, 480 {0x3804, 0x0a}, 481 {0x3805, 0x3f}, 482 {0x3806, 0x07}, 483 {0x3807, 0xaf}, 484 {0x3808, 0x05}, 485 {0x3809, 0x10}, 486 {0x380a, 0x03}, 487 {0x380b, 0xcc}, 488 {0x380c, 0x02}, 489 {0x380d, 0xe4}, 490 {0x380e, 0x03}, 491 {0x380f, 0xf4}, 492 {0x3810, 0x00}, 493 {0x3811, 0x00}, 494 {0x3812, 0x00}, 495 {0x3813, 0x06}, 496 {0x3814, 0x03}, 497 {0x3815, 0x01}, 498 {0x3816, 0x03}, 499 {0x3817, 0x01}, 500 {0x3818, 0x00}, 501 {0x3819, 0x00}, 502 {0x381a, 0x00}, 503 {0x381b, 0x01}, 504 {0x3820, 0x8b}, 505 {0x3821, 0x01}, 506 {0x3c80, 0x08}, 507 {0x3c82, 0x00}, 508 {0x3c83, 0x00}, 509 {0x3c88, 0x00}, 510 {0x3d85, 0x14}, 511 {0x3f02, 0x08}, 512 {0x3f03, 0x10}, 513 {0x4008, 0x02}, 514 {0x4009, 0x09}, 515 {0x404e, 0x20}, 516 {0x4501, 0x00}, 517 {0x4502, 0x10}, 518 {0x4800, 0x00}, 519 {0x481f, 0x2a}, 520 {0x4837, 0x13}, 521 {0x5000, 0x13}, 522 {0x5780, 0x3e}, 523 {0x5781, 0x0f}, 524 {0x5782, 0x44}, 525 {0x5783, 0x02}, 526 {0x5784, 0x01}, 527 {0x5785, 0x01}, 528 {0x5786, 0x00}, 529 {0x5787, 0x04}, 530 {0x5788, 0x02}, 531 {0x5789, 0x0f}, 532 {0x578a, 0xfd}, 533 {0x578b, 0xf5}, 534 {0x578c, 0xf5}, 535 {0x578d, 0x03}, 536 {0x578e, 0x08}, 537 {0x578f, 0x0c}, 538 {0x5790, 0x08}, 539 {0x5791, 0x06}, 540 {0x5792, 0x00}, 541 {0x5793, 0x52}, 542 {0x5794, 0xa3}, 543 {0x5b00, 0x00}, 544 {0x5b01, 0x1c}, 545 {0x5b02, 0x00}, 546 {0x5b03, 0x7f}, 547 {0x5b05, 0x6c}, 548 {0x5e10, 0xfc}, 549 {0x4010, 0xf1}, 550 {0x3503, 0x08}, 551 {0x3505, 0x8c}, 552 {0x3507, 0x03}, 553 {0x3508, 0x00}, 554 {0x3509, 0xf8}, 555 {0x0100, 0x01}, 556 {REG_NULL, 0x00} 557 }; 558 559 /* 560 * Xclk 24Mhz 561 * Pclk 45Mhz 562 * linelength 672(0x2a0) 563 * framelength 2232(0x8b8) 564 * grabwindow_width 1280 565 * grabwindow_height 720 566 * max_framerate 30fps 567 * mipi_datarate per lane 840Mbps 568 */ 569 static const struct regval ov5695_1280x720_regs[] = { 570 {0x3501, 0x45}, 571 {0x366e, 0x0c}, 572 {0x3800, 0x00}, 573 {0x3801, 0x00}, 574 {0x3802, 0x01}, 575 {0x3803, 0x00}, 576 {0x3804, 0x0a}, 577 {0x3805, 0x3f}, 578 {0x3806, 0x06}, 579 {0x3807, 0xaf}, 580 {0x3808, 0x05}, 581 {0x3809, 0x00}, 582 {0x380a, 0x02}, 583 {0x380b, 0xd0}, 584 {0x380c, 0x02}, 585 {0x380d, 0xa0}, 586 {0x380e, 0x08}, 587 {0x380f, 0xb8}, 588 {0x3811, 0x06}, 589 {0x3813, 0x02}, 590 {0x3814, 0x03}, 591 {0x3816, 0x03}, 592 {0x3817, 0x01}, 593 {0x3820, 0x8b}, 594 {0x3821, 0x01}, 595 {0x4501, 0x00}, 596 {0x4008, 0x02}, 597 {0x4009, 0x09}, 598 {REG_NULL, 0x00} 599 }; 600 601 /* 602 * Xclk 24Mhz 603 * Pclk 45Mhz 604 * linelength 672(0x2a0) 605 * framelength 558(0x22e) 606 * grabwindow_width 640 607 * grabwindow_height 480 608 * max_framerate 120fps 609 * mipi_datarate per lane 840Mbps 610 */ 611 static const struct regval ov5695_640x480_regs[] = { 612 {0x3501, 0x22}, 613 {0x366e, 0x0c}, 614 {0x3800, 0x00}, 615 {0x3801, 0x00}, 616 {0x3802, 0x00}, 617 {0x3803, 0x08}, 618 {0x3804, 0x0a}, 619 {0x3805, 0x3f}, 620 {0x3806, 0x07}, 621 {0x3807, 0xa7}, 622 {0x3808, 0x02}, 623 {0x3809, 0x80}, 624 {0x380a, 0x01}, 625 {0x380b, 0xe0}, 626 {0x380c, 0x02}, 627 {0x380d, 0xa0}, 628 {0x380e, 0x02}, 629 {0x380f, 0x2e}, 630 {0x3811, 0x06}, 631 {0x3813, 0x04}, 632 {0x3814, 0x07}, 633 {0x3816, 0x05}, 634 {0x3817, 0x03}, 635 {0x3820, 0x8d}, 636 {0x3821, 0x01}, 637 {0x4501, 0x00}, 638 {0x4008, 0x02}, 639 {0x4009, 0x09}, 640 {REG_NULL, 0x00} 641 }; 642 643 static const struct ov5695_mode supported_modes[] = { 644 { 645 .width = 2592, 646 .height = 1944, 647 .max_fps = 30, 648 .exp_def = 0x0450, 649 .hts_def = 0x02e4 * 4, 650 .vts_def = 0x07e8, 651 .reg_list = ov5695_2592x1944_regs, 652 }, 653 { 654 .width = 1920, 655 .height = 1080, 656 .max_fps = 30, 657 .exp_def = 0x0450, 658 .hts_def = 0x02a0 * 4, 659 .vts_def = 0x08b8, 660 .reg_list = ov5695_1920x1080_regs, 661 }, 662 { 663 .width = 1296, 664 .height = 972, 665 .max_fps = 60, 666 .exp_def = 0x03e0, 667 .hts_def = 0x02e4 * 4, 668 .vts_def = 0x03f4, 669 .reg_list = ov5695_1296x972_regs, 670 }, 671 { 672 .width = 1280, 673 .height = 720, 674 .max_fps = 30, 675 .exp_def = 0x0450, 676 .hts_def = 0x02a0 * 4, 677 .vts_def = 0x08b8, 678 .reg_list = ov5695_1280x720_regs, 679 }, 680 { 681 .width = 640, 682 .height = 480, 683 .max_fps = 120, 684 .exp_def = 0x0450, 685 .hts_def = 0x02a0 * 4, 686 .vts_def = 0x022e, 687 .reg_list = ov5695_640x480_regs, 688 }, 689 }; 690 691 #define OV5695_LINK_FREQ_420MHZ 420000000 692 static const s64 link_freq_menu_items[] = { 693 OV5695_LINK_FREQ_420MHZ 694 }; 695 696 static const char * const ov5695_test_pattern_menu[] = { 697 "Disabled", 698 "Vertical Color Bar Type 1", 699 "Vertical Color Bar Type 2", 700 "Vertical Color Bar Type 3", 701 "Vertical Color Bar Type 4" 702 }; 703 704 /* Write registers up to 4 at a time */ 705 static int ov5695_write_reg(struct i2c_client *client, u16 reg, 706 u32 len, u32 val) 707 { 708 u32 buf_i, val_i; 709 u8 buf[6]; 710 u8 *val_p; 711 __be32 val_be; 712 713 if (len > 4) 714 return -EINVAL; 715 716 buf[0] = reg >> 8; 717 buf[1] = reg & 0xff; 718 719 val_be = cpu_to_be32(val); 720 val_p = (u8 *)&val_be; 721 buf_i = 2; 722 val_i = 4 - len; 723 724 while (val_i < 4) 725 buf[buf_i++] = val_p[val_i++]; 726 727 if (i2c_master_send(client, buf, len + 2) != len + 2) 728 return -EIO; 729 730 return 0; 731 } 732 733 static int ov5695_write_array(struct i2c_client *client, 734 const struct regval *regs) 735 { 736 u32 i; 737 int ret = 0; 738 739 for (i = 0; ret == 0 && regs[i].addr != REG_NULL; i++) 740 ret = ov5695_write_reg(client, regs[i].addr, 741 OV5695_REG_VALUE_08BIT, regs[i].val); 742 743 return ret; 744 } 745 746 /* Read registers up to 4 at a time */ 747 static int ov5695_read_reg(struct i2c_client *client, u16 reg, unsigned int len, 748 u32 *val) 749 { 750 struct i2c_msg msgs[2]; 751 u8 *data_be_p; 752 __be32 data_be = 0; 753 __be16 reg_addr_be = cpu_to_be16(reg); 754 int ret; 755 756 if (len > 4) 757 return -EINVAL; 758 759 data_be_p = (u8 *)&data_be; 760 /* Write register address */ 761 msgs[0].addr = client->addr; 762 msgs[0].flags = 0; 763 msgs[0].len = 2; 764 msgs[0].buf = (u8 *)®_addr_be; 765 766 /* Read data from register */ 767 msgs[1].addr = client->addr; 768 msgs[1].flags = I2C_M_RD; 769 msgs[1].len = len; 770 msgs[1].buf = &data_be_p[4 - len]; 771 772 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 773 if (ret != ARRAY_SIZE(msgs)) 774 return -EIO; 775 776 *val = be32_to_cpu(data_be); 777 778 return 0; 779 } 780 781 static int ov5695_get_reso_dist(const struct ov5695_mode *mode, 782 struct v4l2_mbus_framefmt *framefmt) 783 { 784 return abs(mode->width - framefmt->width) + 785 abs(mode->height - framefmt->height); 786 } 787 788 static const struct ov5695_mode * 789 ov5695_find_best_fit(struct v4l2_subdev_format *fmt) 790 { 791 struct v4l2_mbus_framefmt *framefmt = &fmt->format; 792 int dist; 793 int cur_best_fit = 0; 794 int cur_best_fit_dist = -1; 795 int i; 796 797 for (i = 0; i < ARRAY_SIZE(supported_modes); i++) { 798 dist = ov5695_get_reso_dist(&supported_modes[i], framefmt); 799 if (cur_best_fit_dist == -1 || dist < cur_best_fit_dist) { 800 cur_best_fit_dist = dist; 801 cur_best_fit = i; 802 } 803 } 804 805 return &supported_modes[cur_best_fit]; 806 } 807 808 static int ov5695_set_fmt(struct v4l2_subdev *sd, 809 struct v4l2_subdev_pad_config *cfg, 810 struct v4l2_subdev_format *fmt) 811 { 812 struct ov5695 *ov5695 = to_ov5695(sd); 813 const struct ov5695_mode *mode; 814 s64 h_blank, vblank_def; 815 816 mutex_lock(&ov5695->mutex); 817 818 mode = ov5695_find_best_fit(fmt); 819 fmt->format.code = MEDIA_BUS_FMT_SBGGR10_1X10; 820 fmt->format.width = mode->width; 821 fmt->format.height = mode->height; 822 fmt->format.field = V4L2_FIELD_NONE; 823 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) { 824 #ifdef CONFIG_VIDEO_V4L2_SUBDEV_API 825 *v4l2_subdev_get_try_format(sd, cfg, fmt->pad) = fmt->format; 826 #endif 827 } else { 828 ov5695->cur_mode = mode; 829 h_blank = mode->hts_def - mode->width; 830 __v4l2_ctrl_modify_range(ov5695->hblank, h_blank, 831 h_blank, 1, h_blank); 832 vblank_def = mode->vts_def - mode->height; 833 __v4l2_ctrl_modify_range(ov5695->vblank, vblank_def, 834 OV5695_VTS_MAX - mode->height, 835 1, vblank_def); 836 } 837 838 mutex_unlock(&ov5695->mutex); 839 840 return 0; 841 } 842 843 static int ov5695_get_fmt(struct v4l2_subdev *sd, 844 struct v4l2_subdev_pad_config *cfg, 845 struct v4l2_subdev_format *fmt) 846 { 847 struct ov5695 *ov5695 = to_ov5695(sd); 848 const struct ov5695_mode *mode = ov5695->cur_mode; 849 850 mutex_lock(&ov5695->mutex); 851 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) { 852 #ifdef CONFIG_VIDEO_V4L2_SUBDEV_API 853 fmt->format = *v4l2_subdev_get_try_format(sd, cfg, fmt->pad); 854 #else 855 mutex_unlock(&ov5695->mutex); 856 return -EINVAL; 857 #endif 858 } else { 859 fmt->format.width = mode->width; 860 fmt->format.height = mode->height; 861 fmt->format.code = MEDIA_BUS_FMT_SBGGR10_1X10; 862 fmt->format.field = V4L2_FIELD_NONE; 863 } 864 mutex_unlock(&ov5695->mutex); 865 866 return 0; 867 } 868 869 static int ov5695_enum_mbus_code(struct v4l2_subdev *sd, 870 struct v4l2_subdev_pad_config *cfg, 871 struct v4l2_subdev_mbus_code_enum *code) 872 { 873 if (code->index != 0) 874 return -EINVAL; 875 code->code = MEDIA_BUS_FMT_SBGGR10_1X10; 876 877 return 0; 878 } 879 880 static int ov5695_enum_frame_sizes(struct v4l2_subdev *sd, 881 struct v4l2_subdev_pad_config *cfg, 882 struct v4l2_subdev_frame_size_enum *fse) 883 { 884 if (fse->index >= ARRAY_SIZE(supported_modes)) 885 return -EINVAL; 886 887 if (fse->code != MEDIA_BUS_FMT_SBGGR10_1X10) 888 return -EINVAL; 889 890 fse->min_width = supported_modes[fse->index].width; 891 fse->max_width = supported_modes[fse->index].width; 892 fse->max_height = supported_modes[fse->index].height; 893 fse->min_height = supported_modes[fse->index].height; 894 895 return 0; 896 } 897 898 static int ov5695_enable_test_pattern(struct ov5695 *ov5695, u32 pattern) 899 { 900 u32 val; 901 902 if (pattern) 903 val = (pattern - 1) | OV5695_TEST_PATTERN_ENABLE; 904 else 905 val = OV5695_TEST_PATTERN_DISABLE; 906 907 return ov5695_write_reg(ov5695->client, OV5695_REG_TEST_PATTERN, 908 OV5695_REG_VALUE_08BIT, val); 909 } 910 911 static int __ov5695_start_stream(struct ov5695 *ov5695) 912 { 913 int ret; 914 915 ret = ov5695_write_array(ov5695->client, ov5695_global_regs); 916 if (ret) 917 return ret; 918 ret = ov5695_write_array(ov5695->client, ov5695->cur_mode->reg_list); 919 if (ret) 920 return ret; 921 922 /* In case these controls are set before streaming */ 923 ret = __v4l2_ctrl_handler_setup(&ov5695->ctrl_handler); 924 if (ret) 925 return ret; 926 927 return ov5695_write_reg(ov5695->client, OV5695_REG_CTRL_MODE, 928 OV5695_REG_VALUE_08BIT, OV5695_MODE_STREAMING); 929 } 930 931 static int __ov5695_stop_stream(struct ov5695 *ov5695) 932 { 933 return ov5695_write_reg(ov5695->client, OV5695_REG_CTRL_MODE, 934 OV5695_REG_VALUE_08BIT, OV5695_MODE_SW_STANDBY); 935 } 936 937 static int ov5695_s_stream(struct v4l2_subdev *sd, int on) 938 { 939 struct ov5695 *ov5695 = to_ov5695(sd); 940 struct i2c_client *client = ov5695->client; 941 int ret = 0; 942 943 mutex_lock(&ov5695->mutex); 944 on = !!on; 945 if (on == ov5695->streaming) 946 goto unlock_and_return; 947 948 if (on) { 949 ret = pm_runtime_get_sync(&client->dev); 950 if (ret < 0) { 951 pm_runtime_put_noidle(&client->dev); 952 goto unlock_and_return; 953 } 954 955 ret = __ov5695_start_stream(ov5695); 956 if (ret) { 957 v4l2_err(sd, "start stream failed while write regs\n"); 958 pm_runtime_put(&client->dev); 959 goto unlock_and_return; 960 } 961 } else { 962 __ov5695_stop_stream(ov5695); 963 pm_runtime_put(&client->dev); 964 } 965 966 ov5695->streaming = on; 967 968 unlock_and_return: 969 mutex_unlock(&ov5695->mutex); 970 971 return ret; 972 } 973 974 static int __ov5695_power_on(struct ov5695 *ov5695) 975 { 976 int i, ret; 977 struct device *dev = &ov5695->client->dev; 978 979 ret = clk_prepare_enable(ov5695->xvclk); 980 if (ret < 0) { 981 dev_err(dev, "Failed to enable xvclk\n"); 982 return ret; 983 } 984 985 gpiod_set_value_cansleep(ov5695->reset_gpio, 1); 986 987 /* 988 * The hardware requires the regulators to be powered on in order, 989 * so enable them one by one. 990 */ 991 for (i = 0; i < OV5695_NUM_SUPPLIES; i++) { 992 ret = regulator_enable(ov5695->supplies[i].consumer); 993 if (ret) { 994 dev_err(dev, "Failed to enable %s: %d\n", 995 ov5695->supplies[i].supply, ret); 996 goto disable_reg_clk; 997 } 998 } 999 1000 gpiod_set_value_cansleep(ov5695->reset_gpio, 0); 1001 1002 usleep_range(1000, 1200); 1003 1004 return 0; 1005 1006 disable_reg_clk: 1007 for (--i; i >= 0; i--) 1008 regulator_disable(ov5695->supplies[i].consumer); 1009 clk_disable_unprepare(ov5695->xvclk); 1010 1011 return ret; 1012 } 1013 1014 static void __ov5695_power_off(struct ov5695 *ov5695) 1015 { 1016 struct device *dev = &ov5695->client->dev; 1017 int i, ret; 1018 1019 clk_disable_unprepare(ov5695->xvclk); 1020 gpiod_set_value_cansleep(ov5695->reset_gpio, 1); 1021 1022 /* 1023 * The hardware requires the regulators to be powered off in order, 1024 * so disable them one by one. 1025 */ 1026 for (i = OV5695_NUM_SUPPLIES - 1; i >= 0; i--) { 1027 ret = regulator_disable(ov5695->supplies[i].consumer); 1028 if (ret) 1029 dev_err(dev, "Failed to disable %s: %d\n", 1030 ov5695->supplies[i].supply, ret); 1031 } 1032 } 1033 1034 static int __maybe_unused ov5695_runtime_resume(struct device *dev) 1035 { 1036 struct v4l2_subdev *sd = dev_get_drvdata(dev); 1037 struct ov5695 *ov5695 = to_ov5695(sd); 1038 1039 return __ov5695_power_on(ov5695); 1040 } 1041 1042 static int __maybe_unused ov5695_runtime_suspend(struct device *dev) 1043 { 1044 struct v4l2_subdev *sd = dev_get_drvdata(dev); 1045 struct ov5695 *ov5695 = to_ov5695(sd); 1046 1047 __ov5695_power_off(ov5695); 1048 1049 return 0; 1050 } 1051 1052 #ifdef CONFIG_VIDEO_V4L2_SUBDEV_API 1053 static int ov5695_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh) 1054 { 1055 struct ov5695 *ov5695 = to_ov5695(sd); 1056 struct v4l2_mbus_framefmt *try_fmt = 1057 v4l2_subdev_get_try_format(sd, fh->pad, 0); 1058 const struct ov5695_mode *def_mode = &supported_modes[0]; 1059 1060 mutex_lock(&ov5695->mutex); 1061 /* Initialize try_fmt */ 1062 try_fmt->width = def_mode->width; 1063 try_fmt->height = def_mode->height; 1064 try_fmt->code = MEDIA_BUS_FMT_SBGGR10_1X10; 1065 try_fmt->field = V4L2_FIELD_NONE; 1066 1067 mutex_unlock(&ov5695->mutex); 1068 /* No crop or compose */ 1069 1070 return 0; 1071 } 1072 #endif 1073 1074 static const struct dev_pm_ops ov5695_pm_ops = { 1075 SET_RUNTIME_PM_OPS(ov5695_runtime_suspend, 1076 ov5695_runtime_resume, NULL) 1077 }; 1078 1079 #ifdef CONFIG_VIDEO_V4L2_SUBDEV_API 1080 static const struct v4l2_subdev_internal_ops ov5695_internal_ops = { 1081 .open = ov5695_open, 1082 }; 1083 #endif 1084 1085 static const struct v4l2_subdev_video_ops ov5695_video_ops = { 1086 .s_stream = ov5695_s_stream, 1087 }; 1088 1089 static const struct v4l2_subdev_pad_ops ov5695_pad_ops = { 1090 .enum_mbus_code = ov5695_enum_mbus_code, 1091 .enum_frame_size = ov5695_enum_frame_sizes, 1092 .get_fmt = ov5695_get_fmt, 1093 .set_fmt = ov5695_set_fmt, 1094 }; 1095 1096 static const struct v4l2_subdev_ops ov5695_subdev_ops = { 1097 .video = &ov5695_video_ops, 1098 .pad = &ov5695_pad_ops, 1099 }; 1100 1101 static int ov5695_set_ctrl(struct v4l2_ctrl *ctrl) 1102 { 1103 struct ov5695 *ov5695 = container_of(ctrl->handler, 1104 struct ov5695, ctrl_handler); 1105 struct i2c_client *client = ov5695->client; 1106 s64 max; 1107 int ret = 0; 1108 1109 /* Propagate change of current control to all related controls */ 1110 switch (ctrl->id) { 1111 case V4L2_CID_VBLANK: 1112 /* Update max exposure while meeting expected vblanking */ 1113 max = ov5695->cur_mode->height + ctrl->val - 4; 1114 __v4l2_ctrl_modify_range(ov5695->exposure, 1115 ov5695->exposure->minimum, max, 1116 ov5695->exposure->step, 1117 ov5695->exposure->default_value); 1118 break; 1119 } 1120 1121 if (!pm_runtime_get_if_in_use(&client->dev)) 1122 return 0; 1123 1124 switch (ctrl->id) { 1125 case V4L2_CID_EXPOSURE: 1126 /* 4 least significant bits of expsoure are fractional part */ 1127 ret = ov5695_write_reg(ov5695->client, OV5695_REG_EXPOSURE, 1128 OV5695_REG_VALUE_24BIT, ctrl->val << 4); 1129 break; 1130 case V4L2_CID_ANALOGUE_GAIN: 1131 ret = ov5695_write_reg(ov5695->client, OV5695_REG_ANALOG_GAIN, 1132 OV5695_REG_VALUE_08BIT, ctrl->val); 1133 break; 1134 case V4L2_CID_DIGITAL_GAIN: 1135 ret = ov5695_write_reg(ov5695->client, OV5695_REG_DIGI_GAIN_L, 1136 OV5695_REG_VALUE_08BIT, 1137 ctrl->val & OV5695_DIGI_GAIN_L_MASK); 1138 ret = ov5695_write_reg(ov5695->client, OV5695_REG_DIGI_GAIN_H, 1139 OV5695_REG_VALUE_08BIT, 1140 ctrl->val >> OV5695_DIGI_GAIN_H_SHIFT); 1141 break; 1142 case V4L2_CID_VBLANK: 1143 ret = ov5695_write_reg(ov5695->client, OV5695_REG_VTS, 1144 OV5695_REG_VALUE_16BIT, 1145 ctrl->val + ov5695->cur_mode->height); 1146 break; 1147 case V4L2_CID_TEST_PATTERN: 1148 ret = ov5695_enable_test_pattern(ov5695, ctrl->val); 1149 break; 1150 default: 1151 dev_warn(&client->dev, "%s Unhandled id:0x%x, val:0x%x\n", 1152 __func__, ctrl->id, ctrl->val); 1153 break; 1154 } 1155 1156 pm_runtime_put(&client->dev); 1157 1158 return ret; 1159 } 1160 1161 static const struct v4l2_ctrl_ops ov5695_ctrl_ops = { 1162 .s_ctrl = ov5695_set_ctrl, 1163 }; 1164 1165 static int ov5695_initialize_controls(struct ov5695 *ov5695) 1166 { 1167 const struct ov5695_mode *mode; 1168 struct v4l2_ctrl_handler *handler; 1169 struct v4l2_ctrl *ctrl; 1170 s64 exposure_max, vblank_def; 1171 u32 h_blank; 1172 int ret; 1173 1174 handler = &ov5695->ctrl_handler; 1175 mode = ov5695->cur_mode; 1176 ret = v4l2_ctrl_handler_init(handler, 8); 1177 if (ret) 1178 return ret; 1179 handler->lock = &ov5695->mutex; 1180 1181 ctrl = v4l2_ctrl_new_int_menu(handler, NULL, V4L2_CID_LINK_FREQ, 1182 0, 0, link_freq_menu_items); 1183 if (ctrl) 1184 ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY; 1185 1186 v4l2_ctrl_new_std(handler, NULL, V4L2_CID_PIXEL_RATE, 1187 0, OV5695_PIXEL_RATE, 1, OV5695_PIXEL_RATE); 1188 1189 h_blank = mode->hts_def - mode->width; 1190 ov5695->hblank = v4l2_ctrl_new_std(handler, NULL, V4L2_CID_HBLANK, 1191 h_blank, h_blank, 1, h_blank); 1192 if (ov5695->hblank) 1193 ov5695->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY; 1194 1195 vblank_def = mode->vts_def - mode->height; 1196 ov5695->vblank = v4l2_ctrl_new_std(handler, &ov5695_ctrl_ops, 1197 V4L2_CID_VBLANK, vblank_def, 1198 OV5695_VTS_MAX - mode->height, 1199 1, vblank_def); 1200 1201 exposure_max = mode->vts_def - 4; 1202 ov5695->exposure = v4l2_ctrl_new_std(handler, &ov5695_ctrl_ops, 1203 V4L2_CID_EXPOSURE, OV5695_EXPOSURE_MIN, 1204 exposure_max, OV5695_EXPOSURE_STEP, 1205 mode->exp_def); 1206 1207 ov5695->anal_gain = v4l2_ctrl_new_std(handler, &ov5695_ctrl_ops, 1208 V4L2_CID_ANALOGUE_GAIN, ANALOG_GAIN_MIN, 1209 ANALOG_GAIN_MAX, ANALOG_GAIN_STEP, 1210 ANALOG_GAIN_DEFAULT); 1211 1212 /* Digital gain */ 1213 ov5695->digi_gain = v4l2_ctrl_new_std(handler, &ov5695_ctrl_ops, 1214 V4L2_CID_DIGITAL_GAIN, OV5695_DIGI_GAIN_MIN, 1215 OV5695_DIGI_GAIN_MAX, OV5695_DIGI_GAIN_STEP, 1216 OV5695_DIGI_GAIN_DEFAULT); 1217 1218 ov5695->test_pattern = v4l2_ctrl_new_std_menu_items(handler, 1219 &ov5695_ctrl_ops, V4L2_CID_TEST_PATTERN, 1220 ARRAY_SIZE(ov5695_test_pattern_menu) - 1, 1221 0, 0, ov5695_test_pattern_menu); 1222 1223 if (handler->error) { 1224 ret = handler->error; 1225 dev_err(&ov5695->client->dev, 1226 "Failed to init controls(%d)\n", ret); 1227 goto err_free_handler; 1228 } 1229 1230 ov5695->subdev.ctrl_handler = handler; 1231 1232 return 0; 1233 1234 err_free_handler: 1235 v4l2_ctrl_handler_free(handler); 1236 1237 return ret; 1238 } 1239 1240 static int ov5695_check_sensor_id(struct ov5695 *ov5695, 1241 struct i2c_client *client) 1242 { 1243 struct device *dev = &ov5695->client->dev; 1244 u32 id = 0; 1245 int ret; 1246 1247 ret = ov5695_read_reg(client, OV5695_REG_CHIP_ID, 1248 OV5695_REG_VALUE_24BIT, &id); 1249 if (id != CHIP_ID) { 1250 dev_err(dev, "Unexpected sensor id(%06x), ret(%d)\n", id, ret); 1251 return ret; 1252 } 1253 1254 dev_info(dev, "Detected OV%06x sensor\n", CHIP_ID); 1255 1256 return 0; 1257 } 1258 1259 static int ov5695_configure_regulators(struct ov5695 *ov5695) 1260 { 1261 int i; 1262 1263 for (i = 0; i < OV5695_NUM_SUPPLIES; i++) 1264 ov5695->supplies[i].supply = ov5695_supply_names[i]; 1265 1266 return devm_regulator_bulk_get(&ov5695->client->dev, 1267 OV5695_NUM_SUPPLIES, 1268 ov5695->supplies); 1269 } 1270 1271 static int ov5695_probe(struct i2c_client *client, 1272 const struct i2c_device_id *id) 1273 { 1274 struct device *dev = &client->dev; 1275 struct ov5695 *ov5695; 1276 struct v4l2_subdev *sd; 1277 int ret; 1278 1279 ov5695 = devm_kzalloc(dev, sizeof(*ov5695), GFP_KERNEL); 1280 if (!ov5695) 1281 return -ENOMEM; 1282 1283 ov5695->client = client; 1284 ov5695->cur_mode = &supported_modes[0]; 1285 1286 ov5695->xvclk = devm_clk_get(dev, "xvclk"); 1287 if (IS_ERR(ov5695->xvclk)) { 1288 dev_err(dev, "Failed to get xvclk\n"); 1289 return -EINVAL; 1290 } 1291 ret = clk_set_rate(ov5695->xvclk, OV5695_XVCLK_FREQ); 1292 if (ret < 0) { 1293 dev_err(dev, "Failed to set xvclk rate (24MHz)\n"); 1294 return ret; 1295 } 1296 if (clk_get_rate(ov5695->xvclk) != OV5695_XVCLK_FREQ) 1297 dev_warn(dev, "xvclk mismatched, modes are based on 24MHz\n"); 1298 1299 ov5695->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); 1300 if (IS_ERR(ov5695->reset_gpio)) { 1301 dev_err(dev, "Failed to get reset-gpios\n"); 1302 return -EINVAL; 1303 } 1304 1305 ret = ov5695_configure_regulators(ov5695); 1306 if (ret) { 1307 dev_err(dev, "Failed to get power regulators\n"); 1308 return ret; 1309 } 1310 1311 mutex_init(&ov5695->mutex); 1312 1313 sd = &ov5695->subdev; 1314 v4l2_i2c_subdev_init(sd, client, &ov5695_subdev_ops); 1315 ret = ov5695_initialize_controls(ov5695); 1316 if (ret) 1317 goto err_destroy_mutex; 1318 1319 ret = __ov5695_power_on(ov5695); 1320 if (ret) 1321 goto err_free_handler; 1322 1323 ret = ov5695_check_sensor_id(ov5695, client); 1324 if (ret) 1325 goto err_power_off; 1326 1327 #ifdef CONFIG_VIDEO_V4L2_SUBDEV_API 1328 sd->internal_ops = &ov5695_internal_ops; 1329 sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1330 #endif 1331 #if defined(CONFIG_MEDIA_CONTROLLER) 1332 ov5695->pad.flags = MEDIA_PAD_FL_SOURCE; 1333 sd->entity.function = MEDIA_ENT_F_CAM_SENSOR; 1334 ret = media_entity_pads_init(&sd->entity, 1, &ov5695->pad); 1335 if (ret < 0) 1336 goto err_power_off; 1337 #endif 1338 1339 ret = v4l2_async_register_subdev_sensor(sd); 1340 if (ret) { 1341 dev_err(dev, "v4l2 async register subdev failed\n"); 1342 goto err_clean_entity; 1343 } 1344 1345 pm_runtime_set_active(dev); 1346 pm_runtime_enable(dev); 1347 pm_runtime_idle(dev); 1348 1349 return 0; 1350 1351 err_clean_entity: 1352 #if defined(CONFIG_MEDIA_CONTROLLER) 1353 media_entity_cleanup(&sd->entity); 1354 #endif 1355 err_power_off: 1356 __ov5695_power_off(ov5695); 1357 err_free_handler: 1358 v4l2_ctrl_handler_free(&ov5695->ctrl_handler); 1359 err_destroy_mutex: 1360 mutex_destroy(&ov5695->mutex); 1361 1362 return ret; 1363 } 1364 1365 static int ov5695_remove(struct i2c_client *client) 1366 { 1367 struct v4l2_subdev *sd = i2c_get_clientdata(client); 1368 struct ov5695 *ov5695 = to_ov5695(sd); 1369 1370 v4l2_async_unregister_subdev(sd); 1371 #if defined(CONFIG_MEDIA_CONTROLLER) 1372 media_entity_cleanup(&sd->entity); 1373 #endif 1374 v4l2_ctrl_handler_free(&ov5695->ctrl_handler); 1375 mutex_destroy(&ov5695->mutex); 1376 1377 pm_runtime_disable(&client->dev); 1378 if (!pm_runtime_status_suspended(&client->dev)) 1379 __ov5695_power_off(ov5695); 1380 pm_runtime_set_suspended(&client->dev); 1381 1382 return 0; 1383 } 1384 1385 #if IS_ENABLED(CONFIG_OF) 1386 static const struct of_device_id ov5695_of_match[] = { 1387 { .compatible = "ovti,ov5695" }, 1388 {}, 1389 }; 1390 MODULE_DEVICE_TABLE(of, ov5695_of_match); 1391 #endif 1392 1393 static struct i2c_driver ov5695_i2c_driver = { 1394 .driver = { 1395 .name = "ov5695", 1396 .pm = &ov5695_pm_ops, 1397 .of_match_table = of_match_ptr(ov5695_of_match), 1398 }, 1399 .probe = &ov5695_probe, 1400 .remove = &ov5695_remove, 1401 }; 1402 1403 module_i2c_driver(ov5695_i2c_driver); 1404 1405 MODULE_DESCRIPTION("OmniVision ov5695 sensor driver"); 1406 MODULE_LICENSE("GPL v2"); 1407