PageRenderTime 82ms CodeModel.GetById 25ms app.highlight 43ms RepoModel.GetById 0ms app.codeStats 0ms

/drivers/media/video/cx23885/cx23885-video.c

https://bitbucket.org/abioy/linux
C | 1550 lines | 1260 code | 212 blank | 78 comment | 164 complexity | bc841fb814c904c080df17bc72a3df25 MD5 | raw file
Possible License(s): CC-BY-SA-3.0, GPL-2.0, LGPL-2.0, AGPL-1.0
   1/*
   2 *  Driver for the Conexant CX23885 PCIe bridge
   3 *
   4 *  Copyright (c) 2007 Steven Toth <stoth@linuxtv.org>
   5 *
   6 *  This program is free software; you can redistribute it and/or modify
   7 *  it under the terms of the GNU General Public License as published by
   8 *  the Free Software Foundation; either version 2 of the License, or
   9 *  (at your option) any later version.
  10 *
  11 *  This program is distributed in the hope that it will be useful,
  12 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 *
  15 *  GNU General Public License for more details.
  16 *
  17 *  You should have received a copy of the GNU General Public License
  18 *  along with this program; if not, write to the Free Software
  19 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22#include <linux/init.h>
  23#include <linux/list.h>
  24#include <linux/module.h>
  25#include <linux/moduleparam.h>
  26#include <linux/kmod.h>
  27#include <linux/kernel.h>
  28#include <linux/slab.h>
  29#include <linux/smp_lock.h>
  30#include <linux/interrupt.h>
  31#include <linux/delay.h>
  32#include <linux/kthread.h>
  33#include <asm/div64.h>
  34
  35#include "cx23885.h"
  36#include <media/v4l2-common.h>
  37#include <media/v4l2-ioctl.h>
  38#include "cx23885-ioctl.h"
  39#include "tuner-xc2028.h"
  40
  41MODULE_DESCRIPTION("v4l2 driver module for cx23885 based TV cards");
  42MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
  43MODULE_LICENSE("GPL");
  44
  45/* ------------------------------------------------------------------ */
  46
  47static unsigned int video_nr[] = {[0 ... (CX23885_MAXBOARDS - 1)] = UNSET };
  48static unsigned int vbi_nr[]   = {[0 ... (CX23885_MAXBOARDS - 1)] = UNSET };
  49static unsigned int radio_nr[] = {[0 ... (CX23885_MAXBOARDS - 1)] = UNSET };
  50
  51module_param_array(video_nr, int, NULL, 0444);
  52module_param_array(vbi_nr,   int, NULL, 0444);
  53module_param_array(radio_nr, int, NULL, 0444);
  54
  55MODULE_PARM_DESC(video_nr, "video device numbers");
  56MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
  57MODULE_PARM_DESC(radio_nr, "radio device numbers");
  58
  59static unsigned int video_debug;
  60module_param(video_debug, int, 0644);
  61MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
  62
  63static unsigned int irq_debug;
  64module_param(irq_debug, int, 0644);
  65MODULE_PARM_DESC(irq_debug, "enable debug messages [IRQ handler]");
  66
  67static unsigned int vid_limit = 16;
  68module_param(vid_limit, int, 0644);
  69MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
  70
  71#define dprintk(level, fmt, arg...)\
  72	do { if (video_debug >= level)\
  73		printk(KERN_DEBUG "%s/0: " fmt, dev->name, ## arg);\
  74	} while (0)
  75
  76/* ------------------------------------------------------------------- */
  77/* static data                                                         */
  78
  79#define FORMAT_FLAGS_PACKED       0x01
  80
  81static struct cx23885_fmt formats[] = {
  82	{
  83		.name     = "8 bpp, gray",
  84		.fourcc   = V4L2_PIX_FMT_GREY,
  85		.depth    = 8,
  86		.flags    = FORMAT_FLAGS_PACKED,
  87	}, {
  88		.name     = "15 bpp RGB, le",
  89		.fourcc   = V4L2_PIX_FMT_RGB555,
  90		.depth    = 16,
  91		.flags    = FORMAT_FLAGS_PACKED,
  92	}, {
  93		.name     = "15 bpp RGB, be",
  94		.fourcc   = V4L2_PIX_FMT_RGB555X,
  95		.depth    = 16,
  96		.flags    = FORMAT_FLAGS_PACKED,
  97	}, {
  98		.name     = "16 bpp RGB, le",
  99		.fourcc   = V4L2_PIX_FMT_RGB565,
 100		.depth    = 16,
 101		.flags    = FORMAT_FLAGS_PACKED,
 102	}, {
 103		.name     = "16 bpp RGB, be",
 104		.fourcc   = V4L2_PIX_FMT_RGB565X,
 105		.depth    = 16,
 106		.flags    = FORMAT_FLAGS_PACKED,
 107	}, {
 108		.name     = "24 bpp RGB, le",
 109		.fourcc   = V4L2_PIX_FMT_BGR24,
 110		.depth    = 24,
 111		.flags    = FORMAT_FLAGS_PACKED,
 112	}, {
 113		.name     = "32 bpp RGB, le",
 114		.fourcc   = V4L2_PIX_FMT_BGR32,
 115		.depth    = 32,
 116		.flags    = FORMAT_FLAGS_PACKED,
 117	}, {
 118		.name     = "32 bpp RGB, be",
 119		.fourcc   = V4L2_PIX_FMT_RGB32,
 120		.depth    = 32,
 121		.flags    = FORMAT_FLAGS_PACKED,
 122	}, {
 123		.name     = "4:2:2, packed, YUYV",
 124		.fourcc   = V4L2_PIX_FMT_YUYV,
 125		.depth    = 16,
 126		.flags    = FORMAT_FLAGS_PACKED,
 127	}, {
 128		.name     = "4:2:2, packed, UYVY",
 129		.fourcc   = V4L2_PIX_FMT_UYVY,
 130		.depth    = 16,
 131		.flags    = FORMAT_FLAGS_PACKED,
 132	},
 133};
 134
 135static struct cx23885_fmt *format_by_fourcc(unsigned int fourcc)
 136{
 137	unsigned int i;
 138
 139	for (i = 0; i < ARRAY_SIZE(formats); i++)
 140		if (formats[i].fourcc == fourcc)
 141			return formats+i;
 142
 143	printk(KERN_ERR "%s(0x%08x) NOT FOUND\n", __func__, fourcc);
 144	return NULL;
 145}
 146
 147/* ------------------------------------------------------------------- */
 148
 149static const struct v4l2_queryctrl no_ctl = {
 150	.name  = "42",
 151	.flags = V4L2_CTRL_FLAG_DISABLED,
 152};
 153
 154static struct cx23885_ctrl cx23885_ctls[] = {
 155	/* --- video --- */
 156	{
 157		.v = {
 158			.id            = V4L2_CID_BRIGHTNESS,
 159			.name          = "Brightness",
 160			.minimum       = 0x00,
 161			.maximum       = 0xff,
 162			.step          = 1,
 163			.default_value = 0x7f,
 164			.type          = V4L2_CTRL_TYPE_INTEGER,
 165		},
 166		.off                   = 128,
 167		.reg                   = LUMA_CTRL,
 168		.mask                  = 0x00ff,
 169		.shift                 = 0,
 170	}, {
 171		.v = {
 172			.id            = V4L2_CID_CONTRAST,
 173			.name          = "Contrast",
 174			.minimum       = 0,
 175			.maximum       = 0xff,
 176			.step          = 1,
 177			.default_value = 0x3f,
 178			.type          = V4L2_CTRL_TYPE_INTEGER,
 179		},
 180		.off                   = 0,
 181		.reg                   = LUMA_CTRL,
 182		.mask                  = 0xff00,
 183		.shift                 = 8,
 184	}, {
 185		.v = {
 186			.id            = V4L2_CID_HUE,
 187			.name          = "Hue",
 188			.minimum       = 0,
 189			.maximum       = 0xff,
 190			.step          = 1,
 191			.default_value = 0x7f,
 192			.type          = V4L2_CTRL_TYPE_INTEGER,
 193		},
 194		.off                   = 128,
 195		.reg                   = CHROMA_CTRL,
 196		.mask                  = 0xff0000,
 197		.shift                 = 16,
 198	}, {
 199		/* strictly, this only describes only U saturation.
 200		 * V saturation is handled specially through code.
 201		 */
 202		.v = {
 203			.id            = V4L2_CID_SATURATION,
 204			.name          = "Saturation",
 205			.minimum       = 0,
 206			.maximum       = 0xff,
 207			.step          = 1,
 208			.default_value = 0x7f,
 209			.type          = V4L2_CTRL_TYPE_INTEGER,
 210		},
 211		.off                   = 0,
 212		.reg                   = CHROMA_CTRL,
 213		.mask                  = 0x00ff,
 214		.shift                 = 0,
 215	}, {
 216	/* --- audio --- */
 217		.v = {
 218			.id            = V4L2_CID_AUDIO_MUTE,
 219			.name          = "Mute",
 220			.minimum       = 0,
 221			.maximum       = 1,
 222			.default_value = 1,
 223			.type          = V4L2_CTRL_TYPE_BOOLEAN,
 224		},
 225		.reg                   = PATH1_CTL1,
 226		.mask                  = (0x1f << 24),
 227		.shift                 = 24,
 228	}, {
 229		.v = {
 230			.id            = V4L2_CID_AUDIO_VOLUME,
 231			.name          = "Volume",
 232			.minimum       = 0,
 233			.maximum       = 0x3f,
 234			.step          = 1,
 235			.default_value = 0x3f,
 236			.type          = V4L2_CTRL_TYPE_INTEGER,
 237		},
 238		.reg                   = PATH1_VOL_CTL,
 239		.mask                  = 0xff,
 240		.shift                 = 0,
 241	}
 242};
 243static const int CX23885_CTLS = ARRAY_SIZE(cx23885_ctls);
 244
 245/* Must be sorted from low to high control ID! */
 246static const u32 cx23885_user_ctrls[] = {
 247	V4L2_CID_USER_CLASS,
 248	V4L2_CID_BRIGHTNESS,
 249	V4L2_CID_CONTRAST,
 250	V4L2_CID_SATURATION,
 251	V4L2_CID_HUE,
 252	V4L2_CID_AUDIO_VOLUME,
 253	V4L2_CID_AUDIO_MUTE,
 254	0
 255};
 256
 257static const u32 *ctrl_classes[] = {
 258	cx23885_user_ctrls,
 259	NULL
 260};
 261
 262static void cx23885_video_wakeup(struct cx23885_dev *dev,
 263		 struct cx23885_dmaqueue *q, u32 count)
 264{
 265	struct cx23885_buffer *buf;
 266	int bc;
 267
 268	for (bc = 0;; bc++) {
 269		if (list_empty(&q->active))
 270			break;
 271		buf = list_entry(q->active.next,
 272				 struct cx23885_buffer, vb.queue);
 273
 274		/* count comes from the hw and is is 16bit wide --
 275		 * this trick handles wrap-arounds correctly for
 276		 * up to 32767 buffers in flight... */
 277		if ((s16) (count - buf->count) < 0)
 278			break;
 279
 280		do_gettimeofday(&buf->vb.ts);
 281		dprintk(2, "[%p/%d] wakeup reg=%d buf=%d\n", buf, buf->vb.i,
 282			count, buf->count);
 283		buf->vb.state = VIDEOBUF_DONE;
 284		list_del(&buf->vb.queue);
 285		wake_up(&buf->vb.done);
 286	}
 287	if (list_empty(&q->active))
 288		del_timer(&q->timeout);
 289	else
 290		mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
 291	if (bc != 1)
 292		printk(KERN_ERR "%s: %d buffers handled (should be 1)\n",
 293			__func__, bc);
 294}
 295
 296static int cx23885_set_tvnorm(struct cx23885_dev *dev, v4l2_std_id norm)
 297{
 298	dprintk(1, "%s(norm = 0x%08x) name: [%s]\n",
 299		__func__,
 300		(unsigned int)norm,
 301		v4l2_norm_to_name(norm));
 302
 303	dev->tvnorm = norm;
 304
 305	call_all(dev, core, s_std, norm);
 306
 307	return 0;
 308}
 309
 310static struct video_device *cx23885_vdev_init(struct cx23885_dev *dev,
 311				    struct pci_dev *pci,
 312				    struct video_device *template,
 313				    char *type)
 314{
 315	struct video_device *vfd;
 316	dprintk(1, "%s()\n", __func__);
 317
 318	vfd = video_device_alloc();
 319	if (NULL == vfd)
 320		return NULL;
 321	*vfd = *template;
 322	vfd->v4l2_dev = &dev->v4l2_dev;
 323	vfd->release = video_device_release;
 324	snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)",
 325		 dev->name, type, cx23885_boards[dev->board].name);
 326	video_set_drvdata(vfd, dev);
 327	return vfd;
 328}
 329
 330static int cx23885_ctrl_query(struct v4l2_queryctrl *qctrl)
 331{
 332	int i;
 333
 334	if (qctrl->id < V4L2_CID_BASE ||
 335	    qctrl->id >= V4L2_CID_LASTP1)
 336		return -EINVAL;
 337	for (i = 0; i < CX23885_CTLS; i++)
 338		if (cx23885_ctls[i].v.id == qctrl->id)
 339			break;
 340	if (i == CX23885_CTLS) {
 341		*qctrl = no_ctl;
 342		return 0;
 343	}
 344	*qctrl = cx23885_ctls[i].v;
 345	return 0;
 346}
 347
 348/* ------------------------------------------------------------------- */
 349/* resource management                                                 */
 350
 351static int res_get(struct cx23885_dev *dev, struct cx23885_fh *fh,
 352	unsigned int bit)
 353{
 354	dprintk(1, "%s()\n", __func__);
 355	if (fh->resources & bit)
 356		/* have it already allocated */
 357		return 1;
 358
 359	/* is it free? */
 360	mutex_lock(&dev->lock);
 361	if (dev->resources & bit) {
 362		/* no, someone else uses it */
 363		mutex_unlock(&dev->lock);
 364		return 0;
 365	}
 366	/* it's free, grab it */
 367	fh->resources  |= bit;
 368	dev->resources |= bit;
 369	dprintk(1, "res: get %d\n", bit);
 370	mutex_unlock(&dev->lock);
 371	return 1;
 372}
 373
 374static int res_check(struct cx23885_fh *fh, unsigned int bit)
 375{
 376	return fh->resources & bit;
 377}
 378
 379static int res_locked(struct cx23885_dev *dev, unsigned int bit)
 380{
 381	return dev->resources & bit;
 382}
 383
 384static void res_free(struct cx23885_dev *dev, struct cx23885_fh *fh,
 385	unsigned int bits)
 386{
 387	BUG_ON((fh->resources & bits) != bits);
 388	dprintk(1, "%s()\n", __func__);
 389
 390	mutex_lock(&dev->lock);
 391	fh->resources  &= ~bits;
 392	dev->resources &= ~bits;
 393	dprintk(1, "res: put %d\n", bits);
 394	mutex_unlock(&dev->lock);
 395}
 396
 397static int cx23885_video_mux(struct cx23885_dev *dev, unsigned int input)
 398{
 399	dprintk(1, "%s() video_mux: %d [vmux=%d, gpio=0x%x,0x%x,0x%x,0x%x]\n",
 400		__func__,
 401		input, INPUT(input)->vmux,
 402		INPUT(input)->gpio0, INPUT(input)->gpio1,
 403		INPUT(input)->gpio2, INPUT(input)->gpio3);
 404	dev->input = input;
 405
 406	if (dev->board == CX23885_BOARD_MYGICA_X8506 ||
 407		dev->board == CX23885_BOARD_MAGICPRO_PROHDTVE2) {
 408		/* Select Analog TV */
 409		if (INPUT(input)->type == CX23885_VMUX_TELEVISION)
 410			cx23885_gpio_clear(dev, GPIO_0);
 411	}
 412
 413	/* Tell the internal A/V decoder */
 414	v4l2_subdev_call(dev->sd_cx25840, video, s_routing,
 415			INPUT(input)->vmux, 0, 0);
 416
 417	return 0;
 418}
 419
 420/* ------------------------------------------------------------------ */
 421static int cx23885_set_scale(struct cx23885_dev *dev, unsigned int width,
 422	unsigned int height, enum v4l2_field field)
 423{
 424	dprintk(1, "%s()\n", __func__);
 425	return 0;
 426}
 427
 428static int cx23885_start_video_dma(struct cx23885_dev *dev,
 429			   struct cx23885_dmaqueue *q,
 430			   struct cx23885_buffer *buf)
 431{
 432	dprintk(1, "%s()\n", __func__);
 433
 434	/* setup fifo + format */
 435	cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH01],
 436				buf->bpl, buf->risc.dma);
 437	cx23885_set_scale(dev, buf->vb.width, buf->vb.height, buf->vb.field);
 438
 439	/* reset counter */
 440	cx_write(VID_A_GPCNT_CTL, 3);
 441	q->count = 1;
 442
 443	/* enable irq */
 444	cx_set(PCI_INT_MSK, cx_read(PCI_INT_MSK) | 0x01);
 445	cx_set(VID_A_INT_MSK, 0x000011);
 446
 447	/* start dma */
 448	cx_set(DEV_CNTRL2, (1<<5));
 449	cx_set(VID_A_DMA_CTL, 0x11); /* FIFO and RISC enable */
 450
 451	return 0;
 452}
 453
 454
 455static int cx23885_restart_video_queue(struct cx23885_dev *dev,
 456			       struct cx23885_dmaqueue *q)
 457{
 458	struct cx23885_buffer *buf, *prev;
 459	struct list_head *item;
 460	dprintk(1, "%s()\n", __func__);
 461
 462	if (!list_empty(&q->active)) {
 463		buf = list_entry(q->active.next, struct cx23885_buffer,
 464			vb.queue);
 465		dprintk(2, "restart_queue [%p/%d]: restart dma\n",
 466			buf, buf->vb.i);
 467		cx23885_start_video_dma(dev, q, buf);
 468		list_for_each(item, &q->active) {
 469			buf = list_entry(item, struct cx23885_buffer,
 470				vb.queue);
 471			buf->count    = q->count++;
 472		}
 473		mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
 474		return 0;
 475	}
 476
 477	prev = NULL;
 478	for (;;) {
 479		if (list_empty(&q->queued))
 480			return 0;
 481		buf = list_entry(q->queued.next, struct cx23885_buffer,
 482			vb.queue);
 483		if (NULL == prev) {
 484			list_move_tail(&buf->vb.queue, &q->active);
 485			cx23885_start_video_dma(dev, q, buf);
 486			buf->vb.state = VIDEOBUF_ACTIVE;
 487			buf->count    = q->count++;
 488			mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
 489			dprintk(2, "[%p/%d] restart_queue - first active\n",
 490				buf, buf->vb.i);
 491
 492		} else if (prev->vb.width  == buf->vb.width  &&
 493			   prev->vb.height == buf->vb.height &&
 494			   prev->fmt       == buf->fmt) {
 495			list_move_tail(&buf->vb.queue, &q->active);
 496			buf->vb.state = VIDEOBUF_ACTIVE;
 497			buf->count    = q->count++;
 498			prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
 499			prev->risc.jmp[2] = cpu_to_le32(0); /* Bits 63 - 32 */
 500			dprintk(2, "[%p/%d] restart_queue - move to active\n",
 501				buf, buf->vb.i);
 502		} else {
 503			return 0;
 504		}
 505		prev = buf;
 506	}
 507}
 508
 509static int buffer_setup(struct videobuf_queue *q, unsigned int *count,
 510	unsigned int *size)
 511{
 512	struct cx23885_fh *fh = q->priv_data;
 513
 514	*size = fh->fmt->depth*fh->width*fh->height >> 3;
 515	if (0 == *count)
 516		*count = 32;
 517	while (*size * *count > vid_limit * 1024 * 1024)
 518		(*count)--;
 519	return 0;
 520}
 521
 522static int buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
 523	       enum v4l2_field field)
 524{
 525	struct cx23885_fh *fh  = q->priv_data;
 526	struct cx23885_dev *dev = fh->dev;
 527	struct cx23885_buffer *buf =
 528		container_of(vb, struct cx23885_buffer, vb);
 529	int rc, init_buffer = 0;
 530	u32 line0_offset, line1_offset;
 531	struct videobuf_dmabuf *dma = videobuf_to_dma(&buf->vb);
 532
 533	BUG_ON(NULL == fh->fmt);
 534	if (fh->width  < 48 || fh->width  > norm_maxw(dev->tvnorm) ||
 535	    fh->height < 32 || fh->height > norm_maxh(dev->tvnorm))
 536		return -EINVAL;
 537	buf->vb.size = (fh->width * fh->height * fh->fmt->depth) >> 3;
 538	if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
 539		return -EINVAL;
 540
 541	if (buf->fmt       != fh->fmt    ||
 542	    buf->vb.width  != fh->width  ||
 543	    buf->vb.height != fh->height ||
 544	    buf->vb.field  != field) {
 545		buf->fmt       = fh->fmt;
 546		buf->vb.width  = fh->width;
 547		buf->vb.height = fh->height;
 548		buf->vb.field  = field;
 549		init_buffer = 1;
 550	}
 551
 552	if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
 553		init_buffer = 1;
 554		rc = videobuf_iolock(q, &buf->vb, NULL);
 555		if (0 != rc)
 556			goto fail;
 557	}
 558
 559	if (init_buffer) {
 560		buf->bpl = buf->vb.width * buf->fmt->depth >> 3;
 561		switch (buf->vb.field) {
 562		case V4L2_FIELD_TOP:
 563			cx23885_risc_buffer(dev->pci, &buf->risc,
 564					 dma->sglist, 0, UNSET,
 565					 buf->bpl, 0, buf->vb.height);
 566			break;
 567		case V4L2_FIELD_BOTTOM:
 568			cx23885_risc_buffer(dev->pci, &buf->risc,
 569					 dma->sglist, UNSET, 0,
 570					 buf->bpl, 0, buf->vb.height);
 571			break;
 572		case V4L2_FIELD_INTERLACED:
 573			if (dev->tvnorm & V4L2_STD_NTSC) {
 574				/* cx25840 transmits NTSC bottom field first */
 575				dprintk(1, "%s() Creating NTSC risc\n",
 576					__func__);
 577				line0_offset = buf->bpl;
 578				line1_offset = 0;
 579			} else {
 580				/* All other formats are top field first */
 581				dprintk(1, "%s() Creating PAL/SECAM risc\n",
 582					__func__);
 583				line0_offset = 0;
 584				line1_offset = buf->bpl;
 585			}
 586			cx23885_risc_buffer(dev->pci, &buf->risc,
 587					dma->sglist, line0_offset,
 588					line1_offset,
 589					buf->bpl, buf->bpl,
 590					buf->vb.height >> 1);
 591			break;
 592		case V4L2_FIELD_SEQ_TB:
 593			cx23885_risc_buffer(dev->pci, &buf->risc,
 594					 dma->sglist,
 595					 0, buf->bpl * (buf->vb.height >> 1),
 596					 buf->bpl, 0,
 597					 buf->vb.height >> 1);
 598			break;
 599		case V4L2_FIELD_SEQ_BT:
 600			cx23885_risc_buffer(dev->pci, &buf->risc,
 601					 dma->sglist,
 602					 buf->bpl * (buf->vb.height >> 1), 0,
 603					 buf->bpl, 0,
 604					 buf->vb.height >> 1);
 605			break;
 606		default:
 607			BUG();
 608		}
 609	}
 610	dprintk(2, "[%p/%d] buffer_prep - %dx%d %dbpp \"%s\" - dma=0x%08lx\n",
 611		buf, buf->vb.i,
 612		fh->width, fh->height, fh->fmt->depth, fh->fmt->name,
 613		(unsigned long)buf->risc.dma);
 614
 615	buf->vb.state = VIDEOBUF_PREPARED;
 616	return 0;
 617
 618 fail:
 619	cx23885_free_buffer(q, buf);
 620	return rc;
 621}
 622
 623static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
 624{
 625	struct cx23885_buffer   *buf = container_of(vb,
 626		struct cx23885_buffer, vb);
 627	struct cx23885_buffer   *prev;
 628	struct cx23885_fh       *fh   = vq->priv_data;
 629	struct cx23885_dev      *dev  = fh->dev;
 630	struct cx23885_dmaqueue *q    = &dev->vidq;
 631
 632	/* add jump to stopper */
 633	buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC);
 634	buf->risc.jmp[1] = cpu_to_le32(q->stopper.dma);
 635	buf->risc.jmp[2] = cpu_to_le32(0); /* bits 63-32 */
 636
 637	if (!list_empty(&q->queued)) {
 638		list_add_tail(&buf->vb.queue, &q->queued);
 639		buf->vb.state = VIDEOBUF_QUEUED;
 640		dprintk(2, "[%p/%d] buffer_queue - append to queued\n",
 641			buf, buf->vb.i);
 642
 643	} else if (list_empty(&q->active)) {
 644		list_add_tail(&buf->vb.queue, &q->active);
 645		cx23885_start_video_dma(dev, q, buf);
 646		buf->vb.state = VIDEOBUF_ACTIVE;
 647		buf->count    = q->count++;
 648		mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
 649		dprintk(2, "[%p/%d] buffer_queue - first active\n",
 650			buf, buf->vb.i);
 651
 652	} else {
 653		prev = list_entry(q->active.prev, struct cx23885_buffer,
 654			vb.queue);
 655		if (prev->vb.width  == buf->vb.width  &&
 656		    prev->vb.height == buf->vb.height &&
 657		    prev->fmt       == buf->fmt) {
 658			list_add_tail(&buf->vb.queue, &q->active);
 659			buf->vb.state = VIDEOBUF_ACTIVE;
 660			buf->count    = q->count++;
 661			prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
 662			/* 64 bit bits 63-32 */
 663			prev->risc.jmp[2] = cpu_to_le32(0);
 664			dprintk(2, "[%p/%d] buffer_queue - append to active\n",
 665				buf, buf->vb.i);
 666
 667		} else {
 668			list_add_tail(&buf->vb.queue, &q->queued);
 669			buf->vb.state = VIDEOBUF_QUEUED;
 670			dprintk(2, "[%p/%d] buffer_queue - first queued\n",
 671				buf, buf->vb.i);
 672		}
 673	}
 674}
 675
 676static void buffer_release(struct videobuf_queue *q,
 677	struct videobuf_buffer *vb)
 678{
 679	struct cx23885_buffer *buf = container_of(vb,
 680		struct cx23885_buffer, vb);
 681
 682	cx23885_free_buffer(q, buf);
 683}
 684
 685static struct videobuf_queue_ops cx23885_video_qops = {
 686	.buf_setup    = buffer_setup,
 687	.buf_prepare  = buffer_prepare,
 688	.buf_queue    = buffer_queue,
 689	.buf_release  = buffer_release,
 690};
 691
 692static struct videobuf_queue *get_queue(struct cx23885_fh *fh)
 693{
 694	switch (fh->type) {
 695	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 696		return &fh->vidq;
 697	case V4L2_BUF_TYPE_VBI_CAPTURE:
 698		return &fh->vbiq;
 699	default:
 700		BUG();
 701		return NULL;
 702	}
 703}
 704
 705static int get_resource(struct cx23885_fh *fh)
 706{
 707	switch (fh->type) {
 708	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 709		return RESOURCE_VIDEO;
 710	case V4L2_BUF_TYPE_VBI_CAPTURE:
 711		return RESOURCE_VBI;
 712	default:
 713		BUG();
 714		return 0;
 715	}
 716}
 717
 718static int video_open(struct file *file)
 719{
 720	struct video_device *vdev = video_devdata(file);
 721	struct cx23885_dev *dev = video_drvdata(file);
 722	struct cx23885_fh *fh;
 723	enum v4l2_buf_type type = 0;
 724	int radio = 0;
 725
 726	switch (vdev->vfl_type) {
 727	case VFL_TYPE_GRABBER:
 728		type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 729		break;
 730	case VFL_TYPE_VBI:
 731		type = V4L2_BUF_TYPE_VBI_CAPTURE;
 732		break;
 733	case VFL_TYPE_RADIO:
 734		radio = 1;
 735		break;
 736	}
 737
 738	dprintk(1, "open dev=%s radio=%d type=%s\n",
 739		video_device_node_name(vdev), radio, v4l2_type_names[type]);
 740
 741	/* allocate + initialize per filehandle data */
 742	fh = kzalloc(sizeof(*fh), GFP_KERNEL);
 743	if (NULL == fh)
 744		return -ENOMEM;
 745
 746	lock_kernel();
 747
 748	file->private_data = fh;
 749	fh->dev      = dev;
 750	fh->radio    = radio;
 751	fh->type     = type;
 752	fh->width    = 320;
 753	fh->height   = 240;
 754	fh->fmt      = format_by_fourcc(V4L2_PIX_FMT_BGR24);
 755
 756	videobuf_queue_sg_init(&fh->vidq, &cx23885_video_qops,
 757			    &dev->pci->dev, &dev->slock,
 758			    V4L2_BUF_TYPE_VIDEO_CAPTURE,
 759			    V4L2_FIELD_INTERLACED,
 760			    sizeof(struct cx23885_buffer),
 761			    fh);
 762
 763	dprintk(1, "post videobuf_queue_init()\n");
 764
 765	unlock_kernel();
 766
 767	return 0;
 768}
 769
 770static ssize_t video_read(struct file *file, char __user *data,
 771	size_t count, loff_t *ppos)
 772{
 773	struct cx23885_fh *fh = file->private_data;
 774
 775	switch (fh->type) {
 776	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 777		if (res_locked(fh->dev, RESOURCE_VIDEO))
 778			return -EBUSY;
 779		return videobuf_read_one(&fh->vidq, data, count, ppos,
 780					 file->f_flags & O_NONBLOCK);
 781	case V4L2_BUF_TYPE_VBI_CAPTURE:
 782		if (!res_get(fh->dev, fh, RESOURCE_VBI))
 783			return -EBUSY;
 784		return videobuf_read_stream(&fh->vbiq, data, count, ppos, 1,
 785					    file->f_flags & O_NONBLOCK);
 786	default:
 787		BUG();
 788		return 0;
 789	}
 790}
 791
 792static unsigned int video_poll(struct file *file,
 793	struct poll_table_struct *wait)
 794{
 795	struct cx23885_fh *fh = file->private_data;
 796	struct cx23885_buffer *buf;
 797	unsigned int rc = POLLERR;
 798
 799	if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
 800		if (!res_get(fh->dev, fh, RESOURCE_VBI))
 801			return POLLERR;
 802		return videobuf_poll_stream(file, &fh->vbiq, wait);
 803	}
 804
 805	mutex_lock(&fh->vidq.vb_lock);
 806	if (res_check(fh, RESOURCE_VIDEO)) {
 807		/* streaming capture */
 808		if (list_empty(&fh->vidq.stream))
 809			goto done;
 810		buf = list_entry(fh->vidq.stream.next,
 811			struct cx23885_buffer, vb.stream);
 812	} else {
 813		/* read() capture */
 814		buf = (struct cx23885_buffer *)fh->vidq.read_buf;
 815		if (NULL == buf)
 816			goto done;
 817	}
 818	poll_wait(file, &buf->vb.done, wait);
 819	if (buf->vb.state == VIDEOBUF_DONE ||
 820	    buf->vb.state == VIDEOBUF_ERROR)
 821		rc =  POLLIN|POLLRDNORM;
 822	else
 823		rc = 0;
 824done:
 825	mutex_unlock(&fh->vidq.vb_lock);
 826	return rc;
 827}
 828
 829static int video_release(struct file *file)
 830{
 831	struct cx23885_fh *fh = file->private_data;
 832	struct cx23885_dev *dev = fh->dev;
 833
 834	/* turn off overlay */
 835	if (res_check(fh, RESOURCE_OVERLAY)) {
 836		/* FIXME */
 837		res_free(dev, fh, RESOURCE_OVERLAY);
 838	}
 839
 840	/* stop video capture */
 841	if (res_check(fh, RESOURCE_VIDEO)) {
 842		videobuf_queue_cancel(&fh->vidq);
 843		res_free(dev, fh, RESOURCE_VIDEO);
 844	}
 845	if (fh->vidq.read_buf) {
 846		buffer_release(&fh->vidq, fh->vidq.read_buf);
 847		kfree(fh->vidq.read_buf);
 848	}
 849
 850	/* stop vbi capture */
 851	if (res_check(fh, RESOURCE_VBI)) {
 852		if (fh->vbiq.streaming)
 853			videobuf_streamoff(&fh->vbiq);
 854		if (fh->vbiq.reading)
 855			videobuf_read_stop(&fh->vbiq);
 856		res_free(dev, fh, RESOURCE_VBI);
 857	}
 858
 859	videobuf_mmap_free(&fh->vidq);
 860	file->private_data = NULL;
 861	kfree(fh);
 862
 863	/* We are not putting the tuner to sleep here on exit, because
 864	 * we want to use the mpeg encoder in another session to capture
 865	 * tuner video. Closing this will result in no video to the encoder.
 866	 */
 867
 868	return 0;
 869}
 870
 871static int video_mmap(struct file *file, struct vm_area_struct *vma)
 872{
 873	struct cx23885_fh *fh = file->private_data;
 874
 875	return videobuf_mmap_mapper(get_queue(fh), vma);
 876}
 877
 878/* ------------------------------------------------------------------ */
 879/* VIDEO CTRL IOCTLS                                                  */
 880
 881static int cx23885_get_control(struct cx23885_dev *dev,
 882	struct v4l2_control *ctl)
 883{
 884	dprintk(1, "%s() calling cx25840(VIDIOC_G_CTRL)\n", __func__);
 885	call_all(dev, core, g_ctrl, ctl);
 886	return 0;
 887}
 888
 889static int cx23885_set_control(struct cx23885_dev *dev,
 890	struct v4l2_control *ctl)
 891{
 892	dprintk(1, "%s() calling cx25840(VIDIOC_S_CTRL)"
 893		" (disabled - no action)\n", __func__);
 894	return 0;
 895}
 896
 897static void init_controls(struct cx23885_dev *dev)
 898{
 899	struct v4l2_control ctrl;
 900	int i;
 901
 902	for (i = 0; i < CX23885_CTLS; i++) {
 903		ctrl.id = cx23885_ctls[i].v.id;
 904		ctrl.value = cx23885_ctls[i].v.default_value;
 905
 906		cx23885_set_control(dev, &ctrl);
 907	}
 908}
 909
 910/* ------------------------------------------------------------------ */
 911/* VIDEO IOCTLS                                                       */
 912
 913static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 914	struct v4l2_format *f)
 915{
 916	struct cx23885_fh *fh   = priv;
 917
 918	f->fmt.pix.width        = fh->width;
 919	f->fmt.pix.height       = fh->height;
 920	f->fmt.pix.field        = fh->vidq.field;
 921	f->fmt.pix.pixelformat  = fh->fmt->fourcc;
 922	f->fmt.pix.bytesperline =
 923		(f->fmt.pix.width * fh->fmt->depth) >> 3;
 924	f->fmt.pix.sizeimage =
 925		f->fmt.pix.height * f->fmt.pix.bytesperline;
 926
 927	return 0;
 928}
 929
 930static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 931	struct v4l2_format *f)
 932{
 933	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
 934	struct cx23885_fmt *fmt;
 935	enum v4l2_field   field;
 936	unsigned int      maxw, maxh;
 937
 938	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
 939	if (NULL == fmt)
 940		return -EINVAL;
 941
 942	field = f->fmt.pix.field;
 943	maxw  = norm_maxw(dev->tvnorm);
 944	maxh  = norm_maxh(dev->tvnorm);
 945
 946	if (V4L2_FIELD_ANY == field) {
 947		field = (f->fmt.pix.height > maxh/2)
 948			? V4L2_FIELD_INTERLACED
 949			: V4L2_FIELD_BOTTOM;
 950	}
 951
 952	switch (field) {
 953	case V4L2_FIELD_TOP:
 954	case V4L2_FIELD_BOTTOM:
 955		maxh = maxh / 2;
 956		break;
 957	case V4L2_FIELD_INTERLACED:
 958		break;
 959	default:
 960		return -EINVAL;
 961	}
 962
 963	f->fmt.pix.field = field;
 964	v4l_bound_align_image(&f->fmt.pix.width, 48, maxw, 2,
 965			      &f->fmt.pix.height, 32, maxh, 0, 0);
 966	f->fmt.pix.bytesperline =
 967		(f->fmt.pix.width * fmt->depth) >> 3;
 968	f->fmt.pix.sizeimage =
 969		f->fmt.pix.height * f->fmt.pix.bytesperline;
 970
 971	return 0;
 972}
 973
 974static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 975	struct v4l2_format *f)
 976{
 977	struct cx23885_fh *fh = priv;
 978	struct cx23885_dev *dev  = ((struct cx23885_fh *)priv)->dev;
 979	int err;
 980
 981	dprintk(2, "%s()\n", __func__);
 982	err = vidioc_try_fmt_vid_cap(file, priv, f);
 983
 984	if (0 != err)
 985		return err;
 986	fh->fmt        = format_by_fourcc(f->fmt.pix.pixelformat);
 987	fh->width      = f->fmt.pix.width;
 988	fh->height     = f->fmt.pix.height;
 989	fh->vidq.field = f->fmt.pix.field;
 990	dprintk(2, "%s() width=%d height=%d field=%d\n", __func__,
 991		fh->width, fh->height, fh->vidq.field);
 992	call_all(dev, video, s_fmt, f);
 993	return 0;
 994}
 995
 996static int vidioc_querycap(struct file *file, void  *priv,
 997	struct v4l2_capability *cap)
 998{
 999	struct cx23885_dev *dev  = ((struct cx23885_fh *)priv)->dev;
1000
1001	strcpy(cap->driver, "cx23885");
1002	strlcpy(cap->card, cx23885_boards[dev->board].name,
1003		sizeof(cap->card));
1004	sprintf(cap->bus_info, "PCIe:%s", pci_name(dev->pci));
1005	cap->version = CX23885_VERSION_CODE;
1006	cap->capabilities =
1007		V4L2_CAP_VIDEO_CAPTURE |
1008		V4L2_CAP_READWRITE     |
1009		V4L2_CAP_STREAMING     |
1010		V4L2_CAP_VBI_CAPTURE;
1011	if (UNSET != dev->tuner_type)
1012		cap->capabilities |= V4L2_CAP_TUNER;
1013	return 0;
1014}
1015
1016static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
1017	struct v4l2_fmtdesc *f)
1018{
1019	if (unlikely(f->index >= ARRAY_SIZE(formats)))
1020		return -EINVAL;
1021
1022	strlcpy(f->description, formats[f->index].name,
1023		sizeof(f->description));
1024	f->pixelformat = formats[f->index].fourcc;
1025
1026	return 0;
1027}
1028
1029#ifdef CONFIG_VIDEO_V4L1_COMPAT
1030static int vidiocgmbuf(struct file *file, void *priv,
1031	struct video_mbuf *mbuf)
1032{
1033	struct cx23885_fh *fh = priv;
1034	struct videobuf_queue *q;
1035	struct v4l2_requestbuffers req;
1036	unsigned int i;
1037	int err;
1038
1039	q = get_queue(fh);
1040	memset(&req, 0, sizeof(req));
1041	req.type   = q->type;
1042	req.count  = 8;
1043	req.memory = V4L2_MEMORY_MMAP;
1044	err = videobuf_reqbufs(q, &req);
1045	if (err < 0)
1046		return err;
1047
1048	mbuf->frames = req.count;
1049	mbuf->size   = 0;
1050	for (i = 0; i < mbuf->frames; i++) {
1051		mbuf->offsets[i]  = q->bufs[i]->boff;
1052		mbuf->size       += q->bufs[i]->bsize;
1053	}
1054	return 0;
1055}
1056#endif
1057
1058static int vidioc_reqbufs(struct file *file, void *priv,
1059	struct v4l2_requestbuffers *p)
1060{
1061	struct cx23885_fh *fh = priv;
1062	return videobuf_reqbufs(get_queue(fh), p);
1063}
1064
1065static int vidioc_querybuf(struct file *file, void *priv,
1066	struct v4l2_buffer *p)
1067{
1068	struct cx23885_fh *fh = priv;
1069	return videobuf_querybuf(get_queue(fh), p);
1070}
1071
1072static int vidioc_qbuf(struct file *file, void *priv,
1073	struct v4l2_buffer *p)
1074{
1075	struct cx23885_fh *fh = priv;
1076	return videobuf_qbuf(get_queue(fh), p);
1077}
1078
1079static int vidioc_dqbuf(struct file *file, void *priv,
1080	struct v4l2_buffer *p)
1081{
1082	struct cx23885_fh *fh = priv;
1083	return videobuf_dqbuf(get_queue(fh), p,
1084				file->f_flags & O_NONBLOCK);
1085}
1086
1087static int vidioc_streamon(struct file *file, void *priv,
1088	enum v4l2_buf_type i)
1089{
1090	struct cx23885_fh *fh = priv;
1091	struct cx23885_dev *dev = fh->dev;
1092	dprintk(1, "%s()\n", __func__);
1093
1094	if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE))
1095		return -EINVAL;
1096	if (unlikely(i != fh->type))
1097		return -EINVAL;
1098
1099	if (unlikely(!res_get(dev, fh, get_resource(fh))))
1100		return -EBUSY;
1101	return videobuf_streamon(get_queue(fh));
1102}
1103
1104static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
1105{
1106	struct cx23885_fh *fh = priv;
1107	struct cx23885_dev *dev = fh->dev;
1108	int err, res;
1109	dprintk(1, "%s()\n", __func__);
1110
1111	if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1112		return -EINVAL;
1113	if (i != fh->type)
1114		return -EINVAL;
1115
1116	res = get_resource(fh);
1117	err = videobuf_streamoff(get_queue(fh));
1118	if (err < 0)
1119		return err;
1120	res_free(dev, fh, res);
1121	return 0;
1122}
1123
1124static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *tvnorms)
1125{
1126	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
1127	dprintk(1, "%s()\n", __func__);
1128
1129	mutex_lock(&dev->lock);
1130	cx23885_set_tvnorm(dev, *tvnorms);
1131	mutex_unlock(&dev->lock);
1132
1133	return 0;
1134}
1135
1136static int cx23885_enum_input(struct cx23885_dev *dev, struct v4l2_input *i)
1137{
1138	static const char *iname[] = {
1139		[CX23885_VMUX_COMPOSITE1] = "Composite1",
1140		[CX23885_VMUX_COMPOSITE2] = "Composite2",
1141		[CX23885_VMUX_COMPOSITE3] = "Composite3",
1142		[CX23885_VMUX_COMPOSITE4] = "Composite4",
1143		[CX23885_VMUX_SVIDEO]     = "S-Video",
1144		[CX23885_VMUX_COMPONENT]  = "Component",
1145		[CX23885_VMUX_TELEVISION] = "Television",
1146		[CX23885_VMUX_CABLE]      = "Cable TV",
1147		[CX23885_VMUX_DVB]        = "DVB",
1148		[CX23885_VMUX_DEBUG]      = "for debug only",
1149	};
1150	unsigned int n;
1151	dprintk(1, "%s()\n", __func__);
1152
1153	n = i->index;
1154	if (n >= 4)
1155		return -EINVAL;
1156
1157	if (0 == INPUT(n)->type)
1158		return -EINVAL;
1159
1160	memset(i, 0, sizeof(*i));
1161	i->index = n;
1162	i->type  = V4L2_INPUT_TYPE_CAMERA;
1163	strcpy(i->name, iname[INPUT(n)->type]);
1164	if ((CX23885_VMUX_TELEVISION == INPUT(n)->type) ||
1165		(CX23885_VMUX_CABLE == INPUT(n)->type))
1166		i->type = V4L2_INPUT_TYPE_TUNER;
1167		i->std = CX23885_NORMS;
1168	return 0;
1169}
1170
1171static int vidioc_enum_input(struct file *file, void *priv,
1172				struct v4l2_input *i)
1173{
1174	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
1175	dprintk(1, "%s()\n", __func__);
1176	return cx23885_enum_input(dev, i);
1177}
1178
1179static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1180{
1181	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
1182
1183	*i = dev->input;
1184	dprintk(1, "%s() returns %d\n", __func__, *i);
1185	return 0;
1186}
1187
1188static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1189{
1190	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
1191
1192	dprintk(1, "%s(%d)\n", __func__, i);
1193
1194	if (i >= 4) {
1195		dprintk(1, "%s() -EINVAL\n", __func__);
1196		return -EINVAL;
1197	}
1198
1199	mutex_lock(&dev->lock);
1200	cx23885_video_mux(dev, i);
1201	mutex_unlock(&dev->lock);
1202	return 0;
1203}
1204
1205static int vidioc_queryctrl(struct file *file, void *priv,
1206				struct v4l2_queryctrl *qctrl)
1207{
1208	qctrl->id = v4l2_ctrl_next(ctrl_classes, qctrl->id);
1209	if (unlikely(qctrl->id == 0))
1210		return -EINVAL;
1211	return cx23885_ctrl_query(qctrl);
1212}
1213
1214static int vidioc_g_ctrl(struct file *file, void *priv,
1215				struct v4l2_control *ctl)
1216{
1217	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
1218
1219	return cx23885_get_control(dev, ctl);
1220}
1221
1222static int vidioc_s_ctrl(struct file *file, void *priv,
1223				struct v4l2_control *ctl)
1224{
1225	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
1226
1227	return cx23885_set_control(dev, ctl);
1228}
1229
1230static int vidioc_g_tuner(struct file *file, void *priv,
1231				struct v4l2_tuner *t)
1232{
1233	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
1234
1235	if (unlikely(UNSET == dev->tuner_type))
1236		return -EINVAL;
1237	if (0 != t->index)
1238		return -EINVAL;
1239
1240	strcpy(t->name, "Television");
1241	t->type       = V4L2_TUNER_ANALOG_TV;
1242	t->capability = V4L2_TUNER_CAP_NORM;
1243	t->rangehigh  = 0xffffffffUL;
1244	t->signal = 0xffff ; /* LOCKED */
1245	return 0;
1246}
1247
1248static int vidioc_s_tuner(struct file *file, void *priv,
1249				struct v4l2_tuner *t)
1250{
1251	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
1252
1253	if (UNSET == dev->tuner_type)
1254		return -EINVAL;
1255	if (0 != t->index)
1256		return -EINVAL;
1257	return 0;
1258}
1259
1260static int vidioc_g_frequency(struct file *file, void *priv,
1261				struct v4l2_frequency *f)
1262{
1263	struct cx23885_fh *fh = priv;
1264	struct cx23885_dev *dev = fh->dev;
1265
1266	if (unlikely(UNSET == dev->tuner_type))
1267		return -EINVAL;
1268
1269	/* f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV; */
1270	f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1271	f->frequency = dev->freq;
1272
1273	call_all(dev, tuner, g_frequency, f);
1274
1275	return 0;
1276}
1277
1278static int cx23885_set_freq(struct cx23885_dev *dev, struct v4l2_frequency *f)
1279{
1280	if (unlikely(UNSET == dev->tuner_type))
1281		return -EINVAL;
1282	if (unlikely(f->tuner != 0))
1283		return -EINVAL;
1284
1285	mutex_lock(&dev->lock);
1286	dev->freq = f->frequency;
1287
1288	call_all(dev, tuner, s_frequency, f);
1289
1290	/* When changing channels it is required to reset TVAUDIO */
1291	msleep(10);
1292
1293	mutex_unlock(&dev->lock);
1294
1295	return 0;
1296}
1297
1298static int vidioc_s_frequency(struct file *file, void *priv,
1299				struct v4l2_frequency *f)
1300{
1301	struct cx23885_fh *fh = priv;
1302	struct cx23885_dev *dev = fh->dev;
1303
1304	if (unlikely(0 == fh->radio && f->type != V4L2_TUNER_ANALOG_TV))
1305		return -EINVAL;
1306	if (unlikely(1 == fh->radio && f->type != V4L2_TUNER_RADIO))
1307		return -EINVAL;
1308
1309	return
1310		cx23885_set_freq(dev, f);
1311}
1312
1313/* ----------------------------------------------------------- */
1314
1315static void cx23885_vid_timeout(unsigned long data)
1316{
1317	struct cx23885_dev *dev = (struct cx23885_dev *)data;
1318	struct cx23885_dmaqueue *q = &dev->vidq;
1319	struct cx23885_buffer *buf;
1320	unsigned long flags;
1321
1322	cx23885_sram_channel_dump(dev, &dev->sram_channels[SRAM_CH01]);
1323
1324	cx_clear(VID_A_DMA_CTL, 0x11);
1325
1326	spin_lock_irqsave(&dev->slock, flags);
1327	while (!list_empty(&q->active)) {
1328		buf = list_entry(q->active.next,
1329			struct cx23885_buffer, vb.queue);
1330		list_del(&buf->vb.queue);
1331		buf->vb.state = VIDEOBUF_ERROR;
1332		wake_up(&buf->vb.done);
1333		printk(KERN_ERR "%s/0: [%p/%d] timeout - dma=0x%08lx\n",
1334			dev->name, buf, buf->vb.i,
1335			(unsigned long)buf->risc.dma);
1336	}
1337	cx23885_restart_video_queue(dev, q);
1338	spin_unlock_irqrestore(&dev->slock, flags);
1339}
1340
1341int cx23885_video_irq(struct cx23885_dev *dev, u32 status)
1342{
1343	u32 mask, count;
1344	int handled = 0;
1345
1346	mask   = cx_read(VID_A_INT_MSK);
1347	if (0 == (status & mask))
1348		return handled;
1349	cx_write(VID_A_INT_STAT, status);
1350
1351	dprintk(2, "%s() status = 0x%08x\n", __func__, status);
1352	/* risc op code error */
1353	if (status & (1 << 16)) {
1354		printk(KERN_WARNING "%s/0: video risc op code error\n",
1355			dev->name);
1356		cx_clear(VID_A_DMA_CTL, 0x11);
1357		cx23885_sram_channel_dump(dev, &dev->sram_channels[SRAM_CH01]);
1358	}
1359
1360	/* risc1 y */
1361	if (status & 0x01) {
1362		spin_lock(&dev->slock);
1363		count = cx_read(VID_A_GPCNT);
1364		cx23885_video_wakeup(dev, &dev->vidq, count);
1365		spin_unlock(&dev->slock);
1366		handled++;
1367	}
1368	/* risc2 y */
1369	if (status & 0x10) {
1370		dprintk(2, "stopper video\n");
1371		spin_lock(&dev->slock);
1372		cx23885_restart_video_queue(dev, &dev->vidq);
1373		spin_unlock(&dev->slock);
1374		handled++;
1375	}
1376
1377	return handled;
1378}
1379
1380/* ----------------------------------------------------------- */
1381/* exported stuff                                              */
1382
1383static const struct v4l2_file_operations video_fops = {
1384	.owner	       = THIS_MODULE,
1385	.open	       = video_open,
1386	.release       = video_release,
1387	.read	       = video_read,
1388	.poll          = video_poll,
1389	.mmap	       = video_mmap,
1390	.ioctl	       = video_ioctl2,
1391};
1392
1393static const struct v4l2_ioctl_ops video_ioctl_ops = {
1394	.vidioc_querycap      = vidioc_querycap,
1395	.vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
1396	.vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
1397	.vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
1398	.vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
1399	.vidioc_g_fmt_vbi_cap     = cx23885_vbi_fmt,
1400	.vidioc_try_fmt_vbi_cap   = cx23885_vbi_fmt,
1401	.vidioc_s_fmt_vbi_cap     = cx23885_vbi_fmt,
1402	.vidioc_reqbufs       = vidioc_reqbufs,
1403	.vidioc_querybuf      = vidioc_querybuf,
1404	.vidioc_qbuf          = vidioc_qbuf,
1405	.vidioc_dqbuf         = vidioc_dqbuf,
1406	.vidioc_s_std         = vidioc_s_std,
1407	.vidioc_enum_input    = vidioc_enum_input,
1408	.vidioc_g_input       = vidioc_g_input,
1409	.vidioc_s_input       = vidioc_s_input,
1410	.vidioc_queryctrl     = vidioc_queryctrl,
1411	.vidioc_g_ctrl        = vidioc_g_ctrl,
1412	.vidioc_s_ctrl        = vidioc_s_ctrl,
1413	.vidioc_streamon      = vidioc_streamon,
1414	.vidioc_streamoff     = vidioc_streamoff,
1415#ifdef CONFIG_VIDEO_V4L1_COMPAT
1416	.vidiocgmbuf          = vidiocgmbuf,
1417#endif
1418	.vidioc_g_tuner       = vidioc_g_tuner,
1419	.vidioc_s_tuner       = vidioc_s_tuner,
1420	.vidioc_g_frequency   = vidioc_g_frequency,
1421	.vidioc_s_frequency   = vidioc_s_frequency,
1422	.vidioc_g_chip_ident  = cx23885_g_chip_ident,
1423#ifdef CONFIG_VIDEO_ADV_DEBUG
1424	.vidioc_g_register    = cx23885_g_register,
1425	.vidioc_s_register    = cx23885_s_register,
1426#endif
1427};
1428
1429static struct video_device cx23885_vbi_template;
1430static struct video_device cx23885_video_template = {
1431	.name                 = "cx23885-video",
1432	.fops                 = &video_fops,
1433	.ioctl_ops 	      = &video_ioctl_ops,
1434	.tvnorms              = CX23885_NORMS,
1435	.current_norm         = V4L2_STD_NTSC_M,
1436};
1437
1438static const struct v4l2_file_operations radio_fops = {
1439	.owner         = THIS_MODULE,
1440	.open          = video_open,
1441	.release       = video_release,
1442	.ioctl         = video_ioctl2,
1443};
1444
1445
1446void cx23885_video_unregister(struct cx23885_dev *dev)
1447{
1448	dprintk(1, "%s()\n", __func__);
1449	cx_clear(PCI_INT_MSK, 1);
1450
1451	if (dev->video_dev) {
1452		if (video_is_registered(dev->video_dev))
1453			video_unregister_device(dev->video_dev);
1454		else
1455			video_device_release(dev->video_dev);
1456		dev->video_dev = NULL;
1457
1458		btcx_riscmem_free(dev->pci, &dev->vidq.stopper);
1459	}
1460}
1461
1462int cx23885_video_register(struct cx23885_dev *dev)
1463{
1464	int err;
1465
1466	dprintk(1, "%s()\n", __func__);
1467	spin_lock_init(&dev->slock);
1468
1469	/* Initialize VBI template */
1470	memcpy(&cx23885_vbi_template, &cx23885_video_template,
1471		sizeof(cx23885_vbi_template));
1472	strcpy(cx23885_vbi_template.name, "cx23885-vbi");
1473
1474	dev->tvnorm = cx23885_video_template.current_norm;
1475
1476	/* init video dma queues */
1477	INIT_LIST_HEAD(&dev->vidq.active);
1478	INIT_LIST_HEAD(&dev->vidq.queued);
1479	dev->vidq.timeout.function = cx23885_vid_timeout;
1480	dev->vidq.timeout.data = (unsigned long)dev;
1481	init_timer(&dev->vidq.timeout);
1482	cx23885_risc_stopper(dev->pci, &dev->vidq.stopper,
1483		VID_A_DMA_CTL, 0x11, 0x00);
1484
1485	/* Don't enable VBI yet */
1486	cx_set(PCI_INT_MSK, 1);
1487
1488	if (TUNER_ABSENT != dev->tuner_type) {
1489		struct v4l2_subdev *sd = NULL;
1490
1491		if (dev->tuner_addr)
1492			sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
1493				&dev->i2c_bus[1].i2c_adap,
1494				"tuner", "tuner", dev->tuner_addr, NULL);
1495		else
1496			sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
1497				&dev->i2c_bus[1].i2c_adap,
1498				"tuner", "tuner", 0, v4l2_i2c_tuner_addrs(ADDRS_TV));
1499		if (sd) {
1500			struct tuner_setup tun_setup;
1501
1502			memset(&tun_setup, 0, sizeof(tun_setup));
1503			tun_setup.mode_mask = T_ANALOG_TV;
1504			tun_setup.type = dev->tuner_type;
1505			tun_setup.addr = v4l2_i2c_subdev_addr(sd);
1506			tun_setup.tuner_callback = cx23885_tuner_callback;
1507
1508			v4l2_subdev_call(sd, tuner, s_type_addr, &tun_setup);
1509
1510			if (dev->board == CX23885_BOARD_LEADTEK_WINFAST_PXTV1200) {
1511				struct xc2028_ctrl ctrl = {
1512					.fname = XC2028_DEFAULT_FIRMWARE,
1513					.max_len = 64
1514				};
1515				struct v4l2_priv_tun_config cfg = {
1516					.tuner = dev->tuner_type,
1517					.priv = &ctrl
1518				};
1519				v4l2_subdev_call(sd, tuner, s_config, &cfg);
1520			}
1521		}
1522	}
1523
1524
1525	/* register v4l devices */
1526	dev->video_dev = cx23885_vdev_init(dev, dev->pci,
1527		&cx23885_video_template, "video");
1528	err = video_register_device(dev->video_dev, VFL_TYPE_GRABBER,
1529				    video_nr[dev->nr]);
1530	if (err < 0) {
1531		printk(KERN_INFO "%s: can't register video device\n",
1532			dev->name);
1533		goto fail_unreg;
1534	}
1535	printk(KERN_INFO "%s/0: registered device %s [v4l2]\n",
1536	       dev->name, video_device_node_name(dev->video_dev));
1537	/* initial device configuration */
1538	mutex_lock(&dev->lock);
1539	cx23885_set_tvnorm(dev, dev->tvnorm);
1540	init_controls(dev);
1541	cx23885_video_mux(dev, 0);
1542	mutex_unlock(&dev->lock);
1543
1544	return 0;
1545
1546fail_unreg:
1547	cx23885_video_unregister(dev);
1548	return err;
1549}
1550