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