?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rt2800: initialize BBP_R104 on proper subroutines
[linux/fpc-iii.git] / drivers / media / platform / fsl-viu.c
blob3a6a0dcdc3e426390fa2b9ff2ab9edbcc9c47b0d
1 /*
2 * Copyright 2008-2010 Freescale Semiconductor, Inc. All Rights Reserved.
3 *
4 * Freescale VIU video driver
5 *
6 * Authors: Hongjun Chen <hong-jun.chen@freescale.com>
7 * Porting to 2.6.35 by DENX Software Engineering,
8 * Anatolij Gustschin <agust@denx.de>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2 of the License, or (at your
13 * option) any later version.
14 *
15 */
16
17 #include <linux/module.h>
18 #include <linux/clk.h>
19 #include <linux/kernel.h>
20 #include <linux/i2c.h>
21 #include <linux/init.h>
22 #include <linux/interrupt.h>
23 #include <linux/io.h>
24 #include <linux/of_platform.h>
25 #include <linux/slab.h>
26 #include <media/v4l2-common.h>
27 #include <media/v4l2-device.h>
28 #include <media/v4l2-ioctl.h>
29 #include <media/videobuf-dma-contig.h>
30
31 #define DRV_NAME "fsl_viu"
32 #define VIU_VERSION "0.5.1"
33
34 #define BUFFER_TIMEOUT msecs_to_jiffies(500) /* 0.5 seconds */
35
36 #define VIU_VID_MEM_LIMIT 4 /* Video memory limit, in Mb */
37
38 /* I2C address of video decoder chip is 0x4A */
39 #define VIU_VIDEO_DECODER_ADDR 0x25
40
41 /* supported controls */
42 static struct v4l2_queryctrl viu_qctrl[] = {
43 {
44 .id = V4L2_CID_BRIGHTNESS,
45 .type = V4L2_CTRL_TYPE_INTEGER,
46 .name = "Brightness",
47 .minimum = 0,
48 .maximum = 255,
49 .step = 1,
50 .default_value = 127,
51 .flags = 0,
52 }, {
53 .id = V4L2_CID_CONTRAST,
54 .type = V4L2_CTRL_TYPE_INTEGER,
55 .name = "Contrast",
56 .minimum = 0,
57 .maximum = 255,
58 .step = 0x1,
59 .default_value = 0x10,
60 .flags = 0,
61 }, {
62 .id = V4L2_CID_SATURATION,
63 .type = V4L2_CTRL_TYPE_INTEGER,
64 .name = "Saturation",
65 .minimum = 0,
66 .maximum = 255,
67 .step = 0x1,
68 .default_value = 127,
69 .flags = 0,
70 }, {
71 .id = V4L2_CID_HUE,
72 .type = V4L2_CTRL_TYPE_INTEGER,
73 .name = "Hue",
74 .minimum = -128,
75 .maximum = 127,
76 .step = 0x1,
77 .default_value = 0,
78 .flags = 0,
79 }
80 };
81
82 static int qctl_regs[ARRAY_SIZE(viu_qctrl)];
83
84 static int info_level;
85
86 #define dprintk(level, fmt, arg...) \
87 do { \
88 if (level <= info_level) \
89 printk(KERN_DEBUG "viu: " fmt , ## arg); \
90 } while (0)
91
92 /*
93 * Basic structures
94 */
95 struct viu_fmt {
96 char name[32];
97 u32 fourcc; /* v4l2 format id */
98 u32 pixelformat;
99 int depth;
100 };
101
102 static struct viu_fmt formats[] = {
103 {
104 .name = "RGB-16 (5/B-6/G-5/R)",
105 .fourcc = V4L2_PIX_FMT_RGB565,
106 .pixelformat = V4L2_PIX_FMT_RGB565,
107 .depth = 16,
108 }, {
109 .name = "RGB-32 (A-R-G-B)",
110 .fourcc = V4L2_PIX_FMT_RGB32,
111 .pixelformat = V4L2_PIX_FMT_RGB32,
112 .depth = 32,
113 }
114 };
115
116 struct viu_dev;
117 struct viu_buf;
118
119 /* buffer for one video frame */
120 struct viu_buf {
121 /* common v4l buffer stuff -- must be first */
122 struct videobuf_buffer vb;
123 struct viu_fmt *fmt;
124 };
125
126 struct viu_dmaqueue {
127 struct viu_dev *dev;
128 struct list_head active;
129 struct list_head queued;
130 struct timer_list timeout;
131 };
132
133 struct viu_status {
134 u32 field_irq;
135 u32 vsync_irq;
136 u32 hsync_irq;
137 u32 vstart_irq;
138 u32 dma_end_irq;
139 u32 error_irq;
140 };
141
142 struct viu_reg {
143 u32 status_cfg;
144 u32 luminance;
145 u32 chroma_r;
146 u32 chroma_g;
147 u32 chroma_b;
148 u32 field_base_addr;
149 u32 dma_inc;
150 u32 picture_count;
151 u32 req_alarm;
152 u32 alpha;
153 } __attribute__ ((packed));
154
155 struct viu_dev {
156 struct v4l2_device v4l2_dev;
157 struct mutex lock;
158 spinlock_t slock;
159 int users;
160
161 struct device *dev;
162 /* various device info */
163 struct video_device *vdev;
164 struct viu_dmaqueue vidq;
165 enum v4l2_field capfield;
166 int field;
167 int first;
168 int dma_done;
169
170 /* Hardware register area */
171 struct viu_reg *vr;
172
173 /* Interrupt vector */
174 int irq;
175 struct viu_status irqs;
176
177 /* video overlay */
178 struct v4l2_framebuffer ovbuf;
179 struct viu_fmt *ovfmt;
180 unsigned int ovenable;
181 enum v4l2_field ovfield;
182
183 /* crop */
184 struct v4l2_rect crop_current;
185
186 /* clock pointer */
187 struct clk *clk;
188
189 /* decoder */
190 struct v4l2_subdev *decoder;
191
192 v4l2_std_id std;
193 };
194
195 struct viu_fh {
196 struct viu_dev *dev;
197
198 /* video capture */
199 struct videobuf_queue vb_vidq;
200 spinlock_t vbq_lock; /* spinlock for the videobuf queue */
201
202 /* video overlay */
203 struct v4l2_window win;
204 struct v4l2_clip clips[1];
205
206 /* video capture */
207 struct viu_fmt *fmt;
208 int width, height, sizeimage;
209 enum v4l2_buf_type type;
210 };
211
212 static struct viu_reg reg_val;
213
214 /*
215 * Macro definitions of VIU registers
216 */
217
218 /* STATUS_CONFIG register */
219 enum status_config {
220 SOFT_RST = 1 << 0,
221
222 ERR_MASK = 0x0f << 4, /* Error code mask */
223 ERR_NO = 0x00, /* No error */
224 ERR_DMA_V = 0x01 << 4, /* DMA in vertical active */
225 ERR_DMA_VB = 0x02 << 4, /* DMA in vertical blanking */
226 ERR_LINE_TOO_LONG = 0x04 << 4, /* Line too long */
227 ERR_TOO_MANG_LINES = 0x05 << 4, /* Too many lines in field */
228 ERR_LINE_TOO_SHORT = 0x06 << 4, /* Line too short */
229 ERR_NOT_ENOUGH_LINE = 0x07 << 4, /* Not enough lines in field */
230 ERR_FIFO_OVERFLOW = 0x08 << 4, /* FIFO overflow */
231 ERR_FIFO_UNDERFLOW = 0x09 << 4, /* FIFO underflow */
232 ERR_1bit_ECC = 0x0a << 4, /* One bit ECC error */
233 ERR_MORE_ECC = 0x0b << 4, /* Two/more bits ECC error */
234
235 INT_FIELD_EN = 0x01 << 8, /* Enable field interrupt */
236 INT_VSYNC_EN = 0x01 << 9, /* Enable vsync interrupt */
237 INT_HSYNC_EN = 0x01 << 10, /* Enable hsync interrupt */
238 INT_VSTART_EN = 0x01 << 11, /* Enable vstart interrupt */
239 INT_DMA_END_EN = 0x01 << 12, /* Enable DMA end interrupt */
240 INT_ERROR_EN = 0x01 << 13, /* Enable error interrupt */
241 INT_ECC_EN = 0x01 << 14, /* Enable ECC interrupt */
242
243 INT_FIELD_STATUS = 0x01 << 16, /* field interrupt status */
244 INT_VSYNC_STATUS = 0x01 << 17, /* vsync interrupt status */
245 INT_HSYNC_STATUS = 0x01 << 18, /* hsync interrupt status */
246 INT_VSTART_STATUS = 0x01 << 19, /* vstart interrupt status */
247 INT_DMA_END_STATUS = 0x01 << 20, /* DMA end interrupt status */
248 INT_ERROR_STATUS = 0x01 << 21, /* error interrupt status */
249
250 DMA_ACT = 0x01 << 27, /* Enable DMA transfer */
251 FIELD_NO = 0x01 << 28, /* Field number */
252 DITHER_ON = 0x01 << 29, /* Dithering is on */
253 ROUND_ON = 0x01 << 30, /* Round is on */
254 MODE_32BIT = 0x01 << 31, /* Data in RGBa888,
255 * 0 in RGB565
256 */
257 };
258
259 #define norm_maxw() 720
260 #define norm_maxh() 576
261
262 #define INT_ALL_STATUS (INT_FIELD_STATUS | INT_VSYNC_STATUS | \
263 INT_HSYNC_STATUS | INT_VSTART_STATUS | \
264 INT_DMA_END_STATUS | INT_ERROR_STATUS)
265
266 #define NUM_FORMATS ARRAY_SIZE(formats)
267
268 static irqreturn_t viu_intr(int irq, void *dev_id);
269
270 struct viu_fmt *format_by_fourcc(int fourcc)
271 {
272 int i;
273
274 for (i = 0; i < NUM_FORMATS; i++) {
275 if (formats[i].pixelformat == fourcc)
276 return formats + i;
277 }
278
279 dprintk(0, "unknown pixelformat:'%4.4s'\n", (char *)&fourcc);
280 return NULL;
281 }
282
283 void viu_start_dma(struct viu_dev *dev)
284 {
285 struct viu_reg *vr = dev->vr;
286
287 dev->field = 0;
288
289 /* Enable DMA operation */
290 out_be32(&vr->status_cfg, SOFT_RST);
291 out_be32(&vr->status_cfg, INT_FIELD_EN);
292 }
293
294 void viu_stop_dma(struct viu_dev *dev)
295 {
296 struct viu_reg *vr = dev->vr;
297 int cnt = 100;
298 u32 status_cfg;
299
300 out_be32(&vr->status_cfg, 0);
301
302 /* Clear pending interrupts */
303 status_cfg = in_be32(&vr->status_cfg);
304 if (status_cfg & 0x3f0000)
305 out_be32(&vr->status_cfg, status_cfg & 0x3f0000);
306
307 if (status_cfg & DMA_ACT) {
308 do {
309 status_cfg = in_be32(&vr->status_cfg);
310 if (status_cfg & INT_DMA_END_STATUS)
311 break;
312 } while (cnt--);
313
314 if (cnt < 0) {
315 /* timed out, issue soft reset */
316 out_be32(&vr->status_cfg, SOFT_RST);
317 out_be32(&vr->status_cfg, 0);
318 } else {
319 /* clear DMA_END and other pending irqs */
320 out_be32(&vr->status_cfg, status_cfg & 0x3f0000);
321 }
322 }
323
324 dev->field = 0;
325 }
326
327 static int restart_video_queue(struct viu_dmaqueue *vidq)
328 {
329 struct viu_buf *buf, *prev;
330
331 dprintk(1, "%s vidq=0x%08lx\n", __func__, (unsigned long)vidq);
332 if (!list_empty(&vidq->active)) {
333 buf = list_entry(vidq->active.next, struct viu_buf, vb.queue);
334 dprintk(2, "restart_queue [%p/%d]: restart dma\n",
335 buf, buf->vb.i);
336
337 viu_stop_dma(vidq->dev);
338
339 /* cancel all outstanding capture requests */
340 list_for_each_entry_safe(buf, prev, &vidq->active, vb.queue) {
341 list_del(&buf->vb.queue);
342 buf->vb.state = VIDEOBUF_ERROR;
343 wake_up(&buf->vb.done);
344 }
345 mod_timer(&vidq->timeout, jiffies+BUFFER_TIMEOUT);
346 return 0;
347 }
348
349 prev = NULL;
350 for (;;) {
351 if (list_empty(&vidq->queued))
352 return 0;
353 buf = list_entry(vidq->queued.next, struct viu_buf, vb.queue);
354 if (prev == NULL) {
355 list_move_tail(&buf->vb.queue, &vidq->active);
356
357 dprintk(1, "Restarting video dma\n");
358 viu_stop_dma(vidq->dev);
359 viu_start_dma(vidq->dev);
360
361 buf->vb.state = VIDEOBUF_ACTIVE;
362 mod_timer(&vidq->timeout, jiffies+BUFFER_TIMEOUT);
363 dprintk(2, "[%p/%d] restart_queue - first active\n",
364 buf, buf->vb.i);
365
366 } else if (prev->vb.width == buf->vb.width &&
367 prev->vb.height == buf->vb.height &&
368 prev->fmt == buf->fmt) {
369 list_move_tail(&buf->vb.queue, &vidq->active);
370 buf->vb.state = VIDEOBUF_ACTIVE;
371 dprintk(2, "[%p/%d] restart_queue - move to active\n",
372 buf, buf->vb.i);
373 } else {
374 return 0;
375 }
376 prev = buf;
377 }
378 }
379
380 static void viu_vid_timeout(unsigned long data)
381 {
382 struct viu_dev *dev = (struct viu_dev *)data;
383 struct viu_buf *buf;
384 struct viu_dmaqueue *vidq = &dev->vidq;
385
386 while (!list_empty(&vidq->active)) {
387 buf = list_entry(vidq->active.next, struct viu_buf, vb.queue);
388 list_del(&buf->vb.queue);
389 buf->vb.state = VIDEOBUF_ERROR;
390 wake_up(&buf->vb.done);
391 dprintk(1, "viu/0: [%p/%d] timeout\n", buf, buf->vb.i);
392 }
393
394 restart_video_queue(vidq);
395 }
396
397 /*
398 * Videobuf operations
399 */
400 static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
401 unsigned int *size)
402 {
403 struct viu_fh *fh = vq->priv_data;
404
405 *size = fh->width * fh->height * fh->fmt->depth >> 3;
406 if (*count == 0)
407 *count = 32;
408
409 while (*size * *count > VIU_VID_MEM_LIMIT * 1024 * 1024)
410 (*count)--;
411
412 dprintk(1, "%s, count=%d, size=%d\n", __func__, *count, *size);
413 return 0;
414 }
415
416 static void free_buffer(struct videobuf_queue *vq, struct viu_buf *buf)
417 {
418 struct videobuf_buffer *vb = &buf->vb;
419 void *vaddr = NULL;
420
421 BUG_ON(in_interrupt());
422
423 videobuf_waiton(vq, &buf->vb, 0, 0);
424
425 if (vq->int_ops && vq->int_ops->vaddr)
426 vaddr = vq->int_ops->vaddr(vb);
427
428 if (vaddr)
429 videobuf_dma_contig_free(vq, &buf->vb);
430
431 buf->vb.state = VIDEOBUF_NEEDS_INIT;
432 }
433
434 inline int buffer_activate(struct viu_dev *dev, struct viu_buf *buf)
435 {
436 struct viu_reg *vr = dev->vr;
437 int bpp;
438
439 /* setup the DMA base address */
440 reg_val.field_base_addr = videobuf_to_dma_contig(&buf->vb);
441
442 dprintk(1, "buffer_activate [%p/%d]: dma addr 0x%lx\n",
443 buf, buf->vb.i, (unsigned long)reg_val.field_base_addr);
444
445 /* interlace is on by default, set horizontal DMA increment */
446 reg_val.status_cfg = 0;
447 bpp = buf->fmt->depth >> 3;
448 switch (bpp) {
449 case 2:
450 reg_val.status_cfg &= ~MODE_32BIT;
451 reg_val.dma_inc = buf->vb.width * 2;
452 break;
453 case 4:
454 reg_val.status_cfg |= MODE_32BIT;
455 reg_val.dma_inc = buf->vb.width * 4;
456 break;
457 default:
458 dprintk(0, "doesn't support color depth(%d)\n",
459 bpp * 8);
460 return -EINVAL;
461 }
462
463 /* setup picture_count register */
464 reg_val.picture_count = (buf->vb.height / 2) << 16 |
465 buf->vb.width;
466
467 reg_val.status_cfg |= DMA_ACT | INT_DMA_END_EN | INT_FIELD_EN;
468
469 buf->vb.state = VIDEOBUF_ACTIVE;
470 dev->capfield = buf->vb.field;
471
472 /* reset dma increment if needed */
473 if (!V4L2_FIELD_HAS_BOTH(buf->vb.field))
474 reg_val.dma_inc = 0;
475
476 out_be32(&vr->dma_inc, reg_val.dma_inc);
477 out_be32(&vr->picture_count, reg_val.picture_count);
478 out_be32(&vr->field_base_addr, reg_val.field_base_addr);
479 mod_timer(&dev->vidq.timeout, jiffies + BUFFER_TIMEOUT);
480 return 0;
481 }
482
483 static int buffer_prepare(struct videobuf_queue *vq,
484 struct videobuf_buffer *vb,
485 enum v4l2_field field)
486 {
487 struct viu_fh *fh = vq->priv_data;
488 struct viu_buf *buf = container_of(vb, struct viu_buf, vb);
489 int rc;
490
491 BUG_ON(fh->fmt == NULL);
492
493 if (fh->width < 48 || fh->width > norm_maxw() ||
494 fh->height < 32 || fh->height > norm_maxh())
495 return -EINVAL;
496 buf->vb.size = (fh->width * fh->height * fh->fmt->depth) >> 3;
497 if (buf->vb.baddr != 0 && buf->vb.bsize < buf->vb.size)
498 return -EINVAL;
499
500 if (buf->fmt != fh->fmt ||
501 buf->vb.width != fh->width ||
502 buf->vb.height != fh->height ||
503 buf->vb.field != field) {
504 buf->fmt = fh->fmt;
505 buf->vb.width = fh->width;
506 buf->vb.height = fh->height;
507 buf->vb.field = field;
508 }
509
510 if (buf->vb.state == VIDEOBUF_NEEDS_INIT) {
511 rc = videobuf_iolock(vq, &buf->vb, NULL);
512 if (rc != 0)
513 goto fail;
514
515 buf->vb.width = fh->width;
516 buf->vb.height = fh->height;
517 buf->vb.field = field;
518 buf->fmt = fh->fmt;
519 }
520
521 buf->vb.state = VIDEOBUF_PREPARED;
522 return 0;
523
524 fail:
525 free_buffer(vq, buf);
526 return rc;
527 }
528
529 static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
530 {
531 struct viu_buf *buf = container_of(vb, struct viu_buf, vb);
532 struct viu_fh *fh = vq->priv_data;
533 struct viu_dev *dev = fh->dev;
534 struct viu_dmaqueue *vidq = &dev->vidq;
535 struct viu_buf *prev;
536
537 if (!list_empty(&vidq->queued)) {
538 dprintk(1, "adding vb queue=0x%08lx\n",
539 (unsigned long)&buf->vb.queue);
540 dprintk(1, "vidq pointer 0x%p, queued 0x%p\n",
541 vidq, &vidq->queued);
542 dprintk(1, "dev %p, queued: self %p, next %p, head %p\n",
543 dev, &vidq->queued, vidq->queued.next,
544 vidq->queued.prev);
545 list_add_tail(&buf->vb.queue, &vidq->queued);
546 buf->vb.state = VIDEOBUF_QUEUED;
547 dprintk(2, "[%p/%d] buffer_queue - append to queued\n",
548 buf, buf->vb.i);
549 } else if (list_empty(&vidq->active)) {
550 dprintk(1, "adding vb active=0x%08lx\n",
551 (unsigned long)&buf->vb.queue);
552 list_add_tail(&buf->vb.queue, &vidq->active);
553 buf->vb.state = VIDEOBUF_ACTIVE;
554 mod_timer(&vidq->timeout, jiffies+BUFFER_TIMEOUT);
555 dprintk(2, "[%p/%d] buffer_queue - first active\n",
556 buf, buf->vb.i);
557
558 buffer_activate(dev, buf);
559 } else {
560 dprintk(1, "adding vb queue2=0x%08lx\n",
561 (unsigned long)&buf->vb.queue);
562 prev = list_entry(vidq->active.prev, struct viu_buf, vb.queue);
563 if (prev->vb.width == buf->vb.width &&
564 prev->vb.height == buf->vb.height &&
565 prev->fmt == buf->fmt) {
566 list_add_tail(&buf->vb.queue, &vidq->active);
567 buf->vb.state = VIDEOBUF_ACTIVE;
568 dprintk(2, "[%p/%d] buffer_queue - append to active\n",
569 buf, buf->vb.i);
570 } else {
571 list_add_tail(&buf->vb.queue, &vidq->queued);
572 buf->vb.state = VIDEOBUF_QUEUED;
573 dprintk(2, "[%p/%d] buffer_queue - first queued\n",
574 buf, buf->vb.i);
575 }
576 }
577 }
578
579 static void buffer_release(struct videobuf_queue *vq,
580 struct videobuf_buffer *vb)
581 {
582 struct viu_buf *buf = container_of(vb, struct viu_buf, vb);
583 struct viu_fh *fh = vq->priv_data;
584 struct viu_dev *dev = (struct viu_dev *)fh->dev;
585
586 viu_stop_dma(dev);
587 free_buffer(vq, buf);
588 }
589
590 static struct videobuf_queue_ops viu_video_qops = {
591 .buf_setup = buffer_setup,
592 .buf_prepare = buffer_prepare,
593 .buf_queue = buffer_queue,
594 .buf_release = buffer_release,
595 };
596
597 /*
598 * IOCTL vidioc handling
599 */
600 static int vidioc_querycap(struct file *file, void *priv,
601 struct v4l2_capability *cap)
602 {
603 strcpy(cap->driver, "viu");
604 strcpy(cap->card, "viu");
605 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
606 V4L2_CAP_STREAMING |
607 V4L2_CAP_VIDEO_OVERLAY |
608 V4L2_CAP_READWRITE;
609 return 0;
610 }
611
612 static int vidioc_enum_fmt(struct file *file, void *priv,
613 struct v4l2_fmtdesc *f)
614 {
615 int index = f->index;
616
617 if (f->index > NUM_FORMATS)
618 return -EINVAL;
619
620 strlcpy(f->description, formats[index].name, sizeof(f->description));
621 f->pixelformat = formats[index].fourcc;
622 return 0;
623 }
624
625 static int vidioc_g_fmt_cap(struct file *file, void *priv,
626 struct v4l2_format *f)
627 {
628 struct viu_fh *fh = priv;
629
630 f->fmt.pix.width = fh->width;
631 f->fmt.pix.height = fh->height;
632 f->fmt.pix.field = fh->vb_vidq.field;
633 f->fmt.pix.pixelformat = fh->fmt->pixelformat;
634 f->fmt.pix.bytesperline =
635 (f->fmt.pix.width * fh->fmt->depth) >> 3;
636 f->fmt.pix.sizeimage = fh->sizeimage;
637 return 0;
638 }
639
640 static int vidioc_try_fmt_cap(struct file *file, void *priv,
641 struct v4l2_format *f)
642 {
643 struct viu_fmt *fmt;
644 enum v4l2_field field;
645 unsigned int maxw, maxh;
646
647 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
648 if (!fmt) {
649 dprintk(1, "Fourcc format (0x%08x) invalid.",
650 f->fmt.pix.pixelformat);
651 return -EINVAL;
652 }
653
654 field = f->fmt.pix.field;
655
656 if (field == V4L2_FIELD_ANY) {
657 field = V4L2_FIELD_INTERLACED;
658 } else if (field != V4L2_FIELD_INTERLACED) {
659 dprintk(1, "Field type invalid.\n");
660 return -EINVAL;
661 }
662
663 maxw = norm_maxw();
664 maxh = norm_maxh();
665
666 f->fmt.pix.field = field;
667 if (f->fmt.pix.height < 32)
668 f->fmt.pix.height = 32;
669 if (f->fmt.pix.height > maxh)
670 f->fmt.pix.height = maxh;
671 if (f->fmt.pix.width < 48)
672 f->fmt.pix.width = 48;
673 if (f->fmt.pix.width > maxw)
674 f->fmt.pix.width = maxw;
675 f->fmt.pix.width &= ~0x03;
676 f->fmt.pix.bytesperline =
677 (f->fmt.pix.width * fmt->depth) >> 3;
678
679 return 0;
680 }
681
682 static int vidioc_s_fmt_cap(struct file *file, void *priv,
683 struct v4l2_format *f)
684 {
685 struct viu_fh *fh = priv;
686 int ret;
687
688 ret = vidioc_try_fmt_cap(file, fh, f);
689 if (ret < 0)
690 return ret;
691
692 fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
693 fh->width = f->fmt.pix.width;
694 fh->height = f->fmt.pix.height;
695 fh->sizeimage = f->fmt.pix.sizeimage;
696 fh->vb_vidq.field = f->fmt.pix.field;
697 fh->type = f->type;
698 dprintk(1, "set to pixelformat '%4.6s'\n", (char *)&fh->fmt->name);
699 return 0;
700 }
701
702 static int vidioc_g_fmt_overlay(struct file *file, void *priv,
703 struct v4l2_format *f)
704 {
705 struct viu_fh *fh = priv;
706
707 f->fmt.win = fh->win;
708 return 0;
709 }
710
711 static int verify_preview(struct viu_dev *dev, struct v4l2_window *win)
712 {
713 enum v4l2_field field;
714 int maxw, maxh;
715
716 if (dev->ovbuf.base == NULL)
717 return -EINVAL;
718 if (dev->ovfmt == NULL)
719 return -EINVAL;
720 if (win->w.width < 48 || win->w.height < 32)
721 return -EINVAL;
722
723 field = win->field;
724 maxw = dev->crop_current.width;
725 maxh = dev->crop_current.height;
726
727 if (field == V4L2_FIELD_ANY) {
728 field = (win->w.height > maxh/2)
729 ? V4L2_FIELD_INTERLACED
730 : V4L2_FIELD_TOP;
731 }
732 switch (field) {
733 case V4L2_FIELD_TOP:
734 case V4L2_FIELD_BOTTOM:
735 maxh = maxh / 2;
736 break;
737 case V4L2_FIELD_INTERLACED:
738 break;
739 default:
740 return -EINVAL;
741 }
742
743 win->field = field;
744 if (win->w.width > maxw)
745 win->w.width = maxw;
746 if (win->w.height > maxh)
747 win->w.height = maxh;
748 return 0;
749 }
750
751 inline void viu_activate_overlay(struct viu_reg *viu_reg)
752 {
753 struct viu_reg *vr = viu_reg;
754
755 out_be32(&vr->field_base_addr, reg_val.field_base_addr);
756 out_be32(&vr->dma_inc, reg_val.dma_inc);
757 out_be32(&vr->picture_count, reg_val.picture_count);
758 }
759
760 static int viu_setup_preview(struct viu_dev *dev, struct viu_fh *fh)
761 {
762 int bpp;
763
764 dprintk(1, "%s %dx%d %s\n", __func__,
765 fh->win.w.width, fh->win.w.height, dev->ovfmt->name);
766
767 reg_val.status_cfg = 0;
768
769 /* setup window */
770 reg_val.picture_count = (fh->win.w.height / 2) << 16 |
771 fh->win.w.width;
772
773 /* setup color depth and dma increment */
774 bpp = dev->ovfmt->depth / 8;
775 switch (bpp) {
776 case 2:
777 reg_val.status_cfg &= ~MODE_32BIT;
778 reg_val.dma_inc = fh->win.w.width * 2;
779 break;
780 case 4:
781 reg_val.status_cfg |= MODE_32BIT;
782 reg_val.dma_inc = fh->win.w.width * 4;
783 break;
784 default:
785 dprintk(0, "device doesn't support color depth(%d)\n",
786 bpp * 8);
787 return -EINVAL;
788 }
789
790 dev->ovfield = fh->win.field;
791 if (!V4L2_FIELD_HAS_BOTH(dev->ovfield))
792 reg_val.dma_inc = 0;
793
794 reg_val.status_cfg |= DMA_ACT | INT_DMA_END_EN | INT_FIELD_EN;
795
796 /* setup the base address of the overlay buffer */
797 reg_val.field_base_addr = (u32)dev->ovbuf.base;
798
799 return 0;
800 }
801
802 static int vidioc_s_fmt_overlay(struct file *file, void *priv,
803 struct v4l2_format *f)
804 {
805 struct viu_fh *fh = priv;
806 struct viu_dev *dev = (struct viu_dev *)fh->dev;
807 unsigned long flags;
808 int err;
809
810 err = verify_preview(dev, &f->fmt.win);
811 if (err)
812 return err;
813
814 fh->win = f->fmt.win;
815
816 spin_lock_irqsave(&dev->slock, flags);
817 viu_setup_preview(dev, fh);
818 spin_unlock_irqrestore(&dev->slock, flags);
819 return 0;
820 }
821
822 static int vidioc_try_fmt_overlay(struct file *file, void *priv,
823 struct v4l2_format *f)
824 {
825 return 0;
826 }
827
828 static int vidioc_overlay(struct file *file, void *priv, unsigned int on)
829 {
830 struct viu_fh *fh = priv;
831 struct viu_dev *dev = (struct viu_dev *)fh->dev;
832 unsigned long flags;
833
834 if (on) {
835 spin_lock_irqsave(&dev->slock, flags);
836 viu_activate_overlay(dev->vr);
837 dev->ovenable = 1;
838
839 /* start dma */
840 viu_start_dma(dev);
841 spin_unlock_irqrestore(&dev->slock, flags);
842 } else {
843 viu_stop_dma(dev);
844 dev->ovenable = 0;
845 }
846
847 return 0;
848 }
849
850 int vidioc_g_fbuf(struct file *file, void *priv, struct v4l2_framebuffer *arg)
851 {
852 struct viu_fh *fh = priv;
853 struct viu_dev *dev = fh->dev;
854 struct v4l2_framebuffer *fb = arg;
855
856 *fb = dev->ovbuf;
857 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
858 return 0;
859 }
860
861 int vidioc_s_fbuf(struct file *file, void *priv, const struct v4l2_framebuffer *arg)
862 {
863 struct viu_fh *fh = priv;
864 struct viu_dev *dev = fh->dev;
865 const struct v4l2_framebuffer *fb = arg;
866 struct viu_fmt *fmt;
867
868 if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO))
869 return -EPERM;
870
871 /* check args */
872 fmt = format_by_fourcc(fb->fmt.pixelformat);
873 if (fmt == NULL)
874 return -EINVAL;
875
876 /* ok, accept it */
877 dev->ovbuf = *fb;
878 dev->ovfmt = fmt;
879 if (dev->ovbuf.fmt.bytesperline == 0) {
880 dev->ovbuf.fmt.bytesperline =
881 dev->ovbuf.fmt.width * fmt->depth / 8;
882 }
883 return 0;
884 }
885
886 static int vidioc_reqbufs(struct file *file, void *priv,
887 struct v4l2_requestbuffers *p)
888 {
889 struct viu_fh *fh = priv;
890
891 return videobuf_reqbufs(&fh->vb_vidq, p);
892 }
893
894 static int vidioc_querybuf(struct file *file, void *priv,
895 struct v4l2_buffer *p)
896 {
897 struct viu_fh *fh = priv;
898
899 return videobuf_querybuf(&fh->vb_vidq, p);
900 }
901
902 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
903 {
904 struct viu_fh *fh = priv;
905
906 return videobuf_qbuf(&fh->vb_vidq, p);
907 }
908
909 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
910 {
911 struct viu_fh *fh = priv;
912
913 return videobuf_dqbuf(&fh->vb_vidq, p,
914 file->f_flags & O_NONBLOCK);
915 }
916
917 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
918 {
919 struct viu_fh *fh = priv;
920 struct viu_dev *dev = fh->dev;
921
922 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
923 return -EINVAL;
924 if (fh->type != i)
925 return -EINVAL;
926
927 if (dev->ovenable)
928 dev->ovenable = 0;
929
930 viu_start_dma(fh->dev);
931
932 return videobuf_streamon(&fh->vb_vidq);
933 }
934
935 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
936 {
937 struct viu_fh *fh = priv;
938
939 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
940 return -EINVAL;
941 if (fh->type != i)
942 return -EINVAL;
943
944 viu_stop_dma(fh->dev);
945
946 return videobuf_streamoff(&fh->vb_vidq);
947 }
948
949 #define decoder_call(viu, o, f, args...) \
950 v4l2_subdev_call(viu->decoder, o, f, ##args)
951
952 static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *std_id)
953 {
954 struct viu_fh *fh = priv;
955
956 decoder_call(fh->dev, video, querystd, std_id);
957 return 0;
958 }
959
960 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id)
961 {
962 struct viu_fh *fh = priv;
963
964 fh->dev->std = id;
965 decoder_call(fh->dev, core, s_std, id);
966 return 0;
967 }
968
969 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *std_id)
970 {
971 struct viu_fh *fh = priv;
972
973 *std_id = fh->dev->std;
974 return 0;
975 }
976
977 /* only one input in this driver */
978 static int vidioc_enum_input(struct file *file, void *priv,
979 struct v4l2_input *inp)
980 {
981 struct viu_fh *fh = priv;
982
983 if (inp->index != 0)
984 return -EINVAL;
985
986 inp->type = V4L2_INPUT_TYPE_CAMERA;
987 inp->std = fh->dev->vdev->tvnorms;
988 strcpy(inp->name, "Camera");
989 return 0;
990 }
991
992 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
993 {
994 *i = 0;
995 return 0;
996 }
997
998 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
999 {
1000 struct viu_fh *fh = priv;
1001
1002 if (i > 1)
1003 return -EINVAL;
1004
1005 decoder_call(fh->dev, video, s_routing, i, 0, 0);
1006 return 0;
1007 }
1008
1009 /* Controls */
1010 static int vidioc_queryctrl(struct file *file, void *priv,
1011 struct v4l2_queryctrl *qc)
1012 {
1013 int i;
1014
1015 for (i = 0; i < ARRAY_SIZE(viu_qctrl); i++) {
1016 if (qc->id && qc->id == viu_qctrl[i].id) {
1017 memcpy(qc, &(viu_qctrl[i]), sizeof(*qc));
1018 return 0;
1019 }
1020 }
1021 return -EINVAL;
1022 }
1023
1024 static int vidioc_g_ctrl(struct file *file, void *priv,
1025 struct v4l2_control *ctrl)
1026 {
1027 int i;
1028
1029 for (i = 0; i < ARRAY_SIZE(viu_qctrl); i++) {
1030 if (ctrl->id == viu_qctrl[i].id) {
1031 ctrl->value = qctl_regs[i];
1032 return 0;
1033 }
1034 }
1035 return -EINVAL;
1036 }
1037 static int vidioc_s_ctrl(struct file *file, void *priv,
1038 struct v4l2_control *ctrl)
1039 {
1040 int i;
1041
1042 for (i = 0; i < ARRAY_SIZE(viu_qctrl); i++) {
1043 if (ctrl->id == viu_qctrl[i].id) {
1044 if (ctrl->value < viu_qctrl[i].minimum
1045 || ctrl->value > viu_qctrl[i].maximum)
1046 return -ERANGE;
1047 qctl_regs[i] = ctrl->value;
1048 return 0;
1049 }
1050 }
1051 return -EINVAL;
1052 }
1053
1054 inline void viu_activate_next_buf(struct viu_dev *dev,
1055 struct viu_dmaqueue *viuq)
1056 {
1057 struct viu_dmaqueue *vidq = viuq;
1058 struct viu_buf *buf;
1059
1060 /* launch another DMA operation for an active/queued buffer */
1061 if (!list_empty(&vidq->active)) {
1062 buf = list_entry(vidq->active.next, struct viu_buf,
1063 vb.queue);
1064 dprintk(1, "start another queued buffer: 0x%p\n", buf);
1065 buffer_activate(dev, buf);
1066 } else if (!list_empty(&vidq->queued)) {
1067 buf = list_entry(vidq->queued.next, struct viu_buf,
1068 vb.queue);
1069 list_del(&buf->vb.queue);
1070
1071 dprintk(1, "start another queued buffer: 0x%p\n", buf);
1072 list_add_tail(&buf->vb.queue, &vidq->active);
1073 buf->vb.state = VIDEOBUF_ACTIVE;
1074 buffer_activate(dev, buf);
1075 }
1076 }
1077
1078 inline void viu_default_settings(struct viu_reg *viu_reg)
1079 {
1080 struct viu_reg *vr = viu_reg;
1081
1082 out_be32(&vr->luminance, 0x9512A254);
1083 out_be32(&vr->chroma_r, 0x03310000);
1084 out_be32(&vr->chroma_g, 0x06600F38);
1085 out_be32(&vr->chroma_b, 0x00000409);
1086 out_be32(&vr->alpha, 0x000000ff);
1087 out_be32(&vr->req_alarm, 0x00000090);
1088 dprintk(1, "status reg: 0x%08x, field base: 0x%08x\n",
1089 in_be32(&vr->status_cfg), in_be32(&vr->field_base_addr));
1090 }
1091
1092 static void viu_overlay_intr(struct viu_dev *dev, u32 status)
1093 {
1094 struct viu_reg *vr = dev->vr;
1095
1096 if (status & INT_DMA_END_STATUS)
1097 dev->dma_done = 1;
1098
1099 if (status & INT_FIELD_STATUS) {
1100 if (dev->dma_done) {
1101 u32 addr = reg_val.field_base_addr;
1102
1103 dev->dma_done = 0;
1104 if (status & FIELD_NO)
1105 addr += reg_val.dma_inc;
1106
1107 out_be32(&vr->field_base_addr, addr);
1108 out_be32(&vr->dma_inc, reg_val.dma_inc);
1109 out_be32(&vr->status_cfg,
1110 (status & 0xffc0ffff) |
1111 (status & INT_ALL_STATUS) |
1112 reg_val.status_cfg);
1113 } else if (status & INT_VSYNC_STATUS) {
1114 out_be32(&vr->status_cfg,
1115 (status & 0xffc0ffff) |
1116 (status & INT_ALL_STATUS) |
1117 reg_val.status_cfg);
1118 }
1119 }
1120 }
1121
1122 static void viu_capture_intr(struct viu_dev *dev, u32 status)
1123 {
1124 struct viu_dmaqueue *vidq = &dev->vidq;
1125 struct viu_reg *vr = dev->vr;
1126 struct viu_buf *buf;
1127 int field_num;
1128 int need_two;
1129 int dma_done = 0;
1130
1131 field_num = status & FIELD_NO;
1132 need_two = V4L2_FIELD_HAS_BOTH(dev->capfield);
1133
1134 if (status & INT_DMA_END_STATUS) {
1135 dma_done = 1;
1136 if (((field_num == 0) && (dev->field == 0)) ||
1137 (field_num && (dev->field == 1)))
1138 dev->field++;
1139 }
1140
1141 if (status & INT_FIELD_STATUS) {
1142 dprintk(1, "irq: field %d, done %d\n",
1143 !!field_num, dma_done);
1144 if (unlikely(dev->first)) {
1145 if (field_num == 0) {
1146 dev->first = 0;
1147 dprintk(1, "activate first buf\n");
1148 viu_activate_next_buf(dev, vidq);
1149 } else
1150 dprintk(1, "wait field 0\n");
1151 return;
1152 }
1153
1154 /* setup buffer address for next dma operation */
1155 if (!list_empty(&vidq->active)) {
1156 u32 addr = reg_val.field_base_addr;
1157
1158 if (field_num && need_two) {
1159 addr += reg_val.dma_inc;
1160 dprintk(1, "field 1, 0x%lx, dev field %d\n",
1161 (unsigned long)addr, dev->field);
1162 }
1163 out_be32(&vr->field_base_addr, addr);
1164 out_be32(&vr->dma_inc, reg_val.dma_inc);
1165 out_be32(&vr->status_cfg,
1166 (status & 0xffc0ffff) |
1167 (status & INT_ALL_STATUS) |
1168 reg_val.status_cfg);
1169 return;
1170 }
1171 }
1172
1173 if (dma_done && field_num && (dev->field == 2)) {
1174 dev->field = 0;
1175 buf = list_entry(vidq->active.next,
1176 struct viu_buf, vb.queue);
1177 dprintk(1, "viu/0: [%p/%d] 0x%lx/0x%lx: dma complete\n",
1178 buf, buf->vb.i,
1179 (unsigned long)videobuf_to_dma_contig(&buf->vb),
1180 (unsigned long)in_be32(&vr->field_base_addr));
1181
1182 if (waitqueue_active(&buf->vb.done)) {
1183 list_del(&buf->vb.queue);
1184 v4l2_get_timestamp(&buf->vb.ts);
1185 buf->vb.state = VIDEOBUF_DONE;
1186 buf->vb.field_count++;
1187 wake_up(&buf->vb.done);
1188 }
1189 /* activate next dma buffer */
1190 viu_activate_next_buf(dev, vidq);
1191 }
1192 }
1193
1194 static irqreturn_t viu_intr(int irq, void *dev_id)
1195 {
1196 struct viu_dev *dev = (struct viu_dev *)dev_id;
1197 struct viu_reg *vr = dev->vr;
1198 u32 status;
1199 u32 error;
1200
1201 status = in_be32(&vr->status_cfg);
1202
1203 if (status & INT_ERROR_STATUS) {
1204 dev->irqs.error_irq++;
1205 error = status & ERR_MASK;
1206 if (error)
1207 dprintk(1, "Err: error(%d), times:%d!\n",
1208 error >> 4, dev->irqs.error_irq);
1209 /* Clear interrupt error bit and error flags */
1210 out_be32(&vr->status_cfg,
1211 (status & 0xffc0ffff) | INT_ERROR_STATUS);
1212 }
1213
1214 if (status & INT_DMA_END_STATUS) {
1215 dev->irqs.dma_end_irq++;
1216 dev->dma_done = 1;
1217 dprintk(2, "VIU DMA end interrupt times: %d\n",
1218 dev->irqs.dma_end_irq);
1219 }
1220
1221 if (status & INT_HSYNC_STATUS)
1222 dev->irqs.hsync_irq++;
1223
1224 if (status & INT_FIELD_STATUS) {
1225 dev->irqs.field_irq++;
1226 dprintk(2, "VIU field interrupt times: %d\n",
1227 dev->irqs.field_irq);
1228 }
1229
1230 if (status & INT_VSTART_STATUS)
1231 dev->irqs.vstart_irq++;
1232
1233 if (status & INT_VSYNC_STATUS) {
1234 dev->irqs.vsync_irq++;
1235 dprintk(2, "VIU vsync interrupt times: %d\n",
1236 dev->irqs.vsync_irq);
1237 }
1238
1239 /* clear all pending irqs */
1240 status = in_be32(&vr->status_cfg);
1241 out_be32(&vr->status_cfg,
1242 (status & 0xffc0ffff) | (status & INT_ALL_STATUS));
1243
1244 if (dev->ovenable) {
1245 viu_overlay_intr(dev, status);
1246 return IRQ_HANDLED;
1247 }
1248
1249 /* Capture mode */
1250 viu_capture_intr(dev, status);
1251 return IRQ_HANDLED;
1252 }
1253
1254 /*
1255 * File operations for the device
1256 */
1257 static int viu_open(struct file *file)
1258 {
1259 struct video_device *vdev = video_devdata(file);
1260 struct viu_dev *dev = video_get_drvdata(vdev);
1261 struct viu_fh *fh;
1262 struct viu_reg *vr;
1263 int minor = vdev->minor;
1264 u32 status_cfg;
1265 int i;
1266
1267 dprintk(1, "viu: open (minor=%d)\n", minor);
1268
1269 dev->users++;
1270 if (dev->users > 1) {
1271 dev->users--;
1272 return -EBUSY;
1273 }
1274
1275 vr = dev->vr;
1276
1277 dprintk(1, "open minor=%d type=%s users=%d\n", minor,
1278 v4l2_type_names[V4L2_BUF_TYPE_VIDEO_CAPTURE], dev->users);
1279
1280 if (mutex_lock_interruptible(&dev->lock)) {
1281 dev->users--;
1282 return -ERESTARTSYS;
1283 }
1284
1285 /* allocate and initialize per filehandle data */
1286 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1287 if (!fh) {
1288 dev->users--;
1289 mutex_unlock(&dev->lock);
1290 return -ENOMEM;
1291 }
1292
1293 file->private_data = fh;
1294 fh->dev = dev;
1295
1296 fh->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1297 fh->fmt = format_by_fourcc(V4L2_PIX_FMT_RGB32);
1298 fh->width = norm_maxw();
1299 fh->height = norm_maxh();
1300 dev->crop_current.width = fh->width;
1301 dev->crop_current.height = fh->height;
1302
1303 /* Put all controls at a sane state */
1304 for (i = 0; i < ARRAY_SIZE(viu_qctrl); i++)
1305 qctl_regs[i] = viu_qctrl[i].default_value;
1306
1307 dprintk(1, "Open: fh=0x%08lx, dev=0x%08lx, dev->vidq=0x%08lx\n",
1308 (unsigned long)fh, (unsigned long)dev,
1309 (unsigned long)&dev->vidq);
1310 dprintk(1, "Open: list_empty queued=%d\n",
1311 list_empty(&dev->vidq.queued));
1312 dprintk(1, "Open: list_empty active=%d\n",
1313 list_empty(&dev->vidq.active));
1314
1315 viu_default_settings(vr);
1316
1317 status_cfg = in_be32(&vr->status_cfg);
1318 out_be32(&vr->status_cfg,
1319 status_cfg & ~(INT_VSYNC_EN | INT_HSYNC_EN |
1320 INT_FIELD_EN | INT_VSTART_EN |
1321 INT_DMA_END_EN | INT_ERROR_EN | INT_ECC_EN));
1322
1323 status_cfg = in_be32(&vr->status_cfg);
1324 out_be32(&vr->status_cfg, status_cfg | INT_ALL_STATUS);
1325
1326 spin_lock_init(&fh->vbq_lock);
1327 videobuf_queue_dma_contig_init(&fh->vb_vidq, &viu_video_qops,
1328 dev->dev, &fh->vbq_lock,
1329 fh->type, V4L2_FIELD_INTERLACED,
1330 sizeof(struct viu_buf), fh,
1331 &fh->dev->lock);
1332 mutex_unlock(&dev->lock);
1333 return 0;
1334 }
1335
1336 static ssize_t viu_read(struct file *file, char __user *data, size_t count,
1337 loff_t *ppos)
1338 {
1339 struct viu_fh *fh = file->private_data;
1340 struct viu_dev *dev = fh->dev;
1341 int ret = 0;
1342
1343 dprintk(2, "%s\n", __func__);
1344 if (dev->ovenable)
1345 dev->ovenable = 0;
1346
1347 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1348 if (mutex_lock_interruptible(&dev->lock))
1349 return -ERESTARTSYS;
1350 viu_start_dma(dev);
1351 ret = videobuf_read_stream(&fh->vb_vidq, data, count,
1352 ppos, 0, file->f_flags & O_NONBLOCK);
1353 mutex_unlock(&dev->lock);
1354 return ret;
1355 }
1356 return 0;
1357 }
1358
1359 static unsigned int viu_poll(struct file *file, struct poll_table_struct *wait)
1360 {
1361 struct viu_fh *fh = file->private_data;
1362 struct videobuf_queue *q = &fh->vb_vidq;
1363 struct viu_dev *dev = fh->dev;
1364 unsigned int res;
1365
1366 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1367 return POLLERR;
1368
1369 mutex_lock(&dev->lock);
1370 res = videobuf_poll_stream(file, q, wait);
1371 mutex_unlock(&dev->lock);
1372 return res;
1373 }
1374
1375 static int viu_release(struct file *file)
1376 {
1377 struct viu_fh *fh = file->private_data;
1378 struct viu_dev *dev = fh->dev;
1379 int minor = video_devdata(file)->minor;
1380
1381 mutex_lock(&dev->lock);
1382 viu_stop_dma(dev);
1383 videobuf_stop(&fh->vb_vidq);
1384 videobuf_mmap_free(&fh->vb_vidq);
1385 mutex_unlock(&dev->lock);
1386
1387 kfree(fh);
1388
1389 dev->users--;
1390 dprintk(1, "close (minor=%d, users=%d)\n",
1391 minor, dev->users);
1392 return 0;
1393 }
1394
1395 void viu_reset(struct viu_reg *reg)
1396 {
1397 out_be32(&reg->status_cfg, 0);
1398 out_be32(&reg->luminance, 0x9512a254);
1399 out_be32(&reg->chroma_r, 0x03310000);
1400 out_be32(&reg->chroma_g, 0x06600f38);
1401 out_be32(&reg->chroma_b, 0x00000409);
1402 out_be32(&reg->field_base_addr, 0);
1403 out_be32(&reg->dma_inc, 0);
1404 out_be32(&reg->picture_count, 0x01e002d0);
1405 out_be32(&reg->req_alarm, 0x00000090);
1406 out_be32(&reg->alpha, 0x000000ff);
1407 }
1408
1409 static int viu_mmap(struct file *file, struct vm_area_struct *vma)
1410 {
1411 struct viu_fh *fh = file->private_data;
1412 struct viu_dev *dev = fh->dev;
1413 int ret;
1414
1415 dprintk(1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1416
1417 if (mutex_lock_interruptible(&dev->lock))
1418 return -ERESTARTSYS;
1419 ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1420 mutex_unlock(&dev->lock);
1421
1422 dprintk(1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1423 (unsigned long)vma->vm_start,
1424 (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
1425 ret);
1426
1427 return ret;
1428 }
1429
1430 static struct v4l2_file_operations viu_fops = {
1431 .owner = THIS_MODULE,
1432 .open = viu_open,
1433 .release = viu_release,
1434 .read = viu_read,
1435 .poll = viu_poll,
1436 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1437 .mmap = viu_mmap,
1438 };
1439
1440 static const struct v4l2_ioctl_ops viu_ioctl_ops = {
1441 .vidioc_querycap = vidioc_querycap,
1442 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt,
1443 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_cap,
1444 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_cap,
1445 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_cap,
1446 .vidioc_enum_fmt_vid_overlay = vidioc_enum_fmt,
1447 .vidioc_g_fmt_vid_overlay = vidioc_g_fmt_overlay,
1448 .vidioc_try_fmt_vid_overlay = vidioc_try_fmt_overlay,
1449 .vidioc_s_fmt_vid_overlay = vidioc_s_fmt_overlay,
1450 .vidioc_overlay = vidioc_overlay,
1451 .vidioc_g_fbuf = vidioc_g_fbuf,
1452 .vidioc_s_fbuf = vidioc_s_fbuf,
1453 .vidioc_reqbufs = vidioc_reqbufs,
1454 .vidioc_querybuf = vidioc_querybuf,
1455 .vidioc_qbuf = vidioc_qbuf,
1456 .vidioc_dqbuf = vidioc_dqbuf,
1457 .vidioc_g_std = vidioc_g_std,
1458 .vidioc_s_std = vidioc_s_std,
1459 .vidioc_querystd = vidioc_querystd,
1460 .vidioc_enum_input = vidioc_enum_input,
1461 .vidioc_g_input = vidioc_g_input,
1462 .vidioc_s_input = vidioc_s_input,
1463 .vidioc_queryctrl = vidioc_queryctrl,
1464 .vidioc_g_ctrl = vidioc_g_ctrl,
1465 .vidioc_s_ctrl = vidioc_s_ctrl,
1466 .vidioc_streamon = vidioc_streamon,
1467 .vidioc_streamoff = vidioc_streamoff,
1468 };
1469
1470 static struct video_device viu_template = {
1471 .name = "FSL viu",
1472 .fops = &viu_fops,
1473 .minor = -1,
1474 .ioctl_ops = &viu_ioctl_ops,
1475 .release = video_device_release,
1476
1477 .tvnorms = V4L2_STD_NTSC_M | V4L2_STD_PAL,
1478 .current_norm = V4L2_STD_NTSC_M,
1479 };
1480
1481 static int viu_of_probe(struct platform_device *op)
1482 {
1483 struct viu_dev *viu_dev;
1484 struct video_device *vdev;
1485 struct resource r;
1486 struct viu_reg __iomem *viu_regs;
1487 struct i2c_adapter *ad;
1488 int ret, viu_irq;
1489
1490 ret = of_address_to_resource(op->dev.of_node, 0, &r);
1491 if (ret) {
1492 dev_err(&op->dev, "Can't parse device node resource\n");
1493 return -ENODEV;
1494 }
1495
1496 viu_irq = irq_of_parse_and_map(op->dev.of_node, 0);
1497 if (viu_irq == NO_IRQ) {
1498 dev_err(&op->dev, "Error while mapping the irq\n");
1499 return -EINVAL;
1500 }
1501
1502 /* request mem region */
1503 if (!devm_request_mem_region(&op->dev, r.start,
1504 sizeof(struct viu_reg), DRV_NAME)) {
1505 dev_err(&op->dev, "Error while requesting mem region\n");
1506 ret = -EBUSY;
1507 goto err;
1508 }
1509
1510 /* remap registers */
1511 viu_regs = devm_ioremap(&op->dev, r.start, sizeof(struct viu_reg));
1512 if (!viu_regs) {
1513 dev_err(&op->dev, "Can't map register set\n");
1514 ret = -ENOMEM;
1515 goto err;
1516 }
1517
1518 /* Prepare our private structure */
1519 viu_dev = devm_kzalloc(&op->dev, sizeof(struct viu_dev), GFP_ATOMIC);
1520 if (!viu_dev) {
1521 dev_err(&op->dev, "Can't allocate private structure\n");
1522 ret = -ENOMEM;
1523 goto err;
1524 }
1525
1526 viu_dev->vr = viu_regs;
1527 viu_dev->irq = viu_irq;
1528 viu_dev->dev = &op->dev;
1529
1530 /* init video dma queues */
1531 INIT_LIST_HEAD(&viu_dev->vidq.active);
1532 INIT_LIST_HEAD(&viu_dev->vidq.queued);
1533
1534 snprintf(viu_dev->v4l2_dev.name,
1535 sizeof(viu_dev->v4l2_dev.name), "%s", "VIU");
1536 ret = v4l2_device_register(viu_dev->dev, &viu_dev->v4l2_dev);
1537 if (ret < 0) {
1538 dev_err(&op->dev, "v4l2_device_register() failed: %d\n", ret);
1539 goto err;
1540 }
1541
1542 ad = i2c_get_adapter(0);
1543 viu_dev->decoder = v4l2_i2c_new_subdev(&viu_dev->v4l2_dev, ad,
1544 "saa7113", VIU_VIDEO_DECODER_ADDR, NULL);
1545
1546 viu_dev->vidq.timeout.function = viu_vid_timeout;
1547 viu_dev->vidq.timeout.data = (unsigned long)viu_dev;
1548 init_timer(&viu_dev->vidq.timeout);
1549 viu_dev->first = 1;
1550
1551 /* Allocate memory for video device */
1552 vdev = video_device_alloc();
1553 if (vdev == NULL) {
1554 ret = -ENOMEM;
1555 goto err_vdev;
1556 }
1557
1558 memcpy(vdev, &viu_template, sizeof(viu_template));
1559
1560 vdev->v4l2_dev = &viu_dev->v4l2_dev;
1561
1562 viu_dev->vdev = vdev;
1563
1564 /* initialize locks */
1565 mutex_init(&viu_dev->lock);
1566 viu_dev->vdev->lock = &viu_dev->lock;
1567 spin_lock_init(&viu_dev->slock);
1568
1569 video_set_drvdata(viu_dev->vdev, viu_dev);
1570
1571 mutex_lock(&viu_dev->lock);
1572
1573 ret = video_register_device(viu_dev->vdev, VFL_TYPE_GRABBER, -1);
1574 if (ret < 0) {
1575 video_device_release(viu_dev->vdev);
1576 goto err_vdev;
1577 }
1578
1579 /* enable VIU clock */
1580 viu_dev->clk = clk_get(&op->dev, "viu_clk");
1581 if (IS_ERR(viu_dev->clk)) {
1582 dev_err(&op->dev, "failed to find the clock module!\n");
1583 ret = -ENODEV;
1584 goto err_clk;
1585 } else {
1586 clk_enable(viu_dev->clk);
1587 }
1588
1589 /* reset VIU module */
1590 viu_reset(viu_dev->vr);
1591
1592 /* install interrupt handler */
1593 if (request_irq(viu_dev->irq, viu_intr, 0, "viu", (void *)viu_dev)) {
1594 dev_err(&op->dev, "Request VIU IRQ failed.\n");
1595 ret = -ENODEV;
1596 goto err_irq;
1597 }
1598
1599 mutex_unlock(&viu_dev->lock);
1600
1601 dev_info(&op->dev, "Freescale VIU Video Capture Board\n");
1602 return ret;
1603
1604 err_irq:
1605 clk_disable(viu_dev->clk);
1606 clk_put(viu_dev->clk);
1607 err_clk:
1608 video_unregister_device(viu_dev->vdev);
1609 err_vdev:
1610 mutex_unlock(&viu_dev->lock);
1611 i2c_put_adapter(ad);
1612 v4l2_device_unregister(&viu_dev->v4l2_dev);
1613 err:
1614 irq_dispose_mapping(viu_irq);
1615 return ret;
1616 }
1617
1618 static int viu_of_remove(struct platform_device *op)
1619 {
1620 struct v4l2_device *v4l2_dev = dev_get_drvdata(&op->dev);
1621 struct viu_dev *dev = container_of(v4l2_dev, struct viu_dev, v4l2_dev);
1622 struct v4l2_subdev *sdev = list_entry(v4l2_dev->subdevs.next,
1623 struct v4l2_subdev, list);
1624 struct i2c_client *client = v4l2_get_subdevdata(sdev);
1625
1626 free_irq(dev->irq, (void *)dev);
1627 irq_dispose_mapping(dev->irq);
1628
1629 clk_disable(dev->clk);
1630 clk_put(dev->clk);
1631
1632 video_unregister_device(dev->vdev);
1633 i2c_put_adapter(client->adapter);
1634 v4l2_device_unregister(&dev->v4l2_dev);
1635 return 0;
1636 }
1637
1638 #ifdef CONFIG_PM
1639 static int viu_suspend(struct platform_device *op, pm_message_t state)
1640 {
1641 struct v4l2_device *v4l2_dev = dev_get_drvdata(&op->dev);
1642 struct viu_dev *dev = container_of(v4l2_dev, struct viu_dev, v4l2_dev);
1643
1644 clk_disable(dev->clk);
1645 return 0;
1646 }
1647
1648 static int viu_resume(struct platform_device *op)
1649 {
1650 struct v4l2_device *v4l2_dev = dev_get_drvdata(&op->dev);
1651 struct viu_dev *dev = container_of(v4l2_dev, struct viu_dev, v4l2_dev);
1652
1653 clk_enable(dev->clk);
1654 return 0;
1655 }
1656 #endif
1657
1658 /*
1659 * Initialization and module stuff
1660 */
1661 static struct of_device_id mpc512x_viu_of_match[] = {
1662 {
1663 .compatible = "fsl,mpc5121-viu",
1664 },
1665 {},
1666 };
1667 MODULE_DEVICE_TABLE(of, mpc512x_viu_of_match);
1668
1669 static struct platform_driver viu_of_platform_driver = {
1670 .probe = viu_of_probe,
1671 .remove = viu_of_remove,
1672 #ifdef CONFIG_PM
1673 .suspend = viu_suspend,
1674 .resume = viu_resume,
1675 #endif
1676 .driver = {
1677 .name = DRV_NAME,
1678 .owner = THIS_MODULE,
1679 .of_match_table = mpc512x_viu_of_match,
1680 },
1681 };
1682
1683 module_platform_driver(viu_of_platform_driver);
1684
1685 MODULE_DESCRIPTION("Freescale Video-In(VIU)");
1686 MODULE_AUTHOR("Hongjun Chen");
1687 MODULE_LICENSE("GPL");
1688 MODULE_VERSION(VIU_VERSION);
Linux with added FPC-III support