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

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Support for OmniVision OV2680 1080p HD camera sensor.
   4  *
   5  * Copyright (c) 2013 Intel Corporation. All Rights Reserved.
   6  * Copyright (c) 2023 Hans de Goede <hdegoede@redhat.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License version
  10  * 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  */
  18
  19 #include <linux/acpi.h>
  20 #include <linux/device.h>
  21 #include <linux/gpio/consumer.h>
  22 #include <linux/gpio/machine.h>
  23 #include <linux/i2c.h>
  24 #include <linux/module.h>
  25 #include <linux/pm_runtime.h>
  26 #include <linux/types.h>
  27
  28 #include <media/ov_16bit_addr_reg_helpers.h>
  29 #include <media/v4l2-device.h>
  30
  31 #include "ov2680.h"
  32
  33 static int ov2680_write_reg_array(struct i2c_client *client,
  34                                   const struct ov2680_reg *reglist)
  35 {
  36         const struct ov2680_reg *next = reglist;
  37         int ret;
  38
  39         for (; next->reg != 0; next++) {
  40                 ret = ov_write_reg8(client, next->reg, next->val);
  41                 if (ret)
  42                         return ret;
  43         }
  44
  45         return 0;
  46 }
  47
  48 static void ov2680_set_bayer_order(struct ov2680_dev *sensor, struct v4l2_mbus_framefmt *fmt)
  49 {
  50         static const int ov2680_hv_flip_bayer_order[] = {
  51                 MEDIA_BUS_FMT_SBGGR10_1X10,
  52                 MEDIA_BUS_FMT_SGRBG10_1X10,
  53                 MEDIA_BUS_FMT_SGBRG10_1X10,
  54                 MEDIA_BUS_FMT_SRGGB10_1X10,
  55         };
  56         int hv_flip = 0;
  57
  58         if (sensor->ctrls.vflip->val)
  59                 hv_flip += 1;
  60
  61         if (sensor->ctrls.hflip->val)
  62                 hv_flip += 2;
  63
  64         fmt->code = ov2680_hv_flip_bayer_order[hv_flip];
  65 }
  66
  67 static int ov2680_set_vflip(struct ov2680_dev *sensor, s32 val)
  68 {
  69         int ret;
  70
  71         if (sensor->is_streaming)
  72                 return -EBUSY;
  73
  74         ret = ov_update_reg(sensor->client, OV2680_REG_FORMAT1, BIT(2), val ? BIT(2) : 0);
  75         if (ret < 0)
  76                 return ret;
  77
  78         ov2680_set_bayer_order(sensor, &sensor->mode.fmt);
  79         return 0;
  80 }
  81
  82 static int ov2680_set_hflip(struct ov2680_dev *sensor, s32 val)
  83 {
  84         int ret;
  85
  86         if (sensor->is_streaming)
  87                 return -EBUSY;
  88
  89         ret = ov_update_reg(sensor->client, OV2680_REG_FORMAT2, BIT(2), val ? BIT(2) : 0);
  90         if (ret < 0)
  91                 return ret;
  92
  93         ov2680_set_bayer_order(sensor, &sensor->mode.fmt);
  94         return 0;
  95 }
  96
  97 static int ov2680_exposure_set(struct ov2680_dev *sensor, u32 exp)
  98 {
  99         return ov_write_reg24(sensor->client, OV2680_REG_EXPOSURE_PK_HIGH, exp << 4);
 100 }
 101
 102 static int ov2680_gain_set(struct ov2680_dev *sensor, u32 gain)
 103 {
 104         return ov_write_reg16(sensor->client, OV2680_REG_GAIN_PK, gain);
 105 }
 106
 107 static int ov2680_test_pattern_set(struct ov2680_dev *sensor, int value)
 108 {
 109         int ret;
 110
 111         if (!value)
 112                 return ov_update_reg(sensor->client, OV2680_REG_ISP_CTRL00, BIT(7), 0);
 113
 114         ret = ov_update_reg(sensor->client, OV2680_REG_ISP_CTRL00, 0x03, value - 1);
 115         if (ret < 0)
 116                 return ret;
 117
 118         ret = ov_update_reg(sensor->client, OV2680_REG_ISP_CTRL00, BIT(7), BIT(7));
 119         if (ret < 0)
 120                 return ret;
 121
 122         return 0;
 123 }
 124
 125 static int ov2680_s_ctrl(struct v4l2_ctrl *ctrl)
 126 {
 127         struct v4l2_subdev *sd = ctrl_to_sd(ctrl);
 128         struct ov2680_dev *sensor = to_ov2680_sensor(sd);
 129         int ret;
 130
 131         /* Only apply changes to the controls if the device is powered up */
 132         if (!pm_runtime_get_if_in_use(sensor->sd.dev)) {
 133                 ov2680_set_bayer_order(sensor, &sensor->mode.fmt);
 134                 return 0;
 135         }
 136
 137         switch (ctrl->id) {
 138         case V4L2_CID_VFLIP:
 139                 ret = ov2680_set_vflip(sensor, ctrl->val);
 140                 break;
 141         case V4L2_CID_HFLIP:
 142                 ret = ov2680_set_hflip(sensor, ctrl->val);
 143                 break;
 144         case V4L2_CID_EXPOSURE:
 145                 ret = ov2680_exposure_set(sensor, ctrl->val);
 146                 break;
 147         case V4L2_CID_GAIN:
 148                 ret = ov2680_gain_set(sensor, ctrl->val);
 149                 break;
 150         case V4L2_CID_TEST_PATTERN:
 151                 ret = ov2680_test_pattern_set(sensor, ctrl->val);
 152                 break;
 153         default:
 154                 ret = -EINVAL;
 155         }
 156
 157         pm_runtime_put(sensor->sd.dev);
 158         return ret;
 159 }
 160
 161 static const struct v4l2_ctrl_ops ov2680_ctrl_ops = {
 162         .s_ctrl = ov2680_s_ctrl,
 163 };
 164
 165 static int ov2680_init_registers(struct v4l2_subdev *sd)
 166 {
 167         struct i2c_client *client = v4l2_get_subdevdata(sd);
 168         int ret;
 169
 170         ret = ov_write_reg8(client, OV2680_SW_RESET, 0x01);
 171         ret |= ov2680_write_reg_array(client, ov2680_global_setting);
 172
 173         return ret;
 174 }
 175
 176 static struct v4l2_mbus_framefmt *
 177 __ov2680_get_pad_format(struct ov2680_dev *sensor,
 178                         struct v4l2_subdev_state *state,
 179                         unsigned int pad, enum v4l2_subdev_format_whence which)
 180 {
 181         if (which == V4L2_SUBDEV_FORMAT_TRY)
 182                 return v4l2_subdev_get_try_format(&sensor->sd, state, pad);
 183
 184         return &sensor->mode.fmt;
 185 }
 186
 187 static void ov2680_fill_format(struct ov2680_dev *sensor,
 188                                struct v4l2_mbus_framefmt *fmt,
 189                                unsigned int width, unsigned int height)
 190 {
 191         memset(fmt, 0, sizeof(*fmt));
 192         fmt->width = width;
 193         fmt->height = height;
 194         fmt->field = V4L2_FIELD_NONE;
 195         ov2680_set_bayer_order(sensor, fmt);
 196 }
 197
 198 static void ov2680_calc_mode(struct ov2680_dev *sensor, int width, int height)
 199 {
 200         int orig_width = width;
 201         int orig_height = height;
 202
 203         if (width  <= (OV2680_NATIVE_WIDTH / 2) &&
 204             height <= (OV2680_NATIVE_HEIGHT / 2)) {
 205                 sensor->mode.binning = true;
 206                 width *= 2;
 207                 height *= 2;
 208         } else {
 209                 sensor->mode.binning = false;
 210         }
 211
 212         sensor->mode.h_start = ((OV2680_NATIVE_WIDTH - width) / 2) & ~1;
 213         sensor->mode.v_start = ((OV2680_NATIVE_HEIGHT - height) / 2) & ~1;
 214         sensor->mode.h_end = min(sensor->mode.h_start + width + OV2680_END_MARGIN - 1,
 215                                  OV2680_NATIVE_WIDTH - 1);
 216         sensor->mode.v_end = min(sensor->mode.v_start + height + OV2680_END_MARGIN - 1,
 217                                  OV2680_NATIVE_HEIGHT - 1);
 218         sensor->mode.h_output_size = orig_width;
 219         sensor->mode.v_output_size = orig_height;
 220         sensor->mode.hts = OV2680_PIXELS_PER_LINE;
 221         sensor->mode.vts = OV2680_LINES_PER_FRAME;
 222 }
 223
 224 static int ov2680_set_mode(struct ov2680_dev *sensor)
 225 {
 226         struct i2c_client *client = sensor->client;
 227         u8 pll_div, unknown, inc, fmt1, fmt2;
 228         int ret;
 229
 230         if (sensor->mode.binning) {
 231                 pll_div = 1;
 232                 unknown = 0x23;
 233                 inc = 0x31;
 234                 fmt1 = 0xc2;
 235                 fmt2 = 0x01;
 236         } else {
 237                 pll_div = 0;
 238                 unknown = 0x21;
 239                 inc = 0x11;
 240                 fmt1 = 0xc0;
 241                 fmt2 = 0x00;
 242         }
 243
 244         ret = ov_write_reg8(client, 0x3086, pll_div);
 245         if (ret)
 246                 return ret;
 247
 248         ret = ov_write_reg8(client, 0x370a, unknown);
 249         if (ret)
 250                 return ret;
 251
 252         ret = ov_write_reg16(client, OV2680_HORIZONTAL_START_H, sensor->mode.h_start);
 253         if (ret)
 254                 return ret;
 255
 256         ret = ov_write_reg16(client, OV2680_VERTICAL_START_H, sensor->mode.v_start);
 257         if (ret)
 258                 return ret;
 259
 260         ret = ov_write_reg16(client, OV2680_HORIZONTAL_END_H, sensor->mode.h_end);
 261         if (ret)
 262                 return ret;
 263
 264         ret = ov_write_reg16(client, OV2680_VERTICAL_END_H, sensor->mode.v_end);
 265         if (ret)
 266                 return ret;
 267
 268         ret = ov_write_reg16(client, OV2680_HORIZONTAL_OUTPUT_SIZE_H,
 269                                  sensor->mode.h_output_size);
 270         if (ret)
 271                 return ret;
 272
 273         ret = ov_write_reg16(client, OV2680_VERTICAL_OUTPUT_SIZE_H,
 274                                  sensor->mode.v_output_size);
 275         if (ret)
 276                 return ret;
 277
 278         ret = ov_write_reg16(client, OV2680_HTS, sensor->mode.hts);
 279         if (ret)
 280                 return ret;
 281
 282         ret = ov_write_reg16(client, OV2680_VTS, sensor->mode.vts);
 283         if (ret)
 284                 return ret;
 285
 286         ret = ov_write_reg16(client, OV2680_ISP_X_WIN, 0);
 287         if (ret)
 288                 return ret;
 289
 290         ret = ov_write_reg16(client, OV2680_ISP_Y_WIN, 0);
 291         if (ret)
 292                 return ret;
 293
 294         ret = ov_write_reg8(client, OV2680_X_INC, inc);
 295         if (ret)
 296                 return ret;
 297
 298         ret = ov_write_reg8(client, OV2680_Y_INC, inc);
 299         if (ret)
 300                 return ret;
 301
 302         ret = ov_write_reg16(client, OV2680_X_WIN, sensor->mode.h_output_size);
 303         if (ret)
 304                 return ret;
 305
 306         ret = ov_write_reg16(client, OV2680_Y_WIN, sensor->mode.v_output_size);
 307         if (ret)
 308                 return ret;
 309
 310         ret = ov_write_reg8(client, OV2680_REG_FORMAT1, fmt1);
 311         if (ret)
 312                 return ret;
 313
 314         ret = ov_write_reg8(client, OV2680_REG_FORMAT2, fmt2);
 315         if (ret)
 316                 return ret;
 317
 318         return 0;
 319 }
 320
 321 static int ov2680_set_fmt(struct v4l2_subdev *sd,
 322                           struct v4l2_subdev_state *sd_state,
 323                           struct v4l2_subdev_format *format)
 324 {
 325         struct ov2680_dev *sensor = to_ov2680_sensor(sd);
 326         struct v4l2_mbus_framefmt *fmt;
 327         unsigned int width, height;
 328
 329         width = min_t(unsigned int, ALIGN(format->format.width, 2), OV2680_NATIVE_WIDTH);
 330         height = min_t(unsigned int, ALIGN(format->format.height, 2), OV2680_NATIVE_HEIGHT);
 331
 332         fmt = __ov2680_get_pad_format(sensor, sd_state, format->pad, format->which);
 333         ov2680_fill_format(sensor, fmt, width, height);
 334
 335         format->format = *fmt;
 336
 337         if (format->which == V4L2_SUBDEV_FORMAT_TRY)
 338                 return 0;
 339
 340         mutex_lock(&sensor->input_lock);
 341         ov2680_calc_mode(sensor, fmt->width, fmt->height);
 342         mutex_unlock(&sensor->input_lock);
 343         return 0;
 344 }
 345
 346 static int ov2680_get_fmt(struct v4l2_subdev *sd,
 347                           struct v4l2_subdev_state *sd_state,
 348                           struct v4l2_subdev_format *format)
 349 {
 350         struct ov2680_dev *sensor = to_ov2680_sensor(sd);
 351         struct v4l2_mbus_framefmt *fmt;
 352
 353         fmt = __ov2680_get_pad_format(sensor, sd_state, format->pad, format->which);
 354         format->format = *fmt;
 355         return 0;
 356 }
 357
 358 static int ov2680_detect(struct i2c_client *client)
 359 {
 360         struct i2c_adapter *adapter = client->adapter;
 361         u32 high = 0, low = 0;
 362         int ret;
 363         u16 id;
 364         u8 revision;
 365
 366         if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
 367                 return -ENODEV;
 368
 369         ret = ov_read_reg8(client, OV2680_SC_CMMN_CHIP_ID_H, &high);
 370         if (ret) {
 371                 dev_err(&client->dev, "sensor_id_high read failed (%d)\n", ret);
 372                 return -ENODEV;
 373         }
 374         ret = ov_read_reg8(client, OV2680_SC_CMMN_CHIP_ID_L, &low);
 375         id = ((((u16)high) << 8) | (u16)low);
 376
 377         if (id != OV2680_ID) {
 378                 dev_err(&client->dev, "sensor ID error 0x%x\n", id);
 379                 return -ENODEV;
 380         }
 381
 382         ret = ov_read_reg8(client, OV2680_SC_CMMN_SUB_ID, &high);
 383         revision = (u8)high & 0x0f;
 384
 385         dev_info(&client->dev, "sensor_revision id = 0x%x, rev= %d\n",
 386                  id, revision);
 387
 388         return 0;
 389 }
 390
 391 static int ov2680_s_stream(struct v4l2_subdev *sd, int enable)
 392 {
 393         struct ov2680_dev *sensor = to_ov2680_sensor(sd);
 394         struct i2c_client *client = v4l2_get_subdevdata(sd);
 395         int ret = 0;
 396
 397         mutex_lock(&sensor->input_lock);
 398
 399         if (sensor->is_streaming == enable) {
 400                 dev_warn(&client->dev, "stream already %s\n", enable ? "started" : "stopped");
 401                 goto error_unlock;
 402         }
 403
 404         if (enable) {
 405                 ret = pm_runtime_get_sync(sensor->sd.dev);
 406                 if (ret < 0)
 407                         goto error_power_down;
 408
 409                 ret = ov2680_set_mode(sensor);
 410                 if (ret)
 411                         goto error_power_down;
 412
 413                 /* Restore value of all ctrls */
 414                 ret = __v4l2_ctrl_handler_setup(&sensor->ctrls.handler);
 415                 if (ret)
 416                         goto error_power_down;
 417
 418                 ret = ov_write_reg8(client, OV2680_SW_STREAM, OV2680_START_STREAMING);
 419                 if (ret)
 420                         goto error_power_down;
 421         } else {
 422                 ov_write_reg8(client, OV2680_SW_STREAM, OV2680_STOP_STREAMING);
 423                 pm_runtime_put(sensor->sd.dev);
 424         }
 425
 426         sensor->is_streaming = enable;
 427         v4l2_ctrl_activate(sensor->ctrls.vflip, !enable);
 428         v4l2_ctrl_activate(sensor->ctrls.hflip, !enable);
 429
 430         mutex_unlock(&sensor->input_lock);
 431         return 0;
 432
 433 error_power_down:
 434         pm_runtime_put(sensor->sd.dev);
 435         sensor->is_streaming = false;
 436 error_unlock:
 437         mutex_unlock(&sensor->input_lock);
 438         return ret;
 439 }
 440
 441 static int ov2680_s_config(struct v4l2_subdev *sd)
 442 {
 443         struct i2c_client *client = v4l2_get_subdevdata(sd);
 444         int ret;
 445
 446         ret = pm_runtime_get_sync(&client->dev);
 447         if (ret < 0) {
 448                 dev_err(&client->dev, "ov2680 power-up err.\n");
 449                 goto fail_power_on;
 450         }
 451
 452         /* config & detect sensor */
 453         ret = ov2680_detect(client);
 454         if (ret)
 455                 dev_err(&client->dev, "ov2680_detect err s_config.\n");
 456
 457 fail_power_on:
 458         pm_runtime_put(&client->dev);
 459         return ret;
 460 }
 461
 462 static int ov2680_g_frame_interval(struct v4l2_subdev *sd,
 463                                    struct v4l2_subdev_frame_interval *interval)
 464 {
 465         interval->interval.numerator = 1;
 466         interval->interval.denominator = OV2680_FPS;
 467         return 0;
 468 }
 469
 470 static int ov2680_enum_mbus_code(struct v4l2_subdev *sd,
 471                                  struct v4l2_subdev_state *sd_state,
 472                                  struct v4l2_subdev_mbus_code_enum *code)
 473 {
 474         /* We support only a single format */
 475         if (code->index)
 476                 return -EINVAL;
 477
 478         code->code = MEDIA_BUS_FMT_SBGGR10_1X10;
 479         return 0;
 480 }
 481
 482 static int ov2680_enum_frame_size(struct v4l2_subdev *sd,
 483                                   struct v4l2_subdev_state *sd_state,
 484                                   struct v4l2_subdev_frame_size_enum *fse)
 485 {
 486         static const struct v4l2_frmsize_discrete ov2680_frame_sizes[] = {
 487                 { 1616, 1216 },
 488                 { 1616, 1096 },
 489                 { 1616,  916 },
 490                 { 1456, 1096 },
 491                 { 1296,  976 },
 492                 { 1296,  736 },
 493                 {  784,  592 },
 494                 {  656,  496 },
 495         };
 496         int index = fse->index;
 497
 498         if (index >= ARRAY_SIZE(ov2680_frame_sizes))
 499                 return -EINVAL;
 500
 501         fse->min_width = ov2680_frame_sizes[index].width;
 502         fse->min_height = ov2680_frame_sizes[index].height;
 503         fse->max_width = ov2680_frame_sizes[index].width;
 504         fse->max_height = ov2680_frame_sizes[index].height;
 505
 506         return 0;
 507 }
 508
 509 static int ov2680_enum_frame_interval(struct v4l2_subdev *sd,
 510                                       struct v4l2_subdev_state *sd_state,
 511                                       struct v4l2_subdev_frame_interval_enum *fie)
 512 {
 513         /* Only 1 framerate */
 514         if (fie->index)
 515                 return -EINVAL;
 516
 517         fie->interval.numerator = 1;
 518         fie->interval.denominator = OV2680_FPS;
 519         return 0;
 520 }
 521
 522 static int ov2680_g_skip_frames(struct v4l2_subdev *sd, u32 *frames)
 523 {
 524         *frames = OV2680_SKIP_FRAMES;
 525         return 0;
 526 }
 527
 528 static const struct v4l2_subdev_video_ops ov2680_video_ops = {
 529         .s_stream = ov2680_s_stream,
 530         .g_frame_interval = ov2680_g_frame_interval,
 531 };
 532
 533 static const struct v4l2_subdev_sensor_ops ov2680_sensor_ops = {
 534         .g_skip_frames  = ov2680_g_skip_frames,
 535 };
 536
 537 static const struct v4l2_subdev_pad_ops ov2680_pad_ops = {
 538         .enum_mbus_code = ov2680_enum_mbus_code,
 539         .enum_frame_size = ov2680_enum_frame_size,
 540         .enum_frame_interval = ov2680_enum_frame_interval,
 541         .get_fmt = ov2680_get_fmt,
 542         .set_fmt = ov2680_set_fmt,
 543 };
 544
 545 static const struct v4l2_subdev_ops ov2680_ops = {
 546         .video = &ov2680_video_ops,
 547         .pad = &ov2680_pad_ops,
 548         .sensor = &ov2680_sensor_ops,
 549 };
 550
 551 static int ov2680_init_controls(struct ov2680_dev *sensor)
 552 {
 553         static const char * const test_pattern_menu[] = {
 554                 "Disabled",
 555                 "Color Bars",
 556                 "Random Data",
 557                 "Square",
 558                 "Black Image",
 559         };
 560         const struct v4l2_ctrl_ops *ops = &ov2680_ctrl_ops;
 561         struct ov2680_ctrls *ctrls = &sensor->ctrls;
 562         struct v4l2_ctrl_handler *hdl = &ctrls->handler;
 563         int exp_max = OV2680_LINES_PER_FRAME - OV2680_INTEGRATION_TIME_MARGIN;
 564
 565         v4l2_ctrl_handler_init(hdl, 4);
 566
 567         hdl->lock = &sensor->input_lock;
 568
 569         ctrls->hflip = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_HFLIP, 0, 1, 1, 0);
 570         ctrls->vflip = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_VFLIP, 0, 1, 1, 0);
 571         ctrls->exposure = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_EXPOSURE,
 572                                             0, exp_max, 1, exp_max);
 573         ctrls->gain = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_GAIN, 0, 1023, 1, 250);
 574         ctrls->test_pattern =
 575                 v4l2_ctrl_new_std_menu_items(hdl,
 576                                              &ov2680_ctrl_ops, V4L2_CID_TEST_PATTERN,
 577                                              ARRAY_SIZE(test_pattern_menu) - 1,
 578                                              0, 0, test_pattern_menu);
 579
 580         ctrls->hflip->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT;
 581         ctrls->vflip->flags |= V4L2_CTRL_FLAG_MODIFY_LAYOUT;
 582
 583         if (hdl->error)
 584                 return hdl->error;
 585
 586         sensor->sd.ctrl_handler = hdl;
 587         return 0;
 588 }
 589
 590 static void ov2680_remove(struct i2c_client *client)
 591 {
 592         struct v4l2_subdev *sd = i2c_get_clientdata(client);
 593         struct ov2680_dev *sensor = to_ov2680_sensor(sd);
 594
 595         dev_dbg(&client->dev, "ov2680_remove...\n");
 596
 597         v4l2_async_unregister_subdev(&sensor->sd);
 598         media_entity_cleanup(&sensor->sd.entity);
 599         v4l2_ctrl_handler_free(&sensor->ctrls.handler);
 600         mutex_destroy(&sensor->input_lock);
 601         fwnode_handle_put(sensor->ep_fwnode);
 602         pm_runtime_disable(&client->dev);
 603 }
 604
 605 static int ov2680_probe(struct i2c_client *client)
 606 {
 607         struct device *dev = &client->dev;
 608         struct ov2680_dev *sensor;
 609         int ret;
 610
 611         sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL);
 612         if (!sensor)
 613                 return -ENOMEM;
 614
 615         mutex_init(&sensor->input_lock);
 616
 617         sensor->client = client;
 618         v4l2_i2c_subdev_init(&sensor->sd, client, &ov2680_ops);
 619
 620         /*
 621          * Sometimes the fwnode graph is initialized by the bridge driver.
 622          * Bridge drivers doing this may also add GPIO mappings, wait for this.
 623          */
 624         sensor->ep_fwnode = fwnode_graph_get_next_endpoint(dev_fwnode(dev), NULL);
 625         if (!sensor->ep_fwnode)
 626                 return dev_err_probe(dev, -EPROBE_DEFER, "waiting for fwnode graph endpoint\n");
 627
 628         sensor->powerdown = devm_gpiod_get_optional(dev, "powerdown", GPIOD_OUT_HIGH);
 629         if (IS_ERR(sensor->powerdown)) {
 630                 fwnode_handle_put(sensor->ep_fwnode);
 631                 return dev_err_probe(dev, PTR_ERR(sensor->powerdown), "getting powerdown GPIO\n");
 632         }
 633
 634         pm_runtime_set_suspended(dev);
 635         pm_runtime_enable(dev);
 636         pm_runtime_set_autosuspend_delay(dev, 1000);
 637         pm_runtime_use_autosuspend(dev);
 638
 639         ret = ov2680_s_config(&sensor->sd);
 640         if (ret) {
 641                 ov2680_remove(client);
 642                 return ret;
 643         }
 644
 645         sensor->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
 646         sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
 647         sensor->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
 648         sensor->sd.fwnode = sensor->ep_fwnode;
 649
 650         ret = ov2680_init_controls(sensor);
 651         if (ret) {
 652                 ov2680_remove(client);
 653                 return ret;
 654         }
 655
 656         ret = media_entity_pads_init(&sensor->sd.entity, 1, &sensor->pad);
 657         if (ret) {
 658                 ov2680_remove(client);
 659                 return ret;
 660         }
 661
 662         ov2680_fill_format(sensor, &sensor->mode.fmt, OV2680_NATIVE_WIDTH, OV2680_NATIVE_HEIGHT);
 663
 664         ret = v4l2_async_register_subdev_sensor(&sensor->sd);
 665         if (ret) {
 666                 ov2680_remove(client);
 667                 return ret;
 668         }
 669
 670         return 0;
 671 }
 672
 673 static int ov2680_suspend(struct device *dev)
 674 {
 675         struct v4l2_subdev *sd = dev_get_drvdata(dev);
 676         struct ov2680_dev *sensor = to_ov2680_sensor(sd);
 677
 678         gpiod_set_value_cansleep(sensor->powerdown, 1);
 679         return 0;
 680 }
 681
 682 static int ov2680_resume(struct device *dev)
 683 {
 684         struct v4l2_subdev *sd = dev_get_drvdata(dev);
 685         struct ov2680_dev *sensor = to_ov2680_sensor(sd);
 686
 687         /* according to DS, at least 5ms is needed after DOVDD (enabled by ACPI) */
 688         usleep_range(5000, 6000);
 689
 690         gpiod_set_value_cansleep(sensor->powerdown, 0);
 691
 692         /* according to DS, 20ms is needed between PWDN and i2c access */
 693         msleep(20);
 694
 695         ov2680_init_registers(sd);
 696         return 0;
 697 }
 698
 699 static DEFINE_RUNTIME_DEV_PM_OPS(ov2680_pm_ops, ov2680_suspend, ov2680_resume, NULL);
 700
 701 static const struct acpi_device_id ov2680_acpi_match[] = {
 702         {"XXOV2680"},
 703         {"OVTI2680"},
 704         {},
 705 };
 706 MODULE_DEVICE_TABLE(acpi, ov2680_acpi_match);
 707
 708 static struct i2c_driver ov2680_driver = {
 709         .driver = {
 710                 .name = "ov2680",
 711                 .pm = pm_sleep_ptr(&ov2680_pm_ops),
 712                 .acpi_match_table = ov2680_acpi_match,
 713         },
 714         .probe = ov2680_probe,
 715         .remove = ov2680_remove,
 716 };
 717 module_i2c_driver(ov2680_driver);
 718
 719 MODULE_AUTHOR("Jacky Wang <Jacky_wang@ovt.com>");
 720 MODULE_DESCRIPTION("A low-level driver for OmniVision 2680 sensors");
 721 MODULE_LICENSE("GPL");