linux/drivers/media/i2c/ov2680.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Omnivision OV2680 CMOS Image Sensor driver
   4 *
   5 * Copyright (C) 2018 Linaro Ltd
   6 *
   7 * Based on OV5640 Sensor Driver
   8 * Copyright (C) 2011-2013 Freescale Semiconductor, Inc. All Rights Reserved.
   9 * Copyright (C) 2014-2017 Mentor Graphics Inc.
  10 *
  11 */
  12
  13#include <asm/unaligned.h>
  14#include <linux/clk.h>
  15#include <linux/delay.h>
  16#include <linux/err.h>
  17#include <linux/i2c.h>
  18#include <linux/init.h>
  19#include <linux/module.h>
  20#include <linux/of_device.h>
  21#include <linux/gpio/consumer.h>
  22#include <linux/regulator/consumer.h>
  23
  24#include <media/v4l2-common.h>
  25#include <media/v4l2-ctrls.h>
  26#include <media/v4l2-subdev.h>
  27
  28#define OV2680_XVCLK_VALUE      24000000
  29
  30#define OV2680_CHIP_ID          0x2680
  31
  32#define OV2680_REG_STREAM_CTRL          0x0100
  33#define OV2680_REG_SOFT_RESET           0x0103
  34
  35#define OV2680_REG_CHIP_ID_HIGH         0x300a
  36#define OV2680_REG_CHIP_ID_LOW          0x300b
  37
  38#define OV2680_REG_R_MANUAL             0x3503
  39#define OV2680_REG_GAIN_PK              0x350a
  40#define OV2680_REG_EXPOSURE_PK_HIGH     0x3500
  41#define OV2680_REG_TIMING_HTS           0x380c
  42#define OV2680_REG_TIMING_VTS           0x380e
  43#define OV2680_REG_FORMAT1              0x3820
  44#define OV2680_REG_FORMAT2              0x3821
  45
  46#define OV2680_REG_ISP_CTRL00           0x5080
  47
  48#define OV2680_FRAME_RATE               30
  49
  50#define OV2680_REG_VALUE_8BIT           1
  51#define OV2680_REG_VALUE_16BIT          2
  52#define OV2680_REG_VALUE_24BIT          3
  53
  54#define OV2680_WIDTH_MAX                1600
  55#define OV2680_HEIGHT_MAX               1200
  56
  57enum ov2680_mode_id {
  58        OV2680_MODE_QUXGA_800_600,
  59        OV2680_MODE_720P_1280_720,
  60        OV2680_MODE_UXGA_1600_1200,
  61        OV2680_MODE_MAX,
  62};
  63
  64struct reg_value {
  65        u16 reg_addr;
  66        u8 val;
  67};
  68
  69static const char * const ov2680_supply_name[] = {
  70        "DOVDD",
  71        "DVDD",
  72        "AVDD",
  73};
  74
  75#define OV2680_NUM_SUPPLIES ARRAY_SIZE(ov2680_supply_name)
  76
  77struct ov2680_mode_info {
  78        const char *name;
  79        enum ov2680_mode_id id;
  80        u32 width;
  81        u32 height;
  82        const struct reg_value *reg_data;
  83        u32 reg_data_size;
  84};
  85
  86struct ov2680_ctrls {
  87        struct v4l2_ctrl_handler handler;
  88        struct {
  89                struct v4l2_ctrl *auto_exp;
  90                struct v4l2_ctrl *exposure;
  91        };
  92        struct {
  93                struct v4l2_ctrl *auto_gain;
  94                struct v4l2_ctrl *gain;
  95        };
  96
  97        struct v4l2_ctrl *hflip;
  98        struct v4l2_ctrl *vflip;
  99        struct v4l2_ctrl *test_pattern;
 100};
 101
 102struct ov2680_dev {
 103        struct i2c_client               *i2c_client;
 104        struct v4l2_subdev              sd;
 105
 106        struct media_pad                pad;
 107        struct clk                      *xvclk;
 108        u32                             xvclk_freq;
 109        struct regulator_bulk_data      supplies[OV2680_NUM_SUPPLIES];
 110
 111        struct gpio_desc                *reset_gpio;
 112        struct mutex                    lock; /* protect members */
 113
 114        bool                            mode_pending_changes;
 115        bool                            is_enabled;
 116        bool                            is_streaming;
 117
 118        struct ov2680_ctrls             ctrls;
 119        struct v4l2_mbus_framefmt       fmt;
 120        struct v4l2_fract               frame_interval;
 121
 122        const struct ov2680_mode_info   *current_mode;
 123};
 124
 125static const char * const test_pattern_menu[] = {
 126        "Disabled",
 127        "Color Bars",
 128        "Random Data",
 129        "Square",
 130        "Black Image",
 131};
 132
 133static const int ov2680_hv_flip_bayer_order[] = {
 134        MEDIA_BUS_FMT_SBGGR10_1X10,
 135        MEDIA_BUS_FMT_SGRBG10_1X10,
 136        MEDIA_BUS_FMT_SGBRG10_1X10,
 137        MEDIA_BUS_FMT_SRGGB10_1X10,
 138};
 139
 140static const struct reg_value ov2680_setting_30fps_QUXGA_800_600[] = {
 141        {0x3086, 0x01}, {0x370a, 0x23}, {0x3808, 0x03}, {0x3809, 0x20},
 142        {0x380a, 0x02}, {0x380b, 0x58}, {0x380c, 0x06}, {0x380d, 0xac},
 143        {0x380e, 0x02}, {0x380f, 0x84}, {0x3811, 0x04}, {0x3813, 0x04},
 144        {0x3814, 0x31}, {0x3815, 0x31}, {0x3820, 0xc0}, {0x4008, 0x00},
 145        {0x4009, 0x03}, {0x4837, 0x1e}, {0x3501, 0x4e}, {0x3502, 0xe0},
 146};
 147
 148static const struct reg_value ov2680_setting_30fps_720P_1280_720[] = {
 149        {0x3086, 0x00}, {0x3808, 0x05}, {0x3809, 0x00}, {0x380a, 0x02},
 150        {0x380b, 0xd0}, {0x380c, 0x06}, {0x380d, 0xa8}, {0x380e, 0x05},
 151        {0x380f, 0x0e}, {0x3811, 0x08}, {0x3813, 0x06}, {0x3814, 0x11},
 152        {0x3815, 0x11}, {0x3820, 0xc0}, {0x4008, 0x00},
 153};
 154
 155static const struct reg_value ov2680_setting_30fps_UXGA_1600_1200[] = {
 156        {0x3086, 0x00}, {0x3501, 0x4e}, {0x3502, 0xe0}, {0x3808, 0x06},
 157        {0x3809, 0x40}, {0x380a, 0x04}, {0x380b, 0xb0}, {0x380c, 0x06},
 158        {0x380d, 0xa8}, {0x380e, 0x05}, {0x380f, 0x0e}, {0x3811, 0x00},
 159        {0x3813, 0x00}, {0x3814, 0x11}, {0x3815, 0x11}, {0x3820, 0xc0},
 160        {0x4008, 0x00}, {0x4837, 0x18}
 161};
 162
 163static const struct ov2680_mode_info ov2680_mode_init_data = {
 164        "mode_quxga_800_600", OV2680_MODE_QUXGA_800_600, 800, 600,
 165        ov2680_setting_30fps_QUXGA_800_600,
 166        ARRAY_SIZE(ov2680_setting_30fps_QUXGA_800_600),
 167};
 168
 169static const struct ov2680_mode_info ov2680_mode_data[OV2680_MODE_MAX] = {
 170        {"mode_quxga_800_600", OV2680_MODE_QUXGA_800_600,
 171         800, 600, ov2680_setting_30fps_QUXGA_800_600,
 172         ARRAY_SIZE(ov2680_setting_30fps_QUXGA_800_600)},
 173        {"mode_720p_1280_720", OV2680_MODE_720P_1280_720,
 174         1280, 720, ov2680_setting_30fps_720P_1280_720,
 175         ARRAY_SIZE(ov2680_setting_30fps_720P_1280_720)},
 176        {"mode_uxga_1600_1200", OV2680_MODE_UXGA_1600_1200,
 177         1600, 1200, ov2680_setting_30fps_UXGA_1600_1200,
 178         ARRAY_SIZE(ov2680_setting_30fps_UXGA_1600_1200)},
 179};
 180
 181static struct ov2680_dev *to_ov2680_dev(struct v4l2_subdev *sd)
 182{
 183        return container_of(sd, struct ov2680_dev, sd);
 184}
 185
 186static struct device *ov2680_to_dev(struct ov2680_dev *sensor)
 187{
 188        return &sensor->i2c_client->dev;
 189}
 190
 191static inline struct v4l2_subdev *ctrl_to_sd(struct v4l2_ctrl *ctrl)
 192{
 193        return &container_of(ctrl->handler, struct ov2680_dev,
 194                             ctrls.handler)->sd;
 195}
 196
 197static int __ov2680_write_reg(struct ov2680_dev *sensor, u16 reg,
 198                              unsigned int len, u32 val)
 199{
 200        struct i2c_client *client = sensor->i2c_client;
 201        u8 buf[6];
 202        int ret;
 203
 204        if (len > 4)
 205                return -EINVAL;
 206
 207        put_unaligned_be16(reg, buf);
 208        put_unaligned_be32(val << (8 * (4 - len)), buf + 2);
 209        ret = i2c_master_send(client, buf, len + 2);
 210        if (ret != len + 2) {
 211                dev_err(&client->dev, "write error: reg=0x%4x: %d\n", reg, ret);
 212                return -EIO;
 213        }
 214
 215        return 0;
 216}
 217
 218#define ov2680_write_reg(s, r, v) \
 219        __ov2680_write_reg(s, r, OV2680_REG_VALUE_8BIT, v)
 220
 221#define ov2680_write_reg16(s, r, v) \
 222        __ov2680_write_reg(s, r, OV2680_REG_VALUE_16BIT, v)
 223
 224#define ov2680_write_reg24(s, r, v) \
 225        __ov2680_write_reg(s, r, OV2680_REG_VALUE_24BIT, v)
 226
 227static int __ov2680_read_reg(struct ov2680_dev *sensor, u16 reg,
 228                             unsigned int len, u32 *val)
 229{
 230        struct i2c_client *client = sensor->i2c_client;
 231        struct i2c_msg msgs[2];
 232        u8 addr_buf[2] = { reg >> 8, reg & 0xff };
 233        u8 data_buf[4] = { 0, };
 234        int ret;
 235
 236        if (len > 4)
 237                return -EINVAL;
 238
 239        msgs[0].addr = client->addr;
 240        msgs[0].flags = 0;
 241        msgs[0].len = ARRAY_SIZE(addr_buf);
 242        msgs[0].buf = addr_buf;
 243
 244        msgs[1].addr = client->addr;
 245        msgs[1].flags = I2C_M_RD;
 246        msgs[1].len = len;
 247        msgs[1].buf = &data_buf[4 - len];
 248
 249        ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 250        if (ret != ARRAY_SIZE(msgs)) {
 251                dev_err(&client->dev, "read error: reg=0x%4x: %d\n", reg, ret);
 252                return -EIO;
 253        }
 254
 255        *val = get_unaligned_be32(data_buf);
 256
 257        return 0;
 258}
 259
 260#define ov2680_read_reg(s, r, v) \
 261        __ov2680_read_reg(s, r, OV2680_REG_VALUE_8BIT, v)
 262
 263#define ov2680_read_reg16(s, r, v) \
 264        __ov2680_read_reg(s, r, OV2680_REG_VALUE_16BIT, v)
 265
 266#define ov2680_read_reg24(s, r, v) \
 267        __ov2680_read_reg(s, r, OV2680_REG_VALUE_24BIT, v)
 268
 269static int ov2680_mod_reg(struct ov2680_dev *sensor, u16 reg, u8 mask, u8 val)
 270{
 271        u32 readval;
 272        int ret;
 273
 274        ret = ov2680_read_reg(sensor, reg, &readval);
 275        if (ret < 0)
 276                return ret;
 277
 278        readval &= ~mask;
 279        val &= mask;
 280        val |= readval;
 281
 282        return ov2680_write_reg(sensor, reg, val);
 283}
 284
 285static int ov2680_load_regs(struct ov2680_dev *sensor,
 286                            const struct ov2680_mode_info *mode)
 287{
 288        const struct reg_value *regs = mode->reg_data;
 289        unsigned int i;
 290        int ret = 0;
 291        u16 reg_addr;
 292        u8 val;
 293
 294        for (i = 0; i < mode->reg_data_size; ++i, ++regs) {
 295                reg_addr = regs->reg_addr;
 296                val = regs->val;
 297
 298                ret = ov2680_write_reg(sensor, reg_addr, val);
 299                if (ret)
 300                        break;
 301        }
 302
 303        return ret;
 304}
 305
 306static void ov2680_power_up(struct ov2680_dev *sensor)
 307{
 308        if (!sensor->reset_gpio)
 309                return;
 310
 311        gpiod_set_value(sensor->reset_gpio, 0);
 312        usleep_range(5000, 10000);
 313}
 314
 315static void ov2680_power_down(struct ov2680_dev *sensor)
 316{
 317        if (!sensor->reset_gpio)
 318                return;
 319
 320        gpiod_set_value(sensor->reset_gpio, 1);
 321        usleep_range(5000, 10000);
 322}
 323
 324static int ov2680_bayer_order(struct ov2680_dev *sensor)
 325{
 326        u32 format1;
 327        u32 format2;
 328        u32 hv_flip;
 329        int ret;
 330
 331        ret = ov2680_read_reg(sensor, OV2680_REG_FORMAT1, &format1);
 332        if (ret < 0)
 333                return ret;
 334
 335        ret = ov2680_read_reg(sensor, OV2680_REG_FORMAT2, &format2);
 336        if (ret < 0)
 337                return ret;
 338
 339        hv_flip = (format2 & BIT(2)  << 1) | (format1 & BIT(2));
 340
 341        sensor->fmt.code = ov2680_hv_flip_bayer_order[hv_flip];
 342
 343        return 0;
 344}
 345
 346static int ov2680_vflip_enable(struct ov2680_dev *sensor)
 347{
 348        int ret;
 349
 350        ret = ov2680_mod_reg(sensor, OV2680_REG_FORMAT1, BIT(2), BIT(2));
 351        if (ret < 0)
 352                return ret;
 353
 354        return ov2680_bayer_order(sensor);
 355}
 356
 357static int ov2680_vflip_disable(struct ov2680_dev *sensor)
 358{
 359        int ret;
 360
 361        ret = ov2680_mod_reg(sensor, OV2680_REG_FORMAT1, BIT(2), BIT(0));
 362        if (ret < 0)
 363                return ret;
 364
 365        return ov2680_bayer_order(sensor);
 366}
 367
 368static int ov2680_hflip_enable(struct ov2680_dev *sensor)
 369{
 370        int ret;
 371
 372        ret = ov2680_mod_reg(sensor, OV2680_REG_FORMAT2, BIT(2), BIT(2));
 373        if (ret < 0)
 374                return ret;
 375
 376        return ov2680_bayer_order(sensor);
 377}
 378
 379static int ov2680_hflip_disable(struct ov2680_dev *sensor)
 380{
 381        int ret;
 382
 383        ret = ov2680_mod_reg(sensor, OV2680_REG_FORMAT2, BIT(2), BIT(0));
 384        if (ret < 0)
 385                return ret;
 386
 387        return ov2680_bayer_order(sensor);
 388}
 389
 390static int ov2680_test_pattern_set(struct ov2680_dev *sensor, int value)
 391{
 392        int ret;
 393
 394        if (!value)
 395                return ov2680_mod_reg(sensor, OV2680_REG_ISP_CTRL00, BIT(7), 0);
 396
 397        ret = ov2680_mod_reg(sensor, OV2680_REG_ISP_CTRL00, 0x03, value - 1);
 398        if (ret < 0)
 399                return ret;
 400
 401        ret = ov2680_mod_reg(sensor, OV2680_REG_ISP_CTRL00, BIT(7), BIT(7));
 402        if (ret < 0)
 403                return ret;
 404
 405        return 0;
 406}
 407
 408static int ov2680_gain_set(struct ov2680_dev *sensor, bool auto_gain)
 409{
 410        struct ov2680_ctrls *ctrls = &sensor->ctrls;
 411        u32 gain;
 412        int ret;
 413
 414        ret = ov2680_mod_reg(sensor, OV2680_REG_R_MANUAL, BIT(1),
 415                             auto_gain ? 0 : BIT(1));
 416        if (ret < 0)
 417                return ret;
 418
 419        if (auto_gain || !ctrls->gain->is_new)
 420                return 0;
 421
 422        gain = ctrls->gain->val;
 423
 424        ret = ov2680_write_reg16(sensor, OV2680_REG_GAIN_PK, gain);
 425
 426        return 0;
 427}
 428
 429static int ov2680_gain_get(struct ov2680_dev *sensor)
 430{
 431        u32 gain;
 432        int ret;
 433
 434        ret = ov2680_read_reg16(sensor, OV2680_REG_GAIN_PK, &gain);
 435        if (ret)
 436                return ret;
 437
 438        return gain;
 439}
 440
 441static int ov2680_exposure_set(struct ov2680_dev *sensor, bool auto_exp)
 442{
 443        struct ov2680_ctrls *ctrls = &sensor->ctrls;
 444        u32 exp;
 445        int ret;
 446
 447        ret = ov2680_mod_reg(sensor, OV2680_REG_R_MANUAL, BIT(0),
 448                             auto_exp ? 0 : BIT(0));
 449        if (ret < 0)
 450                return ret;
 451
 452        if (auto_exp || !ctrls->exposure->is_new)
 453                return 0;
 454
 455        exp = (u32)ctrls->exposure->val;
 456        exp <<= 4;
 457
 458        return ov2680_write_reg24(sensor, OV2680_REG_EXPOSURE_PK_HIGH, exp);
 459}
 460
 461static int ov2680_exposure_get(struct ov2680_dev *sensor)
 462{
 463        int ret;
 464        u32 exp;
 465
 466        ret = ov2680_read_reg24(sensor, OV2680_REG_EXPOSURE_PK_HIGH, &exp);
 467        if (ret)
 468                return ret;
 469
 470        return exp >> 4;
 471}
 472
 473static int ov2680_stream_enable(struct ov2680_dev *sensor)
 474{
 475        return ov2680_write_reg(sensor, OV2680_REG_STREAM_CTRL, 1);
 476}
 477
 478static int ov2680_stream_disable(struct ov2680_dev *sensor)
 479{
 480        return ov2680_write_reg(sensor, OV2680_REG_STREAM_CTRL, 0);
 481}
 482
 483static int ov2680_mode_set(struct ov2680_dev *sensor)
 484{
 485        struct ov2680_ctrls *ctrls = &sensor->ctrls;
 486        int ret;
 487
 488        ret = ov2680_gain_set(sensor, false);
 489        if (ret < 0)
 490                return ret;
 491
 492        ret = ov2680_exposure_set(sensor, false);
 493        if (ret < 0)
 494                return ret;
 495
 496        ret = ov2680_load_regs(sensor, sensor->current_mode);
 497        if (ret < 0)
 498                return ret;
 499
 500        if (ctrls->auto_gain->val) {
 501                ret = ov2680_gain_set(sensor, true);
 502                if (ret < 0)
 503                        return ret;
 504        }
 505
 506        if (ctrls->auto_exp->val == V4L2_EXPOSURE_AUTO) {
 507                ret = ov2680_exposure_set(sensor, true);
 508                if (ret < 0)
 509                        return ret;
 510        }
 511
 512        sensor->mode_pending_changes = false;
 513
 514        return 0;
 515}
 516
 517static int ov2680_mode_restore(struct ov2680_dev *sensor)
 518{
 519        int ret;
 520
 521        ret = ov2680_load_regs(sensor, &ov2680_mode_init_data);
 522        if (ret < 0)
 523                return ret;
 524
 525        return ov2680_mode_set(sensor);
 526}
 527
 528static int ov2680_power_off(struct ov2680_dev *sensor)
 529{
 530        if (!sensor->is_enabled)
 531                return 0;
 532
 533        clk_disable_unprepare(sensor->xvclk);
 534        ov2680_power_down(sensor);
 535        regulator_bulk_disable(OV2680_NUM_SUPPLIES, sensor->supplies);
 536        sensor->is_enabled = false;
 537
 538        return 0;
 539}
 540
 541static int ov2680_power_on(struct ov2680_dev *sensor)
 542{
 543        struct device *dev = ov2680_to_dev(sensor);
 544        int ret;
 545
 546        if (sensor->is_enabled)
 547                return 0;
 548
 549        ret = regulator_bulk_enable(OV2680_NUM_SUPPLIES, sensor->supplies);
 550        if (ret < 0) {
 551                dev_err(dev, "failed to enable regulators: %d\n", ret);
 552                return ret;
 553        }
 554
 555        if (!sensor->reset_gpio) {
 556                ret = ov2680_write_reg(sensor, OV2680_REG_SOFT_RESET, 0x01);
 557                if (ret != 0) {
 558                        dev_err(dev, "sensor soft reset failed\n");
 559                        return ret;
 560                }
 561                usleep_range(1000, 2000);
 562        } else {
 563                ov2680_power_down(sensor);
 564                ov2680_power_up(sensor);
 565        }
 566
 567        ret = clk_prepare_enable(sensor->xvclk);
 568        if (ret < 0)
 569                return ret;
 570
 571        sensor->is_enabled = true;
 572
 573        /* Set clock lane into LP-11 state */
 574        ov2680_stream_enable(sensor);
 575        usleep_range(1000, 2000);
 576        ov2680_stream_disable(sensor);
 577
 578        return 0;
 579}
 580
 581static int ov2680_s_power(struct v4l2_subdev *sd, int on)
 582{
 583        struct ov2680_dev *sensor = to_ov2680_dev(sd);
 584        int ret = 0;
 585
 586        mutex_lock(&sensor->lock);
 587
 588        if (on)
 589                ret = ov2680_power_on(sensor);
 590        else
 591                ret = ov2680_power_off(sensor);
 592
 593        mutex_unlock(&sensor->lock);
 594
 595        if (on && ret == 0) {
 596                ret = v4l2_ctrl_handler_setup(&sensor->ctrls.handler);
 597                if (ret < 0)
 598                        return ret;
 599
 600                ret = ov2680_mode_restore(sensor);
 601        }
 602
 603        return ret;
 604}
 605
 606static int ov2680_s_g_frame_interval(struct v4l2_subdev *sd,
 607                                     struct v4l2_subdev_frame_interval *fi)
 608{
 609        struct ov2680_dev *sensor = to_ov2680_dev(sd);
 610
 611        mutex_lock(&sensor->lock);
 612        fi->interval = sensor->frame_interval;
 613        mutex_unlock(&sensor->lock);
 614
 615        return 0;
 616}
 617
 618static int ov2680_s_stream(struct v4l2_subdev *sd, int enable)
 619{
 620        struct ov2680_dev *sensor = to_ov2680_dev(sd);
 621        int ret = 0;
 622
 623        mutex_lock(&sensor->lock);
 624
 625        if (sensor->is_streaming == !!enable)
 626                goto unlock;
 627
 628        if (enable && sensor->mode_pending_changes) {
 629                ret = ov2680_mode_set(sensor);
 630                if (ret < 0)
 631                        goto unlock;
 632        }
 633
 634        if (enable)
 635                ret = ov2680_stream_enable(sensor);
 636        else
 637                ret = ov2680_stream_disable(sensor);
 638
 639        sensor->is_streaming = !!enable;
 640
 641unlock:
 642        mutex_unlock(&sensor->lock);
 643
 644        return ret;
 645}
 646
 647static int ov2680_enum_mbus_code(struct v4l2_subdev *sd,
 648                                 struct v4l2_subdev_pad_config *cfg,
 649                                 struct v4l2_subdev_mbus_code_enum *code)
 650{
 651        struct ov2680_dev *sensor = to_ov2680_dev(sd);
 652
 653        if (code->pad != 0 || code->index != 0)
 654                return -EINVAL;
 655
 656        code->code = sensor->fmt.code;
 657
 658        return 0;
 659}
 660
 661static int ov2680_get_fmt(struct v4l2_subdev *sd,
 662                          struct v4l2_subdev_pad_config *cfg,
 663                          struct v4l2_subdev_format *format)
 664{
 665        struct ov2680_dev *sensor = to_ov2680_dev(sd);
 666        struct v4l2_mbus_framefmt *fmt = NULL;
 667        int ret = 0;
 668
 669        if (format->pad != 0)
 670                return -EINVAL;
 671
 672        mutex_lock(&sensor->lock);
 673
 674        if (format->which == V4L2_SUBDEV_FORMAT_TRY) {
 675#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
 676                fmt = v4l2_subdev_get_try_format(&sensor->sd, cfg, format->pad);
 677#else
 678                ret = -EINVAL;
 679#endif
 680        } else {
 681                fmt = &sensor->fmt;
 682        }
 683
 684        if (fmt)
 685                format->format = *fmt;
 686
 687        mutex_unlock(&sensor->lock);
 688
 689        return ret;
 690}
 691
 692static int ov2680_set_fmt(struct v4l2_subdev *sd,
 693                          struct v4l2_subdev_pad_config *cfg,
 694                          struct v4l2_subdev_format *format)
 695{
 696        struct ov2680_dev *sensor = to_ov2680_dev(sd);
 697        struct v4l2_mbus_framefmt *fmt = &format->format;
 698#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
 699        struct v4l2_mbus_framefmt *try_fmt;
 700#endif
 701        const struct ov2680_mode_info *mode;
 702        int ret = 0;
 703
 704        if (format->pad != 0)
 705                return -EINVAL;
 706
 707        mutex_lock(&sensor->lock);
 708
 709        if (sensor->is_streaming) {
 710                ret = -EBUSY;
 711                goto unlock;
 712        }
 713
 714        mode = v4l2_find_nearest_size(ov2680_mode_data,
 715                                      ARRAY_SIZE(ov2680_mode_data), width,
 716                                      height, fmt->width, fmt->height);
 717        if (!mode) {
 718                ret = -EINVAL;
 719                goto unlock;
 720        }
 721
 722        if (format->which == V4L2_SUBDEV_FORMAT_TRY) {
 723#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
 724                try_fmt = v4l2_subdev_get_try_format(sd, cfg, 0);
 725                format->format = *try_fmt;
 726#endif
 727                goto unlock;
 728        }
 729
 730        fmt->width = mode->width;
 731        fmt->height = mode->height;
 732        fmt->code = sensor->fmt.code;
 733        fmt->colorspace = sensor->fmt.colorspace;
 734
 735        sensor->current_mode = mode;
 736        sensor->fmt = format->format;
 737        sensor->mode_pending_changes = true;
 738
 739unlock:
 740        mutex_unlock(&sensor->lock);
 741
 742        return ret;
 743}
 744
 745static int ov2680_init_cfg(struct v4l2_subdev *sd,
 746                           struct v4l2_subdev_pad_config *cfg)
 747{
 748        struct v4l2_subdev_format fmt = {
 749                .which = cfg ? V4L2_SUBDEV_FORMAT_TRY
 750                                : V4L2_SUBDEV_FORMAT_ACTIVE,
 751                .format = {
 752                        .width = 800,
 753                        .height = 600,
 754                }
 755        };
 756
 757        return ov2680_set_fmt(sd, cfg, &fmt);
 758}
 759
 760static int ov2680_enum_frame_size(struct v4l2_subdev *sd,
 761                                  struct v4l2_subdev_pad_config *cfg,
 762                                  struct v4l2_subdev_frame_size_enum *fse)
 763{
 764        int index = fse->index;
 765
 766        if (index >= OV2680_MODE_MAX || index < 0)
 767                return -EINVAL;
 768
 769        fse->min_width = ov2680_mode_data[index].width;
 770        fse->min_height = ov2680_mode_data[index].height;
 771        fse->max_width = ov2680_mode_data[index].width;
 772        fse->max_height = ov2680_mode_data[index].height;
 773
 774        return 0;
 775}
 776
 777static int ov2680_enum_frame_interval(struct v4l2_subdev *sd,
 778                              struct v4l2_subdev_pad_config *cfg,
 779                              struct v4l2_subdev_frame_interval_enum *fie)
 780{
 781        struct v4l2_fract tpf;
 782
 783        if (fie->index >= OV2680_MODE_MAX || fie->width > OV2680_WIDTH_MAX ||
 784            fie->height > OV2680_HEIGHT_MAX ||
 785            fie->which > V4L2_SUBDEV_FORMAT_ACTIVE)
 786                return -EINVAL;
 787
 788        tpf.denominator = OV2680_FRAME_RATE;
 789        tpf.numerator = 1;
 790
 791        fie->interval = tpf;
 792
 793        return 0;
 794}
 795
 796static int ov2680_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
 797{
 798        struct v4l2_subdev *sd = ctrl_to_sd(ctrl);
 799        struct ov2680_dev *sensor = to_ov2680_dev(sd);
 800        struct ov2680_ctrls *ctrls = &sensor->ctrls;
 801        int val;
 802
 803        if (!sensor->is_enabled)
 804                return 0;
 805
 806        switch (ctrl->id) {
 807        case V4L2_CID_GAIN:
 808                val = ov2680_gain_get(sensor);
 809                if (val < 0)
 810                        return val;
 811                ctrls->gain->val = val;
 812                break;
 813        case V4L2_CID_EXPOSURE:
 814                val = ov2680_exposure_get(sensor);
 815                if (val < 0)
 816                        return val;
 817                ctrls->exposure->val = val;
 818                break;
 819        }
 820
 821        return 0;
 822}
 823
 824static int ov2680_s_ctrl(struct v4l2_ctrl *ctrl)
 825{
 826        struct v4l2_subdev *sd = ctrl_to_sd(ctrl);
 827        struct ov2680_dev *sensor = to_ov2680_dev(sd);
 828        struct ov2680_ctrls *ctrls = &sensor->ctrls;
 829
 830        if (!sensor->is_enabled)
 831                return 0;
 832
 833        switch (ctrl->id) {
 834        case V4L2_CID_AUTOGAIN:
 835                return ov2680_gain_set(sensor, !!ctrl->val);
 836        case V4L2_CID_GAIN:
 837                return ov2680_gain_set(sensor, !!ctrls->auto_gain->val);
 838        case V4L2_CID_EXPOSURE_AUTO:
 839                return ov2680_exposure_set(sensor, !!ctrl->val);
 840        case V4L2_CID_EXPOSURE:
 841                return ov2680_exposure_set(sensor, !!ctrls->auto_exp->val);
 842        case V4L2_CID_VFLIP:
 843                if (sensor->is_streaming)
 844                        return -EBUSY;
 845                if (ctrl->val)
 846                        return ov2680_vflip_enable(sensor);
 847                else
 848                        return ov2680_vflip_disable(sensor);
 849        case V4L2_CID_HFLIP:
 850                if (sensor->is_streaming)
 851                        return -EBUSY;
 852                if (ctrl->val)
 853                        return ov2680_hflip_enable(sensor);
 854                else
 855                        return ov2680_hflip_disable(sensor);
 856        case V4L2_CID_TEST_PATTERN:
 857                return ov2680_test_pattern_set(sensor, ctrl->val);
 858        default:
 859                break;
 860        }
 861
 862        return -EINVAL;
 863}
 864
 865static const struct v4l2_ctrl_ops ov2680_ctrl_ops = {
 866        .g_volatile_ctrl = ov2680_g_volatile_ctrl,
 867        .s_ctrl = ov2680_s_ctrl,
 868};
 869
 870static const struct v4l2_subdev_core_ops ov2680_core_ops = {
 871        .s_power = ov2680_s_power,
 872};
 873
 874static const struct v4l2_subdev_video_ops ov2680_video_ops = {
 875        .g_frame_interval       = ov2680_s_g_frame_interval,
 876        .s_frame_interval       = ov2680_s_g_frame_interval,
 877        .s_stream               = ov2680_s_stream,
 878};
 879
 880static const struct v4l2_subdev_pad_ops ov2680_pad_ops = {
 881        .init_cfg               = ov2680_init_cfg,
 882        .enum_mbus_code         = ov2680_enum_mbus_code,
 883        .get_fmt                = ov2680_get_fmt,
 884        .set_fmt                = ov2680_set_fmt,
 885        .enum_frame_size        = ov2680_enum_frame_size,
 886        .enum_frame_interval    = ov2680_enum_frame_interval,
 887};
 888
 889static const struct v4l2_subdev_ops ov2680_subdev_ops = {
 890        .core   = &ov2680_core_ops,
 891        .video  = &ov2680_video_ops,
 892        .pad    = &ov2680_pad_ops,
 893};
 894
 895static int ov2680_mode_init(struct ov2680_dev *sensor)
 896{
 897        const struct ov2680_mode_info *init_mode;
 898
 899        /* set initial mode */
 900        sensor->fmt.code = MEDIA_BUS_FMT_SBGGR10_1X10;
 901        sensor->fmt.width = 800;
 902        sensor->fmt.height = 600;
 903        sensor->fmt.field = V4L2_FIELD_NONE;
 904        sensor->fmt.colorspace = V4L2_COLORSPACE_SRGB;
 905
 906        sensor->frame_interval.denominator = OV2680_FRAME_RATE;
 907        sensor->frame_interval.numerator = 1;
 908
 909        init_mode = &ov2680_mode_init_data;
 910
 911        sensor->current_mode = init_mode;
 912
 913        sensor->mode_pending_changes = true;
 914
 915        return 0;
 916}
 917
 918static int ov2680_v4l2_register(struct ov2680_dev *sensor)
 919{
 920        const struct v4l2_ctrl_ops *ops = &ov2680_ctrl_ops;
 921        struct ov2680_ctrls *ctrls = &sensor->ctrls;
 922        struct v4l2_ctrl_handler *hdl = &ctrls->handler;
 923        int ret = 0;
 924
 925        v4l2_i2c_subdev_init(&sensor->sd, sensor->i2c_client,
 926                             &ov2680_subdev_ops);
 927
 928#ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
 929        sensor->sd.flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
 930#endif
 931        sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
 932        sensor->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
 933
 934        ret = media_entity_pads_init(&sensor->sd.entity, 1, &sensor->pad);
 935        if (ret < 0)
 936                return ret;
 937
 938        v4l2_ctrl_handler_init(hdl, 7);
 939
 940        hdl->lock = &sensor->lock;
 941
 942        ctrls->vflip = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_VFLIP, 0, 1, 1, 0);
 943        ctrls->hflip = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_HFLIP, 0, 1, 1, 0);
 944
 945        ctrls->test_pattern = v4l2_ctrl_new_std_menu_items(hdl,
 946                                        &ov2680_ctrl_ops, V4L2_CID_TEST_PATTERN,
 947                                        ARRAY_SIZE(test_pattern_menu) - 1,
 948                                        0, 0, test_pattern_menu);
 949
 950        ctrls->auto_exp = v4l2_ctrl_new_std_menu(hdl, ops,
 951                                                 V4L2_CID_EXPOSURE_AUTO,
 952                                                 V4L2_EXPOSURE_MANUAL, 0,
 953                                                 V4L2_EXPOSURE_AUTO);
 954
 955        ctrls->exposure = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_EXPOSURE,
 956                                            0, 32767, 1, 0);
 957
 958        ctrls->auto_gain = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_AUTOGAIN,
 959                                             0, 1, 1, 1);
 960        ctrls->gain = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_GAIN, 0, 2047, 1, 0);
 961
 962        if (hdl->error) {
 963                ret = hdl->error;
 964                goto cleanup_entity;
 965        }
 966
 967        ctrls->gain->flags |= V4L2_CTRL_FLAG_VOLATILE;
 968        ctrls->exposure->flags |= V4L2_CTRL_FLAG_VOLATILE;
 969
 970        v4l2_ctrl_auto_cluster(2, &ctrls->auto_gain, 0, true);
 971        v4l2_ctrl_auto_cluster(2, &ctrls->auto_exp, 1, true);
 972
 973        sensor->sd.ctrl_handler = hdl;
 974
 975        ret = v4l2_async_register_subdev(&sensor->sd);
 976        if (ret < 0)
 977                goto cleanup_entity;
 978
 979        return 0;
 980
 981cleanup_entity:
 982        media_entity_cleanup(&sensor->sd.entity);
 983        v4l2_ctrl_handler_free(hdl);
 984
 985        return ret;
 986}
 987
 988static int ov2680_get_regulators(struct ov2680_dev *sensor)
 989{
 990        int i;
 991
 992        for (i = 0; i < OV2680_NUM_SUPPLIES; i++)
 993                sensor->supplies[i].supply = ov2680_supply_name[i];
 994
 995        return devm_regulator_bulk_get(&sensor->i2c_client->dev,
 996                                       OV2680_NUM_SUPPLIES,
 997                                       sensor->supplies);
 998}
 999
1000static int ov2680_check_id(struct ov2680_dev *sensor)
1001{
1002        struct device *dev = ov2680_to_dev(sensor);
1003        u32 chip_id;
1004        int ret;
1005
1006        ov2680_power_on(sensor);
1007
1008        ret = ov2680_read_reg16(sensor, OV2680_REG_CHIP_ID_HIGH, &chip_id);
1009        if (ret < 0) {
1010                dev_err(dev, "failed to read chip id high\n");
1011                return -ENODEV;
1012        }
1013
1014        if (chip_id != OV2680_CHIP_ID) {
1015                dev_err(dev, "chip id: 0x%04x does not match expected 0x%04x\n",
1016                        chip_id, OV2680_CHIP_ID);
1017                return -ENODEV;
1018        }
1019
1020        return 0;
1021}
1022
1023static int ov2680_parse_dt(struct ov2680_dev *sensor)
1024{
1025        struct device *dev = ov2680_to_dev(sensor);
1026        int ret;
1027
1028        sensor->reset_gpio = devm_gpiod_get_optional(dev, "reset",
1029                                                     GPIOD_OUT_HIGH);
1030        ret = PTR_ERR_OR_ZERO(sensor->reset_gpio);
1031        if (ret < 0) {
1032                dev_dbg(dev, "error while getting reset gpio: %d\n", ret);
1033                return ret;
1034        }
1035
1036        sensor->xvclk = devm_clk_get(dev, "xvclk");
1037        if (IS_ERR(sensor->xvclk)) {
1038                dev_err(dev, "xvclk clock missing or invalid\n");
1039                return PTR_ERR(sensor->xvclk);
1040        }
1041
1042        sensor->xvclk_freq = clk_get_rate(sensor->xvclk);
1043        if (sensor->xvclk_freq != OV2680_XVCLK_VALUE) {
1044                dev_err(dev, "wrong xvclk frequency %d HZ, expected: %d Hz\n",
1045                        sensor->xvclk_freq, OV2680_XVCLK_VALUE);
1046                return -EINVAL;
1047        }
1048
1049        return 0;
1050}
1051
1052static int ov2680_probe(struct i2c_client *client)
1053{
1054        struct device *dev = &client->dev;
1055        struct ov2680_dev *sensor;
1056        int ret;
1057
1058        sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL);
1059        if (!sensor)
1060                return -ENOMEM;
1061
1062        sensor->i2c_client = client;
1063
1064        ret = ov2680_parse_dt(sensor);
1065        if (ret < 0)
1066                return -EINVAL;
1067
1068        ret = ov2680_mode_init(sensor);
1069        if (ret < 0)
1070                return ret;
1071
1072        ret = ov2680_get_regulators(sensor);
1073        if (ret < 0) {
1074                dev_err(dev, "failed to get regulators\n");
1075                return ret;
1076        }
1077
1078        mutex_init(&sensor->lock);
1079
1080        ret = ov2680_check_id(sensor);
1081        if (ret < 0)
1082                goto lock_destroy;
1083
1084        ret = ov2680_v4l2_register(sensor);
1085        if (ret < 0)
1086                goto lock_destroy;
1087
1088        dev_info(dev, "ov2680 init correctly\n");
1089
1090        return 0;
1091
1092lock_destroy:
1093        dev_err(dev, "ov2680 init fail: %d\n", ret);
1094        mutex_destroy(&sensor->lock);
1095
1096        return ret;
1097}
1098
1099static int ov2680_remove(struct i2c_client *client)
1100{
1101        struct v4l2_subdev *sd = i2c_get_clientdata(client);
1102        struct ov2680_dev *sensor = to_ov2680_dev(sd);
1103
1104        v4l2_async_unregister_subdev(&sensor->sd);
1105        mutex_destroy(&sensor->lock);
1106        media_entity_cleanup(&sensor->sd.entity);
1107        v4l2_ctrl_handler_free(&sensor->ctrls.handler);
1108
1109        return 0;
1110}
1111
1112static int __maybe_unused ov2680_suspend(struct device *dev)
1113{
1114        struct i2c_client *client = to_i2c_client(dev);
1115        struct v4l2_subdev *sd = i2c_get_clientdata(client);
1116        struct ov2680_dev *sensor = to_ov2680_dev(sd);
1117
1118        if (sensor->is_streaming)
1119                ov2680_stream_disable(sensor);
1120
1121        return 0;
1122}
1123
1124static int __maybe_unused ov2680_resume(struct device *dev)
1125{
1126        struct i2c_client *client = to_i2c_client(dev);
1127        struct v4l2_subdev *sd = i2c_get_clientdata(client);
1128        struct ov2680_dev *sensor = to_ov2680_dev(sd);
1129        int ret;
1130
1131        if (sensor->is_streaming) {
1132                ret = ov2680_stream_enable(sensor);
1133                if (ret < 0)
1134                        goto stream_disable;
1135        }
1136
1137        return 0;
1138
1139stream_disable:
1140        ov2680_stream_disable(sensor);
1141        sensor->is_streaming = false;
1142
1143        return ret;
1144}
1145
1146static const struct dev_pm_ops ov2680_pm_ops = {
1147        SET_SYSTEM_SLEEP_PM_OPS(ov2680_suspend, ov2680_resume)
1148};
1149
1150static const struct of_device_id ov2680_dt_ids[] = {
1151        { .compatible = "ovti,ov2680" },
1152        { /* sentinel */ },
1153};
1154MODULE_DEVICE_TABLE(of, ov2680_dt_ids);
1155
1156static struct i2c_driver ov2680_i2c_driver = {
1157        .driver = {
1158                .name  = "ov2680",
1159                .pm = &ov2680_pm_ops,
1160                .of_match_table = of_match_ptr(ov2680_dt_ids),
1161        },
1162        .probe_new      = ov2680_probe,
1163        .remove         = ov2680_remove,
1164};
1165module_i2c_driver(ov2680_i2c_driver);
1166
1167MODULE_AUTHOR("Rui Miguel Silva <rui.silva@linaro.org>");
1168MODULE_DESCRIPTION("OV2680 CMOS Image Sensor driver");
1169MODULE_LICENSE("GPL v2");
1170