Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
fsl-viu.c
Go to the documentation of this file.
1 /*
2  * Copyright 2008-2010 Freescale Semiconductor, Inc. All Rights Reserved.
3  *
4  * Freescale VIU video driver
5  *
6  * Authors: Hongjun Chen <[email protected]>
7  * Porting to 2.6.35 by DENX Software Engineering,
8  * Anatolij Gustschin <[email protected]>
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_del(&buf->vb.queue);
356  list_add_tail(&buf->vb.queue, &vidq->active);
357 
358  dprintk(1, "Restarting video dma\n");
359  viu_stop_dma(vidq->dev);
360  viu_start_dma(vidq->dev);
361 
362  buf->vb.state = VIDEOBUF_ACTIVE;
363  mod_timer(&vidq->timeout, jiffies+BUFFER_TIMEOUT);
364  dprintk(2, "[%p/%d] restart_queue - first active\n",
365  buf, buf->vb.i);
366 
367  } else if (prev->vb.width == buf->vb.width &&
368  prev->vb.height == buf->vb.height &&
369  prev->fmt == buf->fmt) {
370  list_del(&buf->vb.queue);
371  list_add_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 
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  */
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 
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 
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 
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 
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 
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  */
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->capabilities = V4L2_CAP_VIDEO_CAPTURE |
608  V4L2_CAP_STREAMING |
609  V4L2_CAP_VIDEO_OVERLAY |
610  V4L2_CAP_READWRITE;
611  return 0;
612 }
613 
614 static int vidioc_enum_fmt(struct file *file, void *priv,
615  struct v4l2_fmtdesc *f)
616 {
617  int index = f->index;
618 
619  if (f->index > NUM_FORMATS)
620  return -EINVAL;
621 
622  strlcpy(f->description, formats[index].name, sizeof(f->description));
623  f->pixelformat = formats[index].fourcc;
624  return 0;
625 }
626 
627 static int vidioc_g_fmt_cap(struct file *file, void *priv,
628  struct v4l2_format *f)
629 {
630  struct viu_fh *fh = priv;
631 
632  f->fmt.pix.width = fh->width;
633  f->fmt.pix.height = fh->height;
634  f->fmt.pix.field = fh->vb_vidq.field;
635  f->fmt.pix.pixelformat = fh->fmt->pixelformat;
636  f->fmt.pix.bytesperline =
637  (f->fmt.pix.width * fh->fmt->depth) >> 3;
638  f->fmt.pix.sizeimage = fh->sizeimage;
639  return 0;
640 }
641 
642 static int vidioc_try_fmt_cap(struct file *file, void *priv,
643  struct v4l2_format *f)
644 {
645  struct viu_fmt *fmt;
646  enum v4l2_field field;
647  unsigned int maxw, maxh;
648 
649  fmt = format_by_fourcc(f->fmt.pix.pixelformat);
650  if (!fmt) {
651  dprintk(1, "Fourcc format (0x%08x) invalid.",
652  f->fmt.pix.pixelformat);
653  return -EINVAL;
654  }
655 
656  field = f->fmt.pix.field;
657 
658  if (field == V4L2_FIELD_ANY) {
659  field = V4L2_FIELD_INTERLACED;
660  } else if (field != V4L2_FIELD_INTERLACED) {
661  dprintk(1, "Field type invalid.\n");
662  return -EINVAL;
663  }
664 
665  maxw = norm_maxw();
666  maxh = norm_maxh();
667 
668  f->fmt.pix.field = field;
669  if (f->fmt.pix.height < 32)
670  f->fmt.pix.height = 32;
671  if (f->fmt.pix.height > maxh)
672  f->fmt.pix.height = maxh;
673  if (f->fmt.pix.width < 48)
674  f->fmt.pix.width = 48;
675  if (f->fmt.pix.width > maxw)
676  f->fmt.pix.width = maxw;
677  f->fmt.pix.width &= ~0x03;
678  f->fmt.pix.bytesperline =
679  (f->fmt.pix.width * fmt->depth) >> 3;
680 
681  return 0;
682 }
683 
684 static int vidioc_s_fmt_cap(struct file *file, void *priv,
685  struct v4l2_format *f)
686 {
687  struct viu_fh *fh = priv;
688  int ret;
689 
690  ret = vidioc_try_fmt_cap(file, fh, f);
691  if (ret < 0)
692  return ret;
693 
694  fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
695  fh->width = f->fmt.pix.width;
696  fh->height = f->fmt.pix.height;
697  fh->sizeimage = f->fmt.pix.sizeimage;
698  fh->vb_vidq.field = f->fmt.pix.field;
699  fh->type = f->type;
700  dprintk(1, "set to pixelformat '%4.6s'\n", (char *)&fh->fmt->name);
701  return 0;
702 }
703 
704 static int vidioc_g_fmt_overlay(struct file *file, void *priv,
705  struct v4l2_format *f)
706 {
707  struct viu_fh *fh = priv;
708 
709  f->fmt.win = fh->win;
710  return 0;
711 }
712 
713 static int verify_preview(struct viu_dev *dev, struct v4l2_window *win)
714 {
715  enum v4l2_field field;
716  int maxw, maxh;
717 
718  if (dev->ovbuf.base == NULL)
719  return -EINVAL;
720  if (dev->ovfmt == NULL)
721  return -EINVAL;
722  if (win->w.width < 48 || win->w.height < 32)
723  return -EINVAL;
724 
725  field = win->field;
726  maxw = dev->crop_current.width;
727  maxh = dev->crop_current.height;
728 
729  if (field == V4L2_FIELD_ANY) {
730  field = (win->w.height > maxh/2)
731  ? V4L2_FIELD_INTERLACED
732  : V4L2_FIELD_TOP;
733  }
734  switch (field) {
735  case V4L2_FIELD_TOP:
736  case V4L2_FIELD_BOTTOM:
737  maxh = maxh / 2;
738  break;
739  case V4L2_FIELD_INTERLACED:
740  break;
741  default:
742  return -EINVAL;
743  }
744 
745  win->field = field;
746  if (win->w.width > maxw)
747  win->w.width = maxw;
748  if (win->w.height > maxh)
749  win->w.height = maxh;
750  return 0;
751 }
752 
753 inline void viu_activate_overlay(struct viu_reg *viu_reg)
754 {
755  struct viu_reg *vr = viu_reg;
756 
757  out_be32(&vr->field_base_addr, reg_val.field_base_addr);
758  out_be32(&vr->dma_inc, reg_val.dma_inc);
759  out_be32(&vr->picture_count, reg_val.picture_count);
760 }
761 
762 static int viu_setup_preview(struct viu_dev *dev, struct viu_fh *fh)
763 {
764  int bpp;
765 
766  dprintk(1, "%s %dx%d %s\n", __func__,
767  fh->win.w.width, fh->win.w.height, dev->ovfmt->name);
768 
769  reg_val.status_cfg = 0;
770 
771  /* setup window */
772  reg_val.picture_count = (fh->win.w.height / 2) << 16 |
773  fh->win.w.width;
774 
775  /* setup color depth and dma increment */
776  bpp = dev->ovfmt->depth / 8;
777  switch (bpp) {
778  case 2:
779  reg_val.status_cfg &= ~MODE_32BIT;
780  reg_val.dma_inc = fh->win.w.width * 2;
781  break;
782  case 4:
783  reg_val.status_cfg |= MODE_32BIT;
784  reg_val.dma_inc = fh->win.w.width * 4;
785  break;
786  default:
787  dprintk(0, "device doesn't support color depth(%d)\n",
788  bpp * 8);
789  return -EINVAL;
790  }
791 
792  dev->ovfield = fh->win.field;
793  if (!V4L2_FIELD_HAS_BOTH(dev->ovfield))
794  reg_val.dma_inc = 0;
795 
796  reg_val.status_cfg |= DMA_ACT | INT_DMA_END_EN | INT_FIELD_EN;
797 
798  /* setup the base address of the overlay buffer */
799  reg_val.field_base_addr = (u32)dev->ovbuf.base;
800 
801  return 0;
802 }
803 
804 static int vidioc_s_fmt_overlay(struct file *file, void *priv,
805  struct v4l2_format *f)
806 {
807  struct viu_fh *fh = priv;
808  struct viu_dev *dev = (struct viu_dev *)fh->dev;
809  unsigned long flags;
810  int err;
811 
812  err = verify_preview(dev, &f->fmt.win);
813  if (err)
814  return err;
815 
816  fh->win = f->fmt.win;
817 
818  spin_lock_irqsave(&dev->slock, flags);
819  viu_setup_preview(dev, fh);
820  spin_unlock_irqrestore(&dev->slock, flags);
821  return 0;
822 }
823 
824 static int vidioc_try_fmt_overlay(struct file *file, void *priv,
825  struct v4l2_format *f)
826 {
827  return 0;
828 }
829 
830 static int vidioc_overlay(struct file *file, void *priv, unsigned int on)
831 {
832  struct viu_fh *fh = priv;
833  struct viu_dev *dev = (struct viu_dev *)fh->dev;
834  unsigned long flags;
835 
836  if (on) {
837  spin_lock_irqsave(&dev->slock, flags);
838  viu_activate_overlay(dev->vr);
839  dev->ovenable = 1;
840 
841  /* start dma */
842  viu_start_dma(dev);
843  spin_unlock_irqrestore(&dev->slock, flags);
844  } else {
845  viu_stop_dma(dev);
846  dev->ovenable = 0;
847  }
848 
849  return 0;
850 }
851 
852 int vidioc_g_fbuf(struct file *file, void *priv, struct v4l2_framebuffer *arg)
853 {
854  struct viu_fh *fh = priv;
855  struct viu_dev *dev = fh->dev;
856  struct v4l2_framebuffer *fb = arg;
857 
858  *fb = dev->ovbuf;
859  fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
860  return 0;
861 }
862 
863 int vidioc_s_fbuf(struct file *file, void *priv, const struct v4l2_framebuffer *arg)
864 {
865  struct viu_fh *fh = priv;
866  struct viu_dev *dev = fh->dev;
867  const struct v4l2_framebuffer *fb = arg;
868  struct viu_fmt *fmt;
869 
870  if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO))
871  return -EPERM;
872 
873  /* check args */
874  fmt = format_by_fourcc(fb->fmt.pixelformat);
875  if (fmt == NULL)
876  return -EINVAL;
877 
878  /* ok, accept it */
879  dev->ovbuf = *fb;
880  dev->ovfmt = fmt;
881  if (dev->ovbuf.fmt.bytesperline == 0) {
882  dev->ovbuf.fmt.bytesperline =
883  dev->ovbuf.fmt.width * fmt->depth / 8;
884  }
885  return 0;
886 }
887 
888 static int vidioc_reqbufs(struct file *file, void *priv,
889  struct v4l2_requestbuffers *p)
890 {
891  struct viu_fh *fh = priv;
892 
893  return videobuf_reqbufs(&fh->vb_vidq, p);
894 }
895 
896 static int vidioc_querybuf(struct file *file, void *priv,
897  struct v4l2_buffer *p)
898 {
899  struct viu_fh *fh = priv;
900 
901  return videobuf_querybuf(&fh->vb_vidq, p);
902 }
903 
904 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
905 {
906  struct viu_fh *fh = priv;
907 
908  return videobuf_qbuf(&fh->vb_vidq, p);
909 }
910 
911 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
912 {
913  struct viu_fh *fh = priv;
914 
915  return videobuf_dqbuf(&fh->vb_vidq, p,
916  file->f_flags & O_NONBLOCK);
917 }
918 
919 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
920 {
921  struct viu_fh *fh = priv;
922  struct viu_dev *dev = fh->dev;
923 
924  if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
925  return -EINVAL;
926  if (fh->type != i)
927  return -EINVAL;
928 
929  if (dev->ovenable)
930  dev->ovenable = 0;
931 
932  viu_start_dma(fh->dev);
933 
934  return videobuf_streamon(&fh->vb_vidq);
935 }
936 
937 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
938 {
939  struct viu_fh *fh = priv;
940 
941  if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
942  return -EINVAL;
943  if (fh->type != i)
944  return -EINVAL;
945 
946  viu_stop_dma(fh->dev);
947 
948  return videobuf_streamoff(&fh->vb_vidq);
949 }
950 
951 #define decoder_call(viu, o, f, args...) \
952  v4l2_subdev_call(viu->decoder, o, f, ##args)
953 
954 static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *std_id)
955 {
956  struct viu_fh *fh = priv;
957 
958  decoder_call(fh->dev, video, querystd, std_id);
959  return 0;
960 }
961 
962 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *id)
963 {
964  struct viu_fh *fh = priv;
965 
966  fh->dev->std = *id;
967  decoder_call(fh->dev, core, s_std, *id);
968  return 0;
969 }
970 
971 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *std_id)
972 {
973  struct viu_fh *fh = priv;
974 
975  *std_id = fh->dev->std;
976  return 0;
977 }
978 
979 /* only one input in this driver */
980 static int vidioc_enum_input(struct file *file, void *priv,
981  struct v4l2_input *inp)
982 {
983  struct viu_fh *fh = priv;
984 
985  if (inp->index != 0)
986  return -EINVAL;
987 
988  inp->type = V4L2_INPUT_TYPE_CAMERA;
989  inp->std = fh->dev->vdev->tvnorms;
990  strcpy(inp->name, "Camera");
991  return 0;
992 }
993 
994 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
995 {
996  *i = 0;
997  return 0;
998 }
999 
1000 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1001 {
1002  struct viu_fh *fh = priv;
1003 
1004  if (i > 1)
1005  return -EINVAL;
1006 
1007  decoder_call(fh->dev, video, s_routing, i, 0, 0);
1008  return 0;
1009 }
1010 
1011 /* Controls */
1012 static int vidioc_queryctrl(struct file *file, void *priv,
1013  struct v4l2_queryctrl *qc)
1014 {
1015  int i;
1016 
1017  for (i = 0; i < ARRAY_SIZE(viu_qctrl); i++) {
1018  if (qc->id && qc->id == viu_qctrl[i].id) {
1019  memcpy(qc, &(viu_qctrl[i]), sizeof(*qc));
1020  return 0;
1021  }
1022  }
1023  return -EINVAL;
1024 }
1025 
1026 static int vidioc_g_ctrl(struct file *file, void *priv,
1027  struct v4l2_control *ctrl)
1028 {
1029  int i;
1030 
1031  for (i = 0; i < ARRAY_SIZE(viu_qctrl); i++) {
1032  if (ctrl->id == viu_qctrl[i].id) {
1033  ctrl->value = qctl_regs[i];
1034  return 0;
1035  }
1036  }
1037  return -EINVAL;
1038 }
1039 static int vidioc_s_ctrl(struct file *file, void *priv,
1040  struct v4l2_control *ctrl)
1041 {
1042  int i;
1043 
1044  for (i = 0; i < ARRAY_SIZE(viu_qctrl); i++) {
1045  if (ctrl->id == viu_qctrl[i].id) {
1046  if (ctrl->value < viu_qctrl[i].minimum
1047  || ctrl->value > viu_qctrl[i].maximum)
1048  return -ERANGE;
1049  qctl_regs[i] = ctrl->value;
1050  return 0;
1051  }
1052  }
1053  return -EINVAL;
1054 }
1055 
1056 inline void viu_activate_next_buf(struct viu_dev *dev,
1057  struct viu_dmaqueue *viuq)
1058 {
1059  struct viu_dmaqueue *vidq = viuq;
1060  struct viu_buf *buf;
1061 
1062  /* launch another DMA operation for an active/queued buffer */
1063  if (!list_empty(&vidq->active)) {
1064  buf = list_entry(vidq->active.next, struct viu_buf,
1065  vb.queue);
1066  dprintk(1, "start another queued buffer: 0x%p\n", buf);
1067  buffer_activate(dev, buf);
1068  } else if (!list_empty(&vidq->queued)) {
1069  buf = list_entry(vidq->queued.next, struct viu_buf,
1070  vb.queue);
1071  list_del(&buf->vb.queue);
1072 
1073  dprintk(1, "start another queued buffer: 0x%p\n", buf);
1074  list_add_tail(&buf->vb.queue, &vidq->active);
1075  buf->vb.state = VIDEOBUF_ACTIVE;
1076  buffer_activate(dev, buf);
1077  }
1078 }
1079 
1080 inline void viu_default_settings(struct viu_reg *viu_reg)
1081 {
1082  struct viu_reg *vr = viu_reg;
1083 
1084  out_be32(&vr->luminance, 0x9512A254);
1085  out_be32(&vr->chroma_r, 0x03310000);
1086  out_be32(&vr->chroma_g, 0x06600F38);
1087  out_be32(&vr->chroma_b, 0x00000409);
1088  out_be32(&vr->alpha, 0x000000ff);
1089  out_be32(&vr->req_alarm, 0x00000090);
1090  dprintk(1, "status reg: 0x%08x, field base: 0x%08x\n",
1091  in_be32(&vr->status_cfg), in_be32(&vr->field_base_addr));
1092 }
1093 
1094 static void viu_overlay_intr(struct viu_dev *dev, u32 status)
1095 {
1096  struct viu_reg *vr = dev->vr;
1097 
1098  if (status & INT_DMA_END_STATUS)
1099  dev->dma_done = 1;
1100 
1101  if (status & INT_FIELD_STATUS) {
1102  if (dev->dma_done) {
1103  u32 addr = reg_val.field_base_addr;
1104 
1105  dev->dma_done = 0;
1106  if (status & FIELD_NO)
1107  addr += reg_val.dma_inc;
1108 
1109  out_be32(&vr->field_base_addr, addr);
1110  out_be32(&vr->dma_inc, reg_val.dma_inc);
1111  out_be32(&vr->status_cfg,
1112  (status & 0xffc0ffff) |
1113  (status & INT_ALL_STATUS) |
1114  reg_val.status_cfg);
1115  } else if (status & INT_VSYNC_STATUS) {
1116  out_be32(&vr->status_cfg,
1117  (status & 0xffc0ffff) |
1118  (status & INT_ALL_STATUS) |
1119  reg_val.status_cfg);
1120  }
1121  }
1122 }
1123 
1124 static void viu_capture_intr(struct viu_dev *dev, u32 status)
1125 {
1126  struct viu_dmaqueue *vidq = &dev->vidq;
1127  struct viu_reg *vr = dev->vr;
1128  struct viu_buf *buf;
1129  int field_num;
1130  int need_two;
1131  int dma_done = 0;
1132 
1133  field_num = status & FIELD_NO;
1134  need_two = V4L2_FIELD_HAS_BOTH(dev->capfield);
1135 
1136  if (status & INT_DMA_END_STATUS) {
1137  dma_done = 1;
1138  if (((field_num == 0) && (dev->field == 0)) ||
1139  (field_num && (dev->field == 1)))
1140  dev->field++;
1141  }
1142 
1143  if (status & INT_FIELD_STATUS) {
1144  dprintk(1, "irq: field %d, done %d\n",
1145  !!field_num, dma_done);
1146  if (unlikely(dev->first)) {
1147  if (field_num == 0) {
1148  dev->first = 0;
1149  dprintk(1, "activate first buf\n");
1150  viu_activate_next_buf(dev, vidq);
1151  } else
1152  dprintk(1, "wait field 0\n");
1153  return;
1154  }
1155 
1156  /* setup buffer address for next dma operation */
1157  if (!list_empty(&vidq->active)) {
1158  u32 addr = reg_val.field_base_addr;
1159 
1160  if (field_num && need_two) {
1161  addr += reg_val.dma_inc;
1162  dprintk(1, "field 1, 0x%lx, dev field %d\n",
1163  (unsigned long)addr, dev->field);
1164  }
1165  out_be32(&vr->field_base_addr, addr);
1166  out_be32(&vr->dma_inc, reg_val.dma_inc);
1167  out_be32(&vr->status_cfg,
1168  (status & 0xffc0ffff) |
1169  (status & INT_ALL_STATUS) |
1170  reg_val.status_cfg);
1171  return;
1172  }
1173  }
1174 
1175  if (dma_done && field_num && (dev->field == 2)) {
1176  dev->field = 0;
1177  buf = list_entry(vidq->active.next,
1178  struct viu_buf, vb.queue);
1179  dprintk(1, "viu/0: [%p/%d] 0x%lx/0x%lx: dma complete\n",
1180  buf, buf->vb.i,
1181  (unsigned long)videobuf_to_dma_contig(&buf->vb),
1182  (unsigned long)in_be32(&vr->field_base_addr));
1183 
1184  if (waitqueue_active(&buf->vb.done)) {
1185  list_del(&buf->vb.queue);
1186  do_gettimeofday(&buf->vb.ts);
1187  buf->vb.state = VIDEOBUF_DONE;
1188  buf->vb.field_count++;
1189  wake_up(&buf->vb.done);
1190  }
1191  /* activate next dma buffer */
1192  viu_activate_next_buf(dev, vidq);
1193  }
1194 }
1195 
1196 static irqreturn_t viu_intr(int irq, void *dev_id)
1197 {
1198  struct viu_dev *dev = (struct viu_dev *)dev_id;
1199  struct viu_reg *vr = dev->vr;
1200  u32 status;
1201  u32 error;
1202 
1203  status = in_be32(&vr->status_cfg);
1204 
1205  if (status & INT_ERROR_STATUS) {
1206  dev->irqs.error_irq++;
1207  error = status & ERR_MASK;
1208  if (error)
1209  dprintk(1, "Err: error(%d), times:%d!\n",
1210  error >> 4, dev->irqs.error_irq);
1211  /* Clear interrupt error bit and error flags */
1212  out_be32(&vr->status_cfg,
1213  (status & 0xffc0ffff) | INT_ERROR_STATUS);
1214  }
1215 
1216  if (status & INT_DMA_END_STATUS) {
1217  dev->irqs.dma_end_irq++;
1218  dev->dma_done = 1;
1219  dprintk(2, "VIU DMA end interrupt times: %d\n",
1220  dev->irqs.dma_end_irq);
1221  }
1222 
1223  if (status & INT_HSYNC_STATUS)
1224  dev->irqs.hsync_irq++;
1225 
1226  if (status & INT_FIELD_STATUS) {
1227  dev->irqs.field_irq++;
1228  dprintk(2, "VIU field interrupt times: %d\n",
1229  dev->irqs.field_irq);
1230  }
1231 
1232  if (status & INT_VSTART_STATUS)
1233  dev->irqs.vstart_irq++;
1234 
1235  if (status & INT_VSYNC_STATUS) {
1236  dev->irqs.vsync_irq++;
1237  dprintk(2, "VIU vsync interrupt times: %d\n",
1238  dev->irqs.vsync_irq);
1239  }
1240 
1241  /* clear all pending irqs */
1242  status = in_be32(&vr->status_cfg);
1243  out_be32(&vr->status_cfg,
1244  (status & 0xffc0ffff) | (status & INT_ALL_STATUS));
1245 
1246  if (dev->ovenable) {
1247  viu_overlay_intr(dev, status);
1248  return IRQ_HANDLED;
1249  }
1250 
1251  /* Capture mode */
1252  viu_capture_intr(dev, status);
1253  return IRQ_HANDLED;
1254 }
1255 
1256 /*
1257  * File operations for the device
1258  */
1259 static int viu_open(struct file *file)
1260 {
1261  struct video_device *vdev = video_devdata(file);
1262  struct viu_dev *dev = video_get_drvdata(vdev);
1263  struct viu_fh *fh;
1264  struct viu_reg *vr;
1265  int minor = vdev->minor;
1266  u32 status_cfg;
1267  int i;
1268 
1269  dprintk(1, "viu: open (minor=%d)\n", minor);
1270 
1271  dev->users++;
1272  if (dev->users > 1) {
1273  dev->users--;
1274  return -EBUSY;
1275  }
1276 
1277  vr = dev->vr;
1278 
1279  dprintk(1, "open minor=%d type=%s users=%d\n", minor,
1280  v4l2_type_names[V4L2_BUF_TYPE_VIDEO_CAPTURE], dev->users);
1281 
1282  if (mutex_lock_interruptible(&dev->lock)) {
1283  dev->users--;
1284  return -ERESTARTSYS;
1285  }
1286 
1287  /* allocate and initialize per filehandle data */
1288  fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1289  if (!fh) {
1290  dev->users--;
1291  mutex_unlock(&dev->lock);
1292  return -ENOMEM;
1293  }
1294 
1295  file->private_data = fh;
1296  fh->dev = dev;
1297 
1298  fh->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1299  fh->fmt = format_by_fourcc(V4L2_PIX_FMT_RGB32);
1300  fh->width = norm_maxw();
1301  fh->height = norm_maxh();
1302  dev->crop_current.width = fh->width;
1303  dev->crop_current.height = fh->height;
1304 
1305  /* Put all controls at a sane state */
1306  for (i = 0; i < ARRAY_SIZE(viu_qctrl); i++)
1307  qctl_regs[i] = viu_qctrl[i].default_value;
1308 
1309  dprintk(1, "Open: fh=0x%08lx, dev=0x%08lx, dev->vidq=0x%08lx\n",
1310  (unsigned long)fh, (unsigned long)dev,
1311  (unsigned long)&dev->vidq);
1312  dprintk(1, "Open: list_empty queued=%d\n",
1313  list_empty(&dev->vidq.queued));
1314  dprintk(1, "Open: list_empty active=%d\n",
1315  list_empty(&dev->vidq.active));
1316 
1317  viu_default_settings(vr);
1318 
1319  status_cfg = in_be32(&vr->status_cfg);
1320  out_be32(&vr->status_cfg,
1321  status_cfg & ~(INT_VSYNC_EN | INT_HSYNC_EN |
1322  INT_FIELD_EN | INT_VSTART_EN |
1323  INT_DMA_END_EN | INT_ERROR_EN | INT_ECC_EN));
1324 
1325  status_cfg = in_be32(&vr->status_cfg);
1326  out_be32(&vr->status_cfg, status_cfg | INT_ALL_STATUS);
1327 
1328  spin_lock_init(&fh->vbq_lock);
1329  videobuf_queue_dma_contig_init(&fh->vb_vidq, &viu_video_qops,
1330  dev->dev, &fh->vbq_lock,
1331  fh->type, V4L2_FIELD_INTERLACED,
1332  sizeof(struct viu_buf), fh,
1333  &fh->dev->lock);
1334  mutex_unlock(&dev->lock);
1335  return 0;
1336 }
1337 
1338 static ssize_t viu_read(struct file *file, char __user *data, size_t count,
1339  loff_t *ppos)
1340 {
1341  struct viu_fh *fh = file->private_data;
1342  struct viu_dev *dev = fh->dev;
1343  int ret = 0;
1344 
1345  dprintk(2, "%s\n", __func__);
1346  if (dev->ovenable)
1347  dev->ovenable = 0;
1348 
1349  if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1350  if (mutex_lock_interruptible(&dev->lock))
1351  return -ERESTARTSYS;
1352  viu_start_dma(dev);
1353  ret = videobuf_read_stream(&fh->vb_vidq, data, count,
1354  ppos, 0, file->f_flags & O_NONBLOCK);
1355  mutex_unlock(&dev->lock);
1356  return ret;
1357  }
1358  return 0;
1359 }
1360 
1361 static unsigned int viu_poll(struct file *file, struct poll_table_struct *wait)
1362 {
1363  struct viu_fh *fh = file->private_data;
1364  struct videobuf_queue *q = &fh->vb_vidq;
1365  struct viu_dev *dev = fh->dev;
1366  unsigned int res;
1367 
1368  if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1369  return POLLERR;
1370 
1371  mutex_lock(&dev->lock);
1372  res = videobuf_poll_stream(file, q, wait);
1373  mutex_unlock(&dev->lock);
1374  return res;
1375 }
1376 
1377 static int viu_release(struct file *file)
1378 {
1379  struct viu_fh *fh = file->private_data;
1380  struct viu_dev *dev = fh->dev;
1381  int minor = video_devdata(file)->minor;
1382 
1383  mutex_lock(&dev->lock);
1384  viu_stop_dma(dev);
1385  videobuf_stop(&fh->vb_vidq);
1386  videobuf_mmap_free(&fh->vb_vidq);
1387  mutex_unlock(&dev->lock);
1388 
1389  kfree(fh);
1390 
1391  dev->users--;
1392  dprintk(1, "close (minor=%d, users=%d)\n",
1393  minor, dev->users);
1394  return 0;
1395 }
1396 
1397 void viu_reset(struct viu_reg *reg)
1398 {
1399  out_be32(&reg->status_cfg, 0);
1400  out_be32(&reg->luminance, 0x9512a254);
1401  out_be32(&reg->chroma_r, 0x03310000);
1402  out_be32(&reg->chroma_g, 0x06600f38);
1403  out_be32(&reg->chroma_b, 0x00000409);
1404  out_be32(&reg->field_base_addr, 0);
1405  out_be32(&reg->dma_inc, 0);
1406  out_be32(&reg->picture_count, 0x01e002d0);
1407  out_be32(&reg->req_alarm, 0x00000090);
1408  out_be32(&reg->alpha, 0x000000ff);
1409 }
1410 
1411 static int viu_mmap(struct file *file, struct vm_area_struct *vma)
1412 {
1413  struct viu_fh *fh = file->private_data;
1414  struct viu_dev *dev = fh->dev;
1415  int ret;
1416 
1417  dprintk(1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1418 
1419  if (mutex_lock_interruptible(&dev->lock))
1420  return -ERESTARTSYS;
1421  ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1422  mutex_unlock(&dev->lock);
1423 
1424  dprintk(1, "vma start=0x%08lx, size=%ld, ret=%d\n",
1425  (unsigned long)vma->vm_start,
1426  (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
1427  ret);
1428 
1429  return ret;
1430 }
1431 
1432 static struct v4l2_file_operations viu_fops = {
1433  .owner = THIS_MODULE,
1434  .open = viu_open,
1435  .release = viu_release,
1436  .read = viu_read,
1437  .poll = viu_poll,
1438  .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1439  .mmap = viu_mmap,
1440 };
1441 
1442 static const struct v4l2_ioctl_ops viu_ioctl_ops = {
1443  .vidioc_querycap = vidioc_querycap,
1444  .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt,
1445  .vidioc_g_fmt_vid_cap = vidioc_g_fmt_cap,
1446  .vidioc_try_fmt_vid_cap = vidioc_try_fmt_cap,
1447  .vidioc_s_fmt_vid_cap = vidioc_s_fmt_cap,
1448  .vidioc_enum_fmt_vid_overlay = vidioc_enum_fmt,
1449  .vidioc_g_fmt_vid_overlay = vidioc_g_fmt_overlay,
1450  .vidioc_try_fmt_vid_overlay = vidioc_try_fmt_overlay,
1451  .vidioc_s_fmt_vid_overlay = vidioc_s_fmt_overlay,
1452  .vidioc_overlay = vidioc_overlay,
1453  .vidioc_g_fbuf = vidioc_g_fbuf,
1454  .vidioc_s_fbuf = vidioc_s_fbuf,
1455  .vidioc_reqbufs = vidioc_reqbufs,
1456  .vidioc_querybuf = vidioc_querybuf,
1457  .vidioc_qbuf = vidioc_qbuf,
1458  .vidioc_dqbuf = vidioc_dqbuf,
1459  .vidioc_g_std = vidioc_g_std,
1460  .vidioc_s_std = vidioc_s_std,
1461  .vidioc_querystd = vidioc_querystd,
1462  .vidioc_enum_input = vidioc_enum_input,
1463  .vidioc_g_input = vidioc_g_input,
1464  .vidioc_s_input = vidioc_s_input,
1465  .vidioc_queryctrl = vidioc_queryctrl,
1466  .vidioc_g_ctrl = vidioc_g_ctrl,
1467  .vidioc_s_ctrl = vidioc_s_ctrl,
1468  .vidioc_streamon = vidioc_streamon,
1469  .vidioc_streamoff = vidioc_streamoff,
1470 };
1471 
1472 static struct video_device viu_template = {
1473  .name = "FSL viu",
1474  .fops = &viu_fops,
1475  .minor = -1,
1476  .ioctl_ops = &viu_ioctl_ops,
1477  .release = video_device_release,
1478 
1479  .tvnorms = V4L2_STD_NTSC_M | V4L2_STD_PAL,
1480  .current_norm = V4L2_STD_NTSC_M,
1481 };
1482 
1483 static int __devinit 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 
1492  ret = of_address_to_resource(op->dev.of_node, 0, &r);
1493  if (ret) {
1494  dev_err(&op->dev, "Can't parse device node resource\n");
1495  return -ENODEV;
1496  }
1497 
1498  viu_irq = irq_of_parse_and_map(op->dev.of_node, 0);
1499  if (viu_irq == NO_IRQ) {
1500  dev_err(&op->dev, "Error while mapping the irq\n");
1501  return -EINVAL;
1502  }
1503 
1504  /* request mem region */
1505  if (!devm_request_mem_region(&op->dev, r.start,
1506  sizeof(struct viu_reg), DRV_NAME)) {
1507  dev_err(&op->dev, "Error while requesting mem region\n");
1508  ret = -EBUSY;
1509  goto err;
1510  }
1511 
1512  /* remap registers */
1513  viu_regs = devm_ioremap(&op->dev, r.start, sizeof(struct viu_reg));
1514  if (!viu_regs) {
1515  dev_err(&op->dev, "Can't map register set\n");
1516  ret = -ENOMEM;
1517  goto err;
1518  }
1519 
1520  /* Prepare our private structure */
1521  viu_dev = devm_kzalloc(&op->dev, sizeof(struct viu_dev), GFP_ATOMIC);
1522  if (!viu_dev) {
1523  dev_err(&op->dev, "Can't allocate private structure\n");
1524  ret = -ENOMEM;
1525  goto err;
1526  }
1527 
1528  viu_dev->vr = viu_regs;
1529  viu_dev->irq = viu_irq;
1530  viu_dev->dev = &op->dev;
1531 
1532  /* init video dma queues */
1533  INIT_LIST_HEAD(&viu_dev->vidq.active);
1534  INIT_LIST_HEAD(&viu_dev->vidq.queued);
1535 
1536  snprintf(viu_dev->v4l2_dev.name,
1537  sizeof(viu_dev->v4l2_dev.name), "%s", "VIU");
1538  ret = v4l2_device_register(viu_dev->dev, &viu_dev->v4l2_dev);
1539  if (ret < 0) {
1540  dev_err(&op->dev, "v4l2_device_register() failed: %d\n", ret);
1541  goto err;
1542  }
1543 
1544  ad = i2c_get_adapter(0);
1545  viu_dev->decoder = v4l2_i2c_new_subdev(&viu_dev->v4l2_dev, ad,
1546  "saa7113", VIU_VIDEO_DECODER_ADDR, NULL);
1547 
1548  viu_dev->vidq.timeout.function = viu_vid_timeout;
1549  viu_dev->vidq.timeout.data = (unsigned long)viu_dev;
1550  init_timer(&viu_dev->vidq.timeout);
1551  viu_dev->first = 1;
1552 
1553  /* Allocate memory for video device */
1554  vdev = video_device_alloc();
1555  if (vdev == NULL) {
1556  ret = -ENOMEM;
1557  goto err_vdev;
1558  }
1559 
1560  memcpy(vdev, &viu_template, sizeof(viu_template));
1561 
1562  vdev->v4l2_dev = &viu_dev->v4l2_dev;
1563 
1564  viu_dev->vdev = vdev;
1565 
1566  /* initialize locks */
1567  mutex_init(&viu_dev->lock);
1568  viu_dev->vdev->lock = &viu_dev->lock;
1569  spin_lock_init(&viu_dev->slock);
1570 
1571  video_set_drvdata(viu_dev->vdev, viu_dev);
1572 
1573  mutex_lock(&viu_dev->lock);
1574 
1575  ret = video_register_device(viu_dev->vdev, VFL_TYPE_GRABBER, -1);
1576  if (ret < 0) {
1577  video_device_release(viu_dev->vdev);
1578  goto err_vdev;
1579  }
1580 
1581  /* enable VIU clock */
1582  viu_dev->clk = clk_get(&op->dev, "viu_clk");
1583  if (IS_ERR(viu_dev->clk)) {
1584  dev_err(&op->dev, "failed to find the clock module!\n");
1585  ret = -ENODEV;
1586  goto err_clk;
1587  } else {
1588  clk_enable(viu_dev->clk);
1589  }
1590 
1591  /* reset VIU module */
1592  viu_reset(viu_dev->vr);
1593 
1594  /* install interrupt handler */
1595  if (request_irq(viu_dev->irq, viu_intr, 0, "viu", (void *)viu_dev)) {
1596  dev_err(&op->dev, "Request VIU IRQ failed.\n");
1597  ret = -ENODEV;
1598  goto err_irq;
1599  }
1600 
1601  mutex_unlock(&viu_dev->lock);
1602 
1603  dev_info(&op->dev, "Freescale VIU Video Capture Board\n");
1604  return ret;
1605 
1606 err_irq:
1607  clk_disable(viu_dev->clk);
1608  clk_put(viu_dev->clk);
1609 err_clk:
1610  video_unregister_device(viu_dev->vdev);
1611 err_vdev:
1612  mutex_unlock(&viu_dev->lock);
1613  i2c_put_adapter(ad);
1614  v4l2_device_unregister(&viu_dev->v4l2_dev);
1615 err:
1616  irq_dispose_mapping(viu_irq);
1617  return ret;
1618 }
1619 
1620 static int __devexit viu_of_remove(struct platform_device *op)
1621 {
1622  struct v4l2_device *v4l2_dev = dev_get_drvdata(&op->dev);
1623  struct viu_dev *dev = container_of(v4l2_dev, struct viu_dev, v4l2_dev);
1624  struct v4l2_subdev *sdev = list_entry(v4l2_dev->subdevs.next,
1625  struct v4l2_subdev, list);
1626  struct i2c_client *client = v4l2_get_subdevdata(sdev);
1627 
1628  free_irq(dev->irq, (void *)dev);
1629  irq_dispose_mapping(dev->irq);
1630 
1631  clk_disable(dev->clk);
1632  clk_put(dev->clk);
1633 
1634  video_unregister_device(dev->vdev);
1635  i2c_put_adapter(client->adapter);
1636  v4l2_device_unregister(&dev->v4l2_dev);
1637  return 0;
1638 }
1639 
1640 #ifdef CONFIG_PM
1641 static int viu_suspend(struct platform_device *op, pm_message_t state)
1642 {
1643  struct v4l2_device *v4l2_dev = dev_get_drvdata(&op->dev);
1644  struct viu_dev *dev = container_of(v4l2_dev, struct viu_dev, v4l2_dev);
1645 
1646  clk_disable(dev->clk);
1647  return 0;
1648 }
1649 
1650 static int viu_resume(struct platform_device *op)
1651 {
1652  struct v4l2_device *v4l2_dev = dev_get_drvdata(&op->dev);
1653  struct viu_dev *dev = container_of(v4l2_dev, struct viu_dev, v4l2_dev);
1654 
1655  clk_enable(dev->clk);
1656  return 0;
1657 }
1658 #endif
1659 
1660 /*
1661  * Initialization and module stuff
1662  */
1663 static struct of_device_id mpc512x_viu_of_match[] = {
1664  {
1665  .compatible = "fsl,mpc5121-viu",
1666  },
1667  {},
1668 };
1669 MODULE_DEVICE_TABLE(of, mpc512x_viu_of_match);
1670 
1671 static struct platform_driver viu_of_platform_driver = {
1672  .probe = viu_of_probe,
1673  .remove = __devexit_p(viu_of_remove),
1674 #ifdef CONFIG_PM
1675  .suspend = viu_suspend,
1676  .resume = viu_resume,
1677 #endif
1678  .driver = {
1679  .name = DRV_NAME,
1680  .owner = THIS_MODULE,
1681  .of_match_table = mpc512x_viu_of_match,
1682  },
1683 };
1684 
1685 module_platform_driver(viu_of_platform_driver);
1686 
1687 MODULE_DESCRIPTION("Freescale Video-In(VIU)");
1688 MODULE_AUTHOR("Hongjun Chen");
1689 MODULE_LICENSE("GPL");
1690 MODULE_VERSION(VIU_VERSION);
Generated on Thu Jan 10 2013 13:49:21 for Linux Kernel by   doxygen 1.8.2