drivers/media/i2c/imx258.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (C) 2018 Intel Corporation
   3
   4 #include <linux/acpi.h>
   5 #include <linux/clk.h>
   6 #include <linux/delay.h>
   7 #include <linux/i2c.h>
   8 #include <linux/module.h>
   9 #include <linux/pm_runtime.h>
  10 #include <linux/regulator/consumer.h>
  11 #include <media/v4l2-ctrls.h>
  12 #include <media/v4l2-device.h>
  13 #include <media/v4l2-fwnode.h>
  14 #include <asm/unaligned.h>
  15
  16 #define IMX258_REG_VALUE_08BIT          1
  17 #define IMX258_REG_VALUE_16BIT          2
  18
  19 #define IMX258_REG_MODE_SELECT          0x0100
  20 #define IMX258_MODE_STANDBY             0x00
  21 #define IMX258_MODE_STREAMING           0x01
  22
  23 /* Chip ID */
  24 #define IMX258_REG_CHIP_ID              0x0016
  25 #define IMX258_CHIP_ID                  0x0258
  26
  27 /* V_TIMING internal */
  28 #define IMX258_VTS_30FPS                0x0c50
  29 #define IMX258_VTS_30FPS_2K             0x0638
  30 #define IMX258_VTS_30FPS_VGA            0x034c
  31 #define IMX258_VTS_MAX                  65525
  32
  33 #define IMX258_REG_VTS                  0x0340
  34
  35 /* Exposure control */
  36 #define IMX258_REG_EXPOSURE             0x0202
  37 #define IMX258_EXPOSURE_OFFSET          10
  38 #define IMX258_EXPOSURE_MIN             4
  39 #define IMX258_EXPOSURE_STEP            1
  40 #define IMX258_EXPOSURE_DEFAULT         0x640
  41 #define IMX258_EXPOSURE_MAX             (IMX258_VTS_MAX - IMX258_EXPOSURE_OFFSET)
  42
  43 /* HBLANK control - read only */
  44 #define IMX258_PPL_DEFAULT              5352
  45
  46 /* Analog gain control */
  47 #define IMX258_REG_ANALOG_GAIN          0x0204
  48 #define IMX258_ANA_GAIN_MIN             0
  49 #define IMX258_ANA_GAIN_MAX             480
  50 #define IMX258_ANA_GAIN_STEP            1
  51 #define IMX258_ANA_GAIN_DEFAULT         0x0
  52
  53 /* Digital gain control */
  54 #define IMX258_REG_GR_DIGITAL_GAIN      0x020e
  55 #define IMX258_REG_R_DIGITAL_GAIN       0x0210
  56 #define IMX258_REG_B_DIGITAL_GAIN       0x0212
  57 #define IMX258_REG_GB_DIGITAL_GAIN      0x0214
  58 #define IMX258_DGTL_GAIN_MIN            0
  59 #define IMX258_DGTL_GAIN_MAX            4096    /* Max = 0xFFF */
  60 #define IMX258_DGTL_GAIN_DEFAULT        1024
  61 #define IMX258_DGTL_GAIN_STEP           1
  62
  63 /* HDR control */
  64 #define IMX258_REG_HDR                  0x0220
  65 #define IMX258_HDR_ON                   BIT(0)
  66 #define IMX258_REG_HDR_RATIO            0x0222
  67 #define IMX258_HDR_RATIO_MIN            0
  68 #define IMX258_HDR_RATIO_MAX            5
  69 #define IMX258_HDR_RATIO_STEP           1
  70 #define IMX258_HDR_RATIO_DEFAULT        0x0
  71
  72 /* Test Pattern Control */
  73 #define IMX258_REG_TEST_PATTERN         0x0600
  74
  75 #define IMX258_CLK_BLANK_STOP           0x4040
  76
  77 /* Orientation */
  78 #define REG_MIRROR_FLIP_CONTROL         0x0101
  79 #define REG_CONFIG_MIRROR_FLIP          0x03
  80 #define REG_CONFIG_FLIP_TEST_PATTERN    0x02
  81
  82 /* IMX258 native and active pixel array size. */
  83 #define IMX258_NATIVE_WIDTH             4224U
  84 #define IMX258_NATIVE_HEIGHT            3192U
  85 #define IMX258_PIXEL_ARRAY_LEFT         8U
  86 #define IMX258_PIXEL_ARRAY_TOP          16U
  87 #define IMX258_PIXEL_ARRAY_WIDTH        4208U
  88 #define IMX258_PIXEL_ARRAY_HEIGHT       3120U
  89
  90 struct imx258_reg {
  91         u16 address;
  92         u8 val;
  93 };
  94
  95 struct imx258_reg_list {
  96         u32 num_of_regs;
  97         const struct imx258_reg *regs;
  98 };
  99
 100 #define IMX258_LANE_CONFIGS     2
 101 #define IMX258_2_LANE_MODE      0
 102 #define IMX258_4_LANE_MODE      1
 103
 104 /* Link frequency config */
 105 struct imx258_link_freq_config {
 106         u64 link_frequency;
 107         u32 pixels_per_line;
 108
 109         /* PLL registers for this link frequency */
 110         struct imx258_reg_list reg_list[IMX258_LANE_CONFIGS];
 111 };
 112
 113 /* Mode : resolution and related config&values */
 114 struct imx258_mode {
 115         /* Frame width */
 116         u32 width;
 117         /* Frame height */
 118         u32 height;
 119
 120         /* V-timing */
 121         u32 vts_def;
 122         u32 vts_min;
 123
 124         /* Index of Link frequency config to be used */
 125         u32 link_freq_index;
 126         /* Default register values */
 127         struct imx258_reg_list reg_list;
 128
 129         /* Analog crop rectangle. */
 130         struct v4l2_rect crop;
 131 };
 132
 133 /* 4208x3120 needs 1267Mbps/lane, 4 lanes. Use that rate on 2 lanes as well */
 134 static const struct imx258_reg mipi_1267mbps_19_2mhz_2l[] = {
 135         { 0x0136, 0x13 },
 136         { 0x0137, 0x33 },
 137         { 0x0301, 0x0A },
 138         { 0x0303, 0x02 },
 139         { 0x0305, 0x03 },
 140         { 0x0306, 0x00 },
 141         { 0x0307, 0xC6 },
 142         { 0x0309, 0x0A },
 143         { 0x030B, 0x01 },
 144         { 0x030D, 0x02 },
 145         { 0x030E, 0x00 },
 146         { 0x030F, 0xD8 },
 147         { 0x0310, 0x00 },
 148
 149         { 0x0114, 0x01 },
 150         { 0x0820, 0x09 },
 151         { 0x0821, 0xa6 },
 152         { 0x0822, 0x66 },
 153         { 0x0823, 0x66 },
 154 };
 155
 156 static const struct imx258_reg mipi_1267mbps_19_2mhz_4l[] = {
 157         { 0x0136, 0x13 },
 158         { 0x0137, 0x33 },
 159         { 0x0301, 0x05 },
 160         { 0x0303, 0x02 },
 161         { 0x0305, 0x03 },
 162         { 0x0306, 0x00 },
 163         { 0x0307, 0xC6 },
 164         { 0x0309, 0x0A },
 165         { 0x030B, 0x01 },
 166         { 0x030D, 0x02 },
 167         { 0x030E, 0x00 },
 168         { 0x030F, 0xD8 },
 169         { 0x0310, 0x00 },
 170
 171         { 0x0114, 0x03 },
 172         { 0x0820, 0x13 },
 173         { 0x0821, 0x4C },
 174         { 0x0822, 0xCC },
 175         { 0x0823, 0xCC },
 176 };
 177
 178 static const struct imx258_reg mipi_1272mbps_24mhz_2l[] = {
 179         { 0x0136, 0x18 },
 180         { 0x0137, 0x00 },
 181         { 0x0301, 0x0a },
 182         { 0x0303, 0x02 },
 183         { 0x0305, 0x04 },
 184         { 0x0306, 0x00 },
 185         { 0x0307, 0xD4 },
 186         { 0x0309, 0x0A },
 187         { 0x030B, 0x01 },
 188         { 0x030D, 0x02 },
 189         { 0x030E, 0x00 },
 190         { 0x030F, 0xD8 },
 191         { 0x0310, 0x00 },
 192
 193         { 0x0114, 0x01 },
 194         { 0x0820, 0x13 },
 195         { 0x0821, 0x4C },
 196         { 0x0822, 0xCC },
 197         { 0x0823, 0xCC },
 198 };
 199
 200 static const struct imx258_reg mipi_1272mbps_24mhz_4l[] = {
 201         { 0x0136, 0x18 },
 202         { 0x0137, 0x00 },
 203         { 0x0301, 0x05 },
 204         { 0x0303, 0x02 },
 205         { 0x0305, 0x04 },
 206         { 0x0306, 0x00 },
 207         { 0x0307, 0xD4 },
 208         { 0x0309, 0x0A },
 209         { 0x030B, 0x01 },
 210         { 0x030D, 0x02 },
 211         { 0x030E, 0x00 },
 212         { 0x030F, 0xD8 },
 213         { 0x0310, 0x00 },
 214
 215         { 0x0114, 0x03 },
 216         { 0x0820, 0x13 },
 217         { 0x0821, 0xE0 },
 218         { 0x0822, 0x00 },
 219         { 0x0823, 0x00 },
 220 };
 221
 222 static const struct imx258_reg mipi_640mbps_19_2mhz_2l[] = {
 223         { 0x0136, 0x13 },
 224         { 0x0137, 0x33 },
 225         { 0x0301, 0x05 },
 226         { 0x0303, 0x02 },
 227         { 0x0305, 0x03 },
 228         { 0x0306, 0x00 },
 229         { 0x0307, 0x64 },
 230         { 0x0309, 0x0A },
 231         { 0x030B, 0x01 },
 232         { 0x030D, 0x02 },
 233         { 0x030E, 0x00 },
 234         { 0x030F, 0xD8 },
 235         { 0x0310, 0x00 },
 236
 237         { 0x0114, 0x01 },
 238         { 0x0820, 0x05 },
 239         { 0x0821, 0x00 },
 240         { 0x0822, 0x00 },
 241         { 0x0823, 0x00 },
 242 };
 243
 244 static const struct imx258_reg mipi_640mbps_19_2mhz_4l[] = {
 245         { 0x0136, 0x13 },
 246         { 0x0137, 0x33 },
 247         { 0x0301, 0x05 },
 248         { 0x0303, 0x02 },
 249         { 0x0305, 0x03 },
 250         { 0x0306, 0x00 },
 251         { 0x0307, 0x64 },
 252         { 0x0309, 0x0A },
 253         { 0x030B, 0x01 },
 254         { 0x030D, 0x02 },
 255         { 0x030E, 0x00 },
 256         { 0x030F, 0xD8 },
 257         { 0x0310, 0x00 },
 258
 259         { 0x0114, 0x03 },
 260         { 0x0820, 0x0A },
 261         { 0x0821, 0x00 },
 262         { 0x0822, 0x00 },
 263         { 0x0823, 0x00 },
 264 };
 265
 266 static const struct imx258_reg mipi_642mbps_24mhz_2l[] = {
 267         { 0x0136, 0x18 },
 268         { 0x0137, 0x00 },
 269         { 0x0301, 0x0A },
 270         { 0x0303, 0x02 },
 271         { 0x0305, 0x04 },
 272         { 0x0306, 0x00 },
 273         { 0x0307, 0x6B },
 274         { 0x0309, 0x0A },
 275         { 0x030B, 0x01 },
 276         { 0x030D, 0x02 },
 277         { 0x030E, 0x00 },
 278         { 0x030F, 0xD8 },
 279         { 0x0310, 0x00 },
 280
 281         { 0x0114, 0x01 },
 282         { 0x0820, 0x0A },
 283         { 0x0821, 0x00 },
 284         { 0x0822, 0x00 },
 285         { 0x0823, 0x00 },
 286 };
 287
 288 static const struct imx258_reg mipi_642mbps_24mhz_4l[] = {
 289         { 0x0136, 0x18 },
 290         { 0x0137, 0x00 },
 291         { 0x0301, 0x05 },
 292         { 0x0303, 0x02 },
 293         { 0x0305, 0x04 },
 294         { 0x0306, 0x00 },
 295         { 0x0307, 0x6B },
 296         { 0x0309, 0x0A },
 297         { 0x030B, 0x01 },
 298         { 0x030D, 0x02 },
 299         { 0x030E, 0x00 },
 300         { 0x030F, 0xD8 },
 301         { 0x0310, 0x00 },
 302
 303         { 0x0114, 0x03 },
 304         { 0x0820, 0x0A },
 305         { 0x0821, 0x00 },
 306         { 0x0822, 0x00 },
 307         { 0x0823, 0x00 },
 308 };
 309
 310 static const struct imx258_reg mode_4208x3120_regs[] = {
 311         { 0x3051, 0x00 },
 312         { 0x3052, 0x00 },
 313         { 0x4E21, 0x14 },
 314         { 0x6B11, 0xCF },
 315         { 0x7FF0, 0x08 },
 316         { 0x7FF1, 0x0F },
 317         { 0x7FF2, 0x08 },
 318         { 0x7FF3, 0x1B },
 319         { 0x7FF4, 0x23 },
 320         { 0x7FF5, 0x60 },
 321         { 0x7FF6, 0x00 },
 322         { 0x7FF7, 0x01 },
 323         { 0x7FF8, 0x00 },
 324         { 0x7FF9, 0x78 },
 325         { 0x7FFA, 0x00 },
 326         { 0x7FFB, 0x00 },
 327         { 0x7FFC, 0x00 },
 328         { 0x7FFD, 0x00 },
 329         { 0x7FFE, 0x00 },
 330         { 0x7FFF, 0x03 },
 331         { 0x7F76, 0x03 },
 332         { 0x7F77, 0xFE },
 333         { 0x7FA8, 0x03 },
 334         { 0x7FA9, 0xFE },
 335         { 0x7B24, 0x81 },
 336         { 0x7B25, 0x00 },
 337         { 0x6564, 0x07 },
 338         { 0x6B0D, 0x41 },
 339         { 0x653D, 0x04 },
 340         { 0x6B05, 0x8C },
 341         { 0x6B06, 0xF9 },
 342         { 0x6B08, 0x65 },
 343         { 0x6B09, 0xFC },
 344         { 0x6B0A, 0xCF },
 345         { 0x6B0B, 0xD2 },
 346         { 0x6700, 0x0E },
 347         { 0x6707, 0x0E },
 348         { 0x9104, 0x00 },
 349         { 0x4648, 0x7F },
 350         { 0x7420, 0x00 },
 351         { 0x7421, 0x1C },
 352         { 0x7422, 0x00 },
 353         { 0x7423, 0xD7 },
 354         { 0x5F04, 0x00 },
 355         { 0x5F05, 0xED },
 356         { 0x0112, 0x0A },
 357         { 0x0113, 0x0A },
 358         { 0x0342, 0x14 },
 359         { 0x0343, 0xE8 },
 360         { 0x0344, 0x00 },
 361         { 0x0345, 0x00 },
 362         { 0x0346, 0x00 },
 363         { 0x0347, 0x00 },
 364         { 0x0348, 0x10 },
 365         { 0x0349, 0x6F },
 366         { 0x034A, 0x0C },
 367         { 0x034B, 0x2F },
 368         { 0x0381, 0x01 },
 369         { 0x0383, 0x01 },
 370         { 0x0385, 0x01 },
 371         { 0x0387, 0x01 },
 372         { 0x0900, 0x00 },
 373         { 0x0901, 0x11 },
 374         { 0x0401, 0x00 },
 375         { 0x0404, 0x00 },
 376         { 0x0405, 0x10 },
 377         { 0x0408, 0x00 },
 378         { 0x0409, 0x00 },
 379         { 0x040A, 0x00 },
 380         { 0x040B, 0x00 },
 381         { 0x040C, 0x10 },
 382         { 0x040D, 0x70 },
 383         { 0x040E, 0x0C },
 384         { 0x040F, 0x30 },
 385         { 0x3038, 0x00 },
 386         { 0x303A, 0x00 },
 387         { 0x303B, 0x10 },
 388         { 0x300D, 0x00 },
 389         { 0x034C, 0x10 },
 390         { 0x034D, 0x70 },
 391         { 0x034E, 0x0C },
 392         { 0x034F, 0x30 },
 393         { 0x0350, 0x00 },
 394         { 0x0204, 0x00 },
 395         { 0x0205, 0x00 },
 396         { 0x020E, 0x01 },
 397         { 0x020F, 0x00 },
 398         { 0x0210, 0x01 },
 399         { 0x0211, 0x00 },
 400         { 0x0212, 0x01 },
 401         { 0x0213, 0x00 },
 402         { 0x0214, 0x01 },
 403         { 0x0215, 0x00 },
 404         { 0x7BCD, 0x00 },
 405         { 0x94DC, 0x20 },
 406         { 0x94DD, 0x20 },
 407         { 0x94DE, 0x20 },
 408         { 0x95DC, 0x20 },
 409         { 0x95DD, 0x20 },
 410         { 0x95DE, 0x20 },
 411         { 0x7FB0, 0x00 },
 412         { 0x9010, 0x3E },
 413         { 0x9419, 0x50 },
 414         { 0x941B, 0x50 },
 415         { 0x9519, 0x50 },
 416         { 0x951B, 0x50 },
 417         { 0x3030, 0x00 },
 418         { 0x3032, 0x00 },
 419         { 0x0220, 0x00 },
 420 };
 421
 422 static const struct imx258_reg mode_2104_1560_regs[] = {
 423         { 0x3051, 0x00 },
 424         { 0x3052, 0x00 },
 425         { 0x4E21, 0x14 },
 426         { 0x6B11, 0xCF },
 427         { 0x7FF0, 0x08 },
 428         { 0x7FF1, 0x0F },
 429         { 0x7FF2, 0x08 },
 430         { 0x7FF3, 0x1B },
 431         { 0x7FF4, 0x23 },
 432         { 0x7FF5, 0x60 },
 433         { 0x7FF6, 0x00 },
 434         { 0x7FF7, 0x01 },
 435         { 0x7FF8, 0x00 },
 436         { 0x7FF9, 0x78 },
 437         { 0x7FFA, 0x00 },
 438         { 0x7FFB, 0x00 },
 439         { 0x7FFC, 0x00 },
 440         { 0x7FFD, 0x00 },
 441         { 0x7FFE, 0x00 },
 442         { 0x7FFF, 0x03 },
 443         { 0x7F76, 0x03 },
 444         { 0x7F77, 0xFE },
 445         { 0x7FA8, 0x03 },
 446         { 0x7FA9, 0xFE },
 447         { 0x7B24, 0x81 },
 448         { 0x7B25, 0x00 },
 449         { 0x6564, 0x07 },
 450         { 0x6B0D, 0x41 },
 451         { 0x653D, 0x04 },
 452         { 0x6B05, 0x8C },
 453         { 0x6B06, 0xF9 },
 454         { 0x6B08, 0x65 },
 455         { 0x6B09, 0xFC },
 456         { 0x6B0A, 0xCF },
 457         { 0x6B0B, 0xD2 },
 458         { 0x6700, 0x0E },
 459         { 0x6707, 0x0E },
 460         { 0x9104, 0x00 },
 461         { 0x4648, 0x7F },
 462         { 0x7420, 0x00 },
 463         { 0x7421, 0x1C },
 464         { 0x7422, 0x00 },
 465         { 0x7423, 0xD7 },
 466         { 0x5F04, 0x00 },
 467         { 0x5F05, 0xED },
 468         { 0x0112, 0x0A },
 469         { 0x0113, 0x0A },
 470         { 0x0342, 0x14 },
 471         { 0x0343, 0xE8 },
 472         { 0x0344, 0x00 },
 473         { 0x0345, 0x00 },
 474         { 0x0346, 0x00 },
 475         { 0x0347, 0x00 },
 476         { 0x0348, 0x10 },
 477         { 0x0349, 0x6F },
 478         { 0x034A, 0x0C },
 479         { 0x034B, 0x2F },
 480         { 0x0381, 0x01 },
 481         { 0x0383, 0x01 },
 482         { 0x0385, 0x01 },
 483         { 0x0387, 0x01 },
 484         { 0x0900, 0x01 },
 485         { 0x0901, 0x12 },
 486         { 0x0401, 0x01 },
 487         { 0x0404, 0x00 },
 488         { 0x0405, 0x20 },
 489         { 0x0408, 0x00 },
 490         { 0x0409, 0x00 },
 491         { 0x040A, 0x00 },
 492         { 0x040B, 0x00 },
 493         { 0x040C, 0x10 },
 494         { 0x040D, 0x70 },
 495         { 0x040E, 0x06 },
 496         { 0x040F, 0x18 },
 497         { 0x3038, 0x00 },
 498         { 0x303A, 0x00 },
 499         { 0x303B, 0x10 },
 500         { 0x300D, 0x00 },
 501         { 0x034C, 0x08 },
 502         { 0x034D, 0x38 },
 503         { 0x034E, 0x06 },
 504         { 0x034F, 0x18 },
 505         { 0x0350, 0x00 },
 506         { 0x0204, 0x00 },
 507         { 0x0205, 0x00 },
 508         { 0x020E, 0x01 },
 509         { 0x020F, 0x00 },
 510         { 0x0210, 0x01 },
 511         { 0x0211, 0x00 },
 512         { 0x0212, 0x01 },
 513         { 0x0213, 0x00 },
 514         { 0x0214, 0x01 },
 515         { 0x0215, 0x00 },
 516         { 0x7BCD, 0x01 },
 517         { 0x94DC, 0x20 },
 518         { 0x94DD, 0x20 },
 519         { 0x94DE, 0x20 },
 520         { 0x95DC, 0x20 },
 521         { 0x95DD, 0x20 },
 522         { 0x95DE, 0x20 },
 523         { 0x7FB0, 0x00 },
 524         { 0x9010, 0x3E },
 525         { 0x9419, 0x50 },
 526         { 0x941B, 0x50 },
 527         { 0x9519, 0x50 },
 528         { 0x951B, 0x50 },
 529         { 0x3030, 0x00 },
 530         { 0x3032, 0x00 },
 531         { 0x0220, 0x00 },
 532 };
 533
 534 static const struct imx258_reg mode_1048_780_regs[] = {
 535         { 0x3051, 0x00 },
 536         { 0x3052, 0x00 },
 537         { 0x4E21, 0x14 },
 538         { 0x6B11, 0xCF },
 539         { 0x7FF0, 0x08 },
 540         { 0x7FF1, 0x0F },
 541         { 0x7FF2, 0x08 },
 542         { 0x7FF3, 0x1B },
 543         { 0x7FF4, 0x23 },
 544         { 0x7FF5, 0x60 },
 545         { 0x7FF6, 0x00 },
 546         { 0x7FF7, 0x01 },
 547         { 0x7FF8, 0x00 },
 548         { 0x7FF9, 0x78 },
 549         { 0x7FFA, 0x00 },
 550         { 0x7FFB, 0x00 },
 551         { 0x7FFC, 0x00 },
 552         { 0x7FFD, 0x00 },
 553         { 0x7FFE, 0x00 },
 554         { 0x7FFF, 0x03 },
 555         { 0x7F76, 0x03 },
 556         { 0x7F77, 0xFE },
 557         { 0x7FA8, 0x03 },
 558         { 0x7FA9, 0xFE },
 559         { 0x7B24, 0x81 },
 560         { 0x7B25, 0x00 },
 561         { 0x6564, 0x07 },
 562         { 0x6B0D, 0x41 },
 563         { 0x653D, 0x04 },
 564         { 0x6B05, 0x8C },
 565         { 0x6B06, 0xF9 },
 566         { 0x6B08, 0x65 },
 567         { 0x6B09, 0xFC },
 568         { 0x6B0A, 0xCF },
 569         { 0x6B0B, 0xD2 },
 570         { 0x6700, 0x0E },
 571         { 0x6707, 0x0E },
 572         { 0x9104, 0x00 },
 573         { 0x4648, 0x7F },
 574         { 0x7420, 0x00 },
 575         { 0x7421, 0x1C },
 576         { 0x7422, 0x00 },
 577         { 0x7423, 0xD7 },
 578         { 0x5F04, 0x00 },
 579         { 0x5F05, 0xED },
 580         { 0x0112, 0x0A },
 581         { 0x0113, 0x0A },
 582         { 0x0342, 0x14 },
 583         { 0x0343, 0xE8 },
 584         { 0x0344, 0x00 },
 585         { 0x0345, 0x00 },
 586         { 0x0346, 0x00 },
 587         { 0x0347, 0x00 },
 588         { 0x0348, 0x10 },
 589         { 0x0349, 0x6F },
 590         { 0x034A, 0x0C },
 591         { 0x034B, 0x2F },
 592         { 0x0381, 0x01 },
 593         { 0x0383, 0x01 },
 594         { 0x0385, 0x01 },
 595         { 0x0387, 0x01 },
 596         { 0x0900, 0x01 },
 597         { 0x0901, 0x14 },
 598         { 0x0401, 0x01 },
 599         { 0x0404, 0x00 },
 600         { 0x0405, 0x40 },
 601         { 0x0408, 0x00 },
 602         { 0x0409, 0x00 },
 603         { 0x040A, 0x00 },
 604         { 0x040B, 0x00 },
 605         { 0x040C, 0x10 },
 606         { 0x040D, 0x70 },
 607         { 0x040E, 0x03 },
 608         { 0x040F, 0x0C },
 609         { 0x3038, 0x00 },
 610         { 0x303A, 0x00 },
 611         { 0x303B, 0x10 },
 612         { 0x300D, 0x00 },
 613         { 0x034C, 0x04 },
 614         { 0x034D, 0x18 },
 615         { 0x034E, 0x03 },
 616         { 0x034F, 0x0C },
 617         { 0x0350, 0x00 },
 618         { 0x0204, 0x00 },
 619         { 0x0205, 0x00 },
 620         { 0x020E, 0x01 },
 621         { 0x020F, 0x00 },
 622         { 0x0210, 0x01 },
 623         { 0x0211, 0x00 },
 624         { 0x0212, 0x01 },
 625         { 0x0213, 0x00 },
 626         { 0x0214, 0x01 },
 627         { 0x0215, 0x00 },
 628         { 0x7BCD, 0x00 },
 629         { 0x94DC, 0x20 },
 630         { 0x94DD, 0x20 },
 631         { 0x94DE, 0x20 },
 632         { 0x95DC, 0x20 },
 633         { 0x95DD, 0x20 },
 634         { 0x95DE, 0x20 },
 635         { 0x7FB0, 0x00 },
 636         { 0x9010, 0x3E },
 637         { 0x9419, 0x50 },
 638         { 0x941B, 0x50 },
 639         { 0x9519, 0x50 },
 640         { 0x951B, 0x50 },
 641         { 0x3030, 0x00 },
 642         { 0x3032, 0x00 },
 643         { 0x0220, 0x00 },
 644 };
 645
 646 static const char * const imx258_test_pattern_menu[] = {
 647         "Disabled",
 648         "Solid Colour",
 649         "Eight Vertical Colour Bars",
 650         "Colour Bars With Fade to Grey",
 651         "Pseudorandom Sequence (PN9)",
 652 };
 653
 654 /* regulator supplies */
 655 static const char * const imx258_supply_name[] = {
 656         /* Supplies can be enabled in any order */
 657         "vana",  /* Analog (2.8V) supply */
 658         "vdig",  /* Digital Core (1.05V) supply */
 659         "vif",  /* IF (1.8V) supply */
 660 };
 661
 662 #define IMX258_NUM_SUPPLIES ARRAY_SIZE(imx258_supply_name)
 663
 664 enum {
 665         IMX258_LINK_FREQ_1267MBPS,
 666         IMX258_LINK_FREQ_640MBPS,
 667 };
 668
 669 /*
 670  * pixel_rate = link_freq * data-rate * nr_of_lanes / bits_per_sample
 671  * data rate => double data rate;
 672  * number of lanes => (configurable 2 or 4);
 673  * bits per pixel => 10
 674  */
 675 static u64 link_freq_to_pixel_rate(u64 f, unsigned int nlanes)
 676 {
 677         f *= 2 * nlanes;
 678         do_div(f, 10);
 679
 680         return f;
 681 }
 682
 683 /* Menu items for LINK_FREQ V4L2 control */
 684 /* Configurations for supported link frequencies */
 685 #define IMX258_LINK_FREQ_634MHZ 633600000ULL
 686 #define IMX258_LINK_FREQ_320MHZ 320000000ULL
 687
 688 static const s64 link_freq_menu_items_19_2[] = {
 689         IMX258_LINK_FREQ_634MHZ,
 690         IMX258_LINK_FREQ_320MHZ,
 691 };
 692
 693 /* Configurations for supported link frequencies */
 694 #define IMX258_LINK_FREQ_636MHZ 636000000ULL
 695 #define IMX258_LINK_FREQ_321MHZ 321000000ULL
 696
 697 static const s64 link_freq_menu_items_24[] = {
 698         IMX258_LINK_FREQ_636MHZ,
 699         IMX258_LINK_FREQ_321MHZ,
 700 };
 701
 702 /* Link frequency configs */
 703 static const struct imx258_link_freq_config link_freq_configs_19_2[] = {
 704         [IMX258_LINK_FREQ_1267MBPS] = {
 705                 .pixels_per_line = IMX258_PPL_DEFAULT,
 706                 .reg_list = {
 707                         [IMX258_2_LANE_MODE] = {
 708                                 .num_of_regs = ARRAY_SIZE(mipi_1267mbps_19_2mhz_2l),
 709                                 .regs = mipi_1267mbps_19_2mhz_2l,
 710                         },
 711                         [IMX258_4_LANE_MODE] = {
 712                                 .num_of_regs = ARRAY_SIZE(mipi_1267mbps_19_2mhz_4l),
 713                                 .regs = mipi_1267mbps_19_2mhz_4l,
 714                         },
 715                 }
 716         },
 717         [IMX258_LINK_FREQ_640MBPS] = {
 718                 .pixels_per_line = IMX258_PPL_DEFAULT,
 719                 .reg_list = {
 720                         [IMX258_2_LANE_MODE] = {
 721                                 .num_of_regs = ARRAY_SIZE(mipi_640mbps_19_2mhz_2l),
 722                                 .regs = mipi_640mbps_19_2mhz_2l,
 723                         },
 724                         [IMX258_4_LANE_MODE] = {
 725                                 .num_of_regs = ARRAY_SIZE(mipi_640mbps_19_2mhz_4l),
 726                                 .regs = mipi_640mbps_19_2mhz_4l,
 727                         },
 728                 }
 729         },
 730 };
 731
 732 static const struct imx258_link_freq_config link_freq_configs_24[] = {
 733         [IMX258_LINK_FREQ_1267MBPS] = {
 734                 .pixels_per_line = IMX258_PPL_DEFAULT,
 735                 .reg_list = {
 736                         [IMX258_2_LANE_MODE] = {
 737                                 .num_of_regs = ARRAY_SIZE(mipi_1272mbps_24mhz_2l),
 738                                 .regs = mipi_1272mbps_24mhz_2l,
 739                         },
 740                         [IMX258_4_LANE_MODE] = {
 741                                 .num_of_regs = ARRAY_SIZE(mipi_1272mbps_24mhz_4l),
 742                                 .regs = mipi_1272mbps_24mhz_4l,
 743                         },
 744                 }
 745         },
 746         [IMX258_LINK_FREQ_640MBPS] = {
 747                 .pixels_per_line = IMX258_PPL_DEFAULT,
 748                 .reg_list = {
 749                         [IMX258_2_LANE_MODE] = {
 750                                 .num_of_regs = ARRAY_SIZE(mipi_642mbps_24mhz_2l),
 751                                 .regs = mipi_642mbps_24mhz_2l,
 752                         },
 753                         [IMX258_4_LANE_MODE] = {
 754                                 .num_of_regs = ARRAY_SIZE(mipi_642mbps_24mhz_4l),
 755                                 .regs = mipi_642mbps_24mhz_4l,
 756                         },
 757                 }
 758         },
 759 };
 760
 761 /* Mode configs */
 762 static const struct imx258_mode supported_modes[] = {
 763         {
 764                 .width = 4208,
 765                 .height = 3120,
 766                 .vts_def = IMX258_VTS_30FPS,
 767                 .vts_min = IMX258_VTS_30FPS,
 768                 .reg_list = {
 769                         .num_of_regs = ARRAY_SIZE(mode_4208x3120_regs),
 770                         .regs = mode_4208x3120_regs,
 771                 },
 772                 .link_freq_index = IMX258_LINK_FREQ_1267MBPS,
 773                 .crop = {
 774                         .left = IMX258_PIXEL_ARRAY_LEFT,
 775                         .top = IMX258_PIXEL_ARRAY_TOP,
 776                         .width = 4208,
 777                         .height = 3120,
 778                 },
 779         },
 780         {
 781                 .width = 2104,
 782                 .height = 1560,
 783                 .vts_def = IMX258_VTS_30FPS_2K,
 784                 .vts_min = IMX258_VTS_30FPS_2K,
 785                 .reg_list = {
 786                         .num_of_regs = ARRAY_SIZE(mode_2104_1560_regs),
 787                         .regs = mode_2104_1560_regs,
 788                 },
 789                 .link_freq_index = IMX258_LINK_FREQ_640MBPS,
 790                 .crop = {
 791                         .left = IMX258_PIXEL_ARRAY_LEFT,
 792                         .top = IMX258_PIXEL_ARRAY_TOP,
 793                         .width = 4208,
 794                         .height = 3120,
 795                 },
 796         },
 797         {
 798                 .width = 1048,
 799                 .height = 780,
 800                 .vts_def = IMX258_VTS_30FPS_VGA,
 801                 .vts_min = IMX258_VTS_30FPS_VGA,
 802                 .reg_list = {
 803                         .num_of_regs = ARRAY_SIZE(mode_1048_780_regs),
 804                         .regs = mode_1048_780_regs,
 805                 },
 806                 .link_freq_index = IMX258_LINK_FREQ_640MBPS,
 807                 .crop = {
 808                         .left = IMX258_PIXEL_ARRAY_LEFT,
 809                         .top = IMX258_PIXEL_ARRAY_TOP,
 810                         .width = 4208,
 811                         .height = 3120,
 812                 },
 813         },
 814 };
 815
 816 struct imx258 {
 817         struct v4l2_subdev sd;
 818         struct media_pad pad;
 819
 820         struct v4l2_ctrl_handler ctrl_handler;
 821         /* V4L2 Controls */
 822         struct v4l2_ctrl *link_freq;
 823         struct v4l2_ctrl *pixel_rate;
 824         struct v4l2_ctrl *vblank;
 825         struct v4l2_ctrl *hblank;
 826         struct v4l2_ctrl *exposure;
 827
 828         /* Current mode */
 829         const struct imx258_mode *cur_mode;
 830
 831         const struct imx258_link_freq_config *link_freq_configs;
 832         const s64 *link_freq_menu_items;
 833         unsigned int nlanes;
 834         unsigned int csi2_flags;
 835
 836         /*
 837          * Mutex for serialized access:
 838          * Protect sensor module set pad format and start/stop streaming safely.
 839          */
 840         struct mutex mutex;
 841
 842         /* Streaming on/off */
 843         bool streaming;
 844
 845         struct clk *clk;
 846         struct regulator_bulk_data supplies[IMX258_NUM_SUPPLIES];
 847 };
 848
 849 static inline struct imx258 *to_imx258(struct v4l2_subdev *_sd)
 850 {
 851         return container_of(_sd, struct imx258, sd);
 852 }
 853
 854 /* Read registers up to 2 at a time */
 855 static int imx258_read_reg(struct imx258 *imx258, u16 reg, u32 len, u32 *val)
 856 {
 857         struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
 858         struct i2c_msg msgs[2];
 859         u8 addr_buf[2] = { reg >> 8, reg & 0xff };
 860         u8 data_buf[4] = { 0, };
 861         int ret;
 862
 863         if (len > 4)
 864                 return -EINVAL;
 865
 866         /* Write register address */
 867         msgs[0].addr = client->addr;
 868         msgs[0].flags = 0;
 869         msgs[0].len = ARRAY_SIZE(addr_buf);
 870         msgs[0].buf = addr_buf;
 871
 872         /* Read data from register */
 873         msgs[1].addr = client->addr;
 874         msgs[1].flags = I2C_M_RD;
 875         msgs[1].len = len;
 876         msgs[1].buf = &data_buf[4 - len];
 877
 878         ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 879         if (ret != ARRAY_SIZE(msgs))
 880                 return -EIO;
 881
 882         *val = get_unaligned_be32(data_buf);
 883
 884         return 0;
 885 }
 886
 887 /* Write registers up to 2 at a time */
 888 static int imx258_write_reg(struct imx258 *imx258, u16 reg, u32 len, u32 val)
 889 {
 890         struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
 891         u8 buf[6];
 892
 893         if (len > 4)
 894                 return -EINVAL;
 895
 896         put_unaligned_be16(reg, buf);
 897         put_unaligned_be32(val << (8 * (4 - len)), buf + 2);
 898         if (i2c_master_send(client, buf, len + 2) != len + 2)
 899                 return -EIO;
 900
 901         return 0;
 902 }
 903
 904 /* Write a list of registers */
 905 static int imx258_write_regs(struct imx258 *imx258,
 906                              const struct imx258_reg *regs, u32 len)
 907 {
 908         struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
 909         unsigned int i;
 910         int ret;
 911
 912         for (i = 0; i < len; i++) {
 913                 ret = imx258_write_reg(imx258, regs[i].address, 1,
 914                                         regs[i].val);
 915                 if (ret) {
 916                         dev_err_ratelimited(
 917                                 &client->dev,
 918                                 "Failed to write reg 0x%4.4x. error = %d\n",
 919                                 regs[i].address, ret);
 920
 921                         return ret;
 922                 }
 923         }
 924
 925         return 0;
 926 }
 927
 928 /* Open sub-device */
 929 static int imx258_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
 930 {
 931         struct v4l2_mbus_framefmt *try_fmt =
 932                 v4l2_subdev_get_try_format(sd, fh->state, 0);
 933         struct v4l2_rect *try_crop;
 934
 935         /* Initialize try_fmt */
 936         try_fmt->width = supported_modes[0].width;
 937         try_fmt->height = supported_modes[0].height;
 938         try_fmt->code = MEDIA_BUS_FMT_SBGGR10_1X10;
 939         try_fmt->field = V4L2_FIELD_NONE;
 940
 941         /* Initialize try_crop */
 942         try_crop = v4l2_subdev_get_try_crop(sd, fh->state, 0);
 943         try_crop->left = IMX258_PIXEL_ARRAY_LEFT;
 944         try_crop->top = IMX258_PIXEL_ARRAY_TOP;
 945         try_crop->width = IMX258_PIXEL_ARRAY_WIDTH;
 946         try_crop->height = IMX258_PIXEL_ARRAY_HEIGHT;
 947
 948         return 0;
 949 }
 950
 951 static int imx258_update_digital_gain(struct imx258 *imx258, u32 len, u32 val)
 952 {
 953         int ret;
 954
 955         ret = imx258_write_reg(imx258, IMX258_REG_GR_DIGITAL_GAIN,
 956                                 IMX258_REG_VALUE_16BIT,
 957                                 val);
 958         if (ret)
 959                 return ret;
 960         ret = imx258_write_reg(imx258, IMX258_REG_GB_DIGITAL_GAIN,
 961                                 IMX258_REG_VALUE_16BIT,
 962                                 val);
 963         if (ret)
 964                 return ret;
 965         ret = imx258_write_reg(imx258, IMX258_REG_R_DIGITAL_GAIN,
 966                                 IMX258_REG_VALUE_16BIT,
 967                                 val);
 968         if (ret)
 969                 return ret;
 970         ret = imx258_write_reg(imx258, IMX258_REG_B_DIGITAL_GAIN,
 971                                 IMX258_REG_VALUE_16BIT,
 972                                 val);
 973         if (ret)
 974                 return ret;
 975         return 0;
 976 }
 977
 978 static void imx258_adjust_exposure_range(struct imx258 *imx258)
 979 {
 980         int exposure_max, exposure_def;
 981
 982         /* Honour the VBLANK limits when setting exposure. */
 983         exposure_max = imx258->cur_mode->height + imx258->vblank->val -
 984                        IMX258_EXPOSURE_OFFSET;
 985         exposure_def = min(exposure_max, imx258->exposure->val);
 986         __v4l2_ctrl_modify_range(imx258->exposure, imx258->exposure->minimum,
 987                                  exposure_max, imx258->exposure->step,
 988                                  exposure_def);
 989 }
 990
 991 static int imx258_set_ctrl(struct v4l2_ctrl *ctrl)
 992 {
 993         struct imx258 *imx258 =
 994                 container_of(ctrl->handler, struct imx258, ctrl_handler);
 995         struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
 996         int ret = 0;
 997
 998         /*
 999          * The VBLANK control may change the limits of usable exposure, so check
1000          * and adjust if necessary.
1001          */
1002         if (ctrl->id == V4L2_CID_VBLANK)
1003                 imx258_adjust_exposure_range(imx258);
1004
1005         /*
1006          * Applying V4L2 control value only happens
1007          * when power is up for streaming
1008          */
1009         if (pm_runtime_get_if_in_use(&client->dev) == 0)
1010                 return 0;
1011
1012         switch (ctrl->id) {
1013         case V4L2_CID_ANALOGUE_GAIN:
1014                 ret = imx258_write_reg(imx258, IMX258_REG_ANALOG_GAIN,
1015                                 IMX258_REG_VALUE_16BIT,
1016                                 ctrl->val);
1017                 break;
1018         case V4L2_CID_EXPOSURE:
1019                 ret = imx258_write_reg(imx258, IMX258_REG_EXPOSURE,
1020                                 IMX258_REG_VALUE_16BIT,
1021                                 ctrl->val);
1022                 break;
1023         case V4L2_CID_DIGITAL_GAIN:
1024                 ret = imx258_update_digital_gain(imx258, IMX258_REG_VALUE_16BIT,
1025                                 ctrl->val);
1026                 break;
1027         case V4L2_CID_TEST_PATTERN:
1028                 ret = imx258_write_reg(imx258, IMX258_REG_TEST_PATTERN,
1029                                 IMX258_REG_VALUE_16BIT,
1030                                 ctrl->val);
1031                 ret = imx258_write_reg(imx258, REG_MIRROR_FLIP_CONTROL,
1032                                 IMX258_REG_VALUE_08BIT,
1033                                 !ctrl->val ? REG_CONFIG_MIRROR_FLIP :
1034                                 REG_CONFIG_FLIP_TEST_PATTERN);
1035                 break;
1036         case V4L2_CID_WIDE_DYNAMIC_RANGE:
1037                 if (!ctrl->val) {
1038                         ret = imx258_write_reg(imx258, IMX258_REG_HDR,
1039                                                IMX258_REG_VALUE_08BIT,
1040                                                IMX258_HDR_RATIO_MIN);
1041                 } else {
1042                         ret = imx258_write_reg(imx258, IMX258_REG_HDR,
1043                                                IMX258_REG_VALUE_08BIT,
1044                                                IMX258_HDR_ON);
1045                         if (ret)
1046                                 break;
1047                         ret = imx258_write_reg(imx258, IMX258_REG_HDR_RATIO,
1048                                                IMX258_REG_VALUE_08BIT,
1049                                                BIT(IMX258_HDR_RATIO_MAX));
1050                 }
1051                 break;
1052         case V4L2_CID_VBLANK:
1053                 ret = imx258_write_reg(imx258, IMX258_REG_VTS,
1054                                        IMX258_REG_VALUE_16BIT,
1055                                        imx258->cur_mode->height + ctrl->val);
1056                 break;
1057         default:
1058                 dev_info(&client->dev,
1059                          "ctrl(id:0x%x,val:0x%x) is not handled\n",
1060                          ctrl->id, ctrl->val);
1061                 ret = -EINVAL;
1062                 break;
1063         }
1064
1065         pm_runtime_put(&client->dev);
1066
1067         return ret;
1068 }
1069
1070 static const struct v4l2_ctrl_ops imx258_ctrl_ops = {
1071         .s_ctrl = imx258_set_ctrl,
1072 };
1073
1074 static int imx258_enum_mbus_code(struct v4l2_subdev *sd,
1075                                   struct v4l2_subdev_state *sd_state,
1076                                   struct v4l2_subdev_mbus_code_enum *code)
1077 {
1078         /* Only one bayer order(GRBG) is supported */
1079         if (code->index > 0)
1080                 return -EINVAL;
1081
1082         code->code = MEDIA_BUS_FMT_SBGGR10_1X10;
1083
1084         return 0;
1085 }
1086
1087 static int imx258_enum_frame_size(struct v4l2_subdev *sd,
1088                                   struct v4l2_subdev_state *sd_state,
1089                                   struct v4l2_subdev_frame_size_enum *fse)
1090 {
1091         if (fse->index >= ARRAY_SIZE(supported_modes))
1092                 return -EINVAL;
1093
1094         if (fse->code != MEDIA_BUS_FMT_SBGGR10_1X10)
1095                 return -EINVAL;
1096
1097         fse->min_width = supported_modes[fse->index].width;
1098         fse->max_width = fse->min_width;
1099         fse->min_height = supported_modes[fse->index].height;
1100         fse->max_height = fse->min_height;
1101
1102         return 0;
1103 }
1104
1105 static void imx258_update_pad_format(const struct imx258_mode *mode,
1106                                      struct v4l2_subdev_format *fmt)
1107 {
1108         fmt->format.width = mode->width;
1109         fmt->format.height = mode->height;
1110         fmt->format.code = MEDIA_BUS_FMT_SBGGR10_1X10;
1111         fmt->format.field = V4L2_FIELD_NONE;
1112 }
1113
1114 static int __imx258_get_pad_format(struct imx258 *imx258,
1115                                    struct v4l2_subdev_state *sd_state,
1116                                    struct v4l2_subdev_format *fmt)
1117 {
1118         if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
1119                 fmt->format = *v4l2_subdev_get_try_format(&imx258->sd,
1120                                                           sd_state,
1121                                                           fmt->pad);
1122         else
1123                 imx258_update_pad_format(imx258->cur_mode, fmt);
1124
1125         return 0;
1126 }
1127
1128 static int imx258_get_pad_format(struct v4l2_subdev *sd,
1129                                  struct v4l2_subdev_state *sd_state,
1130                                  struct v4l2_subdev_format *fmt)
1131 {
1132         struct imx258 *imx258 = to_imx258(sd);
1133         int ret;
1134
1135         mutex_lock(&imx258->mutex);
1136         ret = __imx258_get_pad_format(imx258, sd_state, fmt);
1137         mutex_unlock(&imx258->mutex);
1138
1139         return ret;
1140 }
1141
1142 static int imx258_set_pad_format(struct v4l2_subdev *sd,
1143                                  struct v4l2_subdev_state *sd_state,
1144                                  struct v4l2_subdev_format *fmt)
1145 {
1146         struct imx258 *imx258 = to_imx258(sd);
1147         const struct imx258_mode *mode;
1148         struct v4l2_mbus_framefmt *framefmt;
1149         s32 vblank_def;
1150         s32 vblank_min;
1151         s64 h_blank;
1152         s64 pixel_rate;
1153         s64 link_freq;
1154
1155         mutex_lock(&imx258->mutex);
1156
1157         /* Only one raw bayer(GBRG) order is supported */
1158         fmt->format.code = MEDIA_BUS_FMT_SBGGR10_1X10;
1159
1160         mode = v4l2_find_nearest_size(supported_modes,
1161                 ARRAY_SIZE(supported_modes), width, height,
1162                 fmt->format.width, fmt->format.height);
1163         imx258_update_pad_format(mode, fmt);
1164         if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
1165                 framefmt = v4l2_subdev_get_try_format(sd, sd_state, fmt->pad);
1166                 *framefmt = fmt->format;
1167         } else {
1168                 imx258->cur_mode = mode;
1169                 __v4l2_ctrl_s_ctrl(imx258->link_freq, mode->link_freq_index);
1170
1171                 link_freq = imx258->link_freq_menu_items[mode->link_freq_index];
1172                 pixel_rate = link_freq_to_pixel_rate(link_freq, imx258->nlanes);
1173                 __v4l2_ctrl_s_ctrl_int64(imx258->pixel_rate, pixel_rate);
1174                 /* Update limits and set FPS to default */
1175                 vblank_def = imx258->cur_mode->vts_def -
1176                              imx258->cur_mode->height;
1177                 vblank_min = imx258->cur_mode->vts_min -
1178                              imx258->cur_mode->height;
1179                 __v4l2_ctrl_modify_range(
1180                         imx258->vblank, vblank_min,
1181                         IMX258_VTS_MAX - imx258->cur_mode->height, 1,
1182                         vblank_def);
1183                 __v4l2_ctrl_s_ctrl(imx258->vblank, vblank_def);
1184                 h_blank =
1185                         imx258->link_freq_configs[mode->link_freq_index].pixels_per_line
1186                          - imx258->cur_mode->width;
1187                 __v4l2_ctrl_modify_range(imx258->hblank, h_blank,
1188                                          h_blank, 1, h_blank);
1189         }
1190
1191         mutex_unlock(&imx258->mutex);
1192
1193         return 0;
1194 }
1195
1196 static const struct v4l2_rect *
1197 __imx258_get_pad_crop(struct imx258 *imx258,
1198                       struct v4l2_subdev_state *sd_state,
1199                       unsigned int pad, enum v4l2_subdev_format_whence which)
1200 {
1201         switch (which) {
1202         case V4L2_SUBDEV_FORMAT_TRY:
1203                 return v4l2_subdev_get_try_crop(&imx258->sd, sd_state, pad);
1204         case V4L2_SUBDEV_FORMAT_ACTIVE:
1205                 return &imx258->cur_mode->crop;
1206         }
1207
1208         return NULL;
1209 }
1210
1211 static int imx258_get_selection(struct v4l2_subdev *sd,
1212                                 struct v4l2_subdev_state *sd_state,
1213                                 struct v4l2_subdev_selection *sel)
1214 {
1215         switch (sel->target) {
1216         case V4L2_SEL_TGT_CROP: {
1217                 struct imx258 *imx258 = to_imx258(sd);
1218
1219                 mutex_lock(&imx258->mutex);
1220                 sel->r = *__imx258_get_pad_crop(imx258, sd_state, sel->pad,
1221                                                 sel->which);
1222                 mutex_unlock(&imx258->mutex);
1223
1224                 return 0;
1225         }
1226
1227         case V4L2_SEL_TGT_NATIVE_SIZE:
1228                 sel->r.left = 0;
1229                 sel->r.top = 0;
1230                 sel->r.width = IMX258_NATIVE_WIDTH;
1231                 sel->r.height = IMX258_NATIVE_HEIGHT;
1232
1233                 return 0;
1234
1235         case V4L2_SEL_TGT_CROP_DEFAULT:
1236         case V4L2_SEL_TGT_CROP_BOUNDS:
1237                 sel->r.left = IMX258_PIXEL_ARRAY_LEFT;
1238                 sel->r.top = IMX258_PIXEL_ARRAY_TOP;
1239                 sel->r.width = IMX258_PIXEL_ARRAY_WIDTH;
1240                 sel->r.height = IMX258_PIXEL_ARRAY_HEIGHT;
1241
1242                 return 0;
1243         }
1244
1245         return -EINVAL;
1246 }
1247
1248 /* Start streaming */
1249 static int imx258_start_streaming(struct imx258 *imx258)
1250 {
1251         struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
1252         const struct imx258_reg_list *reg_list;
1253         const struct imx258_link_freq_config *link_freq_cfg;
1254         int ret, link_freq_index;
1255
1256         /* Setup PLL */
1257         link_freq_index = imx258->cur_mode->link_freq_index;
1258         link_freq_cfg = &imx258->link_freq_configs[link_freq_index];
1259         reg_list = &link_freq_cfg->reg_list[imx258->nlanes == 2 ? 0 : 1];
1260         ret = imx258_write_regs(imx258, reg_list->regs, reg_list->num_of_regs);
1261         if (ret) {
1262                 dev_err(&client->dev, "%s failed to set plls\n", __func__);
1263                 return ret;
1264         }
1265
1266         ret = imx258_write_reg(imx258, IMX258_CLK_BLANK_STOP,
1267                                IMX258_REG_VALUE_08BIT,
1268                                imx258->csi2_flags & V4L2_MBUS_CSI2_NONCONTINUOUS_CLOCK ?
1269                                1 : 0);
1270         if (ret) {
1271                 dev_err(&client->dev, "%s failed to set clock lane mode\n", __func__);
1272                 return ret;
1273         }
1274
1275         /* Apply default values of current mode */
1276         reg_list = &imx258->cur_mode->reg_list;
1277         ret = imx258_write_regs(imx258, reg_list->regs, reg_list->num_of_regs);
1278         if (ret) {
1279                 dev_err(&client->dev, "%s failed to set mode\n", __func__);
1280                 return ret;
1281         }
1282
1283         /* Set Orientation be 180 degree */
1284         ret = imx258_write_reg(imx258, REG_MIRROR_FLIP_CONTROL,
1285                                IMX258_REG_VALUE_08BIT, REG_CONFIG_MIRROR_FLIP);
1286         if (ret) {
1287                 dev_err(&client->dev, "%s failed to set orientation\n",
1288                         __func__);
1289                 return ret;
1290         }
1291
1292         /* Apply customized values from user */
1293         ret =  __v4l2_ctrl_handler_setup(imx258->sd.ctrl_handler);
1294         if (ret)
1295                 return ret;
1296
1297         /* set stream on register */
1298         return imx258_write_reg(imx258, IMX258_REG_MODE_SELECT,
1299                                 IMX258_REG_VALUE_08BIT,
1300                                 IMX258_MODE_STREAMING);
1301 }
1302
1303 /* Stop streaming */
1304 static int imx258_stop_streaming(struct imx258 *imx258)
1305 {
1306         struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
1307         int ret;
1308
1309         /* set stream off register */
1310         ret = imx258_write_reg(imx258, IMX258_REG_MODE_SELECT,
1311                 IMX258_REG_VALUE_08BIT, IMX258_MODE_STANDBY);
1312         if (ret)
1313                 dev_err(&client->dev, "%s failed to set stream\n", __func__);
1314
1315         /*
1316          * Return success even if it was an error, as there is nothing the
1317          * caller can do about it.
1318          */
1319         return 0;
1320 }
1321
1322 static int imx258_power_on(struct device *dev)
1323 {
1324         struct v4l2_subdev *sd = dev_get_drvdata(dev);
1325         struct imx258 *imx258 = to_imx258(sd);
1326         int ret;
1327
1328         ret = regulator_bulk_enable(IMX258_NUM_SUPPLIES,
1329                                     imx258->supplies);
1330         if (ret) {
1331                 dev_err(dev, "%s: failed to enable regulators\n",
1332                         __func__);
1333                 return ret;
1334         }
1335
1336         ret = clk_prepare_enable(imx258->clk);
1337         if (ret) {
1338                 dev_err(dev, "failed to enable clock\n");
1339                 regulator_bulk_disable(IMX258_NUM_SUPPLIES, imx258->supplies);
1340         }
1341
1342         return ret;
1343 }
1344
1345 static int imx258_power_off(struct device *dev)
1346 {
1347         struct v4l2_subdev *sd = dev_get_drvdata(dev);
1348         struct imx258 *imx258 = to_imx258(sd);
1349
1350         clk_disable_unprepare(imx258->clk);
1351         regulator_bulk_disable(IMX258_NUM_SUPPLIES, imx258->supplies);
1352
1353         return 0;
1354 }
1355
1356 static int imx258_set_stream(struct v4l2_subdev *sd, int enable)
1357 {
1358         struct imx258 *imx258 = to_imx258(sd);
1359         struct i2c_client *client = v4l2_get_subdevdata(sd);
1360         int ret = 0;
1361
1362         mutex_lock(&imx258->mutex);
1363         if (imx258->streaming == enable) {
1364                 mutex_unlock(&imx258->mutex);
1365                 return 0;
1366         }
1367
1368         if (enable) {
1369                 ret = pm_runtime_resume_and_get(&client->dev);
1370                 if (ret < 0)
1371                         goto err_unlock;
1372
1373                 /*
1374                  * Apply default & customized values
1375                  * and then start streaming.
1376                  */
1377                 ret = imx258_start_streaming(imx258);
1378                 if (ret)
1379                         goto err_rpm_put;
1380         } else {
1381                 imx258_stop_streaming(imx258);
1382                 pm_runtime_put(&client->dev);
1383         }
1384
1385         imx258->streaming = enable;
1386         mutex_unlock(&imx258->mutex);
1387
1388         return ret;
1389
1390 err_rpm_put:
1391         pm_runtime_put(&client->dev);
1392 err_unlock:
1393         mutex_unlock(&imx258->mutex);
1394
1395         return ret;
1396 }
1397
1398 static int __maybe_unused imx258_suspend(struct device *dev)
1399 {
1400         struct v4l2_subdev *sd = dev_get_drvdata(dev);
1401         struct imx258 *imx258 = to_imx258(sd);
1402
1403         if (imx258->streaming)
1404                 imx258_stop_streaming(imx258);
1405
1406         return 0;
1407 }
1408
1409 static int __maybe_unused imx258_resume(struct device *dev)
1410 {
1411         struct v4l2_subdev *sd = dev_get_drvdata(dev);
1412         struct imx258 *imx258 = to_imx258(sd);
1413         int ret;
1414
1415         if (imx258->streaming) {
1416                 ret = imx258_start_streaming(imx258);
1417                 if (ret)
1418                         goto error;
1419         }
1420
1421         return 0;
1422
1423 error:
1424         imx258_stop_streaming(imx258);
1425         imx258->streaming = 0;
1426         return ret;
1427 }
1428
1429 /* Verify chip ID */
1430 static int imx258_identify_module(struct imx258 *imx258)
1431 {
1432         struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
1433         int ret;
1434         u32 val;
1435
1436         ret = imx258_read_reg(imx258, IMX258_REG_CHIP_ID,
1437                               IMX258_REG_VALUE_16BIT, &val);
1438         if (ret) {
1439                 dev_err(&client->dev, "failed to read chip id %x\n",
1440                         IMX258_CHIP_ID);
1441                 return ret;
1442         }
1443
1444         if (val != IMX258_CHIP_ID) {
1445                 dev_err(&client->dev, "chip id mismatch: %x!=%x\n",
1446                         IMX258_CHIP_ID, val);
1447                 return -EIO;
1448         }
1449
1450         return 0;
1451 }
1452
1453 static const struct v4l2_subdev_video_ops imx258_video_ops = {
1454         .s_stream = imx258_set_stream,
1455 };
1456
1457 static const struct v4l2_subdev_pad_ops imx258_pad_ops = {
1458         .enum_mbus_code = imx258_enum_mbus_code,
1459         .get_fmt = imx258_get_pad_format,
1460         .set_fmt = imx258_set_pad_format,
1461         .enum_frame_size = imx258_enum_frame_size,
1462         .get_selection = imx258_get_selection,
1463 };
1464
1465 static const struct v4l2_subdev_ops imx258_subdev_ops = {
1466         .video = &imx258_video_ops,
1467         .pad = &imx258_pad_ops,
1468 };
1469
1470 static const struct v4l2_subdev_internal_ops imx258_internal_ops = {
1471         .open = imx258_open,
1472 };
1473
1474 /* Initialize control handlers */
1475 static int imx258_init_controls(struct imx258 *imx258)
1476 {
1477         struct i2c_client *client = v4l2_get_subdevdata(&imx258->sd);
1478         struct v4l2_fwnode_device_properties props;
1479         struct v4l2_ctrl_handler *ctrl_hdlr;
1480         struct v4l2_ctrl *vflip, *hflip;
1481         s64 vblank_def;
1482         s64 vblank_min;
1483         s64 pixel_rate_min;
1484         s64 pixel_rate_max;
1485         int ret;
1486
1487         ctrl_hdlr = &imx258->ctrl_handler;
1488         ret = v4l2_ctrl_handler_init(ctrl_hdlr, 13);
1489         if (ret)
1490                 return ret;
1491
1492         mutex_init(&imx258->mutex);
1493         ctrl_hdlr->lock = &imx258->mutex;
1494         imx258->link_freq = v4l2_ctrl_new_int_menu(ctrl_hdlr,
1495                                 &imx258_ctrl_ops,
1496                                 V4L2_CID_LINK_FREQ,
1497                                 ARRAY_SIZE(link_freq_menu_items_19_2) - 1,
1498                                 0,
1499                                 imx258->link_freq_menu_items);
1500
1501         if (imx258->link_freq)
1502                 imx258->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1503
1504         /* The driver only supports one bayer order and flips by default. */
1505         hflip = v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops,
1506                                   V4L2_CID_HFLIP, 1, 1, 1, 1);
1507         if (hflip)
1508                 hflip->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1509
1510         vflip = v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops,
1511                                   V4L2_CID_VFLIP, 1, 1, 1, 1);
1512         if (vflip)
1513                 vflip->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1514
1515         pixel_rate_max =
1516                 link_freq_to_pixel_rate(imx258->link_freq_menu_items[0],
1517                                         imx258->nlanes);
1518         pixel_rate_min =
1519                 link_freq_to_pixel_rate(imx258->link_freq_menu_items[1],
1520                                         imx258->nlanes);
1521         /* By default, PIXEL_RATE is read only */
1522         imx258->pixel_rate = v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops,
1523                                 V4L2_CID_PIXEL_RATE,
1524                                 pixel_rate_min, pixel_rate_max,
1525                                 1, pixel_rate_max);
1526
1527
1528         vblank_def = imx258->cur_mode->vts_def - imx258->cur_mode->height;
1529         vblank_min = imx258->cur_mode->vts_min - imx258->cur_mode->height;
1530         imx258->vblank = v4l2_ctrl_new_std(
1531                                 ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_VBLANK,
1532                                 vblank_min,
1533                                 IMX258_VTS_MAX - imx258->cur_mode->height, 1,
1534                                 vblank_def);
1535
1536         imx258->hblank = v4l2_ctrl_new_std(
1537                                 ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_HBLANK,
1538                                 IMX258_PPL_DEFAULT - imx258->cur_mode->width,
1539                                 IMX258_PPL_DEFAULT - imx258->cur_mode->width,
1540                                 1,
1541                                 IMX258_PPL_DEFAULT - imx258->cur_mode->width);
1542
1543         if (imx258->hblank)
1544                 imx258->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1545
1546         imx258->exposure = v4l2_ctrl_new_std(
1547                                 ctrl_hdlr, &imx258_ctrl_ops,
1548                                 V4L2_CID_EXPOSURE, IMX258_EXPOSURE_MIN,
1549                                 IMX258_EXPOSURE_MAX, IMX258_EXPOSURE_STEP,
1550                                 IMX258_EXPOSURE_DEFAULT);
1551
1552         v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_ANALOGUE_GAIN,
1553                                 IMX258_ANA_GAIN_MIN, IMX258_ANA_GAIN_MAX,
1554                                 IMX258_ANA_GAIN_STEP, IMX258_ANA_GAIN_DEFAULT);
1555
1556         v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_DIGITAL_GAIN,
1557                                 IMX258_DGTL_GAIN_MIN, IMX258_DGTL_GAIN_MAX,
1558                                 IMX258_DGTL_GAIN_STEP,
1559                                 IMX258_DGTL_GAIN_DEFAULT);
1560
1561         v4l2_ctrl_new_std(ctrl_hdlr, &imx258_ctrl_ops, V4L2_CID_WIDE_DYNAMIC_RANGE,
1562                                 0, 1, 1, IMX258_HDR_RATIO_DEFAULT);
1563
1564         v4l2_ctrl_new_std_menu_items(ctrl_hdlr, &imx258_ctrl_ops,
1565                                 V4L2_CID_TEST_PATTERN,
1566                                 ARRAY_SIZE(imx258_test_pattern_menu) - 1,
1567                                 0, 0, imx258_test_pattern_menu);
1568
1569         if (ctrl_hdlr->error) {
1570                 ret = ctrl_hdlr->error;
1571                 dev_err(&client->dev, "%s control init failed (%d)\n",
1572                                 __func__, ret);
1573                 goto error;
1574         }
1575
1576         ret = v4l2_fwnode_device_parse(&client->dev, &props);
1577         if (ret)
1578                 goto error;
1579
1580         ret = v4l2_ctrl_new_fwnode_properties(ctrl_hdlr, &imx258_ctrl_ops,
1581                                               &props);
1582         if (ret)
1583                 goto error;
1584
1585         imx258->sd.ctrl_handler = ctrl_hdlr;
1586
1587         return 0;
1588
1589 error:
1590         v4l2_ctrl_handler_free(ctrl_hdlr);
1591         mutex_destroy(&imx258->mutex);
1592
1593         return ret;
1594 }
1595
1596 static void imx258_free_controls(struct imx258 *imx258)
1597 {
1598         v4l2_ctrl_handler_free(imx258->sd.ctrl_handler);
1599         mutex_destroy(&imx258->mutex);
1600 }
1601
1602 static int imx258_get_regulators(struct imx258 *imx258,
1603                                  struct i2c_client *client)
1604 {
1605         unsigned int i;
1606
1607         for (i = 0; i < IMX258_NUM_SUPPLIES; i++)
1608                 imx258->supplies[i].supply = imx258_supply_name[i];
1609
1610         return devm_regulator_bulk_get(&client->dev,
1611                                        IMX258_NUM_SUPPLIES,
1612                                        imx258->supplies);
1613 }
1614
1615 static int imx258_probe(struct i2c_client *client)
1616 {
1617         struct imx258 *imx258;
1618         struct fwnode_handle *endpoint;
1619         struct v4l2_fwnode_endpoint ep = {
1620                 .bus_type = V4L2_MBUS_CSI2_DPHY
1621         };
1622         int ret;
1623         u32 val = 0;
1624
1625         imx258 = devm_kzalloc(&client->dev, sizeof(*imx258), GFP_KERNEL);
1626         if (!imx258)
1627                 return -ENOMEM;
1628
1629         ret = imx258_get_regulators(imx258, client);
1630         if (ret)
1631                 return ret;
1632
1633         imx258->clk = devm_clk_get_optional(&client->dev, NULL);
1634         if (IS_ERR(imx258->clk))
1635                 return dev_err_probe(&client->dev, PTR_ERR(imx258->clk),
1636                                      "error getting clock\n");
1637         if (!imx258->clk) {
1638                 dev_dbg(&client->dev,
1639                         "no clock provided, using clock-frequency property\n");
1640
1641                 device_property_read_u32(&client->dev, "clock-frequency", &val);
1642         } else if (IS_ERR(imx258->clk)) {
1643                 return dev_err_probe(&client->dev, PTR_ERR(imx258->clk),
1644                                      "error getting clock\n");
1645         } else {
1646                 val = clk_get_rate(imx258->clk);
1647         }
1648
1649         switch (val) {
1650         case 19200000:
1651                 imx258->link_freq_configs = link_freq_configs_19_2;
1652                 imx258->link_freq_menu_items = link_freq_menu_items_19_2;
1653                 break;
1654         case 24000000:
1655                 imx258->link_freq_configs = link_freq_configs_24;
1656                 imx258->link_freq_menu_items = link_freq_menu_items_24;
1657                 break;
1658         default:
1659                 dev_err(&client->dev, "input clock frequency of %u not supported\n",
1660                         val);
1661                 return -EINVAL;
1662         }
1663
1664         endpoint = fwnode_graph_get_next_endpoint(dev_fwnode(&client->dev), NULL);
1665         if (!endpoint) {
1666                 dev_err(&client->dev, "Endpoint node not found\n");
1667                 return -EINVAL;
1668         }
1669
1670         ret = v4l2_fwnode_endpoint_alloc_parse(endpoint, &ep);
1671         fwnode_handle_put(endpoint);
1672         if (ret == -ENXIO) {
1673                 dev_err(&client->dev, "Unsupported bus type, should be CSI2\n");
1674                 goto error_endpoint_poweron;
1675         } else if (ret) {
1676                 dev_err(&client->dev, "Parsing endpoint node failed\n");
1677                 goto error_endpoint_poweron;
1678         }
1679
1680         /* Get number of data lanes */
1681         imx258->nlanes = ep.bus.mipi_csi2.num_data_lanes;
1682         if (imx258->nlanes != 2 && imx258->nlanes != 4) {
1683                 dev_err(&client->dev, "Invalid data lanes: %u\n",
1684                         imx258->nlanes);
1685                 ret = -EINVAL;
1686                 goto error_endpoint_poweron;
1687         }
1688
1689         imx258->csi2_flags = ep.bus.mipi_csi2.flags;
1690
1691         /* Initialize subdev */
1692         v4l2_i2c_subdev_init(&imx258->sd, client, &imx258_subdev_ops);
1693
1694         /* Will be powered off via pm_runtime_idle */
1695         ret = imx258_power_on(&client->dev);
1696         if (ret)
1697                 goto error_endpoint_poweron;
1698
1699         /* Check module identity */
1700         ret = imx258_identify_module(imx258);
1701         if (ret)
1702                 goto error_identify;
1703
1704         /* Set default mode to max resolution */
1705         imx258->cur_mode = &supported_modes[0];
1706
1707         ret = imx258_init_controls(imx258);
1708         if (ret)
1709                 goto error_identify;
1710
1711         /* Initialize subdev */
1712         imx258->sd.internal_ops = &imx258_internal_ops;
1713         imx258->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
1714         imx258->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR;
1715
1716         /* Initialize source pad */
1717         imx258->pad.flags = MEDIA_PAD_FL_SOURCE;
1718
1719         ret = media_entity_pads_init(&imx258->sd.entity, 1, &imx258->pad);
1720         if (ret)
1721                 goto error_handler_free;
1722
1723         ret = v4l2_async_register_subdev_sensor(&imx258->sd);
1724         if (ret < 0)
1725                 goto error_media_entity;
1726
1727         pm_runtime_set_active(&client->dev);
1728         pm_runtime_enable(&client->dev);
1729         pm_runtime_idle(&client->dev);
1730
1731         return 0;
1732
1733 error_media_entity:
1734         media_entity_cleanup(&imx258->sd.entity);
1735
1736 error_handler_free:
1737         imx258_free_controls(imx258);
1738
1739 error_identify:
1740         imx258_power_off(&client->dev);
1741
1742 error_endpoint_poweron:
1743         v4l2_fwnode_endpoint_free(&ep);
1744
1745         return ret;
1746 }
1747
1748 static void imx258_remove(struct i2c_client *client)
1749 {
1750         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1751         struct imx258 *imx258 = to_imx258(sd);
1752
1753         v4l2_async_unregister_subdev(sd);
1754         media_entity_cleanup(&sd->entity);
1755         imx258_free_controls(imx258);
1756
1757         pm_runtime_disable(&client->dev);
1758         if (!pm_runtime_status_suspended(&client->dev))
1759                 imx258_power_off(&client->dev);
1760         pm_runtime_set_suspended(&client->dev);
1761 }
1762
1763 static const struct dev_pm_ops imx258_pm_ops = {
1764         SET_SYSTEM_SLEEP_PM_OPS(imx258_suspend, imx258_resume)
1765         SET_RUNTIME_PM_OPS(imx258_power_off, imx258_power_on, NULL)
1766 };
1767
1768 #ifdef CONFIG_ACPI
1769 static const struct acpi_device_id imx258_acpi_ids[] = {
1770         { "SONY258A" },
1771         { /* sentinel */ }
1772 };
1773
1774 MODULE_DEVICE_TABLE(acpi, imx258_acpi_ids);
1775 #endif
1776
1777 static const struct of_device_id imx258_dt_ids[] = {
1778         { .compatible = "sony,imx258" },
1779         { /* sentinel */ }
1780 };
1781 MODULE_DEVICE_TABLE(of, imx258_dt_ids);
1782
1783 static struct i2c_driver imx258_i2c_driver = {
1784         .driver = {
1785                 .name = "imx258",
1786                 .pm = &imx258_pm_ops,
1787                 .acpi_match_table = ACPI_PTR(imx258_acpi_ids),
1788                 .of_match_table = imx258_dt_ids,
1789         },
1790         .probe = imx258_probe,
1791         .remove = imx258_remove,
1792 };
1793
1794 module_i2c_driver(imx258_i2c_driver);
1795
1796 MODULE_AUTHOR("Yeh, Andy <andy.yeh@intel.com>");
1797 MODULE_AUTHOR("Chiang, Alan");
1798 MODULE_AUTHOR("Chen, Jason");
1799 MODULE_DESCRIPTION("Sony IMX258 sensor driver");
1800 MODULE_LICENSE("GPL v2");