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