1// SPDX-License-Identifier: GPL-2.0 2// Copyright (c) 2022 Intel Corporation. 3 4#include <linux/acpi.h> 5#include <linux/clk.h> 6#include <linux/delay.h> 7#include <linux/i2c.h> 8#include <linux/module.h> 9#include <linux/pm_runtime.h> 10#include <linux/regulator/consumer.h> 11#include <media/v4l2-ctrls.h> 12#include <media/v4l2-device.h> 13#include <media/v4l2-fwnode.h> 14 15#define OV08D10_SCLK 144000000ULL 16#define OV08D10_XVCLK_19_2 19200000 17#define OV08D10_ROWCLK 36000 18#define OV08D10_DATA_LANES 2 19#define OV08D10_RGB_DEPTH 10 20 21#define OV08D10_REG_PAGE 0xfd 22#define OV08D10_REG_GLOBAL_EFFECTIVE 0x01 23#define OV08D10_REG_CHIP_ID_0 0x00 24#define OV08D10_REG_CHIP_ID_1 0x01 25#define OV08D10_ID_MASK GENMASK(15, 0) 26#define OV08D10_CHIP_ID 0x5608 27 28#define OV08D10_REG_MODE_SELECT 0xa0 29#define OV08D10_MODE_STANDBY 0x00 30#define OV08D10_MODE_STREAMING 0x01 31 32/* vertical-timings from sensor */ 33#define OV08D10_REG_VTS_H 0x05 34#define OV08D10_REG_VTS_L 0x06 35#define OV08D10_VTS_MAX 0x7fff 36 37/* Exposure controls from sensor */ 38#define OV08D10_REG_EXPOSURE_H 0x02 39#define OV08D10_REG_EXPOSURE_M 0x03 40#define OV08D10_REG_EXPOSURE_L 0x04 41#define OV08D10_EXPOSURE_MIN 6 42#define OV08D10_EXPOSURE_MAX_MARGIN 6 43#define OV08D10_EXPOSURE_STEP 1 44 45/* Analog gain controls from sensor */ 46#define OV08D10_REG_ANALOG_GAIN 0x24 47#define OV08D10_ANAL_GAIN_MIN 128 48#define OV08D10_ANAL_GAIN_MAX 2047 49#define OV08D10_ANAL_GAIN_STEP 1 50 51/* Digital gain controls from sensor */ 52#define OV08D10_REG_MWB_DGAIN_C 0x21 53#define OV08D10_REG_MWB_DGAIN_F 0x22 54#define OV08D10_DGTL_GAIN_MIN 0 55#define OV08D10_DGTL_GAIN_MAX 4095 56#define OV08D10_DGTL_GAIN_STEP 1 57#define OV08D10_DGTL_GAIN_DEFAULT 1024 58 59/* Test Pattern Control */ 60#define OV08D10_REG_TEST_PATTERN 0x12 61#define OV08D10_TEST_PATTERN_ENABLE 0x01 62#define OV08D10_TEST_PATTERN_DISABLE 0x00 63 64/* Flip Mirror Controls from sensor */ 65#define OV08D10_REG_FLIP_OPT 0x32 66#define OV08D10_REG_FLIP_MASK 0x3 67 68#define to_ov08d10(_sd) container_of(_sd, struct ov08d10, sd) 69 70struct ov08d10_reg { 71 u8 address; 72 u8 val; 73}; 74 75struct ov08d10_reg_list { 76 u32 num_of_regs; 77 const struct ov08d10_reg *regs; 78}; 79 80struct ov08d10_link_freq_config { 81 const struct ov08d10_reg_list reg_list; 82}; 83 84struct ov08d10_mode { 85 /* Frame width in pixels */ 86 u32 width; 87 88 /* Frame height in pixels */ 89 u32 height; 90 91 /* Horizontal timining size */ 92 u32 hts; 93 94 /* Default vertical timining size */ 95 u32 vts_def; 96 97 /* Min vertical timining size */ 98 u32 vts_min; 99 100 /* Link frequency needed for this resolution */ 101 u32 link_freq_index; 102 103 /* Sensor register settings for this resolution */ 104 const struct ov08d10_reg_list reg_list; 105 106 /* Number of data lanes */ 107 u8 data_lanes; 108}; 109 110/* 3280x2460, 3264x2448 need 720Mbps/lane, 2 lanes */ 111static const struct ov08d10_reg mipi_data_rate_720mbps[] = { 112 {0xfd, 0x00}, 113 {0x11, 0x2a}, 114 {0x14, 0x43}, 115 {0x1a, 0x04}, 116 {0x1b, 0xe1}, 117 {0x1e, 0x13}, 118 {0xb7, 0x02} 119}; 120 121/* 1632x1224 needs 360Mbps/lane, 2 lanes */ 122static const struct ov08d10_reg mipi_data_rate_360mbps[] = { 123 {0xfd, 0x00}, 124 {0x1a, 0x04}, 125 {0x1b, 0xe1}, 126 {0x1d, 0x00}, 127 {0x1c, 0x19}, 128 {0x11, 0x2a}, 129 {0x14, 0x54}, 130 {0x1e, 0x13}, 131 {0xb7, 0x02} 132}; 133 134static const struct ov08d10_reg lane_2_mode_3280x2460[] = { 135 /* 3280x2460 resolution */ 136 {0xfd, 0x01}, 137 {0x12, 0x00}, 138 {0x03, 0x12}, 139 {0x04, 0x58}, 140 {0x07, 0x05}, 141 {0x21, 0x02}, 142 {0x24, 0x30}, 143 {0x33, 0x03}, 144 {0x01, 0x03}, 145 {0x19, 0x10}, 146 {0x42, 0x55}, 147 {0x43, 0x00}, 148 {0x47, 0x07}, 149 {0x48, 0x08}, 150 {0xb2, 0x7f}, 151 {0xb3, 0x7b}, 152 {0xbd, 0x08}, 153 {0xd2, 0x57}, 154 {0xd3, 0x10}, 155 {0xd4, 0x08}, 156 {0xd5, 0x08}, 157 {0xd6, 0x06}, 158 {0xb1, 0x00}, 159 {0xb4, 0x00}, 160 {0xb7, 0x0a}, 161 {0xbc, 0x44}, 162 {0xbf, 0x48}, 163 {0xc1, 0x10}, 164 {0xc3, 0x24}, 165 {0xc8, 0x03}, 166 {0xc9, 0xf8}, 167 {0xe1, 0x33}, 168 {0xe2, 0xbb}, 169 {0x51, 0x0c}, 170 {0x52, 0x0a}, 171 {0x57, 0x8c}, 172 {0x59, 0x09}, 173 {0x5a, 0x08}, 174 {0x5e, 0x10}, 175 {0x60, 0x02}, 176 {0x6d, 0x5c}, 177 {0x76, 0x16}, 178 {0x7c, 0x11}, 179 {0x90, 0x28}, 180 {0x91, 0x16}, 181 {0x92, 0x1c}, 182 {0x93, 0x24}, 183 {0x95, 0x48}, 184 {0x9c, 0x06}, 185 {0xca, 0x0c}, 186 {0xce, 0x0d}, 187 {0xfd, 0x01}, 188 {0xc0, 0x00}, 189 {0xdd, 0x18}, 190 {0xde, 0x19}, 191 {0xdf, 0x32}, 192 {0xe0, 0x70}, 193 {0xfd, 0x01}, 194 {0xc2, 0x05}, 195 {0xd7, 0x88}, 196 {0xd8, 0x77}, 197 {0xd9, 0x00}, 198 {0xfd, 0x07}, 199 {0x00, 0xf8}, 200 {0x01, 0x2b}, 201 {0x05, 0x40}, 202 {0x08, 0x06}, 203 {0x09, 0x11}, 204 {0x28, 0x6f}, 205 {0x2a, 0x20}, 206 {0x2b, 0x05}, 207 {0x5e, 0x10}, 208 {0x52, 0x00}, 209 {0x53, 0x7c}, 210 {0x54, 0x00}, 211 {0x55, 0x7c}, 212 {0x56, 0x00}, 213 {0x57, 0x7c}, 214 {0x58, 0x00}, 215 {0x59, 0x7c}, 216 {0xfd, 0x02}, 217 {0x9a, 0x30}, 218 {0xa8, 0x02}, 219 {0xfd, 0x02}, 220 {0xa1, 0x01}, 221 {0xa2, 0x09}, 222 {0xa3, 0x9c}, 223 {0xa5, 0x00}, 224 {0xa6, 0x0c}, 225 {0xa7, 0xd0}, 226 {0xfd, 0x00}, 227 {0x24, 0x01}, 228 {0xc0, 0x16}, 229 {0xc1, 0x08}, 230 {0xc2, 0x30}, 231 {0x8e, 0x0c}, 232 {0x8f, 0xd0}, 233 {0x90, 0x09}, 234 {0x91, 0x9c}, 235 {0xfd, 0x05}, 236 {0x04, 0x40}, 237 {0x07, 0x00}, 238 {0x0d, 0x01}, 239 {0x0f, 0x01}, 240 {0x10, 0x00}, 241 {0x11, 0x00}, 242 {0x12, 0x0c}, 243 {0x13, 0xcf}, 244 {0x14, 0x00}, 245 {0x15, 0x00}, 246 {0xfd, 0x00}, 247 {0x20, 0x0f}, 248 {0xe7, 0x03}, 249 {0xe7, 0x00} 250}; 251 252static const struct ov08d10_reg lane_2_mode_3264x2448[] = { 253 /* 3264x2448 resolution */ 254 {0xfd, 0x01}, 255 {0x12, 0x00}, 256 {0x03, 0x12}, 257 {0x04, 0x58}, 258 {0x07, 0x05}, 259 {0x21, 0x02}, 260 {0x24, 0x30}, 261 {0x33, 0x03}, 262 {0x01, 0x03}, 263 {0x19, 0x10}, 264 {0x42, 0x55}, 265 {0x43, 0x00}, 266 {0x47, 0x07}, 267 {0x48, 0x08}, 268 {0xb2, 0x7f}, 269 {0xb3, 0x7b}, 270 {0xbd, 0x08}, 271 {0xd2, 0x57}, 272 {0xd3, 0x10}, 273 {0xd4, 0x08}, 274 {0xd5, 0x08}, 275 {0xd6, 0x06}, 276 {0xb1, 0x00}, 277 {0xb4, 0x00}, 278 {0xb7, 0x0a}, 279 {0xbc, 0x44}, 280 {0xbf, 0x48}, 281 {0xc1, 0x10}, 282 {0xc3, 0x24}, 283 {0xc8, 0x03}, 284 {0xc9, 0xf8}, 285 {0xe1, 0x33}, 286 {0xe2, 0xbb}, 287 {0x51, 0x0c}, 288 {0x52, 0x0a}, 289 {0x57, 0x8c}, 290 {0x59, 0x09}, 291 {0x5a, 0x08}, 292 {0x5e, 0x10}, 293 {0x60, 0x02}, 294 {0x6d, 0x5c}, 295 {0x76, 0x16}, 296 {0x7c, 0x11}, 297 {0x90, 0x28}, 298 {0x91, 0x16}, 299 {0x92, 0x1c}, 300 {0x93, 0x24}, 301 {0x95, 0x48}, 302 {0x9c, 0x06}, 303 {0xca, 0x0c}, 304 {0xce, 0x0d}, 305 {0xfd, 0x01}, 306 {0xc0, 0x00}, 307 {0xdd, 0x18}, 308 {0xde, 0x19}, 309 {0xdf, 0x32}, 310 {0xe0, 0x70}, 311 {0xfd, 0x01}, 312 {0xc2, 0x05}, 313 {0xd7, 0x88}, 314 {0xd8, 0x77}, 315 {0xd9, 0x00}, 316 {0xfd, 0x07}, 317 {0x00, 0xf8}, 318 {0x01, 0x2b}, 319 {0x05, 0x40}, 320 {0x08, 0x06}, 321 {0x09, 0x11}, 322 {0x28, 0x6f}, 323 {0x2a, 0x20}, 324 {0x2b, 0x05}, 325 {0x5e, 0x10}, 326 {0x52, 0x00}, 327 {0x53, 0x7c}, 328 {0x54, 0x00}, 329 {0x55, 0x7c}, 330 {0x56, 0x00}, 331 {0x57, 0x7c}, 332 {0x58, 0x00}, 333 {0x59, 0x7c}, 334 {0xfd, 0x02}, 335 {0x9a, 0x30}, 336 {0xa8, 0x02}, 337 {0xfd, 0x02}, 338 {0xa1, 0x09}, 339 {0xa2, 0x09}, 340 {0xa3, 0x90}, 341 {0xa5, 0x08}, 342 {0xa6, 0x0c}, 343 {0xa7, 0xc0}, 344 {0xfd, 0x00}, 345 {0x24, 0x01}, 346 {0xc0, 0x16}, 347 {0xc1, 0x08}, 348 {0xc2, 0x30}, 349 {0x8e, 0x0c}, 350 {0x8f, 0xc0}, 351 {0x90, 0x09}, 352 {0x91, 0x90}, 353 {0xfd, 0x05}, 354 {0x04, 0x40}, 355 {0x07, 0x00}, 356 {0x0d, 0x01}, 357 {0x0f, 0x01}, 358 {0x10, 0x00}, 359 {0x11, 0x00}, 360 {0x12, 0x0c}, 361 {0x13, 0xcf}, 362 {0x14, 0x00}, 363 {0x15, 0x00}, 364 {0xfd, 0x00}, 365 {0x20, 0x0f}, 366 {0xe7, 0x03}, 367 {0xe7, 0x00} 368}; 369 370static const struct ov08d10_reg lane_2_mode_1632x1224[] = { 371 /* 1640x1232 resolution */ 372 {0xfd, 0x01}, 373 {0x1a, 0x0a}, 374 {0x1b, 0x08}, 375 {0x2a, 0x01}, 376 {0x2b, 0x9a}, 377 {0xfd, 0x01}, 378 {0x12, 0x00}, 379 {0x03, 0x05}, 380 {0x04, 0xe2}, 381 {0x07, 0x05}, 382 {0x21, 0x02}, 383 {0x24, 0x30}, 384 {0x33, 0x03}, 385 {0x31, 0x06}, 386 {0x33, 0x03}, 387 {0x01, 0x03}, 388 {0x19, 0x10}, 389 {0x42, 0x55}, 390 {0x43, 0x00}, 391 {0x47, 0x07}, 392 {0x48, 0x08}, 393 {0xb2, 0x7f}, 394 {0xb3, 0x7b}, 395 {0xbd, 0x08}, 396 {0xd2, 0x57}, 397 {0xd3, 0x10}, 398 {0xd4, 0x08}, 399 {0xd5, 0x08}, 400 {0xd6, 0x06}, 401 {0xb1, 0x00}, 402 {0xb4, 0x00}, 403 {0xb7, 0x0a}, 404 {0xbc, 0x44}, 405 {0xbf, 0x48}, 406 {0xc1, 0x10}, 407 {0xc3, 0x24}, 408 {0xc8, 0x03}, 409 {0xc9, 0xf8}, 410 {0xe1, 0x33}, 411 {0xe2, 0xbb}, 412 {0x51, 0x0c}, 413 {0x52, 0x0a}, 414 {0x57, 0x8c}, 415 {0x59, 0x09}, 416 {0x5a, 0x08}, 417 {0x5e, 0x10}, 418 {0x60, 0x02}, 419 {0x6d, 0x5c}, 420 {0x76, 0x16}, 421 {0x7c, 0x1a}, 422 {0x90, 0x28}, 423 {0x91, 0x16}, 424 {0x92, 0x1c}, 425 {0x93, 0x24}, 426 {0x95, 0x48}, 427 {0x9c, 0x06}, 428 {0xca, 0x0c}, 429 {0xce, 0x0d}, 430 {0xfd, 0x01}, 431 {0xc0, 0x00}, 432 {0xdd, 0x18}, 433 {0xde, 0x19}, 434 {0xdf, 0x32}, 435 {0xe0, 0x70}, 436 {0xfd, 0x01}, 437 {0xc2, 0x05}, 438 {0xd7, 0x88}, 439 {0xd8, 0x77}, 440 {0xd9, 0x00}, 441 {0xfd, 0x07}, 442 {0x00, 0xf8}, 443 {0x01, 0x2b}, 444 {0x05, 0x40}, 445 {0x08, 0x03}, 446 {0x09, 0x08}, 447 {0x28, 0x6f}, 448 {0x2a, 0x20}, 449 {0x2b, 0x05}, 450 {0x2c, 0x01}, 451 {0x50, 0x02}, 452 {0x51, 0x03}, 453 {0x5e, 0x00}, 454 {0x52, 0x00}, 455 {0x53, 0x7c}, 456 {0x54, 0x00}, 457 {0x55, 0x7c}, 458 {0x56, 0x00}, 459 {0x57, 0x7c}, 460 {0x58, 0x00}, 461 {0x59, 0x7c}, 462 {0xfd, 0x02}, 463 {0x9a, 0x30}, 464 {0xa8, 0x02}, 465 {0xfd, 0x02}, 466 {0xa9, 0x04}, 467 {0xaa, 0xd0}, 468 {0xab, 0x06}, 469 {0xac, 0x68}, 470 {0xa1, 0x09}, 471 {0xa2, 0x04}, 472 {0xa3, 0xc8}, 473 {0xa5, 0x04}, 474 {0xa6, 0x06}, 475 {0xa7, 0x60}, 476 {0xfd, 0x05}, 477 {0x06, 0x80}, 478 {0x18, 0x06}, 479 {0x19, 0x68}, 480 {0xfd, 0x00}, 481 {0x24, 0x01}, 482 {0xc0, 0x16}, 483 {0xc1, 0x08}, 484 {0xc2, 0x30}, 485 {0x8e, 0x06}, 486 {0x8f, 0x60}, 487 {0x90, 0x04}, 488 {0x91, 0xc8}, 489 {0x93, 0x0e}, 490 {0x94, 0x77}, 491 {0x95, 0x77}, 492 {0x96, 0x10}, 493 {0x98, 0x88}, 494 {0x9c, 0x1a}, 495 {0xfd, 0x05}, 496 {0x04, 0x40}, 497 {0x07, 0x99}, 498 {0x0d, 0x03}, 499 {0x0f, 0x03}, 500 {0x10, 0x00}, 501 {0x11, 0x00}, 502 {0x12, 0x0c}, 503 {0x13, 0xcf}, 504 {0x14, 0x00}, 505 {0x15, 0x00}, 506 {0xfd, 0x00}, 507 {0x20, 0x0f}, 508 {0xe7, 0x03}, 509 {0xe7, 0x00}, 510}; 511 512static const char * const ov08d10_test_pattern_menu[] = { 513 "Disabled", 514 "Standard Color Bar", 515}; 516 517struct ov08d10 { 518 struct v4l2_subdev sd; 519 struct media_pad pad; 520 struct v4l2_ctrl_handler ctrl_handler; 521 522 struct clk *xvclk; 523 524 /* V4L2 Controls */ 525 struct v4l2_ctrl *link_freq; 526 struct v4l2_ctrl *pixel_rate; 527 struct v4l2_ctrl *vblank; 528 struct v4l2_ctrl *hblank; 529 struct v4l2_ctrl *vflip; 530 struct v4l2_ctrl *hflip; 531 struct v4l2_ctrl *exposure; 532 533 /* Current mode */ 534 const struct ov08d10_mode *cur_mode; 535 536 /* To serialize asynchronus callbacks */ 537 struct mutex mutex; 538 539 /* Streaming on/off */ 540 bool streaming; 541 542 /* lanes index */ 543 u8 nlanes; 544 545 const struct ov08d10_lane_cfg *priv_lane; 546 u8 modes_size; 547}; 548 549struct ov08d10_lane_cfg { 550 const s64 link_freq_menu[2]; 551 const struct ov08d10_link_freq_config link_freq_configs[2]; 552 const struct ov08d10_mode sp_modes[3]; 553}; 554 555static const struct ov08d10_lane_cfg lane_cfg_2 = { 556 { 557 720000000, 558 360000000, 559 }, 560 {{ 561 .reg_list = { 562 .num_of_regs = 563 ARRAY_SIZE(mipi_data_rate_720mbps), 564 .regs = mipi_data_rate_720mbps, 565 } 566 }, 567 { 568 .reg_list = { 569 .num_of_regs = 570 ARRAY_SIZE(mipi_data_rate_360mbps), 571 .regs = mipi_data_rate_360mbps, 572 } 573 }}, 574 {{ 575 .width = 3280, 576 .height = 2460, 577 .hts = 1840, 578 .vts_def = 2504, 579 .vts_min = 2504, 580 .reg_list = { 581 .num_of_regs = ARRAY_SIZE(lane_2_mode_3280x2460), 582 .regs = lane_2_mode_3280x2460, 583 }, 584 .link_freq_index = 0, 585 .data_lanes = 2, 586 }, 587 { 588 .width = 3264, 589 .height = 2448, 590 .hts = 1840, 591 .vts_def = 2504, 592 .vts_min = 2504, 593 .reg_list = { 594 .num_of_regs = ARRAY_SIZE(lane_2_mode_3264x2448), 595 .regs = lane_2_mode_3264x2448, 596 }, 597 .link_freq_index = 0, 598 .data_lanes = 2, 599 }, 600 { 601 .width = 1632, 602 .height = 1224, 603 .hts = 1912, 604 .vts_def = 3736, 605 .vts_min = 3736, 606 .reg_list = { 607 .num_of_regs = ARRAY_SIZE(lane_2_mode_1632x1224), 608 .regs = lane_2_mode_1632x1224, 609 }, 610 .link_freq_index = 1, 611 .data_lanes = 2, 612 }} 613}; 614 615static u32 ov08d10_get_format_code(struct ov08d10 *ov08d10) 616{ 617 static const u32 codes[2][2] = { 618 { MEDIA_BUS_FMT_SGRBG10_1X10, MEDIA_BUS_FMT_SRGGB10_1X10}, 619 { MEDIA_BUS_FMT_SBGGR10_1X10, MEDIA_BUS_FMT_SGBRG10_1X10}, 620 }; 621 622 return codes[ov08d10->vflip->val][ov08d10->hflip->val]; 623} 624 625static unsigned int ov08d10_modes_num(const struct ov08d10 *ov08d10) 626{ 627 unsigned int i, count = 0; 628 629 for (i = 0; i < ARRAY_SIZE(ov08d10->priv_lane->sp_modes); i++) { 630 if (ov08d10->priv_lane->sp_modes[i].width == 0) 631 break; 632 count++; 633 } 634 635 return count; 636} 637 638static u64 to_rate(const s64 *link_freq_menu, 639 u32 f_index, u8 nlanes) 640{ 641 u64 pixel_rate = link_freq_menu[f_index] * 2 * nlanes; 642 643 do_div(pixel_rate, OV08D10_RGB_DEPTH); 644 645 return pixel_rate; 646} 647 648static u64 to_pixels_per_line(const s64 *link_freq_menu, u32 hts, 649 u32 f_index, u8 nlanes) 650{ 651 u64 ppl = hts * to_rate(link_freq_menu, f_index, nlanes); 652 653 do_div(ppl, OV08D10_SCLK); 654 655 return ppl; 656} 657 658static int ov08d10_write_reg_list(struct ov08d10 *ov08d10, 659 const struct ov08d10_reg_list *r_list) 660{ 661 struct i2c_client *client = v4l2_get_subdevdata(&ov08d10->sd); 662 unsigned int i; 663 int ret; 664 665 for (i = 0; i < r_list->num_of_regs; i++) { 666 ret = i2c_smbus_write_byte_data(client, r_list->regs[i].address, 667 r_list->regs[i].val); 668 if (ret) { 669 dev_err_ratelimited(&client->dev, 670 "failed to write reg 0x%2.2x. error = %d", 671 r_list->regs[i].address, ret); 672 return ret; 673 } 674 } 675 676 return 0; 677} 678 679static int ov08d10_update_analog_gain(struct ov08d10 *ov08d10, u32 a_gain) 680{ 681 struct i2c_client *client = v4l2_get_subdevdata(&ov08d10->sd); 682 u8 val; 683 int ret; 684 685 val = ((a_gain >> 3) & 0xFF); 686 /* CIS control registers */ 687 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_PAGE, 0x01); 688 if (ret < 0) 689 return ret; 690 691 /* update AGAIN */ 692 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_ANALOG_GAIN, val); 693 if (ret < 0) 694 return ret; 695 696 return i2c_smbus_write_byte_data(client, 697 OV08D10_REG_GLOBAL_EFFECTIVE, 0x01); 698} 699 700static int ov08d10_update_digital_gain(struct ov08d10 *ov08d10, u32 d_gain) 701{ 702 struct i2c_client *client = v4l2_get_subdevdata(&ov08d10->sd); 703 u8 val; 704 int ret; 705 706 d_gain = (d_gain >> 1); 707 /* CIS control registers */ 708 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_PAGE, 0x01); 709 if (ret < 0) 710 return ret; 711 712 val = ((d_gain >> 8) & 0x3F); 713 /* update DGAIN */ 714 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_MWB_DGAIN_C, val); 715 if (ret < 0) 716 return ret; 717 718 val = d_gain & 0xFF; 719 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_MWB_DGAIN_F, val); 720 if (ret < 0) 721 return ret; 722 723 return i2c_smbus_write_byte_data(client, 724 OV08D10_REG_GLOBAL_EFFECTIVE, 0x01); 725} 726 727static int ov08d10_set_exposure(struct ov08d10 *ov08d10, u32 exposure) 728{ 729 struct i2c_client *client = v4l2_get_subdevdata(&ov08d10->sd); 730 u8 val; 731 u8 hts_h, hts_l; 732 u32 hts, cur_vts, exp_cal; 733 int ret; 734 735 cur_vts = ov08d10->cur_mode->vts_def; 736 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_PAGE, 0x01); 737 if (ret < 0) 738 return ret; 739 740 hts_h = i2c_smbus_read_byte_data(client, 0x37); 741 hts_l = i2c_smbus_read_byte_data(client, 0x38); 742 hts = ((hts_h << 8) | (hts_l)); 743 exp_cal = 66 * OV08D10_ROWCLK / hts; 744 exposure = exposure * exp_cal / (cur_vts - OV08D10_EXPOSURE_MAX_MARGIN); 745 /* CIS control registers */ 746 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_PAGE, 0x01); 747 if (ret < 0) 748 return ret; 749 750 /* update exposure */ 751 val = ((exposure >> 16) & 0xFF); 752 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_EXPOSURE_H, val); 753 if (ret < 0) 754 return ret; 755 756 val = ((exposure >> 8) & 0xFF); 757 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_EXPOSURE_M, val); 758 if (ret < 0) 759 return ret; 760 761 val = exposure & 0xFF; 762 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_EXPOSURE_L, val); 763 if (ret < 0) 764 return ret; 765 766 return i2c_smbus_write_byte_data(client, 767 OV08D10_REG_GLOBAL_EFFECTIVE, 0x01); 768} 769 770static int ov08d10_set_vblank(struct ov08d10 *ov08d10, u32 vblank) 771{ 772 struct i2c_client *client = v4l2_get_subdevdata(&ov08d10->sd); 773 u8 val; 774 int ret; 775 776 /* CIS control registers */ 777 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_PAGE, 0x01); 778 if (ret < 0) 779 return ret; 780 781 val = ((vblank >> 8) & 0xFF); 782 /* update vblank */ 783 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_VTS_H, val); 784 if (ret < 0) 785 return ret; 786 787 val = vblank & 0xFF; 788 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_VTS_L, val); 789 if (ret < 0) 790 return ret; 791 792 return i2c_smbus_write_byte_data(client, 793 OV08D10_REG_GLOBAL_EFFECTIVE, 0x01); 794} 795 796static int ov08d10_test_pattern(struct ov08d10 *ov08d10, u32 pattern) 797{ 798 struct i2c_client *client = v4l2_get_subdevdata(&ov08d10->sd); 799 u8 val; 800 int ret; 801 802 if (pattern) 803 val = OV08D10_TEST_PATTERN_ENABLE; 804 else 805 val = OV08D10_TEST_PATTERN_DISABLE; 806 807 /* CIS control registers */ 808 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_PAGE, 0x01); 809 if (ret < 0) 810 return ret; 811 812 ret = i2c_smbus_write_byte_data(client, 813 OV08D10_REG_TEST_PATTERN, val); 814 if (ret < 0) 815 return ret; 816 817 return i2c_smbus_write_byte_data(client, 818 OV08D10_REG_GLOBAL_EFFECTIVE, 0x01); 819} 820 821static int ov08d10_set_ctrl_flip(struct ov08d10 *ov08d10, u32 ctrl_val) 822{ 823 struct i2c_client *client = v4l2_get_subdevdata(&ov08d10->sd); 824 u8 val; 825 int ret; 826 827 /* System control registers */ 828 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_PAGE, 0x01); 829 if (ret < 0) 830 return ret; 831 832 ret = i2c_smbus_read_byte_data(client, OV08D10_REG_FLIP_OPT); 833 if (ret < 0) 834 return ret; 835 836 val = ret | (ctrl_val & OV08D10_REG_FLIP_MASK); 837 838 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_PAGE, 0x01); 839 if (ret < 0) 840 return ret; 841 842 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_FLIP_OPT, val); 843 844 if (ret < 0) 845 return ret; 846 847 return i2c_smbus_write_byte_data(client, 848 OV08D10_REG_GLOBAL_EFFECTIVE, 0x01); 849} 850 851static int ov08d10_set_ctrl(struct v4l2_ctrl *ctrl) 852{ 853 struct ov08d10 *ov08d10 = container_of(ctrl->handler, 854 struct ov08d10, ctrl_handler); 855 struct i2c_client *client = v4l2_get_subdevdata(&ov08d10->sd); 856 s64 exposure_max; 857 int ret; 858 859 /* Propagate change of current control to all related controls */ 860 if (ctrl->id == V4L2_CID_VBLANK) { 861 /* Update max exposure while meeting expected vblanking */ 862 exposure_max = ov08d10->cur_mode->height + ctrl->val - 863 OV08D10_EXPOSURE_MAX_MARGIN; 864 __v4l2_ctrl_modify_range(ov08d10->exposure, 865 ov08d10->exposure->minimum, 866 exposure_max, ov08d10->exposure->step, 867 exposure_max); 868 } 869 870 /* V4L2 controls values will be applied only when power is already up */ 871 if (!pm_runtime_get_if_in_use(&client->dev)) 872 return 0; 873 874 switch (ctrl->id) { 875 case V4L2_CID_ANALOGUE_GAIN: 876 ret = ov08d10_update_analog_gain(ov08d10, ctrl->val); 877 break; 878 879 case V4L2_CID_DIGITAL_GAIN: 880 ret = ov08d10_update_digital_gain(ov08d10, ctrl->val); 881 break; 882 883 case V4L2_CID_EXPOSURE: 884 ret = ov08d10_set_exposure(ov08d10, ctrl->val); 885 break; 886 887 case V4L2_CID_VBLANK: 888 ret = ov08d10_set_vblank(ov08d10, ctrl->val); 889 break; 890 891 case V4L2_CID_TEST_PATTERN: 892 ret = ov08d10_test_pattern(ov08d10, ctrl->val); 893 break; 894 895 case V4L2_CID_HFLIP: 896 case V4L2_CID_VFLIP: 897 ret = ov08d10_set_ctrl_flip(ov08d10, 898 ov08d10->hflip->val | 899 ov08d10->vflip->val << 1); 900 break; 901 902 default: 903 ret = -EINVAL; 904 break; 905 } 906 907 pm_runtime_put(&client->dev); 908 909 return ret; 910} 911 912static const struct v4l2_ctrl_ops ov08d10_ctrl_ops = { 913 .s_ctrl = ov08d10_set_ctrl, 914}; 915 916static int ov08d10_init_controls(struct ov08d10 *ov08d10) 917{ 918 struct v4l2_ctrl_handler *ctrl_hdlr; 919 u8 link_freq_size; 920 s64 exposure_max; 921 s64 vblank_def; 922 s64 vblank_min; 923 s64 h_blank; 924 s64 pixel_rate_max; 925 const struct ov08d10_mode *mode; 926 int ret; 927 928 ctrl_hdlr = &ov08d10->ctrl_handler; 929 ret = v4l2_ctrl_handler_init(ctrl_hdlr, 8); 930 if (ret) 931 return ret; 932 933 ctrl_hdlr->lock = &ov08d10->mutex; 934 link_freq_size = ARRAY_SIZE(ov08d10->priv_lane->link_freq_menu); 935 ov08d10->link_freq = 936 v4l2_ctrl_new_int_menu(ctrl_hdlr, &ov08d10_ctrl_ops, 937 V4L2_CID_LINK_FREQ, 938 link_freq_size - 1, 939 0, 940 ov08d10->priv_lane->link_freq_menu); 941 if (ov08d10->link_freq) 942 ov08d10->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY; 943 944 pixel_rate_max = to_rate(ov08d10->priv_lane->link_freq_menu, 0, 945 ov08d10->cur_mode->data_lanes); 946 ov08d10->pixel_rate = 947 v4l2_ctrl_new_std(ctrl_hdlr, &ov08d10_ctrl_ops, 948 V4L2_CID_PIXEL_RATE, 0, pixel_rate_max, 1, 949 pixel_rate_max); 950 951 mode = ov08d10->cur_mode; 952 vblank_def = mode->vts_def - mode->height; 953 vblank_min = mode->vts_min - mode->height; 954 ov08d10->vblank = 955 v4l2_ctrl_new_std(ctrl_hdlr, &ov08d10_ctrl_ops, 956 V4L2_CID_VBLANK, vblank_min, 957 OV08D10_VTS_MAX - mode->height, 1, 958 vblank_def); 959 960 h_blank = to_pixels_per_line(ov08d10->priv_lane->link_freq_menu, 961 mode->hts, mode->link_freq_index, 962 mode->data_lanes) - 963 mode->width; 964 ov08d10->hblank = v4l2_ctrl_new_std(ctrl_hdlr, &ov08d10_ctrl_ops, 965 V4L2_CID_HBLANK, h_blank, h_blank, 966 1, h_blank); 967 if (ov08d10->hblank) 968 ov08d10->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY; 969 970 v4l2_ctrl_new_std(ctrl_hdlr, &ov08d10_ctrl_ops, V4L2_CID_ANALOGUE_GAIN, 971 OV08D10_ANAL_GAIN_MIN, OV08D10_ANAL_GAIN_MAX, 972 OV08D10_ANAL_GAIN_STEP, OV08D10_ANAL_GAIN_MIN); 973 974 v4l2_ctrl_new_std(ctrl_hdlr, &ov08d10_ctrl_ops, V4L2_CID_DIGITAL_GAIN, 975 OV08D10_DGTL_GAIN_MIN, OV08D10_DGTL_GAIN_MAX, 976 OV08D10_DGTL_GAIN_STEP, OV08D10_DGTL_GAIN_DEFAULT); 977 978 exposure_max = mode->vts_def - OV08D10_EXPOSURE_MAX_MARGIN; 979 ov08d10->exposure = v4l2_ctrl_new_std(ctrl_hdlr, &ov08d10_ctrl_ops, 980 V4L2_CID_EXPOSURE, 981 OV08D10_EXPOSURE_MIN, 982 exposure_max, 983 OV08D10_EXPOSURE_STEP, 984 exposure_max); 985 986 v4l2_ctrl_new_std_menu_items(ctrl_hdlr, &ov08d10_ctrl_ops, 987 V4L2_CID_TEST_PATTERN, 988 ARRAY_SIZE(ov08d10_test_pattern_menu) - 1, 989 0, 0, ov08d10_test_pattern_menu); 990 991 ov08d10->hflip = v4l2_ctrl_new_std(ctrl_hdlr, &ov08d10_ctrl_ops, 992 V4L2_CID_HFLIP, 0, 1, 1, 0); 993 if (ov08d10->hflip) 994 ov08d10->hflip->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT; 995 ov08d10->vflip = v4l2_ctrl_new_std(ctrl_hdlr, &ov08d10_ctrl_ops, 996 V4L2_CID_VFLIP, 0, 1, 1, 0); 997 if (ov08d10->vflip) 998 ov08d10->vflip->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT; 999 1000 if (ctrl_hdlr->error) 1001 return ctrl_hdlr->error; 1002 1003 ov08d10->sd.ctrl_handler = ctrl_hdlr; 1004 1005 return 0; 1006} 1007 1008static void ov08d10_update_pad_format(struct ov08d10 *ov08d10, 1009 const struct ov08d10_mode *mode, 1010 struct v4l2_mbus_framefmt *fmt) 1011{ 1012 fmt->width = mode->width; 1013 fmt->height = mode->height; 1014 fmt->code = ov08d10_get_format_code(ov08d10); 1015 fmt->field = V4L2_FIELD_NONE; 1016} 1017 1018static int ov08d10_start_streaming(struct ov08d10 *ov08d10) 1019{ 1020 struct i2c_client *client = v4l2_get_subdevdata(&ov08d10->sd); 1021 const struct ov08d10_reg_list *reg_list; 1022 int link_freq_index, ret; 1023 1024 link_freq_index = ov08d10->cur_mode->link_freq_index; 1025 reg_list = 1026 &ov08d10->priv_lane->link_freq_configs[link_freq_index].reg_list; 1027 1028 /* soft reset */ 1029 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_PAGE, 0x00); 1030 if (ret < 0) { 1031 dev_err(&client->dev, "failed to reset sensor"); 1032 return ret; 1033 } 1034 ret = i2c_smbus_write_byte_data(client, 0x20, 0x0e); 1035 if (ret < 0) { 1036 dev_err(&client->dev, "failed to reset sensor"); 1037 return ret; 1038 } 1039 usleep_range(3000, 4000); 1040 ret = i2c_smbus_write_byte_data(client, 0x20, 0x0b); 1041 if (ret < 0) { 1042 dev_err(&client->dev, "failed to reset sensor"); 1043 return ret; 1044 } 1045 1046 /* update sensor setting */ 1047 ret = ov08d10_write_reg_list(ov08d10, reg_list); 1048 if (ret) { 1049 dev_err(&client->dev, "failed to set plls"); 1050 return ret; 1051 } 1052 1053 reg_list = &ov08d10->cur_mode->reg_list; 1054 ret = ov08d10_write_reg_list(ov08d10, reg_list); 1055 if (ret) { 1056 dev_err(&client->dev, "failed to set mode"); 1057 return ret; 1058 } 1059 1060 ret = __v4l2_ctrl_handler_setup(ov08d10->sd.ctrl_handler); 1061 if (ret) 1062 return ret; 1063 1064 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_PAGE, 0x00); 1065 if (ret < 0) 1066 return ret; 1067 1068 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_MODE_SELECT, 1069 OV08D10_MODE_STREAMING); 1070 if (ret < 0) 1071 return ret; 1072 1073 return i2c_smbus_write_byte_data(client, OV08D10_REG_PAGE, 0x01); 1074} 1075 1076static void ov08d10_stop_streaming(struct ov08d10 *ov08d10) 1077{ 1078 struct i2c_client *client = v4l2_get_subdevdata(&ov08d10->sd); 1079 int ret; 1080 1081 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_PAGE, 0x00); 1082 if (ret < 0) { 1083 dev_err(&client->dev, "failed to stop streaming"); 1084 return; 1085 } 1086 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_MODE_SELECT, 1087 OV08D10_MODE_STANDBY); 1088 if (ret < 0) { 1089 dev_err(&client->dev, "failed to stop streaming"); 1090 return; 1091 } 1092 1093 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_PAGE, 0x01); 1094 if (ret < 0) { 1095 dev_err(&client->dev, "failed to stop streaming"); 1096 return; 1097 } 1098} 1099 1100static int ov08d10_set_stream(struct v4l2_subdev *sd, int enable) 1101{ 1102 struct ov08d10 *ov08d10 = to_ov08d10(sd); 1103 struct i2c_client *client = v4l2_get_subdevdata(sd); 1104 int ret = 0; 1105 1106 if (ov08d10->streaming == enable) 1107 return 0; 1108 1109 mutex_lock(&ov08d10->mutex); 1110 if (enable) { 1111 ret = pm_runtime_resume_and_get(&client->dev); 1112 if (ret < 0) { 1113 mutex_unlock(&ov08d10->mutex); 1114 return ret; 1115 } 1116 1117 ret = ov08d10_start_streaming(ov08d10); 1118 if (ret) { 1119 enable = 0; 1120 ov08d10_stop_streaming(ov08d10); 1121 pm_runtime_put(&client->dev); 1122 } 1123 } else { 1124 ov08d10_stop_streaming(ov08d10); 1125 pm_runtime_put(&client->dev); 1126 } 1127 1128 ov08d10->streaming = enable; 1129 1130 /* vflip and hflip cannot change during streaming */ 1131 __v4l2_ctrl_grab(ov08d10->vflip, enable); 1132 __v4l2_ctrl_grab(ov08d10->hflip, enable); 1133 1134 mutex_unlock(&ov08d10->mutex); 1135 1136 return ret; 1137} 1138 1139static int __maybe_unused ov08d10_suspend(struct device *dev) 1140{ 1141 struct i2c_client *client = to_i2c_client(dev); 1142 struct v4l2_subdev *sd = i2c_get_clientdata(client); 1143 struct ov08d10 *ov08d10 = to_ov08d10(sd); 1144 1145 mutex_lock(&ov08d10->mutex); 1146 if (ov08d10->streaming) 1147 ov08d10_stop_streaming(ov08d10); 1148 1149 mutex_unlock(&ov08d10->mutex); 1150 1151 return 0; 1152} 1153 1154static int __maybe_unused ov08d10_resume(struct device *dev) 1155{ 1156 struct i2c_client *client = to_i2c_client(dev); 1157 struct v4l2_subdev *sd = i2c_get_clientdata(client); 1158 struct ov08d10 *ov08d10 = to_ov08d10(sd); 1159 int ret; 1160 1161 mutex_lock(&ov08d10->mutex); 1162 1163 if (ov08d10->streaming) { 1164 ret = ov08d10_start_streaming(ov08d10); 1165 if (ret) { 1166 ov08d10->streaming = false; 1167 ov08d10_stop_streaming(ov08d10); 1168 mutex_unlock(&ov08d10->mutex); 1169 return ret; 1170 } 1171 } 1172 1173 mutex_unlock(&ov08d10->mutex); 1174 1175 return 0; 1176} 1177 1178static int ov08d10_set_format(struct v4l2_subdev *sd, 1179 struct v4l2_subdev_state *sd_state, 1180 struct v4l2_subdev_format *fmt) 1181{ 1182 struct ov08d10 *ov08d10 = to_ov08d10(sd); 1183 const struct ov08d10_mode *mode; 1184 s32 vblank_def, h_blank; 1185 s64 pixel_rate; 1186 1187 mode = v4l2_find_nearest_size(ov08d10->priv_lane->sp_modes, 1188 ov08d10->modes_size, 1189 width, height, fmt->format.width, 1190 fmt->format.height); 1191 1192 mutex_lock(&ov08d10->mutex); 1193 ov08d10_update_pad_format(ov08d10, mode, &fmt->format); 1194 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) { 1195 *v4l2_subdev_get_try_format(sd, sd_state, fmt->pad) = 1196 fmt->format; 1197 } else { 1198 ov08d10->cur_mode = mode; 1199 __v4l2_ctrl_s_ctrl(ov08d10->link_freq, mode->link_freq_index); 1200 pixel_rate = to_rate(ov08d10->priv_lane->link_freq_menu, 1201 mode->link_freq_index, 1202 ov08d10->cur_mode->data_lanes); 1203 __v4l2_ctrl_s_ctrl_int64(ov08d10->pixel_rate, pixel_rate); 1204 1205 /* Update limits and set FPS to default */ 1206 vblank_def = mode->vts_def - mode->height; 1207 __v4l2_ctrl_modify_range(ov08d10->vblank, 1208 mode->vts_min - mode->height, 1209 OV08D10_VTS_MAX - mode->height, 1, 1210 vblank_def); 1211 __v4l2_ctrl_s_ctrl(ov08d10->vblank, vblank_def); 1212 h_blank = to_pixels_per_line(ov08d10->priv_lane->link_freq_menu, 1213 mode->hts, 1214 mode->link_freq_index, 1215 ov08d10->cur_mode->data_lanes) 1216 - mode->width; 1217 __v4l2_ctrl_modify_range(ov08d10->hblank, h_blank, h_blank, 1, 1218 h_blank); 1219 } 1220 1221 mutex_unlock(&ov08d10->mutex); 1222 1223 return 0; 1224} 1225 1226static int ov08d10_get_format(struct v4l2_subdev *sd, 1227 struct v4l2_subdev_state *sd_state, 1228 struct v4l2_subdev_format *fmt) 1229{ 1230 struct ov08d10 *ov08d10 = to_ov08d10(sd); 1231 1232 mutex_lock(&ov08d10->mutex); 1233 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) 1234 fmt->format = *v4l2_subdev_get_try_format(&ov08d10->sd, 1235 sd_state, 1236 fmt->pad); 1237 else 1238 ov08d10_update_pad_format(ov08d10, ov08d10->cur_mode, 1239 &fmt->format); 1240 1241 mutex_unlock(&ov08d10->mutex); 1242 1243 return 0; 1244} 1245 1246static int ov08d10_enum_mbus_code(struct v4l2_subdev *sd, 1247 struct v4l2_subdev_state *sd_state, 1248 struct v4l2_subdev_mbus_code_enum *code) 1249{ 1250 struct ov08d10 *ov08d10 = to_ov08d10(sd); 1251 1252 if (code->index > 0) 1253 return -EINVAL; 1254 1255 mutex_lock(&ov08d10->mutex); 1256 code->code = ov08d10_get_format_code(ov08d10); 1257 mutex_unlock(&ov08d10->mutex); 1258 1259 return 0; 1260} 1261 1262static int ov08d10_enum_frame_size(struct v4l2_subdev *sd, 1263 struct v4l2_subdev_state *sd_state, 1264 struct v4l2_subdev_frame_size_enum *fse) 1265{ 1266 struct ov08d10 *ov08d10 = to_ov08d10(sd); 1267 1268 if (fse->index >= ov08d10->modes_size) 1269 return -EINVAL; 1270 1271 mutex_lock(&ov08d10->mutex); 1272 if (fse->code != ov08d10_get_format_code(ov08d10)) { 1273 mutex_unlock(&ov08d10->mutex); 1274 return -EINVAL; 1275 } 1276 mutex_unlock(&ov08d10->mutex); 1277 1278 fse->min_width = ov08d10->priv_lane->sp_modes[fse->index].width; 1279 fse->max_width = fse->min_width; 1280 fse->min_height = ov08d10->priv_lane->sp_modes[fse->index].height; 1281 fse->max_height = fse->min_height; 1282 1283 return 0; 1284} 1285 1286static int ov08d10_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh) 1287{ 1288 struct ov08d10 *ov08d10 = to_ov08d10(sd); 1289 1290 mutex_lock(&ov08d10->mutex); 1291 ov08d10_update_pad_format(ov08d10, &ov08d10->priv_lane->sp_modes[0], 1292 v4l2_subdev_get_try_format(sd, fh->state, 0)); 1293 mutex_unlock(&ov08d10->mutex); 1294 1295 return 0; 1296} 1297 1298static const struct v4l2_subdev_video_ops ov08d10_video_ops = { 1299 .s_stream = ov08d10_set_stream, 1300}; 1301 1302static const struct v4l2_subdev_pad_ops ov08d10_pad_ops = { 1303 .set_fmt = ov08d10_set_format, 1304 .get_fmt = ov08d10_get_format, 1305 .enum_mbus_code = ov08d10_enum_mbus_code, 1306 .enum_frame_size = ov08d10_enum_frame_size, 1307}; 1308 1309static const struct v4l2_subdev_ops ov08d10_subdev_ops = { 1310 .video = &ov08d10_video_ops, 1311 .pad = &ov08d10_pad_ops, 1312}; 1313 1314static const struct v4l2_subdev_internal_ops ov08d10_internal_ops = { 1315 .open = ov08d10_open, 1316}; 1317 1318static int ov08d10_identify_module(struct ov08d10 *ov08d10) 1319{ 1320 struct i2c_client *client = v4l2_get_subdevdata(&ov08d10->sd); 1321 u32 val; 1322 u16 chip_id; 1323 int ret; 1324 1325 /* System control registers */ 1326 ret = i2c_smbus_write_byte_data(client, OV08D10_REG_PAGE, 0x00); 1327 if (ret < 0) 1328 return ret; 1329 1330 /* Validate the chip ID */ 1331 ret = i2c_smbus_read_byte_data(client, OV08D10_REG_CHIP_ID_0); 1332 if (ret < 0) 1333 return ret; 1334 1335 val = ret << 8; 1336 1337 ret = i2c_smbus_read_byte_data(client, OV08D10_REG_CHIP_ID_1); 1338 if (ret < 0) 1339 return ret; 1340 1341 chip_id = val | ret; 1342 1343 if ((chip_id & OV08D10_ID_MASK) != OV08D10_CHIP_ID) { 1344 dev_err(&client->dev, "unexpected sensor id(0x%04x)\n", 1345 chip_id); 1346 return -EINVAL; 1347 } 1348 1349 return 0; 1350} 1351 1352static int ov08d10_get_hwcfg(struct ov08d10 *ov08d10, struct device *dev) 1353{ 1354 struct fwnode_handle *ep; 1355 struct fwnode_handle *fwnode = dev_fwnode(dev); 1356 struct v4l2_fwnode_endpoint bus_cfg = { 1357 .bus_type = V4L2_MBUS_CSI2_DPHY 1358 }; 1359 u32 xvclk_rate; 1360 unsigned int i, j; 1361 int ret; 1362 1363 if (!fwnode) 1364 return -ENXIO; 1365 1366 ret = fwnode_property_read_u32(fwnode, "clock-frequency", &xvclk_rate); 1367 if (ret) 1368 return ret; 1369 1370 if (xvclk_rate != OV08D10_XVCLK_19_2) 1371 dev_warn(dev, "external clock rate %u is unsupported", 1372 xvclk_rate); 1373 1374 ep = fwnode_graph_get_next_endpoint(fwnode, NULL); 1375 if (!ep) 1376 return -ENXIO; 1377 1378 ret = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg); 1379 fwnode_handle_put(ep); 1380 if (ret) 1381 return ret; 1382 1383 /* Get number of data lanes */ 1384 if (bus_cfg.bus.mipi_csi2.num_data_lanes != 2) { 1385 dev_err(dev, "number of CSI2 data lanes %d is not supported", 1386 bus_cfg.bus.mipi_csi2.num_data_lanes); 1387 ret = -EINVAL; 1388 goto check_hwcfg_error; 1389 } 1390 1391 dev_dbg(dev, "Using %u data lanes\n", ov08d10->cur_mode->data_lanes); 1392 1393 ov08d10->priv_lane = &lane_cfg_2; 1394 ov08d10->modes_size = ov08d10_modes_num(ov08d10); 1395 1396 if (!bus_cfg.nr_of_link_frequencies) { 1397 dev_err(dev, "no link frequencies defined"); 1398 ret = -EINVAL; 1399 goto check_hwcfg_error; 1400 } 1401 1402 for (i = 0; i < ARRAY_SIZE(ov08d10->priv_lane->link_freq_menu); i++) { 1403 for (j = 0; j < bus_cfg.nr_of_link_frequencies; j++) { 1404 if (ov08d10->priv_lane->link_freq_menu[i] == 1405 bus_cfg.link_frequencies[j]) 1406 break; 1407 } 1408 1409 if (j == bus_cfg.nr_of_link_frequencies) { 1410 dev_err(dev, "no link frequency %lld supported", 1411 ov08d10->priv_lane->link_freq_menu[i]); 1412 ret = -EINVAL; 1413 goto check_hwcfg_error; 1414 } 1415 } 1416 1417check_hwcfg_error: 1418 v4l2_fwnode_endpoint_free(&bus_cfg); 1419 1420 return ret; 1421} 1422 1423static void ov08d10_remove(struct i2c_client *client) 1424{ 1425 struct v4l2_subdev *sd = i2c_get_clientdata(client); 1426 struct ov08d10 *ov08d10 = to_ov08d10(sd); 1427 1428 v4l2_async_unregister_subdev(sd); 1429 media_entity_cleanup(&sd->entity); 1430 v4l2_ctrl_handler_free(sd->ctrl_handler); 1431 pm_runtime_disable(&client->dev); 1432 mutex_destroy(&ov08d10->mutex); 1433} 1434 1435static int ov08d10_probe(struct i2c_client *client) 1436{ 1437 struct ov08d10 *ov08d10; 1438 int ret; 1439 1440 ov08d10 = devm_kzalloc(&client->dev, sizeof(*ov08d10), GFP_KERNEL); 1441 if (!ov08d10) 1442 return -ENOMEM; 1443 1444 ret = ov08d10_get_hwcfg(ov08d10, &client->dev); 1445 if (ret) { 1446 dev_err(&client->dev, "failed to get HW configuration: %d", 1447 ret); 1448 return ret; 1449 } 1450 1451 v4l2_i2c_subdev_init(&ov08d10->sd, client, &ov08d10_subdev_ops); 1452 1453 ret = ov08d10_identify_module(ov08d10); 1454 if (ret) { 1455 dev_err(&client->dev, "failed to find sensor: %d", ret); 1456 return ret; 1457 } 1458 1459 mutex_init(&ov08d10->mutex); 1460 ov08d10->cur_mode = &ov08d10->priv_lane->sp_modes[0]; 1461 ret = ov08d10_init_controls(ov08d10); 1462 if (ret) { 1463 dev_err(&client->dev, "failed to init controls: %d", ret); 1464 goto probe_error_v4l2_ctrl_handler_free; 1465 } 1466 1467 ov08d10->sd.internal_ops = &ov08d10_internal_ops; 1468 ov08d10->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1469 ov08d10->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; 1470 ov08d10->pad.flags = MEDIA_PAD_FL_SOURCE; 1471 ret = media_entity_pads_init(&ov08d10->sd.entity, 1, &ov08d10->pad); 1472 if (ret) { 1473 dev_err(&client->dev, "failed to init entity pads: %d", ret); 1474 goto probe_error_v4l2_ctrl_handler_free; 1475 } 1476 1477 ret = v4l2_async_register_subdev_sensor(&ov08d10->sd); 1478 if (ret < 0) { 1479 dev_err(&client->dev, "failed to register V4L2 subdev: %d", 1480 ret); 1481 goto probe_error_media_entity_cleanup; 1482 } 1483 1484 /* 1485 * Device is already turned on by i2c-core with ACPI domain PM. 1486 * Enable runtime PM and turn off the device. 1487 */ 1488 pm_runtime_set_active(&client->dev); 1489 pm_runtime_enable(&client->dev); 1490 pm_runtime_idle(&client->dev); 1491 1492 return 0; 1493 1494probe_error_media_entity_cleanup: 1495 media_entity_cleanup(&ov08d10->sd.entity); 1496 1497probe_error_v4l2_ctrl_handler_free: 1498 v4l2_ctrl_handler_free(ov08d10->sd.ctrl_handler); 1499 mutex_destroy(&ov08d10->mutex); 1500 1501 return ret; 1502} 1503 1504static const struct dev_pm_ops ov08d10_pm_ops = { 1505 SET_SYSTEM_SLEEP_PM_OPS(ov08d10_suspend, ov08d10_resume) 1506}; 1507 1508#ifdef CONFIG_ACPI 1509static const struct acpi_device_id ov08d10_acpi_ids[] = { 1510 { "OVTI08D1" }, 1511 { /* sentinel */ } 1512}; 1513 1514MODULE_DEVICE_TABLE(acpi, ov08d10_acpi_ids); 1515#endif 1516 1517static struct i2c_driver ov08d10_i2c_driver = { 1518 .driver = { 1519 .name = "ov08d10", 1520 .pm = &ov08d10_pm_ops, 1521 .acpi_match_table = ACPI_PTR(ov08d10_acpi_ids), 1522 }, 1523 .probe = ov08d10_probe, 1524 .remove = ov08d10_remove, 1525}; 1526 1527module_i2c_driver(ov08d10_i2c_driver); 1528 1529MODULE_AUTHOR("Su, Jimmy <jimmy.su@intel.com>"); 1530MODULE_DESCRIPTION("OmniVision ov08d10 sensor driver"); 1531MODULE_LICENSE("GPL v2"); 1532