[media] marvell-cam: Basic working MMP camera driver
[linux-2.6.git] / drivers / media / video / marvell-ccic / mcam-core.c
1 /*
2  * The Marvell camera core.  This device appears in a number of settings,
3  * so it needs platform-specific support outside of the core.
4  *
5  * Copyright 2011 Jonathan Corbet corbet@lwn.net
6  */
7 #include <linux/kernel.h>
8 #include <linux/module.h>
9 #include <linux/fs.h>
10 #include <linux/mm.h>
11 #include <linux/i2c.h>
12 #include <linux/interrupt.h>
13 #include <linux/spinlock.h>
14 #include <linux/videodev2.h>
15 #include <linux/slab.h>
16 #include <media/v4l2-device.h>
17 #include <media/v4l2-ioctl.h>
18 #include <media/v4l2-chip-ident.h>
19 #include <media/ov7670.h>
20 #include <linux/device.h>
21 #include <linux/wait.h>
22 #include <linux/list.h>
23 #include <linux/dma-mapping.h>
24 #include <linux/delay.h>
25 #include <linux/jiffies.h>
26 #include <linux/vmalloc.h>
27 #include <linux/uaccess.h>
28 #include <linux/io.h>
29
30 #include "mcam-core.h"
31
32
33 /*
34  * Internal DMA buffer management.  Since the controller cannot do S/G I/O,
35  * we must have physically contiguous buffers to bring frames into.
36  * These parameters control how many buffers we use, whether we
37  * allocate them at load time (better chance of success, but nails down
38  * memory) or when somebody tries to use the camera (riskier), and,
39  * for load-time allocation, how big they should be.
40  *
41  * The controller can cycle through three buffers.  We could use
42  * more by flipping pointers around, but it probably makes little
43  * sense.
44  */
45
46 static int alloc_bufs_at_read;
47 module_param(alloc_bufs_at_read, bool, 0444);
48 MODULE_PARM_DESC(alloc_bufs_at_read,
49                 "Non-zero value causes DMA buffers to be allocated when the "
50                 "video capture device is read, rather than at module load "
51                 "time.  This saves memory, but decreases the chances of "
52                 "successfully getting those buffers.");
53
54 static int n_dma_bufs = 3;
55 module_param(n_dma_bufs, uint, 0644);
56 MODULE_PARM_DESC(n_dma_bufs,
57                 "The number of DMA buffers to allocate.  Can be either two "
58                 "(saves memory, makes timing tighter) or three.");
59
60 static int dma_buf_size = VGA_WIDTH * VGA_HEIGHT * 2;  /* Worst case */
61 module_param(dma_buf_size, uint, 0444);
62 MODULE_PARM_DESC(dma_buf_size,
63                 "The size of the allocated DMA buffers.  If actual operating "
64                 "parameters require larger buffers, an attempt to reallocate "
65                 "will be made.");
66
67 static int min_buffers = 1;
68 module_param(min_buffers, uint, 0644);
69 MODULE_PARM_DESC(min_buffers,
70                 "The minimum number of streaming I/O buffers we are willing "
71                 "to work with.");
72
73 static int max_buffers = 10;
74 module_param(max_buffers, uint, 0644);
75 MODULE_PARM_DESC(max_buffers,
76                 "The maximum number of streaming I/O buffers an application "
77                 "will be allowed to allocate.  These buffers are big and live "
78                 "in vmalloc space.");
79
80 static int flip;
81 module_param(flip, bool, 0444);
82 MODULE_PARM_DESC(flip,
83                 "If set, the sensor will be instructed to flip the image "
84                 "vertically.");
85
86 /*
87  * Status flags.  Always manipulated with bit operations.
88  */
89 #define CF_BUF0_VALID    0      /* Buffers valid - first three */
90 #define CF_BUF1_VALID    1
91 #define CF_BUF2_VALID    2
92 #define CF_DMA_ACTIVE    3      /* A frame is incoming */
93 #define CF_CONFIG_NEEDED 4      /* Must configure hardware */
94
95 #define sensor_call(cam, o, f, args...) \
96         v4l2_subdev_call(cam->sensor, o, f, ##args)
97
98 static struct mcam_format_struct {
99         __u8 *desc;
100         __u32 pixelformat;
101         int bpp;   /* Bytes per pixel */
102         enum v4l2_mbus_pixelcode mbus_code;
103 } mcam_formats[] = {
104         {
105                 .desc           = "YUYV 4:2:2",
106                 .pixelformat    = V4L2_PIX_FMT_YUYV,
107                 .mbus_code      = V4L2_MBUS_FMT_YUYV8_2X8,
108                 .bpp            = 2,
109         },
110         {
111                 .desc           = "RGB 444",
112                 .pixelformat    = V4L2_PIX_FMT_RGB444,
113                 .mbus_code      = V4L2_MBUS_FMT_RGB444_2X8_PADHI_LE,
114                 .bpp            = 2,
115         },
116         {
117                 .desc           = "RGB 565",
118                 .pixelformat    = V4L2_PIX_FMT_RGB565,
119                 .mbus_code      = V4L2_MBUS_FMT_RGB565_2X8_LE,
120                 .bpp            = 2,
121         },
122         {
123                 .desc           = "Raw RGB Bayer",
124                 .pixelformat    = V4L2_PIX_FMT_SBGGR8,
125                 .mbus_code      = V4L2_MBUS_FMT_SBGGR8_1X8,
126                 .bpp            = 1
127         },
128 };
129 #define N_MCAM_FMTS ARRAY_SIZE(mcam_formats)
130
131 static struct mcam_format_struct *mcam_find_format(u32 pixelformat)
132 {
133         unsigned i;
134
135         for (i = 0; i < N_MCAM_FMTS; i++)
136                 if (mcam_formats[i].pixelformat == pixelformat)
137                         return mcam_formats + i;
138         /* Not found? Then return the first format. */
139         return mcam_formats;
140 }
141
142 /*
143  * Start over with DMA buffers - dev_lock needed.
144  */
145 static void mcam_reset_buffers(struct mcam_camera *cam)
146 {
147         int i;
148
149         cam->next_buf = -1;
150         for (i = 0; i < cam->nbufs; i++)
151                 clear_bit(i, &cam->flags);
152         cam->specframes = 0;
153 }
154
155 static inline int mcam_needs_config(struct mcam_camera *cam)
156 {
157         return test_bit(CF_CONFIG_NEEDED, &cam->flags);
158 }
159
160 static void mcam_set_config_needed(struct mcam_camera *cam, int needed)
161 {
162         if (needed)
163                 set_bit(CF_CONFIG_NEEDED, &cam->flags);
164         else
165                 clear_bit(CF_CONFIG_NEEDED, &cam->flags);
166 }
167
168
169 /*
170  * Debugging and related.
171  */
172 #define cam_err(cam, fmt, arg...) \
173         dev_err((cam)->dev, fmt, ##arg);
174 #define cam_warn(cam, fmt, arg...) \
175         dev_warn((cam)->dev, fmt, ##arg);
176 #define cam_dbg(cam, fmt, arg...) \
177         dev_dbg((cam)->dev, fmt, ##arg);
178
179
180
181 /* ------------------------------------------------------------------- */
182 /*
183  * Deal with the controller.
184  */
185
186 /*
187  * Do everything we think we need to have the interface operating
188  * according to the desired format.
189  */
190 static void mcam_ctlr_dma(struct mcam_camera *cam)
191 {
192         /*
193          * Store the first two Y buffers (we aren't supporting
194          * planar formats for now, so no UV bufs).  Then either
195          * set the third if it exists, or tell the controller
196          * to just use two.
197          */
198         mcam_reg_write(cam, REG_Y0BAR, cam->dma_handles[0]);
199         mcam_reg_write(cam, REG_Y1BAR, cam->dma_handles[1]);
200         if (cam->nbufs > 2) {
201                 mcam_reg_write(cam, REG_Y2BAR, cam->dma_handles[2]);
202                 mcam_reg_clear_bit(cam, REG_CTRL1, C1_TWOBUFS);
203         } else
204                 mcam_reg_set_bit(cam, REG_CTRL1, C1_TWOBUFS);
205         if (cam->chip_id == V4L2_IDENT_CAFE)
206                 mcam_reg_write(cam, REG_UBAR, 0); /* 32 bits only */
207 }
208
209 static void mcam_ctlr_image(struct mcam_camera *cam)
210 {
211         int imgsz;
212         struct v4l2_pix_format *fmt = &cam->pix_format;
213
214         imgsz = ((fmt->height << IMGSZ_V_SHIFT) & IMGSZ_V_MASK) |
215                 (fmt->bytesperline & IMGSZ_H_MASK);
216         mcam_reg_write(cam, REG_IMGSIZE, imgsz);
217         mcam_reg_write(cam, REG_IMGOFFSET, 0);
218         /* YPITCH just drops the last two bits */
219         mcam_reg_write_mask(cam, REG_IMGPITCH, fmt->bytesperline,
220                         IMGP_YP_MASK);
221         /*
222          * Tell the controller about the image format we are using.
223          */
224         switch (cam->pix_format.pixelformat) {
225         case V4L2_PIX_FMT_YUYV:
226             mcam_reg_write_mask(cam, REG_CTRL0,
227                             C0_DF_YUV|C0_YUV_PACKED|C0_YUVE_YUYV,
228                             C0_DF_MASK);
229             break;
230
231         case V4L2_PIX_FMT_RGB444:
232             mcam_reg_write_mask(cam, REG_CTRL0,
233                             C0_DF_RGB|C0_RGBF_444|C0_RGB4_XRGB,
234                             C0_DF_MASK);
235                 /* Alpha value? */
236             break;
237
238         case V4L2_PIX_FMT_RGB565:
239             mcam_reg_write_mask(cam, REG_CTRL0,
240                             C0_DF_RGB|C0_RGBF_565|C0_RGB5_BGGR,
241                             C0_DF_MASK);
242             break;
243
244         default:
245             cam_err(cam, "Unknown format %x\n", cam->pix_format.pixelformat);
246             break;
247         }
248         /*
249          * Make sure it knows we want to use hsync/vsync.
250          */
251         mcam_reg_write_mask(cam, REG_CTRL0, C0_SIF_HVSYNC,
252                         C0_SIFM_MASK);
253 }
254
255
256 /*
257  * Configure the controller for operation; caller holds the
258  * device mutex.
259  */
260 static int mcam_ctlr_configure(struct mcam_camera *cam)
261 {
262         unsigned long flags;
263
264         spin_lock_irqsave(&cam->dev_lock, flags);
265         mcam_ctlr_dma(cam);
266         mcam_ctlr_image(cam);
267         mcam_set_config_needed(cam, 0);
268         spin_unlock_irqrestore(&cam->dev_lock, flags);
269         return 0;
270 }
271
272 static void mcam_ctlr_irq_enable(struct mcam_camera *cam)
273 {
274         /*
275          * Clear any pending interrupts, since we do not
276          * expect to have I/O active prior to enabling.
277          */
278         mcam_reg_write(cam, REG_IRQSTAT, FRAMEIRQS);
279         mcam_reg_set_bit(cam, REG_IRQMASK, FRAMEIRQS);
280 }
281
282 static void mcam_ctlr_irq_disable(struct mcam_camera *cam)
283 {
284         mcam_reg_clear_bit(cam, REG_IRQMASK, FRAMEIRQS);
285 }
286
287 /*
288  * Make the controller start grabbing images.  Everything must
289  * be set up before doing this.
290  */
291 static void mcam_ctlr_start(struct mcam_camera *cam)
292 {
293         /* set_bit performs a read, so no other barrier should be
294            needed here */
295         mcam_reg_set_bit(cam, REG_CTRL0, C0_ENABLE);
296 }
297
298 static void mcam_ctlr_stop(struct mcam_camera *cam)
299 {
300         mcam_reg_clear_bit(cam, REG_CTRL0, C0_ENABLE);
301 }
302
303 static void mcam_ctlr_init(struct mcam_camera *cam)
304 {
305         unsigned long flags;
306
307         spin_lock_irqsave(&cam->dev_lock, flags);
308         /*
309          * Make sure it's not powered down.
310          */
311         mcam_reg_clear_bit(cam, REG_CTRL1, C1_PWRDWN);
312         /*
313          * Turn off the enable bit.  It sure should be off anyway,
314          * but it's good to be sure.
315          */
316         mcam_reg_clear_bit(cam, REG_CTRL0, C0_ENABLE);
317         /*
318          * Clock the sensor appropriately.  Controller clock should
319          * be 48MHz, sensor "typical" value is half that.
320          */
321         mcam_reg_write_mask(cam, REG_CLKCTRL, 2, CLK_DIV_MASK);
322         spin_unlock_irqrestore(&cam->dev_lock, flags);
323 }
324
325
326 /*
327  * Stop the controller, and don't return until we're really sure that no
328  * further DMA is going on.
329  */
330 static void mcam_ctlr_stop_dma(struct mcam_camera *cam)
331 {
332         unsigned long flags;
333
334         /*
335          * Theory: stop the camera controller (whether it is operating
336          * or not).  Delay briefly just in case we race with the SOF
337          * interrupt, then wait until no DMA is active.
338          */
339         spin_lock_irqsave(&cam->dev_lock, flags);
340         mcam_ctlr_stop(cam);
341         spin_unlock_irqrestore(&cam->dev_lock, flags);
342         mdelay(1);
343         wait_event_timeout(cam->iowait,
344                         !test_bit(CF_DMA_ACTIVE, &cam->flags), HZ);
345         if (test_bit(CF_DMA_ACTIVE, &cam->flags))
346                 cam_err(cam, "Timeout waiting for DMA to end\n");
347                 /* This would be bad news - what now? */
348         spin_lock_irqsave(&cam->dev_lock, flags);
349         cam->state = S_IDLE;
350         mcam_ctlr_irq_disable(cam);
351         spin_unlock_irqrestore(&cam->dev_lock, flags);
352 }
353
354 /*
355  * Power up and down.
356  */
357 static void mcam_ctlr_power_up(struct mcam_camera *cam)
358 {
359         unsigned long flags;
360
361         spin_lock_irqsave(&cam->dev_lock, flags);
362         cam->plat_power_up(cam);
363         mcam_reg_clear_bit(cam, REG_CTRL1, C1_PWRDWN);
364         spin_unlock_irqrestore(&cam->dev_lock, flags);
365         msleep(5); /* Just to be sure */
366 }
367
368 static void mcam_ctlr_power_down(struct mcam_camera *cam)
369 {
370         unsigned long flags;
371
372         spin_lock_irqsave(&cam->dev_lock, flags);
373         /*
374          * School of hard knocks department: be sure we do any register
375          * twiddling on the controller *before* calling the platform
376          * power down routine.
377          */
378         mcam_reg_set_bit(cam, REG_CTRL1, C1_PWRDWN);
379         cam->plat_power_down(cam);
380         spin_unlock_irqrestore(&cam->dev_lock, flags);
381 }
382
383 /* -------------------------------------------------------------------- */
384 /*
385  * Communications with the sensor.
386  */
387
388 static int __mcam_cam_reset(struct mcam_camera *cam)
389 {
390         return sensor_call(cam, core, reset, 0);
391 }
392
393 /*
394  * We have found the sensor on the i2c.  Let's try to have a
395  * conversation.
396  */
397 static int mcam_cam_init(struct mcam_camera *cam)
398 {
399         struct v4l2_dbg_chip_ident chip;
400         int ret;
401
402         mutex_lock(&cam->s_mutex);
403         if (cam->state != S_NOTREADY)
404                 cam_warn(cam, "Cam init with device in funky state %d",
405                                 cam->state);
406         ret = __mcam_cam_reset(cam);
407         if (ret)
408                 goto out;
409         chip.ident = V4L2_IDENT_NONE;
410         chip.match.type = V4L2_CHIP_MATCH_I2C_ADDR;
411         chip.match.addr = cam->sensor_addr;
412         ret = sensor_call(cam, core, g_chip_ident, &chip);
413         if (ret)
414                 goto out;
415         cam->sensor_type = chip.ident;
416         if (cam->sensor_type != V4L2_IDENT_OV7670) {
417                 cam_err(cam, "Unsupported sensor type 0x%x", cam->sensor_type);
418                 ret = -EINVAL;
419                 goto out;
420         }
421 /* Get/set parameters? */
422         ret = 0;
423         cam->state = S_IDLE;
424 out:
425         mcam_ctlr_power_down(cam);
426         mutex_unlock(&cam->s_mutex);
427         return ret;
428 }
429
430 /*
431  * Configure the sensor to match the parameters we have.  Caller should
432  * hold s_mutex
433  */
434 static int mcam_cam_set_flip(struct mcam_camera *cam)
435 {
436         struct v4l2_control ctrl;
437
438         memset(&ctrl, 0, sizeof(ctrl));
439         ctrl.id = V4L2_CID_VFLIP;
440         ctrl.value = flip;
441         return sensor_call(cam, core, s_ctrl, &ctrl);
442 }
443
444
445 static int mcam_cam_configure(struct mcam_camera *cam)
446 {
447         struct v4l2_mbus_framefmt mbus_fmt;
448         int ret;
449
450         v4l2_fill_mbus_format(&mbus_fmt, &cam->pix_format, cam->mbus_code);
451         ret = sensor_call(cam, core, init, 0);
452         if (ret == 0)
453                 ret = sensor_call(cam, video, s_mbus_fmt, &mbus_fmt);
454         /*
455          * OV7670 does weird things if flip is set *before* format...
456          */
457         ret += mcam_cam_set_flip(cam);
458         return ret;
459 }
460
461 /* -------------------------------------------------------------------- */
462 /*
463  * DMA buffer management.  These functions need s_mutex held.
464  */
465
466 /* FIXME: this is inefficient as hell, since dma_alloc_coherent just
467  * does a get_free_pages() call, and we waste a good chunk of an orderN
468  * allocation.  Should try to allocate the whole set in one chunk.
469  */
470 static int mcam_alloc_dma_bufs(struct mcam_camera *cam, int loadtime)
471 {
472         int i;
473
474         mcam_set_config_needed(cam, 1);
475         if (loadtime)
476                 cam->dma_buf_size = dma_buf_size;
477         else
478                 cam->dma_buf_size = cam->pix_format.sizeimage;
479         if (n_dma_bufs > 3)
480                 n_dma_bufs = 3;
481
482         cam->nbufs = 0;
483         for (i = 0; i < n_dma_bufs; i++) {
484                 cam->dma_bufs[i] = dma_alloc_coherent(cam->dev,
485                                 cam->dma_buf_size, cam->dma_handles + i,
486                                 GFP_KERNEL);
487                 if (cam->dma_bufs[i] == NULL) {
488                         cam_warn(cam, "Failed to allocate DMA buffer\n");
489                         break;
490                 }
491                 /* For debug, remove eventually */
492                 memset(cam->dma_bufs[i], 0xcc, cam->dma_buf_size);
493                 (cam->nbufs)++;
494         }
495
496         switch (cam->nbufs) {
497         case 1:
498                 dma_free_coherent(cam->dev, cam->dma_buf_size,
499                                 cam->dma_bufs[0], cam->dma_handles[0]);
500                 cam->nbufs = 0;
501         case 0:
502                 cam_err(cam, "Insufficient DMA buffers, cannot operate\n");
503                 return -ENOMEM;
504
505         case 2:
506                 if (n_dma_bufs > 2)
507                         cam_warn(cam, "Will limp along with only 2 buffers\n");
508                 break;
509         }
510         return 0;
511 }
512
513 static void mcam_free_dma_bufs(struct mcam_camera *cam)
514 {
515         int i;
516
517         for (i = 0; i < cam->nbufs; i++) {
518                 dma_free_coherent(cam->dev, cam->dma_buf_size,
519                                 cam->dma_bufs[i], cam->dma_handles[i]);
520                 cam->dma_bufs[i] = NULL;
521         }
522         cam->nbufs = 0;
523 }
524
525
526
527
528
529 /* ----------------------------------------------------------------------- */
530 /*
531  * Here starts the V4L2 interface code.
532  */
533
534 /*
535  * Read an image from the device.
536  */
537 static ssize_t mcam_deliver_buffer(struct mcam_camera *cam,
538                 char __user *buffer, size_t len, loff_t *pos)
539 {
540         int bufno;
541         unsigned long flags;
542
543         spin_lock_irqsave(&cam->dev_lock, flags);
544         if (cam->next_buf < 0) {
545                 cam_err(cam, "deliver_buffer: No next buffer\n");
546                 spin_unlock_irqrestore(&cam->dev_lock, flags);
547                 return -EIO;
548         }
549         bufno = cam->next_buf;
550         clear_bit(bufno, &cam->flags);
551         if (++(cam->next_buf) >= cam->nbufs)
552                 cam->next_buf = 0;
553         if (!test_bit(cam->next_buf, &cam->flags))
554                 cam->next_buf = -1;
555         cam->specframes = 0;
556         spin_unlock_irqrestore(&cam->dev_lock, flags);
557
558         if (len > cam->pix_format.sizeimage)
559                 len = cam->pix_format.sizeimage;
560         if (copy_to_user(buffer, cam->dma_bufs[bufno], len))
561                 return -EFAULT;
562         (*pos) += len;
563         return len;
564 }
565
566 /*
567  * Get everything ready, and start grabbing frames.
568  */
569 static int mcam_read_setup(struct mcam_camera *cam, enum mcam_state state)
570 {
571         int ret;
572         unsigned long flags;
573
574         /*
575          * Configuration.  If we still don't have DMA buffers,
576          * make one last, desperate attempt.
577          */
578         if (cam->nbufs == 0)
579                 if (mcam_alloc_dma_bufs(cam, 0))
580                         return -ENOMEM;
581
582         if (mcam_needs_config(cam)) {
583                 mcam_cam_configure(cam);
584                 ret = mcam_ctlr_configure(cam);
585                 if (ret)
586                         return ret;
587         }
588
589         /*
590          * Turn it loose.
591          */
592         spin_lock_irqsave(&cam->dev_lock, flags);
593         mcam_reset_buffers(cam);
594         mcam_ctlr_irq_enable(cam);
595         cam->state = state;
596         mcam_ctlr_start(cam);
597         spin_unlock_irqrestore(&cam->dev_lock, flags);
598         return 0;
599 }
600
601
602 static ssize_t mcam_v4l_read(struct file *filp,
603                 char __user *buffer, size_t len, loff_t *pos)
604 {
605         struct mcam_camera *cam = filp->private_data;
606         int ret = 0;
607
608         /*
609          * Perhaps we're in speculative read mode and already
610          * have data?
611          */
612         mutex_lock(&cam->s_mutex);
613         if (cam->state == S_SPECREAD) {
614                 if (cam->next_buf >= 0) {
615                         ret = mcam_deliver_buffer(cam, buffer, len, pos);
616                         if (ret != 0)
617                                 goto out_unlock;
618                 }
619         } else if (cam->state == S_FLAKED || cam->state == S_NOTREADY) {
620                 ret = -EIO;
621                 goto out_unlock;
622         } else if (cam->state != S_IDLE) {
623                 ret = -EBUSY;
624                 goto out_unlock;
625         }
626
627         /*
628          * v4l2: multiple processes can open the device, but only
629          * one gets to grab data from it.
630          */
631         if (cam->owner && cam->owner != filp) {
632                 ret = -EBUSY;
633                 goto out_unlock;
634         }
635         cam->owner = filp;
636
637         /*
638          * Do setup if need be.
639          */
640         if (cam->state != S_SPECREAD) {
641                 ret = mcam_read_setup(cam, S_SINGLEREAD);
642                 if (ret)
643                         goto out_unlock;
644         }
645         /*
646          * Wait for something to happen.  This should probably
647          * be interruptible (FIXME).
648          */
649         wait_event_timeout(cam->iowait, cam->next_buf >= 0, HZ);
650         if (cam->next_buf < 0) {
651                 cam_err(cam, "read() operation timed out\n");
652                 mcam_ctlr_stop_dma(cam);
653                 ret = -EIO;
654                 goto out_unlock;
655         }
656         /*
657          * Give them their data and we should be done.
658          */
659         ret = mcam_deliver_buffer(cam, buffer, len, pos);
660
661 out_unlock:
662         mutex_unlock(&cam->s_mutex);
663         return ret;
664 }
665
666
667
668
669
670
671
672
673 /*
674  * Streaming I/O support.
675  */
676
677
678
679 static int mcam_vidioc_streamon(struct file *filp, void *priv,
680                 enum v4l2_buf_type type)
681 {
682         struct mcam_camera *cam = filp->private_data;
683         int ret = -EINVAL;
684
685         if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
686                 goto out;
687         mutex_lock(&cam->s_mutex);
688         if (cam->state != S_IDLE || cam->n_sbufs == 0)
689                 goto out_unlock;
690
691         cam->sequence = 0;
692         ret = mcam_read_setup(cam, S_STREAMING);
693
694 out_unlock:
695         mutex_unlock(&cam->s_mutex);
696 out:
697         return ret;
698 }
699
700
701 static int mcam_vidioc_streamoff(struct file *filp, void *priv,
702                 enum v4l2_buf_type type)
703 {
704         struct mcam_camera *cam = filp->private_data;
705         int ret = -EINVAL;
706
707         if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
708                 goto out;
709         mutex_lock(&cam->s_mutex);
710         if (cam->state != S_STREAMING)
711                 goto out_unlock;
712
713         mcam_ctlr_stop_dma(cam);
714         ret = 0;
715
716 out_unlock:
717         mutex_unlock(&cam->s_mutex);
718 out:
719         return ret;
720 }
721
722
723
724 static int mcam_setup_siobuf(struct mcam_camera *cam, int index)
725 {
726         struct mcam_sio_buffer *buf = cam->sb_bufs + index;
727
728         INIT_LIST_HEAD(&buf->list);
729         buf->v4lbuf.length = PAGE_ALIGN(cam->pix_format.sizeimage);
730         buf->buffer = vmalloc_user(buf->v4lbuf.length);
731         if (buf->buffer == NULL)
732                 return -ENOMEM;
733         buf->mapcount = 0;
734         buf->cam = cam;
735
736         buf->v4lbuf.index = index;
737         buf->v4lbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
738         buf->v4lbuf.field = V4L2_FIELD_NONE;
739         buf->v4lbuf.memory = V4L2_MEMORY_MMAP;
740         /*
741          * Offset: must be 32-bit even on a 64-bit system.  videobuf-dma-sg
742          * just uses the length times the index, but the spec warns
743          * against doing just that - vma merging problems.  So we
744          * leave a gap between each pair of buffers.
745          */
746         buf->v4lbuf.m.offset = 2*index*buf->v4lbuf.length;
747         return 0;
748 }
749
750 static int mcam_free_sio_buffers(struct mcam_camera *cam)
751 {
752         int i;
753
754         /*
755          * If any buffers are mapped, we cannot free them at all.
756          */
757         for (i = 0; i < cam->n_sbufs; i++)
758                 if (cam->sb_bufs[i].mapcount > 0)
759                         return -EBUSY;
760         /*
761          * OK, let's do it.
762          */
763         for (i = 0; i < cam->n_sbufs; i++)
764                 vfree(cam->sb_bufs[i].buffer);
765         cam->n_sbufs = 0;
766         kfree(cam->sb_bufs);
767         cam->sb_bufs = NULL;
768         INIT_LIST_HEAD(&cam->sb_avail);
769         INIT_LIST_HEAD(&cam->sb_full);
770         return 0;
771 }
772
773
774
775 static int mcam_vidioc_reqbufs(struct file *filp, void *priv,
776                 struct v4l2_requestbuffers *req)
777 {
778         struct mcam_camera *cam = filp->private_data;
779         int ret = 0;  /* Silence warning */
780
781         /*
782          * Make sure it's something we can do.  User pointers could be
783          * implemented without great pain, but that's not been done yet.
784          */
785         if (req->memory != V4L2_MEMORY_MMAP)
786                 return -EINVAL;
787         /*
788          * If they ask for zero buffers, they really want us to stop streaming
789          * (if it's happening) and free everything.  Should we check owner?
790          */
791         mutex_lock(&cam->s_mutex);
792         if (req->count == 0) {
793                 if (cam->state == S_STREAMING)
794                         mcam_ctlr_stop_dma(cam);
795                 ret = mcam_free_sio_buffers(cam);
796                 goto out;
797         }
798         /*
799          * Device needs to be idle and working.  We *could* try to do the
800          * right thing in S_SPECREAD by shutting things down, but it
801          * probably doesn't matter.
802          */
803         if (cam->state != S_IDLE || (cam->owner && cam->owner != filp)) {
804                 ret = -EBUSY;
805                 goto out;
806         }
807         cam->owner = filp;
808
809         if (req->count < min_buffers)
810                 req->count = min_buffers;
811         else if (req->count > max_buffers)
812                 req->count = max_buffers;
813         if (cam->n_sbufs > 0) {
814                 ret = mcam_free_sio_buffers(cam);
815                 if (ret)
816                         goto out;
817         }
818
819         cam->sb_bufs = kzalloc(req->count*sizeof(struct mcam_sio_buffer),
820                         GFP_KERNEL);
821         if (cam->sb_bufs == NULL) {
822                 ret = -ENOMEM;
823                 goto out;
824         }
825         for (cam->n_sbufs = 0; cam->n_sbufs < req->count; (cam->n_sbufs++)) {
826                 ret = mcam_setup_siobuf(cam, cam->n_sbufs);
827                 if (ret)
828                         break;
829         }
830
831         if (cam->n_sbufs == 0)  /* no luck at all - ret already set */
832                 kfree(cam->sb_bufs);
833         req->count = cam->n_sbufs;  /* In case of partial success */
834
835 out:
836         mutex_unlock(&cam->s_mutex);
837         return ret;
838 }
839
840
841 static int mcam_vidioc_querybuf(struct file *filp, void *priv,
842                 struct v4l2_buffer *buf)
843 {
844         struct mcam_camera *cam = filp->private_data;
845         int ret = -EINVAL;
846
847         mutex_lock(&cam->s_mutex);
848         if (buf->index >= cam->n_sbufs)
849                 goto out;
850         *buf = cam->sb_bufs[buf->index].v4lbuf;
851         ret = 0;
852 out:
853         mutex_unlock(&cam->s_mutex);
854         return ret;
855 }
856
857 static int mcam_vidioc_qbuf(struct file *filp, void *priv,
858                 struct v4l2_buffer *buf)
859 {
860         struct mcam_camera *cam = filp->private_data;
861         struct mcam_sio_buffer *sbuf;
862         int ret = -EINVAL;
863         unsigned long flags;
864
865         mutex_lock(&cam->s_mutex);
866         if (buf->index >= cam->n_sbufs)
867                 goto out;
868         sbuf = cam->sb_bufs + buf->index;
869         if (sbuf->v4lbuf.flags & V4L2_BUF_FLAG_QUEUED) {
870                 ret = 0; /* Already queued?? */
871                 goto out;
872         }
873         if (sbuf->v4lbuf.flags & V4L2_BUF_FLAG_DONE) {
874                 /* Spec doesn't say anything, seems appropriate tho */
875                 ret = -EBUSY;
876                 goto out;
877         }
878         sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_QUEUED;
879         spin_lock_irqsave(&cam->dev_lock, flags);
880         list_add(&sbuf->list, &cam->sb_avail);
881         spin_unlock_irqrestore(&cam->dev_lock, flags);
882         ret = 0;
883 out:
884         mutex_unlock(&cam->s_mutex);
885         return ret;
886 }
887
888 static int mcam_vidioc_dqbuf(struct file *filp, void *priv,
889                 struct v4l2_buffer *buf)
890 {
891         struct mcam_camera *cam = filp->private_data;
892         struct mcam_sio_buffer *sbuf;
893         int ret = -EINVAL;
894         unsigned long flags;
895
896         mutex_lock(&cam->s_mutex);
897         if (cam->state != S_STREAMING)
898                 goto out_unlock;
899         if (list_empty(&cam->sb_full) && filp->f_flags & O_NONBLOCK) {
900                 ret = -EAGAIN;
901                 goto out_unlock;
902         }
903
904         while (list_empty(&cam->sb_full) && cam->state == S_STREAMING) {
905                 mutex_unlock(&cam->s_mutex);
906                 if (wait_event_interruptible(cam->iowait,
907                                                 !list_empty(&cam->sb_full))) {
908                         ret = -ERESTARTSYS;
909                         goto out;
910                 }
911                 mutex_lock(&cam->s_mutex);
912         }
913
914         if (cam->state != S_STREAMING)
915                 ret = -EINTR;
916         else {
917                 spin_lock_irqsave(&cam->dev_lock, flags);
918                 /* Should probably recheck !list_empty() here */
919                 sbuf = list_entry(cam->sb_full.next,
920                                 struct mcam_sio_buffer, list);
921                 list_del_init(&sbuf->list);
922                 spin_unlock_irqrestore(&cam->dev_lock, flags);
923                 sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_DONE;
924                 *buf = sbuf->v4lbuf;
925                 ret = 0;
926         }
927
928 out_unlock:
929         mutex_unlock(&cam->s_mutex);
930 out:
931         return ret;
932 }
933
934
935
936 static void mcam_v4l_vm_open(struct vm_area_struct *vma)
937 {
938         struct mcam_sio_buffer *sbuf = vma->vm_private_data;
939         /*
940          * Locking: done under mmap_sem, so we don't need to
941          * go back to the camera lock here.
942          */
943         sbuf->mapcount++;
944 }
945
946
947 static void mcam_v4l_vm_close(struct vm_area_struct *vma)
948 {
949         struct mcam_sio_buffer *sbuf = vma->vm_private_data;
950
951         mutex_lock(&sbuf->cam->s_mutex);
952         sbuf->mapcount--;
953         /* Docs say we should stop I/O too... */
954         if (sbuf->mapcount == 0)
955                 sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_MAPPED;
956         mutex_unlock(&sbuf->cam->s_mutex);
957 }
958
959 static const struct vm_operations_struct mcam_v4l_vm_ops = {
960         .open = mcam_v4l_vm_open,
961         .close = mcam_v4l_vm_close
962 };
963
964
965 static int mcam_v4l_mmap(struct file *filp, struct vm_area_struct *vma)
966 {
967         struct mcam_camera *cam = filp->private_data;
968         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
969         int ret = -EINVAL;
970         int i;
971         struct mcam_sio_buffer *sbuf = NULL;
972
973         if (!(vma->vm_flags & VM_WRITE) || !(vma->vm_flags & VM_SHARED))
974                 return -EINVAL;
975         /*
976          * Find the buffer they are looking for.
977          */
978         mutex_lock(&cam->s_mutex);
979         for (i = 0; i < cam->n_sbufs; i++)
980                 if (cam->sb_bufs[i].v4lbuf.m.offset == offset) {
981                         sbuf = cam->sb_bufs + i;
982                         break;
983                 }
984         if (sbuf == NULL)
985                 goto out;
986
987         ret = remap_vmalloc_range(vma, sbuf->buffer, 0);
988         if (ret)
989                 goto out;
990         vma->vm_flags |= VM_DONTEXPAND;
991         vma->vm_private_data = sbuf;
992         vma->vm_ops = &mcam_v4l_vm_ops;
993         sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_MAPPED;
994         mcam_v4l_vm_open(vma);
995         ret = 0;
996 out:
997         mutex_unlock(&cam->s_mutex);
998         return ret;
999 }
1000
1001
1002
1003 static int mcam_v4l_open(struct file *filp)
1004 {
1005         struct mcam_camera *cam = video_drvdata(filp);
1006
1007         filp->private_data = cam;
1008
1009         mutex_lock(&cam->s_mutex);
1010         if (cam->users == 0) {
1011                 mcam_ctlr_power_up(cam);
1012                 __mcam_cam_reset(cam);
1013                 mcam_set_config_needed(cam, 1);
1014         /* FIXME make sure this is complete */
1015         }
1016         (cam->users)++;
1017         mutex_unlock(&cam->s_mutex);
1018         return 0;
1019 }
1020
1021
1022 static int mcam_v4l_release(struct file *filp)
1023 {
1024         struct mcam_camera *cam = filp->private_data;
1025
1026         mutex_lock(&cam->s_mutex);
1027         (cam->users)--;
1028         if (filp == cam->owner) {
1029                 mcam_ctlr_stop_dma(cam);
1030                 mcam_free_sio_buffers(cam);
1031                 cam->owner = NULL;
1032         }
1033         if (cam->users == 0) {
1034                 mcam_ctlr_power_down(cam);
1035                 if (alloc_bufs_at_read)
1036                         mcam_free_dma_bufs(cam);
1037         }
1038         mutex_unlock(&cam->s_mutex);
1039         return 0;
1040 }
1041
1042
1043
1044 static unsigned int mcam_v4l_poll(struct file *filp,
1045                 struct poll_table_struct *pt)
1046 {
1047         struct mcam_camera *cam = filp->private_data;
1048
1049         poll_wait(filp, &cam->iowait, pt);
1050         if (cam->next_buf >= 0)
1051                 return POLLIN | POLLRDNORM;
1052         return 0;
1053 }
1054
1055
1056
1057 static int mcam_vidioc_queryctrl(struct file *filp, void *priv,
1058                 struct v4l2_queryctrl *qc)
1059 {
1060         struct mcam_camera *cam = priv;
1061         int ret;
1062
1063         mutex_lock(&cam->s_mutex);
1064         ret = sensor_call(cam, core, queryctrl, qc);
1065         mutex_unlock(&cam->s_mutex);
1066         return ret;
1067 }
1068
1069
1070 static int mcam_vidioc_g_ctrl(struct file *filp, void *priv,
1071                 struct v4l2_control *ctrl)
1072 {
1073         struct mcam_camera *cam = priv;
1074         int ret;
1075
1076         mutex_lock(&cam->s_mutex);
1077         ret = sensor_call(cam, core, g_ctrl, ctrl);
1078         mutex_unlock(&cam->s_mutex);
1079         return ret;
1080 }
1081
1082
1083 static int mcam_vidioc_s_ctrl(struct file *filp, void *priv,
1084                 struct v4l2_control *ctrl)
1085 {
1086         struct mcam_camera *cam = priv;
1087         int ret;
1088
1089         mutex_lock(&cam->s_mutex);
1090         ret = sensor_call(cam, core, s_ctrl, ctrl);
1091         mutex_unlock(&cam->s_mutex);
1092         return ret;
1093 }
1094
1095
1096
1097
1098
1099 static int mcam_vidioc_querycap(struct file *file, void *priv,
1100                 struct v4l2_capability *cap)
1101 {
1102         strcpy(cap->driver, "marvell_ccic");
1103         strcpy(cap->card, "marvell_ccic");
1104         cap->version = 1;
1105         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
1106                 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
1107         return 0;
1108 }
1109
1110
1111 /*
1112  * The default format we use until somebody says otherwise.
1113  */
1114 static const struct v4l2_pix_format mcam_def_pix_format = {
1115         .width          = VGA_WIDTH,
1116         .height         = VGA_HEIGHT,
1117         .pixelformat    = V4L2_PIX_FMT_YUYV,
1118         .field          = V4L2_FIELD_NONE,
1119         .bytesperline   = VGA_WIDTH*2,
1120         .sizeimage      = VGA_WIDTH*VGA_HEIGHT*2,
1121 };
1122
1123 static const enum v4l2_mbus_pixelcode mcam_def_mbus_code =
1124                                         V4L2_MBUS_FMT_YUYV8_2X8;
1125
1126 static int mcam_vidioc_enum_fmt_vid_cap(struct file *filp,
1127                 void *priv, struct v4l2_fmtdesc *fmt)
1128 {
1129         if (fmt->index >= N_MCAM_FMTS)
1130                 return -EINVAL;
1131         strlcpy(fmt->description, mcam_formats[fmt->index].desc,
1132                         sizeof(fmt->description));
1133         fmt->pixelformat = mcam_formats[fmt->index].pixelformat;
1134         return 0;
1135 }
1136
1137 static int mcam_vidioc_try_fmt_vid_cap(struct file *filp, void *priv,
1138                 struct v4l2_format *fmt)
1139 {
1140         struct mcam_camera *cam = priv;
1141         struct mcam_format_struct *f;
1142         struct v4l2_pix_format *pix = &fmt->fmt.pix;
1143         struct v4l2_mbus_framefmt mbus_fmt;
1144         int ret;
1145
1146         f = mcam_find_format(pix->pixelformat);
1147         pix->pixelformat = f->pixelformat;
1148         v4l2_fill_mbus_format(&mbus_fmt, pix, f->mbus_code);
1149         mutex_lock(&cam->s_mutex);
1150         ret = sensor_call(cam, video, try_mbus_fmt, &mbus_fmt);
1151         mutex_unlock(&cam->s_mutex);
1152         v4l2_fill_pix_format(pix, &mbus_fmt);
1153         pix->bytesperline = pix->width * f->bpp;
1154         pix->sizeimage = pix->height * pix->bytesperline;
1155         return ret;
1156 }
1157
1158 static int mcam_vidioc_s_fmt_vid_cap(struct file *filp, void *priv,
1159                 struct v4l2_format *fmt)
1160 {
1161         struct mcam_camera *cam = priv;
1162         struct mcam_format_struct *f;
1163         int ret;
1164
1165         /*
1166          * Can't do anything if the device is not idle
1167          * Also can't if there are streaming buffers in place.
1168          */
1169         if (cam->state != S_IDLE || cam->n_sbufs > 0)
1170                 return -EBUSY;
1171
1172         f = mcam_find_format(fmt->fmt.pix.pixelformat);
1173
1174         /*
1175          * See if the formatting works in principle.
1176          */
1177         ret = mcam_vidioc_try_fmt_vid_cap(filp, priv, fmt);
1178         if (ret)
1179                 return ret;
1180         /*
1181          * Now we start to change things for real, so let's do it
1182          * under lock.
1183          */
1184         mutex_lock(&cam->s_mutex);
1185         cam->pix_format = fmt->fmt.pix;
1186         cam->mbus_code = f->mbus_code;
1187
1188         /*
1189          * Make sure we have appropriate DMA buffers.
1190          */
1191         ret = -ENOMEM;
1192         if (cam->nbufs > 0 && cam->dma_buf_size < cam->pix_format.sizeimage)
1193                 mcam_free_dma_bufs(cam);
1194         if (cam->nbufs == 0) {
1195                 if (mcam_alloc_dma_bufs(cam, 0))
1196                         goto out;
1197         }
1198         /*
1199          * It looks like this might work, so let's program the sensor.
1200          */
1201         ret = mcam_cam_configure(cam);
1202         if (!ret)
1203                 ret = mcam_ctlr_configure(cam);
1204 out:
1205         mutex_unlock(&cam->s_mutex);
1206         return ret;
1207 }
1208
1209 /*
1210  * Return our stored notion of how the camera is/should be configured.
1211  * The V4l2 spec wants us to be smarter, and actually get this from
1212  * the camera (and not mess with it at open time).  Someday.
1213  */
1214 static int mcam_vidioc_g_fmt_vid_cap(struct file *filp, void *priv,
1215                 struct v4l2_format *f)
1216 {
1217         struct mcam_camera *cam = priv;
1218
1219         f->fmt.pix = cam->pix_format;
1220         return 0;
1221 }
1222
1223 /*
1224  * We only have one input - the sensor - so minimize the nonsense here.
1225  */
1226 static int mcam_vidioc_enum_input(struct file *filp, void *priv,
1227                 struct v4l2_input *input)
1228 {
1229         if (input->index != 0)
1230                 return -EINVAL;
1231
1232         input->type = V4L2_INPUT_TYPE_CAMERA;
1233         input->std = V4L2_STD_ALL; /* Not sure what should go here */
1234         strcpy(input->name, "Camera");
1235         return 0;
1236 }
1237
1238 static int mcam_vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
1239 {
1240         *i = 0;
1241         return 0;
1242 }
1243
1244 static int mcam_vidioc_s_input(struct file *filp, void *priv, unsigned int i)
1245 {
1246         if (i != 0)
1247                 return -EINVAL;
1248         return 0;
1249 }
1250
1251 /* from vivi.c */
1252 static int mcam_vidioc_s_std(struct file *filp, void *priv, v4l2_std_id *a)
1253 {
1254         return 0;
1255 }
1256
1257 /*
1258  * G/S_PARM.  Most of this is done by the sensor, but we are
1259  * the level which controls the number of read buffers.
1260  */
1261 static int mcam_vidioc_g_parm(struct file *filp, void *priv,
1262                 struct v4l2_streamparm *parms)
1263 {
1264         struct mcam_camera *cam = priv;
1265         int ret;
1266
1267         mutex_lock(&cam->s_mutex);
1268         ret = sensor_call(cam, video, g_parm, parms);
1269         mutex_unlock(&cam->s_mutex);
1270         parms->parm.capture.readbuffers = n_dma_bufs;
1271         return ret;
1272 }
1273
1274 static int mcam_vidioc_s_parm(struct file *filp, void *priv,
1275                 struct v4l2_streamparm *parms)
1276 {
1277         struct mcam_camera *cam = priv;
1278         int ret;
1279
1280         mutex_lock(&cam->s_mutex);
1281         ret = sensor_call(cam, video, s_parm, parms);
1282         mutex_unlock(&cam->s_mutex);
1283         parms->parm.capture.readbuffers = n_dma_bufs;
1284         return ret;
1285 }
1286
1287 static int mcam_vidioc_g_chip_ident(struct file *file, void *priv,
1288                 struct v4l2_dbg_chip_ident *chip)
1289 {
1290         struct mcam_camera *cam = priv;
1291
1292         chip->ident = V4L2_IDENT_NONE;
1293         chip->revision = 0;
1294         if (v4l2_chip_match_host(&chip->match)) {
1295                 chip->ident = cam->chip_id;
1296                 return 0;
1297         }
1298         return sensor_call(cam, core, g_chip_ident, chip);
1299 }
1300
1301 static int mcam_vidioc_enum_framesizes(struct file *filp, void *priv,
1302                 struct v4l2_frmsizeenum *sizes)
1303 {
1304         struct mcam_camera *cam = priv;
1305         int ret;
1306
1307         mutex_lock(&cam->s_mutex);
1308         ret = sensor_call(cam, video, enum_framesizes, sizes);
1309         mutex_unlock(&cam->s_mutex);
1310         return ret;
1311 }
1312
1313 static int mcam_vidioc_enum_frameintervals(struct file *filp, void *priv,
1314                 struct v4l2_frmivalenum *interval)
1315 {
1316         struct mcam_camera *cam = priv;
1317         int ret;
1318
1319         mutex_lock(&cam->s_mutex);
1320         ret = sensor_call(cam, video, enum_frameintervals, interval);
1321         mutex_unlock(&cam->s_mutex);
1322         return ret;
1323 }
1324
1325 #ifdef CONFIG_VIDEO_ADV_DEBUG
1326 static int mcam_vidioc_g_register(struct file *file, void *priv,
1327                 struct v4l2_dbg_register *reg)
1328 {
1329         struct mcam_camera *cam = priv;
1330
1331         if (v4l2_chip_match_host(&reg->match)) {
1332                 reg->val = mcam_reg_read(cam, reg->reg);
1333                 reg->size = 4;
1334                 return 0;
1335         }
1336         return sensor_call(cam, core, g_register, reg);
1337 }
1338
1339 static int mcam_vidioc_s_register(struct file *file, void *priv,
1340                 struct v4l2_dbg_register *reg)
1341 {
1342         struct mcam_camera *cam = priv;
1343
1344         if (v4l2_chip_match_host(&reg->match)) {
1345                 mcam_reg_write(cam, reg->reg, reg->val);
1346                 return 0;
1347         }
1348         return sensor_call(cam, core, s_register, reg);
1349 }
1350 #endif
1351
1352 /*
1353  * This template device holds all of those v4l2 methods; we
1354  * clone it for specific real devices.
1355  */
1356
1357 static const struct v4l2_file_operations mcam_v4l_fops = {
1358         .owner = THIS_MODULE,
1359         .open = mcam_v4l_open,
1360         .release = mcam_v4l_release,
1361         .read = mcam_v4l_read,
1362         .poll = mcam_v4l_poll,
1363         .mmap = mcam_v4l_mmap,
1364         .unlocked_ioctl = video_ioctl2,
1365 };
1366
1367 static const struct v4l2_ioctl_ops mcam_v4l_ioctl_ops = {
1368         .vidioc_querycap        = mcam_vidioc_querycap,
1369         .vidioc_enum_fmt_vid_cap = mcam_vidioc_enum_fmt_vid_cap,
1370         .vidioc_try_fmt_vid_cap = mcam_vidioc_try_fmt_vid_cap,
1371         .vidioc_s_fmt_vid_cap   = mcam_vidioc_s_fmt_vid_cap,
1372         .vidioc_g_fmt_vid_cap   = mcam_vidioc_g_fmt_vid_cap,
1373         .vidioc_enum_input      = mcam_vidioc_enum_input,
1374         .vidioc_g_input         = mcam_vidioc_g_input,
1375         .vidioc_s_input         = mcam_vidioc_s_input,
1376         .vidioc_s_std           = mcam_vidioc_s_std,
1377         .vidioc_reqbufs         = mcam_vidioc_reqbufs,
1378         .vidioc_querybuf        = mcam_vidioc_querybuf,
1379         .vidioc_qbuf            = mcam_vidioc_qbuf,
1380         .vidioc_dqbuf           = mcam_vidioc_dqbuf,
1381         .vidioc_streamon        = mcam_vidioc_streamon,
1382         .vidioc_streamoff       = mcam_vidioc_streamoff,
1383         .vidioc_queryctrl       = mcam_vidioc_queryctrl,
1384         .vidioc_g_ctrl          = mcam_vidioc_g_ctrl,
1385         .vidioc_s_ctrl          = mcam_vidioc_s_ctrl,
1386         .vidioc_g_parm          = mcam_vidioc_g_parm,
1387         .vidioc_s_parm          = mcam_vidioc_s_parm,
1388         .vidioc_enum_framesizes = mcam_vidioc_enum_framesizes,
1389         .vidioc_enum_frameintervals = mcam_vidioc_enum_frameintervals,
1390         .vidioc_g_chip_ident    = mcam_vidioc_g_chip_ident,
1391 #ifdef CONFIG_VIDEO_ADV_DEBUG
1392         .vidioc_g_register      = mcam_vidioc_g_register,
1393         .vidioc_s_register      = mcam_vidioc_s_register,
1394 #endif
1395 };
1396
1397 static struct video_device mcam_v4l_template = {
1398         .name = "mcam",
1399         .tvnorms = V4L2_STD_NTSC_M,
1400         .current_norm = V4L2_STD_NTSC_M,  /* make mplayer happy */
1401
1402         .fops = &mcam_v4l_fops,
1403         .ioctl_ops = &mcam_v4l_ioctl_ops,
1404         .release = video_device_release_empty,
1405 };
1406
1407 /* ---------------------------------------------------------------------- */
1408 /*
1409  * Interrupt handler stuff
1410  */
1411
1412
1413
1414 static void mcam_frame_tasklet(unsigned long data)
1415 {
1416         struct mcam_camera *cam = (struct mcam_camera *) data;
1417         int i;
1418         unsigned long flags;
1419         struct mcam_sio_buffer *sbuf;
1420
1421         spin_lock_irqsave(&cam->dev_lock, flags);
1422         for (i = 0; i < cam->nbufs; i++) {
1423                 int bufno = cam->next_buf;
1424                 if (bufno < 0) {  /* "will never happen" */
1425                         cam_err(cam, "No valid bufs in tasklet!\n");
1426                         break;
1427                 }
1428                 if (++(cam->next_buf) >= cam->nbufs)
1429                         cam->next_buf = 0;
1430                 if (!test_bit(bufno, &cam->flags))
1431                         continue;
1432                 if (list_empty(&cam->sb_avail))
1433                         break;  /* Leave it valid, hope for better later */
1434                 clear_bit(bufno, &cam->flags);
1435                 sbuf = list_entry(cam->sb_avail.next,
1436                                 struct mcam_sio_buffer, list);
1437                 /*
1438                  * Drop the lock during the big copy.  This *should* be safe...
1439                  */
1440                 spin_unlock_irqrestore(&cam->dev_lock, flags);
1441                 memcpy(sbuf->buffer, cam->dma_bufs[bufno],
1442                                 cam->pix_format.sizeimage);
1443                 sbuf->v4lbuf.bytesused = cam->pix_format.sizeimage;
1444                 sbuf->v4lbuf.sequence = cam->buf_seq[bufno];
1445                 sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_QUEUED;
1446                 sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_DONE;
1447                 spin_lock_irqsave(&cam->dev_lock, flags);
1448                 list_move_tail(&sbuf->list, &cam->sb_full);
1449         }
1450         if (!list_empty(&cam->sb_full))
1451                 wake_up(&cam->iowait);
1452         spin_unlock_irqrestore(&cam->dev_lock, flags);
1453 }
1454
1455
1456
1457 static void mcam_frame_complete(struct mcam_camera *cam, int frame)
1458 {
1459         /*
1460          * Basic frame housekeeping.
1461          */
1462         if (test_bit(frame, &cam->flags) && printk_ratelimit())
1463                 cam_err(cam, "Frame overrun on %d, frames lost\n", frame);
1464         set_bit(frame, &cam->flags);
1465         clear_bit(CF_DMA_ACTIVE, &cam->flags);
1466         if (cam->next_buf < 0)
1467                 cam->next_buf = frame;
1468         cam->buf_seq[frame] = ++(cam->sequence);
1469
1470         switch (cam->state) {
1471         /*
1472          * If in single read mode, try going speculative.
1473          */
1474         case S_SINGLEREAD:
1475                 cam->state = S_SPECREAD;
1476                 cam->specframes = 0;
1477                 wake_up(&cam->iowait);
1478                 break;
1479
1480         /*
1481          * If we are already doing speculative reads, and nobody is
1482          * reading them, just stop.
1483          */
1484         case S_SPECREAD:
1485                 if (++(cam->specframes) >= cam->nbufs) {
1486                         mcam_ctlr_stop(cam);
1487                         mcam_ctlr_irq_disable(cam);
1488                         cam->state = S_IDLE;
1489                 }
1490                 wake_up(&cam->iowait);
1491                 break;
1492         /*
1493          * For the streaming case, we defer the real work to the
1494          * camera tasklet.
1495          *
1496          * FIXME: if the application is not consuming the buffers,
1497          * we should eventually put things on hold and restart in
1498          * vidioc_dqbuf().
1499          */
1500         case S_STREAMING:
1501                 tasklet_schedule(&cam->s_tasklet);
1502                 break;
1503
1504         default:
1505                 cam_err(cam, "Frame interrupt in non-operational state\n");
1506                 break;
1507         }
1508 }
1509
1510
1511
1512
1513 int mccic_irq(struct mcam_camera *cam, unsigned int irqs)
1514 {
1515         unsigned int frame, handled = 0;
1516
1517         mcam_reg_write(cam, REG_IRQSTAT, FRAMEIRQS); /* Clear'em all */
1518         /*
1519          * Handle any frame completions.  There really should
1520          * not be more than one of these, or we have fallen
1521          * far behind.
1522          */
1523         for (frame = 0; frame < cam->nbufs; frame++)
1524                 if (irqs & (IRQ_EOF0 << frame)) {
1525                         mcam_frame_complete(cam, frame);
1526                         handled = 1;
1527                 }
1528         /*
1529          * If a frame starts, note that we have DMA active.  This
1530          * code assumes that we won't get multiple frame interrupts
1531          * at once; may want to rethink that.
1532          */
1533         if (irqs & (IRQ_SOF0 | IRQ_SOF1 | IRQ_SOF2)) {
1534                 set_bit(CF_DMA_ACTIVE, &cam->flags);
1535                 handled = 1;
1536         }
1537         return handled;
1538 }
1539
1540 /*
1541  * Registration and such.
1542  */
1543
1544 static struct ov7670_config sensor_cfg = {
1545         /*
1546          * Exclude QCIF mode, because it only captures a tiny portion
1547          * of the sensor FOV
1548          */
1549         .min_width = 320,
1550         .min_height = 240,
1551 };
1552
1553
1554 int mccic_register(struct mcam_camera *cam)
1555 {
1556         struct i2c_board_info ov7670_info = {
1557                 .type = "ov7670",
1558                 .addr = 0x42 >> 1,
1559                 .platform_data = &sensor_cfg,
1560         };
1561         int ret;
1562
1563         /*
1564          * Register with V4L
1565          */
1566         ret = v4l2_device_register(cam->dev, &cam->v4l2_dev);
1567         if (ret)
1568                 return ret;
1569
1570         mutex_init(&cam->s_mutex);
1571         cam->state = S_NOTREADY;
1572         mcam_set_config_needed(cam, 1);
1573         init_waitqueue_head(&cam->iowait);
1574         cam->pix_format = mcam_def_pix_format;
1575         cam->mbus_code = mcam_def_mbus_code;
1576         INIT_LIST_HEAD(&cam->dev_list);
1577         INIT_LIST_HEAD(&cam->sb_avail);
1578         INIT_LIST_HEAD(&cam->sb_full);
1579         tasklet_init(&cam->s_tasklet, mcam_frame_tasklet, (unsigned long) cam);
1580
1581         mcam_ctlr_init(cam);
1582
1583         /*
1584          * Try to find the sensor.
1585          */
1586         sensor_cfg.clock_speed = cam->clock_speed;
1587         sensor_cfg.use_smbus = cam->use_smbus;
1588         cam->sensor_addr = ov7670_info.addr;
1589         cam->sensor = v4l2_i2c_new_subdev_board(&cam->v4l2_dev,
1590                         cam->i2c_adapter, &ov7670_info, NULL);
1591         if (cam->sensor == NULL) {
1592                 ret = -ENODEV;
1593                 goto out_unregister;
1594         }
1595
1596         ret = mcam_cam_init(cam);
1597         if (ret)
1598                 goto out_unregister;
1599         /*
1600          * Get the v4l2 setup done.
1601          */
1602         mutex_lock(&cam->s_mutex);
1603         cam->vdev = mcam_v4l_template;
1604         cam->vdev.debug = 0;
1605         cam->vdev.v4l2_dev = &cam->v4l2_dev;
1606         ret = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
1607         if (ret)
1608                 goto out;
1609         video_set_drvdata(&cam->vdev, cam);
1610
1611         /*
1612          * If so requested, try to get our DMA buffers now.
1613          */
1614         if (!alloc_bufs_at_read) {
1615                 if (mcam_alloc_dma_bufs(cam, 1))
1616                         cam_warn(cam, "Unable to alloc DMA buffers at load"
1617                                         " will try again later.");
1618         }
1619
1620 out:
1621         mutex_unlock(&cam->s_mutex);
1622         return ret;
1623 out_unregister:
1624         v4l2_device_unregister(&cam->v4l2_dev);
1625         return ret;
1626 }
1627
1628
1629 void mccic_shutdown(struct mcam_camera *cam)
1630 {
1631         /*
1632          * If we have no users (and we really, really should have no
1633          * users) the device will already be powered down.  Trying to
1634          * take it down again will wedge the machine, which is frowned
1635          * upon.
1636          */
1637         if (cam->users > 0) {
1638                 cam_warn(cam, "Removing a device with users!\n");
1639                 mcam_ctlr_power_down(cam);
1640         }
1641         mcam_free_dma_bufs(cam);
1642         if (cam->n_sbufs > 0)
1643                 /* What if they are still mapped?  Shouldn't be, but... */
1644                 mcam_free_sio_buffers(cam);
1645         video_unregister_device(&cam->vdev);
1646         v4l2_device_unregister(&cam->v4l2_dev);
1647 }
1648
1649 /*
1650  * Power management
1651  */
1652 #ifdef CONFIG_PM
1653
1654 void mccic_suspend(struct mcam_camera *cam)
1655 {
1656         enum mcam_state cstate = cam->state;
1657
1658         mcam_ctlr_stop_dma(cam);
1659         mcam_ctlr_power_down(cam);
1660         cam->state = cstate;
1661 }
1662
1663 int mccic_resume(struct mcam_camera *cam)
1664 {
1665         int ret = 0;
1666
1667         mutex_lock(&cam->s_mutex);
1668         if (cam->users > 0) {
1669                 mcam_ctlr_power_up(cam);
1670                 __mcam_cam_reset(cam);
1671         } else {
1672                 mcam_ctlr_power_down(cam);
1673         }
1674         mutex_unlock(&cam->s_mutex);
1675
1676         set_bit(CF_CONFIG_NEEDED, &cam->flags);
1677         if (cam->state == S_SPECREAD)
1678                 cam->state = S_IDLE;  /* Don't bother restarting */
1679         else if (cam->state == S_SINGLEREAD || cam->state == S_STREAMING)
1680                 ret = mcam_read_setup(cam, cam->state);
1681         return ret;
1682 }
1683 #endif /* CONFIG_PM */