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>
10 #include <linux/dmi.h>
12 #include <linux/i2c.h>
13 #include <linux/interrupt.h>
14 #include <linux/spinlock.h>
15 #include <linux/videodev2.h>
16 #include <linux/slab.h>
17 #include <media/v4l2-device.h>
18 #include <media/v4l2-ioctl.h>
19 #include <media/v4l2-chip-ident.h>
20 #include <media/ov7670.h>
21 #include <linux/device.h>
22 #include <linux/wait.h>
23 #include <linux/list.h>
24 #include <linux/dma-mapping.h>
25 #include <linux/delay.h>
26 #include <linux/jiffies.h>
27 #include <linux/vmalloc.h>
28 #include <linux/uaccess.h>
31 #include "mcam-core.h"
35 * Internal DMA buffer management. Since the controller cannot do S/G I/O,
36 * we must have physically contiguous buffers to bring frames into.
37 * These parameters control how many buffers we use, whether we
38 * allocate them at load time (better chance of success, but nails down
39 * memory) or when somebody tries to use the camera (riskier), and,
40 * for load-time allocation, how big they should be.
42 * The controller can cycle through three buffers. We could use
43 * more by flipping pointers around, but it probably makes little
47 static int alloc_bufs_at_read
;
48 module_param(alloc_bufs_at_read
, bool, 0444);
49 MODULE_PARM_DESC(alloc_bufs_at_read
,
50 "Non-zero value causes DMA buffers to be allocated when the "
51 "video capture device is read, rather than at module load "
52 "time. This saves memory, but decreases the chances of "
53 "successfully getting those buffers.");
55 static int n_dma_bufs
= 3;
56 module_param(n_dma_bufs
, uint
, 0644);
57 MODULE_PARM_DESC(n_dma_bufs
,
58 "The number of DMA buffers to allocate. Can be either two "
59 "(saves memory, makes timing tighter) or three.");
61 static int dma_buf_size
= VGA_WIDTH
* VGA_HEIGHT
* 2; /* Worst case */
62 module_param(dma_buf_size
, uint
, 0444);
63 MODULE_PARM_DESC(dma_buf_size
,
64 "The size of the allocated DMA buffers. If actual operating "
65 "parameters require larger buffers, an attempt to reallocate "
68 static int min_buffers
= 1;
69 module_param(min_buffers
, uint
, 0644);
70 MODULE_PARM_DESC(min_buffers
,
71 "The minimum number of streaming I/O buffers we are willing "
74 static int max_buffers
= 10;
75 module_param(max_buffers
, uint
, 0644);
76 MODULE_PARM_DESC(max_buffers
,
77 "The maximum number of streaming I/O buffers an application "
78 "will be allowed to allocate. These buffers are big and live "
82 module_param(flip
, bool, 0444);
83 MODULE_PARM_DESC(flip
,
84 "If set, the sensor will be instructed to flip the image "
88 * Status flags. Always manipulated with bit operations.
90 #define CF_BUF0_VALID 0 /* Buffers valid - first three */
91 #define CF_BUF1_VALID 1
92 #define CF_BUF2_VALID 2
93 #define CF_DMA_ACTIVE 3 /* A frame is incoming */
94 #define CF_CONFIG_NEEDED 4 /* Must configure hardware */
96 #define sensor_call(cam, o, f, args...) \
97 v4l2_subdev_call(cam->sensor, o, f, ##args)
99 static struct mcam_format_struct
{
102 int bpp
; /* Bytes per pixel */
103 enum v4l2_mbus_pixelcode mbus_code
;
106 .desc
= "YUYV 4:2:2",
107 .pixelformat
= V4L2_PIX_FMT_YUYV
,
108 .mbus_code
= V4L2_MBUS_FMT_YUYV8_2X8
,
113 .pixelformat
= V4L2_PIX_FMT_RGB444
,
114 .mbus_code
= V4L2_MBUS_FMT_RGB444_2X8_PADHI_LE
,
119 .pixelformat
= V4L2_PIX_FMT_RGB565
,
120 .mbus_code
= V4L2_MBUS_FMT_RGB565_2X8_LE
,
124 .desc
= "Raw RGB Bayer",
125 .pixelformat
= V4L2_PIX_FMT_SBGGR8
,
126 .mbus_code
= V4L2_MBUS_FMT_SBGGR8_1X8
,
130 #define N_MCAM_FMTS ARRAY_SIZE(mcam_formats)
132 static struct mcam_format_struct
*mcam_find_format(u32 pixelformat
)
136 for (i
= 0; i
< N_MCAM_FMTS
; i
++)
137 if (mcam_formats
[i
].pixelformat
== pixelformat
)
138 return mcam_formats
+ i
;
139 /* Not found? Then return the first format. */
144 * Start over with DMA buffers - dev_lock needed.
146 static void mcam_reset_buffers(struct mcam_camera
*cam
)
151 for (i
= 0; i
< cam
->nbufs
; i
++)
152 clear_bit(i
, &cam
->flags
);
156 static inline int mcam_needs_config(struct mcam_camera
*cam
)
158 return test_bit(CF_CONFIG_NEEDED
, &cam
->flags
);
161 static void mcam_set_config_needed(struct mcam_camera
*cam
, int needed
)
164 set_bit(CF_CONFIG_NEEDED
, &cam
->flags
);
166 clear_bit(CF_CONFIG_NEEDED
, &cam
->flags
);
171 * Debugging and related. FIXME these are broken
173 #define cam_err(cam, fmt, arg...) \
174 dev_err((cam)->dev, fmt, ##arg);
175 #define cam_warn(cam, fmt, arg...) \
176 dev_warn((cam)->dev, fmt, ##arg);
177 #define cam_dbg(cam, fmt, arg...) \
178 dev_dbg((cam)->dev, fmt, ##arg);
182 /* ------------------------------------------------------------------- */
184 * Deal with the controller.
188 * Do everything we think we need to have the interface operating
189 * according to the desired format.
191 static void mcam_ctlr_dma(struct mcam_camera
*cam
)
194 * Store the first two Y buffers (we aren't supporting
195 * planar formats for now, so no UV bufs). Then either
196 * set the third if it exists, or tell the controller
199 mcam_reg_write(cam
, REG_Y0BAR
, cam
->dma_handles
[0]);
200 mcam_reg_write(cam
, REG_Y1BAR
, cam
->dma_handles
[1]);
201 if (cam
->nbufs
> 2) {
202 mcam_reg_write(cam
, REG_Y2BAR
, cam
->dma_handles
[2]);
203 mcam_reg_clear_bit(cam
, REG_CTRL1
, C1_TWOBUFS
);
205 mcam_reg_set_bit(cam
, REG_CTRL1
, C1_TWOBUFS
);
206 mcam_reg_write(cam
, REG_UBAR
, 0); /* 32 bits only for now */
209 static void mcam_ctlr_image(struct mcam_camera
*cam
)
212 struct v4l2_pix_format
*fmt
= &cam
->pix_format
;
214 imgsz
= ((fmt
->height
<< IMGSZ_V_SHIFT
) & IMGSZ_V_MASK
) |
215 (fmt
->bytesperline
& IMGSZ_H_MASK
);
216 mcam_reg_write(cam
, REG_IMGSIZE
, imgsz
);
217 mcam_reg_write(cam
, REG_IMGOFFSET
, 0);
218 /* YPITCH just drops the last two bits */
219 mcam_reg_write_mask(cam
, REG_IMGPITCH
, fmt
->bytesperline
,
222 * Tell the controller about the image format we are using.
224 switch (cam
->pix_format
.pixelformat
) {
225 case V4L2_PIX_FMT_YUYV
:
226 mcam_reg_write_mask(cam
, REG_CTRL0
,
227 C0_DF_YUV
|C0_YUV_PACKED
|C0_YUVE_YUYV
,
231 case V4L2_PIX_FMT_RGB444
:
232 mcam_reg_write_mask(cam
, REG_CTRL0
,
233 C0_DF_RGB
|C0_RGBF_444
|C0_RGB4_XRGB
,
238 case V4L2_PIX_FMT_RGB565
:
239 mcam_reg_write_mask(cam
, REG_CTRL0
,
240 C0_DF_RGB
|C0_RGBF_565
|C0_RGB5_BGGR
,
245 cam_err(cam
, "Unknown format %x\n", cam
->pix_format
.pixelformat
);
249 * Make sure it knows we want to use hsync/vsync.
251 mcam_reg_write_mask(cam
, REG_CTRL0
, C0_SIF_HVSYNC
,
257 * Configure the controller for operation; caller holds the
260 static int mcam_ctlr_configure(struct mcam_camera
*cam
)
264 spin_lock_irqsave(&cam
->dev_lock
, flags
);
266 mcam_ctlr_image(cam
);
267 mcam_set_config_needed(cam
, 0);
268 spin_unlock_irqrestore(&cam
->dev_lock
, flags
);
272 static void mcam_ctlr_irq_enable(struct mcam_camera
*cam
)
275 * Clear any pending interrupts, since we do not
276 * expect to have I/O active prior to enabling.
278 mcam_reg_write(cam
, REG_IRQSTAT
, FRAMEIRQS
);
279 mcam_reg_set_bit(cam
, REG_IRQMASK
, FRAMEIRQS
);
282 static void mcam_ctlr_irq_disable(struct mcam_camera
*cam
)
284 mcam_reg_clear_bit(cam
, REG_IRQMASK
, FRAMEIRQS
);
288 * Make the controller start grabbing images. Everything must
289 * be set up before doing this.
291 static void mcam_ctlr_start(struct mcam_camera
*cam
)
293 /* set_bit performs a read, so no other barrier should be
295 mcam_reg_set_bit(cam
, REG_CTRL0
, C0_ENABLE
);
298 static void mcam_ctlr_stop(struct mcam_camera
*cam
)
300 mcam_reg_clear_bit(cam
, REG_CTRL0
, C0_ENABLE
);
303 static void mcam_ctlr_init(struct mcam_camera
*cam
)
307 spin_lock_irqsave(&cam
->dev_lock
, flags
);
309 * Make sure it's not powered down.
311 mcam_reg_clear_bit(cam
, REG_CTRL1
, C1_PWRDWN
);
313 * Turn off the enable bit. It sure should be off anyway,
314 * but it's good to be sure.
316 mcam_reg_clear_bit(cam
, REG_CTRL0
, C0_ENABLE
);
318 * Clock the sensor appropriately. Controller clock should
319 * be 48MHz, sensor "typical" value is half that.
321 mcam_reg_write_mask(cam
, REG_CLKCTRL
, 2, CLK_DIV_MASK
);
322 spin_unlock_irqrestore(&cam
->dev_lock
, flags
);
327 * Stop the controller, and don't return until we're really sure that no
328 * further DMA is going on.
330 static void mcam_ctlr_stop_dma(struct mcam_camera
*cam
)
335 * Theory: stop the camera controller (whether it is operating
336 * or not). Delay briefly just in case we race with the SOF
337 * interrupt, then wait until no DMA is active.
339 spin_lock_irqsave(&cam
->dev_lock
, flags
);
341 spin_unlock_irqrestore(&cam
->dev_lock
, flags
);
343 wait_event_timeout(cam
->iowait
,
344 !test_bit(CF_DMA_ACTIVE
, &cam
->flags
), HZ
);
345 if (test_bit(CF_DMA_ACTIVE
, &cam
->flags
))
346 cam_err(cam
, "Timeout waiting for DMA to end\n");
347 /* This would be bad news - what now? */
348 spin_lock_irqsave(&cam
->dev_lock
, flags
);
350 mcam_ctlr_irq_disable(cam
);
351 spin_unlock_irqrestore(&cam
->dev_lock
, flags
);
357 static void mcam_ctlr_power_up(struct mcam_camera
*cam
)
361 spin_lock_irqsave(&cam
->dev_lock
, flags
);
362 mcam_reg_clear_bit(cam
, REG_CTRL1
, C1_PWRDWN
);
363 cam
->plat_power_up(cam
);
364 spin_unlock_irqrestore(&cam
->dev_lock
, flags
);
365 msleep(5); /* Just to be sure */
368 static void mcam_ctlr_power_down(struct mcam_camera
*cam
)
372 spin_lock_irqsave(&cam
->dev_lock
, flags
);
373 cam
->plat_power_down(cam
);
374 mcam_reg_set_bit(cam
, REG_CTRL1
, C1_PWRDWN
);
375 spin_unlock_irqrestore(&cam
->dev_lock
, flags
);
378 /* -------------------------------------------------------------------- */
380 * Communications with the sensor.
383 static int __mcam_cam_reset(struct mcam_camera
*cam
)
385 return sensor_call(cam
, core
, reset
, 0);
389 * We have found the sensor on the i2c. Let's try to have a
392 static int mcam_cam_init(struct mcam_camera
*cam
)
394 struct v4l2_dbg_chip_ident chip
;
397 mutex_lock(&cam
->s_mutex
);
398 if (cam
->state
!= S_NOTREADY
)
399 cam_warn(cam
, "Cam init with device in funky state %d",
401 ret
= __mcam_cam_reset(cam
);
404 chip
.ident
= V4L2_IDENT_NONE
;
405 chip
.match
.type
= V4L2_CHIP_MATCH_I2C_ADDR
;
406 chip
.match
.addr
= cam
->sensor_addr
;
407 ret
= sensor_call(cam
, core
, g_chip_ident
, &chip
);
410 cam
->sensor_type
= chip
.ident
;
411 if (cam
->sensor_type
!= V4L2_IDENT_OV7670
) {
412 cam_err(cam
, "Unsupported sensor type 0x%x", cam
->sensor_type
);
416 /* Get/set parameters? */
420 mcam_ctlr_power_down(cam
);
421 mutex_unlock(&cam
->s_mutex
);
426 * Configure the sensor to match the parameters we have. Caller should
429 static int mcam_cam_set_flip(struct mcam_camera
*cam
)
431 struct v4l2_control ctrl
;
433 memset(&ctrl
, 0, sizeof(ctrl
));
434 ctrl
.id
= V4L2_CID_VFLIP
;
436 return sensor_call(cam
, core
, s_ctrl
, &ctrl
);
440 static int mcam_cam_configure(struct mcam_camera
*cam
)
442 struct v4l2_mbus_framefmt mbus_fmt
;
445 v4l2_fill_mbus_format(&mbus_fmt
, &cam
->pix_format
, cam
->mbus_code
);
446 ret
= sensor_call(cam
, core
, init
, 0);
448 ret
= sensor_call(cam
, video
, s_mbus_fmt
, &mbus_fmt
);
450 * OV7670 does weird things if flip is set *before* format...
452 ret
+= mcam_cam_set_flip(cam
);
456 /* -------------------------------------------------------------------- */
458 * DMA buffer management. These functions need s_mutex held.
461 /* FIXME: this is inefficient as hell, since dma_alloc_coherent just
462 * does a get_free_pages() call, and we waste a good chunk of an orderN
463 * allocation. Should try to allocate the whole set in one chunk.
465 static int mcam_alloc_dma_bufs(struct mcam_camera
*cam
, int loadtime
)
469 mcam_set_config_needed(cam
, 1);
471 cam
->dma_buf_size
= dma_buf_size
;
473 cam
->dma_buf_size
= cam
->pix_format
.sizeimage
;
478 for (i
= 0; i
< n_dma_bufs
; i
++) {
479 cam
->dma_bufs
[i
] = dma_alloc_coherent(cam
->dev
,
480 cam
->dma_buf_size
, cam
->dma_handles
+ i
,
482 if (cam
->dma_bufs
[i
] == NULL
) {
483 cam_warn(cam
, "Failed to allocate DMA buffer\n");
486 /* For debug, remove eventually */
487 memset(cam
->dma_bufs
[i
], 0xcc, cam
->dma_buf_size
);
491 switch (cam
->nbufs
) {
493 dma_free_coherent(cam
->dev
, cam
->dma_buf_size
,
494 cam
->dma_bufs
[0], cam
->dma_handles
[0]);
497 cam_err(cam
, "Insufficient DMA buffers, cannot operate\n");
502 cam_warn(cam
, "Will limp along with only 2 buffers\n");
508 static void mcam_free_dma_bufs(struct mcam_camera
*cam
)
512 for (i
= 0; i
< cam
->nbufs
; i
++) {
513 dma_free_coherent(cam
->dev
, cam
->dma_buf_size
,
514 cam
->dma_bufs
[i
], cam
->dma_handles
[i
]);
515 cam
->dma_bufs
[i
] = NULL
;
524 /* ----------------------------------------------------------------------- */
526 * Here starts the V4L2 interface code.
530 * Read an image from the device.
532 static ssize_t
mcam_deliver_buffer(struct mcam_camera
*cam
,
533 char __user
*buffer
, size_t len
, loff_t
*pos
)
538 spin_lock_irqsave(&cam
->dev_lock
, flags
);
539 if (cam
->next_buf
< 0) {
540 cam_err(cam
, "deliver_buffer: No next buffer\n");
541 spin_unlock_irqrestore(&cam
->dev_lock
, flags
);
544 bufno
= cam
->next_buf
;
545 clear_bit(bufno
, &cam
->flags
);
546 if (++(cam
->next_buf
) >= cam
->nbufs
)
548 if (!test_bit(cam
->next_buf
, &cam
->flags
))
551 spin_unlock_irqrestore(&cam
->dev_lock
, flags
);
553 if (len
> cam
->pix_format
.sizeimage
)
554 len
= cam
->pix_format
.sizeimage
;
555 if (copy_to_user(buffer
, cam
->dma_bufs
[bufno
], len
))
562 * Get everything ready, and start grabbing frames.
564 static int mcam_read_setup(struct mcam_camera
*cam
, enum mcam_state state
)
570 * Configuration. If we still don't have DMA buffers,
571 * make one last, desperate attempt.
574 if (mcam_alloc_dma_bufs(cam
, 0))
577 if (mcam_needs_config(cam
)) {
578 mcam_cam_configure(cam
);
579 ret
= mcam_ctlr_configure(cam
);
587 spin_lock_irqsave(&cam
->dev_lock
, flags
);
588 mcam_reset_buffers(cam
);
589 mcam_ctlr_irq_enable(cam
);
591 mcam_ctlr_start(cam
);
592 spin_unlock_irqrestore(&cam
->dev_lock
, flags
);
597 static ssize_t
mcam_v4l_read(struct file
*filp
,
598 char __user
*buffer
, size_t len
, loff_t
*pos
)
600 struct mcam_camera
*cam
= filp
->private_data
;
604 * Perhaps we're in speculative read mode and already
607 mutex_lock(&cam
->s_mutex
);
608 if (cam
->state
== S_SPECREAD
) {
609 if (cam
->next_buf
>= 0) {
610 ret
= mcam_deliver_buffer(cam
, buffer
, len
, pos
);
614 } else if (cam
->state
== S_FLAKED
|| cam
->state
== S_NOTREADY
) {
617 } else if (cam
->state
!= S_IDLE
) {
623 * v4l2: multiple processes can open the device, but only
624 * one gets to grab data from it.
626 if (cam
->owner
&& cam
->owner
!= filp
) {
633 * Do setup if need be.
635 if (cam
->state
!= S_SPECREAD
) {
636 ret
= mcam_read_setup(cam
, S_SINGLEREAD
);
641 * Wait for something to happen. This should probably
642 * be interruptible (FIXME).
644 wait_event_timeout(cam
->iowait
, cam
->next_buf
>= 0, HZ
);
645 if (cam
->next_buf
< 0) {
646 cam_err(cam
, "read() operation timed out\n");
647 mcam_ctlr_stop_dma(cam
);
652 * Give them their data and we should be done.
654 ret
= mcam_deliver_buffer(cam
, buffer
, len
, pos
);
657 mutex_unlock(&cam
->s_mutex
);
669 * Streaming I/O support.
674 static int mcam_vidioc_streamon(struct file
*filp
, void *priv
,
675 enum v4l2_buf_type type
)
677 struct mcam_camera
*cam
= filp
->private_data
;
680 if (type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
682 mutex_lock(&cam
->s_mutex
);
683 if (cam
->state
!= S_IDLE
|| cam
->n_sbufs
== 0)
687 ret
= mcam_read_setup(cam
, S_STREAMING
);
690 mutex_unlock(&cam
->s_mutex
);
696 static int mcam_vidioc_streamoff(struct file
*filp
, void *priv
,
697 enum v4l2_buf_type type
)
699 struct mcam_camera
*cam
= filp
->private_data
;
702 if (type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
704 mutex_lock(&cam
->s_mutex
);
705 if (cam
->state
!= S_STREAMING
)
708 mcam_ctlr_stop_dma(cam
);
712 mutex_unlock(&cam
->s_mutex
);
719 static int mcam_setup_siobuf(struct mcam_camera
*cam
, int index
)
721 struct mcam_sio_buffer
*buf
= cam
->sb_bufs
+ index
;
723 INIT_LIST_HEAD(&buf
->list
);
724 buf
->v4lbuf
.length
= PAGE_ALIGN(cam
->pix_format
.sizeimage
);
725 buf
->buffer
= vmalloc_user(buf
->v4lbuf
.length
);
726 if (buf
->buffer
== NULL
)
731 buf
->v4lbuf
.index
= index
;
732 buf
->v4lbuf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
733 buf
->v4lbuf
.field
= V4L2_FIELD_NONE
;
734 buf
->v4lbuf
.memory
= V4L2_MEMORY_MMAP
;
736 * Offset: must be 32-bit even on a 64-bit system. videobuf-dma-sg
737 * just uses the length times the index, but the spec warns
738 * against doing just that - vma merging problems. So we
739 * leave a gap between each pair of buffers.
741 buf
->v4lbuf
.m
.offset
= 2*index
*buf
->v4lbuf
.length
;
745 static int mcam_free_sio_buffers(struct mcam_camera
*cam
)
750 * If any buffers are mapped, we cannot free them at all.
752 for (i
= 0; i
< cam
->n_sbufs
; i
++)
753 if (cam
->sb_bufs
[i
].mapcount
> 0)
758 for (i
= 0; i
< cam
->n_sbufs
; i
++)
759 vfree(cam
->sb_bufs
[i
].buffer
);
763 INIT_LIST_HEAD(&cam
->sb_avail
);
764 INIT_LIST_HEAD(&cam
->sb_full
);
770 static int mcam_vidioc_reqbufs(struct file
*filp
, void *priv
,
771 struct v4l2_requestbuffers
*req
)
773 struct mcam_camera
*cam
= filp
->private_data
;
774 int ret
= 0; /* Silence warning */
777 * Make sure it's something we can do. User pointers could be
778 * implemented without great pain, but that's not been done yet.
780 if (req
->memory
!= V4L2_MEMORY_MMAP
)
783 * If they ask for zero buffers, they really want us to stop streaming
784 * (if it's happening) and free everything. Should we check owner?
786 mutex_lock(&cam
->s_mutex
);
787 if (req
->count
== 0) {
788 if (cam
->state
== S_STREAMING
)
789 mcam_ctlr_stop_dma(cam
);
790 ret
= mcam_free_sio_buffers(cam
);
794 * Device needs to be idle and working. We *could* try to do the
795 * right thing in S_SPECREAD by shutting things down, but it
796 * probably doesn't matter.
798 if (cam
->state
!= S_IDLE
|| (cam
->owner
&& cam
->owner
!= filp
)) {
804 if (req
->count
< min_buffers
)
805 req
->count
= min_buffers
;
806 else if (req
->count
> max_buffers
)
807 req
->count
= max_buffers
;
808 if (cam
->n_sbufs
> 0) {
809 ret
= mcam_free_sio_buffers(cam
);
814 cam
->sb_bufs
= kzalloc(req
->count
*sizeof(struct mcam_sio_buffer
),
816 if (cam
->sb_bufs
== NULL
) {
820 for (cam
->n_sbufs
= 0; cam
->n_sbufs
< req
->count
; (cam
->n_sbufs
++)) {
821 ret
= mcam_setup_siobuf(cam
, cam
->n_sbufs
);
826 if (cam
->n_sbufs
== 0) /* no luck at all - ret already set */
828 req
->count
= cam
->n_sbufs
; /* In case of partial success */
831 mutex_unlock(&cam
->s_mutex
);
836 static int mcam_vidioc_querybuf(struct file
*filp
, void *priv
,
837 struct v4l2_buffer
*buf
)
839 struct mcam_camera
*cam
= filp
->private_data
;
842 mutex_lock(&cam
->s_mutex
);
843 if (buf
->index
>= cam
->n_sbufs
)
845 *buf
= cam
->sb_bufs
[buf
->index
].v4lbuf
;
848 mutex_unlock(&cam
->s_mutex
);
852 static int mcam_vidioc_qbuf(struct file
*filp
, void *priv
,
853 struct v4l2_buffer
*buf
)
855 struct mcam_camera
*cam
= filp
->private_data
;
856 struct mcam_sio_buffer
*sbuf
;
860 mutex_lock(&cam
->s_mutex
);
861 if (buf
->index
>= cam
->n_sbufs
)
863 sbuf
= cam
->sb_bufs
+ buf
->index
;
864 if (sbuf
->v4lbuf
.flags
& V4L2_BUF_FLAG_QUEUED
) {
865 ret
= 0; /* Already queued?? */
868 if (sbuf
->v4lbuf
.flags
& V4L2_BUF_FLAG_DONE
) {
869 /* Spec doesn't say anything, seems appropriate tho */
873 sbuf
->v4lbuf
.flags
|= V4L2_BUF_FLAG_QUEUED
;
874 spin_lock_irqsave(&cam
->dev_lock
, flags
);
875 list_add(&sbuf
->list
, &cam
->sb_avail
);
876 spin_unlock_irqrestore(&cam
->dev_lock
, flags
);
879 mutex_unlock(&cam
->s_mutex
);
883 static int mcam_vidioc_dqbuf(struct file
*filp
, void *priv
,
884 struct v4l2_buffer
*buf
)
886 struct mcam_camera
*cam
= filp
->private_data
;
887 struct mcam_sio_buffer
*sbuf
;
891 mutex_lock(&cam
->s_mutex
);
892 if (cam
->state
!= S_STREAMING
)
894 if (list_empty(&cam
->sb_full
) && filp
->f_flags
& O_NONBLOCK
) {
899 while (list_empty(&cam
->sb_full
) && cam
->state
== S_STREAMING
) {
900 mutex_unlock(&cam
->s_mutex
);
901 if (wait_event_interruptible(cam
->iowait
,
902 !list_empty(&cam
->sb_full
))) {
906 mutex_lock(&cam
->s_mutex
);
909 if (cam
->state
!= S_STREAMING
)
912 spin_lock_irqsave(&cam
->dev_lock
, flags
);
913 /* Should probably recheck !list_empty() here */
914 sbuf
= list_entry(cam
->sb_full
.next
,
915 struct mcam_sio_buffer
, list
);
916 list_del_init(&sbuf
->list
);
917 spin_unlock_irqrestore(&cam
->dev_lock
, flags
);
918 sbuf
->v4lbuf
.flags
&= ~V4L2_BUF_FLAG_DONE
;
924 mutex_unlock(&cam
->s_mutex
);
931 static void mcam_v4l_vm_open(struct vm_area_struct
*vma
)
933 struct mcam_sio_buffer
*sbuf
= vma
->vm_private_data
;
935 * Locking: done under mmap_sem, so we don't need to
936 * go back to the camera lock here.
942 static void mcam_v4l_vm_close(struct vm_area_struct
*vma
)
944 struct mcam_sio_buffer
*sbuf
= vma
->vm_private_data
;
946 mutex_lock(&sbuf
->cam
->s_mutex
);
948 /* Docs say we should stop I/O too... */
949 if (sbuf
->mapcount
== 0)
950 sbuf
->v4lbuf
.flags
&= ~V4L2_BUF_FLAG_MAPPED
;
951 mutex_unlock(&sbuf
->cam
->s_mutex
);
954 static const struct vm_operations_struct mcam_v4l_vm_ops
= {
955 .open
= mcam_v4l_vm_open
,
956 .close
= mcam_v4l_vm_close
960 static int mcam_v4l_mmap(struct file
*filp
, struct vm_area_struct
*vma
)
962 struct mcam_camera
*cam
= filp
->private_data
;
963 unsigned long offset
= vma
->vm_pgoff
<< PAGE_SHIFT
;
966 struct mcam_sio_buffer
*sbuf
= NULL
;
968 if (!(vma
->vm_flags
& VM_WRITE
) || !(vma
->vm_flags
& VM_SHARED
))
971 * Find the buffer they are looking for.
973 mutex_lock(&cam
->s_mutex
);
974 for (i
= 0; i
< cam
->n_sbufs
; i
++)
975 if (cam
->sb_bufs
[i
].v4lbuf
.m
.offset
== offset
) {
976 sbuf
= cam
->sb_bufs
+ i
;
982 ret
= remap_vmalloc_range(vma
, sbuf
->buffer
, 0);
985 vma
->vm_flags
|= VM_DONTEXPAND
;
986 vma
->vm_private_data
= sbuf
;
987 vma
->vm_ops
= &mcam_v4l_vm_ops
;
988 sbuf
->v4lbuf
.flags
|= V4L2_BUF_FLAG_MAPPED
;
989 mcam_v4l_vm_open(vma
);
992 mutex_unlock(&cam
->s_mutex
);
998 static int mcam_v4l_open(struct file
*filp
)
1000 struct mcam_camera
*cam
= video_drvdata(filp
);
1002 filp
->private_data
= cam
;
1004 mutex_lock(&cam
->s_mutex
);
1005 if (cam
->users
== 0) {
1006 mcam_ctlr_power_up(cam
);
1007 __mcam_cam_reset(cam
);
1008 mcam_set_config_needed(cam
, 1);
1009 /* FIXME make sure this is complete */
1012 mutex_unlock(&cam
->s_mutex
);
1017 static int mcam_v4l_release(struct file
*filp
)
1019 struct mcam_camera
*cam
= filp
->private_data
;
1021 mutex_lock(&cam
->s_mutex
);
1023 if (filp
== cam
->owner
) {
1024 mcam_ctlr_stop_dma(cam
);
1025 mcam_free_sio_buffers(cam
);
1028 if (cam
->users
== 0) {
1029 mcam_ctlr_power_down(cam
);
1030 if (alloc_bufs_at_read
)
1031 mcam_free_dma_bufs(cam
);
1033 mutex_unlock(&cam
->s_mutex
);
1039 static unsigned int mcam_v4l_poll(struct file
*filp
,
1040 struct poll_table_struct
*pt
)
1042 struct mcam_camera
*cam
= filp
->private_data
;
1044 poll_wait(filp
, &cam
->iowait
, pt
);
1045 if (cam
->next_buf
>= 0)
1046 return POLLIN
| POLLRDNORM
;
1052 static int mcam_vidioc_queryctrl(struct file
*filp
, void *priv
,
1053 struct v4l2_queryctrl
*qc
)
1055 struct mcam_camera
*cam
= priv
;
1058 mutex_lock(&cam
->s_mutex
);
1059 ret
= sensor_call(cam
, core
, queryctrl
, qc
);
1060 mutex_unlock(&cam
->s_mutex
);
1065 static int mcam_vidioc_g_ctrl(struct file
*filp
, void *priv
,
1066 struct v4l2_control
*ctrl
)
1068 struct mcam_camera
*cam
= priv
;
1071 mutex_lock(&cam
->s_mutex
);
1072 ret
= sensor_call(cam
, core
, g_ctrl
, ctrl
);
1073 mutex_unlock(&cam
->s_mutex
);
1078 static int mcam_vidioc_s_ctrl(struct file
*filp
, void *priv
,
1079 struct v4l2_control
*ctrl
)
1081 struct mcam_camera
*cam
= priv
;
1084 mutex_lock(&cam
->s_mutex
);
1085 ret
= sensor_call(cam
, core
, s_ctrl
, ctrl
);
1086 mutex_unlock(&cam
->s_mutex
);
1094 static int mcam_vidioc_querycap(struct file
*file
, void *priv
,
1095 struct v4l2_capability
*cap
)
1097 strcpy(cap
->driver
, "marvell_ccic");
1098 strcpy(cap
->card
, "marvell_ccic");
1100 cap
->capabilities
= V4L2_CAP_VIDEO_CAPTURE
|
1101 V4L2_CAP_READWRITE
| V4L2_CAP_STREAMING
;
1107 * The default format we use until somebody says otherwise.
1109 static const struct v4l2_pix_format mcam_def_pix_format
= {
1111 .height
= VGA_HEIGHT
,
1112 .pixelformat
= V4L2_PIX_FMT_YUYV
,
1113 .field
= V4L2_FIELD_NONE
,
1114 .bytesperline
= VGA_WIDTH
*2,
1115 .sizeimage
= VGA_WIDTH
*VGA_HEIGHT
*2,
1118 static const enum v4l2_mbus_pixelcode mcam_def_mbus_code
=
1119 V4L2_MBUS_FMT_YUYV8_2X8
;
1121 static int mcam_vidioc_enum_fmt_vid_cap(struct file
*filp
,
1122 void *priv
, struct v4l2_fmtdesc
*fmt
)
1124 if (fmt
->index
>= N_MCAM_FMTS
)
1126 strlcpy(fmt
->description
, mcam_formats
[fmt
->index
].desc
,
1127 sizeof(fmt
->description
));
1128 fmt
->pixelformat
= mcam_formats
[fmt
->index
].pixelformat
;
1132 static int mcam_vidioc_try_fmt_vid_cap(struct file
*filp
, void *priv
,
1133 struct v4l2_format
*fmt
)
1135 struct mcam_camera
*cam
= priv
;
1136 struct mcam_format_struct
*f
;
1137 struct v4l2_pix_format
*pix
= &fmt
->fmt
.pix
;
1138 struct v4l2_mbus_framefmt mbus_fmt
;
1141 f
= mcam_find_format(pix
->pixelformat
);
1142 pix
->pixelformat
= f
->pixelformat
;
1143 v4l2_fill_mbus_format(&mbus_fmt
, pix
, f
->mbus_code
);
1144 mutex_lock(&cam
->s_mutex
);
1145 ret
= sensor_call(cam
, video
, try_mbus_fmt
, &mbus_fmt
);
1146 mutex_unlock(&cam
->s_mutex
);
1147 v4l2_fill_pix_format(pix
, &mbus_fmt
);
1148 pix
->bytesperline
= pix
->width
* f
->bpp
;
1149 pix
->sizeimage
= pix
->height
* pix
->bytesperline
;
1153 static int mcam_vidioc_s_fmt_vid_cap(struct file
*filp
, void *priv
,
1154 struct v4l2_format
*fmt
)
1156 struct mcam_camera
*cam
= priv
;
1157 struct mcam_format_struct
*f
;
1161 * Can't do anything if the device is not idle
1162 * Also can't if there are streaming buffers in place.
1164 if (cam
->state
!= S_IDLE
|| cam
->n_sbufs
> 0)
1167 f
= mcam_find_format(fmt
->fmt
.pix
.pixelformat
);
1170 * See if the formatting works in principle.
1172 ret
= mcam_vidioc_try_fmt_vid_cap(filp
, priv
, fmt
);
1176 * Now we start to change things for real, so let's do it
1179 mutex_lock(&cam
->s_mutex
);
1180 cam
->pix_format
= fmt
->fmt
.pix
;
1181 cam
->mbus_code
= f
->mbus_code
;
1184 * Make sure we have appropriate DMA buffers.
1187 if (cam
->nbufs
> 0 && cam
->dma_buf_size
< cam
->pix_format
.sizeimage
)
1188 mcam_free_dma_bufs(cam
);
1189 if (cam
->nbufs
== 0) {
1190 if (mcam_alloc_dma_bufs(cam
, 0))
1194 * It looks like this might work, so let's program the sensor.
1196 ret
= mcam_cam_configure(cam
);
1198 ret
= mcam_ctlr_configure(cam
);
1200 mutex_unlock(&cam
->s_mutex
);
1205 * Return our stored notion of how the camera is/should be configured.
1206 * The V4l2 spec wants us to be smarter, and actually get this from
1207 * the camera (and not mess with it at open time). Someday.
1209 static int mcam_vidioc_g_fmt_vid_cap(struct file
*filp
, void *priv
,
1210 struct v4l2_format
*f
)
1212 struct mcam_camera
*cam
= priv
;
1214 f
->fmt
.pix
= cam
->pix_format
;
1219 * We only have one input - the sensor - so minimize the nonsense here.
1221 static int mcam_vidioc_enum_input(struct file
*filp
, void *priv
,
1222 struct v4l2_input
*input
)
1224 if (input
->index
!= 0)
1227 input
->type
= V4L2_INPUT_TYPE_CAMERA
;
1228 input
->std
= V4L2_STD_ALL
; /* Not sure what should go here */
1229 strcpy(input
->name
, "Camera");
1233 static int mcam_vidioc_g_input(struct file
*filp
, void *priv
, unsigned int *i
)
1239 static int mcam_vidioc_s_input(struct file
*filp
, void *priv
, unsigned int i
)
1247 static int mcam_vidioc_s_std(struct file
*filp
, void *priv
, v4l2_std_id
*a
)
1253 * G/S_PARM. Most of this is done by the sensor, but we are
1254 * the level which controls the number of read buffers.
1256 static int mcam_vidioc_g_parm(struct file
*filp
, void *priv
,
1257 struct v4l2_streamparm
*parms
)
1259 struct mcam_camera
*cam
= priv
;
1262 mutex_lock(&cam
->s_mutex
);
1263 ret
= sensor_call(cam
, video
, g_parm
, parms
);
1264 mutex_unlock(&cam
->s_mutex
);
1265 parms
->parm
.capture
.readbuffers
= n_dma_bufs
;
1269 static int mcam_vidioc_s_parm(struct file
*filp
, void *priv
,
1270 struct v4l2_streamparm
*parms
)
1272 struct mcam_camera
*cam
= priv
;
1275 mutex_lock(&cam
->s_mutex
);
1276 ret
= sensor_call(cam
, video
, s_parm
, parms
);
1277 mutex_unlock(&cam
->s_mutex
);
1278 parms
->parm
.capture
.readbuffers
= n_dma_bufs
;
1282 static int mcam_vidioc_g_chip_ident(struct file
*file
, void *priv
,
1283 struct v4l2_dbg_chip_ident
*chip
)
1285 struct mcam_camera
*cam
= priv
;
1287 chip
->ident
= V4L2_IDENT_NONE
;
1289 if (v4l2_chip_match_host(&chip
->match
)) {
1290 chip
->ident
= cam
->chip_id
;
1293 return sensor_call(cam
, core
, g_chip_ident
, chip
);
1296 static int mcam_vidioc_enum_framesizes(struct file
*filp
, void *priv
,
1297 struct v4l2_frmsizeenum
*sizes
)
1299 struct mcam_camera
*cam
= priv
;
1302 mutex_lock(&cam
->s_mutex
);
1303 ret
= sensor_call(cam
, video
, enum_framesizes
, sizes
);
1304 mutex_unlock(&cam
->s_mutex
);
1308 static int mcam_vidioc_enum_frameintervals(struct file
*filp
, void *priv
,
1309 struct v4l2_frmivalenum
*interval
)
1311 struct mcam_camera
*cam
= priv
;
1314 mutex_lock(&cam
->s_mutex
);
1315 ret
= sensor_call(cam
, video
, enum_frameintervals
, interval
);
1316 mutex_unlock(&cam
->s_mutex
);
1320 #ifdef CONFIG_VIDEO_ADV_DEBUG
1321 static int mcam_vidioc_g_register(struct file
*file
, void *priv
,
1322 struct v4l2_dbg_register
*reg
)
1324 struct mcam_camera
*cam
= priv
;
1326 if (v4l2_chip_match_host(®
->match
)) {
1327 reg
->val
= mcam_reg_read(cam
, reg
->reg
);
1331 return sensor_call(cam
, core
, g_register
, reg
);
1334 static int mcam_vidioc_s_register(struct file
*file
, void *priv
,
1335 struct v4l2_dbg_register
*reg
)
1337 struct mcam_camera
*cam
= priv
;
1339 if (v4l2_chip_match_host(®
->match
)) {
1340 mcam_reg_write(cam
, reg
->reg
, reg
->val
);
1343 return sensor_call(cam
, core
, s_register
, reg
);
1348 * This template device holds all of those v4l2 methods; we
1349 * clone it for specific real devices.
1352 static const struct v4l2_file_operations mcam_v4l_fops
= {
1353 .owner
= THIS_MODULE
,
1354 .open
= mcam_v4l_open
,
1355 .release
= mcam_v4l_release
,
1356 .read
= mcam_v4l_read
,
1357 .poll
= mcam_v4l_poll
,
1358 .mmap
= mcam_v4l_mmap
,
1359 .unlocked_ioctl
= video_ioctl2
,
1362 static const struct v4l2_ioctl_ops mcam_v4l_ioctl_ops
= {
1363 .vidioc_querycap
= mcam_vidioc_querycap
,
1364 .vidioc_enum_fmt_vid_cap
= mcam_vidioc_enum_fmt_vid_cap
,
1365 .vidioc_try_fmt_vid_cap
= mcam_vidioc_try_fmt_vid_cap
,
1366 .vidioc_s_fmt_vid_cap
= mcam_vidioc_s_fmt_vid_cap
,
1367 .vidioc_g_fmt_vid_cap
= mcam_vidioc_g_fmt_vid_cap
,
1368 .vidioc_enum_input
= mcam_vidioc_enum_input
,
1369 .vidioc_g_input
= mcam_vidioc_g_input
,
1370 .vidioc_s_input
= mcam_vidioc_s_input
,
1371 .vidioc_s_std
= mcam_vidioc_s_std
,
1372 .vidioc_reqbufs
= mcam_vidioc_reqbufs
,
1373 .vidioc_querybuf
= mcam_vidioc_querybuf
,
1374 .vidioc_qbuf
= mcam_vidioc_qbuf
,
1375 .vidioc_dqbuf
= mcam_vidioc_dqbuf
,
1376 .vidioc_streamon
= mcam_vidioc_streamon
,
1377 .vidioc_streamoff
= mcam_vidioc_streamoff
,
1378 .vidioc_queryctrl
= mcam_vidioc_queryctrl
,
1379 .vidioc_g_ctrl
= mcam_vidioc_g_ctrl
,
1380 .vidioc_s_ctrl
= mcam_vidioc_s_ctrl
,
1381 .vidioc_g_parm
= mcam_vidioc_g_parm
,
1382 .vidioc_s_parm
= mcam_vidioc_s_parm
,
1383 .vidioc_enum_framesizes
= mcam_vidioc_enum_framesizes
,
1384 .vidioc_enum_frameintervals
= mcam_vidioc_enum_frameintervals
,
1385 .vidioc_g_chip_ident
= mcam_vidioc_g_chip_ident
,
1386 #ifdef CONFIG_VIDEO_ADV_DEBUG
1387 .vidioc_g_register
= mcam_vidioc_g_register
,
1388 .vidioc_s_register
= mcam_vidioc_s_register
,
1392 static struct video_device mcam_v4l_template
= {
1394 .tvnorms
= V4L2_STD_NTSC_M
,
1395 .current_norm
= V4L2_STD_NTSC_M
, /* make mplayer happy */
1397 .fops
= &mcam_v4l_fops
,
1398 .ioctl_ops
= &mcam_v4l_ioctl_ops
,
1399 .release
= video_device_release_empty
,
1402 /* ---------------------------------------------------------------------- */
1404 * Interrupt handler stuff
1409 static void mcam_frame_tasklet(unsigned long data
)
1411 struct mcam_camera
*cam
= (struct mcam_camera
*) data
;
1413 unsigned long flags
;
1414 struct mcam_sio_buffer
*sbuf
;
1416 spin_lock_irqsave(&cam
->dev_lock
, flags
);
1417 for (i
= 0; i
< cam
->nbufs
; i
++) {
1418 int bufno
= cam
->next_buf
;
1419 if (bufno
< 0) { /* "will never happen" */
1420 cam_err(cam
, "No valid bufs in tasklet!\n");
1423 if (++(cam
->next_buf
) >= cam
->nbufs
)
1425 if (!test_bit(bufno
, &cam
->flags
))
1427 if (list_empty(&cam
->sb_avail
))
1428 break; /* Leave it valid, hope for better later */
1429 clear_bit(bufno
, &cam
->flags
);
1430 sbuf
= list_entry(cam
->sb_avail
.next
,
1431 struct mcam_sio_buffer
, list
);
1433 * Drop the lock during the big copy. This *should* be safe...
1435 spin_unlock_irqrestore(&cam
->dev_lock
, flags
);
1436 memcpy(sbuf
->buffer
, cam
->dma_bufs
[bufno
],
1437 cam
->pix_format
.sizeimage
);
1438 sbuf
->v4lbuf
.bytesused
= cam
->pix_format
.sizeimage
;
1439 sbuf
->v4lbuf
.sequence
= cam
->buf_seq
[bufno
];
1440 sbuf
->v4lbuf
.flags
&= ~V4L2_BUF_FLAG_QUEUED
;
1441 sbuf
->v4lbuf
.flags
|= V4L2_BUF_FLAG_DONE
;
1442 spin_lock_irqsave(&cam
->dev_lock
, flags
);
1443 list_move_tail(&sbuf
->list
, &cam
->sb_full
);
1445 if (!list_empty(&cam
->sb_full
))
1446 wake_up(&cam
->iowait
);
1447 spin_unlock_irqrestore(&cam
->dev_lock
, flags
);
1452 static void mcam_frame_complete(struct mcam_camera
*cam
, int frame
)
1455 * Basic frame housekeeping.
1457 if (test_bit(frame
, &cam
->flags
) && printk_ratelimit())
1458 cam_err(cam
, "Frame overrun on %d, frames lost\n", frame
);
1459 set_bit(frame
, &cam
->flags
);
1460 clear_bit(CF_DMA_ACTIVE
, &cam
->flags
);
1461 if (cam
->next_buf
< 0)
1462 cam
->next_buf
= frame
;
1463 cam
->buf_seq
[frame
] = ++(cam
->sequence
);
1465 switch (cam
->state
) {
1467 * If in single read mode, try going speculative.
1470 cam
->state
= S_SPECREAD
;
1471 cam
->specframes
= 0;
1472 wake_up(&cam
->iowait
);
1476 * If we are already doing speculative reads, and nobody is
1477 * reading them, just stop.
1480 if (++(cam
->specframes
) >= cam
->nbufs
) {
1481 mcam_ctlr_stop(cam
);
1482 mcam_ctlr_irq_disable(cam
);
1483 cam
->state
= S_IDLE
;
1485 wake_up(&cam
->iowait
);
1488 * For the streaming case, we defer the real work to the
1491 * FIXME: if the application is not consuming the buffers,
1492 * we should eventually put things on hold and restart in
1496 tasklet_schedule(&cam
->s_tasklet
);
1500 cam_err(cam
, "Frame interrupt in non-operational state\n");
1508 int mccic_irq(struct mcam_camera
*cam
, unsigned int irqs
)
1510 unsigned int frame
, handled
= 0;
1512 mcam_reg_write(cam
, REG_IRQSTAT
, FRAMEIRQS
); /* Clear'em all */
1514 * Handle any frame completions. There really should
1515 * not be more than one of these, or we have fallen
1518 for (frame
= 0; frame
< cam
->nbufs
; frame
++)
1519 if (irqs
& (IRQ_EOF0
<< frame
)) {
1520 mcam_frame_complete(cam
, frame
);
1524 * If a frame starts, note that we have DMA active. This
1525 * code assumes that we won't get multiple frame interrupts
1526 * at once; may want to rethink that.
1528 if (irqs
& (IRQ_SOF0
| IRQ_SOF1
| IRQ_SOF2
)) {
1529 set_bit(CF_DMA_ACTIVE
, &cam
->flags
);
1536 * Registration and such.
1539 /* FIXME this is really platform stuff */
1540 static const struct dmi_system_id olpc_xo1_dmi
[] = {
1543 DMI_MATCH(DMI_SYS_VENDOR
, "OLPC"),
1544 DMI_MATCH(DMI_PRODUCT_NAME
, "XO"),
1545 DMI_MATCH(DMI_PRODUCT_VERSION
, "1"),
1551 static struct ov7670_config sensor_cfg
= {
1552 /* This controller only does SMBUS */
1556 * Exclude QCIF mode, because it only captures a tiny portion
1564 int mccic_register(struct mcam_camera
*cam
)
1566 struct i2c_board_info ov7670_info
= {
1569 .platform_data
= &sensor_cfg
,
1576 ret
= v4l2_device_register(cam
->dev
, &cam
->v4l2_dev
);
1580 mutex_init(&cam
->s_mutex
);
1581 cam
->state
= S_NOTREADY
;
1582 mcam_set_config_needed(cam
, 1);
1583 init_waitqueue_head(&cam
->iowait
);
1584 cam
->pix_format
= mcam_def_pix_format
;
1585 cam
->mbus_code
= mcam_def_mbus_code
;
1586 INIT_LIST_HEAD(&cam
->dev_list
);
1587 INIT_LIST_HEAD(&cam
->sb_avail
);
1588 INIT_LIST_HEAD(&cam
->sb_full
);
1589 tasklet_init(&cam
->s_tasklet
, mcam_frame_tasklet
, (unsigned long) cam
);
1591 mcam_ctlr_init(cam
);
1593 /* Apply XO-1 clock speed */
1594 if (dmi_check_system(olpc_xo1_dmi
))
1595 sensor_cfg
.clock_speed
= 45;
1598 * Try to find the sensor.
1600 cam
->sensor_addr
= ov7670_info
.addr
;
1601 cam
->sensor
= v4l2_i2c_new_subdev_board(&cam
->v4l2_dev
,
1602 &cam
->i2c_adapter
, &ov7670_info
, NULL
);
1603 if (cam
->sensor
== NULL
) {
1605 goto out_unregister
;
1608 ret
= mcam_cam_init(cam
);
1610 goto out_unregister
;
1612 * Get the v4l2 setup done.
1614 mutex_lock(&cam
->s_mutex
);
1615 cam
->vdev
= mcam_v4l_template
;
1616 cam
->vdev
.debug
= 0;
1617 cam
->vdev
.v4l2_dev
= &cam
->v4l2_dev
;
1618 ret
= video_register_device(&cam
->vdev
, VFL_TYPE_GRABBER
, -1);
1621 video_set_drvdata(&cam
->vdev
, cam
);
1624 * If so requested, try to get our DMA buffers now.
1626 if (!alloc_bufs_at_read
) {
1627 if (mcam_alloc_dma_bufs(cam
, 1))
1628 cam_warn(cam
, "Unable to alloc DMA buffers at load"
1629 " will try again later.");
1633 mutex_unlock(&cam
->s_mutex
);
1636 v4l2_device_unregister(&cam
->v4l2_dev
);
1641 void mccic_shutdown(struct mcam_camera
*cam
)
1644 cam_warn(cam
, "Removing a device with users!\n");
1645 if (cam
->n_sbufs
> 0)
1646 /* What if they are still mapped? Shouldn't be, but... */
1647 mcam_free_sio_buffers(cam
);
1648 mcam_ctlr_stop_dma(cam
);
1649 mcam_ctlr_power_down(cam
);
1650 mcam_free_dma_bufs(cam
);
1651 video_unregister_device(&cam
->vdev
);
1652 v4l2_device_unregister(&cam
->v4l2_dev
);
1660 void mccic_suspend(struct mcam_camera
*cam
)
1662 enum mcam_state cstate
= cam
->state
;
1664 mcam_ctlr_stop_dma(cam
);
1665 mcam_ctlr_power_down(cam
);
1666 cam
->state
= cstate
;
1669 int mccic_resume(struct mcam_camera
*cam
)
1673 mutex_lock(&cam
->s_mutex
);
1674 if (cam
->users
> 0) {
1675 mcam_ctlr_power_up(cam
);
1676 __mcam_cam_reset(cam
);
1678 mcam_ctlr_power_down(cam
);
1680 mutex_unlock(&cam
->s_mutex
);
1682 set_bit(CF_CONFIG_NEEDED
, &cam
->flags
);
1683 if (cam
->state
== S_SPECREAD
)
1684 cam
->state
= S_IDLE
; /* Don't bother restarting */
1685 else if (cam
->state
== S_SINGLEREAD
|| cam
->state
== S_STREAMING
)
1686 ret
= mcam_read_setup(cam
, cam
->state
);
1689 #endif /* CONFIG_PM */