drivers/media/i2c/imx274.c

   1 /*
   2  * imx274.c - imx274 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/camera_common.h>
  30 #include <media/imx274.h>
  31
  32 #include "imx274_mode_tbls.h"
  33
  34 #define IMX274_MAX_COARSE_DIFF          10
  35
  36 #define IMX274_GAIN_SHIFT               8
  37 #define IMX274_MIN_GAIN         (1 << IMX274_GAIN_SHIFT)
  38 #define IMX274_MAX_GAIN         (23 << IMX274_GAIN_SHIFT)
  39 #define IMX274_MIN_FRAME_LENGTH (0x8ED)
  40 #define IMX274_MAX_FRAME_LENGTH (0xB292)
  41 #define IMX274_MIN_EXPOSURE_COARSE      (0x0001)
  42 #define IMX274_MAX_EXPOSURE_COARSE      \
  43         (IMX274_MAX_FRAME_LENGTH-IMX274_MAX_COARSE_DIFF)
  44
  45 #define IMX274_DEFAULT_GAIN             IMX274_MIN_GAIN
  46 #define IMX274_DEFAULT_FRAME_LENGTH     (0x111B)
  47 #define IMX274_DEFAULT_EXPOSURE_COARSE  \
  48         (IMX274_DEFAULT_FRAME_LENGTH-IMX274_MAX_COARSE_DIFF)
  49
  50 #define IMX274_DEFAULT_MODE     IMX274_MODE_3840X2160
  51
  52 #define IMX274_DEFAULT_WIDTH    3840
  53 #define IMX274_DEFAULT_HEIGHT   2160
  54 #define IMX274_DEFAULT_DATAFMT  V4L2_MBUS_FMT_SRGGB10_1X10
  55 #define IMX274_DEFAULT_CLK_FREQ 24000000
  56
  57 struct imx274 {
  58         struct camera_common_power_rail power;
  59         int                             num_ctrls;
  60         struct v4l2_ctrl_handler        ctrl_handler;
  61         struct camera_common_eeprom_data eeprom[IMX274_EEPROM_NUM_BLOCKS];
  62         u8                              eeprom_buf[IMX274_EEPROM_SIZE];
  63         struct i2c_client               *i2c_client;
  64         struct v4l2_subdev              *subdev;
  65         struct media_pad                pad;
  66
  67         s32                             group_hold_prev;
  68         bool                            group_hold_en;
  69         struct regmap                   *regmap;
  70         struct camera_common_data       *s_data;
  71         struct camera_common_pdata      *pdata;
  72         struct v4l2_ctrl                *ctrls[];
  73 };
  74
  75 static const struct regmap_config sensor_regmap_config = {
  76         .reg_bits = 16,
  77         .val_bits = 8,
  78         .cache_type = REGCACHE_RBTREE,
  79 };
  80
  81 static int imx274_g_volatile_ctrl(struct v4l2_ctrl *ctrl);
  82 static int imx274_s_ctrl(struct v4l2_ctrl *ctrl);
  83
  84 static const struct v4l2_ctrl_ops imx274_ctrl_ops = {
  85         .g_volatile_ctrl = imx274_g_volatile_ctrl,
  86         .s_ctrl         = imx274_s_ctrl,
  87 };
  88
  89 static struct v4l2_ctrl_config ctrl_config_list[] = {
  90 /* Do not change the name field for the controls! */
  91         {
  92                 .ops = &imx274_ctrl_ops,
  93                 .id = V4L2_CID_GAIN,
  94                 .name = "Gain",
  95                 .type = V4L2_CTRL_TYPE_INTEGER,
  96                 .flags = V4L2_CTRL_FLAG_SLIDER,
  97                 .min = IMX274_MIN_GAIN,
  98                 .max = IMX274_MAX_GAIN,
  99                 .def = IMX274_DEFAULT_GAIN,
 100                 .step = 1,
 101         },
 102         {
 103                 .ops = &imx274_ctrl_ops,
 104                 .id = V4L2_CID_FRAME_LENGTH,
 105                 .name = "Frame Length",
 106                 .type = V4L2_CTRL_TYPE_INTEGER,
 107                 .flags = V4L2_CTRL_FLAG_SLIDER,
 108                 .min = IMX274_MIN_FRAME_LENGTH,
 109                 .max = IMX274_MAX_FRAME_LENGTH,
 110                 .def = IMX274_DEFAULT_FRAME_LENGTH,
 111                 .step = 1,
 112         },
 113         {
 114                 .ops = &imx274_ctrl_ops,
 115                 .id = V4L2_CID_COARSE_TIME,
 116                 .name = "Coarse Time",
 117                 .type = V4L2_CTRL_TYPE_INTEGER,
 118                 .flags = V4L2_CTRL_FLAG_SLIDER,
 119                 .min = IMX274_MIN_EXPOSURE_COARSE,
 120                 .max = IMX274_MAX_EXPOSURE_COARSE,
 121                 .def = IMX274_DEFAULT_EXPOSURE_COARSE,
 122                 .step = 1,
 123         },
 124         {
 125                 .ops = &imx274_ctrl_ops,
 126                 .id = V4L2_CID_COARSE_TIME_SHORT,
 127                 .name = "Coarse Time Short",
 128                 .type = V4L2_CTRL_TYPE_INTEGER,
 129                 .flags = V4L2_CTRL_FLAG_SLIDER,
 130                 .min = IMX274_MIN_EXPOSURE_COARSE,
 131                 .max = IMX274_MAX_EXPOSURE_COARSE,
 132                 .def = IMX274_DEFAULT_EXPOSURE_COARSE,
 133                 .step = 1,
 134         },
 135         {
 136                 .ops = &imx274_ctrl_ops,
 137                 .id = V4L2_CID_GROUP_HOLD,
 138                 .name = "Group Hold",
 139                 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
 140                 .min = 0,
 141                 .max = ARRAY_SIZE(switch_ctrl_qmenu) - 1,
 142                 .menu_skip_mask = 0,
 143                 .def = 0,
 144                 .qmenu_int = switch_ctrl_qmenu,
 145         },
 146         {
 147                 .ops = &imx274_ctrl_ops,
 148                 .id = V4L2_CID_HDR_EN,
 149                 .name = "HDR enable",
 150                 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
 151                 .min = 0,
 152                 .max = ARRAY_SIZE(switch_ctrl_qmenu) - 1,
 153                 .menu_skip_mask = 0,
 154                 .def = 0,
 155                 .qmenu_int = switch_ctrl_qmenu,
 156         },
 157         {
 158                 .ops = &imx274_ctrl_ops,
 159                 .id = V4L2_CID_EEPROM_DATA,
 160                 .name = "EEPROM Data",
 161                 .type = V4L2_CTRL_TYPE_STRING,
 162                 .flags = V4L2_CTRL_FLAG_VOLATILE,
 163                 .min = 0,
 164                 .max = IMX274_EEPROM_STR_SIZE,
 165                 .step = 2,
 166         },
 167         {
 168                 .ops = &imx274_ctrl_ops,
 169                 .id = V4L2_CID_OTP_DATA,
 170                 .name = "OTP Data",
 171                 .type = V4L2_CTRL_TYPE_STRING,
 172                 .flags = V4L2_CTRL_FLAG_READ_ONLY,
 173                 .min = 0,
 174                 .max = IMX274_OTP_STR_SIZE,
 175                 .step = 2,
 176         },
 177         {
 178                 .ops = &imx274_ctrl_ops,
 179                 .id = V4L2_CID_FUSE_ID,
 180                 .name = "Fuse ID",
 181                 .type = V4L2_CTRL_TYPE_STRING,
 182                 .flags = V4L2_CTRL_FLAG_READ_ONLY,
 183                 .min = 0,
 184                 .max = IMX274_FUSE_ID_STR_SIZE,
 185                 .step = 2,
 186         },
 187 };
 188
 189 static inline void imx274_get_vmax_regs(imx274_reg *regs,
 190                                 u32 vmax)
 191 {
 192         regs->addr = IMX274_VMAX_ADDR_MSB;
 193         regs->val = (vmax >> 8) & 0xff;
 194         (regs + 1)->addr = IMX274_VMAX_ADDR_LSB;
 195         (regs + 1)->val = (vmax) & 0xff;
 196 }
 197
 198 static inline void imx274_get_shr_regs(imx274_reg *regs,
 199                                 u32 shr)
 200 {
 201         regs->addr = IMX274_SHR_ADDR_MSB;
 202         regs->val = (shr >> 8) & 0xff;
 203         (regs + 1)->addr = IMX274_SHR_ADDR_LSB;
 204         (regs + 1)->val = (shr) & 0xff;
 205 }
 206
 207 static inline void imx274_get_gain_reg(imx274_reg *regs,
 208                                 u16 gain)
 209 {
 210         regs->addr = IMX274_GAIN_ADDR_MSB;
 211         regs->val = (gain >> 8) & 0xff;
 212         (regs + 1)->addr = IMX274_GAIN_ADDR_LSB;
 213         (regs + 1)->val = (gain) & 0xff;
 214 }
 215
 216 static int test_mode;
 217 module_param(test_mode, int, 0644);
 218
 219 static inline int imx274_read_reg(struct camera_common_data *s_data,
 220                                 u16 addr, u8 *val)
 221 {
 222         struct imx274 *priv = (struct imx274 *)s_data->priv;
 223         return regmap_read(priv->regmap, addr, (unsigned int *) val);
 224 }
 225
 226 static int imx274_write_reg(struct camera_common_data *s_data, u16 addr, u8 val)
 227 {
 228         int err;
 229         struct imx274 *priv = (struct imx274 *)s_data->priv;
 230
 231         err = regmap_write(priv->regmap, addr, val);
 232         if (err)
 233                 pr_err("%s:i2c write failed, %x = %x\n",
 234                         __func__, addr, val);
 235
 236         return err;
 237 }
 238
 239 static int imx274_write_table(struct imx274 *priv,
 240                                 const imx274_reg table[])
 241 {
 242         return regmap_util_write_table_8(priv->regmap,
 243                                          table,
 244                                          NULL, 0,
 245                                          IMX274_TABLE_WAIT_MS,
 246                                          IMX274_TABLE_END);
 247 }
 248
 249 static int imx274_power_on(struct camera_common_data *s_data)
 250 {
 251         int err = 0;
 252         struct imx274 *priv = (struct imx274 *)s_data->priv;
 253         struct camera_common_power_rail *pw = &priv->power;
 254
 255         dev_dbg(&priv->i2c_client->dev, "%s: power on\n", __func__);
 256
 257         if (priv->pdata && priv->pdata->power_on) {
 258                 err = priv->pdata->power_on(pw);
 259                 if (err)
 260                         pr_err("%s failed.\n", __func__);
 261                 else
 262                         pw->state = SWITCH_ON;
 263                 return err;
 264         }
 265
 266         if (pw->reset_gpio)
 267                 gpio_set_value(pw->reset_gpio, 0);
 268         if (pw->af_gpio)
 269                 gpio_set_value(pw->af_gpio, 1);
 270         if (pw->pwdn_gpio)
 271                 gpio_set_value(pw->pwdn_gpio, 0);
 272         usleep_range(10, 20);
 273
 274
 275         if (pw->dvdd)
 276                 err = regulator_enable(pw->dvdd);
 277         if (err)
 278                 goto imx274_dvdd_fail;
 279
 280         if (pw->iovdd)
 281                 err = regulator_enable(pw->iovdd);
 282         if (err)
 283                 goto imx274_iovdd_fail;
 284
 285         if (pw->avdd)
 286                 err = regulator_enable(pw->avdd);
 287         if (err)
 288                 goto imx274_avdd_fail;
 289
 290         usleep_range(1, 2);
 291         if (pw->reset_gpio)
 292                 gpio_set_value(pw->reset_gpio, 1);
 293         if (pw->pwdn_gpio)
 294                 gpio_set_value(pw->pwdn_gpio, 1);
 295
 296         usleep_range(300, 310);
 297
 298         pw->state = SWITCH_ON;
 299         return 0;
 300
 301 imx274_dvdd_fail:
 302         if (pw->af_gpio)
 303                 gpio_set_value(pw->af_gpio, 0);
 304
 305 imx274_iovdd_fail:
 306         regulator_disable(pw->dvdd);
 307
 308 imx274_avdd_fail:
 309         regulator_disable(pw->iovdd);
 310
 311         pr_err("%s failed.\n", __func__);
 312         return -ENODEV;
 313 }
 314
 315 static int imx274_power_off(struct camera_common_data *s_data)
 316 {
 317         int err = 0;
 318         struct imx274 *priv = (struct imx274 *)s_data->priv;
 319         struct camera_common_power_rail *pw = &priv->power;
 320
 321         return 0;
 322
 323         dev_dbg(&priv->i2c_client->dev, "%s: power off\n", __func__);
 324
 325         if (priv->pdata->power_off) {
 326                 err = priv->pdata->power_off(pw);
 327                 if (err) {
 328                         pr_err("%s failed.\n", __func__);
 329                         return err;
 330                 } else {
 331                         goto power_off_done;
 332                 }
 333         }
 334
 335         usleep_range(1, 2);
 336         if (pw->reset_gpio)
 337                 gpio_set_value(pw->reset_gpio, 0);
 338         if (pw->af_gpio)
 339                 gpio_set_value(pw->af_gpio, 0);
 340         if (pw->pwdn_gpio)
 341                 gpio_set_value(pw->pwdn_gpio, 0);
 342         usleep_range(1, 2);
 343
 344         if (pw->avdd)
 345                 regulator_disable(pw->avdd);
 346         if (pw->iovdd)
 347                 regulator_disable(pw->iovdd);
 348         if (pw->dvdd)
 349                 regulator_disable(pw->dvdd);
 350
 351 power_off_done:
 352         pw->state = SWITCH_OFF;
 353         return 0;
 354 }
 355
 356 static int imx274_power_put(struct imx274 *priv)
 357 {
 358         struct camera_common_power_rail *pw = &priv->power;
 359         if (unlikely(!pw))
 360                 return -EFAULT;
 361
 362         if (likely(pw->avdd))
 363                 regulator_put(pw->avdd);
 364
 365         if (likely(pw->iovdd))
 366                 regulator_put(pw->iovdd);
 367
 368         if (likely(pw->dvdd))
 369                 regulator_put(pw->dvdd);
 370
 371         pw->avdd = NULL;
 372         pw->iovdd = NULL;
 373         pw->dvdd = NULL;
 374
 375         return 0;
 376 }
 377
 378 static int imx274_power_get(struct imx274 *priv)
 379 {
 380         struct camera_common_power_rail *pw = &priv->power;
 381         struct camera_common_pdata *pdata = priv->pdata;
 382         const char *mclk_name;
 383         const char *parentclk_name;
 384         struct clk *parent;
 385         int err = 0;
 386
 387         mclk_name = priv->pdata->mclk_name ?
 388                     priv->pdata->mclk_name : "cam_mclk1";
 389         pw->mclk = devm_clk_get(&priv->i2c_client->dev, mclk_name);
 390         if (IS_ERR(pw->mclk)) {
 391                 dev_err(&priv->i2c_client->dev,
 392                         "unable to get clock %s\n", mclk_name);
 393                 return PTR_ERR(pw->mclk);
 394         }
 395
 396         parentclk_name = priv->pdata->parentclk_name;
 397         if (parentclk_name) {
 398                 parent = devm_clk_get(&priv->i2c_client->dev, parentclk_name);
 399                 if (IS_ERR(parent)) {
 400                         dev_err(&priv->i2c_client->dev,
 401                                 "unable to get parent clcok %s",
 402                                 parentclk_name);
 403                 } else
 404                         clk_set_parent(pw->mclk, parent);
 405         }
 406
 407         /* ananlog 2.7v */
 408         err |= camera_common_regulator_get(priv->i2c_client,
 409                         &pw->avdd, pdata->regulators.avdd);
 410         /* digital 1.2v */
 411         err |= camera_common_regulator_get(priv->i2c_client,
 412                         &pw->dvdd, pdata->regulators.dvdd);
 413         /* IO 1.8v */
 414         err |= camera_common_regulator_get(priv->i2c_client,
 415                         &pw->iovdd, pdata->regulators.iovdd);
 416
 417         if (!err) {
 418                 pw->reset_gpio = pdata->reset_gpio;
 419                 pw->af_gpio = pdata->af_gpio;
 420                 pw->pwdn_gpio = pdata->pwdn_gpio;
 421         }
 422
 423         pw->state = SWITCH_OFF;
 424         return err;
 425 }
 426
 427 static int imx274_set_gain(struct imx274 *priv, s32 val);
 428 static int imx274_set_frame_length(struct imx274 *priv, s32 val);
 429 static int imx274_set_coarse_time(struct imx274 *priv, s32 val);
 430
 431 static int imx274_s_stream(struct v4l2_subdev *sd, int enable)
 432 {
 433         struct i2c_client *client = v4l2_get_subdevdata(sd);
 434         struct camera_common_data *s_data = to_camera_common_data(client);
 435         struct imx274 *priv = (struct imx274 *)s_data->priv;
 436         struct v4l2_control control;
 437         int err;
 438
 439         dev_dbg(&client->dev, "%s++\n", __func__);
 440
 441         imx274_write_table(priv, mode_table[IMX274_MODE_STOP_STREAM]);
 442
 443         dev_dbg(&client->dev, "%s mode[%d]\n", __func__, s_data->mode);
 444
 445         err = imx274_write_table(priv, mode_table[s_data->mode]);
 446         if (err)
 447                 goto exit;
 448
 449         /* write list of override regs for the asking frame length, */
 450         /* coarse integration time, and gain.                       */
 451
 452         control.id = V4L2_CID_GAIN;
 453         err = v4l2_g_ctrl(&priv->ctrl_handler, &control);
 454         err |= imx274_set_gain(priv, control.value);
 455         if (err)
 456                 dev_dbg(&client->dev, "%s: error gain override\n", __func__);
 457
 458         control.id = V4L2_CID_FRAME_LENGTH;
 459         err = v4l2_g_ctrl(&priv->ctrl_handler, &control);
 460         err |= imx274_set_frame_length(priv, control.value);
 461         if (err)
 462                 dev_dbg(&client->dev,
 463                         "%s: error frame length override\n", __func__);
 464
 465         control.id = V4L2_CID_COARSE_TIME;
 466         err = v4l2_g_ctrl(&priv->ctrl_handler, &control);
 467         err |= imx274_set_coarse_time(priv, control.value);
 468         if (err)
 469                 dev_dbg(&client->dev,
 470                         "%s: error coarse time override\n", __func__);
 471
 472         if (test_mode)
 473                 err = imx274_write_table(priv,
 474                         mode_table[IMX274_MODE_TEST_PATTERN]);
 475
 476         err = imx274_write_table(priv, mode_table[IMX274_MODE_START_STREAM]);
 477         if (err)
 478                 goto exit;
 479
 480
 481         return 0;
 482 exit:
 483         dev_dbg(&client->dev, "%s: error setting stream\n", __func__);
 484         return err;
 485 }
 486
 487 static int imx274_get_fmt(struct v4l2_subdev *sd,
 488                 struct v4l2_subdev_fh *fh,
 489                 struct v4l2_subdev_format *format)
 490 {
 491         return camera_common_g_fmt(sd, &format->format);
 492 }
 493
 494 static int imx274_set_fmt(struct v4l2_subdev *sd,
 495                 struct v4l2_subdev_fh *fh,
 496         struct v4l2_subdev_format *format)
 497 {
 498         int ret;
 499
 500         if (format->which == V4L2_SUBDEV_FORMAT_TRY)
 501                 ret = camera_common_try_fmt(sd, &format->format);
 502         else
 503                 ret = camera_common_s_fmt(sd, &format->format);
 504
 505         return ret;
 506 }
 507
 508 static int imx274_g_input_status(struct v4l2_subdev *sd, u32 *status)
 509 {
 510         struct i2c_client *client = v4l2_get_subdevdata(sd);
 511         struct camera_common_data *s_data = to_camera_common_data(client);
 512         struct imx274 *priv = (struct imx274 *)s_data->priv;
 513         struct camera_common_power_rail *pw = &priv->power;
 514
 515         *status = pw->state == SWITCH_ON;
 516         return 0;
 517 }
 518
 519 static struct v4l2_subdev_video_ops imx274_subdev_video_ops = {
 520         .s_stream       = imx274_s_stream,
 521         .s_mbus_fmt     = camera_common_s_fmt,
 522         .g_mbus_fmt     = camera_common_g_fmt,
 523         .try_mbus_fmt   = camera_common_try_fmt,
 524         .enum_mbus_fmt  = camera_common_enum_fmt,
 525         .g_mbus_config  = camera_common_g_mbus_config,
 526         .enum_framesizes        = camera_common_enum_framesizes,
 527         .enum_frameintervals    = camera_common_enum_frameintervals,
 528         .g_input_status         = imx274_g_input_status,
 529 };
 530
 531 static struct v4l2_subdev_core_ops imx274_subdev_core_ops = {
 532         .s_power        = camera_common_s_power,
 533 };
 534
 535 static struct v4l2_subdev_pad_ops imx274_subdev_pad_ops = {
 536         .enum_mbus_code = camera_common_enum_mbus_code,
 537         .set_fmt        = imx274_set_fmt,
 538         .get_fmt        = imx274_get_fmt,
 539 };
 540
 541 static struct v4l2_subdev_ops imx274_subdev_ops = {
 542         .core   = &imx274_subdev_core_ops,
 543         .video  = &imx274_subdev_video_ops,
 544         .pad    = &imx274_subdev_pad_ops,
 545 };
 546
 547 static struct of_device_id imx274_of_match[] = {
 548         { .compatible = "nvidia,imx274", },
 549         { },
 550 };
 551
 552 static struct camera_common_sensor_ops imx274_common_ops = {
 553         .power_on = imx274_power_on,
 554         .power_off = imx274_power_off,
 555         .write_reg = imx274_write_reg,
 556         .read_reg = imx274_read_reg,
 557 };
 558
 559 static int imx274_set_group_hold(struct imx274 *priv)
 560 {
 561         int err;
 562         int gh_prev = switch_ctrl_qmenu[priv->group_hold_prev];
 563
 564         if (priv->group_hold_en == true && gh_prev == SWITCH_OFF) {
 565                 err = imx274_write_reg(priv->s_data,
 566                                        IMX274_GROUP_HOLD_ADDR, 0x1);
 567                 if (err)
 568                         goto fail;
 569                 priv->group_hold_prev = 1;
 570         } else if (priv->group_hold_en == false && gh_prev == SWITCH_ON) {
 571                 err = imx274_write_reg(priv->s_data,
 572                                        IMX274_GROUP_HOLD_ADDR, 0x0);
 573                 if (err)
 574                         goto fail;
 575                 priv->group_hold_prev = 0;
 576         }
 577
 578         return 0;
 579
 580 fail:
 581         dev_dbg(&priv->i2c_client->dev,
 582                  "%s: Group hold control error\n", __func__);
 583         return err;
 584 }
 585
 586 static int imx274_set_gain(struct imx274 *priv, s32 val)
 587 {
 588         imx274_reg reg_list[2];
 589         int err;
 590         int i = 0;
 591         u16 gain;
 592
 593         dev_dbg(&priv->i2c_client->dev,
 594                 "%s: val: %d\n", __func__, val);
 595
 596         if (val < IMX274_MIN_GAIN)
 597                 val = IMX274_MIN_GAIN;
 598         else if (val > IMX274_MAX_GAIN)
 599                 val = IMX274_MAX_GAIN;
 600
 601         gain = 2048 - (2048 * IMX274_MIN_GAIN / val);
 602
 603         imx274_get_gain_reg(reg_list, gain);
 604         imx274_set_group_hold(priv);
 605
 606         /* writing analog gain */
 607         for (i = 0; i < 2; i++) {
 608                 err = imx274_write_reg(priv->s_data, reg_list[i].addr,
 609                          reg_list[i].val);
 610                 if (err)
 611                         goto fail;
 612         }
 613
 614         return 0;
 615
 616 fail:
 617         dev_dbg(&priv->i2c_client->dev,
 618                  "%s: GAIN control error\n", __func__);
 619         return err;
 620 }
 621
 622 static int imx274_set_frame_length(struct imx274 *priv, s32 val)
 623 {
 624         imx274_reg reg_list[2];
 625         int err;
 626         u32 frame_length;
 627         u32 frame_rate;
 628         int i = 0;
 629         u8 svr;
 630         u32 vmax;
 631
 632         dev_dbg(&priv->i2c_client->dev,
 633                  "%s: val: %u\n", __func__, val);
 634
 635         frame_length = (u32)val;
 636
 637         frame_rate = (u32)(IMX274_PIXEL_CLK_HZ /
 638                                 (u32)(frame_length * IMX274_LINE_LENGTH));
 639
 640         imx274_read_reg(priv->s_data, IMX274_SVR_ADDR, &svr);
 641
 642         vmax = (u32)(72000000 /
 643                         (u32)(frame_rate * IMX274_HMAX * (svr + 1))) - 12;
 644
 645         imx274_get_vmax_regs(reg_list, vmax);
 646
 647         imx274_set_group_hold(priv);
 648
 649         for (i = 0; i < 2; i++) {
 650                 err = imx274_write_reg(priv->s_data, reg_list[i].addr,
 651                          reg_list[i].val);
 652                 if (err)
 653                         goto fail;
 654         }
 655
 656         dev_dbg(&priv->i2c_client->dev,
 657                 "%s: frame_rate: %d vmax: %u\n", __func__, frame_rate, vmax);
 658         return 0;
 659
 660 fail:
 661         dev_info(&priv->i2c_client->dev,
 662                  "%s: FRAME_LENGTH control error\n", __func__);
 663         return err;
 664 }
 665
 666 static int imx274_calculate_shr(struct imx274 *priv, u32 rep)
 667 {
 668         u8 svr;
 669         int shr;
 670         int min;
 671         int max;
 672         u8 vmax_l;
 673         u8 vmax_m;
 674         u32 vmax;
 675
 676         imx274_read_reg(priv->s_data, IMX274_SVR_ADDR, &svr);
 677
 678         imx274_read_reg(priv->s_data, IMX274_VMAX_ADDR_LSB, &vmax_l);
 679         imx274_read_reg(priv->s_data, IMX274_VMAX_ADDR_MSB, &vmax_m);
 680
 681         vmax = ((vmax_m << 8) + vmax_l);
 682
 683         min = IMX274_MODE1_SHR_MIN;
 684         max = ((svr + 1) * IMX274_VMAX) - 4;
 685
 686         shr = vmax * (svr + 1) -
 687                         (rep * IMX274_ET_FACTOR - IMX274_MODE1_OFFSET) /
 688                         IMX274_HMAX;
 689
 690         if (shr < min)
 691                 shr = min;
 692
 693         if (shr > max)
 694                 shr = max;
 695
 696         dev_dbg(&priv->i2c_client->dev,
 697                  "%s: shr: %u vmax: %d\n", __func__, shr, vmax);
 698         return shr;
 699 }
 700
 701 static int imx274_set_coarse_time(struct imx274 *priv, s32 val)
 702 {
 703         imx274_reg reg_list[2];
 704         int err;
 705         u32 coarse_time;
 706         u32 shr;
 707         int i = 0;
 708
 709         coarse_time = val;
 710
 711         dev_dbg(&priv->i2c_client->dev,
 712                  "%s: val: %d\n", __func__, coarse_time);
 713
 714         shr = imx274_calculate_shr(priv, coarse_time);
 715
 716         imx274_get_shr_regs(reg_list, shr);
 717         imx274_set_group_hold(priv);
 718
 719         for (i = 0; i < 2; i++) {
 720                 err = imx274_write_reg(priv->s_data, reg_list[i].addr,
 721                          reg_list[i].val);
 722                 if (err)
 723                         goto fail;
 724         }
 725
 726         return 0;
 727
 728 fail:
 729         dev_dbg(&priv->i2c_client->dev,
 730                  "%s: COARSE_TIME control error\n", __func__);
 731         return err;
 732 }
 733
 734 static int imx274_eeprom_device_release(struct imx274 *priv)
 735 {
 736         int i;
 737
 738         for (i = 0; i < IMX274_EEPROM_NUM_BLOCKS; i++) {
 739                 if (priv->eeprom[i].i2c_client != NULL) {
 740                         i2c_unregister_device(priv->eeprom[i].i2c_client);
 741                         priv->eeprom[i].i2c_client = NULL;
 742                 }
 743         }
 744
 745         return 0;
 746 }
 747
 748 static int imx274_eeprom_device_init(struct imx274 *priv)
 749 {
 750         char *dev_name = "eeprom_imx274";
 751         static struct regmap_config eeprom_regmap_config = {
 752                 .reg_bits = 8,
 753                 .val_bits = 8,
 754         };
 755         int i;
 756         int err;
 757
 758         return 0;
 759
 760         for (i = 0; i < IMX274_EEPROM_NUM_BLOCKS; i++) {
 761                 priv->eeprom[i].adap = i2c_get_adapter(
 762                                 priv->i2c_client->adapter->nr);
 763                 memset(&priv->eeprom[i].brd, 0, sizeof(priv->eeprom[i].brd));
 764                 strncpy(priv->eeprom[i].brd.type, dev_name,
 765                                 sizeof(priv->eeprom[i].brd.type));
 766                 priv->eeprom[i].brd.addr = IMX274_EEPROM_ADDRESS + i;
 767                 priv->eeprom[i].i2c_client = i2c_new_device(
 768                                 priv->eeprom[i].adap, &priv->eeprom[i].brd);
 769
 770                 priv->eeprom[i].regmap = devm_regmap_init_i2c(
 771                         priv->eeprom[i].i2c_client, &eeprom_regmap_config);
 772                 if (IS_ERR(priv->eeprom[i].regmap)) {
 773                         err = PTR_ERR(priv->eeprom[i].regmap);
 774                         imx274_eeprom_device_release(priv);
 775                         return err;
 776                 }
 777         }
 778
 779         return 0;
 780 }
 781
 782 static int imx274_read_eeprom(struct imx274 *priv,
 783                                 struct v4l2_ctrl *ctrl)
 784 {
 785         int err, i;
 786
 787         for (i = 0; i < IMX274_EEPROM_NUM_BLOCKS; i++) {
 788                 err = regmap_bulk_read(priv->eeprom[i].regmap, 0,
 789                         &priv->eeprom_buf[i * IMX274_EEPROM_BLOCK_SIZE],
 790                         IMX274_EEPROM_BLOCK_SIZE);
 791                 if (err)
 792                         return err;
 793         }
 794
 795         for (i = 0; i < IMX274_EEPROM_SIZE; i++)
 796                 sprintf(&ctrl->string[i*2], "%02x",
 797                         priv->eeprom_buf[i]);
 798         return 0;
 799 }
 800
 801 static int imx274_write_eeprom(struct imx274 *priv,
 802                                 char *string)
 803 {
 804         int err;
 805         int i;
 806         u8 curr[3];
 807         unsigned long data;
 808
 809         for (i = 0; i < IMX274_EEPROM_SIZE; i++) {
 810                 curr[0] = string[i*2];
 811                 curr[1] = string[i*2+1];
 812                 curr[2] = '\0';
 813
 814                 err = kstrtol(curr, 16, &data);
 815                 if (err) {
 816                         dev_err(&priv->i2c_client->dev,
 817                                 "invalid eeprom string\n");
 818                         return -EINVAL;
 819                 }
 820
 821                 priv->eeprom_buf[i] = (u8)data;
 822                 err = regmap_write(priv->eeprom[i >> 8].regmap,
 823                                    i & 0xFF, (u8)data);
 824                 if (err)
 825                         return err;
 826                 msleep(20);
 827         }
 828         return 0;
 829 }
 830
 831 static int imx274_read_otp_page(struct imx274 *priv,
 832                                 u8 *buf, int page, u16 addr, int size)
 833 {
 834         u8 status;
 835         int err;
 836
 837         err = imx274_write_reg(priv->s_data, IMX274_OTP_PAGE_NUM_ADDR, page);
 838         if (err)
 839                 return err;
 840         err = imx274_write_reg(priv->s_data, IMX274_OTP_CTRL_ADDR, 0x01);
 841         if (err)
 842                 return err;
 843         err = imx274_read_reg(priv->s_data, IMX274_OTP_STATUS_ADDR, &status);
 844         if (err)
 845                 return err;
 846         if (status == IMX274_OTP_STATUS_IN_PROGRESS) {
 847                 dev_err(&priv->i2c_client->dev,
 848                         "another OTP read in progress\n");
 849                 return err;
 850         }
 851
 852         err = regmap_bulk_read(priv->regmap, addr, buf, size);
 853         if (err)
 854                 return err;
 855
 856         err = imx274_read_reg(priv->s_data, IMX274_OTP_STATUS_ADDR, &status);
 857         if (err)
 858                 return err;
 859         if (status == IMX274_OTP_STATUS_READ_FAIL) {
 860                 dev_err(&priv->i2c_client->dev, "fuse id read error\n");
 861                 return err;
 862         }
 863
 864         return 0;
 865 }
 866
 867 static int imx274_verify_streaming(struct imx274 *priv)
 868 {
 869         int err = 0;
 870
 871         err = camera_common_s_power(priv->subdev, true);
 872         if (err)
 873                 return err;
 874
 875         err = imx274_s_stream(priv->subdev, true);
 876         if (err)
 877                 goto error;
 878
 879 error:
 880         imx274_s_stream(priv->subdev, false);
 881         camera_common_s_power(priv->subdev, false);
 882
 883         return err;
 884 }
 885
 886 static int imx274_otp_setup(struct imx274 *priv)
 887 {
 888         int err;
 889         int i;
 890         struct v4l2_ctrl *ctrl;
 891         u8 otp_buf[IMX274_OTP_SIZE];
 892         /* fixed me later */
 893         return 0;
 894
 895         err = camera_common_s_power(priv->subdev, true);
 896         if (err)
 897                 return err;
 898
 899         for (i = 0; i < IMX274_OTP_NUM_PAGES; i++) {
 900                 err = imx274_read_otp_page(priv,
 901                                    &otp_buf[i * IMX274_OTP_PAGE_SIZE],
 902                                    i,
 903                                    IMX274_OTP_PAGE_START_ADDR,
 904                                    IMX274_OTP_PAGE_SIZE);
 905                 if (err)
 906                         break;
 907         }
 908
 909         ctrl = v4l2_ctrl_find(&priv->ctrl_handler, V4L2_CID_OTP_DATA);
 910         if (!ctrl) {
 911                 dev_err(&priv->i2c_client->dev,
 912                         "could not find device ctrl.\n");
 913                 return -EINVAL;
 914         }
 915
 916         if (err) {
 917                 dev_err(&priv->i2c_client->dev, "%s error read otp bank\n",
 918                         __func__);
 919                 ctrl->flags = V4L2_CTRL_FLAG_DISABLED;
 920                 return 0;
 921         }
 922
 923         for (i = 0; i < IMX274_OTP_SIZE; i++)
 924                 sprintf(&ctrl->string[i*2], "%02x",
 925                         otp_buf[i]);
 926         ctrl->cur.string = ctrl->string;
 927
 928         err = camera_common_s_power(priv->subdev, false);
 929         if (err)
 930                 return err;
 931
 932         return 0;
 933 }
 934
 935 static int imx274_fuse_id_setup(struct imx274 *priv)
 936 {
 937         int err;
 938         int i;
 939         struct v4l2_ctrl *ctrl;
 940         u8 fuse_id[IMX274_FUSE_ID_SIZE];
 941         /* fixed me later */
 942         return 0;
 943
 944         err = camera_common_s_power(priv->subdev, true);
 945         if (err)
 946                 return err;
 947
 948         err = imx274_read_otp_page(priv,
 949                            &fuse_id[0],
 950                            IMX274_FUSE_ID_OTP_PAGE,
 951                            IMX274_FUSE_ID_OTP_ROW_ADDR,
 952                            IMX274_FUSE_ID_SIZE);
 953
 954         ctrl = v4l2_ctrl_find(&priv->ctrl_handler, V4L2_CID_FUSE_ID);
 955         if (!ctrl) {
 956                 dev_err(&priv->i2c_client->dev,
 957                         "could not find device ctrl.\n");
 958                 return -EINVAL;
 959         }
 960
 961         if (err) {
 962                 dev_err(&priv->i2c_client->dev, "%s error read fuse id\n",
 963                         __func__);
 964                 ctrl->flags = V4L2_CTRL_FLAG_DISABLED;
 965                 return 0;
 966         }
 967
 968         for (i = 0; i < IMX274_FUSE_ID_SIZE; i++)
 969                 sprintf(&ctrl->string[i*2], "%02x",
 970                         fuse_id[i]);
 971         ctrl->cur.string = ctrl->string;
 972
 973         err = camera_common_s_power(priv->subdev, false);
 974         if (err)
 975                 return err;
 976
 977         return 0;
 978 }
 979
 980 static int imx274_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
 981 {
 982         struct imx274 *priv =
 983                 container_of(ctrl->handler, struct imx274, ctrl_handler);
 984         int err = 0;
 985         return 0;
 986         if (priv->power.state == SWITCH_OFF)
 987                 return 0;
 988
 989         switch (ctrl->id) {
 990         case V4L2_CID_EEPROM_DATA:
 991                 err = imx274_read_eeprom(priv, ctrl);
 992                 if (err)
 993                         return err;
 994                 break;
 995         default:
 996                         pr_err("%s: unknown ctrl id.\n", __func__);
 997                         return -EINVAL;
 998         }
 999
1000         return err;
1001 }
1002
1003 static int imx274_s_ctrl(struct v4l2_ctrl *ctrl)
1004 {
1005         struct imx274 *priv =
1006                 container_of(ctrl->handler, struct imx274, ctrl_handler);
1007         int err = 0;
1008
1009         if (priv->power.state == SWITCH_OFF)
1010                 return 0;
1011
1012         switch (ctrl->id) {
1013         case V4L2_CID_GAIN:
1014                 err = imx274_set_gain(priv, ctrl->val);
1015                 break;
1016         case V4L2_CID_FRAME_LENGTH:
1017                 err = imx274_set_frame_length(priv, ctrl->val);
1018                 break;
1019         case V4L2_CID_COARSE_TIME:
1020                 err = imx274_set_coarse_time(priv, ctrl->val);
1021                 break;
1022         case V4L2_CID_COARSE_TIME_SHORT:
1023                 err = imx274_set_coarse_time(priv, ctrl->val);
1024                 break;
1025         case V4L2_CID_GROUP_HOLD:
1026                 if (switch_ctrl_qmenu[ctrl->val] == SWITCH_ON) {
1027                         priv->group_hold_en = true;
1028                 } else {
1029                         priv->group_hold_en = false;
1030                         err = imx274_set_group_hold(priv);
1031                 }
1032                 break;
1033         case V4L2_CID_EEPROM_DATA:
1034                 if (!ctrl->string[0])
1035                         break;
1036                 err = imx274_write_eeprom(priv, ctrl->string);
1037                 if (err)
1038                         return err;
1039                 break;
1040         case V4L2_CID_HDR_EN:
1041                 break;
1042         default:
1043                 pr_err("%s: unknown ctrl id.\n", __func__);
1044                 return -EINVAL;
1045         }
1046
1047         return err;
1048 }
1049
1050 static int imx274_ctrls_init(struct imx274 *priv)
1051 {
1052         struct i2c_client *client = priv->i2c_client;
1053         struct v4l2_ctrl *ctrl;
1054         int num_ctrls;
1055         int err;
1056         int i;
1057
1058         dev_dbg(&client->dev, "%s++\n", __func__);
1059
1060         num_ctrls = ARRAY_SIZE(ctrl_config_list);
1061         v4l2_ctrl_handler_init(&priv->ctrl_handler, num_ctrls);
1062
1063         for (i = 0; i < num_ctrls; i++) {
1064                 ctrl = v4l2_ctrl_new_custom(&priv->ctrl_handler,
1065                         &ctrl_config_list[i], NULL);
1066                 if (ctrl == NULL) {
1067                         dev_err(&client->dev, "Failed to init %s ctrl\n",
1068                                 ctrl_config_list[i].name);
1069                         continue;
1070                 }
1071
1072                 if (ctrl_config_list[i].type == V4L2_CTRL_TYPE_STRING &&
1073                         ctrl_config_list[i].flags & V4L2_CTRL_FLAG_READ_ONLY) {
1074                         ctrl->string = devm_kzalloc(&client->dev,
1075                                 ctrl_config_list[i].max + 1, GFP_KERNEL);
1076                 }
1077                 priv->ctrls[i] = ctrl;
1078         }
1079
1080         priv->num_ctrls = num_ctrls;
1081         priv->subdev->ctrl_handler = &priv->ctrl_handler;
1082         if (priv->ctrl_handler.error) {
1083                 dev_err(&client->dev, "Error %d adding controls\n",
1084                         priv->ctrl_handler.error);
1085                 err = priv->ctrl_handler.error;
1086                 goto error;
1087         }
1088
1089         err = v4l2_ctrl_handler_setup(&priv->ctrl_handler);
1090         if (err) {
1091                 dev_err(&client->dev,
1092                         "Error %d setting default controls\n", err);
1093                 goto error;
1094         }
1095
1096         err = imx274_otp_setup(priv);
1097         if (err) {
1098                 dev_err(&client->dev,
1099                         "Error %d reading otp data\n", err);
1100                 goto error;
1101         }
1102
1103         err = imx274_fuse_id_setup(priv);
1104         if (err) {
1105                 dev_err(&client->dev,
1106                         "Error %d reading fuse id data\n", err);
1107                 goto error;
1108         }
1109
1110         return 0;
1111
1112 error:
1113         v4l2_ctrl_handler_free(&priv->ctrl_handler);
1114         return err;
1115 }
1116
1117 MODULE_DEVICE_TABLE(of, imx274_of_match);
1118
1119 static struct camera_common_pdata *imx274_parse_dt(struct i2c_client *client)
1120 {
1121         struct device_node *node = client->dev.of_node;
1122         struct camera_common_pdata *board_priv_pdata;
1123         const struct of_device_id *match;
1124         int err;
1125
1126         if (!node)
1127                 return NULL;
1128
1129         match = of_match_device(imx274_of_match, &client->dev);
1130         if (!match) {
1131                 dev_err(&client->dev, " Failed to find matching dt id\n");
1132                 return NULL;
1133         }
1134
1135         board_priv_pdata = devm_kzalloc(&client->dev,
1136                            sizeof(*board_priv_pdata), GFP_KERNEL);
1137         if (!board_priv_pdata) {
1138                 dev_err(&client->dev, "Failed to allocate pdata\n");
1139                 return NULL;
1140         }
1141
1142
1143         err = camera_common_parse_clocks(client, board_priv_pdata);
1144         if (err) {
1145                 dev_err(&client->dev, "Failed to find clocks\n");
1146                 goto error;
1147         }
1148
1149         err = of_property_read_string(node, "mclk",
1150                                       &board_priv_pdata->mclk_name);
1151         if (err)
1152                 dev_err(&client->dev, "mclk not in DT\n");
1153
1154         board_priv_pdata->reset_gpio = of_get_named_gpio(node,
1155                         "reset-gpios", 0);
1156
1157         of_property_read_string(node, "avdd-reg",
1158                         &board_priv_pdata->regulators.avdd);
1159         of_property_read_string(node, "dvdd-reg",
1160                         &board_priv_pdata->regulators.dvdd);
1161         of_property_read_string(node, "iovdd-reg",
1162                         &board_priv_pdata->regulators.iovdd);
1163
1164         return board_priv_pdata;
1165
1166 error:
1167         devm_kfree(&client->dev, board_priv_pdata);
1168         return NULL;
1169 }
1170
1171 static int imx274_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
1172 {
1173         struct i2c_client *client = v4l2_get_subdevdata(sd);
1174         dev_dbg(&client->dev, "%s:\n", __func__);
1175
1176
1177         return 0;
1178 }
1179
1180 static const struct v4l2_subdev_internal_ops imx274_subdev_internal_ops = {
1181         .open = imx274_open,
1182 };
1183
1184 static const struct media_entity_operations imx274_media_ops = {
1185 #ifdef CONFIG_MEDIA_CONTROLLER
1186         .link_validate = v4l2_subdev_link_validate,
1187 #endif
1188 };
1189
1190 static int imx274_probe(struct i2c_client *client,
1191                         const struct i2c_device_id *id)
1192 {
1193         struct camera_common_data *common_data;
1194         struct device_node *node = client->dev.of_node;
1195         struct imx274 *priv;
1196         char debugfs_name[10];
1197         int err;
1198
1199         pr_info("[IMX274]: probing v4l2 sensor.\n");
1200
1201         if (!IS_ENABLED(CONFIG_OF) || !node)
1202                 return -EINVAL;
1203
1204         common_data = devm_kzalloc(&client->dev,
1205                             sizeof(struct camera_common_data), GFP_KERNEL);
1206         if (!common_data) {
1207                 dev_err(&client->dev, "unable to allocate memory!\n");
1208                 return -ENOMEM;
1209         }
1210
1211         priv = devm_kzalloc(&client->dev,
1212                             sizeof(struct imx274) + sizeof(struct v4l2_ctrl *) *
1213                             ARRAY_SIZE(ctrl_config_list),
1214                             GFP_KERNEL);
1215         if (!priv) {
1216                 dev_err(&client->dev, "unable to allocate memory!\n");
1217                 return -ENOMEM;
1218         }
1219
1220         priv->regmap = devm_regmap_init_i2c(client, &sensor_regmap_config);
1221         if (IS_ERR(priv->regmap)) {
1222                 dev_err(&client->dev,
1223                         "regmap init failed: %ld\n", PTR_ERR(priv->regmap));
1224                 return -ENODEV;
1225         }
1226
1227         priv->pdata = imx274_parse_dt(client);
1228         if (!priv->pdata) {
1229                 dev_err(&client->dev, " unable to get platform data\n");
1230                 return -EFAULT;
1231         }
1232
1233         common_data->ops                = &imx274_common_ops;
1234         common_data->ctrl_handler       = &priv->ctrl_handler;
1235         common_data->i2c_client         = client;
1236         common_data->frmfmt             = &imx274_frmfmt[0];
1237         common_data->colorfmt           = camera_common_find_datafmt(
1238                                           IMX274_DEFAULT_DATAFMT);
1239         common_data->power              = &priv->power;
1240         common_data->ctrls              = priv->ctrls;
1241         common_data->priv               = (void *)priv;
1242         common_data->numctrls           = ARRAY_SIZE(ctrl_config_list);
1243         common_data->numfmts            = ARRAY_SIZE(imx274_frmfmt);
1244         common_data->def_mode           = IMX274_DEFAULT_MODE;
1245         common_data->def_width          = IMX274_DEFAULT_WIDTH;
1246         common_data->def_height         = IMX274_DEFAULT_HEIGHT;
1247         common_data->fmt_width          = common_data->def_width;
1248         common_data->fmt_height         = common_data->def_height;
1249         common_data->def_clk_freq       = IMX274_DEFAULT_CLK_FREQ;
1250
1251         priv->i2c_client                = client;
1252         priv->s_data                    = common_data;
1253         priv->subdev                    = &common_data->subdev;
1254         priv->subdev->dev               = &client->dev;
1255
1256         err = imx274_power_get(priv);
1257         if (err)
1258                 return err;
1259
1260         err = camera_common_parse_ports(client, common_data);
1261         if (err) {
1262                 dev_err(&client->dev, "Failed to find port info\n");
1263                 return err;
1264         }
1265         sprintf(debugfs_name, "imx274_%c", common_data->csi_port + 'a');
1266         dev_dbg(&client->dev, "%s: name %s\n", __func__, debugfs_name);
1267
1268         camera_common_create_debugfs(common_data, "imx274");
1269
1270         v4l2_i2c_subdev_init(priv->subdev, client, &imx274_subdev_ops);
1271
1272         err = imx274_ctrls_init(priv);
1273         if (err)
1274                 return err;
1275
1276         err = imx274_verify_streaming(priv);
1277         if (err)
1278                 return err;
1279
1280         /* eeprom interface */
1281         err = imx274_eeprom_device_init(priv);
1282         if (err)
1283                 dev_err(&client->dev,
1284                         "Failed to allocate eeprom register map: %d\n", err);
1285
1286         priv->subdev->internal_ops = &imx274_subdev_internal_ops;
1287         priv->subdev->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE |
1288                                V4L2_SUBDEV_FL_HAS_EVENTS;
1289
1290 #if defined(CONFIG_MEDIA_CONTROLLER)
1291         priv->pad.flags = MEDIA_PAD_FL_SOURCE;
1292         priv->subdev->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
1293         priv->subdev->entity.ops = &imx274_media_ops;
1294         err = media_entity_init(&priv->subdev->entity, 1, &priv->pad, 0);
1295         if (err < 0) {
1296                 dev_err(&client->dev, "unable to init media entity\n");
1297                 return err;
1298         }
1299 #endif
1300
1301         err = v4l2_async_register_subdev(priv->subdev);
1302         if (err)
1303                 return err;
1304
1305         dev_dbg(&client->dev, "Detected IMX274 sensor\n");
1306
1307         return 0;
1308 }
1309
1310 static int
1311 imx274_remove(struct i2c_client *client)
1312 {
1313         struct camera_common_data *s_data = to_camera_common_data(client);
1314         struct imx274 *priv = (struct imx274 *)s_data->priv;
1315
1316         v4l2_async_unregister_subdev(priv->subdev);
1317 #if defined(CONFIG_MEDIA_CONTROLLER)
1318         media_entity_cleanup(&priv->subdev->entity);
1319 #endif
1320
1321         v4l2_ctrl_handler_free(&priv->ctrl_handler);
1322         imx274_power_put(priv);
1323         camera_common_remove_debugfs(s_data);
1324
1325         return 0;
1326 }
1327
1328 static const struct i2c_device_id imx274_id[] = {
1329         { "imx274", 0 },
1330         { }
1331 };
1332
1333 MODULE_DEVICE_TABLE(i2c, imx274_id);
1334
1335 static struct i2c_driver imx274_i2c_driver = {
1336         .driver = {
1337                 .name = "imx274",
1338                 .owner = THIS_MODULE,
1339         },
1340         .probe = imx274_probe,
1341         .remove = imx274_remove,
1342         .id_table = imx274_id,
1343 };
1344
1345 module_i2c_driver(imx274_i2c_driver);
1346
1347 MODULE_DESCRIPTION("Media Controller driver for Sony IMX274");
1348 MODULE_AUTHOR("Josh Kuo <joshk@nvidia.com>");
1349 MODULE_LICENSE("GPL v2");