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

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