1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Support for OmniVision OV2722 1080p HD camera sensor. 4 * 5 * Copyright (c) 2013 Intel Corporation. All Rights Reserved. 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License version 9 * 2 as published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 */ 17 18 #include <linux/module.h> 19 #include <linux/types.h> 20 #include <linux/kernel.h> 21 #include <linux/mm.h> 22 #include <linux/string.h> 23 #include <linux/errno.h> 24 #include <linux/init.h> 25 #include <linux/kmod.h> 26 #include <linux/device.h> 27 #include <linux/delay.h> 28 #include <linux/slab.h> 29 #include <linux/i2c.h> 30 #include <linux/moduleparam.h> 31 #include <media/v4l2-device.h> 32 #include "../include/linux/atomisp_gmin_platform.h" 33 #include <linux/acpi.h> 34 #include <linux/io.h> 35 36 #include "ov2722.h" 37 38 /* i2c read/write stuff */ 39 static int ov2722_read_reg(struct i2c_client *client, 40 u16 data_length, u16 reg, u16 *val) 41 { 42 int err; 43 struct i2c_msg msg[2]; 44 unsigned char data[6]; 45 46 if (!client->adapter) { 47 dev_err(&client->dev, "%s error, no client->adapter\n", 48 __func__); 49 return -ENODEV; 50 } 51 52 if (data_length != OV2722_8BIT && data_length != OV2722_16BIT 53 && data_length != OV2722_32BIT) { 54 dev_err(&client->dev, "%s error, invalid data length\n", 55 __func__); 56 return -EINVAL; 57 } 58 59 memset(msg, 0, sizeof(msg)); 60 61 msg[0].addr = client->addr; 62 msg[0].flags = 0; 63 msg[0].len = I2C_MSG_LENGTH; 64 msg[0].buf = data; 65 66 /* high byte goes out first */ 67 data[0] = (u8)(reg >> 8); 68 data[1] = (u8)(reg & 0xff); 69 70 msg[1].addr = client->addr; 71 msg[1].len = data_length; 72 msg[1].flags = I2C_M_RD; 73 msg[1].buf = data; 74 75 err = i2c_transfer(client->adapter, msg, 2); 76 if (err != 2) { 77 if (err >= 0) 78 err = -EIO; 79 dev_err(&client->dev, 80 "read from offset 0x%x error %d", reg, err); 81 return err; 82 } 83 84 *val = 0; 85 /* high byte comes first */ 86 if (data_length == OV2722_8BIT) 87 *val = (u8)data[0]; 88 else if (data_length == OV2722_16BIT) 89 *val = be16_to_cpu(*(__be16 *)&data[0]); 90 else 91 *val = be32_to_cpu(*(__be32 *)&data[0]); 92 93 return 0; 94 } 95 96 static int ov2722_i2c_write(struct i2c_client *client, u16 len, u8 *data) 97 { 98 struct i2c_msg msg; 99 const int num_msg = 1; 100 int ret; 101 102 msg.addr = client->addr; 103 msg.flags = 0; 104 msg.len = len; 105 msg.buf = data; 106 ret = i2c_transfer(client->adapter, &msg, 1); 107 108 return ret == num_msg ? 0 : -EIO; 109 } 110 111 static int ov2722_write_reg(struct i2c_client *client, u16 data_length, 112 u16 reg, u16 val) 113 { 114 int ret; 115 unsigned char data[4] = {0}; 116 __be16 *wreg = (__be16 *)data; 117 const u16 len = data_length + sizeof(u16); /* 16-bit address + data */ 118 119 if (data_length != OV2722_8BIT && data_length != OV2722_16BIT) { 120 dev_err(&client->dev, 121 "%s error, invalid data_length\n", __func__); 122 return -EINVAL; 123 } 124 125 /* high byte goes out first */ 126 *wreg = cpu_to_be16(reg); 127 128 if (data_length == OV2722_8BIT) { 129 data[2] = (u8)(val); 130 } else { 131 /* OV2722_16BIT */ 132 __be16 *wdata = (__be16 *)&data[2]; 133 134 *wdata = cpu_to_be16(val); 135 } 136 137 ret = ov2722_i2c_write(client, len, data); 138 if (ret) 139 dev_err(&client->dev, 140 "write error: wrote 0x%x to offset 0x%x error %d", 141 val, reg, ret); 142 143 return ret; 144 } 145 146 /* 147 * ov2722_write_reg_array - Initializes a list of OV2722 registers 148 * @client: i2c driver client structure 149 * @reglist: list of registers to be written 150 * 151 * This function initializes a list of registers. When consecutive addresses 152 * are found in a row on the list, this function creates a buffer and sends 153 * consecutive data in a single i2c_transfer(). 154 * 155 * __ov2722_flush_reg_array, __ov2722_buf_reg_array() and 156 * __ov2722_write_reg_is_consecutive() are internal functions to 157 * ov2722_write_reg_array_fast() and should be not used anywhere else. 158 * 159 */ 160 161 static int __ov2722_flush_reg_array(struct i2c_client *client, 162 struct ov2722_write_ctrl *ctrl) 163 { 164 u16 size; 165 __be16 *data16 = (void *)&ctrl->buffer.addr; 166 167 if (ctrl->index == 0) 168 return 0; 169 170 size = sizeof(u16) + ctrl->index; /* 16-bit address + data */ 171 *data16 = cpu_to_be16(ctrl->buffer.addr); 172 ctrl->index = 0; 173 174 return ov2722_i2c_write(client, size, (u8 *)&ctrl->buffer); 175 } 176 177 static int __ov2722_buf_reg_array(struct i2c_client *client, 178 struct ov2722_write_ctrl *ctrl, 179 const struct ov2722_reg *next) 180 { 181 int size; 182 __be16 *data16; 183 184 switch (next->type) { 185 case OV2722_8BIT: 186 size = 1; 187 ctrl->buffer.data[ctrl->index] = (u8)next->val; 188 break; 189 case OV2722_16BIT: 190 size = 2; 191 data16 = (void *)&ctrl->buffer.data[ctrl->index]; 192 *data16 = cpu_to_be16((u16)next->val); 193 break; 194 default: 195 return -EINVAL; 196 } 197 198 /* When first item is added, we need to store its starting address */ 199 if (ctrl->index == 0) 200 ctrl->buffer.addr = next->reg; 201 202 ctrl->index += size; 203 204 /* 205 * Buffer cannot guarantee free space for u32? Better flush it to avoid 206 * possible lack of memory for next item. 207 */ 208 if (ctrl->index + sizeof(u16) >= OV2722_MAX_WRITE_BUF_SIZE) 209 return __ov2722_flush_reg_array(client, ctrl); 210 211 return 0; 212 } 213 214 static int __ov2722_write_reg_is_consecutive(struct i2c_client *client, 215 struct ov2722_write_ctrl *ctrl, 216 const struct ov2722_reg *next) 217 { 218 if (ctrl->index == 0) 219 return 1; 220 221 return ctrl->buffer.addr + ctrl->index == next->reg; 222 } 223 224 static int ov2722_write_reg_array(struct i2c_client *client, 225 const struct ov2722_reg *reglist) 226 { 227 const struct ov2722_reg *next = reglist; 228 struct ov2722_write_ctrl ctrl; 229 int err; 230 231 ctrl.index = 0; 232 for (; next->type != OV2722_TOK_TERM; next++) { 233 switch (next->type & OV2722_TOK_MASK) { 234 case OV2722_TOK_DELAY: 235 err = __ov2722_flush_reg_array(client, &ctrl); 236 if (err) 237 return err; 238 msleep(next->val); 239 break; 240 default: 241 /* 242 * If next address is not consecutive, data needs to be 243 * flushed before proceed. 244 */ 245 if (!__ov2722_write_reg_is_consecutive(client, &ctrl, 246 next)) { 247 err = __ov2722_flush_reg_array(client, &ctrl); 248 if (err) 249 return err; 250 } 251 err = __ov2722_buf_reg_array(client, &ctrl, next); 252 if (err) { 253 dev_err(&client->dev, "%s: write error, aborted\n", 254 __func__); 255 return err; 256 } 257 break; 258 } 259 } 260 261 return __ov2722_flush_reg_array(client, &ctrl); 262 } 263 264 static int ov2722_g_focal(struct v4l2_subdev *sd, s32 *val) 265 { 266 *val = (OV2722_FOCAL_LENGTH_NUM << 16) | OV2722_FOCAL_LENGTH_DEM; 267 return 0; 268 } 269 270 static int ov2722_g_fnumber(struct v4l2_subdev *sd, s32 *val) 271 { 272 /*const f number for imx*/ 273 *val = (OV2722_F_NUMBER_DEFAULT_NUM << 16) | OV2722_F_NUMBER_DEM; 274 return 0; 275 } 276 277 static int ov2722_g_fnumber_range(struct v4l2_subdev *sd, s32 *val) 278 { 279 *val = (OV2722_F_NUMBER_DEFAULT_NUM << 24) | 280 (OV2722_F_NUMBER_DEM << 16) | 281 (OV2722_F_NUMBER_DEFAULT_NUM << 8) | OV2722_F_NUMBER_DEM; 282 return 0; 283 } 284 285 static int ov2722_get_intg_factor(struct i2c_client *client, 286 struct camera_mipi_info *info, 287 const struct ov2722_resolution *res) 288 { 289 struct v4l2_subdev *sd = i2c_get_clientdata(client); 290 struct ov2722_device *dev = NULL; 291 struct atomisp_sensor_mode_data *buf = &info->data; 292 const unsigned int ext_clk_freq_hz = 19200000; 293 const unsigned int pll_invariant_div = 10; 294 unsigned int pix_clk_freq_hz; 295 u16 pre_pll_clk_div; 296 u16 pll_multiplier; 297 u16 op_pix_clk_div; 298 u16 reg_val; 299 int ret; 300 301 if (!info) 302 return -EINVAL; 303 304 dev = to_ov2722_sensor(sd); 305 306 /* pixel clock calculattion */ 307 ret = ov2722_read_reg(client, OV2722_8BIT, 308 OV2722_SC_CMMN_PLL_CTRL3, &pre_pll_clk_div); 309 if (ret) 310 return ret; 311 312 ret = ov2722_read_reg(client, OV2722_8BIT, 313 OV2722_SC_CMMN_PLL_MULTIPLIER, &pll_multiplier); 314 if (ret) 315 return ret; 316 317 ret = ov2722_read_reg(client, OV2722_8BIT, 318 OV2722_SC_CMMN_PLL_DEBUG_OPT, &op_pix_clk_div); 319 if (ret) 320 return ret; 321 322 pre_pll_clk_div = (pre_pll_clk_div & 0x70) >> 4; 323 if (!pre_pll_clk_div) 324 return -EINVAL; 325 326 pll_multiplier = pll_multiplier & 0x7f; 327 op_pix_clk_div = op_pix_clk_div & 0x03; 328 pix_clk_freq_hz = ext_clk_freq_hz / pre_pll_clk_div * pll_multiplier 329 * op_pix_clk_div / pll_invariant_div; 330 331 dev->vt_pix_clk_freq_mhz = pix_clk_freq_hz; 332 buf->vt_pix_clk_freq_mhz = pix_clk_freq_hz; 333 334 /* get integration time */ 335 buf->coarse_integration_time_min = OV2722_COARSE_INTG_TIME_MIN; 336 buf->coarse_integration_time_max_margin = 337 OV2722_COARSE_INTG_TIME_MAX_MARGIN; 338 339 buf->fine_integration_time_min = OV2722_FINE_INTG_TIME_MIN; 340 buf->fine_integration_time_max_margin = 341 OV2722_FINE_INTG_TIME_MAX_MARGIN; 342 343 buf->fine_integration_time_def = OV2722_FINE_INTG_TIME_MIN; 344 buf->frame_length_lines = res->lines_per_frame; 345 buf->line_length_pck = res->pixels_per_line; 346 buf->read_mode = res->bin_mode; 347 348 /* get the cropping and output resolution to ISP for this mode. */ 349 ret = ov2722_read_reg(client, OV2722_16BIT, 350 OV2722_H_CROP_START_H, ®_val); 351 if (ret) 352 return ret; 353 buf->crop_horizontal_start = reg_val; 354 355 ret = ov2722_read_reg(client, OV2722_16BIT, 356 OV2722_V_CROP_START_H, ®_val); 357 if (ret) 358 return ret; 359 buf->crop_vertical_start = reg_val; 360 361 ret = ov2722_read_reg(client, OV2722_16BIT, 362 OV2722_H_CROP_END_H, ®_val); 363 if (ret) 364 return ret; 365 buf->crop_horizontal_end = reg_val; 366 367 ret = ov2722_read_reg(client, OV2722_16BIT, 368 OV2722_V_CROP_END_H, ®_val); 369 if (ret) 370 return ret; 371 buf->crop_vertical_end = reg_val; 372 373 ret = ov2722_read_reg(client, OV2722_16BIT, 374 OV2722_H_OUTSIZE_H, ®_val); 375 if (ret) 376 return ret; 377 buf->output_width = reg_val; 378 379 ret = ov2722_read_reg(client, OV2722_16BIT, 380 OV2722_V_OUTSIZE_H, ®_val); 381 if (ret) 382 return ret; 383 buf->output_height = reg_val; 384 385 buf->binning_factor_x = res->bin_factor_x ? 386 res->bin_factor_x : 1; 387 buf->binning_factor_y = res->bin_factor_y ? 388 res->bin_factor_y : 1; 389 return 0; 390 } 391 392 static long __ov2722_set_exposure(struct v4l2_subdev *sd, int coarse_itg, 393 int gain, int digitgain) 394 395 { 396 struct i2c_client *client = v4l2_get_subdevdata(sd); 397 struct ov2722_device *dev = to_ov2722_sensor(sd); 398 u16 hts, vts; 399 int ret; 400 401 dev_dbg(&client->dev, "set_exposure without group hold\n"); 402 403 /* clear VTS_DIFF on manual mode */ 404 ret = ov2722_write_reg(client, OV2722_16BIT, OV2722_VTS_DIFF_H, 0); 405 if (ret) 406 return ret; 407 408 hts = dev->pixels_per_line; 409 vts = dev->lines_per_frame; 410 411 if ((coarse_itg + OV2722_COARSE_INTG_TIME_MAX_MARGIN) > vts) 412 vts = coarse_itg + OV2722_COARSE_INTG_TIME_MAX_MARGIN; 413 414 coarse_itg <<= 4; 415 digitgain <<= 2; 416 417 ret = ov2722_write_reg(client, OV2722_16BIT, 418 OV2722_VTS_H, vts); 419 if (ret) 420 return ret; 421 422 ret = ov2722_write_reg(client, OV2722_16BIT, 423 OV2722_HTS_H, hts); 424 if (ret) 425 return ret; 426 427 /* set exposure */ 428 ret = ov2722_write_reg(client, OV2722_8BIT, 429 OV2722_AEC_PK_EXPO_L, 430 coarse_itg & 0xff); 431 if (ret) 432 return ret; 433 434 ret = ov2722_write_reg(client, OV2722_16BIT, 435 OV2722_AEC_PK_EXPO_H, 436 (coarse_itg >> 8) & 0xfff); 437 if (ret) 438 return ret; 439 440 /* set analog gain */ 441 ret = ov2722_write_reg(client, OV2722_16BIT, 442 OV2722_AGC_ADJ_H, gain); 443 if (ret) 444 return ret; 445 446 /* set digital gain */ 447 ret = ov2722_write_reg(client, OV2722_16BIT, 448 OV2722_MWB_GAIN_R_H, digitgain); 449 if (ret) 450 return ret; 451 452 ret = ov2722_write_reg(client, OV2722_16BIT, 453 OV2722_MWB_GAIN_G_H, digitgain); 454 if (ret) 455 return ret; 456 457 ret = ov2722_write_reg(client, OV2722_16BIT, 458 OV2722_MWB_GAIN_B_H, digitgain); 459 460 return ret; 461 } 462 463 static int ov2722_set_exposure(struct v4l2_subdev *sd, int exposure, 464 int gain, int digitgain) 465 { 466 struct ov2722_device *dev = to_ov2722_sensor(sd); 467 int ret; 468 469 mutex_lock(&dev->input_lock); 470 ret = __ov2722_set_exposure(sd, exposure, gain, digitgain); 471 mutex_unlock(&dev->input_lock); 472 473 return ret; 474 } 475 476 static long ov2722_s_exposure(struct v4l2_subdev *sd, 477 struct atomisp_exposure *exposure) 478 { 479 int exp = exposure->integration_time[0]; 480 int gain = exposure->gain[0]; 481 int digitgain = exposure->gain[1]; 482 483 /* we should not accept the invalid value below. */ 484 if (gain == 0) { 485 struct i2c_client *client = v4l2_get_subdevdata(sd); 486 487 v4l2_err(client, "%s: invalid value\n", __func__); 488 return -EINVAL; 489 } 490 491 return ov2722_set_exposure(sd, exp, gain, digitgain); 492 } 493 494 static long ov2722_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg) 495 { 496 switch (cmd) { 497 case ATOMISP_IOC_S_EXPOSURE: 498 return ov2722_s_exposure(sd, arg); 499 default: 500 return -EINVAL; 501 } 502 return 0; 503 } 504 505 /* This returns the exposure time being used. This should only be used 506 * for filling in EXIF data, not for actual image processing. 507 */ 508 static int ov2722_q_exposure(struct v4l2_subdev *sd, s32 *value) 509 { 510 struct i2c_client *client = v4l2_get_subdevdata(sd); 511 u16 reg_v, reg_v2; 512 int ret; 513 514 /* get exposure */ 515 ret = ov2722_read_reg(client, OV2722_8BIT, 516 OV2722_AEC_PK_EXPO_L, 517 ®_v); 518 if (ret) 519 goto err; 520 521 ret = ov2722_read_reg(client, OV2722_8BIT, 522 OV2722_AEC_PK_EXPO_M, 523 ®_v2); 524 if (ret) 525 goto err; 526 527 reg_v += reg_v2 << 8; 528 ret = ov2722_read_reg(client, OV2722_8BIT, 529 OV2722_AEC_PK_EXPO_H, 530 ®_v2); 531 if (ret) 532 goto err; 533 534 *value = reg_v + (((u32)reg_v2 << 16)); 535 err: 536 return ret; 537 } 538 539 static int ov2722_g_volatile_ctrl(struct v4l2_ctrl *ctrl) 540 { 541 struct ov2722_device *dev = 542 container_of(ctrl->handler, struct ov2722_device, ctrl_handler); 543 int ret = 0; 544 unsigned int val; 545 546 switch (ctrl->id) { 547 case V4L2_CID_EXPOSURE_ABSOLUTE: 548 ret = ov2722_q_exposure(&dev->sd, &ctrl->val); 549 break; 550 case V4L2_CID_FOCAL_ABSOLUTE: 551 ret = ov2722_g_focal(&dev->sd, &ctrl->val); 552 break; 553 case V4L2_CID_FNUMBER_ABSOLUTE: 554 ret = ov2722_g_fnumber(&dev->sd, &ctrl->val); 555 break; 556 case V4L2_CID_FNUMBER_RANGE: 557 ret = ov2722_g_fnumber_range(&dev->sd, &ctrl->val); 558 break; 559 case V4L2_CID_LINK_FREQ: 560 val = ov2722_res[dev->fmt_idx].mipi_freq; 561 if (val == 0) 562 return -EINVAL; 563 564 ctrl->val = val * 1000; /* To Hz */ 565 break; 566 default: 567 ret = -EINVAL; 568 } 569 570 return ret; 571 } 572 573 static const struct v4l2_ctrl_ops ctrl_ops = { 574 .g_volatile_ctrl = ov2722_g_volatile_ctrl 575 }; 576 577 static const struct v4l2_ctrl_config ov2722_controls[] = { 578 { 579 .ops = &ctrl_ops, 580 .id = V4L2_CID_EXPOSURE_ABSOLUTE, 581 .type = V4L2_CTRL_TYPE_INTEGER, 582 .name = "exposure", 583 .min = 0x0, 584 .max = 0xffff, 585 .step = 0x01, 586 .def = 0x00, 587 .flags = 0, 588 }, 589 { 590 .ops = &ctrl_ops, 591 .id = V4L2_CID_FOCAL_ABSOLUTE, 592 .type = V4L2_CTRL_TYPE_INTEGER, 593 .name = "focal length", 594 .min = OV2722_FOCAL_LENGTH_DEFAULT, 595 .max = OV2722_FOCAL_LENGTH_DEFAULT, 596 .step = 0x01, 597 .def = OV2722_FOCAL_LENGTH_DEFAULT, 598 .flags = 0, 599 }, 600 { 601 .ops = &ctrl_ops, 602 .id = V4L2_CID_FNUMBER_ABSOLUTE, 603 .type = V4L2_CTRL_TYPE_INTEGER, 604 .name = "f-number", 605 .min = OV2722_F_NUMBER_DEFAULT, 606 .max = OV2722_F_NUMBER_DEFAULT, 607 .step = 0x01, 608 .def = OV2722_F_NUMBER_DEFAULT, 609 .flags = 0, 610 }, 611 { 612 .ops = &ctrl_ops, 613 .id = V4L2_CID_FNUMBER_RANGE, 614 .type = V4L2_CTRL_TYPE_INTEGER, 615 .name = "f-number range", 616 .min = OV2722_F_NUMBER_RANGE, 617 .max = OV2722_F_NUMBER_RANGE, 618 .step = 0x01, 619 .def = OV2722_F_NUMBER_RANGE, 620 .flags = 0, 621 }, 622 { 623 .ops = &ctrl_ops, 624 .id = V4L2_CID_LINK_FREQ, 625 .name = "Link Frequency", 626 .type = V4L2_CTRL_TYPE_INTEGER, 627 .min = 1, 628 .max = 1500000 * 1000, 629 .step = 1, 630 .def = 1, 631 .flags = V4L2_CTRL_FLAG_VOLATILE | V4L2_CTRL_FLAG_READ_ONLY, 632 }, 633 }; 634 635 static int ov2722_init(struct v4l2_subdev *sd) 636 { 637 struct ov2722_device *dev = to_ov2722_sensor(sd); 638 639 mutex_lock(&dev->input_lock); 640 641 /* restore settings */ 642 ov2722_res = ov2722_res_preview; 643 N_RES = N_RES_PREVIEW; 644 645 mutex_unlock(&dev->input_lock); 646 647 return 0; 648 } 649 650 static int power_ctrl(struct v4l2_subdev *sd, bool flag) 651 { 652 int ret = -1; 653 struct ov2722_device *dev = to_ov2722_sensor(sd); 654 655 if (!dev || !dev->platform_data) 656 return -ENODEV; 657 658 if (flag) { 659 ret = dev->platform_data->v1p8_ctrl(sd, 1); 660 if (ret == 0) { 661 ret = dev->platform_data->v2p8_ctrl(sd, 1); 662 if (ret) 663 dev->platform_data->v1p8_ctrl(sd, 0); 664 } 665 } else { 666 ret = dev->platform_data->v1p8_ctrl(sd, 0); 667 ret |= dev->platform_data->v2p8_ctrl(sd, 0); 668 } 669 670 return ret; 671 } 672 673 static int gpio_ctrl(struct v4l2_subdev *sd, bool flag) 674 { 675 struct ov2722_device *dev = to_ov2722_sensor(sd); 676 int ret = -1; 677 678 if (!dev || !dev->platform_data) 679 return -ENODEV; 680 681 /* Note: the GPIO order is asymmetric: always RESET# 682 * before PWDN# when turning it on or off. 683 */ 684 ret = dev->platform_data->gpio0_ctrl(sd, flag); 685 /* 686 *ov2722 PWDN# active high when pull down,opposite to the convention 687 */ 688 ret |= dev->platform_data->gpio1_ctrl(sd, !flag); 689 return ret; 690 } 691 692 static int power_up(struct v4l2_subdev *sd) 693 { 694 struct ov2722_device *dev = to_ov2722_sensor(sd); 695 struct i2c_client *client = v4l2_get_subdevdata(sd); 696 int ret; 697 698 if (!dev->platform_data) { 699 dev_err(&client->dev, 700 "no camera_sensor_platform_data"); 701 return -ENODEV; 702 } 703 704 /* power control */ 705 ret = power_ctrl(sd, 1); 706 if (ret) 707 goto fail_power; 708 709 /* according to DS, at least 5ms is needed between DOVDD and PWDN */ 710 usleep_range(5000, 6000); 711 712 /* gpio ctrl */ 713 ret = gpio_ctrl(sd, 1); 714 if (ret) { 715 ret = gpio_ctrl(sd, 0); 716 if (ret) 717 goto fail_power; 718 } 719 720 /* flis clock control */ 721 ret = dev->platform_data->flisclk_ctrl(sd, 1); 722 if (ret) 723 goto fail_clk; 724 725 /* according to DS, 20ms is needed between PWDN and i2c access */ 726 msleep(20); 727 728 return 0; 729 730 fail_clk: 731 gpio_ctrl(sd, 0); 732 fail_power: 733 power_ctrl(sd, 0); 734 dev_err(&client->dev, "sensor power-up failed\n"); 735 736 return ret; 737 } 738 739 static int power_down(struct v4l2_subdev *sd) 740 { 741 struct ov2722_device *dev = to_ov2722_sensor(sd); 742 struct i2c_client *client = v4l2_get_subdevdata(sd); 743 int ret = 0; 744 745 if (!dev->platform_data) { 746 dev_err(&client->dev, 747 "no camera_sensor_platform_data"); 748 return -ENODEV; 749 } 750 751 ret = dev->platform_data->flisclk_ctrl(sd, 0); 752 if (ret) 753 dev_err(&client->dev, "flisclk failed\n"); 754 755 /* gpio ctrl */ 756 ret = gpio_ctrl(sd, 0); 757 if (ret) { 758 ret = gpio_ctrl(sd, 0); 759 if (ret) 760 dev_err(&client->dev, "gpio failed 2\n"); 761 } 762 763 /* power control */ 764 ret = power_ctrl(sd, 0); 765 if (ret) 766 dev_err(&client->dev, "vprog failed.\n"); 767 768 return ret; 769 } 770 771 static int ov2722_s_power(struct v4l2_subdev *sd, int on) 772 { 773 int ret; 774 775 if (on == 0) 776 return power_down(sd); 777 else { 778 ret = power_up(sd); 779 if (!ret) 780 return ov2722_init(sd); 781 } 782 return ret; 783 } 784 785 /* 786 * distance - calculate the distance 787 * @res: resolution 788 * @w: width 789 * @h: height 790 * 791 * Get the gap between resolution and w/h. 792 * res->width/height smaller than w/h wouldn't be considered. 793 * Returns the value of gap or -1 if fail. 794 */ 795 #define LARGEST_ALLOWED_RATIO_MISMATCH 800 796 static int distance(struct ov2722_resolution *res, u32 w, u32 h) 797 { 798 unsigned int w_ratio = (res->width << 13) / w; 799 unsigned int h_ratio; 800 int match; 801 802 if (h == 0) 803 return -1; 804 h_ratio = (res->height << 13) / h; 805 if (h_ratio == 0) 806 return -1; 807 match = abs(((w_ratio << 13) / h_ratio) - 8192); 808 809 if ((w_ratio < 8192) || (h_ratio < 8192) || 810 (match > LARGEST_ALLOWED_RATIO_MISMATCH)) 811 return -1; 812 813 return w_ratio + h_ratio; 814 } 815 816 /* Return the nearest higher resolution index */ 817 static int nearest_resolution_index(int w, int h) 818 { 819 int i; 820 int idx = -1; 821 int dist; 822 int min_dist = INT_MAX; 823 struct ov2722_resolution *tmp_res = NULL; 824 825 for (i = 0; i < N_RES; i++) { 826 tmp_res = &ov2722_res[i]; 827 dist = distance(tmp_res, w, h); 828 if (dist == -1) 829 continue; 830 if (dist < min_dist) { 831 min_dist = dist; 832 idx = i; 833 } 834 } 835 836 return idx; 837 } 838 839 static int get_resolution_index(int w, int h) 840 { 841 int i; 842 843 for (i = 0; i < N_RES; i++) { 844 if (w != ov2722_res[i].width) 845 continue; 846 if (h != ov2722_res[i].height) 847 continue; 848 849 return i; 850 } 851 852 return -1; 853 } 854 855 /* TODO: remove it. */ 856 static int startup(struct v4l2_subdev *sd) 857 { 858 struct ov2722_device *dev = to_ov2722_sensor(sd); 859 struct i2c_client *client = v4l2_get_subdevdata(sd); 860 int ret = 0; 861 862 ret = ov2722_write_reg(client, OV2722_8BIT, 863 OV2722_SW_RESET, 0x01); 864 if (ret) { 865 dev_err(&client->dev, "ov2722 reset err.\n"); 866 return ret; 867 } 868 869 ret = ov2722_write_reg_array(client, ov2722_res[dev->fmt_idx].regs); 870 if (ret) { 871 dev_err(&client->dev, "ov2722 write register err.\n"); 872 return ret; 873 } 874 875 return ret; 876 } 877 878 static int ov2722_set_fmt(struct v4l2_subdev *sd, 879 struct v4l2_subdev_pad_config *cfg, 880 struct v4l2_subdev_format *format) 881 { 882 struct v4l2_mbus_framefmt *fmt = &format->format; 883 struct ov2722_device *dev = to_ov2722_sensor(sd); 884 struct i2c_client *client = v4l2_get_subdevdata(sd); 885 struct camera_mipi_info *ov2722_info = NULL; 886 int ret = 0; 887 int idx; 888 889 if (format->pad) 890 return -EINVAL; 891 if (!fmt) 892 return -EINVAL; 893 ov2722_info = v4l2_get_subdev_hostdata(sd); 894 if (!ov2722_info) 895 return -EINVAL; 896 897 mutex_lock(&dev->input_lock); 898 idx = nearest_resolution_index(fmt->width, fmt->height); 899 if (idx == -1) { 900 /* return the largest resolution */ 901 fmt->width = ov2722_res[N_RES - 1].width; 902 fmt->height = ov2722_res[N_RES - 1].height; 903 } else { 904 fmt->width = ov2722_res[idx].width; 905 fmt->height = ov2722_res[idx].height; 906 } 907 fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10; 908 if (format->which == V4L2_SUBDEV_FORMAT_TRY) { 909 cfg->try_fmt = *fmt; 910 mutex_unlock(&dev->input_lock); 911 return 0; 912 } 913 914 dev->fmt_idx = get_resolution_index(fmt->width, fmt->height); 915 if (dev->fmt_idx == -1) { 916 dev_err(&client->dev, "get resolution fail\n"); 917 mutex_unlock(&dev->input_lock); 918 return -EINVAL; 919 } 920 921 dev->pixels_per_line = ov2722_res[dev->fmt_idx].pixels_per_line; 922 dev->lines_per_frame = ov2722_res[dev->fmt_idx].lines_per_frame; 923 924 ret = startup(sd); 925 if (ret) { 926 int i = 0; 927 928 dev_err(&client->dev, "ov2722 startup err, retry to power up\n"); 929 for (i = 0; i < OV2722_POWER_UP_RETRY_NUM; i++) { 930 dev_err(&client->dev, 931 "ov2722 retry to power up %d/%d times, result: ", 932 i + 1, OV2722_POWER_UP_RETRY_NUM); 933 power_down(sd); 934 ret = power_up(sd); 935 if (ret) { 936 dev_err(&client->dev, "power up failed, continue\n"); 937 continue; 938 } 939 ret = startup(sd); 940 if (ret) { 941 dev_err(&client->dev, " startup FAILED!\n"); 942 } else { 943 dev_err(&client->dev, " startup SUCCESS!\n"); 944 break; 945 } 946 } 947 if (ret) { 948 dev_err(&client->dev, "ov2722 startup err\n"); 949 goto err; 950 } 951 } 952 953 ret = ov2722_get_intg_factor(client, ov2722_info, 954 &ov2722_res[dev->fmt_idx]); 955 if (ret) 956 dev_err(&client->dev, "failed to get integration_factor\n"); 957 958 err: 959 mutex_unlock(&dev->input_lock); 960 return ret; 961 } 962 963 static int ov2722_get_fmt(struct v4l2_subdev *sd, 964 struct v4l2_subdev_pad_config *cfg, 965 struct v4l2_subdev_format *format) 966 { 967 struct v4l2_mbus_framefmt *fmt = &format->format; 968 struct ov2722_device *dev = to_ov2722_sensor(sd); 969 970 if (format->pad) 971 return -EINVAL; 972 if (!fmt) 973 return -EINVAL; 974 975 fmt->width = ov2722_res[dev->fmt_idx].width; 976 fmt->height = ov2722_res[dev->fmt_idx].height; 977 fmt->code = MEDIA_BUS_FMT_SBGGR10_1X10; 978 979 return 0; 980 } 981 982 static int ov2722_detect(struct i2c_client *client) 983 { 984 struct i2c_adapter *adapter = client->adapter; 985 u16 high, low; 986 int ret; 987 u16 id; 988 u8 revision; 989 990 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) 991 return -ENODEV; 992 993 ret = ov2722_read_reg(client, OV2722_8BIT, 994 OV2722_SC_CMMN_CHIP_ID_H, &high); 995 if (ret) { 996 dev_err(&client->dev, "sensor_id_high = 0x%x\n", high); 997 return -ENODEV; 998 } 999 ret = ov2722_read_reg(client, OV2722_8BIT, 1000 OV2722_SC_CMMN_CHIP_ID_L, &low); 1001 id = (high << 8) | low; 1002 1003 if ((id != OV2722_ID) && (id != OV2720_ID)) { 1004 dev_err(&client->dev, "sensor ID error\n"); 1005 return -ENODEV; 1006 } 1007 1008 ret = ov2722_read_reg(client, OV2722_8BIT, 1009 OV2722_SC_CMMN_SUB_ID, &high); 1010 revision = (u8)high & 0x0f; 1011 1012 dev_dbg(&client->dev, "sensor_revision = 0x%x\n", revision); 1013 dev_dbg(&client->dev, "detect ov2722 success\n"); 1014 return 0; 1015 } 1016 1017 static int ov2722_s_stream(struct v4l2_subdev *sd, int enable) 1018 { 1019 struct ov2722_device *dev = to_ov2722_sensor(sd); 1020 struct i2c_client *client = v4l2_get_subdevdata(sd); 1021 int ret; 1022 1023 mutex_lock(&dev->input_lock); 1024 1025 ret = ov2722_write_reg(client, OV2722_8BIT, OV2722_SW_STREAM, 1026 enable ? OV2722_START_STREAMING : 1027 OV2722_STOP_STREAMING); 1028 1029 mutex_unlock(&dev->input_lock); 1030 return ret; 1031 } 1032 1033 static int ov2722_s_config(struct v4l2_subdev *sd, 1034 int irq, void *platform_data) 1035 { 1036 struct ov2722_device *dev = to_ov2722_sensor(sd); 1037 struct i2c_client *client = v4l2_get_subdevdata(sd); 1038 int ret = 0; 1039 1040 if (!platform_data) 1041 return -ENODEV; 1042 1043 dev->platform_data = 1044 (struct camera_sensor_platform_data *)platform_data; 1045 1046 mutex_lock(&dev->input_lock); 1047 1048 /* power off the module, then power on it in future 1049 * as first power on by board may not fulfill the 1050 * power on sequqence needed by the module 1051 */ 1052 ret = power_down(sd); 1053 if (ret) { 1054 dev_err(&client->dev, "ov2722 power-off err.\n"); 1055 goto fail_power_off; 1056 } 1057 1058 ret = power_up(sd); 1059 if (ret) { 1060 dev_err(&client->dev, "ov2722 power-up err.\n"); 1061 goto fail_power_on; 1062 } 1063 1064 ret = dev->platform_data->csi_cfg(sd, 1); 1065 if (ret) 1066 goto fail_csi_cfg; 1067 1068 /* config & detect sensor */ 1069 ret = ov2722_detect(client); 1070 if (ret) { 1071 dev_err(&client->dev, "ov2722_detect err s_config.\n"); 1072 goto fail_csi_cfg; 1073 } 1074 1075 /* turn off sensor, after probed */ 1076 ret = power_down(sd); 1077 if (ret) { 1078 dev_err(&client->dev, "ov2722 power-off err.\n"); 1079 goto fail_csi_cfg; 1080 } 1081 mutex_unlock(&dev->input_lock); 1082 1083 return 0; 1084 1085 fail_csi_cfg: 1086 dev->platform_data->csi_cfg(sd, 0); 1087 fail_power_on: 1088 power_down(sd); 1089 dev_err(&client->dev, "sensor power-gating failed\n"); 1090 fail_power_off: 1091 mutex_unlock(&dev->input_lock); 1092 return ret; 1093 } 1094 1095 static int ov2722_g_frame_interval(struct v4l2_subdev *sd, 1096 struct v4l2_subdev_frame_interval *interval) 1097 { 1098 struct ov2722_device *dev = to_ov2722_sensor(sd); 1099 1100 interval->interval.numerator = 1; 1101 interval->interval.denominator = ov2722_res[dev->fmt_idx].fps; 1102 1103 return 0; 1104 } 1105 1106 static int ov2722_enum_mbus_code(struct v4l2_subdev *sd, 1107 struct v4l2_subdev_pad_config *cfg, 1108 struct v4l2_subdev_mbus_code_enum *code) 1109 { 1110 if (code->index >= MAX_FMTS) 1111 return -EINVAL; 1112 1113 code->code = MEDIA_BUS_FMT_SBGGR10_1X10; 1114 return 0; 1115 } 1116 1117 static int ov2722_enum_frame_size(struct v4l2_subdev *sd, 1118 struct v4l2_subdev_pad_config *cfg, 1119 struct v4l2_subdev_frame_size_enum *fse) 1120 { 1121 int index = fse->index; 1122 1123 if (index >= N_RES) 1124 return -EINVAL; 1125 1126 fse->min_width = ov2722_res[index].width; 1127 fse->min_height = ov2722_res[index].height; 1128 fse->max_width = ov2722_res[index].width; 1129 fse->max_height = ov2722_res[index].height; 1130 1131 return 0; 1132 } 1133 1134 static int ov2722_g_skip_frames(struct v4l2_subdev *sd, u32 *frames) 1135 { 1136 struct ov2722_device *dev = to_ov2722_sensor(sd); 1137 1138 mutex_lock(&dev->input_lock); 1139 *frames = ov2722_res[dev->fmt_idx].skip_frames; 1140 mutex_unlock(&dev->input_lock); 1141 1142 return 0; 1143 } 1144 1145 static const struct v4l2_subdev_sensor_ops ov2722_sensor_ops = { 1146 .g_skip_frames = ov2722_g_skip_frames, 1147 }; 1148 1149 static const struct v4l2_subdev_video_ops ov2722_video_ops = { 1150 .s_stream = ov2722_s_stream, 1151 .g_frame_interval = ov2722_g_frame_interval, 1152 }; 1153 1154 static const struct v4l2_subdev_core_ops ov2722_core_ops = { 1155 .s_power = ov2722_s_power, 1156 .ioctl = ov2722_ioctl, 1157 }; 1158 1159 static const struct v4l2_subdev_pad_ops ov2722_pad_ops = { 1160 .enum_mbus_code = ov2722_enum_mbus_code, 1161 .enum_frame_size = ov2722_enum_frame_size, 1162 .get_fmt = ov2722_get_fmt, 1163 .set_fmt = ov2722_set_fmt, 1164 }; 1165 1166 static const struct v4l2_subdev_ops ov2722_ops = { 1167 .core = &ov2722_core_ops, 1168 .video = &ov2722_video_ops, 1169 .pad = &ov2722_pad_ops, 1170 .sensor = &ov2722_sensor_ops, 1171 }; 1172 1173 static int ov2722_remove(struct i2c_client *client) 1174 { 1175 struct v4l2_subdev *sd = i2c_get_clientdata(client); 1176 struct ov2722_device *dev = to_ov2722_sensor(sd); 1177 1178 dev->platform_data->csi_cfg(sd, 0); 1179 v4l2_ctrl_handler_free(&dev->ctrl_handler); 1180 v4l2_device_unregister_subdev(sd); 1181 1182 atomisp_gmin_remove_subdev(sd); 1183 1184 media_entity_cleanup(&dev->sd.entity); 1185 kfree(dev); 1186 1187 return 0; 1188 } 1189 1190 static int __ov2722_init_ctrl_handler(struct ov2722_device *dev) 1191 { 1192 struct v4l2_ctrl_handler *hdl; 1193 unsigned int i; 1194 1195 hdl = &dev->ctrl_handler; 1196 v4l2_ctrl_handler_init(&dev->ctrl_handler, ARRAY_SIZE(ov2722_controls)); 1197 for (i = 0; i < ARRAY_SIZE(ov2722_controls); i++) 1198 v4l2_ctrl_new_custom(&dev->ctrl_handler, &ov2722_controls[i], 1199 NULL); 1200 1201 dev->link_freq = v4l2_ctrl_find(&dev->ctrl_handler, V4L2_CID_LINK_FREQ); 1202 1203 if (dev->ctrl_handler.error || !dev->link_freq) 1204 return dev->ctrl_handler.error; 1205 1206 dev->sd.ctrl_handler = hdl; 1207 1208 return 0; 1209 } 1210 1211 static int ov2722_probe(struct i2c_client *client) 1212 { 1213 struct ov2722_device *dev; 1214 void *ovpdev; 1215 int ret; 1216 1217 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1218 if (!dev) 1219 return -ENOMEM; 1220 1221 mutex_init(&dev->input_lock); 1222 1223 dev->fmt_idx = 0; 1224 v4l2_i2c_subdev_init(&dev->sd, client, &ov2722_ops); 1225 1226 ovpdev = gmin_camera_platform_data(&dev->sd, 1227 ATOMISP_INPUT_FORMAT_RAW_10, 1228 atomisp_bayer_order_grbg); 1229 1230 ret = ov2722_s_config(&dev->sd, client->irq, ovpdev); 1231 if (ret) 1232 goto out_free; 1233 1234 ret = __ov2722_init_ctrl_handler(dev); 1235 if (ret) 1236 goto out_ctrl_handler_free; 1237 1238 dev->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1239 dev->pad.flags = MEDIA_PAD_FL_SOURCE; 1240 dev->format.code = MEDIA_BUS_FMT_SBGGR10_1X10; 1241 dev->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; 1242 1243 ret = media_entity_pads_init(&dev->sd.entity, 1, &dev->pad); 1244 if (ret) 1245 ov2722_remove(client); 1246 1247 return atomisp_register_i2c_module(&dev->sd, ovpdev, RAW_CAMERA); 1248 1249 out_ctrl_handler_free: 1250 v4l2_ctrl_handler_free(&dev->ctrl_handler); 1251 1252 out_free: 1253 v4l2_device_unregister_subdev(&dev->sd); 1254 kfree(dev); 1255 return ret; 1256 } 1257 1258 static const struct acpi_device_id ov2722_acpi_match[] = { 1259 { "INT33FB" }, 1260 {}, 1261 }; 1262 MODULE_DEVICE_TABLE(acpi, ov2722_acpi_match); 1263 1264 static struct i2c_driver ov2722_driver = { 1265 .driver = { 1266 .name = "ov2722", 1267 .acpi_match_table = ov2722_acpi_match, 1268 }, 1269 .probe_new = ov2722_probe, 1270 .remove = ov2722_remove, 1271 }; 1272 module_i2c_driver(ov2722_driver); 1273 1274 MODULE_AUTHOR("Wei Liu <wei.liu@intel.com>"); 1275 MODULE_DESCRIPTION("A low-level driver for OmniVision 2722 sensors"); 1276 MODULE_LICENSE("GPL"); 1277