drivers/media/video/fsl-viu.c

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