drivers/media/platform/soc_camera/rcar_vin.c

   1 /*
   2  * SoC-camera host driver for Renesas R-Car VIN unit
   3  *
   4  * Copyright (C) 2011-2013 Renesas Solutions Corp.
   5  * Copyright (C) 2013 Cogent Embedded, Inc., <source@cogentembedded.com>
   6  *
   7  * Based on V4L2 Driver for SuperH Mobile CEU interface "sh_mobile_ceu_camera.c"
   8  *
   9  * Copyright (C) 2008 Magnus Damm
  10  *
  11  * This program is free software; you can redistribute  it and/or modify it
  12  * under  the terms of  the GNU General  Public License as published by the
  13  * Free Software Foundation;  either version 2 of the  License, or (at your
  14  * option) any later version.
  15  */
  16
  17 #include <linux/delay.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/io.h>
  20 #include <linux/kernel.h>
  21 #include <linux/module.h>
  22 #include <linux/of.h>
  23 #include <linux/of_device.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/pm_runtime.h>
  26 #include <linux/slab.h>
  27 #include <linux/videodev2.h>
  28
  29 #include <media/soc_camera.h>
  30 #include <media/drv-intf/soc_mediabus.h>
  31 #include <media/v4l2-common.h>
  32 #include <media/v4l2-dev.h>
  33 #include <media/v4l2-device.h>
  34 #include <media/v4l2-mediabus.h>
  35 #include <media/v4l2-of.h>
  36 #include <media/v4l2-subdev.h>
  37 #include <media/videobuf2-dma-contig.h>
  38
  39 #include "soc_scale_crop.h"
  40
  41 #define DRV_NAME "rcar_vin"
  42
  43 /* Register offsets for R-Car VIN */
  44 #define VNMC_REG        0x00    /* Video n Main Control Register */
  45 #define VNMS_REG        0x04    /* Video n Module Status Register */
  46 #define VNFC_REG        0x08    /* Video n Frame Capture Register */
  47 #define VNSLPRC_REG     0x0C    /* Video n Start Line Pre-Clip Register */
  48 #define VNELPRC_REG     0x10    /* Video n End Line Pre-Clip Register */
  49 #define VNSPPRC_REG     0x14    /* Video n Start Pixel Pre-Clip Register */
  50 #define VNEPPRC_REG     0x18    /* Video n End Pixel Pre-Clip Register */
  51 #define VNSLPOC_REG     0x1C    /* Video n Start Line Post-Clip Register */
  52 #define VNELPOC_REG     0x20    /* Video n End Line Post-Clip Register */
  53 #define VNSPPOC_REG     0x24    /* Video n Start Pixel Post-Clip Register */
  54 #define VNEPPOC_REG     0x28    /* Video n End Pixel Post-Clip Register */
  55 #define VNIS_REG        0x2C    /* Video n Image Stride Register */
  56 #define VNMB_REG(m)     (0x30 + ((m) << 2)) /* Video n Memory Base m Register */
  57 #define VNIE_REG        0x40    /* Video n Interrupt Enable Register */
  58 #define VNINTS_REG      0x44    /* Video n Interrupt Status Register */
  59 #define VNSI_REG        0x48    /* Video n Scanline Interrupt Register */
  60 #define VNMTC_REG       0x4C    /* Video n Memory Transfer Control Register */
  61 #define VNYS_REG        0x50    /* Video n Y Scale Register */
  62 #define VNXS_REG        0x54    /* Video n X Scale Register */
  63 #define VNDMR_REG       0x58    /* Video n Data Mode Register */
  64 #define VNDMR2_REG      0x5C    /* Video n Data Mode Register 2 */
  65 #define VNUVAOF_REG     0x60    /* Video n UV Address Offset Register */
  66 #define VNC1A_REG       0x80    /* Video n Coefficient Set C1A Register */
  67 #define VNC1B_REG       0x84    /* Video n Coefficient Set C1B Register */
  68 #define VNC1C_REG       0x88    /* Video n Coefficient Set C1C Register */
  69 #define VNC2A_REG       0x90    /* Video n Coefficient Set C2A Register */
  70 #define VNC2B_REG       0x94    /* Video n Coefficient Set C2B Register */
  71 #define VNC2C_REG       0x98    /* Video n Coefficient Set C2C Register */
  72 #define VNC3A_REG       0xA0    /* Video n Coefficient Set C3A Register */
  73 #define VNC3B_REG       0xA4    /* Video n Coefficient Set C3B Register */
  74 #define VNC3C_REG       0xA8    /* Video n Coefficient Set C3C Register */
  75 #define VNC4A_REG       0xB0    /* Video n Coefficient Set C4A Register */
  76 #define VNC4B_REG       0xB4    /* Video n Coefficient Set C4B Register */
  77 #define VNC4C_REG       0xB8    /* Video n Coefficient Set C4C Register */
  78 #define VNC5A_REG       0xC0    /* Video n Coefficient Set C5A Register */
  79 #define VNC5B_REG       0xC4    /* Video n Coefficient Set C5B Register */
  80 #define VNC5C_REG       0xC8    /* Video n Coefficient Set C5C Register */
  81 #define VNC6A_REG       0xD0    /* Video n Coefficient Set C6A Register */
  82 #define VNC6B_REG       0xD4    /* Video n Coefficient Set C6B Register */
  83 #define VNC6C_REG       0xD8    /* Video n Coefficient Set C6C Register */
  84 #define VNC7A_REG       0xE0    /* Video n Coefficient Set C7A Register */
  85 #define VNC7B_REG       0xE4    /* Video n Coefficient Set C7B Register */
  86 #define VNC7C_REG       0xE8    /* Video n Coefficient Set C7C Register */
  87 #define VNC8A_REG       0xF0    /* Video n Coefficient Set C8A Register */
  88 #define VNC8B_REG       0xF4    /* Video n Coefficient Set C8B Register */
  89 #define VNC8C_REG       0xF8    /* Video n Coefficient Set C8C Register */
  90
  91 /* Register bit fields for R-Car VIN */
  92 /* Video n Main Control Register bits */
  93 #define VNMC_FOC                (1 << 21)
  94 #define VNMC_YCAL               (1 << 19)
  95 #define VNMC_INF_YUV8_BT656     (0 << 16)
  96 #define VNMC_INF_YUV8_BT601     (1 << 16)
  97 #define VNMC_INF_YUV10_BT656    (2 << 16)
  98 #define VNMC_INF_YUV10_BT601    (3 << 16)
  99 #define VNMC_INF_YUV16          (5 << 16)
 100 #define VNMC_INF_RGB888         (6 << 16)
 101 #define VNMC_VUP                (1 << 10)
 102 #define VNMC_IM_ODD             (0 << 3)
 103 #define VNMC_IM_ODD_EVEN        (1 << 3)
 104 #define VNMC_IM_EVEN            (2 << 3)
 105 #define VNMC_IM_FULL            (3 << 3)
 106 #define VNMC_BPS                (1 << 1)
 107 #define VNMC_ME                 (1 << 0)
 108
 109 /* Video n Module Status Register bits */
 110 #define VNMS_FBS_MASK           (3 << 3)
 111 #define VNMS_FBS_SHIFT          3
 112 #define VNMS_AV                 (1 << 1)
 113 #define VNMS_CA                 (1 << 0)
 114
 115 /* Video n Frame Capture Register bits */
 116 #define VNFC_C_FRAME            (1 << 1)
 117 #define VNFC_S_FRAME            (1 << 0)
 118
 119 /* Video n Interrupt Enable Register bits */
 120 #define VNIE_FIE                (1 << 4)
 121 #define VNIE_EFE                (1 << 1)
 122
 123 /* Video n Data Mode Register bits */
 124 #define VNDMR_EXRGB             (1 << 8)
 125 #define VNDMR_BPSM              (1 << 4)
 126 #define VNDMR_DTMD_YCSEP        (1 << 1)
 127 #define VNDMR_DTMD_ARGB         (1 << 0)
 128
 129 /* Video n Data Mode Register 2 bits */
 130 #define VNDMR2_VPS              (1 << 30)
 131 #define VNDMR2_HPS              (1 << 29)
 132 #define VNDMR2_FTEV             (1 << 17)
 133 #define VNDMR2_VLV(n)           ((n & 0xf) << 12)
 134
 135 #define VIN_MAX_WIDTH           2048
 136 #define VIN_MAX_HEIGHT          2048
 137
 138 #define TIMEOUT_MS              100
 139
 140 #define RCAR_VIN_HSYNC_ACTIVE_LOW       (1 << 0)
 141 #define RCAR_VIN_VSYNC_ACTIVE_LOW       (1 << 1)
 142 #define RCAR_VIN_BT601                  (1 << 2)
 143 #define RCAR_VIN_BT656                  (1 << 3)
 144
 145 enum chip_id {
 146         RCAR_GEN3,
 147         RCAR_GEN2,
 148         RCAR_H1,
 149         RCAR_M1,
 150         RCAR_E1,
 151 };
 152
 153 struct vin_coeff {
 154         unsigned short xs_value;
 155         u32 coeff_set[24];
 156 };
 157
 158 static const struct vin_coeff vin_coeff_set[] = {
 159         { 0x0000, {
 160                 0x00000000,             0x00000000,             0x00000000,
 161                 0x00000000,             0x00000000,             0x00000000,
 162                 0x00000000,             0x00000000,             0x00000000,
 163                 0x00000000,             0x00000000,             0x00000000,
 164                 0x00000000,             0x00000000,             0x00000000,
 165                 0x00000000,             0x00000000,             0x00000000,
 166                 0x00000000,             0x00000000,             0x00000000,
 167                 0x00000000,             0x00000000,             0x00000000 },
 168         },
 169         { 0x1000, {
 170                 0x000fa400,             0x000fa400,             0x09625902,
 171                 0x000003f8,             0x00000403,             0x3de0d9f0,
 172                 0x001fffed,             0x00000804,             0x3cc1f9c3,
 173                 0x001003de,             0x00000c01,             0x3cb34d7f,
 174                 0x002003d2,             0x00000c00,             0x3d24a92d,
 175                 0x00200bca,             0x00000bff,             0x3df600d2,
 176                 0x002013cc,             0x000007ff,             0x3ed70c7e,
 177                 0x00100fde,             0x00000000,             0x3f87c036 },
 178         },
 179         { 0x1200, {
 180                 0x002ffff1,             0x002ffff1,             0x02a0a9c8,
 181                 0x002003e7,             0x001ffffa,             0x000185bc,
 182                 0x002007dc,             0x000003ff,             0x3e52859c,
 183                 0x00200bd4,             0x00000002,             0x3d53996b,
 184                 0x00100fd0,             0x00000403,             0x3d04ad2d,
 185                 0x00000bd5,             0x00000403,             0x3d35ace7,
 186                 0x3ff003e4,             0x00000801,             0x3dc674a1,
 187                 0x3fffe800,             0x00000800,             0x3e76f461 },
 188         },
 189         { 0x1400, {
 190                 0x00100be3,             0x00100be3,             0x04d1359a,
 191                 0x00000fdb,             0x002003ed,             0x0211fd93,
 192                 0x00000fd6,             0x002003f4,             0x0002d97b,
 193                 0x000007d6,             0x002ffffb,             0x3e93b956,
 194                 0x3ff003da,             0x001003ff,             0x3db49926,
 195                 0x3fffefe9,             0x00100001,             0x3d655cee,
 196                 0x3fffd400,             0x00000003,             0x3d65f4b6,
 197                 0x000fb421,             0x00000402,             0x3dc6547e },
 198         },
 199         { 0x1600, {
 200                 0x00000bdd,             0x00000bdd,             0x06519578,
 201                 0x3ff007da,             0x00000be3,             0x03c24973,
 202                 0x3ff003d9,             0x00000be9,             0x01b30d5f,
 203                 0x3ffff7df,             0x001003f1,             0x0003c542,
 204                 0x000fdfec,             0x001003f7,             0x3ec4711d,
 205                 0x000fc400,             0x002ffffd,             0x3df504f1,
 206                 0x001fa81a,             0x002ffc00,             0x3d957cc2,
 207                 0x002f8c3c,             0x00100000,             0x3db5c891 },
 208         },
 209         { 0x1800, {
 210                 0x3ff003dc,             0x3ff003dc,             0x0791e558,
 211                 0x000ff7dd,             0x3ff007de,             0x05328554,
 212                 0x000fe7e3,             0x3ff00be2,             0x03232546,
 213                 0x000fd7ee,             0x000007e9,             0x0143bd30,
 214                 0x001fb800,             0x000007ee,             0x00044511,
 215                 0x002fa015,             0x000007f4,             0x3ef4bcee,
 216                 0x002f8832,             0x001003f9,             0x3e4514c7,
 217                 0x001f7853,             0x001003fd,             0x3de54c9f },
 218         },
 219         { 0x1a00, {
 220                 0x000fefe0,             0x000fefe0,             0x08721d3c,
 221                 0x001fdbe7,             0x000ffbde,             0x0652a139,
 222                 0x001fcbf0,             0x000003df,             0x0463292e,
 223                 0x002fb3ff,             0x3ff007e3,             0x0293a91d,
 224                 0x002f9c12,             0x3ff00be7,             0x01241905,
 225                 0x001f8c29,             0x000007ed,             0x3fe470eb,
 226                 0x000f7c46,             0x000007f2,             0x3f04b8ca,
 227                 0x3fef7865,             0x000007f6,             0x3e74e4a8 },
 228         },
 229         { 0x1c00, {
 230                 0x001fd3e9,             0x001fd3e9,             0x08f23d26,
 231                 0x002fbff3,             0x001fe3e4,             0x0712ad23,
 232                 0x002fa800,             0x000ff3e0,             0x05631d1b,
 233                 0x001f9810,             0x000ffbe1,             0x03b3890d,
 234                 0x000f8c23,             0x000003e3,             0x0233e8fa,
 235                 0x3fef843b,             0x000003e7,             0x00f430e4,
 236                 0x3fbf8456,             0x3ff00bea,             0x00046cc8,
 237                 0x3f8f8c72,             0x3ff00bef,             0x3f3490ac },
 238         },
 239         { 0x1e00, {
 240                 0x001fbbf4,             0x001fbbf4,             0x09425112,
 241                 0x001fa800,             0x002fc7ed,             0x0792b110,
 242                 0x000f980e,             0x001fdbe6,             0x0613110a,
 243                 0x3fff8c20,             0x001fe7e3,             0x04a368fd,
 244                 0x3fcf8c33,             0x000ff7e2,             0x0343b8ed,
 245                 0x3f9f8c4a,             0x000fffe3,             0x0203f8da,
 246                 0x3f5f9c61,             0x000003e6,             0x00e428c5,
 247                 0x3f1fb07b,             0x000003eb,             0x3fe440af },
 248         },
 249         { 0x2000, {
 250                 0x000fa400,             0x000fa400,             0x09625902,
 251                 0x3fff980c,             0x001fb7f5,             0x0812b0ff,
 252                 0x3fdf901c,             0x001fc7ed,             0x06b2fcfa,
 253                 0x3faf902d,             0x001fd3e8,             0x055348f1,
 254                 0x3f7f983f,             0x001fe3e5,             0x04038ce3,
 255                 0x3f3fa454,             0x001fefe3,             0x02e3c8d1,
 256                 0x3f0fb86a,             0x001ff7e4,             0x01c3e8c0,
 257                 0x3ecfd880,             0x000fffe6,             0x00c404ac },
 258         },
 259         { 0x2200, {
 260                 0x3fdf9c0b,             0x3fdf9c0b,             0x09725cf4,
 261                 0x3fbf9818,             0x3fffa400,             0x0842a8f1,
 262                 0x3f8f9827,             0x000fb3f7,             0x0702f0ec,
 263                 0x3f5fa037,             0x000fc3ef,             0x05d330e4,
 264                 0x3f2fac49,             0x001fcfea,             0x04a364d9,
 265                 0x3effc05c,             0x001fdbe7,             0x038394ca,
 266                 0x3ecfdc6f,             0x001fe7e6,             0x0273b0bb,
 267                 0x3ea00083,             0x001fefe6,             0x0183c0a9 },
 268         },
 269         { 0x2400, {
 270                 0x3f9fa014,             0x3f9fa014,             0x098260e6,
 271                 0x3f7f9c23,             0x3fcf9c0a,             0x08629ce5,
 272                 0x3f4fa431,             0x3fefa400,             0x0742d8e1,
 273                 0x3f1fb440,             0x3fffb3f8,             0x062310d9,
 274                 0x3eefc850,             0x000fbbf2,             0x050340d0,
 275                 0x3ecfe062,             0x000fcbec,             0x041364c2,
 276                 0x3ea00073,             0x001fd3ea,             0x03037cb5,
 277                 0x3e902086,             0x001fdfe8,             0x022388a5 },
 278         },
 279         { 0x2600, {
 280                 0x3f5fa81e,             0x3f5fa81e,             0x096258da,
 281                 0x3f3fac2b,             0x3f8fa412,             0x088290d8,
 282                 0x3f0fbc38,             0x3fafa408,             0x0772c8d5,
 283                 0x3eefcc47,             0x3fcfa800,             0x0672f4ce,
 284                 0x3ecfe456,             0x3fefaffa,             0x05531cc6,
 285                 0x3eb00066,             0x3fffbbf3,             0x047334bb,
 286                 0x3ea01c77,             0x000fc7ee,             0x039348ae,
 287                 0x3ea04486,             0x000fd3eb,             0x02b350a1 },
 288         },
 289         { 0x2800, {
 290                 0x3f2fb426,             0x3f2fb426,             0x094250ce,
 291                 0x3f0fc032,             0x3f4fac1b,             0x086284cd,
 292                 0x3eefd040,             0x3f7fa811,             0x0782acc9,
 293                 0x3ecfe84c,             0x3f9fa807,             0x06a2d8c4,
 294                 0x3eb0005b,             0x3fbfac00,             0x05b2f4bc,
 295                 0x3eb0186a,             0x3fdfb3fa,             0x04c308b4,
 296                 0x3eb04077,             0x3fefbbf4,             0x03f31ca8,
 297                 0x3ec06884,             0x000fbff2,             0x03031c9e },
 298         },
 299         { 0x2a00, {
 300                 0x3f0fc42d,             0x3f0fc42d,             0x090240c4,
 301                 0x3eefd439,             0x3f2fb822,             0x08526cc2,
 302                 0x3edfe845,             0x3f4fb018,             0x078294bf,
 303                 0x3ec00051,             0x3f6fac0f,             0x06b2b4bb,
 304                 0x3ec0185f,             0x3f8fac07,             0x05e2ccb4,
 305                 0x3ec0386b,             0x3fafac00,             0x0502e8ac,
 306                 0x3ed05c77,             0x3fcfb3fb,             0x0432f0a3,
 307                 0x3ef08482,             0x3fdfbbf6,             0x0372f898 },
 308         },
 309         { 0x2c00, {
 310                 0x3eefdc31,             0x3eefdc31,             0x08e238b8,
 311                 0x3edfec3d,             0x3f0fc828,             0x082258b9,
 312                 0x3ed00049,             0x3f1fc01e,             0x077278b6,
 313                 0x3ed01455,             0x3f3fb815,             0x06c294b2,
 314                 0x3ed03460,             0x3f5fb40d,             0x0602acac,
 315                 0x3ef0506c,             0x3f7fb006,             0x0542c0a4,
 316                 0x3f107476,             0x3f9fb400,             0x0472c89d,
 317                 0x3f309c80,             0x3fbfb7fc,             0x03b2cc94 },
 318         },
 319         { 0x2e00, {
 320                 0x3eefec37,             0x3eefec37,             0x088220b0,
 321                 0x3ee00041,             0x3effdc2d,             0x07f244ae,
 322                 0x3ee0144c,             0x3f0fd023,             0x07625cad,
 323                 0x3ef02c57,             0x3f1fc81a,             0x06c274a9,
 324                 0x3f004861,             0x3f3fbc13,             0x060288a6,
 325                 0x3f20686b,             0x3f5fb80c,             0x05529c9e,
 326                 0x3f408c74,             0x3f6fb805,             0x04b2ac96,
 327                 0x3f80ac7e,             0x3f8fb800,             0x0402ac8e },
 328         },
 329         { 0x3000, {
 330                 0x3ef0003a,             0x3ef0003a,             0x084210a6,
 331                 0x3ef01045,             0x3effec32,             0x07b228a7,
 332                 0x3f00284e,             0x3f0fdc29,             0x073244a4,
 333                 0x3f104058,             0x3f0fd420,             0x06a258a2,
 334                 0x3f305c62,             0x3f2fc818,             0x0612689d,
 335                 0x3f508069,             0x3f3fc011,             0x05728496,
 336                 0x3f80a072,             0x3f4fc00a,             0x04d28c90,
 337                 0x3fc0c07b,             0x3f6fbc04,             0x04429088 },
 338         },
 339         { 0x3200, {
 340                 0x3f00103e,             0x3f00103e,             0x07f1fc9e,
 341                 0x3f102447,             0x3f000035,             0x0782149d,
 342                 0x3f203c4f,             0x3f0ff02c,             0x07122c9c,
 343                 0x3f405458,             0x3f0fe424,             0x06924099,
 344                 0x3f607061,             0x3f1fd41d,             0x06024c97,
 345                 0x3f909068,             0x3f2fcc16,             0x05726490,
 346                 0x3fc0b070,             0x3f3fc80f,             0x04f26c8a,
 347                 0x0000d077,             0x3f4fc409,             0x04627484 },
 348         },
 349         { 0x3400, {
 350                 0x3f202040,             0x3f202040,             0x07a1e898,
 351                 0x3f303449,             0x3f100c38,             0x0741fc98,
 352                 0x3f504c50,             0x3f10002f,             0x06e21495,
 353                 0x3f706459,             0x3f1ff028,             0x06722492,
 354                 0x3fa08060,             0x3f1fe421,             0x05f2348f,
 355                 0x3fd09c67,             0x3f1fdc19,             0x05824c89,
 356                 0x0000bc6e,             0x3f2fd014,             0x04f25086,
 357                 0x0040dc74,             0x3f3fcc0d,             0x04825c7f },
 358         },
 359         { 0x3600, {
 360                 0x3f403042,             0x3f403042,             0x0761d890,
 361                 0x3f504848,             0x3f301c3b,             0x0701f090,
 362                 0x3f805c50,             0x3f200c33,             0x06a2008f,
 363                 0x3fa07458,             0x3f10002b,             0x06520c8d,
 364                 0x3fd0905e,             0x3f1ff424,             0x05e22089,
 365                 0x0000ac65,             0x3f1fe81d,             0x05823483,
 366                 0x0030cc6a,             0x3f2fdc18,             0x04f23c81,
 367                 0x0080e871,             0x3f2fd412,             0x0482407c },
 368         },
 369         { 0x3800, {
 370                 0x3f604043,             0x3f604043,             0x0721c88a,
 371                 0x3f80544a,             0x3f502c3c,             0x06d1d88a,
 372                 0x3fb06851,             0x3f301c35,             0x0681e889,
 373                 0x3fd08456,             0x3f30082f,             0x0611fc88,
 374                 0x00009c5d,             0x3f200027,             0x05d20884,
 375                 0x0030b863,             0x3f2ff421,             0x05621880,
 376                 0x0070d468,             0x3f2fe81b,             0x0502247c,
 377                 0x00c0ec6f,             0x3f2fe015,             0x04a22877 },
 378         },
 379         { 0x3a00, {
 380                 0x3f904c44,             0x3f904c44,             0x06e1b884,
 381                 0x3fb0604a,             0x3f70383e,             0x0691c885,
 382                 0x3fe07451,             0x3f502c36,             0x0661d483,
 383                 0x00009055,             0x3f401831,             0x0601ec81,
 384                 0x0030a85b,             0x3f300c2a,             0x05b1f480,
 385                 0x0070c061,             0x3f300024,             0x0562047a,
 386                 0x00b0d867,             0x3f3ff41e,             0x05020c77,
 387                 0x00f0f46b,             0x3f2fec19,             0x04a21474 },
 388         },
 389         { 0x3c00, {
 390                 0x3fb05c43,             0x3fb05c43,             0x06c1b07e,
 391                 0x3fe06c4b,             0x3f902c3f,             0x0681c081,
 392                 0x0000844f,             0x3f703838,             0x0631cc7d,
 393                 0x00309855,             0x3f602433,             0x05d1d47e,
 394                 0x0060b459,             0x3f50142e,             0x0581e47b,
 395                 0x00a0c85f,             0x3f400828,             0x0531f078,
 396                 0x00e0e064,             0x3f300021,             0x0501fc73,
 397                 0x00b0fc6a,             0x3f3ff41d,             0x04a20873 },
 398         },
 399         { 0x3e00, {
 400                 0x3fe06444,             0x3fe06444,             0x0681a07a,
 401                 0x00007849,             0x3fc0503f,             0x0641b07a,
 402                 0x0020904d,             0x3fa0403a,             0x05f1c07a,
 403                 0x0060a453,             0x3f803034,             0x05c1c878,
 404                 0x0090b858,             0x3f70202f,             0x0571d477,
 405                 0x00d0d05d,             0x3f501829,             0x0531e073,
 406                 0x0110e462,             0x3f500825,             0x04e1e471,
 407                 0x01510065,             0x3f40001f,             0x04a1f06d },
 408         },
 409         { 0x4000, {
 410                 0x00007044,             0x00007044,             0x06519476,
 411                 0x00208448,             0x3fe05c3f,             0x0621a476,
 412                 0x0050984d,             0x3fc04c3a,             0x05e1b075,
 413                 0x0080ac52,             0x3fa03c35,             0x05a1b875,
 414                 0x00c0c056,             0x3f803030,             0x0561c473,
 415                 0x0100d45b,             0x3f70202b,             0x0521d46f,
 416                 0x0140e860,             0x3f601427,             0x04d1d46e,
 417                 0x01810064,             0x3f500822,             0x0491dc6b },
 418         },
 419         { 0x5000, {
 420                 0x0110a442,             0x0110a442,             0x0551545e,
 421                 0x0140b045,             0x00e0983f,             0x0531585f,
 422                 0x0160c047,             0x00c08c3c,             0x0511645e,
 423                 0x0190cc4a,             0x00908039,             0x04f1685f,
 424                 0x01c0dc4c,             0x00707436,             0x04d1705e,
 425                 0x0200e850,             0x00506833,             0x04b1785b,
 426                 0x0230f453,             0x00305c30,             0x0491805a,
 427                 0x02710056,             0x0010542d,             0x04718059 },
 428         },
 429         { 0x6000, {
 430                 0x01c0bc40,             0x01c0bc40,             0x04c13052,
 431                 0x01e0c841,             0x01a0b43d,             0x04c13851,
 432                 0x0210cc44,             0x0180a83c,             0x04a13453,
 433                 0x0230d845,             0x0160a03a,             0x04913c52,
 434                 0x0260e047,             0x01409838,             0x04714052,
 435                 0x0280ec49,             0x01208c37,             0x04514c50,
 436                 0x02b0f44b,             0x01008435,             0x04414c50,
 437                 0x02d1004c,             0x00e07c33,             0x0431544f },
 438         },
 439         { 0x7000, {
 440                 0x0230c83e,             0x0230c83e,             0x04711c4c,
 441                 0x0250d03f,             0x0210c43c,             0x0471204b,
 442                 0x0270d840,             0x0200b83c,             0x0451244b,
 443                 0x0290dc42,             0x01e0b43a,             0x0441244c,
 444                 0x02b0e443,             0x01c0b038,             0x0441284b,
 445                 0x02d0ec44,             0x01b0a438,             0x0421304a,
 446                 0x02f0f445,             0x0190a036,             0x04213449,
 447                 0x0310f847,             0x01709c34,             0x04213848 },
 448         },
 449         { 0x8000, {
 450                 0x0280d03d,             0x0280d03d,             0x04310c48,
 451                 0x02a0d43e,             0x0270c83c,             0x04311047,
 452                 0x02b0dc3e,             0x0250c83a,             0x04311447,
 453                 0x02d0e040,             0x0240c03a,             0x04211446,
 454                 0x02e0e840,             0x0220bc39,             0x04111847,
 455                 0x0300e842,             0x0210b438,             0x04012445,
 456                 0x0310f043,             0x0200b037,             0x04012045,
 457                 0x0330f444,             0x01e0ac36,             0x03f12445 },
 458         },
 459         { 0xefff, {
 460                 0x0340dc3a,             0x0340dc3a,             0x03b0ec40,
 461                 0x0340e03a,             0x0330e039,             0x03c0f03e,
 462                 0x0350e03b,             0x0330dc39,             0x03c0ec3e,
 463                 0x0350e43a,             0x0320dc38,             0x03c0f43e,
 464                 0x0360e43b,             0x0320d839,             0x03b0f03e,
 465                 0x0360e83b,             0x0310d838,             0x03c0fc3b,
 466                 0x0370e83b,             0x0310d439,             0x03a0f83d,
 467                 0x0370e83c,             0x0300d438,             0x03b0fc3c },
 468         }
 469 };
 470
 471 enum rcar_vin_state {
 472         STOPPED = 0,
 473         RUNNING,
 474         STOPPING,
 475 };
 476
 477 struct rcar_vin_priv {
 478         void __iomem                    *base;
 479         spinlock_t                      lock;
 480         int                             sequence;
 481         /* State of the VIN module in capturing mode */
 482         enum rcar_vin_state             state;
 483         struct soc_camera_host          ici;
 484         struct list_head                capture;
 485 #define MAX_BUFFER_NUM                  3
 486         struct vb2_v4l2_buffer          *queue_buf[MAX_BUFFER_NUM];
 487         enum v4l2_field                 field;
 488         unsigned int                    pdata_flags;
 489         unsigned int                    vb_count;
 490         unsigned int                    nr_hw_slots;
 491         bool                            request_to_stop;
 492         struct completion               capture_stop;
 493         enum chip_id                    chip;
 494 };
 495
 496 #define is_continuous_transfer(priv)    (priv->vb_count > MAX_BUFFER_NUM)
 497
 498 struct rcar_vin_buffer {
 499         struct vb2_v4l2_buffer vb;
 500         struct list_head                list;
 501 };
 502
 503 #define to_buf_list(vb2_buffer) (&container_of(vb2_buffer, \
 504                                                        struct rcar_vin_buffer, \
 505                                                        vb)->list)
 506
 507 struct rcar_vin_cam {
 508         /* VIN offsets within the camera output, before the VIN scaler */
 509         unsigned int                    vin_left;
 510         unsigned int                    vin_top;
 511         /* Client output, as seen by the VIN */
 512         unsigned int                    width;
 513         unsigned int                    height;
 514         /* User window from S_FMT */
 515         unsigned int out_width;
 516         unsigned int out_height;
 517         /*
 518          * User window from S_CROP / G_CROP, produced by client cropping and
 519          * scaling, VIN scaling and VIN cropping, mapped back onto the client
 520          * input window
 521          */
 522         struct v4l2_rect                subrect;
 523         /* Camera cropping rectangle */
 524         struct v4l2_rect                rect;
 525         const struct soc_mbus_pixelfmt  *extra_fmt;
 526 };
 527
 528 /*
 529  * .queue_setup() is called to check whether the driver can accept the requested
 530  * number of buffers and to fill in plane sizes for the current frame format if
 531  * required
 532  */
 533 static int rcar_vin_videobuf_setup(struct vb2_queue *vq,
 534                                    unsigned int *count,
 535                                    unsigned int *num_planes,
 536                                    unsigned int sizes[], struct device *alloc_devs[])
 537 {
 538         struct soc_camera_device *icd = soc_camera_from_vb2q(vq);
 539         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
 540         struct rcar_vin_priv *priv = ici->priv;
 541
 542         if (!vq->num_buffers)
 543                 priv->sequence = 0;
 544
 545         if (!*count)
 546                 *count = 2;
 547         priv->vb_count = *count;
 548
 549         /* Number of hardware slots */
 550         if (is_continuous_transfer(priv))
 551                 priv->nr_hw_slots = MAX_BUFFER_NUM;
 552         else
 553                 priv->nr_hw_slots = 1;
 554
 555         if (*num_planes)
 556                 return sizes[0] < icd->sizeimage ? -EINVAL : 0;
 557
 558         sizes[0] = icd->sizeimage;
 559         *num_planes = 1;
 560
 561         dev_dbg(icd->parent, "count=%d, size=%u\n", *count, sizes[0]);
 562
 563         return 0;
 564 }
 565
 566 static int rcar_vin_setup(struct rcar_vin_priv *priv)
 567 {
 568         struct soc_camera_device *icd = priv->ici.icd;
 569         struct rcar_vin_cam *cam = icd->host_priv;
 570         u32 vnmc, dmr, interrupts;
 571         bool progressive = false, output_is_yuv = false, input_is_yuv = false;
 572
 573         switch (priv->field) {
 574         case V4L2_FIELD_TOP:
 575                 vnmc = VNMC_IM_ODD;
 576                 break;
 577         case V4L2_FIELD_BOTTOM:
 578                 vnmc = VNMC_IM_EVEN;
 579                 break;
 580         case V4L2_FIELD_INTERLACED:
 581         case V4L2_FIELD_INTERLACED_TB:
 582                 vnmc = VNMC_IM_FULL;
 583                 break;
 584         case V4L2_FIELD_INTERLACED_BT:
 585                 vnmc = VNMC_IM_FULL | VNMC_FOC;
 586                 break;
 587         case V4L2_FIELD_NONE:
 588                 if (is_continuous_transfer(priv)) {
 589                         vnmc = VNMC_IM_ODD_EVEN;
 590                         progressive = true;
 591                 } else {
 592                         vnmc = VNMC_IM_ODD;
 593                 }
 594                 break;
 595         default:
 596                 vnmc = VNMC_IM_ODD;
 597                 break;
 598         }
 599
 600         /* input interface */
 601         switch (icd->current_fmt->code) {
 602         case MEDIA_BUS_FMT_YUYV8_1X16:
 603                 /* BT.601/BT.1358 16bit YCbCr422 */
 604                 vnmc |= VNMC_INF_YUV16;
 605                 input_is_yuv = true;
 606                 break;
 607         case MEDIA_BUS_FMT_YUYV8_2X8:
 608                 /* BT.656 8bit YCbCr422 or BT.601 8bit YCbCr422 */
 609                 vnmc |= priv->pdata_flags & RCAR_VIN_BT656 ?
 610                         VNMC_INF_YUV8_BT656 : VNMC_INF_YUV8_BT601;
 611                 input_is_yuv = true;
 612                 break;
 613         case MEDIA_BUS_FMT_RGB888_1X24:
 614                 vnmc |= VNMC_INF_RGB888;
 615                 break;
 616         case MEDIA_BUS_FMT_YUYV10_2X10:
 617                 /* BT.656 10bit YCbCr422 or BT.601 10bit YCbCr422 */
 618                 vnmc |= priv->pdata_flags & RCAR_VIN_BT656 ?
 619                         VNMC_INF_YUV10_BT656 : VNMC_INF_YUV10_BT601;
 620                 input_is_yuv = true;
 621                 break;
 622         default:
 623                 break;
 624         }
 625
 626         /* output format */
 627         switch (icd->current_fmt->host_fmt->fourcc) {
 628         case V4L2_PIX_FMT_NV16:
 629                 iowrite32(ALIGN(cam->width * cam->height, 0x80),
 630                           priv->base + VNUVAOF_REG);
 631                 dmr = VNDMR_DTMD_YCSEP;
 632                 output_is_yuv = true;
 633                 break;
 634         case V4L2_PIX_FMT_YUYV:
 635                 dmr = VNDMR_BPSM;
 636                 output_is_yuv = true;
 637                 break;
 638         case V4L2_PIX_FMT_UYVY:
 639                 dmr = 0;
 640                 output_is_yuv = true;
 641                 break;
 642         case V4L2_PIX_FMT_RGB555X:
 643                 dmr = VNDMR_DTMD_ARGB;
 644                 break;
 645         case V4L2_PIX_FMT_RGB565:
 646                 dmr = 0;
 647                 break;
 648         case V4L2_PIX_FMT_RGB32:
 649                 if (priv->chip != RCAR_GEN2 && priv->chip != RCAR_H1 &&
 650                     priv->chip != RCAR_E1)
 651                         goto e_format;
 652
 653                 dmr = VNDMR_EXRGB;
 654                 break;
 655         case V4L2_PIX_FMT_ARGB32:
 656                 if (priv->chip != RCAR_GEN3)
 657                         goto e_format;
 658
 659                 dmr = VNDMR_EXRGB | VNDMR_DTMD_ARGB;
 660                 break;
 661         default:
 662                 goto e_format;
 663         }
 664
 665         /* Always update on field change */
 666         vnmc |= VNMC_VUP;
 667
 668         /* If input and output use the same colorspace, use bypass mode */
 669         if (input_is_yuv == output_is_yuv)
 670                 vnmc |= VNMC_BPS;
 671
 672         /* progressive or interlaced mode */
 673         interrupts = progressive ? VNIE_FIE : VNIE_EFE;
 674
 675         /* ack interrupts */
 676         iowrite32(interrupts, priv->base + VNINTS_REG);
 677         /* enable interrupts */
 678         iowrite32(interrupts, priv->base + VNIE_REG);
 679         /* start capturing */
 680         iowrite32(dmr, priv->base + VNDMR_REG);
 681         iowrite32(vnmc | VNMC_ME, priv->base + VNMC_REG);
 682
 683         return 0;
 684
 685 e_format:
 686         dev_warn(icd->parent, "Invalid fourcc format (0x%x)\n",
 687                  icd->current_fmt->host_fmt->fourcc);
 688         return -EINVAL;
 689 }
 690
 691 static void rcar_vin_capture(struct rcar_vin_priv *priv)
 692 {
 693         if (is_continuous_transfer(priv))
 694                 /* Continuous Frame Capture Mode */
 695                 iowrite32(VNFC_C_FRAME, priv->base + VNFC_REG);
 696         else
 697                 /* Single Frame Capture Mode */
 698                 iowrite32(VNFC_S_FRAME, priv->base + VNFC_REG);
 699 }
 700
 701 static void rcar_vin_request_capture_stop(struct rcar_vin_priv *priv)
 702 {
 703         priv->state = STOPPING;
 704
 705         /* set continuous & single transfer off */
 706         iowrite32(0, priv->base + VNFC_REG);
 707         /* disable capture (release DMA buffer), reset */
 708         iowrite32(ioread32(priv->base + VNMC_REG) & ~VNMC_ME,
 709                   priv->base + VNMC_REG);
 710
 711         /* update the status if stopped already */
 712         if (!(ioread32(priv->base + VNMS_REG) & VNMS_CA))
 713                 priv->state = STOPPED;
 714 }
 715
 716 static int rcar_vin_get_free_hw_slot(struct rcar_vin_priv *priv)
 717 {
 718         int slot;
 719
 720         for (slot = 0; slot < priv->nr_hw_slots; slot++)
 721                 if (priv->queue_buf[slot] == NULL)
 722                         return slot;
 723
 724         return -1;
 725 }
 726
 727 static int rcar_vin_hw_ready(struct rcar_vin_priv *priv)
 728 {
 729         /* Ensure all HW slots are filled */
 730         return rcar_vin_get_free_hw_slot(priv) < 0 ? 1 : 0;
 731 }
 732
 733 /* Moves a buffer from the queue to the HW slots */
 734 static int rcar_vin_fill_hw_slot(struct rcar_vin_priv *priv)
 735 {
 736         struct vb2_v4l2_buffer *vbuf;
 737         dma_addr_t phys_addr_top;
 738         int slot;
 739
 740         if (list_empty(&priv->capture))
 741                 return 0;
 742
 743         /* Find a free HW slot */
 744         slot = rcar_vin_get_free_hw_slot(priv);
 745         if (slot < 0)
 746                 return 0;
 747
 748         vbuf = &list_entry(priv->capture.next,
 749                         struct rcar_vin_buffer, list)->vb;
 750         list_del_init(to_buf_list(vbuf));
 751         priv->queue_buf[slot] = vbuf;
 752         phys_addr_top = vb2_dma_contig_plane_dma_addr(&vbuf->vb2_buf, 0);
 753         iowrite32(phys_addr_top, priv->base + VNMB_REG(slot));
 754
 755         return 1;
 756 }
 757
 758 static void rcar_vin_videobuf_queue(struct vb2_buffer *vb)
 759 {
 760         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 761         struct soc_camera_device *icd = soc_camera_from_vb2q(vb->vb2_queue);
 762         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
 763         struct rcar_vin_priv *priv = ici->priv;
 764         unsigned long size;
 765
 766         size = icd->sizeimage;
 767
 768         if (vb2_plane_size(vb, 0) < size) {
 769                 dev_err(icd->parent, "Buffer #%d too small (%lu < %lu)\n",
 770                         vb->index, vb2_plane_size(vb, 0), size);
 771                 goto error;
 772         }
 773
 774         vb2_set_plane_payload(vb, 0, size);
 775
 776         dev_dbg(icd->parent, "%s (vb=0x%p) 0x%p %lu\n", __func__,
 777                 vb, vb2_plane_vaddr(vb, 0), vb2_get_plane_payload(vb, 0));
 778
 779         spin_lock_irq(&priv->lock);
 780
 781         list_add_tail(to_buf_list(vbuf), &priv->capture);
 782         rcar_vin_fill_hw_slot(priv);
 783
 784         /* If we weren't running, and have enough buffers, start capturing! */
 785         if (priv->state != RUNNING && rcar_vin_hw_ready(priv)) {
 786                 if (rcar_vin_setup(priv)) {
 787                         /* Submit error */
 788                         list_del_init(to_buf_list(vbuf));
 789                         spin_unlock_irq(&priv->lock);
 790                         goto error;
 791                 }
 792                 priv->request_to_stop = false;
 793                 init_completion(&priv->capture_stop);
 794                 priv->state = RUNNING;
 795                 rcar_vin_capture(priv);
 796         }
 797
 798         spin_unlock_irq(&priv->lock);
 799
 800         return;
 801
 802 error:
 803         vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
 804 }
 805
 806 /*
 807  * Wait for capture to stop and all in-flight buffers to be finished with by
 808  * the video hardware. This must be called under &priv->lock
 809  *
 810  */
 811 static void rcar_vin_wait_stop_streaming(struct rcar_vin_priv *priv)
 812 {
 813         while (priv->state != STOPPED) {
 814                 /* issue stop if running */
 815                 if (priv->state == RUNNING)
 816                         rcar_vin_request_capture_stop(priv);
 817
 818                 /* wait until capturing has been stopped */
 819                 if (priv->state == STOPPING) {
 820                         priv->request_to_stop = true;
 821                         spin_unlock_irq(&priv->lock);
 822                         if (!wait_for_completion_timeout(
 823                                         &priv->capture_stop,
 824                                         msecs_to_jiffies(TIMEOUT_MS)))
 825                                 priv->state = STOPPED;
 826                         spin_lock_irq(&priv->lock);
 827                 }
 828         }
 829 }
 830
 831 static void rcar_vin_stop_streaming(struct vb2_queue *vq)
 832 {
 833         struct soc_camera_device *icd = soc_camera_from_vb2q(vq);
 834         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
 835         struct rcar_vin_priv *priv = ici->priv;
 836         struct list_head *buf_head, *tmp;
 837         int i;
 838
 839         spin_lock_irq(&priv->lock);
 840         rcar_vin_wait_stop_streaming(priv);
 841
 842         for (i = 0; i < MAX_BUFFER_NUM; i++) {
 843                 if (priv->queue_buf[i]) {
 844                         vb2_buffer_done(&priv->queue_buf[i]->vb2_buf,
 845                                         VB2_BUF_STATE_ERROR);
 846                         priv->queue_buf[i] = NULL;
 847                 }
 848         }
 849
 850         list_for_each_safe(buf_head, tmp, &priv->capture) {
 851                 vb2_buffer_done(&list_entry(buf_head,
 852                                 struct rcar_vin_buffer, list)->vb.vb2_buf,
 853                                 VB2_BUF_STATE_ERROR);
 854                 list_del_init(buf_head);
 855         }
 856         spin_unlock_irq(&priv->lock);
 857 }
 858
 859 static struct vb2_ops rcar_vin_vb2_ops = {
 860         .queue_setup    = rcar_vin_videobuf_setup,
 861         .buf_queue      = rcar_vin_videobuf_queue,
 862         .stop_streaming = rcar_vin_stop_streaming,
 863         .wait_prepare   = vb2_ops_wait_prepare,
 864         .wait_finish    = vb2_ops_wait_finish,
 865 };
 866
 867 static irqreturn_t rcar_vin_irq(int irq, void *data)
 868 {
 869         struct rcar_vin_priv *priv = data;
 870         u32 int_status;
 871         bool can_run = false, hw_stopped;
 872         int slot;
 873         unsigned int handled = 0;
 874
 875         spin_lock(&priv->lock);
 876
 877         int_status = ioread32(priv->base + VNINTS_REG);
 878         if (!int_status)
 879                 goto done;
 880         /* ack interrupts */
 881         iowrite32(int_status, priv->base + VNINTS_REG);
 882         handled = 1;
 883
 884         /* nothing to do if capture status is 'STOPPED' */
 885         if (priv->state == STOPPED)
 886                 goto done;
 887
 888         hw_stopped = !(ioread32(priv->base + VNMS_REG) & VNMS_CA);
 889
 890         if (!priv->request_to_stop) {
 891                 if (is_continuous_transfer(priv))
 892                         slot = (ioread32(priv->base + VNMS_REG) &
 893                                 VNMS_FBS_MASK) >> VNMS_FBS_SHIFT;
 894                 else
 895                         slot = 0;
 896
 897                 priv->queue_buf[slot]->field = priv->field;
 898                 priv->queue_buf[slot]->sequence = priv->sequence++;
 899                 priv->queue_buf[slot]->vb2_buf.timestamp = ktime_get_ns();
 900                 vb2_buffer_done(&priv->queue_buf[slot]->vb2_buf,
 901                                 VB2_BUF_STATE_DONE);
 902                 priv->queue_buf[slot] = NULL;
 903
 904                 if (priv->state != STOPPING)
 905                         can_run = rcar_vin_fill_hw_slot(priv);
 906
 907                 if (hw_stopped || !can_run) {
 908                         priv->state = STOPPED;
 909                 } else if (is_continuous_transfer(priv) &&
 910                            list_empty(&priv->capture) &&
 911                            priv->state == RUNNING) {
 912                         /*
 913                          * The continuous capturing requires an explicit stop
 914                          * operation when there is no buffer to be set into
 915                          * the VnMBm registers.
 916                          */
 917                         rcar_vin_request_capture_stop(priv);
 918                 } else {
 919                         rcar_vin_capture(priv);
 920                 }
 921
 922         } else if (hw_stopped) {
 923                 priv->state = STOPPED;
 924                 priv->request_to_stop = false;
 925                 complete(&priv->capture_stop);
 926         }
 927
 928 done:
 929         spin_unlock(&priv->lock);
 930
 931         return IRQ_RETVAL(handled);
 932 }
 933
 934 static int rcar_vin_add_device(struct soc_camera_device *icd)
 935 {
 936         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
 937         struct rcar_vin_priv *priv = ici->priv;
 938         int i;
 939
 940         for (i = 0; i < MAX_BUFFER_NUM; i++)
 941                 priv->queue_buf[i] = NULL;
 942
 943         pm_runtime_get_sync(ici->v4l2_dev.dev);
 944
 945         dev_dbg(icd->parent, "R-Car VIN driver attached to camera %d\n",
 946                 icd->devnum);
 947
 948         return 0;
 949 }
 950
 951 static void rcar_vin_remove_device(struct soc_camera_device *icd)
 952 {
 953         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
 954         struct rcar_vin_priv *priv = ici->priv;
 955         struct vb2_v4l2_buffer *vbuf;
 956         int i;
 957
 958         /* disable capture, disable interrupts */
 959         iowrite32(ioread32(priv->base + VNMC_REG) & ~VNMC_ME,
 960                   priv->base + VNMC_REG);
 961         iowrite32(0, priv->base + VNIE_REG);
 962
 963         priv->state = STOPPED;
 964         priv->request_to_stop = false;
 965
 966         /* make sure active buffer is cancelled */
 967         spin_lock_irq(&priv->lock);
 968         for (i = 0; i < MAX_BUFFER_NUM; i++) {
 969                 vbuf = priv->queue_buf[i];
 970                 if (vbuf) {
 971                         list_del_init(to_buf_list(vbuf));
 972                         vb2_buffer_done(&vbuf->vb2_buf, VB2_BUF_STATE_ERROR);
 973                 }
 974         }
 975         spin_unlock_irq(&priv->lock);
 976
 977         pm_runtime_put(ici->v4l2_dev.dev);
 978
 979         dev_dbg(icd->parent, "R-Car VIN driver detached from camera %d\n",
 980                 icd->devnum);
 981 }
 982
 983 static void set_coeff(struct rcar_vin_priv *priv, unsigned short xs)
 984 {
 985         int i;
 986         const struct vin_coeff *p_prev_set = NULL;
 987         const struct vin_coeff *p_set = NULL;
 988
 989         /* Look for suitable coefficient values */
 990         for (i = 0; i < ARRAY_SIZE(vin_coeff_set); i++) {
 991                 p_prev_set = p_set;
 992                 p_set = &vin_coeff_set[i];
 993
 994                 if (xs < p_set->xs_value)
 995                         break;
 996         }
 997
 998         /* Use previous value if its XS value is closer */
 999         if (p_prev_set && p_set &&
1000             xs - p_prev_set->xs_value < p_set->xs_value - xs)
1001                 p_set = p_prev_set;
1002
1003         /* Set coefficient registers */
1004         iowrite32(p_set->coeff_set[0], priv->base + VNC1A_REG);
1005         iowrite32(p_set->coeff_set[1], priv->base + VNC1B_REG);
1006         iowrite32(p_set->coeff_set[2], priv->base + VNC1C_REG);
1007
1008         iowrite32(p_set->coeff_set[3], priv->base + VNC2A_REG);
1009         iowrite32(p_set->coeff_set[4], priv->base + VNC2B_REG);
1010         iowrite32(p_set->coeff_set[5], priv->base + VNC2C_REG);
1011
1012         iowrite32(p_set->coeff_set[6], priv->base + VNC3A_REG);
1013         iowrite32(p_set->coeff_set[7], priv->base + VNC3B_REG);
1014         iowrite32(p_set->coeff_set[8], priv->base + VNC3C_REG);
1015
1016         iowrite32(p_set->coeff_set[9], priv->base + VNC4A_REG);
1017         iowrite32(p_set->coeff_set[10], priv->base + VNC4B_REG);
1018         iowrite32(p_set->coeff_set[11], priv->base + VNC4C_REG);
1019
1020         iowrite32(p_set->coeff_set[12], priv->base + VNC5A_REG);
1021         iowrite32(p_set->coeff_set[13], priv->base + VNC5B_REG);
1022         iowrite32(p_set->coeff_set[14], priv->base + VNC5C_REG);
1023
1024         iowrite32(p_set->coeff_set[15], priv->base + VNC6A_REG);
1025         iowrite32(p_set->coeff_set[16], priv->base + VNC6B_REG);
1026         iowrite32(p_set->coeff_set[17], priv->base + VNC6C_REG);
1027
1028         iowrite32(p_set->coeff_set[18], priv->base + VNC7A_REG);
1029         iowrite32(p_set->coeff_set[19], priv->base + VNC7B_REG);
1030         iowrite32(p_set->coeff_set[20], priv->base + VNC7C_REG);
1031
1032         iowrite32(p_set->coeff_set[21], priv->base + VNC8A_REG);
1033         iowrite32(p_set->coeff_set[22], priv->base + VNC8B_REG);
1034         iowrite32(p_set->coeff_set[23], priv->base + VNC8C_REG);
1035 }
1036
1037 /* rect is guaranteed to not exceed the scaled camera rectangle */
1038 static int rcar_vin_set_rect(struct soc_camera_device *icd)
1039 {
1040         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1041         struct rcar_vin_cam *cam = icd->host_priv;
1042         struct rcar_vin_priv *priv = ici->priv;
1043         unsigned int left_offset, top_offset;
1044         unsigned char dsize = 0;
1045         struct v4l2_rect *cam_subrect = &cam->subrect;
1046         u32 value;
1047
1048         dev_dbg(icd->parent, "Crop %ux%u@%u:%u\n",
1049                 icd->user_width, icd->user_height, cam->vin_left, cam->vin_top);
1050
1051         left_offset = cam->vin_left;
1052         top_offset = cam->vin_top;
1053
1054         if (icd->current_fmt->host_fmt->fourcc == V4L2_PIX_FMT_RGB32 &&
1055             priv->chip == RCAR_E1)
1056                 dsize = 1;
1057
1058         dev_dbg(icd->parent, "Cam %ux%u@%u:%u\n",
1059                 cam->width, cam->height, cam->vin_left, cam->vin_top);
1060         dev_dbg(icd->parent, "Cam subrect %ux%u@%u:%u\n",
1061                 cam_subrect->width, cam_subrect->height,
1062                 cam_subrect->left, cam_subrect->top);
1063
1064         /* Set Start/End Pixel/Line Pre-Clip */
1065         iowrite32(left_offset << dsize, priv->base + VNSPPRC_REG);
1066         iowrite32((left_offset + cam_subrect->width - 1) << dsize,
1067                   priv->base + VNEPPRC_REG);
1068         switch (priv->field) {
1069         case V4L2_FIELD_INTERLACED:
1070         case V4L2_FIELD_INTERLACED_TB:
1071         case V4L2_FIELD_INTERLACED_BT:
1072                 iowrite32(top_offset / 2, priv->base + VNSLPRC_REG);
1073                 iowrite32((top_offset + cam_subrect->height) / 2 - 1,
1074                           priv->base + VNELPRC_REG);
1075                 break;
1076         default:
1077                 iowrite32(top_offset, priv->base + VNSLPRC_REG);
1078                 iowrite32(top_offset + cam_subrect->height - 1,
1079                           priv->base + VNELPRC_REG);
1080                 break;
1081         }
1082
1083         /* Set scaling coefficient */
1084         value = 0;
1085         if (cam_subrect->height != cam->out_height)
1086                 value = (4096 * cam_subrect->height) / cam->out_height;
1087         dev_dbg(icd->parent, "YS Value: %x\n", value);
1088         iowrite32(value, priv->base + VNYS_REG);
1089
1090         value = 0;
1091         if (cam_subrect->width != cam->out_width)
1092                 value = (4096 * cam_subrect->width) / cam->out_width;
1093
1094         /* Horizontal upscaling is up to double size */
1095         if (0 < value && value < 2048)
1096                 value = 2048;
1097
1098         dev_dbg(icd->parent, "XS Value: %x\n", value);
1099         iowrite32(value, priv->base + VNXS_REG);
1100
1101         /* Horizontal upscaling is carried out by scaling down from double size */
1102         if (value < 4096)
1103                 value *= 2;
1104
1105         set_coeff(priv, value);
1106
1107         /* Set Start/End Pixel/Line Post-Clip */
1108         iowrite32(0, priv->base + VNSPPOC_REG);
1109         iowrite32(0, priv->base + VNSLPOC_REG);
1110         iowrite32((cam->out_width - 1) << dsize, priv->base + VNEPPOC_REG);
1111         switch (priv->field) {
1112         case V4L2_FIELD_INTERLACED:
1113         case V4L2_FIELD_INTERLACED_TB:
1114         case V4L2_FIELD_INTERLACED_BT:
1115                 iowrite32(cam->out_height / 2 - 1,
1116                           priv->base + VNELPOC_REG);
1117                 break;
1118         default:
1119                 iowrite32(cam->out_height - 1, priv->base + VNELPOC_REG);
1120                 break;
1121         }
1122
1123         iowrite32(ALIGN(cam->out_width, 0x10), priv->base + VNIS_REG);
1124
1125         return 0;
1126 }
1127
1128 static void capture_stop_preserve(struct rcar_vin_priv *priv, u32 *vnmc)
1129 {
1130         *vnmc = ioread32(priv->base + VNMC_REG);
1131         /* module disable */
1132         iowrite32(*vnmc & ~VNMC_ME, priv->base + VNMC_REG);
1133 }
1134
1135 static void capture_restore(struct rcar_vin_priv *priv, u32 vnmc)
1136 {
1137         unsigned long timeout = jiffies + 10 * HZ;
1138
1139         /*
1140          * Wait until the end of the current frame. It can take a long time,
1141          * but if it has been aborted by a MRST1 reset, it should exit sooner.
1142          */
1143         while ((ioread32(priv->base + VNMS_REG) & VNMS_AV) &&
1144                 time_before(jiffies, timeout))
1145                 msleep(1);
1146
1147         if (time_after(jiffies, timeout)) {
1148                 dev_err(priv->ici.v4l2_dev.dev,
1149                         "Timeout waiting for frame end! Interface problem?\n");
1150                 return;
1151         }
1152
1153         iowrite32(vnmc, priv->base + VNMC_REG);
1154 }
1155
1156 #define VIN_MBUS_FLAGS  (V4L2_MBUS_MASTER |             \
1157                          V4L2_MBUS_PCLK_SAMPLE_RISING | \
1158                          V4L2_MBUS_HSYNC_ACTIVE_HIGH |  \
1159                          V4L2_MBUS_HSYNC_ACTIVE_LOW |   \
1160                          V4L2_MBUS_VSYNC_ACTIVE_HIGH |  \
1161                          V4L2_MBUS_VSYNC_ACTIVE_LOW |   \
1162                          V4L2_MBUS_DATA_ACTIVE_HIGH)
1163
1164 static int rcar_vin_set_bus_param(struct soc_camera_device *icd)
1165 {
1166         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1167         struct rcar_vin_priv *priv = ici->priv;
1168         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1169         struct v4l2_mbus_config cfg;
1170         unsigned long common_flags;
1171         u32 vnmc;
1172         u32 val;
1173         int ret;
1174
1175         capture_stop_preserve(priv, &vnmc);
1176
1177         ret = v4l2_subdev_call(sd, video, g_mbus_config, &cfg);
1178         if (!ret) {
1179                 common_flags = soc_mbus_config_compatible(&cfg, VIN_MBUS_FLAGS);
1180                 if (!common_flags) {
1181                         dev_warn(icd->parent,
1182                                  "MBUS flags incompatible: camera 0x%x, host 0x%x\n",
1183                                  cfg.flags, VIN_MBUS_FLAGS);
1184                         return -EINVAL;
1185                 }
1186         } else if (ret != -ENOIOCTLCMD) {
1187                 return ret;
1188         } else {
1189                 common_flags = VIN_MBUS_FLAGS;
1190         }
1191
1192         /* Make choises, based on platform preferences */
1193         if ((common_flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH) &&
1194             (common_flags & V4L2_MBUS_HSYNC_ACTIVE_LOW)) {
1195                 if (priv->pdata_flags & RCAR_VIN_HSYNC_ACTIVE_LOW)
1196                         common_flags &= ~V4L2_MBUS_HSYNC_ACTIVE_HIGH;
1197                 else
1198                         common_flags &= ~V4L2_MBUS_HSYNC_ACTIVE_LOW;
1199         }
1200
1201         if ((common_flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH) &&
1202             (common_flags & V4L2_MBUS_VSYNC_ACTIVE_LOW)) {
1203                 if (priv->pdata_flags & RCAR_VIN_VSYNC_ACTIVE_LOW)
1204                         common_flags &= ~V4L2_MBUS_VSYNC_ACTIVE_HIGH;
1205                 else
1206                         common_flags &= ~V4L2_MBUS_VSYNC_ACTIVE_LOW;
1207         }
1208
1209         cfg.flags = common_flags;
1210         ret = v4l2_subdev_call(sd, video, s_mbus_config, &cfg);
1211         if (ret < 0 && ret != -ENOIOCTLCMD)
1212                 return ret;
1213
1214         val = VNDMR2_FTEV | VNDMR2_VLV(1);
1215         if (!(common_flags & V4L2_MBUS_VSYNC_ACTIVE_LOW))
1216                 val |= VNDMR2_VPS;
1217         if (!(common_flags & V4L2_MBUS_HSYNC_ACTIVE_LOW))
1218                 val |= VNDMR2_HPS;
1219         iowrite32(val, priv->base + VNDMR2_REG);
1220
1221         ret = rcar_vin_set_rect(icd);
1222         if (ret < 0)
1223                 return ret;
1224
1225         capture_restore(priv, vnmc);
1226
1227         return 0;
1228 }
1229
1230 static int rcar_vin_try_bus_param(struct soc_camera_device *icd,
1231                                   unsigned char buswidth)
1232 {
1233         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1234         struct v4l2_mbus_config cfg;
1235         int ret;
1236
1237         ret = v4l2_subdev_call(sd, video, g_mbus_config, &cfg);
1238         if (ret == -ENOIOCTLCMD)
1239                 return 0;
1240         else if (ret)
1241                 return ret;
1242
1243         if (buswidth > 24)
1244                 return -EINVAL;
1245
1246         /* check is there common mbus flags */
1247         ret = soc_mbus_config_compatible(&cfg, VIN_MBUS_FLAGS);
1248         if (ret)
1249                 return 0;
1250
1251         dev_warn(icd->parent,
1252                 "MBUS flags incompatible: camera 0x%x, host 0x%x\n",
1253                  cfg.flags, VIN_MBUS_FLAGS);
1254
1255         return -EINVAL;
1256 }
1257
1258 static bool rcar_vin_packing_supported(const struct soc_mbus_pixelfmt *fmt)
1259 {
1260         return  fmt->packing == SOC_MBUS_PACKING_NONE ||
1261                 (fmt->bits_per_sample > 8 &&
1262                  fmt->packing == SOC_MBUS_PACKING_EXTEND16);
1263 }
1264
1265 static const struct soc_mbus_pixelfmt rcar_vin_formats[] = {
1266         {
1267                 .fourcc                 = V4L2_PIX_FMT_NV16,
1268                 .name                   = "NV16",
1269                 .bits_per_sample        = 8,
1270                 .packing                = SOC_MBUS_PACKING_2X8_PADHI,
1271                 .order                  = SOC_MBUS_ORDER_LE,
1272                 .layout                 = SOC_MBUS_LAYOUT_PLANAR_Y_C,
1273         },
1274         {
1275                 .fourcc                 = V4L2_PIX_FMT_YUYV,
1276                 .name                   = "YUYV",
1277                 .bits_per_sample        = 16,
1278                 .packing                = SOC_MBUS_PACKING_NONE,
1279                 .order                  = SOC_MBUS_ORDER_LE,
1280                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
1281         },
1282         {
1283                 .fourcc                 = V4L2_PIX_FMT_UYVY,
1284                 .name                   = "UYVY",
1285                 .bits_per_sample        = 16,
1286                 .packing                = SOC_MBUS_PACKING_NONE,
1287                 .order                  = SOC_MBUS_ORDER_LE,
1288                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
1289         },
1290         {
1291                 .fourcc                 = V4L2_PIX_FMT_RGB565,
1292                 .name                   = "RGB565",
1293                 .bits_per_sample        = 16,
1294                 .packing                = SOC_MBUS_PACKING_NONE,
1295                 .order                  = SOC_MBUS_ORDER_LE,
1296                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
1297         },
1298         {
1299                 .fourcc                 = V4L2_PIX_FMT_RGB555X,
1300                 .name                   = "ARGB1555",
1301                 .bits_per_sample        = 16,
1302                 .packing                = SOC_MBUS_PACKING_NONE,
1303                 .order                  = SOC_MBUS_ORDER_LE,
1304                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
1305         },
1306         {
1307                 .fourcc                 = V4L2_PIX_FMT_RGB32,
1308                 .name                   = "RGB888",
1309                 .bits_per_sample        = 32,
1310                 .packing                = SOC_MBUS_PACKING_NONE,
1311                 .order                  = SOC_MBUS_ORDER_LE,
1312                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
1313         },
1314         {
1315                 .fourcc                 = V4L2_PIX_FMT_ARGB32,
1316                 .name                   = "ARGB8888",
1317                 .bits_per_sample        = 32,
1318                 .packing                = SOC_MBUS_PACKING_NONE,
1319                 .order                  = SOC_MBUS_ORDER_LE,
1320                 .layout                 = SOC_MBUS_LAYOUT_PACKED,
1321         },
1322 };
1323
1324 static int rcar_vin_get_formats(struct soc_camera_device *icd, unsigned int idx,
1325                                 struct soc_camera_format_xlate *xlate)
1326 {
1327         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1328         struct device *dev = icd->parent;
1329         int ret, k, n;
1330         int formats = 0;
1331         struct rcar_vin_cam *cam;
1332         struct v4l2_subdev_mbus_code_enum code = {
1333                 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1334                 .index = idx,
1335         };
1336         const struct soc_mbus_pixelfmt *fmt;
1337
1338         ret = v4l2_subdev_call(sd, pad, enum_mbus_code, NULL, &code);
1339         if (ret < 0)
1340                 return 0;
1341
1342         fmt = soc_mbus_get_fmtdesc(code.code);
1343         if (!fmt) {
1344                 dev_warn(dev, "unsupported format code #%u: %d\n", idx, code.code);
1345                 return 0;
1346         }
1347
1348         ret = rcar_vin_try_bus_param(icd, fmt->bits_per_sample);
1349         if (ret < 0)
1350                 return 0;
1351
1352         if (!icd->host_priv) {
1353                 struct v4l2_subdev_format fmt = {
1354                         .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1355                 };
1356                 struct v4l2_mbus_framefmt *mf = &fmt.format;
1357                 struct v4l2_rect rect;
1358                 struct device *dev = icd->parent;
1359                 int shift;
1360
1361                 ret = v4l2_subdev_call(sd, pad, get_fmt, NULL, &fmt);
1362                 if (ret < 0)
1363                         return ret;
1364
1365                 /* Cache current client geometry */
1366                 ret = soc_camera_client_g_rect(sd, &rect);
1367                 if (ret == -ENOIOCTLCMD) {
1368                         /* Sensor driver doesn't support cropping */
1369                         rect.left = 0;
1370                         rect.top = 0;
1371                         rect.width = mf->width;
1372                         rect.height = mf->height;
1373                 } else if (ret < 0) {
1374                         return ret;
1375                 }
1376
1377                 /*
1378                  * If sensor proposes too large format then try smaller ones:
1379                  * 1280x960, 640x480, 320x240
1380                  */
1381                 for (shift = 0; shift < 3; shift++) {
1382                         if (mf->width <= VIN_MAX_WIDTH &&
1383                             mf->height <= VIN_MAX_HEIGHT)
1384                                 break;
1385
1386                         mf->width = 1280 >> shift;
1387                         mf->height = 960 >> shift;
1388                         ret = v4l2_device_call_until_err(sd->v4l2_dev,
1389                                                          soc_camera_grp_id(icd),
1390                                                          pad, set_fmt, NULL,
1391                                                          &fmt);
1392                         if (ret < 0)
1393                                 return ret;
1394                 }
1395
1396                 if (shift == 3) {
1397                         dev_err(dev,
1398                                 "Failed to configure the client below %ux%u\n",
1399                                 mf->width, mf->height);
1400                         return -EIO;
1401                 }
1402
1403                 dev_dbg(dev, "camera fmt %ux%u\n", mf->width, mf->height);
1404
1405                 cam = kzalloc(sizeof(*cam), GFP_KERNEL);
1406                 if (!cam)
1407                         return -ENOMEM;
1408                 /*
1409                  * We are called with current camera crop,
1410                  * initialise subrect with it
1411                  */
1412                 cam->rect = rect;
1413                 cam->subrect = rect;
1414                 cam->width = mf->width;
1415                 cam->height = mf->height;
1416                 cam->out_width  = mf->width;
1417                 cam->out_height = mf->height;
1418
1419                 icd->host_priv = cam;
1420         } else {
1421                 cam = icd->host_priv;
1422         }
1423
1424         /* Beginning of a pass */
1425         if (!idx)
1426                 cam->extra_fmt = NULL;
1427
1428         switch (code.code) {
1429         case MEDIA_BUS_FMT_YUYV8_1X16:
1430         case MEDIA_BUS_FMT_YUYV8_2X8:
1431         case MEDIA_BUS_FMT_YUYV10_2X10:
1432         case MEDIA_BUS_FMT_RGB888_1X24:
1433                 if (cam->extra_fmt)
1434                         break;
1435
1436                 /* Add all our formats that can be generated by VIN */
1437                 cam->extra_fmt = rcar_vin_formats;
1438
1439                 n = ARRAY_SIZE(rcar_vin_formats);
1440                 formats += n;
1441                 for (k = 0; xlate && k < n; k++, xlate++) {
1442                         xlate->host_fmt = &rcar_vin_formats[k];
1443                         xlate->code = code.code;
1444                         dev_dbg(dev, "Providing format %s using code %d\n",
1445                                 rcar_vin_formats[k].name, code.code);
1446                 }
1447                 break;
1448         default:
1449                 if (!rcar_vin_packing_supported(fmt))
1450                         return 0;
1451
1452                 dev_dbg(dev, "Providing format %s in pass-through mode\n",
1453                         fmt->name);
1454                 break;
1455         }
1456
1457         /* Generic pass-through */
1458         formats++;
1459         if (xlate) {
1460                 xlate->host_fmt = fmt;
1461                 xlate->code = code.code;
1462                 xlate++;
1463         }
1464
1465         return formats;
1466 }
1467
1468 static void rcar_vin_put_formats(struct soc_camera_device *icd)
1469 {
1470         kfree(icd->host_priv);
1471         icd->host_priv = NULL;
1472 }
1473
1474 static int rcar_vin_set_crop(struct soc_camera_device *icd,
1475                              const struct v4l2_crop *a)
1476 {
1477         struct v4l2_crop a_writable = *a;
1478         const struct v4l2_rect *rect = &a_writable.c;
1479         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1480         struct rcar_vin_priv *priv = ici->priv;
1481         struct v4l2_crop cam_crop;
1482         struct rcar_vin_cam *cam = icd->host_priv;
1483         struct v4l2_rect *cam_rect = &cam_crop.c;
1484         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1485         struct device *dev = icd->parent;
1486         struct v4l2_subdev_format fmt = {
1487                 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1488         };
1489         struct v4l2_mbus_framefmt *mf = &fmt.format;
1490         u32 vnmc;
1491         int ret, i;
1492
1493         dev_dbg(dev, "S_CROP(%ux%u@%u:%u)\n", rect->width, rect->height,
1494                 rect->left, rect->top);
1495
1496         /* During camera cropping its output window can change too, stop VIN */
1497         capture_stop_preserve(priv, &vnmc);
1498         dev_dbg(dev, "VNMC_REG 0x%x\n", vnmc);
1499
1500         /* Apply iterative camera S_CROP for new input window. */
1501         ret = soc_camera_client_s_crop(sd, &a_writable, &cam_crop,
1502                                        &cam->rect, &cam->subrect);
1503         if (ret < 0)
1504                 return ret;
1505
1506         dev_dbg(dev, "camera cropped to %ux%u@%u:%u\n",
1507                 cam_rect->width, cam_rect->height,
1508                 cam_rect->left, cam_rect->top);
1509
1510         /* On success cam_crop contains current camera crop */
1511
1512         /* Retrieve camera output window */
1513         ret = v4l2_subdev_call(sd, pad, get_fmt, NULL, &fmt);
1514         if (ret < 0)
1515                 return ret;
1516
1517         if (mf->width > VIN_MAX_WIDTH || mf->height > VIN_MAX_HEIGHT)
1518                 return -EINVAL;
1519
1520         /* Cache camera output window */
1521         cam->width = mf->width;
1522         cam->height = mf->height;
1523
1524         icd->user_width  = cam->width;
1525         icd->user_height = cam->height;
1526
1527         cam->vin_left = rect->left & ~1;
1528         cam->vin_top = rect->top & ~1;
1529
1530         /* Use VIN cropping to crop to the new window. */
1531         ret = rcar_vin_set_rect(icd);
1532         if (ret < 0)
1533                 return ret;
1534
1535         cam->subrect = *rect;
1536
1537         dev_dbg(dev, "VIN cropped to %ux%u@%u:%u\n",
1538                 icd->user_width, icd->user_height,
1539                 cam->vin_left, cam->vin_top);
1540
1541         /* Restore capture */
1542         for (i = 0; i < MAX_BUFFER_NUM; i++) {
1543                 if (priv->queue_buf[i] && priv->state == STOPPED) {
1544                         vnmc |= VNMC_ME;
1545                         break;
1546                 }
1547         }
1548         capture_restore(priv, vnmc);
1549
1550         /* Even if only camera cropping succeeded */
1551         return ret;
1552 }
1553
1554 static int rcar_vin_get_crop(struct soc_camera_device *icd,
1555                              struct v4l2_crop *a)
1556 {
1557         struct rcar_vin_cam *cam = icd->host_priv;
1558
1559         a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1560         a->c = cam->subrect;
1561
1562         return 0;
1563 }
1564
1565 /* Similar to set_crop multistage iterative algorithm */
1566 static int rcar_vin_set_fmt(struct soc_camera_device *icd,
1567                             struct v4l2_format *f)
1568 {
1569         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1570         struct rcar_vin_priv *priv = ici->priv;
1571         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1572         struct rcar_vin_cam *cam = icd->host_priv;
1573         struct v4l2_pix_format *pix = &f->fmt.pix;
1574         struct v4l2_mbus_framefmt mf;
1575         struct device *dev = icd->parent;
1576         __u32 pixfmt = pix->pixelformat;
1577         const struct soc_camera_format_xlate *xlate;
1578         unsigned int vin_sub_width = 0, vin_sub_height = 0;
1579         int ret;
1580         bool can_scale;
1581         enum v4l2_field field;
1582         v4l2_std_id std;
1583
1584         dev_dbg(dev, "S_FMT(pix=0x%x, %ux%u)\n",
1585                 pixfmt, pix->width, pix->height);
1586
1587         switch (pix->field) {
1588         default:
1589                 pix->field = V4L2_FIELD_NONE;
1590                 /* fall-through */
1591         case V4L2_FIELD_NONE:
1592         case V4L2_FIELD_TOP:
1593         case V4L2_FIELD_BOTTOM:
1594         case V4L2_FIELD_INTERLACED_TB:
1595         case V4L2_FIELD_INTERLACED_BT:
1596                 field = pix->field;
1597                 break;
1598         case V4L2_FIELD_INTERLACED:
1599                 /* Query for standard if not explicitly mentioned _TB/_BT */
1600                 ret = v4l2_subdev_call(sd, video, querystd, &std);
1601                 if (ret == -ENOIOCTLCMD) {
1602                         field = V4L2_FIELD_NONE;
1603                 } else if (ret < 0) {
1604                         return ret;
1605                 } else {
1606                         field = std & V4L2_STD_625_50 ?
1607                                 V4L2_FIELD_INTERLACED_TB :
1608                                 V4L2_FIELD_INTERLACED_BT;
1609                 }
1610                 break;
1611         }
1612
1613         xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
1614         if (!xlate) {
1615                 dev_warn(dev, "Format %x not found\n", pixfmt);
1616                 return -EINVAL;
1617         }
1618         /* Calculate client output geometry */
1619         soc_camera_calc_client_output(icd, &cam->rect, &cam->subrect, pix, &mf,
1620                                       12);
1621         mf.field = pix->field;
1622         mf.colorspace = pix->colorspace;
1623         mf.code  = xlate->code;
1624
1625         switch (pixfmt) {
1626         case V4L2_PIX_FMT_RGB32:
1627                 can_scale = priv->chip != RCAR_E1;
1628                 break;
1629         case V4L2_PIX_FMT_ARGB32:
1630         case V4L2_PIX_FMT_UYVY:
1631         case V4L2_PIX_FMT_YUYV:
1632         case V4L2_PIX_FMT_RGB565:
1633         case V4L2_PIX_FMT_RGB555X:
1634                 can_scale = true;
1635                 break;
1636         default:
1637                 can_scale = false;
1638                 break;
1639         }
1640
1641         dev_dbg(dev, "request camera output %ux%u\n", mf.width, mf.height);
1642
1643         ret = soc_camera_client_scale(icd, &cam->rect, &cam->subrect,
1644                                       &mf, &vin_sub_width, &vin_sub_height,
1645                                       can_scale, 12);
1646
1647         /* Done with the camera. Now see if we can improve the result */
1648         dev_dbg(dev, "Camera %d fmt %ux%u, requested %ux%u\n",
1649                 ret, mf.width, mf.height, pix->width, pix->height);
1650
1651         if (ret == -ENOIOCTLCMD)
1652                 dev_dbg(dev, "Sensor doesn't support scaling\n");
1653         else if (ret < 0)
1654                 return ret;
1655
1656         if (mf.code != xlate->code)
1657                 return -EINVAL;
1658
1659         /* Prepare VIN crop */
1660         cam->width = mf.width;
1661         cam->height = mf.height;
1662
1663         /* Use VIN scaling to scale to the requested user window. */
1664
1665         /* We cannot scale up */
1666         if (pix->width > vin_sub_width)
1667                 vin_sub_width = pix->width;
1668
1669         if (pix->height > vin_sub_height)
1670                 vin_sub_height = pix->height;
1671
1672         pix->colorspace = mf.colorspace;
1673
1674         if (!can_scale) {
1675                 pix->width = vin_sub_width;
1676                 pix->height = vin_sub_height;
1677         }
1678
1679         /*
1680          * We have calculated CFLCR, the actual configuration will be performed
1681          * in rcar_vin_set_bus_param()
1682          */
1683
1684         dev_dbg(dev, "W: %u : %u, H: %u : %u\n",
1685                 vin_sub_width, pix->width, vin_sub_height, pix->height);
1686
1687         cam->out_width = pix->width;
1688         cam->out_height = pix->height;
1689
1690         icd->current_fmt = xlate;
1691
1692         priv->field = field;
1693
1694         return 0;
1695 }
1696
1697 static int rcar_vin_try_fmt(struct soc_camera_device *icd,
1698                             struct v4l2_format *f)
1699 {
1700         const struct soc_camera_format_xlate *xlate;
1701         struct v4l2_pix_format *pix = &f->fmt.pix;
1702         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1703         struct v4l2_subdev_pad_config pad_cfg;
1704         struct v4l2_subdev_format format = {
1705                 .which = V4L2_SUBDEV_FORMAT_TRY,
1706         };
1707         struct v4l2_mbus_framefmt *mf = &format.format;
1708         __u32 pixfmt = pix->pixelformat;
1709         int width, height;
1710         int ret;
1711
1712         xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
1713         if (!xlate) {
1714                 xlate = icd->current_fmt;
1715                 dev_dbg(icd->parent, "Format %x not found, keeping %x\n",
1716                         pixfmt, xlate->host_fmt->fourcc);
1717                 pixfmt = xlate->host_fmt->fourcc;
1718                 pix->pixelformat = pixfmt;
1719                 pix->colorspace = icd->colorspace;
1720         }
1721
1722         /* FIXME: calculate using depth and bus width */
1723         v4l_bound_align_image(&pix->width, 2, VIN_MAX_WIDTH, 1,
1724                               &pix->height, 4, VIN_MAX_HEIGHT, 2, 0);
1725
1726         width = pix->width;
1727         height = pix->height;
1728
1729         /* let soc-camera calculate these values */
1730         pix->bytesperline = 0;
1731         pix->sizeimage = 0;
1732
1733         /* limit to sensor capabilities */
1734         mf->width = pix->width;
1735         mf->height = pix->height;
1736         mf->field = pix->field;
1737         mf->code = xlate->code;
1738         mf->colorspace = pix->colorspace;
1739
1740         ret = v4l2_device_call_until_err(sd->v4l2_dev, soc_camera_grp_id(icd),
1741                                          pad, set_fmt, &pad_cfg, &format);
1742         if (ret < 0)
1743                 return ret;
1744
1745         /* Adjust only if VIN cannot scale */
1746         if (pix->width > mf->width * 2)
1747                 pix->width = mf->width * 2;
1748         if (pix->height > mf->height * 3)
1749                 pix->height = mf->height * 3;
1750
1751         pix->field = mf->field;
1752         pix->colorspace = mf->colorspace;
1753
1754         if (pixfmt == V4L2_PIX_FMT_NV16) {
1755                 /* FIXME: check against rect_max after converting soc-camera */
1756                 /* We can scale precisely, need a bigger image from camera */
1757                 if (pix->width < width || pix->height < height) {
1758                         /*
1759                          * We presume, the sensor behaves sanely, i.e. if
1760                          * requested a bigger rectangle, it will not return a
1761                          * smaller one.
1762                          */
1763                         mf->width = VIN_MAX_WIDTH;
1764                         mf->height = VIN_MAX_HEIGHT;
1765                         ret = v4l2_device_call_until_err(sd->v4l2_dev,
1766                                                          soc_camera_grp_id(icd),
1767                                                          pad, set_fmt, &pad_cfg,
1768                                                          &format);
1769                         if (ret < 0) {
1770                                 dev_err(icd->parent,
1771                                         "client try_fmt() = %d\n", ret);
1772                                 return ret;
1773                         }
1774                 }
1775                 /* We will scale exactly */
1776                 if (mf->width > width)
1777                         pix->width = width;
1778                 if (mf->height > height)
1779                         pix->height = height;
1780         }
1781
1782         return ret;
1783 }
1784
1785 static unsigned int rcar_vin_poll(struct file *file, poll_table *pt)
1786 {
1787         struct soc_camera_device *icd = file->private_data;
1788
1789         return vb2_poll(&icd->vb2_vidq, file, pt);
1790 }
1791
1792 static int rcar_vin_querycap(struct soc_camera_host *ici,
1793                              struct v4l2_capability *cap)
1794 {
1795         strlcpy(cap->card, "R_Car_VIN", sizeof(cap->card));
1796         cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1797         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1798         snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s%d", DRV_NAME, ici->nr);
1799
1800         return 0;
1801 }
1802
1803 static int rcar_vin_init_videobuf2(struct vb2_queue *vq,
1804                                    struct soc_camera_device *icd)
1805 {
1806         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1807
1808         vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1809         vq->io_modes = VB2_MMAP | VB2_USERPTR;
1810         vq->drv_priv = icd;
1811         vq->ops = &rcar_vin_vb2_ops;
1812         vq->mem_ops = &vb2_dma_contig_memops;
1813         vq->buf_struct_size = sizeof(struct rcar_vin_buffer);
1814         vq->timestamp_flags  = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1815         vq->lock = &ici->host_lock;
1816         vq->dev = ici->v4l2_dev.dev;
1817
1818         return vb2_queue_init(vq);
1819 }
1820
1821 static struct soc_camera_host_ops rcar_vin_host_ops = {
1822         .owner          = THIS_MODULE,
1823         .add            = rcar_vin_add_device,
1824         .remove         = rcar_vin_remove_device,
1825         .get_formats    = rcar_vin_get_formats,
1826         .put_formats    = rcar_vin_put_formats,
1827         .get_crop       = rcar_vin_get_crop,
1828         .set_crop       = rcar_vin_set_crop,
1829         .try_fmt        = rcar_vin_try_fmt,
1830         .set_fmt        = rcar_vin_set_fmt,
1831         .poll           = rcar_vin_poll,
1832         .querycap       = rcar_vin_querycap,
1833         .set_bus_param  = rcar_vin_set_bus_param,
1834         .init_videobuf2 = rcar_vin_init_videobuf2,
1835 };
1836
1837 #ifdef CONFIG_OF
1838 static const struct of_device_id rcar_vin_of_table[] = {
1839         { .compatible = "renesas,vin-r8a7795", .data = (void *)RCAR_GEN3 },
1840         { .compatible = "renesas,vin-r8a7794", .data = (void *)RCAR_GEN2 },
1841         { .compatible = "renesas,vin-r8a7793", .data = (void *)RCAR_GEN2 },
1842         { .compatible = "renesas,vin-r8a7791", .data = (void *)RCAR_GEN2 },
1843         { .compatible = "renesas,vin-r8a7790", .data = (void *)RCAR_GEN2 },
1844         { .compatible = "renesas,vin-r8a7779", .data = (void *)RCAR_H1 },
1845         { .compatible = "renesas,vin-r8a7778", .data = (void *)RCAR_M1 },
1846         { .compatible = "renesas,rcar-gen3-vin", .data = (void *)RCAR_GEN3 },
1847         { .compatible = "renesas,rcar-gen2-vin", .data = (void *)RCAR_GEN2 },
1848         { },
1849 };
1850 MODULE_DEVICE_TABLE(of, rcar_vin_of_table);
1851 #endif
1852
1853 static int rcar_vin_probe(struct platform_device *pdev)
1854 {
1855         const struct of_device_id *match = NULL;
1856         struct rcar_vin_priv *priv;
1857         struct v4l2_of_endpoint ep;
1858         struct device_node *np;
1859         struct resource *mem;
1860         unsigned int pdata_flags;
1861         int irq, ret;
1862
1863         match = of_match_device(of_match_ptr(rcar_vin_of_table), &pdev->dev);
1864
1865         np = of_graph_get_next_endpoint(pdev->dev.of_node, NULL);
1866         if (!np) {
1867                 dev_err(&pdev->dev, "could not find endpoint\n");
1868                 return -EINVAL;
1869         }
1870
1871         ret = v4l2_of_parse_endpoint(np, &ep);
1872         if (ret) {
1873                 dev_err(&pdev->dev, "could not parse endpoint\n");
1874                 return ret;
1875         }
1876
1877         if (ep.bus_type == V4L2_MBUS_BT656)
1878                 pdata_flags = RCAR_VIN_BT656;
1879         else {
1880                 pdata_flags = 0;
1881                 if (ep.bus.parallel.flags & V4L2_MBUS_HSYNC_ACTIVE_LOW)
1882                         pdata_flags |= RCAR_VIN_HSYNC_ACTIVE_LOW;
1883                 if (ep.bus.parallel.flags & V4L2_MBUS_VSYNC_ACTIVE_LOW)
1884                         pdata_flags |= RCAR_VIN_VSYNC_ACTIVE_LOW;
1885         }
1886
1887         of_node_put(np);
1888
1889         dev_dbg(&pdev->dev, "pdata_flags = %08x\n", pdata_flags);
1890
1891         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1892         if (mem == NULL)
1893                 return -EINVAL;
1894
1895         irq = platform_get_irq(pdev, 0);
1896         if (irq <= 0)
1897                 return -EINVAL;
1898
1899         priv = devm_kzalloc(&pdev->dev, sizeof(struct rcar_vin_priv),
1900                             GFP_KERNEL);
1901         if (!priv)
1902                 return -ENOMEM;
1903
1904         priv->base = devm_ioremap_resource(&pdev->dev, mem);
1905         if (IS_ERR(priv->base))
1906                 return PTR_ERR(priv->base);
1907
1908         ret = devm_request_irq(&pdev->dev, irq, rcar_vin_irq, IRQF_SHARED,
1909                                dev_name(&pdev->dev), priv);
1910         if (ret)
1911                 return ret;
1912
1913         priv->ici.priv = priv;
1914         priv->ici.v4l2_dev.dev = &pdev->dev;
1915         priv->ici.drv_name = dev_name(&pdev->dev);
1916         priv->ici.ops = &rcar_vin_host_ops;
1917
1918         priv->pdata_flags = pdata_flags;
1919         if (!match) {
1920                 priv->ici.nr = pdev->id;
1921                 priv->chip = pdev->id_entry->driver_data;
1922         } else {
1923                 priv->ici.nr = of_alias_get_id(pdev->dev.of_node, "vin");
1924                 priv->chip = (enum chip_id)match->data;
1925         }
1926
1927         spin_lock_init(&priv->lock);
1928         INIT_LIST_HEAD(&priv->capture);
1929
1930         priv->state = STOPPED;
1931
1932         pm_suspend_ignore_children(&pdev->dev, true);
1933         pm_runtime_enable(&pdev->dev);
1934
1935         ret = soc_camera_host_register(&priv->ici);
1936         if (ret)
1937                 goto cleanup;
1938
1939         return 0;
1940
1941 cleanup:
1942         pm_runtime_disable(&pdev->dev);
1943
1944         return ret;
1945 }
1946
1947 static int rcar_vin_remove(struct platform_device *pdev)
1948 {
1949         struct soc_camera_host *soc_host = to_soc_camera_host(&pdev->dev);
1950
1951         soc_camera_host_unregister(soc_host);
1952         pm_runtime_disable(&pdev->dev);
1953
1954         return 0;
1955 }
1956
1957 static struct platform_driver rcar_vin_driver = {
1958         .probe          = rcar_vin_probe,
1959         .remove         = rcar_vin_remove,
1960         .driver         = {
1961                 .name           = DRV_NAME,
1962                 .of_match_table = of_match_ptr(rcar_vin_of_table),
1963         },
1964 };
1965
1966 module_platform_driver(rcar_vin_driver);
1967
1968 MODULE_LICENSE("GPL");
1969 MODULE_ALIAS("platform:rcar_vin");
1970 MODULE_DESCRIPTION("Renesas R-Car VIN camera host driver");