2 * The Marvell camera core. This device appears in a number of settings,
3 * so it needs platform-specific support outside of the core.
5 * Copyright 2011 Jonathan Corbet corbet@lwn.net
7 #include <linux/kernel.h>
8 #include <linux/module.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>
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>
33 #include "mcam-core.h"
35 #ifdef MCAM_MODE_VMALLOC
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.
44 * The controller can cycle through three buffers. We could use
45 * more by flipping pointers around, but it probably makes little
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");
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.");
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 "
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 */
76 module_param(flip, bool, 0444);
77 MODULE_PARM_DESC(flip,
78 "If set, the sensor will be instructed to flip the image "
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 "
89 * Status flags. Always manipulated with bit operations.
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
102 #define sensor_call(cam, o, f, args...) \
103 v4l2_subdev_call(cam->sensor, o, f, ##args)
105 static struct mcam_format_struct {
108 int bpp; /* Bytes per pixel */
113 .desc = "YUYV 4:2:2",
114 .pixelformat = V4L2_PIX_FMT_YUYV,
115 .mbus_code = MEDIA_BUS_FMT_YUYV8_2X8,
120 .desc = "YVYU 4:2:2",
121 .pixelformat = V4L2_PIX_FMT_YVYU,
122 .mbus_code = MEDIA_BUS_FMT_YUYV8_2X8,
127 .desc = "YUV 4:2:0 PLANAR",
128 .pixelformat = V4L2_PIX_FMT_YUV420,
129 .mbus_code = MEDIA_BUS_FMT_YUYV8_2X8,
134 .desc = "YVU 4:2:0 PLANAR",
135 .pixelformat = V4L2_PIX_FMT_YVU420,
136 .mbus_code = MEDIA_BUS_FMT_YUYV8_2X8,
142 .pixelformat = V4L2_PIX_FMT_XRGB444,
143 .mbus_code = MEDIA_BUS_FMT_RGB444_2X8_PADHI_LE,
149 .pixelformat = V4L2_PIX_FMT_RGB565,
150 .mbus_code = MEDIA_BUS_FMT_RGB565_2X8_LE,
155 .desc = "Raw RGB Bayer",
156 .pixelformat = V4L2_PIX_FMT_SBGGR8,
157 .mbus_code = MEDIA_BUS_FMT_SBGGR8_1X8,
162 #define N_MCAM_FMTS ARRAY_SIZE(mcam_formats)
164 static struct mcam_format_struct *mcam_find_format(u32 pixelformat)
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. */
176 * The default format we use until somebody says otherwise.
178 static const struct v4l2_pix_format mcam_def_pix_format = {
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,
188 static const u32 mcam_def_mbus_code = MEDIA_BUS_FMT_YUYV8_2X8;
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.
197 struct mcam_dma_desc {
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.
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 */
215 static inline struct mcam_vb_buffer *vb_to_mvb(struct vb2_v4l2_buffer *vb)
217 return container_of(vb, struct mcam_vb_buffer, vb_buf);
221 * Hand a completed buffer back to user space.
223 static void mcam_buffer_done(struct mcam_camera *cam, int frame,
224 struct vb2_v4l2_buffer *vbuf)
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);
237 * Debugging and related.
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);
248 * Flag manipulation helpers
250 static void mcam_reset_buffers(struct mcam_camera *cam)
255 for (i = 0; i < cam->nbufs; i++) {
256 clear_bit(i, &cam->flags);
257 clear_bit(CF_FRAME_SOF0 + i, &cam->flags);
261 static inline int mcam_needs_config(struct mcam_camera *cam)
263 return test_bit(CF_CONFIG_NEEDED, &cam->flags);
266 static void mcam_set_config_needed(struct mcam_camera *cam, int needed)
269 set_bit(CF_CONFIG_NEEDED, &cam->flags);
271 clear_bit(CF_CONFIG_NEEDED, &cam->flags);
274 /* ------------------------------------------------------------------- */
276 * Make the controller start grabbing images. Everything must
277 * be set up before doing this.
279 static void mcam_ctlr_start(struct mcam_camera *cam)
281 /* set_bit performs a read, so no other barrier should be
283 mcam_reg_set_bit(cam, REG_CTRL0, C0_ENABLE);
286 static void mcam_ctlr_stop(struct mcam_camera *cam)
288 mcam_reg_clear_bit(cam, REG_CTRL0, C0_ENABLE);
291 static void mcam_enable_mipi(struct mcam_camera *mcam)
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]);
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 */
306 * 0x41 actives 1 lane
307 * 0x43 actives 2 lanes
308 * 0x45 actives 3 lanes (never happen)
309 * 0x47 actives 4 lanes
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);
316 mcam->mipi_enabled = true;
320 static void mcam_disable_mipi(struct mcam_camera *mcam)
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;
330 static bool mcam_fmt_is_planar(__u32 pfmt)
332 struct mcam_format_struct *f;
334 f = mcam_find_format(pfmt);
338 static void mcam_write_yuv_bases(struct mcam_camera *cam,
339 unsigned frame, dma_addr_t base)
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;
347 switch (fmt->pixelformat) {
348 case V4L2_PIX_FMT_YUV420:
350 v = u + pixel_count / 4;
352 case V4L2_PIX_FMT_YVU420:
354 u = v + pixel_count / 4;
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);
367 /* ------------------------------------------------------------------- */
369 #ifdef MCAM_MODE_VMALLOC
371 * Code specific to the vmalloc buffer mode.
375 * Allocate in-kernel DMA buffers for vmalloc mode.
377 static int mcam_alloc_dma_bufs(struct mcam_camera *cam, int loadtime)
381 mcam_set_config_needed(cam, 1);
383 cam->dma_buf_size = dma_buf_size;
385 cam->dma_buf_size = cam->pix_format.sizeimage;
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,
394 if (cam->dma_bufs[i] == NULL) {
395 cam_warn(cam, "Failed to allocate DMA buffer\n");
401 switch (cam->nbufs) {
403 dma_free_coherent(cam->dev, cam->dma_buf_size,
404 cam->dma_bufs[0], cam->dma_handles[0]);
407 cam_err(cam, "Insufficient DMA buffers, cannot operate\n");
412 cam_warn(cam, "Will limp along with only 2 buffers\n");
418 static void mcam_free_dma_bufs(struct mcam_camera *cam)
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;
432 * Set up DMA buffers when operating in vmalloc mode
434 static void mcam_ctlr_dma_vmalloc(struct mcam_camera *cam)
437 * Store the first two YUV buffers. Then either
438 * set the third if it exists, or tell the controller
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);
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 */
453 * Copy data out to user space in the vmalloc case
455 static void mcam_frame_tasklet(unsigned long data)
457 struct mcam_camera *cam = (struct mcam_camera *) data;
460 struct mcam_vb_buffer *buf;
462 spin_lock_irqsave(&cam->dev_lock, flags);
463 for (i = 0; i < cam->nbufs; i++) {
464 int bufno = cam->next_buf;
466 if (cam->state != S_STREAMING || bufno < 0)
467 break; /* I/O got stopped */
468 if (++(cam->next_buf) >= cam->nbufs)
470 if (!test_bit(bufno, &cam->flags))
472 if (list_empty(&cam->buffers)) {
473 cam->frame_state.singles++;
474 break; /* Leave it valid, hope for better later */
476 cam->frame_state.delivered++;
477 clear_bit(bufno, &cam->flags);
478 buf = list_first_entry(&cam->buffers, struct mcam_vb_buffer,
480 list_del_init(&buf->queue);
482 * Drop the lock during the big copy. This *should* be safe...
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);
491 spin_unlock_irqrestore(&cam->dev_lock, flags);
496 * Make sure our allocated buffers are up to the task.
498 static int mcam_check_dma_buffers(struct mcam_camera *cam)
500 if (cam->nbufs > 0 && cam->dma_buf_size < cam->pix_format.sizeimage)
501 mcam_free_dma_bufs(cam);
503 return mcam_alloc_dma_bufs(cam, 0);
507 static void mcam_vmalloc_done(struct mcam_camera *cam, int frame)
509 tasklet_schedule(&cam->s_tasklet);
512 #else /* MCAM_MODE_VMALLOC */
514 static inline int mcam_alloc_dma_bufs(struct mcam_camera *cam, int loadtime)
519 static inline void mcam_free_dma_bufs(struct mcam_camera *cam)
524 static inline int mcam_check_dma_buffers(struct mcam_camera *cam)
531 #endif /* MCAM_MODE_VMALLOC */
534 #ifdef MCAM_MODE_DMA_CONTIG
535 /* ---------------------------------------------------------------------- */
537 * DMA-contiguous code.
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.
548 static void mcam_set_contig_buffer(struct mcam_camera *cam, int frame)
550 struct mcam_vb_buffer *buf;
551 dma_addr_t dma_handle;
552 struct vb2_v4l2_buffer *vb;
555 * If there are no available buffers, go into single mode
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++;
563 * OK, we have a buffer we can use.
565 buf = list_first_entry(&cam->buffers, struct mcam_vb_buffer,
567 list_del_init(&buf->queue);
568 clear_bit(CF_SINGLE_BUFFER, &cam->flags);
571 cam->vb_bufs[frame] = buf;
574 dma_handle = vb2_dma_contig_plane_dma_addr(&vb->vb2_buf, 0);
575 mcam_write_yuv_bases(cam, frame, dma_handle);
579 * Initial B_DMA_contig setup.
581 static void mcam_ctlr_dma_contig(struct mcam_camera *cam)
583 mcam_reg_set_bit(cam, REG_CTRL1, C1_TWOBUFS);
585 mcam_set_contig_buffer(cam, 0);
586 mcam_set_contig_buffer(cam, 1);
590 * Frame completion handling.
592 static void mcam_dma_contig_done(struct mcam_camera *cam, int frame)
594 struct mcam_vb_buffer *buf = cam->vb_bufs[frame];
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);
601 mcam_set_contig_buffer(cam, frame);
604 #endif /* MCAM_MODE_DMA_CONTIG */
606 #ifdef MCAM_MODE_DMA_SG
607 /* ---------------------------------------------------------------------- */
609 * Scatter/gather-specific code.
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.
616 static void mcam_sg_next_buffer(struct mcam_camera *cam)
618 struct mcam_vb_buffer *buf;
620 buf = list_first_entry(&cam->buffers, struct mcam_vb_buffer, queue);
621 list_del_init(&buf->queue);
623 * Very Bad Not Good Things happen if you don't clear
624 * C1_DESC_ENA before making any descriptor changes.
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;
637 * Initial B_DMA_sg setup
639 static void mcam_ctlr_dma_sg(struct mcam_camera *cam)
642 * The list-empty condition can hit us at resume time
643 * if the buffer list was empty when the system was suspended.
645 if (list_empty(&cam->buffers)) {
646 set_bit(CF_SG_RESTART, &cam->flags);
650 mcam_reg_clear_bit(cam, REG_CTRL1, C1_DESC_3WORD);
651 mcam_sg_next_buffer(cam);
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.
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).
669 static void mcam_dma_sg_done(struct mcam_camera *cam, int frame)
671 struct mcam_vb_buffer *buf = cam->vb_bufs[0];
674 * If we're no longer supposed to be streaming, don't do anything.
676 if (cam->state != S_STREAMING)
679 * If we have another buffer available, put it in and
680 * restart the engine.
682 if (!list_empty(&cam->buffers)) {
683 mcam_sg_next_buffer(cam);
684 mcam_ctlr_start(cam);
686 * Otherwise set CF_SG_RESTART and the controller will
687 * be restarted once another buffer shows up.
690 set_bit(CF_SG_RESTART, &cam->flags);
691 cam->frame_state.singles++;
692 cam->vb_bufs[0] = NULL;
695 * Now we can give the completed frame back to user space.
697 cam->frame_state.delivered++;
698 mcam_buffer_done(cam, frame, &buf->vb_buf);
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.
708 static void mcam_sg_restart(struct mcam_camera *cam)
710 mcam_ctlr_dma_sg(cam);
711 mcam_ctlr_start(cam);
712 clear_bit(CF_SG_RESTART, &cam->flags);
715 #else /* MCAM_MODE_DMA_SG */
717 static inline void mcam_sg_restart(struct mcam_camera *cam)
722 #endif /* MCAM_MODE_DMA_SG */
724 /* ---------------------------------------------------------------------- */
726 * Buffer-mode-independent controller code.
732 static void mcam_ctlr_image(struct mcam_camera *cam)
734 struct v4l2_pix_format *fmt = &cam->pix_format;
735 u32 widthy = 0, widthuv = 0, imgsz_h, imgsz_w;
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;
742 switch (fmt->pixelformat) {
743 case V4L2_PIX_FMT_YUYV:
744 case V4L2_PIX_FMT_YVYU:
745 widthy = fmt->width * 2;
748 case V4L2_PIX_FMT_YUV420:
749 case V4L2_PIX_FMT_YVU420:
751 widthuv = fmt->width / 2;
754 widthy = fmt->bytesperline;
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);
765 * Tell the controller about the image format we are using.
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);
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);
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);
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);
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);
789 case V4L2_PIX_FMT_SBGGR8:
790 mcam_reg_write_mask(cam, REG_CTRL0,
791 C0_DF_RGB | C0_RGB5_GRBG, C0_DF_MASK);
794 cam_err(cam, "camera: unknown format: %#x\n", fmt->pixelformat);
799 * Make sure it knows we want to use hsync/vsync.
801 mcam_reg_write_mask(cam, REG_CTRL0, C0_SIF_HVSYNC, C0_SIFM_MASK);
803 * This field controls the generation of EOF(DVP only)
805 if (cam->bus_type != V4L2_MBUS_CSI2)
806 mcam_reg_set_bit(cam, REG_CTRL0,
807 C0_EOF_VSYNC | C0_VEDGE_CTRL);
812 * Configure the controller for operation; caller holds the
815 static int mcam_ctlr_configure(struct mcam_camera *cam)
819 spin_lock_irqsave(&cam->dev_lock, flags);
820 clear_bit(CF_SG_RESTART, &cam->flags);
822 mcam_ctlr_image(cam);
823 mcam_set_config_needed(cam, 0);
824 spin_unlock_irqrestore(&cam->dev_lock, flags);
828 static void mcam_ctlr_irq_enable(struct mcam_camera *cam)
831 * Clear any pending interrupts, since we do not
832 * expect to have I/O active prior to enabling.
834 mcam_reg_write(cam, REG_IRQSTAT, FRAMEIRQS);
835 mcam_reg_set_bit(cam, REG_IRQMASK, FRAMEIRQS);
838 static void mcam_ctlr_irq_disable(struct mcam_camera *cam)
840 mcam_reg_clear_bit(cam, REG_IRQMASK, FRAMEIRQS);
845 static void mcam_ctlr_init(struct mcam_camera *cam)
849 spin_lock_irqsave(&cam->dev_lock, flags);
851 * Make sure it's not powered down.
853 mcam_reg_clear_bit(cam, REG_CTRL1, C1_PWRDWN);
855 * Turn off the enable bit. It sure should be off anyway,
856 * but it's good to be sure.
858 mcam_reg_clear_bit(cam, REG_CTRL0, C0_ENABLE);
860 * Clock the sensor appropriately. Controller clock should
861 * be 48MHz, sensor "typical" value is half that.
863 mcam_reg_write_mask(cam, REG_CLKCTRL, 2, CLK_DIV_MASK);
864 spin_unlock_irqrestore(&cam->dev_lock, flags);
869 * Stop the controller, and don't return until we're really sure that no
870 * further DMA is going on.
872 static void mcam_ctlr_stop_dma(struct mcam_camera *cam)
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.
881 spin_lock_irqsave(&cam->dev_lock, flags);
882 clear_bit(CF_SG_RESTART, &cam->flags);
885 spin_unlock_irqrestore(&cam->dev_lock, flags);
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.
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);
905 static int mcam_ctlr_power_up(struct mcam_camera *cam)
910 spin_lock_irqsave(&cam->dev_lock, flags);
911 ret = cam->plat_power_up(cam);
913 spin_unlock_irqrestore(&cam->dev_lock, flags);
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 */
922 static void mcam_ctlr_power_down(struct mcam_camera *cam)
926 spin_lock_irqsave(&cam->dev_lock, flags);
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.
932 mcam_reg_set_bit(cam, REG_CTRL1, C1_PWRDWN);
933 cam->plat_power_down(cam);
934 spin_unlock_irqrestore(&cam->dev_lock, flags);
937 /* -------------------------------------------------------------------- */
939 * Communications with the sensor.
942 static int __mcam_cam_reset(struct mcam_camera *cam)
944 return sensor_call(cam, core, reset, 0);
948 * We have found the sensor on the i2c. Let's try to have a
951 static int mcam_cam_init(struct mcam_camera *cam)
955 if (cam->state != S_NOTREADY)
956 cam_warn(cam, "Cam init with device in funky state %d",
958 ret = __mcam_cam_reset(cam);
959 /* Get/set parameters? */
961 mcam_ctlr_power_down(cam);
966 * Configure the sensor to match the parameters we have. Caller should
969 static int mcam_cam_set_flip(struct mcam_camera *cam)
971 struct v4l2_control ctrl;
973 memset(&ctrl, 0, sizeof(ctrl));
974 ctrl.id = V4L2_CID_VFLIP;
976 return sensor_call(cam, core, s_ctrl, &ctrl);
980 static int mcam_cam_configure(struct mcam_camera *cam)
982 struct v4l2_subdev_format format = {
983 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
987 v4l2_fill_mbus_format(&format.format, &cam->pix_format, cam->mbus_code);
988 ret = sensor_call(cam, core, init, 0);
990 ret = sensor_call(cam, pad, set_fmt, NULL, &format);
992 * OV7670 does weird things if flip is set *before* format...
994 ret += mcam_cam_set_flip(cam);
999 * Get everything ready, and start grabbing frames.
1001 static int mcam_read_setup(struct mcam_camera *cam)
1004 unsigned long flags;
1007 * Configuration. If we still don't have DMA buffers,
1008 * make one last, desperate attempt.
1010 if (cam->buffer_mode == B_vmalloc && cam->nbufs == 0 &&
1011 mcam_alloc_dma_bufs(cam, 0))
1014 if (mcam_needs_config(cam)) {
1015 mcam_cam_configure(cam);
1016 ret = mcam_ctlr_configure(cam);
1024 spin_lock_irqsave(&cam->dev_lock, flags);
1025 clear_bit(CF_DMA_ACTIVE, &cam->flags);
1026 mcam_reset_buffers(cam);
1028 * Update CSI2_DPHY value
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);
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);
1046 /* ----------------------------------------------------------------------- */
1048 * Videobuf2 interface code.
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[],
1056 struct mcam_camera *cam = vb2_get_drv_priv(vq);
1057 int minbufs = (cam->buffer_mode == B_DMA_contig) ? 3 : 2;
1059 if (fmt && fmt->fmt.pix.sizeimage < cam->pix_format.sizeimage)
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)
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;
1073 static void mcam_vb_buf_queue(struct vb2_buffer *vb)
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;
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);
1088 mcam_read_setup(cam);
1091 static void mcam_vb_requeue_bufs(struct vb2_queue *vq,
1092 enum vb2_buffer_state state)
1094 struct mcam_camera *cam = vb2_get_drv_priv(vq);
1095 struct mcam_vb_buffer *buf, *node;
1096 unsigned long flags;
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);
1104 for (i = 0; i < MAX_DMA_BUFS; i++) {
1105 buf = cam->vb_bufs[i];
1108 vb2_buffer_done(&buf->vb_buf.vb2_buf, state);
1109 cam->vb_bufs[i] = NULL;
1112 spin_unlock_irqrestore(&cam->dev_lock, flags);
1116 * These need to be called with the mutex held from vb2
1118 static int mcam_vb_start_streaming(struct vb2_queue *vq, unsigned int count)
1120 struct mcam_camera *cam = vb2_get_drv_priv(vq);
1124 if (cam->state != S_IDLE) {
1125 mcam_vb_requeue_bufs(vq, VB2_BUF_STATE_QUEUED);
1128 cam->frame_state.frames = 0;
1129 cam->frame_state.singles = 0;
1130 cam->frame_state.delivered = 0;
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.
1139 if (cam->buffer_mode != B_vmalloc && list_empty(&cam->buffers)) {
1140 cam->state = S_BUFWAIT;
1145 * Ensure clear the left over frame flags
1146 * before every really start streaming
1148 for (frame = 0; frame < cam->nbufs; frame++)
1149 clear_bit(CF_FRAME_SOF0 + frame, &cam->flags);
1151 ret = mcam_read_setup(cam);
1153 mcam_vb_requeue_bufs(vq, VB2_BUF_STATE_QUEUED);
1157 static void mcam_vb_stop_streaming(struct vb2_queue *vq)
1159 struct mcam_camera *cam = vb2_get_drv_priv(vq);
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;
1169 if (cam->state != S_STREAMING)
1171 mcam_ctlr_stop_dma(cam);
1173 * Reset the CCIC PHY after stopping streaming,
1174 * otherwise, the CCIC may be unstable.
1176 if (cam->ctlr_reset)
1177 cam->ctlr_reset(cam);
1179 * VB2 reclaims the buffers, so we need to forget
1182 mcam_vb_requeue_bufs(vq, VB2_BUF_STATE_ERROR);
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,
1196 #ifdef MCAM_MODE_DMA_SG
1198 * Scatter/gather mode uses all of the above functions plus a
1199 * few extras to deal with DMA mapping.
1201 static int mcam_vb_sg_buf_init(struct vb2_buffer *vb)
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;
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");
1218 static int mcam_vb_sg_buf_prepare(struct vb2_buffer *vb)
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;
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);
1235 static void mcam_vb_sg_buf_cleanup(struct vb2_buffer *vb)
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;
1242 dma_free_coherent(cam->dev, ndesc * sizeof(struct mcam_dma_desc),
1243 mvb->dma_desc, mvb->dma_desc_pa);
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,
1259 #endif /* MCAM_MODE_DMA_SG */
1261 static int mcam_setup_vb2(struct mcam_camera *cam)
1263 struct vb2_queue *vq = &cam->vb_queue;
1265 memset(vq, 0, sizeof(*vq));
1266 vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
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) {
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);
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);
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;
1307 return vb2_queue_init(vq);
1310 static void mcam_cleanup_vb2(struct mcam_camera *cam)
1312 #ifdef MCAM_MODE_DMA_CONTIG
1313 if (cam->buffer_mode == B_DMA_contig)
1314 vb2_dma_contig_cleanup_ctx(cam->vb_alloc_ctx);
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);
1323 /* ---------------------------------------------------------------------- */
1325 * The long list of V4L2 ioctl() operations.
1328 static int mcam_vidioc_querycap(struct file *file, void *priv,
1329 struct v4l2_capability *cap)
1331 struct mcam_camera *cam = video_drvdata(file);
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;
1343 static int mcam_vidioc_enum_fmt_vid_cap(struct file *filp,
1344 void *priv, struct v4l2_fmtdesc *fmt)
1346 if (fmt->index >= N_MCAM_FMTS)
1348 strlcpy(fmt->description, mcam_formats[fmt->index].desc,
1349 sizeof(fmt->description));
1350 fmt->pixelformat = mcam_formats[fmt->index].pixelformat;
1354 static int mcam_vidioc_try_fmt_vid_cap(struct file *filp, void *priv,
1355 struct v4l2_format *fmt)
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,
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;
1378 pix->sizeimage = pix->height * pix->bytesperline;
1381 pix->colorspace = V4L2_COLORSPACE_SRGB;
1385 static int mcam_vidioc_s_fmt_vid_cap(struct file *filp, void *priv,
1386 struct v4l2_format *fmt)
1388 struct mcam_camera *cam = video_drvdata(filp);
1389 struct mcam_format_struct *f;
1393 * Can't do anything if the device is not idle
1394 * Also can't if there are streaming buffers in place.
1396 if (cam->state != S_IDLE || vb2_is_busy(&cam->vb_queue))
1399 f = mcam_find_format(fmt->fmt.pix.pixelformat);
1402 * See if the formatting works in principle.
1404 ret = mcam_vidioc_try_fmt_vid_cap(filp, priv, fmt);
1408 * Now we start to change things for real, so let's do it
1411 cam->pix_format = fmt->fmt.pix;
1412 cam->mbus_code = f->mbus_code;
1415 * Make sure we have appropriate DMA buffers.
1417 if (cam->buffer_mode == B_vmalloc) {
1418 ret = mcam_check_dma_buffers(cam);
1422 mcam_set_config_needed(cam, 1);
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.
1432 static int mcam_vidioc_g_fmt_vid_cap(struct file *filp, void *priv,
1433 struct v4l2_format *f)
1435 struct mcam_camera *cam = video_drvdata(filp);
1437 f->fmt.pix = cam->pix_format;
1442 * We only have one input - the sensor - so minimize the nonsense here.
1444 static int mcam_vidioc_enum_input(struct file *filp, void *priv,
1445 struct v4l2_input *input)
1447 if (input->index != 0)
1450 input->type = V4L2_INPUT_TYPE_CAMERA;
1451 strcpy(input->name, "Camera");
1455 static int mcam_vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
1461 static int mcam_vidioc_s_input(struct file *filp, void *priv, unsigned int i)
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.
1472 static int mcam_vidioc_g_parm(struct file *filp, void *priv,
1473 struct v4l2_streamparm *parms)
1475 struct mcam_camera *cam = video_drvdata(filp);
1478 ret = sensor_call(cam, video, g_parm, parms);
1479 parms->parm.capture.readbuffers = n_dma_bufs;
1483 static int mcam_vidioc_s_parm(struct file *filp, void *priv,
1484 struct v4l2_streamparm *parms)
1486 struct mcam_camera *cam = video_drvdata(filp);
1489 ret = sensor_call(cam, video, s_parm, parms);
1490 parms->parm.capture.readbuffers = n_dma_bufs;
1494 static int mcam_vidioc_enum_framesizes(struct file *filp, void *priv,
1495 struct v4l2_frmsizeenum *sizes)
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,
1505 f = mcam_find_format(sizes->pixel_format);
1506 if (f->pixelformat != sizes->pixel_format)
1508 fse.code = f->mbus_code;
1509 ret = sensor_call(cam, pad, enum_frame_size, NULL, &fse);
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;
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;
1529 static int mcam_vidioc_enum_frameintervals(struct file *filp, void *priv,
1530 struct v4l2_frmivalenum *interval)
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,
1542 f = mcam_find_format(interval->pixel_format);
1543 if (f->pixelformat != interval->pixel_format)
1545 fie.code = f->mbus_code;
1546 ret = sensor_call(cam, pad, enum_frame_interval, NULL, &fie);
1549 interval->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1550 interval->discrete = fie.interval;
1554 #ifdef CONFIG_VIDEO_ADV_DEBUG
1555 static int mcam_vidioc_g_register(struct file *file, void *priv,
1556 struct v4l2_dbg_register *reg)
1558 struct mcam_camera *cam = video_drvdata(file);
1560 if (reg->reg > cam->regs_size - 4)
1562 reg->val = mcam_reg_read(cam, reg->reg);
1567 static int mcam_vidioc_s_register(struct file *file, void *priv,
1568 const struct v4l2_dbg_register *reg)
1570 struct mcam_camera *cam = video_drvdata(file);
1572 if (reg->reg > cam->regs_size - 4)
1574 mcam_reg_write(cam, reg->reg, reg->val);
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,
1608 /* ---------------------------------------------------------------------- */
1610 * Our various file operations.
1612 static int mcam_v4l_open(struct file *filp)
1614 struct mcam_camera *cam = video_drvdata(filp);
1617 mutex_lock(&cam->s_mutex);
1618 ret = v4l2_fh_open(filp);
1621 if (v4l2_fh_is_singular_file(filp)) {
1622 ret = mcam_ctlr_power_up(cam);
1625 __mcam_cam_reset(cam);
1626 mcam_set_config_needed(cam, 1);
1629 mutex_unlock(&cam->s_mutex);
1631 v4l2_fh_release(filp);
1636 static int mcam_v4l_release(struct file *filp)
1638 struct mcam_camera *cam = video_drvdata(filp);
1641 mutex_lock(&cam->s_mutex);
1642 last_open = v4l2_fh_is_singular_file(filp);
1643 _vb2_fop_release(filp, NULL);
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);
1651 mutex_unlock(&cam->s_mutex);
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,
1667 * This template device holds all of those v4l2 methods; we
1668 * clone it for specific real devices.
1670 static struct video_device mcam_v4l_template = {
1672 .fops = &mcam_v4l_fops,
1673 .ioctl_ops = &mcam_v4l_ioctl_ops,
1674 .release = video_device_release_empty,
1677 /* ---------------------------------------------------------------------- */
1679 * Interrupt handler stuff
1681 static void mcam_frame_complete(struct mcam_camera *cam, int frame)
1684 * Basic frame housekeeping.
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++;
1692 * "This should never happen"
1694 if (cam->state != S_STREAMING)
1697 * Process the frame and set up the next one.
1699 cam->frame_complete(cam, frame);
1704 * The interrupt handler; this needs to be called from the
1705 * platform irq handler with the lock held.
1707 int mccic_irq(struct mcam_camera *cam, unsigned int irqs)
1709 unsigned int frame, handled = 0;
1711 mcam_reg_write(cam, REG_IRQSTAT, FRAMEIRQS); /* Clear'em all */
1713 * Handle any frame completions. There really should
1714 * not be more than one of these, or we have fallen
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
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);
1727 clear_bit(CF_FRAME_SOF0 + frame, &cam->flags);
1728 if (cam->buffer_mode == B_DMA_sg)
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.
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;
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);
1751 /* ---------------------------------------------------------------------- */
1753 * Registration and such.
1755 static struct ov7670_config sensor_cfg = {
1757 * Exclude QCIF mode, because it only captures a tiny portion
1765 int mccic_register(struct mcam_camera *cam)
1767 struct i2c_board_info ov7670_info = {
1770 .platform_data = &sensor_cfg,
1775 * Validate the requested buffer mode.
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;
1785 if (!mcam_buffer_mode_supported(cam->buffer_mode)) {
1786 printk(KERN_ERR "marvell-cam: buffer mode %d unsupported\n",
1793 ret = v4l2_device_register(cam->dev, &cam->v4l2_dev);
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);
1805 * Get the v4l2 setup done.
1807 ret = v4l2_ctrl_handler_init(&cam->ctrl_handler, 10);
1809 goto out_unregister;
1810 cam->v4l2_dev.ctrl_handler = &cam->ctrl_handler;
1813 * Try to find the sensor.
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) {
1822 goto out_unregister;
1825 ret = mcam_cam_init(cam);
1827 goto out_unregister;
1829 ret = mcam_setup_vb2(cam);
1831 goto out_unregister;
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);
1841 mutex_unlock(&cam->s_mutex);
1842 goto out_unregister;
1846 * If so requested, try to get our DMA buffers now.
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.");
1854 mutex_unlock(&cam->s_mutex);
1858 v4l2_ctrl_handler_free(&cam->ctrl_handler);
1859 v4l2_device_unregister(&cam->v4l2_dev);
1864 void mccic_shutdown(struct mcam_camera *cam)
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
1872 if (!list_empty(&cam->vdev.fh_list)) {
1873 cam_warn(cam, "Removing a device with users!\n");
1874 mcam_ctlr_power_down(cam);
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);
1889 void mccic_suspend(struct mcam_camera *cam)
1891 mutex_lock(&cam->s_mutex);
1892 if (!list_empty(&cam->vdev.fh_list)) {
1893 enum mcam_state cstate = cam->state;
1895 mcam_ctlr_stop_dma(cam);
1896 mcam_ctlr_power_down(cam);
1897 cam->state = cstate;
1899 mutex_unlock(&cam->s_mutex);
1902 int mccic_resume(struct mcam_camera *cam)
1906 mutex_lock(&cam->s_mutex);
1907 if (!list_empty(&cam->vdev.fh_list)) {
1908 ret = mcam_ctlr_power_up(cam);
1910 mutex_unlock(&cam->s_mutex);
1913 __mcam_cam_reset(cam);
1915 mcam_ctlr_power_down(cam);
1917 mutex_unlock(&cam->s_mutex);
1919 set_bit(CF_CONFIG_NEEDED, &cam->flags);
1920 if (cam->state == S_STREAMING) {
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.
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);
1931 #endif /* CONFIG_PM */