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