drivers/staging/media/atomisp/i2c/ov5693/atomisp-ov5693.c

   1 /*
   2  * Support for OmniVision OV5693 1080p HD camera sensor.
   3  *
   4  * Copyright (c) 2013 Intel Corporation. All Rights Reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License version
   8  * 2 as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  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 <linux/io.h>
  33 #include <linux/acpi.h>
  34 #include "../../include/linux/atomisp_gmin_platform.h"
  35
  36 #include "ov5693.h"
  37 #include "ad5823.h"
  38
  39 #define __cci_delay(t) \
  40         do { \
  41                 if ((t) < 10) { \
  42                         usleep_range((t) * 1000, ((t) + 1) * 1000); \
  43                 } else { \
  44                         msleep((t)); \
  45                 } \
  46         } while (0)
  47
  48 /* Value 30ms reached through experimentation on byt ecs.
  49  * The DS specifies a much lower value but when using a smaller value
  50  * the I2C bus sometimes locks up permanently when starting the camera.
  51  * This issue could not be reproduced on cht, so we can reduce the
  52  * delay value to a lower value when insmod.
  53  */
  54 static uint up_delay = 30;
  55 module_param(up_delay, uint, 0644);
  56 MODULE_PARM_DESC(up_delay,
  57                  "Delay prior to the first CCI transaction for ov5693");
  58
  59 static int vcm_ad_i2c_wr8(struct i2c_client *client, u8 reg, u8 val)
  60 {
  61         int err;
  62         struct i2c_msg msg;
  63         u8 buf[2];
  64
  65         buf[0] = reg;
  66         buf[1] = val;
  67
  68         msg.addr = VCM_ADDR;
  69         msg.flags = 0;
  70         msg.len = 2;
  71         msg.buf = &buf[0];
  72
  73         err = i2c_transfer(client->adapter, &msg, 1);
  74         if (err != 1) {
  75                 dev_err(&client->dev, "%s: vcm i2c fail, err code = %d\n",
  76                         __func__, err);
  77                 return -EIO;
  78         }
  79         return 0;
  80 }
  81
  82 static int ad5823_i2c_write(struct i2c_client *client, u8 reg, u8 val)
  83 {
  84         struct i2c_msg msg;
  85         u8 buf[2];
  86
  87         buf[0] = reg;
  88         buf[1] = val;
  89         msg.addr = AD5823_VCM_ADDR;
  90         msg.flags = 0;
  91         msg.len = 0x02;
  92         msg.buf = &buf[0];
  93
  94         if (i2c_transfer(client->adapter, &msg, 1) != 1)
  95                 return -EIO;
  96         return 0;
  97 }
  98
  99 static int ad5823_i2c_read(struct i2c_client *client, u8 reg, u8 *val)
 100 {
 101         struct i2c_msg msg[2];
 102         u8 buf[2];
 103
 104         buf[0] = reg;
 105         buf[1] = 0;
 106
 107         msg[0].addr = AD5823_VCM_ADDR;
 108         msg[0].flags = 0;
 109         msg[0].len = 0x01;
 110         msg[0].buf = &buf[0];
 111
 112         msg[1].addr = 0x0c;
 113         msg[1].flags = I2C_M_RD;
 114         msg[1].len = 0x01;
 115         msg[1].buf = &buf[1];
 116         *val = 0;
 117         if (i2c_transfer(client->adapter, msg, 2) != 2)
 118                 return -EIO;
 119         *val = buf[1];
 120         return 0;
 121 }
 122
 123 static const u32 ov5693_embedded_effective_size = 28;
 124
 125 /* i2c read/write stuff */
 126 static int ov5693_read_reg(struct i2c_client *client,
 127                            u16 data_length, u16 reg, u16 *val)
 128 {
 129         int err;
 130         struct i2c_msg msg[2];
 131         unsigned char data[6];
 132
 133         if (!client->adapter) {
 134                 dev_err(&client->dev, "%s error, no client->adapter\n",
 135                         __func__);
 136                 return -ENODEV;
 137         }
 138
 139         if (data_length != OV5693_8BIT && data_length != OV5693_16BIT
 140             && data_length != OV5693_32BIT) {
 141                 dev_err(&client->dev, "%s error, invalid data length\n",
 142                         __func__);
 143                 return -EINVAL;
 144         }
 145
 146         memset(msg, 0, sizeof(msg));
 147
 148         msg[0].addr = client->addr;
 149         msg[0].flags = 0;
 150         msg[0].len = I2C_MSG_LENGTH;
 151         msg[0].buf = data;
 152
 153         /* high byte goes out first */
 154         data[0] = (u8)(reg >> 8);
 155         data[1] = (u8)(reg & 0xff);
 156
 157         msg[1].addr = client->addr;
 158         msg[1].len = data_length;
 159         msg[1].flags = I2C_M_RD;
 160         msg[1].buf = data;
 161
 162         err = i2c_transfer(client->adapter, msg, 2);
 163         if (err != 2) {
 164                 if (err >= 0)
 165                         err = -EIO;
 166                 dev_err(&client->dev,
 167                         "read from offset 0x%x error %d", reg, err);
 168                 return err;
 169         }
 170
 171         *val = 0;
 172         /* high byte comes first */
 173         if (data_length == OV5693_8BIT)
 174                 *val = (u8)data[0];
 175         else if (data_length == OV5693_16BIT)
 176                 *val = be16_to_cpu(*(__be16 *)&data[0]);
 177         else
 178                 *val = be32_to_cpu(*(__be32 *)&data[0]);
 179
 180         return 0;
 181 }
 182
 183 static int ov5693_i2c_write(struct i2c_client *client, u16 len, u8 *data)
 184 {
 185         struct i2c_msg msg;
 186         const int num_msg = 1;
 187         int ret;
 188
 189         msg.addr = client->addr;
 190         msg.flags = 0;
 191         msg.len = len;
 192         msg.buf = data;
 193         ret = i2c_transfer(client->adapter, &msg, 1);
 194
 195         return ret == num_msg ? 0 : -EIO;
 196 }
 197
 198 static int vcm_dw_i2c_write(struct i2c_client *client, u16 data)
 199 {
 200         struct i2c_msg msg;
 201         const int num_msg = 1;
 202         int ret;
 203         __be16 val;
 204
 205         val = cpu_to_be16(data);
 206         msg.addr = VCM_ADDR;
 207         msg.flags = 0;
 208         msg.len = OV5693_16BIT;
 209         msg.buf = (void *)&val;
 210
 211         ret = i2c_transfer(client->adapter, &msg, 1);
 212
 213         return ret == num_msg ? 0 : -EIO;
 214 }
 215
 216 /*
 217  * Theory: per datasheet, the two VCMs both allow for a 2-byte read.
 218  * The DW9714 doesn't actually specify what this does (it has a
 219  * two-byte write-only protocol, but specifies the read sequence as
 220  * legal), but it returns the same data (zeroes) always, after an
 221  * undocumented initial NAK.  The AD5823 has a one-byte address
 222  * register to which all writes go, and subsequent reads will cycle
 223  * through the 8 bytes of registers.  Notably, the default values (the
 224  * device is always power-cycled affirmatively, so we can rely on
 225  * these) in AD5823 are not pairwise repetitions of the same 16 bit
 226  * word.  So all we have to do is sequentially read two bytes at a
 227  * time and see if we detect a difference in any of the first four
 228  * pairs.
 229  */
 230 static int vcm_detect(struct i2c_client *client)
 231 {
 232         int i, ret;
 233         struct i2c_msg msg;
 234         u16 data0 = 0, data;
 235
 236         for (i = 0; i < 4; i++) {
 237                 msg.addr = VCM_ADDR;
 238                 msg.flags = I2C_M_RD;
 239                 msg.len = sizeof(data);
 240                 msg.buf = (u8 *)&data;
 241                 ret = i2c_transfer(client->adapter, &msg, 1);
 242
 243                 /*
 244                  * DW9714 always fails the first read and returns
 245                  * zeroes for subsequent ones
 246                  */
 247                 if (i == 0 && ret == -EREMOTEIO) {
 248                         data0 = 0;
 249                         continue;
 250                 }
 251
 252                 if (i == 0)
 253                         data0 = data;
 254
 255                 if (data != data0)
 256                         return VCM_AD5823;
 257         }
 258         return ret == 1 ? VCM_DW9714 : ret;
 259 }
 260
 261 static int ov5693_write_reg(struct i2c_client *client, u16 data_length,
 262                             u16 reg, u16 val)
 263 {
 264         int ret;
 265         unsigned char data[4] = {0};
 266         __be16 *wreg = (void *)data;
 267         const u16 len = data_length + sizeof(u16); /* 16-bit address + data */
 268
 269         if (data_length != OV5693_8BIT && data_length != OV5693_16BIT) {
 270                 dev_err(&client->dev,
 271                         "%s error, invalid data_length\n", __func__);
 272                 return -EINVAL;
 273         }
 274
 275         /* high byte goes out first */
 276         *wreg = cpu_to_be16(reg);
 277
 278         if (data_length == OV5693_8BIT) {
 279                 data[2] = (u8)(val);
 280         } else {
 281                 /* OV5693_16BIT */
 282                 __be16 *wdata = (void *)&data[2];
 283
 284                 *wdata = cpu_to_be16(val);
 285         }
 286
 287         ret = ov5693_i2c_write(client, len, data);
 288         if (ret)
 289                 dev_err(&client->dev,
 290                         "write error: wrote 0x%x to offset 0x%x error %d",
 291                         val, reg, ret);
 292
 293         return ret;
 294 }
 295
 296 /*
 297  * ov5693_write_reg_array - Initializes a list of OV5693 registers
 298  * @client: i2c driver client structure
 299  * @reglist: list of registers to be written
 300  *
 301  * This function initializes a list of registers. When consecutive addresses
 302  * are found in a row on the list, this function creates a buffer and sends
 303  * consecutive data in a single i2c_transfer().
 304  *
 305  * __ov5693_flush_reg_array, __ov5693_buf_reg_array() and
 306  * __ov5693_write_reg_is_consecutive() are internal functions to
 307  * ov5693_write_reg_array_fast() and should be not used anywhere else.
 308  *
 309  */
 310
 311 static int __ov5693_flush_reg_array(struct i2c_client *client,
 312                                     struct ov5693_write_ctrl *ctrl)
 313 {
 314         u16 size;
 315         __be16 *reg = (void *)&ctrl->buffer.addr;
 316
 317         if (ctrl->index == 0)
 318                 return 0;
 319
 320         size = sizeof(u16) + ctrl->index; /* 16-bit address + data */
 321
 322         *reg = cpu_to_be16(ctrl->buffer.addr);
 323         ctrl->index = 0;
 324
 325         return ov5693_i2c_write(client, size, (u8 *)reg);
 326 }
 327
 328 static int __ov5693_buf_reg_array(struct i2c_client *client,
 329                                   struct ov5693_write_ctrl *ctrl,
 330                                   const struct ov5693_reg *next)
 331 {
 332         int size;
 333         __be16 *data16;
 334
 335         switch (next->type) {
 336         case OV5693_8BIT:
 337                 size = 1;
 338                 ctrl->buffer.data[ctrl->index] = (u8)next->val;
 339                 break;
 340         case OV5693_16BIT:
 341                 size = 2;
 342
 343                 data16 = (void *)&ctrl->buffer.data[ctrl->index];
 344                 *data16 = cpu_to_be16((u16)next->val);
 345                 break;
 346         default:
 347                 return -EINVAL;
 348         }
 349
 350         /* When first item is added, we need to store its starting address */
 351         if (ctrl->index == 0)
 352                 ctrl->buffer.addr = next->reg;
 353
 354         ctrl->index += size;
 355
 356         /*
 357          * Buffer cannot guarantee free space for u32? Better flush it to avoid
 358          * possible lack of memory for next item.
 359          */
 360         if (ctrl->index + sizeof(u16) >= OV5693_MAX_WRITE_BUF_SIZE)
 361                 return __ov5693_flush_reg_array(client, ctrl);
 362
 363         return 0;
 364 }
 365
 366 static int __ov5693_write_reg_is_consecutive(struct i2c_client *client,
 367         struct ov5693_write_ctrl *ctrl,
 368         const struct ov5693_reg *next)
 369 {
 370         if (ctrl->index == 0)
 371                 return 1;
 372
 373         return ctrl->buffer.addr + ctrl->index == next->reg;
 374 }
 375
 376 static int ov5693_write_reg_array(struct i2c_client *client,
 377                                   const struct ov5693_reg *reglist)
 378 {
 379         const struct ov5693_reg *next = reglist;
 380         struct ov5693_write_ctrl ctrl;
 381         int err;
 382
 383         ctrl.index = 0;
 384         for (; next->type != OV5693_TOK_TERM; next++) {
 385                 switch (next->type & OV5693_TOK_MASK) {
 386                 case OV5693_TOK_DELAY:
 387                         err = __ov5693_flush_reg_array(client, &ctrl);
 388                         if (err)
 389                                 return err;
 390                         msleep(next->val);
 391                         break;
 392                 default:
 393                         /*
 394                          * If next address is not consecutive, data needs to be
 395                          * flushed before proceed.
 396                          */
 397                         if (!__ov5693_write_reg_is_consecutive(client, &ctrl,
 398                                                                next)) {
 399                                 err = __ov5693_flush_reg_array(client, &ctrl);
 400                                 if (err)
 401                                         return err;
 402                         }
 403                         err = __ov5693_buf_reg_array(client, &ctrl, next);
 404                         if (err) {
 405                                 dev_err(&client->dev,
 406                                         "%s: write error, aborted\n",
 407                                         __func__);
 408                                 return err;
 409                         }
 410                         break;
 411                 }
 412         }
 413
 414         return __ov5693_flush_reg_array(client, &ctrl);
 415 }
 416
 417 static int ov5693_g_focal(struct v4l2_subdev *sd, s32 *val)
 418 {
 419         *val = (OV5693_FOCAL_LENGTH_NUM << 16) | OV5693_FOCAL_LENGTH_DEM;
 420         return 0;
 421 }
 422
 423 static int ov5693_g_fnumber(struct v4l2_subdev *sd, s32 *val)
 424 {
 425         /*const f number for imx*/
 426         *val = (OV5693_F_NUMBER_DEFAULT_NUM << 16) | OV5693_F_NUMBER_DEM;
 427         return 0;
 428 }
 429
 430 static int ov5693_g_fnumber_range(struct v4l2_subdev *sd, s32 *val)
 431 {
 432         *val = (OV5693_F_NUMBER_DEFAULT_NUM << 24) |
 433                (OV5693_F_NUMBER_DEM << 16) |
 434                (OV5693_F_NUMBER_DEFAULT_NUM << 8) | OV5693_F_NUMBER_DEM;
 435         return 0;
 436 }
 437
 438 static int ov5693_g_bin_factor_x(struct v4l2_subdev *sd, s32 *val)
 439 {
 440         struct ov5693_device *dev = to_ov5693_sensor(sd);
 441
 442         *val = ov5693_res[dev->fmt_idx].bin_factor_x;
 443
 444         return 0;
 445 }
 446
 447 static int ov5693_g_bin_factor_y(struct v4l2_subdev *sd, s32 *val)
 448 {
 449         struct ov5693_device *dev = to_ov5693_sensor(sd);
 450
 451         *val = ov5693_res[dev->fmt_idx].bin_factor_y;
 452
 453         return 0;
 454 }
 455
 456 static int ov5693_get_intg_factor(struct i2c_client *client,
 457                                   struct camera_mipi_info *info,
 458                                   const struct ov5693_resolution *res)
 459 {
 460         struct v4l2_subdev *sd = i2c_get_clientdata(client);
 461         struct ov5693_device *dev = to_ov5693_sensor(sd);
 462         struct atomisp_sensor_mode_data *buf = &info->data;
 463         unsigned int pix_clk_freq_hz;
 464         u16 reg_val;
 465         int ret;
 466
 467         if (!info)
 468                 return -EINVAL;
 469
 470         /* pixel clock */
 471         pix_clk_freq_hz = res->pix_clk_freq * 1000000;
 472
 473         dev->vt_pix_clk_freq_mhz = pix_clk_freq_hz;
 474         buf->vt_pix_clk_freq_mhz = pix_clk_freq_hz;
 475
 476         /* get integration time */
 477         buf->coarse_integration_time_min = OV5693_COARSE_INTG_TIME_MIN;
 478         buf->coarse_integration_time_max_margin =
 479             OV5693_COARSE_INTG_TIME_MAX_MARGIN;
 480
 481         buf->fine_integration_time_min = OV5693_FINE_INTG_TIME_MIN;
 482         buf->fine_integration_time_max_margin =
 483             OV5693_FINE_INTG_TIME_MAX_MARGIN;
 484
 485         buf->fine_integration_time_def = OV5693_FINE_INTG_TIME_MIN;
 486         buf->frame_length_lines = res->lines_per_frame;
 487         buf->line_length_pck = res->pixels_per_line;
 488         buf->read_mode = res->bin_mode;
 489
 490         /* get the cropping and output resolution to ISP for this mode. */
 491         ret =  ov5693_read_reg(client, OV5693_16BIT,
 492                                OV5693_HORIZONTAL_START_H, &reg_val);
 493         if (ret)
 494                 return ret;
 495         buf->crop_horizontal_start = reg_val;
 496
 497         ret =  ov5693_read_reg(client, OV5693_16BIT,
 498                                OV5693_VERTICAL_START_H, &reg_val);
 499         if (ret)
 500                 return ret;
 501         buf->crop_vertical_start = reg_val;
 502
 503         ret = ov5693_read_reg(client, OV5693_16BIT,
 504                               OV5693_HORIZONTAL_END_H, &reg_val);
 505         if (ret)
 506                 return ret;
 507         buf->crop_horizontal_end = reg_val;
 508
 509         ret = ov5693_read_reg(client, OV5693_16BIT,
 510                               OV5693_VERTICAL_END_H, &reg_val);
 511         if (ret)
 512                 return ret;
 513         buf->crop_vertical_end = reg_val;
 514
 515         ret = ov5693_read_reg(client, OV5693_16BIT,
 516                               OV5693_HORIZONTAL_OUTPUT_SIZE_H, &reg_val);
 517         if (ret)
 518                 return ret;
 519         buf->output_width = reg_val;
 520
 521         ret = ov5693_read_reg(client, OV5693_16BIT,
 522                               OV5693_VERTICAL_OUTPUT_SIZE_H, &reg_val);
 523         if (ret)
 524                 return ret;
 525         buf->output_height = reg_val;
 526
 527         buf->binning_factor_x = res->bin_factor_x ?
 528                                 res->bin_factor_x : 1;
 529         buf->binning_factor_y = res->bin_factor_y ?
 530                                 res->bin_factor_y : 1;
 531         return 0;
 532 }
 533
 534 static long __ov5693_set_exposure(struct v4l2_subdev *sd, int coarse_itg,
 535                                   int gain, int digitgain)
 536
 537 {
 538         struct i2c_client *client = v4l2_get_subdevdata(sd);
 539         struct ov5693_device *dev = to_ov5693_sensor(sd);
 540         u16 vts, hts;
 541         int ret, exp_val;
 542
 543         hts = ov5693_res[dev->fmt_idx].pixels_per_line;
 544         vts = ov5693_res[dev->fmt_idx].lines_per_frame;
 545         /*
 546          * If coarse_itg is larger than 1<<15, can not write to reg directly.
 547          * The way is to write coarse_itg/2 to the reg, meanwhile write 2*hts
 548          * to the reg.
 549          */
 550         if (coarse_itg > (1 << 15)) {
 551                 hts = hts * 2;
 552                 coarse_itg = (int)coarse_itg / 2;
 553         }
 554         /* group hold */
 555         ret = ov5693_write_reg(client, OV5693_8BIT,
 556                                OV5693_GROUP_ACCESS, 0x00);
 557         if (ret) {
 558                 dev_err(&client->dev, "%s: write %x error, aborted\n",
 559                         __func__, OV5693_GROUP_ACCESS);
 560                 return ret;
 561         }
 562
 563         ret = ov5693_write_reg(client, OV5693_8BIT,
 564                                OV5693_TIMING_HTS_H, (hts >> 8) & 0xFF);
 565         if (ret) {
 566                 dev_err(&client->dev, "%s: write %x error, aborted\n",
 567                         __func__, OV5693_TIMING_HTS_H);
 568                 return ret;
 569         }
 570
 571         ret = ov5693_write_reg(client, OV5693_8BIT,
 572                                OV5693_TIMING_HTS_L, hts & 0xFF);
 573         if (ret) {
 574                 dev_err(&client->dev, "%s: write %x error, aborted\n",
 575                         __func__, OV5693_TIMING_HTS_L);
 576                 return ret;
 577         }
 578         /* Increase the VTS to match exposure + MARGIN */
 579         if (coarse_itg > vts - OV5693_INTEGRATION_TIME_MARGIN)
 580                 vts = (u16)coarse_itg + OV5693_INTEGRATION_TIME_MARGIN;
 581
 582         ret = ov5693_write_reg(client, OV5693_8BIT,
 583                                OV5693_TIMING_VTS_H, (vts >> 8) & 0xFF);
 584         if (ret) {
 585                 dev_err(&client->dev, "%s: write %x error, aborted\n",
 586                         __func__, OV5693_TIMING_VTS_H);
 587                 return ret;
 588         }
 589
 590         ret = ov5693_write_reg(client, OV5693_8BIT,
 591                                OV5693_TIMING_VTS_L, vts & 0xFF);
 592         if (ret) {
 593                 dev_err(&client->dev, "%s: write %x error, aborted\n",
 594                         __func__, OV5693_TIMING_VTS_L);
 595                 return ret;
 596         }
 597
 598         /* set exposure */
 599
 600         /* Lower four bit should be 0*/
 601         exp_val = coarse_itg << 4;
 602         ret = ov5693_write_reg(client, OV5693_8BIT,
 603                                OV5693_EXPOSURE_L, exp_val & 0xFF);
 604         if (ret) {
 605                 dev_err(&client->dev, "%s: write %x error, aborted\n",
 606                         __func__, OV5693_EXPOSURE_L);
 607                 return ret;
 608         }
 609
 610         ret = ov5693_write_reg(client, OV5693_8BIT,
 611                                OV5693_EXPOSURE_M, (exp_val >> 8) & 0xFF);
 612         if (ret) {
 613                 dev_err(&client->dev, "%s: write %x error, aborted\n",
 614                         __func__, OV5693_EXPOSURE_M);
 615                 return ret;
 616         }
 617
 618         ret = ov5693_write_reg(client, OV5693_8BIT,
 619                                OV5693_EXPOSURE_H, (exp_val >> 16) & 0x0F);
 620         if (ret) {
 621                 dev_err(&client->dev, "%s: write %x error, aborted\n",
 622                         __func__, OV5693_EXPOSURE_H);
 623                 return ret;
 624         }
 625
 626         /* Analog gain */
 627         ret = ov5693_write_reg(client, OV5693_8BIT,
 628                                OV5693_AGC_L, gain & 0xff);
 629         if (ret) {
 630                 dev_err(&client->dev, "%s: write %x error, aborted\n",
 631                         __func__, OV5693_AGC_L);
 632                 return ret;
 633         }
 634
 635         ret = ov5693_write_reg(client, OV5693_8BIT,
 636                                OV5693_AGC_H, (gain >> 8) & 0xff);
 637         if (ret) {
 638                 dev_err(&client->dev, "%s: write %x error, aborted\n",
 639                         __func__, OV5693_AGC_H);
 640                 return ret;
 641         }
 642
 643         /* Digital gain */
 644         if (digitgain) {
 645                 ret = ov5693_write_reg(client, OV5693_16BIT,
 646                                        OV5693_MWB_RED_GAIN_H, digitgain);
 647                 if (ret) {
 648                         dev_err(&client->dev, "%s: write %x error, aborted\n",
 649                                 __func__, OV5693_MWB_RED_GAIN_H);
 650                         return ret;
 651                 }
 652
 653                 ret = ov5693_write_reg(client, OV5693_16BIT,
 654                                        OV5693_MWB_GREEN_GAIN_H, digitgain);
 655                 if (ret) {
 656                         dev_err(&client->dev, "%s: write %x error, aborted\n",
 657                                 __func__, OV5693_MWB_RED_GAIN_H);
 658                         return ret;
 659                 }
 660
 661                 ret = ov5693_write_reg(client, OV5693_16BIT,
 662                                        OV5693_MWB_BLUE_GAIN_H, digitgain);
 663                 if (ret) {
 664                         dev_err(&client->dev, "%s: write %x error, aborted\n",
 665                                 __func__, OV5693_MWB_RED_GAIN_H);
 666                         return ret;
 667                 }
 668         }
 669
 670         /* End group */
 671         ret = ov5693_write_reg(client, OV5693_8BIT,
 672                                OV5693_GROUP_ACCESS, 0x10);
 673         if (ret)
 674                 return ret;
 675
 676         /* Delay launch group */
 677         ret = ov5693_write_reg(client, OV5693_8BIT,
 678                                OV5693_GROUP_ACCESS, 0xa0);
 679         if (ret)
 680                 return ret;
 681         return ret;
 682 }
 683
 684 static int ov5693_set_exposure(struct v4l2_subdev *sd, int exposure,
 685                                int gain, int digitgain)
 686 {
 687         struct ov5693_device *dev = to_ov5693_sensor(sd);
 688         int ret;
 689
 690         mutex_lock(&dev->input_lock);
 691         ret = __ov5693_set_exposure(sd, exposure, gain, digitgain);
 692         mutex_unlock(&dev->input_lock);
 693
 694         return ret;
 695 }
 696
 697 static long ov5693_s_exposure(struct v4l2_subdev *sd,
 698                               struct atomisp_exposure *exposure)
 699 {
 700         u16 coarse_itg = exposure->integration_time[0];
 701         u16 analog_gain = exposure->gain[0];
 702         u16 digital_gain = exposure->gain[1];
 703
 704         /* we should not accept the invalid value below */
 705         if (analog_gain == 0) {
 706                 struct i2c_client *client = v4l2_get_subdevdata(sd);
 707
 708                 v4l2_err(client, "%s: invalid value\n", __func__);
 709                 return -EINVAL;
 710         }
 711         return ov5693_set_exposure(sd, coarse_itg, analog_gain, digital_gain);
 712 }
 713
 714 static int ov5693_read_otp_reg_array(struct i2c_client *client, u16 size,
 715                                      u16 addr, u8 *buf)
 716 {
 717         u16 index;
 718         int ret;
 719         u16 *pVal = NULL;
 720
 721         for (index = 0; index <= size; index++) {
 722                 pVal = (u16 *)(buf + index);
 723                 ret =
 724                     ov5693_read_reg(client, OV5693_8BIT, addr + index,
 725                                     pVal);
 726                 if (ret)
 727                         return ret;
 728         }
 729
 730         return 0;
 731 }
 732
 733 static int __ov5693_otp_read(struct v4l2_subdev *sd, u8 *buf)
 734 {
 735         struct i2c_client *client = v4l2_get_subdevdata(sd);
 736         struct ov5693_device *dev = to_ov5693_sensor(sd);
 737         int ret;
 738         int i;
 739         u8 *b = buf;
 740
 741         dev->otp_size = 0;
 742         for (i = 1; i < OV5693_OTP_BANK_MAX; i++) {
 743                 /*set bank NO and OTP read mode. */
 744                 ret = ov5693_write_reg(client, OV5693_8BIT, OV5693_OTP_BANK_REG,
 745                                        (i | 0xc0));     //[7:6] 2'b11 [5:0] bank no
 746                 if (ret) {
 747                         dev_err(&client->dev, "failed to prepare OTP page\n");
 748                         return ret;
 749                 }
 750                 //pr_debug("write 0x%x->0x%x\n",OV5693_OTP_BANK_REG,(i|0xc0));
 751
 752                 /*enable read */
 753                 ret = ov5693_write_reg(client, OV5693_8BIT, OV5693_OTP_READ_REG,
 754                                        OV5693_OTP_MODE_READ);   // enable :1
 755                 if (ret) {
 756                         dev_err(&client->dev,
 757                                 "failed to set OTP reading mode page");
 758                         return ret;
 759                 }
 760                 //pr_debug("write 0x%x->0x%x\n",OV5693_OTP_READ_REG,OV5693_OTP_MODE_READ);
 761
 762                 /* Reading the OTP data array */
 763                 ret = ov5693_read_otp_reg_array(client, OV5693_OTP_BANK_SIZE,
 764                                                 OV5693_OTP_START_ADDR,
 765                                                 b);
 766                 if (ret) {
 767                         dev_err(&client->dev, "failed to read OTP data\n");
 768                         return ret;
 769                 }
 770
 771                 //pr_debug("BANK[%2d] %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", i, *b, *(b+1), *(b+2), *(b+3), *(b+4), *(b+5), *(b+6), *(b+7), *(b+8), *(b+9), *(b+10), *(b+11), *(b+12), *(b+13), *(b+14), *(b+15));
 772
 773                 //Intel OTP map, try to read 320byts first.
 774                 if (i == 21) {
 775                         if ((*b) == 0) {
 776                                 dev->otp_size = 320;
 777                                 break;
 778                         } else {
 779                                 b = buf;
 780                                 continue;
 781                         }
 782                 } else if (i ==
 783                            24) {                //if the first 320bytes data doesn't not exist, try to read the next 32bytes data.
 784                         if ((*b) == 0) {
 785                                 dev->otp_size = 32;
 786                                 break;
 787                         } else {
 788                                 b = buf;
 789                                 continue;
 790                         }
 791                 } else if (i ==
 792                            27) {                //if the prvious 32bytes data doesn't exist, try to read the next 32bytes data again.
 793                         if ((*b) == 0) {
 794                                 dev->otp_size = 32;
 795                                 break;
 796                         } else {
 797                                 dev->otp_size = 0;      // no OTP data.
 798                                 break;
 799                         }
 800                 }
 801
 802                 b = b + OV5693_OTP_BANK_SIZE;
 803         }
 804         return 0;
 805 }
 806
 807 /*
 808  * Read otp data and store it into a kmalloced buffer.
 809  * The caller must kfree the buffer when no more needed.
 810  * @size: set to the size of the returned otp data.
 811  */
 812 static void *ov5693_otp_read(struct v4l2_subdev *sd)
 813 {
 814         struct i2c_client *client = v4l2_get_subdevdata(sd);
 815         u8 *buf;
 816         int ret;
 817
 818         buf = devm_kzalloc(&client->dev, (OV5693_OTP_DATA_SIZE + 16), GFP_KERNEL);
 819         if (!buf)
 820                 return ERR_PTR(-ENOMEM);
 821
 822         //otp valid after mipi on and sw stream on
 823         ret = ov5693_write_reg(client, OV5693_8BIT, OV5693_FRAME_OFF_NUM, 0x00);
 824
 825         ret = ov5693_write_reg(client, OV5693_8BIT,
 826                                OV5693_SW_STREAM, OV5693_START_STREAMING);
 827
 828         ret = __ov5693_otp_read(sd, buf);
 829
 830         //mipi off and sw stream off after otp read
 831         ret = ov5693_write_reg(client, OV5693_8BIT, OV5693_FRAME_OFF_NUM, 0x0f);
 832
 833         ret = ov5693_write_reg(client, OV5693_8BIT,
 834                                OV5693_SW_STREAM, OV5693_STOP_STREAMING);
 835
 836         /* Driver has failed to find valid data */
 837         if (ret) {
 838                 dev_err(&client->dev, "sensor found no valid OTP data\n");
 839                 return ERR_PTR(ret);
 840         }
 841
 842         return buf;
 843 }
 844
 845 static int ov5693_g_priv_int_data(struct v4l2_subdev *sd,
 846                                   struct v4l2_private_int_data *priv)
 847 {
 848         struct i2c_client *client = v4l2_get_subdevdata(sd);
 849         struct ov5693_device *dev = to_ov5693_sensor(sd);
 850         u8 __user *to = priv->data;
 851         u32 read_size = priv->size;
 852         int ret;
 853
 854         /* No need to copy data if size is 0 */
 855         if (!read_size)
 856                 goto out;
 857
 858         if (IS_ERR(dev->otp_data)) {
 859                 dev_err(&client->dev, "OTP data not available");
 860                 return PTR_ERR(dev->otp_data);
 861         }
 862
 863         /* Correct read_size value only if bigger than maximum */
 864         if (read_size > OV5693_OTP_DATA_SIZE)
 865                 read_size = OV5693_OTP_DATA_SIZE;
 866
 867         ret = copy_to_user(to, dev->otp_data, read_size);
 868         if (ret) {
 869                 dev_err(&client->dev, "%s: failed to copy OTP data to user\n",
 870                         __func__);
 871                 return -EFAULT;
 872         }
 873
 874         pr_debug("%s read_size:%d\n", __func__, read_size);
 875
 876 out:
 877         /* Return correct size */
 878         priv->size = dev->otp_size;
 879
 880         return 0;
 881 }
 882
 883 static long ov5693_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
 884 {
 885         switch (cmd) {
 886         case ATOMISP_IOC_S_EXPOSURE:
 887                 return ov5693_s_exposure(sd, arg);
 888         case ATOMISP_IOC_G_SENSOR_PRIV_INT_DATA:
 889                 return ov5693_g_priv_int_data(sd, arg);
 890         default:
 891                 return -EINVAL;
 892         }
 893         return 0;
 894 }
 895
 896 /*
 897  * This returns the exposure time being used. This should only be used
 898  * for filling in EXIF data, not for actual image processing.
 899  */
 900 static int ov5693_q_exposure(struct v4l2_subdev *sd, s32 *value)
 901 {
 902         struct i2c_client *client = v4l2_get_subdevdata(sd);
 903         u16 reg_v, reg_v2;
 904         int ret;
 905
 906         /* get exposure */
 907         ret = ov5693_read_reg(client, OV5693_8BIT,
 908                               OV5693_EXPOSURE_L,
 909                               &reg_v);
 910         if (ret)
 911                 goto err;
 912
 913         ret = ov5693_read_reg(client, OV5693_8BIT,
 914                               OV5693_EXPOSURE_M,
 915                               &reg_v2);
 916         if (ret)
 917                 goto err;
 918
 919         reg_v += reg_v2 << 8;
 920         ret = ov5693_read_reg(client, OV5693_8BIT,
 921                               OV5693_EXPOSURE_H,
 922                               &reg_v2);
 923         if (ret)
 924                 goto err;
 925
 926         *value = reg_v + (((u32)reg_v2 << 16));
 927 err:
 928         return ret;
 929 }
 930
 931 static int ad5823_t_focus_vcm(struct v4l2_subdev *sd, u16 val)
 932 {
 933         struct i2c_client *client = v4l2_get_subdevdata(sd);
 934         int ret = -EINVAL;
 935         u8 vcm_code;
 936
 937         ret = ad5823_i2c_read(client, AD5823_REG_VCM_CODE_MSB, &vcm_code);
 938         if (ret)
 939                 return ret;
 940
 941         /* set reg VCM_CODE_MSB Bit[1:0] */
 942         vcm_code = (vcm_code & VCM_CODE_MSB_MASK) |
 943                    ((val >> 8) & ~VCM_CODE_MSB_MASK);
 944         ret = ad5823_i2c_write(client, AD5823_REG_VCM_CODE_MSB, vcm_code);
 945         if (ret)
 946                 return ret;
 947
 948         /* set reg VCM_CODE_LSB Bit[7:0] */
 949         ret = ad5823_i2c_write(client, AD5823_REG_VCM_CODE_LSB, (val & 0xff));
 950         if (ret)
 951                 return ret;
 952
 953         /* set required vcm move time */
 954         vcm_code = AD5823_RESONANCE_PERIOD / AD5823_RESONANCE_COEF
 955                    - AD5823_HIGH_FREQ_RANGE;
 956         ret = ad5823_i2c_write(client, AD5823_REG_VCM_MOVE_TIME, vcm_code);
 957
 958         return ret;
 959 }
 960
 961 static int ad5823_t_focus_abs(struct v4l2_subdev *sd, s32 value)
 962 {
 963         value = min(value, AD5823_MAX_FOCUS_POS);
 964         return ad5823_t_focus_vcm(sd, value);
 965 }
 966
 967 static int ov5693_t_focus_abs(struct v4l2_subdev *sd, s32 value)
 968 {
 969         struct ov5693_device *dev = to_ov5693_sensor(sd);
 970         struct i2c_client *client = v4l2_get_subdevdata(sd);
 971         int ret = 0;
 972
 973         dev_dbg(&client->dev, "%s: FOCUS_POS: 0x%x\n", __func__, value);
 974         value = clamp(value, 0, OV5693_VCM_MAX_FOCUS_POS);
 975         if (dev->vcm == VCM_DW9714) {
 976                 if (dev->vcm_update) {
 977                         ret = vcm_dw_i2c_write(client, VCM_PROTECTION_OFF);
 978                         if (ret)
 979                                 return ret;
 980                         ret = vcm_dw_i2c_write(client, DIRECT_VCM);
 981                         if (ret)
 982                                 return ret;
 983                         ret = vcm_dw_i2c_write(client, VCM_PROTECTION_ON);
 984                         if (ret)
 985                                 return ret;
 986                         dev->vcm_update = false;
 987                 }
 988                 ret = vcm_dw_i2c_write(client,
 989                                        vcm_val(value, VCM_DEFAULT_S));
 990         } else if (dev->vcm == VCM_AD5823) {
 991                 ad5823_t_focus_abs(sd, value);
 992         }
 993         if (ret == 0) {
 994                 dev->number_of_steps = value - dev->focus;
 995                 dev->focus = value;
 996                 dev->timestamp_t_focus_abs = ktime_get();
 997         } else
 998                 dev_err(&client->dev,
 999                         "%s: i2c failed. ret %d\n", __func__, ret);
1000
1001         return ret;
1002 }
1003
1004 static int ov5693_t_focus_rel(struct v4l2_subdev *sd, s32 value)
1005 {
1006         struct ov5693_device *dev = to_ov5693_sensor(sd);
1007
1008         return ov5693_t_focus_abs(sd, dev->focus + value);
1009 }
1010
1011 #define DELAY_PER_STEP_NS       1000000
1012 #define DELAY_MAX_PER_STEP_NS   (1000000 * 1023)
1013 static int ov5693_q_focus_status(struct v4l2_subdev *sd, s32 *value)
1014 {
1015         u32 status = 0;
1016         struct ov5693_device *dev = to_ov5693_sensor(sd);
1017         ktime_t temptime;
1018         ktime_t timedelay = ns_to_ktime(min_t(u32,
1019                                               abs(dev->number_of_steps) * DELAY_PER_STEP_NS,
1020                                               DELAY_MAX_PER_STEP_NS));
1021
1022         temptime = ktime_sub(ktime_get(), (dev->timestamp_t_focus_abs));
1023         if (ktime_compare(temptime, timedelay) <= 0) {
1024                 status |= ATOMISP_FOCUS_STATUS_MOVING;
1025                 status |= ATOMISP_FOCUS_HP_IN_PROGRESS;
1026         } else {
1027                 status |= ATOMISP_FOCUS_STATUS_ACCEPTS_NEW_MOVE;
1028                 status |= ATOMISP_FOCUS_HP_COMPLETE;
1029         }
1030
1031         *value = status;
1032
1033         return 0;
1034 }
1035
1036 static int ov5693_q_focus_abs(struct v4l2_subdev *sd, s32 *value)
1037 {
1038         struct ov5693_device *dev = to_ov5693_sensor(sd);
1039         s32 val;
1040
1041         ov5693_q_focus_status(sd, &val);
1042
1043         if (val & ATOMISP_FOCUS_STATUS_MOVING)
1044                 *value  = dev->focus - dev->number_of_steps;
1045         else
1046                 *value  = dev->focus;
1047
1048         return 0;
1049 }
1050
1051 static int ov5693_t_vcm_slew(struct v4l2_subdev *sd, s32 value)
1052 {
1053         struct ov5693_device *dev = to_ov5693_sensor(sd);
1054
1055         dev->number_of_steps = value;
1056         dev->vcm_update = true;
1057         return 0;
1058 }
1059
1060 static int ov5693_t_vcm_timing(struct v4l2_subdev *sd, s32 value)
1061 {
1062         struct ov5693_device *dev = to_ov5693_sensor(sd);
1063
1064         dev->number_of_steps = value;
1065         dev->vcm_update = true;
1066         return 0;
1067 }
1068
1069 static int ov5693_s_ctrl(struct v4l2_ctrl *ctrl)
1070 {
1071         struct ov5693_device *dev =
1072             container_of(ctrl->handler, struct ov5693_device, ctrl_handler);
1073         struct i2c_client *client = v4l2_get_subdevdata(&dev->sd);
1074         int ret = 0;
1075
1076         switch (ctrl->id) {
1077         case V4L2_CID_FOCUS_ABSOLUTE:
1078                 dev_dbg(&client->dev, "%s: CID_FOCUS_ABSOLUTE:%d.\n",
1079                         __func__, ctrl->val);
1080                 ret = ov5693_t_focus_abs(&dev->sd, ctrl->val);
1081                 break;
1082         case V4L2_CID_FOCUS_RELATIVE:
1083                 dev_dbg(&client->dev, "%s: CID_FOCUS_RELATIVE:%d.\n",
1084                         __func__, ctrl->val);
1085                 ret = ov5693_t_focus_rel(&dev->sd, ctrl->val);
1086                 break;
1087         case V4L2_CID_VCM_SLEW:
1088                 ret = ov5693_t_vcm_slew(&dev->sd, ctrl->val);
1089                 break;
1090         case V4L2_CID_VCM_TIMEING:
1091                 ret = ov5693_t_vcm_timing(&dev->sd, ctrl->val);
1092                 break;
1093         default:
1094                 ret = -EINVAL;
1095         }
1096         return ret;
1097 }
1098
1099 static int ov5693_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1100 {
1101         struct ov5693_device *dev =
1102             container_of(ctrl->handler, struct ov5693_device, ctrl_handler);
1103         int ret = 0;
1104
1105         switch (ctrl->id) {
1106         case V4L2_CID_EXPOSURE_ABSOLUTE:
1107                 ret = ov5693_q_exposure(&dev->sd, &ctrl->val);
1108                 break;
1109         case V4L2_CID_FOCAL_ABSOLUTE:
1110                 ret = ov5693_g_focal(&dev->sd, &ctrl->val);
1111                 break;
1112         case V4L2_CID_FNUMBER_ABSOLUTE:
1113                 ret = ov5693_g_fnumber(&dev->sd, &ctrl->val);
1114                 break;
1115         case V4L2_CID_FNUMBER_RANGE:
1116                 ret = ov5693_g_fnumber_range(&dev->sd, &ctrl->val);
1117                 break;
1118         case V4L2_CID_FOCUS_ABSOLUTE:
1119                 ret = ov5693_q_focus_abs(&dev->sd, &ctrl->val);
1120                 break;
1121         case V4L2_CID_FOCUS_STATUS:
1122                 ret = ov5693_q_focus_status(&dev->sd, &ctrl->val);
1123                 break;
1124         case V4L2_CID_BIN_FACTOR_HORZ:
1125                 ret = ov5693_g_bin_factor_x(&dev->sd, &ctrl->val);
1126                 break;
1127         case V4L2_CID_BIN_FACTOR_VERT:
1128                 ret = ov5693_g_bin_factor_y(&dev->sd, &ctrl->val);
1129                 break;
1130         default:
1131                 ret = -EINVAL;
1132         }
1133
1134         return ret;
1135 }
1136
1137 static const struct v4l2_ctrl_ops ctrl_ops = {
1138         .s_ctrl = ov5693_s_ctrl,
1139         .g_volatile_ctrl = ov5693_g_volatile_ctrl
1140 };
1141
1142 static const struct v4l2_ctrl_config ov5693_controls[] = {
1143         {
1144                 .ops = &ctrl_ops,
1145                 .id = V4L2_CID_EXPOSURE_ABSOLUTE,
1146                 .type = V4L2_CTRL_TYPE_INTEGER,
1147                 .name = "exposure",
1148                 .min = 0x0,
1149                 .max = 0xffff,
1150                 .step = 0x01,
1151                 .def = 0x00,
1152                 .flags = 0,
1153         },
1154         {
1155                 .ops = &ctrl_ops,
1156                 .id = V4L2_CID_FOCAL_ABSOLUTE,
1157                 .type = V4L2_CTRL_TYPE_INTEGER,
1158                 .name = "focal length",
1159                 .min = OV5693_FOCAL_LENGTH_DEFAULT,
1160                 .max = OV5693_FOCAL_LENGTH_DEFAULT,
1161                 .step = 0x01,
1162                 .def = OV5693_FOCAL_LENGTH_DEFAULT,
1163                 .flags = 0,
1164         },
1165         {
1166                 .ops = &ctrl_ops,
1167                 .id = V4L2_CID_FNUMBER_ABSOLUTE,
1168                 .type = V4L2_CTRL_TYPE_INTEGER,
1169                 .name = "f-number",
1170                 .min = OV5693_F_NUMBER_DEFAULT,
1171                 .max = OV5693_F_NUMBER_DEFAULT,
1172                 .step = 0x01,
1173                 .def = OV5693_F_NUMBER_DEFAULT,
1174                 .flags = 0,
1175         },
1176         {
1177                 .ops = &ctrl_ops,
1178                 .id = V4L2_CID_FNUMBER_RANGE,
1179                 .type = V4L2_CTRL_TYPE_INTEGER,
1180                 .name = "f-number range",
1181                 .min = OV5693_F_NUMBER_RANGE,
1182                 .max = OV5693_F_NUMBER_RANGE,
1183                 .step = 0x01,
1184                 .def = OV5693_F_NUMBER_RANGE,
1185                 .flags = 0,
1186         },
1187         {
1188                 .ops = &ctrl_ops,
1189                 .id = V4L2_CID_FOCUS_ABSOLUTE,
1190                 .type = V4L2_CTRL_TYPE_INTEGER,
1191                 .name = "focus move absolute",
1192                 .min = 0,
1193                 .max = OV5693_VCM_MAX_FOCUS_POS,
1194                 .step = 1,
1195                 .def = 0,
1196                 .flags = 0,
1197         },
1198         {
1199                 .ops = &ctrl_ops,
1200                 .id = V4L2_CID_FOCUS_RELATIVE,
1201                 .type = V4L2_CTRL_TYPE_INTEGER,
1202                 .name = "focus move relative",
1203                 .min = OV5693_VCM_MAX_FOCUS_NEG,
1204                 .max = OV5693_VCM_MAX_FOCUS_POS,
1205                 .step = 1,
1206                 .def = 0,
1207                 .flags = 0,
1208         },
1209         {
1210                 .ops = &ctrl_ops,
1211                 .id = V4L2_CID_FOCUS_STATUS,
1212                 .type = V4L2_CTRL_TYPE_INTEGER,
1213                 .name = "focus status",
1214                 .min = 0,
1215                 .max = 100,             /* allow enum to grow in the future */
1216                 .step = 1,
1217                 .def = 0,
1218                 .flags = 0,
1219         },
1220         {
1221                 .ops = &ctrl_ops,
1222                 .id = V4L2_CID_VCM_SLEW,
1223                 .type = V4L2_CTRL_TYPE_INTEGER,
1224                 .name = "vcm slew",
1225                 .min = 0,
1226                 .max = OV5693_VCM_SLEW_STEP_MAX,
1227                 .step = 1,
1228                 .def = 0,
1229                 .flags = 0,
1230         },
1231         {
1232                 .ops = &ctrl_ops,
1233                 .id = V4L2_CID_VCM_TIMEING,
1234                 .type = V4L2_CTRL_TYPE_INTEGER,
1235                 .name = "vcm step time",
1236                 .min = 0,
1237                 .max = OV5693_VCM_SLEW_TIME_MAX,
1238                 .step = 1,
1239                 .def = 0,
1240                 .flags = 0,
1241         },
1242         {
1243                 .ops = &ctrl_ops,
1244                 .id = V4L2_CID_BIN_FACTOR_HORZ,
1245                 .type = V4L2_CTRL_TYPE_INTEGER,
1246                 .name = "horizontal binning factor",
1247                 .min = 0,
1248                 .max = OV5693_BIN_FACTOR_MAX,
1249                 .step = 1,
1250                 .def = 0,
1251                 .flags = 0,
1252         },
1253         {
1254                 .ops = &ctrl_ops,
1255                 .id = V4L2_CID_BIN_FACTOR_VERT,
1256                 .type = V4L2_CTRL_TYPE_INTEGER,
1257                 .name = "vertical binning factor",
1258                 .min = 0,
1259                 .max = OV5693_BIN_FACTOR_MAX,
1260                 .step = 1,
1261                 .def = 0,
1262                 .flags = 0,
1263         },
1264 };
1265
1266 static int ov5693_init(struct v4l2_subdev *sd)
1267 {
1268         struct ov5693_device *dev = to_ov5693_sensor(sd);
1269         struct i2c_client *client = v4l2_get_subdevdata(sd);
1270         int ret;
1271
1272         pr_info("%s\n", __func__);
1273         mutex_lock(&dev->input_lock);
1274         dev->vcm_update = false;
1275
1276         if (dev->vcm == VCM_AD5823) {
1277                 ret = vcm_ad_i2c_wr8(client, 0x01, 0x01); /* vcm init test */
1278                 if (ret)
1279                         dev_err(&client->dev,
1280                                 "vcm reset failed\n");
1281                 /*change the mode*/
1282                 ret = ad5823_i2c_write(client, AD5823_REG_VCM_CODE_MSB,
1283                                        AD5823_RING_CTRL_ENABLE);
1284                 if (ret)
1285                         dev_err(&client->dev,
1286                                 "vcm enable ringing failed\n");
1287                 ret = ad5823_i2c_write(client, AD5823_REG_MODE,
1288                                        AD5823_ARC_RES1);
1289                 if (ret)
1290                         dev_err(&client->dev,
1291                                 "vcm change mode failed\n");
1292         }
1293
1294         /*change initial focus value for ad5823*/
1295         if (dev->vcm == VCM_AD5823) {
1296                 dev->focus = AD5823_INIT_FOCUS_POS;
1297                 ov5693_t_focus_abs(sd, AD5823_INIT_FOCUS_POS);
1298         } else {
1299                 dev->focus = 0;
1300                 ov5693_t_focus_abs(sd, 0);
1301         }
1302
1303         mutex_unlock(&dev->input_lock);
1304
1305         return 0;
1306 }
1307
1308 static int power_ctrl(struct v4l2_subdev *sd, bool flag)
1309 {
1310         int ret;
1311         struct ov5693_device *dev = to_ov5693_sensor(sd);
1312
1313         if (!dev || !dev->platform_data)
1314                 return -ENODEV;
1315
1316         /*
1317          * This driver assumes "internal DVDD, PWDNB tied to DOVDD".
1318          * In this set up only gpio0 (XSHUTDN) should be available
1319          * but in some products (for example ECS) gpio1 (PWDNB) is
1320          * also available. If gpio1 is available we emulate it being
1321          * tied to DOVDD here.
1322          */
1323         if (flag) {
1324                 ret = dev->platform_data->v2p8_ctrl(sd, 1);
1325                 dev->platform_data->gpio1_ctrl(sd, 1);
1326                 if (ret == 0) {
1327                         ret = dev->platform_data->v1p8_ctrl(sd, 1);
1328                         if (ret) {
1329                                 dev->platform_data->gpio1_ctrl(sd, 0);
1330                                 ret = dev->platform_data->v2p8_ctrl(sd, 0);
1331                         }
1332                 }
1333         } else {
1334                 dev->platform_data->gpio1_ctrl(sd, 0);
1335                 ret = dev->platform_data->v1p8_ctrl(sd, 0);
1336                 ret |= dev->platform_data->v2p8_ctrl(sd, 0);
1337         }
1338
1339         return ret;
1340 }
1341
1342 static int gpio_ctrl(struct v4l2_subdev *sd, bool flag)
1343 {
1344         struct ov5693_device *dev = to_ov5693_sensor(sd);
1345
1346         if (!dev || !dev->platform_data)
1347                 return -ENODEV;
1348
1349         return dev->platform_data->gpio0_ctrl(sd, flag);
1350 }
1351
1352 static int __power_up(struct v4l2_subdev *sd)
1353 {
1354         struct ov5693_device *dev = to_ov5693_sensor(sd);
1355         struct i2c_client *client = v4l2_get_subdevdata(sd);
1356         int ret;
1357
1358         if (!dev->platform_data) {
1359                 dev_err(&client->dev,
1360                         "no camera_sensor_platform_data");
1361                 return -ENODEV;
1362         }
1363
1364         /* power control */
1365         ret = power_ctrl(sd, 1);
1366         if (ret)
1367                 goto fail_power;
1368
1369         /* according to DS, at least 5ms is needed between DOVDD and PWDN */
1370         /* add this delay time to 10~11ms*/
1371         usleep_range(10000, 11000);
1372
1373         /* gpio ctrl */
1374         ret = gpio_ctrl(sd, 1);
1375         if (ret) {
1376                 ret = gpio_ctrl(sd, 1);
1377                 if (ret)
1378                         goto fail_power;
1379         }
1380
1381         /* flis clock control */
1382         ret = dev->platform_data->flisclk_ctrl(sd, 1);
1383         if (ret)
1384                 goto fail_clk;
1385
1386         __cci_delay(up_delay);
1387
1388         return 0;
1389
1390 fail_clk:
1391         gpio_ctrl(sd, 0);
1392 fail_power:
1393         power_ctrl(sd, 0);
1394         dev_err(&client->dev, "sensor power-up failed\n");
1395
1396         return ret;
1397 }
1398
1399 static int power_down(struct v4l2_subdev *sd)
1400 {
1401         struct ov5693_device *dev = to_ov5693_sensor(sd);
1402         struct i2c_client *client = v4l2_get_subdevdata(sd);
1403         int ret = 0;
1404
1405         dev->focus = OV5693_INVALID_CONFIG;
1406         if (!dev->platform_data) {
1407                 dev_err(&client->dev,
1408                         "no camera_sensor_platform_data");
1409                 return -ENODEV;
1410         }
1411
1412         ret = dev->platform_data->flisclk_ctrl(sd, 0);
1413         if (ret)
1414                 dev_err(&client->dev, "flisclk failed\n");
1415
1416         /* gpio ctrl */
1417         ret = gpio_ctrl(sd, 0);
1418         if (ret) {
1419                 ret = gpio_ctrl(sd, 0);
1420                 if (ret)
1421                         dev_err(&client->dev, "gpio failed 2\n");
1422         }
1423
1424         /* power control */
1425         ret = power_ctrl(sd, 0);
1426         if (ret)
1427                 dev_err(&client->dev, "vprog failed.\n");
1428
1429         return ret;
1430 }
1431
1432 static int power_up(struct v4l2_subdev *sd)
1433 {
1434         static const int retry_count = 4;
1435         int i, ret;
1436
1437         for (i = 0; i < retry_count; i++) {
1438                 ret = __power_up(sd);
1439                 if (!ret)
1440                         return 0;
1441
1442                 power_down(sd);
1443         }
1444         return ret;
1445 }
1446
1447 static int ov5693_s_power(struct v4l2_subdev *sd, int on)
1448 {
1449         int ret;
1450
1451         pr_info("%s: on %d\n", __func__, on);
1452         if (on == 0)
1453                 return power_down(sd);
1454         else {
1455                 ret = power_up(sd);
1456                 if (!ret) {
1457                         ret = ov5693_init(sd);
1458                         /* restore settings */
1459                         ov5693_res = ov5693_res_preview;
1460                         N_RES = N_RES_PREVIEW;
1461                 }
1462         }
1463         return ret;
1464 }
1465
1466 /*
1467  * distance - calculate the distance
1468  * @res: resolution
1469  * @w: width
1470  * @h: height
1471  *
1472  * Get the gap between res_w/res_h and w/h.
1473  * distance = (res_w/res_h - w/h) / (w/h) * 8192
1474  * res->width/height smaller than w/h wouldn't be considered.
1475  * The gap of ratio larger than 1/8 wouldn't be considered.
1476  * Returns the value of gap or -1 if fail.
1477  */
1478 #define LARGEST_ALLOWED_RATIO_MISMATCH 1024
1479 static int distance(struct ov5693_resolution *res, u32 w, u32 h)
1480 {
1481         int ratio;
1482         int distance;
1483
1484         if (w == 0 || h == 0 ||
1485             res->width < w || res->height < h)
1486                 return -1;
1487
1488         ratio = res->width << 13;
1489         ratio /= w;
1490         ratio *= h;
1491         ratio /= res->height;
1492
1493         distance = abs(ratio - 8192);
1494
1495         if (distance > LARGEST_ALLOWED_RATIO_MISMATCH)
1496                 return -1;
1497
1498         return distance;
1499 }
1500
1501 /* Return the nearest higher resolution index
1502  * Firstly try to find the approximate aspect ratio resolution
1503  * If we find multiple same AR resolutions, choose the
1504  * minimal size.
1505  */
1506 static int nearest_resolution_index(int w, int h)
1507 {
1508         int i;
1509         int idx = -1;
1510         int dist;
1511         int min_dist = INT_MAX;
1512         int min_res_w = INT_MAX;
1513         struct ov5693_resolution *tmp_res = NULL;
1514
1515         for (i = 0; i < N_RES; i++) {
1516                 tmp_res = &ov5693_res[i];
1517                 dist = distance(tmp_res, w, h);
1518                 if (dist == -1)
1519                         continue;
1520                 if (dist < min_dist) {
1521                         min_dist = dist;
1522                         idx = i;
1523                         min_res_w = ov5693_res[i].width;
1524                         continue;
1525                 }
1526                 if (dist == min_dist && ov5693_res[i].width < min_res_w)
1527                         idx = i;
1528         }
1529
1530         return idx;
1531 }
1532
1533 static int get_resolution_index(int w, int h)
1534 {
1535         int i;
1536
1537         for (i = 0; i < N_RES; i++) {
1538                 if (w != ov5693_res[i].width)
1539                         continue;
1540                 if (h != ov5693_res[i].height)
1541                         continue;
1542
1543                 return i;
1544         }
1545
1546         return -1;
1547 }
1548
1549 /* TODO: remove it. */
1550 static int startup(struct v4l2_subdev *sd)
1551 {
1552         struct ov5693_device *dev = to_ov5693_sensor(sd);
1553         struct i2c_client *client = v4l2_get_subdevdata(sd);
1554         int ret = 0;
1555
1556         ret = ov5693_write_reg(client, OV5693_8BIT,
1557                                OV5693_SW_RESET, 0x01);
1558         if (ret) {
1559                 dev_err(&client->dev, "ov5693 reset err.\n");
1560                 return ret;
1561         }
1562
1563         ret = ov5693_write_reg_array(client, ov5693_global_setting);
1564         if (ret) {
1565                 dev_err(&client->dev, "ov5693 write register err.\n");
1566                 return ret;
1567         }
1568
1569         ret = ov5693_write_reg_array(client, ov5693_res[dev->fmt_idx].regs);
1570         if (ret) {
1571                 dev_err(&client->dev, "ov5693 write register err.\n");
1572                 return ret;
1573         }
1574
1575         return ret;
1576 }
1577
1578 static int ov5693_set_fmt(struct v4l2_subdev *sd,
1579                           struct v4l2_subdev_pad_config *cfg,
1580                           struct v4l2_subdev_format *format)
1581 {
1582         struct v4l2_mbus_framefmt *fmt = &format->format;
1583         struct ov5693_device *dev = to_ov5693_sensor(sd);
1584         struct i2c_client *client = v4l2_get_subdevdata(sd);
1585         struct camera_mipi_info *ov5693_info = NULL;
1586         int ret = 0;
1587         int idx;
1588
1589         if (format->pad)
1590                 return -EINVAL;
1591         if (!fmt)
1592                 return -EINVAL;
1593         ov5693_info = v4l2_get_subdev_hostdata(sd);
1594         if (!ov5693_info)
1595                 return -EINVAL;
1596
1597         mutex_lock(&dev->input_lock);
1598         idx = nearest_resolution_index(fmt->width, fmt->height);
1599         if (idx == -1) {
1600                 /* return the largest resolution */
1601                 fmt->width = ov5693_res[N_RES - 1].width;
1602                 fmt->height = ov5693_res[N_RES - 1].height;
1603         } else {
1604                 fmt->width = ov5693_res[idx].width;
1605                 fmt->height = ov5693_res[idx].height;
1606         }
1607
1608         fmt->code = MEDIA_BUS_FMT_SBGGR10_1X10;
1609         if (format->which == V4L2_SUBDEV_FORMAT_TRY) {
1610                 cfg->try_fmt = *fmt;
1611                 mutex_unlock(&dev->input_lock);
1612                 return 0;
1613         }
1614
1615         dev->fmt_idx = get_resolution_index(fmt->width, fmt->height);
1616         if (dev->fmt_idx == -1) {
1617                 dev_err(&client->dev, "get resolution fail\n");
1618                 mutex_unlock(&dev->input_lock);
1619                 return -EINVAL;
1620         }
1621
1622         ret = startup(sd);
1623         if (ret) {
1624                 int i = 0;
1625
1626                 dev_err(&client->dev, "ov5693 startup err, retry to power up\n");
1627                 for (i = 0; i < OV5693_POWER_UP_RETRY_NUM; i++) {
1628                         dev_err(&client->dev,
1629                                 "ov5693 retry to power up %d/%d times, result: ",
1630                                 i + 1, OV5693_POWER_UP_RETRY_NUM);
1631                         power_down(sd);
1632                         ret = power_up(sd);
1633                         if (!ret) {
1634                                 mutex_unlock(&dev->input_lock);
1635                                 ov5693_init(sd);
1636                                 mutex_lock(&dev->input_lock);
1637                         } else {
1638                                 dev_err(&client->dev, "power up failed, continue\n");
1639                                 continue;
1640                         }
1641                         ret = startup(sd);
1642                         if (ret) {
1643                                 dev_err(&client->dev, " startup FAILED!\n");
1644                         } else {
1645                                 dev_err(&client->dev, " startup SUCCESS!\n");
1646                                 break;
1647                         }
1648                 }
1649         }
1650
1651         /*
1652          * After sensor settings are set to HW, sometimes stream is started.
1653          * This would cause ISP timeout because ISP is not ready to receive
1654          * data yet. So add stop streaming here.
1655          */
1656         ret = ov5693_write_reg(client, OV5693_8BIT, OV5693_SW_STREAM,
1657                                OV5693_STOP_STREAMING);
1658         if (ret)
1659                 dev_warn(&client->dev, "ov5693 stream off err\n");
1660
1661         ret = ov5693_get_intg_factor(client, ov5693_info,
1662                                      &ov5693_res[dev->fmt_idx]);
1663         if (ret) {
1664                 dev_err(&client->dev, "failed to get integration_factor\n");
1665                 goto err;
1666         }
1667
1668         ov5693_info->metadata_width = fmt->width * 10 / 8;
1669         ov5693_info->metadata_height = 1;
1670         ov5693_info->metadata_effective_width = &ov5693_embedded_effective_size;
1671
1672 err:
1673         mutex_unlock(&dev->input_lock);
1674         return ret;
1675 }
1676
1677 static int ov5693_get_fmt(struct v4l2_subdev *sd,
1678                           struct v4l2_subdev_pad_config *cfg,
1679                           struct v4l2_subdev_format *format)
1680 {
1681         struct v4l2_mbus_framefmt *fmt = &format->format;
1682         struct ov5693_device *dev = to_ov5693_sensor(sd);
1683
1684         if (format->pad)
1685                 return -EINVAL;
1686
1687         if (!fmt)
1688                 return -EINVAL;
1689
1690         fmt->width = ov5693_res[dev->fmt_idx].width;
1691         fmt->height = ov5693_res[dev->fmt_idx].height;
1692         fmt->code = MEDIA_BUS_FMT_SBGGR10_1X10;
1693
1694         return 0;
1695 }
1696
1697 static int ov5693_detect(struct i2c_client *client)
1698 {
1699         struct i2c_adapter *adapter = client->adapter;
1700         u16 high, low;
1701         int ret;
1702         u16 id;
1703         u8 revision;
1704
1705         if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
1706                 return -ENODEV;
1707
1708         ret = ov5693_read_reg(client, OV5693_8BIT,
1709                               OV5693_SC_CMMN_CHIP_ID_H, &high);
1710         if (ret) {
1711                 dev_err(&client->dev, "sensor_id_high = 0x%x\n", high);
1712                 return -ENODEV;
1713         }
1714         ret = ov5693_read_reg(client, OV5693_8BIT,
1715                               OV5693_SC_CMMN_CHIP_ID_L, &low);
1716         id = ((((u16)high) << 8) | (u16)low);
1717
1718         if (id != OV5693_ID) {
1719                 dev_err(&client->dev, "sensor ID error 0x%x\n", id);
1720                 return -ENODEV;
1721         }
1722
1723         ret = ov5693_read_reg(client, OV5693_8BIT,
1724                               OV5693_SC_CMMN_SUB_ID, &high);
1725         revision = (u8)high & 0x0f;
1726
1727         dev_dbg(&client->dev, "sensor_revision = 0x%x\n", revision);
1728         dev_dbg(&client->dev, "detect ov5693 success\n");
1729         return 0;
1730 }
1731
1732 static int ov5693_s_stream(struct v4l2_subdev *sd, int enable)
1733 {
1734         struct ov5693_device *dev = to_ov5693_sensor(sd);
1735         struct i2c_client *client = v4l2_get_subdevdata(sd);
1736         int ret;
1737
1738         mutex_lock(&dev->input_lock);
1739
1740         ret = ov5693_write_reg(client, OV5693_8BIT, OV5693_SW_STREAM,
1741                                enable ? OV5693_START_STREAMING :
1742                                OV5693_STOP_STREAMING);
1743
1744         mutex_unlock(&dev->input_lock);
1745
1746         return ret;
1747 }
1748
1749 static int ov5693_s_config(struct v4l2_subdev *sd,
1750                            int irq, void *platform_data)
1751 {
1752         struct ov5693_device *dev = to_ov5693_sensor(sd);
1753         struct i2c_client *client = v4l2_get_subdevdata(sd);
1754         int ret = 0;
1755
1756         if (!platform_data)
1757                 return -ENODEV;
1758
1759         dev->platform_data =
1760             (struct camera_sensor_platform_data *)platform_data;
1761
1762         mutex_lock(&dev->input_lock);
1763         /* power off the module, then power on it in future
1764          * as first power on by board may not fulfill the
1765          * power on sequqence needed by the module
1766          */
1767         ret = power_down(sd);
1768         if (ret) {
1769                 dev_err(&client->dev, "ov5693 power-off err.\n");
1770                 goto fail_power_off;
1771         }
1772
1773         ret = power_up(sd);
1774         if (ret) {
1775                 dev_err(&client->dev, "ov5693 power-up err.\n");
1776                 goto fail_power_on;
1777         }
1778
1779         if (!dev->vcm)
1780                 dev->vcm = vcm_detect(client);
1781
1782         ret = dev->platform_data->csi_cfg(sd, 1);
1783         if (ret)
1784                 goto fail_csi_cfg;
1785
1786         /* config & detect sensor */
1787         ret = ov5693_detect(client);
1788         if (ret) {
1789                 dev_err(&client->dev, "ov5693_detect err s_config.\n");
1790                 goto fail_csi_cfg;
1791         }
1792
1793         dev->otp_data = ov5693_otp_read(sd);
1794
1795         /* turn off sensor, after probed */
1796         ret = power_down(sd);
1797         if (ret) {
1798                 dev_err(&client->dev, "ov5693 power-off err.\n");
1799                 goto fail_csi_cfg;
1800         }
1801         mutex_unlock(&dev->input_lock);
1802
1803         return ret;
1804
1805 fail_csi_cfg:
1806         dev->platform_data->csi_cfg(sd, 0);
1807 fail_power_on:
1808         power_down(sd);
1809         dev_err(&client->dev, "sensor power-gating failed\n");
1810 fail_power_off:
1811         mutex_unlock(&dev->input_lock);
1812         return ret;
1813 }
1814
1815 static int ov5693_g_frame_interval(struct v4l2_subdev *sd,
1816                                    struct v4l2_subdev_frame_interval *interval)
1817 {
1818         struct ov5693_device *dev = to_ov5693_sensor(sd);
1819
1820         interval->interval.numerator = 1;
1821         interval->interval.denominator = ov5693_res[dev->fmt_idx].fps;
1822
1823         return 0;
1824 }
1825
1826 static int ov5693_enum_mbus_code(struct v4l2_subdev *sd,
1827                                  struct v4l2_subdev_pad_config *cfg,
1828                                  struct v4l2_subdev_mbus_code_enum *code)
1829 {
1830         if (code->index >= MAX_FMTS)
1831                 return -EINVAL;
1832
1833         code->code = MEDIA_BUS_FMT_SBGGR10_1X10;
1834         return 0;
1835 }
1836
1837 static int ov5693_enum_frame_size(struct v4l2_subdev *sd,
1838                                   struct v4l2_subdev_pad_config *cfg,
1839                                   struct v4l2_subdev_frame_size_enum *fse)
1840 {
1841         int index = fse->index;
1842
1843         if (index >= N_RES)
1844                 return -EINVAL;
1845
1846         fse->min_width = ov5693_res[index].width;
1847         fse->min_height = ov5693_res[index].height;
1848         fse->max_width = ov5693_res[index].width;
1849         fse->max_height = ov5693_res[index].height;
1850
1851         return 0;
1852 }
1853
1854 static const struct v4l2_subdev_video_ops ov5693_video_ops = {
1855         .s_stream = ov5693_s_stream,
1856         .g_frame_interval = ov5693_g_frame_interval,
1857 };
1858
1859 static const struct v4l2_subdev_core_ops ov5693_core_ops = {
1860         .s_power = ov5693_s_power,
1861         .ioctl = ov5693_ioctl,
1862 };
1863
1864 static const struct v4l2_subdev_pad_ops ov5693_pad_ops = {
1865         .enum_mbus_code = ov5693_enum_mbus_code,
1866         .enum_frame_size = ov5693_enum_frame_size,
1867         .get_fmt = ov5693_get_fmt,
1868         .set_fmt = ov5693_set_fmt,
1869 };
1870
1871 static const struct v4l2_subdev_ops ov5693_ops = {
1872         .core = &ov5693_core_ops,
1873         .video = &ov5693_video_ops,
1874         .pad = &ov5693_pad_ops,
1875 };
1876
1877 static int ov5693_remove(struct i2c_client *client)
1878 {
1879         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1880         struct ov5693_device *dev = to_ov5693_sensor(sd);
1881
1882         dev_dbg(&client->dev, "ov5693_remove...\n");
1883
1884         dev->platform_data->csi_cfg(sd, 0);
1885
1886         v4l2_device_unregister_subdev(sd);
1887
1888         atomisp_gmin_remove_subdev(sd);
1889
1890         media_entity_cleanup(&dev->sd.entity);
1891         v4l2_ctrl_handler_free(&dev->ctrl_handler);
1892         kfree(dev);
1893
1894         return 0;
1895 }
1896
1897 static int ov5693_probe(struct i2c_client *client)
1898 {
1899         struct ov5693_device *dev;
1900         int i2c;
1901         int ret = 0;
1902         void *pdata;
1903         unsigned int i;
1904         acpi_handle handle;
1905         struct acpi_device *adev;
1906
1907         handle = ACPI_HANDLE(&client->dev);
1908         if (!handle || acpi_bus_get_device(handle, &adev)) {
1909                 dev_err(&client->dev, "Error could not get ACPI device\n");
1910                 return -ENODEV;
1911         }
1912
1913         pr_info("%s: ACPI detected it on bus ID=%s, HID=%s\n",
1914                 __func__, acpi_device_bid(adev), acpi_device_hid(adev));
1915
1916         /*
1917          * Firmware workaround: Some modules use a "secondary default"
1918          * address of 0x10 which doesn't appear on schematics, and
1919          * some BIOS versions haven't gotten the memo.  Work around
1920          * via config.
1921          */
1922         i2c = gmin_get_var_int(&client->dev, false, "I2CAddr", -1);
1923         if (i2c != -1) {
1924                 dev_info(&client->dev,
1925                          "Overriding firmware-provided I2C address (0x%x) with 0x%x\n",
1926                          client->addr, i2c);
1927                 client->addr = i2c;
1928         }
1929
1930         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1931         if (!dev)
1932                 return -ENOMEM;
1933
1934         mutex_init(&dev->input_lock);
1935
1936         dev->fmt_idx = 0;
1937         v4l2_i2c_subdev_init(&dev->sd, client, &ov5693_ops);
1938
1939         pdata = gmin_camera_platform_data(&dev->sd,
1940                                           ATOMISP_INPUT_FORMAT_RAW_10,
1941                                           atomisp_bayer_order_bggr);
1942         if (!pdata)
1943                 goto out_free;
1944
1945         ret = ov5693_s_config(&dev->sd, client->irq, pdata);
1946         if (ret)
1947                 goto out_free;
1948
1949         ret = atomisp_register_i2c_module(&dev->sd, pdata, RAW_CAMERA);
1950         if (ret)
1951                 goto out_free;
1952
1953         dev->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
1954         dev->pad.flags = MEDIA_PAD_FL_SOURCE;
1955         dev->format.code = MEDIA_BUS_FMT_SBGGR10_1X10;
1956         dev->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
1957         ret =
1958             v4l2_ctrl_handler_init(&dev->ctrl_handler,
1959                                    ARRAY_SIZE(ov5693_controls));
1960         if (ret) {
1961                 ov5693_remove(client);
1962                 return ret;
1963         }
1964
1965         for (i = 0; i < ARRAY_SIZE(ov5693_controls); i++)
1966                 v4l2_ctrl_new_custom(&dev->ctrl_handler, &ov5693_controls[i],
1967                                      NULL);
1968
1969         if (dev->ctrl_handler.error) {
1970                 ov5693_remove(client);
1971                 return dev->ctrl_handler.error;
1972         }
1973
1974         /* Use same lock for controls as for everything else. */
1975         dev->ctrl_handler.lock = &dev->input_lock;
1976         dev->sd.ctrl_handler = &dev->ctrl_handler;
1977
1978         ret = media_entity_pads_init(&dev->sd.entity, 1, &dev->pad);
1979         if (ret)
1980                 ov5693_remove(client);
1981
1982         return ret;
1983 out_free:
1984         v4l2_device_unregister_subdev(&dev->sd);
1985         kfree(dev);
1986         return ret;
1987 }
1988
1989 static const struct acpi_device_id ov5693_acpi_match[] = {
1990         {"INT33BE"},
1991         {},
1992 };
1993 MODULE_DEVICE_TABLE(acpi, ov5693_acpi_match);
1994
1995 static struct i2c_driver ov5693_driver = {
1996         .driver = {
1997                 .name = "ov5693",
1998                 .acpi_match_table = ov5693_acpi_match,
1999         },
2000         .probe_new = ov5693_probe,
2001         .remove = ov5693_remove,
2002 };
2003 module_i2c_driver(ov5693_driver);
2004
2005 MODULE_DESCRIPTION("A low-level driver for OmniVision 5693 sensors");
2006 MODULE_LICENSE("GPL");