Loading...
1/*
2 * drivers/media/video/omap24xxcam.c
3 *
4 * OMAP 2 camera block driver.
5 *
6 * Copyright (C) 2004 MontaVista Software, Inc.
7 * Copyright (C) 2004 Texas Instruments.
8 * Copyright (C) 2007-2008 Nokia Corporation.
9 *
10 * Contact: Sakari Ailus <sakari.ailus@nokia.com>
11 *
12 * Based on code from Andy Lowe <source@mvista.com>
13 *
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License
16 * version 2 as published by the Free Software Foundation.
17 *
18 * This program is distributed in the hope that it will be useful, but
19 * WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
26 * 02110-1301 USA
27 */
28
29#include <linux/delay.h>
30#include <linux/kernel.h>
31#include <linux/interrupt.h>
32#include <linux/videodev2.h>
33#include <linux/pci.h> /* needed for videobufs */
34#include <linux/platform_device.h>
35#include <linux/clk.h>
36#include <linux/io.h>
37#include <linux/slab.h>
38#include <linux/sched.h>
39#include <linux/module.h>
40
41#include <media/v4l2-common.h>
42#include <media/v4l2-ioctl.h>
43
44#include "omap24xxcam.h"
45
46#define OMAP24XXCAM_VERSION "0.0.1"
47
48#define RESET_TIMEOUT_NS 10000
49
50static void omap24xxcam_reset(struct omap24xxcam_device *cam);
51static int omap24xxcam_sensor_if_enable(struct omap24xxcam_device *cam);
52static void omap24xxcam_device_unregister(struct v4l2_int_device *s);
53static int omap24xxcam_remove(struct platform_device *pdev);
54
55/* module parameters */
56static int video_nr = -1; /* video device minor (-1 ==> auto assign) */
57/*
58 * Maximum amount of memory to use for capture buffers.
59 * Default is 4800KB, enough to double-buffer SXGA.
60 */
61static int capture_mem = 1280 * 960 * 2 * 2;
62
63static struct v4l2_int_device omap24xxcam;
64
65/*
66 *
67 * Clocks.
68 *
69 */
70
71static void omap24xxcam_clock_put(struct omap24xxcam_device *cam)
72{
73 if (cam->ick != NULL && !IS_ERR(cam->ick))
74 clk_put(cam->ick);
75 if (cam->fck != NULL && !IS_ERR(cam->fck))
76 clk_put(cam->fck);
77
78 cam->ick = cam->fck = NULL;
79}
80
81static int omap24xxcam_clock_get(struct omap24xxcam_device *cam)
82{
83 int rval = 0;
84
85 cam->fck = clk_get(cam->dev, "fck");
86 if (IS_ERR(cam->fck)) {
87 dev_err(cam->dev, "can't get camera fck");
88 rval = PTR_ERR(cam->fck);
89 omap24xxcam_clock_put(cam);
90 return rval;
91 }
92
93 cam->ick = clk_get(cam->dev, "ick");
94 if (IS_ERR(cam->ick)) {
95 dev_err(cam->dev, "can't get camera ick");
96 rval = PTR_ERR(cam->ick);
97 omap24xxcam_clock_put(cam);
98 }
99
100 return rval;
101}
102
103static void omap24xxcam_clock_on(struct omap24xxcam_device *cam)
104{
105 clk_enable(cam->fck);
106 clk_enable(cam->ick);
107}
108
109static void omap24xxcam_clock_off(struct omap24xxcam_device *cam)
110{
111 clk_disable(cam->fck);
112 clk_disable(cam->ick);
113}
114
115/*
116 *
117 * Camera core
118 *
119 */
120
121/*
122 * Set xclk.
123 *
124 * To disable xclk, use value zero.
125 */
126static void omap24xxcam_core_xclk_set(const struct omap24xxcam_device *cam,
127 u32 xclk)
128{
129 if (xclk) {
130 u32 divisor = CAM_MCLK / xclk;
131
132 if (divisor == 1)
133 omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET,
134 CC_CTRL_XCLK,
135 CC_CTRL_XCLK_DIV_BYPASS);
136 else
137 omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET,
138 CC_CTRL_XCLK, divisor);
139 } else
140 omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET,
141 CC_CTRL_XCLK, CC_CTRL_XCLK_DIV_STABLE_LOW);
142}
143
144static void omap24xxcam_core_hwinit(const struct omap24xxcam_device *cam)
145{
146 /*
147 * Setting the camera core AUTOIDLE bit causes problems with frame
148 * synchronization, so we will clear the AUTOIDLE bit instead.
149 */
150 omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_SYSCONFIG,
151 CC_SYSCONFIG_AUTOIDLE);
152
153 /* program the camera interface DMA packet size */
154 omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_CTRL_DMA,
155 CC_CTRL_DMA_EN | (DMA_THRESHOLD / 4 - 1));
156
157 /* enable camera core error interrupts */
158 omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_IRQENABLE,
159 CC_IRQENABLE_FW_ERR_IRQ
160 | CC_IRQENABLE_FSC_ERR_IRQ
161 | CC_IRQENABLE_SSC_ERR_IRQ
162 | CC_IRQENABLE_FIFO_OF_IRQ);
163}
164
165/*
166 * Enable the camera core.
167 *
168 * Data transfer to the camera DMA starts from next starting frame.
169 */
170static void omap24xxcam_core_enable(const struct omap24xxcam_device *cam)
171{
172
173 omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_CTRL,
174 cam->cc_ctrl);
175}
176
177/*
178 * Disable camera core.
179 *
180 * The data transfer will be stopped immediately (CC_CTRL_CC_RST). The
181 * core internal state machines will be reset. Use
182 * CC_CTRL_CC_FRAME_TRIG instead if you want to transfer the current
183 * frame completely.
184 */
185static void omap24xxcam_core_disable(const struct omap24xxcam_device *cam)
186{
187 omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_CTRL,
188 CC_CTRL_CC_RST);
189}
190
191/* Interrupt service routine for camera core interrupts. */
192static void omap24xxcam_core_isr(struct omap24xxcam_device *cam)
193{
194 u32 cc_irqstatus;
195 const u32 cc_irqstatus_err =
196 CC_IRQSTATUS_FW_ERR_IRQ
197 | CC_IRQSTATUS_FSC_ERR_IRQ
198 | CC_IRQSTATUS_SSC_ERR_IRQ
199 | CC_IRQSTATUS_FIFO_UF_IRQ
200 | CC_IRQSTATUS_FIFO_OF_IRQ;
201
202 cc_irqstatus = omap24xxcam_reg_in(cam->mmio_base + CC_REG_OFFSET,
203 CC_IRQSTATUS);
204 omap24xxcam_reg_out(cam->mmio_base + CC_REG_OFFSET, CC_IRQSTATUS,
205 cc_irqstatus);
206
207 if (cc_irqstatus & cc_irqstatus_err
208 && !atomic_read(&cam->in_reset)) {
209 dev_dbg(cam->dev, "resetting camera, cc_irqstatus 0x%x\n",
210 cc_irqstatus);
211 omap24xxcam_reset(cam);
212 }
213}
214
215/*
216 *
217 * videobuf_buffer handling.
218 *
219 * Memory for mmapped videobuf_buffers is not allocated
220 * conventionally, but by several kmalloc allocations and then
221 * creating the scatterlist on our own. User-space buffers are handled
222 * normally.
223 *
224 */
225
226/*
227 * Free the memory-mapped buffer memory allocated for a
228 * videobuf_buffer and the associated scatterlist.
229 */
230static void omap24xxcam_vbq_free_mmap_buffer(struct videobuf_buffer *vb)
231{
232 struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
233 size_t alloc_size;
234 struct page *page;
235 int i;
236
237 if (dma->sglist == NULL)
238 return;
239
240 i = dma->sglen;
241 while (i) {
242 i--;
243 alloc_size = sg_dma_len(&dma->sglist[i]);
244 page = sg_page(&dma->sglist[i]);
245 do {
246 ClearPageReserved(page++);
247 } while (alloc_size -= PAGE_SIZE);
248 __free_pages(sg_page(&dma->sglist[i]),
249 get_order(sg_dma_len(&dma->sglist[i])));
250 }
251
252 kfree(dma->sglist);
253 dma->sglist = NULL;
254}
255
256/* Release all memory related to the videobuf_queue. */
257static void omap24xxcam_vbq_free_mmap_buffers(struct videobuf_queue *vbq)
258{
259 int i;
260
261 mutex_lock(&vbq->vb_lock);
262
263 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
264 if (NULL == vbq->bufs[i])
265 continue;
266 if (V4L2_MEMORY_MMAP != vbq->bufs[i]->memory)
267 continue;
268 vbq->ops->buf_release(vbq, vbq->bufs[i]);
269 omap24xxcam_vbq_free_mmap_buffer(vbq->bufs[i]);
270 kfree(vbq->bufs[i]);
271 vbq->bufs[i] = NULL;
272 }
273
274 mutex_unlock(&vbq->vb_lock);
275
276 videobuf_mmap_free(vbq);
277}
278
279/*
280 * Allocate physically as contiguous as possible buffer for video
281 * frame and allocate and build DMA scatter-gather list for it.
282 */
283static int omap24xxcam_vbq_alloc_mmap_buffer(struct videobuf_buffer *vb)
284{
285 unsigned int order;
286 size_t alloc_size, size = vb->bsize; /* vb->bsize is page aligned */
287 struct page *page;
288 int max_pages, err = 0, i = 0;
289 struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
290
291 /*
292 * allocate maximum size scatter-gather list. Note this is
293 * overhead. We may not use as many entries as we allocate
294 */
295 max_pages = vb->bsize >> PAGE_SHIFT;
296 dma->sglist = kcalloc(max_pages, sizeof(*dma->sglist), GFP_KERNEL);
297 if (dma->sglist == NULL) {
298 err = -ENOMEM;
299 goto out;
300 }
301
302 while (size) {
303 order = get_order(size);
304 /*
305 * do not over-allocate even if we would get larger
306 * contiguous chunk that way
307 */
308 if ((PAGE_SIZE << order) > size)
309 order--;
310
311 /* try to allocate as many contiguous pages as possible */
312 page = alloc_pages(GFP_KERNEL, order);
313 /* if allocation fails, try to allocate smaller amount */
314 while (page == NULL) {
315 order--;
316 page = alloc_pages(GFP_KERNEL, order);
317 if (page == NULL && !order) {
318 err = -ENOMEM;
319 goto out;
320 }
321 }
322 size -= (PAGE_SIZE << order);
323
324 /* append allocated chunk of pages into scatter-gather list */
325 sg_set_page(&dma->sglist[i], page, PAGE_SIZE << order, 0);
326 dma->sglen++;
327 i++;
328
329 alloc_size = (PAGE_SIZE << order);
330
331 /* clear pages before giving them to user space */
332 memset(page_address(page), 0, alloc_size);
333
334 /* mark allocated pages reserved */
335 do {
336 SetPageReserved(page++);
337 } while (alloc_size -= PAGE_SIZE);
338 }
339 /*
340 * REVISIT: not fully correct to assign nr_pages == sglen but
341 * video-buf is passing nr_pages for e.g. unmap_sg calls
342 */
343 dma->nr_pages = dma->sglen;
344 dma->direction = PCI_DMA_FROMDEVICE;
345
346 return 0;
347
348out:
349 omap24xxcam_vbq_free_mmap_buffer(vb);
350 return err;
351}
352
353static int omap24xxcam_vbq_alloc_mmap_buffers(struct videobuf_queue *vbq,
354 unsigned int count)
355{
356 int i, err = 0;
357 struct omap24xxcam_fh *fh =
358 container_of(vbq, struct omap24xxcam_fh, vbq);
359
360 mutex_lock(&vbq->vb_lock);
361
362 for (i = 0; i < count; i++) {
363 err = omap24xxcam_vbq_alloc_mmap_buffer(vbq->bufs[i]);
364 if (err)
365 goto out;
366 dev_dbg(fh->cam->dev, "sglen is %d for buffer %d\n",
367 videobuf_to_dma(vbq->bufs[i])->sglen, i);
368 }
369
370 mutex_unlock(&vbq->vb_lock);
371
372 return 0;
373out:
374 while (i) {
375 i--;
376 omap24xxcam_vbq_free_mmap_buffer(vbq->bufs[i]);
377 }
378
379 mutex_unlock(&vbq->vb_lock);
380
381 return err;
382}
383
384/*
385 * This routine is called from interrupt context when a scatter-gather DMA
386 * transfer of a videobuf_buffer completes.
387 */
388static void omap24xxcam_vbq_complete(struct omap24xxcam_sgdma *sgdma,
389 u32 csr, void *arg)
390{
391 struct omap24xxcam_device *cam =
392 container_of(sgdma, struct omap24xxcam_device, sgdma);
393 struct omap24xxcam_fh *fh = cam->streaming->private_data;
394 struct videobuf_buffer *vb = (struct videobuf_buffer *)arg;
395 const u32 csr_error = CAMDMA_CSR_MISALIGNED_ERR
396 | CAMDMA_CSR_SUPERVISOR_ERR | CAMDMA_CSR_SECURE_ERR
397 | CAMDMA_CSR_TRANS_ERR | CAMDMA_CSR_DROP;
398 unsigned long flags;
399
400 spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
401 if (--cam->sgdma_in_queue == 0)
402 omap24xxcam_core_disable(cam);
403 spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
404
405 do_gettimeofday(&vb->ts);
406 vb->field_count = atomic_add_return(2, &fh->field_count);
407 if (csr & csr_error) {
408 vb->state = VIDEOBUF_ERROR;
409 if (!atomic_read(&fh->cam->in_reset)) {
410 dev_dbg(cam->dev, "resetting camera, csr 0x%x\n", csr);
411 omap24xxcam_reset(cam);
412 }
413 } else
414 vb->state = VIDEOBUF_DONE;
415 wake_up(&vb->done);
416}
417
418static void omap24xxcam_vbq_release(struct videobuf_queue *vbq,
419 struct videobuf_buffer *vb)
420{
421 struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
422
423 /* wait for buffer, especially to get out of the sgdma queue */
424 videobuf_waiton(vbq, vb, 0, 0);
425 if (vb->memory == V4L2_MEMORY_MMAP) {
426 dma_unmap_sg(vbq->dev, dma->sglist, dma->sglen,
427 dma->direction);
428 dma->direction = DMA_NONE;
429 } else {
430 videobuf_dma_unmap(vbq->dev, videobuf_to_dma(vb));
431 videobuf_dma_free(videobuf_to_dma(vb));
432 }
433
434 vb->state = VIDEOBUF_NEEDS_INIT;
435}
436
437/*
438 * Limit the number of available kernel image capture buffers based on the
439 * number requested, the currently selected image size, and the maximum
440 * amount of memory permitted for kernel capture buffers.
441 */
442static int omap24xxcam_vbq_setup(struct videobuf_queue *vbq, unsigned int *cnt,
443 unsigned int *size)
444{
445 struct omap24xxcam_fh *fh = vbq->priv_data;
446
447 if (*cnt <= 0)
448 *cnt = VIDEO_MAX_FRAME; /* supply a default number of buffers */
449
450 if (*cnt > VIDEO_MAX_FRAME)
451 *cnt = VIDEO_MAX_FRAME;
452
453 *size = fh->pix.sizeimage;
454
455 /* accessing fh->cam->capture_mem is ok, it's constant */
456 if (*size * *cnt > fh->cam->capture_mem)
457 *cnt = fh->cam->capture_mem / *size;
458
459 return 0;
460}
461
462static int omap24xxcam_dma_iolock(struct videobuf_queue *vbq,
463 struct videobuf_dmabuf *dma)
464{
465 int err = 0;
466
467 dma->direction = PCI_DMA_FROMDEVICE;
468 if (!dma_map_sg(vbq->dev, dma->sglist, dma->sglen, dma->direction)) {
469 kfree(dma->sglist);
470 dma->sglist = NULL;
471 dma->sglen = 0;
472 err = -EIO;
473 }
474
475 return err;
476}
477
478static int omap24xxcam_vbq_prepare(struct videobuf_queue *vbq,
479 struct videobuf_buffer *vb,
480 enum v4l2_field field)
481{
482 struct omap24xxcam_fh *fh = vbq->priv_data;
483 int err = 0;
484
485 /*
486 * Accessing pix here is okay since it's constant while
487 * streaming is on (and we only get called then).
488 */
489 if (vb->baddr) {
490 /* This is a userspace buffer. */
491 if (fh->pix.sizeimage > vb->bsize) {
492 /* The buffer isn't big enough. */
493 err = -EINVAL;
494 } else
495 vb->size = fh->pix.sizeimage;
496 } else {
497 if (vb->state != VIDEOBUF_NEEDS_INIT) {
498 /*
499 * We have a kernel bounce buffer that has
500 * already been allocated.
501 */
502 if (fh->pix.sizeimage > vb->size) {
503 /*
504 * The image size has been changed to
505 * a larger size since this buffer was
506 * allocated, so we need to free and
507 * reallocate it.
508 */
509 omap24xxcam_vbq_release(vbq, vb);
510 vb->size = fh->pix.sizeimage;
511 }
512 } else {
513 /* We need to allocate a new kernel bounce buffer. */
514 vb->size = fh->pix.sizeimage;
515 }
516 }
517
518 if (err)
519 return err;
520
521 vb->width = fh->pix.width;
522 vb->height = fh->pix.height;
523 vb->field = field;
524
525 if (vb->state == VIDEOBUF_NEEDS_INIT) {
526 if (vb->memory == V4L2_MEMORY_MMAP)
527 /*
528 * we have built the scatter-gather list by ourself so
529 * do the scatter-gather mapping as well
530 */
531 err = omap24xxcam_dma_iolock(vbq, videobuf_to_dma(vb));
532 else
533 err = videobuf_iolock(vbq, vb, NULL);
534 }
535
536 if (!err)
537 vb->state = VIDEOBUF_PREPARED;
538 else
539 omap24xxcam_vbq_release(vbq, vb);
540
541 return err;
542}
543
544static void omap24xxcam_vbq_queue(struct videobuf_queue *vbq,
545 struct videobuf_buffer *vb)
546{
547 struct omap24xxcam_fh *fh = vbq->priv_data;
548 struct omap24xxcam_device *cam = fh->cam;
549 enum videobuf_state state = vb->state;
550 unsigned long flags;
551 int err;
552
553 /*
554 * FIXME: We're marking the buffer active since we have no
555 * pretty way of marking it active exactly when the
556 * scatter-gather transfer starts.
557 */
558 vb->state = VIDEOBUF_ACTIVE;
559
560 err = omap24xxcam_sgdma_queue(&fh->cam->sgdma,
561 videobuf_to_dma(vb)->sglist,
562 videobuf_to_dma(vb)->sglen, vb->size,
563 omap24xxcam_vbq_complete, vb);
564
565 if (!err) {
566 spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
567 if (++cam->sgdma_in_queue == 1
568 && !atomic_read(&cam->in_reset))
569 omap24xxcam_core_enable(cam);
570 spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
571 } else {
572 /*
573 * Oops. We're not supposed to get any errors here.
574 * The only way we could get an error is if we ran out
575 * of scatter-gather DMA slots, but we are supposed to
576 * have at least as many scatter-gather DMA slots as
577 * video buffers so that can't happen.
578 */
579 dev_err(cam->dev, "failed to queue a video buffer for dma!\n");
580 dev_err(cam->dev, "likely a bug in the driver!\n");
581 vb->state = state;
582 }
583}
584
585static struct videobuf_queue_ops omap24xxcam_vbq_ops = {
586 .buf_setup = omap24xxcam_vbq_setup,
587 .buf_prepare = omap24xxcam_vbq_prepare,
588 .buf_queue = omap24xxcam_vbq_queue,
589 .buf_release = omap24xxcam_vbq_release,
590};
591
592/*
593 *
594 * OMAP main camera system
595 *
596 */
597
598/*
599 * Reset camera block to power-on state.
600 */
601static void omap24xxcam_poweron_reset(struct omap24xxcam_device *cam)
602{
603 int max_loop = RESET_TIMEOUT_NS;
604
605 /* Reset whole camera subsystem */
606 omap24xxcam_reg_out(cam->mmio_base,
607 CAM_SYSCONFIG,
608 CAM_SYSCONFIG_SOFTRESET);
609
610 /* Wait till it's finished */
611 while (!(omap24xxcam_reg_in(cam->mmio_base, CAM_SYSSTATUS)
612 & CAM_SYSSTATUS_RESETDONE)
613 && --max_loop) {
614 ndelay(1);
615 }
616
617 if (!(omap24xxcam_reg_in(cam->mmio_base, CAM_SYSSTATUS)
618 & CAM_SYSSTATUS_RESETDONE))
619 dev_err(cam->dev, "camera soft reset timeout\n");
620}
621
622/*
623 * (Re)initialise the camera block.
624 */
625static void omap24xxcam_hwinit(struct omap24xxcam_device *cam)
626{
627 omap24xxcam_poweron_reset(cam);
628
629 /* set the camera subsystem autoidle bit */
630 omap24xxcam_reg_out(cam->mmio_base, CAM_SYSCONFIG,
631 CAM_SYSCONFIG_AUTOIDLE);
632
633 /* set the camera MMU autoidle bit */
634 omap24xxcam_reg_out(cam->mmio_base,
635 CAMMMU_REG_OFFSET + CAMMMU_SYSCONFIG,
636 CAMMMU_SYSCONFIG_AUTOIDLE);
637
638 omap24xxcam_core_hwinit(cam);
639
640 omap24xxcam_dma_hwinit(&cam->sgdma.dma);
641}
642
643/*
644 * Callback for dma transfer stalling.
645 */
646static void omap24xxcam_stalled_dma_reset(unsigned long data)
647{
648 struct omap24xxcam_device *cam = (struct omap24xxcam_device *)data;
649
650 if (!atomic_read(&cam->in_reset)) {
651 dev_dbg(cam->dev, "dma stalled, resetting camera\n");
652 omap24xxcam_reset(cam);
653 }
654}
655
656/*
657 * Stop capture. Mark we're doing a reset, stop DMA transfers and
658 * core. (No new scatter-gather transfers will be queued whilst
659 * in_reset is non-zero.)
660 *
661 * If omap24xxcam_capture_stop is called from several places at
662 * once, only the first call will have an effect. Similarly, the last
663 * call omap24xxcam_streaming_cont will have effect.
664 *
665 * Serialisation is ensured by using cam->core_enable_disable_lock.
666 */
667static void omap24xxcam_capture_stop(struct omap24xxcam_device *cam)
668{
669 unsigned long flags;
670
671 spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
672
673 if (atomic_inc_return(&cam->in_reset) != 1) {
674 spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
675 return;
676 }
677
678 omap24xxcam_core_disable(cam);
679
680 spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
681
682 omap24xxcam_sgdma_sync(&cam->sgdma);
683}
684
685/*
686 * Reset and continue streaming.
687 *
688 * Note: Resetting the camera FIFO via the CC_RST bit in the CC_CTRL
689 * register is supposed to be sufficient to recover from a camera
690 * interface error, but it doesn't seem to be enough. If we only do
691 * that then subsequent image captures are out of sync by either one
692 * or two times DMA_THRESHOLD bytes. Resetting and re-initializing the
693 * entire camera subsystem prevents the problem with frame
694 * synchronization.
695 */
696static void omap24xxcam_capture_cont(struct omap24xxcam_device *cam)
697{
698 unsigned long flags;
699
700 spin_lock_irqsave(&cam->core_enable_disable_lock, flags);
701
702 if (atomic_read(&cam->in_reset) != 1)
703 goto out;
704
705 omap24xxcam_hwinit(cam);
706
707 omap24xxcam_sensor_if_enable(cam);
708
709 omap24xxcam_sgdma_process(&cam->sgdma);
710
711 if (cam->sgdma_in_queue)
712 omap24xxcam_core_enable(cam);
713
714out:
715 atomic_dec(&cam->in_reset);
716 spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
717}
718
719static ssize_t
720omap24xxcam_streaming_show(struct device *dev, struct device_attribute *attr,
721 char *buf)
722{
723 struct omap24xxcam_device *cam = dev_get_drvdata(dev);
724
725 return sprintf(buf, "%s\n", cam->streaming ? "active" : "inactive");
726}
727static DEVICE_ATTR(streaming, S_IRUGO, omap24xxcam_streaming_show, NULL);
728
729/*
730 * Stop capture and restart it. I.e. reset the camera during use.
731 */
732static void omap24xxcam_reset(struct omap24xxcam_device *cam)
733{
734 omap24xxcam_capture_stop(cam);
735 omap24xxcam_capture_cont(cam);
736}
737
738/*
739 * The main interrupt handler.
740 */
741static irqreturn_t omap24xxcam_isr(int irq, void *arg)
742{
743 struct omap24xxcam_device *cam = (struct omap24xxcam_device *)arg;
744 u32 irqstatus;
745 unsigned int irqhandled = 0;
746
747 irqstatus = omap24xxcam_reg_in(cam->mmio_base, CAM_IRQSTATUS);
748
749 if (irqstatus &
750 (CAM_IRQSTATUS_DMA_IRQ2 | CAM_IRQSTATUS_DMA_IRQ1
751 | CAM_IRQSTATUS_DMA_IRQ0)) {
752 omap24xxcam_dma_isr(&cam->sgdma.dma);
753 irqhandled = 1;
754 }
755 if (irqstatus & CAM_IRQSTATUS_CC_IRQ) {
756 omap24xxcam_core_isr(cam);
757 irqhandled = 1;
758 }
759 if (irqstatus & CAM_IRQSTATUS_MMU_IRQ)
760 dev_err(cam->dev, "unhandled camera MMU interrupt!\n");
761
762 return IRQ_RETVAL(irqhandled);
763}
764
765/*
766 *
767 * Sensor handling.
768 *
769 */
770
771/*
772 * Enable the external sensor interface. Try to negotiate interface
773 * parameters with the sensor and start using the new ones. The calls
774 * to sensor_if_enable and sensor_if_disable need not to be balanced.
775 */
776static int omap24xxcam_sensor_if_enable(struct omap24xxcam_device *cam)
777{
778 int rval;
779 struct v4l2_ifparm p;
780
781 rval = vidioc_int_g_ifparm(cam->sdev, &p);
782 if (rval) {
783 dev_err(cam->dev, "vidioc_int_g_ifparm failed with %d\n", rval);
784 return rval;
785 }
786
787 cam->if_type = p.if_type;
788
789 cam->cc_ctrl = CC_CTRL_CC_EN;
790
791 switch (p.if_type) {
792 case V4L2_IF_TYPE_BT656:
793 if (p.u.bt656.frame_start_on_rising_vs)
794 cam->cc_ctrl |= CC_CTRL_NOBT_SYNCHRO;
795 if (p.u.bt656.bt_sync_correct)
796 cam->cc_ctrl |= CC_CTRL_BT_CORRECT;
797 if (p.u.bt656.swap)
798 cam->cc_ctrl |= CC_CTRL_PAR_ORDERCAM;
799 if (p.u.bt656.latch_clk_inv)
800 cam->cc_ctrl |= CC_CTRL_PAR_CLK_POL;
801 if (p.u.bt656.nobt_hs_inv)
802 cam->cc_ctrl |= CC_CTRL_NOBT_HS_POL;
803 if (p.u.bt656.nobt_vs_inv)
804 cam->cc_ctrl |= CC_CTRL_NOBT_VS_POL;
805
806 switch (p.u.bt656.mode) {
807 case V4L2_IF_TYPE_BT656_MODE_NOBT_8BIT:
808 cam->cc_ctrl |= CC_CTRL_PAR_MODE_NOBT8;
809 break;
810 case V4L2_IF_TYPE_BT656_MODE_NOBT_10BIT:
811 cam->cc_ctrl |= CC_CTRL_PAR_MODE_NOBT10;
812 break;
813 case V4L2_IF_TYPE_BT656_MODE_NOBT_12BIT:
814 cam->cc_ctrl |= CC_CTRL_PAR_MODE_NOBT12;
815 break;
816 case V4L2_IF_TYPE_BT656_MODE_BT_8BIT:
817 cam->cc_ctrl |= CC_CTRL_PAR_MODE_BT8;
818 break;
819 case V4L2_IF_TYPE_BT656_MODE_BT_10BIT:
820 cam->cc_ctrl |= CC_CTRL_PAR_MODE_BT10;
821 break;
822 default:
823 dev_err(cam->dev,
824 "bt656 interface mode %d not supported\n",
825 p.u.bt656.mode);
826 return -EINVAL;
827 }
828 /*
829 * The clock rate that the sensor wants has changed.
830 * We have to adjust the xclk from OMAP 2 side to
831 * match the sensor's wish as closely as possible.
832 */
833 if (p.u.bt656.clock_curr != cam->if_u.bt656.xclk) {
834 u32 xclk = p.u.bt656.clock_curr;
835 u32 divisor;
836
837 if (xclk == 0)
838 return -EINVAL;
839
840 if (xclk > CAM_MCLK)
841 xclk = CAM_MCLK;
842
843 divisor = CAM_MCLK / xclk;
844 if (divisor * xclk < CAM_MCLK)
845 divisor++;
846 if (CAM_MCLK / divisor < p.u.bt656.clock_min
847 && divisor > 1)
848 divisor--;
849 if (divisor > 30)
850 divisor = 30;
851
852 xclk = CAM_MCLK / divisor;
853
854 if (xclk < p.u.bt656.clock_min
855 || xclk > p.u.bt656.clock_max)
856 return -EINVAL;
857
858 cam->if_u.bt656.xclk = xclk;
859 }
860 omap24xxcam_core_xclk_set(cam, cam->if_u.bt656.xclk);
861 break;
862 default:
863 /* FIXME: how about other interfaces? */
864 dev_err(cam->dev, "interface type %d not supported\n",
865 p.if_type);
866 return -EINVAL;
867 }
868
869 return 0;
870}
871
872static void omap24xxcam_sensor_if_disable(const struct omap24xxcam_device *cam)
873{
874 switch (cam->if_type) {
875 case V4L2_IF_TYPE_BT656:
876 omap24xxcam_core_xclk_set(cam, 0);
877 break;
878 }
879}
880
881/*
882 * Initialise the sensor hardware.
883 */
884static int omap24xxcam_sensor_init(struct omap24xxcam_device *cam)
885{
886 int err = 0;
887 struct v4l2_int_device *sdev = cam->sdev;
888
889 omap24xxcam_clock_on(cam);
890 err = omap24xxcam_sensor_if_enable(cam);
891 if (err) {
892 dev_err(cam->dev, "sensor interface could not be enabled at "
893 "initialisation, %d\n", err);
894 cam->sdev = NULL;
895 goto out;
896 }
897
898 /* power up sensor during sensor initialization */
899 vidioc_int_s_power(sdev, 1);
900
901 err = vidioc_int_dev_init(sdev);
902 if (err) {
903 dev_err(cam->dev, "cannot initialize sensor, error %d\n", err);
904 /* Sensor init failed --- it's nonexistent to us! */
905 cam->sdev = NULL;
906 goto out;
907 }
908
909 dev_info(cam->dev, "sensor is %s\n", sdev->name);
910
911out:
912 omap24xxcam_sensor_if_disable(cam);
913 omap24xxcam_clock_off(cam);
914
915 vidioc_int_s_power(sdev, 0);
916
917 return err;
918}
919
920static void omap24xxcam_sensor_exit(struct omap24xxcam_device *cam)
921{
922 if (cam->sdev)
923 vidioc_int_dev_exit(cam->sdev);
924}
925
926static void omap24xxcam_sensor_disable(struct omap24xxcam_device *cam)
927{
928 omap24xxcam_sensor_if_disable(cam);
929 omap24xxcam_clock_off(cam);
930 vidioc_int_s_power(cam->sdev, 0);
931}
932
933/*
934 * Power-up and configure camera sensor. It's ready for capturing now.
935 */
936static int omap24xxcam_sensor_enable(struct omap24xxcam_device *cam)
937{
938 int rval;
939
940 omap24xxcam_clock_on(cam);
941
942 omap24xxcam_sensor_if_enable(cam);
943
944 rval = vidioc_int_s_power(cam->sdev, 1);
945 if (rval)
946 goto out;
947
948 rval = vidioc_int_init(cam->sdev);
949 if (rval)
950 goto out;
951
952 return 0;
953
954out:
955 omap24xxcam_sensor_disable(cam);
956
957 return rval;
958}
959
960static void omap24xxcam_sensor_reset_work(struct work_struct *work)
961{
962 struct omap24xxcam_device *cam =
963 container_of(work, struct omap24xxcam_device,
964 sensor_reset_work);
965
966 if (atomic_read(&cam->reset_disable))
967 return;
968
969 omap24xxcam_capture_stop(cam);
970
971 if (vidioc_int_reset(cam->sdev) == 0) {
972 vidioc_int_init(cam->sdev);
973 } else {
974 /* Can't reset it by vidioc_int_reset. */
975 omap24xxcam_sensor_disable(cam);
976 omap24xxcam_sensor_enable(cam);
977 }
978
979 omap24xxcam_capture_cont(cam);
980}
981
982/*
983 *
984 * IOCTL interface.
985 *
986 */
987
988static int vidioc_querycap(struct file *file, void *fh,
989 struct v4l2_capability *cap)
990{
991 struct omap24xxcam_fh *ofh = fh;
992 struct omap24xxcam_device *cam = ofh->cam;
993
994 strlcpy(cap->driver, CAM_NAME, sizeof(cap->driver));
995 strlcpy(cap->card, cam->vfd->name, sizeof(cap->card));
996 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
997
998 return 0;
999}
1000
1001static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
1002 struct v4l2_fmtdesc *f)
1003{
1004 struct omap24xxcam_fh *ofh = fh;
1005 struct omap24xxcam_device *cam = ofh->cam;
1006 int rval;
1007
1008 rval = vidioc_int_enum_fmt_cap(cam->sdev, f);
1009
1010 return rval;
1011}
1012
1013static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1014 struct v4l2_format *f)
1015{
1016 struct omap24xxcam_fh *ofh = fh;
1017 struct omap24xxcam_device *cam = ofh->cam;
1018 int rval;
1019
1020 mutex_lock(&cam->mutex);
1021 rval = vidioc_int_g_fmt_cap(cam->sdev, f);
1022 mutex_unlock(&cam->mutex);
1023
1024 return rval;
1025}
1026
1027static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1028 struct v4l2_format *f)
1029{
1030 struct omap24xxcam_fh *ofh = fh;
1031 struct omap24xxcam_device *cam = ofh->cam;
1032 int rval;
1033
1034 mutex_lock(&cam->mutex);
1035 if (cam->streaming) {
1036 rval = -EBUSY;
1037 goto out;
1038 }
1039
1040 rval = vidioc_int_s_fmt_cap(cam->sdev, f);
1041
1042out:
1043 mutex_unlock(&cam->mutex);
1044
1045 if (!rval) {
1046 mutex_lock(&ofh->vbq.vb_lock);
1047 ofh->pix = f->fmt.pix;
1048 mutex_unlock(&ofh->vbq.vb_lock);
1049 }
1050
1051 memset(f, 0, sizeof(*f));
1052 vidioc_g_fmt_vid_cap(file, fh, f);
1053
1054 return rval;
1055}
1056
1057static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
1058 struct v4l2_format *f)
1059{
1060 struct omap24xxcam_fh *ofh = fh;
1061 struct omap24xxcam_device *cam = ofh->cam;
1062 int rval;
1063
1064 mutex_lock(&cam->mutex);
1065 rval = vidioc_int_try_fmt_cap(cam->sdev, f);
1066 mutex_unlock(&cam->mutex);
1067
1068 return rval;
1069}
1070
1071static int vidioc_reqbufs(struct file *file, void *fh,
1072 struct v4l2_requestbuffers *b)
1073{
1074 struct omap24xxcam_fh *ofh = fh;
1075 struct omap24xxcam_device *cam = ofh->cam;
1076 int rval;
1077
1078 mutex_lock(&cam->mutex);
1079 if (cam->streaming) {
1080 mutex_unlock(&cam->mutex);
1081 return -EBUSY;
1082 }
1083
1084 omap24xxcam_vbq_free_mmap_buffers(&ofh->vbq);
1085 mutex_unlock(&cam->mutex);
1086
1087 rval = videobuf_reqbufs(&ofh->vbq, b);
1088
1089 /*
1090 * Either videobuf_reqbufs failed or the buffers are not
1091 * memory-mapped (which would need special attention).
1092 */
1093 if (rval < 0 || b->memory != V4L2_MEMORY_MMAP)
1094 goto out;
1095
1096 rval = omap24xxcam_vbq_alloc_mmap_buffers(&ofh->vbq, rval);
1097 if (rval)
1098 omap24xxcam_vbq_free_mmap_buffers(&ofh->vbq);
1099
1100out:
1101 return rval;
1102}
1103
1104static int vidioc_querybuf(struct file *file, void *fh,
1105 struct v4l2_buffer *b)
1106{
1107 struct omap24xxcam_fh *ofh = fh;
1108
1109 return videobuf_querybuf(&ofh->vbq, b);
1110}
1111
1112static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
1113{
1114 struct omap24xxcam_fh *ofh = fh;
1115
1116 return videobuf_qbuf(&ofh->vbq, b);
1117}
1118
1119static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
1120{
1121 struct omap24xxcam_fh *ofh = fh;
1122 struct omap24xxcam_device *cam = ofh->cam;
1123 struct videobuf_buffer *vb;
1124 int rval;
1125
1126videobuf_dqbuf_again:
1127 rval = videobuf_dqbuf(&ofh->vbq, b, file->f_flags & O_NONBLOCK);
1128 if (rval)
1129 goto out;
1130
1131 vb = ofh->vbq.bufs[b->index];
1132
1133 mutex_lock(&cam->mutex);
1134 /* _needs_reset returns -EIO if reset is required. */
1135 rval = vidioc_int_g_needs_reset(cam->sdev, (void *)vb->baddr);
1136 mutex_unlock(&cam->mutex);
1137 if (rval == -EIO)
1138 schedule_work(&cam->sensor_reset_work);
1139 else
1140 rval = 0;
1141
1142out:
1143 /*
1144 * This is a hack. We don't want to show -EIO to the user
1145 * space. Requeue the buffer and try again if we're not doing
1146 * this in non-blocking mode.
1147 */
1148 if (rval == -EIO) {
1149 videobuf_qbuf(&ofh->vbq, b);
1150 if (!(file->f_flags & O_NONBLOCK))
1151 goto videobuf_dqbuf_again;
1152 /*
1153 * We don't have a videobuf_buffer now --- maybe next
1154 * time...
1155 */
1156 rval = -EAGAIN;
1157 }
1158
1159 return rval;
1160}
1161
1162static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1163{
1164 struct omap24xxcam_fh *ofh = fh;
1165 struct omap24xxcam_device *cam = ofh->cam;
1166 int rval;
1167
1168 mutex_lock(&cam->mutex);
1169 if (cam->streaming) {
1170 rval = -EBUSY;
1171 goto out;
1172 }
1173
1174 rval = omap24xxcam_sensor_if_enable(cam);
1175 if (rval) {
1176 dev_dbg(cam->dev, "vidioc_int_g_ifparm failed\n");
1177 goto out;
1178 }
1179
1180 rval = videobuf_streamon(&ofh->vbq);
1181 if (!rval) {
1182 cam->streaming = file;
1183 sysfs_notify(&cam->dev->kobj, NULL, "streaming");
1184 }
1185
1186out:
1187 mutex_unlock(&cam->mutex);
1188
1189 return rval;
1190}
1191
1192static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1193{
1194 struct omap24xxcam_fh *ofh = fh;
1195 struct omap24xxcam_device *cam = ofh->cam;
1196 struct videobuf_queue *q = &ofh->vbq;
1197 int rval;
1198
1199 atomic_inc(&cam->reset_disable);
1200
1201 flush_work_sync(&cam->sensor_reset_work);
1202
1203 rval = videobuf_streamoff(q);
1204 if (!rval) {
1205 mutex_lock(&cam->mutex);
1206 cam->streaming = NULL;
1207 mutex_unlock(&cam->mutex);
1208 sysfs_notify(&cam->dev->kobj, NULL, "streaming");
1209 }
1210
1211 atomic_dec(&cam->reset_disable);
1212
1213 return rval;
1214}
1215
1216static int vidioc_enum_input(struct file *file, void *fh,
1217 struct v4l2_input *inp)
1218{
1219 if (inp->index > 0)
1220 return -EINVAL;
1221
1222 strlcpy(inp->name, "camera", sizeof(inp->name));
1223 inp->type = V4L2_INPUT_TYPE_CAMERA;
1224
1225 return 0;
1226}
1227
1228static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1229{
1230 *i = 0;
1231
1232 return 0;
1233}
1234
1235static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1236{
1237 if (i > 0)
1238 return -EINVAL;
1239
1240 return 0;
1241}
1242
1243static int vidioc_queryctrl(struct file *file, void *fh,
1244 struct v4l2_queryctrl *a)
1245{
1246 struct omap24xxcam_fh *ofh = fh;
1247 struct omap24xxcam_device *cam = ofh->cam;
1248 int rval;
1249
1250 rval = vidioc_int_queryctrl(cam->sdev, a);
1251
1252 return rval;
1253}
1254
1255static int vidioc_g_ctrl(struct file *file, void *fh,
1256 struct v4l2_control *a)
1257{
1258 struct omap24xxcam_fh *ofh = fh;
1259 struct omap24xxcam_device *cam = ofh->cam;
1260 int rval;
1261
1262 mutex_lock(&cam->mutex);
1263 rval = vidioc_int_g_ctrl(cam->sdev, a);
1264 mutex_unlock(&cam->mutex);
1265
1266 return rval;
1267}
1268
1269static int vidioc_s_ctrl(struct file *file, void *fh,
1270 struct v4l2_control *a)
1271{
1272 struct omap24xxcam_fh *ofh = fh;
1273 struct omap24xxcam_device *cam = ofh->cam;
1274 int rval;
1275
1276 mutex_lock(&cam->mutex);
1277 rval = vidioc_int_s_ctrl(cam->sdev, a);
1278 mutex_unlock(&cam->mutex);
1279
1280 return rval;
1281}
1282
1283static int vidioc_g_parm(struct file *file, void *fh,
1284 struct v4l2_streamparm *a) {
1285 struct omap24xxcam_fh *ofh = fh;
1286 struct omap24xxcam_device *cam = ofh->cam;
1287 int rval;
1288
1289 mutex_lock(&cam->mutex);
1290 rval = vidioc_int_g_parm(cam->sdev, a);
1291 mutex_unlock(&cam->mutex);
1292
1293 return rval;
1294}
1295
1296static int vidioc_s_parm(struct file *file, void *fh,
1297 struct v4l2_streamparm *a)
1298{
1299 struct omap24xxcam_fh *ofh = fh;
1300 struct omap24xxcam_device *cam = ofh->cam;
1301 struct v4l2_streamparm old_streamparm;
1302 int rval;
1303
1304 mutex_lock(&cam->mutex);
1305 if (cam->streaming) {
1306 rval = -EBUSY;
1307 goto out;
1308 }
1309
1310 old_streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1311 rval = vidioc_int_g_parm(cam->sdev, &old_streamparm);
1312 if (rval)
1313 goto out;
1314
1315 rval = vidioc_int_s_parm(cam->sdev, a);
1316 if (rval)
1317 goto out;
1318
1319 rval = omap24xxcam_sensor_if_enable(cam);
1320 /*
1321 * Revert to old streaming parameters if enabling sensor
1322 * interface with the new ones failed.
1323 */
1324 if (rval)
1325 vidioc_int_s_parm(cam->sdev, &old_streamparm);
1326
1327out:
1328 mutex_unlock(&cam->mutex);
1329
1330 return rval;
1331}
1332
1333/*
1334 *
1335 * File operations.
1336 *
1337 */
1338
1339static unsigned int omap24xxcam_poll(struct file *file,
1340 struct poll_table_struct *wait)
1341{
1342 struct omap24xxcam_fh *fh = file->private_data;
1343 struct omap24xxcam_device *cam = fh->cam;
1344 struct videobuf_buffer *vb;
1345
1346 mutex_lock(&cam->mutex);
1347 if (cam->streaming != file) {
1348 mutex_unlock(&cam->mutex);
1349 return POLLERR;
1350 }
1351 mutex_unlock(&cam->mutex);
1352
1353 mutex_lock(&fh->vbq.vb_lock);
1354 if (list_empty(&fh->vbq.stream)) {
1355 mutex_unlock(&fh->vbq.vb_lock);
1356 return POLLERR;
1357 }
1358 vb = list_entry(fh->vbq.stream.next, struct videobuf_buffer, stream);
1359 mutex_unlock(&fh->vbq.vb_lock);
1360
1361 poll_wait(file, &vb->done, wait);
1362
1363 if (vb->state == VIDEOBUF_DONE || vb->state == VIDEOBUF_ERROR)
1364 return POLLIN | POLLRDNORM;
1365
1366 return 0;
1367}
1368
1369static int omap24xxcam_mmap_buffers(struct file *file,
1370 struct vm_area_struct *vma)
1371{
1372 struct omap24xxcam_fh *fh = file->private_data;
1373 struct omap24xxcam_device *cam = fh->cam;
1374 struct videobuf_queue *vbq = &fh->vbq;
1375 unsigned int first, last, size, i, j;
1376 int err = 0;
1377
1378 mutex_lock(&cam->mutex);
1379 if (cam->streaming) {
1380 mutex_unlock(&cam->mutex);
1381 return -EBUSY;
1382 }
1383 mutex_unlock(&cam->mutex);
1384 mutex_lock(&vbq->vb_lock);
1385
1386 /* look for first buffer to map */
1387 for (first = 0; first < VIDEO_MAX_FRAME; first++) {
1388 if (NULL == vbq->bufs[first])
1389 continue;
1390 if (V4L2_MEMORY_MMAP != vbq->bufs[first]->memory)
1391 continue;
1392 if (vbq->bufs[first]->boff == (vma->vm_pgoff << PAGE_SHIFT))
1393 break;
1394 }
1395
1396 /* look for last buffer to map */
1397 for (size = 0, last = first; last < VIDEO_MAX_FRAME; last++) {
1398 if (NULL == vbq->bufs[last])
1399 continue;
1400 if (V4L2_MEMORY_MMAP != vbq->bufs[last]->memory)
1401 continue;
1402 size += vbq->bufs[last]->bsize;
1403 if (size == (vma->vm_end - vma->vm_start))
1404 break;
1405 }
1406
1407 size = 0;
1408 for (i = first; i <= last && i < VIDEO_MAX_FRAME; i++) {
1409 struct videobuf_dmabuf *dma = videobuf_to_dma(vbq->bufs[i]);
1410
1411 for (j = 0; j < dma->sglen; j++) {
1412 err = remap_pfn_range(
1413 vma, vma->vm_start + size,
1414 page_to_pfn(sg_page(&dma->sglist[j])),
1415 sg_dma_len(&dma->sglist[j]), vma->vm_page_prot);
1416 if (err)
1417 goto out;
1418 size += sg_dma_len(&dma->sglist[j]);
1419 }
1420 }
1421
1422out:
1423 mutex_unlock(&vbq->vb_lock);
1424
1425 return err;
1426}
1427
1428static int omap24xxcam_mmap(struct file *file, struct vm_area_struct *vma)
1429{
1430 struct omap24xxcam_fh *fh = file->private_data;
1431 int rval;
1432
1433 /* let the video-buf mapper check arguments and set-up structures */
1434 rval = videobuf_mmap_mapper(&fh->vbq, vma);
1435 if (rval)
1436 return rval;
1437
1438 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1439
1440 /* do mapping to our allocated buffers */
1441 rval = omap24xxcam_mmap_buffers(file, vma);
1442 /*
1443 * In case of error, free vma->vm_private_data allocated by
1444 * videobuf_mmap_mapper.
1445 */
1446 if (rval)
1447 kfree(vma->vm_private_data);
1448
1449 return rval;
1450}
1451
1452static int omap24xxcam_open(struct file *file)
1453{
1454 struct omap24xxcam_device *cam = omap24xxcam.priv;
1455 struct omap24xxcam_fh *fh;
1456 struct v4l2_format format;
1457
1458 if (!cam || !cam->vfd)
1459 return -ENODEV;
1460
1461 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1462 if (fh == NULL)
1463 return -ENOMEM;
1464
1465 mutex_lock(&cam->mutex);
1466 if (cam->sdev == NULL || !try_module_get(cam->sdev->module)) {
1467 mutex_unlock(&cam->mutex);
1468 goto out_try_module_get;
1469 }
1470
1471 if (atomic_inc_return(&cam->users) == 1) {
1472 omap24xxcam_hwinit(cam);
1473 if (omap24xxcam_sensor_enable(cam)) {
1474 mutex_unlock(&cam->mutex);
1475 goto out_omap24xxcam_sensor_enable;
1476 }
1477 }
1478 mutex_unlock(&cam->mutex);
1479
1480 fh->cam = cam;
1481 mutex_lock(&cam->mutex);
1482 vidioc_int_g_fmt_cap(cam->sdev, &format);
1483 mutex_unlock(&cam->mutex);
1484 /* FIXME: how about fh->pix when there are more users? */
1485 fh->pix = format.fmt.pix;
1486
1487 file->private_data = fh;
1488
1489 spin_lock_init(&fh->vbq_lock);
1490
1491 videobuf_queue_sg_init(&fh->vbq, &omap24xxcam_vbq_ops, NULL,
1492 &fh->vbq_lock, V4L2_BUF_TYPE_VIDEO_CAPTURE,
1493 V4L2_FIELD_NONE,
1494 sizeof(struct videobuf_buffer), fh, NULL);
1495
1496 return 0;
1497
1498out_omap24xxcam_sensor_enable:
1499 omap24xxcam_poweron_reset(cam);
1500 module_put(cam->sdev->module);
1501
1502out_try_module_get:
1503 kfree(fh);
1504
1505 return -ENODEV;
1506}
1507
1508static int omap24xxcam_release(struct file *file)
1509{
1510 struct omap24xxcam_fh *fh = file->private_data;
1511 struct omap24xxcam_device *cam = fh->cam;
1512
1513 atomic_inc(&cam->reset_disable);
1514
1515 flush_work_sync(&cam->sensor_reset_work);
1516
1517 /* stop streaming capture */
1518 videobuf_streamoff(&fh->vbq);
1519
1520 mutex_lock(&cam->mutex);
1521 if (cam->streaming == file) {
1522 cam->streaming = NULL;
1523 mutex_unlock(&cam->mutex);
1524 sysfs_notify(&cam->dev->kobj, NULL, "streaming");
1525 } else {
1526 mutex_unlock(&cam->mutex);
1527 }
1528
1529 atomic_dec(&cam->reset_disable);
1530
1531 omap24xxcam_vbq_free_mmap_buffers(&fh->vbq);
1532
1533 /*
1534 * Make sure the reset work we might have scheduled is not
1535 * pending! It may be run *only* if we have users. (And it may
1536 * not be scheduled anymore since streaming is already
1537 * disabled.)
1538 */
1539 flush_work_sync(&cam->sensor_reset_work);
1540
1541 mutex_lock(&cam->mutex);
1542 if (atomic_dec_return(&cam->users) == 0) {
1543 omap24xxcam_sensor_disable(cam);
1544 omap24xxcam_poweron_reset(cam);
1545 }
1546 mutex_unlock(&cam->mutex);
1547
1548 file->private_data = NULL;
1549
1550 module_put(cam->sdev->module);
1551 kfree(fh);
1552
1553 return 0;
1554}
1555
1556static struct v4l2_file_operations omap24xxcam_fops = {
1557 .ioctl = video_ioctl2,
1558 .poll = omap24xxcam_poll,
1559 .mmap = omap24xxcam_mmap,
1560 .open = omap24xxcam_open,
1561 .release = omap24xxcam_release,
1562};
1563
1564/*
1565 *
1566 * Power management.
1567 *
1568 */
1569
1570#ifdef CONFIG_PM
1571static int omap24xxcam_suspend(struct platform_device *pdev, pm_message_t state)
1572{
1573 struct omap24xxcam_device *cam = platform_get_drvdata(pdev);
1574
1575 if (atomic_read(&cam->users) == 0)
1576 return 0;
1577
1578 if (!atomic_read(&cam->reset_disable))
1579 omap24xxcam_capture_stop(cam);
1580
1581 omap24xxcam_sensor_disable(cam);
1582 omap24xxcam_poweron_reset(cam);
1583
1584 return 0;
1585}
1586
1587static int omap24xxcam_resume(struct platform_device *pdev)
1588{
1589 struct omap24xxcam_device *cam = platform_get_drvdata(pdev);
1590
1591 if (atomic_read(&cam->users) == 0)
1592 return 0;
1593
1594 omap24xxcam_hwinit(cam);
1595 omap24xxcam_sensor_enable(cam);
1596
1597 if (!atomic_read(&cam->reset_disable))
1598 omap24xxcam_capture_cont(cam);
1599
1600 return 0;
1601}
1602#endif /* CONFIG_PM */
1603
1604static const struct v4l2_ioctl_ops omap24xxcam_ioctl_fops = {
1605 .vidioc_querycap = vidioc_querycap,
1606 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1607 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1608 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1609 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1610 .vidioc_reqbufs = vidioc_reqbufs,
1611 .vidioc_querybuf = vidioc_querybuf,
1612 .vidioc_qbuf = vidioc_qbuf,
1613 .vidioc_dqbuf = vidioc_dqbuf,
1614 .vidioc_streamon = vidioc_streamon,
1615 .vidioc_streamoff = vidioc_streamoff,
1616 .vidioc_enum_input = vidioc_enum_input,
1617 .vidioc_g_input = vidioc_g_input,
1618 .vidioc_s_input = vidioc_s_input,
1619 .vidioc_queryctrl = vidioc_queryctrl,
1620 .vidioc_g_ctrl = vidioc_g_ctrl,
1621 .vidioc_s_ctrl = vidioc_s_ctrl,
1622 .vidioc_g_parm = vidioc_g_parm,
1623 .vidioc_s_parm = vidioc_s_parm,
1624};
1625
1626/*
1627 *
1628 * Camera device (i.e. /dev/video).
1629 *
1630 */
1631
1632static int omap24xxcam_device_register(struct v4l2_int_device *s)
1633{
1634 struct omap24xxcam_device *cam = s->u.slave->master->priv;
1635 struct video_device *vfd;
1636 int rval;
1637
1638 /* We already have a slave. */
1639 if (cam->sdev)
1640 return -EBUSY;
1641
1642 cam->sdev = s;
1643
1644 if (device_create_file(cam->dev, &dev_attr_streaming) != 0) {
1645 dev_err(cam->dev, "could not register sysfs entry\n");
1646 rval = -EBUSY;
1647 goto err;
1648 }
1649
1650 /* initialize the video_device struct */
1651 vfd = cam->vfd = video_device_alloc();
1652 if (!vfd) {
1653 dev_err(cam->dev, "could not allocate video device struct\n");
1654 rval = -ENOMEM;
1655 goto err;
1656 }
1657 vfd->release = video_device_release;
1658
1659 vfd->parent = cam->dev;
1660
1661 strlcpy(vfd->name, CAM_NAME, sizeof(vfd->name));
1662 vfd->fops = &omap24xxcam_fops;
1663 vfd->ioctl_ops = &omap24xxcam_ioctl_fops;
1664
1665 omap24xxcam_hwinit(cam);
1666
1667 rval = omap24xxcam_sensor_init(cam);
1668 if (rval)
1669 goto err;
1670
1671 if (video_register_device(vfd, VFL_TYPE_GRABBER, video_nr) < 0) {
1672 dev_err(cam->dev, "could not register V4L device\n");
1673 rval = -EBUSY;
1674 goto err;
1675 }
1676
1677 omap24xxcam_poweron_reset(cam);
1678
1679 dev_info(cam->dev, "registered device %s\n",
1680 video_device_node_name(vfd));
1681
1682 return 0;
1683
1684err:
1685 omap24xxcam_device_unregister(s);
1686
1687 return rval;
1688}
1689
1690static void omap24xxcam_device_unregister(struct v4l2_int_device *s)
1691{
1692 struct omap24xxcam_device *cam = s->u.slave->master->priv;
1693
1694 omap24xxcam_sensor_exit(cam);
1695
1696 if (cam->vfd) {
1697 if (!video_is_registered(cam->vfd)) {
1698 /*
1699 * The device was never registered, so release the
1700 * video_device struct directly.
1701 */
1702 video_device_release(cam->vfd);
1703 } else {
1704 /*
1705 * The unregister function will release the
1706 * video_device struct as well as
1707 * unregistering it.
1708 */
1709 video_unregister_device(cam->vfd);
1710 }
1711 cam->vfd = NULL;
1712 }
1713
1714 device_remove_file(cam->dev, &dev_attr_streaming);
1715
1716 cam->sdev = NULL;
1717}
1718
1719static struct v4l2_int_master omap24xxcam_master = {
1720 .attach = omap24xxcam_device_register,
1721 .detach = omap24xxcam_device_unregister,
1722};
1723
1724static struct v4l2_int_device omap24xxcam = {
1725 .module = THIS_MODULE,
1726 .name = CAM_NAME,
1727 .type = v4l2_int_type_master,
1728 .u = {
1729 .master = &omap24xxcam_master
1730 },
1731};
1732
1733/*
1734 *
1735 * Driver initialisation and deinitialisation.
1736 *
1737 */
1738
1739static int __devinit omap24xxcam_probe(struct platform_device *pdev)
1740{
1741 struct omap24xxcam_device *cam;
1742 struct resource *mem;
1743 int irq;
1744
1745 cam = kzalloc(sizeof(*cam), GFP_KERNEL);
1746 if (!cam) {
1747 dev_err(&pdev->dev, "could not allocate memory\n");
1748 goto err;
1749 }
1750
1751 platform_set_drvdata(pdev, cam);
1752
1753 cam->dev = &pdev->dev;
1754
1755 /*
1756 * Impose a lower limit on the amount of memory allocated for
1757 * capture. We require at least enough memory to double-buffer
1758 * QVGA (300KB).
1759 */
1760 if (capture_mem < 320 * 240 * 2 * 2)
1761 capture_mem = 320 * 240 * 2 * 2;
1762 cam->capture_mem = capture_mem;
1763
1764 /* request the mem region for the camera registers */
1765 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1766 if (!mem) {
1767 dev_err(cam->dev, "no mem resource?\n");
1768 goto err;
1769 }
1770 if (!request_mem_region(mem->start, resource_size(mem), pdev->name)) {
1771 dev_err(cam->dev,
1772 "cannot reserve camera register I/O region\n");
1773 goto err;
1774 }
1775 cam->mmio_base_phys = mem->start;
1776 cam->mmio_size = resource_size(mem);
1777
1778 /* map the region */
1779 cam->mmio_base = ioremap_nocache(cam->mmio_base_phys, cam->mmio_size);
1780 if (!cam->mmio_base) {
1781 dev_err(cam->dev, "cannot map camera register I/O region\n");
1782 goto err;
1783 }
1784
1785 irq = platform_get_irq(pdev, 0);
1786 if (irq <= 0) {
1787 dev_err(cam->dev, "no irq for camera?\n");
1788 goto err;
1789 }
1790
1791 /* install the interrupt service routine */
1792 if (request_irq(irq, omap24xxcam_isr, 0, CAM_NAME, cam)) {
1793 dev_err(cam->dev,
1794 "could not install interrupt service routine\n");
1795 goto err;
1796 }
1797 cam->irq = irq;
1798
1799 if (omap24xxcam_clock_get(cam))
1800 goto err;
1801
1802 INIT_WORK(&cam->sensor_reset_work, omap24xxcam_sensor_reset_work);
1803
1804 mutex_init(&cam->mutex);
1805 spin_lock_init(&cam->core_enable_disable_lock);
1806
1807 omap24xxcam_sgdma_init(&cam->sgdma,
1808 cam->mmio_base + CAMDMA_REG_OFFSET,
1809 omap24xxcam_stalled_dma_reset,
1810 (unsigned long)cam);
1811
1812 omap24xxcam.priv = cam;
1813
1814 if (v4l2_int_device_register(&omap24xxcam))
1815 goto err;
1816
1817 return 0;
1818
1819err:
1820 omap24xxcam_remove(pdev);
1821 return -ENODEV;
1822}
1823
1824static int omap24xxcam_remove(struct platform_device *pdev)
1825{
1826 struct omap24xxcam_device *cam = platform_get_drvdata(pdev);
1827
1828 if (!cam)
1829 return 0;
1830
1831 if (omap24xxcam.priv != NULL)
1832 v4l2_int_device_unregister(&omap24xxcam);
1833 omap24xxcam.priv = NULL;
1834
1835 omap24xxcam_clock_put(cam);
1836
1837 if (cam->irq) {
1838 free_irq(cam->irq, cam);
1839 cam->irq = 0;
1840 }
1841
1842 if (cam->mmio_base) {
1843 iounmap((void *)cam->mmio_base);
1844 cam->mmio_base = 0;
1845 }
1846
1847 if (cam->mmio_base_phys) {
1848 release_mem_region(cam->mmio_base_phys, cam->mmio_size);
1849 cam->mmio_base_phys = 0;
1850 }
1851
1852 kfree(cam);
1853
1854 return 0;
1855}
1856
1857static struct platform_driver omap24xxcam_driver = {
1858 .probe = omap24xxcam_probe,
1859 .remove = omap24xxcam_remove,
1860#ifdef CONFIG_PM
1861 .suspend = omap24xxcam_suspend,
1862 .resume = omap24xxcam_resume,
1863#endif
1864 .driver = {
1865 .name = CAM_NAME,
1866 .owner = THIS_MODULE,
1867 },
1868};
1869
1870module_platform_driver(omap24xxcam_driver);
1871
1872MODULE_AUTHOR("Sakari Ailus <sakari.ailus@nokia.com>");
1873MODULE_DESCRIPTION("OMAP24xx Video for Linux camera driver");
1874MODULE_LICENSE("GPL");
1875MODULE_VERSION(OMAP24XXCAM_VERSION);
1876module_param(video_nr, int, 0);
1877MODULE_PARM_DESC(video_nr,
1878 "Minor number for video device (-1 ==> auto assign)");
1879module_param(capture_mem, int, 0);
1880MODULE_PARM_DESC(capture_mem, "Maximum amount of memory for capture "
1881 "buffers (default 4800kiB)");