drivers/staging/media/atomisp/i2c/ov8858.c

   1 /*
   2  * Support for OmniVision ov8858 camera sensor.
   3  *
   4  * Copyright (c) 2014 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  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18  * 02110-1301, USA.
  19  *
  20  */
  21
  22 #include <linux/delay.h>
  23 #include <linux/module.h>
  24 #include <media/v4l2-device.h>
  25 #include <linux/acpi.h>
  26 #include "../include/linux/atomisp_gmin_platform.h"
  27 #ifdef CONFIG_PLATFORM_BTNS
  28 #include "ov8858_btns.h"
  29 #else
  30 #include "ov8858.h"
  31 #endif
  32 static int ov8858_i2c_read(struct i2c_client *client, u16 len, u16 addr,
  33                            u8 *buf)
  34 {
  35         struct i2c_msg msg[2];
  36         u8 address[2];
  37         int err;
  38
  39         if (!client->adapter) {
  40                 dev_err(&client->dev, "%s error, no adapter\n", __func__);
  41                 return -ENODEV;
  42         }
  43
  44         dev_dbg(&client->dev, "%s: len = %d, addr = 0x%04x\n",
  45                 __func__, len, addr);
  46
  47         memset(msg, 0, sizeof(msg));
  48
  49         address[0] = (addr >> 8) & 0xff;
  50         address[1] = addr & 0xff;
  51
  52         msg[0].addr = client->addr;
  53         msg[0].flags = 0;
  54         msg[0].len = I2C_MSG_LENGTH;
  55         msg[0].buf = address;
  56
  57         msg[1].addr = client->addr;
  58         msg[1].len = len;
  59         msg[1].flags = I2C_M_RD;
  60         msg[1].buf = buf;
  61
  62         err = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
  63         if (err != 2) {
  64                 if (err >= 0)
  65                         err = -EIO;
  66                 goto error;
  67         }
  68
  69         return 0;
  70 error:
  71         dev_err(&client->dev, "reading from address 0x%x error %d", addr, err);
  72         return err;
  73 }
  74
  75 static int ov8858_read_reg(struct i2c_client *client, u16 type, u16 reg,
  76                            u16 *val)
  77 {
  78         u8 data[OV8858_SHORT_MAX];
  79         int err;
  80
  81         dev_dbg(&client->dev, "%s: type = %d, reg = 0x%04x\n",
  82                 __func__, type, reg);
  83
  84         /* read only 8 and 16 bit values */
  85         if (type != OV8858_8BIT && type != OV8858_16BIT) {
  86                 dev_err(&client->dev, "%s error, invalid data length\n",
  87                         __func__);
  88                 return -EINVAL;
  89         }
  90
  91         memset(data, 0, sizeof(data));
  92
  93         err = ov8858_i2c_read(client, type, reg, data);
  94         if (err)
  95                 goto error;
  96
  97         /* high byte comes first */
  98         if (type == OV8858_8BIT)
  99                 *val = (u8)data[0];
 100         else
 101                 *val = data[0] << 8 | data[1];
 102
 103         dev_dbg(&client->dev, "%s: val = 0x%04x\n", __func__, *val);
 104
 105         return 0;
 106
 107 error:
 108         dev_err(&client->dev, "read from offset 0x%x error %d", reg, err);
 109         return err;
 110 }
 111
 112 static int ov8858_i2c_write(struct i2c_client *client, u16 len, u8 *data)
 113 {
 114         struct i2c_msg msg;
 115         const int num_msg = 1;
 116         int ret;
 117
 118         msg.addr = client->addr;
 119         msg.flags = 0;
 120         msg.len = len;
 121         msg.buf = data;
 122
 123         ret = i2c_transfer(client->adapter, &msg, 1);
 124
 125         return ret == num_msg ? 0 : -EIO;
 126 }
 127
 128 static int
 129 ov8858_write_reg(struct i2c_client *client, u16 data_length, u16 reg, u16 val)
 130 {
 131         int ret;
 132         unsigned char data[4] = {0};
 133         u16 *wreg;
 134         const u16 len = data_length + sizeof(u16); /* 16-bit address + data */
 135
 136         dev_dbg(&client->dev,
 137                 "%s: data_length = %d, reg = 0x%04x, val = 0x%04x\n",
 138                 __func__, data_length, reg, val);
 139
 140         if (!client->adapter) {
 141                 dev_err(&client->dev, "%s error, no adapter\n", __func__);
 142                 return -ENODEV;
 143         }
 144
 145         if (data_length != OV8858_8BIT && data_length != OV8858_16BIT) {
 146                 dev_err(&client->dev, "%s error, invalid length\n", __func__);
 147                 return -EINVAL;
 148         }
 149
 150         /* high byte goes out first */
 151         wreg = (u16 *)data;
 152         *wreg = cpu_to_be16(reg);
 153
 154         if (data_length == OV8858_8BIT) {
 155                 data[2] = (u8)(val);
 156         } else {
 157                 /* OV8858_16BIT */
 158                 u16 *wdata = (u16 *)&data[2];
 159                 *wdata = be16_to_cpu(val);
 160         }
 161
 162         ret = ov8858_i2c_write(client, len, data);
 163         if (ret)
 164                 dev_err(&client->dev,
 165                         "write error: wrote 0x%x to offset 0x%x error %d",
 166                         val, reg, ret);
 167
 168         return ret;
 169 }
 170
 171 /*
 172  * ov8858_write_reg_array - Initializes a list of registers
 173  * @client: i2c driver client structure
 174  * @reglist: list of registers to be written
 175  *
 176  * This function initializes a list of registers. When consecutive addresses
 177  * are found in a row on the list, this function creates a buffer and sends
 178  * consecutive data in a single i2c_transfer().
 179  *
 180  * __ov8858_flush_reg_array(), __ov8858_buf_reg_array() and
 181  * __ov8858_write_reg_is_consecutive() are internal functions to
 182  * ov8858_write_reg_array() and should be not used anywhere else.
 183  *
 184  */
 185 static int __ov8858_flush_reg_array(struct i2c_client *client,
 186                                     struct ov8858_write_ctrl *ctrl)
 187 {
 188         u16 size;
 189         if (ctrl->index == 0)
 190                 return 0;
 191
 192         size = sizeof(u16) + ctrl->index; /* 16-bit address + data */
 193         ctrl->buffer.addr = cpu_to_be16(ctrl->buffer.addr);
 194         ctrl->index = 0;
 195
 196         return ov8858_i2c_write(client, size, (u8 *)&ctrl->buffer);
 197 }
 198
 199 static int __ov8858_buf_reg_array(struct i2c_client *client,
 200                                   struct ov8858_write_ctrl *ctrl,
 201                                   const struct ov8858_reg *next)
 202 {
 203         int size;
 204         u16 *data16;
 205
 206         switch (next->type) {
 207         case OV8858_8BIT:
 208                 size = 1;
 209                 ctrl->buffer.data[ctrl->index] = (u8)next->val;
 210                 break;
 211         case OV8858_16BIT:
 212                 size = 2;
 213                 data16 = (u16 *)&ctrl->buffer.data[ctrl->index];
 214                 *data16 = cpu_to_be16((u16)next->val);
 215                 break;
 216         default:
 217                 return -EINVAL;
 218         }
 219
 220         /* When first item is added, we need to store its starting address */
 221         if (ctrl->index == 0)
 222                 ctrl->buffer.addr = next->sreg;
 223
 224         ctrl->index += size;
 225
 226         /*
 227          * Buffer cannot guarantee free space for u32? Better flush it to avoid
 228          * possible lack of memory for next item.
 229          */
 230         if (ctrl->index + sizeof(u16) >= OV8858_MAX_WRITE_BUF_SIZE)
 231                 __ov8858_flush_reg_array(client, ctrl);
 232
 233         return 0;
 234 }
 235
 236 static int
 237 __ov8858_write_reg_is_consecutive(struct i2c_client *client,
 238                                   struct ov8858_write_ctrl *ctrl,
 239                                   const struct ov8858_reg *next)
 240 {
 241         if (ctrl->index == 0)
 242                 return 1;
 243
 244         return ctrl->buffer.addr + ctrl->index == next->sreg;
 245 }
 246
 247 static int ov8858_write_reg_array(struct i2c_client *client,
 248                                   const struct ov8858_reg *reglist)
 249 {
 250         const struct ov8858_reg *next = reglist;
 251         struct ov8858_write_ctrl ctrl;
 252         int err;
 253
 254         ctrl.index = 0;
 255         for (; next->type != OV8858_TOK_TERM; next++) {
 256                 switch (next->type & OV8858_TOK_MASK) {
 257                 case OV8858_TOK_DELAY:
 258                         err = __ov8858_flush_reg_array(client, &ctrl);
 259                         if (err)
 260                                 return err;
 261                         msleep(next->val);
 262                         break;
 263
 264                 default:
 265                         /*
 266                          * If next address is not consecutive, data needs to be
 267                          * flushed before proceeding
 268                          */
 269                         if (!__ov8858_write_reg_is_consecutive(client,
 270                                                                &ctrl, next)) {
 271                                 err = __ov8858_flush_reg_array(client, &ctrl);
 272                                 if (err)
 273                                         return err;
 274                         }
 275                         err = __ov8858_buf_reg_array(client, &ctrl, next);
 276                         if (err) {
 277                                 dev_err(&client->dev, "%s: write error\n",
 278                                         __func__);
 279                                 return err;
 280                         }
 281                         break;
 282                 }
 283         }
 284
 285         return __ov8858_flush_reg_array(client, &ctrl);
 286 }
 287
 288 static int __ov8858_min_fps_diff(int fps,
 289                                  const struct ov8858_fps_setting *fps_list)
 290 {
 291         int diff = INT_MAX;
 292         int i;
 293
 294         if (fps == 0)
 295                 return 0;
 296
 297         for (i = 0; i < MAX_FPS_OPTIONS_SUPPORTED; i++) {
 298                 if (!fps_list[i].fps)
 299                         break;
 300                 if (abs(fps_list[i].fps - fps) < diff)
 301                         diff = abs(fps_list[i].fps - fps);
 302         }
 303
 304         return diff;
 305 }
 306
 307 static int __ov8858_nearest_fps_index(int fps,
 308                                       const struct ov8858_fps_setting *fps_list)
 309 {
 310         int fps_index = 0;
 311         int i;
 312
 313         for (i = 0; i < MAX_FPS_OPTIONS_SUPPORTED; i++) {
 314                 if (!fps_list[i].fps)
 315                         break;
 316                 if (abs(fps_list[i].fps - fps)
 317                     < abs(fps_list[fps_index].fps - fps))
 318                         fps_index = i;
 319         }
 320         return fps_index;
 321 }
 322
 323 static int __ov8858_update_frame_timing(struct v4l2_subdev *sd,
 324                                         u16 *hts, u16 *vts)
 325 {
 326         struct i2c_client *client = v4l2_get_subdevdata(sd);
 327         int ret;
 328
 329
 330         dev_dbg(&client->dev, "%s OV8858_TIMING_HTS=0x%04x\n",
 331                 __func__, *hts);
 332
 333         /* HTS = pixel_per_line / 2 */
 334         ret = ov8858_write_reg(client, OV8858_16BIT,
 335                                 OV8858_TIMING_HTS, *hts >> 1);
 336         if (ret)
 337                 return ret;
 338         dev_dbg(&client->dev, "%s OV8858_TIMING_VTS=0x%04x\n",
 339                 __func__, *vts);
 340
 341         return ov8858_write_reg(client, OV8858_16BIT, OV8858_TIMING_VTS, *vts);
 342 }
 343
 344 static int __ov8858_set_exposure(struct v4l2_subdev *sd, int exposure, int gain,
 345                                  int dig_gain, u16 *hts, u16 *vts)
 346 {
 347         struct ov8858_device *dev = to_ov8858_sensor(sd);
 348         struct i2c_client *client = v4l2_get_subdevdata(sd);
 349         int exp_val, ret;
 350         dev_dbg(&client->dev, "%s, exposure = %d, gain=%d, dig_gain=%d\n",
 351                 __func__, exposure, gain, dig_gain);
 352
 353         if (dev->limit_exposure_flag) {
 354                 if (exposure > *vts - OV8858_INTEGRATION_TIME_MARGIN)
 355                         exposure = *vts - OV8858_INTEGRATION_TIME_MARGIN;
 356         } else {
 357                 if (*vts < exposure + OV8858_INTEGRATION_TIME_MARGIN)
 358                         *vts = (u16) exposure + OV8858_INTEGRATION_TIME_MARGIN;
 359         }
 360
 361         ret = __ov8858_update_frame_timing(sd, hts, vts);
 362         if (ret)
 363                 return ret;
 364
 365         /* For ov8858, the low 4 bits are fraction bits and must be kept 0 */
 366         exp_val = exposure << 4;
 367         ret = ov8858_write_reg(client, OV8858_8BIT,
 368                                OV8858_LONG_EXPO+2, exp_val & 0xFF);
 369         if (ret)
 370                 return ret;
 371
 372         ret = ov8858_write_reg(client, OV8858_8BIT,
 373                                OV8858_LONG_EXPO+1, (exp_val >> 8) & 0xFF);
 374         if (ret)
 375                 return ret;
 376
 377         ret = ov8858_write_reg(client, OV8858_8BIT,
 378                                OV8858_LONG_EXPO, (exp_val >> 16) & 0x0F);
 379         if (ret)
 380                 return ret;
 381
 382         /* Digital gain : to all MWB channel gains */
 383         if (dig_gain) {
 384                 ret = ov8858_write_reg(client, OV8858_16BIT,
 385                                 OV8858_MWB_RED_GAIN_H, dig_gain);
 386                 if (ret)
 387                         return ret;
 388
 389                 ret = ov8858_write_reg(client, OV8858_16BIT,
 390                                 OV8858_MWB_GREEN_GAIN_H, dig_gain);
 391                 if (ret)
 392                         return ret;
 393
 394                 ret = ov8858_write_reg(client, OV8858_16BIT,
 395                                 OV8858_MWB_BLUE_GAIN_H, dig_gain);
 396                 if (ret)
 397                         return ret;
 398         }
 399
 400         ret = ov8858_write_reg(client, OV8858_16BIT, OV8858_LONG_GAIN,
 401                                 gain & 0x07ff);
 402         if (ret)
 403                 return ret;
 404
 405         dev->gain = gain;
 406         dev->exposure = exposure;
 407         dev->digital_gain = dig_gain;
 408
 409         return 0;
 410 }
 411
 412 static int ov8858_set_exposure(struct v4l2_subdev *sd, int exposure, int gain,
 413                                 int dig_gain)
 414 {
 415         struct ov8858_device *dev = to_ov8858_sensor(sd);
 416         const struct ov8858_resolution *res;
 417         u16 hts, vts;
 418         int ret;
 419
 420         mutex_lock(&dev->input_lock);
 421
 422         /* Validate exposure:  cannot exceed 16bit value */
 423         exposure = clamp_t(int, exposure, 0, OV8858_MAX_EXPOSURE_VALUE);
 424
 425         /* Validate gain: must not exceed maximum 8bit value */
 426         gain = clamp_t(int, gain, 0, OV8858_MAX_GAIN_VALUE);
 427
 428         /* Validate digital gain: must not exceed 12 bit value*/
 429         dig_gain = clamp_t(int, dig_gain, 0, OV8858_MWB_GAIN_MAX);
 430
 431         res = &dev->curr_res_table[dev->fmt_idx];
 432         /*
 433          * Vendor: HTS reg value is half the total pixel line
 434          */
 435         hts = res->fps_options[dev->fps_index].pixels_per_line;
 436         vts = res->fps_options[dev->fps_index].lines_per_frame;
 437
 438         ret = __ov8858_set_exposure(sd, exposure, gain, dig_gain, &hts, &vts);
 439
 440         mutex_unlock(&dev->input_lock);
 441
 442         return ret;
 443 }
 444
 445 /*
 446    When exposure gain value set to sensor, the sensor changed value.
 447    So we need the function to get real value
 448  */
 449 static int ov8858_g_update_exposure(struct v4l2_subdev *sd,
 450                                 struct atomisp_update_exposure *exposure)
 451 {
 452         struct ov8858_device *dev = to_ov8858_sensor(sd);
 453         struct i2c_client *client = v4l2_get_subdevdata(sd);
 454         int gain = exposure->gain;
 455
 456         dev_dbg(&client->dev, "%s: gain: %d, digi_gain: %d\n", __func__,
 457                         exposure->gain, exposure->digi_gain);
 458         exposure->update_digi_gain = dev->digital_gain;
 459         /* This real gain value fetching function is provided by vendor */
 460         exposure->update_gain = (((gain & 0x700) >> 8) + 1) * (gain & 0xFF);
 461
 462         return 0;
 463 }
 464
 465 static int ov8858_s_exposure(struct v4l2_subdev *sd,
 466                              struct atomisp_exposure *exposure)
 467 {
 468         return ov8858_set_exposure(sd, exposure->integration_time[0],
 469                                 exposure->gain[0], exposure->gain[1]);
 470 }
 471
 472 static int ov8858_priv_int_data_init(struct v4l2_subdev *sd)
 473 {
 474         struct ov8858_device *dev = to_ov8858_sensor(sd);
 475         struct i2c_client *client = v4l2_get_subdevdata(sd);
 476         u32 size = OV8858_OTP_END_ADDR - OV8858_OTP_START_ADDR + 1;
 477         int r;
 478         u16 isp_ctrl2 = 0;
 479
 480         if (!dev->otp_data) {
 481                 dev->otp_data = devm_kzalloc(&client->dev, size, GFP_KERNEL);
 482                 if (!dev->otp_data) {
 483                         dev_err(&client->dev, "%s: can't allocate memory",
 484                                 __func__);
 485                         r = -ENOMEM;
 486                         goto error3;
 487                 }
 488
 489                 /* Streaming has to be on */
 490                 r = ov8858_write_reg(client, OV8858_8BIT, OV8858_STREAM_MODE,
 491                                      0x01);
 492                 if (r)
 493                         goto error2;
 494
 495                 /* Turn off Dead Pixel Correction */
 496                 r = ov8858_read_reg(client, OV8858_8BIT,
 497                                     OV8858_OTP_ISP_CTRL2, &isp_ctrl2);
 498                 if (r)
 499                         goto error1;
 500
 501                 r = ov8858_write_reg(client, OV8858_8BIT, OV8858_OTP_ISP_CTRL2,
 502                                      isp_ctrl2 & ~OV8858_OTP_DPC_ENABLE);
 503                 if (r)
 504                         goto error1;
 505
 506                 /* Enable partial OTP read mode */
 507                 r = ov8858_write_reg(client, OV8858_8BIT, OV8858_OTP_MODE_CTRL,
 508                                      OV8858_OTP_MODE_PROGRAM_DISABLE |
 509                                      OV8858_OTP_MODE_MANUAL);
 510                 if (r)
 511                         goto error1;
 512
 513                 /* Set address range of OTP memory to read */
 514                 r = ov8858_write_reg(client, OV8858_16BIT,
 515                                      OV8858_OTP_START_ADDR_REG,
 516                                      OV8858_OTP_START_ADDR);
 517                 if (r)
 518                         goto error1;
 519
 520                 r = ov8858_write_reg(client, OV8858_16BIT,
 521                                      OV8858_OTP_END_ADDR_REG,
 522                                      OV8858_OTP_END_ADDR);
 523                 if (r)
 524                         goto error1;
 525
 526                 /* Load the OTP data into the OTP buffer */
 527                 r = ov8858_write_reg(client, OV8858_8BIT, OV8858_OTP_LOAD_CTRL,
 528                                      OV8858_OTP_LOAD_ENABLE);
 529                 if (r)
 530                         goto error1;
 531
 532                 /* Wait for the data to load into the buffer */
 533                 usleep_range(5000, 5500);
 534
 535                 /* Read the OTP data from the buffer */
 536                 r = ov8858_i2c_read(client, size, OV8858_OTP_START_ADDR,
 537                                     dev->otp_data);
 538                 if (r)
 539                         goto error1;
 540
 541                 /* Turn on Dead Pixel Correction */
 542                 r = ov8858_write_reg(client, OV8858_8BIT, OV8858_OTP_ISP_CTRL2,
 543                                      isp_ctrl2 | OV8858_OTP_DPC_ENABLE);
 544                 if (r)
 545                         goto error1;
 546
 547                 /* Stop streaming */
 548                 r = ov8858_write_reg(client, 1, OV8858_STREAM_MODE, 0x00);
 549                 if (r) {
 550                         dev_err(&client->dev, "%s: cannot turn off streaming\n",
 551                                 __func__);
 552                         goto error1;
 553                 }
 554         }
 555
 556
 557         return 0;
 558
 559 error1:
 560         /* Turn on Dead Pixel Correction and set streaming off */
 561         ov8858_write_reg(client, OV8858_8BIT, OV8858_OTP_ISP_CTRL2,
 562                              isp_ctrl2 | OV8858_OTP_DPC_ENABLE);
 563         ov8858_write_reg(client, 1, OV8858_STREAM_MODE, 0x00);
 564 error2:
 565         devm_kfree(&client->dev, dev->otp_data);
 566         dev->otp_data = NULL;
 567 error3:
 568         dev_err(&client->dev, "%s: OTP reading failed\n", __func__);
 569         return r;
 570 }
 571
 572 static int ov8858_g_priv_int_data(struct v4l2_subdev *sd,
 573                                   struct v4l2_private_int_data *priv)
 574 {
 575         struct ov8858_device *dev = to_ov8858_sensor(sd);
 576         struct i2c_client *client = v4l2_get_subdevdata(sd);
 577         u32 size = OV8858_OTP_END_ADDR - OV8858_OTP_START_ADDR + 1;
 578         int r;
 579
 580         mutex_lock(&dev->input_lock);
 581
 582         if (!dev->otp_data) {
 583                 dev_err(&client->dev, "%s: otp data is NULL\n", __func__);
 584                 mutex_unlock(&dev->input_lock);
 585                 return -EFAULT;
 586         }
 587
 588         if (copy_to_user(priv->data, dev->otp_data,
 589                          min_t(__u32, priv->size, size))) {
 590                 r = -EFAULT;
 591                 dev_err(&client->dev, "%s: OTP reading failed\n", __func__);
 592                 mutex_unlock(&dev->input_lock);
 593                 return r;
 594         }
 595
 596         priv->size = size;
 597         mutex_unlock(&dev->input_lock);
 598
 599         return 0;
 600 }
 601
 602 static int __ov8858_init(struct v4l2_subdev *sd)
 603 {
 604         struct i2c_client *client = v4l2_get_subdevdata(sd);
 605         struct ov8858_device *dev = to_ov8858_sensor(sd);
 606         int ret;
 607         dev_dbg(&client->dev, "%s\n", __func__);
 608
 609         /* Sets the default FPS */
 610         dev->fps_index = 0;
 611
 612         /* Set default exposure values (initially start values) */
 613         dev->exposure = 256;
 614         dev->gain = 16;
 615         dev->digital_gain = 1024;
 616         dev->limit_exposure_flag = false;
 617
 618         dev_dbg(&client->dev, "%s: Writing basic settings to ov8858\n",
 619                 __func__);
 620         ret = ov8858_write_reg_array(client, ov8858_BasicSettings);
 621         if (ret)
 622                 return ret;
 623
 624         return ov8858_priv_int_data_init(sd);
 625 }
 626
 627 static int ov8858_init(struct v4l2_subdev *sd, u32 val)
 628 {
 629         struct ov8858_device *dev = to_ov8858_sensor(sd);
 630         int ret;
 631
 632         mutex_lock(&dev->input_lock);
 633         ret = __ov8858_init(sd);
 634         mutex_unlock(&dev->input_lock);
 635
 636         return ret;
 637 }
 638
 639 static void ov8858_uninit(struct v4l2_subdev *sd)
 640 {
 641         struct i2c_client *client = v4l2_get_subdevdata(sd);
 642         struct ov8858_device *dev = to_ov8858_sensor(sd);
 643         struct v4l2_ctrl *ctrl;
 644         dev_dbg(&client->dev, "%s:\n", __func__);
 645
 646         dev->exposure = 0;
 647         dev->gain     = 0;
 648         dev->digital_gain = 0;
 649         dev->limit_exposure_flag = false;
 650         mutex_unlock(&dev->input_lock);
 651         ctrl = v4l2_ctrl_find(sd->ctrl_handler,
 652                                 V4L2_CID_EXPOSURE_AUTO_PRIORITY);
 653         if (ctrl)
 654                 v4l2_ctrl_s_ctrl(ctrl, V4L2_EXPOSURE_AUTO);
 655         mutex_lock(&dev->input_lock);
 656 }
 657
 658 static int ov8858_g_comp_delay(struct v4l2_subdev *sd, unsigned int *usec)
 659 {
 660         struct i2c_client *client = v4l2_get_subdevdata(sd);
 661         struct ov8858_device *dev = to_ov8858_sensor(sd);
 662         int ret = 0, exposure;
 663         u16 vts, data;
 664
 665         if (dev->exposure == 0) {
 666                 ret = ov8858_read_reg(client, OV8858_16BIT,
 667                                        OV8858_LONG_EXPO + 1, &data);
 668                 if (ret)
 669                         return ret;
 670                 exposure = data;
 671                 exposure >>= 4;
 672         } else {
 673                 exposure = dev->exposure;
 674         }
 675
 676         ret = ov8858_read_reg(client, OV8858_16BIT, OV8858_TIMING_VTS, &vts);
 677         if (ret || vts == 0)
 678                 vts = OV8858_DEPTH_VTS_CONST;
 679
 680         *usec = (exposure * 33333 / vts);
 681         if (*usec >  OV8858_DEPTH_COMP_CONST)
 682                 *usec = *usec  - OV8858_DEPTH_COMP_CONST;
 683         else
 684                 *usec = OV8858_DEPTH_COMP_CONST;
 685
 686         return 0;
 687 }
 688
 689 static long ov8858_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
 690 {
 691         struct i2c_client *client = v4l2_get_subdevdata(sd);
 692         switch (cmd) {
 693         case ATOMISP_IOC_S_EXPOSURE:
 694                 return ov8858_s_exposure(sd, (struct atomisp_exposure *)arg);
 695         case ATOMISP_IOC_G_SENSOR_PRIV_INT_DATA:
 696                 return ov8858_g_priv_int_data(sd, arg);
 697         case ATOMISP_IOC_G_DEPTH_SYNC_COMP:
 698                 return ov8858_g_comp_delay(sd, (unsigned int *)arg);
 699         case ATOMISP_IOC_G_UPDATE_EXPOSURE:
 700                 return ov8858_g_update_exposure(sd,
 701                                 (struct atomisp_update_exposure *)arg);
 702         default:
 703                 dev_dbg(&client->dev, "Unhandled command 0x%X\n", cmd);
 704                 return -EINVAL;
 705         }
 706 }
 707
 708 static int __power_ctrl(struct v4l2_subdev *sd, bool flag)
 709 {
 710         int ret = 0;
 711         struct ov8858_device *dev = to_ov8858_sensor(sd);
 712         struct i2c_client *client = v4l2_get_subdevdata(sd);
 713
 714         if (!dev || !dev->platform_data)
 715                 return -ENODEV;
 716
 717         /* Non-gmin platforms use the legacy callback */
 718         if (dev->platform_data->power_ctrl)
 719                 return dev->platform_data->power_ctrl(sd, flag);
 720
 721         if (dev->platform_data->v1p2_ctrl) {
 722                 ret = dev->platform_data->v1p2_ctrl(sd, flag);
 723                 if (ret) {
 724                         dev_err(&client->dev,
 725                                 "failed to power %s 1.2v power rail\n",
 726                                 flag ? "up" : "down");
 727                         return ret;
 728                 }
 729         }
 730
 731         if (dev->platform_data->v2p8_ctrl) {
 732                 ret = dev->platform_data->v2p8_ctrl(sd, flag);
 733                 if (ret) {
 734                         dev_err(&client->dev,
 735                                 "failed to power %s 2.8v power rail\n",
 736                                 flag ? "up" : "down");
 737                         return ret;
 738                 }
 739         }
 740
 741         if (dev->platform_data->v1p8_ctrl) {
 742                 ret = dev->platform_data->v1p8_ctrl(sd, flag);
 743                 if (ret) {
 744                         dev_err(&client->dev,
 745                                 "failed to power %s 1.8v power rail\n",
 746                                 flag ? "up" : "down");
 747                         if (dev->platform_data->v2p8_ctrl)
 748                                 dev->platform_data->v2p8_ctrl(sd, 0);
 749                         return ret;
 750                 }
 751         }
 752
 753         if (flag)
 754                 msleep(20); /* Wait for power lines to stabilize */
 755         return ret;
 756 }
 757
 758 static int __gpio_ctrl(struct v4l2_subdev *sd, bool flag)
 759 {
 760         struct i2c_client *client;
 761         struct ov8858_device *dev;
 762
 763         if (!sd)
 764                 return -EINVAL;
 765
 766         client = v4l2_get_subdevdata(sd);
 767         dev = to_ov8858_sensor(sd);
 768
 769         if (!client || !dev || !dev->platform_data)
 770                 return -ENODEV;
 771
 772         /* Non-gmin platforms use the legacy callback */
 773         if (dev->platform_data->gpio_ctrl)
 774                 return dev->platform_data->gpio_ctrl(sd, flag);
 775
 776         if (dev->platform_data->gpio0_ctrl)
 777                 return dev->platform_data->gpio0_ctrl(sd, flag);
 778
 779         dev_err(&client->dev, "failed to find platform gpio callback\n");
 780
 781         return -EINVAL;
 782 }
 783
 784 static int power_up(struct v4l2_subdev *sd)
 785 {
 786         struct i2c_client *client = v4l2_get_subdevdata(sd);
 787         struct ov8858_device *dev = to_ov8858_sensor(sd);
 788         int ret;
 789         dev_dbg(&client->dev, "%s\n", __func__);
 790
 791         /* Enable power */
 792         ret = __power_ctrl(sd, 1);
 793         if (ret) {
 794                 dev_err(&client->dev, "power rail on failed %d.\n", ret);
 795                 goto fail_power;
 796         }
 797
 798         /* Enable clock */
 799         ret = dev->platform_data->flisclk_ctrl(sd, 1);
 800         if (ret) {
 801                 dev_err(&client->dev, "flisclk on failed %d\n", ret);
 802                 goto fail_clk;
 803         }
 804
 805         /* Release reset */
 806         ret = __gpio_ctrl(sd, 1);
 807         if (ret) {
 808                 dev_err(&client->dev, "gpio on failed %d\n", ret);
 809                 goto fail_gpio;
 810         }
 811
 812         /* Minumum delay is 8192 clock cycles before first i2c transaction,
 813          * which is 1.37 ms at the lowest allowed clock rate 6 MHz */
 814         usleep_range(2000, 2500);
 815         return 0;
 816
 817 fail_gpio:
 818         dev->platform_data->flisclk_ctrl(sd, 0);
 819 fail_clk:
 820         __power_ctrl(sd, 0);
 821 fail_power:
 822         dev_err(&client->dev, "Sensor power-up failed\n");
 823
 824         return ret;
 825 }
 826
 827 static int power_down(struct v4l2_subdev *sd)
 828 {
 829         struct ov8858_device *dev = to_ov8858_sensor(sd);
 830         struct i2c_client *client = v4l2_get_subdevdata(sd);
 831         int ret;
 832         dev_dbg(&client->dev, "%s\n", __func__);
 833
 834         ret = dev->platform_data->flisclk_ctrl(sd, 0);
 835         if (ret)
 836                 dev_err(&client->dev, "flisclk off failed\n");
 837
 838         ret = __gpio_ctrl(sd, 0);
 839         if (ret)
 840                 dev_err(&client->dev, "gpio off failed\n");
 841
 842         ret = __power_ctrl(sd, 0);
 843         if (ret)
 844                 dev_err(&client->dev, "power rail off failed.\n");
 845
 846         return ret;
 847 }
 848
 849 static int __ov8858_s_power(struct v4l2_subdev *sd, int on)
 850 {
 851         struct ov8858_device *dev = to_ov8858_sensor(sd);
 852         int ret, r = 0;
 853
 854         if (on == 0) {
 855                 ov8858_uninit(sd);
 856                 if (dev->vcm_driver && dev->vcm_driver->power_down)
 857                         r = dev->vcm_driver->power_down(sd);
 858                 ret = power_down(sd);
 859                 if (r != 0 && ret == 0)
 860                         ret = r;
 861         } else {
 862                 ret = power_up(sd);
 863                 if (ret)
 864                         power_down(sd);
 865                 if (dev->vcm_driver && dev->vcm_driver->power_up) {
 866                         ret = dev->vcm_driver->power_up(sd);
 867                         if (ret) {
 868                                 power_down(sd);
 869                                 return ret;
 870                         }
 871                 }
 872                 return __ov8858_init(sd);
 873         }
 874
 875         return ret;
 876 }
 877
 878 static int ov8858_s_power(struct v4l2_subdev *sd, int on)
 879 {
 880         int ret;
 881         struct ov8858_device *dev = to_ov8858_sensor(sd);
 882
 883         mutex_lock(&dev->input_lock);
 884         ret = __ov8858_s_power(sd, on);
 885         mutex_unlock(&dev->input_lock);
 886
 887         /*
 888          * FIXME: Compatibility with old behaviour: return to preview
 889          * when the device is power cycled.
 890          */
 891         if (!ret && on)
 892                 v4l2_ctrl_s_ctrl(dev->run_mode, ATOMISP_RUN_MODE_PREVIEW);
 893
 894         return ret;
 895 }
 896
 897 /*
 898  * Return value of the specified register, first try getting it from
 899  * the register list and if not found, get from the sensor via i2c.
 900  */
 901 static int ov8858_get_register(struct v4l2_subdev *sd, int reg, int type,
 902                                const struct ov8858_reg *reglist)
 903 {
 904         struct i2c_client *client = v4l2_get_subdevdata(sd);
 905         const struct ov8858_reg *next;
 906         u16 val;
 907
 908         /* Try if the values are in the register list */
 909         for (next = reglist; next->type != OV8858_TOK_TERM; next++) {
 910                 if (next->sreg == reg) {
 911                         if (type == OV8858_8BIT)
 912                                 return next->val;
 913
 914                         if (type == OV8858_16BIT &&
 915                             next[1].type != OV8858_TOK_TERM)
 916                                 return next[0].val << 8 | next[1].val;
 917                 }
 918         }
 919
 920         /* If not, read from sensor */
 921         if (ov8858_read_reg(client, type, reg, &val)) {
 922                 dev_err(&client->dev, "failed to read register 0x%08x\n", reg);
 923                 return -EIO;
 924         }
 925
 926         return val;
 927 }
 928
 929 static inline int ov8858_get_register_16bit(struct v4l2_subdev *sd, int reg,
 930                                             const struct ov8858_reg *reglist)
 931 {
 932         return ov8858_get_register(sd, reg, OV8858_16BIT, reglist);
 933 }
 934
 935 static inline int ov8858_get_register_8bit(struct v4l2_subdev *sd, int reg,
 936                                            const struct ov8858_reg *reglist)
 937 {
 938         return ov8858_get_register(sd, reg, OV8858_8BIT, reglist);
 939 }
 940
 941 static int __ov8858_get_pll1_values(struct v4l2_subdev *sd,
 942                                     int *value,
 943                                     const struct ov8858_reg *reglist)
 944 {
 945         struct i2c_client *client = v4l2_get_subdevdata(sd);
 946         unsigned int prediv_idx;
 947         unsigned int multiplier;
 948         unsigned int sys_prediv;
 949         unsigned int prediv_coef[] = {2, 3, 4, 5, 6, 8, 12, 16};
 950         int ret;
 951
 952         ret = ov8858_get_register_8bit(sd, OV8858_PLL1_PREDIV0, reglist);
 953         if (ret < 0)
 954                 return ret;
 955
 956         if (ret & OV8858_PLL1_PREDIV0_MASK)
 957                 *value /= 2;
 958
 959         ret = ov8858_get_register_8bit(sd, OV8858_PLL1_PREDIV, reglist);
 960
 961         if (ret < 0)
 962                 return ret;
 963
 964         prediv_idx = ret & OV8858_PLL1_PREDIV_MASK;
 965         *value = *value * 2 / prediv_coef[prediv_idx];
 966
 967         ret = ov8858_get_register_16bit(sd, OV8858_PLL1_MULTIPLIER, reglist);
 968         if (ret < 0)
 969                 return ret;
 970
 971         multiplier = ret;
 972         *value *= multiplier & OV8858_PLL1_MULTIPLIER_MASK;
 973         ret = ov8858_get_register_8bit(sd, OV8858_PLL1_SYS_PRE_DIV, reglist);
 974
 975         if (ret < 0)
 976                 return ret;
 977
 978         sys_prediv = ret & OV8858_PLL1_SYS_PRE_DIV_MASK;
 979         *value /= (sys_prediv + 3);
 980         ret = ov8858_get_register_8bit(sd, OV8858_PLL1_SYS_DIVIDER, reglist);
 981
 982         if (ret < 0)
 983                 return ret;
 984
 985         if (ret & OV8858_PLL1_SYS_DIVIDER_MASK)
 986                 *value /= 2;
 987
 988         dev_dbg(&client->dev, "%s: *value: %d\n", __func__, *value);
 989
 990         return 0;
 991 }
 992
 993 static int __ov8858_get_pll2a_values(struct v4l2_subdev *sd, int *value,
 994                                      const struct ov8858_reg *reglist)
 995 {
 996         struct i2c_client *client = v4l2_get_subdevdata(sd);
 997         unsigned int prediv_idx;
 998         unsigned int multiplier;
 999         unsigned int prediv_coef[] = {2, 3, 4, 5, 6, 8, 12, 16};
1000         int ret;
1001
1002         ret = ov8858_get_register_8bit(sd, OV8858_PLL2_PREDIV0, reglist);
1003         if (ret < 0)
1004                 return ret;
1005
1006         if (ret & OV8858_PLL2_PREDIV0_MASK)
1007                 *value /= 2;
1008
1009         ret = ov8858_get_register_8bit(sd, OV8858_PLL2_PREDIV, reglist);
1010         if (ret < 0)
1011                 return ret;
1012
1013         prediv_idx = (ret & OV8858_PLL2_PREDIV_MASK);
1014         *value = *value * 2 / prediv_coef[prediv_idx];
1015
1016         ret = ov8858_get_register_16bit(sd, OV8858_PLL2_MULTIPLIER, reglist);
1017         if (ret < 0)
1018                 return ret;
1019
1020         multiplier = ret;
1021         *value *= multiplier & OV8858_PLL2_MULTIPLIER_MASK;
1022         dev_dbg(&client->dev, "%s: *value: %d\n", __func__, *value);
1023
1024         return 0;
1025 }
1026 static int __ov8858_get_pll2b_values(struct v4l2_subdev *sd, int *value,
1027                                      const struct ov8858_reg *reglist)
1028 {
1029         struct i2c_client *client = v4l2_get_subdevdata(sd);
1030         unsigned int dac_divider;
1031         int ret;
1032
1033         ret = ov8858_get_register_8bit(sd, OV8858_PLL2_DAC_DIVIDER, reglist);
1034         if (ret < 0)
1035                 return ret;
1036
1037         dac_divider = (ret & OV8858_PLL2_DAC_DIVIDER_MASK) + 1;
1038         *value /= dac_divider;
1039
1040         dev_dbg(&client->dev, "%s: *value: %d\n", __func__, *value);
1041
1042         return 0;
1043 }
1044 static int __ov8858_get_pll2c_values(struct v4l2_subdev *sd, int *value,
1045                                      const struct ov8858_reg *reglist)
1046 {
1047         struct i2c_client *client = v4l2_get_subdevdata(sd);
1048         unsigned int sys_pre_div;
1049         unsigned int sys_divider_idx;
1050         unsigned int sys_divider_coef[] = {2, 3, 4, 5, 6, 7, 8, 10};
1051         int ret;
1052
1053         ret = ov8858_get_register_8bit(sd, OV8858_PLL2_SYS_PRE_DIV, reglist);
1054         if (ret < 0)
1055                 return ret;
1056
1057         sys_pre_div = (ret & OV8858_PLL2_SYS_PRE_DIV_MASK) + 1;
1058         *value /= sys_pre_div;
1059
1060         ret = ov8858_get_register_8bit(sd, OV8858_PLL2_SYS_DIVIDER, reglist);
1061         if (ret < 0)
1062                 return ret;
1063
1064         sys_divider_idx = ret & OV8858_PLL2_SYS_DIVIDER_MASK;
1065         *value *= 2 /  sys_divider_coef[sys_divider_idx];
1066
1067         dev_dbg(&client->dev, "%s: *value: %d\n", __func__, *value);
1068
1069         return 0;
1070 }
1071
1072 static int ov8858_get_intg_factor(struct v4l2_subdev *sd,
1073                                   struct camera_mipi_info *info,
1074                                   const struct ov8858_reg *reglist)
1075 {
1076         const unsigned int ext_clk = 19200000; /* Hz */
1077         struct atomisp_sensor_mode_data *m = &info->data;
1078         struct ov8858_device *dev = to_ov8858_sensor(sd);
1079         struct i2c_client *client = v4l2_get_subdevdata(sd);
1080         struct device *d = &client->dev;
1081         const struct ov8858_resolution *res =
1082                                 &dev->curr_res_table[dev->fmt_idx];
1083         unsigned int pll_sclksel1;
1084         unsigned int pll_sclksel2;
1085         unsigned int sys_pre_div;
1086         unsigned int sclk_pdiv;
1087         unsigned int sclk = ext_clk;
1088         u16 hts;
1089         int ret;
1090
1091         memset(&info->data, 0, sizeof(info->data));
1092
1093         ret = ov8858_get_register_8bit(sd, OV8858_PLL_SCLKSEL1, reglist);
1094         if (ret < 0)
1095                 return ret;
1096
1097         dev_dbg(d, "%s: OV8858_PLL_SCLKSEL1: 0x%02x\n", __func__, ret);
1098         pll_sclksel1 = ret & OV8858_PLL_SCLKSEL1_MASK;
1099
1100         ret = ov8858_get_register_8bit(sd, OV8858_PLL_SCLKSEL2, reglist);
1101         if (ret < 0)
1102                 return ret;
1103
1104         dev_dbg(d, "%s: OV8858_PLL_SCLKSEL2: 0x%02x\n", __func__, ret);
1105         pll_sclksel2 = ret & OV8858_PLL_SCLKSEL2_MASK;
1106
1107         if (pll_sclksel2) {
1108                 ret = __ov8858_get_pll2a_values(sd, &sclk, reglist);
1109                 if (ret < 0)
1110                         return ret;
1111                 ret = __ov8858_get_pll2b_values(sd, &sclk, reglist);
1112                 if (ret < 0)
1113                         return ret;
1114         } else if (pll_sclksel1) {
1115                 ret = __ov8858_get_pll2a_values(sd, &sclk, reglist);
1116                 if (ret < 0)
1117                         return ret;
1118                 ret = __ov8858_get_pll2c_values(sd, &sclk, reglist);
1119                 if (ret < 0)
1120                         return ret;
1121         } else {
1122                 ret = __ov8858_get_pll1_values(sd, &sclk, reglist);
1123                 if (ret < 0)
1124                         return ret;
1125         }
1126
1127         ret = ov8858_get_register_8bit(sd, OV8858_SRB_HOST_INPUT_DIS, reglist);
1128         if (ret < 0)
1129                 return ret;
1130
1131         dev_dbg(d, "%s: OV8858_SRB_HOST_INPUT_DIS: 0x%02x\n", __func__, ret);
1132
1133         sys_pre_div = ret & OV8858_SYS_PRE_DIV_MASK;
1134         sys_pre_div >>= OV8858_SYS_PRE_DIV_OFFSET;
1135
1136         if (sys_pre_div == 1)
1137                 sclk /= 2;
1138         else if (sys_pre_div == 2)
1139                 sclk /= 4;
1140
1141         sclk_pdiv = ret & OV8858_SCLK_PDIV_MASK;
1142         sclk_pdiv >>= OV8858_SCLK_PDIV_OFFSET;
1143
1144         if (sclk_pdiv > 1)
1145                 sclk /= sclk_pdiv;
1146
1147         dev_dbg(d, "%s: sclk: %d\n", __func__, sclk);
1148
1149         dev->vt_pix_clk_freq_mhz = sclk;
1150         m->vt_pix_clk_freq_mhz = sclk;
1151
1152         /* HTS and VTS */
1153         m->frame_length_lines =
1154                         res->fps_options[dev->fps_index].lines_per_frame;
1155         m->line_length_pck = res->fps_options[dev->fps_index].pixels_per_line;
1156
1157         m->coarse_integration_time_min = 0;
1158         m->coarse_integration_time_max_margin = OV8858_INTEGRATION_TIME_MARGIN;
1159         ret = ov8858_read_reg(client, OV8858_16BIT, OV8858_TIMING_HTS, &hts);
1160         if (ret < 0)
1161                 return ret;
1162         m->hts = hts;
1163         dev_dbg(&client->dev, "%s: get HTS %d\n", __func__, hts);
1164
1165         /* OV Sensor do not use fine integration time. */
1166         m->fine_integration_time_min = 0;
1167         m->fine_integration_time_max_margin = 0;
1168
1169         /*
1170          * read_mode indicate whether binning is used for calculating
1171          * the correct exposure value from the user side. So adapt the
1172          * read mode values accordingly.
1173          */
1174         m->read_mode = res->bin_factor_x ?
1175                 OV8858_READ_MODE_BINNING_ON : OV8858_READ_MODE_BINNING_OFF;
1176
1177         ret = ov8858_get_register_8bit(sd, OV8858_H_INC_ODD, res->regs);
1178         if (ret < 0)
1179                 return ret;
1180         m->binning_factor_x = (ret + 1) / 2;
1181
1182         ret = ov8858_get_register_8bit(sd, OV8858_V_INC_ODD, res->regs);
1183         if (ret < 0)
1184                 return ret;
1185         m->binning_factor_y = (ret + 1) / 2;
1186
1187         /* Get the cropping and output resolution to ISP for this mode. */
1188         ret =  ov8858_get_register_16bit(sd, OV8858_HORIZONTAL_START_H,
1189                                          res->regs);
1190         if (ret < 0)
1191                 return ret;
1192
1193         m->crop_horizontal_start = ret;
1194
1195         ret = ov8858_get_register_16bit(sd, OV8858_VERTICAL_START_H, res->regs);
1196         if (ret < 0)
1197                 return ret;
1198
1199         m->crop_vertical_start = ret;
1200
1201         ret = ov8858_get_register_16bit(sd, OV8858_HORIZONTAL_END_H, res->regs);
1202         if (ret < 0)
1203                 return ret;
1204
1205         m->crop_horizontal_end = ret;
1206
1207         ret = ov8858_get_register_16bit(sd, OV8858_VERTICAL_END_H, res->regs);
1208         if (ret < 0)
1209                 return ret;
1210
1211         m->crop_vertical_end = ret;
1212
1213         ret = ov8858_get_register_16bit(sd, OV8858_HORIZONTAL_OUTPUT_SIZE_H,
1214                                         res->regs);
1215         if (ret < 0)
1216                 return ret;
1217
1218         m->output_width = ret;
1219
1220         ret = ov8858_get_register_16bit(sd, OV8858_VERTICAL_OUTPUT_SIZE_H,
1221                                         res->regs);
1222         if (ret < 0)
1223                 return ret;
1224
1225         m->output_height = ret;
1226
1227         return 0;
1228 }
1229
1230 /*
1231  * distance - calculate the distance
1232  * @res: resolution
1233  * @w: width
1234  * @h: height
1235  *
1236  * Get the gap between res_w/res_h and w/h.
1237  * distance = (res_w/res_h - w/h) / (w/h) * 8192
1238  * res->width/height smaller than w/h wouldn't be considered.
1239  * The gap of ratio larger than 1/8 wouldn't be considered.
1240  * Returns the value of gap or -1 if fail.
1241  */
1242 #define LARGEST_ALLOWED_RATIO_MISMATCH 1024
1243 static int distance(struct ov8858_resolution const *res, const u32 w,
1244                     const u32 h)
1245 {
1246         int ratio;
1247         int distance;
1248
1249         if (w == 0 || h == 0 ||
1250                 res->width < w || res->height < h)
1251                 return -1;
1252
1253         ratio = res->width << 13;
1254         ratio /= w;
1255         ratio *= h;
1256         ratio /= res->height;
1257
1258         distance = abs(ratio - 8192);
1259
1260         if (distance > LARGEST_ALLOWED_RATIO_MISMATCH)
1261                 return -1;
1262         return distance;
1263 }
1264
1265 /*
1266  * Returns the nearest higher resolution index.
1267  * @w: width
1268  * @h: height
1269  * matching is done based on enveloping resolution and
1270  * aspect ratio. If the aspect ratio cannot be matched
1271  * to any index, -1 is returned.
1272  */
1273 static int nearest_resolution_index(struct v4l2_subdev *sd, int w, int h)
1274 {
1275         int i;
1276         int idx = -1;
1277         int dist;
1278         int fps_diff;
1279         int min_fps_diff = INT_MAX;
1280         int min_dist = INT_MAX;
1281         int min_res_w = INT_MAX;
1282         const struct ov8858_resolution *tmp_res = NULL;
1283         struct i2c_client *client = v4l2_get_subdevdata(sd);
1284         struct ov8858_device *dev = to_ov8858_sensor(sd);
1285         dev_dbg(&client->dev, "%s: w=%d, h=%d\n", __func__, w, h);
1286
1287         for (i = 0; i < dev->entries_curr_table; i++) {
1288                 tmp_res = &dev->curr_res_table[i];
1289                 dist = distance(tmp_res, w, h);
1290                 dev_dbg(&client->dev,
1291                         "%s[%d]: %dx%d distance=%d\n", tmp_res->desc,
1292                         i, tmp_res->width, tmp_res->height, dist);
1293                 if (dist == -1)
1294                         continue;
1295                 if (dist < min_dist) {
1296                         min_dist = dist;
1297                         min_res_w = tmp_res->width;
1298                         min_fps_diff = __ov8858_min_fps_diff(dev->fps,
1299                                                 tmp_res->fps_options);
1300                         idx = i;
1301                 }
1302                 if (dist == min_dist) {
1303                         fps_diff = __ov8858_min_fps_diff(dev->fps,
1304                                                 tmp_res->fps_options);
1305                         if (fps_diff < min_fps_diff) {
1306                                 min_fps_diff = fps_diff;
1307                                 idx = i;
1308                         }
1309                         if (tmp_res->width < min_res_w) {
1310                                 min_res_w = tmp_res->width;
1311                                 idx = i;
1312                         }
1313                 }
1314         }
1315
1316         return idx;
1317 }
1318
1319 static int ov8858_set_fmt(struct v4l2_subdev *sd,
1320                           struct v4l2_subdev_pad_config *cfg,
1321                           struct v4l2_subdev_format *format)
1322 {
1323         struct v4l2_mbus_framefmt *fmt = &format->format;
1324         struct ov8858_device *dev = to_ov8858_sensor(sd);
1325         struct camera_mipi_info *ov8858_info = NULL;
1326         struct i2c_client *client = v4l2_get_subdevdata(sd);
1327         const struct ov8858_resolution *res;
1328         int ret;
1329         int idx;
1330         if (format->pad)
1331                 return -EINVAL;
1332         if (!fmt)
1333                 return -EINVAL;
1334
1335         ov8858_info = v4l2_get_subdev_hostdata(sd);
1336         if (ov8858_info == NULL)
1337                 return -EINVAL;
1338
1339         mutex_lock(&dev->input_lock);
1340
1341         if ((fmt->width > OV8858_RES_WIDTH_MAX) ||
1342             (fmt->height > OV8858_RES_HEIGHT_MAX)) {
1343                 fmt->width = OV8858_RES_WIDTH_MAX;
1344                 fmt->height = OV8858_RES_HEIGHT_MAX;
1345         } else {
1346                 idx = nearest_resolution_index(sd, fmt->width, fmt->height);
1347
1348                 /*
1349                  * nearest_resolution_index() doesn't return smaller
1350                  * resolutions. If it fails, it means the requested resolution
1351                  * is higher than we can support. Fallback to highest possible
1352                  * resolution in this case.
1353                  */
1354                 if (idx == -1)
1355                         idx = dev->entries_curr_table - 1;
1356
1357                 fmt->width = dev->curr_res_table[idx].width;
1358                 fmt->height = dev->curr_res_table[idx].height;
1359         }
1360
1361         fmt->code = MEDIA_BUS_FMT_SBGGR10_1X10;
1362         if (format->which == V4L2_SUBDEV_FORMAT_TRY) {
1363                 cfg->try_fmt = *fmt;
1364                 mutex_unlock(&dev->input_lock);
1365                 return 0;
1366         }
1367
1368         dev->fmt_idx = nearest_resolution_index(sd, fmt->width, fmt->height);
1369         if (dev->fmt_idx == -1) {
1370                 ret = -EINVAL;
1371                 goto out;
1372         }
1373         res = &dev->curr_res_table[dev->fmt_idx];
1374         dev_dbg(&client->dev, "%s: selected width = %d, height = %d\n",
1375                 __func__, res->width, res->height);
1376
1377         /* Adjust the FPS selection based on the resolution selected */
1378         dev->fps_index = __ov8858_nearest_fps_index(dev->fps, res->fps_options);
1379         dev->fps = res->fps_options[dev->fps_index].fps;
1380         dev->regs = res->fps_options[dev->fps_index].regs;
1381         if (!dev->regs)
1382                 dev->regs = res->regs;
1383
1384         ret = ov8858_write_reg_array(client, dev->regs);
1385         if (ret)
1386                 goto out;
1387
1388         dev->pixels_per_line = res->fps_options[dev->fps_index].pixels_per_line;
1389         dev->lines_per_frame = res->fps_options[dev->fps_index].lines_per_frame;
1390
1391         /* ov8858 only support RGB RAW10 output */
1392         ov8858_info->metadata_width = res->width * 10 / 8;
1393         ov8858_info->metadata_height = 2;
1394         ov8858_info->metadata_format = ATOMISP_INPUT_FORMAT_EMBEDDED;
1395
1396         /* Set the initial exposure */
1397         ret = __ov8858_set_exposure(sd, dev->exposure, dev->gain,
1398                                     dev->digital_gain, &dev->pixels_per_line,
1399                                     &dev->lines_per_frame);
1400         if (ret)
1401                 goto out;
1402
1403         ret = ov8858_get_intg_factor(sd, ov8858_info, dev->regs);
1404
1405 out:
1406         mutex_unlock(&dev->input_lock);
1407
1408         return ret;
1409 }
1410
1411 static int ov8858_get_fmt(struct v4l2_subdev *sd,
1412                           struct v4l2_subdev_pad_config *cfg,
1413                           struct v4l2_subdev_format *format)
1414 {
1415         struct v4l2_mbus_framefmt *fmt = &format->format;
1416         struct ov8858_device *dev = to_ov8858_sensor(sd);
1417
1418         if (format->pad)
1419                 return -EINVAL;
1420         if (!fmt)
1421                 return -EINVAL;
1422
1423         mutex_lock(&dev->input_lock);
1424         fmt->width = dev->curr_res_table[dev->fmt_idx].width;
1425         fmt->height = dev->curr_res_table[dev->fmt_idx].height;
1426         fmt->code = MEDIA_BUS_FMT_SBGGR10_1X10;
1427         mutex_unlock(&dev->input_lock);
1428
1429         return 0;
1430 }
1431
1432 static int ov8858_detect(struct i2c_client *client, u16 *id)
1433 {
1434         struct i2c_adapter *adapter = client->adapter;
1435         u16 id_hi = 0;
1436         u16 id_low = 0;
1437         int ret;
1438
1439         /* i2c check */
1440         if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
1441                 return -ENODEV;
1442
1443         dev_dbg(&client->dev, "%s: I2C functionality ok\n", __func__);
1444         ret = ov8858_read_reg(client, OV8858_8BIT, OV8858_CHIP_ID_HIGH, &id_hi);
1445         if (ret)
1446                 return ret;
1447         dev_dbg(&client->dev, "%s: id_high = 0x%04x\n", __func__, id_hi);
1448         ret = ov8858_read_reg(client, OV8858_8BIT, OV8858_CHIP_ID_LOW, &id_low);
1449         if (ret)
1450                 return ret;
1451         dev_dbg(&client->dev, "%s: id_low = 0x%04x\n", __func__, id_low);
1452         *id = (id_hi << 8) | id_low;
1453
1454         dev_dbg(&client->dev, "%s: chip_id = 0x%04x\n", __func__, *id);
1455
1456         dev_info(&client->dev, "%s: chip_id = 0x%04x\n", __func__, *id);
1457         if (*id != OV8858_CHIP_ID)
1458                 return -ENODEV;
1459
1460         /* Stream off now. */
1461         return ov8858_write_reg(client, OV8858_8BIT, OV8858_STREAM_MODE, 0);
1462 }
1463
1464 static void __ov8858_print_timing(struct v4l2_subdev *sd)
1465 {
1466         struct ov8858_device *dev = to_ov8858_sensor(sd);
1467         struct i2c_client *client = v4l2_get_subdevdata(sd);
1468         u16 width = dev->curr_res_table[dev->fmt_idx].width;
1469         u16 height = dev->curr_res_table[dev->fmt_idx].height;
1470
1471         dev_dbg(&client->dev, "Dump ov8858 timing in stream on:\n");
1472         dev_dbg(&client->dev, "width: %d:\n", width);
1473         dev_dbg(&client->dev, "height: %d:\n", height);
1474         dev_dbg(&client->dev, "pixels_per_line: %d:\n", dev->pixels_per_line);
1475         dev_dbg(&client->dev, "line per frame: %d:\n", dev->lines_per_frame);
1476         dev_dbg(&client->dev, "pix freq: %d:\n", dev->vt_pix_clk_freq_mhz);
1477         /* updated formula: pixels_per_line = 2 * HTS */
1478         /* updated formula: fps = SCLK / (VTS * HTS) */
1479         dev_dbg(&client->dev, "init fps: %d:\n", dev->vt_pix_clk_freq_mhz /
1480                 (dev->pixels_per_line / 2) / dev->lines_per_frame);
1481         dev_dbg(&client->dev, "HBlank: %d nS:\n",
1482                 1000 * (dev->pixels_per_line - width) /
1483                 (dev->vt_pix_clk_freq_mhz / 1000000));
1484         dev_dbg(&client->dev, "VBlank: %d uS:\n",
1485                 (dev->lines_per_frame - height) * dev->pixels_per_line /
1486                 (dev->vt_pix_clk_freq_mhz / 1000000));
1487 }
1488
1489 /*
1490  * ov8858 stream on/off
1491  */
1492 static int ov8858_s_stream(struct v4l2_subdev *sd, int enable)
1493 {
1494         struct ov8858_device *dev = to_ov8858_sensor(sd);
1495         struct i2c_client *client = v4l2_get_subdevdata(sd);
1496         int ret;
1497         u16 val;
1498         dev_dbg(&client->dev, "%s: enable = %d\n", __func__, enable);
1499
1500         /* Set orientation */
1501         ret = ov8858_read_reg(client, OV8858_8BIT, OV8858_FORMAT2, &val);
1502         if (ret)
1503                 return ret;
1504
1505         ret = ov8858_write_reg(client, OV8858_8BIT, OV8858_FORMAT2,
1506                                dev->hflip ? val | OV8858_FLIP_ENABLE :
1507                                val & ~OV8858_FLIP_ENABLE);
1508         if (ret)
1509                 return ret;
1510
1511         ret = ov8858_read_reg(client, OV8858_8BIT, OV8858_FORMAT1, &val);
1512         if (ret)
1513                 return ret;
1514
1515         ret = ov8858_write_reg(client, OV8858_8BIT, OV8858_FORMAT1,
1516                                dev->vflip ? val | OV8858_FLIP_ENABLE :
1517                                val & ~OV8858_FLIP_ENABLE);
1518         if (ret)
1519                 return ret;
1520
1521         mutex_lock(&dev->input_lock);
1522         if (enable) {
1523                 __ov8858_print_timing(sd);
1524                 ret = ov8858_write_reg_array(client, ov8858_streaming);
1525                 if (ret != 0) {
1526                         dev_err(&client->dev, "write_reg_array err\n");
1527                         goto out;
1528                 }
1529                 dev->streaming = 1;
1530         } else {
1531                 ret = ov8858_write_reg_array(client, ov8858_soft_standby);
1532                 if (ret != 0) {
1533                         dev_err(&client->dev, "write_reg_array err\n");
1534                         goto out;
1535                 }
1536                 dev->streaming = 0;
1537                 dev->fps_index = 0;
1538                 dev->fps = 0;
1539         }
1540 out:
1541         mutex_unlock(&dev->input_lock);
1542         return ret;
1543 }
1544
1545 static int __update_ov8858_device_settings(struct ov8858_device *dev,
1546                                            u16 sensor_id)
1547 {
1548         if (sensor_id == OV8858_CHIP_ID)
1549 #ifdef CONFIG_PLATFORM_BTNS
1550                 dev->vcm_driver = &ov8858_vcms[OV8858_ID_DEFAULT];
1551 #else
1552                 dev->vcm_driver = &ov8858_vcms[OV8858_SUNNY];
1553 #endif
1554         else
1555                 return -ENODEV;
1556
1557         if (dev->vcm_driver && dev->vcm_driver->init)
1558                 return dev->vcm_driver->init(&dev->sd);
1559
1560         return 0;
1561 }
1562
1563 static int ov8858_s_config(struct v4l2_subdev *sd,
1564                            int irq, void *pdata)
1565 {
1566         struct ov8858_device *dev = to_ov8858_sensor(sd);
1567         struct i2c_client *client = v4l2_get_subdevdata(sd);
1568         u16 sensor_id;
1569         int ret;
1570
1571         if (pdata == NULL)
1572                 return -ENODEV;
1573
1574         dev->platform_data = pdata;
1575
1576         mutex_lock(&dev->input_lock);
1577
1578         if (dev->platform_data->platform_init) {
1579                 ret = dev->platform_data->platform_init(client);
1580                 if (ret) {
1581                         mutex_unlock(&dev->input_lock);
1582                         dev_err(&client->dev, "platform init error %d!\n", ret);
1583                         return ret;
1584                 }
1585         }
1586
1587         ret = __ov8858_s_power(sd, 1);
1588         if (ret) {
1589                 dev_err(&client->dev, "power-up error %d!\n", ret);
1590                 mutex_unlock(&dev->input_lock);
1591                 return ret;
1592         }
1593
1594         ret = dev->platform_data->csi_cfg(sd, 1);
1595         if (ret)
1596                 goto fail_csi_cfg;
1597
1598         /* config & detect sensor */
1599         ret = ov8858_detect(client, &sensor_id);
1600         if (ret) {
1601                 dev_err(&client->dev, "detect error %d!\n", ret);
1602                 goto fail_detect;
1603         }
1604
1605         dev->sensor_id = sensor_id;
1606
1607         /* power off sensor */
1608         ret = __ov8858_s_power(sd, 0);
1609         if (ret) {
1610                 dev->platform_data->csi_cfg(sd, 0);
1611                 dev_err(&client->dev, "__ov8858_s_power-down error %d!\n", ret);
1612                 goto fail_update;
1613         }
1614
1615         /* Resolution settings depend on sensor type and platform */
1616         ret = __update_ov8858_device_settings(dev, dev->sensor_id);
1617         if (ret) {
1618                 dev->platform_data->csi_cfg(sd, 0);
1619                 dev_err(&client->dev, "__update_ov8858_device_settings error %d!\n", ret);
1620                 goto fail_update;
1621         }
1622
1623         mutex_unlock(&dev->input_lock);
1624         return ret;
1625
1626 fail_detect:
1627         dev->platform_data->csi_cfg(sd, 0);
1628 fail_csi_cfg:
1629         __ov8858_s_power(sd, 0);
1630 fail_update:
1631         if (dev->platform_data->platform_deinit)
1632                 dev->platform_data->platform_deinit();
1633         mutex_unlock(&dev->input_lock);
1634         dev_err(&client->dev, "sensor power-gating failed\n");
1635         return ret;
1636 }
1637
1638 static int
1639 ov8858_enum_mbus_code(struct v4l2_subdev *sd,
1640                       struct v4l2_subdev_pad_config *cfg,
1641                       struct v4l2_subdev_mbus_code_enum *code)
1642 {
1643         if (code->index)
1644                 return -EINVAL;
1645         code->code = MEDIA_BUS_FMT_SBGGR10_1X10;
1646
1647         return 0;
1648 }
1649
1650 static int
1651 ov8858_enum_frame_size(struct v4l2_subdev *sd,
1652                        struct v4l2_subdev_pad_config *cfg,
1653                        struct v4l2_subdev_frame_size_enum *fse)
1654 {
1655         int index = fse->index;
1656         struct ov8858_device *dev = to_ov8858_sensor(sd);
1657
1658         mutex_lock(&dev->input_lock);
1659         if (index >= dev->entries_curr_table) {
1660                 mutex_unlock(&dev->input_lock);
1661                 return -EINVAL;
1662         }
1663
1664         fse->min_width = dev->curr_res_table[index].width;
1665         fse->min_height = dev->curr_res_table[index].height;
1666         fse->max_width = dev->curr_res_table[index].width;
1667         fse->max_height = dev->curr_res_table[index].height;
1668         mutex_unlock(&dev->input_lock);
1669
1670         return 0;
1671 }
1672
1673 static int ov8858_s_ctrl(struct v4l2_ctrl *ctrl)
1674 {
1675         struct ov8858_device *dev = container_of(
1676                 ctrl->handler, struct ov8858_device, ctrl_handler);
1677         struct i2c_client *client = v4l2_get_subdevdata(&dev->sd);
1678
1679         /* input_lock is taken by the control framework, so it
1680          * doesn't need to be taken here.
1681          */
1682
1683         switch (ctrl->id) {
1684         case V4L2_CID_RUN_MODE:
1685                 switch (ctrl->val) {
1686                 case ATOMISP_RUN_MODE_VIDEO:
1687                         dev->curr_res_table = ov8858_res_video;
1688                         dev->entries_curr_table = ARRAY_SIZE(ov8858_res_video);
1689                         break;
1690                 case ATOMISP_RUN_MODE_STILL_CAPTURE:
1691                         dev->curr_res_table = ov8858_res_still;
1692                         dev->entries_curr_table = ARRAY_SIZE(ov8858_res_still);
1693                         break;
1694                 default:
1695                         dev->curr_res_table = ov8858_res_preview;
1696                         dev->entries_curr_table =
1697                                         ARRAY_SIZE(ov8858_res_preview);
1698                 }
1699
1700                 dev->fmt_idx = 0;
1701                 dev->fps_index = 0;
1702
1703                 return 0;
1704         case V4L2_CID_FOCUS_ABSOLUTE:
1705                 if (dev->vcm_driver && dev->vcm_driver->t_focus_abs)
1706                         return dev->vcm_driver->t_focus_abs(&dev->sd,
1707                                                             ctrl->val);
1708                 return 0;
1709         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
1710                 if (ctrl->val == V4L2_EXPOSURE_AUTO)
1711                         dev->limit_exposure_flag = false;
1712                 else if (ctrl->val == V4L2_EXPOSURE_APERTURE_PRIORITY)
1713                         dev->limit_exposure_flag = true;
1714                 return 0;
1715         case V4L2_CID_HFLIP:
1716                 dev->hflip = ctrl->val;
1717                 return 0;
1718         case V4L2_CID_VFLIP:
1719                 dev->vflip = ctrl->val;
1720                 return 0;
1721         default:
1722                 dev_err(&client->dev, "%s: Error: Invalid ctrl: 0x%X\n",
1723                         __func__, ctrl->id);
1724                 return -EINVAL;
1725         }
1726 }
1727
1728 static int ov8858_g_ctrl(struct v4l2_ctrl *ctrl)
1729 {
1730         struct ov8858_device *dev = container_of(
1731                 ctrl->handler, struct ov8858_device, ctrl_handler);
1732         struct i2c_client *client = v4l2_get_subdevdata(&dev->sd);
1733         int r_odd, r_even;
1734         int i = dev->fmt_idx;
1735
1736         switch (ctrl->id) {
1737         case V4L2_CID_FOCUS_STATUS:
1738                 if (dev->vcm_driver && dev->vcm_driver->q_focus_status)
1739                         return dev->vcm_driver->q_focus_status(&dev->sd,
1740                                                                &(ctrl->val));
1741                 return 0;
1742         case V4L2_CID_BIN_FACTOR_HORZ:
1743                 r_odd = ov8858_get_register_8bit(&dev->sd, OV8858_H_INC_ODD,
1744                                                  dev->curr_res_table[i].regs);
1745                 if (r_odd < 0)
1746                         return r_odd;
1747                 r_even = ov8858_get_register_8bit(&dev->sd, OV8858_H_INC_EVEN,
1748                                                   dev->curr_res_table[i].regs);
1749                 if (r_even < 0)
1750                         return r_even;
1751                 ctrl->val = fls(r_odd + (r_even)) - 2;
1752                 return 0;
1753
1754         case V4L2_CID_BIN_FACTOR_VERT:
1755                 r_odd = ov8858_get_register_8bit(&dev->sd, OV8858_V_INC_ODD,
1756                                                  dev->curr_res_table[i].regs);
1757                 if (r_odd < 0)
1758                         return r_odd;
1759                 r_even = ov8858_get_register_8bit(&dev->sd, OV8858_V_INC_EVEN,
1760                                                   dev->curr_res_table[i].regs);
1761                 if (r_even < 0)
1762                         return r_even;
1763                 ctrl->val = fls(r_odd + (r_even)) - 2;
1764                 return 0;
1765         case V4L2_CID_HFLIP:
1766                 ctrl->val = dev->hflip;
1767                 break;
1768         case V4L2_CID_VFLIP:
1769                 ctrl->val = dev->vflip;
1770                 break;
1771         case V4L2_CID_EXPOSURE_ABSOLUTE:
1772                 ctrl->val = dev->exposure;
1773                 break;
1774         default:
1775                 dev_warn(&client->dev,
1776                          "%s: Error: Invalid ctrl: 0x%X\n", __func__, ctrl->id);
1777                 return -EINVAL;
1778         }
1779
1780         return 0;
1781 }
1782
1783 static int
1784 ov8858_g_frame_interval(struct v4l2_subdev *sd,
1785                         struct v4l2_subdev_frame_interval *interval)
1786 {
1787         struct ov8858_device *dev = to_ov8858_sensor(sd);
1788         const struct ov8858_resolution *res =
1789                                 &dev->curr_res_table[dev->fmt_idx];
1790
1791         mutex_lock(&dev->input_lock);
1792         interval->interval.denominator = res->fps_options[dev->fps_index].fps;
1793         interval->interval.numerator = 1;
1794         mutex_unlock(&dev->input_lock);
1795         return 0;
1796 }
1797
1798 static int __ov8858_s_frame_interval(struct v4l2_subdev *sd,
1799                                     struct v4l2_subdev_frame_interval *interval)
1800 {
1801         struct ov8858_device *dev = to_ov8858_sensor(sd);
1802         struct i2c_client *client = v4l2_get_subdevdata(sd);
1803         const struct ov8858_resolution *res =
1804                                 &dev->curr_res_table[dev->fmt_idx];
1805         struct camera_mipi_info *info = NULL;
1806         unsigned int fps_index;
1807         int ret = 0;
1808         int fps;
1809
1810         info = v4l2_get_subdev_hostdata(sd);
1811         if (info == NULL)
1812                 return -EINVAL;
1813
1814         if (!interval->interval.numerator)
1815                 interval->interval.numerator = 1;
1816
1817         fps = interval->interval.denominator / interval->interval.numerator;
1818
1819         /* No need to proceed further if we are not streaming */
1820         if (!dev->streaming) {
1821                 /* Save the new FPS and use it while selecting setting */
1822                 dev->fps = fps;
1823                 return 0;
1824         }
1825
1826          /* Ignore if we are already using the required FPS. */
1827         if (fps == res->fps_options[dev->fps_index].fps)
1828                 return 0;
1829
1830         fps_index = __ov8858_nearest_fps_index(fps, res->fps_options);
1831
1832         if (res->fps_options[fps_index].regs &&
1833             res->fps_options[fps_index].regs != dev->regs) {
1834                 dev_err(&client->dev,
1835                         "Sensor is streaming, can't apply new configuration\n");
1836                 return -EBUSY;
1837         }
1838
1839         dev->fps_index = fps_index;
1840         dev->fps = res->fps_options[dev->fps_index].fps;
1841
1842         /* Update the new frametimings based on FPS */
1843         dev->pixels_per_line =
1844                 res->fps_options[dev->fps_index].pixels_per_line;
1845         dev->lines_per_frame =
1846                 res->fps_options[dev->fps_index].lines_per_frame;
1847
1848         /* update frametiming. Conside the curren exposure/gain as well */
1849         ret = __ov8858_update_frame_timing(sd,
1850                         &dev->pixels_per_line, &dev->lines_per_frame);
1851         if (ret)
1852                 return ret;
1853
1854         /* Update the new values so that user side knows the current settings */
1855         ret = ov8858_get_intg_factor(sd, info, dev->regs);
1856         if (ret)
1857                 return ret;
1858
1859         interval->interval.denominator = res->fps_options[dev->fps_index].fps;
1860         interval->interval.numerator = 1;
1861         __ov8858_print_timing(sd);
1862
1863         return ret;
1864 }
1865
1866 static int ov8858_s_frame_interval(struct v4l2_subdev *sd,
1867                                    struct v4l2_subdev_frame_interval *interval)
1868 {
1869         struct ov8858_device *dev = to_ov8858_sensor(sd);
1870         int ret;
1871
1872         mutex_lock(&dev->input_lock);
1873         ret = __ov8858_s_frame_interval(sd, interval);
1874         mutex_unlock(&dev->input_lock);
1875
1876         return ret;
1877 }
1878
1879 static int ov8858_g_skip_frames(struct v4l2_subdev *sd, u32 *frames)
1880 {
1881         struct ov8858_device *dev = to_ov8858_sensor(sd);
1882
1883         mutex_lock(&dev->input_lock);
1884         *frames = dev->curr_res_table[dev->fmt_idx].skip_frames;
1885         mutex_unlock(&dev->input_lock);
1886
1887         return 0;
1888 }
1889
1890 static const struct v4l2_subdev_sensor_ops ov8858_sensor_ops = {
1891         .g_skip_frames  = ov8858_g_skip_frames,
1892 };
1893
1894 static const struct v4l2_ctrl_ops ctrl_ops = {
1895         .s_ctrl = ov8858_s_ctrl,
1896         .g_volatile_ctrl = ov8858_g_ctrl,
1897 };
1898
1899 static const struct v4l2_subdev_video_ops ov8858_video_ops = {
1900         .s_stream = ov8858_s_stream,
1901         .g_frame_interval = ov8858_g_frame_interval,
1902         .s_frame_interval = ov8858_s_frame_interval,
1903 };
1904
1905 static const struct v4l2_subdev_core_ops ov8858_core_ops = {
1906         .s_power = ov8858_s_power,
1907         .ioctl = ov8858_ioctl,
1908         .init = ov8858_init,
1909 };
1910
1911 static const struct v4l2_subdev_pad_ops ov8858_pad_ops = {
1912         .enum_mbus_code = ov8858_enum_mbus_code,
1913         .enum_frame_size = ov8858_enum_frame_size,
1914         .get_fmt = ov8858_get_fmt,
1915         .set_fmt = ov8858_set_fmt,
1916 };
1917
1918 static const struct v4l2_subdev_ops ov8858_ops = {
1919         .core = &ov8858_core_ops,
1920         .video = &ov8858_video_ops,
1921         .pad = &ov8858_pad_ops,
1922         .sensor = &ov8858_sensor_ops,
1923 };
1924
1925 static const struct media_entity_operations ov_entity_ops = {
1926         .link_setup = NULL,
1927 };
1928
1929 static int ov8858_remove(struct i2c_client *client)
1930 {
1931         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1932         struct ov8858_device *dev = to_ov8858_sensor(sd);
1933         if (dev->platform_data->platform_deinit)
1934                 dev->platform_data->platform_deinit();
1935
1936         media_entity_cleanup(&dev->sd.entity);
1937         v4l2_ctrl_handler_free(&dev->ctrl_handler);
1938         dev->platform_data->csi_cfg(sd, 0);
1939         v4l2_device_unregister_subdev(sd);
1940         kfree(dev);
1941
1942         return 0;
1943 }
1944
1945 static const char * const ctrl_run_mode_menu[] = {
1946         NULL,
1947         "Video",
1948         "Still capture",
1949         "Continuous capture",
1950         "Preview",
1951 };
1952
1953 static const struct v4l2_ctrl_config ctrl_run_mode = {
1954         .ops = &ctrl_ops,
1955         .id = V4L2_CID_RUN_MODE,
1956         .name = "run mode",
1957         .type = V4L2_CTRL_TYPE_MENU,
1958         .min = 1,
1959         .def = 4,
1960         .max = 4,
1961         .qmenu = ctrl_run_mode_menu,
1962 };
1963
1964 static const struct v4l2_ctrl_config ctrls[] = {
1965         {
1966                 .ops = &ctrl_ops,
1967                 .id = V4L2_CID_VFLIP,
1968                 .name = "Vertical flip",
1969                 .type = V4L2_CTRL_TYPE_BOOLEAN,
1970                 .min = false,
1971                 .max = true,
1972                 .step = 1,
1973         }, {
1974                 .ops = &ctrl_ops,
1975                 .id = V4L2_CID_HFLIP,
1976                 .name = "Horizontal flip",
1977                 .type = V4L2_CTRL_TYPE_BOOLEAN,
1978                 .min = false,
1979                 .max = true,
1980                 .step = 1,
1981         }, {
1982                 .ops = &ctrl_ops,
1983                 .id = V4L2_CID_EXPOSURE_ABSOLUTE,
1984                 .name = "Absolute exposure",
1985                 .type = V4L2_CTRL_TYPE_INTEGER,
1986                 .max = 0xffff,
1987                 .min = 0x0,
1988                 .step = 1,
1989                 .def = 0x00,
1990                 .flags = V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_VOLATILE,
1991         }, {
1992                 .ops = &ctrl_ops,
1993                 .id = V4L2_CID_FOCUS_ABSOLUTE,
1994                 .name = "Focus absolute",
1995                 .type = V4L2_CTRL_TYPE_INTEGER,
1996                 .step = 1,
1997                 .max = OV8858_MAX_FOCUS_POS,
1998         }, {
1999                 /* This one is junk: see the spec for proper use of this CID. */
2000                 .ops = &ctrl_ops,
2001                 .id = V4L2_CID_FOCUS_STATUS,
2002                 .name = "Focus status",
2003                 .type = V4L2_CTRL_TYPE_INTEGER,
2004                 .step = 1,
2005                 .max = 100,
2006                 .flags = V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_VOLATILE,
2007         }, {
2008                 /* This is crap. For compatibility use only. */
2009                 .ops = &ctrl_ops,
2010                 .id = V4L2_CID_FOCAL_ABSOLUTE,
2011                 .name = "Focal lenght",
2012                 .type = V4L2_CTRL_TYPE_INTEGER,
2013                 .min = (OV8858_FOCAL_LENGTH_NUM << 16) |
2014                        OV8858_FOCAL_LENGTH_DEM,
2015                 .max = (OV8858_FOCAL_LENGTH_NUM << 16) |
2016                        OV8858_FOCAL_LENGTH_DEM,
2017                 .step = 1,
2018                 .def = (OV8858_FOCAL_LENGTH_NUM << 16) |
2019                        OV8858_FOCAL_LENGTH_DEM,
2020                 .flags = V4L2_CTRL_FLAG_READ_ONLY,
2021         }, {
2022                 /* This one is crap, too. For compatibility use only. */
2023                 .ops = &ctrl_ops,
2024                 .id = V4L2_CID_FNUMBER_ABSOLUTE,
2025                 .name = "F-number",
2026                 .type = V4L2_CTRL_TYPE_INTEGER,
2027                 .min = (OV8858_F_NUMBER_DEFAULT_NUM << 16) |
2028                        OV8858_F_NUMBER_DEM,
2029                 .max = (OV8858_F_NUMBER_DEFAULT_NUM << 16) |
2030                        OV8858_F_NUMBER_DEM,
2031                 .step = 1,
2032                 .def = (OV8858_F_NUMBER_DEFAULT_NUM << 16) |
2033                        OV8858_F_NUMBER_DEM,
2034                 .flags = V4L2_CTRL_FLAG_READ_ONLY,
2035         }, {
2036                 /*
2037                  * The most utter crap. _Never_ use this, even for
2038                  * compatibility reasons!
2039                  */
2040                 .ops = &ctrl_ops,
2041                 .id = V4L2_CID_FNUMBER_RANGE,
2042                 .name = "F-number range",
2043                 .type = V4L2_CTRL_TYPE_INTEGER,
2044                 .min = (OV8858_F_NUMBER_DEFAULT_NUM << 24) |
2045                        (OV8858_F_NUMBER_DEM << 16) |
2046                        (OV8858_F_NUMBER_DEFAULT_NUM << 8) |
2047                        OV8858_F_NUMBER_DEM,
2048                 .max = (OV8858_F_NUMBER_DEFAULT_NUM << 24) |
2049                        (OV8858_F_NUMBER_DEM << 16) |
2050                        (OV8858_F_NUMBER_DEFAULT_NUM << 8) |
2051                        OV8858_F_NUMBER_DEM,
2052                 .step = 1,
2053                 .def = (OV8858_F_NUMBER_DEFAULT_NUM << 24) |
2054                        (OV8858_F_NUMBER_DEM << 16) |
2055                        (OV8858_F_NUMBER_DEFAULT_NUM << 8) |
2056                        OV8858_F_NUMBER_DEM,
2057                 .flags = V4L2_CTRL_FLAG_READ_ONLY,
2058         }, {
2059                 .ops = &ctrl_ops,
2060                 .id = V4L2_CID_BIN_FACTOR_HORZ,
2061                 .name = "Horizontal binning factor",
2062                 .type = V4L2_CTRL_TYPE_INTEGER,
2063                 .max = OV8858_BIN_FACTOR_MAX,
2064                 .step = 1,
2065                 .flags = V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_VOLATILE,
2066         }, {
2067                 .ops = &ctrl_ops,
2068                 .id = V4L2_CID_BIN_FACTOR_VERT,
2069                 .name = "Vertical binning factor",
2070                 .type = V4L2_CTRL_TYPE_INTEGER,
2071                 .max = OV8858_BIN_FACTOR_MAX,
2072                 .step = 1,
2073                 .flags = V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_VOLATILE,
2074         }, {
2075                 .ops = &ctrl_ops,
2076                 .id = V4L2_CID_EXPOSURE_AUTO_PRIORITY,
2077                 .name = "Exposure auto priority",
2078                 .type = V4L2_CTRL_TYPE_INTEGER,
2079                 .min = V4L2_EXPOSURE_AUTO,
2080                 .max = V4L2_EXPOSURE_APERTURE_PRIORITY,
2081                 .step = 1,
2082         }
2083 };
2084
2085 static int ov8858_probe(struct i2c_client *client,
2086                         const struct i2c_device_id *id)
2087 {
2088         struct ov8858_device *dev;
2089         unsigned int i;
2090         int ret = 0;
2091         struct camera_sensor_platform_data *pdata;
2092
2093         dev_dbg(&client->dev, "%s:\n", __func__);
2094
2095         /* allocate sensor device & init sub device */
2096         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
2097         if (!dev) {
2098                 dev_err(&client->dev, "%s: out of memory\n", __func__);
2099                 return -ENOMEM;
2100         }
2101
2102         mutex_init(&dev->input_lock);
2103
2104         if (id)
2105                 dev->i2c_id = id->driver_data;
2106         dev->fmt_idx = 0;
2107         dev->sensor_id = OV_ID_DEFAULT;
2108         dev->vcm_driver = &ov8858_vcms[OV8858_ID_DEFAULT];
2109
2110         v4l2_i2c_subdev_init(&(dev->sd), client, &ov8858_ops);
2111
2112         if (ACPI_COMPANION(&client->dev)) {
2113                 pdata = gmin_camera_platform_data(&dev->sd,
2114                                                   ATOMISP_INPUT_FORMAT_RAW_10,
2115                                                   atomisp_bayer_order_bggr);
2116                 if (!pdata) {
2117                         dev_err(&client->dev,
2118                                 "%s: failed to get acpi platform data\n",
2119                                 __func__);
2120                         goto out_free;
2121                 }
2122                 ret = ov8858_s_config(&dev->sd, client->irq, pdata);
2123                 if (ret) {
2124                         dev_err(&client->dev,
2125                                 "%s: failed to set config\n", __func__);
2126                         goto out_free;
2127                 }
2128                 ret = atomisp_register_i2c_module(&dev->sd, pdata, RAW_CAMERA);
2129                 if (ret) {
2130                         dev_err(&client->dev,
2131                                 "%s: failed to register subdev\n", __func__);
2132                         goto out_free;
2133                 }
2134         }
2135         /*
2136          * sd->name is updated with sensor driver name by the v4l2.
2137          * change it to sensor name in this case.
2138          */
2139         snprintf(dev->sd.name, sizeof(dev->sd.name), "%s%x %d-%04x",
2140                  OV_SUBDEV_PREFIX, dev->sensor_id,
2141                  i2c_adapter_id(client->adapter), client->addr);
2142
2143         dev->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
2144         dev->pad.flags = MEDIA_PAD_FL_SOURCE;
2145         dev->format.code = MEDIA_BUS_FMT_SBGGR10_1X10;
2146         dev->sd.entity.ops = &ov_entity_ops;
2147         dev->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
2148
2149         ret = v4l2_ctrl_handler_init(&dev->ctrl_handler, ARRAY_SIZE(ctrls) + 1);
2150         if (ret) {
2151                 ov8858_remove(client);
2152                 return ret;
2153         }
2154
2155         dev->run_mode = v4l2_ctrl_new_custom(&dev->ctrl_handler,
2156                                              &ctrl_run_mode, NULL);
2157
2158         for (i = 0; i < ARRAY_SIZE(ctrls); i++)
2159                 v4l2_ctrl_new_custom(&dev->ctrl_handler, &ctrls[i], NULL);
2160
2161         if (dev->ctrl_handler.error) {
2162                 ov8858_remove(client);
2163                 return dev->ctrl_handler.error;
2164         }
2165
2166         /* Use same lock for controls as for everything else. */
2167         dev->ctrl_handler.lock = &dev->input_lock;
2168         dev->sd.ctrl_handler = &dev->ctrl_handler;
2169         v4l2_ctrl_handler_setup(&dev->ctrl_handler);
2170
2171         ret = media_entity_pads_init(&dev->sd.entity, 1, &dev->pad);
2172         if (ret) {
2173                 ov8858_remove(client);
2174                 return ret;
2175         }
2176
2177         return 0;
2178
2179 out_free:
2180         v4l2_device_unregister_subdev(&dev->sd);
2181         kfree(dev);
2182         return ret;
2183 }
2184
2185 static const struct i2c_device_id ov8858_id[] = {
2186         {OV8858_NAME, 0},
2187         {}
2188 };
2189
2190 MODULE_DEVICE_TABLE(i2c, ov8858_id);
2191
2192 static const struct acpi_device_id ov8858_acpi_match[] = {
2193         {"INT3477"},
2194         {},
2195 };
2196
2197 static struct i2c_driver ov8858_driver = {
2198         .driver = {
2199                 .name = OV8858_NAME,
2200                 .acpi_match_table = ACPI_PTR(ov8858_acpi_match),
2201         },
2202         .probe = ov8858_probe,
2203         .remove = ov8858_remove,
2204         .id_table = ov8858_id,
2205 };
2206
2207 static __init int ov8858_init_mod(void)
2208 {
2209         return i2c_add_driver(&ov8858_driver);
2210 }
2211
2212 static __exit void ov8858_exit_mod(void)
2213 {
2214         i2c_del_driver(&ov8858_driver);
2215 }
2216
2217 module_init(ov8858_init_mod);
2218 module_exit(ov8858_exit_mod);
2219
2220 MODULE_DESCRIPTION("A low-level driver for Omnivision OV8858 sensors");
2221 MODULE_LICENSE("GPL");