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/videodev2.h>
23 #include <media/v4l2-device.h>
24 #include <media/v4l2-ioctl.h>
25 #include <media/v4l2-chip-ident.h>
26 #include <media/ov7670.h>
27 #include <media/videobuf2-vmalloc.h>
28 #include <media/videobuf2-dma-contig.h>
29 #include <media/videobuf2-dma-sg.h>
31 #include "mcam-core.h"
34 * Basic frame stats - to be deleted shortly
40 #ifdef MCAM_MODE_VMALLOC
42 * Internal DMA buffer management. Since the controller cannot do S/G I/O,
43 * we must have physically contiguous buffers to bring frames into.
44 * These parameters control how many buffers we use, whether we
45 * allocate them at load time (better chance of success, but nails down
46 * memory) or when somebody tries to use the camera (riskier), and,
47 * for load-time allocation, how big they should be.
49 * The controller can cycle through three buffers. We could use
50 * more by flipping pointers around, but it probably makes little
54 static bool alloc_bufs_at_read;
55 module_param(alloc_bufs_at_read, bool, 0444);
56 MODULE_PARM_DESC(alloc_bufs_at_read,
57 "Non-zero value causes DMA buffers to be allocated when the "
58 "video capture device is read, rather than at module load "
59 "time. This saves memory, but decreases the chances of "
60 "successfully getting those buffers. This parameter is "
61 "only used in the vmalloc buffer mode");
63 static int n_dma_bufs = 3;
64 module_param(n_dma_bufs, uint, 0644);
65 MODULE_PARM_DESC(n_dma_bufs,
66 "The number of DMA buffers to allocate. Can be either two "
67 "(saves memory, makes timing tighter) or three.");
69 static int dma_buf_size = VGA_WIDTH * VGA_HEIGHT * 2; /* Worst case */
70 module_param(dma_buf_size, uint, 0444);
71 MODULE_PARM_DESC(dma_buf_size,
72 "The size of the allocated DMA buffers. If actual operating "
73 "parameters require larger buffers, an attempt to reallocate "
75 #else /* MCAM_MODE_VMALLOC */
76 static const bool alloc_bufs_at_read = 0;
77 static const int n_dma_bufs = 3; /* Used by S/G_PARM */
78 #endif /* MCAM_MODE_VMALLOC */
81 module_param(flip, bool, 0444);
82 MODULE_PARM_DESC(flip,
83 "If set, the sensor will be instructed to flip the image "
86 static int buffer_mode = -1;
87 module_param(buffer_mode, int, 0444);
88 MODULE_PARM_DESC(buffer_mode,
89 "Set the buffer mode to be used; default is to go with what "
90 "the platform driver asks for. Set to 0 for vmalloc, 1 for "
94 * Status flags. Always manipulated with bit operations.
96 #define CF_BUF0_VALID 0 /* Buffers valid - first three */
97 #define CF_BUF1_VALID 1
98 #define CF_BUF2_VALID 2
99 #define CF_DMA_ACTIVE 3 /* A frame is incoming */
100 #define CF_CONFIG_NEEDED 4 /* Must configure hardware */
101 #define CF_SINGLE_BUFFER 5 /* Running with a single buffer */
102 #define CF_SG_RESTART 6 /* SG restart needed */
104 #define sensor_call(cam, o, f, args...) \
105 v4l2_subdev_call(cam->sensor, o, f, ##args)
107 static struct mcam_format_struct {
110 int bpp; /* Bytes per pixel */
111 enum v4l2_mbus_pixelcode mbus_code;
114 .desc = "YUYV 4:2:2",
115 .pixelformat = V4L2_PIX_FMT_YUYV,
116 .mbus_code = V4L2_MBUS_FMT_YUYV8_2X8,
121 .pixelformat = V4L2_PIX_FMT_RGB444,
122 .mbus_code = V4L2_MBUS_FMT_RGB444_2X8_PADHI_LE,
127 .pixelformat = V4L2_PIX_FMT_RGB565,
128 .mbus_code = V4L2_MBUS_FMT_RGB565_2X8_LE,
132 .desc = "Raw RGB Bayer",
133 .pixelformat = V4L2_PIX_FMT_SBGGR8,
134 .mbus_code = V4L2_MBUS_FMT_SBGGR8_1X8,
138 #define N_MCAM_FMTS ARRAY_SIZE(mcam_formats)
140 static struct mcam_format_struct *mcam_find_format(u32 pixelformat)
144 for (i = 0; i < N_MCAM_FMTS; i++)
145 if (mcam_formats[i].pixelformat == pixelformat)
146 return mcam_formats + i;
147 /* Not found? Then return the first format. */
152 * The default format we use until somebody says otherwise.
154 static const struct v4l2_pix_format mcam_def_pix_format = {
156 .height = VGA_HEIGHT,
157 .pixelformat = V4L2_PIX_FMT_YUYV,
158 .field = V4L2_FIELD_NONE,
159 .bytesperline = VGA_WIDTH*2,
160 .sizeimage = VGA_WIDTH*VGA_HEIGHT*2,
163 static const enum v4l2_mbus_pixelcode mcam_def_mbus_code =
164 V4L2_MBUS_FMT_YUYV8_2X8;
168 * The two-word DMA descriptor format used by the Armada 610 and like. There
169 * Is a three-word format as well (set C1_DESC_3WORD) where the third
170 * word is a pointer to the next descriptor, but we don't use it. Two-word
171 * descriptors have to be contiguous in memory.
173 struct mcam_dma_desc {
179 * Our buffer type for working with videobuf2. Note that the vb2
180 * developers have decreed that struct vb2_buffer must be at the
181 * beginning of this structure.
183 struct mcam_vb_buffer {
184 struct vb2_buffer vb_buf;
185 struct list_head queue;
186 struct mcam_dma_desc *dma_desc; /* Descriptor virtual address */
187 dma_addr_t dma_desc_pa; /* Descriptor physical address */
188 int dma_desc_nent; /* Number of mapped descriptors */
191 static inline struct mcam_vb_buffer *vb_to_mvb(struct vb2_buffer *vb)
193 return container_of(vb, struct mcam_vb_buffer, vb_buf);
197 * Hand a completed buffer back to user space.
199 static void mcam_buffer_done(struct mcam_camera *cam, int frame,
200 struct vb2_buffer *vbuf)
202 vbuf->v4l2_buf.bytesused = cam->pix_format.sizeimage;
203 vbuf->v4l2_buf.sequence = cam->buf_seq[frame];
204 vb2_set_plane_payload(vbuf, 0, cam->pix_format.sizeimage);
205 vb2_buffer_done(vbuf, VB2_BUF_STATE_DONE);
211 * Debugging and related.
213 #define cam_err(cam, fmt, arg...) \
214 dev_err((cam)->dev, fmt, ##arg);
215 #define cam_warn(cam, fmt, arg...) \
216 dev_warn((cam)->dev, fmt, ##arg);
217 #define cam_dbg(cam, fmt, arg...) \
218 dev_dbg((cam)->dev, fmt, ##arg);
222 * Flag manipulation helpers
224 static void mcam_reset_buffers(struct mcam_camera *cam)
229 for (i = 0; i < cam->nbufs; i++)
230 clear_bit(i, &cam->flags);
233 static inline int mcam_needs_config(struct mcam_camera *cam)
235 return test_bit(CF_CONFIG_NEEDED, &cam->flags);
238 static void mcam_set_config_needed(struct mcam_camera *cam, int needed)
241 set_bit(CF_CONFIG_NEEDED, &cam->flags);
243 clear_bit(CF_CONFIG_NEEDED, &cam->flags);
246 /* ------------------------------------------------------------------- */
248 * Make the controller start grabbing images. Everything must
249 * be set up before doing this.
251 static void mcam_ctlr_start(struct mcam_camera *cam)
253 /* set_bit performs a read, so no other barrier should be
255 mcam_reg_set_bit(cam, REG_CTRL0, C0_ENABLE);
258 static void mcam_ctlr_stop(struct mcam_camera *cam)
260 mcam_reg_clear_bit(cam, REG_CTRL0, C0_ENABLE);
263 /* ------------------------------------------------------------------- */
265 #ifdef MCAM_MODE_VMALLOC
267 * Code specific to the vmalloc buffer mode.
271 * Allocate in-kernel DMA buffers for vmalloc mode.
273 static int mcam_alloc_dma_bufs(struct mcam_camera *cam, int loadtime)
277 mcam_set_config_needed(cam, 1);
279 cam->dma_buf_size = dma_buf_size;
281 cam->dma_buf_size = cam->pix_format.sizeimage;
286 for (i = 0; i < n_dma_bufs; i++) {
287 cam->dma_bufs[i] = dma_alloc_coherent(cam->dev,
288 cam->dma_buf_size, cam->dma_handles + i,
290 if (cam->dma_bufs[i] == NULL) {
291 cam_warn(cam, "Failed to allocate DMA buffer\n");
297 switch (cam->nbufs) {
299 dma_free_coherent(cam->dev, cam->dma_buf_size,
300 cam->dma_bufs[0], cam->dma_handles[0]);
303 cam_err(cam, "Insufficient DMA buffers, cannot operate\n");
308 cam_warn(cam, "Will limp along with only 2 buffers\n");
314 static void mcam_free_dma_bufs(struct mcam_camera *cam)
318 for (i = 0; i < cam->nbufs; i++) {
319 dma_free_coherent(cam->dev, cam->dma_buf_size,
320 cam->dma_bufs[i], cam->dma_handles[i]);
321 cam->dma_bufs[i] = NULL;
328 * Set up DMA buffers when operating in vmalloc mode
330 static void mcam_ctlr_dma_vmalloc(struct mcam_camera *cam)
333 * Store the first two Y buffers (we aren't supporting
334 * planar formats for now, so no UV bufs). Then either
335 * set the third if it exists, or tell the controller
338 mcam_reg_write(cam, REG_Y0BAR, cam->dma_handles[0]);
339 mcam_reg_write(cam, REG_Y1BAR, cam->dma_handles[1]);
340 if (cam->nbufs > 2) {
341 mcam_reg_write(cam, REG_Y2BAR, cam->dma_handles[2]);
342 mcam_reg_clear_bit(cam, REG_CTRL1, C1_TWOBUFS);
344 mcam_reg_set_bit(cam, REG_CTRL1, C1_TWOBUFS);
345 if (cam->chip_id == V4L2_IDENT_CAFE)
346 mcam_reg_write(cam, REG_UBAR, 0); /* 32 bits only */
350 * Copy data out to user space in the vmalloc case
352 static void mcam_frame_tasklet(unsigned long data)
354 struct mcam_camera *cam = (struct mcam_camera *) data;
357 struct mcam_vb_buffer *buf;
359 spin_lock_irqsave(&cam->dev_lock, flags);
360 for (i = 0; i < cam->nbufs; i++) {
361 int bufno = cam->next_buf;
363 if (cam->state != S_STREAMING || bufno < 0)
364 break; /* I/O got stopped */
365 if (++(cam->next_buf) >= cam->nbufs)
367 if (!test_bit(bufno, &cam->flags))
369 if (list_empty(&cam->buffers)) {
371 break; /* Leave it valid, hope for better later */
374 clear_bit(bufno, &cam->flags);
375 buf = list_first_entry(&cam->buffers, struct mcam_vb_buffer,
377 list_del_init(&buf->queue);
379 * Drop the lock during the big copy. This *should* be safe...
381 spin_unlock_irqrestore(&cam->dev_lock, flags);
382 memcpy(vb2_plane_vaddr(&buf->vb_buf, 0), cam->dma_bufs[bufno],
383 cam->pix_format.sizeimage);
384 mcam_buffer_done(cam, bufno, &buf->vb_buf);
385 spin_lock_irqsave(&cam->dev_lock, flags);
387 spin_unlock_irqrestore(&cam->dev_lock, flags);
392 * Make sure our allocated buffers are up to the task.
394 static int mcam_check_dma_buffers(struct mcam_camera *cam)
396 if (cam->nbufs > 0 && cam->dma_buf_size < cam->pix_format.sizeimage)
397 mcam_free_dma_bufs(cam);
399 return mcam_alloc_dma_bufs(cam, 0);
403 static void mcam_vmalloc_done(struct mcam_camera *cam, int frame)
405 tasklet_schedule(&cam->s_tasklet);
408 #else /* MCAM_MODE_VMALLOC */
410 static inline int mcam_alloc_dma_bufs(struct mcam_camera *cam, int loadtime)
415 static inline void mcam_free_dma_bufs(struct mcam_camera *cam)
420 static inline int mcam_check_dma_buffers(struct mcam_camera *cam)
427 #endif /* MCAM_MODE_VMALLOC */
430 #ifdef MCAM_MODE_DMA_CONTIG
431 /* ---------------------------------------------------------------------- */
433 * DMA-contiguous code.
436 * Set up a contiguous buffer for the given frame. Here also is where
437 * the underrun strategy is set: if there is no buffer available, reuse
438 * the buffer from the other BAR and set the CF_SINGLE_BUFFER flag to
439 * keep the interrupt handler from giving that buffer back to user
440 * space. In this way, we always have a buffer to DMA to and don't
441 * have to try to play games stopping and restarting the controller.
443 static void mcam_set_contig_buffer(struct mcam_camera *cam, int frame)
445 struct mcam_vb_buffer *buf;
447 * If there are no available buffers, go into single mode
449 if (list_empty(&cam->buffers)) {
450 buf = cam->vb_bufs[frame ^ 0x1];
451 cam->vb_bufs[frame] = buf;
452 mcam_reg_write(cam, frame == 0 ? REG_Y0BAR : REG_Y1BAR,
453 vb2_dma_contig_plane_dma_addr(&buf->vb_buf, 0));
454 set_bit(CF_SINGLE_BUFFER, &cam->flags);
459 * OK, we have a buffer we can use.
461 buf = list_first_entry(&cam->buffers, struct mcam_vb_buffer, queue);
462 list_del_init(&buf->queue);
463 mcam_reg_write(cam, frame == 0 ? REG_Y0BAR : REG_Y1BAR,
464 vb2_dma_contig_plane_dma_addr(&buf->vb_buf, 0));
465 cam->vb_bufs[frame] = buf;
466 clear_bit(CF_SINGLE_BUFFER, &cam->flags);
470 * Initial B_DMA_contig setup.
472 static void mcam_ctlr_dma_contig(struct mcam_camera *cam)
474 mcam_reg_set_bit(cam, REG_CTRL1, C1_TWOBUFS);
476 mcam_set_contig_buffer(cam, 0);
477 mcam_set_contig_buffer(cam, 1);
481 * Frame completion handling.
483 static void mcam_dma_contig_done(struct mcam_camera *cam, int frame)
485 struct mcam_vb_buffer *buf = cam->vb_bufs[frame];
487 if (!test_bit(CF_SINGLE_BUFFER, &cam->flags)) {
489 mcam_buffer_done(cam, frame, &buf->vb_buf);
491 mcam_set_contig_buffer(cam, frame);
494 #endif /* MCAM_MODE_DMA_CONTIG */
496 #ifdef MCAM_MODE_DMA_SG
497 /* ---------------------------------------------------------------------- */
499 * Scatter/gather-specific code.
503 * Set up the next buffer for S/G I/O; caller should be sure that
504 * the controller is stopped and a buffer is available.
506 static void mcam_sg_next_buffer(struct mcam_camera *cam)
508 struct mcam_vb_buffer *buf;
510 buf = list_first_entry(&cam->buffers, struct mcam_vb_buffer, queue);
511 list_del_init(&buf->queue);
513 * Very Bad Not Good Things happen if you don't clear
514 * C1_DESC_ENA before making any descriptor changes.
516 mcam_reg_clear_bit(cam, REG_CTRL1, C1_DESC_ENA);
517 mcam_reg_write(cam, REG_DMA_DESC_Y, buf->dma_desc_pa);
518 mcam_reg_write(cam, REG_DESC_LEN_Y,
519 buf->dma_desc_nent*sizeof(struct mcam_dma_desc));
520 mcam_reg_write(cam, REG_DESC_LEN_U, 0);
521 mcam_reg_write(cam, REG_DESC_LEN_V, 0);
522 mcam_reg_set_bit(cam, REG_CTRL1, C1_DESC_ENA);
523 cam->vb_bufs[0] = buf;
527 * Initial B_DMA_sg setup
529 static void mcam_ctlr_dma_sg(struct mcam_camera *cam)
532 * The list-empty condition can hit us at resume time
533 * if the buffer list was empty when the system was suspended.
535 if (list_empty(&cam->buffers)) {
536 set_bit(CF_SG_RESTART, &cam->flags);
540 mcam_reg_clear_bit(cam, REG_CTRL1, C1_DESC_3WORD);
541 mcam_sg_next_buffer(cam);
547 * Frame completion with S/G is trickier. We can't muck with
548 * a descriptor chain on the fly, since the controller buffers it
549 * internally. So we have to actually stop and restart; Marvell
550 * says this is the way to do it.
552 * Of course, stopping is easier said than done; experience shows
553 * that the controller can start a frame *after* C0_ENABLE has been
554 * cleared. So when running in S/G mode, the controller is "stopped"
555 * on receipt of the start-of-frame interrupt. That means we can
556 * safely change the DMA descriptor array here and restart things
557 * (assuming there's another buffer waiting to go).
559 static void mcam_dma_sg_done(struct mcam_camera *cam, int frame)
561 struct mcam_vb_buffer *buf = cam->vb_bufs[0];
564 * If we're no longer supposed to be streaming, don't do anything.
566 if (cam->state != S_STREAMING)
569 * If we have another buffer available, put it in and
570 * restart the engine.
572 if (!list_empty(&cam->buffers)) {
573 mcam_sg_next_buffer(cam);
574 mcam_ctlr_start(cam);
576 * Otherwise set CF_SG_RESTART and the controller will
577 * be restarted once another buffer shows up.
580 set_bit(CF_SG_RESTART, &cam->flags);
582 cam->vb_bufs[0] = NULL;
585 * Now we can give the completed frame back to user space.
588 mcam_buffer_done(cam, frame, &buf->vb_buf);
593 * Scatter/gather mode requires stopping the controller between
594 * frames so we can put in a new DMA descriptor array. If no new
595 * buffer exists at frame completion, the controller is left stopped;
596 * this function is charged with gettig things going again.
598 static void mcam_sg_restart(struct mcam_camera *cam)
600 mcam_ctlr_dma_sg(cam);
601 mcam_ctlr_start(cam);
602 clear_bit(CF_SG_RESTART, &cam->flags);
605 #else /* MCAM_MODE_DMA_SG */
607 static inline void mcam_sg_restart(struct mcam_camera *cam)
612 #endif /* MCAM_MODE_DMA_SG */
614 /* ---------------------------------------------------------------------- */
616 * Buffer-mode-independent controller code.
622 static void mcam_ctlr_image(struct mcam_camera *cam)
625 struct v4l2_pix_format *fmt = &cam->pix_format;
627 imgsz = ((fmt->height << IMGSZ_V_SHIFT) & IMGSZ_V_MASK) |
628 (fmt->bytesperline & IMGSZ_H_MASK);
629 mcam_reg_write(cam, REG_IMGSIZE, imgsz);
630 mcam_reg_write(cam, REG_IMGOFFSET, 0);
631 /* YPITCH just drops the last two bits */
632 mcam_reg_write_mask(cam, REG_IMGPITCH, fmt->bytesperline,
635 * Tell the controller about the image format we are using.
637 switch (cam->pix_format.pixelformat) {
638 case V4L2_PIX_FMT_YUYV:
639 mcam_reg_write_mask(cam, REG_CTRL0,
640 C0_DF_YUV|C0_YUV_PACKED|C0_YUVE_YUYV,
644 case V4L2_PIX_FMT_RGB444:
645 mcam_reg_write_mask(cam, REG_CTRL0,
646 C0_DF_RGB|C0_RGBF_444|C0_RGB4_XRGB,
651 case V4L2_PIX_FMT_RGB565:
652 mcam_reg_write_mask(cam, REG_CTRL0,
653 C0_DF_RGB|C0_RGBF_565|C0_RGB5_BGGR,
658 cam_err(cam, "Unknown format %x\n", cam->pix_format.pixelformat);
662 * Make sure it knows we want to use hsync/vsync.
664 mcam_reg_write_mask(cam, REG_CTRL0, C0_SIF_HVSYNC,
670 * Configure the controller for operation; caller holds the
673 static int mcam_ctlr_configure(struct mcam_camera *cam)
677 spin_lock_irqsave(&cam->dev_lock, flags);
678 clear_bit(CF_SG_RESTART, &cam->flags);
680 mcam_ctlr_image(cam);
681 mcam_set_config_needed(cam, 0);
682 spin_unlock_irqrestore(&cam->dev_lock, flags);
686 static void mcam_ctlr_irq_enable(struct mcam_camera *cam)
689 * Clear any pending interrupts, since we do not
690 * expect to have I/O active prior to enabling.
692 mcam_reg_write(cam, REG_IRQSTAT, FRAMEIRQS);
693 mcam_reg_set_bit(cam, REG_IRQMASK, FRAMEIRQS);
696 static void mcam_ctlr_irq_disable(struct mcam_camera *cam)
698 mcam_reg_clear_bit(cam, REG_IRQMASK, FRAMEIRQS);
703 static void mcam_ctlr_init(struct mcam_camera *cam)
707 spin_lock_irqsave(&cam->dev_lock, flags);
709 * Make sure it's not powered down.
711 mcam_reg_clear_bit(cam, REG_CTRL1, C1_PWRDWN);
713 * Turn off the enable bit. It sure should be off anyway,
714 * but it's good to be sure.
716 mcam_reg_clear_bit(cam, REG_CTRL0, C0_ENABLE);
718 * Clock the sensor appropriately. Controller clock should
719 * be 48MHz, sensor "typical" value is half that.
721 mcam_reg_write_mask(cam, REG_CLKCTRL, 2, CLK_DIV_MASK);
722 spin_unlock_irqrestore(&cam->dev_lock, flags);
727 * Stop the controller, and don't return until we're really sure that no
728 * further DMA is going on.
730 static void mcam_ctlr_stop_dma(struct mcam_camera *cam)
735 * Theory: stop the camera controller (whether it is operating
736 * or not). Delay briefly just in case we race with the SOF
737 * interrupt, then wait until no DMA is active.
739 spin_lock_irqsave(&cam->dev_lock, flags);
740 clear_bit(CF_SG_RESTART, &cam->flags);
743 spin_unlock_irqrestore(&cam->dev_lock, flags);
745 * This is a brutally long sleep, but experience shows that
746 * it can take the controller a while to get the message that
747 * it needs to stop grabbing frames. In particular, we can
748 * sometimes (on mmp) get a frame at the end WITHOUT the
749 * start-of-frame indication.
752 if (test_bit(CF_DMA_ACTIVE, &cam->flags))
753 cam_err(cam, "Timeout waiting for DMA to end\n");
754 /* This would be bad news - what now? */
755 spin_lock_irqsave(&cam->dev_lock, flags);
756 mcam_ctlr_irq_disable(cam);
757 spin_unlock_irqrestore(&cam->dev_lock, flags);
763 static void mcam_ctlr_power_up(struct mcam_camera *cam)
767 spin_lock_irqsave(&cam->dev_lock, flags);
768 cam->plat_power_up(cam);
769 mcam_reg_clear_bit(cam, REG_CTRL1, C1_PWRDWN);
770 spin_unlock_irqrestore(&cam->dev_lock, flags);
771 msleep(5); /* Just to be sure */
774 static void mcam_ctlr_power_down(struct mcam_camera *cam)
778 spin_lock_irqsave(&cam->dev_lock, flags);
780 * School of hard knocks department: be sure we do any register
781 * twiddling on the controller *before* calling the platform
782 * power down routine.
784 mcam_reg_set_bit(cam, REG_CTRL1, C1_PWRDWN);
785 cam->plat_power_down(cam);
786 spin_unlock_irqrestore(&cam->dev_lock, flags);
789 /* -------------------------------------------------------------------- */
791 * Communications with the sensor.
794 static int __mcam_cam_reset(struct mcam_camera *cam)
796 return sensor_call(cam, core, reset, 0);
800 * We have found the sensor on the i2c. Let's try to have a
803 static int mcam_cam_init(struct mcam_camera *cam)
805 struct v4l2_dbg_chip_ident chip;
808 mutex_lock(&cam->s_mutex);
809 if (cam->state != S_NOTREADY)
810 cam_warn(cam, "Cam init with device in funky state %d",
812 ret = __mcam_cam_reset(cam);
815 chip.ident = V4L2_IDENT_NONE;
816 chip.match.type = V4L2_CHIP_MATCH_I2C_ADDR;
817 chip.match.addr = cam->sensor_addr;
818 ret = sensor_call(cam, core, g_chip_ident, &chip);
821 cam->sensor_type = chip.ident;
822 if (cam->sensor_type != V4L2_IDENT_OV7670) {
823 cam_err(cam, "Unsupported sensor type 0x%x", cam->sensor_type);
827 /* Get/set parameters? */
831 mcam_ctlr_power_down(cam);
832 mutex_unlock(&cam->s_mutex);
837 * Configure the sensor to match the parameters we have. Caller should
840 static int mcam_cam_set_flip(struct mcam_camera *cam)
842 struct v4l2_control ctrl;
844 memset(&ctrl, 0, sizeof(ctrl));
845 ctrl.id = V4L2_CID_VFLIP;
847 return sensor_call(cam, core, s_ctrl, &ctrl);
851 static int mcam_cam_configure(struct mcam_camera *cam)
853 struct v4l2_mbus_framefmt mbus_fmt;
856 v4l2_fill_mbus_format(&mbus_fmt, &cam->pix_format, cam->mbus_code);
857 ret = sensor_call(cam, core, init, 0);
859 ret = sensor_call(cam, video, s_mbus_fmt, &mbus_fmt);
861 * OV7670 does weird things if flip is set *before* format...
863 ret += mcam_cam_set_flip(cam);
868 * Get everything ready, and start grabbing frames.
870 static int mcam_read_setup(struct mcam_camera *cam)
876 * Configuration. If we still don't have DMA buffers,
877 * make one last, desperate attempt.
879 if (cam->buffer_mode == B_vmalloc && cam->nbufs == 0 &&
880 mcam_alloc_dma_bufs(cam, 0))
883 if (mcam_needs_config(cam)) {
884 mcam_cam_configure(cam);
885 ret = mcam_ctlr_configure(cam);
893 spin_lock_irqsave(&cam->dev_lock, flags);
894 clear_bit(CF_DMA_ACTIVE, &cam->flags);
895 mcam_reset_buffers(cam);
896 mcam_ctlr_irq_enable(cam);
897 cam->state = S_STREAMING;
898 if (!test_bit(CF_SG_RESTART, &cam->flags))
899 mcam_ctlr_start(cam);
900 spin_unlock_irqrestore(&cam->dev_lock, flags);
904 /* ----------------------------------------------------------------------- */
906 * Videobuf2 interface code.
909 static int mcam_vb_queue_setup(struct vb2_queue *vq,
910 const struct v4l2_format *fmt, unsigned int *nbufs,
911 unsigned int *num_planes, unsigned int sizes[],
914 struct mcam_camera *cam = vb2_get_drv_priv(vq);
915 int minbufs = (cam->buffer_mode == B_DMA_contig) ? 3 : 2;
917 sizes[0] = cam->pix_format.sizeimage;
918 *num_planes = 1; /* Someday we have to support planar formats... */
919 if (*nbufs < minbufs)
921 if (cam->buffer_mode == B_DMA_contig)
922 alloc_ctxs[0] = cam->vb_alloc_ctx;
927 static void mcam_vb_buf_queue(struct vb2_buffer *vb)
929 struct mcam_vb_buffer *mvb = vb_to_mvb(vb);
930 struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
934 spin_lock_irqsave(&cam->dev_lock, flags);
935 start = (cam->state == S_BUFWAIT) && !list_empty(&cam->buffers);
936 list_add(&mvb->queue, &cam->buffers);
937 if (cam->state == S_STREAMING && test_bit(CF_SG_RESTART, &cam->flags))
938 mcam_sg_restart(cam);
939 spin_unlock_irqrestore(&cam->dev_lock, flags);
941 mcam_read_setup(cam);
946 * vb2 uses these to release the mutex when waiting in dqbuf. I'm
947 * not actually sure we need to do this (I'm not sure that vb2_dqbuf() needs
948 * to be called with the mutex held), but better safe than sorry.
950 static void mcam_vb_wait_prepare(struct vb2_queue *vq)
952 struct mcam_camera *cam = vb2_get_drv_priv(vq);
954 mutex_unlock(&cam->s_mutex);
957 static void mcam_vb_wait_finish(struct vb2_queue *vq)
959 struct mcam_camera *cam = vb2_get_drv_priv(vq);
961 mutex_lock(&cam->s_mutex);
965 * These need to be called with the mutex held from vb2
967 static int mcam_vb_start_streaming(struct vb2_queue *vq, unsigned int count)
969 struct mcam_camera *cam = vb2_get_drv_priv(vq);
971 if (cam->state != S_IDLE) {
972 INIT_LIST_HEAD(&cam->buffers);
977 * Videobuf2 sneakily hoards all the buffers and won't
978 * give them to us until *after* streaming starts. But
979 * we can't actually start streaming until we have a
980 * destination. So go into a wait state and hope they
981 * give us buffers soon.
983 if (cam->buffer_mode != B_vmalloc && list_empty(&cam->buffers)) {
984 cam->state = S_BUFWAIT;
987 return mcam_read_setup(cam);
990 static int mcam_vb_stop_streaming(struct vb2_queue *vq)
992 struct mcam_camera *cam = vb2_get_drv_priv(vq);
995 if (cam->state == S_BUFWAIT) {
996 /* They never gave us buffers */
1000 if (cam->state != S_STREAMING)
1002 mcam_ctlr_stop_dma(cam);
1004 * VB2 reclaims the buffers, so we need to forget
1007 spin_lock_irqsave(&cam->dev_lock, flags);
1008 INIT_LIST_HEAD(&cam->buffers);
1009 spin_unlock_irqrestore(&cam->dev_lock, flags);
1014 static const struct vb2_ops mcam_vb2_ops = {
1015 .queue_setup = mcam_vb_queue_setup,
1016 .buf_queue = mcam_vb_buf_queue,
1017 .start_streaming = mcam_vb_start_streaming,
1018 .stop_streaming = mcam_vb_stop_streaming,
1019 .wait_prepare = mcam_vb_wait_prepare,
1020 .wait_finish = mcam_vb_wait_finish,
1024 #ifdef MCAM_MODE_DMA_SG
1026 * Scatter/gather mode uses all of the above functions plus a
1027 * few extras to deal with DMA mapping.
1029 static int mcam_vb_sg_buf_init(struct vb2_buffer *vb)
1031 struct mcam_vb_buffer *mvb = vb_to_mvb(vb);
1032 struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
1033 int ndesc = cam->pix_format.sizeimage/PAGE_SIZE + 1;
1035 mvb->dma_desc = dma_alloc_coherent(cam->dev,
1036 ndesc * sizeof(struct mcam_dma_desc),
1037 &mvb->dma_desc_pa, GFP_KERNEL);
1038 if (mvb->dma_desc == NULL) {
1039 cam_err(cam, "Unable to get DMA descriptor array\n");
1045 static int mcam_vb_sg_buf_prepare(struct vb2_buffer *vb)
1047 struct mcam_vb_buffer *mvb = vb_to_mvb(vb);
1048 struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
1049 struct vb2_dma_sg_desc *sgd = vb2_dma_sg_plane_desc(vb, 0);
1050 struct mcam_dma_desc *desc = mvb->dma_desc;
1051 struct scatterlist *sg;
1054 mvb->dma_desc_nent = dma_map_sg(cam->dev, sgd->sglist, sgd->num_pages,
1056 if (mvb->dma_desc_nent <= 0)
1057 return -EIO; /* Not sure what's right here */
1058 for_each_sg(sgd->sglist, sg, mvb->dma_desc_nent, i) {
1059 desc->dma_addr = sg_dma_address(sg);
1060 desc->segment_len = sg_dma_len(sg);
1066 static int mcam_vb_sg_buf_finish(struct vb2_buffer *vb)
1068 struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
1069 struct vb2_dma_sg_desc *sgd = vb2_dma_sg_plane_desc(vb, 0);
1071 dma_unmap_sg(cam->dev, sgd->sglist, sgd->num_pages, DMA_FROM_DEVICE);
1075 static void mcam_vb_sg_buf_cleanup(struct vb2_buffer *vb)
1077 struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
1078 struct mcam_vb_buffer *mvb = vb_to_mvb(vb);
1079 int ndesc = cam->pix_format.sizeimage/PAGE_SIZE + 1;
1081 dma_free_coherent(cam->dev, ndesc * sizeof(struct mcam_dma_desc),
1082 mvb->dma_desc, mvb->dma_desc_pa);
1086 static const struct vb2_ops mcam_vb2_sg_ops = {
1087 .queue_setup = mcam_vb_queue_setup,
1088 .buf_init = mcam_vb_sg_buf_init,
1089 .buf_prepare = mcam_vb_sg_buf_prepare,
1090 .buf_queue = mcam_vb_buf_queue,
1091 .buf_finish = mcam_vb_sg_buf_finish,
1092 .buf_cleanup = mcam_vb_sg_buf_cleanup,
1093 .start_streaming = mcam_vb_start_streaming,
1094 .stop_streaming = mcam_vb_stop_streaming,
1095 .wait_prepare = mcam_vb_wait_prepare,
1096 .wait_finish = mcam_vb_wait_finish,
1099 #endif /* MCAM_MODE_DMA_SG */
1101 static int mcam_setup_vb2(struct mcam_camera *cam)
1103 struct vb2_queue *vq = &cam->vb_queue;
1105 memset(vq, 0, sizeof(*vq));
1106 vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1108 INIT_LIST_HEAD(&cam->buffers);
1109 switch (cam->buffer_mode) {
1111 #ifdef MCAM_MODE_DMA_CONTIG
1112 vq->ops = &mcam_vb2_ops;
1113 vq->mem_ops = &vb2_dma_contig_memops;
1114 cam->vb_alloc_ctx = vb2_dma_contig_init_ctx(cam->dev);
1115 vq->io_modes = VB2_MMAP | VB2_USERPTR;
1116 cam->dma_setup = mcam_ctlr_dma_contig;
1117 cam->frame_complete = mcam_dma_contig_done;
1121 #ifdef MCAM_MODE_DMA_SG
1122 vq->ops = &mcam_vb2_sg_ops;
1123 vq->mem_ops = &vb2_dma_sg_memops;
1124 vq->io_modes = VB2_MMAP | VB2_USERPTR;
1125 cam->dma_setup = mcam_ctlr_dma_sg;
1126 cam->frame_complete = mcam_dma_sg_done;
1130 #ifdef MCAM_MODE_VMALLOC
1131 tasklet_init(&cam->s_tasklet, mcam_frame_tasklet,
1132 (unsigned long) cam);
1133 vq->ops = &mcam_vb2_ops;
1134 vq->mem_ops = &vb2_vmalloc_memops;
1135 vq->buf_struct_size = sizeof(struct mcam_vb_buffer);
1136 vq->io_modes = VB2_MMAP;
1137 cam->dma_setup = mcam_ctlr_dma_vmalloc;
1138 cam->frame_complete = mcam_vmalloc_done;
1142 return vb2_queue_init(vq);
1145 static void mcam_cleanup_vb2(struct mcam_camera *cam)
1147 vb2_queue_release(&cam->vb_queue);
1148 #ifdef MCAM_MODE_DMA_CONTIG
1149 if (cam->buffer_mode == B_DMA_contig)
1150 vb2_dma_contig_cleanup_ctx(cam->vb_alloc_ctx);
1155 /* ---------------------------------------------------------------------- */
1157 * The long list of V4L2 ioctl() operations.
1160 static int mcam_vidioc_streamon(struct file *filp, void *priv,
1161 enum v4l2_buf_type type)
1163 struct mcam_camera *cam = filp->private_data;
1166 mutex_lock(&cam->s_mutex);
1167 ret = vb2_streamon(&cam->vb_queue, type);
1168 mutex_unlock(&cam->s_mutex);
1173 static int mcam_vidioc_streamoff(struct file *filp, void *priv,
1174 enum v4l2_buf_type type)
1176 struct mcam_camera *cam = filp->private_data;
1179 mutex_lock(&cam->s_mutex);
1180 ret = vb2_streamoff(&cam->vb_queue, type);
1181 mutex_unlock(&cam->s_mutex);
1186 static int mcam_vidioc_reqbufs(struct file *filp, void *priv,
1187 struct v4l2_requestbuffers *req)
1189 struct mcam_camera *cam = filp->private_data;
1192 mutex_lock(&cam->s_mutex);
1193 ret = vb2_reqbufs(&cam->vb_queue, req);
1194 mutex_unlock(&cam->s_mutex);
1199 static int mcam_vidioc_querybuf(struct file *filp, void *priv,
1200 struct v4l2_buffer *buf)
1202 struct mcam_camera *cam = filp->private_data;
1205 mutex_lock(&cam->s_mutex);
1206 ret = vb2_querybuf(&cam->vb_queue, buf);
1207 mutex_unlock(&cam->s_mutex);
1211 static int mcam_vidioc_qbuf(struct file *filp, void *priv,
1212 struct v4l2_buffer *buf)
1214 struct mcam_camera *cam = filp->private_data;
1217 mutex_lock(&cam->s_mutex);
1218 ret = vb2_qbuf(&cam->vb_queue, buf);
1219 mutex_unlock(&cam->s_mutex);
1223 static int mcam_vidioc_dqbuf(struct file *filp, void *priv,
1224 struct v4l2_buffer *buf)
1226 struct mcam_camera *cam = filp->private_data;
1229 mutex_lock(&cam->s_mutex);
1230 ret = vb2_dqbuf(&cam->vb_queue, buf, filp->f_flags & O_NONBLOCK);
1231 mutex_unlock(&cam->s_mutex);
1237 static int mcam_vidioc_queryctrl(struct file *filp, void *priv,
1238 struct v4l2_queryctrl *qc)
1240 struct mcam_camera *cam = priv;
1243 mutex_lock(&cam->s_mutex);
1244 ret = sensor_call(cam, core, queryctrl, qc);
1245 mutex_unlock(&cam->s_mutex);
1250 static int mcam_vidioc_g_ctrl(struct file *filp, void *priv,
1251 struct v4l2_control *ctrl)
1253 struct mcam_camera *cam = priv;
1256 mutex_lock(&cam->s_mutex);
1257 ret = sensor_call(cam, core, g_ctrl, ctrl);
1258 mutex_unlock(&cam->s_mutex);
1263 static int mcam_vidioc_s_ctrl(struct file *filp, void *priv,
1264 struct v4l2_control *ctrl)
1266 struct mcam_camera *cam = priv;
1269 mutex_lock(&cam->s_mutex);
1270 ret = sensor_call(cam, core, s_ctrl, ctrl);
1271 mutex_unlock(&cam->s_mutex);
1276 static int mcam_vidioc_querycap(struct file *file, void *priv,
1277 struct v4l2_capability *cap)
1279 strcpy(cap->driver, "marvell_ccic");
1280 strcpy(cap->card, "marvell_ccic");
1282 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
1283 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
1288 static int mcam_vidioc_enum_fmt_vid_cap(struct file *filp,
1289 void *priv, struct v4l2_fmtdesc *fmt)
1291 if (fmt->index >= N_MCAM_FMTS)
1293 strlcpy(fmt->description, mcam_formats[fmt->index].desc,
1294 sizeof(fmt->description));
1295 fmt->pixelformat = mcam_formats[fmt->index].pixelformat;
1299 static int mcam_vidioc_try_fmt_vid_cap(struct file *filp, void *priv,
1300 struct v4l2_format *fmt)
1302 struct mcam_camera *cam = priv;
1303 struct mcam_format_struct *f;
1304 struct v4l2_pix_format *pix = &fmt->fmt.pix;
1305 struct v4l2_mbus_framefmt mbus_fmt;
1308 f = mcam_find_format(pix->pixelformat);
1309 pix->pixelformat = f->pixelformat;
1310 v4l2_fill_mbus_format(&mbus_fmt, pix, f->mbus_code);
1311 mutex_lock(&cam->s_mutex);
1312 ret = sensor_call(cam, video, try_mbus_fmt, &mbus_fmt);
1313 mutex_unlock(&cam->s_mutex);
1314 v4l2_fill_pix_format(pix, &mbus_fmt);
1315 pix->bytesperline = pix->width * f->bpp;
1316 pix->sizeimage = pix->height * pix->bytesperline;
1320 static int mcam_vidioc_s_fmt_vid_cap(struct file *filp, void *priv,
1321 struct v4l2_format *fmt)
1323 struct mcam_camera *cam = priv;
1324 struct mcam_format_struct *f;
1328 * Can't do anything if the device is not idle
1329 * Also can't if there are streaming buffers in place.
1331 if (cam->state != S_IDLE || cam->vb_queue.num_buffers > 0)
1334 f = mcam_find_format(fmt->fmt.pix.pixelformat);
1337 * See if the formatting works in principle.
1339 ret = mcam_vidioc_try_fmt_vid_cap(filp, priv, fmt);
1343 * Now we start to change things for real, so let's do it
1346 mutex_lock(&cam->s_mutex);
1347 cam->pix_format = fmt->fmt.pix;
1348 cam->mbus_code = f->mbus_code;
1351 * Make sure we have appropriate DMA buffers.
1353 if (cam->buffer_mode == B_vmalloc) {
1354 ret = mcam_check_dma_buffers(cam);
1358 mcam_set_config_needed(cam, 1);
1360 mutex_unlock(&cam->s_mutex);
1365 * Return our stored notion of how the camera is/should be configured.
1366 * The V4l2 spec wants us to be smarter, and actually get this from
1367 * the camera (and not mess with it at open time). Someday.
1369 static int mcam_vidioc_g_fmt_vid_cap(struct file *filp, void *priv,
1370 struct v4l2_format *f)
1372 struct mcam_camera *cam = priv;
1374 f->fmt.pix = cam->pix_format;
1379 * We only have one input - the sensor - so minimize the nonsense here.
1381 static int mcam_vidioc_enum_input(struct file *filp, void *priv,
1382 struct v4l2_input *input)
1384 if (input->index != 0)
1387 input->type = V4L2_INPUT_TYPE_CAMERA;
1388 input->std = V4L2_STD_ALL; /* Not sure what should go here */
1389 strcpy(input->name, "Camera");
1393 static int mcam_vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
1399 static int mcam_vidioc_s_input(struct file *filp, void *priv, unsigned int i)
1407 static int mcam_vidioc_s_std(struct file *filp, void *priv, v4l2_std_id *a)
1413 * G/S_PARM. Most of this is done by the sensor, but we are
1414 * the level which controls the number of read buffers.
1416 static int mcam_vidioc_g_parm(struct file *filp, void *priv,
1417 struct v4l2_streamparm *parms)
1419 struct mcam_camera *cam = priv;
1422 mutex_lock(&cam->s_mutex);
1423 ret = sensor_call(cam, video, g_parm, parms);
1424 mutex_unlock(&cam->s_mutex);
1425 parms->parm.capture.readbuffers = n_dma_bufs;
1429 static int mcam_vidioc_s_parm(struct file *filp, void *priv,
1430 struct v4l2_streamparm *parms)
1432 struct mcam_camera *cam = priv;
1435 mutex_lock(&cam->s_mutex);
1436 ret = sensor_call(cam, video, s_parm, parms);
1437 mutex_unlock(&cam->s_mutex);
1438 parms->parm.capture.readbuffers = n_dma_bufs;
1442 static int mcam_vidioc_g_chip_ident(struct file *file, void *priv,
1443 struct v4l2_dbg_chip_ident *chip)
1445 struct mcam_camera *cam = priv;
1447 chip->ident = V4L2_IDENT_NONE;
1449 if (v4l2_chip_match_host(&chip->match)) {
1450 chip->ident = cam->chip_id;
1453 return sensor_call(cam, core, g_chip_ident, chip);
1456 static int mcam_vidioc_enum_framesizes(struct file *filp, void *priv,
1457 struct v4l2_frmsizeenum *sizes)
1459 struct mcam_camera *cam = priv;
1462 mutex_lock(&cam->s_mutex);
1463 ret = sensor_call(cam, video, enum_framesizes, sizes);
1464 mutex_unlock(&cam->s_mutex);
1468 static int mcam_vidioc_enum_frameintervals(struct file *filp, void *priv,
1469 struct v4l2_frmivalenum *interval)
1471 struct mcam_camera *cam = priv;
1474 mutex_lock(&cam->s_mutex);
1475 ret = sensor_call(cam, video, enum_frameintervals, interval);
1476 mutex_unlock(&cam->s_mutex);
1480 #ifdef CONFIG_VIDEO_ADV_DEBUG
1481 static int mcam_vidioc_g_register(struct file *file, void *priv,
1482 struct v4l2_dbg_register *reg)
1484 struct mcam_camera *cam = priv;
1486 if (v4l2_chip_match_host(®->match)) {
1487 reg->val = mcam_reg_read(cam, reg->reg);
1491 return sensor_call(cam, core, g_register, reg);
1494 static int mcam_vidioc_s_register(struct file *file, void *priv,
1495 struct v4l2_dbg_register *reg)
1497 struct mcam_camera *cam = priv;
1499 if (v4l2_chip_match_host(®->match)) {
1500 mcam_reg_write(cam, reg->reg, reg->val);
1503 return sensor_call(cam, core, s_register, reg);
1507 static const struct v4l2_ioctl_ops mcam_v4l_ioctl_ops = {
1508 .vidioc_querycap = mcam_vidioc_querycap,
1509 .vidioc_enum_fmt_vid_cap = mcam_vidioc_enum_fmt_vid_cap,
1510 .vidioc_try_fmt_vid_cap = mcam_vidioc_try_fmt_vid_cap,
1511 .vidioc_s_fmt_vid_cap = mcam_vidioc_s_fmt_vid_cap,
1512 .vidioc_g_fmt_vid_cap = mcam_vidioc_g_fmt_vid_cap,
1513 .vidioc_enum_input = mcam_vidioc_enum_input,
1514 .vidioc_g_input = mcam_vidioc_g_input,
1515 .vidioc_s_input = mcam_vidioc_s_input,
1516 .vidioc_s_std = mcam_vidioc_s_std,
1517 .vidioc_reqbufs = mcam_vidioc_reqbufs,
1518 .vidioc_querybuf = mcam_vidioc_querybuf,
1519 .vidioc_qbuf = mcam_vidioc_qbuf,
1520 .vidioc_dqbuf = mcam_vidioc_dqbuf,
1521 .vidioc_streamon = mcam_vidioc_streamon,
1522 .vidioc_streamoff = mcam_vidioc_streamoff,
1523 .vidioc_queryctrl = mcam_vidioc_queryctrl,
1524 .vidioc_g_ctrl = mcam_vidioc_g_ctrl,
1525 .vidioc_s_ctrl = mcam_vidioc_s_ctrl,
1526 .vidioc_g_parm = mcam_vidioc_g_parm,
1527 .vidioc_s_parm = mcam_vidioc_s_parm,
1528 .vidioc_enum_framesizes = mcam_vidioc_enum_framesizes,
1529 .vidioc_enum_frameintervals = mcam_vidioc_enum_frameintervals,
1530 .vidioc_g_chip_ident = mcam_vidioc_g_chip_ident,
1531 #ifdef CONFIG_VIDEO_ADV_DEBUG
1532 .vidioc_g_register = mcam_vidioc_g_register,
1533 .vidioc_s_register = mcam_vidioc_s_register,
1537 /* ---------------------------------------------------------------------- */
1539 * Our various file operations.
1541 static int mcam_v4l_open(struct file *filp)
1543 struct mcam_camera *cam = video_drvdata(filp);
1546 filp->private_data = cam;
1548 frames = singles = delivered = 0;
1549 mutex_lock(&cam->s_mutex);
1550 if (cam->users == 0) {
1551 ret = mcam_setup_vb2(cam);
1554 mcam_ctlr_power_up(cam);
1555 __mcam_cam_reset(cam);
1556 mcam_set_config_needed(cam, 1);
1560 mutex_unlock(&cam->s_mutex);
1565 static int mcam_v4l_release(struct file *filp)
1567 struct mcam_camera *cam = filp->private_data;
1569 cam_dbg(cam, "Release, %d frames, %d singles, %d delivered\n", frames,
1570 singles, delivered);
1571 mutex_lock(&cam->s_mutex);
1573 if (cam->users == 0) {
1574 mcam_ctlr_stop_dma(cam);
1575 mcam_cleanup_vb2(cam);
1576 mcam_ctlr_power_down(cam);
1577 if (cam->buffer_mode == B_vmalloc && alloc_bufs_at_read)
1578 mcam_free_dma_bufs(cam);
1580 mutex_unlock(&cam->s_mutex);
1584 static ssize_t mcam_v4l_read(struct file *filp,
1585 char __user *buffer, size_t len, loff_t *pos)
1587 struct mcam_camera *cam = filp->private_data;
1590 mutex_lock(&cam->s_mutex);
1591 ret = vb2_read(&cam->vb_queue, buffer, len, pos,
1592 filp->f_flags & O_NONBLOCK);
1593 mutex_unlock(&cam->s_mutex);
1599 static unsigned int mcam_v4l_poll(struct file *filp,
1600 struct poll_table_struct *pt)
1602 struct mcam_camera *cam = filp->private_data;
1605 mutex_lock(&cam->s_mutex);
1606 ret = vb2_poll(&cam->vb_queue, filp, pt);
1607 mutex_unlock(&cam->s_mutex);
1612 static int mcam_v4l_mmap(struct file *filp, struct vm_area_struct *vma)
1614 struct mcam_camera *cam = filp->private_data;
1617 mutex_lock(&cam->s_mutex);
1618 ret = vb2_mmap(&cam->vb_queue, vma);
1619 mutex_unlock(&cam->s_mutex);
1625 static const struct v4l2_file_operations mcam_v4l_fops = {
1626 .owner = THIS_MODULE,
1627 .open = mcam_v4l_open,
1628 .release = mcam_v4l_release,
1629 .read = mcam_v4l_read,
1630 .poll = mcam_v4l_poll,
1631 .mmap = mcam_v4l_mmap,
1632 .unlocked_ioctl = video_ioctl2,
1637 * This template device holds all of those v4l2 methods; we
1638 * clone it for specific real devices.
1640 static struct video_device mcam_v4l_template = {
1642 .tvnorms = V4L2_STD_NTSC_M,
1643 .current_norm = V4L2_STD_NTSC_M, /* make mplayer happy */
1645 .fops = &mcam_v4l_fops,
1646 .ioctl_ops = &mcam_v4l_ioctl_ops,
1647 .release = video_device_release_empty,
1650 /* ---------------------------------------------------------------------- */
1652 * Interrupt handler stuff
1654 static void mcam_frame_complete(struct mcam_camera *cam, int frame)
1657 * Basic frame housekeeping.
1659 set_bit(frame, &cam->flags);
1660 clear_bit(CF_DMA_ACTIVE, &cam->flags);
1661 cam->next_buf = frame;
1662 cam->buf_seq[frame] = ++(cam->sequence);
1665 * "This should never happen"
1667 if (cam->state != S_STREAMING)
1670 * Process the frame and set up the next one.
1672 cam->frame_complete(cam, frame);
1677 * The interrupt handler; this needs to be called from the
1678 * platform irq handler with the lock held.
1680 int mccic_irq(struct mcam_camera *cam, unsigned int irqs)
1682 unsigned int frame, handled = 0;
1684 mcam_reg_write(cam, REG_IRQSTAT, FRAMEIRQS); /* Clear'em all */
1686 * Handle any frame completions. There really should
1687 * not be more than one of these, or we have fallen
1690 * When running in S/G mode, the frame number lacks any
1691 * real meaning - there's only one descriptor array - but
1692 * the controller still picks a different one to signal
1695 for (frame = 0; frame < cam->nbufs; frame++)
1696 if (irqs & (IRQ_EOF0 << frame)) {
1697 mcam_frame_complete(cam, frame);
1699 if (cam->buffer_mode == B_DMA_sg)
1703 * If a frame starts, note that we have DMA active. This
1704 * code assumes that we won't get multiple frame interrupts
1705 * at once; may want to rethink that.
1707 if (irqs & (IRQ_SOF0 | IRQ_SOF1 | IRQ_SOF2)) {
1708 set_bit(CF_DMA_ACTIVE, &cam->flags);
1710 if (cam->buffer_mode == B_DMA_sg)
1711 mcam_ctlr_stop(cam);
1716 /* ---------------------------------------------------------------------- */
1718 * Registration and such.
1720 static struct ov7670_config sensor_cfg = {
1722 * Exclude QCIF mode, because it only captures a tiny portion
1730 int mccic_register(struct mcam_camera *cam)
1732 struct i2c_board_info ov7670_info = {
1735 .platform_data = &sensor_cfg,
1740 * Validate the requested buffer mode.
1742 if (buffer_mode >= 0)
1743 cam->buffer_mode = buffer_mode;
1744 if (cam->buffer_mode == B_DMA_sg &&
1745 cam->chip_id == V4L2_IDENT_CAFE) {
1746 printk(KERN_ERR "marvell-cam: Cafe can't do S/G I/O, "
1747 "attempting vmalloc mode instead\n");
1748 cam->buffer_mode = B_vmalloc;
1750 if (!mcam_buffer_mode_supported(cam->buffer_mode)) {
1751 printk(KERN_ERR "marvell-cam: buffer mode %d unsupported\n",
1758 ret = v4l2_device_register(cam->dev, &cam->v4l2_dev);
1762 mutex_init(&cam->s_mutex);
1763 cam->state = S_NOTREADY;
1764 mcam_set_config_needed(cam, 1);
1765 cam->pix_format = mcam_def_pix_format;
1766 cam->mbus_code = mcam_def_mbus_code;
1767 INIT_LIST_HEAD(&cam->buffers);
1768 mcam_ctlr_init(cam);
1771 * Try to find the sensor.
1773 sensor_cfg.clock_speed = cam->clock_speed;
1774 sensor_cfg.use_smbus = cam->use_smbus;
1775 cam->sensor_addr = ov7670_info.addr;
1776 cam->sensor = v4l2_i2c_new_subdev_board(&cam->v4l2_dev,
1777 cam->i2c_adapter, &ov7670_info, NULL);
1778 if (cam->sensor == NULL) {
1780 goto out_unregister;
1783 ret = mcam_cam_init(cam);
1785 goto out_unregister;
1787 * Get the v4l2 setup done.
1789 mutex_lock(&cam->s_mutex);
1790 cam->vdev = mcam_v4l_template;
1791 cam->vdev.debug = 0;
1792 cam->vdev.v4l2_dev = &cam->v4l2_dev;
1793 ret = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
1796 video_set_drvdata(&cam->vdev, cam);
1799 * If so requested, try to get our DMA buffers now.
1801 if (cam->buffer_mode == B_vmalloc && !alloc_bufs_at_read) {
1802 if (mcam_alloc_dma_bufs(cam, 1))
1803 cam_warn(cam, "Unable to alloc DMA buffers at load"
1804 " will try again later.");
1808 mutex_unlock(&cam->s_mutex);
1811 v4l2_device_unregister(&cam->v4l2_dev);
1816 void mccic_shutdown(struct mcam_camera *cam)
1819 * If we have no users (and we really, really should have no
1820 * users) the device will already be powered down. Trying to
1821 * take it down again will wedge the machine, which is frowned
1824 if (cam->users > 0) {
1825 cam_warn(cam, "Removing a device with users!\n");
1826 mcam_ctlr_power_down(cam);
1828 vb2_queue_release(&cam->vb_queue);
1829 if (cam->buffer_mode == B_vmalloc)
1830 mcam_free_dma_bufs(cam);
1831 video_unregister_device(&cam->vdev);
1832 v4l2_device_unregister(&cam->v4l2_dev);
1840 void mccic_suspend(struct mcam_camera *cam)
1842 mutex_lock(&cam->s_mutex);
1843 if (cam->users > 0) {
1844 enum mcam_state cstate = cam->state;
1846 mcam_ctlr_stop_dma(cam);
1847 mcam_ctlr_power_down(cam);
1848 cam->state = cstate;
1850 mutex_unlock(&cam->s_mutex);
1853 int mccic_resume(struct mcam_camera *cam)
1857 mutex_lock(&cam->s_mutex);
1858 if (cam->users > 0) {
1859 mcam_ctlr_power_up(cam);
1860 __mcam_cam_reset(cam);
1862 mcam_ctlr_power_down(cam);
1864 mutex_unlock(&cam->s_mutex);
1866 set_bit(CF_CONFIG_NEEDED, &cam->flags);
1867 if (cam->state == S_STREAMING) {
1869 * If there was a buffer in the DMA engine at suspend
1870 * time, put it back on the queue or we'll forget about it.
1872 if (cam->buffer_mode == B_DMA_sg && cam->vb_bufs[0])
1873 list_add(&cam->vb_bufs[0]->queue, &cam->buffers);
1874 ret = mcam_read_setup(cam);
1878 #endif /* CONFIG_PM */