drivers/media/platform/renesas/renesas-ceu.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * V4L2 Driver for Renesas Capture Engine Unit (CEU) interface
   4  * Copyright (C) 2017-2018 Jacopo Mondi <jacopo+renesas@jmondi.org>
   5  *
   6  * Based on soc-camera driver "soc_camera/sh_mobile_ceu_camera.c"
   7  * Copyright (C) 2008 Magnus Damm
   8  *
   9  * Based on V4L2 Driver for PXA camera host - "pxa_camera.c",
  10  * Copyright (C) 2006, Sascha Hauer, Pengutronix
  11  * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
  12  */
  13
  14 #include <linux/delay.h>
  15 #include <linux/device.h>
  16 #include <linux/dma-mapping.h>
  17 #include <linux/err.h>
  18 #include <linux/errno.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/io.h>
  21 #include <linux/kernel.h>
  22 #include <linux/mm.h>
  23 #include <linux/module.h>
  24 #include <linux/of.h>
  25 #include <linux/of_graph.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/pm_runtime.h>
  28 #include <linux/slab.h>
  29 #include <linux/time.h>
  30 #include <linux/videodev2.h>
  31
  32 #include <media/v4l2-async.h>
  33 #include <media/v4l2-common.h>
  34 #include <media/v4l2-ctrls.h>
  35 #include <media/v4l2-dev.h>
  36 #include <media/v4l2-device.h>
  37 #include <media/v4l2-event.h>
  38 #include <media/v4l2-fwnode.h>
  39 #include <media/v4l2-image-sizes.h>
  40 #include <media/v4l2-ioctl.h>
  41 #include <media/v4l2-mediabus.h>
  42 #include <media/videobuf2-dma-contig.h>
  43
  44 #include <media/drv-intf/renesas-ceu.h>
  45
  46 #define DRIVER_NAME     "renesas-ceu"
  47
  48 /* CEU registers offsets and masks. */
  49 #define CEU_CAPSR       0x00 /* Capture start register                  */
  50 #define CEU_CAPCR       0x04 /* Capture control register                */
  51 #define CEU_CAMCR       0x08 /* Capture interface control register      */
  52 #define CEU_CAMOR       0x10 /* Capture interface offset register       */
  53 #define CEU_CAPWR       0x14 /* Capture interface width register        */
  54 #define CEU_CAIFR       0x18 /* Capture interface input format register */
  55 #define CEU_CRCNTR      0x28 /* CEU register control register           */
  56 #define CEU_CRCMPR      0x2c /* CEU register forcible control register  */
  57 #define CEU_CFLCR       0x30 /* Capture filter control register         */
  58 #define CEU_CFSZR       0x34 /* Capture filter size clip register       */
  59 #define CEU_CDWDR       0x38 /* Capture destination width register      */
  60 #define CEU_CDAYR       0x3c /* Capture data address Y register         */
  61 #define CEU_CDACR       0x40 /* Capture data address C register         */
  62 #define CEU_CFWCR       0x5c /* Firewall operation control register     */
  63 #define CEU_CDOCR       0x64 /* Capture data output control register    */
  64 #define CEU_CEIER       0x70 /* Capture event interrupt enable register */
  65 #define CEU_CETCR       0x74 /* Capture event flag clear register       */
  66 #define CEU_CSTSR       0x7c /* Capture status register                 */
  67 #define CEU_CSRTR       0x80 /* Capture software reset register         */
  68
  69 /* Data synchronous fetch mode. */
  70 #define CEU_CAMCR_JPEG                  BIT(4)
  71
  72 /* Input components ordering: CEU_CAMCR.DTARY field. */
  73 #define CEU_CAMCR_DTARY_8_UYVY          (0x00 << 8)
  74 #define CEU_CAMCR_DTARY_8_VYUY          (0x01 << 8)
  75 #define CEU_CAMCR_DTARY_8_YUYV          (0x02 << 8)
  76 #define CEU_CAMCR_DTARY_8_YVYU          (0x03 << 8)
  77 /* TODO: input components ordering for 16 bits input. */
  78
  79 /* Bus transfer MTU. */
  80 #define CEU_CAPCR_BUS_WIDTH256          (0x3 << 20)
  81
  82 /* Bus width configuration. */
  83 #define CEU_CAMCR_DTIF_16BITS           BIT(12)
  84
  85 /* No downsampling to planar YUV420 in image fetch mode. */
  86 #define CEU_CDOCR_NO_DOWSAMPLE          BIT(4)
  87
  88 /* Swap all input data in 8-bit, 16-bits and 32-bits units (Figure 46.45). */
  89 #define CEU_CDOCR_SWAP_ENDIANNESS       (7)
  90
  91 /* Capture reset and enable bits. */
  92 #define CEU_CAPSR_CPKIL                 BIT(16)
  93 #define CEU_CAPSR_CE                    BIT(0)
  94
  95 /* CEU operating flag bit. */
  96 #define CEU_CAPCR_CTNCP                 BIT(16)
  97 #define CEU_CSTRST_CPTON                BIT(0)
  98
  99 /* Platform specific IRQ source flags. */
 100 #define CEU_CETCR_ALL_IRQS_RZ           0x397f313
 101 #define CEU_CETCR_ALL_IRQS_SH4          0x3d7f313
 102
 103 /* Prohibited register access interrupt bit. */
 104 #define CEU_CETCR_IGRW                  BIT(4)
 105 /* One-frame capture end interrupt. */
 106 #define CEU_CEIER_CPE                   BIT(0)
 107 /* VBP error. */
 108 #define CEU_CEIER_VBP                   BIT(20)
 109 #define CEU_CEIER_MASK                  (CEU_CEIER_CPE | CEU_CEIER_VBP)
 110
 111 #define CEU_MAX_WIDTH   2560
 112 #define CEU_MAX_HEIGHT  1920
 113 #define CEU_MAX_BPL     8188
 114 #define CEU_W_MAX(w)    ((w) < CEU_MAX_WIDTH ? (w) : CEU_MAX_WIDTH)
 115 #define CEU_H_MAX(h)    ((h) < CEU_MAX_HEIGHT ? (h) : CEU_MAX_HEIGHT)
 116
 117 /*
 118  * ceu_bus_fmt - describe a 8-bits yuyv format the sensor can produce
 119  *
 120  * @mbus_code: bus format code
 121  * @fmt_order: CEU_CAMCR.DTARY ordering of input components (Y, Cb, Cr)
 122  * @fmt_order_swap: swapped CEU_CAMCR.DTARY ordering of input components
 123  *                  (Y, Cr, Cb)
 124  * @swapped: does Cr appear before Cb?
 125  * @bps: number of bits sent over bus for each sample
 126  * @bpp: number of bits per pixels unit
 127  */
 128 struct ceu_mbus_fmt {
 129         u32     mbus_code;
 130         u32     fmt_order;
 131         u32     fmt_order_swap;
 132         bool    swapped;
 133         u8      bps;
 134         u8      bpp;
 135 };
 136
 137 /*
 138  * ceu_buffer - Link vb2 buffer to the list of available buffers.
 139  */
 140 struct ceu_buffer {
 141         struct vb2_v4l2_buffer vb;
 142         struct list_head queue;
 143 };
 144
 145 static inline struct ceu_buffer *vb2_to_ceu(struct vb2_v4l2_buffer *vbuf)
 146 {
 147         return container_of(vbuf, struct ceu_buffer, vb);
 148 }
 149
 150 /*
 151  * ceu_subdev - Wraps v4l2 sub-device and provides async subdevice.
 152  */
 153 struct ceu_subdev {
 154         struct v4l2_async_connection asd;
 155         struct v4l2_subdev *v4l2_sd;
 156
 157         /* per-subdevice mbus configuration options */
 158         unsigned int mbus_flags;
 159         struct ceu_mbus_fmt mbus_fmt;
 160 };
 161
 162 static struct ceu_subdev *to_ceu_subdev(struct v4l2_async_connection *asd)
 163 {
 164         return container_of(asd, struct ceu_subdev, asd);
 165 }
 166
 167 /*
 168  * ceu_device - CEU device instance
 169  */
 170 struct ceu_device {
 171         struct device           *dev;
 172         struct video_device     vdev;
 173         struct v4l2_device      v4l2_dev;
 174
 175         /* subdevices descriptors */
 176         struct ceu_subdev       **subdevs;
 177         /* the subdevice currently in use */
 178         struct ceu_subdev       *sd;
 179         unsigned int            sd_index;
 180         unsigned int            num_sd;
 181
 182         /* platform specific mask with all IRQ sources flagged */
 183         u32                     irq_mask;
 184
 185         /* currently configured field and pixel format */
 186         enum v4l2_field field;
 187         struct v4l2_pix_format_mplane v4l2_pix;
 188
 189         /* async subdev notification helpers */
 190         struct v4l2_async_notifier notifier;
 191
 192         /* vb2 queue, capture buffer list and active buffer pointer */
 193         struct vb2_queue        vb2_vq;
 194         struct list_head        capture;
 195         struct vb2_v4l2_buffer  *active;
 196         unsigned int            sequence;
 197
 198         /* mlock - lock access to interface reset and vb2 queue */
 199         struct mutex    mlock;
 200
 201         /* lock - lock access to capture buffer queue and active buffer */
 202         spinlock_t      lock;
 203
 204         /* base - CEU memory base address */
 205         void __iomem    *base;
 206 };
 207
 208 static inline struct ceu_device *v4l2_to_ceu(struct v4l2_device *v4l2_dev)
 209 {
 210         return container_of(v4l2_dev, struct ceu_device, v4l2_dev);
 211 }
 212
 213 /* --- CEU memory output formats --- */
 214
 215 /*
 216  * ceu_fmt - describe a memory output format supported by CEU interface.
 217  *
 218  * @fourcc: memory layout fourcc format code
 219  * @bpp: number of bits for each pixel stored in memory
 220  */
 221 struct ceu_fmt {
 222         u32     fourcc;
 223         u32     bpp;
 224 };
 225
 226 /*
 227  * ceu_format_list - List of supported memory output formats
 228  *
 229  * If sensor provides any YUYV bus format, all the following planar memory
 230  * formats are available thanks to CEU re-ordering and sub-sampling
 231  * capabilities.
 232  */
 233 static const struct ceu_fmt ceu_fmt_list[] = {
 234         {
 235                 .fourcc = V4L2_PIX_FMT_NV16,
 236                 .bpp    = 16,
 237         },
 238         {
 239                 .fourcc = V4L2_PIX_FMT_NV61,
 240                 .bpp    = 16,
 241         },
 242         {
 243                 .fourcc = V4L2_PIX_FMT_NV12,
 244                 .bpp    = 12,
 245         },
 246         {
 247                 .fourcc = V4L2_PIX_FMT_NV21,
 248                 .bpp    = 12,
 249         },
 250         {
 251                 .fourcc = V4L2_PIX_FMT_YUYV,
 252                 .bpp    = 16,
 253         },
 254         {
 255                 .fourcc = V4L2_PIX_FMT_UYVY,
 256                 .bpp    = 16,
 257         },
 258         {
 259                 .fourcc = V4L2_PIX_FMT_YVYU,
 260                 .bpp    = 16,
 261         },
 262         {
 263                 .fourcc = V4L2_PIX_FMT_VYUY,
 264                 .bpp    = 16,
 265         },
 266 };
 267
 268 static const struct ceu_fmt *get_ceu_fmt_from_fourcc(unsigned int fourcc)
 269 {
 270         const struct ceu_fmt *fmt = &ceu_fmt_list[0];
 271         unsigned int i;
 272
 273         for (i = 0; i < ARRAY_SIZE(ceu_fmt_list); i++, fmt++)
 274                 if (fmt->fourcc == fourcc)
 275                         return fmt;
 276
 277         return NULL;
 278 }
 279
 280 static bool ceu_fmt_mplane(struct v4l2_pix_format_mplane *pix)
 281 {
 282         switch (pix->pixelformat) {
 283         case V4L2_PIX_FMT_YUYV:
 284         case V4L2_PIX_FMT_UYVY:
 285         case V4L2_PIX_FMT_YVYU:
 286         case V4L2_PIX_FMT_VYUY:
 287                 return false;
 288         case V4L2_PIX_FMT_NV16:
 289         case V4L2_PIX_FMT_NV61:
 290         case V4L2_PIX_FMT_NV12:
 291         case V4L2_PIX_FMT_NV21:
 292                 return true;
 293         default:
 294                 return false;
 295         }
 296 }
 297
 298 /* --- CEU HW operations --- */
 299
 300 static void ceu_write(struct ceu_device *priv, unsigned int reg_offs, u32 data)
 301 {
 302         iowrite32(data, priv->base + reg_offs);
 303 }
 304
 305 static u32 ceu_read(struct ceu_device *priv, unsigned int reg_offs)
 306 {
 307         return ioread32(priv->base + reg_offs);
 308 }
 309
 310 /*
 311  * ceu_soft_reset() - Software reset the CEU interface.
 312  * @ceu_device: CEU device.
 313  *
 314  * Returns 0 for success, -EIO for error.
 315  */
 316 static int ceu_soft_reset(struct ceu_device *ceudev)
 317 {
 318         unsigned int i;
 319
 320         ceu_write(ceudev, CEU_CAPSR, CEU_CAPSR_CPKIL);
 321
 322         for (i = 0; i < 100; i++) {
 323                 if (!(ceu_read(ceudev, CEU_CSTSR) & CEU_CSTRST_CPTON))
 324                         break;
 325                 udelay(1);
 326         }
 327
 328         if (i == 100) {
 329                 dev_err(ceudev->dev, "soft reset time out\n");
 330                 return -EIO;
 331         }
 332
 333         for (i = 0; i < 100; i++) {
 334                 if (!(ceu_read(ceudev, CEU_CAPSR) & CEU_CAPSR_CPKIL))
 335                         return 0;
 336                 udelay(1);
 337         }
 338
 339         /* If we get here, CEU has not reset properly. */
 340         return -EIO;
 341 }
 342
 343 /* --- CEU Capture Operations --- */
 344
 345 /*
 346  * ceu_hw_config() - Configure CEU interface registers.
 347  */
 348 static int ceu_hw_config(struct ceu_device *ceudev)
 349 {
 350         u32 camcr, cdocr, cfzsr, cdwdr, capwr;
 351         struct v4l2_pix_format_mplane *pix = &ceudev->v4l2_pix;
 352         struct ceu_subdev *ceu_sd = ceudev->sd;
 353         struct ceu_mbus_fmt *mbus_fmt = &ceu_sd->mbus_fmt;
 354         unsigned int mbus_flags = ceu_sd->mbus_flags;
 355
 356         /* Start configuring CEU registers */
 357         ceu_write(ceudev, CEU_CAIFR, 0);
 358         ceu_write(ceudev, CEU_CFWCR, 0);
 359         ceu_write(ceudev, CEU_CRCNTR, 0);
 360         ceu_write(ceudev, CEU_CRCMPR, 0);
 361
 362         /* Set the frame capture period for both image capture and data sync. */
 363         capwr = (pix->height << 16) | pix->width * mbus_fmt->bpp / 8;
 364
 365         /*
 366          * Swap input data endianness by default.
 367          * In data fetch mode bytes are received in chunks of 8 bytes.
 368          * D0, D1, D2, D3, D4, D5, D6, D7 (D0 received first)
 369          * The data is however by default written to memory in reverse order:
 370          * D7, D6, D5, D4, D3, D2, D1, D0 (D7 written to lowest byte)
 371          *
 372          * Use CEU_CDOCR[2:0] to swap data ordering.
 373          */
 374         cdocr = CEU_CDOCR_SWAP_ENDIANNESS;
 375
 376         /*
 377          * Configure CAMCR and CDOCR:
 378          * match input components ordering with memory output format and
 379          * handle downsampling to YUV420.
 380          *
 381          * If the memory output planar format is 'swapped' (Cr before Cb) and
 382          * input format is not, use the swapped version of CAMCR.DTARY.
 383          *
 384          * If the memory output planar format is not 'swapped' (Cb before Cr)
 385          * and input format is, use the swapped version of CAMCR.DTARY.
 386          *
 387          * CEU by default downsample to planar YUV420 (CDCOR[4] = 0).
 388          * If output is planar YUV422 set CDOCR[4] = 1
 389          *
 390          * No downsample for data fetch sync mode.
 391          */
 392         switch (pix->pixelformat) {
 393         /* Data fetch sync mode */
 394         case V4L2_PIX_FMT_YUYV:
 395         case V4L2_PIX_FMT_YVYU:
 396         case V4L2_PIX_FMT_UYVY:
 397         case V4L2_PIX_FMT_VYUY:
 398                 camcr   = CEU_CAMCR_JPEG;
 399                 cdocr   |= CEU_CDOCR_NO_DOWSAMPLE;
 400                 cfzsr   = (pix->height << 16) | pix->width;
 401                 cdwdr   = pix->plane_fmt[0].bytesperline;
 402                 break;
 403
 404         /* Non-swapped planar image capture mode. */
 405         case V4L2_PIX_FMT_NV16:
 406                 cdocr   |= CEU_CDOCR_NO_DOWSAMPLE;
 407                 fallthrough;
 408         case V4L2_PIX_FMT_NV12:
 409                 if (mbus_fmt->swapped)
 410                         camcr = mbus_fmt->fmt_order_swap;
 411                 else
 412                         camcr = mbus_fmt->fmt_order;
 413
 414                 cfzsr   = (pix->height << 16) | pix->width;
 415                 cdwdr   = pix->width;
 416                 break;
 417
 418         /* Swapped planar image capture mode. */
 419         case V4L2_PIX_FMT_NV61:
 420                 cdocr   |= CEU_CDOCR_NO_DOWSAMPLE;
 421                 fallthrough;
 422         case V4L2_PIX_FMT_NV21:
 423                 if (mbus_fmt->swapped)
 424                         camcr = mbus_fmt->fmt_order;
 425                 else
 426                         camcr = mbus_fmt->fmt_order_swap;
 427
 428                 cfzsr   = (pix->height << 16) | pix->width;
 429                 cdwdr   = pix->width;
 430                 break;
 431
 432         default:
 433                 return -EINVAL;
 434         }
 435
 436         camcr |= mbus_flags & V4L2_MBUS_VSYNC_ACTIVE_LOW ? 1 << 1 : 0;
 437         camcr |= mbus_flags & V4L2_MBUS_HSYNC_ACTIVE_LOW ? 1 << 0 : 0;
 438
 439         /* TODO: handle 16 bit bus width with DTIF bit in CAMCR */
 440         ceu_write(ceudev, CEU_CAMCR, camcr);
 441         ceu_write(ceudev, CEU_CDOCR, cdocr);
 442         ceu_write(ceudev, CEU_CAPCR, CEU_CAPCR_BUS_WIDTH256);
 443
 444         /*
 445          * TODO: make CAMOR offsets configurable.
 446          * CAMOR wants to know the number of blanks between a VS/HS signal
 447          * and valid data. This value should actually come from the sensor...
 448          */
 449         ceu_write(ceudev, CEU_CAMOR, 0);
 450
 451         /* TODO: 16 bit bus width require re-calculation of cdwdr and cfzsr */
 452         ceu_write(ceudev, CEU_CAPWR, capwr);
 453         ceu_write(ceudev, CEU_CFSZR, cfzsr);
 454         ceu_write(ceudev, CEU_CDWDR, cdwdr);
 455
 456         return 0;
 457 }
 458
 459 /*
 460  * ceu_capture() - Trigger start of a capture sequence.
 461  *
 462  * Program the CEU DMA registers with addresses where to transfer image data.
 463  */
 464 static int ceu_capture(struct ceu_device *ceudev)
 465 {
 466         struct v4l2_pix_format_mplane *pix = &ceudev->v4l2_pix;
 467         dma_addr_t phys_addr_top;
 468
 469         phys_addr_top =
 470                 vb2_dma_contig_plane_dma_addr(&ceudev->active->vb2_buf, 0);
 471         ceu_write(ceudev, CEU_CDAYR, phys_addr_top);
 472
 473         /* Ignore CbCr plane for non multi-planar image formats. */
 474         if (ceu_fmt_mplane(pix)) {
 475                 phys_addr_top =
 476                         vb2_dma_contig_plane_dma_addr(&ceudev->active->vb2_buf,
 477                                                       1);
 478                 ceu_write(ceudev, CEU_CDACR, phys_addr_top);
 479         }
 480
 481         /*
 482          * Trigger new capture start: once for each frame, as we work in
 483          * one-frame capture mode.
 484          */
 485         ceu_write(ceudev, CEU_CAPSR, CEU_CAPSR_CE);
 486
 487         return 0;
 488 }
 489
 490 static irqreturn_t ceu_irq(int irq, void *data)
 491 {
 492         struct ceu_device *ceudev = data;
 493         struct vb2_v4l2_buffer *vbuf;
 494         struct ceu_buffer *buf;
 495         u32 status;
 496
 497         /* Clean interrupt status. */
 498         status = ceu_read(ceudev, CEU_CETCR);
 499         ceu_write(ceudev, CEU_CETCR, ~ceudev->irq_mask);
 500
 501         /* Unexpected interrupt. */
 502         if (!(status & CEU_CEIER_MASK))
 503                 return IRQ_NONE;
 504
 505         spin_lock(&ceudev->lock);
 506
 507         /* Stale interrupt from a released buffer, ignore it. */
 508         vbuf = ceudev->active;
 509         if (!vbuf) {
 510                 spin_unlock(&ceudev->lock);
 511                 return IRQ_HANDLED;
 512         }
 513
 514         /*
 515          * When a VBP interrupt occurs, no capture end interrupt will occur
 516          * and the image of that frame is not captured correctly.
 517          */
 518         if (status & CEU_CEIER_VBP) {
 519                 dev_err(ceudev->dev, "VBP interrupt: abort capture\n");
 520                 goto error_irq_out;
 521         }
 522
 523         /* Prepare to return the 'previous' buffer. */
 524         vbuf->vb2_buf.timestamp = ktime_get_ns();
 525         vbuf->sequence = ceudev->sequence++;
 526         vbuf->field = ceudev->field;
 527
 528         /* Prepare a new 'active' buffer and trigger a new capture. */
 529         if (!list_empty(&ceudev->capture)) {
 530                 buf = list_first_entry(&ceudev->capture, struct ceu_buffer,
 531                                        queue);
 532                 list_del(&buf->queue);
 533                 ceudev->active = &buf->vb;
 534
 535                 ceu_capture(ceudev);
 536         }
 537
 538         /* Return the 'previous' buffer. */
 539         vb2_buffer_done(&vbuf->vb2_buf, VB2_BUF_STATE_DONE);
 540
 541         spin_unlock(&ceudev->lock);
 542
 543         return IRQ_HANDLED;
 544
 545 error_irq_out:
 546         /* Return the 'previous' buffer and all queued ones. */
 547         vb2_buffer_done(&vbuf->vb2_buf, VB2_BUF_STATE_ERROR);
 548
 549         list_for_each_entry(buf, &ceudev->capture, queue)
 550                 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
 551
 552         spin_unlock(&ceudev->lock);
 553
 554         return IRQ_HANDLED;
 555 }
 556
 557 /* --- CEU Videobuf2 operations --- */
 558
 559 static void ceu_update_plane_sizes(struct v4l2_plane_pix_format *plane,
 560                                    unsigned int bpl, unsigned int szimage)
 561 {
 562         memset(plane, 0, sizeof(*plane));
 563
 564         plane->sizeimage = szimage;
 565         if (plane->bytesperline < bpl || plane->bytesperline > CEU_MAX_BPL)
 566                 plane->bytesperline = bpl;
 567 }
 568
 569 /*
 570  * ceu_calc_plane_sizes() - Fill per-plane 'struct v4l2_plane_pix_format'
 571  *                          information according to the currently configured
 572  *                          pixel format.
 573  * @ceu_device: CEU device.
 574  * @ceu_fmt: Active image format.
 575  * @pix: Pixel format information (store line width and image sizes)
 576  */
 577 static void ceu_calc_plane_sizes(struct ceu_device *ceudev,
 578                                  const struct ceu_fmt *ceu_fmt,
 579                                  struct v4l2_pix_format_mplane *pix)
 580 {
 581         unsigned int bpl, szimage;
 582
 583         switch (pix->pixelformat) {
 584         case V4L2_PIX_FMT_YUYV:
 585         case V4L2_PIX_FMT_UYVY:
 586         case V4L2_PIX_FMT_YVYU:
 587         case V4L2_PIX_FMT_VYUY:
 588                 pix->num_planes = 1;
 589                 bpl             = pix->width * ceu_fmt->bpp / 8;
 590                 szimage         = pix->height * bpl;
 591                 ceu_update_plane_sizes(&pix->plane_fmt[0], bpl, szimage);
 592                 break;
 593
 594         case V4L2_PIX_FMT_NV12:
 595         case V4L2_PIX_FMT_NV21:
 596                 pix->num_planes = 2;
 597                 bpl             = pix->width;
 598                 szimage         = pix->height * pix->width;
 599                 ceu_update_plane_sizes(&pix->plane_fmt[0], bpl, szimage);
 600                 ceu_update_plane_sizes(&pix->plane_fmt[1], bpl, szimage / 2);
 601                 break;
 602
 603         case V4L2_PIX_FMT_NV16:
 604         case V4L2_PIX_FMT_NV61:
 605         default:
 606                 pix->num_planes = 2;
 607                 bpl             = pix->width;
 608                 szimage         = pix->height * pix->width;
 609                 ceu_update_plane_sizes(&pix->plane_fmt[0], bpl, szimage);
 610                 ceu_update_plane_sizes(&pix->plane_fmt[1], bpl, szimage);
 611                 break;
 612         }
 613 }
 614
 615 /*
 616  * ceu_vb2_setup() - is called to check whether the driver can accept the
 617  *                   requested number of buffers and to fill in plane sizes
 618  *                   for the current frame format, if required.
 619  */
 620 static int ceu_vb2_setup(struct vb2_queue *vq, unsigned int *count,
 621                          unsigned int *num_planes, unsigned int sizes[],
 622                          struct device *alloc_devs[])
 623 {
 624         struct ceu_device *ceudev = vb2_get_drv_priv(vq);
 625         struct v4l2_pix_format_mplane *pix = &ceudev->v4l2_pix;
 626         unsigned int i;
 627
 628         /* num_planes is set: just check plane sizes. */
 629         if (*num_planes) {
 630                 for (i = 0; i < pix->num_planes; i++)
 631                         if (sizes[i] < pix->plane_fmt[i].sizeimage)
 632                                 return -EINVAL;
 633
 634                 return 0;
 635         }
 636
 637         /* num_planes not set: called from REQBUFS, just set plane sizes. */
 638         *num_planes = pix->num_planes;
 639         for (i = 0; i < pix->num_planes; i++)
 640                 sizes[i] = pix->plane_fmt[i].sizeimage;
 641
 642         return 0;
 643 }
 644
 645 static void ceu_vb2_queue(struct vb2_buffer *vb)
 646 {
 647         struct ceu_device *ceudev = vb2_get_drv_priv(vb->vb2_queue);
 648         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 649         struct ceu_buffer *buf = vb2_to_ceu(vbuf);
 650         unsigned long irqflags;
 651
 652         spin_lock_irqsave(&ceudev->lock, irqflags);
 653         list_add_tail(&buf->queue, &ceudev->capture);
 654         spin_unlock_irqrestore(&ceudev->lock, irqflags);
 655 }
 656
 657 static int ceu_vb2_prepare(struct vb2_buffer *vb)
 658 {
 659         struct ceu_device *ceudev = vb2_get_drv_priv(vb->vb2_queue);
 660         struct v4l2_pix_format_mplane *pix = &ceudev->v4l2_pix;
 661         unsigned int i;
 662
 663         for (i = 0; i < pix->num_planes; i++) {
 664                 if (vb2_plane_size(vb, i) < pix->plane_fmt[i].sizeimage) {
 665                         dev_err(ceudev->dev,
 666                                 "Plane size too small (%lu < %u)\n",
 667                                 vb2_plane_size(vb, i),
 668                                 pix->plane_fmt[i].sizeimage);
 669                         return -EINVAL;
 670                 }
 671
 672                 vb2_set_plane_payload(vb, i, pix->plane_fmt[i].sizeimage);
 673         }
 674
 675         return 0;
 676 }
 677
 678 static int ceu_start_streaming(struct vb2_queue *vq, unsigned int count)
 679 {
 680         struct ceu_device *ceudev = vb2_get_drv_priv(vq);
 681         struct v4l2_subdev *v4l2_sd = ceudev->sd->v4l2_sd;
 682         struct ceu_buffer *buf;
 683         unsigned long irqflags;
 684         int ret;
 685
 686         /* Program the CEU interface according to the CEU image format. */
 687         ret = ceu_hw_config(ceudev);
 688         if (ret)
 689                 goto error_return_bufs;
 690
 691         ret = v4l2_subdev_call(v4l2_sd, video, s_stream, 1);
 692         if (ret && ret != -ENOIOCTLCMD) {
 693                 dev_dbg(ceudev->dev,
 694                         "Subdevice failed to start streaming: %d\n", ret);
 695                 goto error_return_bufs;
 696         }
 697
 698         spin_lock_irqsave(&ceudev->lock, irqflags);
 699         ceudev->sequence = 0;
 700
 701         /* Grab the first available buffer and trigger the first capture. */
 702         buf = list_first_entry(&ceudev->capture, struct ceu_buffer,
 703                                queue);
 704
 705         list_del(&buf->queue);
 706         ceudev->active = &buf->vb;
 707
 708         /* Clean and program interrupts for first capture. */
 709         ceu_write(ceudev, CEU_CETCR, ~ceudev->irq_mask);
 710         ceu_write(ceudev, CEU_CEIER, CEU_CEIER_MASK);
 711
 712         ceu_capture(ceudev);
 713
 714         spin_unlock_irqrestore(&ceudev->lock, irqflags);
 715
 716         return 0;
 717
 718 error_return_bufs:
 719         spin_lock_irqsave(&ceudev->lock, irqflags);
 720         list_for_each_entry(buf, &ceudev->capture, queue)
 721                 vb2_buffer_done(&ceudev->active->vb2_buf,
 722                                 VB2_BUF_STATE_QUEUED);
 723         ceudev->active = NULL;
 724         spin_unlock_irqrestore(&ceudev->lock, irqflags);
 725
 726         return ret;
 727 }
 728
 729 static void ceu_stop_streaming(struct vb2_queue *vq)
 730 {
 731         struct ceu_device *ceudev = vb2_get_drv_priv(vq);
 732         struct v4l2_subdev *v4l2_sd = ceudev->sd->v4l2_sd;
 733         struct ceu_buffer *buf;
 734         unsigned long irqflags;
 735
 736         /* Clean and disable interrupt sources. */
 737         ceu_write(ceudev, CEU_CETCR,
 738                   ceu_read(ceudev, CEU_CETCR) & ceudev->irq_mask);
 739         ceu_write(ceudev, CEU_CEIER, CEU_CEIER_MASK);
 740
 741         v4l2_subdev_call(v4l2_sd, video, s_stream, 0);
 742
 743         spin_lock_irqsave(&ceudev->lock, irqflags);
 744         if (ceudev->active) {
 745                 vb2_buffer_done(&ceudev->active->vb2_buf,
 746                                 VB2_BUF_STATE_ERROR);
 747                 ceudev->active = NULL;
 748         }
 749
 750         /* Release all queued buffers. */
 751         list_for_each_entry(buf, &ceudev->capture, queue)
 752                 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
 753         INIT_LIST_HEAD(&ceudev->capture);
 754
 755         spin_unlock_irqrestore(&ceudev->lock, irqflags);
 756
 757         ceu_soft_reset(ceudev);
 758 }
 759
 760 static const struct vb2_ops ceu_vb2_ops = {
 761         .queue_setup            = ceu_vb2_setup,
 762         .buf_queue              = ceu_vb2_queue,
 763         .buf_prepare            = ceu_vb2_prepare,
 764         .wait_prepare           = vb2_ops_wait_prepare,
 765         .wait_finish            = vb2_ops_wait_finish,
 766         .start_streaming        = ceu_start_streaming,
 767         .stop_streaming         = ceu_stop_streaming,
 768 };
 769
 770 /* --- CEU image formats handling --- */
 771
 772 /*
 773  * __ceu_try_fmt() - test format on CEU and sensor
 774  * @ceudev: The CEU device.
 775  * @v4l2_fmt: format to test.
 776  * @sd_mbus_code: the media bus code accepted by the subdevice; output param.
 777  *
 778  * Returns 0 for success, < 0 for errors.
 779  */
 780 static int __ceu_try_fmt(struct ceu_device *ceudev, struct v4l2_format *v4l2_fmt,
 781                          u32 *sd_mbus_code)
 782 {
 783         struct ceu_subdev *ceu_sd = ceudev->sd;
 784         struct v4l2_pix_format_mplane *pix = &v4l2_fmt->fmt.pix_mp;
 785         struct v4l2_subdev *v4l2_sd = ceu_sd->v4l2_sd;
 786         struct v4l2_subdev_pad_config pad_cfg;
 787         struct v4l2_subdev_state pad_state = {
 788                 .pads = &pad_cfg,
 789         };
 790         const struct ceu_fmt *ceu_fmt;
 791         u32 mbus_code_old;
 792         u32 mbus_code;
 793         int ret;
 794
 795         /*
 796          * Set format on sensor sub device: bus format used to produce memory
 797          * format is selected depending on YUV component ordering or
 798          * at initialization time.
 799          */
 800         struct v4l2_subdev_format sd_format = {
 801                 .which  = V4L2_SUBDEV_FORMAT_TRY,
 802         };
 803
 804         mbus_code_old = ceu_sd->mbus_fmt.mbus_code;
 805
 806         switch (pix->pixelformat) {
 807         case V4L2_PIX_FMT_YUYV:
 808                 mbus_code = MEDIA_BUS_FMT_YUYV8_2X8;
 809                 break;
 810         case V4L2_PIX_FMT_UYVY:
 811                 mbus_code = MEDIA_BUS_FMT_UYVY8_2X8;
 812                 break;
 813         case V4L2_PIX_FMT_YVYU:
 814                 mbus_code = MEDIA_BUS_FMT_YVYU8_2X8;
 815                 break;
 816         case V4L2_PIX_FMT_VYUY:
 817                 mbus_code = MEDIA_BUS_FMT_VYUY8_2X8;
 818                 break;
 819         case V4L2_PIX_FMT_NV16:
 820         case V4L2_PIX_FMT_NV61:
 821         case V4L2_PIX_FMT_NV12:
 822         case V4L2_PIX_FMT_NV21:
 823                 mbus_code = ceu_sd->mbus_fmt.mbus_code;
 824                 break;
 825
 826         default:
 827                 pix->pixelformat = V4L2_PIX_FMT_NV16;
 828                 mbus_code = ceu_sd->mbus_fmt.mbus_code;
 829                 break;
 830         }
 831
 832         ceu_fmt = get_ceu_fmt_from_fourcc(pix->pixelformat);
 833
 834         /* CFSZR requires height and width to be 4-pixel aligned. */
 835         v4l_bound_align_image(&pix->width, 2, CEU_MAX_WIDTH, 4,
 836                               &pix->height, 4, CEU_MAX_HEIGHT, 4, 0);
 837
 838         v4l2_fill_mbus_format_mplane(&sd_format.format, pix);
 839
 840         /*
 841          * Try with the mbus_code matching YUYV components ordering first,
 842          * if that one fails, fallback to default selected at initialization
 843          * time.
 844          */
 845         sd_format.format.code = mbus_code;
 846         ret = v4l2_subdev_call(v4l2_sd, pad, set_fmt, &pad_state, &sd_format);
 847         if (ret) {
 848                 if (ret == -EINVAL) {
 849                         /* fallback */
 850                         sd_format.format.code = mbus_code_old;
 851                         ret = v4l2_subdev_call(v4l2_sd, pad, set_fmt,
 852                                                &pad_state, &sd_format);
 853                 }
 854
 855                 if (ret)
 856                         return ret;
 857         }
 858
 859         /* Apply size returned by sensor as the CEU can't scale. */
 860         v4l2_fill_pix_format_mplane(pix, &sd_format.format);
 861
 862         /* Calculate per-plane sizes based on image format. */
 863         ceu_calc_plane_sizes(ceudev, ceu_fmt, pix);
 864
 865         /* Report to caller the configured mbus format. */
 866         *sd_mbus_code = sd_format.format.code;
 867
 868         return 0;
 869 }
 870
 871 /*
 872  * ceu_try_fmt() - Wrapper for __ceu_try_fmt; discard configured mbus_fmt
 873  */
 874 static int ceu_try_fmt(struct ceu_device *ceudev, struct v4l2_format *v4l2_fmt)
 875 {
 876         u32 mbus_code;
 877
 878         return __ceu_try_fmt(ceudev, v4l2_fmt, &mbus_code);
 879 }
 880
 881 /*
 882  * ceu_set_fmt() - Apply the supplied format to both sensor and CEU
 883  */
 884 static int ceu_set_fmt(struct ceu_device *ceudev, struct v4l2_format *v4l2_fmt)
 885 {
 886         struct ceu_subdev *ceu_sd = ceudev->sd;
 887         struct v4l2_subdev *v4l2_sd = ceu_sd->v4l2_sd;
 888         u32 mbus_code;
 889         int ret;
 890
 891         /*
 892          * Set format on sensor sub device: bus format used to produce memory
 893          * format is selected at initialization time.
 894          */
 895         struct v4l2_subdev_format format = {
 896                 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
 897         };
 898
 899         ret = __ceu_try_fmt(ceudev, v4l2_fmt, &mbus_code);
 900         if (ret)
 901                 return ret;
 902
 903         format.format.code = mbus_code;
 904         v4l2_fill_mbus_format_mplane(&format.format, &v4l2_fmt->fmt.pix_mp);
 905         ret = v4l2_subdev_call(v4l2_sd, pad, set_fmt, NULL, &format);
 906         if (ret)
 907                 return ret;
 908
 909         ceudev->v4l2_pix = v4l2_fmt->fmt.pix_mp;
 910         ceudev->field = V4L2_FIELD_NONE;
 911
 912         return 0;
 913 }
 914
 915 /*
 916  * ceu_set_default_fmt() - Apply default NV16 memory output format with VGA
 917  *                         sizes.
 918  */
 919 static int ceu_set_default_fmt(struct ceu_device *ceudev)
 920 {
 921         int ret;
 922
 923         struct v4l2_format v4l2_fmt = {
 924                 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
 925                 .fmt.pix_mp = {
 926                         .width          = VGA_WIDTH,
 927                         .height         = VGA_HEIGHT,
 928                         .field          = V4L2_FIELD_NONE,
 929                         .pixelformat    = V4L2_PIX_FMT_NV16,
 930                         .num_planes     = 2,
 931                         .plane_fmt      = {
 932                                 [0]     = {
 933                                         .sizeimage = VGA_WIDTH * VGA_HEIGHT * 2,
 934                                         .bytesperline = VGA_WIDTH * 2,
 935                                 },
 936                                 [1]     = {
 937                                         .sizeimage = VGA_WIDTH * VGA_HEIGHT * 2,
 938                                         .bytesperline = VGA_WIDTH * 2,
 939                                 },
 940                         },
 941                 },
 942         };
 943
 944         ret = ceu_try_fmt(ceudev, &v4l2_fmt);
 945         if (ret)
 946                 return ret;
 947
 948         ceudev->v4l2_pix = v4l2_fmt.fmt.pix_mp;
 949         ceudev->field = V4L2_FIELD_NONE;
 950
 951         return 0;
 952 }
 953
 954 /*
 955  * ceu_init_mbus_fmt() - Query sensor for supported formats and initialize
 956  *                       CEU media bus format used to produce memory formats.
 957  *
 958  * Find out if sensor can produce a permutation of 8-bits YUYV bus format.
 959  * From a single 8-bits YUYV bus format the CEU can produce several memory
 960  * output formats:
 961  * - NV[12|21|16|61] through image fetch mode;
 962  * - YUYV422 if sensor provides YUYV422
 963  *
 964  * TODO: Other YUYV422 permutations through data fetch sync mode and DTARY
 965  * TODO: Binary data (eg. JPEG) and raw formats through data fetch sync mode
 966  */
 967 static int ceu_init_mbus_fmt(struct ceu_device *ceudev)
 968 {
 969         struct ceu_subdev *ceu_sd = ceudev->sd;
 970         struct ceu_mbus_fmt *mbus_fmt = &ceu_sd->mbus_fmt;
 971         struct v4l2_subdev *v4l2_sd = ceu_sd->v4l2_sd;
 972         bool yuyv_bus_fmt = false;
 973
 974         struct v4l2_subdev_mbus_code_enum sd_mbus_fmt = {
 975                 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
 976                 .index = 0,
 977         };
 978
 979         /* Find out if sensor can produce any permutation of 8-bits YUYV422. */
 980         while (!yuyv_bus_fmt &&
 981                !v4l2_subdev_call(v4l2_sd, pad, enum_mbus_code,
 982                                  NULL, &sd_mbus_fmt)) {
 983                 switch (sd_mbus_fmt.code) {
 984                 case MEDIA_BUS_FMT_YUYV8_2X8:
 985                 case MEDIA_BUS_FMT_YVYU8_2X8:
 986                 case MEDIA_BUS_FMT_UYVY8_2X8:
 987                 case MEDIA_BUS_FMT_VYUY8_2X8:
 988                         yuyv_bus_fmt = true;
 989                         break;
 990                 default:
 991                         /*
 992                          * Only support 8-bits YUYV bus formats at the moment;
 993                          *
 994                          * TODO: add support for binary formats (data sync
 995                          * fetch mode).
 996                          */
 997                         break;
 998                 }
 999
1000                 sd_mbus_fmt.index++;
1001         }
1002
1003         if (!yuyv_bus_fmt)
1004                 return -ENXIO;
1005
1006         /*
1007          * Save the first encountered YUYV format as "mbus_fmt" and use it
1008          * to output all planar YUV422 and YUV420 (NV*) formats to memory as
1009          * well as for data synch fetch mode (YUYV - YVYU etc. ).
1010          */
1011         mbus_fmt->mbus_code     = sd_mbus_fmt.code;
1012         mbus_fmt->bps           = 8;
1013
1014         /* Annotate the selected bus format components ordering. */
1015         switch (sd_mbus_fmt.code) {
1016         case MEDIA_BUS_FMT_YUYV8_2X8:
1017                 mbus_fmt->fmt_order             = CEU_CAMCR_DTARY_8_YUYV;
1018                 mbus_fmt->fmt_order_swap        = CEU_CAMCR_DTARY_8_YVYU;
1019                 mbus_fmt->swapped               = false;
1020                 mbus_fmt->bpp                   = 16;
1021                 break;
1022
1023         case MEDIA_BUS_FMT_YVYU8_2X8:
1024                 mbus_fmt->fmt_order             = CEU_CAMCR_DTARY_8_YVYU;
1025                 mbus_fmt->fmt_order_swap        = CEU_CAMCR_DTARY_8_YUYV;
1026                 mbus_fmt->swapped               = true;
1027                 mbus_fmt->bpp                   = 16;
1028                 break;
1029
1030         case MEDIA_BUS_FMT_UYVY8_2X8:
1031                 mbus_fmt->fmt_order             = CEU_CAMCR_DTARY_8_UYVY;
1032                 mbus_fmt->fmt_order_swap        = CEU_CAMCR_DTARY_8_VYUY;
1033                 mbus_fmt->swapped               = false;
1034                 mbus_fmt->bpp                   = 16;
1035                 break;
1036
1037         case MEDIA_BUS_FMT_VYUY8_2X8:
1038                 mbus_fmt->fmt_order             = CEU_CAMCR_DTARY_8_VYUY;
1039                 mbus_fmt->fmt_order_swap        = CEU_CAMCR_DTARY_8_UYVY;
1040                 mbus_fmt->swapped               = true;
1041                 mbus_fmt->bpp                   = 16;
1042                 break;
1043         }
1044
1045         return 0;
1046 }
1047
1048 /* --- Runtime PM Handlers --- */
1049
1050 /*
1051  * ceu_runtime_resume() - soft-reset the interface and turn sensor power on.
1052  */
1053 static int __maybe_unused ceu_runtime_resume(struct device *dev)
1054 {
1055         struct ceu_device *ceudev = dev_get_drvdata(dev);
1056         struct v4l2_subdev *v4l2_sd = ceudev->sd->v4l2_sd;
1057
1058         v4l2_subdev_call(v4l2_sd, core, s_power, 1);
1059
1060         ceu_soft_reset(ceudev);
1061
1062         return 0;
1063 }
1064
1065 /*
1066  * ceu_runtime_suspend() - disable capture and interrupts and soft-reset.
1067  *                         Turn sensor power off.
1068  */
1069 static int __maybe_unused ceu_runtime_suspend(struct device *dev)
1070 {
1071         struct ceu_device *ceudev = dev_get_drvdata(dev);
1072         struct v4l2_subdev *v4l2_sd = ceudev->sd->v4l2_sd;
1073
1074         v4l2_subdev_call(v4l2_sd, core, s_power, 0);
1075
1076         ceu_write(ceudev, CEU_CEIER, 0);
1077         ceu_soft_reset(ceudev);
1078
1079         return 0;
1080 }
1081
1082 /* --- File Operations --- */
1083
1084 static int ceu_open(struct file *file)
1085 {
1086         struct ceu_device *ceudev = video_drvdata(file);
1087         int ret;
1088
1089         ret = v4l2_fh_open(file);
1090         if (ret)
1091                 return ret;
1092
1093         mutex_lock(&ceudev->mlock);
1094         /* Causes soft-reset and sensor power on on first open */
1095         ret = pm_runtime_resume_and_get(ceudev->dev);
1096         mutex_unlock(&ceudev->mlock);
1097
1098         return ret;
1099 }
1100
1101 static int ceu_release(struct file *file)
1102 {
1103         struct ceu_device *ceudev = video_drvdata(file);
1104
1105         vb2_fop_release(file);
1106
1107         mutex_lock(&ceudev->mlock);
1108         /* Causes soft-reset and sensor power down on last close */
1109         pm_runtime_put(ceudev->dev);
1110         mutex_unlock(&ceudev->mlock);
1111
1112         return 0;
1113 }
1114
1115 static const struct v4l2_file_operations ceu_fops = {
1116         .owner                  = THIS_MODULE,
1117         .open                   = ceu_open,
1118         .release                = ceu_release,
1119         .unlocked_ioctl         = video_ioctl2,
1120         .mmap                   = vb2_fop_mmap,
1121         .poll                   = vb2_fop_poll,
1122 };
1123
1124 /* --- Video Device IOCTLs --- */
1125
1126 static int ceu_querycap(struct file *file, void *priv,
1127                         struct v4l2_capability *cap)
1128 {
1129         struct ceu_device *ceudev = video_drvdata(file);
1130
1131         strscpy(cap->card, "Renesas CEU", sizeof(cap->card));
1132         strscpy(cap->driver, DRIVER_NAME, sizeof(cap->driver));
1133         snprintf(cap->bus_info, sizeof(cap->bus_info),
1134                  "platform:renesas-ceu-%s", dev_name(ceudev->dev));
1135
1136         return 0;
1137 }
1138
1139 static int ceu_enum_fmt_vid_cap(struct file *file, void *priv,
1140                                 struct v4l2_fmtdesc *f)
1141 {
1142         const struct ceu_fmt *fmt;
1143
1144         if (f->index >= ARRAY_SIZE(ceu_fmt_list))
1145                 return -EINVAL;
1146
1147         fmt = &ceu_fmt_list[f->index];
1148         f->pixelformat = fmt->fourcc;
1149
1150         return 0;
1151 }
1152
1153 static int ceu_try_fmt_vid_cap(struct file *file, void *priv,
1154                                struct v4l2_format *f)
1155 {
1156         struct ceu_device *ceudev = video_drvdata(file);
1157
1158         return ceu_try_fmt(ceudev, f);
1159 }
1160
1161 static int ceu_s_fmt_vid_cap(struct file *file, void *priv,
1162                              struct v4l2_format *f)
1163 {
1164         struct ceu_device *ceudev = video_drvdata(file);
1165
1166         if (vb2_is_streaming(&ceudev->vb2_vq))
1167                 return -EBUSY;
1168
1169         return ceu_set_fmt(ceudev, f);
1170 }
1171
1172 static int ceu_g_fmt_vid_cap(struct file *file, void *priv,
1173                              struct v4l2_format *f)
1174 {
1175         struct ceu_device *ceudev = video_drvdata(file);
1176
1177         f->fmt.pix_mp = ceudev->v4l2_pix;
1178
1179         return 0;
1180 }
1181
1182 static int ceu_enum_input(struct file *file, void *priv,
1183                           struct v4l2_input *inp)
1184 {
1185         struct ceu_device *ceudev = video_drvdata(file);
1186
1187         if (inp->index >= ceudev->num_sd)
1188                 return -EINVAL;
1189
1190         inp->type = V4L2_INPUT_TYPE_CAMERA;
1191         inp->std = 0;
1192         snprintf(inp->name, sizeof(inp->name), "Camera %u", inp->index);
1193
1194         return 0;
1195 }
1196
1197 static int ceu_g_input(struct file *file, void *priv, unsigned int *i)
1198 {
1199         struct ceu_device *ceudev = video_drvdata(file);
1200
1201         *i = ceudev->sd_index;
1202
1203         return 0;
1204 }
1205
1206 static int ceu_s_input(struct file *file, void *priv, unsigned int i)
1207 {
1208         struct ceu_device *ceudev = video_drvdata(file);
1209         struct ceu_subdev *ceu_sd_old;
1210         int ret;
1211
1212         if (i >= ceudev->num_sd)
1213                 return -EINVAL;
1214
1215         if (vb2_is_streaming(&ceudev->vb2_vq))
1216                 return -EBUSY;
1217
1218         if (i == ceudev->sd_index)
1219                 return 0;
1220
1221         ceu_sd_old = ceudev->sd;
1222         ceudev->sd = ceudev->subdevs[i];
1223
1224         /*
1225          * Make sure we can generate output image formats and apply
1226          * default one.
1227          */
1228         ret = ceu_init_mbus_fmt(ceudev);
1229         if (ret) {
1230                 ceudev->sd = ceu_sd_old;
1231                 return -EINVAL;
1232         }
1233
1234         ret = ceu_set_default_fmt(ceudev);
1235         if (ret) {
1236                 ceudev->sd = ceu_sd_old;
1237                 return -EINVAL;
1238         }
1239
1240         /* Now that we're sure we can use the sensor, power off the old one. */
1241         v4l2_subdev_call(ceu_sd_old->v4l2_sd, core, s_power, 0);
1242         v4l2_subdev_call(ceudev->sd->v4l2_sd, core, s_power, 1);
1243
1244         ceudev->sd_index = i;
1245
1246         return 0;
1247 }
1248
1249 static int ceu_g_parm(struct file *file, void *fh, struct v4l2_streamparm *a)
1250 {
1251         struct ceu_device *ceudev = video_drvdata(file);
1252
1253         return v4l2_g_parm_cap(video_devdata(file), ceudev->sd->v4l2_sd, a);
1254 }
1255
1256 static int ceu_s_parm(struct file *file, void *fh, struct v4l2_streamparm *a)
1257 {
1258         struct ceu_device *ceudev = video_drvdata(file);
1259
1260         return v4l2_s_parm_cap(video_devdata(file), ceudev->sd->v4l2_sd, a);
1261 }
1262
1263 static int ceu_enum_framesizes(struct file *file, void *fh,
1264                                struct v4l2_frmsizeenum *fsize)
1265 {
1266         struct ceu_device *ceudev = video_drvdata(file);
1267         struct ceu_subdev *ceu_sd = ceudev->sd;
1268         const struct ceu_fmt *ceu_fmt;
1269         struct v4l2_subdev *v4l2_sd = ceu_sd->v4l2_sd;
1270         int ret;
1271
1272         struct v4l2_subdev_frame_size_enum fse = {
1273                 .code   = ceu_sd->mbus_fmt.mbus_code,
1274                 .index  = fsize->index,
1275                 .which  = V4L2_SUBDEV_FORMAT_ACTIVE,
1276         };
1277
1278         /* Just check if user supplied pixel format is supported. */
1279         ceu_fmt = get_ceu_fmt_from_fourcc(fsize->pixel_format);
1280         if (!ceu_fmt)
1281                 return -EINVAL;
1282
1283         ret = v4l2_subdev_call(v4l2_sd, pad, enum_frame_size,
1284                                NULL, &fse);
1285         if (ret)
1286                 return ret;
1287
1288         fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1289         fsize->discrete.width = CEU_W_MAX(fse.max_width);
1290         fsize->discrete.height = CEU_H_MAX(fse.max_height);
1291
1292         return 0;
1293 }
1294
1295 static int ceu_enum_frameintervals(struct file *file, void *fh,
1296                                    struct v4l2_frmivalenum *fival)
1297 {
1298         struct ceu_device *ceudev = video_drvdata(file);
1299         struct ceu_subdev *ceu_sd = ceudev->sd;
1300         const struct ceu_fmt *ceu_fmt;
1301         struct v4l2_subdev *v4l2_sd = ceu_sd->v4l2_sd;
1302         int ret;
1303
1304         struct v4l2_subdev_frame_interval_enum fie = {
1305                 .code   = ceu_sd->mbus_fmt.mbus_code,
1306                 .index = fival->index,
1307                 .width = fival->width,
1308                 .height = fival->height,
1309                 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1310         };
1311
1312         /* Just check if user supplied pixel format is supported. */
1313         ceu_fmt = get_ceu_fmt_from_fourcc(fival->pixel_format);
1314         if (!ceu_fmt)
1315                 return -EINVAL;
1316
1317         ret = v4l2_subdev_call(v4l2_sd, pad, enum_frame_interval, NULL,
1318                                &fie);
1319         if (ret)
1320                 return ret;
1321
1322         fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1323         fival->discrete = fie.interval;
1324
1325         return 0;
1326 }
1327
1328 static const struct v4l2_ioctl_ops ceu_ioctl_ops = {
1329         .vidioc_querycap                = ceu_querycap,
1330
1331         .vidioc_enum_fmt_vid_cap        = ceu_enum_fmt_vid_cap,
1332         .vidioc_try_fmt_vid_cap_mplane  = ceu_try_fmt_vid_cap,
1333         .vidioc_s_fmt_vid_cap_mplane    = ceu_s_fmt_vid_cap,
1334         .vidioc_g_fmt_vid_cap_mplane    = ceu_g_fmt_vid_cap,
1335
1336         .vidioc_enum_input              = ceu_enum_input,
1337         .vidioc_g_input                 = ceu_g_input,
1338         .vidioc_s_input                 = ceu_s_input,
1339
1340         .vidioc_reqbufs                 = vb2_ioctl_reqbufs,
1341         .vidioc_querybuf                = vb2_ioctl_querybuf,
1342         .vidioc_qbuf                    = vb2_ioctl_qbuf,
1343         .vidioc_expbuf                  = vb2_ioctl_expbuf,
1344         .vidioc_dqbuf                   = vb2_ioctl_dqbuf,
1345         .vidioc_create_bufs             = vb2_ioctl_create_bufs,
1346         .vidioc_prepare_buf             = vb2_ioctl_prepare_buf,
1347         .vidioc_streamon                = vb2_ioctl_streamon,
1348         .vidioc_streamoff               = vb2_ioctl_streamoff,
1349
1350         .vidioc_g_parm                  = ceu_g_parm,
1351         .vidioc_s_parm                  = ceu_s_parm,
1352         .vidioc_enum_framesizes         = ceu_enum_framesizes,
1353         .vidioc_enum_frameintervals     = ceu_enum_frameintervals,
1354
1355         .vidioc_log_status              = v4l2_ctrl_log_status,
1356         .vidioc_subscribe_event         = v4l2_ctrl_subscribe_event,
1357         .vidioc_unsubscribe_event       = v4l2_event_unsubscribe,
1358 };
1359
1360 /*
1361  * ceu_vdev_release() - release CEU video device memory when last reference
1362  *                      to this driver is closed
1363  */
1364 static void ceu_vdev_release(struct video_device *vdev)
1365 {
1366         struct ceu_device *ceudev = video_get_drvdata(vdev);
1367
1368         kfree(ceudev);
1369 }
1370
1371 static int ceu_notify_bound(struct v4l2_async_notifier *notifier,
1372                             struct v4l2_subdev *v4l2_sd,
1373                             struct v4l2_async_connection *asd)
1374 {
1375         struct v4l2_device *v4l2_dev = notifier->v4l2_dev;
1376         struct ceu_device *ceudev = v4l2_to_ceu(v4l2_dev);
1377         struct ceu_subdev *ceu_sd = to_ceu_subdev(asd);
1378
1379         ceu_sd->v4l2_sd = v4l2_sd;
1380         ceudev->num_sd++;
1381
1382         return 0;
1383 }
1384
1385 static int ceu_notify_complete(struct v4l2_async_notifier *notifier)
1386 {
1387         struct v4l2_device *v4l2_dev = notifier->v4l2_dev;
1388         struct ceu_device *ceudev = v4l2_to_ceu(v4l2_dev);
1389         struct video_device *vdev = &ceudev->vdev;
1390         struct vb2_queue *q = &ceudev->vb2_vq;
1391         struct v4l2_subdev *v4l2_sd;
1392         int ret;
1393
1394         /* Initialize vb2 queue. */
1395         q->type                 = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1396         q->io_modes             = VB2_MMAP | VB2_DMABUF;
1397         q->drv_priv             = ceudev;
1398         q->ops                  = &ceu_vb2_ops;
1399         q->mem_ops              = &vb2_dma_contig_memops;
1400         q->buf_struct_size      = sizeof(struct ceu_buffer);
1401         q->timestamp_flags      = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1402         q->min_buffers_needed   = 2;
1403         q->lock                 = &ceudev->mlock;
1404         q->dev                  = ceudev->v4l2_dev.dev;
1405
1406         ret = vb2_queue_init(q);
1407         if (ret)
1408                 return ret;
1409
1410         /*
1411          * Make sure at least one sensor is primary and use it to initialize
1412          * ceu formats.
1413          */
1414         if (!ceudev->sd) {
1415                 ceudev->sd = ceudev->subdevs[0];
1416                 ceudev->sd_index = 0;
1417         }
1418
1419         v4l2_sd = ceudev->sd->v4l2_sd;
1420
1421         ret = ceu_init_mbus_fmt(ceudev);
1422         if (ret)
1423                 return ret;
1424
1425         ret = ceu_set_default_fmt(ceudev);
1426         if (ret)
1427                 return ret;
1428
1429         /* Register the video device. */
1430         strscpy(vdev->name, DRIVER_NAME, sizeof(vdev->name));
1431         vdev->v4l2_dev          = v4l2_dev;
1432         vdev->lock              = &ceudev->mlock;
1433         vdev->queue             = &ceudev->vb2_vq;
1434         vdev->ctrl_handler      = v4l2_sd->ctrl_handler;
1435         vdev->fops              = &ceu_fops;
1436         vdev->ioctl_ops         = &ceu_ioctl_ops;
1437         vdev->release           = ceu_vdev_release;
1438         vdev->device_caps       = V4L2_CAP_VIDEO_CAPTURE_MPLANE |
1439                                   V4L2_CAP_STREAMING;
1440         video_set_drvdata(vdev, ceudev);
1441
1442         ret = video_register_device(vdev, VFL_TYPE_VIDEO, -1);
1443         if (ret < 0) {
1444                 v4l2_err(vdev->v4l2_dev,
1445                          "video_register_device failed: %d\n", ret);
1446                 return ret;
1447         }
1448
1449         return 0;
1450 }
1451
1452 static const struct v4l2_async_notifier_operations ceu_notify_ops = {
1453         .bound          = ceu_notify_bound,
1454         .complete       = ceu_notify_complete,
1455 };
1456
1457 /*
1458  * ceu_init_async_subdevs() - Initialize CEU subdevices and async_subdevs in
1459  *                           ceu device. Both DT and platform data parsing use
1460  *                           this routine.
1461  *
1462  * Returns 0 for success, -ENOMEM for failure.
1463  */
1464 static int ceu_init_async_subdevs(struct ceu_device *ceudev, unsigned int n_sd)
1465 {
1466         /* Reserve memory for 'n_sd' ceu_subdev descriptors. */
1467         ceudev->subdevs = devm_kcalloc(ceudev->dev, n_sd,
1468                                        sizeof(*ceudev->subdevs), GFP_KERNEL);
1469         if (!ceudev->subdevs)
1470                 return -ENOMEM;
1471
1472         ceudev->sd = NULL;
1473         ceudev->sd_index = 0;
1474         ceudev->num_sd = 0;
1475
1476         return 0;
1477 }
1478
1479 /*
1480  * ceu_parse_platform_data() - Initialize async_subdevices using platform
1481  *                             device provided data.
1482  */
1483 static int ceu_parse_platform_data(struct ceu_device *ceudev,
1484                                    const struct ceu_platform_data *pdata)
1485 {
1486         const struct ceu_async_subdev *async_sd;
1487         struct ceu_subdev *ceu_sd;
1488         unsigned int i;
1489         int ret;
1490
1491         if (pdata->num_subdevs == 0)
1492                 return -ENODEV;
1493
1494         ret = ceu_init_async_subdevs(ceudev, pdata->num_subdevs);
1495         if (ret)
1496                 return ret;
1497
1498         for (i = 0; i < pdata->num_subdevs; i++) {
1499
1500                 /* Setup the ceu subdevice and the async subdevice. */
1501                 async_sd = &pdata->subdevs[i];
1502                 ceu_sd = v4l2_async_nf_add_i2c(&ceudev->notifier,
1503                                                async_sd->i2c_adapter_id,
1504                                                async_sd->i2c_address,
1505                                                struct ceu_subdev);
1506                 if (IS_ERR(ceu_sd)) {
1507                         v4l2_async_nf_cleanup(&ceudev->notifier);
1508                         return PTR_ERR(ceu_sd);
1509                 }
1510                 ceu_sd->mbus_flags = async_sd->flags;
1511                 ceudev->subdevs[i] = ceu_sd;
1512         }
1513
1514         return pdata->num_subdevs;
1515 }
1516
1517 /*
1518  * ceu_parse_dt() - Initialize async_subdevs parsing device tree graph.
1519  */
1520 static int ceu_parse_dt(struct ceu_device *ceudev)
1521 {
1522         struct device_node *of = ceudev->dev->of_node;
1523         struct device_node *ep;
1524         struct ceu_subdev *ceu_sd;
1525         unsigned int i;
1526         int num_ep;
1527         int ret;
1528
1529         num_ep = of_graph_get_endpoint_count(of);
1530         if (!num_ep)
1531                 return -ENODEV;
1532
1533         ret = ceu_init_async_subdevs(ceudev, num_ep);
1534         if (ret)
1535                 return ret;
1536
1537         for (i = 0; i < num_ep; i++) {
1538                 struct v4l2_fwnode_endpoint fw_ep = {
1539                         .bus_type = V4L2_MBUS_PARALLEL,
1540                         .bus = {
1541                                 .parallel = {
1542                                         .flags = V4L2_MBUS_HSYNC_ACTIVE_HIGH |
1543                                                  V4L2_MBUS_VSYNC_ACTIVE_HIGH,
1544                                         .bus_width = 8,
1545                                 },
1546                         },
1547                 };
1548
1549                 ep = of_graph_get_endpoint_by_regs(of, 0, i);
1550                 if (!ep) {
1551                         dev_err(ceudev->dev,
1552                                 "No subdevice connected on endpoint %u.\n", i);
1553                         ret = -ENODEV;
1554                         goto error_cleanup;
1555                 }
1556
1557                 ret = v4l2_fwnode_endpoint_parse(of_fwnode_handle(ep), &fw_ep);
1558                 if (ret) {
1559                         dev_err(ceudev->dev,
1560                                 "Unable to parse endpoint #%u: %d.\n", i, ret);
1561                         goto error_cleanup;
1562                 }
1563
1564                 /* Setup the ceu subdevice and the async subdevice. */
1565                 ceu_sd = v4l2_async_nf_add_fwnode_remote(&ceudev->notifier,
1566                                                          of_fwnode_handle(ep),
1567                                                          struct ceu_subdev);
1568                 if (IS_ERR(ceu_sd)) {
1569                         ret = PTR_ERR(ceu_sd);
1570                         goto error_cleanup;
1571                 }
1572                 ceu_sd->mbus_flags = fw_ep.bus.parallel.flags;
1573                 ceudev->subdevs[i] = ceu_sd;
1574
1575                 of_node_put(ep);
1576         }
1577
1578         return num_ep;
1579
1580 error_cleanup:
1581         v4l2_async_nf_cleanup(&ceudev->notifier);
1582         of_node_put(ep);
1583         return ret;
1584 }
1585
1586 /*
1587  * struct ceu_data - Platform specific CEU data
1588  * @irq_mask: CETCR mask with all interrupt sources enabled. The mask differs
1589  *            between SH4 and RZ platforms.
1590  */
1591 struct ceu_data {
1592         u32 irq_mask;
1593 };
1594
1595 static const struct ceu_data ceu_data_sh4 = {
1596         .irq_mask = CEU_CETCR_ALL_IRQS_SH4,
1597 };
1598
1599 #if IS_ENABLED(CONFIG_OF)
1600 static const struct ceu_data ceu_data_rz = {
1601         .irq_mask = CEU_CETCR_ALL_IRQS_RZ,
1602 };
1603
1604 static const struct of_device_id ceu_of_match[] = {
1605         { .compatible = "renesas,r7s72100-ceu", .data = &ceu_data_rz },
1606         { .compatible = "renesas,r8a7740-ceu", .data = &ceu_data_rz },
1607         { }
1608 };
1609 MODULE_DEVICE_TABLE(of, ceu_of_match);
1610 #endif
1611
1612 static int ceu_probe(struct platform_device *pdev)
1613 {
1614         struct device *dev = &pdev->dev;
1615         const struct ceu_data *ceu_data;
1616         struct ceu_device *ceudev;
1617         unsigned int irq;
1618         int num_subdevs;
1619         int ret;
1620
1621         ceudev = kzalloc(sizeof(*ceudev), GFP_KERNEL);
1622         if (!ceudev)
1623                 return -ENOMEM;
1624
1625         platform_set_drvdata(pdev, ceudev);
1626         ceudev->dev = dev;
1627
1628         INIT_LIST_HEAD(&ceudev->capture);
1629         spin_lock_init(&ceudev->lock);
1630         mutex_init(&ceudev->mlock);
1631
1632         ceudev->base = devm_platform_ioremap_resource(pdev, 0);
1633         if (IS_ERR(ceudev->base)) {
1634                 ret = PTR_ERR(ceudev->base);
1635                 goto error_free_ceudev;
1636         }
1637
1638         ret = platform_get_irq(pdev, 0);
1639         if (ret < 0)
1640                 goto error_free_ceudev;
1641         irq = ret;
1642
1643         ret = devm_request_irq(dev, irq, ceu_irq,
1644                                0, dev_name(dev), ceudev);
1645         if (ret) {
1646                 dev_err(&pdev->dev, "Unable to request CEU interrupt.\n");
1647                 goto error_free_ceudev;
1648         }
1649
1650         pm_runtime_enable(dev);
1651
1652         ret = v4l2_device_register(dev, &ceudev->v4l2_dev);
1653         if (ret)
1654                 goto error_pm_disable;
1655
1656         v4l2_async_nf_init(&ceudev->notifier, &ceudev->v4l2_dev);
1657
1658         if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
1659                 ceu_data = of_device_get_match_data(dev);
1660                 num_subdevs = ceu_parse_dt(ceudev);
1661         } else if (dev->platform_data) {
1662                 /* Assume SH4 if booting with platform data. */
1663                 ceu_data = &ceu_data_sh4;
1664                 num_subdevs = ceu_parse_platform_data(ceudev,
1665                                                       dev->platform_data);
1666         } else {
1667                 num_subdevs = -EINVAL;
1668         }
1669
1670         if (num_subdevs < 0) {
1671                 ret = num_subdevs;
1672                 goto error_v4l2_unregister;
1673         }
1674         ceudev->irq_mask = ceu_data->irq_mask;
1675
1676         ceudev->notifier.v4l2_dev       = &ceudev->v4l2_dev;
1677         ceudev->notifier.ops            = &ceu_notify_ops;
1678         ret = v4l2_async_nf_register(&ceudev->notifier);
1679         if (ret)
1680                 goto error_cleanup;
1681
1682         dev_info(dev, "Renesas Capture Engine Unit %s\n", dev_name(dev));
1683
1684         return 0;
1685
1686 error_cleanup:
1687         v4l2_async_nf_cleanup(&ceudev->notifier);
1688 error_v4l2_unregister:
1689         v4l2_device_unregister(&ceudev->v4l2_dev);
1690 error_pm_disable:
1691         pm_runtime_disable(dev);
1692 error_free_ceudev:
1693         kfree(ceudev);
1694
1695         return ret;
1696 }
1697
1698 static void ceu_remove(struct platform_device *pdev)
1699 {
1700         struct ceu_device *ceudev = platform_get_drvdata(pdev);
1701
1702         pm_runtime_disable(ceudev->dev);
1703
1704         v4l2_async_nf_unregister(&ceudev->notifier);
1705
1706         v4l2_async_nf_cleanup(&ceudev->notifier);
1707
1708         v4l2_device_unregister(&ceudev->v4l2_dev);
1709
1710         video_unregister_device(&ceudev->vdev);
1711 }
1712
1713 static const struct dev_pm_ops ceu_pm_ops = {
1714         SET_RUNTIME_PM_OPS(ceu_runtime_suspend,
1715                            ceu_runtime_resume,
1716                            NULL)
1717 };
1718
1719 static struct platform_driver ceu_driver = {
1720         .driver         = {
1721                 .name   = DRIVER_NAME,
1722                 .pm     = &ceu_pm_ops,
1723                 .of_match_table = of_match_ptr(ceu_of_match),
1724         },
1725         .probe          = ceu_probe,
1726         .remove_new     = ceu_remove,
1727 };
1728
1729 module_platform_driver(ceu_driver);
1730
1731 MODULE_DESCRIPTION("Renesas CEU camera driver");
1732 MODULE_AUTHOR("Jacopo Mondi <jacopo+renesas@jmondi.org>");
1733 MODULE_LICENSE("GPL v2");