aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/platform/omap24xxcam.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2012-10-07 04:49:05 -0400
committerLinus Torvalds <torvalds@linux-foundation.org>2012-10-07 04:49:05 -0400
commit0b8e74c6f44094189dbe78baf4101acc7570c6af (patch)
tree6440561d09fb71ba5928664604ec92f29940be6b /drivers/media/platform/omap24xxcam.c
parent7f60ba388f5b9dd8b0da463b394412dace3ab814 (diff)
parentbd0d10498826ed150da5e4c45baf8b9c7088fb71 (diff)
Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media
Pull media updates from Mauro Carvalho Chehab: "The first part of the media updates for Kernel 3.7. This series contain: - A major tree renaming patch series: now, drivers are organized internally by their used bus, instead of by V4L2 and/or DVB API, providing a cleaner driver location for hybrid drivers that implement both APIs, and allowing to cleanup the Kconfig items and make them more intuitive for the end user; - Media Kernel developers are typically very lazy with their duties of keeping the MAINTAINERS entries for their drivers updated. As now the tree is more organized, we're doing an effort to add/update those entries for the drivers that aren't currently orphan; - Several DVB USB drivers got moved to a new DVB USB v2 core; the new core fixes several bugs (as the existing one that got bitroted). Now, suspend/resume finally started to work fine (at least with some devices - we should expect more work with regards to it); - added multistream support for DVB-T2, and unified the API for DVB-S2 and ISDB-S. Backward binary support is preserved; - as usual, a few new drivers, some V4L2 core improvements and lots of drivers improvements and fixes. There are some points to notice on this series: 1) you should expect a trivial merge conflict on your tree, with the removal of Documentation/feature-removal-schedule.txt: this series would be adding two additional entries there. I opted to not rebase it due to this recent change; 2) With regards to the PCTV 520e udev-related breakage, I opted to fix it in a way that the patches can be backported to 3.5 even without your firmware fix patch. This way, Greg doesn't need to rush backporting your patch (as there are still the firmware cache and firmware path customization issues to be addressed there). I'll send later a patch (likely after the end of the merge window) reverting the rest of the DRX-K async firmware request, fully restoring its original behaviour to allow media drivers to initialize everything serialized as before for 3.7 and upper. 3) I'm planning to work on this weekend to test the DMABUF patches for V4L2. The patches are on my queue for several Kernel cycles, but, up to now, there is/was no way to test the series locally. I have some concerns about this particular changeset with regards to security issues, and with regards to the replacement of the old VIDIOC_OVERLAY ioctl's that is broken on modern systems, due to GPU drivers change. The Overlay API allows direct PCI2PCI transfers from a media capture card into the GPU framebuffer, but its API is crappy. Also, the only existing X11 driver that implements it requires a XV extension that is not available anymore on modern drivers. The DMABUF can do the same thing, but with it is promising to be a properly-designed API. If I can successfully test this series and be happy with it, I should be asking you to pull them next week." * 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (717 commits) em28xx: regression fix: use DRX-K sync firmware requests on em28xx drxk: allow loading firmware synchrousnously em28xx: Make all em28xx extensions to be initialized asynchronously [media] tda18271: properly report read errors in tda18271_get_id [media] tda18271: delay IR & RF calibration until init() if delay_cal is set [media] MAINTAINERS: add Michael Krufky as tda827x maintainer [media] MAINTAINERS: add Michael Krufky as tda8290 maintainer [media] MAINTAINERS: add Michael Krufky as cxusb maintainer [media] MAINTAINERS: add Michael Krufky as lg2160 maintainer [media] MAINTAINERS: add Michael Krufky as lgdt3305 maintainer [media] MAINTAINERS: add Michael Krufky as mxl111sf maintainer [media] MAINTAINERS: add Michael Krufky as mxl5007t maintainer [media] MAINTAINERS: add Michael Krufky as tda18271 maintainer [media] s5p-tv: Report only multi-plane capabilities in vidioc_querycap [media] s5p-mfc: Fix misplaced return statement in s5p_mfc_suspend() [media] exynos-gsc: Add missing static storage class specifiers [media] exynos-gsc: Remove <linux/version.h> header file inclusion [media] s5p-fimc: Fix incorrect condition in fimc_lite_reqbufs() [media] s5p-tv: Fix potential NULL pointer dereference error [media] s5k6aa: Fix possible NULL pointer dereference ...
Diffstat (limited to 'drivers/media/platform/omap24xxcam.c')
-rw-r--r--drivers/media/platform/omap24xxcam.c1881
1 files changed, 1881 insertions, 0 deletions
diff --git a/drivers/media/platform/omap24xxcam.c b/drivers/media/platform/omap24xxcam.c
new file mode 100644
index 000000000000..70f45c381318
--- /dev/null
+++ b/drivers/media/platform/omap24xxcam.c
@@ -0,0 +1,1881 @@
1/*
2 * drivers/media/platform/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(&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(&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(&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)");
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-15 14:34:17 -0400