drivers/media/platform/marvell/mcam-core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * The Marvell camera core.  This device appears in a number of settings,
   4  * so it needs platform-specific support outside of the core.
   5  *
   6  * Copyright 2011 Jonathan Corbet corbet@lwn.net
   7  * Copyright 2018 Lubomir Rintel <lkundrak@v3.sk>
   8  */
   9 #include <linux/kernel.h>
  10 #include <linux/module.h>
  11 #include <linux/fs.h>
  12 #include <linux/mm.h>
  13 #include <linux/i2c.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/spinlock.h>
  16 #include <linux/slab.h>
  17 #include <linux/device.h>
  18 #include <linux/wait.h>
  19 #include <linux/list.h>
  20 #include <linux/dma-mapping.h>
  21 #include <linux/delay.h>
  22 #include <linux/vmalloc.h>
  23 #include <linux/io.h>
  24 #include <linux/clk.h>
  25 #include <linux/clk-provider.h>
  26 #include <linux/videodev2.h>
  27 #include <linux/pm_runtime.h>
  28 #include <media/v4l2-device.h>
  29 #include <media/v4l2-ioctl.h>
  30 #include <media/v4l2-ctrls.h>
  31 #include <media/v4l2-event.h>
  32 #include <media/videobuf2-vmalloc.h>
  33 #include <media/videobuf2-dma-contig.h>
  34 #include <media/videobuf2-dma-sg.h>
  35
  36 #include "mcam-core.h"
  37
  38 #ifdef MCAM_MODE_VMALLOC
  39 /*
  40  * Internal DMA buffer management.  Since the controller cannot do S/G I/O,
  41  * we must have physically contiguous buffers to bring frames into.
  42  * These parameters control how many buffers we use, whether we
  43  * allocate them at load time (better chance of success, but nails down
  44  * memory) or when somebody tries to use the camera (riskier), and,
  45  * for load-time allocation, how big they should be.
  46  *
  47  * The controller can cycle through three buffers.  We could use
  48  * more by flipping pointers around, but it probably makes little
  49  * sense.
  50  */
  51
  52 static bool alloc_bufs_at_read;
  53 module_param(alloc_bufs_at_read, bool, 0444);
  54 MODULE_PARM_DESC(alloc_bufs_at_read,
  55                 "Non-zero value causes DMA buffers to be allocated when the video capture device is read, rather than at module load time.  This saves memory, but decreases the chances of successfully getting those buffers.  This parameter is only used in the vmalloc buffer mode");
  56
  57 static int n_dma_bufs = 3;
  58 module_param(n_dma_bufs, uint, 0644);
  59 MODULE_PARM_DESC(n_dma_bufs,
  60                 "The number of DMA buffers to allocate.  Can be either two (saves memory, makes timing tighter) or three.");
  61
  62 static int dma_buf_size = VGA_WIDTH * VGA_HEIGHT * 2;  /* Worst case */
  63 module_param(dma_buf_size, uint, 0444);
  64 MODULE_PARM_DESC(dma_buf_size,
  65                 "The size of the allocated DMA buffers.  If actual operating parameters require larger buffers, an attempt to reallocate will be made.");
  66 #else /* MCAM_MODE_VMALLOC */
  67 static const bool alloc_bufs_at_read;
  68 static const int n_dma_bufs = 3;  /* Used by S/G_PARM */
  69 #endif /* MCAM_MODE_VMALLOC */
  70
  71 static bool flip;
  72 module_param(flip, bool, 0444);
  73 MODULE_PARM_DESC(flip,
  74                 "If set, the sensor will be instructed to flip the image vertically.");
  75
  76 static int buffer_mode = -1;
  77 module_param(buffer_mode, int, 0444);
  78 MODULE_PARM_DESC(buffer_mode,
  79                 "Set the buffer mode to be used; default is to go with what the platform driver asks for.  Set to 0 for vmalloc, 1 for DMA contiguous.");
  80
  81 /*
  82  * Status flags.  Always manipulated with bit operations.
  83  */
  84 #define CF_BUF0_VALID    0      /* Buffers valid - first three */
  85 #define CF_BUF1_VALID    1
  86 #define CF_BUF2_VALID    2
  87 #define CF_DMA_ACTIVE    3      /* A frame is incoming */
  88 #define CF_CONFIG_NEEDED 4      /* Must configure hardware */
  89 #define CF_SINGLE_BUFFER 5      /* Running with a single buffer */
  90 #define CF_SG_RESTART    6      /* SG restart needed */
  91 #define CF_FRAME_SOF0    7      /* Frame 0 started */
  92 #define CF_FRAME_SOF1    8
  93 #define CF_FRAME_SOF2    9
  94
  95 #define sensor_call(cam, o, f, args...) \
  96         v4l2_subdev_call(cam->sensor, o, f, ##args)
  97
  98 #define notifier_to_mcam(notifier) \
  99         container_of(notifier, struct mcam_camera, notifier)
 100
 101 static struct mcam_format_struct {
 102         __u32 pixelformat;
 103         int bpp;   /* Bytes per pixel */
 104         bool planar;
 105         u32 mbus_code;
 106 } mcam_formats[] = {
 107         {
 108                 .pixelformat    = V4L2_PIX_FMT_YUYV,
 109                 .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
 110                 .bpp            = 2,
 111                 .planar         = false,
 112         },
 113         {
 114                 .pixelformat    = V4L2_PIX_FMT_YVYU,
 115                 .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
 116                 .bpp            = 2,
 117                 .planar         = false,
 118         },
 119         {
 120                 .pixelformat    = V4L2_PIX_FMT_YUV420,
 121                 .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
 122                 .bpp            = 1,
 123                 .planar         = true,
 124         },
 125         {
 126                 .pixelformat    = V4L2_PIX_FMT_YVU420,
 127                 .mbus_code      = MEDIA_BUS_FMT_YUYV8_2X8,
 128                 .bpp            = 1,
 129                 .planar         = true,
 130         },
 131         {
 132                 .pixelformat    = V4L2_PIX_FMT_XRGB444,
 133                 .mbus_code      = MEDIA_BUS_FMT_RGB444_2X8_PADHI_LE,
 134                 .bpp            = 2,
 135                 .planar         = false,
 136         },
 137         {
 138                 .pixelformat    = V4L2_PIX_FMT_RGB565,
 139                 .mbus_code      = MEDIA_BUS_FMT_RGB565_2X8_LE,
 140                 .bpp            = 2,
 141                 .planar         = false,
 142         },
 143         {
 144                 .pixelformat    = V4L2_PIX_FMT_SBGGR8,
 145                 .mbus_code      = MEDIA_BUS_FMT_SBGGR8_1X8,
 146                 .bpp            = 1,
 147                 .planar         = false,
 148         },
 149 };
 150 #define N_MCAM_FMTS ARRAY_SIZE(mcam_formats)
 151
 152 static struct mcam_format_struct *mcam_find_format(u32 pixelformat)
 153 {
 154         unsigned i;
 155
 156         for (i = 0; i < N_MCAM_FMTS; i++)
 157                 if (mcam_formats[i].pixelformat == pixelformat)
 158                         return mcam_formats + i;
 159         /* Not found? Then return the first format. */
 160         return mcam_formats;
 161 }
 162
 163 /*
 164  * The default format we use until somebody says otherwise.
 165  */
 166 static const struct v4l2_pix_format mcam_def_pix_format = {
 167         .width          = VGA_WIDTH,
 168         .height         = VGA_HEIGHT,
 169         .pixelformat    = V4L2_PIX_FMT_YUYV,
 170         .field          = V4L2_FIELD_NONE,
 171         .bytesperline   = VGA_WIDTH*2,
 172         .sizeimage      = VGA_WIDTH*VGA_HEIGHT*2,
 173         .colorspace     = V4L2_COLORSPACE_SRGB,
 174 };
 175
 176 static const u32 mcam_def_mbus_code = MEDIA_BUS_FMT_YUYV8_2X8;
 177
 178
 179 /*
 180  * The two-word DMA descriptor format used by the Armada 610 and like.  There
 181  * Is a three-word format as well (set C1_DESC_3WORD) where the third
 182  * word is a pointer to the next descriptor, but we don't use it.  Two-word
 183  * descriptors have to be contiguous in memory.
 184  */
 185 struct mcam_dma_desc {
 186         u32 dma_addr;
 187         u32 segment_len;
 188 };
 189
 190 /*
 191  * Our buffer type for working with videobuf2.  Note that the vb2
 192  * developers have decreed that struct vb2_v4l2_buffer must be at the
 193  * beginning of this structure.
 194  */
 195 struct mcam_vb_buffer {
 196         struct vb2_v4l2_buffer vb_buf;
 197         struct list_head queue;
 198         struct mcam_dma_desc *dma_desc; /* Descriptor virtual address */
 199         dma_addr_t dma_desc_pa;         /* Descriptor physical address */
 200 };
 201
 202 static inline struct mcam_vb_buffer *vb_to_mvb(struct vb2_v4l2_buffer *vb)
 203 {
 204         return container_of(vb, struct mcam_vb_buffer, vb_buf);
 205 }
 206
 207 /*
 208  * Hand a completed buffer back to user space.
 209  */
 210 static void mcam_buffer_done(struct mcam_camera *cam, int frame,
 211                 struct vb2_v4l2_buffer *vbuf)
 212 {
 213         vbuf->vb2_buf.planes[0].bytesused = cam->pix_format.sizeimage;
 214         vbuf->sequence = cam->buf_seq[frame];
 215         vbuf->field = V4L2_FIELD_NONE;
 216         vbuf->vb2_buf.timestamp = ktime_get_ns();
 217         vb2_set_plane_payload(&vbuf->vb2_buf, 0, cam->pix_format.sizeimage);
 218         vb2_buffer_done(&vbuf->vb2_buf, VB2_BUF_STATE_DONE);
 219 }
 220
 221
 222
 223 /*
 224  * Debugging and related.
 225  */
 226 #define cam_err(cam, fmt, arg...) \
 227         dev_err((cam)->dev, fmt, ##arg);
 228 #define cam_warn(cam, fmt, arg...) \
 229         dev_warn((cam)->dev, fmt, ##arg);
 230 #define cam_dbg(cam, fmt, arg...) \
 231         dev_dbg((cam)->dev, fmt, ##arg);
 232
 233
 234 /*
 235  * Flag manipulation helpers
 236  */
 237 static void mcam_reset_buffers(struct mcam_camera *cam)
 238 {
 239         int i;
 240
 241         cam->next_buf = -1;
 242         for (i = 0; i < cam->nbufs; i++) {
 243                 clear_bit(i, &cam->flags);
 244                 clear_bit(CF_FRAME_SOF0 + i, &cam->flags);
 245         }
 246 }
 247
 248 static inline int mcam_needs_config(struct mcam_camera *cam)
 249 {
 250         return test_bit(CF_CONFIG_NEEDED, &cam->flags);
 251 }
 252
 253 static void mcam_set_config_needed(struct mcam_camera *cam, int needed)
 254 {
 255         if (needed)
 256                 set_bit(CF_CONFIG_NEEDED, &cam->flags);
 257         else
 258                 clear_bit(CF_CONFIG_NEEDED, &cam->flags);
 259 }
 260
 261 /* ------------------------------------------------------------------- */
 262 /*
 263  * Make the controller start grabbing images.  Everything must
 264  * be set up before doing this.
 265  */
 266 static void mcam_ctlr_start(struct mcam_camera *cam)
 267 {
 268         /* set_bit performs a read, so no other barrier should be
 269            needed here */
 270         mcam_reg_set_bit(cam, REG_CTRL0, C0_ENABLE);
 271 }
 272
 273 static void mcam_ctlr_stop(struct mcam_camera *cam)
 274 {
 275         mcam_reg_clear_bit(cam, REG_CTRL0, C0_ENABLE);
 276 }
 277
 278 static void mcam_enable_mipi(struct mcam_camera *mcam)
 279 {
 280         /* Using MIPI mode and enable MIPI */
 281         if (mcam->calc_dphy)
 282                 mcam->calc_dphy(mcam);
 283         cam_dbg(mcam, "camera: DPHY3=0x%x, DPHY5=0x%x, DPHY6=0x%x\n",
 284                         mcam->dphy[0], mcam->dphy[1], mcam->dphy[2]);
 285         mcam_reg_write(mcam, REG_CSI2_DPHY3, mcam->dphy[0]);
 286         mcam_reg_write(mcam, REG_CSI2_DPHY5, mcam->dphy[1]);
 287         mcam_reg_write(mcam, REG_CSI2_DPHY6, mcam->dphy[2]);
 288
 289         if (!mcam->mipi_enabled) {
 290                 if (mcam->lane > 4 || mcam->lane <= 0) {
 291                         cam_warn(mcam, "lane number error\n");
 292                         mcam->lane = 1; /* set the default value */
 293                 }
 294                 /*
 295                  * 0x41 actives 1 lane
 296                  * 0x43 actives 2 lanes
 297                  * 0x45 actives 3 lanes (never happen)
 298                  * 0x47 actives 4 lanes
 299                  */
 300                 mcam_reg_write(mcam, REG_CSI2_CTRL0,
 301                         CSI2_C0_MIPI_EN | CSI2_C0_ACT_LANE(mcam->lane));
 302                 mcam->mipi_enabled = true;
 303         }
 304 }
 305
 306 static void mcam_disable_mipi(struct mcam_camera *mcam)
 307 {
 308         /* Using Parallel mode or disable MIPI */
 309         mcam_reg_write(mcam, REG_CSI2_CTRL0, 0x0);
 310         mcam_reg_write(mcam, REG_CSI2_DPHY3, 0x0);
 311         mcam_reg_write(mcam, REG_CSI2_DPHY5, 0x0);
 312         mcam_reg_write(mcam, REG_CSI2_DPHY6, 0x0);
 313         mcam->mipi_enabled = false;
 314 }
 315
 316 static bool mcam_fmt_is_planar(__u32 pfmt)
 317 {
 318         struct mcam_format_struct *f;
 319
 320         f = mcam_find_format(pfmt);
 321         return f->planar;
 322 }
 323
 324 static void mcam_write_yuv_bases(struct mcam_camera *cam,
 325                                  unsigned frame, dma_addr_t base)
 326 {
 327         struct v4l2_pix_format *fmt = &cam->pix_format;
 328         u32 pixel_count = fmt->width * fmt->height;
 329         dma_addr_t y, u = 0, v = 0;
 330
 331         y = base;
 332
 333         switch (fmt->pixelformat) {
 334         case V4L2_PIX_FMT_YUV420:
 335                 u = y + pixel_count;
 336                 v = u + pixel_count / 4;
 337                 break;
 338         case V4L2_PIX_FMT_YVU420:
 339                 v = y + pixel_count;
 340                 u = v + pixel_count / 4;
 341                 break;
 342         default:
 343                 break;
 344         }
 345
 346         mcam_reg_write(cam, REG_Y0BAR + frame * 4, y);
 347         if (mcam_fmt_is_planar(fmt->pixelformat)) {
 348                 mcam_reg_write(cam, REG_U0BAR + frame * 4, u);
 349                 mcam_reg_write(cam, REG_V0BAR + frame * 4, v);
 350         }
 351 }
 352
 353 /* ------------------------------------------------------------------- */
 354
 355 #ifdef MCAM_MODE_VMALLOC
 356 /*
 357  * Code specific to the vmalloc buffer mode.
 358  */
 359
 360 /*
 361  * Allocate in-kernel DMA buffers for vmalloc mode.
 362  */
 363 static int mcam_alloc_dma_bufs(struct mcam_camera *cam, int loadtime)
 364 {
 365         int i;
 366
 367         mcam_set_config_needed(cam, 1);
 368         if (loadtime)
 369                 cam->dma_buf_size = dma_buf_size;
 370         else
 371                 cam->dma_buf_size = cam->pix_format.sizeimage;
 372         if (n_dma_bufs > 3)
 373                 n_dma_bufs = 3;
 374
 375         cam->nbufs = 0;
 376         for (i = 0; i < n_dma_bufs; i++) {
 377                 cam->dma_bufs[i] = dma_alloc_coherent(cam->dev,
 378                                 cam->dma_buf_size, cam->dma_handles + i,
 379                                 GFP_KERNEL);
 380                 if (cam->dma_bufs[i] == NULL) {
 381                         cam_warn(cam, "Failed to allocate DMA buffer\n");
 382                         break;
 383                 }
 384                 (cam->nbufs)++;
 385         }
 386
 387         switch (cam->nbufs) {
 388         case 1:
 389                 dma_free_coherent(cam->dev, cam->dma_buf_size,
 390                                 cam->dma_bufs[0], cam->dma_handles[0]);
 391                 cam->nbufs = 0;
 392                 fallthrough;
 393         case 0:
 394                 cam_err(cam, "Insufficient DMA buffers, cannot operate\n");
 395                 return -ENOMEM;
 396
 397         case 2:
 398                 if (n_dma_bufs > 2)
 399                         cam_warn(cam, "Will limp along with only 2 buffers\n");
 400                 break;
 401         }
 402         return 0;
 403 }
 404
 405 static void mcam_free_dma_bufs(struct mcam_camera *cam)
 406 {
 407         int i;
 408
 409         for (i = 0; i < cam->nbufs; i++) {
 410                 dma_free_coherent(cam->dev, cam->dma_buf_size,
 411                                 cam->dma_bufs[i], cam->dma_handles[i]);
 412                 cam->dma_bufs[i] = NULL;
 413         }
 414         cam->nbufs = 0;
 415 }
 416
 417
 418 /*
 419  * Set up DMA buffers when operating in vmalloc mode
 420  */
 421 static void mcam_ctlr_dma_vmalloc(struct mcam_camera *cam)
 422 {
 423         /*
 424          * Store the first two YUV buffers. Then either
 425          * set the third if it exists, or tell the controller
 426          * to just use two.
 427          */
 428         mcam_write_yuv_bases(cam, 0, cam->dma_handles[0]);
 429         mcam_write_yuv_bases(cam, 1, cam->dma_handles[1]);
 430         if (cam->nbufs > 2) {
 431                 mcam_write_yuv_bases(cam, 2, cam->dma_handles[2]);
 432                 mcam_reg_clear_bit(cam, REG_CTRL1, C1_TWOBUFS);
 433         } else
 434                 mcam_reg_set_bit(cam, REG_CTRL1, C1_TWOBUFS);
 435         if (cam->chip_id == MCAM_CAFE)
 436                 mcam_reg_write(cam, REG_UBAR, 0); /* 32 bits only */
 437 }
 438
 439 /*
 440  * Copy data out to user space in the vmalloc case
 441  */
 442 static void mcam_frame_tasklet(struct tasklet_struct *t)
 443 {
 444         struct mcam_camera *cam = from_tasklet(cam, t, s_tasklet);
 445         int i;
 446         unsigned long flags;
 447         struct mcam_vb_buffer *buf;
 448
 449         spin_lock_irqsave(&cam->dev_lock, flags);
 450         for (i = 0; i < cam->nbufs; i++) {
 451                 int bufno = cam->next_buf;
 452
 453                 if (cam->state != S_STREAMING || bufno < 0)
 454                         break;  /* I/O got stopped */
 455                 if (++(cam->next_buf) >= cam->nbufs)
 456                         cam->next_buf = 0;
 457                 if (!test_bit(bufno, &cam->flags))
 458                         continue;
 459                 if (list_empty(&cam->buffers)) {
 460                         cam->frame_state.singles++;
 461                         break;  /* Leave it valid, hope for better later */
 462                 }
 463                 cam->frame_state.delivered++;
 464                 clear_bit(bufno, &cam->flags);
 465                 buf = list_first_entry(&cam->buffers, struct mcam_vb_buffer,
 466                                 queue);
 467                 list_del_init(&buf->queue);
 468                 /*
 469                  * Drop the lock during the big copy.  This *should* be safe...
 470                  */
 471                 spin_unlock_irqrestore(&cam->dev_lock, flags);
 472                 memcpy(vb2_plane_vaddr(&buf->vb_buf.vb2_buf, 0),
 473                                 cam->dma_bufs[bufno],
 474                                 cam->pix_format.sizeimage);
 475                 mcam_buffer_done(cam, bufno, &buf->vb_buf);
 476                 spin_lock_irqsave(&cam->dev_lock, flags);
 477         }
 478         spin_unlock_irqrestore(&cam->dev_lock, flags);
 479 }
 480
 481
 482 /*
 483  * Make sure our allocated buffers are up to the task.
 484  */
 485 static int mcam_check_dma_buffers(struct mcam_camera *cam)
 486 {
 487         if (cam->nbufs > 0 && cam->dma_buf_size < cam->pix_format.sizeimage)
 488                         mcam_free_dma_bufs(cam);
 489         if (cam->nbufs == 0)
 490                 return mcam_alloc_dma_bufs(cam, 0);
 491         return 0;
 492 }
 493
 494 static void mcam_vmalloc_done(struct mcam_camera *cam, int frame)
 495 {
 496         tasklet_schedule(&cam->s_tasklet);
 497 }
 498
 499 #else /* MCAM_MODE_VMALLOC */
 500
 501 static inline int mcam_alloc_dma_bufs(struct mcam_camera *cam, int loadtime)
 502 {
 503         return 0;
 504 }
 505
 506 static inline void mcam_free_dma_bufs(struct mcam_camera *cam)
 507 {
 508         return;
 509 }
 510
 511 static inline int mcam_check_dma_buffers(struct mcam_camera *cam)
 512 {
 513         return 0;
 514 }
 515
 516
 517
 518 #endif /* MCAM_MODE_VMALLOC */
 519
 520
 521 #ifdef MCAM_MODE_DMA_CONTIG
 522 /* ---------------------------------------------------------------------- */
 523 /*
 524  * DMA-contiguous code.
 525  */
 526
 527 /*
 528  * Set up a contiguous buffer for the given frame.  Here also is where
 529  * the underrun strategy is set: if there is no buffer available, reuse
 530  * the buffer from the other BAR and set the CF_SINGLE_BUFFER flag to
 531  * keep the interrupt handler from giving that buffer back to user
 532  * space.  In this way, we always have a buffer to DMA to and don't
 533  * have to try to play games stopping and restarting the controller.
 534  */
 535 static void mcam_set_contig_buffer(struct mcam_camera *cam, int frame)
 536 {
 537         struct mcam_vb_buffer *buf;
 538         dma_addr_t dma_handle;
 539         struct vb2_v4l2_buffer *vb;
 540
 541         /*
 542          * If there are no available buffers, go into single mode
 543          */
 544         if (list_empty(&cam->buffers)) {
 545                 buf = cam->vb_bufs[frame ^ 0x1];
 546                 set_bit(CF_SINGLE_BUFFER, &cam->flags);
 547                 cam->frame_state.singles++;
 548         } else {
 549                 /*
 550                  * OK, we have a buffer we can use.
 551                  */
 552                 buf = list_first_entry(&cam->buffers, struct mcam_vb_buffer,
 553                                         queue);
 554                 list_del_init(&buf->queue);
 555                 clear_bit(CF_SINGLE_BUFFER, &cam->flags);
 556         }
 557
 558         cam->vb_bufs[frame] = buf;
 559         vb = &buf->vb_buf;
 560
 561         dma_handle = vb2_dma_contig_plane_dma_addr(&vb->vb2_buf, 0);
 562         mcam_write_yuv_bases(cam, frame, dma_handle);
 563 }
 564
 565 /*
 566  * Initial B_DMA_contig setup.
 567  */
 568 static void mcam_ctlr_dma_contig(struct mcam_camera *cam)
 569 {
 570         mcam_reg_set_bit(cam, REG_CTRL1, C1_TWOBUFS);
 571         cam->nbufs = 2;
 572         mcam_set_contig_buffer(cam, 0);
 573         mcam_set_contig_buffer(cam, 1);
 574 }
 575
 576 /*
 577  * Frame completion handling.
 578  */
 579 static void mcam_dma_contig_done(struct mcam_camera *cam, int frame)
 580 {
 581         struct mcam_vb_buffer *buf = cam->vb_bufs[frame];
 582
 583         if (!test_bit(CF_SINGLE_BUFFER, &cam->flags)) {
 584                 cam->frame_state.delivered++;
 585                 cam->vb_bufs[frame] = NULL;
 586                 mcam_buffer_done(cam, frame, &buf->vb_buf);
 587         }
 588         mcam_set_contig_buffer(cam, frame);
 589 }
 590
 591 #endif /* MCAM_MODE_DMA_CONTIG */
 592
 593 #ifdef MCAM_MODE_DMA_SG
 594 /* ---------------------------------------------------------------------- */
 595 /*
 596  * Scatter/gather-specific code.
 597  */
 598
 599 /*
 600  * Set up the next buffer for S/G I/O; caller should be sure that
 601  * the controller is stopped and a buffer is available.
 602  */
 603 static void mcam_sg_next_buffer(struct mcam_camera *cam)
 604 {
 605         struct mcam_vb_buffer *buf;
 606         struct sg_table *sg_table;
 607
 608         buf = list_first_entry(&cam->buffers, struct mcam_vb_buffer, queue);
 609         list_del_init(&buf->queue);
 610         sg_table = vb2_dma_sg_plane_desc(&buf->vb_buf.vb2_buf, 0);
 611         /*
 612          * Very Bad Not Good Things happen if you don't clear
 613          * C1_DESC_ENA before making any descriptor changes.
 614          */
 615         mcam_reg_clear_bit(cam, REG_CTRL1, C1_DESC_ENA);
 616         mcam_reg_write(cam, REG_DMA_DESC_Y, buf->dma_desc_pa);
 617         mcam_reg_write(cam, REG_DESC_LEN_Y,
 618                         sg_table->nents * sizeof(struct mcam_dma_desc));
 619         mcam_reg_write(cam, REG_DESC_LEN_U, 0);
 620         mcam_reg_write(cam, REG_DESC_LEN_V, 0);
 621         mcam_reg_set_bit(cam, REG_CTRL1, C1_DESC_ENA);
 622         cam->vb_bufs[0] = buf;
 623 }
 624
 625 /*
 626  * Initial B_DMA_sg setup
 627  */
 628 static void mcam_ctlr_dma_sg(struct mcam_camera *cam)
 629 {
 630         /*
 631          * The list-empty condition can hit us at resume time
 632          * if the buffer list was empty when the system was suspended.
 633          */
 634         if (list_empty(&cam->buffers)) {
 635                 set_bit(CF_SG_RESTART, &cam->flags);
 636                 return;
 637         }
 638
 639         mcam_reg_clear_bit(cam, REG_CTRL1, C1_DESC_3WORD);
 640         mcam_sg_next_buffer(cam);
 641         cam->nbufs = 3;
 642 }
 643
 644
 645 /*
 646  * Frame completion with S/G is trickier.  We can't muck with
 647  * a descriptor chain on the fly, since the controller buffers it
 648  * internally.  So we have to actually stop and restart; Marvell
 649  * says this is the way to do it.
 650  *
 651  * Of course, stopping is easier said than done; experience shows
 652  * that the controller can start a frame *after* C0_ENABLE has been
 653  * cleared.  So when running in S/G mode, the controller is "stopped"
 654  * on receipt of the start-of-frame interrupt.  That means we can
 655  * safely change the DMA descriptor array here and restart things
 656  * (assuming there's another buffer waiting to go).
 657  */
 658 static void mcam_dma_sg_done(struct mcam_camera *cam, int frame)
 659 {
 660         struct mcam_vb_buffer *buf = cam->vb_bufs[0];
 661
 662         /*
 663          * If we're no longer supposed to be streaming, don't do anything.
 664          */
 665         if (cam->state != S_STREAMING)
 666                 return;
 667         /*
 668          * If we have another buffer available, put it in and
 669          * restart the engine.
 670          */
 671         if (!list_empty(&cam->buffers)) {
 672                 mcam_sg_next_buffer(cam);
 673                 mcam_ctlr_start(cam);
 674         /*
 675          * Otherwise set CF_SG_RESTART and the controller will
 676          * be restarted once another buffer shows up.
 677          */
 678         } else {
 679                 set_bit(CF_SG_RESTART, &cam->flags);
 680                 cam->frame_state.singles++;
 681                 cam->vb_bufs[0] = NULL;
 682         }
 683         /*
 684          * Now we can give the completed frame back to user space.
 685          */
 686         cam->frame_state.delivered++;
 687         mcam_buffer_done(cam, frame, &buf->vb_buf);
 688 }
 689
 690
 691 /*
 692  * Scatter/gather mode requires stopping the controller between
 693  * frames so we can put in a new DMA descriptor array.  If no new
 694  * buffer exists at frame completion, the controller is left stopped;
 695  * this function is charged with getting things going again.
 696  */
 697 static void mcam_sg_restart(struct mcam_camera *cam)
 698 {
 699         mcam_ctlr_dma_sg(cam);
 700         mcam_ctlr_start(cam);
 701         clear_bit(CF_SG_RESTART, &cam->flags);
 702 }
 703
 704 #else /* MCAM_MODE_DMA_SG */
 705
 706 static inline void mcam_sg_restart(struct mcam_camera *cam)
 707 {
 708         return;
 709 }
 710
 711 #endif /* MCAM_MODE_DMA_SG */
 712
 713 /* ---------------------------------------------------------------------- */
 714 /*
 715  * Buffer-mode-independent controller code.
 716  */
 717
 718 /*
 719  * Image format setup
 720  */
 721 static void mcam_ctlr_image(struct mcam_camera *cam)
 722 {
 723         struct v4l2_pix_format *fmt = &cam->pix_format;
 724         u32 widthy = 0, widthuv = 0, imgsz_h, imgsz_w;
 725
 726         cam_dbg(cam, "camera: bytesperline = %d; height = %d\n",
 727                 fmt->bytesperline, fmt->sizeimage / fmt->bytesperline);
 728         imgsz_h = (fmt->height << IMGSZ_V_SHIFT) & IMGSZ_V_MASK;
 729         imgsz_w = (fmt->width * 2) & IMGSZ_H_MASK;
 730
 731         switch (fmt->pixelformat) {
 732         case V4L2_PIX_FMT_YUYV:
 733         case V4L2_PIX_FMT_YVYU:
 734                 widthy = fmt->width * 2;
 735                 widthuv = 0;
 736                 break;
 737         case V4L2_PIX_FMT_YUV420:
 738         case V4L2_PIX_FMT_YVU420:
 739                 widthy = fmt->width;
 740                 widthuv = fmt->width / 2;
 741                 break;
 742         default:
 743                 widthy = fmt->bytesperline;
 744                 widthuv = 0;
 745                 break;
 746         }
 747
 748         mcam_reg_write_mask(cam, REG_IMGPITCH, widthuv << 16 | widthy,
 749                         IMGP_YP_MASK | IMGP_UVP_MASK);
 750         mcam_reg_write(cam, REG_IMGSIZE, imgsz_h | imgsz_w);
 751         mcam_reg_write(cam, REG_IMGOFFSET, 0x0);
 752
 753         /*
 754          * Tell the controller about the image format we are using.
 755          */
 756         switch (fmt->pixelformat) {
 757         case V4L2_PIX_FMT_YUV420:
 758         case V4L2_PIX_FMT_YVU420:
 759                 mcam_reg_write_mask(cam, REG_CTRL0,
 760                         C0_DF_YUV | C0_YUV_420PL | C0_YUVE_VYUY, C0_DF_MASK);
 761                 break;
 762         case V4L2_PIX_FMT_YUYV:
 763                 mcam_reg_write_mask(cam, REG_CTRL0,
 764                         C0_DF_YUV | C0_YUV_PACKED | C0_YUVE_NOSWAP, C0_DF_MASK);
 765                 break;
 766         case V4L2_PIX_FMT_YVYU:
 767                 mcam_reg_write_mask(cam, REG_CTRL0,
 768                         C0_DF_YUV | C0_YUV_PACKED | C0_YUVE_SWAP24, C0_DF_MASK);
 769                 break;
 770         case V4L2_PIX_FMT_XRGB444:
 771                 mcam_reg_write_mask(cam, REG_CTRL0,
 772                         C0_DF_RGB | C0_RGBF_444 | C0_RGB4_XBGR, C0_DF_MASK);
 773                 break;
 774         case V4L2_PIX_FMT_RGB565:
 775                 mcam_reg_write_mask(cam, REG_CTRL0,
 776                         C0_DF_RGB | C0_RGBF_565 | C0_RGB5_BGGR, C0_DF_MASK);
 777                 break;
 778         case V4L2_PIX_FMT_SBGGR8:
 779                 mcam_reg_write_mask(cam, REG_CTRL0,
 780                         C0_DF_RGB | C0_RGB5_GRBG, C0_DF_MASK);
 781                 break;
 782         default:
 783                 cam_err(cam, "camera: unknown format: %#x\n", fmt->pixelformat);
 784                 break;
 785         }
 786
 787         /*
 788          * Make sure it knows we want to use hsync/vsync.
 789          */
 790         mcam_reg_write_mask(cam, REG_CTRL0, C0_SIF_HVSYNC, C0_SIFM_MASK);
 791 }
 792
 793
 794 /*
 795  * Configure the controller for operation; caller holds the
 796  * device mutex.
 797  */
 798 static int mcam_ctlr_configure(struct mcam_camera *cam)
 799 {
 800         unsigned long flags;
 801
 802         spin_lock_irqsave(&cam->dev_lock, flags);
 803         clear_bit(CF_SG_RESTART, &cam->flags);
 804         cam->dma_setup(cam);
 805         mcam_ctlr_image(cam);
 806         mcam_set_config_needed(cam, 0);
 807         spin_unlock_irqrestore(&cam->dev_lock, flags);
 808         return 0;
 809 }
 810
 811 static void mcam_ctlr_irq_enable(struct mcam_camera *cam)
 812 {
 813         /*
 814          * Clear any pending interrupts, since we do not
 815          * expect to have I/O active prior to enabling.
 816          */
 817         mcam_reg_write(cam, REG_IRQSTAT, FRAMEIRQS);
 818         mcam_reg_set_bit(cam, REG_IRQMASK, FRAMEIRQS);
 819 }
 820
 821 static void mcam_ctlr_irq_disable(struct mcam_camera *cam)
 822 {
 823         mcam_reg_clear_bit(cam, REG_IRQMASK, FRAMEIRQS);
 824 }
 825
 826 /*
 827  * Stop the controller, and don't return until we're really sure that no
 828  * further DMA is going on.
 829  */
 830 static void mcam_ctlr_stop_dma(struct mcam_camera *cam)
 831 {
 832         unsigned long flags;
 833
 834         /*
 835          * Theory: stop the camera controller (whether it is operating
 836          * or not).  Delay briefly just in case we race with the SOF
 837          * interrupt, then wait until no DMA is active.
 838          */
 839         spin_lock_irqsave(&cam->dev_lock, flags);
 840         clear_bit(CF_SG_RESTART, &cam->flags);
 841         mcam_ctlr_stop(cam);
 842         cam->state = S_IDLE;
 843         spin_unlock_irqrestore(&cam->dev_lock, flags);
 844         /*
 845          * This is a brutally long sleep, but experience shows that
 846          * it can take the controller a while to get the message that
 847          * it needs to stop grabbing frames.  In particular, we can
 848          * sometimes (on mmp) get a frame at the end WITHOUT the
 849          * start-of-frame indication.
 850          */
 851         msleep(150);
 852         if (test_bit(CF_DMA_ACTIVE, &cam->flags))
 853                 cam_err(cam, "Timeout waiting for DMA to end\n");
 854                 /* This would be bad news - what now? */
 855         spin_lock_irqsave(&cam->dev_lock, flags);
 856         mcam_ctlr_irq_disable(cam);
 857         spin_unlock_irqrestore(&cam->dev_lock, flags);
 858 }
 859
 860 /*
 861  * Power up and down.
 862  */
 863 static int mcam_ctlr_power_up(struct mcam_camera *cam)
 864 {
 865         unsigned long flags;
 866         int ret;
 867
 868         spin_lock_irqsave(&cam->dev_lock, flags);
 869         if (cam->plat_power_up) {
 870                 ret = cam->plat_power_up(cam);
 871                 if (ret) {
 872                         spin_unlock_irqrestore(&cam->dev_lock, flags);
 873                         return ret;
 874                 }
 875         }
 876         mcam_reg_clear_bit(cam, REG_CTRL1, C1_PWRDWN);
 877         spin_unlock_irqrestore(&cam->dev_lock, flags);
 878         return 0;
 879 }
 880
 881 static void mcam_ctlr_power_down(struct mcam_camera *cam)
 882 {
 883         unsigned long flags;
 884
 885         spin_lock_irqsave(&cam->dev_lock, flags);
 886         /*
 887          * School of hard knocks department: be sure we do any register
 888          * twiddling on the controller *before* calling the platform
 889          * power down routine.
 890          */
 891         mcam_reg_set_bit(cam, REG_CTRL1, C1_PWRDWN);
 892         if (cam->plat_power_down)
 893                 cam->plat_power_down(cam);
 894         spin_unlock_irqrestore(&cam->dev_lock, flags);
 895 }
 896
 897 /* ---------------------------------------------------------------------- */
 898 /*
 899  * Master sensor clock.
 900  */
 901 static int mclk_prepare(struct clk_hw *hw)
 902 {
 903         struct mcam_camera *cam = container_of(hw, struct mcam_camera, mclk_hw);
 904
 905         clk_prepare(cam->clk[0]);
 906         return 0;
 907 }
 908
 909 static void mclk_unprepare(struct clk_hw *hw)
 910 {
 911         struct mcam_camera *cam = container_of(hw, struct mcam_camera, mclk_hw);
 912
 913         clk_unprepare(cam->clk[0]);
 914 }
 915
 916 static int mclk_enable(struct clk_hw *hw)
 917 {
 918         struct mcam_camera *cam = container_of(hw, struct mcam_camera, mclk_hw);
 919         int mclk_src;
 920         int mclk_div;
 921         int ret;
 922
 923         /*
 924          * Clock the sensor appropriately.  Controller clock should
 925          * be 48MHz, sensor "typical" value is half that.
 926          */
 927         if (cam->bus_type == V4L2_MBUS_CSI2_DPHY) {
 928                 mclk_src = cam->mclk_src;
 929                 mclk_div = cam->mclk_div;
 930         } else {
 931                 mclk_src = 3;
 932                 mclk_div = 2;
 933         }
 934
 935         ret = pm_runtime_resume_and_get(cam->dev);
 936         if (ret < 0)
 937                 return ret;
 938         clk_enable(cam->clk[0]);
 939         mcam_reg_write(cam, REG_CLKCTRL, (mclk_src << 29) | mclk_div);
 940         mcam_ctlr_power_up(cam);
 941
 942         return 0;
 943 }
 944
 945 static void mclk_disable(struct clk_hw *hw)
 946 {
 947         struct mcam_camera *cam = container_of(hw, struct mcam_camera, mclk_hw);
 948
 949         mcam_ctlr_power_down(cam);
 950         clk_disable(cam->clk[0]);
 951         pm_runtime_put(cam->dev);
 952 }
 953
 954 static unsigned long mclk_recalc_rate(struct clk_hw *hw,
 955                                 unsigned long parent_rate)
 956 {
 957         return 48000000;
 958 }
 959
 960 static const struct clk_ops mclk_ops = {
 961         .prepare = mclk_prepare,
 962         .unprepare = mclk_unprepare,
 963         .enable = mclk_enable,
 964         .disable = mclk_disable,
 965         .recalc_rate = mclk_recalc_rate,
 966 };
 967
 968 /* -------------------------------------------------------------------- */
 969 /*
 970  * Communications with the sensor.
 971  */
 972
 973 static int __mcam_cam_reset(struct mcam_camera *cam)
 974 {
 975         return sensor_call(cam, core, reset, 0);
 976 }
 977
 978 /*
 979  * We have found the sensor on the i2c.  Let's try to have a
 980  * conversation.
 981  */
 982 static int mcam_cam_init(struct mcam_camera *cam)
 983 {
 984         int ret;
 985
 986         if (cam->state != S_NOTREADY)
 987                 cam_warn(cam, "Cam init with device in funky state %d",
 988                                 cam->state);
 989         ret = __mcam_cam_reset(cam);
 990         /* Get/set parameters? */
 991         cam->state = S_IDLE;
 992         return ret;
 993 }
 994
 995 /*
 996  * Configure the sensor to match the parameters we have.  Caller should
 997  * hold s_mutex
 998  */
 999 static int mcam_cam_set_flip(struct mcam_camera *cam)
1000 {
1001         struct v4l2_control ctrl;
1002
1003         memset(&ctrl, 0, sizeof(ctrl));
1004         ctrl.id = V4L2_CID_VFLIP;
1005         ctrl.value = flip;
1006         return v4l2_s_ctrl(NULL, cam->sensor->ctrl_handler, &ctrl);
1007 }
1008
1009
1010 static int mcam_cam_configure(struct mcam_camera *cam)
1011 {
1012         struct v4l2_subdev_format format = {
1013                 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1014         };
1015         int ret;
1016
1017         v4l2_fill_mbus_format(&format.format, &cam->pix_format, cam->mbus_code);
1018         ret = sensor_call(cam, core, init, 0);
1019         if (ret == 0)
1020                 ret = sensor_call(cam, pad, set_fmt, NULL, &format);
1021         /*
1022          * OV7670 does weird things if flip is set *before* format...
1023          */
1024         ret += mcam_cam_set_flip(cam);
1025         return ret;
1026 }
1027
1028 /*
1029  * Get everything ready, and start grabbing frames.
1030  */
1031 static int mcam_read_setup(struct mcam_camera *cam)
1032 {
1033         int ret;
1034         unsigned long flags;
1035
1036         /*
1037          * Configuration.  If we still don't have DMA buffers,
1038          * make one last, desperate attempt.
1039          */
1040         if (cam->buffer_mode == B_vmalloc && cam->nbufs == 0 &&
1041                         mcam_alloc_dma_bufs(cam, 0))
1042                 return -ENOMEM;
1043
1044         if (mcam_needs_config(cam)) {
1045                 mcam_cam_configure(cam);
1046                 ret = mcam_ctlr_configure(cam);
1047                 if (ret)
1048                         return ret;
1049         }
1050
1051         /*
1052          * Turn it loose.
1053          */
1054         spin_lock_irqsave(&cam->dev_lock, flags);
1055         clear_bit(CF_DMA_ACTIVE, &cam->flags);
1056         mcam_reset_buffers(cam);
1057         if (cam->bus_type == V4L2_MBUS_CSI2_DPHY)
1058                 mcam_enable_mipi(cam);
1059         else
1060                 mcam_disable_mipi(cam);
1061         mcam_ctlr_irq_enable(cam);
1062         cam->state = S_STREAMING;
1063         if (!test_bit(CF_SG_RESTART, &cam->flags))
1064                 mcam_ctlr_start(cam);
1065         spin_unlock_irqrestore(&cam->dev_lock, flags);
1066         return 0;
1067 }
1068
1069 /* ----------------------------------------------------------------------- */
1070 /*
1071  * Videobuf2 interface code.
1072  */
1073
1074 static int mcam_vb_queue_setup(struct vb2_queue *vq,
1075                 unsigned int *nbufs,
1076                 unsigned int *num_planes, unsigned int sizes[],
1077                 struct device *alloc_devs[])
1078 {
1079         struct mcam_camera *cam = vb2_get_drv_priv(vq);
1080         int minbufs = (cam->buffer_mode == B_DMA_contig) ? 3 : 2;
1081         unsigned size = cam->pix_format.sizeimage;
1082
1083         if (*nbufs < minbufs)
1084                 *nbufs = minbufs;
1085
1086         if (*num_planes)
1087                 return sizes[0] < size ? -EINVAL : 0;
1088         sizes[0] = size;
1089         *num_planes = 1; /* Someday we have to support planar formats... */
1090         return 0;
1091 }
1092
1093
1094 static void mcam_vb_buf_queue(struct vb2_buffer *vb)
1095 {
1096         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1097         struct mcam_vb_buffer *mvb = vb_to_mvb(vbuf);
1098         struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
1099         unsigned long flags;
1100         int start;
1101
1102         spin_lock_irqsave(&cam->dev_lock, flags);
1103         start = (cam->state == S_BUFWAIT) && !list_empty(&cam->buffers);
1104         list_add(&mvb->queue, &cam->buffers);
1105         if (cam->state == S_STREAMING && test_bit(CF_SG_RESTART, &cam->flags))
1106                 mcam_sg_restart(cam);
1107         spin_unlock_irqrestore(&cam->dev_lock, flags);
1108         if (start)
1109                 mcam_read_setup(cam);
1110 }
1111
1112 static void mcam_vb_requeue_bufs(struct vb2_queue *vq,
1113                                  enum vb2_buffer_state state)
1114 {
1115         struct mcam_camera *cam = vb2_get_drv_priv(vq);
1116         struct mcam_vb_buffer *buf, *node;
1117         unsigned long flags;
1118         unsigned i;
1119
1120         spin_lock_irqsave(&cam->dev_lock, flags);
1121         list_for_each_entry_safe(buf, node, &cam->buffers, queue) {
1122                 vb2_buffer_done(&buf->vb_buf.vb2_buf, state);
1123                 list_del(&buf->queue);
1124         }
1125         for (i = 0; i < MAX_DMA_BUFS; i++) {
1126                 buf = cam->vb_bufs[i];
1127
1128                 if (buf) {
1129                         vb2_buffer_done(&buf->vb_buf.vb2_buf, state);
1130                         cam->vb_bufs[i] = NULL;
1131                 }
1132         }
1133         spin_unlock_irqrestore(&cam->dev_lock, flags);
1134 }
1135
1136 /*
1137  * These need to be called with the mutex held from vb2
1138  */
1139 static int mcam_vb_start_streaming(struct vb2_queue *vq, unsigned int count)
1140 {
1141         struct mcam_camera *cam = vb2_get_drv_priv(vq);
1142         unsigned int frame;
1143         int ret;
1144
1145         if (cam->state != S_IDLE) {
1146                 mcam_vb_requeue_bufs(vq, VB2_BUF_STATE_QUEUED);
1147                 return -EINVAL;
1148         }
1149         cam->frame_state.frames = 0;
1150         cam->frame_state.singles = 0;
1151         cam->frame_state.delivered = 0;
1152         cam->sequence = 0;
1153         /*
1154          * Videobuf2 sneakily hoards all the buffers and won't
1155          * give them to us until *after* streaming starts.  But
1156          * we can't actually start streaming until we have a
1157          * destination.  So go into a wait state and hope they
1158          * give us buffers soon.
1159          */
1160         if (cam->buffer_mode != B_vmalloc && list_empty(&cam->buffers)) {
1161                 cam->state = S_BUFWAIT;
1162                 return 0;
1163         }
1164
1165         /*
1166          * Ensure clear the left over frame flags
1167          * before every really start streaming
1168          */
1169         for (frame = 0; frame < cam->nbufs; frame++)
1170                 clear_bit(CF_FRAME_SOF0 + frame, &cam->flags);
1171
1172         ret = mcam_read_setup(cam);
1173         if (ret)
1174                 mcam_vb_requeue_bufs(vq, VB2_BUF_STATE_QUEUED);
1175         return ret;
1176 }
1177
1178 static void mcam_vb_stop_streaming(struct vb2_queue *vq)
1179 {
1180         struct mcam_camera *cam = vb2_get_drv_priv(vq);
1181
1182         cam_dbg(cam, "stop_streaming: %d frames, %d singles, %d delivered\n",
1183                         cam->frame_state.frames, cam->frame_state.singles,
1184                         cam->frame_state.delivered);
1185         if (cam->state == S_BUFWAIT) {
1186                 /* They never gave us buffers */
1187                 cam->state = S_IDLE;
1188                 return;
1189         }
1190         if (cam->state != S_STREAMING)
1191                 return;
1192         mcam_ctlr_stop_dma(cam);
1193         /*
1194          * VB2 reclaims the buffers, so we need to forget
1195          * about them.
1196          */
1197         mcam_vb_requeue_bufs(vq, VB2_BUF_STATE_ERROR);
1198 }
1199
1200
1201 static const struct vb2_ops mcam_vb2_ops = {
1202         .queue_setup            = mcam_vb_queue_setup,
1203         .buf_queue              = mcam_vb_buf_queue,
1204         .start_streaming        = mcam_vb_start_streaming,
1205         .stop_streaming         = mcam_vb_stop_streaming,
1206         .wait_prepare           = vb2_ops_wait_prepare,
1207         .wait_finish            = vb2_ops_wait_finish,
1208 };
1209
1210
1211 #ifdef MCAM_MODE_DMA_SG
1212 /*
1213  * Scatter/gather mode uses all of the above functions plus a
1214  * few extras to deal with DMA mapping.
1215  */
1216 static int mcam_vb_sg_buf_init(struct vb2_buffer *vb)
1217 {
1218         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1219         struct mcam_vb_buffer *mvb = vb_to_mvb(vbuf);
1220         struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
1221         int ndesc = cam->pix_format.sizeimage/PAGE_SIZE + 1;
1222
1223         mvb->dma_desc = dma_alloc_coherent(cam->dev,
1224                         ndesc * sizeof(struct mcam_dma_desc),
1225                         &mvb->dma_desc_pa, GFP_KERNEL);
1226         if (mvb->dma_desc == NULL) {
1227                 cam_err(cam, "Unable to get DMA descriptor array\n");
1228                 return -ENOMEM;
1229         }
1230         return 0;
1231 }
1232
1233 static int mcam_vb_sg_buf_prepare(struct vb2_buffer *vb)
1234 {
1235         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1236         struct mcam_vb_buffer *mvb = vb_to_mvb(vbuf);
1237         struct sg_table *sg_table = vb2_dma_sg_plane_desc(vb, 0);
1238         struct mcam_dma_desc *desc = mvb->dma_desc;
1239         struct scatterlist *sg;
1240         int i;
1241
1242         for_each_sg(sg_table->sgl, sg, sg_table->nents, i) {
1243                 desc->dma_addr = sg_dma_address(sg);
1244                 desc->segment_len = sg_dma_len(sg);
1245                 desc++;
1246         }
1247         return 0;
1248 }
1249
1250 static void mcam_vb_sg_buf_cleanup(struct vb2_buffer *vb)
1251 {
1252         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1253         struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
1254         struct mcam_vb_buffer *mvb = vb_to_mvb(vbuf);
1255         int ndesc = cam->pix_format.sizeimage/PAGE_SIZE + 1;
1256
1257         dma_free_coherent(cam->dev, ndesc * sizeof(struct mcam_dma_desc),
1258                         mvb->dma_desc, mvb->dma_desc_pa);
1259 }
1260
1261
1262 static const struct vb2_ops mcam_vb2_sg_ops = {
1263         .queue_setup            = mcam_vb_queue_setup,
1264         .buf_init               = mcam_vb_sg_buf_init,
1265         .buf_prepare            = mcam_vb_sg_buf_prepare,
1266         .buf_queue              = mcam_vb_buf_queue,
1267         .buf_cleanup            = mcam_vb_sg_buf_cleanup,
1268         .start_streaming        = mcam_vb_start_streaming,
1269         .stop_streaming         = mcam_vb_stop_streaming,
1270         .wait_prepare           = vb2_ops_wait_prepare,
1271         .wait_finish            = vb2_ops_wait_finish,
1272 };
1273
1274 #endif /* MCAM_MODE_DMA_SG */
1275
1276 static int mcam_setup_vb2(struct mcam_camera *cam)
1277 {
1278         struct vb2_queue *vq = &cam->vb_queue;
1279
1280         memset(vq, 0, sizeof(*vq));
1281         vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1282         vq->drv_priv = cam;
1283         vq->lock = &cam->s_mutex;
1284         vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1285         vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1286         vq->buf_struct_size = sizeof(struct mcam_vb_buffer);
1287         vq->dev = cam->dev;
1288         INIT_LIST_HEAD(&cam->buffers);
1289         switch (cam->buffer_mode) {
1290         case B_DMA_contig:
1291 #ifdef MCAM_MODE_DMA_CONTIG
1292                 vq->ops = &mcam_vb2_ops;
1293                 vq->mem_ops = &vb2_dma_contig_memops;
1294                 cam->dma_setup = mcam_ctlr_dma_contig;
1295                 cam->frame_complete = mcam_dma_contig_done;
1296 #endif
1297                 break;
1298         case B_DMA_sg:
1299 #ifdef MCAM_MODE_DMA_SG
1300                 vq->ops = &mcam_vb2_sg_ops;
1301                 vq->mem_ops = &vb2_dma_sg_memops;
1302                 cam->dma_setup = mcam_ctlr_dma_sg;
1303                 cam->frame_complete = mcam_dma_sg_done;
1304 #endif
1305                 break;
1306         case B_vmalloc:
1307 #ifdef MCAM_MODE_VMALLOC
1308                 tasklet_setup(&cam->s_tasklet, mcam_frame_tasklet);
1309                 vq->ops = &mcam_vb2_ops;
1310                 vq->mem_ops = &vb2_vmalloc_memops;
1311                 cam->dma_setup = mcam_ctlr_dma_vmalloc;
1312                 cam->frame_complete = mcam_vmalloc_done;
1313 #endif
1314                 break;
1315         }
1316         return vb2_queue_init(vq);
1317 }
1318
1319
1320 /* ---------------------------------------------------------------------- */
1321 /*
1322  * The long list of V4L2 ioctl() operations.
1323  */
1324
1325 static int mcam_vidioc_querycap(struct file *file, void *priv,
1326                 struct v4l2_capability *cap)
1327 {
1328         struct mcam_camera *cam = video_drvdata(file);
1329
1330         strscpy(cap->driver, "marvell_ccic", sizeof(cap->driver));
1331         strscpy(cap->card, "marvell_ccic", sizeof(cap->card));
1332         strscpy(cap->bus_info, cam->bus_info, sizeof(cap->bus_info));
1333         return 0;
1334 }
1335
1336
1337 static int mcam_vidioc_enum_fmt_vid_cap(struct file *filp,
1338                 void *priv, struct v4l2_fmtdesc *fmt)
1339 {
1340         if (fmt->index >= N_MCAM_FMTS)
1341                 return -EINVAL;
1342         fmt->pixelformat = mcam_formats[fmt->index].pixelformat;
1343         return 0;
1344 }
1345
1346 static int mcam_vidioc_try_fmt_vid_cap(struct file *filp, void *priv,
1347                 struct v4l2_format *fmt)
1348 {
1349         struct mcam_camera *cam = video_drvdata(filp);
1350         struct mcam_format_struct *f;
1351         struct v4l2_pix_format *pix = &fmt->fmt.pix;
1352         struct v4l2_subdev_pad_config pad_cfg;
1353         struct v4l2_subdev_state pad_state = {
1354                 .pads = &pad_cfg,
1355         };
1356         struct v4l2_subdev_format format = {
1357                 .which = V4L2_SUBDEV_FORMAT_TRY,
1358         };
1359         int ret;
1360
1361         f = mcam_find_format(pix->pixelformat);
1362         pix->pixelformat = f->pixelformat;
1363         v4l2_fill_mbus_format(&format.format, pix, f->mbus_code);
1364         ret = sensor_call(cam, pad, set_fmt, &pad_state, &format);
1365         v4l2_fill_pix_format(pix, &format.format);
1366         pix->bytesperline = pix->width * f->bpp;
1367         switch (f->pixelformat) {
1368         case V4L2_PIX_FMT_YUV420:
1369         case V4L2_PIX_FMT_YVU420:
1370                 pix->sizeimage = pix->height * pix->bytesperline * 3 / 2;
1371                 break;
1372         default:
1373                 pix->sizeimage = pix->height * pix->bytesperline;
1374                 break;
1375         }
1376         pix->colorspace = V4L2_COLORSPACE_SRGB;
1377         return ret;
1378 }
1379
1380 static int mcam_vidioc_s_fmt_vid_cap(struct file *filp, void *priv,
1381                 struct v4l2_format *fmt)
1382 {
1383         struct mcam_camera *cam = video_drvdata(filp);
1384         struct mcam_format_struct *f;
1385         int ret;
1386
1387         /*
1388          * Can't do anything if the device is not idle
1389          * Also can't if there are streaming buffers in place.
1390          */
1391         if (cam->state != S_IDLE || vb2_is_busy(&cam->vb_queue))
1392                 return -EBUSY;
1393
1394         f = mcam_find_format(fmt->fmt.pix.pixelformat);
1395
1396         /*
1397          * See if the formatting works in principle.
1398          */
1399         ret = mcam_vidioc_try_fmt_vid_cap(filp, priv, fmt);
1400         if (ret)
1401                 return ret;
1402         /*
1403          * Now we start to change things for real, so let's do it
1404          * under lock.
1405          */
1406         cam->pix_format = fmt->fmt.pix;
1407         cam->mbus_code = f->mbus_code;
1408
1409         /*
1410          * Make sure we have appropriate DMA buffers.
1411          */
1412         if (cam->buffer_mode == B_vmalloc) {
1413                 ret = mcam_check_dma_buffers(cam);
1414                 if (ret)
1415                         goto out;
1416         }
1417         mcam_set_config_needed(cam, 1);
1418 out:
1419         return ret;
1420 }
1421
1422 /*
1423  * Return our stored notion of how the camera is/should be configured.
1424  * The V4l2 spec wants us to be smarter, and actually get this from
1425  * the camera (and not mess with it at open time).  Someday.
1426  */
1427 static int mcam_vidioc_g_fmt_vid_cap(struct file *filp, void *priv,
1428                 struct v4l2_format *f)
1429 {
1430         struct mcam_camera *cam = video_drvdata(filp);
1431
1432         f->fmt.pix = cam->pix_format;
1433         return 0;
1434 }
1435
1436 /*
1437  * We only have one input - the sensor - so minimize the nonsense here.
1438  */
1439 static int mcam_vidioc_enum_input(struct file *filp, void *priv,
1440                 struct v4l2_input *input)
1441 {
1442         if (input->index != 0)
1443                 return -EINVAL;
1444
1445         input->type = V4L2_INPUT_TYPE_CAMERA;
1446         strscpy(input->name, "Camera", sizeof(input->name));
1447         return 0;
1448 }
1449
1450 static int mcam_vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
1451 {
1452         *i = 0;
1453         return 0;
1454 }
1455
1456 static int mcam_vidioc_s_input(struct file *filp, void *priv, unsigned int i)
1457 {
1458         if (i != 0)
1459                 return -EINVAL;
1460         return 0;
1461 }
1462
1463 /*
1464  * G/S_PARM.  Most of this is done by the sensor, but we are
1465  * the level which controls the number of read buffers.
1466  */
1467 static int mcam_vidioc_g_parm(struct file *filp, void *priv,
1468                 struct v4l2_streamparm *a)
1469 {
1470         struct mcam_camera *cam = video_drvdata(filp);
1471         int ret;
1472
1473         ret = v4l2_g_parm_cap(video_devdata(filp), cam->sensor, a);
1474         a->parm.capture.readbuffers = n_dma_bufs;
1475         return ret;
1476 }
1477
1478 static int mcam_vidioc_s_parm(struct file *filp, void *priv,
1479                 struct v4l2_streamparm *a)
1480 {
1481         struct mcam_camera *cam = video_drvdata(filp);
1482         int ret;
1483
1484         ret = v4l2_s_parm_cap(video_devdata(filp), cam->sensor, a);
1485         a->parm.capture.readbuffers = n_dma_bufs;
1486         return ret;
1487 }
1488
1489 static int mcam_vidioc_enum_framesizes(struct file *filp, void *priv,
1490                 struct v4l2_frmsizeenum *sizes)
1491 {
1492         struct mcam_camera *cam = video_drvdata(filp);
1493         struct mcam_format_struct *f;
1494         struct v4l2_subdev_frame_size_enum fse = {
1495                 .index = sizes->index,
1496                 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1497         };
1498         int ret;
1499
1500         f = mcam_find_format(sizes->pixel_format);
1501         if (f->pixelformat != sizes->pixel_format)
1502                 return -EINVAL;
1503         fse.code = f->mbus_code;
1504         ret = sensor_call(cam, pad, enum_frame_size, NULL, &fse);
1505         if (ret)
1506                 return ret;
1507         if (fse.min_width == fse.max_width &&
1508             fse.min_height == fse.max_height) {
1509                 sizes->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1510                 sizes->discrete.width = fse.min_width;
1511                 sizes->discrete.height = fse.min_height;
1512                 return 0;
1513         }
1514         sizes->type = V4L2_FRMSIZE_TYPE_CONTINUOUS;
1515         sizes->stepwise.min_width = fse.min_width;
1516         sizes->stepwise.max_width = fse.max_width;
1517         sizes->stepwise.min_height = fse.min_height;
1518         sizes->stepwise.max_height = fse.max_height;
1519         sizes->stepwise.step_width = 1;
1520         sizes->stepwise.step_height = 1;
1521         return 0;
1522 }
1523
1524 static int mcam_vidioc_enum_frameintervals(struct file *filp, void *priv,
1525                 struct v4l2_frmivalenum *interval)
1526 {
1527         struct mcam_camera *cam = video_drvdata(filp);
1528         struct mcam_format_struct *f;
1529         struct v4l2_subdev_frame_interval_enum fie = {
1530                 .index = interval->index,
1531                 .width = interval->width,
1532                 .height = interval->height,
1533                 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1534         };
1535         int ret;
1536
1537         f = mcam_find_format(interval->pixel_format);
1538         if (f->pixelformat != interval->pixel_format)
1539                 return -EINVAL;
1540         fie.code = f->mbus_code;
1541         ret = sensor_call(cam, pad, enum_frame_interval, NULL, &fie);
1542         if (ret)
1543                 return ret;
1544         interval->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1545         interval->discrete = fie.interval;
1546         return 0;
1547 }
1548
1549 #ifdef CONFIG_VIDEO_ADV_DEBUG
1550 static int mcam_vidioc_g_register(struct file *file, void *priv,
1551                 struct v4l2_dbg_register *reg)
1552 {
1553         struct mcam_camera *cam = video_drvdata(file);
1554
1555         if (reg->reg > cam->regs_size - 4)
1556                 return -EINVAL;
1557         reg->val = mcam_reg_read(cam, reg->reg);
1558         reg->size = 4;
1559         return 0;
1560 }
1561
1562 static int mcam_vidioc_s_register(struct file *file, void *priv,
1563                 const struct v4l2_dbg_register *reg)
1564 {
1565         struct mcam_camera *cam = video_drvdata(file);
1566
1567         if (reg->reg > cam->regs_size - 4)
1568                 return -EINVAL;
1569         mcam_reg_write(cam, reg->reg, reg->val);
1570         return 0;
1571 }
1572 #endif
1573
1574 static const struct v4l2_ioctl_ops mcam_v4l_ioctl_ops = {
1575         .vidioc_querycap        = mcam_vidioc_querycap,
1576         .vidioc_enum_fmt_vid_cap = mcam_vidioc_enum_fmt_vid_cap,
1577         .vidioc_try_fmt_vid_cap = mcam_vidioc_try_fmt_vid_cap,
1578         .vidioc_s_fmt_vid_cap   = mcam_vidioc_s_fmt_vid_cap,
1579         .vidioc_g_fmt_vid_cap   = mcam_vidioc_g_fmt_vid_cap,
1580         .vidioc_enum_input      = mcam_vidioc_enum_input,
1581         .vidioc_g_input         = mcam_vidioc_g_input,
1582         .vidioc_s_input         = mcam_vidioc_s_input,
1583         .vidioc_reqbufs         = vb2_ioctl_reqbufs,
1584         .vidioc_create_bufs     = vb2_ioctl_create_bufs,
1585         .vidioc_querybuf        = vb2_ioctl_querybuf,
1586         .vidioc_qbuf            = vb2_ioctl_qbuf,
1587         .vidioc_dqbuf           = vb2_ioctl_dqbuf,
1588         .vidioc_expbuf          = vb2_ioctl_expbuf,
1589         .vidioc_streamon        = vb2_ioctl_streamon,
1590         .vidioc_streamoff       = vb2_ioctl_streamoff,
1591         .vidioc_g_parm          = mcam_vidioc_g_parm,
1592         .vidioc_s_parm          = mcam_vidioc_s_parm,
1593         .vidioc_enum_framesizes = mcam_vidioc_enum_framesizes,
1594         .vidioc_enum_frameintervals = mcam_vidioc_enum_frameintervals,
1595         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1596         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1597 #ifdef CONFIG_VIDEO_ADV_DEBUG
1598         .vidioc_g_register      = mcam_vidioc_g_register,
1599         .vidioc_s_register      = mcam_vidioc_s_register,
1600 #endif
1601 };
1602
1603 /* ---------------------------------------------------------------------- */
1604 /*
1605  * Our various file operations.
1606  */
1607 static int mcam_v4l_open(struct file *filp)
1608 {
1609         struct mcam_camera *cam = video_drvdata(filp);
1610         int ret;
1611
1612         mutex_lock(&cam->s_mutex);
1613         ret = v4l2_fh_open(filp);
1614         if (ret)
1615                 goto out;
1616         if (v4l2_fh_is_singular_file(filp)) {
1617                 ret = sensor_call(cam, core, s_power, 1);
1618                 if (ret)
1619                         goto out;
1620                 ret = pm_runtime_resume_and_get(cam->dev);
1621                 if (ret < 0)
1622                         goto out;
1623                 __mcam_cam_reset(cam);
1624                 mcam_set_config_needed(cam, 1);
1625         }
1626 out:
1627         mutex_unlock(&cam->s_mutex);
1628         if (ret)
1629                 v4l2_fh_release(filp);
1630         return ret;
1631 }
1632
1633
1634 static int mcam_v4l_release(struct file *filp)
1635 {
1636         struct mcam_camera *cam = video_drvdata(filp);
1637         bool last_open;
1638
1639         mutex_lock(&cam->s_mutex);
1640         last_open = v4l2_fh_is_singular_file(filp);
1641         _vb2_fop_release(filp, NULL);
1642         if (last_open) {
1643                 mcam_disable_mipi(cam);
1644                 sensor_call(cam, core, s_power, 0);
1645                 pm_runtime_put(cam->dev);
1646                 if (cam->buffer_mode == B_vmalloc && alloc_bufs_at_read)
1647                         mcam_free_dma_bufs(cam);
1648         }
1649
1650         mutex_unlock(&cam->s_mutex);
1651         return 0;
1652 }
1653
1654 static const struct v4l2_file_operations mcam_v4l_fops = {
1655         .owner = THIS_MODULE,
1656         .open = mcam_v4l_open,
1657         .release = mcam_v4l_release,
1658         .read = vb2_fop_read,
1659         .poll = vb2_fop_poll,
1660         .mmap = vb2_fop_mmap,
1661         .unlocked_ioctl = video_ioctl2,
1662 };
1663
1664
1665 /*
1666  * This template device holds all of those v4l2 methods; we
1667  * clone it for specific real devices.
1668  */
1669 static const struct video_device mcam_v4l_template = {
1670         .name = "mcam",
1671         .fops = &mcam_v4l_fops,
1672         .ioctl_ops = &mcam_v4l_ioctl_ops,
1673         .release = video_device_release_empty,
1674         .device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
1675                        V4L2_CAP_STREAMING,
1676 };
1677
1678 /* ---------------------------------------------------------------------- */
1679 /*
1680  * Interrupt handler stuff
1681  */
1682 static void mcam_frame_complete(struct mcam_camera *cam, int frame)
1683 {
1684         /*
1685          * Basic frame housekeeping.
1686          */
1687         set_bit(frame, &cam->flags);
1688         clear_bit(CF_DMA_ACTIVE, &cam->flags);
1689         cam->next_buf = frame;
1690         cam->buf_seq[frame] = cam->sequence++;
1691         cam->frame_state.frames++;
1692         /*
1693          * "This should never happen"
1694          */
1695         if (cam->state != S_STREAMING)
1696                 return;
1697         /*
1698          * Process the frame and set up the next one.
1699          */
1700         cam->frame_complete(cam, frame);
1701 }
1702
1703
1704 /*
1705  * The interrupt handler; this needs to be called from the
1706  * platform irq handler with the lock held.
1707  */
1708 int mccic_irq(struct mcam_camera *cam, unsigned int irqs)
1709 {
1710         unsigned int frame, handled = 0;
1711
1712         mcam_reg_write(cam, REG_IRQSTAT, FRAMEIRQS); /* Clear'em all */
1713         /*
1714          * Handle any frame completions.  There really should
1715          * not be more than one of these, or we have fallen
1716          * far behind.
1717          *
1718          * When running in S/G mode, the frame number lacks any
1719          * real meaning - there's only one descriptor array - but
1720          * the controller still picks a different one to signal
1721          * each time.
1722          */
1723         for (frame = 0; frame < cam->nbufs; frame++)
1724                 if (irqs & (IRQ_EOF0 << frame) &&
1725                         test_bit(CF_FRAME_SOF0 + frame, &cam->flags)) {
1726                         mcam_frame_complete(cam, frame);
1727                         handled = 1;
1728                         clear_bit(CF_FRAME_SOF0 + frame, &cam->flags);
1729                         if (cam->buffer_mode == B_DMA_sg)
1730                                 break;
1731                 }
1732         /*
1733          * If a frame starts, note that we have DMA active.  This
1734          * code assumes that we won't get multiple frame interrupts
1735          * at once; may want to rethink that.
1736          */
1737         for (frame = 0; frame < cam->nbufs; frame++) {
1738                 if (irqs & (IRQ_SOF0 << frame)) {
1739                         set_bit(CF_FRAME_SOF0 + frame, &cam->flags);
1740                         handled = IRQ_HANDLED;
1741                 }
1742         }
1743
1744         if (handled == IRQ_HANDLED) {
1745                 set_bit(CF_DMA_ACTIVE, &cam->flags);
1746                 if (cam->buffer_mode == B_DMA_sg)
1747                         mcam_ctlr_stop(cam);
1748         }
1749         return handled;
1750 }
1751 EXPORT_SYMBOL_GPL(mccic_irq);
1752
1753 /* ---------------------------------------------------------------------- */
1754 /*
1755  * Registration and such.
1756  */
1757
1758 static int mccic_notify_bound(struct v4l2_async_notifier *notifier,
1759         struct v4l2_subdev *subdev, struct v4l2_async_connection *asd)
1760 {
1761         struct mcam_camera *cam = notifier_to_mcam(notifier);
1762         int ret;
1763
1764         mutex_lock(&cam->s_mutex);
1765         if (cam->sensor) {
1766                 cam_err(cam, "sensor already bound\n");
1767                 ret = -EBUSY;
1768                 goto out;
1769         }
1770
1771         v4l2_set_subdev_hostdata(subdev, cam);
1772         cam->sensor = subdev;
1773
1774         ret = mcam_cam_init(cam);
1775         if (ret) {
1776                 cam->sensor = NULL;
1777                 goto out;
1778         }
1779
1780         ret = mcam_setup_vb2(cam);
1781         if (ret) {
1782                 cam->sensor = NULL;
1783                 goto out;
1784         }
1785
1786         cam->vdev = mcam_v4l_template;
1787         cam->vdev.v4l2_dev = &cam->v4l2_dev;
1788         cam->vdev.lock = &cam->s_mutex;
1789         cam->vdev.queue = &cam->vb_queue;
1790         video_set_drvdata(&cam->vdev, cam);
1791         ret = video_register_device(&cam->vdev, VFL_TYPE_VIDEO, -1);
1792         if (ret) {
1793                 cam->sensor = NULL;
1794                 goto out;
1795         }
1796
1797         cam_dbg(cam, "sensor %s bound\n", subdev->name);
1798 out:
1799         mutex_unlock(&cam->s_mutex);
1800         return ret;
1801 }
1802
1803 static void mccic_notify_unbind(struct v4l2_async_notifier *notifier,
1804         struct v4l2_subdev *subdev, struct v4l2_async_connection *asd)
1805 {
1806         struct mcam_camera *cam = notifier_to_mcam(notifier);
1807
1808         mutex_lock(&cam->s_mutex);
1809         if (cam->sensor != subdev) {
1810                 cam_err(cam, "sensor %s not bound\n", subdev->name);
1811                 goto out;
1812         }
1813
1814         video_unregister_device(&cam->vdev);
1815         cam->sensor = NULL;
1816         cam_dbg(cam, "sensor %s unbound\n", subdev->name);
1817
1818 out:
1819         mutex_unlock(&cam->s_mutex);
1820 }
1821
1822 static int mccic_notify_complete(struct v4l2_async_notifier *notifier)
1823 {
1824         struct mcam_camera *cam = notifier_to_mcam(notifier);
1825         int ret;
1826
1827         /*
1828          * Get the v4l2 setup done.
1829          */
1830         ret = v4l2_ctrl_handler_init(&cam->ctrl_handler, 10);
1831         if (!ret)
1832                 cam->v4l2_dev.ctrl_handler = &cam->ctrl_handler;
1833
1834         return ret;
1835 }
1836
1837 static const struct v4l2_async_notifier_operations mccic_notify_ops = {
1838         .bound = mccic_notify_bound,
1839         .unbind = mccic_notify_unbind,
1840         .complete = mccic_notify_complete,
1841 };
1842
1843 int mccic_register(struct mcam_camera *cam)
1844 {
1845         struct clk_init_data mclk_init = { };
1846         int ret;
1847
1848         /*
1849          * Validate the requested buffer mode.
1850          */
1851         if (buffer_mode >= 0)
1852                 cam->buffer_mode = buffer_mode;
1853         if (cam->buffer_mode == B_DMA_sg &&
1854                         cam->chip_id == MCAM_CAFE) {
1855                 printk(KERN_ERR "marvell-cam: Cafe can't do S/G I/O, attempting vmalloc mode instead\n");
1856                 cam->buffer_mode = B_vmalloc;
1857         }
1858
1859         if (!mcam_buffer_mode_supported(cam->buffer_mode)) {
1860                 printk(KERN_ERR "marvell-cam: buffer mode %d unsupported\n",
1861                                 cam->buffer_mode);
1862                 ret = -EINVAL;
1863                 goto out;
1864         }
1865
1866         mutex_init(&cam->s_mutex);
1867         cam->state = S_NOTREADY;
1868         mcam_set_config_needed(cam, 1);
1869         cam->pix_format = mcam_def_pix_format;
1870         cam->mbus_code = mcam_def_mbus_code;
1871
1872         cam->notifier.ops = &mccic_notify_ops;
1873         ret = v4l2_async_nf_register(&cam->v4l2_dev, &cam->notifier);
1874         if (ret < 0) {
1875                 cam_warn(cam, "failed to register a sensor notifier");
1876                 goto out;
1877         }
1878
1879         /*
1880          * Register sensor master clock.
1881          */
1882         mclk_init.parent_names = NULL;
1883         mclk_init.num_parents = 0;
1884         mclk_init.ops = &mclk_ops;
1885         mclk_init.name = "mclk";
1886
1887         of_property_read_string(cam->dev->of_node, "clock-output-names",
1888                                                         &mclk_init.name);
1889
1890         cam->mclk_hw.init = &mclk_init;
1891
1892         cam->mclk = devm_clk_register(cam->dev, &cam->mclk_hw);
1893         if (IS_ERR(cam->mclk)) {
1894                 ret = PTR_ERR(cam->mclk);
1895                 dev_err(cam->dev, "can't register clock\n");
1896                 goto out;
1897         }
1898
1899         /*
1900          * If so requested, try to get our DMA buffers now.
1901          */
1902         if (cam->buffer_mode == B_vmalloc && !alloc_bufs_at_read) {
1903                 if (mcam_alloc_dma_bufs(cam, 1))
1904                         cam_warn(cam, "Unable to alloc DMA buffers at load will try again later.");
1905         }
1906
1907         return 0;
1908
1909 out:
1910         v4l2_async_nf_unregister(&cam->notifier);
1911         v4l2_async_nf_cleanup(&cam->notifier);
1912         return ret;
1913 }
1914 EXPORT_SYMBOL_GPL(mccic_register);
1915
1916 void mccic_shutdown(struct mcam_camera *cam)
1917 {
1918         /*
1919          * If we have no users (and we really, really should have no
1920          * users) the device will already be powered down.  Trying to
1921          * take it down again will wedge the machine, which is frowned
1922          * upon.
1923          */
1924         if (!list_empty(&cam->vdev.fh_list)) {
1925                 cam_warn(cam, "Removing a device with users!\n");
1926                 sensor_call(cam, core, s_power, 0);
1927         }
1928         if (cam->buffer_mode == B_vmalloc)
1929                 mcam_free_dma_bufs(cam);
1930         v4l2_ctrl_handler_free(&cam->ctrl_handler);
1931         v4l2_async_nf_unregister(&cam->notifier);
1932         v4l2_async_nf_cleanup(&cam->notifier);
1933 }
1934 EXPORT_SYMBOL_GPL(mccic_shutdown);
1935
1936 /*
1937  * Power management
1938  */
1939 void mccic_suspend(struct mcam_camera *cam)
1940 {
1941         mutex_lock(&cam->s_mutex);
1942         if (!list_empty(&cam->vdev.fh_list)) {
1943                 enum mcam_state cstate = cam->state;
1944
1945                 mcam_ctlr_stop_dma(cam);
1946                 sensor_call(cam, core, s_power, 0);
1947                 cam->state = cstate;
1948         }
1949         mutex_unlock(&cam->s_mutex);
1950 }
1951 EXPORT_SYMBOL_GPL(mccic_suspend);
1952
1953 int mccic_resume(struct mcam_camera *cam)
1954 {
1955         int ret = 0;
1956
1957         mutex_lock(&cam->s_mutex);
1958         if (!list_empty(&cam->vdev.fh_list)) {
1959                 ret = sensor_call(cam, core, s_power, 1);
1960                 if (ret) {
1961                         mutex_unlock(&cam->s_mutex);
1962                         return ret;
1963                 }
1964                 __mcam_cam_reset(cam);
1965         } else {
1966                 sensor_call(cam, core, s_power, 0);
1967         }
1968         mutex_unlock(&cam->s_mutex);
1969
1970         set_bit(CF_CONFIG_NEEDED, &cam->flags);
1971         if (cam->state == S_STREAMING) {
1972                 /*
1973                  * If there was a buffer in the DMA engine at suspend
1974                  * time, put it back on the queue or we'll forget about it.
1975                  */
1976                 if (cam->buffer_mode == B_DMA_sg && cam->vb_bufs[0])
1977                         list_add(&cam->vb_bufs[0]->queue, &cam->buffers);
1978                 ret = mcam_read_setup(cam);
1979         }
1980         return ret;
1981 }
1982 EXPORT_SYMBOL_GPL(mccic_resume);
1983
1984 MODULE_LICENSE("GPL v2");
1985 MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>");