/drivers/media/video/fsl-viu.c
C | 1686 lines | 1319 code | 283 blank | 84 comment | 171 complexity | e13f22dfcbc86539af5a839ed7668f9a MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
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 */ 48static 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 88static int qctl_regs[ARRAY_SIZE(viu_qctrl)]; 89 90static 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 */ 101struct viu_fmt { 102 char name[32]; 103 u32 fourcc; /* v4l2 format id */ 104 u32 pixelformat; 105 int depth; 106}; 107 108static 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 122struct viu_dev; 123struct viu_buf; 124 125/* buffer for one video frame */ 126struct viu_buf { 127 /* common v4l buffer stuff -- must be first */ 128 struct videobuf_buffer vb; 129 struct viu_fmt *fmt; 130}; 131 132struct viu_dmaqueue { 133 struct viu_dev *dev; 134 struct list_head active; 135 struct list_head queued; 136 struct timer_list timeout; 137}; 138 139struct 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 148struct 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 161struct 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 201struct 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 218static struct viu_reg reg_val; 219 220/* 221 * Macro definitions of VIU registers 222 */ 223 224/* STATUS_CONFIG register */ 225enum 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 274static irqreturn_t viu_intr(int irq, void *dev_id); 275 276struct 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 289void 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 300void 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 333static 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 388static 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 */ 408static 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 424static 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 442inline 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 491static 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 532fail: 533 free_buffer(vq, buf); 534 return rc; 535} 536 537static 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 587static 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 598static 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 */ 608static 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 621static 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 634static 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 649static 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 691static 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 711static 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 720static 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 760inline 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 769static 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 811static 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 831static int vidioc_try_fmt_overlay(struct file *file, void *priv, 832 struct v4l2_format *f) 833{ 834 return 0; 835} 836 837static 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 859int 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 870int 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 895static 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 903static 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 911static 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 918static 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 926static 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 944static 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 961static 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 969static 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 978static 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 */ 987static 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 1001static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) 1002{ 1003 *i = 0; 1004 return 0; 1005} 1006 1007static 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 */ 1019static 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 1033static 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} 1046static 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 1063inline 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 1087inline 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 1101static 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 1131static 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 1203static 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 */ 1266static 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 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 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 1358static 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 1369static 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 1387void viu_reset(struct viu_reg *reg) 1388{ 1389 out_be32(®->status_cfg, 0); 1390 out_be32(®->luminance, 0x9512a254); 1391 out_be32(®->chroma_r, 0x03310000); 1392 out_be32(®->chroma_g, 0x06600f38); 1393 out_be32(®->chroma_b, 0x00000409); 1394 out_be32(®->field_base_addr, 0); 1395 out_be32(®->dma_inc, 0); 1396 out_be32(®->picture_count, 0x01e002d0); 1397 out_be32(®->req_alarm, 0x00000090); 1398 out_be32(®->alpha, 0x000000ff); 1399} 1400 1401static 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 1418static 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 1428static 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 1458static 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 1469static 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 1592err_irq: 1593 clk_disable(viu_dev->clk); 1594 clk_put(viu_dev->clk); 1595err_clk: 1596 video_unregister_device(viu_dev->vdev); 1597err_vdev: 1598 mutex_unlock(&viu_dev->lock); 1599 i2c_put_adapter(ad); 1600 v4l2_device_unregister(&viu_dev->v4l2_dev); 1601err: 1602 irq_dispose_mapping(viu_irq); 1603 return ret; 1604} 1605 1606static 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 1627static 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 1636static 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 */ 1649static struct of_device_id mpc512x_viu_of_match[] = { 1650 { 1651 .compatible = "fsl,mpc5121-viu", 1652 }, 1653 {}, 1654}; 1655MODULE_DEVICE_TABLE(of, mpc512x_viu_of_match); 1656 1657static 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 1671static int __init viu_init(void) 1672{ 1673 return platform_driver_register(&viu_of_platform_driver); 1674} 1675 1676static void __exit viu_exit(void) 1677{ 1678 platform_driver_unregister(&viu_of_platform_driver); 1679} 1680 1681module_init(viu_init); 1682module_exit(viu_exit); 1683 1684MODULE_DESCRIPTION("Freescale Video-In(VIU)"); 1685MODULE_AUTHOR("Hongjun Chen"); 1686MODULE_LICENSE("GPL");