drivers/media/i2c/soc_camera/imx230_v4l2.c

   1 /*
   2  * imx230.c - imx230 sensor driver
   3  *
   4  * Copyright (c) 2015-2016, NVIDIA CORPORATION.  All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <linux/slab.h>
  20 #include <linux/uaccess.h>
  21 #include <linux/gpio.h>
  22 #include <linux/module.h>
  23
  24 #include <linux/seq_file.h>
  25 #include <linux/of.h>
  26 #include <linux/of_device.h>
  27 #include <linux/of_gpio.h>
  28
  29 #include <media/v4l2-chip-ident.h>
  30 #include <media/tegra_v4l2_camera.h>
  31 #include <media/camera_common.h>
  32 #include <media/imx230.h>
  33
  34 #include "imx230_mode_tbls.h"
  35
  36 #define IMX230_MAX_COARSE_DIFF          10
  37
  38 /* gain values are common among sensor modes */
  39 #define IMX230_GAIN_SHIFT               8
  40 #define IMX230_MIN_GAIN         (1 << IMX230_GAIN_SHIFT)
  41 #define IMX230_MAX_GAIN         (16 << IMX230_GAIN_SHIFT)
  42 #define IMX230_DEFAULT_GAIN     IMX230_MIN_GAIN
  43
  44 /* common FL/CT values among sensor modes */
  45 #define IMX230_MIN_FRAME_LENGTH (0x0)
  46 #define IMX230_MAX_FRAME_LENGTH (0xffff)
  47 #define IMX230_MIN_EXPOSURE_COARSE      (0x0001)
  48 #define IMX230_MAX_EXPOSURE_COARSE      \
  49         (IMX230_MAX_FRAME_LENGTH-IMX230_MAX_COARSE_DIFF)
  50
  51 /* Definitions for full sensor mode that matches full mode's sequence */
  52 #define IMX230_MIN_FRAME_LENGTH_5344x4016       (0x1022)
  53 #define IMX230_DEFAULT_WIDTH_5344x4016  5344
  54 #define IMX230_DEFAULT_HEIGHT_5344x4016 4016
  55
  56 /* Use full sensor mode settings as default values */
  57 #define IMX230_DEFAULT_MODE     IMX230_MODE_5344x4016
  58 #define IMX230_DEFAULT_WIDTH    IMX230_DEFAULT_WIDTH_5344x4016
  59 #define IMX230_DEFAULT_HEIGHT   IMX230_DEFAULT_HEIGHT_5344x4016
  60 #define IMX230_DEFAULT_FRAME_LENGTH     IMX230_MIN_FRAME_LENGTH_5344x4016
  61 #define IMX230_DEFAULT_EXPOSURE_COARSE  \
  62         (IMX230_DEFAULT_FRAME_LENGTH-IMX230_MAX_COARSE_DIFF)
  63
  64 /* Some other common default values */
  65 #define IMX230_DEFAULT_DATAFMT  V4L2_MBUS_FMT_SRGGB10_1X10
  66 #define IMX230_DEFAULT_CLK_FREQ 24000000
  67
  68 /* R0x0344-R0x034B */
  69 #define IMX230_NUM_CROP_REGS    8
  70
  71 struct imx230 {
  72         struct camera_common_power_rail power;
  73         int                             num_ctrls;
  74         struct v4l2_ctrl_handler        ctrl_handler;
  75 #ifdef IMX230_EEPROM_PRESENT
  76         struct camera_common_eeprom_data eeprom[IMX230_EEPROM_NUM_BLOCKS];
  77         u8                              eeprom_buf[IMX230_EEPROM_SIZE];
  78 #endif /* if IMX230_EEPROM_PRESENT */
  79         struct i2c_client               *i2c_client;
  80         struct v4l2_subdev              *subdev;
  81
  82         s32                             group_hold_prev;
  83         bool                            group_hold_en;
  84         struct regmap                   *regmap;
  85         struct camera_common_data       *s_data;
  86         struct camera_common_pdata      *pdata;
  87         struct v4l2_ctrl                *ctrls[];
  88 };
  89
  90 static const struct regmap_config sensor_regmap_config = {
  91         .reg_bits = 16,
  92         .val_bits = 8,
  93         .cache_type = REGCACHE_RBTREE,
  94 };
  95
  96 static int imx230_g_volatile_ctrl(struct v4l2_ctrl *ctrl);
  97 static int imx230_s_ctrl(struct v4l2_ctrl *ctrl);
  98
  99 static const struct v4l2_ctrl_ops imx230_ctrl_ops = {
 100         .g_volatile_ctrl = imx230_g_volatile_ctrl,
 101         .s_ctrl         = imx230_s_ctrl,
 102 };
 103
 104 static struct v4l2_ctrl_config ctrl_config_list[] = {
 105 /* Do not change the name field for the controls! */
 106         {
 107                 .ops = &imx230_ctrl_ops,
 108                 .id = V4L2_CID_GAIN,
 109                 .name = "Gain",
 110                 .type = V4L2_CTRL_TYPE_INTEGER,
 111                 .flags = V4L2_CTRL_FLAG_SLIDER,
 112                 .min = IMX230_MIN_GAIN,
 113                 .max = IMX230_MAX_GAIN,
 114                 .def = IMX230_DEFAULT_GAIN,
 115                 .step = 1,
 116         },
 117         {
 118                 .ops = &imx230_ctrl_ops,
 119                 .id = V4L2_CID_FRAME_LENGTH,
 120                 .name = "Frame Length",
 121                 .type = V4L2_CTRL_TYPE_INTEGER,
 122                 .flags = V4L2_CTRL_FLAG_SLIDER,
 123                 .min = IMX230_MIN_FRAME_LENGTH,
 124                 .max = IMX230_MAX_FRAME_LENGTH,
 125                 .def = IMX230_DEFAULT_FRAME_LENGTH,
 126                 .step = 1,
 127         },
 128         {
 129                 .ops = &imx230_ctrl_ops,
 130                 .id = V4L2_CID_COARSE_TIME,
 131                 .name = "Coarse Time",
 132                 .type = V4L2_CTRL_TYPE_INTEGER,
 133                 .flags = V4L2_CTRL_FLAG_SLIDER,
 134                 .min = IMX230_MIN_EXPOSURE_COARSE,
 135                 .max = IMX230_MAX_EXPOSURE_COARSE,
 136                 .def = IMX230_DEFAULT_EXPOSURE_COARSE,
 137                 .step = 1,
 138         },
 139         {
 140                 .ops = &imx230_ctrl_ops,
 141                 .id = V4L2_CID_COARSE_TIME_SHORT,
 142                 .name = "Coarse Time Short",
 143                 .type = V4L2_CTRL_TYPE_INTEGER,
 144                 .flags = V4L2_CTRL_FLAG_SLIDER,
 145                 .min = IMX230_MIN_EXPOSURE_COARSE,
 146                 .max = IMX230_MAX_EXPOSURE_COARSE,
 147                 .def = IMX230_DEFAULT_EXPOSURE_COARSE,
 148                 .step = 1,
 149         },
 150         {
 151                 .ops = &imx230_ctrl_ops,
 152                 .id = V4L2_CID_GROUP_HOLD,
 153                 .name = "Group Hold",
 154                 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
 155                 .min = 0,
 156                 .max = ARRAY_SIZE(switch_ctrl_qmenu) - 1,
 157                 .menu_skip_mask = 0,
 158                 .def = 0,
 159                 .qmenu_int = switch_ctrl_qmenu,
 160         },
 161         {
 162                 .ops = &imx230_ctrl_ops,
 163                 .id = V4L2_CID_HDR_EN,
 164                 .name = "HDR enable",
 165                 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
 166                 .min = 0,
 167                 .max = ARRAY_SIZE(switch_ctrl_qmenu) - 1,
 168                 .menu_skip_mask = 0,
 169                 .def = 0,
 170                 .qmenu_int = switch_ctrl_qmenu,
 171         },
 172 #ifdef IMX230_EEPROM_PRESENT
 173         {
 174                 .ops = &imx230_ctrl_ops,
 175                 .id = V4L2_CID_EEPROM_DATA,
 176                 .name = "EEPROM Data",
 177                 .type = V4L2_CTRL_TYPE_STRING,
 178                 .flags = V4L2_CTRL_FLAG_VOLATILE,
 179                 .min = 0,
 180                 .max = IMX230_EEPROM_STR_SIZE,
 181                 .step = 2,
 182         },
 183 #endif /* if IMX230_EEPROM_PRESENT */
 184         {
 185                 .ops = &imx230_ctrl_ops,
 186                 .id = V4L2_CID_OTP_DATA,
 187                 .name = "OTP Data",
 188                 .type = V4L2_CTRL_TYPE_STRING,
 189                 .flags = V4L2_CTRL_FLAG_READ_ONLY,
 190                 .min = 0,
 191                 .max = IMX230_OTP_STR_SIZE,
 192                 .step = 2,
 193         },
 194         {
 195                 .ops = &imx230_ctrl_ops,
 196                 .id = V4L2_CID_FUSE_ID,
 197                 .name = "Fuse ID",
 198                 .type = V4L2_CTRL_TYPE_STRING,
 199                 .flags = V4L2_CTRL_FLAG_READ_ONLY,
 200                 .min = 0,
 201                 .max = IMX230_FUSE_ID_STR_SIZE,
 202                 .step = 2,
 203         },
 204 };
 205
 206 static inline void imx230_get_frame_length_regs(imx230_reg *regs,
 207                                 u32 frame_length)
 208 {
 209         regs->addr = IMX230_FRAME_LENGTH_ADDR_MSB;
 210         regs->val = (frame_length >> 8) & 0xff;
 211         (regs + 1)->addr = IMX230_FRAME_LENGTH_ADDR_LSB;
 212         (regs + 1)->val = (frame_length) & 0xff;
 213 }
 214
 215 static inline void imx230_get_coarse_time_regs(imx230_reg *regs,
 216                                 u32 coarse_time)
 217 {
 218         regs->addr = IMX230_COARSE_TIME_ADDR_MSB;
 219         regs->val = (coarse_time >> 8) & 0xff;
 220         (regs + 1)->addr = IMX230_COARSE_TIME_ADDR_LSB;
 221         (regs + 1)->val = (coarse_time) & 0xff;
 222 }
 223
 224 static inline void imx230_get_coarse_time_short_regs(imx230_reg *regs,
 225                                 u32 coarse_time)
 226 {
 227         regs->addr = IMX230_COARSE_TIME_SHORT_ADDR_MSB;
 228         regs->val = (coarse_time >> 8) & 0xff;
 229         (regs + 1)->addr = IMX230_COARSE_TIME_SHORT_ADDR_LSB;
 230         (regs + 1)->val = (coarse_time) & 0xff;
 231 }
 232
 233 static inline void imx230_get_gain_reg(imx230_reg *regs,
 234                                 u16 gain)
 235 {
 236         regs->addr = IMX230_GAIN_ADDR_MSB;
 237         regs->val = (gain >> 8) & 0xff;
 238         (regs + 1)->addr = IMX230_GAIN_ADDR_LSB;
 239         (regs + 1)->val = (gain) & 0xff;
 240 }
 241
 242 static inline void imx230_get_gain_short_reg(imx230_reg *regs,
 243                                 u16 gain)
 244 {
 245         regs->addr = IMX230_GAIN_SHORT_ADDR_MSB;
 246         regs->val = (gain >> 8) & 0xff;
 247         (regs + 1)->addr = IMX230_GAIN_SHORT_ADDR_LSB;
 248         (regs + 1)->val = (gain) & 0xff;
 249 }
 250
 251 static void imx230_get_crop_regs(imx230_reg *regs,
 252                                 struct v4l2_rect *rect)
 253 {
 254         u32 x_start, y_start;
 255         u32 x_end, y_end;
 256         x_start = rect->left;
 257         y_start = rect->top;
 258         x_end = x_start + rect->width - 1;
 259         y_end = y_start + rect->height - 1;
 260
 261         regs->addr = IMX230_CROP_X_START_ADDR_MSB;
 262         regs->val = (x_start >> 8) & 0xff;
 263         (regs + 1)->addr = IMX230_CROP_X_START_ADDR_LSB;
 264         (regs + 1)->val = (x_start) & 0xff;
 265
 266         (regs + 2)->addr = IMX230_CROP_Y_START_ADDR_MSB;
 267         (regs + 2)->val = (y_start >> 8) & 0xff;
 268         (regs + 3)->addr = IMX230_CROP_Y_START_ADDR_LSB;
 269         (regs + 3)->val = (y_start) & 0xff;
 270
 271         (regs + 4)->addr = IMX230_CROP_X_END_ADDR_MSB;
 272         (regs + 4)->val = (x_end >> 8) & 0xff;
 273         (regs + 5)->addr = IMX230_CROP_X_END_ADDR_LSB;
 274         (regs + 5)->val = (x_end) & 0xff;
 275
 276         (regs + 6)->addr = IMX230_CROP_Y_END_ADDR_MSB;
 277         (regs + 6)->val = (y_end >> 8) & 0xff;
 278         (regs + 7)->addr = IMX230_CROP_Y_END_ADDR_LSB;
 279         (regs + 7)->val = (y_end) & 0xff;
 280 }
 281
 282 static int test_mode;
 283 module_param(test_mode, int, 0644);
 284
 285 static inline int imx230_read_reg(struct camera_common_data *s_data,
 286                                 u16 addr, u8 *val)
 287 {
 288         struct imx230 *priv = (struct imx230 *)s_data->priv;
 289         return regmap_read(priv->regmap, addr, (unsigned int *) val);
 290 }
 291
 292 static int imx230_write_reg(struct camera_common_data *s_data, u16 addr, u8 val)
 293 {
 294         int err;
 295         struct imx230 *priv = (struct imx230 *)s_data->priv;
 296
 297         err = regmap_write(priv->regmap, addr, val);
 298         if (err)
 299                 pr_err("%s:i2c write failed, %x = %x\n",
 300                         __func__, addr, val);
 301
 302         return err;
 303 }
 304
 305 static int imx230_write_table(struct imx230 *priv,
 306                                 const imx230_reg table[])
 307 {
 308         return regmap_util_write_table_8(priv->regmap,
 309                                          table,
 310                                          NULL, 0,
 311                                          IMX230_TABLE_WAIT_MS,
 312                                          IMX230_TABLE_END);
 313 }
 314
 315 static int imx230_power_on(struct camera_common_data *s_data)
 316 {
 317         int err = 0;
 318         struct imx230 *priv = (struct imx230 *)s_data->priv;
 319         struct camera_common_power_rail *pw = &priv->power;
 320
 321         dev_dbg(&priv->i2c_client->dev, "%s: power on\n", __func__);
 322
 323         if (priv->pdata->power_on) {
 324                 err = priv->pdata->power_on(pw);
 325                 if (err) {
 326                         pr_err("%s failed.\n", __func__);
 327                 } else {
 328                         pw->state = SWITCH_ON;
 329                 }
 330                 return err;
 331         }
 332
 333         if (pw->reset_gpio)
 334                 gpio_set_value(pw->reset_gpio, 0);
 335         usleep_range(10, 20);
 336
 337         /* It's used to switch on 2V5_CAM_H and 1V1_CAM_H */
 338         if (pw->pwdn_gpio)
 339                 gpio_set_value(pw->pwdn_gpio, 1);
 340
 341         if (pw->avdd)
 342                 err = regulator_enable(pw->avdd);
 343         if (err)
 344                 goto imx230_avdd_fail;
 345
 346         if (pw->iovdd)
 347                 err = regulator_enable(pw->iovdd);
 348         if (err)
 349                 goto imx230_iovdd_fail;
 350
 351         usleep_range(11, 20);
 352         if (pw->reset_gpio)
 353                 gpio_set_value(pw->reset_gpio, 1);
 354
 355         usleep_range(1000, 1010);
 356
 357         pw->state = SWITCH_ON;
 358         return 0;
 359
 360 imx230_iovdd_fail:
 361         regulator_disable(pw->avdd);
 362
 363 imx230_avdd_fail:
 364
 365         pr_err("%s failed.\n", __func__);
 366         return -ENODEV;
 367 }
 368
 369 static int imx230_power_off(struct camera_common_data *s_data)
 370 {
 371         int err = 0;
 372         struct imx230 *priv = (struct imx230 *)s_data->priv;
 373         struct camera_common_power_rail *pw = &priv->power;
 374
 375         dev_dbg(&priv->i2c_client->dev, "%s: power off\n", __func__);
 376
 377         if (priv->pdata->power_off) {
 378                 err = priv->pdata->power_off(pw);
 379                 if (err) {
 380                         pr_err("%s failed.\n", __func__);
 381                         return err;
 382                 } else {
 383                         goto power_off_done;
 384                 }
 385         }
 386
 387         usleep_range(1, 2);
 388         if (pw->reset_gpio)
 389                 gpio_set_value(pw->reset_gpio, 0);
 390         usleep_range(1, 2);
 391
 392         if (pw->pwdn_gpio)
 393                 gpio_set_value(pw->pwdn_gpio, 0);
 394
 395         if (pw->iovdd)
 396                 regulator_disable(pw->iovdd);
 397         if (pw->avdd)
 398                 regulator_disable(pw->avdd);
 399
 400 power_off_done:
 401
 402         pw->state = SWITCH_OFF;
 403         return 0;
 404 }
 405
 406 static int imx230_power_put(struct imx230 *priv)
 407 {
 408         struct camera_common_power_rail *pw = &priv->power;
 409         if (unlikely(!pw))
 410                 return -EFAULT;
 411
 412         if (likely(pw->avdd))
 413                 regulator_put(pw->avdd);
 414
 415         if (likely(pw->iovdd))
 416                 regulator_put(pw->iovdd);
 417
 418         pw->avdd = NULL;
 419         pw->iovdd = NULL;
 420
 421         return 0;
 422 }
 423
 424 static int imx230_power_get(struct imx230 *priv)
 425 {
 426         struct camera_common_power_rail *pw = &priv->power;
 427         struct camera_common_pdata *pdata = priv->pdata;
 428         const char *mclk_name;
 429         int err = 0;
 430
 431         mclk_name = priv->pdata->mclk_name ?
 432                     priv->pdata->mclk_name : "cam_mclk1";
 433         pw->mclk = devm_clk_get(&priv->i2c_client->dev, mclk_name);
 434         if (IS_ERR(pw->mclk)) {
 435                 dev_err(&priv->i2c_client->dev,
 436                         "unable to get clock %s\n", mclk_name);
 437                 return PTR_ERR(pw->mclk);
 438         }
 439
 440         /* ananlog 2.7v */
 441         err |= camera_common_regulator_get(priv->i2c_client,
 442                         &pw->avdd, pdata->regulators.avdd);
 443         /* IO 1.8v */
 444         err |= camera_common_regulator_get(priv->i2c_client,
 445                         &pw->iovdd, pdata->regulators.iovdd);
 446
 447         if (!err) {
 448                 pw->reset_gpio = pdata->reset_gpio;
 449                 pw->pwdn_gpio = pdata->pwdn_gpio;
 450         }
 451
 452         pw->state = SWITCH_OFF;
 453         return err;
 454 }
 455
 456 static int imx230_set_gain(struct imx230 *priv, s32 val);
 457 static int imx230_set_frame_length(struct imx230 *priv, s32 val);
 458 static int imx230_set_coarse_time(struct imx230 *priv, s32 val);
 459 static int imx230_set_coarse_time_short(struct imx230 *priv, s32 val);
 460 static int imx230_set_crop_data(struct imx230 *priv, struct v4l2_rect *rect);
 461 static int imx230_get_crop_data(struct imx230 *priv, struct v4l2_rect *rect);
 462
 463 static int imx230_s_stream(struct v4l2_subdev *sd, int enable)
 464 {
 465         struct i2c_client *client = v4l2_get_subdevdata(sd);
 466         struct camera_common_data *s_data = to_camera_common_data(client);
 467         struct imx230 *priv = (struct imx230 *)s_data->priv;
 468         struct v4l2_control control;
 469         int err;
 470
 471         dev_dbg(&client->dev, "%s++ enable %d mode %d\n",
 472                 __func__, enable, s_data->mode);
 473
 474         if (!enable)
 475                 return imx230_write_table(priv,
 476                         mode_table[IMX230_MODE_STOP_STREAM]);
 477
 478         err = imx230_write_table(priv, mode_table[IMX230_MODE_COMMON]);
 479         if (err)
 480                 goto exit;
 481         err = imx230_write_table(priv, mode_table[s_data->mode]);
 482         if (err)
 483                 goto exit;
 484
 485         /* write list of override regs for the asking frame length, */
 486         /* coarse integration time, and gain.                       */
 487         control.id = V4L2_CID_GAIN;
 488         err = v4l2_g_ctrl(&priv->ctrl_handler, &control);
 489         err |= imx230_set_gain(priv, control.value);
 490         if (err)
 491                 dev_dbg(&client->dev, "%s: error gain override\n", __func__);
 492
 493         control.id = V4L2_CID_FRAME_LENGTH;
 494         err = v4l2_g_ctrl(&priv->ctrl_handler, &control);
 495         err |= imx230_set_frame_length(priv, control.value);
 496         if (err)
 497                 dev_dbg(&client->dev,
 498                         "%s: error frame length override\n", __func__);
 499
 500         control.id = V4L2_CID_COARSE_TIME;
 501         err = v4l2_g_ctrl(&priv->ctrl_handler, &control);
 502         err |= imx230_set_coarse_time(priv, control.value);
 503         if (err)
 504                 dev_dbg(&client->dev,
 505                         "%s: error coarse time override\n", __func__);
 506
 507         control.id = V4L2_CID_COARSE_TIME_SHORT;
 508         err = v4l2_g_ctrl(&priv->ctrl_handler, &control);
 509         err |= imx230_set_coarse_time_short(priv, control.value);
 510         if (err)
 511                 dev_dbg(&client->dev,
 512                         "%s: error coarse time short override\n", __func__);
 513
 514         err = imx230_write_table(priv, mode_table[IMX230_MODE_START_STREAM]);
 515         if (err)
 516                 goto exit;
 517
 518         if (test_mode)
 519                 err = imx230_write_table(priv,
 520                         mode_table[IMX230_MODE_TEST_PATTERN]);
 521
 522         dev_dbg(&client->dev, "%s: success setting stream\n", __func__);
 523         return 0;
 524 exit:
 525         dev_dbg(&client->dev, "%s: error setting stream\n", __func__);
 526         return err;
 527 }
 528
 529 static int imx230_s_crop(struct v4l2_subdev *sd, const struct v4l2_crop *crop)
 530 {
 531         struct i2c_client *client = v4l2_get_subdevdata(sd);
 532         struct camera_common_data *s_data = to_camera_common_data(client);
 533         struct imx230 *priv = (struct imx230 *)s_data->priv;
 534         struct v4l2_rect *rect = &crop->c;
 535         int err;
 536
 537         u32 width, height;
 538         u32 bottom, right;
 539
 540         width = s_data->fmt_width;
 541         height = s_data->fmt_height;
 542
 543         if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 544                 return -EINVAL;
 545
 546         if ((width != rect->width) || (height != rect->height)) {
 547                 dev_err(&client->dev,
 548                         "%s: CROP Resolution Mismatch: %dx%d\n",
 549                         __func__, rect->width, rect->height);
 550                 return -EINVAL;
 551         }
 552         if (rect->top < 0 || rect->left < 0) {
 553                 dev_err(&client->dev,
 554                         "%s: CROP Bound Error: left:%d, top:%d\n",
 555                         __func__, rect->left, rect->top);
 556                 return -EINVAL;
 557         }
 558         right = rect->left + width - 1;
 559         bottom = rect->top + height - 1;
 560
 561         /* Crop window is within the full mode's active */
 562         if ((right > IMX230_DEFAULT_WIDTH_5344x4016) ||
 563                 (bottom > IMX230_DEFAULT_HEIGHT_5344x4016)) {
 564                 dev_err(&client->dev,
 565                         "%s: CROP Bound Error: right:%d, bottom:%d)\n",
 566                         __func__, right, bottom);
 567                 return -EINVAL;
 568         }
 569         err = imx230_set_crop_data(priv, rect);
 570
 571         return err;
 572 }
 573
 574 static int imx230_g_crop(struct v4l2_subdev *sd, struct v4l2_crop *crop)
 575 {
 576         struct i2c_client *client = v4l2_get_subdevdata(sd);
 577         struct camera_common_data *s_data = to_camera_common_data(client);
 578         struct imx230 *priv = (struct imx230 *)s_data->priv;
 579         struct v4l2_rect *rect = &crop->c;
 580         int err;
 581
 582         if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 583                 return -EINVAL;
 584
 585         err = imx230_get_crop_data(priv, rect);
 586
 587         return err;
 588 }
 589
 590 static struct v4l2_subdev_video_ops imx230_subdev_video_ops = {
 591         .s_stream       = imx230_s_stream,
 592         .s_crop         = imx230_s_crop,
 593         .g_crop         = imx230_g_crop,
 594         .s_mbus_fmt     = camera_common_s_fmt,
 595         .g_mbus_fmt     = camera_common_g_fmt,
 596         .try_mbus_fmt   = camera_common_try_fmt,
 597         .enum_mbus_fmt  = camera_common_enum_fmt,
 598         .g_mbus_config  = camera_common_g_mbus_config,
 599 };
 600
 601 static struct v4l2_subdev_core_ops imx230_subdev_core_ops = {
 602         .g_chip_ident   = camera_common_g_chip_ident,
 603         .s_power        = camera_common_s_power,
 604 };
 605
 606 static struct v4l2_subdev_ops imx230_subdev_ops = {
 607         .core   = &imx230_subdev_core_ops,
 608         .video  = &imx230_subdev_video_ops,
 609 };
 610
 611 static struct of_device_id imx230_of_match[] = {
 612         { .compatible = "nvidia,imx230", },
 613         { },
 614 };
 615
 616 static struct camera_common_sensor_ops imx230_common_ops = {
 617         .power_on = imx230_power_on,
 618         .power_off = imx230_power_off,
 619         .write_reg = imx230_write_reg,
 620         .read_reg = imx230_read_reg,
 621 };
 622
 623 static int imx230_set_group_hold(struct imx230 *priv)
 624 {
 625         int err;
 626         int gh_prev = switch_ctrl_qmenu[priv->group_hold_prev];
 627
 628         if (priv->group_hold_en == true && gh_prev == SWITCH_OFF) {
 629                 err = imx230_write_reg(priv->s_data,
 630                                            IMX230_GROUP_HOLD_ADDR, 0x1);
 631                 if (err)
 632                         goto fail;
 633                 priv->group_hold_prev = 1;
 634         } else if (priv->group_hold_en == false && gh_prev == SWITCH_ON) {
 635                 err = imx230_write_reg(priv->s_data,
 636                                            IMX230_GROUP_HOLD_ADDR, 0x0);
 637                 if (err)
 638                         goto fail;
 639                 priv->group_hold_prev = 0;
 640         }
 641
 642         return 0;
 643
 644 fail:
 645         dev_dbg(&priv->i2c_client->dev,
 646                  "%s: Group hold control error\n", __func__);
 647         return err;
 648 }
 649
 650 int imx230_to_gain(u32 rep, int shift)
 651 {
 652         int gain;
 653         int gain_int;
 654         int gain_dec;
 655         int min_int = (1 << shift);
 656         int denom;
 657
 658         /* last 4 bit of rep is
 659          * decimal representation of gain */
 660         gain_int = (int)(rep >> shift);
 661         gain_dec = (int)(rep & ~(0xffff << shift));
 662
 663         denom = gain_int * min_int + gain_dec;
 664         gain = 512 - ((512 * min_int + (denom - 1)) / denom);
 665
 666         return gain;
 667 }
 668
 669 static int imx230_set_gain(struct imx230 *priv, s32 val)
 670 {
 671         imx230_reg reg_list[2];
 672         imx230_reg reg_list_short[2];
 673         int err;
 674         u32 gain;
 675         int i = 0;
 676
 677         /* translate value */
 678         gain = (u16)imx230_to_gain(val, IMX230_GAIN_SHIFT);
 679
 680         dev_dbg(&priv->i2c_client->dev,
 681                  "%s: val: %d gain: %x\n", __func__, val, gain);
 682
 683         imx230_get_gain_reg(reg_list, gain);
 684         imx230_get_gain_short_reg(reg_list_short, gain);
 685         imx230_set_group_hold(priv);
 686
 687         /* writing long gain */
 688         for (i = 0; i < 2; i++) {
 689                 err = imx230_write_reg(priv->s_data, reg_list[i].addr,
 690                          reg_list[i].val);
 691                 if (err)
 692                         goto fail;
 693         }
 694         /* writing short gain */
 695         for (i = 0; i < 2; i++) {
 696                 err = imx230_write_reg(priv->s_data, reg_list_short[i].addr,
 697                          reg_list_short[i].val);
 698                 if (err)
 699                         goto fail;
 700         }
 701
 702         return 0;
 703
 704 fail:
 705         dev_dbg(&priv->i2c_client->dev,
 706                  "%s: GAIN control error\n", __func__);
 707         return err;
 708 }
 709
 710 static int imx230_set_frame_length(struct imx230 *priv, s32 val)
 711 {
 712         imx230_reg reg_list[2];
 713         int err;
 714         u32 frame_length;
 715         int i = 0;
 716
 717         frame_length = val;
 718
 719         dev_dbg(&priv->i2c_client->dev,
 720                  "%s: val: %d\n", __func__, frame_length);
 721
 722         imx230_get_frame_length_regs(reg_list, frame_length);
 723         imx230_set_group_hold(priv);
 724
 725         for (i = 0; i < 2; i++) {
 726                 err = imx230_write_reg(priv->s_data, reg_list[i].addr,
 727                          reg_list[i].val);
 728                 if (err)
 729                         goto fail;
 730         }
 731
 732         return 0;
 733
 734 fail:
 735         dev_dbg(&priv->i2c_client->dev,
 736                  "%s: FRAME_LENGTH control error\n", __func__);
 737         return err;
 738 }
 739
 740 static int imx230_set_coarse_time(struct imx230 *priv, s32 val)
 741 {
 742         imx230_reg reg_list[2];
 743         int err;
 744         u32 coarse_time;
 745         int i = 0;
 746
 747         coarse_time = val;
 748
 749         dev_dbg(&priv->i2c_client->dev,
 750                  "%s: val: %d\n", __func__, coarse_time);
 751
 752         imx230_get_coarse_time_regs(reg_list, coarse_time);
 753         imx230_set_group_hold(priv);
 754
 755         for (i = 0; i < 2; i++) {
 756                 err = imx230_write_reg(priv->s_data, reg_list[i].addr,
 757                          reg_list[i].val);
 758                 if (err)
 759                         goto fail;
 760         }
 761
 762         return 0;
 763
 764 fail:
 765         dev_dbg(&priv->i2c_client->dev,
 766                  "%s: COARSE_TIME control error\n", __func__);
 767         return err;
 768 }
 769
 770 static int imx230_set_coarse_time_short(struct imx230 *priv, s32 val)
 771 {
 772         imx230_reg reg_list[2];
 773         int err;
 774         struct v4l2_control hdr_control;
 775         int hdr_en;
 776         u32 coarse_time_short;
 777         int i = 0;
 778
 779         /* check hdr enable ctrl */
 780         hdr_control.id = V4L2_CID_HDR_EN;
 781
 782         err = v4l2_g_ctrl(&priv->ctrl_handler, &hdr_control);
 783         if (err < 0) {
 784                 dev_err(&priv->i2c_client->dev,
 785                         "could not find device ctrl.\n");
 786                 return err;
 787         }
 788
 789         hdr_en = switch_ctrl_qmenu[hdr_control.value];
 790         if (hdr_en == SWITCH_OFF)
 791                 return 0;
 792
 793         coarse_time_short = val;
 794
 795         dev_dbg(&priv->i2c_client->dev,
 796                  "%s: val: %d\n", __func__, coarse_time_short);
 797
 798         imx230_get_coarse_time_short_regs(reg_list, coarse_time_short);
 799         imx230_set_group_hold(priv);
 800
 801         for (i = 0; i < 2; i++) {
 802                 err  = imx230_write_reg(priv->s_data, reg_list[i].addr,
 803                          reg_list[i].val);
 804                 if (err)
 805                         goto fail;
 806         }
 807
 808         return 0;
 809
 810 fail:
 811         dev_dbg(&priv->i2c_client->dev,
 812                  "%s: COARSE_TIME_SHORT control error\n", __func__);
 813         return err;
 814 }
 815
 816 static int imx230_set_crop_data(struct imx230 *priv, struct v4l2_rect *rect)
 817 {
 818         imx230_reg reg_list_crop[IMX230_NUM_CROP_REGS];
 819         int err;
 820         int i = 0;
 821
 822         dev_dbg(&priv->i2c_client->dev,
 823                  "%s:  crop->left:%d, crop->top:%d, crop->res: %dx%d\n",
 824                  __func__, rect->left, rect->top, rect->width, rect->height);
 825
 826         imx230_get_crop_regs(reg_list_crop, rect);
 827         imx230_set_group_hold(priv);
 828
 829         for (i = 0; i < IMX230_NUM_CROP_REGS; i++) {
 830                 err = imx230_write_reg(priv->s_data, reg_list_crop[i].addr,
 831                          reg_list_crop[i].val);
 832                 if (err) {
 833                         dev_dbg(&priv->i2c_client->dev,
 834                                 "%s: SENSOR_CROP control error\n", __func__);
 835                         return err;
 836                 }
 837         }
 838
 839         return 0;
 840 }
 841
 842 static int imx230_get_crop_data(struct imx230 *priv, struct v4l2_rect *rect)
 843 {
 844         imx230_reg reg_list_crop[IMX230_NUM_CROP_REGS];
 845         int i, err;
 846         int a, b;
 847         int right, bottom;
 848
 849         for (i = 0; i < IMX230_NUM_CROP_REGS; i++) {
 850                 reg_list_crop[i].addr = (IMX230_CROP_X_START_ADDR_MSB + i);
 851                 err = imx230_read_reg(priv->s_data, reg_list_crop[i].addr,
 852                         &reg_list_crop[i].val);
 853                 if (err) {
 854                         dev_dbg(&priv->i2c_client->dev,
 855                                 "%s: SENSOR_CROP control error\n", __func__);
 856                         return err;
 857                 }
 858         }
 859
 860         a = reg_list_crop[0].val & 0x00ff;
 861         b = reg_list_crop[1].val & 0x00ff;
 862         rect->left = (a << 8) | b;
 863
 864         a = reg_list_crop[2].val & 0x00ff;
 865         b = reg_list_crop[3].val & 0x00ff;
 866         rect->top = (a << 8) | b;
 867
 868         a = reg_list_crop[4].val & 0x00ff;
 869         b = reg_list_crop[5].val & 0x00ff;
 870         right = (a << 8) | b;
 871         rect->width = right - rect->left + 1;
 872
 873         a = reg_list_crop[6].val & 0x00ff;
 874         b = reg_list_crop[7].val & 0x00ff;
 875         bottom = (a << 8) | b;
 876         rect->height = bottom - rect->top + 1;
 877
 878         return 0;
 879 }
 880
 881 #ifdef IMX230_EEPROM_PRESENT
 882 static int imx230_eeprom_device_release(struct imx230 *priv)
 883 {
 884         int i;
 885
 886         for (i = 0; i < IMX230_EEPROM_NUM_BLOCKS; i++) {
 887                 if (priv->eeprom[i].i2c_client != NULL) {
 888                         i2c_unregister_device(priv->eeprom[i].i2c_client);
 889                         priv->eeprom[i].i2c_client = NULL;
 890                 }
 891         }
 892
 893         return 0;
 894 }
 895
 896 static int imx230_eeprom_device_init(struct imx230 *priv)
 897 {
 898         char *dev_name = "eeprom_imx230";
 899         static struct regmap_config eeprom_regmap_config = {
 900                 .reg_bits = 8,
 901                 .val_bits = 8,
 902         };
 903         int i;
 904         int err;
 905
 906         for (i = 0; i < IMX230_EEPROM_NUM_BLOCKS; i++) {
 907                 priv->eeprom[i].adap = i2c_get_adapter(
 908                                 priv->i2c_client->adapter->nr);
 909                 memset(&priv->eeprom[i].brd, 0, sizeof(priv->eeprom[i].brd));
 910                 strncpy(priv->eeprom[i].brd.type, dev_name,
 911                                 sizeof(priv->eeprom[i].brd.type));
 912                 priv->eeprom[i].brd.addr = IMX230_EEPROM_ADDRESS + i;
 913                 priv->eeprom[i].i2c_client = i2c_new_device(
 914                                 priv->eeprom[i].adap, &priv->eeprom[i].brd);
 915
 916                 priv->eeprom[i].regmap = devm_regmap_init_i2c(
 917                         priv->eeprom[i].i2c_client, &eeprom_regmap_config);
 918                 if (IS_ERR(priv->eeprom[i].regmap)) {
 919                         err = PTR_ERR(priv->eeprom[i].regmap);
 920                         imx230_eeprom_device_release(priv);
 921                         return err;
 922                 }
 923         }
 924
 925         return 0;
 926 }
 927
 928 static int imx230_read_eeprom(struct imx230 *priv,
 929                                 struct v4l2_ctrl *ctrl)
 930 {
 931         int err, i;
 932
 933         for (i = 0; i < IMX230_EEPROM_NUM_BLOCKS; i++) {
 934                 err = regmap_bulk_read(priv->eeprom[i].regmap, 0,
 935                         &priv->eeprom_buf[i * IMX230_EEPROM_BLOCK_SIZE],
 936                         IMX230_EEPROM_BLOCK_SIZE);
 937                 if (err)
 938                         return err;
 939         }
 940
 941         for (i = 0; i < IMX230_EEPROM_SIZE; i++)
 942                 sprintf(&ctrl->string[i*2], "%02x",
 943                         priv->eeprom_buf[i]);
 944         return 0;
 945 }
 946
 947 static int imx230_write_eeprom(struct imx230 *priv,
 948                                 char *string)
 949 {
 950         int err;
 951         int i;
 952         u8 curr[3];
 953         unsigned long data;
 954
 955         for (i = 0; i < IMX230_EEPROM_SIZE; i++) {
 956                 curr[0] = string[i*2];
 957                 curr[1] = string[i*2+1];
 958                 curr[2] = '\0';
 959
 960                 err = kstrtol(curr, 16, &data);
 961                 if (err) {
 962                         dev_err(&priv->i2c_client->dev,
 963                                 "invalid eeprom string\n");
 964                         return -EINVAL;
 965                 }
 966
 967                 priv->eeprom_buf[i] = (u8)data;
 968                 err = regmap_write(priv->eeprom[i >> 8].regmap,
 969                                    i & 0xFF, (u8)data);
 970                 if (err)
 971                         return err;
 972                 msleep(20);
 973         }
 974         return 0;
 975 }
 976 #endif /* if IMX230_EEPROM_PRESENT */
 977
 978 static int imx230_read_otp_page(struct imx230 *priv,
 979                                 u8 *buf, int page, u16 addr, int size)
 980 {
 981         u8 status;
 982         int err;
 983
 984         err = imx230_write_reg(priv->s_data, IMX230_OTP_PAGE_NUM_ADDR, page);
 985         if (err)
 986                 return err;
 987         err = imx230_write_reg(priv->s_data, IMX230_OTP_CTRL_ADDR, 0x01);
 988         if (err)
 989                 return err;
 990         err = imx230_read_reg(priv->s_data, IMX230_OTP_STATUS_ADDR, &status);
 991         if (err)
 992                 return err;
 993         if (status == IMX230_OTP_STATUS_IN_PROGRESS) {
 994                 dev_err(&priv->i2c_client->dev,
 995                         "another OTP read in progress\n");
 996                 return err;
 997         }
 998
 999         err = regmap_bulk_read(priv->regmap, addr, buf, size);
1000         if (err)
1001                 return err;
1002
1003         err = imx230_read_reg(priv->s_data, IMX230_OTP_STATUS_ADDR, &status);
1004         if (err)
1005                 return err;
1006         if (status == IMX230_OTP_STATUS_READ_FAIL) {
1007                 dev_err(&priv->i2c_client->dev, "fuse id read error\n");
1008                 return err;
1009         }
1010
1011         return 0;
1012 }
1013
1014 static int imx230_otp_setup(struct imx230 *priv)
1015 {
1016         int err;
1017         int i;
1018         struct v4l2_ctrl *ctrl;
1019         u8 otp_buf[IMX230_OTP_SIZE];
1020
1021         err = camera_common_s_power(priv->subdev, true);
1022
1023         if (err)
1024                 return -ENODEV;
1025
1026         for (i = 0; i < IMX230_OTP_NUM_PAGES; i++) {
1027                 err = imx230_read_otp_page(priv,
1028                                    &otp_buf[i * IMX230_OTP_PAGE_SIZE],
1029                                    i,
1030                                    IMX230_OTP_PAGE_START_ADDR,
1031                                    IMX230_OTP_PAGE_SIZE);
1032                 if (err)
1033                         dev_err(&priv->i2c_client->dev, "otp read failed\n");
1034         }
1035
1036         ctrl = v4l2_ctrl_find(&priv->ctrl_handler, V4L2_CID_OTP_DATA);
1037         if (!ctrl) {
1038                 dev_err(&priv->i2c_client->dev,
1039                         "could not find device ctrl.\n");
1040                 return -EINVAL;
1041         }
1042
1043         for (i = 0; i < IMX230_OTP_SIZE; i++)
1044                 sprintf(&ctrl->string[i*2], "%02x",
1045                         otp_buf[i]);
1046         ctrl->cur.string = ctrl->string;
1047
1048         err = camera_common_s_power(priv->subdev, false);
1049         if (err)
1050                 return -ENODEV;
1051
1052         return 0;
1053 }
1054
1055 static int imx230_fuse_id_setup(struct imx230 *priv)
1056 {
1057         int err;
1058         int i;
1059         struct v4l2_ctrl *ctrl;
1060         u8 fuse_id[IMX230_FUSE_ID_SIZE];
1061
1062         err = camera_common_s_power(priv->subdev, true);
1063         if (err)
1064                 return -ENODEV;
1065
1066         err = imx230_read_otp_page(priv,
1067                            &fuse_id[0],
1068                            IMX230_FUSE_ID_OTP_PAGE,
1069                            IMX230_FUSE_ID_OTP_ROW_ADDR,
1070                            IMX230_FUSE_ID_SIZE);
1071
1072         if (err)
1073                 dev_err(&priv->i2c_client->dev, "fuse id otp read failed\n");
1074
1075         ctrl = v4l2_ctrl_find(&priv->ctrl_handler, V4L2_CID_FUSE_ID);
1076         if (!ctrl) {
1077                 dev_err(&priv->i2c_client->dev,
1078                         "could not find device ctrl.\n");
1079                 return -EINVAL;
1080         }
1081
1082         for (i = 0; i < IMX230_FUSE_ID_SIZE; i++) {
1083                 sprintf(&ctrl->string[i*2], "%02x",
1084                         fuse_id[i]);
1085                 dev_dbg(&priv->i2c_client->dev, "fuse_id[i] %02x\n",
1086                         fuse_id[i]);
1087         }
1088         ctrl->cur.string = ctrl->string;
1089
1090         err = camera_common_s_power(priv->subdev, false);
1091         if (err)
1092                 return -ENODEV;
1093
1094         return 0;
1095 }
1096
1097 static int imx230_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1098 {
1099         struct imx230 *priv =
1100                 container_of(ctrl->handler, struct imx230, ctrl_handler);
1101         int err = 0;
1102
1103         if (priv->power.state == SWITCH_OFF)
1104                 return 0;
1105
1106         switch (ctrl->id) {
1107 #ifdef IMX230_EEPROM_PRESENT
1108         case V4L2_CID_EEPROM_DATA:
1109                 err = imx230_read_eeprom(priv, ctrl);
1110                 if (err)
1111                         return err;
1112                 break;
1113 #endif /* if IMX230_EEPROM_PRESENT */
1114         default:
1115                         pr_err("%s: unknown ctrl id.\n", __func__);
1116                         return -EINVAL;
1117         }
1118
1119         return err;
1120 }
1121
1122 static int imx230_s_ctrl(struct v4l2_ctrl *ctrl)
1123 {
1124         struct imx230 *priv =
1125                 container_of(ctrl->handler, struct imx230, ctrl_handler);
1126         int err = 0;
1127
1128         if (priv->power.state == SWITCH_OFF)
1129                 return 0;
1130
1131         switch (ctrl->id) {
1132         case V4L2_CID_GAIN:
1133                 err = imx230_set_gain(priv, ctrl->val);
1134                 break;
1135         case V4L2_CID_FRAME_LENGTH:
1136                 err = imx230_set_frame_length(priv, ctrl->val);
1137                 break;
1138         case V4L2_CID_COARSE_TIME:
1139                 err = imx230_set_coarse_time(priv, ctrl->val);
1140                 break;
1141         case V4L2_CID_COARSE_TIME_SHORT:
1142                 err = imx230_set_coarse_time_short(priv, ctrl->val);
1143                 break;
1144         case V4L2_CID_GROUP_HOLD:
1145                 if (switch_ctrl_qmenu[ctrl->val] == SWITCH_ON) {
1146                         priv->group_hold_en = true;
1147                 } else {
1148                         priv->group_hold_en = false;
1149                         err = imx230_set_group_hold(priv);
1150                 }
1151                 break;
1152 #ifdef IMX230_EEPROM_PRESENT
1153         case V4L2_CID_EEPROM_DATA:
1154                 pr_debug("%s: eeprom %d\n", __func__, ctrl->id);
1155                 if (!ctrl->string[0])
1156                         break;
1157                 err = imx230_write_eeprom(priv, ctrl->string);
1158                 if (err)
1159                         return err;
1160                 break;
1161 #endif /* if IMX230_EEPROM_PRESENT */
1162         case V4L2_CID_HDR_EN:
1163                 break;
1164         default:
1165                 pr_err("%s: unknown ctrl id.\n", __func__);
1166                 return -EINVAL;
1167         }
1168
1169         return err;
1170 }
1171
1172 static int imx230_ctrls_init(struct imx230 *priv)
1173 {
1174         struct i2c_client *client = priv->i2c_client;
1175         struct v4l2_ctrl *ctrl;
1176         int num_ctrls;
1177         int err;
1178         int i;
1179
1180         dev_dbg(&client->dev, "%s++\n", __func__);
1181
1182         num_ctrls = ARRAY_SIZE(ctrl_config_list);
1183         v4l2_ctrl_handler_init(&priv->ctrl_handler, num_ctrls);
1184
1185         for (i = 0; i < num_ctrls; i++) {
1186                 ctrl = v4l2_ctrl_new_custom(&priv->ctrl_handler,
1187                         &ctrl_config_list[i], NULL);
1188                 if (ctrl == NULL) {
1189                         dev_err(&client->dev, "Failed to init %s ctrl\n",
1190                                 ctrl_config_list[i].name);
1191                         continue;
1192                 }
1193
1194                 if (ctrl_config_list[i].type == V4L2_CTRL_TYPE_STRING &&
1195                         ctrl_config_list[i].flags & V4L2_CTRL_FLAG_READ_ONLY) {
1196                         ctrl->string = devm_kzalloc(&client->dev,
1197                                 ctrl_config_list[i].max + 1, GFP_KERNEL);
1198                         if (!ctrl->string) {
1199                                 dev_err(&client->dev,
1200                                         "Failed to allocate otp data\n");
1201                                 return -ENOMEM;
1202                         }
1203                 }
1204                 priv->ctrls[i] = ctrl;
1205         }
1206
1207         priv->num_ctrls = num_ctrls;
1208         priv->subdev->ctrl_handler = &priv->ctrl_handler;
1209         if (priv->ctrl_handler.error) {
1210                 dev_err(&client->dev, "Error %d adding controls\n",
1211                         priv->ctrl_handler.error);
1212                 err = priv->ctrl_handler.error;
1213                 goto error;
1214         }
1215
1216         err = v4l2_ctrl_handler_setup(&priv->ctrl_handler);
1217         if (err) {
1218                 dev_err(&client->dev,
1219                         "Error %d setting default controls\n", err);
1220                 goto error;
1221         }
1222
1223         err = imx230_otp_setup(priv);
1224         if (err) {
1225                 dev_err(&client->dev,
1226                         "Error %d reading otp data\n", err);
1227                 goto error;
1228         }
1229
1230         err = imx230_fuse_id_setup(priv);
1231         if (err) {
1232                 dev_err(&client->dev,
1233                         "Error %d reading fuse id data\n", err);
1234                 goto error;
1235         }
1236
1237         return 0;
1238
1239 error:
1240         v4l2_ctrl_handler_free(&priv->ctrl_handler);
1241         return err;
1242 }
1243
1244 MODULE_DEVICE_TABLE(of, imx230_of_match);
1245
1246 static struct camera_common_pdata *imx230_parse_dt(struct i2c_client *client)
1247 {
1248         struct device_node *np = client->dev.of_node;
1249         struct camera_common_pdata *board_priv_pdata;
1250         const struct of_device_id *match;
1251         int sts;
1252
1253         match = of_match_device(imx230_of_match, &client->dev);
1254         if (!match) {
1255                 dev_err(&client->dev, "Failed to find matching dt id\n");
1256                 return NULL;
1257         }
1258
1259         board_priv_pdata = devm_kzalloc(&client->dev,
1260                            sizeof(*board_priv_pdata), GFP_KERNEL);
1261         if (!board_priv_pdata) {
1262                 dev_err(&client->dev, "Failed to allocate pdata\n");
1263                 return NULL;
1264         }
1265
1266         sts = of_property_read_string(np, "mclk", &board_priv_pdata->mclk_name);
1267         if (sts)
1268                 dev_err(&client->dev, "mclk not found %d\n", sts);
1269         sts = of_get_named_gpio(np, "reset-gpios", 0);
1270         if (sts >= 0)
1271                 board_priv_pdata->reset_gpio = sts;
1272         sts = of_get_named_gpio(np, "pwdn-gpios", 0);
1273         if (sts >= 0)
1274                 board_priv_pdata->pwdn_gpio = sts;
1275
1276         sts = of_property_read_string(np, "avdd-reg",
1277                         &board_priv_pdata->regulators.avdd);
1278         if (sts)
1279                 dev_err(&client->dev, "avdd-reg not found %d\n", sts);
1280         sts = of_property_read_string(np, "iovdd-reg",
1281                         &board_priv_pdata->regulators.iovdd);
1282         if (sts)
1283                 dev_err(&client->dev, "iovdd-reg not found %d\n", sts);
1284
1285         return board_priv_pdata;
1286 }
1287
1288 static int imx230_probe(struct i2c_client *client,
1289                         const struct i2c_device_id *id)
1290 {
1291         struct camera_common_data *common_data;
1292         struct imx230 *priv;
1293         struct soc_camera_subdev_desc *ssdd = soc_camera_i2c_to_desc(client);
1294         struct tegra_camera_platform_data *imx230_camera_data;
1295         int err;
1296
1297         pr_err("[IMX230]: probing v4l2 sensor.\n");
1298
1299         common_data = devm_kzalloc(&client->dev,
1300                             sizeof(struct camera_common_data), GFP_KERNEL);
1301         if (!common_data) {
1302                 dev_err(&client->dev, "unable to allocate memory!\n");
1303                 return -ENOMEM;
1304         }
1305
1306         priv = devm_kzalloc(&client->dev,
1307                             sizeof(struct imx230) + sizeof(struct v4l2_ctrl *) *
1308                             ARRAY_SIZE(ctrl_config_list),
1309                             GFP_KERNEL);
1310         if (!priv) {
1311                 dev_err(&client->dev, "unable to allocate memory!\n");
1312                 return -ENOMEM;
1313         }
1314
1315         priv->regmap = devm_regmap_init_i2c(client, &sensor_regmap_config);
1316         if (IS_ERR(priv->regmap)) {
1317                 dev_err(&client->dev,
1318                         "regmap init failed: %ld\n", PTR_ERR(priv->regmap));
1319                 return -ENODEV;
1320         }
1321
1322         ssdd = soc_camera_i2c_to_desc(client);
1323         imx230_camera_data = (struct tegra_camera_platform_data *)
1324                              ssdd->drv_priv;
1325         if (!imx230_camera_data) {
1326                 dev_err(&client->dev, "unable to find platform data\n");
1327                 return -EFAULT;
1328         }
1329
1330         client->dev.of_node = of_find_node_by_name(NULL, "imx230");
1331
1332         if (client->dev.of_node)
1333                 priv->pdata = imx230_parse_dt(client);
1334         else
1335                 priv->pdata = ssdd->dev_priv;
1336
1337         if (!priv->pdata) {
1338                 dev_err(&client->dev, "unable to get platform data\n");
1339                 return -EFAULT;
1340         }
1341
1342         common_data->ops                = &imx230_common_ops;
1343         common_data->ctrl_handler       = &priv->ctrl_handler;
1344         common_data->i2c_client         = client;
1345         common_data->frmfmt             = &imx230_frmfmt[0];
1346         common_data->colorfmt           = camera_common_find_datafmt(
1347                                           IMX230_DEFAULT_DATAFMT);
1348         common_data->ctrls              = priv->ctrls;
1349         common_data->power              = &priv->power;
1350         common_data->priv               = (void *)priv;
1351         common_data->ident              = V4L2_IDENT_IMX230;
1352         common_data->numfmts            = ARRAY_SIZE(imx230_frmfmt);
1353         common_data->def_mode           = IMX230_DEFAULT_MODE;
1354         common_data->def_width          = IMX230_DEFAULT_WIDTH;
1355         common_data->def_height         = IMX230_DEFAULT_HEIGHT;
1356         common_data->def_clk_freq       = IMX230_DEFAULT_CLK_FREQ;
1357         common_data->csi_port           = (int)imx230_camera_data->port;
1358         common_data->numlanes           = imx230_camera_data->lanes;
1359
1360         priv->i2c_client                = client;
1361         priv->s_data                    = common_data;
1362         priv->subdev                    = &common_data->subdev;
1363
1364         err = imx230_power_get(priv);
1365         if (err)
1366                 return err;
1367
1368         camera_common_create_debugfs(common_data, "imx230");
1369
1370         v4l2_i2c_subdev_init(&common_data->subdev, client, &imx230_subdev_ops);
1371
1372         err = imx230_ctrls_init(priv);
1373         if (err)
1374                 return err;
1375
1376 #ifdef IMX230_EEPROM_PRESENT
1377         /* eeprom interface */
1378         err = imx230_eeprom_device_init(priv);
1379         if (err)
1380                 dev_err(&client->dev,
1381                         "Failed to allocate eeprom register map: %d\n", err);
1382 #endif /* if IMX230_EEPROM_PRESENT */
1383
1384         return 0;
1385 }
1386
1387 static int
1388 imx230_remove(struct i2c_client *client)
1389 {
1390         struct soc_camera_subdev_desc *ssdd;
1391         struct camera_common_data *s_data = to_camera_common_data(client);
1392         struct imx230 *priv = (struct imx230 *)s_data->priv;
1393
1394         pr_err("[IMX230]: removing v4l2 sensor.\n");
1395
1396         ssdd = soc_camera_i2c_to_desc(client);
1397         if (ssdd->free_bus)
1398                 ssdd->free_bus(ssdd);
1399
1400         v4l2_ctrl_handler_free(&priv->ctrl_handler);
1401         imx230_power_put(priv);
1402         camera_common_remove_debugfs(s_data);
1403
1404         return 0;
1405 }
1406
1407 static const struct i2c_device_id imx230_id[] = {
1408         { "imx230_v4l2", 0 },
1409         { }
1410 };
1411
1412 MODULE_DEVICE_TABLE(i2c, imx230_id);
1413
1414 static struct i2c_driver imx230_i2c_driver = {
1415         .driver = {
1416                 .name = "imx230_v4l2",
1417                 .owner = THIS_MODULE,
1418         },
1419         .probe = imx230_probe,
1420         .remove = imx230_remove,
1421         .id_table = imx230_id,
1422 };
1423
1424 module_i2c_driver(imx230_i2c_driver);
1425
1426 MODULE_DESCRIPTION("SoC Camera driver for Sony IMX230");
1427 MODULE_AUTHOR("NVIDIA Corporation");
1428 MODULE_LICENSE("GPL v2");