1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (c) 2020 Intel Corporation. 3 4 #include <asm/unaligned.h> 5 #include <linux/acpi.h> 6 #include <linux/delay.h> 7 #include <linux/i2c.h> 8 #include <linux/module.h> 9 #include <linux/pm_runtime.h> 10 #include <media/v4l2-ctrls.h> 11 #include <media/v4l2-device.h> 12 #include <media/v4l2-fwnode.h> 13 14 #define OV9734_LINK_FREQ_180MHZ 180000000ULL 15 #define OV9734_SCLK 36000000LL 16 #define OV9734_MCLK 19200000 17 /* ov9734 only support 1-lane mipi output */ 18 #define OV9734_DATA_LANES 1 19 #define OV9734_RGB_DEPTH 10 20 21 #define OV9734_REG_CHIP_ID 0x300a 22 #define OV9734_CHIP_ID 0x9734 23 24 #define OV9734_REG_MODE_SELECT 0x0100 25 #define OV9734_MODE_STANDBY 0x00 26 #define OV9734_MODE_STREAMING 0x01 27 28 /* vertical-timings from sensor */ 29 #define OV9734_REG_VTS 0x380e 30 #define OV9734_VTS_30FPS 0x0322 31 #define OV9734_VTS_30FPS_MIN 0x0322 32 #define OV9734_VTS_MAX 0x7fff 33 34 /* horizontal-timings from sensor */ 35 #define OV9734_REG_HTS 0x380c 36 37 /* Exposure controls from sensor */ 38 #define OV9734_REG_EXPOSURE 0x3500 39 #define OV9734_EXPOSURE_MIN 4 40 #define OV9734_EXPOSURE_MAX_MARGIN 4 41 #define OV9734_EXPOSURE_STEP 1 42 43 /* Analog gain controls from sensor */ 44 #define OV9734_REG_ANALOG_GAIN 0x350a 45 #define OV9734_ANAL_GAIN_MIN 16 46 #define OV9734_ANAL_GAIN_MAX 248 47 #define OV9734_ANAL_GAIN_STEP 1 48 49 /* Digital gain controls from sensor */ 50 #define OV9734_REG_MWB_R_GAIN 0x5180 51 #define OV9734_REG_MWB_G_GAIN 0x5182 52 #define OV9734_REG_MWB_B_GAIN 0x5184 53 #define OV9734_DGTL_GAIN_MIN 256 54 #define OV9734_DGTL_GAIN_MAX 1023 55 #define OV9734_DGTL_GAIN_STEP 1 56 #define OV9734_DGTL_GAIN_DEFAULT 256 57 58 /* Test Pattern Control */ 59 #define OV9734_REG_TEST_PATTERN 0x5080 60 #define OV9734_TEST_PATTERN_ENABLE BIT(7) 61 #define OV9734_TEST_PATTERN_BAR_SHIFT 2 62 63 enum { 64 OV9734_LINK_FREQ_180MHZ_INDEX, 65 }; 66 67 struct ov9734_reg { 68 u16 address; 69 u8 val; 70 }; 71 72 struct ov9734_reg_list { 73 u32 num_of_regs; 74 const struct ov9734_reg *regs; 75 }; 76 77 struct ov9734_link_freq_config { 78 const struct ov9734_reg_list reg_list; 79 }; 80 81 struct ov9734_mode { 82 /* Frame width in pixels */ 83 u32 width; 84 85 /* Frame height in pixels */ 86 u32 height; 87 88 /* Horizontal timining size */ 89 u32 hts; 90 91 /* Default vertical timining size */ 92 u32 vts_def; 93 94 /* Min vertical timining size */ 95 u32 vts_min; 96 97 /* Link frequency needed for this resolution */ 98 u32 link_freq_index; 99 100 /* Sensor register settings for this resolution */ 101 const struct ov9734_reg_list reg_list; 102 }; 103 104 static const struct ov9734_reg mipi_data_rate_360mbps[] = { 105 {0x3030, 0x19}, 106 {0x3080, 0x02}, 107 {0x3081, 0x4b}, 108 {0x3082, 0x04}, 109 {0x3083, 0x00}, 110 {0x3084, 0x02}, 111 {0x3085, 0x01}, 112 {0x3086, 0x01}, 113 {0x3089, 0x01}, 114 {0x308a, 0x00}, 115 {0x301e, 0x15}, 116 {0x3103, 0x01}, 117 }; 118 119 static const struct ov9734_reg mode_1296x734_regs[] = { 120 {0x3001, 0x00}, 121 {0x3002, 0x00}, 122 {0x3007, 0x00}, 123 {0x3010, 0x00}, 124 {0x3011, 0x08}, 125 {0x3014, 0x22}, 126 {0x3600, 0x55}, 127 {0x3601, 0x02}, 128 {0x3605, 0x22}, 129 {0x3611, 0xe7}, 130 {0x3654, 0x10}, 131 {0x3655, 0x77}, 132 {0x3656, 0x77}, 133 {0x3657, 0x07}, 134 {0x3658, 0x22}, 135 {0x3659, 0x22}, 136 {0x365a, 0x02}, 137 {0x3784, 0x05}, 138 {0x3785, 0x55}, 139 {0x37c0, 0x07}, 140 {0x3800, 0x00}, 141 {0x3801, 0x04}, 142 {0x3802, 0x00}, 143 {0x3803, 0x04}, 144 {0x3804, 0x05}, 145 {0x3805, 0x0b}, 146 {0x3806, 0x02}, 147 {0x3807, 0xdb}, 148 {0x3808, 0x05}, 149 {0x3809, 0x00}, 150 {0x380a, 0x02}, 151 {0x380b, 0xd0}, 152 {0x380c, 0x05}, 153 {0x380d, 0xc6}, 154 {0x380e, 0x03}, 155 {0x380f, 0x22}, 156 {0x3810, 0x00}, 157 {0x3811, 0x04}, 158 {0x3812, 0x00}, 159 {0x3813, 0x04}, 160 {0x3816, 0x00}, 161 {0x3817, 0x00}, 162 {0x3818, 0x00}, 163 {0x3819, 0x04}, 164 {0x3820, 0x18}, 165 {0x3821, 0x00}, 166 {0x382c, 0x06}, 167 {0x3500, 0x00}, 168 {0x3501, 0x31}, 169 {0x3502, 0x00}, 170 {0x3503, 0x03}, 171 {0x3504, 0x00}, 172 {0x3505, 0x00}, 173 {0x3509, 0x10}, 174 {0x350a, 0x00}, 175 {0x350b, 0x40}, 176 {0x3d00, 0x00}, 177 {0x3d01, 0x00}, 178 {0x3d02, 0x00}, 179 {0x3d03, 0x00}, 180 {0x3d04, 0x00}, 181 {0x3d05, 0x00}, 182 {0x3d06, 0x00}, 183 {0x3d07, 0x00}, 184 {0x3d08, 0x00}, 185 {0x3d09, 0x00}, 186 {0x3d0a, 0x00}, 187 {0x3d0b, 0x00}, 188 {0x3d0c, 0x00}, 189 {0x3d0d, 0x00}, 190 {0x3d0e, 0x00}, 191 {0x3d0f, 0x00}, 192 {0x3d80, 0x00}, 193 {0x3d81, 0x00}, 194 {0x3d82, 0x38}, 195 {0x3d83, 0xa4}, 196 {0x3d84, 0x00}, 197 {0x3d85, 0x00}, 198 {0x3d86, 0x1f}, 199 {0x3d87, 0x03}, 200 {0x3d8b, 0x00}, 201 {0x3d8f, 0x00}, 202 {0x4001, 0xe0}, 203 {0x4009, 0x0b}, 204 {0x4300, 0x03}, 205 {0x4301, 0xff}, 206 {0x4304, 0x00}, 207 {0x4305, 0x00}, 208 {0x4309, 0x00}, 209 {0x4600, 0x00}, 210 {0x4601, 0x80}, 211 {0x4800, 0x00}, 212 {0x4805, 0x00}, 213 {0x4821, 0x50}, 214 {0x4823, 0x50}, 215 {0x4837, 0x2d}, 216 {0x4a00, 0x00}, 217 {0x4f00, 0x80}, 218 {0x4f01, 0x10}, 219 {0x4f02, 0x00}, 220 {0x4f03, 0x00}, 221 {0x4f04, 0x00}, 222 {0x4f05, 0x00}, 223 {0x4f06, 0x00}, 224 {0x4f07, 0x00}, 225 {0x4f08, 0x00}, 226 {0x4f09, 0x00}, 227 {0x5000, 0x2f}, 228 {0x500c, 0x00}, 229 {0x500d, 0x00}, 230 {0x500e, 0x00}, 231 {0x500f, 0x00}, 232 {0x5010, 0x00}, 233 {0x5011, 0x00}, 234 {0x5012, 0x00}, 235 {0x5013, 0x00}, 236 {0x5014, 0x00}, 237 {0x5015, 0x00}, 238 {0x5016, 0x00}, 239 {0x5017, 0x00}, 240 {0x5080, 0x00}, 241 {0x5180, 0x01}, 242 {0x5181, 0x00}, 243 {0x5182, 0x01}, 244 {0x5183, 0x00}, 245 {0x5184, 0x01}, 246 {0x5185, 0x00}, 247 {0x5708, 0x06}, 248 {0x380f, 0x2a}, 249 {0x5780, 0x3e}, 250 {0x5781, 0x0f}, 251 {0x5782, 0x44}, 252 {0x5783, 0x02}, 253 {0x5784, 0x01}, 254 {0x5785, 0x01}, 255 {0x5786, 0x00}, 256 {0x5787, 0x04}, 257 {0x5788, 0x02}, 258 {0x5789, 0x0f}, 259 {0x578a, 0xfd}, 260 {0x578b, 0xf5}, 261 {0x578c, 0xf5}, 262 {0x578d, 0x03}, 263 {0x578e, 0x08}, 264 {0x578f, 0x0c}, 265 {0x5790, 0x08}, 266 {0x5791, 0x04}, 267 {0x5792, 0x00}, 268 {0x5793, 0x52}, 269 {0x5794, 0xa3}, 270 {0x5000, 0x3f}, 271 {0x3801, 0x00}, 272 {0x3803, 0x00}, 273 {0x3805, 0x0f}, 274 {0x3807, 0xdf}, 275 {0x3809, 0x10}, 276 {0x380b, 0xde}, 277 {0x3811, 0x00}, 278 {0x3813, 0x01}, 279 }; 280 281 static const char * const ov9734_test_pattern_menu[] = { 282 "Disabled", 283 "Standard Color Bar", 284 "Top-Bottom Darker Color Bar", 285 "Right-Left Darker Color Bar", 286 "Bottom-Top Darker Color Bar", 287 }; 288 289 static const s64 link_freq_menu_items[] = { 290 OV9734_LINK_FREQ_180MHZ, 291 }; 292 293 static const struct ov9734_link_freq_config link_freq_configs[] = { 294 [OV9734_LINK_FREQ_180MHZ_INDEX] = { 295 .reg_list = { 296 .num_of_regs = ARRAY_SIZE(mipi_data_rate_360mbps), 297 .regs = mipi_data_rate_360mbps, 298 } 299 }, 300 }; 301 302 static const struct ov9734_mode supported_modes[] = { 303 { 304 .width = 1296, 305 .height = 734, 306 .hts = 0x5c6, 307 .vts_def = OV9734_VTS_30FPS, 308 .vts_min = OV9734_VTS_30FPS_MIN, 309 .reg_list = { 310 .num_of_regs = ARRAY_SIZE(mode_1296x734_regs), 311 .regs = mode_1296x734_regs, 312 }, 313 .link_freq_index = OV9734_LINK_FREQ_180MHZ_INDEX, 314 }, 315 }; 316 317 struct ov9734 { 318 struct v4l2_subdev sd; 319 struct media_pad pad; 320 struct v4l2_ctrl_handler ctrl_handler; 321 322 /* V4L2 Controls */ 323 struct v4l2_ctrl *link_freq; 324 struct v4l2_ctrl *pixel_rate; 325 struct v4l2_ctrl *vblank; 326 struct v4l2_ctrl *hblank; 327 struct v4l2_ctrl *exposure; 328 329 /* Current mode */ 330 const struct ov9734_mode *cur_mode; 331 332 /* To serialize asynchronus callbacks */ 333 struct mutex mutex; 334 335 /* Streaming on/off */ 336 bool streaming; 337 }; 338 339 static inline struct ov9734 *to_ov9734(struct v4l2_subdev *subdev) 340 { 341 return container_of(subdev, struct ov9734, sd); 342 } 343 344 static u64 to_pixel_rate(u32 f_index) 345 { 346 u64 pixel_rate = link_freq_menu_items[f_index] * 2 * OV9734_DATA_LANES; 347 348 do_div(pixel_rate, OV9734_RGB_DEPTH); 349 350 return pixel_rate; 351 } 352 353 static u64 to_pixels_per_line(u32 hts, u32 f_index) 354 { 355 u64 ppl = hts * to_pixel_rate(f_index); 356 357 do_div(ppl, OV9734_SCLK); 358 359 return ppl; 360 } 361 362 static int ov9734_read_reg(struct ov9734 *ov9734, u16 reg, u16 len, u32 *val) 363 { 364 struct i2c_client *client = v4l2_get_subdevdata(&ov9734->sd); 365 struct i2c_msg msgs[2]; 366 u8 addr_buf[2]; 367 u8 data_buf[4] = {0}; 368 int ret; 369 370 if (len > sizeof(data_buf)) 371 return -EINVAL; 372 373 put_unaligned_be16(reg, addr_buf); 374 msgs[0].addr = client->addr; 375 msgs[0].flags = 0; 376 msgs[0].len = sizeof(addr_buf); 377 msgs[0].buf = addr_buf; 378 msgs[1].addr = client->addr; 379 msgs[1].flags = I2C_M_RD; 380 msgs[1].len = len; 381 msgs[1].buf = &data_buf[sizeof(data_buf) - len]; 382 383 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 384 if (ret != ARRAY_SIZE(msgs)) 385 return ret < 0 ? ret : -EIO; 386 387 *val = get_unaligned_be32(data_buf); 388 389 return 0; 390 } 391 392 static int ov9734_write_reg(struct ov9734 *ov9734, u16 reg, u16 len, u32 val) 393 { 394 struct i2c_client *client = v4l2_get_subdevdata(&ov9734->sd); 395 u8 buf[6]; 396 int ret = 0; 397 398 if (len > 4) 399 return -EINVAL; 400 401 put_unaligned_be16(reg, buf); 402 put_unaligned_be32(val << 8 * (4 - len), buf + 2); 403 404 ret = i2c_master_send(client, buf, len + 2); 405 if (ret != len + 2) 406 return ret < 0 ? ret : -EIO; 407 408 return 0; 409 } 410 411 static int ov9734_write_reg_list(struct ov9734 *ov9734, 412 const struct ov9734_reg_list *r_list) 413 { 414 struct i2c_client *client = v4l2_get_subdevdata(&ov9734->sd); 415 unsigned int i; 416 int ret; 417 418 for (i = 0; i < r_list->num_of_regs; i++) { 419 ret = ov9734_write_reg(ov9734, r_list->regs[i].address, 1, 420 r_list->regs[i].val); 421 if (ret) { 422 dev_err_ratelimited(&client->dev, 423 "write reg 0x%4.4x return err = %d", 424 r_list->regs[i].address, ret); 425 return ret; 426 } 427 } 428 429 return 0; 430 } 431 432 static int ov9734_update_digital_gain(struct ov9734 *ov9734, u32 d_gain) 433 { 434 int ret; 435 436 ret = ov9734_write_reg(ov9734, OV9734_REG_MWB_R_GAIN, 2, d_gain); 437 if (ret) 438 return ret; 439 440 ret = ov9734_write_reg(ov9734, OV9734_REG_MWB_G_GAIN, 2, d_gain); 441 if (ret) 442 return ret; 443 444 return ov9734_write_reg(ov9734, OV9734_REG_MWB_B_GAIN, 2, d_gain); 445 } 446 447 static int ov9734_test_pattern(struct ov9734 *ov9734, u32 pattern) 448 { 449 if (pattern) 450 pattern = (pattern - 1) << OV9734_TEST_PATTERN_BAR_SHIFT | 451 OV9734_TEST_PATTERN_ENABLE; 452 453 return ov9734_write_reg(ov9734, OV9734_REG_TEST_PATTERN, 1, pattern); 454 } 455 456 static int ov9734_set_ctrl(struct v4l2_ctrl *ctrl) 457 { 458 struct ov9734 *ov9734 = container_of(ctrl->handler, 459 struct ov9734, ctrl_handler); 460 struct i2c_client *client = v4l2_get_subdevdata(&ov9734->sd); 461 s64 exposure_max; 462 int ret = 0; 463 464 /* Propagate change of current control to all related controls */ 465 if (ctrl->id == V4L2_CID_VBLANK) { 466 /* Update max exposure while meeting expected vblanking */ 467 exposure_max = ov9734->cur_mode->height + ctrl->val - 468 OV9734_EXPOSURE_MAX_MARGIN; 469 __v4l2_ctrl_modify_range(ov9734->exposure, 470 ov9734->exposure->minimum, 471 exposure_max, ov9734->exposure->step, 472 exposure_max); 473 } 474 475 /* V4L2 controls values will be applied only when power is already up */ 476 if (!pm_runtime_get_if_in_use(&client->dev)) 477 return 0; 478 479 switch (ctrl->id) { 480 case V4L2_CID_ANALOGUE_GAIN: 481 ret = ov9734_write_reg(ov9734, OV9734_REG_ANALOG_GAIN, 482 2, ctrl->val); 483 break; 484 485 case V4L2_CID_DIGITAL_GAIN: 486 ret = ov9734_update_digital_gain(ov9734, ctrl->val); 487 break; 488 489 case V4L2_CID_EXPOSURE: 490 /* 4 least significant bits of expsoure are fractional part */ 491 ret = ov9734_write_reg(ov9734, OV9734_REG_EXPOSURE, 492 3, ctrl->val << 4); 493 break; 494 495 case V4L2_CID_VBLANK: 496 ret = ov9734_write_reg(ov9734, OV9734_REG_VTS, 2, 497 ov9734->cur_mode->height + ctrl->val); 498 break; 499 500 case V4L2_CID_TEST_PATTERN: 501 ret = ov9734_test_pattern(ov9734, ctrl->val); 502 break; 503 504 default: 505 ret = -EINVAL; 506 break; 507 } 508 509 pm_runtime_put(&client->dev); 510 511 return ret; 512 } 513 514 static const struct v4l2_ctrl_ops ov9734_ctrl_ops = { 515 .s_ctrl = ov9734_set_ctrl, 516 }; 517 518 static int ov9734_init_controls(struct ov9734 *ov9734) 519 { 520 struct v4l2_ctrl_handler *ctrl_hdlr; 521 const struct ov9734_mode *cur_mode; 522 s64 exposure_max, h_blank, pixel_rate; 523 u32 vblank_min, vblank_max, vblank_default; 524 int ret, size; 525 526 ctrl_hdlr = &ov9734->ctrl_handler; 527 ret = v4l2_ctrl_handler_init(ctrl_hdlr, 8); 528 if (ret) 529 return ret; 530 531 ctrl_hdlr->lock = &ov9734->mutex; 532 cur_mode = ov9734->cur_mode; 533 size = ARRAY_SIZE(link_freq_menu_items); 534 ov9734->link_freq = v4l2_ctrl_new_int_menu(ctrl_hdlr, &ov9734_ctrl_ops, 535 V4L2_CID_LINK_FREQ, 536 size - 1, 0, 537 link_freq_menu_items); 538 if (ov9734->link_freq) 539 ov9734->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY; 540 541 pixel_rate = to_pixel_rate(OV9734_LINK_FREQ_180MHZ_INDEX); 542 ov9734->pixel_rate = v4l2_ctrl_new_std(ctrl_hdlr, &ov9734_ctrl_ops, 543 V4L2_CID_PIXEL_RATE, 0, 544 pixel_rate, 1, pixel_rate); 545 vblank_min = cur_mode->vts_min - cur_mode->height; 546 vblank_max = OV9734_VTS_MAX - cur_mode->height; 547 vblank_default = cur_mode->vts_def - cur_mode->height; 548 ov9734->vblank = v4l2_ctrl_new_std(ctrl_hdlr, &ov9734_ctrl_ops, 549 V4L2_CID_VBLANK, vblank_min, 550 vblank_max, 1, vblank_default); 551 h_blank = to_pixels_per_line(cur_mode->hts, cur_mode->link_freq_index); 552 h_blank -= cur_mode->width; 553 ov9734->hblank = v4l2_ctrl_new_std(ctrl_hdlr, &ov9734_ctrl_ops, 554 V4L2_CID_HBLANK, h_blank, h_blank, 1, 555 h_blank); 556 if (ov9734->hblank) 557 ov9734->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY; 558 559 v4l2_ctrl_new_std(ctrl_hdlr, &ov9734_ctrl_ops, V4L2_CID_ANALOGUE_GAIN, 560 OV9734_ANAL_GAIN_MIN, OV9734_ANAL_GAIN_MAX, 561 OV9734_ANAL_GAIN_STEP, OV9734_ANAL_GAIN_MIN); 562 v4l2_ctrl_new_std(ctrl_hdlr, &ov9734_ctrl_ops, V4L2_CID_DIGITAL_GAIN, 563 OV9734_DGTL_GAIN_MIN, OV9734_DGTL_GAIN_MAX, 564 OV9734_DGTL_GAIN_STEP, OV9734_DGTL_GAIN_DEFAULT); 565 exposure_max = ov9734->cur_mode->vts_def - OV9734_EXPOSURE_MAX_MARGIN; 566 ov9734->exposure = v4l2_ctrl_new_std(ctrl_hdlr, &ov9734_ctrl_ops, 567 V4L2_CID_EXPOSURE, 568 OV9734_EXPOSURE_MIN, exposure_max, 569 OV9734_EXPOSURE_STEP, 570 exposure_max); 571 v4l2_ctrl_new_std_menu_items(ctrl_hdlr, &ov9734_ctrl_ops, 572 V4L2_CID_TEST_PATTERN, 573 ARRAY_SIZE(ov9734_test_pattern_menu) - 1, 574 0, 0, ov9734_test_pattern_menu); 575 if (ctrl_hdlr->error) 576 return ctrl_hdlr->error; 577 578 ov9734->sd.ctrl_handler = ctrl_hdlr; 579 580 return 0; 581 } 582 583 static void ov9734_update_pad_format(const struct ov9734_mode *mode, 584 struct v4l2_mbus_framefmt *fmt) 585 { 586 fmt->width = mode->width; 587 fmt->height = mode->height; 588 fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10; 589 fmt->field = V4L2_FIELD_NONE; 590 } 591 592 static int ov9734_start_streaming(struct ov9734 *ov9734) 593 { 594 struct i2c_client *client = v4l2_get_subdevdata(&ov9734->sd); 595 const struct ov9734_reg_list *reg_list; 596 int link_freq_index, ret; 597 598 link_freq_index = ov9734->cur_mode->link_freq_index; 599 reg_list = &link_freq_configs[link_freq_index].reg_list; 600 ret = ov9734_write_reg_list(ov9734, reg_list); 601 if (ret) { 602 dev_err(&client->dev, "failed to set plls"); 603 return ret; 604 } 605 606 reg_list = &ov9734->cur_mode->reg_list; 607 ret = ov9734_write_reg_list(ov9734, reg_list); 608 if (ret) { 609 dev_err(&client->dev, "failed to set mode"); 610 return ret; 611 } 612 613 ret = __v4l2_ctrl_handler_setup(ov9734->sd.ctrl_handler); 614 if (ret) 615 return ret; 616 617 ret = ov9734_write_reg(ov9734, OV9734_REG_MODE_SELECT, 618 1, OV9734_MODE_STREAMING); 619 if (ret) 620 dev_err(&client->dev, "failed to start stream"); 621 622 return ret; 623 } 624 625 static void ov9734_stop_streaming(struct ov9734 *ov9734) 626 { 627 struct i2c_client *client = v4l2_get_subdevdata(&ov9734->sd); 628 629 if (ov9734_write_reg(ov9734, OV9734_REG_MODE_SELECT, 630 1, OV9734_MODE_STANDBY)) 631 dev_err(&client->dev, "failed to stop stream"); 632 } 633 634 static int ov9734_set_stream(struct v4l2_subdev *sd, int enable) 635 { 636 struct ov9734 *ov9734 = to_ov9734(sd); 637 struct i2c_client *client = v4l2_get_subdevdata(sd); 638 int ret = 0; 639 640 mutex_lock(&ov9734->mutex); 641 if (ov9734->streaming == enable) { 642 mutex_unlock(&ov9734->mutex); 643 return 0; 644 } 645 646 if (enable) { 647 ret = pm_runtime_get_sync(&client->dev); 648 if (ret < 0) { 649 pm_runtime_put_noidle(&client->dev); 650 mutex_unlock(&ov9734->mutex); 651 return ret; 652 } 653 654 ret = ov9734_start_streaming(ov9734); 655 if (ret) { 656 enable = 0; 657 ov9734_stop_streaming(ov9734); 658 pm_runtime_put(&client->dev); 659 } 660 } else { 661 ov9734_stop_streaming(ov9734); 662 pm_runtime_put(&client->dev); 663 } 664 665 ov9734->streaming = enable; 666 mutex_unlock(&ov9734->mutex); 667 668 return ret; 669 } 670 671 static int __maybe_unused ov9734_suspend(struct device *dev) 672 { 673 struct i2c_client *client = to_i2c_client(dev); 674 struct v4l2_subdev *sd = i2c_get_clientdata(client); 675 struct ov9734 *ov9734 = to_ov9734(sd); 676 677 mutex_lock(&ov9734->mutex); 678 if (ov9734->streaming) 679 ov9734_stop_streaming(ov9734); 680 681 mutex_unlock(&ov9734->mutex); 682 683 return 0; 684 } 685 686 static int __maybe_unused ov9734_resume(struct device *dev) 687 { 688 struct i2c_client *client = to_i2c_client(dev); 689 struct v4l2_subdev *sd = i2c_get_clientdata(client); 690 struct ov9734 *ov9734 = to_ov9734(sd); 691 int ret = 0; 692 693 mutex_lock(&ov9734->mutex); 694 if (!ov9734->streaming) 695 goto exit; 696 697 ret = ov9734_start_streaming(ov9734); 698 if (ret) { 699 ov9734->streaming = false; 700 ov9734_stop_streaming(ov9734); 701 } 702 703 exit: 704 mutex_unlock(&ov9734->mutex); 705 return ret; 706 } 707 708 static int ov9734_set_format(struct v4l2_subdev *sd, 709 struct v4l2_subdev_pad_config *cfg, 710 struct v4l2_subdev_format *fmt) 711 { 712 struct ov9734 *ov9734 = to_ov9734(sd); 713 const struct ov9734_mode *mode; 714 s32 vblank_def, h_blank; 715 716 mode = v4l2_find_nearest_size(supported_modes, 717 ARRAY_SIZE(supported_modes), width, 718 height, fmt->format.width, 719 fmt->format.height); 720 721 mutex_lock(&ov9734->mutex); 722 ov9734_update_pad_format(mode, &fmt->format); 723 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) { 724 *v4l2_subdev_get_try_format(sd, cfg, fmt->pad) = fmt->format; 725 } else { 726 ov9734->cur_mode = mode; 727 __v4l2_ctrl_s_ctrl(ov9734->link_freq, mode->link_freq_index); 728 __v4l2_ctrl_s_ctrl_int64(ov9734->pixel_rate, 729 to_pixel_rate(mode->link_freq_index)); 730 731 /* Update limits and set FPS to default */ 732 vblank_def = mode->vts_def - mode->height; 733 __v4l2_ctrl_modify_range(ov9734->vblank, 734 mode->vts_min - mode->height, 735 OV9734_VTS_MAX - mode->height, 1, 736 vblank_def); 737 __v4l2_ctrl_s_ctrl(ov9734->vblank, vblank_def); 738 h_blank = to_pixels_per_line(mode->hts, mode->link_freq_index) - 739 mode->width; 740 __v4l2_ctrl_modify_range(ov9734->hblank, h_blank, h_blank, 1, 741 h_blank); 742 } 743 744 mutex_unlock(&ov9734->mutex); 745 746 return 0; 747 } 748 749 static int ov9734_get_format(struct v4l2_subdev *sd, 750 struct v4l2_subdev_pad_config *cfg, 751 struct v4l2_subdev_format *fmt) 752 { 753 struct ov9734 *ov9734 = to_ov9734(sd); 754 755 mutex_lock(&ov9734->mutex); 756 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) 757 fmt->format = *v4l2_subdev_get_try_format(&ov9734->sd, cfg, 758 fmt->pad); 759 else 760 ov9734_update_pad_format(ov9734->cur_mode, &fmt->format); 761 762 mutex_unlock(&ov9734->mutex); 763 764 return 0; 765 } 766 767 static int ov9734_enum_mbus_code(struct v4l2_subdev *sd, 768 struct v4l2_subdev_pad_config *cfg, 769 struct v4l2_subdev_mbus_code_enum *code) 770 { 771 if (code->index > 0) 772 return -EINVAL; 773 774 code->code = MEDIA_BUS_FMT_SGRBG10_1X10; 775 776 return 0; 777 } 778 779 static int ov9734_enum_frame_size(struct v4l2_subdev *sd, 780 struct v4l2_subdev_pad_config *cfg, 781 struct v4l2_subdev_frame_size_enum *fse) 782 { 783 if (fse->index >= ARRAY_SIZE(supported_modes)) 784 return -EINVAL; 785 786 if (fse->code != MEDIA_BUS_FMT_SGRBG10_1X10) 787 return -EINVAL; 788 789 fse->min_width = supported_modes[fse->index].width; 790 fse->max_width = fse->min_width; 791 fse->min_height = supported_modes[fse->index].height; 792 fse->max_height = fse->min_height; 793 794 return 0; 795 } 796 797 static int ov9734_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh) 798 { 799 struct ov9734 *ov9734 = to_ov9734(sd); 800 801 mutex_lock(&ov9734->mutex); 802 ov9734_update_pad_format(&supported_modes[0], 803 v4l2_subdev_get_try_format(sd, fh->pad, 0)); 804 mutex_unlock(&ov9734->mutex); 805 806 return 0; 807 } 808 809 static const struct v4l2_subdev_video_ops ov9734_video_ops = { 810 .s_stream = ov9734_set_stream, 811 }; 812 813 static const struct v4l2_subdev_pad_ops ov9734_pad_ops = { 814 .set_fmt = ov9734_set_format, 815 .get_fmt = ov9734_get_format, 816 .enum_mbus_code = ov9734_enum_mbus_code, 817 .enum_frame_size = ov9734_enum_frame_size, 818 }; 819 820 static const struct v4l2_subdev_ops ov9734_subdev_ops = { 821 .video = &ov9734_video_ops, 822 .pad = &ov9734_pad_ops, 823 }; 824 825 static const struct media_entity_operations ov9734_subdev_entity_ops = { 826 .link_validate = v4l2_subdev_link_validate, 827 }; 828 829 static const struct v4l2_subdev_internal_ops ov9734_internal_ops = { 830 .open = ov9734_open, 831 }; 832 833 static int ov9734_identify_module(struct ov9734 *ov9734) 834 { 835 struct i2c_client *client = v4l2_get_subdevdata(&ov9734->sd); 836 int ret; 837 u32 val; 838 839 ret = ov9734_read_reg(ov9734, OV9734_REG_CHIP_ID, 2, &val); 840 if (ret) 841 return ret; 842 843 if (val != OV9734_CHIP_ID) { 844 dev_err(&client->dev, "chip id mismatch: %x!=%x", 845 OV9734_CHIP_ID, val); 846 return -ENXIO; 847 } 848 849 return 0; 850 } 851 852 static int ov9734_check_hwcfg(struct device *dev) 853 { 854 struct fwnode_handle *ep; 855 struct fwnode_handle *fwnode = dev_fwnode(dev); 856 struct v4l2_fwnode_endpoint bus_cfg = { 857 .bus_type = V4L2_MBUS_CSI2_DPHY 858 }; 859 u32 mclk; 860 int ret; 861 unsigned int i, j; 862 863 if (!fwnode) 864 return -ENXIO; 865 866 ret = fwnode_property_read_u32(fwnode, "clock-frequency", &mclk); 867 if (ret) 868 return ret; 869 870 if (mclk != OV9734_MCLK) { 871 dev_err(dev, "external clock %d is not supported", mclk); 872 return -EINVAL; 873 } 874 875 ep = fwnode_graph_get_next_endpoint(fwnode, NULL); 876 if (!ep) 877 return -ENXIO; 878 879 ret = v4l2_fwnode_endpoint_alloc_parse(ep, &bus_cfg); 880 fwnode_handle_put(ep); 881 if (ret) 882 return ret; 883 884 if (!bus_cfg.nr_of_link_frequencies) { 885 dev_err(dev, "no link frequencies defined"); 886 ret = -EINVAL; 887 goto check_hwcfg_error; 888 } 889 890 for (i = 0; i < ARRAY_SIZE(link_freq_menu_items); i++) { 891 for (j = 0; j < bus_cfg.nr_of_link_frequencies; j++) { 892 if (link_freq_menu_items[i] == 893 bus_cfg.link_frequencies[j]) 894 break; 895 } 896 897 if (j == bus_cfg.nr_of_link_frequencies) { 898 dev_err(dev, "no link frequency %lld supported", 899 link_freq_menu_items[i]); 900 ret = -EINVAL; 901 goto check_hwcfg_error; 902 } 903 } 904 905 check_hwcfg_error: 906 v4l2_fwnode_endpoint_free(&bus_cfg); 907 908 return ret; 909 } 910 911 static int ov9734_remove(struct i2c_client *client) 912 { 913 struct v4l2_subdev *sd = i2c_get_clientdata(client); 914 struct ov9734 *ov9734 = to_ov9734(sd); 915 916 v4l2_async_unregister_subdev(sd); 917 media_entity_cleanup(&sd->entity); 918 v4l2_ctrl_handler_free(sd->ctrl_handler); 919 pm_runtime_disable(&client->dev); 920 mutex_destroy(&ov9734->mutex); 921 922 return 0; 923 } 924 925 static int ov9734_probe(struct i2c_client *client) 926 { 927 struct ov9734 *ov9734; 928 int ret; 929 930 ret = ov9734_check_hwcfg(&client->dev); 931 if (ret) { 932 dev_err(&client->dev, "failed to check HW configuration: %d", 933 ret); 934 return ret; 935 } 936 937 ov9734 = devm_kzalloc(&client->dev, sizeof(*ov9734), GFP_KERNEL); 938 if (!ov9734) 939 return -ENOMEM; 940 941 v4l2_i2c_subdev_init(&ov9734->sd, client, &ov9734_subdev_ops); 942 ret = ov9734_identify_module(ov9734); 943 if (ret) { 944 dev_err(&client->dev, "failed to find sensor: %d", ret); 945 return ret; 946 } 947 948 mutex_init(&ov9734->mutex); 949 ov9734->cur_mode = &supported_modes[0]; 950 ret = ov9734_init_controls(ov9734); 951 if (ret) { 952 dev_err(&client->dev, "failed to init controls: %d", ret); 953 goto probe_error_v4l2_ctrl_handler_free; 954 } 955 956 ov9734->sd.internal_ops = &ov9734_internal_ops; 957 ov9734->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 958 ov9734->sd.entity.ops = &ov9734_subdev_entity_ops; 959 ov9734->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; 960 ov9734->pad.flags = MEDIA_PAD_FL_SOURCE; 961 ret = media_entity_pads_init(&ov9734->sd.entity, 1, &ov9734->pad); 962 if (ret) { 963 dev_err(&client->dev, "failed to init entity pads: %d", ret); 964 goto probe_error_v4l2_ctrl_handler_free; 965 } 966 967 ret = v4l2_async_register_subdev_sensor_common(&ov9734->sd); 968 if (ret < 0) { 969 dev_err(&client->dev, "failed to register V4L2 subdev: %d", 970 ret); 971 goto probe_error_media_entity_cleanup; 972 } 973 974 /* 975 * Device is already turned on by i2c-core with ACPI domain PM. 976 * Enable runtime PM and turn off the device. 977 */ 978 pm_runtime_set_active(&client->dev); 979 pm_runtime_enable(&client->dev); 980 pm_runtime_idle(&client->dev); 981 982 return 0; 983 984 probe_error_media_entity_cleanup: 985 media_entity_cleanup(&ov9734->sd.entity); 986 987 probe_error_v4l2_ctrl_handler_free: 988 v4l2_ctrl_handler_free(ov9734->sd.ctrl_handler); 989 mutex_destroy(&ov9734->mutex); 990 991 return ret; 992 } 993 994 static const struct dev_pm_ops ov9734_pm_ops = { 995 SET_SYSTEM_SLEEP_PM_OPS(ov9734_suspend, ov9734_resume) 996 }; 997 998 static const struct acpi_device_id ov9734_acpi_ids[] = { 999 { "OVTI9734", }, 1000 {} 1001 }; 1002 1003 MODULE_DEVICE_TABLE(acpi, ov9734_acpi_ids); 1004 1005 static struct i2c_driver ov9734_i2c_driver = { 1006 .driver = { 1007 .name = "ov9734", 1008 .pm = &ov9734_pm_ops, 1009 .acpi_match_table = ov9734_acpi_ids, 1010 }, 1011 .probe_new = ov9734_probe, 1012 .remove = ov9734_remove, 1013 }; 1014 1015 module_i2c_driver(ov9734_i2c_driver); 1016 1017 MODULE_AUTHOR("Qiu, Tianshu <tian.shu.qiu@intel.com>"); 1018 MODULE_AUTHOR("Bingbu Cao <bingbu.cao@intel.com>"); 1019 MODULE_DESCRIPTION("OmniVision OV9734 sensor driver"); 1020 MODULE_LICENSE("GPL v2"); 1021