1/* 2 * Copyright 2008-2010 Freescale Semiconductor, Inc. All Rights Reserved. 3 * 4 * Freescale VIU video driver 5 * 6 * Authors: Hongjun Chen <hong-jun.chen@freescale.com> 7 * Porting to 2.6.35 by DENX Software Engineering, 8 * Anatolij Gustschin <agust@denx.de> 9 * 10 * This program is free software; you can redistribute it and/or modify it 11 * under the terms of the GNU General Public License as published by the 12 * Free Software Foundation; either version 2 of the License, or (at your 13 * option) any later version. 14 * 15 */ 16 17#include <linux/module.h> 18#include <linux/clk.h> 19#include <linux/kernel.h> 20#include <linux/i2c.h> 21#include <linux/init.h> 22#include <linux/interrupt.h> 23#include <linux/io.h> 24#include <linux/of_address.h> 25#include <linux/of_irq.h> 26#include <linux/of_platform.h> 27#include <linux/slab.h> 28#include <media/v4l2-common.h> 29#include <media/v4l2-device.h> 30#include <media/v4l2-ioctl.h> 31#include <media/videobuf-dma-contig.h> 32 33#define DRV_NAME "fsl_viu" 34#define VIU_VERSION "0.5.1" 35 36#define BUFFER_TIMEOUT msecs_to_jiffies(500) /* 0.5 seconds */ 37 38#define VIU_VID_MEM_LIMIT 4 /* Video memory limit, in Mb */ 39 40/* I2C address of video decoder chip is 0x4A */ 41#define VIU_VIDEO_DECODER_ADDR 0x25 42 43/* supported controls */ 44static struct v4l2_queryctrl viu_qctrl[] = { 45 { 46 .id = V4L2_CID_BRIGHTNESS, 47 .type = V4L2_CTRL_TYPE_INTEGER, 48 .name = "Brightness", 49 .minimum = 0, 50 .maximum = 255, 51 .step = 1, 52 .default_value = 127, 53 .flags = 0, 54 }, { 55 .id = V4L2_CID_CONTRAST, 56 .type = V4L2_CTRL_TYPE_INTEGER, 57 .name = "Contrast", 58 .minimum = 0, 59 .maximum = 255, 60 .step = 0x1, 61 .default_value = 0x10, 62 .flags = 0, 63 }, { 64 .id = V4L2_CID_SATURATION, 65 .type = V4L2_CTRL_TYPE_INTEGER, 66 .name = "Saturation", 67 .minimum = 0, 68 .maximum = 255, 69 .step = 0x1, 70 .default_value = 127, 71 .flags = 0, 72 }, { 73 .id = V4L2_CID_HUE, 74 .type = V4L2_CTRL_TYPE_INTEGER, 75 .name = "Hue", 76 .minimum = -128, 77 .maximum = 127, 78 .step = 0x1, 79 .default_value = 0, 80 .flags = 0, 81 } 82}; 83 84static int qctl_regs[ARRAY_SIZE(viu_qctrl)]; 85 86static int info_level; 87 88#define dprintk(level, fmt, arg...) \ 89 do { \ 90 if (level <= info_level) \ 91 printk(KERN_DEBUG "viu: " fmt , ## arg); \ 92 } while (0) 93 94/* 95 * Basic structures 96 */ 97struct viu_fmt { 98 char name[32]; 99 u32 fourcc; /* v4l2 format id */ 100 u32 pixelformat; 101 int depth; 102}; 103 104static struct viu_fmt formats[] = { 105 { 106 .name = "RGB-16 (5/B-6/G-5/R)", 107 .fourcc = V4L2_PIX_FMT_RGB565, 108 .pixelformat = V4L2_PIX_FMT_RGB565, 109 .depth = 16, 110 }, { 111 .name = "RGB-32 (A-R-G-B)", 112 .fourcc = V4L2_PIX_FMT_RGB32, 113 .pixelformat = V4L2_PIX_FMT_RGB32, 114 .depth = 32, 115 } 116}; 117 118struct viu_dev; 119struct viu_buf; 120 121/* buffer for one video frame */ 122struct viu_buf { 123 /* common v4l buffer stuff -- must be first */ 124 struct videobuf_buffer vb; 125 struct viu_fmt *fmt; 126}; 127 128struct viu_dmaqueue { 129 struct viu_dev *dev; 130 struct list_head active; 131 struct list_head queued; 132 struct timer_list timeout; 133}; 134 135struct viu_status { 136 u32 field_irq; 137 u32 vsync_irq; 138 u32 hsync_irq; 139 u32 vstart_irq; 140 u32 dma_end_irq; 141 u32 error_irq; 142}; 143 144struct viu_reg { 145 u32 status_cfg; 146 u32 luminance; 147 u32 chroma_r; 148 u32 chroma_g; 149 u32 chroma_b; 150 u32 field_base_addr; 151 u32 dma_inc; 152 u32 picture_count; 153 u32 req_alarm; 154 u32 alpha; 155} __attribute__ ((packed)); 156 157struct viu_dev { 158 struct v4l2_device v4l2_dev; 159 struct mutex lock; 160 spinlock_t slock; 161 int users; 162 163 struct device *dev; 164 /* various device info */ 165 struct video_device *vdev; 166 struct viu_dmaqueue vidq; 167 enum v4l2_field capfield; 168 int field; 169 int first; 170 int dma_done; 171 172 /* Hardware register area */ 173 struct viu_reg *vr; 174 175 /* Interrupt vector */ 176 int irq; 177 struct viu_status irqs; 178 179 /* video overlay */ 180 struct v4l2_framebuffer ovbuf; 181 struct viu_fmt *ovfmt; 182 unsigned int ovenable; 183 enum v4l2_field ovfield; 184 185 /* crop */ 186 struct v4l2_rect crop_current; 187 188 /* clock pointer */ 189 struct clk *clk; 190 191 /* decoder */ 192 struct v4l2_subdev *decoder; 193 194 v4l2_std_id std; 195}; 196 197struct viu_fh { 198 struct viu_dev *dev; 199 200 /* video capture */ 201 struct videobuf_queue vb_vidq; 202 spinlock_t vbq_lock; /* spinlock for the videobuf queue */ 203 204 /* video overlay */ 205 struct v4l2_window win; 206 struct v4l2_clip clips[1]; 207 208 /* video capture */ 209 struct viu_fmt *fmt; 210 int width, height, sizeimage; 211 enum v4l2_buf_type type; 212}; 213 214static struct viu_reg reg_val; 215 216/* 217 * Macro definitions of VIU registers 218 */ 219 220/* STATUS_CONFIG register */ 221enum status_config { 222 SOFT_RST = 1 << 0, 223 224 ERR_MASK = 0x0f << 4, /* Error code mask */ 225 ERR_NO = 0x00, /* No error */ 226 ERR_DMA_V = 0x01 << 4, /* DMA in vertical active */ 227 ERR_DMA_VB = 0x02 << 4, /* DMA in vertical blanking */ 228 ERR_LINE_TOO_LONG = 0x04 << 4, /* Line too long */ 229 ERR_TOO_MANG_LINES = 0x05 << 4, /* Too many lines in field */ 230 ERR_LINE_TOO_SHORT = 0x06 << 4, /* Line too short */ 231 ERR_NOT_ENOUGH_LINE = 0x07 << 4, /* Not enough lines in field */ 232 ERR_FIFO_OVERFLOW = 0x08 << 4, /* FIFO overflow */ 233 ERR_FIFO_UNDERFLOW = 0x09 << 4, /* FIFO underflow */ 234 ERR_1bit_ECC = 0x0a << 4, /* One bit ECC error */ 235 ERR_MORE_ECC = 0x0b << 4, /* Two/more bits ECC error */ 236 237 INT_FIELD_EN = 0x01 << 8, /* Enable field interrupt */ 238 INT_VSYNC_EN = 0x01 << 9, /* Enable vsync interrupt */ 239 INT_HSYNC_EN = 0x01 << 10, /* Enable hsync interrupt */ 240 INT_VSTART_EN = 0x01 << 11, /* Enable vstart interrupt */ 241 INT_DMA_END_EN = 0x01 << 12, /* Enable DMA end interrupt */ 242 INT_ERROR_EN = 0x01 << 13, /* Enable error interrupt */ 243 INT_ECC_EN = 0x01 << 14, /* Enable ECC interrupt */ 244 245 INT_FIELD_STATUS = 0x01 << 16, /* field interrupt status */ 246 INT_VSYNC_STATUS = 0x01 << 17, /* vsync interrupt status */ 247 INT_HSYNC_STATUS = 0x01 << 18, /* hsync interrupt status */ 248 INT_VSTART_STATUS = 0x01 << 19, /* vstart interrupt status */ 249 INT_DMA_END_STATUS = 0x01 << 20, /* DMA end interrupt status */ 250 INT_ERROR_STATUS = 0x01 << 21, /* error interrupt status */ 251 252 DMA_ACT = 0x01 << 27, /* Enable DMA transfer */ 253 FIELD_NO = 0x01 << 28, /* Field number */ 254 DITHER_ON = 0x01 << 29, /* Dithering is on */ 255 ROUND_ON = 0x01 << 30, /* Round is on */ 256 MODE_32BIT = 0x01 << 31, /* Data in RGBa888, 257 * 0 in RGB565 258 */ 259}; 260 261#define norm_maxw() 720 262#define norm_maxh() 576 263 264#define INT_ALL_STATUS (INT_FIELD_STATUS | INT_VSYNC_STATUS | \ 265 INT_HSYNC_STATUS | INT_VSTART_STATUS | \ 266 INT_DMA_END_STATUS | INT_ERROR_STATUS) 267 268#define NUM_FORMATS ARRAY_SIZE(formats) 269 270static irqreturn_t viu_intr(int irq, void *dev_id); 271 272struct viu_fmt *format_by_fourcc(int fourcc) 273{ 274 int i; 275 276 for (i = 0; i < NUM_FORMATS; i++) { 277 if (formats[i].pixelformat == fourcc) 278 return formats + i; 279 } 280 281 dprintk(0, "unknown pixelformat:'%4.4s'\n", (char *)&fourcc); 282 return NULL; 283} 284 285void viu_start_dma(struct viu_dev *dev) 286{ 287 struct viu_reg *vr = dev->vr; 288 289 dev->field = 0; 290 291 /* Enable DMA operation */ 292 out_be32(&vr->status_cfg, SOFT_RST); 293 out_be32(&vr->status_cfg, INT_FIELD_EN); 294} 295 296void viu_stop_dma(struct viu_dev *dev) 297{ 298 struct viu_reg *vr = dev->vr; 299 int cnt = 100; 300 u32 status_cfg; 301 302 out_be32(&vr->status_cfg, 0); 303 304 /* Clear pending interrupts */ 305 status_cfg = in_be32(&vr->status_cfg); 306 if (status_cfg & 0x3f0000) 307 out_be32(&vr->status_cfg, status_cfg & 0x3f0000); 308 309 if (status_cfg & DMA_ACT) { 310 do { 311 status_cfg = in_be32(&vr->status_cfg); 312 if (status_cfg & INT_DMA_END_STATUS) 313 break; 314 } while (cnt--); 315 316 if (cnt < 0) { 317 /* timed out, issue soft reset */ 318 out_be32(&vr->status_cfg, SOFT_RST); 319 out_be32(&vr->status_cfg, 0); 320 } else { 321 /* clear DMA_END and other pending irqs */ 322 out_be32(&vr->status_cfg, status_cfg & 0x3f0000); 323 } 324 } 325 326 dev->field = 0; 327} 328 329static int restart_video_queue(struct viu_dmaqueue *vidq) 330{ 331 struct viu_buf *buf, *prev; 332 333 dprintk(1, "%s vidq=0x%08lx\n", __func__, (unsigned long)vidq); 334 if (!list_empty(&vidq->active)) { 335 buf = list_entry(vidq->active.next, struct viu_buf, vb.queue); 336 dprintk(2, "restart_queue [%p/%d]: restart dma\n", 337 buf, buf->vb.i); 338 339 viu_stop_dma(vidq->dev); 340 341 /* cancel all outstanding capture requests */ 342 list_for_each_entry_safe(buf, prev, &vidq->active, vb.queue) { 343 list_del(&buf->vb.queue); 344 buf->vb.state = VIDEOBUF_ERROR; 345 wake_up(&buf->vb.done); 346 } 347 mod_timer(&vidq->timeout, jiffies+BUFFER_TIMEOUT); 348 return 0; 349 } 350 351 prev = NULL; 352 for (;;) { 353 if (list_empty(&vidq->queued)) 354 return 0; 355 buf = list_entry(vidq->queued.next, struct viu_buf, vb.queue); 356 if (prev == NULL) { 357 list_move_tail(&buf->vb.queue, &vidq->active); 358 359 dprintk(1, "Restarting video dma\n"); 360 viu_stop_dma(vidq->dev); 361 viu_start_dma(vidq->dev); 362 363 buf->vb.state = VIDEOBUF_ACTIVE; 364 mod_timer(&vidq->timeout, jiffies+BUFFER_TIMEOUT); 365 dprintk(2, "[%p/%d] restart_queue - first active\n", 366 buf, buf->vb.i); 367 368 } else if (prev->vb.width == buf->vb.width && 369 prev->vb.height == buf->vb.height && 370 prev->fmt == buf->fmt) { 371 list_move_tail(&buf->vb.queue, &vidq->active); 372 buf->vb.state = VIDEOBUF_ACTIVE; 373 dprintk(2, "[%p/%d] restart_queue - move to active\n", 374 buf, buf->vb.i); 375 } else { 376 return 0; 377 } 378 prev = buf; 379 } 380} 381 382static 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 */ 402static 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 418static 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 436inline 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 485static 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 526fail: 527 free_buffer(vq, buf); 528 return rc; 529} 530 531static 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 581static 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 592static 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 */ 602static 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 614static 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 627static 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 642static 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 684static 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 704static 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 713static 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 753inline 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 762static 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 804static 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 824static int vidioc_try_fmt_overlay(struct file *file, void *priv, 825 struct v4l2_format *f) 826{ 827 return 0; 828} 829 830static 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 852int 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 863int 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 888static 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 896static 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 904static 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 911static 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 919static 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 937static 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 954static 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 962static 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, video, s_std, id); 968 return 0; 969} 970 971static 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 */ 980static 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 994static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) 995{ 996 *i = 0; 997 return 0; 998} 999 1000static 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 */ 1012static 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 1026static 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} 1039static 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 1056inline 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 1080inline 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 1094static 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 1124static 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 v4l2_get_timestamp(&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 1196static 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 */ 1259static 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 1338static 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 1361static 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 1377static 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 1397void viu_reset(struct viu_reg *reg) 1398{ 1399 out_be32(®->status_cfg, 0); 1400 out_be32(®->luminance, 0x9512a254); 1401 out_be32(®->chroma_r, 0x03310000); 1402 out_be32(®->chroma_g, 0x06600f38); 1403 out_be32(®->chroma_b, 0x00000409); 1404 out_be32(®->field_base_addr, 0); 1405 out_be32(®->dma_inc, 0); 1406 out_be32(®->picture_count, 0x01e002d0); 1407 out_be32(®->req_alarm, 0x00000090); 1408 out_be32(®->alpha, 0x000000ff); 1409} 1410 1411static 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 1432static 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 1442static 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 1472static 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}; 1481 1482static int viu_of_probe(struct platform_device *op) 1483{ 1484 struct viu_dev *viu_dev; 1485 struct video_device *vdev; 1486 struct resource r; 1487 struct viu_reg __iomem *viu_regs; 1488 struct i2c_adapter *ad; 1489 int ret, viu_irq; 1490 struct clk *clk; 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->std = V4L2_STD_NTSC_M; 1552 viu_dev->first = 1; 1553 1554 /* Allocate memory for video device */ 1555 vdev = video_device_alloc(); 1556 if (vdev == NULL) { 1557 ret = -ENOMEM; 1558 goto err_vdev; 1559 } 1560 1561 memcpy(vdev, &viu_template, sizeof(viu_template)); 1562 1563 vdev->v4l2_dev = &viu_dev->v4l2_dev; 1564 1565 viu_dev->vdev = vdev; 1566 1567 /* initialize locks */ 1568 mutex_init(&viu_dev->lock); 1569 viu_dev->vdev->lock = &viu_dev->lock; 1570 spin_lock_init(&viu_dev->slock); 1571 1572 video_set_drvdata(viu_dev->vdev, viu_dev); 1573 1574 mutex_lock(&viu_dev->lock); 1575 1576 ret = video_register_device(viu_dev->vdev, VFL_TYPE_GRABBER, -1); 1577 if (ret < 0) { 1578 video_device_release(viu_dev->vdev); 1579 goto err_vdev; 1580 } 1581 1582 /* enable VIU clock */ 1583 clk = devm_clk_get(&op->dev, "ipg"); 1584 if (IS_ERR(clk)) { 1585 dev_err(&op->dev, "failed to lookup the clock!\n"); 1586 ret = PTR_ERR(clk); 1587 goto err_clk; 1588 } 1589 ret = clk_prepare_enable(clk); 1590 if (ret) { 1591 dev_err(&op->dev, "failed to enable the clock!\n"); 1592 goto err_clk; 1593 } 1594 viu_dev->clk = clk; 1595 1596 /* reset VIU module */ 1597 viu_reset(viu_dev->vr); 1598 1599 /* install interrupt handler */ 1600 if (request_irq(viu_dev->irq, viu_intr, 0, "viu", (void *)viu_dev)) { 1601 dev_err(&op->dev, "Request VIU IRQ failed.\n"); 1602 ret = -ENODEV; 1603 goto err_irq; 1604 } 1605 1606 mutex_unlock(&viu_dev->lock); 1607 1608 dev_info(&op->dev, "Freescale VIU Video Capture Board\n"); 1609 return ret; 1610 1611err_irq: 1612 clk_disable_unprepare(viu_dev->clk); 1613err_clk: 1614 video_unregister_device(viu_dev->vdev); 1615err_vdev: 1616 mutex_unlock(&viu_dev->lock); 1617 i2c_put_adapter(ad); 1618 v4l2_device_unregister(&viu_dev->v4l2_dev); 1619err: 1620 irq_dispose_mapping(viu_irq); 1621 return ret; 1622} 1623 1624static int viu_of_remove(struct platform_device *op) 1625{ 1626 struct v4l2_device *v4l2_dev = dev_get_drvdata(&op->dev); 1627 struct viu_dev *dev = container_of(v4l2_dev, struct viu_dev, v4l2_dev); 1628 struct v4l2_subdev *sdev = list_entry(v4l2_dev->subdevs.next, 1629 struct v4l2_subdev, list); 1630 struct i2c_client *client = v4l2_get_subdevdata(sdev); 1631 1632 free_irq(dev->irq, (void *)dev); 1633 irq_dispose_mapping(dev->irq); 1634 1635 clk_disable_unprepare(dev->clk); 1636 1637 video_unregister_device(dev->vdev); 1638 i2c_put_adapter(client->adapter); 1639 v4l2_device_unregister(&dev->v4l2_dev); 1640 return 0; 1641} 1642 1643#ifdef CONFIG_PM 1644static int viu_suspend(struct platform_device *op, pm_message_t state) 1645{ 1646 struct v4l2_device *v4l2_dev = dev_get_drvdata(&op->dev); 1647 struct viu_dev *dev = container_of(v4l2_dev, struct viu_dev, v4l2_dev); 1648 1649 clk_disable(dev->clk); 1650 return 0; 1651} 1652 1653static int viu_resume(struct platform_device *op) 1654{ 1655 struct v4l2_device *v4l2_dev = dev_get_drvdata(&op->dev); 1656 struct viu_dev *dev = container_of(v4l2_dev, struct viu_dev, v4l2_dev); 1657 1658 clk_enable(dev->clk); 1659 return 0; 1660} 1661#endif 1662 1663/* 1664 * Initialization and module stuff 1665 */ 1666static struct of_device_id mpc512x_viu_of_match[] = { 1667 { 1668 .compatible = "fsl,mpc5121-viu", 1669 }, 1670 {}, 1671}; 1672MODULE_DEVICE_TABLE(of, mpc512x_viu_of_match); 1673 1674static struct platform_driver viu_of_platform_driver = { 1675 .probe = viu_of_probe, 1676 .remove = viu_of_remove, 1677#ifdef CONFIG_PM 1678 .suspend = viu_suspend, 1679 .resume = viu_resume, 1680#endif 1681 .driver = { 1682 .name = DRV_NAME, 1683 .owner = THIS_MODULE, 1684 .of_match_table = mpc512x_viu_of_match, 1685 }, 1686}; 1687 1688module_platform_driver(viu_of_platform_driver); 1689 1690MODULE_DESCRIPTION("Freescale Video-In(VIU)"); 1691MODULE_AUTHOR("Hongjun Chen"); 1692MODULE_LICENSE("GPL"); 1693MODULE_VERSION(VIU_VERSION); 1694