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